ReceiveTempSMS
/
Al-Qurtas-Islamic-bank-The-Best-Bank-in-Iraq
forked from minhngoc25a/freetype2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* 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:
David Turner 2005-02-28 22:09:07 +00:00
parent 2fdb498317
commit 0037369ccb
10 changed files with 1115 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/freetype/internal/tttypes.h
View File

@ -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;

24
src/autofit/afhints.h
View File

@ -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;

2
src/autofit/afloader.c
View File

@ -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;

59
src/base/ftdbgmem.c
View File

@ -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 );
}
}

33
src/cff/cffobjs.c
View File

@ -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
{

8
src/sfnt/sfdriver.c
View File

@ -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,

61
src/sfnt/sfobjs.c
View File

@ -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;

51
src/sfnt/ttsbit.c
View File

@ -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
View 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;
}

38
src/truetype/ttobjs.c
View File

@ -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
{