[Git][freetype/freetype][smooth_malloc] 7 commits: fix typo in FT

Alexei Podtelezhnikov pushed to branch smooth_malloc at FreeType / FreeType

Commits:

21435f07
by Zachary Zollman at 2023-10-08T23:34:28+00:00
```
fix typo in FT_Outline_Decompose note
```
84cd2e98
by Alexei Podtelezhnikov (Алексей Подтележников) at 2023-10-09T22:11:41-04:00
```
* src/raster/ftraster.c: Tracing updates.
```

322e580b

by Alexei Podtelezhnikov (Алексей Подтележников) at 2023-10-09T22:22:24-04:00

* src/smooth/ftgrays.c: Move the sweep functions...

... out of the setjmp/longjmp scope for readability.

3cb3acf2

by Alexei Podtelezhnikov (Алексей Подтележников) at 2023-10-09T22:34:11-04:00

[smooth] Switch to dynamic memory allocation.

This is a proof of concept for `malloc` overhead benchmarking.

* src/smooth/ftgrays.c (gray_TWorker): Store `memory`.
(gray_convert_glyph): Allocate memory dynamically and handle errors.
(gray_raster_render): Set memory.

7bdd4d1a

by Alexei Podtelezhnikov (Алексей Подтележников) at 2023-10-09T22:38:16-04:00

[smooth] Estimate of the rendering pool size.

The estimate is based on the taxi perimeter with extra space added
for local extrema.

* src/smooth/ftgrays.c (gray_taxi): New function for the perimeter.
(gray_convert_glyph): Updated, banding suppressed.

819d73f6

by Alexei Podtelezhnikov (Алексей Подтележников) at 2023-10-09T22:39:27-04:00

[smooth] Limit acceptable glyph complexity.

* src/smooth/ftgrays.c (gray_convert_glyph): Do not attempt to draw
glyphs with taxicab:cbox perimeter ratio above 20.

4f01f5db

by Alexei Podtelezhnikov (Алексей Подтележников) at 2023-10-09T22:42:25-04:00

[smooth] Limit pool size on demand.

* src/smooth/ftgrays.c (gray_convert_glyph): Honor FT_GRAY_POOL_SIZE.

Changes:

include/freetype/ftoutln.h

@@ -112,7 +112,7 @@ FT_BEGIN_HEADER
     *   Degenerate contours, segments, and Bezier arcs may be reported.  In
     *   most cases, it is best to filter these out before using the outline
     *   for stroking or other path modification purposes (which may cause
 -   *   degenerate segments to become non-degenrate and visible, like when
 +   *   degenerate segments to become non-degenerate and visible, like when
     *   stroke caps are used or the path is otherwise outset).  Some glyph
     *   outlines may contain deliberate degenerate single points for mark
     *   attachement.

src/raster/ftraster.c

@@ -645,13 +645,13 @@
        if ( overshoot )
          ras.cProfile->flags |= Overshoot_Bottom;
 -      FT_TRACE6(( "  new ascending profile = "">\n", (void *)ras.cProfile ));
 +      FT_TRACE7(( "  new ascending profile = "">\n", (void *)ras.cProfile ));
        break;
      case Descending_State:
        if ( overshoot )
          ras.cProfile->flags |= Overshoot_Top;
 -      FT_TRACE6(( "  new descending profile = "">\n", (void *)ras.cProfile ));
 +      FT_TRACE7(( "  new descending profile = "">\n", (void *)ras.cProfile ));
        break;
      default:
