ref: 4e4a43631c91cceeae2f90e190ca2cef67910374
dir: /src/cache/ftcsbits.c/
#include <cache/ftcsbits.h>
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** GLYPH IMAGE NODES *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
LOCAL_FUNC_X
void ftc_sbit_chunk_node_destroy( FTC_ChunkNode node )
{
FTC_ChunkSet cset = node->cset;
FT_Memory memory = cset->memory;
FT_UInt count = node->num_elements;
FTC_SBit sbit = (FTC_SBit)node->elements;
for ( ; count > 0; sbit++, count-- )
FREE( sbit->buffer );
FREE( node );
}
static
FT_Error ftc_bitmap_copy( FT_Memory memory,
FT_Bitmap* source,
FTC_SBit target )
{
FT_Error error;
FT_Int pitch = source->pitch;
FT_ULong size;
if ( pitch < 0 )
pitch = -pitch;
size = (FT_ULong)( pitch * source->rows );
if ( !ALLOC( target->buffer, size ) )
MEM_Copy( target->buffer, source->buffer, size );
return error;
}
LOCAL_FUNC_X
FT_Error ftc_sbit_chunk_node_new( FTC_ChunkSet cset,
FT_UInt index,
FTC_SBitChunk *anode )
{
FT_Error error;
FT_Memory memory = cset->memory;
FTC_SBitSet sbitset = (FTC_SBitSet)cset;
FTC_SBitChunk node = 0;
FT_Face face;
FT_Size size;
/* allocate node */
if ( ALLOC( node, sizeof ( *node ) ) )
goto Exit;
/* init its inner fields */
error = FTC_ChunkNode_Init( FTC_CHUNKNODE(node), cset, index, 1 );
if (error)
goto Exit;
/* we will now load all glyph images */
error = FTC_Manager_Lookup_Size( cset->manager,
&sbitset->description.font,
&face, &size );
if ( !error )
{
FT_UInt glyph_index = index * cset->chunk_size;
FT_UInt load_flags = FT_LOAD_DEFAULT;
FT_UInt image_type = sbitset->description.image_type;
FT_UInt count = node->num_elements;
FTC_SBit sbit = (FTC_SBit)node->elements;
if ( FTC_IMAGE_FORMAT( image_type ) == ftc_image_format_bitmap )
{
if ( image_type & ftc_image_flag_monochrome )
load_flags |= FT_LOAD_MONOCHROME;
/* disable embedded bitmaps loading if necessary */
if ( image_type & ftc_image_flag_no_sbits )
load_flags |= FT_LOAD_NO_BITMAP;
}
else if ( FTC_IMAGE_FORMAT( image_type ) == ftc_image_format_outline )
{
/* disable embedded bitmaps loading */
load_flags |= FT_LOAD_NO_BITMAP;
if ( image_type & ftc_image_flag_unscaled )
{
FT_ERROR(( "FTC_SBit_Cache: cannot load vector outlines in a"
" sbit cache, please check your arguments !!\n" ));
error = FT_Err_Bad_Argument;
goto Exit;
}
}
/* always render glyphs to bitmaps */
load_flags |= FT_LOAD_RENDER;
if ( image_type & ftc_image_flag_unhinted )
load_flags |= FT_LOAD_NO_HINTING;
if ( image_type & ftc_image_flag_autohinted )
load_flags |= FT_LOAD_FORCE_AUTOHINT;
/* load a chunk of small bitmaps in a row */
for ( ; count > 0; count--, glyph_index++ )
{
error = FT_Load_Glyph( face, glyph_index, load_flags );
if (!error)
{
FT_Int temp;
FT_GlyphSlot slot = face->glyph;
FT_Bitmap* bitmap = &slot->bitmap;
FT_Int advance;
/* check that our values fit in 8-bit containers !! */
#define CHECK_SCHAR(d) ( temp = (FT_SChar)d, temp == d )
#define CHECK_BYTE(d) ( temp = (FT_Byte) d, temp == d )
advance = (slot->metrics.horiAdvance+32) >> 6;
if ( CHECK_BYTE ( bitmap->rows ) &&
CHECK_BYTE ( bitmap->width ) &&
CHECK_SCHAR( bitmap->pitch ) &&
CHECK_SCHAR( slot->bitmap_left ) &&
CHECK_SCHAR( slot->bitmap_top ) &&
CHECK_SCHAR( advance ) )
{
sbit->width = (FT_Byte) bitmap->width;
sbit->height = (FT_Byte) bitmap->height;
sbit->pitch = (FT_SChar)bitmap->pitch;
sbit->left = (FT_SChar)slot->bitmap_left;
sbit->top = (FT_SChar)slot->bitmap_top;
sbit->advance = (FT_SChar)advance;
/* grab the bitmap when possible */
if ( slot->flags & ft_glyph_own_bitmap )
{
slot->flags &= ~ft_glyph_own_bitmap;
sbit->buffer = bitmap->buffer;
}
else
{
/* copy the bitmap into a new buffer - ignore error */
ftc_bitmap_copy( memory, bitmap, sbit );
}
}
}
else
sbit->buffer = 0;
}
/* ignore the errors that might have occured there */
/* we recognize unloaded glyphs with "sbit.buffer == 0" */
error = 0;
}
Exit:
if ( error && node )
{
FREE( node->elements );
FREE( node );
}
*anode = node;
return error;
}
/* this function is important because it is both part of */
/* a FTC_ChunkSet_Class and a FTC_CacheNode_Class */
/* */
LOCAL_FUNC_X
FT_ULong ftc_sbit_chunk_node_size( FTC_SBitChunk node )
{
FT_ULong size = 0;
FT_Glyph glyph = node->ft_glyph;
switch ( glyph->format )
{
case ft_glyph_format_bitmap:
{
FT_BitmapGlyph bitg;
bitg = (FT_BitmapGlyph)glyph;
size = bitg->bitmap.rows * labs( bitg->bitmap.pitch ) +
sizeof ( *bitg );
}
break;
case ft_glyph_format_outline:
{
FT_OutlineGlyph outg;
outg = (FT_OutlineGlyph)glyph;
size = outg->outline.n_points *
( sizeof( FT_Vector ) + sizeof ( FT_Byte ) ) +
outg->outline.n_contours * sizeof ( FT_Short ) +
sizeof ( *outg );
}
break;
default:
;
}
size += sizeof ( *node );
return size;
}
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** GLYPH IMAGE QUEUES *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
LOCAL_FUNC_X
FT_Error ftc_image_set_init( FTC_ImageSet iset,
FTC_Image_Desc* type )
{
iset->description = *type;
return 0;
}
LOCAL_FUNC_X
FT_Bool ftc_image_set_compare( FTC_ImageSet iset,
FTC_Image_Desc* type )
{
return !memcmp( &iset->description, type, sizeof ( *type ) );
}
FT_CPLUSPLUS( const FTC_ChunkSet_Class ) ftc_sbit_chunk_set_class =
{
sizeof( FTC_ImageSetRec ),
(FTC_ChunkSet_InitFunc) ftc_image_set_init,
(FTC_ChunkSet_DoneFunc) 0,
(FTC_ChunkSet_CompareFunc) ftc_image_set_compare,
(FTC_ChunkSet_NewNodeFunc) ftc_sbit_chunk_node_new,
(FTC_ChunkSet_SizeNodeFunc) ftc_sbit_chunk_node_size,
(FTC_ChunkSet_DestroyNodeFunc)ftc_sbit_chunk_node_destroy
};
/*************************************************************************/
/*************************************************************************/
/***** *****/
/***** GLYPH IMAGE CACHE *****/
/***** *****/
/*************************************************************************/
/*************************************************************************/
FT_CPLUSPLUS( const FTC_Glyph_Cache_Class ) ftc_sbit_chunk_cache_class =
{
{
sizeof( FTC_Image_CacheRec ),
(FTC_Cache_InitFunc) FTC_Glyph_Cache_Init,
(FTC_Cache_DoneFunc) FTC_Glyph_Cache_Done
},
(FTC_ChunkSet_Class*) &ftc_sbit_chunk_set_class
};
FT_EXPORT_FUNC( FT_Error ) FTC_Image_Cache_New( FTC_Manager manager,
FTC_Image_Cache* acache )
{
return FTC_Manager_Register_Cache(
manager,
(FTC_Cache_Class*)&ftc_sbit_chunk_cache_class,
(FTC_Cache*)acache );
}
FT_EXPORT_DEF( FT_Error )
FTC_Image_Cache_Lookup( FTC_Image_Cache cache,
FTC_Image_Desc* desc,
FT_UInt gindex,
FT_Glyph* aglyph )
{
FT_Error error;
FTC_ChunkSet gset;
FTC_GlyphNode node;
FTC_Manager manager;
FTC_ImageSet img_set;
/* check for valid `desc' delayed to FT_Lru_Lookup() */
if ( !cache || !aglyph )
return FT_Err_Invalid_Argument;
*aglyph = 0;
gset = cache->root.last_gset;
img_set = (FTC_ImageSet)gset;
if ( !gset || memcmp( &img_set->description, desc, sizeof ( *desc ) ) )
{
error = FT_Lru_Lookup( cache->root.gsets_lru,
(FT_LruKey)desc,
(FT_Pointer*)&gset );
cache->root.last_gset = gset;
if ( error )
goto Exit;
}
error = FTC_ChunkSet_Lookup_Node( gset, gindex, &node );
if ( error )
goto Exit;
/* now compress the manager's cache pool if needed */
manager = cache->root.root.manager;
if ( manager->num_bytes > manager->max_bytes )
{
FTC_GlyphNode_Ref ( node );
FTC_Manager_Compress( manager );
FTC_GlyphNode_Unref ( node );
}
*aglyph = ((FTC_SBitChunk)node)->ft_glyph;
Exit:
return error;
}