Update bundled freetype to 2.6.1

third_party/freetype/src/cid/cidgload.c

 /***************************************************************************/
 /*                                                                         */
 /*  cidgload.c                                                             */
 /*                                                                         */
 /*    CID-keyed Type1 Glyph Loader (body).                                 */
 /*                                                                         */
-/*  Copyright 1996-2007, 2009, 2010, 2013 by                               */
+/*  Copyright 1996-2015 by                                                 */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used,       */
 /*  modified, and distributed under the terms of the FreeType project      */
 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 /*  this file you indicate that you have read the license and              */
 /*  understand and accept it fully.                                        */
 /*                                                                         */
 /***************************************************************************/
 
@@ skipping 19 matching lines @@
 #define FT_COMPONENT  trace_cidgload
 
 
   FT_CALLBACK_DEF( FT_Error )
   cid_load_glyph( T1_Decoder  decoder,
                   FT_UInt     glyph_index )
   {
     CID_Face       face = (CID_Face)decoder->builder.face;
     CID_FaceInfo   cid  = &face->cid;
     FT_Byte*       p;
-    FT_UInt        fd_select;
+    FT_ULong       fd_select;
     FT_Stream      stream       = face->cid_stream;
     FT_Error       error        = FT_Err_Ok;
-    FT_Byte*       charstring   = 0;
+    FT_Byte*       charstring   = NULL;
     FT_Memory      memory       = face->root.memory;
     FT_ULong       glyph_length = 0;
     PSAux_Service  psaux        = (PSAux_Service)face->psaux;
 
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
     FT_Incremental_InterfaceRec *inc =
                                   face->root.internal->incremental_interface;
 #endif
 
 
     FT_TRACE1(( "cid_load_glyph: glyph index %d\n", glyph_index ));
 
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
 
     /* For incremental fonts get the character data using */
     /* the callback function.                             */
     if ( inc )
     {
       FT_Data  glyph_data;
 
 
       error = inc->funcs->get_glyph_data( inc->object,
                                           glyph_index, &glyph_data );
       if ( error )
         goto Exit;
 
       p         = (FT_Byte*)glyph_data.pointer;
-      fd_select = (FT_UInt)cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
+      fd_select = cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
 
       if ( glyph_data.length != 0 )
       {
-        glyph_length = glyph_data.length - cid->fd_bytes;
+        glyph_length = (FT_ULong)( glyph_data.length - cid->fd_bytes );
         (void)FT_ALLOC( charstring, glyph_length );
         if ( !error )
           ft_memcpy( charstring, glyph_data.pointer + cid->fd_bytes,
                      glyph_length );
       }
 
       inc->funcs->free_glyph_data( inc->object, &glyph_data );
 
       if ( error )
         goto Exit;
     }
 
     else
 
 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
 
     /* For ordinary fonts read the CID font dictionary index */
     /* and charstring offset from the CIDMap.                */
     {
-      FT_UInt   entry_len = cid->fd_bytes + cid->gd_bytes;
+      FT_UInt   entry_len = (FT_UInt)( cid->fd_bytes + cid->gd_bytes );
       FT_ULong  off1;
 
 
       if ( FT_STREAM_SEEK( cid->data_offset + cid->cidmap_offset +
                            glyph_index * entry_len )               ||
            FT_FRAME_ENTER( 2 * entry_len )                         )
         goto Exit;
 
       p            = (FT_Byte*)stream->cursor;
-      fd_select    = (FT_UInt) cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
-      off1         = (FT_ULong)cid_get_offset( &p, (FT_Byte)cid->gd_bytes );
+      fd_select    = cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
+      off1         = cid_get_offset( &p, (FT_Byte)cid->gd_bytes );
       p           += cid->fd_bytes;
       glyph_length = cid_get_offset( &p, (FT_Byte)cid->gd_bytes ) - off1;
       FT_FRAME_EXIT();
 
-      if ( fd_select >= (FT_UInt)cid->num_dicts )
+      if ( fd_select >= (FT_ULong)cid->num_dicts )
       {
         error = FT_THROW( Invalid_Offset );
         goto Exit;
       }
       if ( glyph_length == 0 )
         goto Exit;
       if ( FT_ALLOC( charstring, glyph_length ) )
         goto Exit;
       if ( FT_STREAM_READ_AT( cid->data_offset + off1,
                               charstring, glyph_length ) )
         goto Exit;
     }
 
     /* Now set up the subrs array and parse the charstrings. */
     {
       CID_FaceDict  dict;
       CID_Subrs     cid_subrs = face->subrs + fd_select;
-      FT_Int        cs_offset;
+      FT_UInt       cs_offset;
 
 
       /* Set up subrs */
       decoder->num_subrs = cid_subrs->num_subrs;
       decoder->subrs     = cid_subrs->code;
       decoder->subrs_len = 0;
 
       /* Set up font matrix */
       dict                 = cid->font_dicts + fd_select;
 
       decoder->font_matrix = dict->font_matrix;
       decoder->font_offset = dict->font_offset;
       decoder->lenIV       = dict->private_dict.lenIV;
 
       /* Decode the charstring. */
 
       /* Adjustment for seed bytes. */
-      cs_offset = ( decoder->lenIV >= 0 ? decoder->lenIV : 0 );
+      cs_offset = decoder->lenIV >= 0 ? (FT_UInt)decoder->lenIV : 0;
 
       /* Decrypt only if lenIV >= 0. */
       if ( decoder->lenIV >= 0 )
         psaux->t1_decrypt( charstring, glyph_length, 4330 );
 
       error = decoder->funcs.parse_charstrings(
                 decoder, charstring + cs_offset,
-                (FT_Int)glyph_length - cs_offset );
+                glyph_length - cs_offset );
     }
 
     FT_FREE( charstring );
 
 #ifdef FT_CONFIG_OPTION_INCREMENTAL
 
     /* Incremental fonts can optionally override the metrics. */
     if ( !error && inc && inc->funcs->get_glyph_metrics )
     {
       FT_Incremental_MetricsRec  metrics;
@@ skipping 177 matching lines @@
         FIXED_TO_INT( decoder.builder.advance.x );
 
       internal->glyph_matrix      = font_matrix;
       internal->glyph_delta       = font_offset;
       internal->glyph_transformed = 1;
     }
     else
     {
       FT_BBox            cbox;
       FT_Glyph_Metrics*  metrics = &cidglyph->metrics;
-      FT_Vector          advance;
 
 
       /* copy the _unscaled_ advance width */
       metrics->horiAdvance =
         FIXED_TO_INT( decoder.builder.advance.x );
       cidglyph->linearHoriAdvance =
         FIXED_TO_INT( decoder.builder.advance.x );
       cidglyph->internal->glyph_transformed = 0;
 
       /* make up vertical ones */
       metrics->vertAdvance        = ( face->cid.font_bbox.yMax -
                                       face->cid.font_bbox.yMin ) >> 16;
       cidglyph->linearVertAdvance = metrics->vertAdvance;
 
       cidglyph->format            = FT_GLYPH_FORMAT_OUTLINE;
 
       if ( cidsize->metrics.y_ppem < 24 )
         cidglyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;
 
-      /* apply the font matrix */
-      FT_Outline_Transform( &cidglyph->outline, &font_matrix );
+      /* apply the font matrix, if any */
+      if ( font_matrix.xx != 0x10000L || font_matrix.yy != 0x10000L ||
+           font_matrix.xy != 0        || font_matrix.yx != 0        )
+      {
+        FT_Outline_Transform( &cidglyph->outline, &font_matrix );
 
-      FT_Outline_Translate( &cidglyph->outline,
-                            font_offset.x,
-                            font_offset.y );
+        metrics->horiAdvance = FT_MulFix( metrics->horiAdvance,
+                                          font_matrix.xx );
+        metrics->vertAdvance = FT_MulFix( metrics->vertAdvance,
+                                          font_matrix.yy );
+      }
 
-      advance.x = metrics->horiAdvance;
-      advance.y = 0;
-      FT_Vector_Transform( &advance, &font_matrix );
-      metrics->horiAdvance = advance.x + font_offset.x;
+      if ( font_offset.x || font_offset.y )
+      {
+        FT_Outline_Translate( &cidglyph->outline,
+                              font_offset.x,
+                              font_offset.y );
 
-      advance.x = 0;
-      advance.y = metrics->vertAdvance;
-      FT_Vector_Transform( &advance, &font_matrix );
-      metrics->vertAdvance = advance.y + font_offset.y;
+        metrics->horiAdvance += font_offset.x;
+        metrics->vertAdvance += font_offset.y;
+      }
 
       if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )
       {
         /* scale the outline and the metrics */
         FT_Int       n;
         FT_Outline*  cur = decoder.builder.base;
         FT_Vector*   vec = cur->points;
         FT_Fixed     x_scale = glyph->x_scale;
         FT_Fixed     y_scale = glyph->y_scale;
 
@@ skipping 27 matching lines @@
                                         metrics->vertAdvance );
       }
     }
 
   Exit:
     return error;
   }
 
 
 /* END */