@@ -707,7 +707,7 @@
        PProfile  oldProfile;
 -      FT_TRACE6(( "  ending profile %p, start = %ld, height = %ld\n",
 +      FT_TRACE7(( "  ending profile %p, start = %ld, height = %ld\n",
                    (void *)ras.cProfile, ras.cProfile->start, h ));
        ras.cProfile->height = h;
@@ -3038,6 +3038,9 @@
          if ( y_min == y_max )
            return ras.error;  /* still Raster_Overflow */
 +        FT_TRACE6(( "band [%d..%d]: to be bisected\n",
 +                    y_min, y_max ));
++
          y_mid = ( y_min + y_max ) >> 1;
          band_stack[band_top++] = y_min;
@@ -3045,6 +3048,9 @@
+       }
        else
+       {
 +        FT_TRACE6(( "band [%d..%d]: %td bytes remaining\n",
 +                    y_min, y_max, (char*)ras.maxBuff - (char*)ras.top ));
++
          if ( ras.fProfile )
            if ( Draw_Sweep( RAS_VAR ) )
               return ras.error;
@@ -3095,7 +3101,7 @@
+     }
      /* Vertical Sweep */
 -    FT_TRACE7(( "Vertical pass (ftraster)\n" ));
 +    FT_TRACE6(( "Vertical pass (ftraster)\n" ));
      ras.Proc_Sweep_Init = Vertical_Sweep_Init;
      ras.Proc_Sweep_Span = Vertical_Sweep_Span;
@@ -3115,7 +3121,7 @@
      /* Horizontal Sweep */
      if ( !( ras.outline.flags & FT_OUTLINE_SINGLE_PASS ) )
+     {
 -      FT_TRACE7(( "Horizontal pass (ftraster)\n" ));
 +      FT_TRACE6(( "Horizontal pass (ftraster)\n" ));
        ras.Proc_Sweep_Init = Horizontal_Sweep_Init;
        ras.Proc_Sweep_Span = Horizontal_Sweep_Span;

src/smooth/ftgrays.c

@@ -469,10 +469,8 @@ typedef ptrdiff_t  FT_PtrDist;
    } TPixmap;
    /* maximum number of gray cells in the buffer */
 -#if FT_RENDER_POOL_SIZE > 2048
 +#if defined( FT_GRAY_POOL_SIZE ) && FT_GRAY_POOL_SIZE > 2048
  #define FT_MAX_GRAY_POOL  ( FT_RENDER_POOL_SIZE / sizeof ( TCell ) )
 -#else
 -#define FT_MAX_GRAY_POOL  ( 2048 / sizeof ( TCell ) )
  #endif
    /* FT_Span buffer size for direct rendering only */
@@ -490,6 +488,7 @@ typedef ptrdiff_t  FT_PtrDist;
    typedef struct  gray_TWorker_
+   {
      ft_jmp_buf  jump_buffer;
 +    FT_Memory   memory;
      TCoord  min_ex, max_ex;  /* min and max integer pixel coordinates */
      TCoord  min_ey, max_ey;
@@ -1486,139 +1485,6 @@ typedef ptrdiff_t  FT_PtrDist;
+   }
 -  static void
 -  gray_sweep( RAS_ARG )
 -  {
 -    int  fill = ( ras.outline.flags & FT_OUTLINE_EVEN_ODD_FILL ) ? 0x100
 -                                                                 : INT_MIN;
 -    int  coverage;
 -    int  y;
+-
+-
 -    for ( y = ras.min_ey; y < ras.max_ey; y++ )
 -    {
 -      PCell   cell  = ras.ycells[y - ras.min_ey];
 -      TCoord  x     = ras.min_ex;
 -      TArea   cover = 0;
+-
 -      unsigned char*  line = ras.target.origin - ras.target.pitch * y;
+-
+-
 -      for ( ; cell != ras.cell_null; cell = cell->next )
 -      {
 -        TArea  area;
+-
+-
 -        if ( cover != 0 && cell->x > x )
 -        {
 -          FT_FILL_RULE( coverage, cover, fill );
 -          FT_GRAY_SET( line + x, coverage, cell->x - x );
 -        }
+-
 -        cover += (TArea)cell->cover * ( ONE_PIXEL * 2 );
 -        area   = cover - cell->area;
+-
 -        if ( area != 0 && cell->x >= ras.min_ex )
 -        {
 -          FT_FILL_RULE( coverage, area, fill );
 -          line[cell->x] = (unsigned char)coverage;
 -        }
+-
 -        x = cell->x + 1;
 -      }
+-
 -      if ( cover != 0 )  /* only if cropped */
 -      {
 -        FT_FILL_RULE( coverage, cover, fill );
 -        FT_GRAY_SET( line + x, coverage, ras.max_ex - x );
 -      }
 -    }
 -  }
+-
+-
 -  static void
 -  gray_sweep_direct( RAS_ARG )
 -  {
 -    int  fill = ( ras.outline.flags & FT_OUTLINE_EVEN_ODD_FILL ) ? 0x100
 -                                                                 : INT_MIN;
 -    int  coverage;
 -    int  y;
+-
 -    FT_Span  span[FT_MAX_GRAY_SPANS];
 -    int      n = 0;
+-
+-
 -    for ( y = ras.min_ey; y < ras.max_ey; y++ )
 -    {
 -      PCell   cell  = ras.ycells[y - ras.min_ey];
 -      TCoord  x     = ras.min_ex;
 -      TArea   cover = 0;
+-
+-
 -      for ( ; cell != ras.cell_null; cell = cell->next )
 -      {
 -        TArea  area;
+-
+-
 -        if ( cover != 0 && cell->x > x )
 -        {
 -          FT_FILL_RULE( coverage, cover, fill );
+-
 -          span[n].coverage = (unsigned char)coverage;
 -          span[n].x        = (short)x;
 -          span[n].len      = (unsigned short)( cell->x - x );
+-
 -          if ( ++n == FT_MAX_GRAY_SPANS )
 -          {
 -            /* flush the span buffer and reset the count */
 -            ras.render_span( y, n, span, ras.render_span_data );
 -            n = 0;
 -          }
 -        }
+-
 -        cover += (TArea)cell->cover * ( ONE_PIXEL * 2 );
 -        area   = cover - cell->area;
+-
 -        if ( area != 0 && cell->x >= ras.min_ex )
 -        {
 -          FT_FILL_RULE( coverage, area, fill );
+-
 -          span[n].coverage = (unsigned char)coverage;
 -          span[n].x        = (short)cell->x;
 -          span[n].len      = 1;
+-
 -          if ( ++n == FT_MAX_GRAY_SPANS )
 -          {
 -            /* flush the span buffer and reset the count */
 -            ras.render_span( y, n, span, ras.render_span_data );
 -            n = 0;
 -          }
 -        }
+-
 -        x = cell->x + 1;
 -      }
+-
 -      if ( cover != 0 )  /* only if cropped */
 -      {
 -        FT_FILL_RULE( coverage, cover, fill );
+-
 -        span[n].coverage = (unsigned char)coverage;
 -        span[n].x        = (short)x;
 -        span[n].len      = (unsigned short)( ras.max_ex - x );
+-
 -        ++n;
 -      }
+-
 -      if ( n )
 -      {
 -        /* flush the span buffer and reset the count */
 -        ras.render_span( y, n, span, ras.render_span_data );
 -        n = 0;
 -      }
 -    }
 -  }
+-
+-
  #ifdef STANDALONE_
    /**************************************************************************
@@ -1934,7 +1800,7 @@ typedef ptrdiff_t  FT_PtrDist;
        if ( continued )
          FT_Trace_Enable();
 -      FT_TRACE7(( "band [%d..%d]: %td cell%s remaining/\n",
 +      FT_TRACE7(( "band [%d..%d]: %td cell%s remaining\n",
                    ras.min_ey,
                    ras.max_ey,
                    ras.cell_null - ras.cell_free,
@@ -1952,15 +1818,190 @@ typedef ptrdiff_t  FT_PtrDist;
+   }
 +  static void
 +  gray_sweep( RAS_ARG )
 +  {
 +    int  fill = ( ras.outline.flags & FT_OUTLINE_EVEN_ODD_FILL ) ? 0x100
 +                                                                 : INT_MIN;
 +    int  coverage;
 +    int  y;
++
++
 +    for ( y = ras.min_ey; y < ras.max_ey; y++ )
 +    {
 +      PCell   cell  = ras.ycells[y - ras.min_ey];
 +      TCoord  x     = ras.min_ex;
 +      TArea   cover = 0;
++
 +      unsigned char*  line = ras.target.origin - ras.target.pitch * y;
++
++
 +      for ( ; cell != ras.cell_null; cell = cell->next )
 +      {
 +        TArea  area;
++
++
 +        if ( cover != 0 && cell->x > x )
 +        {
 +          FT_FILL_RULE( coverage, cover, fill );
 +          FT_GRAY_SET( line + x, coverage, cell->x - x );
 +        }
++
 +        cover += (TArea)cell->cover * ( ONE_PIXEL * 2 );
 +        area   = cover - cell->area;
++
 +        if ( area != 0 && cell->x >= ras.min_ex )
 +        {
 +          FT_FILL_RULE( coverage, area, fill );
 +          line[cell->x] = (unsigned char)coverage;
 +        }
++
 +        x = cell->x + 1;
 +      }
++
 +      if ( cover != 0 )  /* only if cropped */
 +      {
 +        FT_FILL_RULE( coverage, cover, fill );
 +        FT_GRAY_SET( line + x, coverage, ras.max_ex - x );
 +      }
 +    }
 +  }
