Update bundled freetype to 2.6.1

third_party/freetype/src/base/ftbitmap.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftbitmap.c                                                             */
 /*                                                                         */
 /*    FreeType utility functions for bitmaps (body).                       */
 /*                                                                         */
-/*  Copyright 2004-2009, 2011, 2013, 2014 by                               */
+/*  Copyright 2004-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.                                        */
 /*                                                                         */
 /***************************************************************************/
 
 
 #include <ft2build.h>
 #include FT_INTERNAL_DEBUG_H
 
 #include FT_BITMAP_H
 #include FT_IMAGE_H
 #include FT_INTERNAL_OBJECTS_H
 
 
   static
   const FT_Bitmap  null_bitmap = { 0, 0, 0, 0, 0, 0, 0, 0 };
 
 
   /* documentation is in ftbitmap.h */
 
   FT_EXPORT_DEF( void )
+  FT_Bitmap_Init( FT_Bitmap  *abitmap )
+  {
+    if ( abitmap )
+      *abitmap = null_bitmap;
+  }
+
+
+  /* deprecated function name; retained for ABI compatibility */
+
+  FT_EXPORT_DEF( void )
   FT_Bitmap_New( FT_Bitmap  *abitmap )
   {
     if ( abitmap )
       *abitmap = null_bitmap;
   }
 
 
   /* documentation is in ftbitmap.h */
 
   FT_EXPORT_DEF( FT_Error )
@@ skipping 66 matching lines @@
       if ( source_pitch_sign == target_pitch_sign )
         FT_MEM_COPY( target->buffer, source->buffer, size );
       else
       {
         /* take care of bitmap flow */
         FT_UInt   i;
         FT_Byte*  s = source->buffer;
         FT_Byte*  t = target->buffer;
 
 
-        t += pitch * ( target->rows - 1 );
+        t += (FT_ULong)pitch * ( target->rows - 1 );
 
         for ( i = target->rows; i > 0; i-- )
         {
           FT_ARRAY_COPY( t, s, pitch );
 
           s += pitch;
           t -= pitch;
         }
       }
     }
