nihilazo
/
rockbox
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rockbox/tools/convttf.c

1362 lines
38 KiB
C
Raw Permalink Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2007 Jonas Hurrelmann
*
* A command-line tool to convert ttf file to bitmap fonts
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_GLYPH_H
#include <stdio.h>
#ifdef WIN32
#ifdef _MSC_VER
#define snprintf _snprintf
#endif
#else
#include <stdlib.h>
#include <unistd.h>
#endif
#include FT_SFNT_NAMES_H
#include FT_TRUETYPE_TABLES_H
#include <string.h>
/*
* Set the default values used to generate a BDF font.
*/
#ifndef DEFAULT_PLATFORM_ID
#define DEFAULT_PLATFORM_ID 3
#endif
#ifndef DEFAULT_ENCODING_ID
#define DEFAULT_ENCODING_ID 1
#endif
#define ABS(x) (((x) < 0) ? -(x) : (x))
#define VERSION "RB12"
/*
* nameID macros for getting strings from the OT font.
*/
enum {
BDFOTF_COPYRIGHT_STRING = 0,
BDFOTF_FAMILY_STRING,
BDFOTF_SUBFAMILY_STRING,
BDFOTF_UNIQUEID_STRING,
BDFOTF_FULLNAME_STRING,
BDFOTF_VENDOR_STRING,
BDFOTF_POSTSCRIPT_STRING,
BDFOTF_TRADEMARK_STRING,
};
/*
* String names for the string indexes. Used for error messages.
*/
static char *string_names[] = {
"\"Copyright\"",
"\"Family\"",
"\"SubFamily\"",
"\"Unique ID\"",
"\"Full Name\"",
"\"Vendor\"",
"\"Postscript Name\"",
"\"Trademark\""
};
/*
* The default platform and encoding ID's.
*/
static int pid = DEFAULT_PLATFORM_ID;
static int eid = DEFAULT_ENCODING_ID;
/*
* A flag indicating if a CMap was found or not.
*/
static FT_UShort nocmap;
int pct = 0; /* display ttc table if it is not zero. */
FT_Long max_char = 65535;
int pixel_size = 15;
FT_Long start_char = 0;
FT_Long limit_char;
FT_Long firstchar = 0;
FT_Long lastchar;
FT_Long ttc_index = -1;
int flg_all_ttc = 0;
short antialias = 1; /* smooth fonts with gray levels */
int oflag = 0;
char outfile[1024];
float between_chr = 0.0f;
float between_row = 0.0f;
int hv_resolution = 60;
int dump_glyphs = 0;
int digits_equally_wide = 1; /* Try to make digits equally wide */
int trimming = 0;
int trim_dp = 0; /* trim descent percent */
int trim_da = 0; /* trim descnet actual */
int trim_ap = 0; /* trim ascent precent */
int trim_aa = 0; /* trim ascent actual */
int ft_load_opts = FT_LOAD_RENDER | FT_LOAD_NO_BITMAP;
struct font_header_struct {
char header[4]; /* magic number and version bytes */
unsigned short maxwidth; /* max width in pixels */
unsigned short height; /* height in pixels */
unsigned short ascent; /* ascent (baseline) height */
unsigned short depth; /* depth 0=1-bit, 1=4-bit */
unsigned long firstchar; /* first character in font */
unsigned long defaultchar; /* default character in font */
unsigned long size; /* # characters in font */
unsigned long nbits; /* # bytes imagebits data in file */ /* = bits_size */
FT_Long noffset; /* # longs offset data in file */
FT_Long nwidth; /* # bytes width data in file */
};
struct font_struct {
struct font_header_struct header;
unsigned char *chars_data;
unsigned short *offset;
FT_Long *offset_long;
unsigned char *width;
};
struct ttc_table{
FT_Long ttc_count;
char **ttf_name;
};
/* exit the program with given message */
static void
panic( const char* message)
{
fprintf( stderr, "%s\n", message );
exit( 1 );
}
static void
arg_panic( const char* message, const char* arg )
{
fprintf( stderr, "%s: %s\n", message, arg );
exit( 1 );
}
static int writebyte(FILE *fp, unsigned char c)
{
return putc(c, fp) != EOF;
}
static int writeshort(FILE *fp, unsigned short s)
{
putc(s, fp);
return putc(s>>8, fp) != EOF;
}
static int writeint(FILE *fp, unsigned int l)
{
putc(l, fp);
putc(l>>8, fp);
putc(l>>16, fp);
return putc(l>>24, fp) != EOF;
}
static int writestr(FILE *fp, char *str, int count)
{
return (int)fwrite(str, 1, count, fp) == count;
}
/* print usage information */
void usage(void)
{
char help[] = {
"Usage: convttf [options] [input-files]\n"
" convttf [options] [-o output-file] [single-input-file]\n\n"
" Default output-file : <font-size>-<basename>.fnt.\n"
" When '-ta' or '-tc' is specified in command line,\n "
" default output-file is: \n"
" <font-size>-<internal postscript-name of input-file>.fnt.\n"
"Options:\n"
" -s N Start output at character encodings >= N\n"
" -l N Limit output to character encodings <= N\n"
" -p N Font size N in pixel (default N=15)\n"
" -c N Character separation in pixel.Insert space between lines.\n"
" -x Trim glyphs horizontally of nearly empty space\n"
" (to improve spacing on V's W's, etc.)\n"
" -X Set the horizontal and vertical resolution (default: 60)\n"
" -TA N Trim vertical ascent (N percent)\n"
" -TD N Trim vertical descent (N percent)\n"
" -Ta N Trim vertical ascent (N pixels)\n"
" -Td N Trim vertical descent (N pixels)\n"
" -r N Row separation in pixel.Insert space between characters\n"
" -d Debug: print converted glyph images\n"
" -tt Display the True Type Collection tables available in the font\n"
" -t N Index of true type collection. It must be start from 0.(default N=0).\n"
" -ta Convert all fonts in ttc (ignores outfile option)\n"
" -w Don't try to make digits (0-9) equally wide\n"
" -L Use lighter hinting algorithm\n"
};
fprintf(stderr, "%s", help);
exit( 1 );
}
/* remove directory prefix and file suffix from full path*/
char *basename(char *path)
{
char *p, *b;
static char base[256];
/* remove prepended path and extension*/
b = path;
for (p=path; *p; ++p) {
#ifdef WIN32
if (*p == '/' || *p == '\\')
#else
if (*p == '/')
#endif
b = p + 1;
}
strcpy(base, b);
for (p=base; *p; ++p) {
if (*p == '.') {
*p = 0;
break;
}
}
return base;
}
void setcharmap(FT_Face face)
{
FT_Long i;
/*
* Get the requested cmap.
*/
for (i = 0; i < face->num_charmaps; i++) {
if (face->charmaps[i]->platform_id == pid &&
face->charmaps[i]->encoding_id == eid)
break;
}
if (i == face->num_charmaps && pid == 3 && eid == 1) {
/*
* Make a special case when this fails with pid == 3 and eid == 1.
* Change to eid == 0 and try again. This captures the two possible
* cases for MS fonts. Some other method should be used to cycle
* through all the alternatives later.
*/
for (i = 0; i < face->num_charmaps; i++) {
if (face->charmaps[i]->platform_id == pid &&
face->charmaps[i]->encoding_id == 0)
break;
}
if (i < face->num_charmaps) {
pid = 3;
eid = 1;
FT_Set_Charmap(face, face->charmaps[i]);
} else {
/*
* No CMAP was found.
*/
nocmap = 1;
pid = eid = -1;
}
} else {
FT_Set_Charmap(face, face->charmaps[i]);
nocmap = 0;
}
}
/*
* quote in otf2bdf.
* A generic routine to get a name from the OT name table. This routine
* always looks for English language names and checks three possibilities:
* 1. English names with the MS Unicode encoding ID.
* 2. English names with the MS unknown encoding ID.
* 3. English names with the Apple Unicode encoding ID.
*
* The particular name ID mut be provided (e.g. nameID = 0 for copyright
* string, nameID = 6 for Postscript name, nameID = 1 for typeface name.
*
* If the `dash_to_space' flag is non-zero, all dashes (-) in the name will be
* replaced with the character passed.
*
* Returns the number of bytes added.
*/
static int
otf_get_english_string(FT_Face face, int nameID, int dash_to_space,
char *name, int name_size)
{
int j, encid;
FT_UInt i, nrec;
FT_SfntName sfntName;
unsigned char *s = NULL;
unsigned short slen = 0;
nrec = FT_Get_Sfnt_Name_Count(face);
for (encid = 1, j = 0; j < 2; j++, encid--) {
/*
* Locate one of the MS English font names.
*/
for (i = 0; i < nrec; i++) {
FT_Get_Sfnt_Name(face, i, &sfntName);
if (sfntName.platform_id == 3 &&
sfntName.encoding_id == encid &&
sfntName.name_id == nameID &&
(sfntName.language_id == 0x0409 ||
sfntName.language_id == 0x0809 ||
sfntName.language_id == 0x0c09 ||
sfntName.language_id == 0x1009 ||
sfntName.language_id == 0x1409 ||
sfntName.language_id == 0x1809)) {
s = sfntName.string;
slen = sfntName.string_len;
break;
}
}
if (i < nrec) {
if (slen >> 1 >= name_size) {
fprintf(stderr, "warning: %s string longer than buffer."
"Truncating to %d bytes.\n", string_names[nameID], name_size);
slen = name_size << 1;
}
/*
* Found one of the MS English font names. The name is by
* definition encoded in Unicode, so copy every second byte into
* the `name' parameter, assuming there is enough space.
*/
for (i = 1; i < slen; i += 2) {
if (dash_to_space)
*name++ = (s[i] != '-') ? s[i] : ' ';
else if (s[i] == '\r' || s[i] == '\n') {
if (s[i] == '\r' && i + 2 < slen && s[i + 2] == '\n')
i += 2;
*name++ = ' ';
*name++ = ' ';
} else
*name++ = s[i];
}
*name = 0;
return (slen >> 1);
}
}
/*
* No MS English name found, attempt to find an Apple Unicode English
* name.
*/
for (i = 0; i < nrec; i++) {
FT_Get_Sfnt_Name(face, i, &sfntName);
if (sfntName.platform_id == 0 && sfntName.language_id == 0 &&
sfntName.name_id == nameID) {
s = sfntName.string;
slen = sfntName.string_len;
break;
}
}
if (i < nrec) {
if (slen >> 1 >= name_size) {
fprintf(stderr, "warning: %s string longer than buffer."
"Truncating to %d bytes.\n", string_names[nameID], name_size);
slen = name_size << 1;
}
/*
* Found the Apple Unicode English name. The name is by definition
* encoded in Unicode, so copy every second byte into the `name'
* parameter, assuming there is enough space.
*/
for (i = 1; i < slen; i += 2) {
if (dash_to_space)
*name++ = (s[i] != '-') ? s[i] : ' ';
else if (s[i] == '\r' || s[i] == '\n') {
if (s[i] == '\r' && i + 2 < slen && s[i + 2] == '\n')
i += 2;
*name++ = ' ';
*name++ = ' ';
} else
*name++ = s[i];
}
*name = 0;
return (slen >> 1);
}
return 0;
}
int get_ttc_table(char *path, struct ttc_table *ttcname )
{
FT_Error err;
FT_Library library;
FT_Face face;
FT_Long i;
char xlfd[BUFSIZ];
/* init number of ttf in ttc */
ttcname->ttc_count = 0;
/* Initialize engine */
if ( ( err = FT_Init_FreeType( &library ) ) != 0 )
{
panic( "Error while initializing engine" );
return err;
}
/* Load face */
err = FT_New_Face( library, path, (FT_Long) 0, &face );
if ( err )
{
arg_panic( "Could not find/open font", path );
return err;
}
ttcname->ttc_count = face->num_faces;
ttcname->ttf_name = malloc( sizeof(char*) * ttcname->ttc_count);
for(i = 0; i < ttcname->ttc_count; i++)
{
err = FT_New_Face( library, path, i, &face );
if ( err == FT_Err_Cannot_Open_Stream )
arg_panic( "Could not find/open font", path );
otf_get_english_string(face, BDFOTF_POSTSCRIPT_STRING, 0, xlfd,
sizeof(xlfd));
ttcname->ttf_name[i] = malloc(sizeof(char) * (strlen(xlfd) + 1 ));
strcpy(ttcname->ttf_name[i], xlfd);
}
return 0;
}
void print_ttc_table(char* path)
{
struct ttc_table ttcname;
FT_Long i;
get_ttc_table(path, &ttcname);
printf("ttc header count = %ld \n\n", ttcname.ttc_count);
printf("Encoding tables available in the true type collection\n\n");
printf("INDEX\tPOSTSCRIPT NAME\n");
printf("-----------------------------------------------------\n");
for(i = 0; i < ttcname.ttc_count; i++)
{
printf("%ld\t%s\n", i, ttcname.ttf_name[i]);
}
for(i = 0; i < ttcname.ttc_count; i++)
{
free(ttcname.ttf_name[i]);
}
printf("\n\n");
free(ttcname.ttf_name);
return;
}
FT_Long getcharindex(FT_Face face, FT_Long code)
{
FT_Long idx;
if (nocmap) {
if (code >= face->num_glyphs)
idx = 0;
else
idx = code;
} else
idx = FT_Get_Char_Index( face, code);
if ( idx <= 0 || idx > face->num_glyphs)
return 0;
else
return idx;
}
void print_raw_glyph( FT_Face face)
{
int pixel,row,col,width;
width = face->glyph->metrics.width >> 6;
printf("\n---Raw-Glyph---\n");
for(row=0; row < face->glyph->metrics.height >> 6; row++)
{
printf("_");
for(col=0; col < width; col++)
{
pixel = *(face->glyph->bitmap.buffer+width*row+col)/26;
if ( pixel ) printf("%d",pixel); else printf(" ");
}
printf("_\n");
}
printf("----End-----\n");
}
int glyph_width( FT_Face face, FT_Long code, FT_Long digit_width )
{
int width;
if (code >= '0' && code <= '9' && digit_width)
{
width = digit_width;
}
else
{
int pitch, h_adv;
unsigned spacing = (unsigned)(between_chr * (1<<6));/* convert to fixed point */
pitch = ABS(face->glyph->bitmap.pitch);
h_adv = face->glyph->metrics.horiAdvance >> 6;
width = (face->glyph->metrics.width + spacing) >> 6;
if(pitch == 0) pitch = h_adv;
if(width < pitch) width = pitch;
}
return width;
}
FT_Long check_digit_width( FT_Face face )
{
FT_Long code;
FT_Long last_advance = -1;
for (code='0'; code <= '9'; ++code)
{
FT_Glyph_Metrics* metrics;
FT_Load_Char(face, code, ft_load_opts);
metrics = &face->glyph->metrics;
if ((last_advance != -1 && last_advance != metrics->horiAdvance) ||
metrics->horiBearingX < 0)
{
last_advance = 0;
break;
}
last_advance = metrics->horiAdvance;
}
return last_advance >> 6;
}
void trim_glyph( FT_GlyphSlot glyph, int *empty_first_col,
int *empty_last_col, int *width )
{
int row;
int stride = glyph->bitmap.pitch;
int end = stride-1;
int trim_left = 2, trim_right = 2;
const unsigned char limit = 64u;
const unsigned char *image = glyph->bitmap.buffer;
if (*width < 2)
return; /* nothing to do? */
for(row=0; row< glyph->metrics.height >> 6; row++)
{
const unsigned char *column = image+row*stride;
if (*column++ < limit && trim_left)
{
if (*column >= limit/2)
trim_left = 1;
}
else
trim_left = 0;
column = image+row*stride+end;
if (*column-- < limit && trim_right)
{
if (*column >= limit/2)
trim_right = 1;
}
else
trim_right = 0;
}
(*width) -= trim_left + trim_right;
if (*width < 0) *width = 0;
*empty_first_col = trim_left;
*empty_last_col = trim_right;
}
void convttf(char* path, char* destfile, FT_Long face_index)
{
FT_Error err;
FT_Library library;
FT_Face face;
int w,h;
int row,col;
int empty_first_col, empty_last_col;
FT_Long charindex;
FT_Long idx = 0;
FT_Long code;
FT_Long digit_width = 0;
float extra_space;
FT_Long char_count;
char use_long_offset;
int done = 0;
char char_name[1024];
int converted_char_count = 0;
int failed_char_count = 0;
int depth = 2;
unsigned char bit_shift = 1u << depth;
unsigned char pixel_per_byte = CHAR_BIT / bit_shift;
struct font_struct export_font;
char pad[] = {0,0,0,0};
int skip,i;
FILE *file;
/* Initialize engine */
if ( ( err = FT_Init_FreeType( &library ) ) != 0 )
panic( "Error while initializing engine" );
/* Load face */
err = FT_New_Face( library, path, (FT_Long) face_index, &face );
if ( err == FT_Err_Cannot_Open_Stream )
arg_panic( "Could not find/open font\n", path );
else if ( err )
arg_panic( "Error while opening font\n", path );
setcharmap( face );
/* Set font header data */
export_font.header.header[0] = 'R';
export_font.header.header[1] = 'B';
export_font.header.header[2] = '1';
export_font.header.header[3] = '2';
#if 0
export_font.header.height = 0;
export_font.header.ascent = 0;
#endif
extra_space = (float)(between_row-trim_aa-trim_da);
FT_Set_Char_Size( face, 0, pixel_size << 6, hv_resolution, hv_resolution );
export_font.header.ascent =
((face->size->metrics.ascender*(100-trim_ap)/100) >> 6) - trim_aa;
export_font.header.height =
(((face->size->metrics.ascender*(100-trim_ap)/100) -
(face->size->metrics.descender*(100-trim_dp)/100)) >> 6) + extra_space;
printf("\n");
printf("Please wait, converting %s:\n", path);
/* "face->num_glyphs" is NG.; */
if ( limit_char == 0 ) limit_char = max_char;
if ( limit_char > max_char ) limit_char = max_char;
char_count = 0;
export_font.header.maxwidth = 1;
export_font.header.depth = 1;
firstchar = limit_char;
lastchar = start_char;
if (digits_equally_wide)
digit_width = check_digit_width(face);
/* calculate memory usage */
for(code = start_char; code <= limit_char ; code++ )
{
charindex = getcharindex( face, code);
if ( !(charindex) ) continue;
err = FT_Load_Glyph(face, charindex, ft_load_opts);
if ( err ) continue;
w = glyph_width( face, code, digit_width );
if (w == 0) continue;
empty_first_col = empty_last_col = 0;
if(trimming)
trim_glyph( face->glyph, &empty_first_col, &empty_last_col, &w);
if (export_font.header.maxwidth < w)
export_font.header.maxwidth = w;
char_count++;
idx += (w*export_font.header.height + pixel_per_byte - 1)/pixel_per_byte;
if (code >= lastchar)
lastchar = code;
if (code <= firstchar)
firstchar = code;
}
export_font.header.defaultchar = firstchar;
export_font.header.firstchar = firstchar;
export_font.header.size = lastchar - firstchar + 1;
export_font.header.nbits = idx;
export_font.header.noffset = export_font.header.size;
export_font.header.nwidth = export_font.header.size;
/* check if we need to use long offsets */
use_long_offset = (export_font.header.nbits >= 0xFFDB );
/* allocate memory */
export_font.offset = NULL;
export_font.offset_long = NULL;
if (use_long_offset)
export_font.offset_long =
malloc( sizeof(FT_Long)* export_font.header.noffset );
else
export_font.offset =
malloc( sizeof(unsigned short)* export_font.header.noffset );
export_font.width =
malloc( sizeof(unsigned char) * export_font.header.nwidth );
export_font.chars_data =
malloc( sizeof(unsigned char) * export_font.header.nbits );
/* for now we use the full height for each character */
h = export_font.header.height;
idx = 0;
for( code = firstchar; code <= lastchar; code++ )
{
FT_GlyphSlot slot;
FT_Bitmap* source;
unsigned char* src;
unsigned char* tmpbuf;
int start_y;
int glyph_height;
int stride;
unsigned char* buf;
unsigned char* endbuf;
/* insert empty pixels on the left */
int col_off;
int numbits;
unsigned int field;
/* Get gylph index from the char and render it */
charindex = getcharindex( face, code);
if ( !charindex )
{
if ( use_long_offset )
export_font.offset_long[code - firstchar] = export_font.offset_long[0];
else
export_font.offset[code - firstchar] = export_font.offset[0];
export_font.width[code - firstchar] = export_font.width[0];
continue;
}
err = FT_Load_Glyph(face, charindex, ft_load_opts);
if ( err ) {
continue;
}
if FT_HAS_GLYPH_NAMES( face )
FT_Get_Glyph_Name( face, charindex, char_name, 16);
else
char_name[0] = '\0';
slot = face->glyph;
source = &slot->bitmap;
#if 0
print_raw_glyph( face );
#endif
w = glyph_width( face, code, digit_width );
if (w == 0) continue;
empty_first_col = empty_last_col = 0;
if(trimming)
trim_glyph( face->glyph, &empty_first_col, &empty_last_col, &w );
if ( use_long_offset )
export_font.offset_long[code - firstchar] = idx;
else
export_font.offset[code - firstchar] = idx;
export_font.width[code - firstchar] = w;
/* copy the glyph bitmap to a full sized glyph bitmap */
src = source->buffer;
tmpbuf = malloc(sizeof(unsigned char) * w * h);
memset(tmpbuf, 0xff, w*h);
start_y = export_font.header.ascent - slot->bitmap_top;
glyph_height = source->rows;
stride = source->pitch;
buf = tmpbuf;
endbuf = tmpbuf + w*h;
err = 0;
/* insert empty pixels on the left */
col_off = w - stride;
if (col_off > 1) col_off /= 2;
if (col_off < 0) col_off = 0;
for(row=0; row < glyph_height; row++)
{
if(row+start_y < 0 || row+start_y >= h)
continue;
for(col = empty_first_col; col < stride; col++)
{
unsigned char *tsrc, *dst;
dst = buf + (w*(start_y+row)) + col + col_off;
tsrc = src + stride*row + col;
if (dst < endbuf && dst >= tmpbuf)
*dst = 0xff - *tsrc;
else {
err = 1;
printf("Error! row: %3d col: %3d\n", row, col);
}
}
}
if(err) print_raw_glyph(face);
buf = tmpbuf;
field = 0;
numbits = pixel_per_byte;
for(row=0; row < h; row++)
{
for(col=0; col < w; col++)
{
unsigned int src2 = *buf++;
unsigned int cur_col = (src2 + 8) / 17;
field |= (cur_col << (bit_shift*(pixel_per_byte-numbits)));
if (--numbits == 0)
{
export_font.chars_data[idx++] = (unsigned char)field;
numbits = pixel_per_byte;
field = 0;
}
}
}
/* Pad last byte */
if (numbits != pixel_per_byte)
{
export_font.chars_data[idx++] = (unsigned char)field;
}
if( dump_glyphs )
{
/* debug: dump char */
unsigned char bit_max = (1 << bit_shift) - 1;
printf("\n---Converted Glyph Dump---\n");
if ( code > 32 && code < 255 ) {
unsigned char current_data;
unsigned char font_bits;
row = h;
if(use_long_offset)
buf = &(export_font.chars_data[export_font.offset_long[
code - firstchar]]);
else
buf = &(export_font.chars_data[export_font.offset[
code - firstchar]]);
numbits = pixel_per_byte;
current_data = *buf;
do
{
col = w;
printf("-");
do
{
font_bits = current_data & bit_max;
if (font_bits==bit_max)
printf(" ");
else
{
if(font_bits > bit_max/2)
printf(".");
else
printf("@");
}
if (--numbits == 0)
{
current_data = *(++buf);
numbits = pixel_per_byte;
}
else
{
current_data >>= bit_shift;
}
} while (--col);
printf("-\n");
} while (--row);
}
buf = NULL;
printf("---End Glyph Dump---\n");
}
free(tmpbuf);
converted_char_count++;
done = (100*(converted_char_count))/char_count;
printf("Converted %s %d (%d%%)\e[K\r",
char_name,converted_char_count,done); fflush(stdout);
}
file = fopen(destfile, "wb");
printf("Writing %s\n", destfile);
/* font info */
writestr(file, VERSION, 4);
writeshort(file, export_font.header.maxwidth);
writeshort(file, export_font.header.height);
writeshort(file, export_font.header.ascent);
writeshort(file, export_font.header.depth);
writeint(file, export_font.header.firstchar);
writeint(file, export_font.header.defaultchar);
writeint(file, export_font.header.size);
writeint(file, export_font.header.nbits);
writeint(file, export_font.header.noffset);
writeint(file, export_font.header.nwidth);
fwrite( (char*)export_font.chars_data, 1,
export_font.header.nbits, file);
free(export_font.chars_data);
if ( use_long_offset )
{
skip = ((export_font.header.nbits + 3) & ~3) -
export_font.header.nbits;
fwrite(pad, 1, skip, file); /* pad */
for(i = 0; i < export_font.header.noffset; i++)
writeint(file, export_font.offset_long[i]);
}
else
{
skip = ((export_font.header.nbits + 1) & ~1) -
export_font.header.nbits;
fwrite(pad, 1, skip, file); /* pad */
for(i = 0; i < export_font.header.noffset; i++)
writeshort(file, export_font.offset[i]);
}
for(i = 0; i < export_font.header.nwidth; i++)
writebyte(file, export_font.width[i]);
free(export_font.width);
if ( use_long_offset )
free(export_font.offset_long);
else
free(export_font.offset);
fclose(file);
FT_Done_Face( face );
FT_Done_FreeType( library );
printf("done (converted %d glyphs, %d errors).\e[K\n\n",
converted_char_count, failed_char_count);
}
void convttc(char* path)
{
struct ttc_table ttcname;
FT_Long i;
get_ttc_table(path, &ttcname);
if (ttcname.ttc_count == 0)
{
printf("This file is a not true type font.\n");
return;
}
/* default */
if (!flg_all_ttc && ttc_index == -1)
{
if (!oflag)
{ /* generate filename */
snprintf(outfile, sizeof(outfile),
"%d-%s.fnt", pixel_size, basename(path));
}
convttf(path, outfile, (FT_Long) 0);
}
/* set face_index of ttc */
else if (!flg_all_ttc)
{
print_ttc_table(path);
if ( !oflag )
{
if (ttc_index >= 0 &&
ttc_index < ttcname.ttc_count)
{
if (strcmp(ttcname.ttf_name[ttc_index], "") != 0)
{
snprintf(outfile, sizeof(outfile), "%d-%s.fnt",
pixel_size, ttcname.ttf_name[ttc_index]);
}
else
{
snprintf(outfile, sizeof(outfile), "%d-%s-%ld.fnt",
pixel_size, basename(path), ttc_index);
}
}
else
{
printf("illegal face index of ttc.\n");
}
}
convttf(path, outfile, ttc_index);
}
else { /* convert all fonts */
print_ttc_table(path);
for(i = 0; i < ttcname.ttc_count; i++)
{
snprintf(outfile, sizeof(outfile), "%d-%s.fnt",
pixel_size, ttcname.ttf_name[i]);
convttf(path, outfile, i);
}
}
for(i = 0; i < ttcname.ttc_count; i++)
{
free(ttcname.ttf_name[i]);
}
free(ttcname.ttf_name);
}
/* parse command line options*/
void getopts(int *pac, char ***pav)
{
char *p;
char **av;
int ac;
ac = *pac;
av = *pav;
limit_char = max_char;
start_char = 0;
while (ac > 0 && av[0][0] == '-') {
p = &av[0][1];
while( *p)
switch(*p++) {
case 'h':case 'H':
usage();
break;
case ' ': /* multiple -args on av[]*/
while( *p && *p == ' ')
p++;
if( *p++ != '-') /* next option must have dash*/
p = "";
break; /* proceed to next option*/
case 'o': /* set output file*/
oflag = 1;
if (*p) {
strcpy(outfile, p);
while (*p && *p != ' ')
p++;
}
else {
av++; ac--;
if (ac > 0)
strcpy(outfile, av[0]);
}
break;
case 'l': /* set encoding limit*/
if (*p) {
limit_char = atoi(p);
while (*p && *p != ' ')
p++;
}
else {
av++; ac--;
if (ac > 0)
limit_char = atoi(av[0]);
}
break;
case 's': /* set encoding start*/
if (*p) {
start_char = atol(p);
while (*p && *p != ' ')
p++;
}
else {
av++; ac--;
if (ac > 0)
start_char = atol(av[0]);
}
break;
case 'p': /* set pixel size*/
if (*p) {
pixel_size = atoi(p);
while (*p && *p != ' ')
p++;
}
else {
av++; ac--;
if (ac > 0)
pixel_size = atoi(av[0]);
}
break;
case 'c': /* set spaece between characters */
{
if (*p) {
between_chr = atof(p);
while (*p && *p != ' ')
p++;
}
else {
av++; ac--;
if (ac > 0)
between_chr = atof(av[0]);
}
break;
}
case 'd':
dump_glyphs = 1;
while (*p && *p != ' ')
p++;
break;
case 'x':
trimming = 1;
while (*p && *p != ' ')
p++;
break;
case 'X':
if (*p) {
hv_resolution = atoi(p);
while (*p && *p != ' ')
p++;
}
else {
av++; ac--;
if (ac > 0)
hv_resolution = atoi(av[0]);
}
break;
case 'r':
if (*p) {
between_row = atof(p);
while (*p && *p != ' ')
p++;
}
else {
av++; ac--;
if (ac > 0)
between_row = atof(av[0]);
}
break;
case 'T':
if(*p == 'A') {
if(*(++p)) {
trim_ap = atoi(p);
while (*p && *p != ' ')
p++;
}
else {
av++; ac--;
if (ac > 0)
trim_ap = atoi(av[0]);
}
break;
}
if(*p == 'D') {
if(*(++p)) {
trim_dp = atoi(p);
while (*p && *p != ' ')
p++;
}
else {
av++; ac--;
if (ac > 0)
trim_dp = atoi(av[0]);
}
break;
}
if(*p == 'a') {
if(*(++p)) {
trim_aa = atoi(p);
while (*p && *p != ' ')
p++;
}
else {
av++; ac--;
if (ac > 0)
trim_aa = atoi(av[0]);
}
break;
}
if(*p == 'd') {
if(*(++p)) {
trim_da = atoi(p);
}
else {
av++; ac--;
if (ac > 0)
trim_da = atoi(av[0]);
}
break;
}
fprintf(stderr, "Unknown option ignored: %s\n", p-1);
while (*p && *p != ' ')
p++;
break;
case 't': /* display ttc table */
if (*p == 't') {
pct = 1;
while (*p && *p != ' ')
p++;
}
else if (*p == 'a') {
flg_all_ttc = 1;
while (*p && *p != ' ')
p++;
}
else if (*p) {
ttc_index = atoi(p);
while (*p && *p != ' ')
p++;
}
else {
av++; ac--;
if (ac > 0)
ttc_index = atoi(av[0]);
}
break;
case 'w': /* Don't try to make digits equally wide */
digits_equally_wide = 0;
while (*p && *p != ' ')
p++;
break;
case 'L': /* Light rendering algorithm */
ft_load_opts |= FT_LOAD_TARGET_LIGHT;
break;
default:
fprintf(stderr, "Unknown option ignored: %s\n", p-1);
while (*p && *p != ' ')
p++;
}
++av; --ac;
}
*pac = ac;
*pav = av;
}
int main(int ac, char **av)
{
int ret = 0;
++av; --ac; /* skip av[0]*/
getopts(&ac, &av); /* read command line options*/
if (ac < 1)
{
usage();
}
if (oflag)
{
if (ac > 1)
{
usage();
}
}
if (limit_char < start_char)
{
usage();
exit(0);
}
while (pct && ac > 0)
{
print_ttc_table(av[0]);
++av; --ac;
exit(0);
}
while (ac > 0)
{
convttc(av[0]);
++av; --ac;
}
exit(ret);
}
/*
* Trie node structure.
*/
typedef struct {
unsigned short key; /* Key value. */
unsigned short val; /* Data for the key. */
unsigned long sibs; /* Offset of siblings from trie beginning. */
unsigned long kids; /* Offset of children from trie beginning. */
} node_t;
/*
* The trie used for remapping codes.
*/
static node_t *nodes;
static unsigned long nodes_used = 0;
int
otf2bdf_remap(unsigned short *code)
{
unsigned long i, n, t;
unsigned short c, codes[2];
/*
* If no mapping table was loaded, then simply return the code.
*/
if (nodes_used == 0)
return 1;
c = *code;
codes[0] = (c >> 8) & 0xff;
codes[1] = c & 0xff;
for (i = n = 0; i < 2; i++) {
t = nodes[n].kids;
if (t == 0)
return 0;
for (; nodes[t].sibs && nodes[t].key != codes[i]; t = nodes[t].sibs);
if (nodes[t].key != codes[i])
return 0;
n = t;
}
*code = nodes[n].val;
return 1;
}
Reference in New Issue View Git Blame Copy Permalink