[Git][freetype/freetype][gsoc-anurag-2023-final] 11 commits: [dense] Add

Anurag Thakur pushed to branch gsoc-anurag-2023-final at FreeType / FreeType

Commits:

cf779f5f

by Anurag Thakur at 2023-10-10T03:15:13+05:30

[dense] Add -msse4.1 to compile with CMake

* CMakeLists.txt: Add -msse4.1 to ${CMAKE_C_FLAGS}

1bf65eff

by Anurag Thakur at 2023-10-10T03:17:34+05:30

[dense] Add compilation fixes for meson

* builds/meson/parse_modules_cfg.py: Add dense module

* meson.build: Add SSE flags to ft2_defines, -lm to link_args

* src/dense/ftdense.c: Fixes for compilation errors

3b3c4662

by Anurag Thakur at 2023-10-10T03:20:48+05:30

[dense] Add ARM NEON support and improve SSE perf

* src/dense/ftdense.c: Add FT_NEON flag, implement ARM NEON support
in dense_render_glyph, improve SSE performance

* src/dense/rules.mk: Replacse -msse4.1 with -march=native

45de1dba

by Anurag Thakur at 2023-10-10T03:24:09+05:30

[dense] Declare FT_New_Face2

* include/freetype/freetype.h: Add FT_New_Face2 function to be used
for preloading optimization

c33e0b82

by Anurag Thakur at 2023-10-10T03:26:28+05:30

[dense] Add FT_PreLine struct

* include/freetype/freetype.h: Add FT_PreLineRec struct and its handle FT_PreLine

d074c39c

by Anurag Thakur at 2023-10-10T03:28:13+05:30

[dense] Modified FT_FaceRec, FT_GlyphSlotRec and FT_Raster_Params

* include/freetype/freetype.h: Add glyph_array filed to FT_FaceRec,
prelines, prel_shifted fileds to GlyphSlotRec

* include/freetype/ftimage.h: Add prelines filed to FT_raster_Params

e7c4fb9d

by Anurag Thakur at 2023-10-10T03:31:03+05:30

[dense] Add FT_Refresh_Glyph

* include/freetype/freetype.h: Declare FT_Refresh_Glyph

* src/base/ftobjs.c: Implement FT_Refresh_Glyph

b2f570a2

by Anurag Thakur at 2023-10-10T03:35:20+05:30

[dense] Implement FT_New_Face2 and fix glyph loading

* include/freetype/freetype.h: Add filed "size" to FT_Open_Args

* src/base/ftobjs.c: Use slot from face's glyph_array in FT_Load_Glyph
Implement FT_New_Face2

2254ce19

by Anurag Thakur at 2023-10-10T03:38:02+05:30

[dense] Add code for curve flattening at load time

src/base/ftobjs.c: Add Lerp, conic_to2, ft_decompose_outline functions

c1804c48

by Anurag Thakur at 2023-10-10T03:39:47+05:30

[dense] Add support for preloading in ft_open_face_internal

* src/base/ftobjs.c: Add code for loading glyph data into
face->glyph_aray after ft_open_face_internal has succeeded

b1f9f98e

by Anurag Thakur at 2023-10-10T03:41:29+05:30

[dense] Add support for rendering prelines

* src/dense/ftdense.c: Add dense_render_line2 function, that takes
a PreLine as argument.

FT_Outline_Decompose call in dense_render_glyph replaced by a loop
that renders PreLines

* src/dense/ftdenserend.c: Add support for shifting PreLines as
per target bitmap

Changes:

CMakeLists.txt

@@ -247,6 +247,8 @@ if (BUILD_FRAMEWORK)
  endif ()
 +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse4.1")
++
  # Find dependencies
  include(FindPkgConfig)

builds/meson/parse_modules_cfg.py

@@ -87,6 +87,7 @@ def generate_ftmodule(lists):
          names = {
              "raster": ("ft_raster1",),
              "smooth": ("ft_smooth",),
 +            "dense": ("ft_dense",),
              "svg": ("ft_svg",),
              "sdf": ("ft_sdf", "ft_bitmap_sdf"),
          }.get(module)

include/freetype/freetype.h

@@ -1276,6 +1276,7 @@ FT_BEGIN_HEADER
      FT_ListRec        sizes_list;
      FT_Generic        autohint;   /* face-specific auto-hinter data */
 +    FT_GlyphSlot*      glyph_array;
      void*             extensions; /* unused                         */
      FT_Face_Internal  internal;
@@ -1283,6 +1284,44 @@ FT_BEGIN_HEADER
    } FT_FaceRec;
++
 +  /**************************************************************************
 +   *
 +   * @type:
 +   *   FT_PreLine
 +   *
 +   * @description:
 +   *   A handle to FT_PreLineRec_ containing coordinates of start and end
 +   *   points for a line.
 +   *
 +   */
 +  typedef struct FT_PreLineRec_* FT_PreLine;
++
 +  /**************************************************************************
 +   *
 +   * @struct:
 +   *   FT_PreLineRec
 +   *
 +   * @description:
 +   *   Linkedlist containing lines to be drawn for a glyph.
 +   *
 +   * @fields:
 +   *   x1, y1 ::
 +   *     Coordinates of line start point.
 +   *
 +   *   y1, y2 ::
 +   *     Coordinates of line end point.
 +   *
 +   *   next ::
 +   *     The next PreLine for current glyph
 +   *
 +   */
 +  typedef struct FT_PreLineRec_
 +  {
 +    int x1, x2, y1, y2;
 +    FT_PreLine next;
 +  } FT_PreLineRec;
