* src/base/ftdbgmem.c (FT_DumpMemory): added sorting of memory sources
according to decreasing maximum cumulative allocations. * include/freetype/internal/tttypes.h, src/sfnt/ttsbit.c, src/sfnt/ttsbit0.c, src/truetype/ttobjs.c, src/cff/cffobjs.c, src/sfnt/sfobjs.c: implementing new heap-optimized embedded bitmap loader. This one also fixes bug #12107 * src/sfnt/sfobjs.c: fixed bug that prevented loading SFNT fonts without a 'kern' table.
This commit is contained in:
parent
2fdb498317
commit
0037369ccb
@ -1263,8 +1263,14 @@ FT_BEGIN_HEADER
|
||||
TT_PCLT pclt;
|
||||
|
||||
/* embedded bitmaps support */
|
||||
#ifdef FT_OPTIMIZE_MEMORY
|
||||
FT_Byte* sbit_table;
|
||||
FT_ULong sbit_table_size;
|
||||
FT_UInt sbit_num_strikes;
|
||||
#else
|
||||
FT_ULong num_sbit_strikes;
|
||||
TT_SBit_Strike sbit_strikes;
|
||||
#endif
|
||||
|
||||
FT_ULong num_sbit_scales;
|
||||
TT_SBit_Scale sbit_scales;
|
||||
|
@ -86,12 +86,12 @@ FT_BEGIN_HEADER
|
||||
{
|
||||
AF_Flags flags; /* point flags used by hinter */
|
||||
FT_Pos ox, oy; /* original, scaled position */
|
||||
FT_Pos fx, fy; /* original, unscaled position (font units) */
|
||||
FT_Short fx, fy; /* original, unscaled position (font units) */
|
||||
FT_Pos x, y; /* current position */
|
||||
FT_Pos u, v; /* current (x,y) or (y,x) depending on context */
|
||||
|
||||
AF_Direction in_dir; /* direction of inwards vector */
|
||||
AF_Direction out_dir; /* direction of outwards vector */
|
||||
FT_Char in_dir; /* direction of inwards vector */
|
||||
FT_Char out_dir; /* direction of outwards vector */
|
||||
|
||||
AF_Point next; /* next point in contour */
|
||||
AF_Point prev; /* previous point in contour */
|
||||
@ -102,10 +102,10 @@ FT_BEGIN_HEADER
|
||||
typedef struct AF_SegmentRec_
|
||||
{
|
||||
AF_Edge_Flags flags; /* edge/segment flags for this segment */
|
||||
AF_Direction dir; /* segment direction */
|
||||
FT_Pos pos; /* position of segment */
|
||||
FT_Pos min_coord; /* minimum coordinate of segment */
|
||||
FT_Pos max_coord; /* maximum coordinate of segment */
|
||||
FT_Char dir; /* segment direction */
|
||||
FT_Short pos; /* position of segment */
|
||||
FT_Short min_coord; /* minimum coordinate of segment */
|
||||
FT_Short max_coord; /* maximum coordinate of segment */
|
||||
|
||||
AF_Edge edge; /* the segment's parent edge */
|
||||
AF_Segment edge_next; /* link to next segment in parent edge */
|
||||
@ -124,18 +124,18 @@ FT_BEGIN_HEADER
|
||||
|
||||
typedef struct AF_EdgeRec_
|
||||
{
|
||||
FT_Pos fpos; /* original, unscaled position (font units) */
|
||||
FT_Short fpos; /* original, unscaled position (font units) */
|
||||
FT_Pos opos; /* original, scaled position */
|
||||
FT_Pos pos; /* current position */
|
||||
|
||||
AF_Edge_Flags flags; /* edge flags */
|
||||
AF_Direction dir; /* edge direction */
|
||||
FT_Byte flags; /* edge flags */
|
||||
FT_Char dir; /* edge direction */
|
||||
FT_Fixed scale; /* used to speed up interpolation between edges */
|
||||
AF_Width blue_edge; /* non-NULL if this is a blue edge */
|
||||
|
||||
AF_Edge link;
|
||||
AF_Edge serif;
|
||||
FT_Int num_linked;
|
||||
FT_Short num_linked;
|
||||
|
||||
FT_Int score;
|
||||
|
||||
@ -179,7 +179,7 @@ FT_BEGIN_HEADER
|
||||
AF_Point* contours;
|
||||
|
||||
AF_AxisHintsRec axis[ AF_DIMENSION_MAX ];
|
||||
|
||||
|
||||
FT_UInt32 scaler_flags; /* copy of scaler flags */
|
||||
FT_UInt32 other_flags; /* free for script-specific implementations */
|
||||
AF_ScriptMetrics metrics;
|
||||
|
@ -54,6 +54,8 @@
|
||||
FT_LOCAL_DEF( void )
|
||||
af_loader_done( AF_Loader loader )
|
||||
{
|
||||
af_glyph_hints_done( &loader->hints );
|
||||
|
||||
loader->face = NULL;
|
||||
loader->globals = NULL;
|
||||
|
||||
|
@ -921,6 +921,22 @@
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
ft_mem_source_compare( const void* p1,
|
||||
const void* p2 )
|
||||
{
|
||||
FT_MemSource s1 = *(FT_MemSource*)p1;
|
||||
FT_MemSource s2 = *(FT_MemSource*)p2;
|
||||
|
||||
if ( s2->max_size > s1->max_size )
|
||||
return 1;
|
||||
else if ( s2->max_size < s1->max_size )
|
||||
return -1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
extern void
|
||||
FT_DumpMemory( FT_Memory memory )
|
||||
{
|
||||
@ -931,8 +947,32 @@
|
||||
{
|
||||
FT_MemSource* bucket = table->sources;
|
||||
FT_MemSource* limit = bucket + FT_MEM_SOURCE_BUCKETS;
|
||||
FT_MemSource* sources;
|
||||
FT_UInt nn, count;
|
||||
const char* fmt;
|
||||
|
||||
count = 0;
|
||||
for ( ; bucket < limit; bucket++ )
|
||||
{
|
||||
FT_MemSource source = *bucket;
|
||||
|
||||
for ( ; source; source = source->link )
|
||||
count++;
|
||||
}
|
||||
|
||||
sources = ft_mem_table_alloc( table, sizeof(*sources) * count );
|
||||
|
||||
count = 0;
|
||||
for ( bucket = table->sources; bucket < limit; bucket++ )
|
||||
{
|
||||
FT_MemSource source = *bucket;
|
||||
|
||||
for ( ; source; source = source->link )
|
||||
sources[count++] = source;
|
||||
}
|
||||
|
||||
ft_qsort( sources, count, sizeof(*sources), ft_mem_source_compare );
|
||||
|
||||
printf( "FreeType Memory Dump: current=%ld max=%ld total=%ld count=%ld\n",
|
||||
table->alloc_current, table->alloc_max, table->alloc_total, table->alloc_count );
|
||||
printf( " block block sizes sizes sizes source\n" );
|
||||
@ -940,20 +980,19 @@
|
||||
printf( "-------------------------------------------------\n" );
|
||||
fmt = "%6ld %6ld %8ld %8ld %8ld %s:%d\n";
|
||||
|
||||
for ( ; bucket < limit; bucket++ )
|
||||
for ( nn = 0; nn < count; nn++ )
|
||||
{
|
||||
FT_MemSource source = *bucket;
|
||||
FT_MemSource source = sources[nn];
|
||||
|
||||
for ( ; source; source = source->link )
|
||||
{
|
||||
printf( fmt,
|
||||
source->cur_blocks, source->max_blocks,
|
||||
source->cur_size, source->max_size, source->cur_max,
|
||||
FT_FILENAME( source->file_name ),
|
||||
source->line_no );
|
||||
}
|
||||
printf( fmt,
|
||||
source->cur_blocks, source->max_blocks,
|
||||
source->cur_size, source->max_size, source->cur_max,
|
||||
FT_FILENAME( source->file_name ),
|
||||
source->line_no );
|
||||
}
|
||||
printf( "------------------------------------------------\n" );
|
||||
|
||||
ft_mem_table_free( table, sources );
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -74,30 +74,45 @@
|
||||
sbit_metrics = &size->strike_metrics;
|
||||
|
||||
error = sfnt->set_sbit_strike( face,
|
||||
metrics->x_ppem, metrics->y_ppem,
|
||||
metrics->x_ppem,
|
||||
metrics->y_ppem,
|
||||
&strike_index );
|
||||
|
||||
if ( !error )
|
||||
{
|
||||
/* XXX: TODO: move this code to the SFNT module where it belongs */
|
||||
#ifdef FT_OPTIMIZE_MEMORY
|
||||
FT_Byte* strike = face->sbit_table + 8 + strike_index*48;
|
||||
|
||||
sbit_metrics->ascender = (FT_Char)strike[16] << 6; /* hori.ascender */
|
||||
sbit_metrics->descender = (FT_Char)strike[17] << 6; /* hori.descender */
|
||||
|
||||
/* XXX: Is this correct? */
|
||||
sbit_metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB */
|
||||
strike[18] + /* max_width */
|
||||
(FT_Char)strike[23] /* min_advance_SB */
|
||||
) << 6;
|
||||
|
||||
#else /* !OPTIMIZE_MEMORY */
|
||||
TT_SBit_Strike strike = face->sbit_strikes + strike_index;
|
||||
|
||||
|
||||
sbit_metrics->x_ppem = metrics->x_ppem;
|
||||
sbit_metrics->y_ppem = metrics->y_ppem;
|
||||
|
||||
sbit_metrics->ascender = strike->hori.ascender << 6;
|
||||
sbit_metrics->descender = strike->hori.descender << 6;
|
||||
|
||||
/* XXX: Is this correct? */
|
||||
sbit_metrics->height = sbit_metrics->ascender -
|
||||
sbit_metrics->descender;
|
||||
|
||||
/* XXX: Is this correct? */
|
||||
sbit_metrics->max_advance = ( strike->hori.min_origin_SB +
|
||||
strike->hori.max_width +
|
||||
strike->hori.min_advance_SB ) << 6;
|
||||
#endif /* !OPTIMIZE_MEMORY */
|
||||
|
||||
size->strike_index = (FT_UInt)strike_index;
|
||||
/* XXX: Is this correct? */
|
||||
sbit_metrics->height = sbit_metrics->ascender -
|
||||
sbit_metrics->descender;
|
||||
|
||||
sbit_metrics->x_ppem = metrics->x_ppem;
|
||||
sbit_metrics->y_ppem = metrics->y_ppem;
|
||||
size->strike_index = (FT_UInt)strike_index;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -366,8 +366,8 @@
|
||||
/* see `ttsbit.h' and `sfnt.h' */
|
||||
tt_face_set_sbit_strike,
|
||||
tt_face_load_sbit_strikes,
|
||||
tt_find_sbit_image,
|
||||
tt_load_sbit_metrics,
|
||||
NULL /* tt_find_sbit_image */,
|
||||
NULL /* tt_load_sbit_metrics */,
|
||||
tt_face_load_sbit_image,
|
||||
tt_face_free_sbit_strikes,
|
||||
|
||||
@ -376,8 +376,8 @@
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
|
||||
|
@ -511,6 +511,8 @@
|
||||
(void)LOAD_( gasp );
|
||||
(void)LOAD_( kerning );
|
||||
|
||||
error = 0;
|
||||
|
||||
face->root.family_name = tt_face_get_name( face,
|
||||
TT_NAME_ID_PREFERRED_FAMILY );
|
||||
if ( !face->root.family_name )
|
||||
@ -526,7 +528,7 @@
|
||||
/* now set up root fields */
|
||||
{
|
||||
FT_Face root = &face->root;
|
||||
FT_Int32 flags = 0;
|
||||
FT_Int32 flags = root->face_flags;
|
||||
FT_Memory memory;
|
||||
|
||||
|
||||
@ -537,7 +539,7 @@
|
||||
/* Compute face flags. */
|
||||
/* */
|
||||
if ( has_outline == TRUE )
|
||||
flags = FT_FACE_FLAG_SCALABLE; /* scalable outlines */
|
||||
flags |= FT_FACE_FLAG_SCALABLE; /* scalable outlines */
|
||||
|
||||
flags |= FT_FACE_FLAG_SFNT | /* SFNT file format */
|
||||
FT_FACE_FLAG_HORIZONTAL; /* horizontal data */
|
||||
@ -635,59 +637,6 @@
|
||||
}
|
||||
|
||||
|
||||
#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
|
||||
|
||||
if ( face->num_sbit_strikes )
|
||||
{
|
||||
FT_ULong n;
|
||||
|
||||
|
||||
root->face_flags |= FT_FACE_FLAG_FIXED_SIZES;
|
||||
|
||||
#if 0
|
||||
/* XXX: I don't know criteria whether layout is horizontal */
|
||||
/* or vertical. */
|
||||
if ( has_outline.... )
|
||||
{
|
||||
...
|
||||
root->face_flags |= FT_FACE_FLAG_VERTICAL;
|
||||
}
|
||||
#endif
|
||||
root->num_fixed_sizes = (FT_Int)face->num_sbit_strikes;
|
||||
|
||||
if ( FT_NEW_ARRAY( root->available_sizes, face->num_sbit_strikes ) )
|
||||
goto Exit;
|
||||
|
||||
for ( n = 0 ; n < face->num_sbit_strikes ; n++ )
|
||||
{
|
||||
FT_Bitmap_Size* bsize = root->available_sizes + n;
|
||||
TT_SBit_Strike strike = face->sbit_strikes + n;
|
||||
FT_UShort fupem = face->header.Units_Per_EM;
|
||||
FT_Short height = (FT_Short)( face->horizontal.Ascender -
|
||||
face->horizontal.Descender +
|
||||
face->horizontal.Line_Gap );
|
||||
FT_Short avg = face->os2.xAvgCharWidth;
|
||||
|
||||
|
||||
/* assume 72dpi */
|
||||
bsize->height =
|
||||
(FT_Short)( ( height * strike->y_ppem + fupem/2 ) / fupem );
|
||||
bsize->width =
|
||||
(FT_Short)( ( avg * strike->y_ppem + fupem/2 ) / fupem );
|
||||
bsize->size = strike->y_ppem << 6;
|
||||
bsize->x_ppem = strike->x_ppem << 6;
|
||||
bsize->y_ppem = strike->y_ppem << 6;
|
||||
}
|
||||
}
|
||||
else
|
||||
|
||||
#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
|
||||
|
||||
{
|
||||
root->num_fixed_sizes = 0;
|
||||
root->available_sizes = 0;
|
||||
}
|
||||
|
||||
/*********************************************************************/
|
||||
/* */
|
||||
/* Set up metrics. */
|
||||
@ -830,7 +779,7 @@
|
||||
#ifdef FT_OPTIMIZE_MEMORY
|
||||
{
|
||||
FT_Stream stream = FT_FACE_STREAM( face );
|
||||
|
||||
|
||||
FT_FRAME_RELEASE( face->horz_metrics );
|
||||
FT_FRAME_RELEASE( face->vert_metrics );
|
||||
face->horz_metrics_size = 0;
|
||||
|
@ -15,6 +15,14 @@
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include FT_INTERNAL_STREAM_H
|
||||
#include FT_TRUETYPE_TAGS_H
|
||||
|
||||
#ifdef FT_OPTIMIZE_MEMORY
|
||||
#include "ttsbit0.c"
|
||||
#else /* !OPTIMIZE_MEMORY */
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
@ -407,7 +415,7 @@
|
||||
FT_ULong num_strikes;
|
||||
FT_ULong table_base;
|
||||
|
||||
const FT_Frame_Field sbit_line_metrics_fields[] =
|
||||
static const FT_Frame_Field sbit_line_metrics_fields[] =
|
||||
{
|
||||
#undef FT_STRUCTURE
|
||||
#define FT_STRUCTURE TT_SBit_LineMetricsRec
|
||||
@ -430,7 +438,7 @@
|
||||
FT_FRAME_END
|
||||
};
|
||||
|
||||
const FT_Frame_Field strike_start_fields[] =
|
||||
static const FT_Frame_Field strike_start_fields[] =
|
||||
{
|
||||
#undef FT_STRUCTURE
|
||||
#define FT_STRUCTURE TT_SBit_StrikeRec
|
||||
@ -443,7 +451,7 @@
|
||||
FT_FRAME_END
|
||||
};
|
||||
|
||||
const FT_Frame_Field strike_end_fields[] =
|
||||
static const FT_Frame_Field strike_end_fields[] =
|
||||
{
|
||||
/* no FT_FRAME_START */
|
||||
FT_FRAME_USHORT( start_glyph ),
|
||||
@ -576,6 +584,42 @@
|
||||
}
|
||||
}
|
||||
|
||||
/* now set up the root fields to indicate the strikes
|
||||
*/
|
||||
if ( face->num_sbit_strikes )
|
||||
{
|
||||
FT_ULong n;
|
||||
FT_Face root = FT_FACE(face);
|
||||
|
||||
|
||||
if ( FT_NEW_ARRAY( root->available_sizes, face->num_sbit_strikes ) )
|
||||
goto Exit;
|
||||
|
||||
for ( n = 0 ; n < face->num_sbit_strikes ; n++ )
|
||||
{
|
||||
FT_Bitmap_Size* bsize = root->available_sizes + n;
|
||||
TT_SBit_Strike strike = face->sbit_strikes + n;
|
||||
FT_UShort fupem = face->header.Units_Per_EM;
|
||||
FT_Short height = (FT_Short)( face->horizontal.Ascender -
|
||||
face->horizontal.Descender +
|
||||
face->horizontal.Line_Gap );
|
||||
FT_Short avg = face->os2.xAvgCharWidth;
|
||||
|
||||
|
||||
/* assume 72dpi */
|
||||
bsize->height =
|
||||
(FT_Short)( ( height * strike->y_ppem + fupem/2 ) / fupem );
|
||||
bsize->width =
|
||||
(FT_Short)( ( avg * strike->y_ppem + fupem/2 ) / fupem );
|
||||
bsize->size = strike->y_ppem << 6;
|
||||
bsize->x_ppem = strike->x_ppem << 6;
|
||||
bsize->y_ppem = strike->y_ppem << 6;
|
||||
}
|
||||
|
||||
root->face_flags |= FT_FACE_FLAG_FIXED_SIZES;
|
||||
root->num_fixed_sizes = (FT_Int)face->num_sbit_strikes;
|
||||
}
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
@ -1472,3 +1516,4 @@
|
||||
|
||||
|
||||
/* END */
|
||||
#endif /* !OPTIMIZE_MEMORY */
|
||||
|
943
src/sfnt/ttsbit0.c
Normal file
943
src/sfnt/ttsbit0.c
Normal file
@ -0,0 +1,943 @@
|
||||
/***************************************************************************/
|
||||
/* */
|
||||
/* ttsbit.c */
|
||||
/* */
|
||||
/* TrueType and OpenType embedded bitmap support (body). */
|
||||
/* */
|
||||
/* Copyright 1996-2001, 2002, 2003, 2004 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_sbit_strikes( TT_Face face,
|
||||
FT_Stream stream )
|
||||
{
|
||||
FT_Error error = 0;
|
||||
FT_Memory memory = stream->memory;
|
||||
FT_Fixed version;
|
||||
FT_ULong num_strikes, table_size;
|
||||
FT_ULong table_base;
|
||||
FT_Byte* p;
|
||||
FT_Byte* p_limit;
|
||||
FT_UInt nn, 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 != 0x00020000 || 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're 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;
|
||||
|
||||
/* now allocate the root array of F_Bitmap_Size records,
|
||||
* populate them, and that's all there is to it. Unfortunately,
|
||||
* it's not possible to indicate bit depths in the FT_Bitmap_Size
|
||||
* record. What were we thinking ?
|
||||
*/
|
||||
{
|
||||
FT_Memory memory = face->root.stream->memory;
|
||||
FT_UInt em_size = (FT_UInt) face->header.Units_Per_EM;
|
||||
FT_Short height = (FT_Short)( face->horizontal.Ascender -
|
||||
face->horizontal.Descender +
|
||||
face->horizontal.Line_Gap );
|
||||
|
||||
FT_Short avgwidth = face->os2.xAvgCharWidth;
|
||||
|
||||
if ( FT_NEW_ARRAY( face->root.available_sizes, count ) )
|
||||
goto Fail;
|
||||
|
||||
for ( nn = 0; nn < count; nn++ )
|
||||
{
|
||||
FT_Bitmap_Size* bsize = face->root.available_sizes + nn;
|
||||
FT_UInt x_ppem, y_ppem;
|
||||
|
||||
x_ppem = p[44];
|
||||
y_ppem = p[45];
|
||||
|
||||
bsize->x_ppem = (FT_Pos)(x_ppem << 6);
|
||||
bsize->y_ppem = (FT_Pos)(y_ppem << 6);
|
||||
|
||||
bsize->height = (FT_Short)( height*y_ppem + em_size/2 ) / em_size;
|
||||
bsize->width = (FT_Short)( avgwidth*y_ppem + em_size/2 ) / em_size;
|
||||
bsize->size = bsize->y_ppem;
|
||||
|
||||
p += 48;
|
||||
}
|
||||
|
||||
face->root.face_flags |= FT_FACE_FLAG_FIXED_SIZES;
|
||||
face->root.num_fixed_sizes = 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_sbit_strikes( 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_UInt x_ppem,
|
||||
FT_UInt y_ppem,
|
||||
FT_ULong *astrike_index )
|
||||
{
|
||||
FT_UInt nn, count;
|
||||
FT_Byte* p;
|
||||
FT_Byte* p_limit;
|
||||
|
||||
if ( x_ppem > 255 ||
|
||||
y_ppem < 1 || y_ppem > 255 )
|
||||
return SFNT_Err_Invalid_PPem;
|
||||
|
||||
p = face->sbit_table + 8;
|
||||
p_limit = p + face->sbit_table_size;
|
||||
count = face->sbit_num_strikes;
|
||||
for ( nn = 0; nn < count; nn++ )
|
||||
{
|
||||
if ( x_ppem == (FT_UInt)p[44] && y_ppem == (FT_UInt)p[45] )
|
||||
{
|
||||
*astrike_index = (FT_ULong)nn;
|
||||
return SFNT_Err_Ok;
|
||||
}
|
||||
p += 48;
|
||||
}
|
||||
|
||||
return SFNT_Err_Invalid_PPem;
|
||||
}
|
||||
|
||||
|
||||
|
||||
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 = 0;
|
||||
FT_UInt width, height;
|
||||
FT_Bitmap* map = decoder->bitmap;
|
||||
FT_Long size;
|
||||
|
||||
if ( !decoder->metrics_loaded )
|
||||
{
|
||||
error = FT_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 FT_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 = 0;
|
||||
FT_Byte* line;
|
||||
FT_Int bit_height, bit_width, pitch, width, height, h;
|
||||
FT_Bitmap* bitmap;
|
||||
FT_UInt 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;
|
||||
|
||||
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 = FT_Err_Invalid_File_Format;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
if ( p+((width+7)>>3)*height > limit )
|
||||
{
|
||||
error = FT_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++ & (0xFF00 >> 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++ & (0xFF00 >> w)));
|
||||
|
||||
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 = 0;
|
||||
FT_Byte* line;
|
||||
FT_Int bit_height, bit_width, pitch, width, height, h;
|
||||
FT_Bitmap* bitmap;
|
||||
FT_UInt32 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;
|
||||
|
||||
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 = FT_Err_Invalid_File_Format;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
if ( p+((width+7)>>3)*height > limit )
|
||||
{
|
||||
error = FT_Err_Invalid_File_Format;
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* now do the blit
|
||||
*/
|
||||
line += y_pos*pitch + (x_pos >> 3);
|
||||
x_pos &= 7;
|
||||
rval = 0x10000;
|
||||
|
||||
for ( h = height; h > 0; h--, line += pitch )
|
||||
{
|
||||
FT_Byte* write = line;
|
||||
FT_UInt32 wval = 0x100 << x_pos;
|
||||
FT_Int w;
|
||||
|
||||
for ( w = width; w >= 8; w -= 8 )
|
||||
{
|
||||
if ( rval & 0x10000 )
|
||||
rval = 0x100 | *p++;
|
||||
|
||||
wval |= (rval & 0x80);
|
||||
|
||||
wval <<= 1;
|
||||
rval <<= 1;
|
||||
|
||||
if ( wval & 0x10000 )
|
||||
{
|
||||
write[0] = (FT_Byte)(write[0] | (wval >> 8));
|
||||
write += 1;
|
||||
wval = 0x100;
|
||||
}
|
||||
}
|
||||
|
||||
if ( wval != 0x100 )
|
||||
{
|
||||
while ( wval > 0x1FF )
|
||||
wval >>= 1;
|
||||
|
||||
write[0] = (FT_Byte)(write[0] | wval);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
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 = FT_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 = FT_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 = 0;
|
||||
}
|
||||
|
||||
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, offset, index_format, image_format;
|
||||
FT_ULong image_start, image_end, 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:
|
||||
p = decoder->eblc_base + decoder->strike_index_array + FT_NEXT_ULONG(p);
|
||||
if ( p+8 > p_limit )
|
||||
goto NoBitmap;
|
||||
|
||||
/* now, we're going to 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_offset + 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_offset + 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_offset + image_start,
|
||||
image_end,
|
||||
x_pos,
|
||||
y_pos );
|
||||
NoBitmap:
|
||||
return FT_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;
|
||||
|
||||
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;
|
||||
}
|
@ -749,33 +749,39 @@
|
||||
|
||||
if ( !error )
|
||||
{
|
||||
/* XXX: TODO: move this code to the SFNT module where it belongs */
|
||||
#ifdef FT_OPTIMIZE_MEMORY
|
||||
FT_Byte* strike = face->sbit_table + 8 + strike_index*48;
|
||||
|
||||
sbit_metrics->ascender = (FT_Char)strike[16] << 6; /* hori.ascender */
|
||||
sbit_metrics->descender = (FT_Char)strike[17] << 6; /* hori.descender */
|
||||
|
||||
/* XXX: Is this correct? */
|
||||
sbit_metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB */
|
||||
strike[18] + /* max_width */
|
||||
(FT_Char)strike[23] /* min_advance_SB */
|
||||
) << 6;
|
||||
|
||||
#else /* !OPTIMIZE_MEMORY */
|
||||
TT_SBit_Strike strike = face->sbit_strikes + strike_index;
|
||||
|
||||
|
||||
sbit_metrics->x_ppem = metrics->x_ppem;
|
||||
sbit_metrics->y_ppem = metrics->y_ppem;
|
||||
#if 0
|
||||
/*
|
||||
* sbit_metrics->?_scale
|
||||
* are not used now.
|
||||
*/
|
||||
sbit_metrics->x_scale = 1 << 16;
|
||||
sbit_metrics->y_scale = 1 << 16;
|
||||
#endif
|
||||
|
||||
sbit_metrics->ascender = strike->hori.ascender << 6;
|
||||
sbit_metrics->descender = strike->hori.descender << 6;
|
||||
|
||||
/* XXX: Is this correct? */
|
||||
sbit_metrics->height = sbit_metrics->ascender -
|
||||
sbit_metrics->descender;
|
||||
|
||||
/* XXX: Is this correct? */
|
||||
sbit_metrics->max_advance = ( strike->hori.min_origin_SB +
|
||||
strike->hori.max_width +
|
||||
strike->hori.min_advance_SB ) << 6;
|
||||
#endif /* !OPTIMIZE_MEMORY */
|
||||
|
||||
size->strike_index = (FT_UInt)strike_index;
|
||||
/* XXX: Is this correct? */
|
||||
sbit_metrics->height = sbit_metrics->ascender -
|
||||
sbit_metrics->descender;
|
||||
|
||||
sbit_metrics->x_ppem = metrics->x_ppem;
|
||||
sbit_metrics->y_ppem = metrics->y_ppem;
|
||||
size->strike_index = (FT_UInt)strike_index;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
Loading…
Reference in New Issue
Block a user