@@ skipping 22 matching lines @@
     width  = bitmap->width;
     height = bitmap->rows;
     pitch  = bitmap->pitch;
     if ( pitch < 0 )
       pitch = -pitch;
 
     switch ( bitmap->pixel_mode )
     {
     case FT_PIXEL_MODE_MONO:
       bpp       = 1;
-      new_pitch = ( width + xpixels + 7 ) >> 3;
+      new_pitch = (int)( ( width + xpixels + 7 ) >> 3 );
       break;
     case FT_PIXEL_MODE_GRAY2:
       bpp       = 2;
-      new_pitch = ( width + xpixels + 3 ) >> 2;
+      new_pitch = (int)( ( width + xpixels + 3 ) >> 2 );
       break;
     case FT_PIXEL_MODE_GRAY4:
       bpp       = 4;
-      new_pitch = ( width + xpixels + 1 ) >> 1;
+      new_pitch = (int)( ( width + xpixels + 1 ) >> 1 );
       break;
     case FT_PIXEL_MODE_GRAY:
     case FT_PIXEL_MODE_LCD:
     case FT_PIXEL_MODE_LCD_V:
       bpp       = 8;
-      new_pitch = ( width + xpixels );
+      new_pitch = (int)( width + xpixels );
       break;
     default:
       return FT_THROW( Invalid_Glyph_Format );
     }
 
     /* if no need to allocate memory */
     if ( ypixels == 0 && new_pitch <= pitch )
     {
       /* zero the padding */
-      FT_UInt  bit_width = pitch * 8;
+      FT_UInt  bit_width = (FT_UInt)pitch * 8;
       FT_UInt  bit_last  = ( width + xpixels ) * bpp;
 
 
       if ( bit_last < bit_width )
       {
         FT_Byte*  line  = bitmap->buffer + ( bit_last >> 3 );
         FT_Byte*  end   = bitmap->buffer + pitch;
         FT_UInt   shift = bit_last & 7;
         FT_UInt   mask  = 0xFF00U >> shift;
         FT_UInt   count = height;
@@ skipping 22 matching lines @@
       return error;
 
     /* new rows get added at the top of the bitmap, */
     /* thus take care of the flow direction         */
     if ( bitmap->pitch > 0 )
     {
       FT_UInt  len = ( width * bpp + 7 ) >> 3;
 
 
       for ( i = 0; i < bitmap->rows; i++ )
-        FT_MEM_COPY( buffer + new_pitch * ( ypixels + i ),
-                     bitmap->buffer + pitch * i, len );
+        FT_MEM_COPY( buffer + (FT_UInt)new_pitch * ( ypixels + i ),
+                     bitmap->buffer + (FT_UInt)pitch * i,
+                     len );
     }
     else
     {
       FT_UInt  len = ( width * bpp + 7 ) >> 3;
 
 
       for ( i = 0; i < bitmap->rows; i++ )
-        FT_MEM_COPY( buffer + new_pitch * i,
-                     bitmap->buffer + pitch * i, len );
+        FT_MEM_COPY( buffer + (FT_UInt)new_pitch * i,
+                     bitmap->buffer + (FT_UInt)pitch * i,
+                     len );
     }
 
     FT_FREE( bitmap->buffer );
     bitmap->buffer = buffer;
 
     if ( bitmap->pitch < 0 )
       new_pitch = -new_pitch;
 
     /* set pitch only, width and height are left untouched */
     bitmap->pitch = new_pitch;
@@ skipping 37 matching lines @@
 
     switch ( bitmap->pixel_mode )
     {
     case FT_PIXEL_MODE_GRAY2:
     case FT_PIXEL_MODE_GRAY4:
       {
         FT_Bitmap  tmp;
 
 
         /* convert to 8bpp */
-        FT_Bitmap_New( &tmp );
+        FT_Bitmap_Init( &tmp );
         error = FT_Bitmap_Convert( library, bitmap, &tmp, 1 );
         if ( error )
           return error;
 
         FT_Bitmap_Done( library, bitmap );
         *bitmap = tmp;
       }
       break;
 
     case FT_PIXEL_MODE_MONO:
       if ( xstr > 8 )
         xstr = 8;
       break;
 
     case FT_PIXEL_MODE_LCD:
       xstr *= 3;
       break;
 
     case FT_PIXEL_MODE_LCD_V:
       ystr *= 3;
       break;
 
     case FT_PIXEL_MODE_BGRA:
       /* We don't embolden color glyphs. */
       return FT_Err_Ok;
     }
 
-    error = ft_bitmap_assure_buffer( library->memory, bitmap, xstr, ystr );
+    error = ft_bitmap_assure_buffer( library->memory, bitmap,
+                                     (FT_UInt)xstr, (FT_UInt)ystr );
     if ( error )
       return error;
 
     /* take care of bitmap flow */
     pitch = bitmap->pitch;
     if ( pitch > 0 )
       p = bitmap->buffer + pitch * ystr;
     else
     {
       pitch = -pitch;
-      p = bitmap->buffer + pitch * ( bitmap->rows - 1 );
+      p = bitmap->buffer + (FT_UInt)pitch * ( bitmap->rows - 1 );
     }
 
     /* for each row */
     for ( y = 0; y < bitmap->rows ; y++ )
     {
       /*
        * Horizontally:
        *
        * From the last pixel on, make each pixel or'ed with the
        * `xstr' pixels before it.
        */
       for ( x = pitch - 1; x >= 0; x-- )
       {
         unsigned char  tmp;
 
 
         tmp = p[x];
         for ( i = 1; i <= xstr; i++ )
         {
           if ( bitmap->pixel_mode == FT_PIXEL_MODE_MONO )
           {
             p[x] |= tmp >> i;
 
             /* the maximum value of 8 for `xstr' comes from here */
             if ( x > 0 )
               p[x] |= p[x - 1] << ( 8 - i );
 
 #if 0
-            if ( p[x] == 0xff )
+            if ( p[x] == 0xFF )
               break;
 #endif
           }
           else
           {
             if ( x - i >= 0 )
             {
               if ( p[x] + p[x - i] > bitmap->num_grays - 1 )
               {
                 p[x] = (unsigned char)( bitmap->num_grays - 1 );
@@ skipping 23 matching lines @@
 
 
         q = p - bitmap->pitch * x;
         for ( i = 0; i < pitch; i++ )
           q[i] |= p[i];
       }
 
       p += bitmap->pitch;
     }
 
-    bitmap->width += xstr;
-    bitmap->rows += ystr;
+    bitmap->width += (FT_UInt)xstr;
+    bitmap->rows += (FT_UInt)ystr;
 
     return FT_Err_Ok;
   }
 
 
   static FT_Byte
   ft_gray_for_premultiplied_srgb_bgra( const FT_Byte*  bgra )
   {
     FT_UInt  a = bgra[3];
     FT_UInt  l;
@@ skipping 72 matching lines @@
     case FT_PIXEL_MODE_BGRA:
       {
         FT_Int    pad, old_target_pitch, target_pitch;
         FT_ULong  old_size;
 
 
         old_target_pitch = target->pitch;
         if ( old_target_pitch < 0 )
           old_target_pitch = -old_target_pitch;
 
-        old_size = target->rows * old_target_pitch;
+        old_size = target->rows * (FT_UInt)old_target_pitch;
 
         target->pixel_mode = FT_PIXEL_MODE_GRAY;
         target->rows       = source->rows;
         target->width      = source->width;
 
         pad = 0;
         if ( alignment > 0 )
         {
-          pad = source->width % alignment;
+          pad = (FT_Int)source->width % alignment;
           if ( pad != 0 )
             pad = alignment - pad;
         }
 
-        target_pitch = source->width + pad;
+        target_pitch = (FT_Int)source->width + pad;
 
-        if ( target_pitch > 0                                     &&
-             (FT_ULong)target->rows > FT_ULONG_MAX / target_pitch )
+        if ( target_pitch > 0                                               &&
+             (FT_ULong)target->rows > FT_ULONG_MAX / (FT_ULong)target_pitch )
           return FT_THROW( Invalid_Argument );
 
-        if ( target->rows * target_pitch > old_size               &&
+        if ( target->rows * (FT_ULong)target_pitch > old_size              &&
              FT_QREALLOC( target->buffer,
-                          old_size, target->rows * target_pitch ) )
+                          old_size, target->rows * (FT_UInt)target_pitch ) )
           return error;
 
         target->pitch = target->pitch < 0 ? -target_pitch : target_pitch;
       }
       break;
 
     default:
       error = FT_THROW( Invalid_Argument );
     }
 
     s = source->buffer;
     t = target->buffer;
 
     /* take care of bitmap flow */
     if ( source->pitch < 0 )
-      s -= source->pitch * ( source->rows - 1 );
+      s -= source->pitch * (FT_Int)( source->rows - 1 );
     if ( target->pitch < 0 )
-      t -= target->pitch * ( target->rows - 1 );
+      t -= target->pitch * (FT_Int)( target->rows - 1 );
 
     switch ( source->pixel_mode )
     {
     case FT_PIXEL_MODE_MONO:
       {
         FT_UInt  i;
 
 
         target->num_grays = 2;
 
@@ skipping 42 matching lines @@
           t += target->pitch;
         }
       }
       break;
 
 
     case FT_PIXEL_MODE_GRAY:
     case FT_PIXEL_MODE_LCD:
     case FT_PIXEL_MODE_LCD_V:
       {
-        FT_Int   width = source->width;
+        FT_UInt  width = source->width;
         FT_UInt  i;
 
 
         target->num_grays = 256;
 
         for ( i = source->rows; i > 0; i-- )
         {
           FT_ARRAY_COPY( t, s, width );
 
           s += source->pitch;
@@ skipping 131 matching lines @@
   FT_EXPORT_DEF( FT_Error )
   FT_GlyphSlot_Own_Bitmap( FT_GlyphSlot  slot )
   {
     if ( slot && slot->format == FT_GLYPH_FORMAT_BITMAP   &&
          !( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) )
     {
       FT_Bitmap  bitmap;
       FT_Error   error;
 
 
-      FT_Bitmap_New( &bitmap );
+      FT_Bitmap_Init( &bitmap );
       error = FT_Bitmap_Copy( slot->library, &slot->bitmap, &bitmap );
       if ( error )
         return error;
 
       slot->bitmap = bitmap;
       slot->internal->flags |= FT_GLYPH_OWN_BITMAP;
     }
 
     return FT_Err_Ok;
   }
@@ skipping 17 matching lines @@
     memory = library->memory;
 
     FT_FREE( bitmap->buffer );
     *bitmap = null_bitmap;
 
     return FT_Err_Ok;
   }
 
 
 /* END */