Update freetype to 2.5.4.

third_party/freetype/src/cff/cf2ft.c

 /***************************************************************************/
 /*                                                                         */
 /*  cf2ft.c                                                                */
 /*                                                                         */
 /*    FreeType Glue Component to Adobe's Interpreter (body).               */
 /*                                                                         */
-/*  Copyright 2013 Adobe Systems Incorporated.                             */
+/*  Copyright 2013-2014 Adobe Systems Incorporated.                        */
 /*                                                                         */
 /*  This software, and all works of authorship, whether in source or       */
 /*  object code form as indicated by the copyright notice(s) included      */
 /*  herein (collectively, the "Work") is made available, and may only be   */
 /*  used, modified, and distributed under the FreeType Project License,    */
 /*  LICENSE.TXT.  Additionally, subject to the terms and conditions of the */
 /*  FreeType Project License, each contributor to the Work hereby grants   */
 /*  to any individual or legal entity exercising permissions granted by    */
 /*  the FreeType Project License and this section (hereafter, "You" or     */
 /*  "Your") a perpetual, worldwide, non-exclusive, no-charge,              */
@@ skipping 12 matching lines @@
 /*                                                                         */
 /*  By using, modifying, or distributing the Work you indicate that you    */
 /*  have read and understood the terms and conditions of the               */
 /*  FreeType Project License as well as those provided in this section,    */
 /*  and you accept them fully.                                             */
 /*                                                                         */
 /***************************************************************************/
 
 
 #include "cf2ft.h"
-#include "../../include/freetype/internal/ftdebug.h"
+#include FT_INTERNAL_DEBUG_H
 
 #include "cf2font.h"
 #include "cf2error.h"
 
 
 #define CF2_MAX_SIZE  cf2_intToFixed( 2000 )    /* max ppem */
 
 
   /*
    * This check should avoid most internal overflow cases.  Clients should
    * generally respond to `Glyph_Too_Big' by getting a glyph outline
    * at EM size, scaling it and filling it as a graphics operation.
    *
    */
   static FT_Error
   cf2_checkTransform( const CF2_Matrix*  transform,
                       CF2_Int            unitsPerEm )
   {
     CF2_Fixed  maxScale;
 
 
     FT_ASSERT( unitsPerEm > 0 );
 
-    FT_ASSERT( transform->a > 0 && transform->d > 0 );
+    if ( transform->a <= 0 || transform->d <= 0 )
+      return FT_THROW( Invalid_Size_Handle );
+
     FT_ASSERT( transform->b == 0 && transform->c == 0 );
     FT_ASSERT( transform->tx == 0 && transform->ty == 0 );
 
     if ( unitsPerEm > 0x7FFF )
       return FT_THROW( Glyph_Too_Big );
 
     maxScale = FT_DivFix( CF2_MAX_SIZE, cf2_intToFixed( unitsPerEm ) );
 
     if ( transform->a > maxScale || transform->d > maxScale )
       return FT_THROW( Glyph_Too_Big );
@@ skipping 58 matching lines @@
     /* note: two successive moves simply close the contour twice */
     cff_builder_close_contour( builder );
     builder->path_begun = 0;
   }
 
 
   static void
   cf2_builder_lineTo( CF2_OutlineCallbacks      callbacks,
                       const CF2_CallbackParams  params )
   {
+    FT_Error  error;
+
     /* downcast the object pointer */
     CF2_Outline   outline = (CF2_Outline)callbacks;
     CFF_Builder*  builder;
-        FT_Error          error;
 
 
     FT_ASSERT( outline && outline->decoder );
     FT_ASSERT( params->op == CF2_PathOpLineTo );
 
     builder = &outline->decoder->builder;
 
     if ( !builder->path_begun )
     {
       /* record the move before the line; also check points and set */
       /* `path_begun'                                               */
-                error = cff_builder_start_point(builder,
-                               params->pt0.x,
-                               params->pt0.y );
-                if (callbacks && callbacks->error) *callbacks->error = error;
-                if (error) return;
+      error = cff_builder_start_point( builder,
+                                       params->pt0.x,
+                                       params->pt0.y );
+      if ( error )
+      {
+        if ( !*callbacks->error )
+          *callbacks->error =  error;
+        return;
+      }
     }
 
     /* `cff_builder_add_point1' includes a check_points call for one point */
-        error = cff_builder_add_point1(builder,
-                            params->pt1.x,
-                            params->pt1.y );
-        if (callbacks && callbacks->error) *callbacks->error = error;
+    error = cff_builder_add_point1( builder,
+                                    params->pt1.x,
+                                    params->pt1.y );
+    if ( error )
+    {
+      if ( !*callbacks->error )
+        *callbacks->error =  error;
+      return;
+    }
   }
 
 
   static void
   cf2_builder_cubeTo( CF2_OutlineCallbacks      callbacks,
                       const CF2_CallbackParams  params )
   {
+    FT_Error  error;
+
     /* downcast the object pointer */
     CF2_Outline   outline = (CF2_Outline)callbacks;
     CFF_Builder*  builder;
-        FT_Error          error;
 
 
     FT_ASSERT( outline && outline->decoder );
     FT_ASSERT( params->op == CF2_PathOpCubeTo );
 
     builder = &outline->decoder->builder;
 
     if ( !builder->path_begun )
     {
       /* record the move before the line; also check points and set */
       /* `path_begun'                                               */
       error = cff_builder_start_point( builder,
-                               params->pt0.x,
-                               params->pt0.y );
-          if (callbacks && callbacks->error) *callbacks->error = error;
-          if (error) return;
+                                       params->pt0.x,
+                                       params->pt0.y );
+      if ( error )
+      {
+        if ( !*callbacks->error )
+          *callbacks->error =  error;
+        return;
+      }
     }
 
     /* prepare room for 3 points: 2 off-curve, 1 on-curve */
     error = cff_check_points( builder, 3 );