++
    /**************************************************************************
+    *
     * @enum:
@@ -2171,6 +2210,12 @@ FT_BEGIN_HEADER
     *   other ::
     *     Reserved.
+    *
 +   *   prelines ::
 +   *     Linkedlist containing lines to be drawn for the glyph
 +   *
 +   *   prel_shifted ::
 +   *     If the points in preline have been adjustted according to target bitmap
 +   *
     *   lsb_delta ::
     *     The difference between hinted and unhinted left side bearing while
     *     auto-hinting is active.  Zero otherwise.
@@ -2288,6 +2333,8 @@ FT_BEGIN_HEADER
      FT_Pos            rsb_delta;
      void*             other;
 +    FT_PreLine        prelines;
 +    int               prel_shifted;
      FT_Slot_Internal  internal;
@@ -2487,6 +2534,10 @@ FT_BEGIN_HEADER
     *   params ::
     *     Extra parameters passed to the font driver when opening a new face.
+    *
 +   *   size ::
 +   *     Size at which the glyphs will be rendered. Use same value as
 +   *     @FT_Set_Pixel_Sizes
 +   *
     * @note:
     *   The stream type is determined by the contents of `flags`:
+    *
@@ -2524,6 +2575,7 @@ FT_BEGIN_HEADER
      FT_Module       driver;
      FT_Int          num_params;
      FT_Parameter*   params;
 +    FT_UInt         size;
    } FT_Open_Args;
@@ -2573,6 +2625,54 @@ FT_BEGIN_HEADER
                 FT_Face     *aface );
 +/**************************************************************************
 +   *
 +   * @function:
 +   *   FT_New_Face2
 +   *
 +   * @description:
 +   *   Call @FT_Open_Face to open a font by its pathname with given flags.
 +   *
 +   * @inout:
 +   *   library ::
 +   *     A handle to the library resource.
 +   *
 +   * @input:
 +   *   pathname ::
 +   *     A path to the font file.
 +   *
 +   *   face_index ::
 +   *     See @FT_Open_Face for a detailed description of this parameter.
 +   *
 +   *   size ::
 +   *     Size at which glyphs will be rendered, Use the same value as @FT_Set_Pixel_Sizes
 +   *
 +   * @output:
 +   *   aface ::
 +   *     A handle to a new face object.  If `face_index` is greater than or
 +   *     equal to zero, it must be non-`NULL`.
 +   *
 +   * @return:
 +   *   FreeType error code.  0~means success.
 +   *
 +   * @note:
 +   *   The `pathname` string should be recognizable as such by a standard
 +   *   `fopen` call on your system; in particular, this means that `pathname`
 +   *   must not contain null bytes.  If that is not sufficient to address all
 +   *   file name possibilities (for example, to handle wide character file
 +   *   names on Windows in UTF-16 encoding) you might use @FT_Open_Face to
 +   *   pass a memory array or a stream object instead.
 +   *
 +   *   Use @FT_Done_Face to destroy the created @FT_Face object (along with
 +   *   its slot and sizes).
 +   */
 +  FT_EXPORT( FT_Error )
 +  FT_New_Face2( FT_Library   library,
 +               const char*  filepathname,
 +               FT_Long      face_index,
 +               FT_Face     *aface,
 +               FT_UInt      size);
++
    /**************************************************************************
+    *
     * @function:
@@ -3228,6 +3328,31 @@ FT_BEGIN_HEADER
                   FT_UInt   glyph_index,
                   FT_Int32  load_flags );
 +  /**************************************************************************
 +   *
 +   * @function:
 +   *   FT_Refresh_Glyph
 +   *
 +   * @description:
 +   *   Prepare the glyph at glyph_index for rendering. Resets the glyph
 +   *   if it has already been rendered
 +   *
 +   * @inout:
 +   *   face ::
 +   *     A handle to the target face object where the glyph is loaded.
 +   *
 +   * @input:
 +   *   glyph_index ::
 +   *     The index of the glyph in the font file.
 +   *
 +   * @return:
 +   *   FreeType error code.  0~means success.
 +   *
 +   */
 +  FT_EXPORT( FT_Error )
 +  FT_Refresh_Glyph( FT_Face   face,
 +                    FT_UInt   glyph_index);
++
    /**************************************************************************
+    *

include/freetype/ftimage.h

@@ -1030,6 +1030,9 @@ FT_BEGIN_HEADER
     *     An optional span clipping box expressed in _integer_ pixels
     *     (not in 26.6 fixed-point units).
+    *
 +   *   prelines ::
 +   *     Pointer of type FT_PreLine, containing line data for a glyph
 +   *
     * @note:
     *   The @FT_RASTER_FLAG_AA bit flag must be set in the `flags` to
     *   generate an anti-aliased glyph bitmap, otherwise a monochrome bitmap
@@ -1059,6 +1062,7 @@ FT_BEGIN_HEADER
      FT_Raster_BitSet_Func   bit_set;      /* unused */
      void*                   user;
      FT_BBox                 clip_box;
 +    void*                   prelines;
    } FT_Raster_Params;

