freetype/src/sfnt/ttsbit0.c

/***************************************************************************/
/*                                                                         */
/*  ttsbit.c                                                               */
/*                                                                         */
/*    TrueType and OpenType embedded bitmap support (body).                */
/*                                                                         */
/*  Copyright 1996-2001, 2002, 2003, 2004 by                               */
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
/*                                                                         */
/*  This file is part of the FreeType project, and may only be used,       */
/*  modified, and distributed under the terms of the FreeType project      */
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
/*  this file you indicate that you have read the license and              */
/*  understand and accept it fully.                                        */
/*                                                                         */
/***************************************************************************/


#include <ft2build.h>
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_STREAM_H
#include FT_TRUETYPE_TAGS_H
#include "ttsbit.h"

#include "sferrors.h"


  /*************************************************************************/
  /*                                                                       */
  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  /* messages during execution.                                            */
  /*                                                                       */
#undef  FT_COMPONENT
#define FT_COMPONENT  trace_ttsbit


    static const FT_Frame_Field  tt_sbit_line_metrics_fields[] =
    {
#undef  FT_STRUCTURE
#define FT_STRUCTURE  TT_SBit_LineMetricsRec

      /* no FT_FRAME_START */
        FT_FRAME_CHAR( ascender ),
        FT_FRAME_CHAR( descender ),
        FT_FRAME_BYTE( max_width ),

        FT_FRAME_CHAR( caret_slope_numerator ),
        FT_FRAME_CHAR( caret_slope_denominator ),
        FT_FRAME_CHAR( caret_offset ),

        FT_FRAME_CHAR( min_origin_SB ),
        FT_FRAME_CHAR( min_advance_SB ),
        FT_FRAME_CHAR( max_before_BL ),
        FT_FRAME_CHAR( min_after_BL ),
        FT_FRAME_CHAR( pads[0] ),
        FT_FRAME_CHAR( pads[1] ),
      FT_FRAME_END
    };

    static const FT_Frame_Field  tt_strike_start_fields[] =
    {
#undef  FT_STRUCTURE
#define FT_STRUCTURE  TT_SBit_StrikeRec

      /* no FT_FRAME_START */
        FT_FRAME_ULONG( ranges_offset ),
        FT_FRAME_SKIP_LONG,
        FT_FRAME_ULONG( num_ranges ),
        FT_FRAME_ULONG( color_ref ),
      FT_FRAME_END
    };

    static const FT_Frame_Field  tt_strike_end_fields[] =
    {
      /* no FT_FRAME_START */
        FT_FRAME_USHORT( start_glyph ),
        FT_FRAME_USHORT( end_glyph ),
        FT_FRAME_BYTE  ( x_ppem ),
        FT_FRAME_BYTE  ( y_ppem ),
        FT_FRAME_BYTE  ( bit_depth ),
        FT_FRAME_CHAR  ( flags ),
      FT_FRAME_END
    };



  FT_LOCAL_DEF( FT_Error )
  tt_face_load_sbit_strikes( TT_Face    face,
                             FT_Stream  stream )
  {
    FT_Error   error  = 0;
    FT_Memory  memory = stream->memory;
    FT_Fixed   version;
    FT_ULong   num_strikes, table_size;
    FT_ULong   table_base;
    FT_Byte*   p;
    FT_Byte*   p_limit;
    FT_UInt    nn, count;

    face->sbit_num_strikes = 0;

    /* this table is optional */
    error = face->goto_table( face, TTAG_EBLC, stream, &table_size );
    if ( error )
      error = face->goto_table( face, TTAG_bloc, stream, &table_size );
    if ( error )
      goto Exit;

    if ( table_size < 8 )
    {
      FT_ERROR(( "%s: table too short !\n", "tt_face_load_sbit_strikes" ));
      error = SFNT_Err_Invalid_File_Format;
      goto Exit;
    }

    if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) )
      goto Exit;

    face->sbit_table_size = table_size;

    p       = face->sbit_table;
    p_limit = p + table_size;

    version     = FT_NEXT_ULONG(p);
    num_strikes = FT_NEXT_ULONG(p);

    if ( version != 0x00020000 || num_strikes >= 0x10000UL )
    {
      FT_ERROR(( "%s: invalid table version !\n", "tt_face_load_sbit_strikes" ));
      error = SFNT_Err_Invalid_File_Format;
      goto Fail;
    }

   /* count the number of strikes available in the table. we're a bit
    * paranoid there and don't trust the data.
    */
    count = (FT_UInt)num_strikes;
    if ( 8+48UL*count > table_size )
      count = (FT_UInt)( (p_limit - p)/48 );

    face->sbit_num_strikes = count;

   /* now allocate the root array of F_Bitmap_Size records,
    * populate them, and that's all there is to it. Unfortunately,
    * it's not possible to indicate bit depths in the FT_Bitmap_Size
    * record. What were we thinking ?
    */
    {
      FT_Memory  memory  = face->root.stream->memory;
      FT_UInt    em_size = (FT_UInt) face->header.Units_Per_EM;
      FT_Short   height  = (FT_Short)( face->horizontal.Ascender -
                                       face->horizontal.Descender +
                                       face->horizontal.Line_Gap );

      FT_Short   avgwidth = face->os2.xAvgCharWidth;

      if ( FT_NEW_ARRAY( face->root.available_sizes, count ) )
        goto Fail;

      for ( nn = 0; nn < count; nn++ )
      {
        FT_Bitmap_Size*  bsize = face->root.available_sizes + nn;
        FT_UInt          x_ppem, y_ppem;

        x_ppem = p[44];
        y_ppem = p[45];

        bsize->x_ppem = (FT_Pos)(x_ppem << 6);
        bsize->y_ppem = (FT_Pos)(y_ppem << 6);

        bsize->height = (FT_Short)( height*y_ppem   + em_size/2 ) / em_size;
        bsize->width  = (FT_Short)( avgwidth*y_ppem + em_size/2 ) / em_size;
        bsize->size   = bsize->y_ppem;

        p += 48;
      }

      face->root.face_flags     |= FT_FACE_FLAG_FIXED_SIZES;
      face->root.num_fixed_sizes = count;

    }

  Exit:
    return error;

  Fail:
    FT_FRAME_RELEASE( face->sbit_table );
    face->sbit_table_size = 0;
    goto Exit;
  }


  FT_LOCAL_DEF( void )
  tt_face_free_sbit_strikes( TT_Face  face )
  {
    FT_Stream  stream = face->root.stream;

    FT_FRAME_RELEASE( face->sbit_table );
    face->sbit_table_size  = 0;
    face->sbit_num_strikes = 0;
  }


  FT_LOCAL_DEF( FT_Error )
  tt_face_set_sbit_strike( TT_Face    face,
                           FT_UInt    x_ppem,
                           FT_UInt    y_ppem,
                           FT_ULong  *astrike_index )
  {
    FT_UInt   nn, count;
    FT_Byte*  p;
    FT_Byte*  p_limit;

    if ( x_ppem > 255 ||
         y_ppem < 1 || y_ppem > 255 )
      return SFNT_Err_Invalid_PPem;

    p       = face->sbit_table + 8;
    p_limit = p + face->sbit_table_size;
    count   = face->sbit_num_strikes;
    for ( nn = 0; nn < count; nn++ )
    {
      if ( x_ppem == (FT_UInt)p[44] && y_ppem == (FT_UInt)p[45] )
      {
        *astrike_index = (FT_ULong)nn;
        return SFNT_Err_Ok;
      }
      p += 48;
    }

    return SFNT_Err_Invalid_PPem;
  }



  typedef struct
  {
    TT_Face          face;
    FT_Stream        stream;
    FT_Bitmap*       bitmap;
    TT_SBit_Metrics  metrics;
    FT_Bool          metrics_loaded;
    FT_Bool          bitmap_allocated;
    FT_Byte          bit_depth;

    FT_ULong         ebdt_start;
    FT_ULong         ebdt_size;

    FT_ULong         strike_index_array;
    FT_ULong         strike_index_count;
    FT_Byte*         eblc_base;
    FT_Byte*         eblc_limit;

  } TT_SBitDecoderRec, *TT_SBitDecoder;


  static FT_Error
  tt_sbit_decoder_init( TT_SBitDecoder       decoder,
                        TT_Face              face,
                        FT_ULong             strike_index,
                        TT_SBit_MetricsRec*  metrics )
  {
    FT_Error   error;
    FT_Stream  stream     = face->root.stream;
    FT_ULong   ebdt_size;

    error = face->goto_table( face, TTAG_EBDT, stream, &ebdt_size );
    if ( error )
      error = face->goto_table( face, TTAG_bdat, stream, &ebdt_size );
    if (error)
      goto Exit;

    decoder->face       = face;
    decoder->stream     = stream;
    decoder->bitmap     = &face->root.glyph->bitmap;
    decoder->metrics    = metrics;

    decoder->metrics_loaded   = 0;
    decoder->bitmap_allocated = 0;

    decoder->ebdt_start = FT_STREAM_POS();
    decoder->ebdt_size  = ebdt_size;

    decoder->eblc_base  = face->sbit_table;
    decoder->eblc_limit = face->sbit_table + face->sbit_table_size;

   /* now find the strike corresponding to the index
    */
    {
      FT_Byte*  p = decoder->eblc_base + 8 + 48*strike_index;

      decoder->strike_index_array = FT_NEXT_ULONG(p);
      p                          += 4;
      decoder->strike_index_count = FT_NEXT_ULONG(p);
      p                          += 34;
      decoder->bit_depth          = *p;
    }

  Exit:
    return error;
  }


  static void
  tt_sbit_decoder_done( TT_SBitDecoder  decoder )
  {
    FT_UNUSED(decoder);
  }



  static FT_Error
  tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder  decoder )
  {
    FT_Error    error = 0;
    FT_UInt     width, height;
    FT_Bitmap*  map = decoder->bitmap;
    FT_Long     size;

    if ( !decoder->metrics_loaded )
    {
      error = FT_Err_Invalid_Argument;
      goto Exit;
    }

    width  = decoder->metrics->width;
    height = decoder->metrics->height;

    map->width = (int) width;
    map->rows  = (int) height;

    switch ( decoder->bit_depth )
    {
    case 1:
        map->pixel_mode = FT_PIXEL_MODE_MONO;
        map->pitch      = ( map->width + 7 ) >> 3;
        break;

    case 2:
        map->pixel_mode = FT_PIXEL_MODE_GRAY2;
        map->pitch      = ( map->width + 3 ) >> 2;
        break;

    case 4:
        map->pixel_mode = FT_PIXEL_MODE_GRAY4;
        map->pitch      = ( map->width + 1 ) >> 1;
        break;

    case 8:
        map->pixel_mode = FT_PIXEL_MODE_GRAY;
        map->pitch      = map->width;
        break;

    default:
      error = SFNT_Err_Invalid_File_Format;
      goto Exit;
    }

    size = map->rows * map->pitch;

    /* check that there is no empty image */
    if ( size == 0 )
      goto Exit;     /* exit successfully! */

    error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size );
    if (error)
      goto Exit;

    decoder->bitmap_allocated = 1;

  Exit:
    return error;
  }


  static FT_Error
  tt_sbit_decoder_load_metrics( TT_SBitDecoder  decoder,
                                FT_Byte*       *pp,
                                FT_Byte*        limit,
                                FT_Bool         big )
  {
    FT_Byte*         p       = *pp;
    TT_SBit_Metrics  metrics = decoder->metrics;

    if ( p+5 > limit )
      goto Fail;

    if ( !decoder->metrics_loaded )
    {
      metrics->height       = p[0];
      metrics->width        = p[1];
      metrics->horiBearingX = (FT_Char) p[2];
      metrics->horiBearingY = (FT_Char) p[3];
      metrics->horiAdvance  = p[4];
    }

    p += 5;
    if ( big )
    {
      if ( p+3 > limit )
        goto Fail;

      if ( !decoder->metrics_loaded )
      {
        metrics->vertBearingX = (FT_Char) p[0];
        metrics->vertBearingY = (FT_Char) p[1];
        metrics->vertAdvance  = p[2];
      }

      p += 3;
    }

    decoder->metrics_loaded = 1;
    *pp = p;
    return 0;

  Fail:
    return FT_Err_Invalid_Argument;
  }





 /* forward declaration */
  static FT_Error
  tt_sbit_decoder_load_image( TT_SBitDecoder  decoder,
                              FT_UInt         glyph_index,
                              FT_Int          x_pos,
                              FT_Int          y_pos );

  typedef FT_Error  (*TT_SBitDecoder_LoadFunc)( TT_SBitDecoder  decoder,
                                                FT_Byte*        p,
                                                FT_Byte*        plimit,
                                                FT_Int          x_pos,
                                                FT_Int          y_pos );




  static FT_Error
  tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder  decoder,
                                     FT_Byte*        p,
                                     FT_Byte*        limit,
                                     FT_Int          x_pos,
                                     FT_Int          y_pos )
  {
    FT_Error    error = 0;
    FT_Byte*    line;
    FT_Int      bit_height, bit_width, pitch, width, height, h;
    FT_Bitmap*  bitmap;
    FT_UInt     rval;

    if ( !decoder->bitmap_allocated )
    {
      error = tt_sbit_decoder_alloc_bitmap( decoder );
      if (error)
        goto Exit;
    }

   /* check that we can write the glyph into the bitmap
    */
    bitmap     = decoder->bitmap;
    bit_width  = bitmap->width;
    bit_height = bitmap->rows;
    pitch      = bitmap->pitch;

    width  = decoder->metrics->width;
    height = decoder->metrics->height;

    if ( x_pos < 0 || x_pos+width > bit_width   ||
         y_pos < 0 || y_pos+height > bit_height )
    {
      error = FT_Err_Invalid_File_Format;
      goto Exit;
    }

    if ( p+((width+7)>>3)*height > limit )
    {
      error = FT_Err_Invalid_File_Format;
      goto Exit;
    }

   /* now do the blit
    */
    line  += y_pos*pitch + (x_pos >> 3);
    x_pos &= 7;

    if ( x_pos == 0 )  /* the easy one */
    {
      for ( h = height; h > 0; h--, line += pitch )
      {
        FT_Byte*  write = line;
        FT_Int    w;

        for ( w = width; w >= 8; w -= 8 )
        {
          write[0] = (FT_Byte)(write[0] | *p++);
          write   += 1;
        }

        if ( w > 0 )
          write[0] = (FT_Byte)(write[0] | (*p++ & (0xFF00 >> w)));
      }
    }
    else  /* x_pos > 0 */
    {
      for ( h = height; h > 0; h--, line += pitch )
      {
        FT_Byte*  write = line;
        FT_Int    w;
        FT_UInt   wval = 0;

        for ( w = width; w >= 8; w -= 8 )
        {
          wval      = (FT_UInt)(wval | *p++);
          write[0]  = (FT_Byte)(write[0] | (wval >> x_pos));
          write    += 1;
          wval    <<= 8;
        }

        if ( w > 0 )
          wval = (FT_UInt)(wval | (*p++ & (0xFF00 >> w)));

        write[0] = (FT_Byte)(write[0] | (wval >> x_pos));
      }
    }

  Exit:
    return error;
  }


  static FT_Error
  tt_sbit_decoder_load_bit_aligned ( TT_SBitDecoder  decoder,
                                     FT_Byte*        p,
                                     FT_Byte*        limit,
                                     FT_Int          x_pos,
                                     FT_Int          y_pos )
  {
    FT_Error    error = 0;
    FT_Byte*    line;
    FT_Int      bit_height, bit_width, pitch, width, height, h;
    FT_Bitmap*  bitmap;
    FT_UInt32   rval;

    if ( !decoder->bitmap_allocated )
    {
      error = tt_sbit_decoder_alloc_bitmap( decoder );
      if (error)
        goto Exit;
    }

   /* check that we can write the glyph into the bitmap
    */
    bitmap     = decoder->bitmap;
    bit_width  = bitmap->width;
    bit_height = bitmap->rows;
    pitch      = bitmap->pitch;

    width  = decoder->metrics->width;
    height = decoder->metrics->height;

    if ( x_pos < 0 || x_pos+width  > bit_width  ||
         y_pos < 0 || y_pos+height > bit_height )
    {
      error = FT_Err_Invalid_File_Format;
      goto Exit;
    }

    if ( p+((width+7)>>3)*height > limit )
    {
      error = FT_Err_Invalid_File_Format;
      goto Exit;
    }

   /* now do the blit
    */
    line  += y_pos*pitch + (x_pos >> 3);
    x_pos &= 7;
    rval   = 0x10000;

    for ( h = height; h > 0; h--, line += pitch )
    {
      FT_Byte*   write = line;
      FT_UInt32  wval  = 0x100 << x_pos;
      FT_Int     w;

      for ( w = width; w >= 8; w -= 8 )
      {
        if ( rval & 0x10000 )
          rval = 0x100 | *p++;

        wval |= (rval & 0x80);

        wval <<= 1;
        rval <<= 1;

        if ( wval & 0x10000 )
        {
          write[0] = (FT_Byte)(write[0] | (wval >> 8));
          write   += 1;
          wval     = 0x100;
        }
      }

      if ( wval != 0x100 )
      {
        while ( wval > 0x1FF )
          wval >>= 1;

        write[0] = (FT_Byte)(write[0] | wval);
      }
    }

  Exit:
    return error;
  }


  static FT_Error
  tt_sbit_decoder_load_compound( TT_SBitDecoder  decoder,
                                 FT_Byte*        p,
                                 FT_Byte*        limit,
                                 FT_Int          x_pos,
                                 FT_Int          y_pos )
  {
    FT_Error  error;
    FT_UInt   num_components, nn;


    if ( p+2 > limit )
      goto Fail;

    num_components = FT_NEXT_USHORT(p);
    if ( p+4*num_components > limit )
      goto Fail;

    for ( nn = 0; nn < num_components; nn++ )
    {
      FT_UInt   gindex = FT_NEXT_USHORT(p);
      FT_Byte   dx     = FT_NEXT_BYTE(p);
      FT_Byte   dy     = FT_NEXT_BYTE(p);

      /* NB: a recursive call */
      error = tt_sbit_decoder_load_image( decoder, gindex, x_pos+dx, y_pos+dy );
      if ( error )
        break;
    }

  Exit:
    return error;

  Fail:
    error = FT_Err_Invalid_File_Format;
    goto Exit;
  }


  static FT_Error
  tt_sbit_decoder_load_bitmap( TT_SBitDecoder  decoder,
                               FT_UInt         glyph_format,
                               FT_ULong        glyph_start,
                               FT_ULong        glyph_size,
                               FT_Int          x_pos,
                               FT_Int          y_pos )
  {
    FT_Error   error;
    FT_Stream  stream = decoder->stream;
    FT_Byte*   p;
    FT_Byte*   p_limit;
    FT_Byte*   data;

   /* seek into the EBDT table now
    */
    if ( glyph_start + glyph_size > decoder->ebdt_size )
    {
      error = FT_Err_Invalid_Argument;
      goto Exit;
    }

    if ( FT_STREAM_SEEK( decoder->ebdt_start + glyph_start ) ||
         FT_FRAME_EXTRACT( glyph_size, data )                 )
      goto Exit;

    p       = data;
    p_limit = p + glyph_size;

   /* read the data, depending on the glyph format
    */
    switch ( glyph_format )
    {
    case 1: case 2: case 8:
      error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 );
      break;

    case 6: case 7: case 9:
      error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 );
      break;

    default:
      error = 0;
    }

    if ( error )
      goto Fail;

    {
      TT_SBitDecoder_LoadFunc  loader;

      switch ( glyph_format )
      {
      case 1: case 6:
          loader = tt_sbit_decoder_load_byte_aligned;
          break;

      case 2: case 5: case 7:
          loader = tt_sbit_decoder_load_bit_aligned;
          break;

      case 8:
          if ( p+1 > p_limit )
            goto Fail;

          p += 1;  /* skip padding */
          /* fall-through */

      case 9:
          loader = tt_sbit_decoder_load_compound;
          break;

      default:
          goto Fail;
      }

      error = loader( decoder, p, p_limit, x_pos, y_pos );
    }

  Fail:
    FT_FRAME_RELEASE( data );

  Exit:
    return error;
  }


  static FT_Error
  tt_sbit_decoder_load_image( TT_SBitDecoder  decoder,
                              FT_UInt         glyph_index,
                              FT_Int          x_pos,
                              FT_Int          y_pos )
  {
   /* first, we find the correct strike range that applies to this
    * glyph index.
    */
    FT_Byte*  p          = decoder->eblc_base + decoder->strike_index_array;
    FT_Byte*  p_limit    = decoder->eblc_limit;
    FT_ULong  num_ranges = decoder->strike_index_count;
    FT_UInt   start, end, offset, index_format, image_format;
    FT_ULong  image_start, image_end, image_offset;

    if ( p+8*num_ranges > p_limit )
      goto NoBitmap;

    for ( ; num_ranges > 0; num_ranges-- )
    {
      start = FT_NEXT_USHORT(p);
      end   = FT_NEXT_USHORT(p);

      if ( glyph_index >= start && glyph_index <= end )
        goto FoundRange;

      p += 4;  /* ignore index offset */
    }
    goto NoBitmap;

  FoundRange:
    p = decoder->eblc_base + decoder->strike_index_array + FT_NEXT_ULONG(p);
    if ( p+8 > p_limit )
      goto NoBitmap;

   /* now, we're going to find the glyph's location and extend within
    * the ebdt table
    */
    index_format = FT_NEXT_USHORT(p);
    image_format = FT_NEXT_USHORT(p);
    image_offset = FT_NEXT_ULONG(p);

    switch ( index_format )
    {
    case 1: /* 4-byte offsets relative to 'image_offset' */
        {
          p += 4*(glyph_index-start);
          if ( p+8 > p_limit )
            goto NoBitmap;

          image_start = FT_NEXT_ULONG(p);
          image_end   = FT_NEXT_ULONG(p);

          if ( image_start == image_end )  /* missing glyph */
            goto NoBitmap;
        }
        break;

    case 2: /* big metrics, constant image size */
        {
          FT_ULong  image_size;

          if ( p+12 > p_limit )
            goto NoBitmap;

          image_size = FT_NEXT_ULONG(p);

          if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
            goto NoBitmap;

          image_start = image_offset + image_size*(glyph_index-start);
          image_end   = image_start  + image_size;
        }
        break;

    case 3: /* 2-byte offsets relative to 'image_offset' */
        {
          p += 2*(glyph_index-start);
          if ( p+4 > p_limit )
            goto NoBitmap;

          image_start = FT_NEXT_USHORT(p);
          image_end   = FT_NEXT_USHORT(p);

          if ( image_start == image_end )  /* missing glyph */
            goto NoBitmap;
        }
        break;

    case 4: /* sparse glyph array with (glyph,offset) pairs */
        {
          FT_ULong  mm, num_glyphs;

          if ( p+4 > p_limit )
            goto NoBitmap;

          num_glyphs = FT_NEXT_ULONG(p);
          if ( p+(num_glyphs+1)*4 > p_limit )
            goto NoBitmap;

          for ( mm = 0; mm < num_glyphs; mm++ )
          {
            FT_UInt  gindex = FT_NEXT_USHORT(p);

            if ( gindex == glyph_index )
            {
              image_start = FT_NEXT_USHORT(p);
              p          += 2;
              image_end   = FT_PEEK_USHORT(p);
              break;
            }
            p += 2;
          }

          if ( mm >= num_glyphs )
            goto NoBitmap;
        }
        break;

    case 5: /* constant metrics with sparse glyph codes */
        {
          FT_ULong  image_size, mm, num_glyphs;

          if ( p+16 > p_limit )
            goto NoBitmap;

          image_size = FT_NEXT_ULONG(p);

          if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
            goto NoBitmap;

          num_glyphs = FT_NEXT_ULONG(p);
          if ( p + 2*num_glyphs > p_limit )
            goto NoBitmap;

          for ( mm = 0; mm < num_glyphs; mm++ )
          {
            FT_UInt  gindex = FT_NEXT_USHORT(p);

            if ( gindex == glyph_index )
              break;
          }

          if ( mm >= num_glyphs )
            goto NoBitmap;

          image_start = image_offset + image_size*mm;
          image_end   = image_start + image_size;
        }
        break;

    default:
        goto NoBitmap;
    }

    if ( image_start > image_end )
      goto NoBitmap;

    image_end  -= image_start;
    image_start = image_offset + image_start;


    return tt_sbit_decoder_load_bitmap( decoder,
                                        image_format,
                                        image_offset + image_start,
                                        image_end,
                                        x_pos,
                                        y_pos );
  NoBitmap:
    return FT_Err_Invalid_Argument;
  }




  FT_LOCAL( FT_Error )
  tt_face_load_sbit_image( TT_Face              face,
                           FT_ULong             strike_index,
                           FT_UInt              glyph_index,
                           FT_UInt              load_flags,
                           FT_Stream            stream,
                           FT_Bitmap           *map,
                           TT_SBit_MetricsRec  *metrics )
  {
    TT_SBitDecoderRec  decoder[1];
    FT_Error           error;

    error = tt_sbit_decoder_init( decoder, face, strike_index, metrics );
    if ( !error )
    {
      error = tt_sbit_decoder_load_image( decoder, glyph_index, 0, 0 );
      tt_sbit_decoder_done( decoder );
    }

    return error;
  }