thirdparty/freetype-2.3.12/src/sfnt/ttsbit0.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ttsbit0.c                                                              */
   4 /*                                                                         */
   5 /*    TrueType and OpenType embedded bitmap support (body).                */
   6 /*    This is a heap-optimized version.                                    */
   7 /*                                                                         */
   8 /*  Copyright 2005, 2006, 2007, 2008, 2009 by                              */
   9 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  10 /*                                                                         */
  11 /*  This file is part of the FreeType project, and may only be used,       */
  12 /*  modified, and distributed under the terms of the FreeType project      */
  13 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  14 /*  this file you indicate that you have read the license and              */
  15 /*  understand and accept it fully.                                        */
  16 /*                                                                         */
  17 /***************************************************************************/
  18
  19
  20 /* This file is included by ttsbit.c */
  21
  22
  23 #include <ft2build.h>
  24 #include FT_INTERNAL_DEBUG_H
  25 #include FT_INTERNAL_STREAM_H
  26 #include FT_TRUETYPE_TAGS_H
  27 #include "ttsbit.h"
  28
  29 #include "sferrors.h"
  30
  31
  32   /*************************************************************************/
  33   /*                                                                       */
  34   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  35   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  36   /* messages during execution.                                            */
  37   /*                                                                       */
  38 #undef  FT_COMPONENT
  39 #define FT_COMPONENT  trace_ttsbit
  40
  41
  42   FT_LOCAL_DEF( FT_Error )
  43   tt_face_load_eblc( TT_Face    face,
  44                      FT_Stream  stream )
  45   {
  46     FT_Error  error = SFNT_Err_Ok;
  47     FT_Fixed  version;
  48     FT_ULong  num_strikes, table_size;
  49     FT_Byte*  p;
  50     FT_Byte*  p_limit;
  51     FT_UInt   count;
  52
  53
  54     face->sbit_num_strikes = 0;
  55
  56     /* this table is optional */
  57     error = face->goto_table( face, TTAG_EBLC, stream, &table_size );
  58     if ( error )
  59       error = face->goto_table( face, TTAG_bloc, stream, &table_size );
  60     if ( error )
  61       goto Exit;
  62
  63     if ( table_size < 8 )
  64     {
  65       FT_ERROR(( "tt_face_load_sbit_strikes: table too short\n" ));
  66       error = SFNT_Err_Invalid_File_Format;
  67       goto Exit;
  68     }
  69
  70     if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) )
  71       goto Exit;
  72
  73     face->sbit_table_size = table_size;
  74
  75     p       = face->sbit_table;
  76     p_limit = p + table_size;
  77
  78     version     = FT_NEXT_ULONG( p );
  79     num_strikes = FT_NEXT_ULONG( p );
  80
  81     if ( version != 0x00020000UL || num_strikes >= 0x10000UL )
  82     {
  83       FT_ERROR(( "tt_face_load_sbit_strikes: invalid table version\n" ));
  84       error = SFNT_Err_Invalid_File_Format;
  85       goto Fail;
  86     }
  87
  88     /*
  89      *  Count the number of strikes available in the table.  We are a bit
  90      *  paranoid there and don't trust the data.
  91      */
  92     count = (FT_UInt)num_strikes;
  93     if ( 8 + 48UL * count > table_size )
  94       count = (FT_UInt)( ( p_limit - p ) / 48 );
  95
  96     face->sbit_num_strikes = count;
  97
  98     FT_TRACE3(( "sbit_num_strikes: %u\n", count ));
  99   Exit:
 100     return error;
 101
 102   Fail:
 103     FT_FRAME_RELEASE( face->sbit_table );
 104     face->sbit_table_size = 0;
 105     goto Exit;
 106   }
 107
 108
 109   FT_LOCAL_DEF( void )
 110   tt_face_free_eblc( TT_Face  face )
 111   {
 112     FT_Stream  stream = face->root.stream;
 113
 114
 115     FT_FRAME_RELEASE( face->sbit_table );
 116     face->sbit_table_size  = 0;
 117     face->sbit_num_strikes = 0;
 118   }
 119
 120
 121   FT_LOCAL_DEF( FT_Error )
 122   tt_face_set_sbit_strike( TT_Face          face,
 123                            FT_Size_Request  req,
 124                            FT_ULong*        astrike_index )
 125   {
 126     return FT_Match_Size( (FT_Face)face, req, 0, astrike_index );
 127   }
 128
 129
 130   FT_LOCAL_DEF( FT_Error )
 131   tt_face_load_strike_metrics( TT_Face           face,
 132                                FT_ULong          strike_index,
 133                                FT_Size_Metrics*  metrics )
 134   {
 135     FT_Byte*  strike;
 136
 137
 138     if ( strike_index >= (FT_ULong)face->sbit_num_strikes )
 139       return SFNT_Err_Invalid_Argument;
 140
 141     strike = face->sbit_table + 8 + strike_index * 48;
 142
 143     metrics->x_ppem = (FT_UShort)strike[44];
 144     metrics->y_ppem = (FT_UShort)strike[45];
 145
 146     metrics->ascender  = (FT_Char)strike[16] << 6;  /* hori.ascender  */
 147     metrics->descender = (FT_Char)strike[17] << 6;  /* hori.descender */
 148     metrics->height    = metrics->ascender - metrics->descender;
 149
 150     /* XXX: Is this correct? */
 151     metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB  */
 152                                       strike[18] + /* max_width      */
 153                              (FT_Char)strike[23]   /* min_advance_SB */
 154                                                  ) << 6;
 155
 156     return SFNT_Err_Ok;
 157   }
 158
 159
 160   typedef struct  TT_SBitDecoderRec_
 161   {
 162     TT_Face          face;
 163     FT_Stream        stream;
 164     FT_Bitmap*       bitmap;
 165     TT_SBit_Metrics  metrics;
 166     FT_Bool          metrics_loaded;
 167     FT_Bool          bitmap_allocated;
 168     FT_Byte          bit_depth;
 169
 170     FT_ULong         ebdt_start;
 171     FT_ULong         ebdt_size;
 172
 173     FT_ULong         strike_index_array;
 174     FT_ULong         strike_index_count;
 175     FT_Byte*         eblc_base;
 176     FT_Byte*         eblc_limit;
 177
 178   } TT_SBitDecoderRec, *TT_SBitDecoder;
 179
 180
 181   static FT_Error
 182   tt_sbit_decoder_init( TT_SBitDecoder       decoder,
 183                         TT_Face              face,
 184                         FT_ULong             strike_index,
 185                         TT_SBit_MetricsRec*  metrics )
 186   {
 187     FT_Error   error;
 188     FT_Stream  stream = face->root.stream;
 189     FT_ULong   ebdt_size;
 190
 191
 192     error = face->goto_table( face, TTAG_EBDT, stream, &ebdt_size );
 193     if ( error )
 194       error = face->goto_table( face, TTAG_bdat, stream, &ebdt_size );
 195     if ( error )
 196       goto Exit;
 197
 198     decoder->face    = face;
 199     decoder->stream  = stream;
 200     decoder->bitmap  = &face->root.glyph->bitmap;
 201     decoder->metrics = metrics;
 202
 203     decoder->metrics_loaded   = 0;
 204     decoder->bitmap_allocated = 0;
 205
 206     decoder->ebdt_start = FT_STREAM_POS();
 207     decoder->ebdt_size  = ebdt_size;
 208
 209     decoder->eblc_base  = face->sbit_table;
 210     decoder->eblc_limit = face->sbit_table + face->sbit_table_size;
 211
 212     /* now find the strike corresponding to the index */
 213     {
 214       FT_Byte*  p;
 215
 216
 217       if ( 8 + 48 * strike_index + 3 * 4 + 34 + 1 > face->sbit_table_size )
 218       {
 219         error = SFNT_Err_Invalid_File_Format;
 220         goto Exit;
 221       }
 222
 223       p = decoder->eblc_base + 8 + 48 * strike_index;
 224
 225       decoder->strike_index_array = FT_NEXT_ULONG( p );
 226       p                          += 4;
 227       decoder->strike_index_count = FT_NEXT_ULONG( p );
 228       p                          += 34;
 229       decoder->bit_depth          = *p;
 230
 231       if ( decoder->strike_index_array > face->sbit_table_size             ||
 232            decoder->strike_index_array + 8 * decoder->strike_index_count >
 233              face->sbit_table_size                                         )
 234         error = SFNT_Err_Invalid_File_Format;
 235     }
 236
 237   Exit:
 238     return error;
 239   }
 240
 241
 242   static void
 243   tt_sbit_decoder_done( TT_SBitDecoder  decoder )
 244   {
 245     FT_UNUSED( decoder );
 246   }
 247
 248
 249   static FT_Error
 250   tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder  decoder )
 251   {
 252     FT_Error    error = SFNT_Err_Ok;
 253     FT_UInt     width, height;
 254     FT_Bitmap*  map = decoder->bitmap;
 255     FT_Long     size;
 256
 257
 258     if ( !decoder->metrics_loaded )
 259     {
 260       error = SFNT_Err_Invalid_Argument;
 261       goto Exit;
 262     }
 263
 264     width  = decoder->metrics->width;
 265     height = decoder->metrics->height;
 266
 267     map->width = (int)width;
 268     map->rows  = (int)height;
 269
 270     switch ( decoder->bit_depth )
 271     {
 272     case 1:
 273       map->pixel_mode = FT_PIXEL_MODE_MONO;
 274       map->pitch      = ( map->width + 7 ) >> 3;
 275       break;
 276
 277     case 2:
 278       map->pixel_mode = FT_PIXEL_MODE_GRAY2;
 279       map->pitch      = ( map->width + 3 ) >> 2;
 280       break;
 281
 282     case 4:
 283       map->pixel_mode = FT_PIXEL_MODE_GRAY4;
 284       map->pitch      = ( map->width + 1 ) >> 1;
 285       break;
 286
 287     case 8:
 288       map->pixel_mode = FT_PIXEL_MODE_GRAY;
 289       map->pitch      = map->width;
 290       break;
 291
 292     default:
 293       error = SFNT_Err_Invalid_File_Format;
 294       goto Exit;
 295     }
 296
 297     size = map->rows * map->pitch;
 298
 299     /* check that there is no empty image */
 300     if ( size == 0 )
 301       goto Exit;     /* exit successfully! */
 302
 303     error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size );
 304     if ( error )
 305       goto Exit;
 306
 307     decoder->bitmap_allocated = 1;
 308
 309   Exit:
 310     return error;
 311   }
 312
 313
 314   static FT_Error
 315   tt_sbit_decoder_load_metrics( TT_SBitDecoder  decoder,
 316                                 FT_Byte*       *pp,
 317                                 FT_Byte*        limit,
 318                                 FT_Bool         big )
 319   {
 320     FT_Byte*         p       = *pp;
 321     TT_SBit_Metrics  metrics = decoder->metrics;
 322
 323
 324     if ( p + 5 > limit )
 325       goto Fail;
 326
 327     metrics->height       = p[0];
 328     metrics->width        = p[1];
 329     metrics->horiBearingX = (FT_Char)p[2];
 330     metrics->horiBearingY = (FT_Char)p[3];
 331     metrics->horiAdvance  = p[4];
 332
 333     p += 5;
 334     if ( big )
 335     {
 336       if ( p + 3 > limit )
 337         goto Fail;
 338
 339       metrics->vertBearingX = (FT_Char)p[0];
 340       metrics->vertBearingY = (FT_Char)p[1];
 341       metrics->vertAdvance  = p[2];
 342
 343       p += 3;
 344     }
 345
 346     decoder->metrics_loaded = 1;
 347     *pp = p;
 348     return SFNT_Err_Ok;
 349
 350   Fail:
 351     return SFNT_Err_Invalid_Argument;
 352   }
 353
 354
 355   /* forward declaration */
 356   static FT_Error
 357   tt_sbit_decoder_load_image( TT_SBitDecoder  decoder,
 358                               FT_UInt         glyph_index,
 359                               FT_Int          x_pos,
 360                               FT_Int          y_pos );
 361
 362   typedef FT_Error  (*TT_SBitDecoder_LoadFunc)( TT_SBitDecoder  decoder,
 363                                                 FT_Byte*        p,
 364                                                 FT_Byte*        plimit,
 365                                                 FT_Int          x_pos,
 366                                                 FT_Int          y_pos );
 367
 368
 369   static FT_Error
 370   tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder  decoder,
 371                                      FT_Byte*        p,
 372                                      FT_Byte*        limit,
 373                                      FT_Int          x_pos,
 374                                      FT_Int          y_pos )
 375   {
 376     FT_Error    error = SFNT_Err_Ok;
 377     FT_Byte*    line;
 378     FT_Int      bit_height, bit_width, pitch, width, height, h;
 379     FT_Bitmap*  bitmap;
 380
 381
 382     if ( !decoder->bitmap_allocated )
 383     {
 384       error = tt_sbit_decoder_alloc_bitmap( decoder );
 385       if ( error )
 386         goto Exit;
 387     }
 388
 389     /* check that we can write the glyph into the bitmap */
 390     bitmap     = decoder->bitmap;
 391     bit_width  = bitmap->width;
 392     bit_height = bitmap->rows;
 393     pitch      = bitmap->pitch;
 394     line       = bitmap->buffer;
 395
 396     width  = decoder->metrics->width;
 397     height = decoder->metrics->height;
 398
 399     if ( x_pos < 0 || x_pos + width > bit_width   ||
 400          y_pos < 0 || y_pos + height > bit_height )
 401     {
 402       error = SFNT_Err_Invalid_File_Format;
 403       goto Exit;
 404     }
 405
 406     if ( p + ( ( width + 7 ) >> 3 ) * height > limit )
 407     {
 408       error = SFNT_Err_Invalid_File_Format;
 409       goto Exit;
 410     }
 411
 412     /* now do the blit */
 413     line  += y_pos * pitch + ( x_pos >> 3 );
 414     x_pos &= 7;
 415
 416     if ( x_pos == 0 )  /* the easy one */
 417     {
 418       for ( h = height; h > 0; h--, line += pitch )
 419       {
 420         FT_Byte*  write = line;
 421         FT_Int    w;
 422
 423
 424         for ( w = width; w >= 8; w -= 8 )
 425         {
 426           write[0] = (FT_Byte)( write[0] | *p++ );
 427           write   += 1;
 428         }
 429
 430         if ( w > 0 )
 431           write[0] = (FT_Byte)( write[0] | ( *p++ & ( 0xFF00U >> w ) ) );
 432       }
 433     }
 434     else  /* x_pos > 0 */
 435     {
 436       for ( h = height; h > 0; h--, line += pitch )
 437       {
 438         FT_Byte*  write = line;
 439         FT_Int    w;
 440         FT_UInt   wval = 0;
 441
 442
 443         for ( w = width; w >= 8; w -= 8 )
 444         {
 445           wval      = (FT_UInt)( wval | *p++ );
 446           write[0]  = (FT_Byte)( write[0] | ( wval >> x_pos ) );
 447           write    += 1;
 448           wval    <<= 8;
 449         }
 450
 451         if ( w > 0 )
 452           wval = (FT_UInt)( wval | ( *p++ & ( 0xFF00U >> w ) ) );
 453
 454         /* all bits read and there are `x_pos + w' bits to be written */
 455
 456         write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) );
 457
 458         if ( x_pos + w > 8 )
 459         {
 460           write++;
 461           wval   <<= 8;
 462           write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) );
 463         }
 464       }
 465     }
 466
 467   Exit:
 468     return error;
 469   }
 470
 471
 472   /*
 473    * Load a bit-aligned bitmap (with pointer `p') into a line-aligned bitmap
 474    * (with pointer `write').  In the example below, the width is 3 pixel,
 475    * and `x_pos' is 1 pixel.
 476    *
 477    *       p                               p+1
 478    *     |                               |                               |
 479    *     | 7   6   5   4   3   2   1   0 | 7   6   5   4   3   2   1   0 |...
 480    *     |                               |                               |
 481    *       +-------+   +-------+   +-------+ ...
 482    *           .           .           .
 483    *           .           .           .
 484    *           v           .           .
 485    *       +-------+       .           .
 486    * |                               | .
 487    * | 7   6   5   4   3   2   1   0 | .
 488    * |                               | .
 489    *   write               .           .
 490    *                       .           .
 491    *                       v           .
 492    *                   +-------+       .
 493    *             |                               |
 494    *             | 7   6   5   4   3   2   1   0 |
 495    *             |                               |
 496    *               write+1             .
 497    *                                   .
 498    *                                   v
 499    *                               +-------+
 500    *                         |                               |
 501    *                         | 7   6   5   4   3   2   1   0 |
 502    *                         |                               |
 503    *                           write+2
 504    *
 505    */
 506
 507   static FT_Error
 508   tt_sbit_decoder_load_bit_aligned( TT_SBitDecoder  decoder,
 509                                     FT_Byte*        p,
 510                                     FT_Byte*        limit,
 511                                     FT_Int          x_pos,
 512                                     FT_Int          y_pos )
 513   {
 514     FT_Error    error = SFNT_Err_Ok;
 515     FT_Byte*    line;
 516     FT_Int      bit_height, bit_width, pitch, width, height, h, nbits;
 517     FT_Bitmap*  bitmap;
 518     FT_UShort   rval;
 519
 520
 521     if ( !decoder->bitmap_allocated )
 522     {
 523       error = tt_sbit_decoder_alloc_bitmap( decoder );
 524       if ( error )
 525         goto Exit;
 526     }
 527
 528     /* check that we can write the glyph into the bitmap */
 529     bitmap     = decoder->bitmap;
 530     bit_width  = bitmap->width;
 531     bit_height = bitmap->rows;
 532     pitch      = bitmap->pitch;
 533     line       = bitmap->buffer;
 534
 535     width  = decoder->metrics->width;
 536     height = decoder->metrics->height;
 537
 538     if ( x_pos < 0 || x_pos + width  > bit_width  ||
 539          y_pos < 0 || y_pos + height > bit_height )
 540     {
 541       error = SFNT_Err_Invalid_File_Format;
 542       goto Exit;
 543     }
 544
 545     if ( p + ( ( width * height + 7 ) >> 3 ) > limit )
 546     {
 547       error = SFNT_Err_Invalid_File_Format;
 548       goto Exit;
 549     }
 550
 551     /* now do the blit */
 552
 553     /* adjust `line' to point to the first byte of the bitmap */
 554     line  += y_pos * pitch + ( x_pos >> 3 );
 555     x_pos &= 7;
 556
 557     /* the higher byte of `rval' is used as a buffer */
 558     rval  = 0;
 559     nbits = 0;
 560
 561     for ( h = height; h > 0; h--, line += pitch )
 562     {
 563       FT_Byte*  write = line;
 564       FT_Int    w     = width;
 565
 566
 567       /* handle initial byte (in target bitmap) specially if necessary */
 568       if ( x_pos )
 569       {
 570         w = ( width < 8 - x_pos ) ? width : 8 - x_pos;
 571
 572         if ( h == height )
 573         {
 574           rval  = *p++;
 575           nbits = x_pos;
 576         }
 577         else if ( nbits < w )
 578         {
 579           if ( p < limit )
 580             rval |= *p++;
 581           nbits += 8 - w;
 582         }
 583         else
 584         {
 585           rval  >>= 8;
 586           nbits  -= w;
 587         }
 588
 589         *write++ |= ( ( rval >> nbits ) & 0xFF ) &
 590                     ( ~( 0xFF << w ) << ( 8 - w - x_pos ) );
 591         rval    <<= 8;
 592
 593         w = width - w;
 594       }
 595
 596       /* handle medial bytes */
 597       for ( ; w >= 8; w -= 8 )
 598       {
 599         rval     |= *p++;
 600         *write++ |= ( rval >> nbits ) & 0xFF;
 601
 602         rval <<= 8;
 603       }
 604
 605       /* handle final byte if necessary */
 606       if ( w > 0 )
 607       {
 608         if ( nbits < w )
 609         {
 610           if ( p < limit )
 611             rval |= *p++;
 612           *write |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
 613           nbits  += 8 - w;
 614
 615           rval <<= 8;
 616         }
 617         else
 618         {
 619           *write |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
 620           nbits  -= w;
 621         }
 622       }
 623     }
 624
 625   Exit:
 626     return error;
 627   }
 628
 629
 630   static FT_Error
 631   tt_sbit_decoder_load_compound( TT_SBitDecoder  decoder,
 632                                  FT_Byte*        p,
 633                                  FT_Byte*        limit,
 634                                  FT_Int          x_pos,
 635                                  FT_Int          y_pos )
 636   {
 637     FT_Error  error = SFNT_Err_Ok;
 638     FT_UInt   num_components, nn;
 639
 640     FT_Char  horiBearingX = decoder->metrics->horiBearingX;
 641     FT_Char  horiBearingY = decoder->metrics->horiBearingY;
 642     FT_Byte  horiAdvance  = decoder->metrics->horiAdvance;
 643     FT_Char  vertBearingX = decoder->metrics->vertBearingX;
 644     FT_Char  vertBearingY = decoder->metrics->vertBearingY;
 645     FT_Byte  vertAdvance  = decoder->metrics->vertAdvance;
 646
 647
 648     if ( p + 2 > limit )
 649       goto Fail;
 650
 651     num_components = FT_NEXT_USHORT( p );
 652     if ( p + 4 * num_components > limit )
 653       goto Fail;
 654
 655     if ( !decoder->bitmap_allocated )
 656     {
 657       error = tt_sbit_decoder_alloc_bitmap( decoder );
 658       if ( error )
 659         goto Exit;
 660     }
 661
 662     for ( nn = 0; nn < num_components; nn++ )
 663     {
 664       FT_UInt  gindex = FT_NEXT_USHORT( p );
 665       FT_Byte  dx     = FT_NEXT_BYTE( p );
 666       FT_Byte  dy     = FT_NEXT_BYTE( p );
 667
 668
 669       /* NB: a recursive call */
 670       error = tt_sbit_decoder_load_image( decoder, gindex,
 671                                           x_pos + dx, y_pos + dy );
 672       if ( error )
 673         break;
 674     }
 675
 676     decoder->metrics->horiBearingX = horiBearingX;
 677     decoder->metrics->horiBearingY = horiBearingY;
 678     decoder->metrics->horiAdvance  = horiAdvance;
 679     decoder->metrics->vertBearingX = vertBearingX;
 680     decoder->metrics->vertBearingY = vertBearingY;
 681     decoder->metrics->vertAdvance  = vertAdvance;
 682     decoder->metrics->width        = (FT_UInt)decoder->bitmap->width;
 683     decoder->metrics->height       = (FT_UInt)decoder->bitmap->rows;
 684
 685   Exit:
 686     return error;
 687
 688   Fail:
 689     error = SFNT_Err_Invalid_File_Format;
 690     goto Exit;
 691   }
 692
 693
 694   static FT_Error
 695   tt_sbit_decoder_load_bitmap( TT_SBitDecoder  decoder,
 696                                FT_UInt         glyph_format,
 697                                FT_ULong        glyph_start,
 698                                FT_ULong        glyph_size,
 699                                FT_Int          x_pos,
 700                                FT_Int          y_pos )
 701   {
 702     FT_Error   error;
 703     FT_Stream  stream = decoder->stream;
 704     FT_Byte*   p;
 705     FT_Byte*   p_limit;
 706     FT_Byte*   data;
 707
 708
 709     /* seek into the EBDT table now */
 710     if ( glyph_start + glyph_size > decoder->ebdt_size )
 711     {
 712       error = SFNT_Err_Invalid_Argument;
 713       goto Exit;
 714     }
 715
 716     if ( FT_STREAM_SEEK( decoder->ebdt_start + glyph_start ) ||
 717          FT_FRAME_EXTRACT( glyph_size, data )                )
 718       goto Exit;
 719
 720     p       = data;
 721     p_limit = p + glyph_size;
 722
 723     /* read the data, depending on the glyph format */
 724     switch ( glyph_format )
 725     {
 726     case 1:
 727     case 2:
 728     case 8:
 729       error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 );
 730       break;
 731
 732     case 6:
 733     case 7:
 734     case 9:
 735       error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 );
 736       break;
 737
 738     default:
 739       error = SFNT_Err_Ok;
 740     }
 741
 742     if ( error )
 743       goto Fail;
 744
 745     {
 746       TT_SBitDecoder_LoadFunc  loader;
 747
 748
 749       switch ( glyph_format )
 750       {
 751       case 1:
 752       case 6:
 753         loader = tt_sbit_decoder_load_byte_aligned;
 754         break;
 755
 756       case 2:
 757       case 5:
 758       case 7:
 759         loader = tt_sbit_decoder_load_bit_aligned;
 760         break;
 761
 762       case 8:
 763         if ( p + 1 > p_limit )
 764           goto Fail;
 765
 766         p += 1;  /* skip padding */
 767         /* fall-through */
 768
 769       case 9:
 770         loader = tt_sbit_decoder_load_compound;
 771         break;
 772
 773       default:
 774         goto Fail;
 775       }
 776
 777       error = loader( decoder, p, p_limit, x_pos, y_pos );
 778     }
 779
 780   Fail:
 781     FT_FRAME_RELEASE( data );
 782
 783   Exit:
 784     return error;
 785   }
 786
 787
 788   static FT_Error
 789   tt_sbit_decoder_load_image( TT_SBitDecoder  decoder,
 790                               FT_UInt         glyph_index,
 791                               FT_Int          x_pos,
 792                               FT_Int          y_pos )
 793   {
 794     /*
 795      *  First, we find the correct strike range that applies to this
 796      *  glyph index.
 797      */
 798
 799     FT_Byte*  p          = decoder->eblc_base + decoder->strike_index_array;
 800     FT_Byte*  p_limit    = decoder->eblc_limit;
 801     FT_ULong  num_ranges = decoder->strike_index_count;
 802     FT_UInt   start, end, index_format, image_format;
 803     FT_ULong  image_start = 0, image_end = 0, image_offset;
 804
 805
 806     for ( ; num_ranges > 0; num_ranges-- )
 807     {
 808       start = FT_NEXT_USHORT( p );
 809       end   = FT_NEXT_USHORT( p );
 810
 811       if ( glyph_index >= start && glyph_index <= end )
 812         goto FoundRange;
 813
 814       p += 4;  /* ignore index offset */
 815     }
 816     goto NoBitmap;
 817
 818   FoundRange:
 819     image_offset = FT_NEXT_ULONG( p );
 820
 821     /* overflow check */
 822     if ( decoder->eblc_base + decoder->strike_index_array + image_offset <
 823            decoder->eblc_base )
 824       goto Failure;
 825
 826     p = decoder->eblc_base + decoder->strike_index_array + image_offset;
 827     if ( p + 8 > p_limit )
 828       goto NoBitmap;
 829
 830     /* now find the glyph's location and extend within the ebdt table */
 831     index_format = FT_NEXT_USHORT( p );
 832     image_format = FT_NEXT_USHORT( p );
 833     image_offset = FT_NEXT_ULONG ( p );
 834
 835     switch ( index_format )
 836     {
 837     case 1: /* 4-byte offsets relative to `image_offset' */
 838       {
 839         p += 4 * ( glyph_index - start );
 840         if ( p + 8 > p_limit )
 841           goto NoBitmap;
 842
 843         image_start = FT_NEXT_ULONG( p );
 844         image_end   = FT_NEXT_ULONG( p );
 845
 846         if ( image_start == image_end )  /* missing glyph */
 847           goto NoBitmap;
 848       }
 849       break;
 850
 851     case 2: /* big metrics, constant image size */
 852       {
 853         FT_ULong  image_size;
 854
 855
 856         if ( p + 12 > p_limit )
 857           goto NoBitmap;
 858
 859         image_size = FT_NEXT_ULONG( p );
 860
 861         if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
 862           goto NoBitmap;
 863
 864         image_start = image_size * ( glyph_index - start );
 865         image_end   = image_start + image_size;
 866       }
 867       break;
 868
 869     case 3: /* 2-byte offsets relative to 'image_offset' */
 870       {
 871         p += 2 * ( glyph_index - start );
 872         if ( p + 4 > p_limit )
 873           goto NoBitmap;
 874
 875         image_start = FT_NEXT_USHORT( p );
 876         image_end   = FT_NEXT_USHORT( p );
 877
 878         if ( image_start == image_end )  /* missing glyph */
 879           goto NoBitmap;
 880       }
 881       break;
 882
 883     case 4: /* sparse glyph array with (glyph,offset) pairs */
 884       {
 885         FT_ULong  mm, num_glyphs;
 886
 887
 888         if ( p + 4 > p_limit )
 889           goto NoBitmap;
 890
 891         num_glyphs = FT_NEXT_ULONG( p );
 892
 893         /* overflow check */
 894         if ( p + ( num_glyphs + 1 ) * 4 < p )
 895           goto Failure;
 896
 897         if ( p + ( num_glyphs + 1 ) * 4 > p_limit )
 898           goto NoBitmap;
 899
 900         for ( mm = 0; mm < num_glyphs; mm++ )
 901         {
 902           FT_UInt  gindex = FT_NEXT_USHORT( p );
 903
 904
 905           if ( gindex == glyph_index )
 906           {
 907             image_start = FT_NEXT_USHORT( p );
 908             p          += 2;
 909             image_end   = FT_PEEK_USHORT( p );
 910             break;
 911           }
 912           p += 2;
 913         }
 914
 915         if ( mm >= num_glyphs )
 916           goto NoBitmap;
 917       }
 918       break;
 919
 920     case 5: /* constant metrics with sparse glyph codes */
 921       {
 922         FT_ULong  image_size, mm, num_glyphs;
 923
 924
 925         if ( p + 16 > p_limit )
 926           goto NoBitmap;
 927
 928         image_size = FT_NEXT_ULONG( p );
 929
 930         if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
 931           goto NoBitmap;
 932
 933         num_glyphs = FT_NEXT_ULONG( p );
 934
 935         /* overflow check */
 936         if ( p + 2 * num_glyphs < p )
 937           goto Failure;
 938
 939         if ( p + 2 * num_glyphs > p_limit )
 940           goto NoBitmap;
 941
 942         for ( mm = 0; mm < num_glyphs; mm++ )
 943         {
 944           FT_UInt  gindex = FT_NEXT_USHORT( p );
 945
 946
 947           if ( gindex == glyph_index )
 948             break;
 949         }
 950
 951         if ( mm >= num_glyphs )
 952           goto NoBitmap;
 953
 954         image_start = image_size * mm;
 955         image_end   = image_start + image_size;
 956       }
 957       break;
 958
 959     default:
 960       goto NoBitmap;
 961     }
 962
 963     if ( image_start > image_end )
 964       goto NoBitmap;
 965
 966     image_end  -= image_start;
 967     image_start = image_offset + image_start;
 968
 969     return tt_sbit_decoder_load_bitmap( decoder,
 970                                         image_format,
 971                                         image_start,
 972                                         image_end,
 973                                         x_pos,
 974                                         y_pos );
 975
 976   Failure:
 977     return SFNT_Err_Invalid_Table;
 978
 979   NoBitmap:
 980     return SFNT_Err_Invalid_Argument;
 981   }
 982
 983
 984   FT_LOCAL( FT_Error )
 985   tt_face_load_sbit_image( TT_Face              face,
 986                            FT_ULong             strike_index,
 987                            FT_UInt              glyph_index,
 988                            FT_UInt              load_flags,
 989                            FT_Stream            stream,
 990                            FT_Bitmap           *map,
 991                            TT_SBit_MetricsRec  *metrics )
 992   {
 993     TT_SBitDecoderRec  decoder[1];
 994     FT_Error           error;
 995
 996     FT_UNUSED( load_flags );
 997     FT_UNUSED( stream );
 998     FT_UNUSED( map );
 999
1000
1001     error = tt_sbit_decoder_init( decoder, face, strike_index, metrics );
1002     if ( !error )
1003     {
1004       error = tt_sbit_decoder_load_image( decoder, glyph_index, 0, 0 );
1005       tt_sbit_decoder_done( decoder );
1006     }
1007
1008     return error;
1009   }
1010
1011 /* EOF */