case 8:    case 9:      {        /* Now, load composite sbit glyphs */        /* This code is not sophisticated */        TT_SBit_Component*  component_array;        UShort              num_components;        Int i = 0;        if ( ACCESS_Frame( 2L ) )          return error;        num_components = GET_UShort();        FORGET_Frame();        MEM_Alloc( component_array,                   sizeof ( TT_SBit_Component ) * num_components );        if ( ACCESS_Frame( 4L * num_components ) )          return error;        for ( i = 0; i < num_components; i++ )        {          component_array[i].glyph_code = GET_UShort();          component_array[i].x_offset   = GET_Char();          component_array[i].y_offset   = GET_Char();        }        FORGET_Frame();        component_depth++;        for ( i = 0; i < num_components; i++ )        {          error = Load_SBit_Image( strike, component_array[i].glyph_code,                                   component_array[i].x_offset,                                   component_array[i].y_offset,                                   ebdt_offset,                                   image,                                   component_depth, face );          if ( error )            return error;        }        FREE( component_array );        break;      default:        return TT_Err_Invalid_File_Format;      }    }    return TT_Err_Ok;  }/******************************************************************* * *  Function:  Load_TrueType_Ebdt * ******************************************************************/  static TT_Error  Load_TrueType_Ebdt( PFace           face,                      TT_SBit_Strike  strike,                      ULong           glyph_index,                      TT_SBit_Image*  image )  {    DEFINE_LOCALS;    ULong   ebdt_offset;    ULong   version;    Long    i;    /* Try to find the `EBDT' or `bdat' table in the font files. */    /* Both tags describe the same table, `EBDT' is for OpenType */    /* fonts, while `bdat' is for TrueType GX fonts.  Many fonts */    /* contain both tags pointing to the same table              */    i = TT_LookUp_Table( face, TTAG_EBDT );    if ( i < 0 )      i = TT_LookUp_Table( face, TTAG_bdat );    if ( i < 0 )      return TT_Err_Table_Missing;    ebdt_offset = face->dirTables[i].Offset;    if ( FILE_Seek( ebdt_offset ) ||         ACCESS_Frame( 4L )       )  /* read into frame */      return error;    version  = GET_ULong();    FORGET_Frame();    PTRACE2(( "-- Format version : %08lx\n", version ));    if ( version != 0x00020000 )    {      PERROR(( "Invalid file format!\n" ));      return TT_Err_Invalid_File_Format;    } /* This doesn't compile, I simply commented it out ?? - David */ /*    PTRACE4(( "-- Format: %d\n", range->image_format ));    */    error = Load_SBit_Image( strike,                             glyph_index,                             0, 0,                             ebdt_offset,                             image,                             0, face );    if ( error )      return error;    return TT_Err_Ok;  }  static TT_Error  EBLC_Create( void*  ext,                                PFace  face )  {    TT_EBLC*  eblc = (TT_EBLC*)ext;    /* by convention */    if ( !eblc )      return TT_Err_Ok;    return Load_TrueType_Eblc( face, eblc );  }  static TT_Error  EBLC_Destroy( void*  ext,                                 PFace  face )  {    TT_EBLC*  eblc = (TT_EBLC*)ext;    (void)face;    if ( eblc )      Free_TrueType_Eblc( eblc );    return TT_Err_Ok;  }  /*************************************************************/  /*                                                           */  /* <Function>                                                */  /*    TT_Init_SBit_Extension                                 */  /*                                                           */  /* <Description>                                             */  /*    Initialize the embedded bitmaps extension for the      */  /*    FreeType engine.                                       */  /*                                                           */  /* <Input>                                                   */  /*    engine :: handle to current FreeType library instance  */  /*                                                           */  /* <Return>                                                  */  /*    Error code. 0 means success.                           */  /*                                                           */  FT_EXPORT_FUNC( TT_Error )  TT_Init_SBit_Extension( TT_Engine  engine )  {    PEngine_Instance  _engine = HANDLE_Engine( engine );    TT_Error  error;    if ( !_engine )      return TT_Err_Invalid_Engine;    error = TT_Register_Extension( _engine,                                   SBIT_ID,                                   sizeof ( TT_EBLC ),                                   EBLC_Create,                                   EBLC_Destroy );    return error;  }  /*************************************************************/  /*                                                           */  /* <Function>                                                */  /*    TT_Get_Face_Bitmaps                                    */  /*                                                           */  /* <Description>                                             */  /*    Loads the `EBLC' table from a font file, if any.       */  /*                                                           */  /* <Input>                                                   */  /*    face :: handle to the source TrueType font/face        */  /*                                                           */  /* <Output>                                                  */  /*    eblc_table :: a descriptor for the EBLC table          */  /*                                                           */  /* <Return>                                                  */  /*    Error code.  0 means success.                          */  /*                                                           */  /* <Note>                                                    */  /*    This function returns TT_Err_Table_Missing if the      */  /*    font contains no embedded bitmaps.  All fields in      */  /*    `eblc_table' will then be set to 0.                    */  /*                                                           */  FT_EXPORT_FUNC( TT_Error )  TT_Get_Face_Bitmaps( TT_Face   face,                       TT_EBLC*  eblc_table )  {    PFace     faze = HANDLE_Face( face );    TT_EBLC*  eblc;    TT_Error  error;    error = TT_Extension_Get( faze, SBIT_ID, (void**)&eblc );    if ( !error )    {      if ( eblc->version )      {        *eblc_table = *eblc;        return TT_Err_Ok;      }      error = TT_Err_Table_Missing;    }    eblc_table->version     = 0;    eblc_table->num_strikes = 0;    eblc_table->strikes     = 0;    return error;  }/******************************************************************* * *  <Function> TT_Get_SBit_Strike * *  <Description> *     Loads suitable strike (bitmap sizetable) for given instance. *     This strike includes sbitLineMetrics. * *  <Input> *     face     :: the source face *     instance :: the current size instance * *  <Output> *     strike   :: the bitmap strike descriptor * *  <Return> *     TrueType error code.  0 means success. * ******************************************************************/  FT_EXPORT_FUNC( TT_Error )  TT_Get_SBit_Strike( TT_Face          face,                      TT_Instance      instance,                      TT_SBit_Strike*  strike )  {    TT_Error   error;    PFace      faze = HANDLE_Face( face );    PInstance  ins  = HANDLE_Instance( instance );    TT_EBLC*   eblc;    TT_Int     x_ppem, y_ppem;    if ( !strike || !ins || ins->owner != faze )      return TT_Err_Invalid_Argument;    error = TT_Extension_Get( faze, SBIT_ID, (void**)&eblc );    if ( error )      goto Exit;    /********************************************************************/    /*                                                                  */    /* Look for an sbit strike that matches the current x and y ppms    */    /*                                                                  */    {      UShort           count = eblc->num_strikes;      TT_SBit_Strike*  cur   = eblc->strikes;      x_ppem = ins->metrics.x_ppem;      y_ppem = ins->metrics.y_ppem;      MEM_Set( strike, 0, sizeof ( TT_SBit_Strike ) );      for ( ; count > 0; count--, cur++ )        if ( cur->x_ppem == x_ppem &&             cur->y_ppem == y_ppem )        {          *strike = *cur;          break;        }      /* return immediately if we didn't find an appropriate strike */      if ( !strike->num_ranges )        error = TT_Err_Invalid_PPem;    }  Exit:    return error;  }  /*************************************************************/  /*                                                           */  /* <Function>                                                */  /*    TT_Load_Glyph_Bitmap                                   */  /*                                                           */  /* <Description>                                             */  /*    Loads a given glyph embedded bitmap.                   */  /*                                                           */  /* <Input>                                                   */  /*    face        :: handle to the source TrueType font/face */  /*    instance    :: current size/transform instance         */  /*    glyph_index :: index of source glyph                   */  /*    bitmap      :: target embedded bitmap descriptor       */  /*                                                           */  /* <Return>                                                  */  /*    Error code.  0 means success.                          */  /*                                                           */  /* <Note>                                                    */  /*    This function returns an error if there is no          */  /*    embedded bitmap for the glyph at the given             */  /*    instance.                                              */  /*                                                           */  FT_EXPORT_FUNC( TT_Error )  TT_Load_Glyph_Bitmap( TT_Face         face,                        TT_Instance     instance,                        TT_UShort       glyph_index,                        TT_SBit_Image*  image )  {    TT_Stream  stream;    TT_Error   error;    PFace      faze = HANDLE_Face( face );    PInstance  ins  = HANDLE_Instance( instance );    TT_SBit_Strike  strike;    if ( ins->owner != faze )    {      error = TT_Err_Invalid_Argument;      goto Fail;    }    /********************************************************************/    /*                                                                  */    /* Look for an sbit strike that matches the current x and y ppms    */    /*                                                                  */    error = TT_Get_SBit_Strike( face, instance, &strike );    if ( error )      goto Fail;    /* return immediately if the glyph index isn't in the strike extent */    if ( glyph_index < strike.start_glyph ||         glyph_index > strike.end_glyph   )    {      error = TT_Err_Invalid_Glyph_Index;      goto Fail;    }    {      image->bit_depth = 1;      if ( !USE_Stream( faze->stream, stream ) )      {        error = Load_TrueType_Ebdt( faze, strike, glyph_index, image );        DONE_Stream( stream );        /* exit successfully if we can */        if ( !error )        {          image->map.flow = TT_Flow_Down;          Crop_Bitmap( image );          /* correct sbit metrics */          {            TT_Big_Glyph_Metrics*  metrics = &image->metrics;            metrics->bbox.xMin *= 64;            metrics->bbox.xMax *= 64;            metrics->bbox.yMax *= 64;            metrics->bbox.yMin *= 64;            metrics->horiBearingX *= 64;            metrics->horiBearingY *= 64;            metrics->horiAdvance  *= 64;            metrics->vertBearingX *= 64;            metrics->vertBearingY *= 64;            metrics->vertAdvance  *= 64;          }          goto Exit;        }      }    }  Fail:    image->map.width  = 0;    image->map.rows   = 0;    image->map.cols   = 0;    image->map.size   = 0;    image->map.bitmap = 0;    image->map.flow   = 0;    image->bit_depth  = 0;  Exit:    return error;  }  /*************************************************************/  /*                                                           */  /* <Function>                                                */  /*    TT_New_SBit_Image                                      */  /*                                                           */  /* <Description>                                             */  /*    Allocates a new embedded bitmap container.             */  /*                                                           */  /* <Output>                                                  */  /*    image :: sbit image                                    */  /*                                                           */  /* <Return>                                                  */  /*    Error code.  0 means success.                          */  /*                                                           */  FT_EXPORT_FUNC( TT_Error )  TT_New_SBit_Image( TT_SBit_Image**  image )  {    return MEM_Alloc( *image, sizeof ( **image ) );  }  /*************************************************************/  /*                                                           */  /* <Function>                                                */  /*    TT_Done_SBit_Image                                     */  /*                                                           */  /* <Description>                                             */  /*    Releases an embedded bitmap container.                 */  /*                                                           */  /* <Input>                                                   */  /*    image :: sbit image                                    */  /*                                                           */  FT_EXPORT_FUNC( void )  TT_Done_SBit_Image( TT_SBit_Image*  image )  {    FREE( image->map.bitmap );    FREE( image );  }/* END */