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