Edit
kc3-lang/freetype/src/sfnt/ttsbit.c
Werner Lemberg
- src/sfnt/ttsbit.c
-
/**************************************************************************** * * ttsbit.c * * TrueType and OpenType embedded bitmap support (body). * * Copyright (C) 2005-2020 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 * this file you indicate that you have read the license and * understand and accept it fully. * */ #include <freetype/internal/ftdebug.h> #include <freetype/internal/ftstream.h> #include <freetype/tttags.h> #include <freetype/ftbitmap.h> #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS #include "ttsbit.h" #include "sferrors.h" #include "ttmtx.h" #include "pngshim.h" /************************************************************************** * * The macro FT_COMPONENT is used in trace mode. It is an implicit * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log * messages during execution. */ #undef FT_COMPONENT #define FT_COMPONENT ttsbit FT_LOCAL_DEF( FT_Error ) tt_face_load_sbit( TT_Face face, FT_Stream stream ) { FT_Error error; FT_ULong table_size; FT_ULong table_start; face->sbit_table = NULL; face->sbit_table_size = 0; face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE; face->sbit_num_strikes = 0; error = face->goto_table( face, TTAG_CBLC, stream, &table_size ); if ( !error ) face->sbit_table_type = TT_SBIT_TABLE_TYPE_CBLC; else { error = face->goto_table( face, TTAG_EBLC, stream, &table_size ); if ( error ) error = face->goto_table( face, TTAG_bloc, stream, &table_size ); if ( !error ) face->sbit_table_type = TT_SBIT_TABLE_TYPE_EBLC; } if ( error ) { error = face->goto_table( face, TTAG_sbix, stream, &table_size ); if ( !error ) face->sbit_table_type = TT_SBIT_TABLE_TYPE_SBIX; } if ( error ) goto Exit; if ( table_size < 8 ) { FT_ERROR(( "tt_face_load_sbit_strikes: table too short\n" )); error = FT_THROW( Invalid_File_Format ); goto Exit; } table_start = FT_STREAM_POS(); switch ( (FT_UInt)face->sbit_table_type ) { case TT_SBIT_TABLE_TYPE_EBLC: case TT_SBIT_TABLE_TYPE_CBLC: { FT_Byte* p; FT_Fixed version; FT_ULong num_strikes; FT_UInt count; if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) ) goto Exit; face->sbit_table_size = table_size; p = face->sbit_table; version = FT_NEXT_LONG( p ); num_strikes = FT_NEXT_ULONG( p ); /* there's at least one font (FZShuSong-Z01, version 3) */ /* that uses the wrong byte order for the `version' field */ if ( ( (FT_ULong)version & 0xFFFF0000UL ) != 0x00020000UL && ( (FT_ULong)version & 0x0000FFFFUL ) != 0x00000200UL && ( (FT_ULong)version & 0xFFFF0000UL ) != 0x00030000UL && ( (FT_ULong)version & 0x0000FFFFUL ) != 0x00000300UL ) { error = FT_THROW( Unknown_File_Format ); goto Exit; } if ( num_strikes >= 0x10000UL ) { error = FT_THROW( Invalid_File_Format ); goto Exit; } /* * 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)( ( table_size - 8 ) / 48 ); face->sbit_num_strikes = count; } break; case TT_SBIT_TABLE_TYPE_SBIX: { FT_UShort version; FT_UShort flags; FT_ULong num_strikes; FT_UInt count; if ( FT_FRAME_ENTER( 8 ) ) goto Exit; version = FT_GET_USHORT(); flags = FT_GET_USHORT(); num_strikes = FT_GET_ULONG(); FT_FRAME_EXIT(); if ( version < 1 ) { error = FT_THROW( Unknown_File_Format ); goto Exit; } /* Bit 0 must always be `1'. */ /* Bit 1 controls the overlay of bitmaps with outlines. */ /* All other bits should be zero. */ if ( !( flags == 1 || flags == 3 ) || num_strikes >= 0x10000UL ) { error = FT_THROW( Invalid_File_Format ); goto Exit; } /* we currently don't support bit 1; however, it is better to */ /* draw at least something... */ if ( flags == 3 ) FT_TRACE1(( "tt_face_load_sbit_strikes:" " sbix overlay not supported yet\n" " " " expect bad rendering results\n" )); /* * 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 + 4UL * count > table_size ) count = (FT_UInt)( ( table_size - 8 ) / 4 ); if ( FT_STREAM_SEEK( FT_STREAM_POS() - 8 ) ) goto Exit; face->sbit_table_size = 8 + count * 4; if ( FT_FRAME_EXTRACT( face->sbit_table_size, face->sbit_table ) ) goto Exit; face->sbit_num_strikes = count; } break; default: /* we ignore unknown table formats */ error = FT_THROW( Unknown_File_Format ); break; } if ( !error ) FT_TRACE3(( "tt_face_load_sbit_strikes: found %u strikes\n", face->sbit_num_strikes )); face->ebdt_start = 0; face->ebdt_size = 0; if ( face->sbit_table_type == TT_SBIT_TABLE_TYPE_SBIX ) { /* the `sbix' table is self-contained; */ /* it has no associated data table */ face->ebdt_start = table_start; face->ebdt_size = table_size; } else if ( face->sbit_table_type != TT_SBIT_TABLE_TYPE_NONE ) { FT_ULong ebdt_size; 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 ) { face->ebdt_start = FT_STREAM_POS(); face->ebdt_size = ebdt_size; } } if ( !face->ebdt_size ) { FT_TRACE2(( "tt_face_load_sbit_strikes:" " no embedded bitmap data table found;\n" " " " resetting number of strikes to zero\n" )); face->sbit_num_strikes = 0; } return FT_Err_Ok; Exit: if ( error ) { if ( face->sbit_table ) FT_FRAME_RELEASE( face->sbit_table ); face->sbit_table_size = 0; face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE; } return error; } FT_LOCAL_DEF( void ) tt_face_free_sbit( TT_Face face ) { FT_Stream stream = face->root.stream; FT_FRAME_RELEASE( face->sbit_table ); face->sbit_table_size = 0; face->sbit_table_type = TT_SBIT_TABLE_TYPE_NONE; face->sbit_num_strikes = 0; } 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 ); } FT_LOCAL_DEF( FT_Error ) tt_face_load_strike_metrics( TT_Face face, FT_ULong strike_index, FT_Size_Metrics* metrics ) { /* we have to test for the existence of `sbit_strike_map' */ /* because the function gets also used at the very beginning */ /* to construct `sbit_strike_map' itself */ if ( face->sbit_strike_map ) { if ( strike_index >= (FT_ULong)face->root.num_fixed_sizes ) return FT_THROW( Invalid_Argument ); /* map to real index */ strike_index = face->sbit_strike_map[strike_index]; } else { if ( strike_index >= (FT_ULong)face->sbit_num_strikes ) return FT_THROW( Invalid_Argument ); } switch ( (FT_UInt)face->sbit_table_type ) { case TT_SBIT_TABLE_TYPE_EBLC: case TT_SBIT_TABLE_TYPE_CBLC: { FT_Byte* strike; FT_Char max_before_bl; FT_Char min_after_bl; strike = face->sbit_table + 8 + strike_index * 48; metrics->x_ppem = (FT_UShort)strike[44]; metrics->y_ppem = (FT_UShort)strike[45]; metrics->ascender = (FT_Char)strike[16] * 64; /* hori.ascender */ metrics->descender = (FT_Char)strike[17] * 64; /* hori.descender */ /* Due to fuzzy wording in the EBLC documentation, we find both */ /* positive and negative values for `descender'. Additionally, */ /* many fonts have both `ascender' and `descender' set to zero */ /* (which is definitely wrong). MS Windows simply ignores all */ /* those values... For these reasons we apply some heuristics */ /* to get a reasonable, non-zero value for the height. */ max_before_bl = (FT_Char)strike[24]; min_after_bl = (FT_Char)strike[25]; if ( metrics->descender > 0 ) { /* compare sign of descender with `min_after_bl' */ if ( min_after_bl < 0 ) metrics->descender = -metrics->descender; } else if ( metrics->descender == 0 ) { if ( metrics->ascender == 0 ) { FT_TRACE2(( "tt_face_load_strike_metrics:" " sanitizing invalid ascender and descender\n" " " " values for strike %d (%dppem, %dppem)\n", strike_index, metrics->x_ppem, metrics->y_ppem )); /* sanitize buggy ascender and descender values */ if ( max_before_bl || min_after_bl ) { metrics->ascender = max_before_bl * 64; metrics->descender = min_after_bl * 64; } else { metrics->ascender = metrics->y_ppem * 64; metrics->descender = 0; } } } #if 0 else ; /* if we have a negative descender, simply use it */ #endif metrics->height = metrics->ascender - metrics->descender; if ( metrics->height == 0 ) { FT_TRACE2(( "tt_face_load_strike_metrics:" " sanitizing invalid height value\n" " " " for strike (%d, %d)\n", metrics->x_ppem, metrics->y_ppem )); metrics->height = metrics->y_ppem * 64; metrics->descender = metrics->ascender - metrics->height; } /* Is this correct? */ metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB */ strike[18] + /* max_width */ (FT_Char)strike[23] /* min_advance_SB */ ) * 64; /* set the scale values (in 16.16 units) so advances */ /* from the hmtx and vmtx table are scaled correctly */ metrics->x_scale = FT_MulDiv( metrics->x_ppem, 64 * 0x10000, face->header.Units_Per_EM ); metrics->y_scale = FT_MulDiv( metrics->y_ppem, 64 * 0x10000, face->header.Units_Per_EM ); return FT_Err_Ok; } case TT_SBIT_TABLE_TYPE_SBIX: { FT_Stream stream = face->root.stream; FT_UInt offset; FT_UShort upem, ppem, resolution; TT_HoriHeader *hori; FT_Pos ppem_; /* to reduce casts */ FT_Error error; FT_Byte* p; p = face->sbit_table + 8 + 4 * strike_index; offset = FT_NEXT_ULONG( p ); if ( offset + 4 > face->ebdt_size ) return FT_THROW( Invalid_File_Format ); if ( FT_STREAM_SEEK( face->ebdt_start + offset ) || FT_FRAME_ENTER( 4 ) ) return error; ppem = FT_GET_USHORT(); resolution = FT_GET_USHORT(); FT_UNUSED( resolution ); /* What to do with this? */ FT_FRAME_EXIT(); upem = face->header.Units_Per_EM; hori = &face->horizontal; metrics->x_ppem = ppem; metrics->y_ppem = ppem; ppem_ = (FT_Pos)ppem; metrics->ascender = FT_MulDiv( hori->Ascender, ppem_ * 64, upem ); metrics->descender = FT_MulDiv( hori->Descender, ppem_ * 64, upem ); metrics->height = FT_MulDiv( hori->Ascender - hori->Descender + hori->Line_Gap, ppem_ * 64, upem ); metrics->max_advance = FT_MulDiv( hori->advance_Width_Max, ppem_ * 64, upem ); /* set the scale values (in 16.16 units) so advances */ /* from the hmtx and vmtx table are scaled correctly */ metrics->x_scale = FT_MulDiv( metrics->x_ppem, 64 * 0x10000, face->header.Units_Per_EM ); metrics->y_scale = FT_MulDiv( metrics->y_ppem, 64 * 0x10000, face->header.Units_Per_EM ); return error; } default: return FT_THROW( Unknown_File_Format ); } } typedef struct TT_SBitDecoderRec_ { TT_Face face; FT_Stream stream; FT_Bitmap* bitmap; TT_SBit_Metrics metrics; FT_Bool metrics_loaded; FT_Bool bitmap_allocated; FT_Byte bit_depth; FT_ULong ebdt_start; FT_ULong ebdt_size; FT_ULong strike_index_array; FT_ULong strike_index_count; FT_Byte* eblc_base; FT_Byte* eblc_limit; } TT_SBitDecoderRec, *TT_SBitDecoder; static FT_Error tt_sbit_decoder_init( TT_SBitDecoder decoder, TT_Face face, FT_ULong strike_index, TT_SBit_MetricsRec* metrics ) { FT_Error error = FT_ERR( Table_Missing ); FT_Stream stream = face->root.stream; strike_index = face->sbit_strike_map[strike_index]; if ( !face->ebdt_size ) goto Exit; if ( FT_STREAM_SEEK( face->ebdt_start ) ) goto Exit; decoder->face = face; decoder->stream = stream; decoder->bitmap = &face->root.glyph->bitmap; decoder->metrics = metrics; decoder->metrics_loaded = 0; decoder->bitmap_allocated = 0; decoder->ebdt_start = face->ebdt_start; decoder->ebdt_size = face->ebdt_size; decoder->eblc_base = face->sbit_table; decoder->eblc_limit = face->sbit_table + face->sbit_table_size; /* now find the strike corresponding to the index */ { FT_Byte* p; 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; /* decoder->strike_index_array + */ /* 8 * decoder->strike_index_count > face->sbit_table_size ? */ if ( decoder->strike_index_array > face->sbit_table_size || decoder->strike_index_count > ( face->sbit_table_size - decoder->strike_index_array ) / 8 ) error = FT_THROW( Invalid_File_Format ); } Exit: return error; } static void tt_sbit_decoder_done( TT_SBitDecoder decoder ) { FT_UNUSED( decoder ); } static FT_Error tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder decoder, FT_Bool metrics_only ) { FT_Error error = FT_Err_Ok; FT_UInt width, height; FT_Bitmap* map = decoder->bitmap; FT_ULong size; if ( !decoder->metrics_loaded ) { error = FT_THROW( Invalid_Argument ); goto Exit; } width = decoder->metrics->width; height = decoder->metrics->height; map->width = width; map->rows = height; switch ( decoder->bit_depth ) { case 1: map->pixel_mode = FT_PIXEL_MODE_MONO; map->pitch = (int)( ( map->width + 7 ) >> 3 ); map->num_grays = 2; break; case 2: map->pixel_mode = FT_PIXEL_MODE_GRAY2; map->pitch = (int)( ( map->width + 3 ) >> 2 ); map->num_grays = 4; break; case 4: map->pixel_mode = FT_PIXEL_MODE_GRAY4; map->pitch = (int)( ( map->width + 1 ) >> 1 ); map->num_grays = 16; break; case 8: map->pixel_mode = FT_PIXEL_MODE_GRAY; map->pitch = (int)( map->width ); map->num_grays = 256; break; case 32: map->pixel_mode = FT_PIXEL_MODE_BGRA; map->pitch = (int)( map->width * 4 ); map->num_grays = 256; break; default: error = FT_THROW( Invalid_File_Format ); goto Exit; } size = map->rows * (FT_ULong)map->pitch; /* check that there is no empty image */ if ( size == 0 ) goto Exit; /* exit successfully! */ if ( metrics_only ) goto Exit; /* only metrics are requested */ error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size ); if ( error ) goto Exit; decoder->bitmap_allocated = 1; Exit: return error; } static FT_Error tt_sbit_decoder_load_metrics( TT_SBitDecoder decoder, FT_Byte* *pp, FT_Byte* limit, FT_Bool big ) { FT_Byte* p = *pp; TT_SBit_Metrics metrics = decoder->metrics; if ( p + 5 > limit ) goto Fail; metrics->height = p[0]; metrics->width = p[1]; metrics->horiBearingX = (FT_Char)p[2]; metrics->horiBearingY = (FT_Char)p[3]; metrics->horiAdvance = p[4]; p += 5; if ( big ) { if ( p + 3 > limit ) goto Fail; metrics->vertBearingX = (FT_Char)p[0]; metrics->vertBearingY = (FT_Char)p[1]; metrics->vertAdvance = p[2]; p += 3; } else { /* avoid uninitialized data in case there is no vertical info -- */ metrics->vertBearingX = 0; metrics->vertBearingY = 0; metrics->vertAdvance = 0; } decoder->metrics_loaded = 1; *pp = p; return FT_Err_Ok; Fail: FT_TRACE1(( "tt_sbit_decoder_load_metrics: broken table\n" )); return FT_THROW( Invalid_Argument ); } /* forward declaration */ static FT_Error tt_sbit_decoder_load_image( TT_SBitDecoder decoder, FT_UInt glyph_index, FT_Int x_pos, FT_Int y_pos, FT_UInt recurse_count, FT_Bool metrics_only ); typedef FT_Error (*TT_SBitDecoder_LoadFunc)( TT_SBitDecoder decoder, FT_Byte* p, FT_Byte* plimit, FT_Int x_pos, FT_Int y_pos, FT_UInt recurse_count ); static FT_Error tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder decoder, FT_Byte* p, FT_Byte* limit, FT_Int x_pos, FT_Int y_pos, FT_UInt recurse_count ) { FT_Error error = FT_Err_Ok; FT_Byte* line; FT_Int pitch, width, height, line_bits, h; FT_UInt bit_height, bit_width; FT_Bitmap* bitmap; FT_UNUSED( recurse_count ); /* 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; width = decoder->metrics->width; height = decoder->metrics->height; line_bits = width * decoder->bit_depth; if ( x_pos < 0 || (FT_UInt)( x_pos + width ) > bit_width || y_pos < 0 || (FT_UInt)( 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; } if ( p + ( ( line_bits + 7 ) >> 3 ) * height > limit ) { 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; if ( x_pos == 0 ) /* the easy one */ { for ( h = height; h > 0; h--, line += pitch ) { FT_Byte* pwrite = line; FT_Int w; for ( w = line_bits; w >= 8; w -= 8 ) { pwrite[0] = (FT_Byte)( pwrite[0] | *p++ ); pwrite += 1; } 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; for ( w = line_bits; w >= 8; w -= 8 ) { wval = (FT_UInt)( wval | *p++ ); pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); pwrite += 1; wval <<= 8; } if ( w > 0 ) wval = (FT_UInt)( wval | ( *p++ & ( 0xFF00U >> w ) ) ); /* all bits read and there are `x_pos + w' bits to be written */ pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); if ( x_pos + w > 8 ) { pwrite++; wval <<= 8; pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); } } } Exit: if ( !error ) FT_TRACE3(( "tt_sbit_decoder_load_byte_aligned: loaded\n" )); return error; } /* * 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_Byte* p, FT_Byte* limit, FT_Int x_pos, FT_Int y_pos, FT_UInt recurse_count ) { FT_Error error = FT_Err_Ok; FT_Byte* line; FT_Int pitch, width, height, line_bits, h, nbits; FT_UInt bit_height, bit_width; FT_Bitmap* bitmap; FT_UShort rval; FT_UNUSED( recurse_count ); /* 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; width = decoder->metrics->width; height = decoder->metrics->height; line_bits = width * decoder->bit_depth; if ( x_pos < 0 || (FT_UInt)( x_pos + width ) > bit_width || y_pos < 0 || (FT_UInt)( 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; } 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; } if ( !line_bits || !height ) { /* nothing to do */ goto Exit; } /* 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; /* 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; /* handle initial byte (in target bitmap) specially if necessary */ if ( x_pos ) { w = ( line_bits < 8 - x_pos ) ? line_bits : 8 - x_pos; 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; } *pwrite++ |= ( ( rval >> nbits ) & 0xFF ) & ( ~( 0xFFU << w ) << ( 8 - w - x_pos ) ); rval <<= 8; w = line_bits - w; } /* handle medial bytes */ for ( ; w >= 8; w -= 8 ) { rval |= *p++; *pwrite++ |= ( rval >> nbits ) & 0xFF; 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; } static FT_Error tt_sbit_decoder_load_compound( TT_SBitDecoder decoder, FT_Byte* p, FT_Byte* limit, FT_Int x_pos, FT_Int y_pos, FT_UInt recurse_count ) { FT_Error error = FT_Err_Ok; FT_UInt num_components, nn; FT_Char horiBearingX = (FT_Char)decoder->metrics->horiBearingX; FT_Char horiBearingY = (FT_Char)decoder->metrics->horiBearingY; FT_Byte horiAdvance = (FT_Byte)decoder->metrics->horiAdvance; FT_Char vertBearingX = (FT_Char)decoder->metrics->vertBearingX; FT_Char vertBearingY = (FT_Char)decoder->metrics->vertBearingY; FT_Byte vertAdvance = (FT_Byte)decoder->metrics->vertAdvance; if ( p + 2 > limit ) goto Fail; num_components = FT_NEXT_USHORT( p ); if ( p + 4 * num_components > limit ) { FT_TRACE1(( "tt_sbit_decoder_load_compound: broken table\n" )); goto Fail; } FT_TRACE3(( "tt_sbit_decoder_load_compound: loading %d component%s\n", num_components, num_components == 1 ? "" : "s" )); for ( nn = 0; nn < num_components; nn++ ) { FT_UInt gindex = FT_NEXT_USHORT( p ); FT_Char dx = FT_NEXT_CHAR( p ); FT_Char dy = FT_NEXT_CHAR( p ); /* NB: a recursive call */ error = tt_sbit_decoder_load_image( decoder, gindex, x_pos + dx, y_pos + dy, recurse_count + 1, /* request full bitmap image */ FALSE ); if ( error ) break; } FT_TRACE3(( "tt_sbit_decoder_load_compound: done\n" )); 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; Fail: error = FT_THROW( Invalid_File_Format ); goto Exit; } #ifdef FT_CONFIG_OPTION_USE_PNG static FT_Error tt_sbit_decoder_load_png( TT_SBitDecoder decoder, FT_Byte* p, FT_Byte* limit, FT_Int x_pos, FT_Int y_pos, FT_UInt recurse_count ) { FT_Error error = FT_Err_Ok; FT_ULong png_len; FT_UNUSED( recurse_count ); if ( limit - p < 4 ) { FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" )); error = FT_THROW( Invalid_File_Format ); goto Exit; } 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->face->root.glyph, x_pos, y_pos, decoder->bit_depth, decoder->metrics, decoder->stream->memory, p, png_len, FALSE, FALSE ); Exit: if ( !error ) FT_TRACE3(( "tt_sbit_decoder_load_png: loaded\n" )); return error; } #endif /* FT_CONFIG_OPTION_USE_PNG */ static FT_Error tt_sbit_decoder_load_bitmap( TT_SBitDecoder decoder, FT_UInt glyph_format, FT_ULong glyph_start, FT_ULong glyph_size, FT_Int x_pos, FT_Int y_pos, FT_UInt recurse_count, FT_Bool metrics_only ) { FT_Error error; FT_Stream stream = decoder->stream; FT_Byte* p; FT_Byte* p_limit; FT_Byte* data; /* seek into the EBDT table now */ if ( !glyph_size || 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: case 17: error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 ); break; case 6: case 7: case 9: case 18: error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ); break; default: error = FT_Err_Ok; } if ( error ) goto Fail; { TT_SBitDecoder_LoadFunc loader; switch ( glyph_format ) { case 1: case 6: loader = tt_sbit_decoder_load_byte_aligned; break; case 2: case 7: { /* Don't trust `glyph_format'. For example, Apple's main Korean */ /* system font, `AppleMyungJo.ttf' (version 7.0d2e6), uses glyph */ /* format 7, but the data is format 6. We check whether we have */ /* an excessive number of bytes in the image: If it is equal to */ /* the value for a byte-aligned glyph, use the other loading */ /* routine. */ /* */ /* Note that for some (width,height) combinations, where the */ /* width is not a multiple of 8, the sizes for bit- and */ /* byte-aligned data are equal, for example (7,7) or (15,6). We */ /* then prefer what `glyph_format' specifies. */ FT_UInt width = decoder->metrics->width; FT_UInt height = decoder->metrics->height; FT_UInt bit_size = ( width * height + 7 ) >> 3; FT_UInt byte_size = height * ( ( width + 7 ) >> 3 ); if ( bit_size < byte_size && byte_size == (FT_UInt)( p_limit - p ) ) loader = tt_sbit_decoder_load_byte_aligned; else loader = tt_sbit_decoder_load_bit_aligned; } break; case 5: loader = tt_sbit_decoder_load_bit_aligned; break; case 8: if ( p + 1 > p_limit ) goto Fail; p += 1; /* skip padding */ /* fall-through */ case 9: loader = tt_sbit_decoder_load_compound; break; case 17: /* small metrics, PNG image data */ case 18: /* big metrics, PNG image data */ case 19: /* metrics in EBLC, PNG image data */ #ifdef FT_CONFIG_OPTION_USE_PNG loader = tt_sbit_decoder_load_png; break; #else error = FT_THROW( Unimplemented_Feature ); goto Fail; #endif /* FT_CONFIG_OPTION_USE_PNG */ default: error = FT_THROW( Invalid_Table ); goto Fail; } if ( !decoder->bitmap_allocated ) { error = tt_sbit_decoder_alloc_bitmap( decoder, metrics_only ); if ( error ) goto Fail; } if ( metrics_only ) goto Fail; /* this is not an error */ error = loader( decoder, p, p_limit, x_pos, y_pos, recurse_count ); } Fail: FT_FRAME_RELEASE( data ); Exit: return error; } static FT_Error tt_sbit_decoder_load_image( TT_SBitDecoder decoder, FT_UInt glyph_index, FT_Int x_pos, FT_Int y_pos, FT_UInt recurse_count, FT_Bool metrics_only ) { 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; /* arbitrary recursion limit */ if ( recurse_count > 100 ) { FT_TRACE4(( "tt_sbit_decoder_load_image:" " recursion depth exceeded\n" )); goto Failure; } /* First, we find the correct strike range that applies to this */ /* glyph index. */ for ( ; num_ranges > 0; num_ranges-- ) { start = FT_NEXT_USHORT( p ); end = FT_NEXT_USHORT( p ); if ( glyph_index >= start && glyph_index <= end ) goto FoundRange; p += 4; /* ignore index offset */ } goto NoBitmap; FoundRange: 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; 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 ( index_format ) { case 1: /* 4-byte offsets relative to `image_offset' */ p += 4 * ( glyph_index - start ); if ( p + 8 > p_limit ) goto NoBitmap; image_start = FT_NEXT_ULONG( p ); image_end = FT_NEXT_ULONG( p ); if ( image_start == image_end ) /* missing glyph */ goto NoBitmap; break; case 2: /* big metrics, constant image size */ { FT_ULong image_size; if ( p + 12 > p_limit ) goto NoBitmap; image_size = FT_NEXT_ULONG( p ); if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) ) goto NoBitmap; image_start = image_size * ( glyph_index - start ); image_end = image_start + image_size; } break; case 3: /* 2-byte offsets relative to 'image_offset' */ p += 2 * ( glyph_index - start ); if ( p + 4 > p_limit ) goto NoBitmap; image_start = FT_NEXT_USHORT( p ); image_end = FT_NEXT_USHORT( p ); if ( image_start == image_end ) /* missing glyph */ goto NoBitmap; break; case 4: /* sparse glyph array with (glyph,offset) pairs */ { FT_ULong mm, num_glyphs; if ( p + 4 > p_limit ) goto NoBitmap; num_glyphs = FT_NEXT_ULONG( p ); /* overflow check for p + ( num_glyphs + 1 ) * 4 */ if ( p + 4 > p_limit || num_glyphs > (FT_ULong)( ( ( p_limit - p ) >> 2 ) - 1 ) ) goto NoBitmap; for ( mm = 0; mm < num_glyphs; mm++ ) { FT_UInt gindex = FT_NEXT_USHORT( p ); if ( gindex == glyph_index ) { image_start = FT_NEXT_USHORT( p ); p += 2; image_end = FT_PEEK_USHORT( p ); break; } p += 2; } if ( mm >= num_glyphs ) goto NoBitmap; } break; case 5: /* constant metrics with sparse glyph codes */ case 19: { FT_ULong image_size, mm, num_glyphs; if ( p + 16 > p_limit ) goto NoBitmap; image_size = FT_NEXT_ULONG( p ); if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) ) goto NoBitmap; num_glyphs = FT_NEXT_ULONG( p ); /* 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 ( gindex == glyph_index ) break; } if ( mm >= num_glyphs ) goto NoBitmap; image_start = image_size * mm; image_end = image_start + image_size; } break; default: goto NoBitmap; } if ( image_start > image_end ) goto NoBitmap; image_end -= image_start; image_start = image_offset + image_start; FT_TRACE3(( "tt_sbit_decoder_load_image:" " found sbit (format %d) for glyph index %d\n", image_format, glyph_index )); return tt_sbit_decoder_load_bitmap( decoder, image_format, image_start, image_end, x_pos, y_pos, recurse_count, metrics_only ); Failure: return FT_THROW( Invalid_Table ); NoBitmap: if ( recurse_count ) { FT_TRACE4(( "tt_sbit_decoder_load_image:" " missing subglyph sbit with glyph index %d\n", glyph_index )); return FT_THROW( Invalid_Composite ); } FT_TRACE4(( "tt_sbit_decoder_load_image:" " no sbit found for glyph index %d\n", glyph_index )); return FT_THROW( Missing_Bitmap ); } static FT_Error tt_face_load_sbix_image( TT_Face face, FT_ULong strike_index, FT_UInt glyph_index, FT_Stream stream, FT_Bitmap *map, TT_SBit_MetricsRec *metrics, FT_Bool metrics_only ) { FT_UInt strike_offset, glyph_start, glyph_end; FT_Int originOffsetX, originOffsetY; FT_Tag graphicType; FT_Int recurse_depth = 0; FT_Error error; FT_Byte* p; FT_UNUSED( map ); #ifndef FT_CONFIG_OPTION_USE_PNG FT_UNUSED( metrics_only ); #endif strike_index = face->sbit_strike_map[strike_index]; metrics->width = 0; metrics->height = 0; p = face->sbit_table + 8 + 4 * strike_index; strike_offset = FT_NEXT_ULONG( p ); retry: if ( glyph_index > (FT_UInt)face->root.num_glyphs ) return FT_THROW( Invalid_Argument ); if ( strike_offset >= face->ebdt_size || face->ebdt_size - strike_offset < 4 + glyph_index * 4 + 8 ) return FT_THROW( Invalid_File_Format ); if ( FT_STREAM_SEEK( face->ebdt_start + strike_offset + 4 + glyph_index * 4 ) || FT_FRAME_ENTER( 8 ) ) return error; glyph_start = FT_GET_ULONG(); glyph_end = FT_GET_ULONG(); FT_FRAME_EXIT(); if ( glyph_start == glyph_end ) return FT_THROW( Missing_Bitmap ); if ( glyph_start > glyph_end || glyph_end - glyph_start < 8 || face->ebdt_size - strike_offset < glyph_end ) return FT_THROW( Invalid_File_Format ); if ( FT_STREAM_SEEK( face->ebdt_start + strike_offset + glyph_start ) || FT_FRAME_ENTER( glyph_end - glyph_start ) ) return error; originOffsetX = FT_GET_SHORT(); originOffsetY = FT_GET_SHORT(); graphicType = FT_GET_TAG4(); switch ( graphicType ) { case FT_MAKE_TAG( 'd', 'u', 'p', 'e' ): if ( recurse_depth < 4 ) { glyph_index = FT_GET_USHORT(); FT_FRAME_EXIT(); recurse_depth++; goto retry; } error = FT_THROW( Invalid_File_Format ); break; case FT_MAKE_TAG( 'p', 'n', 'g', ' ' ): #ifdef FT_CONFIG_OPTION_USE_PNG error = Load_SBit_Png( face->root.glyph, 0, 0, 32, metrics, stream->memory, stream->cursor, glyph_end - glyph_start - 8, TRUE, metrics_only ); #else error = FT_THROW( Unimplemented_Feature ); #endif break; case FT_MAKE_TAG( 'j', 'p', 'g', ' ' ): case FT_MAKE_TAG( 't', 'i', 'f', 'f' ): case FT_MAKE_TAG( 'r', 'g', 'b', 'l' ): /* used on iOS 7.1 */ error = FT_THROW( Unknown_File_Format ); break; default: error = FT_THROW( Unimplemented_Feature ); break; } FT_FRAME_EXIT(); if ( !error ) { FT_Short abearing; FT_UShort aadvance; tt_face_get_metrics( face, FALSE, glyph_index, &abearing, &aadvance ); metrics->horiBearingX = (FT_Short)originOffsetX; metrics->horiBearingY = (FT_Short)( -originOffsetY + metrics->height ); metrics->horiAdvance = (FT_UShort)( aadvance * face->root.size->metrics.x_ppem / face->header.Units_Per_EM ); } return error; } FT_LOCAL( FT_Error ) tt_face_load_sbit_image( TT_Face face, FT_ULong strike_index, FT_UInt glyph_index, FT_UInt load_flags, FT_Stream stream, FT_Bitmap *map, TT_SBit_MetricsRec *metrics ) { FT_Error error = FT_Err_Ok; switch ( (FT_UInt)face->sbit_table_type ) { case TT_SBIT_TABLE_TYPE_EBLC: case TT_SBIT_TABLE_TYPE_CBLC: { TT_SBitDecoderRec decoder[1]; error = tt_sbit_decoder_init( decoder, face, strike_index, metrics ); if ( !error ) { error = tt_sbit_decoder_load_image( decoder, glyph_index, 0, 0, 0, ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) != 0 ); tt_sbit_decoder_done( decoder ); } } break; case TT_SBIT_TABLE_TYPE_SBIX: error = tt_face_load_sbix_image( face, strike_index, glyph_index, stream, map, metrics, ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) != 0 ); break; default: error = FT_THROW( Unknown_File_Format ); break; } /* Flatten color bitmaps if color was not requested. */ if ( !error && !( load_flags & FT_LOAD_COLOR ) && !( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) && map->pixel_mode == FT_PIXEL_MODE_BGRA ) { FT_Bitmap new_map; FT_Library library = face->root.glyph->library; FT_Bitmap_Init( &new_map ); /* Convert to 8bit grayscale. */ error = FT_Bitmap_Convert( library, map, &new_map, 1 ); if ( error ) FT_Bitmap_Done( library, &new_map ); else { map->pixel_mode = new_map.pixel_mode; map->pitch = new_map.pitch; map->num_grays = new_map.num_grays; ft_glyphslot_set_bitmap( face->root.glyph, new_map.buffer ); face->root.glyph->internal->flags |= FT_GLYPH_OWN_BITMAP; } } return error; } #else /* !TT_CONFIG_OPTION_EMBEDDED_BITMAPS */ /* ANSI C doesn't like empty source files */ typedef int _tt_sbit_dummy; #endif /* !TT_CONFIG_OPTION_EMBEDDED_BITMAPS */ /* END */