-        if (callbacks && callbacks->error) *callbacks->error = error;
-        if (error) return;
+    if ( error )
+    {
+      if ( !*callbacks->error )
+        *callbacks->error =  error;
+      return;
+    }
 
     cff_builder_add_point( builder,
                            params->pt1.x,
                            params->pt1.y, 0 );
     cff_builder_add_point( builder,
                            params->pt2.x,
                            params->pt2.y, 0 );
     cff_builder_add_point( builder,
                            params->pt3.x,
                            params->pt3.y, 1 );
@@ skipping 25 matching lines @@
                            FT_Bool*      scaled )
   {
     FT_ASSERT( decoder && decoder->builder.glyph );
 
     /* note: FreeType scale includes a factor of 64 */
     *hinted = decoder->builder.glyph->hint;
     *scaled = decoder->builder.glyph->scaled;
 
     if ( *hinted )
     {
-      *x_scale = FT_DivFix( decoder->builder.glyph->x_scale,
-                            cf2_intToFixed( 64 ) );
-      *y_scale = FT_DivFix( decoder->builder.glyph->y_scale,
-                            cf2_intToFixed( 64 ) );
+      *x_scale = ( decoder->builder.glyph->x_scale + 32 ) / 64;
+      *y_scale = ( decoder->builder.glyph->y_scale + 32 ) / 64;
     }
     else
     {
       /* for unhinted outlines, `cff_slot_load' does the scaling, */
       /* thus render at `unity' scale                             */
 
       *x_scale = 0x0400;   /* 1/64 as 16.16 */
       *y_scale = 0x0400;
     }
   }
@@ skipping 84 matching lines @@
                                &transform.d,
                                &hinted,
                                &scaled );
 
       font->renderingFlags = 0;
       if ( hinted )
         font->renderingFlags |= CF2_FlagsHinted;
       if ( scaled && !driver->no_stem_darkening )
         font->renderingFlags |= CF2_FlagsDarkened;
 
+      font->darkenParams[0] = driver->darken_params[0];
+      font->darkenParams[1] = driver->darken_params[1];
+      font->darkenParams[2] = driver->darken_params[2];
+      font->darkenParams[3] = driver->darken_params[3];
+      font->darkenParams[4] = driver->darken_params[4];
+      font->darkenParams[5] = driver->darken_params[5];
+      font->darkenParams[6] = driver->darken_params[6];
+      font->darkenParams[7] = driver->darken_params[7];
+
       /* now get an outline for this glyph;      */
       /* also get units per em to validate scale */
       font->unitsPerEm = (CF2_Int)cf2_getUnitsPerEm( decoder );
 
