Make cell_block_limit non-hard-coded

mdboom · mdboom · commit 1b937a4fea5a · 2014-11-11T08:38:31.000-05:00
diff --git a/extern/agg24/include/agg_rasterizer_cells_aa.h b/extern/agg24/include/agg_rasterizer_cells_aa.h
@@ -2,15 +2,15 @@
 // Anti-Grain Geometry - Version 2.4
 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
 //
-// Permission to copy, use, modify, sell and distribute this software 
-// is granted provided this copyright notice appears in all copies. 
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
 // This software is provided "as is" without express or implied
 // warranty, and with no claim as to its suitability for any purpose.
 //
 //----------------------------------------------------------------------------
 //
-// The author gratefully acknowleges the support of David Turner, 
-// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType 
+// The author gratefully acknowleges the support of David Turner,
+// Robert Wilhelm, and Werner Lemberg - the authors of the FreeType
 // libray - in producing this work. See http://www.freetype.org for details.
 //
 //----------------------------------------------------------------------------
@@ -19,16 +19,17 @@
 //          http://www.antigrain.com
 //----------------------------------------------------------------------------
 //
-// Adaptation for 32-bit screen coordinates has been sponsored by 
+// Adaptation for 32-bit screen coordinates has been sponsored by
 // Liberty Technology Systems, Inc., visit http://lib-sys.com
 //
 // Liberty Technology Systems, Inc. is the provider of
 // PostScript and PDF technology for software developers.
-// 
+//
 //----------------------------------------------------------------------------
 #ifndef AGG_RASTERIZER_CELLS_AA_INCLUDED
 #define AGG_RASTERIZER_CELLS_AA_INCLUDED
 
+#include <stdexcept>
 #include <string.h>
 #include <math.h>
 #include "agg_math.h"
@@ -48,8 +49,7 @@ namespace agg
             cell_block_shift = 12,
             cell_block_size  = 1 << cell_block_shift,
             cell_block_mask  = cell_block_size - 1,
-            cell_block_pool  = 256,
-            cell_block_limit = 1024
+            cell_block_pool  = 256
         };
 
         struct sorted_y
@@ -63,7 +63,7 @@ namespace agg
         typedef rasterizer_cells_aa<Cell> self_type;
 
         ~rasterizer_cells_aa();
-        rasterizer_cells_aa();
+        rasterizer_cells_aa(unsigned cell_block_limit=1024);
 
         void reset();
         void style(const cell_type& style_cell);
@@ -76,19 +76,19 @@ namespace agg
 
         void sort_cells();
 
-        unsigned total_cells() const 
+        unsigned total_cells() const
         {
             return m_num_cells;
         }
 
