static void ttf_instance_setc(struct image_ttf_face_struct *face_s,
struct image_ttf_faceinstance_struct *face_i,
int towhat,
char *where)
{
TT_Face_Properties prop;
TT_Instance_Metrics metr;
int res;
int resol;
if ((res=TT_Get_Face_Properties(face_s->face,&prop)))
my_tt_error(where,"TT_Get_Face_Properties",res);
resol=58; /* should be 72, but glyphs fit using this value */
/*
(int)((72*(prop.horizontal->Ascender+
prop.horizontal->Descender)/
(float)prop.horizontal->Ascender));
*/
if ((res=TT_Set_Instance_Resolutions(face_i->instance,
(TT_UShort)resol, (TT_UShort)resol)))
my_tt_error("Image.TTF.FaceInstance()",
"TT_Set_Instance_Resolutions: ",res);
if ((res=TT_Get_Instance_Metrics(face_i->instance,&metr)))
my_tt_error(where,"TT_Get_Instance_Metrics",res);
if ((res=TT_Set_Instance_CharSize(face_i->instance,towhat)))
my_tt_error(where,"TT_Set_Instance_CharSize: ",res);
face_i->baseline=
DOUBLE_TO_INT(((double)(towhat/64.0+towhat/640.0)*
prop.horizontal->Ascender)/
(prop.horizontal->Ascender - prop.horizontal->Descender));
face_i->height= (towhat/64 + towhat/640);
face_i->trans = ~63 &
(32 +
DOUBLE_TO_INT(64*((towhat/64.0+towhat/640.0)*
prop.horizontal->Ascender)/
(prop.horizontal->Ascender-prop.horizontal->Descender)));
}
void
TTFopen(char *filename, Font *fnt, int new_dpi, int new_ptsize, Boolean quiet)
{
unsigned short i, num_cmap;
unsigned short cmap_plat;
unsigned short cmap_enc;
TT_Error error;
TT_UShort script_index, language_index, feature_index;
TT_UShort req_feature_index = 0xFFFF;
dpi = new_dpi;
ptsize = new_ptsize;
if ((error = TT_Init_FreeType(&engine)))
oops("Cannot initialize FreeType engine (error code = 0x%x).", error);
if (fnt->PSnames)
if ((error = TT_Init_Post_Extension(engine)))
oops("Cannot initialize PS name support (error code = 0x%x).", error);
if (fnt->rotate)
if ((error = TT_Init_GSUB_Extension(engine)))
oops("Cannot initialize GSUB support (error code = 0x%x).", error);
/*
* Load face.
*/
error = TT_Open_Face(engine, filename, &face);
if (error)
oops("Cannot open `%s'.", filename);
/*
* Get face properties and allocate preloaded arrays.
*/
TT_Get_Face_Properties(face, &properties);
/*
* Now we try to open the proper font in a collection.
*/
if (fnt->fontindex != 0)
{
if (properties.num_Faces == 1)
warning("This isn't a TrueType collection.\n"
"Parameter `Fontindex' is ignored.");
else
{
TT_Close_Face(face);
if ((error = TT_Open_Collection(engine, filename,
fnt->fontindex, &face)))
oops("Cannot open font %lu in TrueType Collection `%s'.",
fnt->fontindex, filename);
}
}
/*
* Create instance.
*/
if ((error = TT_New_Instance(face, &instance)))
oops("Cannot create instance for `%s' (error code = 0x%x).",
filename, error);
if ((error = TT_Set_Instance_Resolutions(instance, dpi, dpi)))
oops("Cannot set device resolutions (error code = 0x%x).");
if ((error = TT_Set_Instance_CharSize(instance, ptsize * 64)))
oops("Cannot set character size (error code = 0x%x).", error);
ppem = (dpi * ptsize + 36) / 72;
if (!quiet)
printf("dpi = %d, ptsize = %d, ppem = %d\n\n", dpi, ptsize, ppem);
matrix1.xx = (TT_Fixed)(floor(fnt->efactor * 1024) * (1<<16)/1024);
matrix1.xy = (TT_Fixed)(floor(fnt->slant * 1024) * (1<<16)/1024);
matrix1.yx = (TT_Fixed)0;
matrix1.yy = (TT_Fixed)(1<<16);
if (fnt->rotate)
{
matrix2.xx = 0;
matrix2.yx = 1L << 16;
matrix2.xy = -matrix2.yx;
matrix2.yy = matrix2.xx;
}
if ((error = TT_Set_Instance_Transform_Flags(
instance,
fnt->rotate ? 1 : 0,
fnt->efactor != 1.0 ? 1 : 0)))
oops("Cannot set transform flags (error code = 0x%x).", error);
/*
* Create glyph container.
*/
if ((error = TT_New_Glyph(face, &glyph)))
oops("Cannot create glyph container (error code = 0x%x).");
if (fnt->PSnames != Only)
{
num_cmap = properties.num_CharMaps;
for (i = 0; i < num_cmap; i++)
{
if ((error = TT_Get_CharMap_ID(face, i, &cmap_plat, &cmap_enc)))
oops("Cannot query cmap (error code = 0x%x).", error);
if (cmap_plat == fnt->pid && cmap_enc == fnt->eid)
break;
}
if (i == num_cmap)
oops("Invalid platform and/or encoding ID.");
if ((error = TT_Get_CharMap(face, i, &char_map)))
oops("Cannot load cmap (error code = 0x%x).", error);
}
if (fnt->PSnames)
{
if ((error = TT_Load_PS_Names(face, &post)))
oops("Cannot load TrueType PS names (error code = 0x%x).", error);
}
else if (cmap_plat == Microsoft_platform &&
cmap_enc == Microsoft_Unicode_encoding)
set_encoding_scheme(encUnicode, fnt);
else if (cmap_plat == Macintosh_platform &&
cmap_enc == Macintosh_encoding)
set_encoding_scheme(encMac, fnt);
else
set_encoding_scheme(encFontSpecific, fnt);
if (fnt->rotate)
{
gsub = &gsub_;
error = TT_Load_GSUB_Table(face, gsub, NULL);
if (!error)
has_gsub = True;
else if (error != TT_Err_Table_Missing)
warning("Cannot load GSUB table (error code = 0x%x).", error);
else
warning("No GSUB data available "
"for vertical glyph presentation forms.");
/* we check for the `vert' feature in Chinese, Japanese, and Korean */
error = TT_GSUB_Select_Script(gsub,
SCRIPT_kana,
&script_index);
if (error)
goto check_hani;
error = TT_GSUB_Select_Feature(gsub,
FEATURE_vert,
script_index,
0xFFFF,
&feature_index);
if (error)
{
error = TT_GSUB_Select_Language(gsub,
LANGUAGE_JAN,
script_index,
&language_index,
&req_feature_index);
if (error)
goto check_hani;
error = TT_GSUB_Select_Feature(gsub,
FEATURE_vert,
script_index,
language_index,
&feature_index);
if (error)
goto check_hani;
else
goto Done;
}
else
goto Done;
check_hani:
error = TT_GSUB_Select_Script(gsub,
SCRIPT_hani,
&script_index);
if (error)
goto check_hang;
error = TT_GSUB_Select_Feature(gsub,
FEATURE_vert,
script_index,
0xFFFF,
&feature_index);
if (error)
{
error = TT_GSUB_Select_Language(gsub,
LANGUAGE_CHN,
script_index,
&language_index,
&req_feature_index);
if (error)
goto check_hang;
error = TT_GSUB_Select_Feature(gsub,
FEATURE_vert,
script_index,
language_index,
&feature_index);
if (error)
goto check_hang;
else
goto Done;
}
else
goto Done;
check_hang:
error = TT_GSUB_Select_Script(gsub,
SCRIPT_hang,
&script_index);
if (error)
goto Done;
error = TT_GSUB_Select_Feature(gsub,
FEATURE_vert,
script_index,
0xFFFF,
&feature_index);
if (error)
{
error = TT_GSUB_Select_Language(gsub,
LANGUAGE_KOR,
script_index,
&language_index,
&req_feature_index);
if (error)
goto Done;
error = TT_GSUB_Select_Feature(gsub,
FEATURE_vert,
script_index,
language_index,
&feature_index);
}
Done:
if (error)
{
warning("There is no data for vertical typesetting in GSUB table.");
has_gsub = False;
}
if (req_feature_index != 0xFFFF)
TT_GSUB_Add_Feature(gsub, req_feature_index, ALL_GLYPHS);
TT_GSUB_Add_Feature(gsub, feature_index, ALL_GLYPHS);
in.length = 1;
in.pos = 0;
in.string = in_string;
in.properties = NULL;
out.pos = 0;
out.allocated = 0;
out.string = NULL;
out.properties = NULL;
}
}
TTF_Font *TTF_OpenFont(const char *file, int ptsize)
{
TTF_Font *font;
TT_Face_Properties properties;
TT_Instance_Metrics imetrics;
int i, n;
TT_UShort platform, encoding;
TT_Error error;
font = (TTF_Font *)malloc(sizeof(*font));
if ( font == NULL ) {
SDL_SetError("Out of memory");
return(NULL);
}
memset(font, 0, sizeof(*font));
/* Open the font and create ancillary data */
error = TT_Open_Face(engine, file, &font->face);
if ( error ) {
SDL_SetError("Couldn't load font file");
free(font);
return(NULL);
}
error = TT_New_Glyph(font->face, &font->glyph);
if ( error ) {
SDL_SetError("Couldn't create glyph container");
TTF_CloseFont(font);
return(NULL);
}
error = TT_New_Instance(font->face, &font->inst);
if ( error ) {
SDL_SetError("Couldn't create font instance");
TTF_CloseFont(font);
return(NULL);
}
/* Set the display resolution */
error = TT_Set_Instance_Resolutions(font->inst, 72, 72);
if ( error ) {
SDL_SetError("Couldn't set font resolution");
TTF_CloseFont(font);
return(NULL);
}
error = TT_Set_Instance_CharSize(font->inst, ptsize*64);
if ( error ) {
SDL_SetError("Couldn't set font size");
TTF_CloseFont(font);
return(NULL);
}
/* Get a Unicode mapping for this font */
n = TT_Get_CharMap_Count(font->face);
for ( i=0; i<n; ++i ) {
TT_Get_CharMap_ID(font->face, i, &platform, &encoding);
if ( ((platform == TT_PLATFORM_MICROSOFT) &&
(encoding == TT_MS_ID_UNICODE_CS)) ||
((platform == TT_PLATFORM_APPLE_UNICODE) &&
(encoding == TT_APPLE_ID_DEFAULT)) ) {
TT_Get_CharMap(font->face, i, &font->map);
break;
}
}
if ( i == n ) {
SDL_SetError("Font doesn't have a Unicode mapping");
TTF_CloseFont(font);
return(NULL);
}
/* Get the font metrics for this font */
TT_Get_Face_Properties(font->face, &properties );
TT_Get_Instance_Metrics(font->inst, &imetrics);
font->pointsize = imetrics.y_ppem;
font->ascent = (float)properties.horizontal->Ascender /
properties.header->Units_Per_EM;
font->ascent *= font->pointsize;
font->descent = (float)properties.horizontal->Descender /
properties.header->Units_Per_EM;
font->descent *= font->pointsize;
font->lineskip = (float)properties.horizontal->Line_Gap /
properties.header->Units_Per_EM;
font->lineskip *= font->pointsize;
font->height = round(font->ascent - font->descent);
/* Set the default font style */
font->style = TTF_STYLE_NORMAL;
font->glyph_overhang = font->pointsize/10;
/* x offset = cos(((90.0-12)/360)*2*M_PI), or 12 degree angle */
font->glyph_italics = 0.207;
font->glyph_italics *= font->height;
return(font);
}
int
main( int argc, char** argv )
{
int i, orig_ptsize, file;
char filename[128 + 4];
char alt_filename[128 + 4];
char* execname;
int option;
int ptsize;
int num_Faces = 0;
int glyph_index = 0;
int load_flags = TTLOAD_DEFAULT;
int force_sbit = 0;
TT_Engine engine;
TT_Face face;
TT_Instance instance;
TT_Glyph glyph;
TT_Raster_Map map;
TT_Big_Glyph_Metrics metrics;
TT_Face_Properties properties;
TT_Instance_Metrics imetrics;
TT_EBLC eblc;
TT_SBit_Image* bitmap = NULL;
TT_Error error;
int res = 72;
#ifdef HAVE_LIBINTL_H
setlocale( LC_ALL, "" );
bindtextdomain( "freetype", LOCALEDIR );
textdomain( "freetype" );
#endif
execname = ft_basename( argv[0] );
while ( 1 )
{
option = ft_getopt( argc, argv, "c:r:i:B" );
if ( option == -1 )
break;
switch ( option )
{
case 'r':
res = atoi( ft_optarg );
if ( res < 1 )
usage( execname );
break;
case 'c':
num_Faces = atoi( ft_optarg );
if ( num_Faces < 0 )
usage( execname );
break;
case 'i':
glyph_index = atoi( ft_optarg );
if ( glyph_index < 0 )
usage( execname );
break;
case 'B':
force_sbit = 1;
break;
default:
usage( execname );
break;
}
}
argc -= ft_optind;
argv += ft_optind;
if ( argc <= 1 )
usage( execname );
if ( sscanf( argv[0], "%d", &orig_ptsize ) != 1 )
orig_ptsize = 64;
file = 1;
ptsize = orig_ptsize;
i = strlen( argv[file] );
while ( i > 0 && argv[file][i] != '\\' && argv[file][i] != '/' )
{
if ( argv[file][i] == '.' )
i = 0;
i--;
}
filename[128] = '\0';
alt_filename[128] = '\0';
strncpy( filename, argv[file], 128 );
strncpy( alt_filename, argv[file], 128 );
if ( i >= 0 )
{
strncpy( filename + strlen( filename ), ".ttf", 4 );
strncpy( alt_filename + strlen( alt_filename ), ".ttc", 4 );
}
/* Initialize engine */
error = TT_Init_FreeType( &engine );
if ( error )
{
fprintf( stderr, gettext( "Error while initializing engine.\n" ) );
goto Failure;
}
error = TT_Init_SBit_Extension( engine );
if ( error )
{
fprintf( stderr, gettext(
"Error while initializing embedded bitmap extension.\n" ) );
goto Failure;
}
/* Load face */
error = TT_Open_Face( engine, filename, &face );
if ( error == TT_Err_Could_Not_Open_File )
{
strcpy( filename, alt_filename );
error = TT_Open_Face( engine, alt_filename, &face );
}
if ( error == TT_Err_Could_Not_Open_File )
Panic( gettext( "Could not find or open %s.\n" ), filename );
if ( error )
{
fprintf( stderr, gettext( "Error while opening %s.\n" ),
filename );
goto Failure;
}
TT_Get_Face_Properties( face, &properties );
printf( gettext( "There are %d fonts in this collection.\n" ),
(int)(properties.num_Faces) );
if ( num_Faces >= properties.num_Faces )
Panic( gettext(
"There is no collection with index %d in this font file.\n" ),
num_Faces );
TT_Close_Face( face );
error = TT_Open_Collection( engine, filename, num_Faces, &face );
/* get face properties and eblc */
TT_Get_Face_Properties( face, &properties );
if ( force_sbit )
{
error = TT_Get_Face_Bitmaps( face, &eblc );
if ( error == TT_Err_Table_Missing )
Panic( gettext( "There is no embedded bitmap data in the font.\n" ) );
if ( error )
{
fprintf( stderr, gettext(
"Error while retrieving embedded bitmaps table.\n" ) );
goto Failure;
}
}
/* create glyph */
error = TT_New_Glyph( face, &glyph );
if ( error )
{
fprintf( stderr, gettext( "Could not create glyph container.\n" ) );
goto Failure;
}
/* create instance */
error = TT_New_Instance( face, &instance );
if ( error )
{
fprintf( stderr, gettext( "Could not create instance.\n" ) );
goto Failure;
}
error = TT_Set_Instance_Resolutions( instance, res, res );
if ( error )
{
fprintf( stderr, gettext( "Could not set device resolutions.\n" ) );
goto Failure;
}
error = TT_Set_Instance_CharSize( instance, ptsize*64 );
if ( error )
{
fprintf( stderr, gettext( "Could not reset instance.\n" ) );
goto Failure;
}
TT_Get_Instance_Metrics( instance, &imetrics );
printf( gettext( "Instance metrics: ppemX %d, ppemY %d\n" ),
imetrics.x_ppem,
imetrics.y_ppem );
if ( force_sbit )
{
error = TT_New_SBit_Image( &bitmap );
if ( error )
{
fprintf( stderr, gettext(
"Could not allocate glyph bitmap container.\n" ) );
goto Failure;
}
error = TT_Load_Glyph_Bitmap( face, instance, glyph_index, bitmap );
if ( error )
{
fprintf( stderr, gettext(
"Can't load bitmap for glyph %d.\n" ), glyph_index );
goto Failure;
}
Show_Metrics( bitmap->metrics, "SBit's metrics" );
printf( "SBit glyph:\n" );
Show_Single_Glyph( &bitmap->map );
}
else
{
TT_Load_Glyph( instance, glyph, glyph_index, load_flags );
TT_Get_Glyph_Big_Metrics( glyph, &metrics );
map.width = ( metrics.bbox.xMax - metrics.bbox.xMin ) / 64;
map.rows = ( metrics.bbox.yMax - metrics.bbox.yMin ) / 64;
map.cols = ( map.width + 7 ) / 8;
map.size = map.cols * map.rows;
map.bitmap = malloc( map.size );
map.flow = TT_Flow_Down;
memset( map.bitmap, 0, map.size );
error = TT_Get_Glyph_Bitmap( glyph, &map,
-metrics.bbox.xMin,
-metrics.bbox.yMin );
Show_Metrics( metrics, gettext( "Outline's metrics" ) );
printf( gettext( "Outline glyph\n" ) );
Show_Single_Glyph( &map );
}
free( map.bitmap );
if ( bitmap )
TT_Done_SBit_Image( bitmap );
TT_Done_Instance( instance );
TT_Done_Glyph( glyph );
TT_Done_FreeType( engine );
exit( EXIT_SUCCESS ); /* for safety reasons */
return 0; /* never reached */
Failure:
fprintf( stderr, " " );
fprintf( stderr, gettext( "FreeType error message: %s\n" ),
TT_ErrToString18( error ) );
exit( EXIT_FAILURE );
return 0; /* never reached */
}
static
int
i_tt_get_instance( TT_Fonthandle *handle, i_img_dim points, int smooth ) {
int i,idx;
TT_Error error;
mm_log((1,"i_tt_get_instance(handle %p, points %" i_DF ", smooth %d)\n",
handle, i_DFc(points), smooth));
if (smooth == -1) { /* Smooth doesn't matter for this search */
for(i=0;i<TT_CHC;i++) {
if (handle->instanceh[i].ptsize==points) {
mm_log((1,"i_tt_get_instance: in cache - (non selective smoothing search) returning %d\n",i));
return i;
}
}
smooth=1; /* We will be adding a font - add it as smooth then */
} else { /* Smooth doesn't matter for this search */
for(i=0;i<TT_CHC;i++) {
if (handle->instanceh[i].ptsize == points
&& handle->instanceh[i].smooth == smooth) {
mm_log((1,"i_tt_get_instance: in cache returning %d\n",i));
return i;
}
}
}
/* Found the instance in the cache - return the cache index */
for(idx=0;idx<TT_CHC;idx++) {
if (!(handle->instanceh[idx].order)) break; /* find the lru item */
}
mm_log((1,"i_tt_get_instance: lru item is %d\n",idx));
mm_log((1,"i_tt_get_instance: lru pointer %p\n",
USTRCT(handle->instanceh[idx].instance) ));
if ( USTRCT(handle->instanceh[idx].instance) ) {
mm_log((1,"i_tt_get_instance: freeing lru item from cache %d\n",idx));
/* Free cached glyphs */
for(i=0;i<256;i++)
if ( USTRCT(handle->instanceh[idx].glyphs[i].glyph) )
TT_Done_Glyph( handle->instanceh[idx].glyphs[i].glyph );
for(i=0;i<256;i++) {
handle->instanceh[idx].glyphs[i].ch = TT_NOCHAR;
USTRCT(handle->instanceh[idx].glyphs[i].glyph)=NULL;
}
/* Free instance if needed */
TT_Done_Instance( handle->instanceh[idx].instance );
}
/* create and initialize instance */
/* FIXME: probably a memory leak on fail */
(void) (( error = TT_New_Instance( handle->face, &handle->instanceh[idx].instance ) ) ||
( error = TT_Set_Instance_Resolutions( handle->instanceh[idx].instance, LTT_dpi, LTT_dpi ) ) ||
( error = TT_Set_Instance_CharSize( handle->instanceh[idx].instance, points*64 ) ) );
if ( error ) {
mm_log((1, "Could not create and initialize instance: error %x.\n",
(unsigned)error ));
return -1;
}
/* Now that the instance should the inplace we need to lower all of the
ru counts and put `this' one with the highest entry */
for(i=0;i<TT_CHC;i++) handle->instanceh[i].order--;
handle->instanceh[idx].order=TT_CHC-1;
handle->instanceh[idx].ptsize=points;
handle->instanceh[idx].smooth=smooth;
TT_Get_Instance_Metrics( handle->instanceh[idx].instance, &(handle->instanceh[idx].imetrics) );
/* Zero the memory for the glyph storage so they are not thought as
cached if they haven't been cached since this new font was loaded */
for(i=0;i<256;i++) {
handle->instanceh[idx].glyphs[i].ch = TT_NOCHAR;
USTRCT(handle->instanceh[idx].glyphs[i].glyph)=NULL;
}
return idx;
}