-      error2 = cf2_checkTransform( &transform, font->unitsPerEm );
-      if ( error2 )
-        return error2;
+      if ( scaled )
+      {
+        error2 = cf2_checkTransform( &transform, font->unitsPerEm );
+        if ( error2 )
+          return error2;
+      }
 
       error2 = cf2_getGlyphOutline( font, &buf, &transform, &glyphWidth );
       if ( error2 )
         return FT_ERR( Invalid_File_Format );
 
       cf2_setGlyphWidth( &font->outline, glyphWidth );
 
       return FT_Err_Ok;
     }
   }
 
 
   /* get pointer to current FreeType subfont (based on current glyphID) */
   FT_LOCAL_DEF( CFF_SubFont )
   cf2_getSubfont( CFF_Decoder*  decoder )
   {
     FT_ASSERT( decoder && decoder->current_subfont );
 
     return decoder->current_subfont;
   }
 
 
   /* get `y_ppem' from `CFF_Size' */
   FT_LOCAL_DEF( CF2_Fixed )
   cf2_getPpemY( CFF_Decoder*  decoder )
   {
     FT_ASSERT( decoder                          &&
                decoder->builder.face            &&
                decoder->builder.face->root.size );
-    FT_ASSERT( decoder->builder.face->root.size->metrics.y_ppem );
 
+    /*
+     * Note that `y_ppem' can be zero if there wasn't a call to
+     * `FT_Set_Char_Size' or something similar.  However, this isn't a
+     * problem since we come to this place in the code only if
+     * FT_LOAD_NO_SCALE is set (the other case gets caught by
+     * `cf2_checkTransform').  The ppem value is needed to compute the stem
+     * darkening, which is disabled for getting the unscaled outline.
+     *
+     */
     return cf2_intToFixed(
              decoder->builder.face->root.size->metrics.y_ppem );
   }
 
 
   /* get standard stem widths for the current subfont; */
   /* FreeType stores these as integer font units       */
   /* (note: variable names seem swapped)               */
   FT_LOCAL_DEF( CF2_Fixed )
   cf2_getStdVW( CFF_Decoder*  decoder )
@@ skipping 97 matching lines @@
   }
 
 
   /* convert unbiased subroutine index to `CF2_Buffer' and */
   /* return 0 on success                                   */
   FT_LOCAL_DEF( CF2_Int )
   cf2_initGlobalRegionBuffer( CFF_Decoder*  decoder,
                               CF2_UInt      idx,
                               CF2_Buffer    buf )
   {
-    FT_ASSERT( decoder && decoder->globals );
+    FT_ASSERT( decoder );
 
     FT_ZERO( buf );
 
     idx += decoder->globals_bias;
     if ( idx >= decoder->num_globals )
       return TRUE;     /* error */
 
+    FT_ASSERT( decoder->globals );
+
     buf->start =
     buf->ptr   = decoder->globals[idx];
     buf->end   = decoder->globals[idx + 1];
 
     return FALSE;      /* success */
   }
 
 
   /* convert AdobeStandardEncoding code to CF2_Buffer; */
   /* used for seac component                           */
@@ skipping 45 matching lines @@
                          (FT_Byte**)&buf->start,
                          (FT_ULong)( buf->end - buf->start ) );
   }
 
 
   FT_LOCAL_DEF( CF2_Int )
   cf2_initLocalRegionBuffer( CFF_Decoder*  decoder,
                              CF2_UInt      idx,
                              CF2_Buffer    buf )
   {
-    FT_ASSERT( decoder && decoder->locals );
+    FT_ASSERT( decoder );
 
     FT_ZERO( buf );
 
     idx += decoder->locals_bias;
     if ( idx >= decoder->num_locals )
       return TRUE;     /* error */
 
+    FT_ASSERT( decoder->locals );
+
     buf->start =
     buf->ptr   = decoder->locals[idx];
     buf->end   = decoder->locals[idx + 1];
 
     return FALSE;      /* success */
   }
 
 
   FT_LOCAL_DEF( CF2_Fixed )
   cf2_getDefaultWidthX( CFF_Decoder*  decoder )
@@ skipping 37 matching lines @@
 
     FT_ASSERT( decoder );
 
     cff_builder_close_contour( &decoder->builder );
 
     FT_GlyphLoader_Add( decoder->builder.loader );
   }
 
 
 /* END */