meson.build

@@ -395,6 +395,13 @@ if use_unix_ftsystem_c
  endif
 +if cc.get_id() == 'msvc'
 +  ft2_defines += ['/arch:AVX']
 +else
 +  ft2_defines += ['-msse4.1']
 +endif
++
++
  ft2_lib = library('freetype',
    sources: ft2_sources + [ftmodule_h],
    c_args: ft2_defines,
@@ -403,7 +410,7 @@ ft2_lib = library('freetype',
    dependencies: ft2_deps,
    install: true,
    version: ft2_so_version,
 -  link_args: common_ldflags,
 +  link_args: common_ldflags + ['-lm'],
+ )

src/base/ftobjs.c

@@ -42,6 +42,7 @@
  #include <freetype/internal/services/svkern.h>
  #include <freetype/internal/services/svtteng.h>
 +#include <math.h>
  #include <freetype/ftdriver.h>
  #ifdef FT_CONFIG_OPTION_MAC_FONTS
@@ -893,6 +894,14 @@
    /* documentation is in freetype.h */
 +  FT_EXPORT_DEF( FT_Error )
 +  FT_Refresh_Glyph( FT_Face   face,
 +                 FT_UInt   glyph_index)
++
 +  {
 +    ft_glyphslot_free_bitmap( face->glyph_array[glyph_index] );
 +    face->glyph_array[glyph_index]->format = FT_GLYPH_FORMAT_OUTLINE;
 +  }
    FT_EXPORT_DEF( FT_Error )
    FT_Load_Glyph( FT_Face   face,
@@ -914,7 +923,7 @@
      /* The validity test for `glyph_index' is performed by the */
      /* font drivers.                                           */
 -    slot = face->glyph;
 +    slot = face->glyph_array[glyph_index];
      ft_glyphslot_clear( slot );
      driver  = face->driver;
@@ -1616,12 +1625,34 @@
        return FT_THROW( Invalid_Argument );
      args.flags    = FT_OPEN_PATHNAME;
 +    args.size     = 0;
      args.pathname = (char*)pathname;
      args.stream   = NULL;
      return ft_open_face_internal( library, &args, face_index, aface, 1 );
+   }
 +  FT_EXPORT_DEF( FT_Error )
 +  FT_New_Face2( FT_Library   library,
 +                const char*  pathname,
 +                FT_Long      face_index,
 +                FT_Face     *aface,
 +                FT_UInt      size)
 +  {
 +    FT_Open_Args  args;
++
 +     /* test for valid `library' and `aface' delayed to `FT_Open_Face' */
 +     if ( !pathname )
 +       return FT_THROW( Invalid_Argument );
++
 +     args.flags    = FT_OPEN_PATHNAME;
 +     args.size     = size;
 +     args.pathname = (char*)pathname;
 +     args.stream   = NULL;
++
 +     return ft_open_face_internal( library, &args, face_index, aface, 1 );
 +  }
++
  #endif
@@ -2519,6 +2550,306 @@
+   }
 +static FT_Vector
 +Lerp( float T, FT_Vector P0, FT_Vector P1 )
 +{
 +  FT_Vector p;
 +  p.x = P0.x + T * ( P1.x - P0.x );
 +  p.y = P0.y + T * ( P1.y - P0.y );
 +  return p;
 +}
++
 +int conic_to2(FT_GlyphSlot* slot, FT_Vector *control, FT_Vector *from, FT_Vector *to, FT_PreLine *ptr)
 +{
 +  /*
 +  Calculate devsq as the square of four times the
 +  distance from the control point to the midpoint of the curve.
 +  This is the place at which the curve is furthest from the
 +  line joining the control points.
++
 +  4 x point on curve = p0 + 2p1 + p2
 +  4 x midpoint = 4p1
++
 +  The division by four is omitted to save time.
 +  */
 +  FT_Vector aP0 = { from->x , from->y};
 +  FT_Vector aP1 = { control->x, control->y };
 +  FT_Vector aP2 = { to->x, to->y };
++
 +  float devx  = aP0.x - aP1.x - aP1.x + aP2.x;
 +  float devy  = aP0.y - aP1.y - aP1.y + aP2.y;
 +  float devsq = devx * devx + devy * devy;
++
 +  if ( devsq < 0.333f )
 +  {
 +    FT_PreLine pl3       = malloc(sizeof(FT_PreLineRec));
 +            pl3->x1      = (*ptr)->x2;
 +            pl3->y1      = (*ptr)->y2;
 +            pl3->x2      = aP2.x;
 +            pl3->y2      = aP2.y;
 +            pl3->next    = NULL;
 +            (*ptr)->next = pl3;
 +            *ptr         = (*ptr)->next;
 +    return 0;
 +  }
++
 +  /*
 +  According to Raph Levien, the reason for the subdivision by n (instead of
 +  recursive division by the Casteljau system) is that "I expect the flatness
 +  computation to be semi-expensive (it's done once rather than on each potential
 +  subdivision) and also because you'll often get fewer subdivisions. Taking a
 +  circular arc as a simplifying assumption, where I get n, a recursive approach
 +  would get 2^ceil(lg n), which, if I haven't made any horrible mistakes, is
 +  expected to be 33% more in the limit".
 +  */
++
 +  const float tol = 3.0f;
 +  int         n   = (int)floor( sqrt( sqrt( tol * devsq ) ) )/8;
 +  FT_Vector p      = aP0;
 +  float     nrecip = 1.0f / ( n + 1.0f );
 +  float     t      = 0.0f;
 +  for ( int i = 0; i < n; i++ )
 +  {
 +    t += nrecip;
 +    FT_Vector next = Lerp( t, Lerp( t, aP0, aP1 ), Lerp( t, aP1, aP2 ) );
 +    FT_PreLine pl4  = malloc(sizeof(FT_PreLineRec));
 +            pl4->x1       = (*ptr)->x2;
 +            pl4->y1       = (*ptr)->y2;
 +            pl4->x2       = next.x;
 +            pl4->y2       = next.y;
 +            pl4->next     = NULL;
 +            (*ptr)->next  = pl4;
 +            *ptr          = (*ptr)->next;
 +            p              = next;
 +  }
++
 +  FT_PreLine pl5          = malloc(sizeof(FT_PreLineRec));
 +            pl5->x1       = (*ptr)->x2;
 +            pl5->y1       = (*ptr)->y2;
 +            pl5->x2       = aP2.x;
 +            pl5->y2       = aP2.y;
 +            pl5->next     = NULL;
 +            (*ptr)->next  = pl5;
 +            *ptr          = (*ptr)->next;
 +  return 0;
 +}
