src/sfnt/ttsbit.c

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