-        unsigned scanline_num_cells(unsigned y) const 
-        { 
-            return m_sorted_y[y - m_min_y].num; 
+        unsigned scanline_num_cells(unsigned y) const
+        {
+            return m_sorted_y[y - m_min_y].num;
         }
 
         const cell_type* const* scanline_cells(unsigned y) const
-        { 
-            return m_sorted_cells.data() + m_sorted_y[y - m_min_y].start; 
+        {
+            return m_sorted_cells.data() + m_sorted_y[y - m_min_y].start;
         }
 
         bool sorted() const { return m_sorted; }
@@ -101,12 +101,13 @@ namespace agg
         void add_curr_cell();
         void render_hline(int ey, int x1, int y1, int x2, int y2);
         void allocate_block();
-        
+
     private:
         unsigned                m_num_blocks;
         unsigned                m_max_blocks;
         unsigned                m_curr_block;
         unsigned                m_num_cells;
+        unsigned                m_cell_block_limit;
         cell_type**             m_cells;
         cell_type*              m_curr_cell_ptr;
         pod_vector<cell_type*>  m_sorted_cells;
@@ -124,7 +125,7 @@ namespace agg
 
 
     //------------------------------------------------------------------------
-    template<class Cell> 
+    template<class Cell>
     rasterizer_cells_aa<Cell>::~rasterizer_cells_aa()
     {
         if(m_num_blocks)
@@ -140,12 +141,13 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Cell> 
-    rasterizer_cells_aa<Cell>::rasterizer_cells_aa() :
+    template<class Cell>
+    rasterizer_cells_aa<Cell>::rasterizer_cells_aa(unsigned cell_block_limit) :
         m_num_blocks(0),
         m_max_blocks(0),
         m_curr_block(0),
         m_num_cells(0),
+        m_cell_block_limit(cell_block_limit),
         m_cells(0),
         m_curr_cell_ptr(0),
         m_sorted_cells(),
@@ -161,10 +163,10 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Cell> 
+    template<class Cell>
     void rasterizer_cells_aa<Cell>::reset()
     {
-        m_num_cells = 0; 
+        m_num_cells = 0;
         m_curr_block = 0;
         m_curr_cell.initial();
         m_style_cell.initial();
@@ -176,14 +178,16 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Cell> 
+    template<class Cell>
     AGG_INLINE void rasterizer_cells_aa<Cell>::add_curr_cell()
     {
         if(m_curr_cell.area | m_curr_cell.cover)
         {
             if((m_num_cells & cell_block_mask) == 0)
             {
-                if(m_num_blocks >= cell_block_limit) return;
+                if(m_num_blocks >= m_cell_block_limit) {
+                    throw std::overflow_error("Exceeded cell block limit");
+                }
                 allocate_block();
             }
             *m_curr_cell_ptr++ = m_curr_cell;
@@ -192,7 +196,7 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Cell> 
+    template<class Cell>
     AGG_INLINE void rasterizer_cells_aa<Cell>::set_curr_cell(int x, int y)
     {
         if(m_curr_cell.not_equal(x, y, m_style_cell))
@@ -207,9 +211,9 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Cell> 
-    AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey, 
-                                                            int x1, int y1, 
+    template<class Cell>
+    AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey,
+                                                            int x1, int y1,
                                                             int x2, int y2)
     {
         int ex1 = x1 >> poly_subpixel_shift;
@@ -305,14 +309,14 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Cell> 
+    template<class Cell>
     AGG_INLINE void rasterizer_cells_aa<Cell>::style(const cell_type& style_cell)
-    { 
-        m_style_cell.style(style_cell); 
+    {
+        m_style_cell.style(style_cell);
     }
 
     //------------------------------------------------------------------------
-    template<class Cell> 
+    template<class Cell>
     void rasterizer_cells_aa<Cell>::line(int x1, int y1, int x2, int y2)
     {
         enum dx_limit_e { dx_limit = 16384 << poly_subpixel_shift };
@@ -358,7 +362,7 @@ namespace agg
 
         //Vertical line - we have to calculate start and end cells,
         //and then - the common values of the area and coverage for
-        //all cells of the line. We know exactly there's only one 
+        //all cells of the line. We know exactly there's only one
         //cell, so, we don't have to call render_hline().
         incr  = 1;
         if(dx == 0)
@@ -463,15 +467,15 @@ namespace agg
     }
 
     //------------------------------------------------------------------------
-    template<class Cell> 
+    template<class Cell>
     void rasterizer_cells_aa<Cell>::allocate_block()
     {
         if(m_curr_block >= m_num_blocks)
         {
             if(m_num_blocks >= m_max_blocks)
             {
-                cell_type** new_cells = 
-                    pod_allocator<cell_type*>::allocate(m_max_blocks + 
+                cell_type** new_cells =
+                    pod_allocator<cell_type*>::allocate(m_max_blocks +
                                                         cell_block_pool);
 
                 if(m_cells)
@@ -483,7 +487,7 @@ namespace agg
                 m_max_blocks += cell_block_pool;
             }
 
-            m_cells[m_num_blocks++] = 
+            m_cells[m_num_blocks++] =
                 pod_allocator<cell_type>::allocate(cell_block_size);
 
         }
@@ -513,7 +517,7 @@ namespace agg
     void qsort_cells(Cell** start, unsigned num)
     {
         Cell**  stack[80];
-        Cell*** top; 
+        Cell*** top;
         Cell**  limit;
         Cell**  base;
 
@@ -538,7 +542,7 @@ namespace agg
                 i = base + 1;
                 j = limit - 1;
 
-                // now ensure that *i <= *base <= *j 
+                // now ensure that *i <= *base <= *j
                 if((*j)->x < (*i)->x)
                 {
                     swap_cells(i, j);
@@ -619,7 +623,7 @@ namespace agg
 
 
     //------------------------------------------------------------------------
-    template<class Cell> 
+    template<class Cell>
     void rasterizer_cells_aa<Cell>::sort_cells()
     {
         if(m_sorted) return; //Perform sort only the first time.
@@ -636,9 +640,9 @@ namespace agg
 //for(unsigned nc = 0; nc < m_num_cells; nc++)
 //{
 //    cell_type* cell = m_cells[nc >> cell_block_shift] + (nc & cell_block_mask);
-//    if(cell->x < m_min_x || 
-//       cell->y < m_min_y || 
-//       cell->x > m_max_x || 
+//    if(cell->x < m_min_x ||
+//       cell->y < m_min_y ||
+//       cell->x > m_max_x ||
 //       cell->y > m_max_y)
 //    {
 //        cell = cell; // Breakpoint here
@@ -661,7 +665,7 @@ namespace agg
             cell_ptr = *block_ptr++;
             i = (nb > cell_block_size) ? cell_block_size : nb;
             nb -= i;
-            while(i--) 
+            while(i--)
             {
                 m_sorted_y[cell_ptr->y - m_min_y].start++;
                 ++cell_ptr;
@@ -693,7 +697,7 @@ namespace agg
                 ++cell_ptr;
             }
         }
-        
+
         // Finally arrange the X-arrays
         for(i = 0; i < m_sorted_y.size(); i++)
         {
diff --git a/extern/agg24/include/agg_rasterizer_compound_aa.h b/extern/agg24/include/agg_rasterizer_compound_aa.h
@@ -109,8 +109,8 @@ namespace agg
         };
 
         //--------------------------------------------------------------------
-        rasterizer_compound_aa() : 
-            m_outline(),
+        rasterizer_compound_aa(unsigned cell_block_limit=1024) :
+            m_outline(cell_block_limit),
             m_clipper(),
             m_filling_rule(fill_non_zero),
             m_layer_order(layer_direct),
diff --git a/extern/agg24/include/agg_rasterizer_scanline_aa.h b/extern/agg24/include/agg_rasterizer_scanline_aa.h
@@ -93,8 +93,8 @@ namespace agg
         };
 
         //--------------------------------------------------------------------
-        rasterizer_scanline_aa() : 
-            m_outline(),
+        rasterizer_scanline_aa(unsigned cell_block_limit=1024) :
+            m_outline(cell_block_limit),
             m_clipper(),
             m_filling_rule(fill_non_zero),
             m_auto_close(true),
@@ -107,9 +107,9 @@ namespace agg
         }
 
         //--------------------------------------------------------------------
-        template<class GammaF> 
-        rasterizer_scanline_aa(const GammaF& gamma_function) : 
-            m_outline(),
+        template<class GammaF>
+        rasterizer_scanline_aa(const GammaF& gamma_function, unsigned cell_block_limit) :
+            m_outline(cell_block_limit),
             m_clipper(m_outline),
             m_filling_rule(fill_non_zero),
             m_auto_close(true),
diff --git a/extern/agg24/include/agg_rasterizer_scanline_aa_nogamma.h b/extern/agg24/include/agg_rasterizer_scanline_aa_nogamma.h
@@ -121,8 +121,8 @@ namespace agg
         };
 
         //--------------------------------------------------------------------
-        rasterizer_scanline_aa_nogamma() : 
-            m_outline(),
+        rasterizer_scanline_aa_nogamma(unsigned cell_block_limit=1024) :
+            m_outline(cell_block_limit),
             m_clipper(),
             m_filling_rule(fill_non_zero),
             m_auto_close(true),
diff --git a/src/_backend_agg.cpp b/src/_backend_agg.cpp
@@ -46,7 +46,7 @@ RendererAgg::RendererAgg(unsigned int width, unsigned int height, double dpi)
       rendererBase(),
       rendererAA(),
       rendererBin(),
-      theRasterizer(),
+      theRasterizer(4096),
       lastclippath(NULL),
       _fill_color(agg::rgba(1, 1, 1, 0))
 {

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ RendererAgg::RendererAgg(unsigned int width, unsigned int height, double dpi)`
`46`	`46`	`rendererBase(),`
`47`	`47`	`rendererAA(),`
`48`	`48`	`rendererBin(),`
`49`		`- theRasterizer(),`
	`49`	`+ theRasterizer(4096),`
`50`	`50`	`lastclippath(NULL),`
`51`	`51`	`_fill_color(agg::rgba(1, 1, 1, 0))`
`52`	`52`	`{`