++
 +/**
 + * Convert the outline data of slot to prelines
 +*/
 +FT_Error ft_decompose_outline(FT_GlyphSlot* slot){
 +  FT_Vector   v_last;
 +  FT_Vector   v_control;
 +  FT_Vector   v_start;
++
 +  FT_Vector*  point;
 +  FT_Vector*  limit;
 +  char*       tags;
++
 +  FT_Error    error;
++
 +  FT_Int   n;         /* index of contour in outline     */
 +  FT_Int   first;     /* index of first point in contour */
 +  FT_Int   last;      /* index of last point in contour  */
++
 +  FT_Int   tag;       /* current point's state           */
++
 +  FT_Int   shift;
 +  FT_Pos   delta;
++
 +  FT_Outline* outline = &(*slot)->outline;
++
 +  if ( !outline )
 +    return FT_THROW( Invalid_Outline );
++
 +  last = -1;
 +  FT_PreLine ptr = (*slot)->prelines;
++
 +  for ( n = 0; n < outline->n_contours; n++ )
 +  {
 +    FT_TRACE5(( "ft_decompose_outline: Contour %d\n", n ));
++
 +    first = last + 1;
 +    last  = outline->contours[n];
 +    if ( last < first ){
 +      FT_TRACE5(( "Invalid Outline"));
 +      break;
 +    }
 +    limit = outline->points + last;
++
 +    v_start   = outline->points[first];
++
++
 +    v_last   = outline->points[last];
++
 +    v_control = v_start;
++
 +    point = outline->points + first;
 +    tags  = outline->tags   + first;
 +    tag   = FT_CURVE_TAG( tags[0] );
++
 +    /* A contour cannot start with a cubic control point! */
 +    if ( tag == FT_CURVE_TAG_CUBIC )
 +    {
 +      FT_TRACE5(( "Invalid Outline"));
 +      break;
 +    }
 +    /* check first point to determine origin */
 +    if ( tag == FT_CURVE_TAG_CONIC )
 +    {
 +      /* first point is conic control.  Yes, this happens. */
 +      if ( FT_CURVE_TAG( outline->tags[last] ) == FT_CURVE_TAG_ON )
 +      {
 +        /* start at last point if it is on the curve */
 +        v_start = v_last;
 +        limit--;
 +      }
 +      else
 +      {
 +        /* if both first and last points are conic,         */
 +        /* start at their middle and record its position    */
 +        /* for closure                                      */
 +        v_start.x = ( v_start.x + v_last.x ) / 2;
 +        v_start.y = ( v_start.y + v_last.y ) / 2;
++
 +      /* v_last = v_start; */
 +      }
 +      point--;
 +      tags--;
 +    }
++
 +    FT_TRACE5(( "  move to (%.2f, %.2f)\n",
 +                (double)v_start.x / 64, (double)v_start.y / 64 ));
++
++
 +    FT_PreLine pl  = malloc(sizeof(FT_PreLineRec));
 +          pl->x1 = v_start.x;
 +          pl->y1 = v_start.y;
 +          pl->x2 = v_start.x;
 +          pl->y2 = v_start.y;
 +          pl->next = NULL;
++
 +          if ( ( *slot )->prelines == NULL )
 +          {
 +            ptr = ( *slot )->prelines = pl;
 +          }
 +          else
 +          {
 +            ptr->next = pl;
 +            ptr       = ptr->next;
 +          }
++
 +    while ( point < limit )
 +    {
 +      point++;
 +      tags++;
++
 +      tag = FT_CURVE_TAG( tags[0] );
 +      switch ( tag )
 +      {
 +      case FT_CURVE_TAG_ON:  /* emit a single line_to */
 +        {
 +          FT_Vector  vec;
++
++
 +          vec.x = point->x;
 +          vec.y = point->y;
++
 +          FT_TRACE5(( "  line to (%.2f, %.2f)\n",
 +                      (double)vec.x / 64, (double)vec.y / 64 ));
++
 +          FT_PreLine pl3  = malloc(sizeof(FT_PreLineRec));
 +          pl3->x1 = ptr->x2;
 +          pl3->y1 = ptr->y2;
 +          pl3->x2 = vec.x;
 +          pl3->y2 = vec.y;
 +          pl3->next = NULL;
 +          ptr->next = pl3;
 +          ptr = ptr->next;
 +          continue;
 +        }
++
 +      case FT_CURVE_TAG_CONIC:  /* consume conic arcs */
 +        v_control.x =  point->x ;
 +        v_control.y = point->y ;
++
 +      Do_Conic:
 +        if ( point < limit )
 +        {
 +          FT_Vector  vec;
 +          FT_Vector  v_middle;
++
++
 +          point++;
 +          tags++;
 +          tag = FT_CURVE_TAG( tags[0] );
++
 +          vec.x = point->x;
 +          vec.y = point->y;
++
 +          if ( tag == FT_CURVE_TAG_ON )
 +          {
 +            FT_TRACE5(( "  conic to (%.2f, %.2f)"
 +                        " with control (%.2f, %.2f)\n",
 +                        (double)vec.x / 64,
 +                        (double)vec.y / 64,
 +                        (double)v_control.x / 64,
 +                        (double)v_control.y / 64 ));
 +            FT_Vector vex0 = {ptr->x2, ptr->y2};
 +            error = conic_to2(slot, &v_control, &vex0,&vec , &ptr);
++
 +            continue;
 +          }
++
 +          if ( tag != FT_CURVE_TAG_CONIC )
 +          {
 +            FT_TRACE5( ( "Invalid Outline" ) );
 +            break;
 +          }
 +          v_middle.x = ( v_control.x + vec.x ) / 2;
 +          v_middle.y = ( v_control.y + vec.y ) / 2;
++
 +          FT_TRACE5(( "  conic to (%.2f, %.2f)"
 +                      " with control (%.2f, %.2f)\n",
 +                      (double)v_middle.x / 64,
 +                      (double)v_middle.y / 64,
 +                      (double)v_control.x / 64,
 +                      (double)v_control.y / 64 ));
 +          FT_Vector vex = {ptr->x2, ptr->y2};
 +          error = conic_to2(slot, &v_control, &vex,&v_middle, &ptr);
++
 +          v_control = vec;
 +          goto Do_Conic;
 +        }
++
 +        FT_TRACE5(( "  conic to (%.2f, %.2f)"
 +                    " with control (%.2f, %.2f)\n",
 +                    (double)v_start.x / 64,
 +                    (double)v_start.y / 64,
 +                    (double)v_control.x / 64,
 +                    (double)v_control.y / 64 ));
 +        FT_Vector vex2 = {ptr->x2, ptr->y2};
 +        error = conic_to2( slot, &v_control, &vex2, &v_start, &ptr );
 +      }
 +    }
++
 +    /* close the contour with a line segment */
 +    FT_TRACE5(( "  line to (%.2f, %.2f)\n",
 +                 (double)v_start.x / 64, (double)v_start.y / 64 ));
 +    FT_PreLine pl2  = malloc(sizeof(FT_PreLineRec));
 +    pl2->x1 = ptr->x2;
 +    pl2->y1 = ptr->y2;
 +    pl2->x2 = v_start.x;
 +    pl2->y2 = v_start.y;
 +    pl2->next = NULL;
 +    ptr->next = pl2;
 +    ptr = ptr->next;
++
 +  }
++
 +  return 0;
 +}