++
++
 +  static void
 +  gray_sweep_direct( RAS_ARG )
 +  {
 +    int  fill = ( ras.outline.flags & FT_OUTLINE_EVEN_ODD_FILL ) ? 0x100
 +                                                                 : INT_MIN;
 +    int  coverage;
 +    int  y;
++
 +    FT_Span  span[FT_MAX_GRAY_SPANS];
 +    int      n = 0;
++
++
 +    for ( y = ras.min_ey; y < ras.max_ey; y++ )
 +    {
 +      PCell   cell  = ras.ycells[y - ras.min_ey];
 +      TCoord  x     = ras.min_ex;
 +      TArea   cover = 0;
++
++
 +      for ( ; cell != ras.cell_null; cell = cell->next )
 +      {
 +        TArea  area;
++
++
 +        if ( cover != 0 && cell->x > x )
 +        {
 +          FT_FILL_RULE( coverage, cover, fill );
++
 +          span[n].coverage = (unsigned char)coverage;
 +          span[n].x        = (short)x;
 +          span[n].len      = (unsigned short)( cell->x - x );
++
 +          if ( ++n == FT_MAX_GRAY_SPANS )
 +          {
 +            /* flush the span buffer and reset the count */
 +            ras.render_span( y, n, span, ras.render_span_data );
 +            n = 0;
 +          }
 +        }
++
 +        cover += (TArea)cell->cover * ( ONE_PIXEL * 2 );
 +        area   = cover - cell->area;
++
 +        if ( area != 0 && cell->x >= ras.min_ex )
 +        {
 +          FT_FILL_RULE( coverage, area, fill );
++
 +          span[n].coverage = (unsigned char)coverage;
 +          span[n].x        = (short)cell->x;
 +          span[n].len      = 1;
++
 +          if ( ++n == FT_MAX_GRAY_SPANS )
 +          {
 +            /* flush the span buffer and reset the count */
 +            ras.render_span( y, n, span, ras.render_span_data );
 +            n = 0;
 +          }
 +        }
++
 +        x = cell->x + 1;
 +      }
++
 +      if ( cover != 0 )  /* only if cropped */
 +      {
 +        FT_FILL_RULE( coverage, cover, fill );
++
 +        span[n].coverage = (unsigned char)coverage;
 +        span[n].x        = (short)x;
 +        span[n].len      = (unsigned short)( ras.max_ex - x );
++
 +        ++n;
 +      }
++
 +      if ( n )
 +      {
 +        /* flush the span buffer and reset the count */
 +        ras.render_span( y, n, span, ras.render_span_data );
 +        n = 0;
 +      }
 +    }
 +  }
