/******************************************************************* * *  ftxsbit.c * *    Embedded bitmap API extension * *  Copyright 1996-2001 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. * * *  This extension is used to load the embedded bitmaps present *  in certain TrueType files. * ******************************************************************/#include "ftxsbit.h"#include "ttobjs.h"#include "ttfile.h"#include "ttload.h"#include "ttmemory.h"#include "tttags.h"#include "ttextend.h"#include "ttdebug.h"#define SBIT_ID  Build_Extension_ID( 's', 'b', 'i', 't' )/* Required by the tracing mode */#undef  TT_COMPONENT#define TT_COMPONENT  trace_bitmap/* In all functions, the stream is taken from the 'face' object */#define DEFINE_LOCALS           DEFINE_LOAD_LOCALS( face->stream )#define DEFINE_LOCALS_WO_FRAME  DEFINE_LOAD_LOCALS_WO_FRAME( face->stream )/*************************** * * miscellaneous functions * ***************************//******************************************************************* * *  Function:  Load_BitmapData * *  Bit-aligned bitmap data -> Byte-aligned bitmap data when pad is 0 * ******************************************************************/  static TT_Error  Load_BitmapData( TT_SBit_Image*  image,                   Int             image_size,                   Byte            x_offset,                   Byte            y_offset,                   UShort          source_width,                   UShort          source_height,                   Bool            byte_padded,                   PFace           face )  {    DEFINE_LOCALS;    Int     count;   /* number of bits left in rows              */    Int     loaded;  /* number of bits loaded in the accumulator */    UShort  buff;    /* accumulator                              */    PByte   line;     /* target write cursor */    PByte   limit;    if ( ( y_offset + source_height > image->map.rows ) ||         ( x_offset + source_width > image->map.width ) )      return TT_Err_Invalid_Argument;    if ( ACCESS_Frame( image_size ) )      return error;    buff   = 0;    loaded = 0;    line   = (PByte)image->map.bitmap +               y_offset * image->map.cols;    limit  = (PByte)image->map.bitmap +               ( y_offset + source_height ) * image->map.cols;    for ( ; line < limit; line += image->map.cols )    {      PByte  ptr;      ptr   = line + x_offset / 8;      count = source_width;      /* We may assume that `loaded' is less than 8 */      buff  >>= x_offset % 8;      loaded += x_offset % 8;      /* first of all, read all consecutive bytes */      while ( count >= 8 )      {        if ( loaded < 8 )        {          buff   |= ((UShort)GET_Byte()) << (8 - loaded);          loaded += 8;        }        *ptr++ |= (Byte)(buff >> 8);        buff  <<= 8;        loaded -= 8;        count  -= 8;      }      /* now write remaining bits (i.e. end of line with count < 8) */      if ( count > 0 )      {        if ( loaded < count )        {          buff   |= ((UShort)GET_Byte()) << (8 - loaded);          loaded += 8;        }        *ptr   |= ((Byte)(buff >> 8)) & ~(0xFF >> count);        buff  <<= count;        loaded -= count;      }      if ( byte_padded )      {        buff   = 0;        loaded = 0;      }    }    FORGET_Frame();    return TT_Err_Ok;  }/******************************************************************* * *  Function:  Crop_Bitmap * ******************************************************************/  static void  Crop_Bitmap( TT_SBit_Image*  image )  {    /*******************************************************/    /* In the following situation, some bounding boxes of  */    /* embedded bitmaps are too large.  We need to crop it */    /* to a reasonable size.                               */    /*                                                     */    /*      ---------                                      */    /*      |       |                -----                 */    /*      |  ***  |                |***|                 */    /*      |   *   |    ----->      | * |                 */    /*      |   *   |                | * |                 */    /*      |   *   |                | * |                 */    /*      |   *   |                | * |                 */    /*      |  ***  |                |***|                 */    /*      ---------                -----                 */    /*                                                     */    /*******************************************************/    Int    rows, count;    Long   line_len;    PByte  line;    /********************************************************************/    /*                                                                  */    /* first of all, check the top-most lines of the bitmap and remove  */    /* them if they're empty.                                           */    /*                                                                  */    {      line     = (PByte)image->map.bitmap;      rows     = image->map.rows;      line_len = image->map.cols;      for ( count = 0; count < rows; count++ )      {        PByte  cur   = line;        PByte  limit = line + line_len;        for ( ; cur < limit; cur++ )          if ( cur[0] )            goto Found_Top;        /* the current line was empty -- skip to next one */        line = limit;      }    Found_Top:      /* check that we have at least one filled line */      if ( count >= rows )        goto Empty_Bitmap;      /* now, crop the empty upper lines */      if ( count > 0 )      {        line = (PByte)image->map.bitmap;        MEM_Move( line, line + count*line_len, (rows-count) * line_len );        image->metrics.bbox.yMax    -= count;        image->metrics.vertBearingY -= count;        image->metrics.horiBearingY -= count;        image->map.rows             -= count;        rows                        -= count;      }    }    /*******************************************************************/    /*                                                                 */    /* second, crop the lower lines                                    */    /*                                                                 */    {      line = (PByte)image->map.bitmap + (rows-1) * line_len;      for ( count = 0; count < rows; count++ )      {        PByte  cur   = line;        PByte  limit = line + line_len;        for ( ; cur < limit; cur++ )          if ( cur[0] )            goto Found_Bottom;        /* the current line was empty -- skip to previous one */        line -= line_len;      }    Found_Bottom:      if ( count > 0 )      {        image->metrics.bbox.yMin += count;        image->map.rows          -= count;        rows                     -= count;      }    }    /*******************************************************************/    /*                                                                 */    /* third, get rid of the space on the left side of the glyph       */    /*                                                                 */    do    {      PByte  limit;      line  = (PByte)image->map.bitmap;      limit = line + rows * line_len;      for ( ; line < limit; line += line_len )        if ( line[0] & 0x80 )          goto Found_Left;      /* shift the whole glyph one pixel to the left */      line  = (PByte)image->map.bitmap;      limit = line + rows * line_len;      for ( ; line < limit; line += line_len )      {        Int    n, width = image->map.width;        Byte   old;        PByte  cur = line;        old = cur[0] << 1;        for ( n = 8; n < width; n += 8 )        {          Byte  val;          val    = cur[1];          cur[0] = old | (val >> 7);          old    = val << 1;          cur++;        }        cur[0] = old;      }      image->map.width--;      image->metrics.horiBearingX++;      image->metrics.vertBearingX++;      image->metrics.bbox.xMin++;    } while ( image->map.width > 0 );  Found_Left:    /*********************************************************************/    /*                                                                   */    /* finally, crop the bitmap width to get rid of the space on the     */    /* right side of the glyph.                                          */    /*                                                                   */    do    {      Int    right = image->map.width-1;      PByte  limit;      Byte   mask;      line  = (PByte)image->map.bitmap + (right >> 3);      limit = line + rows*line_len;      mask  = 0x80 >> (right & 7);      for ( ; line < limit; line += line_len )        if ( line[0] & mask )          goto Found_Right;      /* crop the whole glyph on the right */      image->map.width--;      image->metrics.bbox.xMax--;    } while ( image->map.width > 0 );  Found_Right:    /* all right, the bitmap was cropped */    return;  Empty_Bitmap:    image->map.width = 0;    image->map.rows  = 0;    image->map.cols  = 0;    image->map.size  = 0;  }/************* * * Main body * *************/  static TT_Error  Load_Range_Codes( TT_SBit_Range*  range,                    PFace           face,                    Bool            load_offsets )  {    DEFINE_LOCALS;    ULong  count, n, size;    (void)face;    /* read glyph count */    if ( ACCESS_Frame( 4L ) )      goto Exit;    count = GET_ULong();    FORGET_Frame();    range->num_glyphs = count;    /* Allocate glyph offsets table if needed */    if ( load_offsets )    {      if ( ALLOC_ARRAY( range->glyph_offsets, count, ULong ) )        goto Exit;      size = count * 4L;    }    else      size = count * 2L;    /* Allocate glyph codes table and access frame */    if ( ALLOC_ARRAY ( range->glyph_codes, count, UShort ) ||         ACCESS_Frame( size )                              )      goto Exit;    for ( n = 0; n < count; n++ )    {      range->glyph_codes[n] = GET_UShort();      if ( load_offsets )        range->glyph_offsets[n] = (ULong)range->image_offset + GET_UShort();    }    FORGET_Frame();  Exit:    return error;  }  static TT_Error  Load_SBit_Range( TT_SBit_Strike*  strike,                   TT_SBit_Range*   range,                   PFace            face )  {    DEFINE_LOCALS;    UShort  format;    (void)face;    (void)strike;    format = range->index_format;    PTRACE6(( "Index Format: %d\n", format ));    switch( format )    {    case 1:   /* variable metrics with 4-byte offsets */    case 3:   /* variable metrics with 2-byte offsets */      {        UShort  num_glyphs, size_elem;        Bool    large = (format == 1);        ULong*  cur;        num_glyphs = range->last_glyph - range->first_glyph + 1;        PTRACE5(( "  num glyphs: %hu\n", num_glyphs ));        range->num_glyphs = num_glyphs;        num_glyphs++;  /* BEWARE */        size_elem = large ? 4 : 2;        if ( ALLOC_ARRAY( range->glyph_offsets, num_glyphs, ULong ) ||             ACCESS_Frame( num_glyphs * size_elem )                 )          return error;        cur = range->glyph_offsets;        while ( num_glyphs > 0 )        {          cur[0] = (TT_ULong)( range->image_offset +                               (large ? GET_ULong() : GET_UShort()) );          PTRACE7(( "  offset: %d\n", cur[0] ));          cur++;          num_glyphs--;        }        FORGET_Frame();      }      break;    case 2:   /* all glyphs have identical metrics */    case 4:    case 5:      {        error = 0;        if ( format != 4 )  /* read constant metrics, formats 2 and 5 */        {          TT_SBit_Metrics*  metrics;          if ( ACCESS_Frame( 12L ) )            return error;          range->image_size = GET_ULong();          metrics           = &range->metrics;          metrics->height = GET_Byte();