++
    static FT_Error
    ft_open_face_internal( FT_Library           library,
                           const FT_Open_Args*  args,
@@ -2748,6 +3079,33 @@
          face->size = size;
+       }
 +      if ( args->size > 0 )
 +      {
 +        face->glyph_array = (FT_GlyphSlot*)malloc(
 +            face->driver->clazz->slot_object_size * face->num_glyphs );
 +        error = FT_Set_Pixel_Sizes( face, 0, args->size );
++
 +        for ( int gindex = 0; gindex < face->num_glyphs; gindex++ )
 +        {
 +          driver                = face->driver;
 +          FT_Driver_Class clazz = driver->clazz;
 +          memory                = driver->root.memory;
++
 +          FT_ALLOC( face->glyph_array[gindex], clazz->slot_object_size );
++
 +          face->glyph_array[gindex]->face         = face;
 +          face->glyph_array[gindex]->prel_shifted = 0;
 +          face->glyph_array[gindex]->glyph_index  = gindex;
 +          ft_glyphslot_init( face->glyph_array[gindex] );
++
 +          face->glyph_array[gindex]->next = NULL;
 +          *face->glyph                    = *face->glyph_array[gindex];
++
 +          FT_Load_Glyph( face, gindex, FT_LOAD_NO_HINTING );
++
 +          ft_decompose_outline( &face->glyph_array[gindex] );
 +        }
 +      }
+     }
      /* some checks */

src/dense/ftdense.c

@@ -16,15 +16,25 @@
      defined( __x86_64__ )                        || \
      defined( _M_AMD64 )                          || \
      ( defined( _M_IX86_FP ) && _M_IX86_FP >= 2 )
 -#  define FT_SSE4_1 1
 +  #define FT_SSE4_1 1
  #else
 -#  define FT_SSE4_1 0
 +  #define FT_SSE4_1 0
 +#endif
++
 +#if defined(__ARM_NEON)
 +  #define FT_NEON 1
 +#else
 +  #define FT_NEON 0
  #endif
  #if FT_SSE4_1
 -    #include <immintrin.h>
 +  #include <immintrin.h>
++
 +#elif FT_NEON
++
 +  #include <arm_neon.h>
  #endif
@@ -83,6 +93,165 @@ dense_line_to( const FT_Vector* to, dense_worker* worker )
    return 0;
+ }
 +void
 +dense_render_line2( dense_worker* worker, FT_PreLine pl )
 +{
++
 +  FT26D6 fx = UPSCALE(pl->x1)>>2;
 +  FT26D6 fy = UPSCALE(pl->y1)>>2;
++
 +  FT26D6 from_x = fx;
 +  FT26D6 from_y = fy;
++
++
 +  FT26D6 tx = UPSCALE(pl->x2)>>2;
 +  FT26D6 ty = UPSCALE(pl->y2)>>2;
++
 +  if ( fy == ty )
 +    return;
++
 +  FT26D6 to_x = tx;
 +  FT26D6 to_y = ty;
++
 +  int dir = 1;
 +  if ( from_y >= to_y )
 +  {
 +    dir = -1;
 +    FT_SWAP(from_x, to_x);
 +    FT_SWAP(from_y, to_y);
 +  }
++
 +  // Clip to the height.
 +  if ( from_y >= worker->m_h<<6 || to_y <= 0 )
 +    return;
++
 +  FT26D6 deltax,deltay;
 +  deltax = to_x - from_x;
 +  deltay = to_y - from_y;
++
 +    FT_UDIVPREP(from_x != to_x, deltax);
++
 +    FT_UDIVPREP(from_y != to_y, deltay);
++
 +  if ( from_y < 0 )
 +  {
 +    from_x -= from_y * deltax/deltay;
 +    from_y = 0;
 +  }
++
 +  if ( to_y > worker->m_h<<6 )
 +  {
 +    to_x -= (( to_y - worker->m_h<<6 ) * deltax/deltay);
 +    to_y = worker->m_h<<6;
 +  }
++
++
 +  if(deltax == 0){
 +    FT26D6 x       = from_x;
 +    int   x0i    = x>>6;
 +    FT26D6 x0floor = x0i<<6;
++
 +    // y-coordinate of first pixel of line
 +    int    y0      = from_y>>6;
++
 +    // y-coordinate of last pixel of line
 +    int    y_limit = (to_y + 0x3f)>>6;
 +    FT20D12* m_a   = worker->m_a;
++
++
++
 +    for ( int y = y0; y < y_limit; y++ )
 +    {
 +      int linestart = y * worker->m_w;
++
 +     FT26D6 dy   = FT_MIN( (y + 1)<<6, to_y ) - FT_MAX( y<<6, from_y );
++
 +      m_a[linestart + x0i] += dir*dy*(64 - x + x0floor);
 +      m_a[linestart + ( x0i + 1 )] += dir*dy*(x-x0floor);
++
 +    }
 +  }
 +  else
 +  {
 +    int    x       = from_x;
 +    int    y0      = from_y>>6;
 +    int    y_limit = (to_y + 0x3f)>>6;
++
 +    FT20D12* m_a     = worker->m_a;
++
 +    for ( int y = y0; y < y_limit; y++ )
 +    {
 +      int   linestart = y * worker->m_w;
 +      FT26D6 dy        = FT_MIN( (y + 1)<<6, to_y ) - FT_MAX( y<<6, from_y );
 +      FT26D6 xnext     = x + FT_UDIV((dy*deltax), deltay);
 +      FT26D6 d         = dy * dir;
++
 +      FT26D6 x0, x1;
 +      if ( x < xnext )
 +      {
 +        x0 = x;
 +        x1 = xnext;
 +      }
 +      else
 +      {
 +        x0 = xnext;
 +        x1 = x;
 +      }
++
++
 +      int   x0i    = x0>>6;
 +      FT26D6 x0floor = x0i<<6;
++
++
 +      int   x1i    = (x1+0x3f)>>6;
 +      FT26D6 x1ceil =  x1i <<6;
++
 +      if ( x1i <= x0i + 1 )
 +      {
 +        FT26D6 xmf = ( ( x + xnext )>>1) - x0floor;
 +        m_a[linestart + x0i] += d * ((1<<6) - xmf);
 +        m_a[linestart + ( x0i + 1 )] += d * xmf;
 +      }
 +      else
 +      {
++
 +        FT26D6 oneOverS = x1 - x0;
++
 +        FT_UDIVPREP(x1 != x0, oneOverS);
++
 +        FT26D6 x0f = x0 - x0floor;
++
++
 +        FT26D6 oneMinusX0f = (1<<6) - x0f;
 +        FT26D6 a0 = FT_UDIV(((oneMinusX0f * oneMinusX0f) >> 1), oneOverS);
 +        FT26D6 x1f = x1 - x1ceil + (1<<6);
 +        FT26D6 am =  FT_UDIV(((x1f * x1f) >> 1) , oneOverS);
++
 +        m_a[linestart + x0i] += d * a0;
++
 +        if ( x1i == x0i + 2 )
 +          m_a[linestart + ( x0i + 1 )] += d * ( (1<<6) - a0 - am );
 +        else
 +        {
 +          FT26D6 a1 =  FT_UDIV((((1<<6) + (1<<5) - x0f) << 6) , oneOverS);
 +          m_a[linestart + ( x0i + 1 )] += d * ( a1 - a0 );
++
 +          FT26D6 dTimesS =  FT_UDIV((d << 12) , oneOverS);
++
 +          for ( FT26D6 xi = x0i + 2; xi < x1i - 1; xi++ )
 +            m_a[linestart + xi] += dTimesS;
++
 +          FT26D6 a2 = a1 +  FT_UDIV((( x1i - x0i - 3 )<<12),oneOverS);
 +          m_a[linestart + ( x1i - 1 )] += d * ( (1<<6) - a2 - am );
 +        }
 +        m_a[linestart + x1i] += d * am;
 +      }
 +      x = xnext;
 +    }
 +  }
 +}
