src/sfnt/ttsbit.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ttsbit.c                                                               */
   4 /*                                                                         */
   5 /*    TrueType and OpenType embedded bitmap support (body).                */
   6 /*                                                                         */
   7 /*  Copyright 2005-2009, 2013, 2014 by                                     */
   8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
   9 /*                                                                         */
  10 /*  Copyright 2013 by Google, Inc.                                         */
  11 /*  Google Author(s): Behdad Esfahbod.                                     */
  12 /*                                                                         */
  13 /*  This file is part of the FreeType project, and may only be used,       */
  14 /*  modified, and distributed under the terms of the FreeType project      */
  15 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  16 /*  this file you indicate that you have read the license and              */
  17 /*  understand and accept it fully.                                        */
  18 /*                                                                         */
  19 /***************************************************************************/
  20
  21
  22 #include <ft2build.h>
  23 #include FT_INTERNAL_DEBUG_H
  24 #include FT_INTERNAL_STREAM_H
  25 #include FT_TRUETYPE_TAGS_H
  26 #include FT_BITMAP_H
  27 #include "ttsbit.h"
  28
  29 #include "sferrors.h"
  30
  31 #include "ttmtx.h"
  32 #include "pngshim.h"
  33
  34
  35   /*************************************************************************/
  36   /*                                                                       */
  37   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  38   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  39   /* messages during execution.                                            */
  40   /*                                                                       */
  41 #undef  FT_COMPONENT
  42 #define FT_COMPONENT  trace_ttsbit
  43
  44
  45   FT_LOCAL_DEF( FT_Error )
  46   tt_face_load_sbit( TT_Face    face,
  47                      FT_Stream  stream )
  48   {
  49     FT_Error  error;
  50     FT_ULong  table_size;
  51
  52
  53     face->sbit_table       = NULL;
  54     face->sbit_table_size  = 0;
  55     face->sbit_table_type  = TT_SBIT_TABLE_TYPE_NONE;
  56     face->sbit_num_strikes = 0;
  57
  58     error = face->goto_table( face, TTAG_CBLC, stream, &table_size );
  59     if ( !error )
  60       face->sbit_table_type = TT_SBIT_TABLE_TYPE_CBLC;
  61     else
  62     {
  63       error = face->goto_table( face, TTAG_EBLC, stream, &table_size );
  64       if ( error )
  65         error = face->goto_table( face, TTAG_bloc, stream, &table_size );
  66       if ( !error )
  67         face->sbit_table_type = TT_SBIT_TABLE_TYPE_EBLC;
  68     }
  69
  70     if ( error )
  71     {
  72       error = face->goto_table( face, TTAG_sbix, stream, &table_size );
  73       if ( !error )
  74         face->sbit_table_type = TT_SBIT_TABLE_TYPE_SBIX;
  75     }
  76     if ( error )
  77       goto Exit;
  78
  79     if ( table_size < 8 )
  80     {
  81       FT_ERROR(( "tt_face_load_sbit_strikes: table too short\n" ));
  82       error = FT_THROW( Invalid_File_Format );
  83       goto Exit;
  84     }
  85
  86     switch ( (FT_UInt)face->sbit_table_type )
  87     {
  88     case TT_SBIT_TABLE_TYPE_EBLC:
  89     case TT_SBIT_TABLE_TYPE_CBLC:
  90       {
  91         FT_Byte*  p;
  92         FT_Fixed  version;
  93         FT_ULong  num_strikes;
  94         FT_UInt   count;
  95
  96
  97         if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) )
  98           goto Exit;
  99
 100         face->sbit_table_size = table_size;
 101
 102         p = face->sbit_table;
 103
 104         version     = FT_NEXT_ULONG( p );
 105         num_strikes = FT_NEXT_ULONG( p );
 106
 107         if ( ( version & 0xFFFF0000UL ) != 0x00020000UL )
 108         {
 109           error = FT_THROW( Unknown_File_Format );
 110           goto Exit;
 111         }
 112
 113         if ( num_strikes >= 0x10000UL )
 114         {
 115           error = FT_THROW( Invalid_File_Format );
 116           goto Exit;
 117         }
 118
 119         /*
 120          *  Count the number of strikes available in the table.  We are a bit
 121          *  paranoid there and don't trust the data.
 122          */
 123         count = (FT_UInt)num_strikes;
 124         if ( 8 + 48UL * count > table_size )
 125           count = (FT_UInt)( ( table_size - 8 ) / 48 );
 126
 127         face->sbit_num_strikes = count;
 128       }
 129       break;
 130
 131     case TT_SBIT_TABLE_TYPE_SBIX:
 132       {
 133         FT_UShort  version;
 134         FT_UShort  flags;
 135         FT_ULong   num_strikes;
 136         FT_UInt    count;
 137
 138
 139         if ( FT_FRAME_ENTER( 8 ) )
 140           goto Exit;
 141
 142         version     = FT_GET_USHORT();
 143         flags       = FT_GET_USHORT();
 144         num_strikes = FT_GET_ULONG();
 145
 146         FT_FRAME_EXIT();
 147
 148         if ( version < 1 )
 149         {
 150           error = FT_THROW( Unknown_File_Format );
 151           goto Exit;
 152         }
 153
 154         /* Bit 0 must always be `1'.                            */
 155         /* Bit 1 controls the overlay of bitmaps with outlines. */
 156         /* All other bits should be zero.                       */
 157         if ( !( flags == 1 || flags == 3 ) ||
 158              num_strikes >= 0x10000UL      )
 159         {
 160           error = FT_THROW( Invalid_File_Format );
 161           goto Exit;
 162         }
 163
 164         /* we currently don't support bit 1; however, it is better to */
 165         /* draw at least something...                                 */
 166         if ( flags == 3 )
 167           FT_TRACE1(( "tt_face_load_sbit_strikes:"
 168                       " sbix overlay not supported yet\n"
 169                       "                          "
 170                       " expect bad rendering results\n" ));
 171
 172         /*
 173          *  Count the number of strikes available in the table.  We are a bit
 174          *  paranoid there and don't trust the data.
 175          */
 176         count = (FT_UInt)num_strikes;
 177         if ( 8 + 4UL * count > table_size )
 178           count = (FT_UInt)( ( table_size - 8 ) / 4 );
 179
 180         if ( FT_STREAM_SEEK( FT_STREAM_POS() - 8 ) )
 181           goto Exit;
 182
 183         face->sbit_table_size = 8 + count * 4;
 184         if ( FT_FRAME_EXTRACT( face->sbit_table_size, face->sbit_table ) )
 185           goto Exit;
 186
 187         face->sbit_num_strikes = count;
 188       }
 189       break;
 190
 191     default:
 192       error = FT_THROW( Unknown_File_Format );
 193       break;
 194     }
 195
 196     if ( !error )
 197       FT_TRACE3(( "sbit_num_strikes: %u\n", face->sbit_num_strikes ));
 198
 199     return FT_Err_Ok;
 200
 201   Exit:
 202     if ( error )
 203     {
 204       if ( face->sbit_table )
 205         FT_FRAME_RELEASE( face->sbit_table );
 206       face->sbit_table_size = 0;
 207       face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE;
 208     }
 209
 210     return error;
 211   }
 212
 213
 214   FT_LOCAL_DEF( void )
 215   tt_face_free_sbit( TT_Face  face )
 216   {
 217     FT_Stream  stream = face->root.stream;
 218
 219
 220     FT_FRAME_RELEASE( face->sbit_table );
 221     face->sbit_table_size  = 0;
 222     face->sbit_table_type  = TT_SBIT_TABLE_TYPE_NONE;
 223     face->sbit_num_strikes = 0;
 224   }
 225
 226
 227   FT_LOCAL_DEF( FT_Error )
 228   tt_face_set_sbit_strike( TT_Face          face,
 229                            FT_Size_Request  req,
 230                            FT_ULong*        astrike_index )
 231   {
 232     return FT_Match_Size( (FT_Face)face, req, 0, astrike_index );
 233   }
 234
 235
 236   FT_LOCAL_DEF( FT_Error )
 237   tt_face_load_strike_metrics( TT_Face           face,
 238                                FT_ULong          strike_index,
 239                                FT_Size_Metrics*  metrics )
 240   {
 241     if ( strike_index >= (FT_ULong)face->sbit_num_strikes )
 242       return FT_THROW( Invalid_Argument );
 243
 244     switch ( (FT_UInt)face->sbit_table_type )
 245     {
 246     case TT_SBIT_TABLE_TYPE_EBLC:
 247     case TT_SBIT_TABLE_TYPE_CBLC:
 248       {
 249         FT_Byte*  strike;
 250
 251
 252         strike = face->sbit_table + 8 + strike_index * 48;
 253
 254         metrics->x_ppem = (FT_UShort)strike[44];
 255         metrics->y_ppem = (FT_UShort)strike[45];
 256
 257         metrics->ascender  = (FT_Char)strike[16] << 6;  /* hori.ascender  */
 258         metrics->descender = (FT_Char)strike[17] << 6;  /* hori.descender */
 259         metrics->height    = metrics->ascender - metrics->descender;
 260
 261         /* Is this correct? */
 262         metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB  */
 263                                           strike[18] + /* max_width      */
 264                                  (FT_Char)strike[23]   /* min_advance_SB */
 265                                                      ) << 6;
 266         return FT_Err_Ok;
 267       }
 268
 269     case TT_SBIT_TABLE_TYPE_SBIX:
 270       {
 271         FT_Stream       stream = face->root.stream;
 272         FT_UInt         offset, upem;
 273         FT_UShort       ppem, resolution;
 274         TT_HoriHeader  *hori;
 275         FT_ULong        table_size;
 276
 277         FT_Error  error;
 278         FT_Byte*  p;
 279
 280
 281         p      = face->sbit_table + 8 + 4 * strike_index;
 282         offset = FT_NEXT_ULONG( p );
 283
 284         error = face->goto_table( face, TTAG_sbix, stream, &table_size );
 285         if ( error )
 286           return error;
 287
 288         if ( offset + 4  > table_size )
 289           return FT_THROW( Invalid_File_Format );
 290
 291         if ( FT_STREAM_SEEK( FT_STREAM_POS() + offset ) ||
 292              FT_FRAME_ENTER( 4 )                        )
 293           return error;
 294
 295         ppem       = FT_GET_USHORT();
 296         resolution = FT_GET_USHORT();
 297
 298         FT_UNUSED( resolution ); /* What to do with this? */
 299
 300         FT_FRAME_EXIT();
 301
 302         upem = face->header.Units_Per_EM;
 303         hori = &face->horizontal;
 304
 305         metrics->x_ppem = ppem;
 306         metrics->y_ppem = ppem;
 307
 308         metrics->ascender    = ppem * hori->Ascender * 64 / upem;
 309         metrics->descender   = ppem * hori->Descender * 64 / upem;
 310         metrics->height      = ppem * ( hori->Ascender -
 311                                         hori->Descender +
 312                                         hori->Line_Gap ) * 64 / upem;
 313         metrics->max_advance = ppem * hori->advance_Width_Max * 64 / upem;
 314
 315         return error;
 316       }
 317
 318     default:
 319       return FT_THROW( Unknown_File_Format );
 320     }
 321   }
 322
 323
 324   typedef struct  TT_SBitDecoderRec_
 325   {
 326     TT_Face          face;
 327     FT_Stream        stream;
 328     FT_Bitmap*       bitmap;
 329     TT_SBit_Metrics  metrics;
 330     FT_Bool          metrics_loaded;
 331     FT_Bool          bitmap_allocated;
 332     FT_Byte          bit_depth;
 333
 334     FT_ULong         ebdt_start;
 335     FT_ULong         ebdt_size;
 336
 337     FT_ULong         strike_index_array;
 338     FT_ULong         strike_index_count;
 339     FT_Byte*         eblc_base;
 340     FT_Byte*         eblc_limit;
 341
 342   } TT_SBitDecoderRec, *TT_SBitDecoder;
 343
 344
 345   static FT_Error
 346   tt_sbit_decoder_init( TT_SBitDecoder       decoder,
 347                         TT_Face              face,
 348                         FT_ULong             strike_index,
 349                         TT_SBit_MetricsRec*  metrics )
 350   {
 351     FT_Error   error;
 352     FT_Stream  stream = face->root.stream;
 353     FT_ULong   ebdt_size;
 354
 355
 356     error = face->goto_table( face, TTAG_CBDT, stream, &ebdt_size );
 357     if ( error )
 358       error = face->goto_table( face, TTAG_EBDT, stream, &ebdt_size );
 359     if ( error )
 360       error = face->goto_table( face, TTAG_bdat, stream, &ebdt_size );
 361     if ( error )
 362       goto Exit;
 363
 364     decoder->face    = face;
 365     decoder->stream  = stream;
 366     decoder->bitmap  = &face->root.glyph->bitmap;
 367     decoder->metrics = metrics;
 368
 369     decoder->metrics_loaded   = 0;
 370     decoder->bitmap_allocated = 0;
 371
 372     decoder->ebdt_start = FT_STREAM_POS();
 373     decoder->ebdt_size  = ebdt_size;
 374
 375     decoder->eblc_base  = face->sbit_table;
 376     decoder->eblc_limit = face->sbit_table + face->sbit_table_size;
 377
 378     /* now find the strike corresponding to the index */
 379     {
 380       FT_Byte*  p;
 381
 382
 383       if ( 8 + 48 * strike_index + 3 * 4 + 34 + 1 > face->sbit_table_size )
 384       {
 385         error = FT_THROW( Invalid_File_Format );
 386         goto Exit;
 387       }
 388
 389       p = decoder->eblc_base + 8 + 48 * strike_index;
 390
 391       decoder->strike_index_array = FT_NEXT_ULONG( p );
 392       p                          += 4;
 393       decoder->strike_index_count = FT_NEXT_ULONG( p );
 394       p                          += 34;
 395       decoder->bit_depth          = *p;
 396
 397       /* decoder->strike_index_array +                               */
 398       /*   8 * decoder->strike_index_count > face->sbit_table_size ? */
 399       if ( decoder->strike_index_array > face->sbit_table_size           ||
 400            decoder->strike_index_count >
 401              ( face->sbit_table_size - decoder->strike_index_array ) / 8 )
 402         error = FT_THROW( Invalid_File_Format );
 403     }
 404
 405   Exit:
 406     return error;
 407   }
 408
 409
 410   static void
 411   tt_sbit_decoder_done( TT_SBitDecoder  decoder )
 412   {
 413     FT_UNUSED( decoder );
 414   }
 415
 416
 417   static FT_Error
 418   tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder  decoder )
 419   {
 420     FT_Error    error = FT_Err_Ok;
 421     FT_UInt     width, height;
 422     FT_Bitmap*  map = decoder->bitmap;
 423     FT_Long     size;
 424
 425
 426     if ( !decoder->metrics_loaded )
 427     {
 428       error = FT_THROW( Invalid_Argument );
 429       goto Exit;
 430     }
 431
 432     width  = decoder->metrics->width;
 433     height = decoder->metrics->height;
 434
 435     map->width = (int)width;
 436     map->rows  = (int)height;
 437
 438     switch ( decoder->bit_depth )
 439     {
 440     case 1:
 441       map->pixel_mode = FT_PIXEL_MODE_MONO;
 442       map->pitch      = ( map->width + 7 ) >> 3;
 443       map->num_grays  = 2;
 444       break;
 445
 446     case 2:
 447       map->pixel_mode = FT_PIXEL_MODE_GRAY2;
 448       map->pitch      = ( map->width + 3 ) >> 2;
 449       map->num_grays  = 4;
 450       break;
 451
 452     case 4:
 453       map->pixel_mode = FT_PIXEL_MODE_GRAY4;
 454       map->pitch      = ( map->width + 1 ) >> 1;
 455       map->num_grays  = 16;
 456       break;
 457
 458     case 8:
 459       map->pixel_mode = FT_PIXEL_MODE_GRAY;
 460       map->pitch      = map->width;
 461       map->num_grays  = 256;
 462       break;
 463
 464     case 32:
 465       map->pixel_mode = FT_PIXEL_MODE_BGRA;
 466       map->pitch      = map->width * 4;
 467       map->num_grays  = 256;
 468       break;
 469
 470     default:
 471       error = FT_THROW( Invalid_File_Format );
 472       goto Exit;
 473     }
 474
 475     size = map->rows * map->pitch;
 476
 477     /* check that there is no empty image */
 478     if ( size == 0 )
 479       goto Exit;     /* exit successfully! */
 480
 481     error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size );
 482     if ( error )
 483       goto Exit;
 484
 485     decoder->bitmap_allocated = 1;
 486
 487   Exit:
 488     return error;
 489   }
 490
 491
 492   static FT_Error
 493   tt_sbit_decoder_load_metrics( TT_SBitDecoder  decoder,
 494                                 FT_Byte*       *pp,
 495                                 FT_Byte*        limit,
 496                                 FT_Bool         big )
 497   {
 498     FT_Byte*         p       = *pp;
 499     TT_SBit_Metrics  metrics = decoder->metrics;
 500
 501
 502     if ( p + 5 > limit )
 503       goto Fail;
 504
 505     metrics->height       = p[0];
 506     metrics->width        = p[1];
 507     metrics->horiBearingX = (FT_Char)p[2];
 508     metrics->horiBearingY = (FT_Char)p[3];
 509     metrics->horiAdvance  = p[4];
 510
 511     p += 5;
 512     if ( big )
 513     {
 514       if ( p + 3 > limit )
 515         goto Fail;
 516
 517       metrics->vertBearingX = (FT_Char)p[0];
 518       metrics->vertBearingY = (FT_Char)p[1];
 519       metrics->vertAdvance  = p[2];
 520
 521       p += 3;
 522     }
 523     else
 524     {
 525       /* avoid uninitialized data in case there is no vertical info -- */
 526       metrics->vertBearingX = 0;
 527       metrics->vertBearingY = 0;
 528       metrics->vertAdvance  = 0;
 529     }
 530
 531     decoder->metrics_loaded = 1;
 532     *pp = p;
 533     return FT_Err_Ok;
 534
 535   Fail:
 536     FT_TRACE1(( "tt_sbit_decoder_load_metrics: broken table\n" ));
 537     return FT_THROW( Invalid_Argument );
 538   }
 539
 540
 541   /* forward declaration */
 542   static FT_Error
 543   tt_sbit_decoder_load_image( TT_SBitDecoder  decoder,
 544                               FT_UInt         glyph_index,
 545                               FT_Int          x_pos,
 546                               FT_Int          y_pos );
 547
 548   typedef FT_Error  (*TT_SBitDecoder_LoadFunc)( TT_SBitDecoder  decoder,
 549                                                 FT_Byte*        p,
 550                                                 FT_Byte*        plimit,
 551                                                 FT_Int          x_pos,
 552                                                 FT_Int          y_pos );
 553
 554
 555   static FT_Error
 556   tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder  decoder,
 557                                      FT_Byte*        p,
 558                                      FT_Byte*        limit,
 559                                      FT_Int          x_pos,
 560                                      FT_Int          y_pos )
 561   {
 562     FT_Error    error = FT_Err_Ok;
 563     FT_Byte*    line;
 564     FT_Int      bit_height, bit_width, pitch, width, height, line_bits, h;
 565     FT_Bitmap*  bitmap;
 566
 567
 568     /* check that we can write the glyph into the bitmap */
 569     bitmap     = decoder->bitmap;
 570     bit_width  = bitmap->width;
 571     bit_height = bitmap->rows;
 572     pitch      = bitmap->pitch;
 573     line       = bitmap->buffer;
 574
 575     width  = decoder->metrics->width;
 576     height = decoder->metrics->height;
 577
 578     line_bits = width * decoder->bit_depth;
 579
 580     if ( x_pos < 0 || x_pos + width > bit_width   ||
 581          y_pos < 0 || y_pos + height > bit_height )
 582     {
 583       FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned:"
 584                   " invalid bitmap dimensions\n" ));
 585       error = FT_THROW( Invalid_File_Format );
 586       goto Exit;
 587     }
 588
 589     if ( p + ( ( line_bits + 7 ) >> 3 ) * height > limit )
 590     {
 591       FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned: broken bitmap\n" ));
 592       error = FT_THROW( Invalid_File_Format );
 593       goto Exit;
 594     }
 595
 596     /* now do the blit */
 597     line  += y_pos * pitch + ( x_pos >> 3 );
 598     x_pos &= 7;
 599
 600     if ( x_pos == 0 )  /* the easy one */
 601     {
 602       for ( h = height; h > 0; h--, line += pitch )
 603       {
 604         FT_Byte*  pwrite = line;
 605         FT_Int    w;
 606
 607
 608         for ( w = line_bits; w >= 8; w -= 8 )
 609         {
 610           pwrite[0] = (FT_Byte)( pwrite[0] | *p++ );
 611           pwrite   += 1;
 612         }
 613
 614         if ( w > 0 )
 615           pwrite[0] = (FT_Byte)( pwrite[0] | ( *p++ & ( 0xFF00U >> w ) ) );
 616       }
 617     }
 618     else  /* x_pos > 0 */
 619     {
 620       for ( h = height; h > 0; h--, line += pitch )
 621       {
 622         FT_Byte*  pwrite = line;
 623         FT_Int    w;
 624         FT_UInt   wval = 0;
 625
 626
 627         for ( w = line_bits; w >= 8; w -= 8 )
 628         {
 629           wval       = (FT_UInt)( wval | *p++ );
 630           pwrite[0]  = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
 631           pwrite    += 1;
 632           wval     <<= 8;
 633         }
 634
 635         if ( w > 0 )
 636           wval = (FT_UInt)( wval | ( *p++ & ( 0xFF00U >> w ) ) );
 637
 638         /* all bits read and there are `x_pos + w' bits to be written */
 639
 640         pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
 641
 642         if ( x_pos + w > 8 )
 643         {
 644           pwrite++;
 645           wval     <<= 8;
 646           pwrite[0]  = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
 647         }
 648       }
 649     }
 650
 651   Exit:
 652     if ( !error )
 653       FT_TRACE3(( "tt_sbit_decoder_load_byte_aligned: loaded\n" ));
 654     return error;
 655   }
 656
 657
 658   /*
 659    * Load a bit-aligned bitmap (with pointer `p') into a line-aligned bitmap
 660    * (with pointer `pwrite').  In the example below, the width is 3 pixel,
 661    * and `x_pos' is 1 pixel.
 662    *
 663    *       p                               p+1
 664    *     |                               |                               |
 665    *     | 7   6   5   4   3   2   1   0 | 7   6   5   4   3   2   1   0 |...
 666    *     |                               |                               |
 667    *       +-------+   +-------+   +-------+ ...
 668    *           .           .           .
 669    *           .           .           .
 670    *           v           .           .
 671    *       +-------+       .           .
 672    * |                               | .
 673    * | 7   6   5   4   3   2   1   0 | .
 674    * |                               | .
 675    *   pwrite              .           .
 676    *                       .           .
 677    *                       v           .
 678    *                   +-------+       .
 679    *             |                               |
 680    *             | 7   6   5   4   3   2   1   0 |
 681    *             |                               |
 682    *               pwrite+1            .
 683    *                                   .
 684    *                                   v
 685    *                               +-------+
 686    *                         |                               |
 687    *                         | 7   6   5   4   3   2   1   0 |
 688    *                         |                               |
 689    *                           pwrite+2
 690    *
 691    */
 692
 693   static FT_Error
 694   tt_sbit_decoder_load_bit_aligned( TT_SBitDecoder  decoder,
 695                                     FT_Byte*        p,
 696                                     FT_Byte*        limit,
 697                                     FT_Int          x_pos,
 698                                     FT_Int          y_pos )
 699   {
 700     FT_Error    error = FT_Err_Ok;
 701     FT_Byte*    line;
 702     FT_Int      bit_height, bit_width, pitch, width, height, line_bits, h, nbits;
 703     FT_Bitmap*  bitmap;
 704     FT_UShort   rval;
 705
 706
 707     /* check that we can write the glyph into the bitmap */
 708     bitmap     = decoder->bitmap;
 709     bit_width  = bitmap->width;
 710     bit_height = bitmap->rows;
 711     pitch      = bitmap->pitch;
 712     line       = bitmap->buffer;
 713
 714     width  = decoder->metrics->width;
 715     height = decoder->metrics->height;
 716
 717     line_bits = width * decoder->bit_depth;
 718
 719     if ( x_pos < 0 || x_pos + width  > bit_width  ||
 720          y_pos < 0 || y_pos + height > bit_height )
 721     {
 722       FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned:"
 723                   " invalid bitmap dimensions\n" ));
 724       error = FT_THROW( Invalid_File_Format );
 725       goto Exit;
 726     }
 727
 728     if ( p + ( ( line_bits * height + 7 ) >> 3 ) > limit )
 729     {
 730       FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned: broken bitmap\n" ));
 731       error = FT_THROW( Invalid_File_Format );
 732       goto Exit;
 733     }
 734
 735     /* now do the blit */
 736
 737     /* adjust `line' to point to the first byte of the bitmap */
 738     line  += y_pos * pitch + ( x_pos >> 3 );
 739     x_pos &= 7;
 740
 741     /* the higher byte of `rval' is used as a buffer */
 742     rval  = 0;
 743     nbits = 0;
 744
 745     for ( h = height; h > 0; h--, line += pitch )
 746     {
 747       FT_Byte*  pwrite = line;
 748       FT_Int    w      = line_bits;
 749
 750
 751       /* handle initial byte (in target bitmap) specially if necessary */
 752       if ( x_pos )
 753       {
 754         w = ( line_bits < 8 - x_pos ) ? line_bits : 8 - x_pos;
 755
 756         if ( h == height )
 757         {
 758           rval  = *p++;
 759           nbits = x_pos;
 760         }
 761         else if ( nbits < w )
 762         {
 763           if ( p < limit )
 764             rval |= *p++;
 765           nbits += 8 - w;
 766         }
 767         else
 768         {
 769           rval  >>= 8;
 770           nbits  -= w;
 771         }
 772
 773         *pwrite++ |= ( ( rval >> nbits ) & 0xFF ) &
 774                      ( ~( 0xFF << w ) << ( 8 - w - x_pos ) );
 775         rval     <<= 8;
 776
 777         w = line_bits - w;
 778       }
 779
 780       /* handle medial bytes */
 781       for ( ; w >= 8; w -= 8 )
 782       {
 783         rval      |= *p++;
 784         *pwrite++ |= ( rval >> nbits ) & 0xFF;
 785
 786         rval <<= 8;
 787       }
 788
 789       /* handle final byte if necessary */
 790       if ( w > 0 )
 791       {
 792         if ( nbits < w )
 793         {
 794           if ( p < limit )
 795             rval |= *p++;
 796           *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
 797           nbits   += 8 - w;
 798
 799           rval <<= 8;
 800         }
 801         else
 802         {
 803           *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
 804           nbits   -= w;
 805         }
 806       }
 807     }
 808
 809   Exit:
 810     if ( !error )
 811       FT_TRACE3(( "tt_sbit_decoder_load_bit_aligned: loaded\n" ));
 812     return error;
 813   }
 814
 815
 816   static FT_Error
 817   tt_sbit_decoder_load_compound( TT_SBitDecoder  decoder,
 818                                  FT_Byte*        p,
 819                                  FT_Byte*        limit,
 820                                  FT_Int          x_pos,
 821                                  FT_Int          y_pos )
 822   {
 823     FT_Error  error = FT_Err_Ok;
 824     FT_UInt   num_components, nn;
 825
 826     FT_Char  horiBearingX = (FT_Char)decoder->metrics->horiBearingX;
 827     FT_Char  horiBearingY = (FT_Char)decoder->metrics->horiBearingY;
 828     FT_Byte  horiAdvance  = (FT_Byte)decoder->metrics->horiAdvance;
 829     FT_Char  vertBearingX = (FT_Char)decoder->metrics->vertBearingX;
 830     FT_Char  vertBearingY = (FT_Char)decoder->metrics->vertBearingY;
 831     FT_Byte  vertAdvance  = (FT_Byte)decoder->metrics->vertAdvance;
 832
 833
 834     if ( p + 2 > limit )
 835       goto Fail;
 836
 837     num_components = FT_NEXT_USHORT( p );
 838     if ( p + 4 * num_components > limit )
 839     {
 840       FT_TRACE1(( "tt_sbit_decoder_load_compound: broken table\n" ));
 841       goto Fail;
 842     }
 843
 844     FT_TRACE3(( "tt_sbit_decoder_load_compound: loading %d components\n",
 845                 num_components ));
 846
 847     for ( nn = 0; nn < num_components; nn++ )
 848     {
 849       FT_UInt  gindex = FT_NEXT_USHORT( p );
 850       FT_Byte  dx     = FT_NEXT_BYTE( p );
 851       FT_Byte  dy     = FT_NEXT_BYTE( p );
 852
 853
 854       /* NB: a recursive call */
 855       error = tt_sbit_decoder_load_image( decoder, gindex,
 856                                           x_pos + dx, y_pos + dy );
 857       if ( error )
 858         break;
 859     }
 860
 861     FT_TRACE3(( "tt_sbit_decoder_load_compound: done\n" ));
 862
 863     decoder->metrics->horiBearingX = horiBearingX;
 864     decoder->metrics->horiBearingY = horiBearingY;
 865     decoder->metrics->horiAdvance  = horiAdvance;
 866     decoder->metrics->vertBearingX = vertBearingX;
 867     decoder->metrics->vertBearingY = vertBearingY;
 868     decoder->metrics->vertAdvance  = vertAdvance;
 869     decoder->metrics->width        = (FT_Byte)decoder->bitmap->width;
 870     decoder->metrics->height       = (FT_Byte)decoder->bitmap->rows;
 871
 872   Exit:
 873     return error;
 874
 875   Fail:
 876     error = FT_THROW( Invalid_File_Format );
 877     goto Exit;
 878   }
 879
 880
 881 #ifdef FT_CONFIG_OPTION_USE_PNG
 882
 883   static FT_Error
 884   tt_sbit_decoder_load_png( TT_SBitDecoder  decoder,
 885                             FT_Byte*        p,
 886                             FT_Byte*        limit,
 887                             FT_Int          x_pos,
 888                             FT_Int          y_pos )
 889   {
 890     FT_Error  error = FT_Err_Ok;
 891     FT_ULong  png_len;
 892
 893
 894     if ( limit - p < 4 )
 895     {
 896       FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" ));
 897       error = FT_THROW( Invalid_File_Format );
 898       goto Exit;
 899     }
 900
 901     png_len = FT_NEXT_ULONG( p );
 902     if ( (FT_ULong)( limit - p ) < png_len )
 903     {
 904       FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" ));
 905       error = FT_THROW( Invalid_File_Format );
 906       goto Exit;
 907     }
 908
 909     error = Load_SBit_Png( decoder->face->root.glyph,
 910                            x_pos,
 911                            y_pos,
 912                            decoder->bit_depth,
 913                            decoder->metrics,
 914                            decoder->stream->memory,
 915                            p,
 916                            png_len,
 917                            FALSE );
 918
 919   Exit:
 920     if ( !error )
 921       FT_TRACE3(( "tt_sbit_decoder_load_png: loaded\n" ));
 922     return error;
 923   }
 924
 925 #endif /* FT_CONFIG_OPTION_USE_PNG */
 926
 927
 928   static FT_Error
 929   tt_sbit_decoder_load_bitmap( TT_SBitDecoder  decoder,
 930                                FT_UInt         glyph_format,
 931                                FT_ULong        glyph_start,
 932                                FT_ULong        glyph_size,
 933                                FT_Int          x_pos,
 934                                FT_Int          y_pos )
 935   {
 936     FT_Error   error;
 937     FT_Stream  stream = decoder->stream;
 938     FT_Byte*   p;
 939     FT_Byte*   p_limit;
 940     FT_Byte*   data;
 941
 942
 943     /* seek into the EBDT table now */
 944     if ( glyph_start + glyph_size > decoder->ebdt_size )
 945     {
 946       error = FT_THROW( Invalid_Argument );
 947       goto Exit;
 948     }
 949
 950     if ( FT_STREAM_SEEK( decoder->ebdt_start + glyph_start ) ||
 951          FT_FRAME_EXTRACT( glyph_size, data )                )
 952       goto Exit;
 953
 954     p       = data;
 955     p_limit = p + glyph_size;
 956
 957     /* read the data, depending on the glyph format */
 958     switch ( glyph_format )
 959     {
 960     case 1:
 961     case 2:
 962     case 8:
 963     case 17:
 964       error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 );
 965       break;
 966
 967     case 6:
 968     case 7:
 969     case 9:
 970     case 18:
 971       error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 );
 972       break;
 973
 974     default:
 975       error = FT_Err_Ok;
 976     }
 977
 978     if ( error )
 979       goto Fail;
 980
 981     {
 982       TT_SBitDecoder_LoadFunc  loader;
 983
 984
 985       switch ( glyph_format )
 986       {
 987       case 1:
 988       case 6:
 989         loader = tt_sbit_decoder_load_byte_aligned;
 990         break;
 991
 992       case 2:
 993       case 7:
 994         {
 995           /* Don't trust `glyph_format'.  For example, Apple's main Korean */
 996           /* system font, `AppleMyungJo.ttf' (version 7.0d2e6), uses glyph */
 997           /* format 7, but the data is format 6.  We check whether we have */
 998           /* an excessive number of bytes in the image: If it is equal to  */
 999           /* the value for a byte-aligned glyph, use the other loading     */
1000           /* routine.                                                      */
1001           /*                                                               */
1002           /* Note that for some (width,height) combinations, where the     */
1003           /* width is not a multiple of 8, the sizes for bit- and          */
1004           /* byte-aligned data are equal, for example (7,7) or (15,6).  We */
1005           /* then prefer what `glyph_format' specifies.                    */
1006
1007           FT_UInt  width  = decoder->metrics->width;
1008           FT_UInt  height = decoder->metrics->height;
1009
1010           FT_UInt  bit_size  = ( width * height + 7 ) >> 3;
1011           FT_UInt  byte_size = height * ( ( width + 7 ) >> 3 );
1012
1013
1014           if ( bit_size < byte_size                  &&
1015                byte_size == (FT_UInt)( p_limit - p ) )
1016             loader = tt_sbit_decoder_load_byte_aligned;
1017           else
1018             loader = tt_sbit_decoder_load_bit_aligned;
1019         }
1020         break;
1021
1022       case 5:
1023         loader = tt_sbit_decoder_load_bit_aligned;
1024         break;
1025
1026       case 8:
1027         if ( p + 1 > p_limit )
1028           goto Fail;
1029
1030         p += 1;  /* skip padding */
1031         /* fall-through */
1032
1033       case 9:
1034         loader = tt_sbit_decoder_load_compound;
1035         break;
1036
1037       case 17: /* small metrics, PNG image data   */
1038       case 18: /* big metrics, PNG image data     */
1039       case 19: /* metrics in EBLC, PNG image data */
1040 #ifdef FT_CONFIG_OPTION_USE_PNG
1041         loader = tt_sbit_decoder_load_png;
1042         break;
1043 #else
1044         error = FT_THROW( Unimplemented_Feature );
1045         goto Fail;
1046 #endif /* FT_CONFIG_OPTION_USE_PNG */
1047
1048       default:
1049         error = FT_THROW( Invalid_Table );
1050         goto Fail;
1051       }
1052
1053       if ( !decoder->bitmap_allocated )
1054       {
1055         error = tt_sbit_decoder_alloc_bitmap( decoder );
1056         if ( error )
1057           goto Fail;
1058       }
1059
1060       error = loader( decoder, p, p_limit, x_pos, y_pos );
1061     }
1062
1063   Fail:
1064     FT_FRAME_RELEASE( data );
1065
1066   Exit:
1067     return error;
1068   }
1069
1070
1071   static FT_Error
1072   tt_sbit_decoder_load_image( TT_SBitDecoder  decoder,
1073                               FT_UInt         glyph_index,
1074                               FT_Int          x_pos,
1075                               FT_Int          y_pos )
1076   {
1077     /*
1078      *  First, we find the correct strike range that applies to this
1079      *  glyph index.
1080      */
1081
1082     FT_Byte*  p          = decoder->eblc_base + decoder->strike_index_array;
1083     FT_Byte*  p_limit    = decoder->eblc_limit;
1084     FT_ULong  num_ranges = decoder->strike_index_count;
1085     FT_UInt   start, end, index_format, image_format;
1086     FT_ULong  image_start = 0, image_end = 0, image_offset;
1087
1088
1089     for ( ; num_ranges > 0; num_ranges-- )
1090     {
1091       start = FT_NEXT_USHORT( p );
1092       end   = FT_NEXT_USHORT( p );
1093
1094       if ( glyph_index >= start && glyph_index <= end )
1095         goto FoundRange;
1096
1097       p += 4;  /* ignore index offset */
1098     }
1099     goto NoBitmap;
1100
1101   FoundRange:
1102     image_offset = FT_NEXT_ULONG( p );
1103
1104     /* overflow check */
1105     p = decoder->eblc_base + decoder->strike_index_array;
1106     if ( image_offset > (FT_ULong)( p_limit - p ) )
1107       goto Failure;
1108
1109     p += image_offset;
1110     if ( p + 8 > p_limit )
1111       goto NoBitmap;
1112
1113     /* now find the glyph's location and extend within the ebdt table */
1114     index_format = FT_NEXT_USHORT( p );
1115     image_format = FT_NEXT_USHORT( p );
1116     image_offset = FT_NEXT_ULONG ( p );
1117
1118     switch ( index_format )
1119     {
1120     case 1: /* 4-byte offsets relative to `image_offset' */
1121       p += 4 * ( glyph_index - start );
1122       if ( p + 8 > p_limit )
1123         goto NoBitmap;
1124
1125       image_start = FT_NEXT_ULONG( p );
1126       image_end   = FT_NEXT_ULONG( p );
1127
1128       if ( image_start == image_end )  /* missing glyph */
1129         goto NoBitmap;
1130       break;
1131
1132     case 2: /* big metrics, constant image size */
1133       {
1134         FT_ULong  image_size;
1135
1136
1137         if ( p + 12 > p_limit )
1138           goto NoBitmap;
1139
1140         image_size = FT_NEXT_ULONG( p );
1141
1142         if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
1143           goto NoBitmap;
1144
1145         image_start = image_size * ( glyph_index - start );
1146         image_end   = image_start + image_size;
1147       }
1148       break;
1149
1150     case 3: /* 2-byte offsets relative to 'image_offset' */
1151       p += 2 * ( glyph_index - start );
1152       if ( p + 4 > p_limit )
1153         goto NoBitmap;
1154
1155       image_start = FT_NEXT_USHORT( p );
1156       image_end   = FT_NEXT_USHORT( p );
1157
1158       if ( image_start == image_end )  /* missing glyph */
1159         goto NoBitmap;
1160       break;
1161
1162     case 4: /* sparse glyph array with (glyph,offset) pairs */
1163       {
1164         FT_ULong  mm, num_glyphs;
1165
1166
1167         if ( p + 4 > p_limit )
1168           goto NoBitmap;
1169
1170         num_glyphs = FT_NEXT_ULONG( p );
1171
1172         /* overflow check for p + ( num_glyphs + 1 ) * 4 */
1173         if ( p + 4 > p_limit                                         ||
1174              num_glyphs > (FT_ULong)( ( ( p_limit - p ) >> 2 ) - 1 ) )
1175           goto NoBitmap;
1176
1177         for ( mm = 0; mm < num_glyphs; mm++ )
1178         {
1179           FT_UInt  gindex = FT_NEXT_USHORT( p );
1180
1181
1182           if ( gindex == glyph_index )
1183           {
1184             image_start = FT_NEXT_USHORT( p );
1185             p          += 2;
1186             image_end   = FT_PEEK_USHORT( p );
1187             break;
1188           }
1189           p += 2;
1190         }
1191
1192         if ( mm >= num_glyphs )
1193           goto NoBitmap;
1194       }
1195       break;
1196
1197     case 5: /* constant metrics with sparse glyph codes */
1198     case 19:
1199       {
1200         FT_ULong  image_size, mm, num_glyphs;
1201
1202
1203         if ( p + 16 > p_limit )
1204           goto NoBitmap;
1205
1206         image_size = FT_NEXT_ULONG( p );
1207
1208         if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
1209           goto NoBitmap;
1210
1211         num_glyphs = FT_NEXT_ULONG( p );
1212
1213         /* overflow check for p + 2 * num_glyphs */
1214         if ( num_glyphs > (FT_ULong)( ( p_limit - p ) >> 1 ) )
1215           goto NoBitmap;
1216
1217         for ( mm = 0; mm < num_glyphs; mm++ )
1218         {
1219           FT_UInt  gindex = FT_NEXT_USHORT( p );
1220
1221
1222           if ( gindex == glyph_index )
1223             break;
1224         }
1225
1226         if ( mm >= num_glyphs )
1227           goto NoBitmap;
1228
1229         image_start = image_size * mm;
1230         image_end   = image_start + image_size;
1231       }
1232       break;
1233
1234     default:
1235       goto NoBitmap;
1236     }
1237
1238     if ( image_start > image_end )
1239       goto NoBitmap;
1240
1241     image_end  -= image_start;
1242     image_start = image_offset + image_start;
1243
1244     FT_TRACE3(( "tt_sbit_decoder_load_image:"
1245                 " found sbit (format %d) for glyph index %d\n",
1246                 image_format, glyph_index ));
1247
1248     return tt_sbit_decoder_load_bitmap( decoder,
1249                                         image_format,
1250                                         image_start,
1251                                         image_end,
1252                                         x_pos,
1253                                         y_pos );
1254
1255   Failure:
1256     return FT_THROW( Invalid_Table );
1257
1258   NoBitmap:
1259     FT_TRACE4(( "tt_sbit_decoder_load_image:"
1260                 " no sbit found for glyph index %d\n", glyph_index ));
1261
1262     return FT_THROW( Invalid_Argument );
1263   }
1264
1265
1266   static FT_Error
1267   tt_face_load_sbix_image( TT_Face              face,
1268                            FT_ULong             strike_index,
1269                            FT_UInt              glyph_index,
1270                            FT_Stream            stream,
1271                            FT_Bitmap           *map,
1272                            TT_SBit_MetricsRec  *metrics )
1273   {
1274     FT_UInt   sbix_pos, strike_offset, glyph_start, glyph_end;
1275     FT_ULong  table_size;
1276     FT_Int    originOffsetX, originOffsetY;
1277     FT_Tag    graphicType;
1278     FT_Int    recurse_depth = 0;
1279
1280     FT_Error  error;
1281     FT_Byte*  p;
1282
1283     FT_UNUSED( map );
1284
1285
1286     metrics->width  = 0;
1287     metrics->height = 0;
1288
1289     p = face->sbit_table + 8 + 4 * strike_index;
1290     strike_offset = FT_NEXT_ULONG( p );
1291
1292     error = face->goto_table( face, TTAG_sbix, stream, &table_size );
1293     if ( error )
1294       return error;
1295     sbix_pos = FT_STREAM_POS();
1296
1297   retry:
1298     if ( glyph_index > (FT_UInt)face->root.num_glyphs )
1299       return FT_THROW( Invalid_Argument );
1300
1301     if ( strike_offset >= table_size                          ||
1302          table_size - strike_offset < 4 + glyph_index * 4 + 8 )
1303       return FT_THROW( Invalid_File_Format );
1304
1305     if ( FT_STREAM_SEEK( sbix_pos + strike_offset + 4 + glyph_index * 4 ) ||
1306          FT_FRAME_ENTER( 8 )                                              )
1307       return error;
1308
1309     glyph_start = FT_GET_ULONG();
1310     glyph_end   = FT_GET_ULONG();
1311
1312     FT_FRAME_EXIT();
1313
1314     if ( glyph_start == glyph_end )
1315       return FT_THROW( Invalid_Argument );
1316     if ( glyph_start > glyph_end                ||
1317          glyph_end - glyph_start < 8            ||
1318          table_size - strike_offset < glyph_end )
1319       return FT_THROW( Invalid_File_Format );
1320
1321     if ( FT_STREAM_SEEK( sbix_pos + strike_offset + glyph_start ) ||
1322          FT_FRAME_ENTER( glyph_end - glyph_start )                )
1323       return error;
1324
1325     originOffsetX = FT_GET_SHORT();
1326     originOffsetY = FT_GET_SHORT();
1327
1328     graphicType = FT_GET_TAG4();
1329
1330     switch ( graphicType )
1331     {
1332     case FT_MAKE_TAG( 'd', 'u', 'p', 'e' ):
1333       if ( recurse_depth < 4 )
1334       {
1335         glyph_index = FT_GET_USHORT();
1336         FT_FRAME_EXIT();
1337         recurse_depth++;
1338         goto retry;
1339       }
1340       error = FT_THROW( Invalid_File_Format );
1341       break;
1342
1343     case FT_MAKE_TAG( 'p', 'n', 'g', ' ' ):
1344 #ifdef FT_CONFIG_OPTION_USE_PNG
1345       error = Load_SBit_Png( face->root.glyph,
1346                              0,
1347                              0,
1348                              32,
1349                              metrics,
1350                              stream->memory,
1351                              stream->cursor,
1352                              glyph_end - glyph_start - 8,
1353                              TRUE );
1354 #else
1355       error = FT_THROW( Unimplemented_Feature );
1356 #endif
1357       break;
1358
1359     case FT_MAKE_TAG( 'j', 'p', 'g', ' ' ):
1360     case FT_MAKE_TAG( 't', 'i', 'f', 'f' ):
1361     case FT_MAKE_TAG( 'r', 'g', 'b', 'l' ): /* used on iOS 7.1 */
1362       error = FT_THROW( Unknown_File_Format );
1363       break;
1364
1365     default:
1366       error = FT_THROW( Unimplemented_Feature );
1367       break;
1368     }
1369
1370     FT_FRAME_EXIT();
1371
1372     if ( !error )
1373     {
1374       FT_Short   abearing;
1375       FT_UShort  aadvance;
1376
1377
1378       tt_face_get_metrics( face, FALSE, glyph_index, &abearing, &aadvance );
1379
1380       metrics->horiBearingX = (FT_Short)originOffsetX;
1381       metrics->horiBearingY = (FT_Short)( -originOffsetY + metrics->height );
1382       metrics->horiAdvance  = (FT_Short)( aadvance *
1383                                           face->root.size->metrics.x_ppem /
1384                                           face->header.Units_Per_EM );
1385     }
1386
1387     return error;
1388   }
1389
1390   FT_LOCAL( FT_Error )
1391   tt_face_load_sbit_image( TT_Face              face,
1392                            FT_ULong             strike_index,
1393                            FT_UInt              glyph_index,
1394                            FT_UInt              load_flags,
1395                            FT_Stream            stream,
1396                            FT_Bitmap           *map,
1397                            TT_SBit_MetricsRec  *metrics )
1398   {
1399     FT_Error  error = FT_Err_Ok;
1400
1401
1402     switch ( (FT_UInt)face->sbit_table_type )
1403     {
1404     case TT_SBIT_TABLE_TYPE_EBLC:
1405     case TT_SBIT_TABLE_TYPE_CBLC:
1406       {
1407         TT_SBitDecoderRec  decoder[1];
1408
1409
1410         error = tt_sbit_decoder_init( decoder, face, strike_index, metrics );
1411         if ( !error )
1412         {
1413           error = tt_sbit_decoder_load_image( decoder,
1414                                               glyph_index,
1415                                               0,
1416                                               0 );
1417           tt_sbit_decoder_done( decoder );
1418         }
1419       }
1420       break;
1421
1422     case TT_SBIT_TABLE_TYPE_SBIX:
1423       error = tt_face_load_sbix_image( face,
1424                                        strike_index,
1425                                        glyph_index,
1426                                        stream,
1427                                        map,
1428                                        metrics );
1429       break;
1430
1431     default:
1432       error = FT_THROW( Unknown_File_Format );
1433       break;
1434     }
1435
1436     /* Flatten color bitmaps if color was not requested. */
1437     if ( !error                                &&
1438          !( load_flags & FT_LOAD_COLOR )       &&
1439          map->pixel_mode == FT_PIXEL_MODE_BGRA )
1440     {
1441       FT_Bitmap   new_map;
1442       FT_Library  library = face->root.glyph->library;
1443
1444
1445       FT_Bitmap_New( &new_map );
1446
1447       /* Convert to 8bit grayscale. */
1448       error = FT_Bitmap_Convert( library, map, &new_map, 1 );
1449       if ( error )
1450         FT_Bitmap_Done( library, &new_map );
1451       else
1452       {
1453         map->pixel_mode = new_map.pixel_mode;
1454         map->pitch      = new_map.pitch;
1455         map->num_grays  = new_map.num_grays;
1456
1457         ft_glyphslot_set_bitmap( face->root.glyph, new_map.buffer );
1458         face->root.glyph->internal->flags |= FT_GLYPH_OWN_BITMAP;
1459       }
1460     }
1461
1462     return error;
1463   }
1464
1465
1466 /* EOF */