Index: src/sfnt/ttsbit.c |
diff --git a/src/sfnt/ttsbit.c b/src/sfnt/ttsbit.c |
index 283ba7ef7284464918506e45196906a5b46c94a6..cd3e5a4a004a5072ba6e1e4b053c5fe98b173a4a 100644 |
--- a/src/sfnt/ttsbit.c |
+++ b/src/sfnt/ttsbit.c |
@@ -4,10 +4,12 @@ |
/* */ |
/* TrueType and OpenType embedded bitmap support (body). */ |
/* */ |
-/* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, */ |
-/* 2010 by */ |
+/* Copyright 2005-2009, 2013 by */ |
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ |
/* */ |
+/* Copyright 2013 by Google, Inc. */ |
+/* Google Author(s): Behdad Esfahbod. */ |
+/* */ |
/* 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 */ |
@@ -16,29 +18,18 @@ |
/* */ |
/***************************************************************************/ |
-#include <ft2build.h> |
-#include FT_INTERNAL_DEBUG_H |
-#include FT_INTERNAL_STREAM_H |
-#include FT_TRUETYPE_TAGS_H |
- |
- /* |
- * Alas, the memory-optimized sbit loader can't be used when implementing |
- * the `old internals' hack |
- */ |
-#ifndef FT_CONFIG_OPTION_OLD_INTERNALS |
- |
-#include "ttsbit0.c" |
- |
-#else /* FT_CONFIG_OPTION_OLD_INTERNALS */ |
#include <ft2build.h> |
#include FT_INTERNAL_DEBUG_H |
#include FT_INTERNAL_STREAM_H |
#include FT_TRUETYPE_TAGS_H |
+#include FT_BITMAP_H |
#include "ttsbit.h" |
#include "sferrors.h" |
+#include "pngshim.h" |
+ |
/*************************************************************************/ |
/* */ |
@@ -50,1398 +41,1108 @@ |
#define FT_COMPONENT trace_ttsbit |
- /*************************************************************************/ |
- /* */ |
- /* <Function> */ |
- /* blit_sbit */ |
- /* */ |
- /* <Description> */ |
- /* Blits a bitmap from an input stream into a given target. Supports */ |
- /* x and y offsets as well as byte padded lines. */ |
- /* */ |
- /* <Input> */ |
- /* target :: The target bitmap/pixmap. */ |
- /* */ |
- /* source :: The input packed bitmap data. */ |
- /* */ |
- /* line_bits :: The number of bits per line. */ |
- /* */ |
- /* byte_padded :: A flag which is true if lines are byte-padded. */ |
- /* */ |
- /* x_offset :: The horizontal offset. */ |
- /* */ |
- /* y_offset :: The vertical offset. */ |
- /* */ |
- /* <Note> */ |
- /* IMPORTANT: The x and y offsets are relative to the top corner of */ |
- /* the target bitmap (unlike the normal TrueType */ |
- /* convention). A positive y offset indicates a downwards */ |
- /* direction! */ |
- /* */ |
- static void |
- blit_sbit( FT_Bitmap* target, |
- FT_Byte* source, |
- FT_Int line_bits, |
- FT_Bool byte_padded, |
- FT_Int x_offset, |
- FT_Int y_offset, |
- FT_Int source_height ) |
+ FT_LOCAL_DEF( FT_Error ) |
+ tt_face_load_eblc( TT_Face face, |
+ FT_Stream stream ) |
{ |
- FT_Byte* line_buff; |
- FT_Int line_incr; |
- FT_Int height; |
+ FT_Error error = FT_Err_Ok; |
+ FT_Fixed version; |
+ FT_ULong num_strikes, table_size; |
+ FT_Byte* p; |
+ FT_Byte* p_limit; |
+ FT_UInt count; |
- FT_UShort acc; |
- FT_UInt loaded; |
+ face->sbit_num_strikes = 0; |
+ |
+ /* this table is optional */ |
+ error = face->goto_table( face, TTAG_CBLC, stream, &table_size ); |
+ if ( error ) |
+ 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; |
- /* first of all, compute starting write position */ |
- line_incr = target->pitch; |
- line_buff = target->buffer; |
+ if ( table_size < 8 ) |
+ { |
+ FT_ERROR(( "tt_face_load_sbit_strikes: table too short\n" )); |
+ error = FT_THROW( Invalid_File_Format ); |
+ goto Exit; |
+ } |
- if ( line_incr < 0 ) |
- line_buff -= line_incr * ( target->rows - 1 ); |
+ if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) ) |
+ goto Exit; |
- line_buff += ( x_offset >> 3 ) + y_offset * line_incr; |
+ face->sbit_table_size = table_size; |
- /***********************************************************************/ |
- /* */ |
- /* We use the extra-classic `accumulator' trick to extract the bits */ |
- /* from the source byte stream. */ |
- /* */ |
- /* Namely, the variable `acc' is a 16-bit accumulator containing the */ |
- /* last `loaded' bits from the input stream. The bits are shifted to */ |
- /* the upmost position in `acc'. */ |
- /* */ |
- /***********************************************************************/ |
+ p = face->sbit_table; |
+ p_limit = p + table_size; |
- acc = 0; /* clear accumulator */ |
- loaded = 0; /* no bits were loaded */ |
+ version = FT_NEXT_ULONG( p ); |
+ num_strikes = FT_NEXT_ULONG( p ); |
- for ( height = source_height; height > 0; height-- ) |
+ if ( version != 0x00020000UL || num_strikes >= 0x10000UL ) |
{ |
- FT_Byte* cur = line_buff; /* current write cursor */ |
- FT_Int count = line_bits; /* # of bits to extract per line */ |
- FT_Byte shift = (FT_Byte)( x_offset & 7 ); /* current write shift */ |
- FT_Byte space = (FT_Byte)( 8 - shift ); |
- |
+ FT_ERROR(( "tt_face_load_sbit_strikes: invalid table version\n" )); |
+ error = FT_THROW( Invalid_File_Format ); |
+ goto Fail; |
+ } |
- /* first of all, read individual source bytes */ |
- if ( count >= 8 ) |
- { |
- count -= 8; |
- { |
- do |
- { |
- FT_Byte val; |
- |
- |
- /* ensure that there are at least 8 bits in the accumulator */ |
- if ( loaded < 8 ) |
- { |
- acc |= (FT_UShort)((FT_UShort)*source++ << ( 8 - loaded )); |
- loaded += 8; |
- } |
- |
- /* now write one byte */ |
- val = (FT_Byte)( acc >> 8 ); |
- if ( shift ) |
- { |
- cur[0] |= (FT_Byte)( val >> shift ); |
- cur[1] |= (FT_Byte)( val << space ); |
- } |
- else |
- cur[0] |= val; |
- |
- cur++; |
- acc <<= 8; /* remove bits from accumulator */ |
- loaded -= 8; |
- count -= 8; |
- |
- } while ( count >= 0 ); |
- } |
+ /* |
+ * Count the number of strikes available in the table. We are 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 ); |
- /* restore `count' to correct value */ |
- count += 8; |
- } |
+ face->sbit_num_strikes = count; |
- /* now write remaining bits (count < 8) */ |
- if ( count > 0 ) |
- { |
- FT_Byte val; |
+ FT_TRACE3(( "sbit_num_strikes: %u\n", count )); |
+ Exit: |
+ return error; |
+ Fail: |
+ FT_FRAME_RELEASE( face->sbit_table ); |
+ face->sbit_table_size = 0; |
+ goto Exit; |
+ } |
- /* ensure that there are at least `count' bits in the accumulator */ |
- if ( (FT_Int)loaded < count ) |
- { |
- acc |= (FT_UShort)((FT_UShort)*source++ << ( 8 - loaded )); |
- loaded += 8; |
- } |
- /* now write remaining bits */ |
- val = (FT_Byte)( ( (FT_Byte)( acc >> 8 ) ) & ~( 0xFF >> count ) ); |
- cur[0] |= (FT_Byte)( val >> shift ); |
+ FT_LOCAL_DEF( void ) |
+ tt_face_free_eblc( TT_Face face ) |
+ { |
+ FT_Stream stream = face->root.stream; |
- if ( count > space ) |
- cur[1] |= (FT_Byte)( val << space ); |
- acc <<= count; |
- loaded -= count; |
- } |
+ FT_FRAME_RELEASE( face->sbit_table ); |
+ face->sbit_table_size = 0; |
+ face->sbit_num_strikes = 0; |
+ } |
- /* now, skip to next line */ |
- if ( byte_padded ) |
- { |
- acc = 0; |
- loaded = 0; /* clear accumulator on byte-padded lines */ |
- } |
- line_buff += line_incr; |
- } |
+ FT_LOCAL_DEF( FT_Error ) |
+ tt_face_set_sbit_strike( TT_Face face, |
+ FT_Size_Request req, |
+ FT_ULong* astrike_index ) |
+ { |
+ return FT_Match_Size( (FT_Face)face, req, 0, astrike_index ); |
} |
- static const FT_Frame_Field sbit_metrics_fields[] = |
+ FT_LOCAL_DEF( FT_Error ) |
+ tt_face_load_strike_metrics( TT_Face face, |
+ FT_ULong strike_index, |
+ FT_Size_Metrics* metrics ) |
{ |
-#undef FT_STRUCTURE |
-#define FT_STRUCTURE TT_SBit_MetricsRec |
+ FT_Byte* strike; |
- FT_FRAME_START( 8 ), |
- FT_FRAME_BYTE( height ), |
- FT_FRAME_BYTE( width ), |
- FT_FRAME_CHAR( horiBearingX ), |
- FT_FRAME_CHAR( horiBearingY ), |
- FT_FRAME_BYTE( horiAdvance ), |
+ if ( strike_index >= (FT_ULong)face->sbit_num_strikes ) |
+ return FT_THROW( Invalid_Argument ); |
- FT_FRAME_CHAR( vertBearingX ), |
- FT_FRAME_CHAR( vertBearingY ), |
- FT_FRAME_BYTE( vertAdvance ), |
- FT_FRAME_END |
- }; |
+ strike = face->sbit_table + 8 + strike_index * 48; |
+ metrics->x_ppem = (FT_UShort)strike[44]; |
+ metrics->y_ppem = (FT_UShort)strike[45]; |
- /*************************************************************************/ |
- /* */ |
- /* <Function> */ |
- /* Load_SBit_Const_Metrics */ |
- /* */ |
- /* <Description> */ |
- /* Loads the metrics for `EBLC' index tables format 2 and 5. */ |
- /* */ |
- /* <Input> */ |
- /* range :: The target range. */ |
- /* */ |
- /* stream :: The input stream. */ |
- /* */ |
- /* <Return> */ |
- /* FreeType error code. 0 means success. */ |
- /* */ |
- static FT_Error |
- Load_SBit_Const_Metrics( TT_SBit_Range range, |
- FT_Stream stream ) |
+ metrics->ascender = (FT_Char)strike[16] << 6; /* hori.ascender */ |
+ metrics->descender = (FT_Char)strike[17] << 6; /* hori.descender */ |
+ metrics->height = metrics->ascender - metrics->descender; |
+ |
+ /* XXX: Is this correct? */ |
+ metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB */ |
+ strike[18] + /* max_width */ |
+ (FT_Char)strike[23] /* min_advance_SB */ |
+ ) << 6; |
+ |
+ return FT_Err_Ok; |
+ } |
+ |
+ |
+ typedef struct TT_SBitDecoderRec_ |
{ |
- FT_Error error; |
+ 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; |
- if ( FT_READ_ULONG( range->image_size ) ) |
- return error; |
+ FT_ULong strike_index_array; |
+ FT_ULong strike_index_count; |
+ FT_Byte* eblc_base; |
+ FT_Byte* eblc_limit; |
- return FT_STREAM_READ_FIELDS( sbit_metrics_fields, &range->metrics ); |
- } |
+ } TT_SBitDecoderRec, *TT_SBitDecoder; |
- /*************************************************************************/ |
- /* */ |
- /* <Function> */ |
- /* Load_SBit_Range_Codes */ |
- /* */ |
- /* <Description> */ |
- /* Loads the range codes for `EBLC' index tables format 4 and 5. */ |
- /* */ |
- /* <Input> */ |
- /* range :: The target range. */ |
- /* */ |
- /* stream :: The input stream. */ |
- /* */ |
- /* load_offsets :: A flag whether to load the glyph offset table. */ |
- /* */ |
- /* <Return> */ |
- /* FreeType error code. 0 means success. */ |
- /* */ |
static FT_Error |
- Load_SBit_Range_Codes( TT_SBit_Range range, |
- FT_Stream stream, |
- FT_Bool load_offsets ) |
+ tt_sbit_decoder_init( TT_SBitDecoder decoder, |
+ TT_Face face, |
+ FT_ULong strike_index, |
+ TT_SBit_MetricsRec* metrics ) |
{ |
FT_Error error; |
- FT_ULong count, n, size; |
- FT_Memory memory = stream->memory; |
+ FT_Stream stream = face->root.stream; |
+ FT_ULong ebdt_size; |
- if ( FT_READ_ULONG( count ) ) |
+ error = face->goto_table( face, TTAG_CBDT, stream, &ebdt_size ); |
+ if ( error ) |
+ 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; |
- range->num_glyphs = count; |
+ decoder->face = face; |
+ decoder->stream = stream; |
+ decoder->bitmap = &face->root.glyph->bitmap; |
+ decoder->metrics = metrics; |
- /* Allocate glyph offsets table if needed */ |
- if ( load_offsets ) |
- { |
- if ( FT_NEW_ARRAY( range->glyph_offsets, count ) ) |
- goto Exit; |
+ decoder->metrics_loaded = 0; |
+ decoder->bitmap_allocated = 0; |
- size = count * 4L; |
- } |
- else |
- size = count * 2L; |
+ decoder->ebdt_start = FT_STREAM_POS(); |
+ decoder->ebdt_size = ebdt_size; |
- /* Allocate glyph codes table and access frame */ |
- if ( FT_NEW_ARRAY ( range->glyph_codes, count ) || |
- FT_FRAME_ENTER( size ) ) |
- goto Exit; |
+ decoder->eblc_base = face->sbit_table; |
+ decoder->eblc_limit = face->sbit_table + face->sbit_table_size; |
- for ( n = 0; n < count; n++ ) |
+ /* now find the strike corresponding to the index */ |
{ |
- range->glyph_codes[n] = FT_GET_USHORT(); |
+ FT_Byte* p; |
- if ( load_offsets ) |
- range->glyph_offsets[n] = (FT_ULong)range->image_offset + |
- FT_GET_USHORT(); |
- } |
- FT_FRAME_EXIT(); |
+ if ( 8 + 48 * strike_index + 3 * 4 + 34 + 1 > face->sbit_table_size ) |
+ { |
+ error = FT_THROW( Invalid_File_Format ); |
+ goto Exit; |
+ } |
+ |
+ 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; |
+ |
+ if ( decoder->strike_index_array > face->sbit_table_size || |
+ decoder->strike_index_array + 8 * decoder->strike_index_count > |
+ face->sbit_table_size ) |
+ error = FT_THROW( Invalid_File_Format ); |
+ } |
Exit: |
return error; |
} |
- /*************************************************************************/ |
- /* */ |
- /* <Function> */ |
- /* Load_SBit_Range */ |
- /* */ |
- /* <Description> */ |
- /* Loads a given `EBLC' index/range table. */ |
- /* */ |
- /* <Input> */ |
- /* range :: The target range. */ |
- /* */ |
- /* stream :: The input stream. */ |
- /* */ |
- /* <Return> */ |
- /* FreeType error code. 0 means success. */ |
- /* */ |
- static FT_Error |
- Load_SBit_Range( TT_SBit_Range range, |
- FT_Stream stream ) |
+ static void |
+ tt_sbit_decoder_done( TT_SBitDecoder decoder ) |
{ |
- FT_Error error; |
- FT_Memory memory = stream->memory; |
- |
- |
- switch( range->index_format ) |
- { |
- case 1: /* variable metrics with 4-byte offsets */ |
- case 3: /* variable metrics with 2-byte offsets */ |
- { |
- FT_ULong num_glyphs, n; |
- FT_Int size_elem; |
- FT_Bool large = FT_BOOL( range->index_format == 1 ); |
+ FT_UNUSED( decoder ); |
+ } |
+ static FT_Error |
+ tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder decoder, |
+ FT_UInt load_flags ) |
+ { |
+ FT_Error error = FT_Err_Ok; |
+ FT_UInt width, height; |
+ FT_Bitmap* map = decoder->bitmap; |
+ FT_Long size; |
- if ( range->last_glyph < range->first_glyph ) |
- { |
- error = SFNT_Err_Invalid_File_Format; |
- goto Exit; |
- } |
- num_glyphs = range->last_glyph - range->first_glyph + 1L; |
- range->num_glyphs = num_glyphs; |
- num_glyphs++; /* XXX: BEWARE - see spec */ |
+ if ( !decoder->metrics_loaded ) |
+ { |
+ error = FT_THROW( Invalid_Argument ); |
+ goto Exit; |
+ } |
- size_elem = large ? 4 : 2; |
+ width = decoder->metrics->width; |
+ height = decoder->metrics->height; |
- if ( FT_NEW_ARRAY( range->glyph_offsets, num_glyphs ) || |
- FT_FRAME_ENTER( num_glyphs * size_elem ) ) |
- goto Exit; |
+ map->width = (int)width; |
+ map->rows = (int)height; |
- for ( n = 0; n < num_glyphs; n++ ) |
- range->glyph_offsets[n] = (FT_ULong)( range->image_offset + |
- ( large ? FT_GET_ULONG() |
- : FT_GET_USHORT() ) ); |
- FT_FRAME_EXIT(); |
- } |
+ switch ( decoder->bit_depth ) |
+ { |
+ case 1: |
+ map->pixel_mode = FT_PIXEL_MODE_MONO; |
+ map->pitch = ( map->width + 7 ) >> 3; |
+ map->num_grays = 2; |
break; |
- case 2: /* all glyphs have identical metrics */ |
- error = Load_SBit_Const_Metrics( range, stream ); |
+ case 2: |
+ map->pixel_mode = FT_PIXEL_MODE_GRAY2; |
+ map->pitch = ( map->width + 3 ) >> 2; |
+ map->num_grays = 4; |
break; |
case 4: |
- error = Load_SBit_Range_Codes( range, stream, 1 ); |
+ map->pixel_mode = FT_PIXEL_MODE_GRAY4; |
+ map->pitch = ( map->width + 1 ) >> 1; |
+ map->num_grays = 16; |
+ break; |
+ |
+ case 8: |
+ map->pixel_mode = FT_PIXEL_MODE_GRAY; |
+ map->pitch = map->width; |
+ map->num_grays = 256; |
break; |
- case 5: |
- error = Load_SBit_Const_Metrics( range, stream ); |
- if ( !error ) |
- error = Load_SBit_Range_Codes( range, stream, 0 ); |
+ case 32: |
+ if ( load_flags & FT_LOAD_COLOR ) |
+ { |
+ map->pixel_mode = FT_PIXEL_MODE_BGRA; |
+ map->pitch = map->width * 4; |
+ map->num_grays = 256; |
+ } |
+ else |
+ { |
+ map->pixel_mode = FT_PIXEL_MODE_GRAY; |
+ map->pitch = map->width; |
+ map->num_grays = 256; |
+ } |
break; |
default: |
- error = SFNT_Err_Invalid_File_Format; |
+ error = FT_THROW( 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; |
} |
- /*************************************************************************/ |
- /* */ |
- /* <Function> */ |
- /* tt_face_load_eblc */ |
- /* */ |
- /* <Description> */ |
- /* Loads the table of embedded bitmap sizes for this face. */ |
- /* */ |
- /* <Input> */ |
- /* face :: The target face object. */ |
- /* */ |
- /* stream :: The input stream. */ |
- /* */ |
- /* <Return> */ |
- /* FreeType error code. 0 means success. */ |
- /* */ |
- FT_LOCAL_DEF( FT_Error ) |
- tt_face_load_eblc( TT_Face face, |
- FT_Stream stream ) |
+ static FT_Error |
+ tt_sbit_decoder_load_metrics( TT_SBitDecoder decoder, |
+ FT_Byte* *pp, |
+ FT_Byte* limit, |
+ FT_Bool big ) |
{ |
- FT_Error error = SFNT_Err_Ok; |
- FT_Memory memory = stream->memory; |
- FT_Fixed version; |
- FT_ULong num_strikes; |
- FT_ULong table_base; |
+ FT_Byte* p = *pp; |
+ TT_SBit_Metrics metrics = decoder->metrics; |
- static const FT_Frame_Field 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 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 strike_end_fields[] = |
+ |
+ if ( p + 5 > limit ) |
+ goto Fail; |
+ |
+ 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 ) |
{ |
- /* 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 |
- }; |
+ if ( p + 3 > limit ) |
+ goto Fail; |
+ metrics->vertBearingX = (FT_Char)p[0]; |
+ metrics->vertBearingY = (FT_Char)p[1]; |
+ metrics->vertAdvance = p[2]; |
- face->num_sbit_strikes = 0; |
+ p += 3; |
+ } |
- /* this table is optional */ |
- error = face->goto_table( face, TTAG_EBLC, stream, 0 ); |
- if ( error ) |
- error = face->goto_table( face, TTAG_bloc, stream, 0 ); |
- if ( error ) |
- goto Exit; |
+ decoder->metrics_loaded = 1; |
+ *pp = p; |
+ return FT_Err_Ok; |
- table_base = FT_STREAM_POS(); |
- if ( FT_FRAME_ENTER( 8L ) ) |
- goto Exit; |
+ Fail: |
+ FT_TRACE1(( "tt_sbit_decoder_load_metrics: broken table" )); |
+ return FT_THROW( Invalid_Argument ); |
+ } |
- version = FT_GET_LONG(); |
- num_strikes = FT_GET_ULONG(); |
- FT_FRAME_EXIT(); |
+ /* forward declaration */ |
+ static FT_Error |
+ tt_sbit_decoder_load_image( TT_SBitDecoder decoder, |
+ FT_UInt load_flags, |
+ FT_UInt glyph_index, |
+ FT_Int x_pos, |
+ FT_Int y_pos ); |
- /* check version number and strike count */ |
- if ( version != 0x00020000L || |
- num_strikes >= 0x10000L ) |
- { |
- FT_ERROR(( "tt_face_load_sbit_strikes: invalid table version\n" )); |
- error = SFNT_Err_Invalid_File_Format; |
+ typedef FT_Error (*TT_SBitDecoder_LoadFunc)( TT_SBitDecoder decoder, |
+ FT_UInt load_flags, |
+ FT_Byte* p, |
+ FT_Byte* plimit, |
+ FT_Int x_pos, |
+ FT_Int y_pos ); |
- goto Exit; |
- } |
- /* allocate the strikes table */ |
- if ( FT_NEW_ARRAY( face->sbit_strikes, num_strikes ) ) |
- goto Exit; |
+ static FT_Error |
+ tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder decoder, |
+ FT_UInt load_flags, |
+ FT_Byte* p, |
+ FT_Byte* limit, |
+ FT_Int x_pos, |
+ FT_Int y_pos ) |
+ { |
+ FT_Error error = FT_Err_Ok; |
+ FT_Byte* line; |
+ FT_Int bit_height, bit_width, pitch, width, height, line_bits, h; |
+ FT_Bitmap* bitmap; |
- face->num_sbit_strikes = num_strikes; |
+ FT_UNUSED( load_flags ); |
- /* now read each strike table separately */ |
- { |
- TT_SBit_Strike strike = face->sbit_strikes; |
- FT_ULong count = num_strikes; |
+ /* check that we can write the glyph into the bitmap */ |
+ bitmap = decoder->bitmap; |
+ bit_width = bitmap->width; |
+ bit_height = bitmap->rows; |
+ pitch = bitmap->pitch; |
+ line = bitmap->buffer; |
- if ( FT_FRAME_ENTER( 48L * num_strikes ) ) |
- goto Exit; |
+ width = decoder->metrics->width; |
+ height = decoder->metrics->height; |
- while ( count > 0 ) |
- { |
- if ( FT_STREAM_READ_FIELDS( strike_start_fields, strike ) || |
- FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->hori ) || |
- FT_STREAM_READ_FIELDS( sbit_line_metrics_fields, &strike->vert ) || |
- FT_STREAM_READ_FIELDS( strike_end_fields, strike ) ) |
- break; |
- |
- count--; |
- strike++; |
- } |
+ line_bits = width * decoder->bit_depth; |
- FT_FRAME_EXIT(); |
+ if ( x_pos < 0 || x_pos + width > bit_width || |
+ y_pos < 0 || y_pos + height > bit_height ) |
+ { |
+ FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned:" |
+ " invalid bitmap dimensions\n" )); |
+ error = FT_THROW( Invalid_File_Format ); |
+ goto Exit; |
} |
- /* allocate the index ranges for each strike table */ |
+ if ( p + ( ( line_bits + 7 ) >> 3 ) * height > limit ) |
{ |
- TT_SBit_Strike strike = face->sbit_strikes; |
- FT_ULong count = num_strikes; |
+ FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned: broken bitmap\n" )); |
+ error = FT_THROW( Invalid_File_Format ); |
+ goto Exit; |
+ } |
+ /* now do the blit */ |
+ line += y_pos * pitch + ( x_pos >> 3 ); |
+ x_pos &= 7; |
- while ( count > 0 ) |
+ if ( x_pos == 0 ) /* the easy one */ |
+ { |
+ for ( h = height; h > 0; h--, line += pitch ) |
{ |
- TT_SBit_Range range; |
- FT_ULong count2 = strike->num_ranges; |
- |
+ FT_Byte* pwrite = line; |
+ FT_Int w; |
- /* read each range */ |
- if ( FT_STREAM_SEEK( table_base + strike->ranges_offset ) || |
- FT_FRAME_ENTER( strike->num_ranges * 8L ) ) |
- goto Exit; |
- if ( FT_NEW_ARRAY( strike->sbit_ranges, strike->num_ranges ) ) |
- goto Exit; |
- |
- range = strike->sbit_ranges; |
- while ( count2 > 0 ) |
+ for ( w = line_bits; w >= 8; w -= 8 ) |
{ |
- range->first_glyph = FT_GET_USHORT(); |
- range->last_glyph = FT_GET_USHORT(); |
- range->table_offset = table_base + strike->ranges_offset + |
- FT_GET_ULONG(); |
- count2--; |
- range++; |
+ pwrite[0] = (FT_Byte)( pwrite[0] | *p++ ); |
+ pwrite += 1; |
} |
- FT_FRAME_EXIT(); |
+ if ( w > 0 ) |
+ pwrite[0] = (FT_Byte)( pwrite[0] | ( *p++ & ( 0xFF00U >> w ) ) ); |
+ } |
+ } |
+ else /* x_pos > 0 */ |
+ { |
+ for ( h = height; h > 0; h--, line += pitch ) |
+ { |
+ FT_Byte* pwrite = line; |
+ FT_Int w; |
+ FT_UInt wval = 0; |
+ |
- /* Now, read each index table */ |
- count2 = strike->num_ranges; |
- range = strike->sbit_ranges; |
- while ( count2 > 0 ) |
+ for ( w = line_bits; w >= 8; w -= 8 ) |
{ |
- /* Read the header */ |
- if ( FT_STREAM_SEEK( range->table_offset ) || |
- FT_FRAME_ENTER( 8L ) ) |
- goto Exit; |
+ wval = (FT_UInt)( wval | *p++ ); |
+ pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); |
+ pwrite += 1; |
+ wval <<= 8; |
+ } |
- range->index_format = FT_GET_USHORT(); |
- range->image_format = FT_GET_USHORT(); |
- range->image_offset = FT_GET_ULONG(); |
+ if ( w > 0 ) |
+ wval = (FT_UInt)( wval | ( *p++ & ( 0xFF00U >> w ) ) ); |
- FT_FRAME_EXIT(); |
+ /* all bits read and there are `x_pos + w' bits to be written */ |
- error = Load_SBit_Range( range, stream ); |
- if ( error ) |
- goto Exit; |
+ pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); |
- count2--; |
- range++; |
+ if ( x_pos + w > 8 ) |
+ { |
+ pwrite++; |
+ wval <<= 8; |
+ pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); |
} |
- |
- count--; |
- strike++; |
} |
} |
Exit: |
+ if ( !error ) |
+ FT_TRACE3(( "tt_sbit_decoder_load_byte_aligned: loaded\n" )); |
return error; |
} |
- /*************************************************************************/ |
- /* */ |
- /* <Function> */ |
- /* tt_face_free_eblc */ |
- /* */ |
- /* <Description> */ |
- /* Releases the embedded bitmap tables. */ |
- /* */ |
- /* <Input> */ |
- /* face :: The target face object. */ |
- /* */ |
- FT_LOCAL_DEF( void ) |
- tt_face_free_eblc( TT_Face face ) |
+ /* |
+ * Load a bit-aligned bitmap (with pointer `p') into a line-aligned bitmap |
+ * (with pointer `pwrite'). In the example below, the width is 3 pixel, |
+ * and `x_pos' is 1 pixel. |
+ * |
+ * p p+1 |
+ * | | | |
+ * | 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 |... |
+ * | | | |
+ * +-------+ +-------+ +-------+ ... |
+ * . . . |
+ * . . . |
+ * v . . |
+ * +-------+ . . |
+ * | | . |
+ * | 7 6 5 4 3 2 1 0 | . |
+ * | | . |
+ * pwrite . . |
+ * . . |
+ * v . |
+ * +-------+ . |
+ * | | |
+ * | 7 6 5 4 3 2 1 0 | |
+ * | | |
+ * pwrite+1 . |
+ * . |
+ * v |
+ * +-------+ |
+ * | | |
+ * | 7 6 5 4 3 2 1 0 | |
+ * | | |
+ * pwrite+2 |
+ * |
+ */ |
+ |
+ static FT_Error |
+ tt_sbit_decoder_load_bit_aligned( TT_SBitDecoder decoder, |
+ FT_UInt load_flags, |
+ FT_Byte* p, |
+ FT_Byte* limit, |
+ FT_Int x_pos, |
+ FT_Int y_pos ) |
{ |
- FT_Memory memory = face->root.memory; |
- TT_SBit_Strike strike = face->sbit_strikes; |
- TT_SBit_Strike strike_limit = strike + face->num_sbit_strikes; |
+ FT_Error error = FT_Err_Ok; |
+ FT_Byte* line; |
+ FT_Int bit_height, bit_width, pitch, width, height, line_bits, h, nbits; |
+ FT_Bitmap* bitmap; |
+ FT_UShort rval; |
+ FT_UNUSED( load_flags ); |
- if ( strike ) |
- { |
- for ( ; strike < strike_limit; strike++ ) |
- { |
- TT_SBit_Range range = strike->sbit_ranges; |
- TT_SBit_Range range_limit = range + strike->num_ranges; |
+ /* check that we can write the glyph into the bitmap */ |
+ bitmap = decoder->bitmap; |
+ bit_width = bitmap->width; |
+ bit_height = bitmap->rows; |
+ pitch = bitmap->pitch; |
+ line = bitmap->buffer; |
- if ( range ) |
- { |
- for ( ; range < range_limit; range++ ) |
- { |
- /* release the glyph offsets and codes tables */ |
- /* where appropriate */ |
- FT_FREE( range->glyph_offsets ); |
- FT_FREE( range->glyph_codes ); |
- } |
- } |
- FT_FREE( strike->sbit_ranges ); |
- strike->num_ranges = 0; |
- } |
- FT_FREE( face->sbit_strikes ); |
+ width = decoder->metrics->width; |
+ height = decoder->metrics->height; |
+ |
+ line_bits = width * decoder->bit_depth; |
+ |
+ if ( x_pos < 0 || x_pos + width > bit_width || |
+ y_pos < 0 || y_pos + height > bit_height ) |
+ { |
+ FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned:" |
+ " invalid bitmap dimensions\n" )); |
+ error = FT_THROW( Invalid_File_Format ); |
+ goto Exit; |
} |
- face->num_sbit_strikes = 0; |
- } |
+ if ( p + ( ( line_bits * height + 7 ) >> 3 ) > limit ) |
+ { |
+ FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned: broken bitmap\n" )); |
+ error = FT_THROW( Invalid_File_Format ); |
+ goto Exit; |
+ } |
- FT_LOCAL_DEF( FT_Error ) |
- tt_face_set_sbit_strike( TT_Face face, |
- FT_Size_Request req, |
- FT_ULong* astrike_index ) |
- { |
- return FT_Match_Size( (FT_Face)face, req, 0, astrike_index ); |
- } |
+ /* now do the blit */ |
+ /* adjust `line' to point to the first byte of the bitmap */ |
+ line += y_pos * pitch + ( x_pos >> 3 ); |
+ x_pos &= 7; |
- FT_LOCAL_DEF( FT_Error ) |
- tt_face_load_strike_metrics( TT_Face face, |
- FT_ULong strike_index, |
- FT_Size_Metrics* metrics ) |
- { |
- TT_SBit_Strike strike; |
+ /* the higher byte of `rval' is used as a buffer */ |
+ rval = 0; |
+ nbits = 0; |
+ for ( h = height; h > 0; h--, line += pitch ) |
+ { |
+ FT_Byte* pwrite = line; |
+ FT_Int w = line_bits; |
- if ( strike_index >= face->num_sbit_strikes ) |
- return SFNT_Err_Invalid_Argument; |
- strike = face->sbit_strikes + strike_index; |
+ /* handle initial byte (in target bitmap) specially if necessary */ |
+ if ( x_pos ) |
+ { |
+ w = ( line_bits < 8 - x_pos ) ? line_bits : 8 - x_pos; |
- metrics->x_ppem = strike->x_ppem; |
- metrics->y_ppem = strike->y_ppem; |
+ if ( h == height ) |
+ { |
+ rval = *p++; |
+ nbits = x_pos; |
+ } |
+ else if ( nbits < w ) |
+ { |
+ if ( p < limit ) |
+ rval |= *p++; |
+ nbits += 8 - w; |
+ } |
+ else |
+ { |
+ rval >>= 8; |
+ nbits -= w; |
+ } |
- metrics->ascender = strike->hori.ascender << 6; |
- metrics->descender = strike->hori.descender << 6; |
+ *pwrite++ |= ( ( rval >> nbits ) & 0xFF ) & |
+ ( ~( 0xFF << w ) << ( 8 - w - x_pos ) ); |
+ rval <<= 8; |
- /* XXX: Is this correct? */ |
- metrics->max_advance = ( strike->hori.min_origin_SB + |
- strike->hori.max_width + |
- strike->hori.min_advance_SB ) << 6; |
+ w = line_bits - w; |
+ } |
- metrics->height = metrics->ascender - metrics->descender; |
+ /* handle medial bytes */ |
+ for ( ; w >= 8; w -= 8 ) |
+ { |
+ rval |= *p++; |
+ *pwrite++ |= ( rval >> nbits ) & 0xFF; |
- return SFNT_Err_Ok; |
- } |
+ rval <<= 8; |
+ } |
+ |
+ /* handle final byte if necessary */ |
+ if ( w > 0 ) |
+ { |
+ if ( nbits < w ) |
+ { |
+ if ( p < limit ) |
+ rval |= *p++; |
+ *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w ); |
+ nbits += 8 - w; |
+ |
+ rval <<= 8; |
+ } |
+ else |
+ { |
+ *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w ); |
+ nbits -= w; |
+ } |
+ } |
+ } |
+ |
+ Exit: |
+ if ( !error ) |
+ FT_TRACE3(( "tt_sbit_decoder_load_bit_aligned: loaded\n" )); |
+ return error; |
+ } |
- /*************************************************************************/ |
- /* */ |
- /* <Function> */ |
- /* find_sbit_range */ |
- /* */ |
- /* <Description> */ |
- /* Scans a given strike's ranges and return, for a given glyph */ |
- /* index, the corresponding sbit range, and `EBDT' offset. */ |
- /* */ |
- /* <Input> */ |
- /* glyph_index :: The glyph index. */ |
- /* */ |
- /* strike :: The source/current sbit strike. */ |
- /* */ |
- /* <Output> */ |
- /* arange :: The sbit range containing the glyph index. */ |
- /* */ |
- /* aglyph_offset :: The offset of the glyph data in `EBDT' table. */ |
- /* */ |
- /* <Return> */ |
- /* FreeType error code. 0 means the glyph index was found. */ |
- /* */ |
static FT_Error |
- find_sbit_range( FT_UInt glyph_index, |
- TT_SBit_Strike strike, |
- TT_SBit_Range *arange, |
- FT_ULong *aglyph_offset ) |
+ tt_sbit_decoder_load_compound( TT_SBitDecoder decoder, |
+ FT_UInt load_flags, |
+ FT_Byte* p, |
+ FT_Byte* limit, |
+ FT_Int x_pos, |
+ FT_Int y_pos ) |
{ |
- TT_SBit_RangeRec *range, *range_limit; |
+ FT_Error error = FT_Err_Ok; |
+ FT_UInt num_components, nn; |
+ FT_Char horiBearingX = decoder->metrics->horiBearingX; |
+ FT_Char horiBearingY = decoder->metrics->horiBearingY; |
+ FT_Byte horiAdvance = decoder->metrics->horiAdvance; |
+ FT_Char vertBearingX = decoder->metrics->vertBearingX; |
+ FT_Char vertBearingY = decoder->metrics->vertBearingY; |
+ FT_Byte vertAdvance = decoder->metrics->vertAdvance; |
- /* check whether the glyph index is within this strike's */ |
- /* glyph range */ |
- if ( glyph_index < (FT_UInt)strike->start_glyph || |
- glyph_index > (FT_UInt)strike->end_glyph ) |
- goto Fail; |
- /* scan all ranges in strike */ |
- range = strike->sbit_ranges; |
- range_limit = range + strike->num_ranges; |
- if ( !range ) |
+ if ( p + 2 > limit ) |
goto Fail; |
- for ( ; range < range_limit; range++ ) |
+ num_components = FT_NEXT_USHORT( p ); |
+ if ( p + 4 * num_components > limit ) |
{ |
- if ( glyph_index >= (FT_UInt)range->first_glyph && |
- glyph_index <= (FT_UInt)range->last_glyph ) |
- { |
- FT_UShort delta = (FT_UShort)( glyph_index - range->first_glyph ); |
+ FT_TRACE1(( "tt_sbit_decoder_load_compound: broken table\n" )); |
+ goto Fail; |
+ } |
+ FT_TRACE3(( "tt_sbit_decoder_load_compound: loading %d components\n", |
+ num_components )); |
- switch ( range->index_format ) |
- { |
- case 1: |
- case 3: |
- *aglyph_offset = range->glyph_offsets[delta]; |
- break; |
- |
- case 2: |
- *aglyph_offset = range->image_offset + |
- range->image_size * delta; |
- break; |
- |
- case 4: |
- case 5: |
- { |
- FT_ULong n; |
- |
- |
- for ( n = 0; n < range->num_glyphs; n++ ) |
- { |
- if ( (FT_UInt)range->glyph_codes[n] == glyph_index ) |
- { |
- if ( range->index_format == 4 ) |
- *aglyph_offset = range->glyph_offsets[n]; |
- else |
- *aglyph_offset = range->image_offset + |
- n * range->image_size; |
- goto Found; |
- } |
- } |
- } |
+ 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 ); |
- /* fall-through */ |
- default: |
- goto Fail; |
- } |
- Found: |
- /* return successfully! */ |
- *arange = range; |
- return SFNT_Err_Ok; |
- } |
+ /* NB: a recursive call */ |
+ error = tt_sbit_decoder_load_image( decoder, load_flags, gindex, |
+ x_pos + dx, y_pos + dy ); |
+ if ( error ) |
+ break; |
} |
- Fail: |
- *arange = 0; |
- *aglyph_offset = 0; |
+ FT_TRACE3(( "tt_sbit_decoder_load_compound: done\n" )); |
- return SFNT_Err_Invalid_Argument; |
- } |
+ decoder->metrics->horiBearingX = horiBearingX; |
+ decoder->metrics->horiBearingY = horiBearingY; |
+ decoder->metrics->horiAdvance = horiAdvance; |
+ decoder->metrics->vertBearingX = vertBearingX; |
+ decoder->metrics->vertBearingY = vertBearingY; |
+ decoder->metrics->vertAdvance = vertAdvance; |
+ decoder->metrics->width = (FT_Byte)decoder->bitmap->width; |
+ decoder->metrics->height = (FT_Byte)decoder->bitmap->rows; |
+ Exit: |
+ return error; |
- /*************************************************************************/ |
- /* */ |
- /* <Function> */ |
- /* tt_find_sbit_image */ |
- /* */ |
- /* <Description> */ |
- /* Checks whether an embedded bitmap (an `sbit') exists for a given */ |
- /* glyph, at a given strike. */ |
- /* */ |
- /* <Input> */ |
- /* face :: The target face object. */ |
- /* */ |
- /* glyph_index :: The glyph index. */ |
- /* */ |
- /* strike_index :: The current strike index. */ |
- /* */ |
- /* <Output> */ |
- /* arange :: The SBit range containing the glyph index. */ |
- /* */ |
- /* astrike :: The SBit strike containing the glyph index. */ |
- /* */ |
- /* aglyph_offset :: The offset of the glyph data in `EBDT' table. */ |
- /* */ |
- /* <Return> */ |
- /* FreeType error code. 0 means success. Returns */ |
- /* SFNT_Err_Invalid_Argument if no sbit exists for the requested */ |
- /* glyph. */ |
- /* */ |
- FT_LOCAL( FT_Error ) |
- tt_find_sbit_image( TT_Face face, |
- FT_UInt glyph_index, |
- FT_ULong strike_index, |
- TT_SBit_Range *arange, |
- TT_SBit_Strike *astrike, |
- FT_ULong *aglyph_offset ) |
- { |
- FT_Error error; |
- TT_SBit_Strike strike; |
+ Fail: |
+ error = FT_THROW( Invalid_File_Format ); |
+ goto Exit; |
+ } |
- if ( !face->sbit_strikes || |
- ( face->num_sbit_strikes <= strike_index ) ) |
- goto Fail; |
+#ifdef FT_CONFIG_OPTION_USE_PNG |
- strike = &face->sbit_strikes[strike_index]; |
+ static FT_Error |
+ tt_sbit_decoder_load_png( TT_SBitDecoder decoder, |
+ FT_UInt load_flags, |
+ FT_Byte* p, |
+ FT_Byte* limit, |
+ FT_Int x_pos, |
+ FT_Int y_pos ) |
+ { |
+ FT_Error error = FT_Err_Ok; |
+ FT_ULong png_len; |
- error = find_sbit_range( glyph_index, strike, |
- arange, aglyph_offset ); |
- if ( error ) |
- goto Fail; |
+ FT_UNUSED( load_flags ); |
- *astrike = strike; |
- return SFNT_Err_Ok; |
+ if ( limit - p < 4 ) |
+ { |
+ FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" )); |
+ error = FT_THROW( Invalid_File_Format ); |
+ goto Exit; |
+ } |
- Fail: |
- /* no embedded bitmap for this glyph in face */ |
- *arange = 0; |
- *astrike = 0; |
- *aglyph_offset = 0; |
+ png_len = FT_NEXT_ULONG( p ); |
+ if ( (FT_ULong)( limit - p ) < png_len ) |
+ { |
+ FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" )); |
+ error = FT_THROW( Invalid_File_Format ); |
+ goto Exit; |
+ } |
+ |
+ error = Load_SBit_Png( decoder->bitmap, |
+ x_pos, |
+ y_pos, |
+ decoder->bit_depth, |
+ decoder->metrics, |
+ decoder->stream->memory, |
+ p, |
+ png_len ); |
- return SFNT_Err_Invalid_Argument; |
+ Exit: |
+ if ( !error ) |
+ FT_TRACE3(( "tt_sbit_decoder_load_png: loaded\n" )); |
+ return error; |
} |
+#endif /* FT_CONFIG_OPTION_USE_PNG */ |
- /*************************************************************************/ |
- /* */ |
- /* <Function> */ |
- /* tt_load_sbit_metrics */ |
- /* */ |
- /* <Description> */ |
- /* Gets the big metrics for a given SBit. */ |
- /* */ |
- /* <Input> */ |
- /* stream :: The input stream. */ |
- /* */ |
- /* range :: The SBit range containing the glyph. */ |
- /* */ |
- /* <Output> */ |
- /* big_metrics :: A big SBit metrics structure for the glyph. */ |
- /* */ |
- /* <Return> */ |
- /* FreeType error code. 0 means success. */ |
- /* */ |
- /* <Note> */ |
- /* The stream cursor must be positioned at the glyph's offset within */ |
- /* the `EBDT' table before the call. */ |
- /* */ |
- /* If the image format uses variable metrics, the stream cursor is */ |
- /* positioned just after the metrics header in the `EBDT' table on */ |
- /* function exit. */ |
- /* */ |
- FT_LOCAL( FT_Error ) |
- tt_load_sbit_metrics( FT_Stream stream, |
- TT_SBit_Range range, |
- TT_SBit_Metrics metrics ) |
+ |
+ static FT_Error |
+ tt_sbit_decoder_load_bitmap( TT_SBitDecoder decoder, |
+ FT_UInt load_flags, |
+ FT_UInt glyph_format, |
+ FT_ULong glyph_start, |
+ FT_ULong glyph_size, |
+ FT_Int x_pos, |
+ FT_Int y_pos ) |
{ |
- FT_Error error = SFNT_Err_Ok; |
+ FT_Error error; |
+ FT_Stream stream = decoder->stream; |
+ FT_Byte* p; |
+ FT_Byte* p_limit; |
+ FT_Byte* data; |
- switch ( range->image_format ) |
+ /* seek into the EBDT table now */ |
+ if ( glyph_start + glyph_size > decoder->ebdt_size ) |
+ { |
+ error = FT_THROW( 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: |
- /* variable small metrics */ |
- { |
- TT_SBit_SmallMetricsRec smetrics; |
- |
- static const FT_Frame_Field sbit_small_metrics_fields[] = |
- { |
-#undef FT_STRUCTURE |
-#define FT_STRUCTURE TT_SBit_SmallMetricsRec |
- |
- FT_FRAME_START( 5 ), |
- FT_FRAME_BYTE( height ), |
- FT_FRAME_BYTE( width ), |
- FT_FRAME_CHAR( bearingX ), |
- FT_FRAME_CHAR( bearingY ), |
- FT_FRAME_BYTE( advance ), |
- FT_FRAME_END |
- }; |
- |
- |
- /* read small metrics */ |
- if ( FT_STREAM_READ_FIELDS( sbit_small_metrics_fields, &smetrics ) ) |
- goto Exit; |
- |
- /* convert it to a big metrics */ |
- metrics->height = smetrics.height; |
- metrics->width = smetrics.width; |
- metrics->horiBearingX = smetrics.bearingX; |
- metrics->horiBearingY = smetrics.bearingY; |
- metrics->horiAdvance = smetrics.advance; |
- |
- /* these metrics are made up at a higher level when */ |
- /* needed. */ |
- metrics->vertBearingX = 0; |
- metrics->vertBearingY = 0; |
- metrics->vertAdvance = 0; |
- } |
+ case 17: |
+ error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 ); |
break; |
case 6: |
case 7: |
case 9: |
- /* variable big metrics */ |
- if ( FT_STREAM_READ_FIELDS( sbit_metrics_fields, metrics ) ) |
- goto Exit; |
+ case 18: |
+ error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ); |
break; |
- case 5: |
- default: /* constant metrics */ |
- if ( range->index_format == 2 || range->index_format == 5 ) |
- *metrics = range->metrics; |
- else |
- return SFNT_Err_Invalid_File_Format; |
- } |
- |
- Exit: |
- return error; |
- } |
+ default: |
+ error = FT_Err_Ok; |
+ } |
+ if ( error ) |
+ goto Fail; |
- /*************************************************************************/ |
- /* */ |
- /* <Function> */ |
- /* crop_bitmap */ |
- /* */ |
- /* <Description> */ |
- /* Crops a bitmap to its tightest bounding box, and adjusts its */ |
- /* metrics. */ |
- /* */ |
- /* <InOut> */ |
- /* map :: The bitmap. */ |
- /* */ |
- /* metrics :: The corresponding metrics structure. */ |
- /* */ |
- static void |
- crop_bitmap( FT_Bitmap* map, |
- TT_SBit_Metrics metrics ) |
- { |
- /***********************************************************************/ |
- /* */ |
- /* In this situation, some bounding boxes of embedded bitmaps are too */ |
- /* large. We need to crop it to a reasonable size. */ |
- /* */ |
- /* --------- */ |
- /* | | ----- */ |
- /* | *** | |***| */ |
- /* | * | | * | */ |
- /* | * | ------> | * | */ |
- /* | * | | * | */ |
- /* | * | | * | */ |
- /* | *** | |***| */ |
- /* --------- ----- */ |
- /* */ |
- /***********************************************************************/ |
- |
- FT_Int rows, count; |
- FT_Long line_len; |
- FT_Byte* line; |
- |
- |
- /***********************************************************************/ |
- /* */ |
- /* first of all, check the top-most lines of the bitmap, and remove */ |
- /* them if they're empty. */ |
- /* */ |
{ |
- line = (FT_Byte*)map->buffer; |
- rows = map->rows; |
- line_len = map->pitch; |
+ TT_SBitDecoder_LoadFunc loader; |
- for ( count = 0; count < rows; count++ ) |
+ switch ( glyph_format ) |
{ |
- FT_Byte* cur = line; |
- FT_Byte* limit = line + line_len; |
- |
- |
- for ( ; cur < limit; cur++ ) |
- if ( cur[0] ) |
- goto Found_Top; |
+ case 1: |
+ case 6: |
+ loader = tt_sbit_decoder_load_byte_aligned; |
+ break; |
- /* the current line was empty - skip to next one */ |
- line = limit; |
- } |
+ case 2: |
+ case 5: |
+ case 7: |
+ loader = tt_sbit_decoder_load_bit_aligned; |
+ break; |
- Found_Top: |
- /* check that we have at least one filled line */ |
- if ( count >= rows ) |
- goto Empty_Bitmap; |
+ case 8: |
+ if ( p + 1 > p_limit ) |
+ goto Fail; |
- /* now, crop the empty upper lines */ |
- if ( count > 0 ) |
- { |
- line = (FT_Byte*)map->buffer; |
+ p += 1; /* skip padding */ |
+ /* fall-through */ |
- FT_MEM_MOVE( line, line + count * line_len, |
- ( rows - count ) * line_len ); |
+ case 9: |
+ loader = tt_sbit_decoder_load_compound; |
+ break; |
- metrics->height = (FT_Byte)( metrics->height - count ); |
- metrics->horiBearingY = (FT_Char)( metrics->horiBearingY - count ); |
- metrics->vertBearingY = (FT_Char)( metrics->vertBearingY - count ); |
+#ifdef FT_CONFIG_OPTION_USE_PNG |
+ case 17: /* small metrics, PNG image data */ |
+ case 18: /* big metrics, PNG image data */ |
+ case 19: /* metrics in EBLC, PNG image data */ |
+ loader = tt_sbit_decoder_load_png; |
+ break; |
+#endif /* FT_CONFIG_OPTION_USE_PNG */ |
- map->rows -= count; |
- rows -= count; |
+ default: |
+ error = FT_THROW( Invalid_Table ); |
+ goto Fail; |
} |
- } |
- /***********************************************************************/ |
- /* */ |
- /* second, crop the lower lines */ |
- /* */ |
- { |
- line = (FT_Byte*)map->buffer + ( rows - 1 ) * line_len; |
- |
- for ( count = 0; count < rows; count++ ) |
+ if ( !decoder->bitmap_allocated ) |
{ |
- FT_Byte* cur = line; |
- FT_Byte* 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; |
+ error = tt_sbit_decoder_alloc_bitmap( decoder, load_flags ); |
+ if ( error ) |
+ goto Fail; |
} |
- Found_Bottom: |
- if ( count > 0 ) |
+ if ( decoder->bit_depth == 32 && |
+ decoder->bitmap->pixel_mode != FT_PIXEL_MODE_BGRA ) |
{ |
- metrics->height = (FT_Byte)( metrics->height - count ); |
- rows -= count; |
- map->rows -= count; |
- } |
- } |
- |
- /***********************************************************************/ |
- /* */ |
- /* third, get rid of the space on the left side of the glyph */ |
- /* */ |
- do |
- { |
- FT_Byte* limit; |
+ /* Flatten color bitmaps if color was not requested. */ |
+ FT_Library library = decoder->face->root.glyph->library; |
+ FT_Memory memory = decoder->stream->memory; |
- line = (FT_Byte*)map->buffer; |
- limit = line + rows * line_len; |
+ FT_Bitmap color, *orig; |
- for ( ; line < limit; line += line_len ) |
- if ( line[0] & 0x80 ) |
- goto Found_Left; |
- /* shift the whole glyph one pixel to the left */ |
- line = (FT_Byte*)map->buffer; |
- limit = line + rows * line_len; |
- |
- for ( ; line < limit; line += line_len ) |
- { |
- FT_Int n, width = map->width; |
- FT_Byte old; |
- FT_Byte* cur = line; |
- |
- |
- old = (FT_Byte)(cur[0] << 1); |
- for ( n = 8; n < width; n += 8 ) |
+ if ( decoder->bitmap->pixel_mode != FT_PIXEL_MODE_GRAY || |
+ x_pos != 0 || y_pos != 0 ) |
{ |
- FT_Byte val; |
- |
- |
- val = cur[1]; |
- cur[0] = (FT_Byte)( old | ( val >> 7 ) ); |
- old = (FT_Byte)( val << 1 ); |
- cur++; |
+ /* Shouldn't happen. */ |
+ error = FT_THROW( Invalid_Table ); |
+ goto Fail; |
} |
- cur[0] = old; |
- } |
- map->width--; |
- metrics->horiBearingX++; |
- metrics->vertBearingX++; |
- metrics->width--; |
+ FT_Bitmap_New( &color ); |
- } while ( map->width > 0 ); |
+ color.rows = decoder->bitmap->rows; |
+ color.width = decoder->bitmap->width; |
+ color.pitch = color.width * 4; |
+ color.pixel_mode = FT_PIXEL_MODE_BGRA; |
- Found_Left: |
+ if ( FT_ALLOC( color.buffer, color.rows * color.pitch ) ) |
+ goto Fail; |
- /***********************************************************************/ |
- /* */ |
- /* finally, crop the bitmap width to get rid of the space on the right */ |
- /* side of the glyph. */ |
- /* */ |
- do |
- { |
- FT_Int right = map->width - 1; |
- FT_Byte* limit; |
- FT_Byte mask; |
+ orig = decoder->bitmap; |
+ decoder->bitmap = &color; |
+ error = loader( decoder, load_flags, p, p_limit, x_pos, y_pos ); |
- line = (FT_Byte*)map->buffer + ( right >> 3 ); |
- limit = line + rows * line_len; |
- mask = (FT_Byte)( 0x80 >> ( right & 7 ) ); |
+ decoder->bitmap = orig; |
- for ( ; line < limit; line += line_len ) |
- if ( line[0] & mask ) |
- goto Found_Right; |
+ /* explicitly test against FT_Err_Ok to avoid compiler warnings */ |
+ /* (we do an assignment within a conditional) */ |
+ if ( error || |
+ ( error = FT_Bitmap_Convert( library, |
+ &color, |
+ decoder->bitmap, |
+ 1 ) ) != FT_Err_Ok ) |
+ { |
+ FT_Bitmap_Done( library, &color ); |
+ goto Fail; |
+ } |
- /* crop the whole glyph to the right */ |
- map->width--; |
- metrics->width--; |
+ FT_Bitmap_Done( library, &color ); |
+ } |
- } while ( map->width > 0 ); |
+ else |
+ error = loader( decoder, load_flags, p, p_limit, x_pos, y_pos ); |
+ } |
- Found_Right: |
- /* all right, the bitmap was cropped */ |
- return; |
+ Fail: |
+ FT_FRAME_RELEASE( data ); |
- Empty_Bitmap: |
- map->width = 0; |
- map->rows = 0; |
- map->pitch = 0; |
- map->pixel_mode = FT_PIXEL_MODE_MONO; |
+ Exit: |
+ return error; |
} |
static FT_Error |
- Load_SBit_Single( FT_Bitmap* map, |
- FT_Int x_offset, |
- FT_Int y_offset, |
- FT_Int pix_bits, |
- FT_UShort image_format, |
- TT_SBit_Metrics metrics, |
- FT_Stream stream ) |
+ tt_sbit_decoder_load_image( TT_SBitDecoder decoder, |
+ FT_UInt load_flags, |
+ FT_UInt glyph_index, |
+ FT_Int x_pos, |
+ FT_Int y_pos ) |
{ |
- FT_Error error; |
+ /* |
+ * 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, index_format, image_format; |
+ FT_ULong image_start = 0, image_end = 0, image_offset; |
- /* check that the source bitmap fits into the target pixmap */ |
- if ( x_offset < 0 || x_offset + metrics->width > map->width || |
- y_offset < 0 || y_offset + metrics->height > map->rows ) |
+ for ( ; num_ranges > 0; num_ranges-- ) |
{ |
- error = SFNT_Err_Invalid_Argument; |
+ start = FT_NEXT_USHORT( p ); |
+ end = FT_NEXT_USHORT( p ); |
- goto Exit; |
+ if ( glyph_index >= start && glyph_index <= end ) |
+ goto FoundRange; |
+ |
+ p += 4; /* ignore index offset */ |
} |
+ goto NoBitmap; |
- { |
- FT_Int glyph_width = metrics->width; |
- FT_Int glyph_height = metrics->height; |
- FT_Int glyph_size; |
- FT_Int line_bits = pix_bits * glyph_width; |
- FT_Bool pad_bytes = 0; |
+ FoundRange: |
+ image_offset = FT_NEXT_ULONG( p ); |
+ /* overflow check */ |
+ p = decoder->eblc_base + decoder->strike_index_array; |
+ if ( image_offset > (FT_ULong)( p_limit - p ) ) |
+ goto Failure; |
- /* compute size of glyph image */ |
- switch ( image_format ) |
- { |
- case 1: /* byte-padded formats */ |
- case 6: |
- { |
- FT_Int line_length; |
+ p += image_offset; |
+ if ( p + 8 > p_limit ) |
+ goto NoBitmap; |
+ /* now 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 ( pix_bits ) |
- { |
- case 1: |
- line_length = ( glyph_width + 7 ) >> 3; |
- break; |
- case 2: |
- line_length = ( glyph_width + 3 ) >> 2; |
- break; |
- case 4: |
- line_length = ( glyph_width + 1 ) >> 1; |
- break; |
- default: |
- line_length = glyph_width; |
- } |
- |
- glyph_size = glyph_height * line_length; |
- pad_bytes = 1; |
- } |
- break; |
+ switch ( index_format ) |
+ { |
+ case 1: /* 4-byte offsets relative to `image_offset' */ |
+ { |
+ p += 4 * ( glyph_index - start ); |
+ if ( p + 8 > p_limit ) |
+ goto NoBitmap; |
- case 2: |
- case 5: |
- case 7: |
- line_bits = glyph_width * pix_bits; |
- glyph_size = ( glyph_height * line_bits + 7 ) >> 3; |
- break; |
+ image_start = FT_NEXT_ULONG( p ); |
+ image_end = FT_NEXT_ULONG( p ); |
- default: /* invalid format */ |
- return SFNT_Err_Invalid_File_Format; |
+ if ( image_start == image_end ) /* missing glyph */ |
+ goto NoBitmap; |
} |
+ break; |
- /* Now read data and draw glyph into target pixmap */ |
- if ( FT_FRAME_ENTER( glyph_size ) ) |
- goto Exit; |
+ case 2: /* big metrics, constant image size */ |
+ { |
+ FT_ULong image_size; |
- /* don't forget to multiply `x_offset' by `map->pix_bits' as */ |
- /* the sbit blitter doesn't make a difference between pixmap */ |
- /* depths. */ |
- blit_sbit( map, (FT_Byte*)stream->cursor, line_bits, pad_bytes, |
- x_offset * pix_bits, y_offset, metrics->height ); |
- FT_FRAME_EXIT(); |
- } |
+ if ( p + 12 > p_limit ) |
+ goto NoBitmap; |
- Exit: |
- return error; |
- } |
+ image_size = FT_NEXT_ULONG( p ); |
+ if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) ) |
+ goto NoBitmap; |
- static FT_Error |
- Load_SBit_Image( TT_SBit_Strike strike, |
- TT_SBit_Range range, |
- FT_ULong ebdt_pos, |
- FT_ULong glyph_offset, |
- FT_GlyphSlot slot, |
- FT_Int x_offset, |
- FT_Int y_offset, |
- FT_Stream stream, |
- TT_SBit_Metrics metrics, |
- FT_Int depth ) |
- { |
- FT_Memory memory = stream->memory; |
- FT_Bitmap* map = &slot->bitmap; |
- FT_Error error; |
+ image_start = 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; |
- /* place stream at beginning of glyph data and read metrics */ |
- if ( FT_STREAM_SEEK( ebdt_pos + glyph_offset ) ) |
- goto Exit; |
+ image_start = FT_NEXT_USHORT( p ); |
+ image_end = FT_NEXT_USHORT( p ); |
- error = tt_load_sbit_metrics( stream, range, metrics ); |
- if ( error ) |
- goto Exit; |
+ if ( image_start == image_end ) /* missing glyph */ |
+ goto NoBitmap; |
+ } |
+ break; |
- /* This function is recursive. At the top-level call, we */ |
- /* compute the dimensions of the higher-level glyph to */ |
- /* allocate the final pixmap buffer. */ |
- if ( depth == 0 ) |
- { |
- FT_Long size; |
+ case 4: /* sparse glyph array with (glyph,offset) pairs */ |
+ { |
+ FT_ULong mm, num_glyphs; |
- map->width = metrics->width; |
- map->rows = metrics->height; |
+ if ( p + 4 > p_limit ) |
+ goto NoBitmap; |
- switch ( strike->bit_depth ) |
- { |
- case 1: |
- map->pixel_mode = FT_PIXEL_MODE_MONO; |
- map->pitch = ( map->width + 7 ) >> 3; |
- break; |
+ num_glyphs = FT_NEXT_ULONG( p ); |
- case 2: |
- map->pixel_mode = FT_PIXEL_MODE_GRAY2; |
- map->pitch = ( map->width + 3 ) >> 2; |
- break; |
+ /* overflow check for p + ( num_glyphs + 1 ) * 4 */ |
+ if ( num_glyphs > (FT_ULong)( ( ( p_limit - p ) >> 2 ) - 1 ) ) |
+ goto NoBitmap; |
- case 4: |
- map->pixel_mode = FT_PIXEL_MODE_GRAY4; |
- map->pitch = ( map->width + 1 ) >> 1; |
- break; |
+ for ( mm = 0; mm < num_glyphs; mm++ ) |
+ { |
+ FT_UInt gindex = FT_NEXT_USHORT( p ); |
- case 8: |
- map->pixel_mode = FT_PIXEL_MODE_GRAY; |
- map->pitch = map->width; |
- break; |
- default: |
- return SFNT_Err_Invalid_File_Format; |
- } |
+ if ( gindex == glyph_index ) |
+ { |
+ image_start = FT_NEXT_USHORT( p ); |
+ p += 2; |
+ image_end = FT_PEEK_USHORT( p ); |
+ break; |
+ } |
+ p += 2; |
+ } |
- size = map->rows * map->pitch; |
+ if ( mm >= num_glyphs ) |
+ goto NoBitmap; |
+ } |
+ break; |
- /* check that there is no empty image */ |
- if ( size == 0 ) |
- goto Exit; /* exit successfully! */ |
+ case 5: /* constant metrics with sparse glyph codes */ |
+ case 19: |
+ { |
+ FT_ULong image_size, mm, num_glyphs; |
- error = ft_glyphslot_alloc_bitmap( slot, size ); |
- if (error) |
- goto Exit; |
- } |
- switch ( range->image_format ) |
- { |
- case 1: /* single sbit image - load it */ |
- case 2: |
- case 5: |
- case 6: |
- case 7: |
- return Load_SBit_Single( map, x_offset, y_offset, strike->bit_depth, |
- range->image_format, metrics, stream ); |
+ if ( p + 16 > p_limit ) |
+ goto NoBitmap; |
- case 8: /* compound format */ |
- if ( FT_STREAM_SKIP( 1L ) ) |
- { |
- error = SFNT_Err_Invalid_Stream_Skip; |
- goto Exit; |
- } |
- /* fallthrough */ |
+ image_size = FT_NEXT_ULONG( p ); |
- case 9: |
- break; |
+ if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) ) |
+ goto NoBitmap; |
- default: /* invalid image format */ |
- return SFNT_Err_Invalid_File_Format; |
- } |
+ num_glyphs = FT_NEXT_ULONG( p ); |
- /* All right, we have a compound format. First of all, read */ |
- /* the array of elements. */ |
- { |
- TT_SBit_Component components = NULL; |
- TT_SBit_Component comp; |
- FT_UShort num_components, count; |
+ /* overflow check for p + 2 * num_glyphs */ |
+ if ( num_glyphs > (FT_ULong)( ( p_limit - p ) >> 1 ) ) |
+ goto NoBitmap; |
+ for ( mm = 0; mm < num_glyphs; mm++ ) |
+ { |
+ FT_UInt gindex = FT_NEXT_USHORT( p ); |
- if ( FT_READ_USHORT( num_components ) || |
- FT_NEW_ARRAY( components, num_components ) ) |
- goto Exit; |
- count = num_components; |
+ if ( gindex == glyph_index ) |
+ break; |
+ } |
- if ( FT_FRAME_ENTER( 4L * num_components ) ) |
- goto Fail_Memory; |
+ if ( mm >= num_glyphs ) |
+ goto NoBitmap; |
- for ( comp = components; count > 0; count--, comp++ ) |
- { |
- comp->glyph_code = FT_GET_USHORT(); |
- comp->x_offset = FT_GET_CHAR(); |
- comp->y_offset = FT_GET_CHAR(); |
+ image_start = image_size * mm; |
+ image_end = image_start + image_size; |
} |
+ break; |
- FT_FRAME_EXIT(); |
+ default: |
+ goto NoBitmap; |
+ } |
- /* Now recursively load each element glyph */ |
- count = num_components; |
- comp = components; |
- for ( ; count > 0; count--, comp++ ) |
- { |
- TT_SBit_Range elem_range; |
- TT_SBit_MetricsRec elem_metrics; |
- FT_ULong elem_offset; |
+ if ( image_start > image_end ) |
+ goto NoBitmap; |
+ image_end -= image_start; |
+ image_start = image_offset + image_start; |
- /* find the range for this element */ |
- error = find_sbit_range( comp->glyph_code, |
- strike, |
- &elem_range, |
- &elem_offset ); |
- if ( error ) |
- goto Fail_Memory; |
- |
- /* now load the element, recursively */ |
- error = Load_SBit_Image( strike, |
- elem_range, |
- ebdt_pos, |
- elem_offset, |
- slot, |
- x_offset + comp->x_offset, |
- y_offset + comp->y_offset, |
- stream, |
- &elem_metrics, |
- depth + 1 ); |
- if ( error ) |
- goto Fail_Memory; |
- } |
+ FT_TRACE3(( "tt_sbit_decoder_load_image:" |
+ " found sbit (format %d) for glyph index %d\n", |
+ image_format, glyph_index )); |
- Fail_Memory: |
- FT_FREE( components ); |
- } |
+ return tt_sbit_decoder_load_bitmap( decoder, |
+ load_flags, |
+ image_format, |
+ image_start, |
+ image_end, |
+ x_pos, |
+ y_pos ); |
- Exit: |
- return error; |
+ Failure: |
+ return FT_THROW( Invalid_Table ); |
+ |
+ NoBitmap: |
+ FT_TRACE4(( "tt_sbit_decoder_load_image:" |
+ " no sbit found for glyph index %d\n", glyph_index )); |
+ |
+ return FT_THROW( Invalid_Argument ); |
} |
- /*************************************************************************/ |
- /* */ |
- /* <Function> */ |
- /* tt_face_load_sbit_image */ |
- /* */ |
- /* <Description> */ |
- /* Loads a given glyph sbit image from the font resource. This also */ |
- /* returns its metrics. */ |
- /* */ |
- /* <Input> */ |
- /* face :: The target face object. */ |
- /* */ |
- /* strike_index :: The current strike index. */ |
- /* */ |
- /* glyph_index :: The current glyph index. */ |
- /* */ |
- /* load_flags :: The glyph load flags (the code checks for the flag */ |
- /* FT_LOAD_CROP_BITMAP). */ |
- /* */ |
- /* stream :: The input stream. */ |
- /* */ |
- /* <Output> */ |
- /* map :: The target pixmap. */ |
- /* */ |
- /* metrics :: A big sbit metrics structure for the glyph image. */ |
- /* */ |
- /* <Return> */ |
- /* FreeType error code. 0 means success. Returns an error if no */ |
- /* glyph sbit exists for the index. */ |
- /* */ |
- /* <Note> */ |
- /* The `map.buffer' field is always freed before the glyph is loaded. */ |
- /* */ |
- FT_LOCAL_DEF( FT_Error ) |
+ FT_LOCAL( FT_Error ) |
tt_face_load_sbit_image( TT_Face face, |
FT_ULong strike_index, |
FT_UInt glyph_index, |
@@ -1450,59 +1151,27 @@ |
FT_Bitmap *map, |
TT_SBit_MetricsRec *metrics ) |
{ |
- FT_Error error; |
- FT_ULong ebdt_pos, glyph_offset; |
+ TT_SBitDecoderRec decoder[1]; |
+ FT_Error error; |
- TT_SBit_Strike strike; |
- TT_SBit_Range range; |
+ FT_UNUSED( load_flags ); |
+ FT_UNUSED( stream ); |
+ FT_UNUSED( map ); |
- /* Check whether there is a glyph sbit for the current index */ |
- error = tt_find_sbit_image( face, glyph_index, strike_index, |
- &range, &strike, &glyph_offset ); |
- if ( error ) |
- goto Exit; |
- |
- /* now, find the location of the `EBDT' table in */ |
- /* the font file */ |
- error = face->goto_table( face, TTAG_EBDT, stream, 0 ); |
- if ( error ) |
- error = face->goto_table( face, TTAG_bdat, stream, 0 ); |
- if ( error ) |
- goto Exit; |
- |
- ebdt_pos = FT_STREAM_POS(); |
- |
- error = Load_SBit_Image( strike, range, ebdt_pos, glyph_offset, |
- face->root.glyph, 0, 0, stream, metrics, 0 ); |
- if ( error ) |
- goto Exit; |
- |
- /* setup vertical metrics if needed */ |
- if ( strike->flags & 1 ) |
+ error = tt_sbit_decoder_init( decoder, face, strike_index, metrics ); |
+ if ( !error ) |
{ |
- /* in case of a horizontal strike only */ |
- FT_Int advance; |
- |
- |
- advance = strike->hori.ascender - strike->hori.descender; |
- |
- /* some heuristic values */ |
- |
- metrics->vertBearingX = (FT_Char)(-metrics->width / 2 ); |
- metrics->vertBearingY = (FT_Char)( ( advance - metrics->height ) / 2 ); |
- metrics->vertAdvance = (FT_Char)( advance * 12 / 10 ); |
+ error = tt_sbit_decoder_load_image( decoder, |
+ load_flags, |
+ glyph_index, |
+ 0, |
+ 0 ); |
+ tt_sbit_decoder_done( decoder ); |
} |
- /* Crop the bitmap now, unless specified otherwise */ |
- if ( load_flags & FT_LOAD_CROP_BITMAP ) |
- crop_bitmap( map, metrics ); |
- |
- Exit: |
return error; |
} |
-#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */ |
- |
-/* END */ |
+/* EOF */ |