Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

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