++
++
  void
  dense_render_line( dense_worker* worker, FT_Pos tox, FT_Pos toy )
+ {
@@ -154,7 +323,7 @@ dense_render_line( dense_worker* worker, FT_Pos tox, FT_Pos toy )
+     {
        int linestart = y * worker->m_w;
 -     FT26D6 dy   = min( (y + 1)<<6, to_y ) - max( y<<6, from_y );
 +     FT26D6 dy   = FT_MIN( (y + 1)<<6, to_y ) - FT_MAX( y<<6, from_y );
        m_a[linestart + x0i] += dir*dy*(64 - x + x0floor);
        m_a[linestart + ( x0i + 1 )] += dir*dy*(x-x0floor);
@@ -416,10 +585,16 @@ FT_DEFINE_OUTLINE_FUNCS( dense_decompose_funcs,
+ )
  static int
 -dense_render_glyph( dense_worker* worker, const FT_Bitmap* target )
 +dense_render_glyph( dense_worker* worker, const FT_Bitmap* target, FT_PreLine pl )
+ {
 -  FT_Error error = FT_Outline_Decompose( &( worker->outline ),
 -                                         &dense_decompose_funcs, worker );
 +  FT_Error error = 0;
++
 +  while (pl != NULL)
 +  {
 +    dense_render_line2(worker, pl);
 +    pl = pl->next;
 +  }
++
    // Render into bitmap
    const FT20D12* source = worker->m_a;
    unsigned char* dest     = target->buffer;
@@ -427,8 +602,8 @@ dense_render_glyph( dense_worker* worker, const FT_Bitmap* target )
  #if FT_SSE4_1
 -__m128i offset = _mm_setzero_si128();
 -  __m128i mask   = _mm_set1_epi32( 0x0c080400 );
 +  __m128i offset = _mm_setzero_si128();
 +  __m128i nzero = _mm_castps_si128(_mm_set1_ps(-0.0));
    for (int i = 0; i < worker->m_h*worker->m_w; i += 4)
+   {
@@ -438,34 +613,45 @@ __m128i offset = _mm_setzero_si128();
      x = _mm_add_epi32( x, _mm_slli_si128( x, 4 ) );
 -    x = _mm_add_epi32(
 -        x, _mm_castps_si128( _mm_shuffle_ps( _mm_setzero_ps(),
 -                                             _mm_castsi128_ps( x ), 0x40 ) ) );
 +    x = _mm_add_epi32( x, _mm_slli_si128( x, 8 ) );
 -    // add the prefsum of previous 4 floats to all current floats
 +    // add the prefix sum of previous 4 ints to all ints
      x = _mm_add_epi32( x, offset );
      // take absolute value
 -    __m128i y = _mm_abs_epi32( x );  // fabs(x)
 +    __m128i y = _mm_srli_epi32( _mm_abs_epi32( x) , 4 );
 +    y = _mm_packus_epi16(_mm_packs_epi32(y, nzero), nzero);
 +    _mm_storeu_si32(&dest[i], y);
++
 +    // store the current prefix sum in offset
 +    offset = _mm_shuffle_epi32(x,_MM_SHUFFLE( 3, 3, 3, 3 ) );
 +  }
 +#elif FT_NEON
 +  int32x4_t offset = vdupq_n_s32(0);
 +  int32x4_t nzero =  vreinterpretq_s32_f32(vdupq_n_f32(-0.0));
 -    // cap max value to 1
 -    y = _mm_min_epi32( y, _mm_set1_epi32( 4080 ) );
 +  for (int i = 0; i < worker->m_h*worker->m_w; i += 4)
 +  {
 +    // load 4 floats from source
 -    // reduce to 255
 -    y = _mm_srli_epi32( y, 4 );
 +    int32x4_t x = vld1q_s32( (int32_t*)&source[i] );
 -    // shuffle
 -    y = _mm_shuffle_epi8( y, mask );
 +    x = vaddq_s32( x, vreinterpretq_s32_s8(vextq_s8(vdupq_n_s8(0), vreinterpretq_s8_s32( x), 12) ));
 -    _mm_store_ss( (float*)&dest[i], (__m128)y );
 +    x = vaddq_s32(x, vreinterpretq_s32_s8(vextq_s8(vdupq_n_s8(0), vreinterpretq_s8_s32(x), 8)));
 -    // store the current prefix sum in offset
 -    offset = _mm_castps_si128( _mm_shuffle_ps( _mm_castsi128_ps( x ),
 -                                               _mm_castsi128_ps( x ),
 -                                               _MM_SHUFFLE( 3, 3, 3, 3 ) ) );
 -  }
 +    // add the prefsum of previous 4 floats to all current floats
 +    x = vaddq_s32( x, offset );
++
 +    int32x4_t y = vshrq_n_s32( vabsq_s32( x) , 4 );
 +    y = vreinterpretq_s32_s16(vcombine_s16(vqmovn_s32(y), vqmovn_s32(nzero)));
 +    y = vreinterpretq_s32_u8(vcombine_u8(vqmovun_s16(vreinterpretq_s16_s32(y)), vqmovun_s16(vreinterpretq_s16_s32(nzero))));
++
 +    vst1q_s32(&dest[i], y);
 -#else /* FT_SSE4_1 */
 +    offset = vdupq_laneq_s32(x,3 );
 +  }
 +#else
    FT20D12 value = 0;
@@ -484,7 +670,7 @@ __m128i offset = _mm_setzero_si128();
      dest++;
+   }
 -#endif /* FT_SSE4_1 */
 +#endif /* FT_SSE4_1 || FT_NEON */
    free(worker->m_a);
    return error;
@@ -495,6 +681,7 @@ dense_raster_render( FT_Raster raster, const FT_Raster_Params* params )
+ {
    const FT_Outline* outline    = (const FT_Outline*)params->source;
    FT_Bitmap*  target_map = params->target;
 +  FT_PreLine pl = params->prelines;
    dense_worker worker[1];
@@ -521,7 +708,7 @@ dense_raster_render( FT_Raster raster, const FT_Raster_Params* params )
    worker->m_w = target_map->pitch;
    worker->m_h = target_map->rows;
 -  int size = worker->m_w * worker->m_h + 4;
 +  int size = (worker->m_w * worker->m_h + 3) & ~3;
    worker->m_a      = malloc( sizeof( FT20D12 ) * size );
    worker->m_a_size = size;
@@ -536,7 +723,7 @@ dense_raster_render( FT_Raster raster, const FT_Raster_Params* params )
    // Invert the pitch to account for different +ve y-axis direction in dense array
    // (maybe temporary solution)
    target_map->pitch *= -1;
 -  return dense_render_glyph( worker, target_map );
 +  return dense_render_glyph( worker, target_map, pl );
+ }
  FT_DEFINE_RASTER_FUNCS(

src/dense/ftdenserend.c

@@ -139,7 +139,8 @@
      /* allocate new one */
 -    if ( FT_ALLOC_MULT( bitmap->buffer, bitmap->rows, bitmap->pitch ) )
 +    // ARM NEON crashes if memory is not aligned
 +    if ( FT_ALLOC_MULT( bitmap->buffer, 1,bitmap->rows*bitmap->pitch + 16 ) )
        goto Exit;
      slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
@@ -161,12 +162,25 @@
+     }
      /* translate outline to render it into the bitmap */
 -    if ( x_shift || y_shift )
 -      FT_Outline_Translate( outline, x_shift, y_shift );
 +    if ( (x_shift || y_shift) && !slot->prel_shifted){
 +      //FT_Outline_Translate( outline, x_shift, y_shift );
 +      FT_PreLine pl = slot->prelines;
 +      while (pl!=NULL)
 +      {
 +        pl->x1 += x_shift;
 +        pl->y1 += y_shift;
 +        pl->x2 += x_shift;
 +        pl->y2 += y_shift;
++
 +        pl = pl->next;
 +      }
 +      slot->prel_shifted = 1;
 +    }
      /* set up parameters */
      params.target = bitmap;
      params.source = outline;
 +    params.prelines = slot->prelines;
      /* render the outline */
      error =
@@ -184,8 +198,8 @@
        slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP;
+     }
 -    if ( x_shift || y_shift )
 -      FT_Outline_Translate( outline, -x_shift, -y_shift );
 +    // if ( x_shift || y_shift )
 +    //   FT_Outline_Translate( outline, -x_shift, -y_shift );
      return error;
+   }

src/dense/rules.mk

@@ -24,7 +24,7 @@ DENSE_COMPILE := $(CC) $(ANSIFLAGS)                               \
                          $I$(subst /,$(COMPILER_SEP),$(DENSE_DIR)) \
                          $(INCLUDE_FLAGS)                          \
                          $(FT_CFLAGS)                              \
 -                        "-msse4.1"
 +                        "-march=native"
  # DENSE driver sources (i.e., C files)
+ #

From:	Anurag Thakur (@AdbhutDev)
Subject:	[Git][freetype/freetype][gsoc-anurag-2023-final] 11 commits: [dense] Add -msse4.1 to compile with CMake
Date:	Mon, 09 Oct 2023 22:16:52 +0000