ref: 94204895db9f059f089299bebe230ab0a1b7aaa9
dir: /src/sfnt/ttsbit0.c/
/***************************************************************************/
/* */
/* ttsbit0.c */
/* */
/* TrueType and OpenType embedded bitmap support (body). */
/* This is a heap-optimized version. */
/* */
/* Copyright 2005, 2006 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include <ft2build.h>
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_STREAM_H
#include FT_TRUETYPE_TAGS_H
#include "ttsbit.h"
#include "sferrors.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 trace_ttsbit
static const FT_Frame_Field tt_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 tt_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 tt_strike_end_fields[] =
{
/* 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
};
FT_LOCAL_DEF( FT_Error )
tt_face_load_eblc( TT_Face face,
FT_Stream stream )
{
FT_Error error = SFNT_Err_Ok;
FT_Fixed version;
FT_ULong num_strikes, table_size;
FT_Byte* p;
FT_Byte* p_limit;
FT_UInt count;
face->sbit_num_strikes = 0;
/* this table is optional */
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;
if ( table_size < 8 )
{
FT_ERROR(( "%s: table too short!\n", "tt_face_load_sbit_strikes" ));
error = SFNT_Err_Invalid_File_Format;
goto Exit;
}
if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) )
goto Exit;
face->sbit_table_size = table_size;
p = face->sbit_table;
p_limit = p + table_size;
version = FT_NEXT_ULONG( p );
num_strikes = FT_NEXT_ULONG( p );
if ( version != 0x00020000UL || num_strikes >= 0x10000UL )
{
FT_ERROR(( "%s: invalid table version!\n",
"tt_face_load_sbit_strikes" ));
error = SFNT_Err_Invalid_File_Format;
goto Fail;
}
/*
* 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 );
face->sbit_num_strikes = count;
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;
}
FT_LOCAL_DEF( void )
tt_face_free_eblc( TT_Face face )
{
FT_Stream stream = face->root.stream;
FT_FRAME_RELEASE( face->sbit_table );
face->sbit_table_size = 0;
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 )
{
FT_Byte* strike;
if ( strike_index >= (FT_ULong)face->sbit_num_strikes )
return SFNT_Err_Invalid_Argument;
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] << 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 SFNT_Err_Ok;
}
typedef struct
{
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_Stream stream = face->root.stream;
FT_ULong ebdt_size;
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;
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 = FT_STREAM_POS();
decoder->ebdt_size = 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 = 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;
}
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_Error error = SFNT_Err_Ok;
FT_UInt width, height;
FT_Bitmap* map = decoder->bitmap;
FT_Long size;
if ( !decoder->metrics_loaded )
{
error = SFNT_Err_Invalid_Argument;
goto Exit;
}
width = decoder->metrics->width;
height = decoder->metrics->height;
map->width = (int)width;
map->rows = (int)height;
switch ( decoder->bit_depth )
{
case 1:
map->pixel_mode = FT_PIXEL_MODE_MONO;
map->pitch = ( map->width + 7 ) >> 3;
break;
case 2:
map->pixel_mode = FT_PIXEL_MODE_GRAY2;
map->pitch = ( map->width + 3 ) >> 2;
break;
case 4:
map->pixel_mode = FT_PIXEL_MODE_GRAY4;
map->pitch = ( map->width + 1 ) >> 1;
break;
case 8:
map->pixel_mode = FT_PIXEL_MODE_GRAY;
map->pitch = map->width;
break;
default:
error = SFNT_Err_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;
}
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;
if ( !decoder->metrics_loaded )
{
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;
if ( !decoder->metrics_loaded )
{
metrics->vertBearingX = (FT_Char)p[0];
metrics->vertBearingY = (FT_Char)p[1];
metrics->vertAdvance = p[2];
}
p += 3;
}
decoder->metrics_loaded = 1;
*pp = p;
return 0;
Fail:
return SFNT_Err_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 );
typedef FT_Error (*TT_SBitDecoder_LoadFunc)( TT_SBitDecoder decoder,
FT_Byte* p,
FT_Byte* plimit,
FT_Int x_pos,
FT_Int y_pos );
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_Error error = SFNT_Err_Ok;
FT_Byte* line;
FT_Int bit_height, bit_width, pitch, width, height, h;
FT_Bitmap* bitmap;
if ( !decoder->bitmap_allocated )
{
error = tt_sbit_decoder_alloc_bitmap( decoder );
if ( error )
goto Exit;
}
/* 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;
if ( x_pos < 0 || x_pos + width > bit_width ||
y_pos < 0 || y_pos + height > bit_height )
{
error = SFNT_Err_Invalid_File_Format;
goto Exit;
}
if ( p + ( ( width + 7 ) >> 3 ) * height > limit )
{
error = SFNT_Err_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* write = line;
FT_Int w;
for ( w = width; w >= 8; w -= 8 )
{
write[0] = (FT_Byte)( write[0] | *p++ );
write += 1;
}
if ( w > 0 )
write[0] = (FT_Byte)( write[0] | ( *p++ & ( 0xFF00U >> w ) ) );
}
}
else /* x_pos > 0 */
{
for ( h = height; h > 0; h--, line += pitch )
{
FT_Byte* write = line;
FT_Int w;
FT_UInt wval = 0;
for ( w = width; w >= 8; w -= 8 )
{
wval = (FT_UInt)( wval | *p++ );
write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) );
write += 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 */
write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) );
if ( x_pos + w > 8 )
{
write++;
wval <<= 8;
write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) );
}
}
}
Exit:
return error;
}
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_Error error = SFNT_Err_Ok;
FT_Byte* line;
FT_Int bit_height, bit_width, pitch, width, height, h, nbits;
FT_Bitmap* bitmap;
FT_UShort rval;
if ( !decoder->bitmap_allocated )
{
error = tt_sbit_decoder_alloc_bitmap( decoder );
if ( error )
goto Exit;
}
/* 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;
if ( x_pos < 0 || x_pos + width > bit_width ||
y_pos < 0 || y_pos + height > bit_height )
{
error = SFNT_Err_Invalid_File_Format;
goto Exit;
}
if ( p + ( ( width * height + 7 ) >> 3 ) > limit )
{
error = SFNT_Err_Invalid_File_Format;
goto Exit;
}
/* now do the blit */
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* write = line;
FT_Int w = width;
if ( x_pos )
{
w = ( width < 8 - x_pos ) ? width : 8 - x_pos;
if ( nbits < w )
{
rval |= *p++;
nbits += 8 - w;
}
else
{
rval >>= 8;
nbits -= w;
}
*write++ |= ( ( rval >> nbits ) & 0xFF ) & ~( 0xFF << w );
rval <<= 8;
w = width - w;
}
for ( ; w >= 8; w -= 8 )
{
rval |= *p++;
*write++ |= ( rval >> nbits ) & 0xFF;
rval <<= 8;
}
if ( w > 0 )
{
if ( nbits < w )
{
rval |= *p++;
*write |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
nbits += 8 - w;
rval <<= 8;
}
else
{
*write |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
nbits -= w;
}
}
}
Exit:
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_Error error = SFNT_Err_Ok;
FT_UInt num_components, nn;
if ( p + 2 > limit )
goto Fail;
num_components = FT_NEXT_USHORT( p );
if ( p + 4 * num_components > limit )
goto Fail;
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 );
/* NB: a recursive call */
error = tt_sbit_decoder_load_image( decoder, gindex,
x_pos + dx, y_pos + dy );
if ( error )
break;
}
Exit:
return error;
Fail:
error = SFNT_Err_Invalid_File_Format;
goto Exit;
}
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_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_start + glyph_size > decoder->ebdt_size )
{
error = SFNT_Err_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:
error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 );
break;
case 6:
case 7:
case 9:
error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 );
break;
default:
error = SFNT_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 5:
case 7:
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;
default:
goto Fail;
}
error = loader( decoder, p, p_limit, x_pos, y_pos );
}
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 )
{
/*
* 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;
if ( p + 8 * num_ranges > p_limit )
goto NoBitmap;
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 );
p = decoder->eblc_base + decoder->strike_index_array + 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 );
if ( p + ( num_glyphs + 1 ) * 4 > p_limit )
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 */
{
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 );
if ( p + 2 * num_glyphs > p_limit )
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;
return tt_sbit_decoder_load_bitmap( decoder,
image_format,
image_start,
image_end,
x_pos,
y_pos );
NoBitmap:
return SFNT_Err_Invalid_Argument;
}
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 )
{
TT_SBitDecoderRec decoder[1];
FT_Error error;
FT_UNUSED( load_flags );
FT_UNUSED( stream );
FT_UNUSED( map );
error = tt_sbit_decoder_init( decoder, face, strike_index, metrics );
if ( !error )
{
error = tt_sbit_decoder_load_image( decoder, glyph_index, 0, 0 );
tt_sbit_decoder_done( decoder );
}
return error;
}
/* EOF */