PageRenderTime 72ms CodeModel.GetById 17ms app.highlight 48ms RepoModel.GetById 1ms app.codeStats 0ms

/src/freetype/src/sfnt/ttsbit0.c

https://bitbucket.org/cabalistic/ogredeps/
C | 1011 lines | 697 code | 224 blank | 90 comment | 97 complexity | 2b988fa453b76cc0a37a9da0b90feafb MD5 | raw file
   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 */