391 lines
12 KiB
C
391 lines
12 KiB
C
#include <freetype/cache/ftcsbits.h>
|
|
#include <freetype/fterrors.h>
|
|
|
|
#define FTC_SBITSET_ELEMENT_COUNT 16
|
|
|
|
|
|
typedef struct FTC_SBitSetRec_
|
|
{
|
|
FTC_ChunkSetRec root;
|
|
FTC_Image_Desc desc;
|
|
|
|
} FTC_SBitSetRec, *FTC_SBitSet;
|
|
|
|
|
|
typedef struct FTC_SBit_CacheRec_
|
|
{
|
|
FTC_Chunk_CacheRec root;
|
|
|
|
} FTC_SBit_CacheRec;
|
|
|
|
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
/***** *****/
|
|
/***** SBIT CACHE 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->elements );
|
|
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_ChunkNode *anode )
|
|
{
|
|
FT_Error error;
|
|
FT_Memory memory = cset->memory;
|
|
FTC_SBitSet sbitset = (FTC_SBitSet)cset;
|
|
FTC_ChunkNode 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( node, cset, index, 1 );
|
|
if (error)
|
|
goto Exit;
|
|
|
|
/* we will now load all glyph images for this chunk */
|
|
error = FTC_Manager_Lookup_Size( cset->manager,
|
|
&sbitset->desc.font,
|
|
&face, &size );
|
|
if ( !error )
|
|
{
|
|
FT_UInt glyph_index = index * cset->element_count;
|
|
FT_UInt load_flags = FT_LOAD_DEFAULT;
|
|
FT_UInt image_type = sbitset->desc.image_type;
|
|
FT_UInt count = node->num_elements;
|
|
FTC_SBit sbit = (FTC_SBit)node->elements;
|
|
|
|
/* determine load flags, depending on the font description's */
|
|
/* image type.. */
|
|
{
|
|
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
|
|
{
|
|
FT_ERROR(( "FTC_SBit_Cache: cannot load scalable glyphs in a"
|
|
" sbit cache, please check your arguments !!\n" ));
|
|
error = FT_Err_Invalid_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++, sbit++ )
|
|
{
|
|
/* by default, indicates a "missing" glyph */
|
|
sbit->buffer = 0;
|
|
|
|
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 xadvance, yadvance;
|
|
|
|
/* check that our values fit in 8-bit containers !! */
|
|
/* if this is not the case, our bitmap is too large */
|
|
/* and we will leave it as "missing" with sbit.buffer = 0 */
|
|
|
|
#define CHECK_CHAR(d) ( temp = (FT_Char)d, temp == d )
|
|
#define CHECK_BYTE(d) ( temp = (FT_Byte)d, temp == d )
|
|
|
|
/* FIXME: add support for vertical layouts maybe.. */
|
|
|
|
/* horizontal advance in pixels */
|
|
xadvance = (slot->metrics.horiAdvance+32) >> 6;
|
|
yadvance = (slot->metrics.vertAdvance+32) >> 6;
|
|
|
|
if ( CHECK_BYTE ( bitmap->rows ) &&
|
|
CHECK_BYTE ( bitmap->width ) &&
|
|
CHECK_CHAR ( bitmap->pitch ) &&
|
|
CHECK_CHAR ( slot->bitmap_left ) &&
|
|
CHECK_CHAR ( slot->bitmap_top ) &&
|
|
CHECK_CHAR ( xadvance ) &&
|
|
CHECK_CHAR ( yadvance ) )
|
|
{
|
|
sbit->width = (FT_Byte) bitmap->width;
|
|
sbit->height = (FT_Byte) bitmap->rows;
|
|
sbit->pitch = (FT_Char) bitmap->pitch;
|
|
sbit->left = (FT_Char) slot->bitmap_left;
|
|
sbit->top = (FT_Char) slot->bitmap_top;
|
|
sbit->xadvance = (FT_Char) xadvance;
|
|
sbit->yadvance = (FT_Char) yadvance;
|
|
sbit->format = (FT_Byte) bitmap->pixel_mode;
|
|
|
|
/* 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 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* 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_ChunkNode node )
|
|
{
|
|
FT_ULong size;
|
|
FTC_ChunkSet cset = node->cset;
|
|
FT_UInt count = node->num_elements;
|
|
FT_Int pitch;
|
|
FTC_SBit sbit = (FTC_SBit)node->elements;
|
|
|
|
size = sizeof (*node); /* the node itself */
|
|
size += cset->element_count * sizeof(FTC_SBitRec); /* the sbit recors */
|
|
|
|
for ( ; count > 0; count--, sbit++ )
|
|
{
|
|
if (sbit->buffer)
|
|
{
|
|
pitch = sbit->pitch;
|
|
if (pitch < 0)
|
|
pitch = -pitch;
|
|
|
|
/* add the size of a given glyph image */
|
|
size += pitch * sbit->height;
|
|
}
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
/***** *****/
|
|
/***** SBIT CHUNK SETS *****/
|
|
/***** *****/
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
|
|
|
|
LOCAL_FUNC_X
|
|
FT_Error ftc_sbit_chunk_set_sizes( FTC_ChunkSet cset,
|
|
FTC_Image_Desc* desc )
|
|
{
|
|
FT_Error error;
|
|
FT_Face face;
|
|
|
|
cset->element_count = FTC_SBITSET_ELEMENT_COUNT;
|
|
cset->element_size = sizeof(FTC_SBitRec);
|
|
|
|
/* lookup the FT_Face to obtain the number of glyphs */
|
|
error = FTC_Manager_Lookup_Face( cset->manager,
|
|
desc->font.face_id, &face );
|
|
if (!error)
|
|
cset->element_max = face->num_glyphs;
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
|
|
LOCAL_FUNC_X
|
|
FT_Error ftc_sbit_chunk_set_init( FTC_SBitSet sset,
|
|
FTC_Image_Desc* type )
|
|
{
|
|
sset->desc = *type;
|
|
return 0;
|
|
}
|
|
|
|
|
|
LOCAL_FUNC_X
|
|
FT_Bool ftc_sbit_chunk_set_compare( FTC_SBitSet sset,
|
|
FTC_Image_Desc* type )
|
|
{
|
|
return !memcmp( &sset->desc, type, sizeof ( *type ) );
|
|
}
|
|
|
|
|
|
FT_CPLUSPLUS( const FTC_ChunkSet_Class ) ftc_sbit_chunk_set_class =
|
|
{
|
|
sizeof( FTC_SBitSetRec ),
|
|
|
|
(FTC_ChunkSet_InitFunc) ftc_sbit_chunk_set_init,
|
|
(FTC_ChunkSet_DoneFunc) 0,
|
|
(FTC_ChunkSet_CompareFunc) ftc_sbit_chunk_set_compare,
|
|
(FTC_ChunkSet_SizesFunc) ftc_sbit_chunk_set_sizes,
|
|
|
|
(FTC_ChunkSet_NewNodeFunc) ftc_sbit_chunk_node_new,
|
|
(FTC_ChunkSet_SizeNodeFunc) ftc_sbit_chunk_node_size,
|
|
(FTC_ChunkSet_DestroyNodeFunc) ftc_sbit_chunk_node_destroy
|
|
};
|
|
|
|
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
/***** *****/
|
|
/***** SBITS CACHE *****/
|
|
/***** *****/
|
|
/*************************************************************************/
|
|
/*************************************************************************/
|
|
|
|
|
|
FT_CPLUSPLUS( const FTC_Chunk_Cache_Class ) ftc_sbit_cache_class =
|
|
{
|
|
{
|
|
sizeof( FTC_SBit_CacheRec ),
|
|
(FTC_Cache_InitFunc) FTC_Chunk_Cache_Init,
|
|
(FTC_Cache_DoneFunc) FTC_Chunk_Cache_Done
|
|
},
|
|
(FTC_ChunkSet_Class*) &ftc_sbit_chunk_set_class
|
|
};
|
|
|
|
|
|
FT_EXPORT_FUNC( FT_Error )
|
|
FTC_SBit_Cache_New( FTC_Manager manager,
|
|
FTC_SBit_Cache* acache )
|
|
{
|
|
return FTC_Manager_Register_Cache(
|
|
manager,
|
|
(FTC_Cache_Class*)&ftc_sbit_cache_class,
|
|
(FTC_Cache*)acache );
|
|
}
|
|
|
|
|
|
FT_EXPORT_DEF( FT_Error )
|
|
FTC_SBit_Cache_Lookup( FTC_SBit_Cache cache,
|
|
FTC_Image_Desc* desc,
|
|
FT_UInt gindex,
|
|
FTC_SBit *asbit )
|
|
{
|
|
FT_Error error;
|
|
FTC_ChunkSet cset;
|
|
FTC_ChunkNode node;
|
|
FT_UInt cindex;
|
|
FTC_Manager manager;
|
|
|
|
FTC_SBitSet sset;
|
|
FTC_SBit sbit;
|
|
|
|
|
|
/* check for valid `desc' delayed to FT_Lru_Lookup() */
|
|
|
|
if ( !cache || !asbit )
|
|
return FT_Err_Invalid_Argument;
|
|
|
|
*asbit = 0;
|
|
cset = cache->root.last_cset;
|
|
sset = (FTC_SBitSet)cset;
|
|
if ( !cset || memcmp( &sset->desc, desc, sizeof ( *desc ) ) )
|
|
{
|
|
error = FT_Lru_Lookup( cache->root.csets_lru,
|
|
(FT_LruKey)desc,
|
|
(FT_Pointer*)&cset );
|
|
cache->root.last_cset = cset;
|
|
if ( error )
|
|
goto Exit;
|
|
}
|
|
|
|
error = FTC_ChunkSet_Lookup_Node( cset, gindex, &node, &cindex );
|
|
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_ChunkNode_Ref ( node );
|
|
FTC_Manager_Compress( manager );
|
|
FTC_ChunkNode_Unref ( node );
|
|
}
|
|
|
|
sbit = ((FTC_SBit)((FTC_ChunkNode)node)->elements) + cindex;
|
|
*asbit = sbit;
|
|
|
|
Exit:
|
|
return error;
|
|
}
|
|
|