++
++
 +  /*
 +   * The taxicab perimeter of the entire outline is used to estimate
 +   * the necessary memory pool or the job size in general.  Clipping
 +   * is ignored because it might hurt the performance.
 +   */
 +  static long
 +  gray_taxi( RAS_ARG )
 +  {
 +    FT_Outline*  outline = &ras.outline;
 +    short        c, p, first, last;
 +    FT_Vector    d, v;
 +    FT_Pos       taxi;
++
++
 +    taxi = 0;
 +    last = -1;
 +    for ( c = 0; c < outline->n_contours; c++ )
 +    {
 +      first = last + 1;
 +      last = outline->contours[c];
++
 +      d = outline->points[last];
 +      for ( p = first; p <= last; p++ )
 +      {
 +        v    = outline->points[p];
 +        d.x -= v.x;
 +        d.y -= v.y;
++
 +        taxi += FT_ABS( d.x ) + FT_ABS( d.y );
++
 +        d = v;
 +      }
 +    }
++
 +    return taxi >> 6;
 +  }
++
++
    static int
    gray_convert_glyph( RAS_ARG )
+   {
      const TCoord  yMin = ras.min_ey;
      const TCoord  yMax = ras.max_ey;
 -    TCell    buffer[FT_MAX_GRAY_POOL];
 +    FT_Error   error = FT_THROW( Ok );
 +    FT_Memory  memory = ras.memory;
++
 +    TCell*   buffer;
      size_t   height = (size_t)( yMax - yMin );
 -    size_t   n = FT_MAX_GRAY_POOL / 8;
 +    size_t   n;
 +    long     size;
      TCoord   y;
      TCoord   bands[32];  /* enough to accommodate bisections */
      TCoord*  band;
@@ -1968,8 +2009,39 @@ typedef ptrdiff_t  FT_PtrDist;
      int  continued = 0;
 +    size = gray_taxi( RAS_VAR );
++
 +    /* taxicab perimeters in excess of 20 CBox perimeters are */
 +    /* not drawn unless in direct mode with possible clipping */
 +    if ( !ras.render_span                                     &&
 +         size > 20 * 2 * ( ras.max_ex - ras.min_ex + height ) )
 +    {
 +      FT_TRACE5(( "Blanking on taxi:cbox = %.2lf\n",
 +                  0.5 * size / ( ras.max_ex - ras.min_ex + height ) ));
 +      return FT_THROW( Ok );
 +    }
++
 +    size += height * sizeof ( PCell ) / sizeof ( TCell ) +
 +            9;  /* empirical extra for local extrema */
++
 +#ifdef FT_MAX_GRAY_POOL
 +    if ( size > FT_MAX_GRAY_POOL )
 +    {
 +      /* both divisions rounded up */
 +      n      = ( size + FT_MAX_GRAY_POOL - 1 ) / FT_MAX_GRAY_POOL;
 +      height = ( height + n - 1 ) / n;
 +      size   = FT_MAX_GRAY_POOL;
 +    }
 +#endif
++
 +    if ( FT_QNEW_ARRAY( buffer, size ) )
 +      return error;
++
 +    FT_TRACE7(( "Allocated %ld cells (%ld bytes)\n",
 +                size, size * sizeof ( TCell ) ));
++
      /* Initialize the null cell at the end of the poll. */
 -    ras.cell_null        = buffer + FT_MAX_GRAY_POOL - 1;
 +    ras.cell_null        = buffer + size - 1;
      ras.cell_null->x     = CELL_MAX_X_VALUE;
      ras.cell_null->area  = 0;
      ras.cell_null->cover = 0;
@@ -1978,13 +2050,6 @@ typedef ptrdiff_t  FT_PtrDist;
      /* set up vertical bands */
      ras.ycells     = (PCell*)buffer;
 -    if ( height > n )
 -    {
 -      /* two divisions rounded up */
 -      n       = ( height + n - 1 ) / n;
 -      height  = ( height + n - 1 ) / n;
 -    }
+-
      for ( y = yMin; y < yMax; )
+     {
        ras.min_ey = y;
@@ -1999,7 +2064,6 @@ typedef ptrdiff_t  FT_PtrDist;
+       {
          TCoord  width = band[0] - band[1];
          TCoord  w;
 -        int     error;
          for ( w = 0; w < width; ++w )
@@ -2028,7 +2092,7 @@ typedef ptrdiff_t  FT_PtrDist;
            continue;
+         }
          else if ( error != Smooth_Err_Raster_Overflow )
 -          return error;
 +          goto Exit;
          /* render pool overflow; we will reduce the render band by half */
          width >>= 1;
@@ -2037,7 +2101,8 @@ typedef ptrdiff_t  FT_PtrDist;
          if ( width == 0 )
+         {
            FT_TRACE7(( "gray_convert_glyph: rotten glyph\n" ));
 -          return FT_THROW( Raster_Overflow );
 +          error = FT_THROW( Raster_Overflow );
 +          goto Exit;
+         }
          band++;
@@ -2046,7 +2111,9 @@ typedef ptrdiff_t  FT_PtrDist;
        } while ( band >= bands );
+     }
 -    return Smooth_Err_Ok;
 +  Exit:
 +    FT_FREE( buffer );
 +    return error;
+   }
@@ -2132,6 +2199,8 @@ typedef ptrdiff_t  FT_PtrDist;
      if ( ras.max_ex <= ras.min_ex || ras.max_ey <= ras.min_ey )
        return Smooth_Err_Ok;
 +    ras.memory = (FT_Memory)((gray_PRaster)raster)->memory;
++
      return gray_convert_glyph( RAS_VAR );
+   }

From:	Alexei Podtelezhnikov (@apodtele)
Subject:	[Git][freetype/freetype][smooth_malloc] 7 commits: fix typo in FT_Outline_Decompose note
Date:	Tue, 10 Oct 2023 02:45:50 +0000

[Git][freetype/freetype][smooth_malloc] 7 commits: fix typo in FT_Outlin

Alexei Podtelezhnikov pushed to branch smooth_malloc at FreeType / FreeType

Commits:

3 changed files:

Changes: