mnerv/freetype
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
5edbb7a80a158583a81de286b7fcc5392916ba38
freetype/contrib/ttf2pfb/ttf2pfb.c
mnerv 5edbb7a80a FreeType 1.31.1
2023-08-27 18:03:45 +02:00

1726 lines
43 KiB
C
Raw Blame History

/*
* ttf2pfb.c -- TrueType to PostScript Type 1 Font converter.
*
* Author: Chun-Yu Lee <d791013@ce.ntu.edu.tw>
* Maintainer: Werner Lemberg <wl@gnu.org>
*
* The generated output is in a raw Type 1 Font format. An encoder
* (e.g. t1asm or t1binary) is needed to convert it into PFA or PFB format.
*
* This program was adapted from the ntu2cjk package (which was part of the
* LaTeX2e CJK package (by Werner Lemberg <wl@gnu.org>)).
*
*
* Modified by Joachim H. Kaiser <jhk@cmpnetmail.com> to include real glyph
* names and other font infos (see PS_Head function).
* The test programs of the FreeType distribution have been heavily used as
* templates.
*
*/
/*
* Requirements:
* - the FreeType library.
* - t1asm or a similar converter if PFA or PFB format is required.
* - getafm or a similar program if AFM font metrics are required.
* - afm2tfm or a similar program if TFM font metrics are required.
* - for compact fonts: the CJK package for typesetting LaTeX documents.
* - dvips 5.66 or higher if self-contained PostScript document
* outputs with partially downloaded fonts are required. Note that
* the partial download code in dvips is still buggy, causing strange
* error messages during loading of the created PS fonts.
* - Ghostscript 3.33 or newer (this is optional).
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#ifdef TM_IN_SYS_TIME
#include <sys/time.h>
#endif
#include <ctype.h>
#include "freetype.h"
#include "extend/ftxpost.h" /* we are in the FreeType package tree */
char rcsid[] = "$Id: ttf2pfb.c,v 1.13 1999/08/20 13:14:26 werner Exp $";
#define PID_UNICODE 3
#define EID_UNICODE 1
#define PID_SJIS 3
#define EID_SJIS 2
#define PID_GB 3
#define EID_GB 3
#define PID_BIG5 3
#define EID_BIG5 4
#define PID_KS 3 /* KS is also called Wansung */
#define EID_KS 5
#define PID_JOHAB 3
#define EID_JOHAB 6
/* Set default values */
#ifndef DEFAULT_PLATFORM_ID
#define DEFAULT_PLATFORM_ID PID_UNICODE /* MS platform */
#endif
#ifndef DEFAULT_ENCODING_ID
#define DEFAULT_ENCODING_ID EID_UNICODE
#endif
/* The possible values for the `force_enc' variable. */
typedef enum enc_type_
{
GB = 1, Big5, JIS, KS, Johab, SJIS, X
} enc_type;
/* A variable to enforce a certain font encoding (if > 0). */
enc_type force_enc = 0;
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
#ifndef FAILURE
#define FAILURE -1
#endif
#define LINELEN 40 /* max # of columns of code range file */
#define NAMELEN 80 /* max length of name used from LookUp */
/*
* Flags and globals
*/
int verbose = FALSE; /* messages should be printed or not. */
int compact = FALSE; /* generate compact font? */
int keep = FALSE; /* keep output font in case of error? */
int mapping = FALSE; /* use encoding file as mapping? */
float fontShift = 0;
#ifndef UShort
typedef unsigned short UShort;
#endif
#ifndef UChar
typedef unsigned char UChar;
#endif
#define TT_Flag_On_Curve 1
/* default platform and encoding ID's. */
int pid = DEFAULT_PLATFORM_ID;
int eid = DEFAULT_ENCODING_ID;
char* prog; /* program name */
/* for orthogonality with fprintf */
#define Fputs(_string_) fprintf(out, "%s\n", _string_)
/* Postscript font related defines and functions */
TT_F26Dot6 lastpsx, lastpsy;
#define Coord(x) (int)(x)
#define PS_LastPt(x, y) lastpsx = x; lastpsy = y
#define PS_Moveto(x, y) \
fprintf(out, "%d %d rmoveto\n", \
Coord(x - lastpsx), Coord(y - lastpsy)); \
PS_LastPt(x, y)
#define PS_Lineto(x, y) \
fprintf(out, "%d %d rlineto\n", \
Coord(x - lastpsx), Coord(y - lastpsy)); \
PS_LastPt(x, y)
/*
* Freetype globals.
*/
TT_Engine engine;
TT_Face face;
TT_Instance instance;
TT_Glyph glyph;
TT_CharMap cmap;
TT_Error error;
TT_Post post;
TT_Outline outline;
TT_Glyph_Metrics metrics;
TT_Face_Properties properties;
/*
* Data structures defined for encoding vectors
*/
/*
* A code range file for the encoding vector of a font contains code
* range pairs, each pair a line. The values for the begin and end of the
* ranges are separated by ` - '. Note that the spaces before and after the
* minus sign are significant. The possible syntax is as follows:
*
* (Note that code ranges must appear in ascending order.)
*
* 1. Absolute range, i.e., the code is at least a two-byte number, e.g.:
*
* 0xA140 - 0xA17E
* 41280 - 41342
* 0xE00000 - 0xE000FF
*
* The first two lines represent the same range.
*
* 2. Relative range, i.e., the code is a one-byte number. If the line ends
* with a colon `:', it designates the high byte(s) range, otherwise the
* low byte range. If there is no high byte(s) range declared before the low
* byte range, the last defined high byte(s) range or `0x00 - 0x00:' will be
* used. e.g.:
*
* 0xA1 - 0xFE:
* 0x40 - 0x7E
* 0xA1 - 0xFE
*
* which is Big-5 Encoding.
*
* 3. Single code. Similar to absolute or relative range but the second
* number of the range is the same as the first number. E.g.:
*
* 0xA141 == 0xA141 - 0xA141
* 0xA1: == 0xA1 - 0xA1:
* 0xA1 == 0xA1 - 0xA1
*
* 4. If the high byte range is declared and there is no low byte range
* declared consecutively, the assumed low byte range is `0x00 - 0xFF'.
*
* 5. Comment line. A line starting with a hash mark `#' followed by any
* characters up to the end of the line is ignored. Blank lines are also
* discarded.
*/
typedef struct _EVHigh
{
UShort start, end;
} EVHigh;
typedef struct _EVLow
{
UChar start, end;
} EVLow;
typedef struct _EVcRange
{
EVHigh high;
UShort numLowRanges;
EVLow* low;
} EVcRange;
typedef struct _EncVec
{
UShort numCodeRanges;
EVcRange* codeRange;
} EncVec;
/* Select encoding vector with respect to pid and eid */
EncVec* eVecMap[5][10];
/* Select encoding vector with respect to force_enc */
EncVec* eVecMap_force[10];
/*************/
/* Functions */
/*************/
void
mesg(const char *msg, ...)
{
va_list ap;
va_start(ap, msg);
vfprintf(stderr, msg, ap);
va_end(ap);
}
/*
* Usage.
*/
void
Usage(int eval)
{
#ifdef DEBUG
mesg("Usage: %s [-h][-v][-c][-k][-m][-d charcode][-l][-ng][-nc]\n", prog);
#else
mesg("Usage: %s [-h][-v][-c][-k][-m]\n", prog);
#endif
mesg("\t[-pid id] [-eid id] [-force enc] [-enc file]\n");
mesg("\t[-plane pl] [-f fname] [-uid id] [-s shift]\n");
mesg("\t[-o output] [-ttf font.ttf | font.ttf]\n");
mesg("-h\t\tThis message.\n");
mesg("-v\t\tPrint messages during conversion.\n");
mesg("-c\t\tCompact font");
mesg(" (256 chars per font; useful for the CJK package).\n");
mesg("-k\t\tKeep output file in case of error.\n");
mesg("-m\t\tUse encoding file as mapping file.\n");
#ifdef DEBUG
mesg("-d charcode\tDebug CharString for the given character code.\n");
mesg("-l\t\tDisplay point labels.\n");
mesg("-ng\t\tDo not show glyph outline.\n");
mesg("-nc\t\tDo not show control paths.\n");
#endif
mesg("-pid id\t\tSet the platform ID [%d].\n", DEFAULT_PLATFORM_ID);
mesg("-eid id\t\tSet the encoding ID [%d].\n", DEFAULT_ENCODING_ID);
mesg("\t\t(Use a strange pid,eid pair to list all possible pid,eid)\n");
mesg("-force enc\tForce a certain encoding [none].\n");
mesg("\t\t(Possible values are `GB', `JIS', `KS', `SJIS', and `X').\n");
mesg("-enc file\tFile contains code ranges [none].\n");
mesg("-plane pl\tA single font plane [0x0].\n");
mesg("-f fname\tFont name [UNKNOWN].\n");
mesg("-uid id\t\tUnique font ID, for private fonts 4000000-4999999 [4999999].\n");
mesg("-s shift\tY-offset factor [%5.3f].\n", fontShift);
mesg("-o outfile\tSet the output filename [stdout].\n");
mesg("-ttf ttfpath\tThe TTF font pathname.\n");
exit(eval);
}
void
fatal(const char *msg,
...)
{
va_list ap;
va_start(ap, msg);
fprintf(stderr, "%s: ", prog);
vfprintf(stderr, msg, ap);
fprintf(stderr, "\n");
va_end(ap);
exit(FAILURE);
}
void
fatal_error(const char *msg,
...)
{
va_list ap;
va_start(ap, msg);
fprintf(stderr, "%s: Error code 0x%04lx: ", prog, error);
vfprintf(stderr, msg, ap);
fprintf(stderr, "\n");
va_end(ap);
exit(FAILURE);
}
/*
* Reallocate a pointer.
*/
void *
re_alloc(void* ptr,
size_t size,
char* sub)
{
register void* value = realloc(ptr, size);
if (value == NULL)
fatal("%s: Virtual memory exhausted", sub);
return value;
}
/*
* We have to introduce the `dummy' integer to assure correct handling of
* the stack. Using `UShort' as the first parameter may fail in case
* this type is promoted to a different type (as happens e.g. under
* emx for DOS).
*/
EncVec*
Alloc_EncVec(int dummy,
...)
{
va_list vp;
EncVec* encVec = NULL;
EVcRange* cRange = NULL;
EVLow* evLow = NULL;
UShort numCR, numLows;
int i, j;
va_start(vp, dummy);
numCR = va_arg(vp, UShort);
encVec = re_alloc(encVec, 1 * sizeof (EncVec), "Alloc_EncVec");
encVec->numCodeRanges = numCR;
cRange = re_alloc(cRange, numCR * sizeof (EVcRange), "Alloc_EncVec");
for (i = 0; i < numCR; i++)
{
(cRange + i)->high.start = va_arg(vp, UShort);
(cRange + i)->high.end = va_arg(vp, UShort);
(cRange + i)->numLowRanges = numLows = va_arg(vp, UShort);
evLow = NULL;
evLow = re_alloc(evLow, numLows * sizeof (EVLow), "Alloc_EncVec");
for (j = 0; j < numLows; j++)
{
(evLow + j)->start = va_arg(vp, UChar);
(evLow + j)->end = va_arg(vp, UChar);
}
(cRange + i)->low = evLow;
}
encVec->codeRange = cRange;
va_end(vp);
return encVec;
}
void
Known_Encodings(void)
{
EncVec* encVec;
/* Big-5 encoding */
encVec = Alloc_EncVec(1,
1, 0xA1, 0xFE,
2, 0x40, 0x7E, 0xA1, 0xFE);
eVecMap[PID_BIG5][EID_BIG5] = encVec;
eVecMap_force[Big5] = encVec;
/* GB encoding */
encVec = Alloc_EncVec(2,
1, 0xA1, 0xF7,
1, 0xA1, 0xFE);
eVecMap[PID_GB][EID_GB] = encVec;
eVecMap_force[GB] = encVec;
/* KS encoding */
encVec = Alloc_EncVec(3,
1, 0xA1, 0xFE,
1, 0xA1, 0xFE);
eVecMap[PID_KS][EID_KS] = encVec;
eVecMap_force[KS] = encVec;
/* Johab encoding */
encVec = Alloc_EncVec(4,
3, 0x84, 0xD3,
2, 0x41, 0x7E,
0x81, 0xFE,
0xD8, 0xDE,
2, 0x31, 0x7E,
0x91, 0xFE,
0xE0, 0xF9,
2, 0x31, 0x7E,
0x91, 0xFE);
eVecMap[PID_JOHAB][EID_JOHAB] = encVec;
eVecMap_force[Johab] = encVec;
/* JIS encoding */
encVec = Alloc_EncVec(5,
1, 0xA1, 0xF4,
1, 0xA1, 0xFE);
eVecMap_force[JIS] = encVec;
eVecMap_force[X] = encVec; /* will be internally translated to SJIS */
/* Unicode encoding */
encVec = Alloc_EncVec(6,
1, 0x00, 0xFF,
1, 0x00, 0xFF);
eVecMap[PID_UNICODE][EID_UNICODE] = encVec;
/* SJIS encoding */
encVec = Alloc_EncVec(7,
3, 0x0, 0x0,
1, 0xA1, 0xDF,
0x81, 0x9F,
2, 0x40, 0x7E,
0x80, 0xFC,
0xE0, 0xEF,
2, 0x40, 0x7E,
0x80, 0xFC);
eVecMap[PID_SJIS][EID_SJIS] = encVec;
eVecMap_force[SJIS] = encVec;
}
/*
* Convert JIS to SJIS encoding.
*/
UShort
JIS_to_SJIS(UShort code)
{
UShort index;
UShort cc0 = (code >> 8) & 0xFF;
UShort cc1 = code & 0xFF;
index = (cc0 - 0xa1) * (0xfe - 0xa1 + 1) + (cc1 - 0xa1);
cc0 = index / ((0x7e - 0x40 + 1) + (0xfc - 0x80 + 1));
cc1 = index % ((0x7e - 0x40 + 1) + (0xfc - 0x80 + 1));
if (cc0 < (0x9f - 0x81 + 1))
cc0 += 0x81;
else
cc0 += 0xe0 - (0x9f - 0x81 + 1);
if (cc1 < (0x7e - 0x40 + 1))
cc1 += 0x40;
else
cc1 += 0x80 - (0x7E - 0x40 + 1);
return (cc0 << 8) + cc1;
}
/*
* Open TTF file and select cmap.
*/
int
Init_Font_Engine(char* infile)
{
UShort cmapindex, platformID, encodingID, num_cmap;
if (verbose)
printf("Initializing TrueType font engine...\n");
/* initialization of the FreeType engine */
error = TT_Init_FreeType(&engine);
if (error)
fatal_error("Couldn't initialize FreeType engine");
/* initialization of the post extension */
error = TT_Init_Post_Extension(engine);
if (error)
fatal_error("Couldn't initialize the post extension");
/* open the input file */
error = TT_Open_Face(engine, infile, &face);
if (error)
fatal_error("Unable to open input file `%s'", infile);
/* load full post table */
error = TT_Load_PS_Names(face, &post);
if (error)
fatal_error("Unable to load post table");
/* get face properties */
TT_Get_Face_Properties(face, &properties);
/* Load the instance. */
error = TT_New_Instance(face, &instance);
if (error)
fatal_error("Couldn't create instance");
error = TT_Set_Instance_Resolutions(instance, 600, 600);
if (error)
fatal_error("Error setting resolutions");
error = TT_Set_Instance_CharSize(instance, 120 * 64);
if (error)
fatal_error("Error setting character size");
error = TT_New_Glyph(face, &glyph);
if (error)
fatal_error("Couldn't create new glyph");
/* Get the requested cmap. */
num_cmap = TT_Get_CharMap_Count(face);
for (cmapindex = 0; cmapindex < num_cmap; cmapindex++)
{
TT_Get_CharMap_ID(face, cmapindex, &platformID, &encodingID);
if (platformID == pid && encodingID == eid)
break;
}
if (cmapindex == num_cmap)
{
mesg("Possible platform and encoding ID pairs:");
for (cmapindex = 0; cmapindex < num_cmap; cmapindex++)
{
TT_Get_CharMap_ID(face, cmapindex, &platformID, &encodingID);
mesg(" (%d, %d)", platformID, encodingID);
}
mesg ("\n");
fatal("No character map for given platform %d, encoding %d", pid, eid);
}
/* malloc for glyph data */
error = TT_Get_CharMap(face, cmapindex, &cmap);
if (error)
fatal_error("Cannot load cmap");
return TRUE;
}
/*
* Get font infos: name, version, copyright.
*/
char*
LookUp_Name(int index)
{
UShort platform, encoding, language, id;
char* string;
UShort string_len;
UShort i, n;
n = properties.num_Names;
for (i = 0; i < n; i++)
{
TT_Get_Name_ID(face, i, &platform, &encoding, &language, &id);
TT_Get_Name_String(face, i, &string, &string_len);
if (id == index)
break;
}
i = (string_len > NAMELEN) ? NAMELEN : string_len;
string[i] = '\0';
return string;
}
/*
* Load a glyph's outline and metrics.
*/
int
LoadTrueTypeChar(int idx)
{
TT_Matrix scale = {(1 << 16) / 64, 0, 0, (1 << 16) / 64};
error = TT_Load_Glyph(instance, glyph, idx, TTLOAD_DEFAULT);
if (error)
fatal_error("Load glyph");
error = TT_Get_Glyph_Outline(glyph, &outline);
if (error)
fatal_error("Get glyph outlines");
TT_Transform_Outline(&outline, &scale);
error = TT_Get_Glyph_Metrics(glyph, &metrics);
if (error)
fatal_error("Get glyph_metrics");
return TRUE;
}
/*
* Get PS name of a glyph.
*/
char*
PS_GlyphName(UShort idx,
UShort code)
{
char *glyphname = ".notdef";
static char CJK_glyphname[8];
if (compact)
{
sprintf(CJK_glyphname, "cjk%04X", code);
glyphname = CJK_glyphname;
}
else
{
if (idx)
TT_Get_PS_Name(face, idx, &glyphname);
}
return glyphname;
}
/*
* Header of Type 1 font.
*/
void
PS_Head(FILE *out,
int plane,
EncVec* planeEV,
char* font,
int UID)
{
EVcRange* cRange = planeEV->codeRange;
UShort numCR = planeEV->numCodeRanges;
int cjk = 0, nGlyph = 0, irange;
EVLow* pLow = cRange->low;
UShort nLow = cRange->numLowRanges;
int ipl, ilow, ich;
int idx;
UShort code;
time_t curtime;
struct tm *loctime;
char text[NAMELEN];
char fam_name[NAMELEN];
char* version;
char fullname[NAMELEN];
char copyright[NAMELEN];
/* Get the current time with local representation */
curtime = time(NULL);
loctime = localtime(&curtime);
/* Get font infos: family name, version, notice */
strcpy(fullname, LookUp_Name(6));
strcpy(fam_name, LookUp_Name(1));
strcpy(text, LookUp_Name(5));
version = &text[strcspn(text, "1234567890.")];
version[strspn(version, "1234567890.")] = '\0';
strcpy(copyright, LookUp_Name(0));
fprintf(out, "%%!FontType1-1.0: %s %s\n", font, version);
fprintf(out, "%%%%Creator: %s, ", prog);
fprintf(out, "%s\n", rcsid);
fprintf(out, "%%%%CreationDate: %s", asctime(loctime));
Fputs("%%VMusage: 030000 030000");
Fputs("11 dict begin");
Fputs("/FontInfo 8 dict dup begin");
fprintf(out, "/version (%s) readonly def\n", version);
fprintf(out, "/Copyright (%s) readonly def\n", copyright);
fprintf(out, "/Notice (Plane %d) readonly def\n", plane);
fprintf(out, "/FullName (%s) readonly def\n", fullname);
fprintf(out, "/FamilyName (%s) readonly def\n", fam_name);
Fputs("/Weight (Regular) readonly def");
Fputs("/ItalicAngle 0 def");
Fputs("/isFixedPitch false def");
/* Fputs("/UnderlineThickness 50 def"); */
Fputs("end readonly def");
fprintf(out, "/FontName /%s def\n", font);
Fputs("/PaintType 0 def");
Fputs("/FontType 1 def");
if (fontShift == 0)
Fputs("/FontMatrix [0.001 0 0 0.001 0 0] readonly def");
else
fprintf(out, "/FontMatrix [0.001 0 0 0.001 0 %5.3f] readonly def\n",
fontShift);
Fputs("/Encoding 256 array");
Fputs("0 1 255 {1 index exch /.notdef put} for");
/* encoding vector */
for (irange = 0; irange < numCR; irange++, cRange++)
{
pLow = cRange->low;
nLow = cRange->numLowRanges;
for (ipl = cRange->high.start; ipl <= cRange->high.end; ipl++)
{
if (nLow == 0)
{
nGlyph = 0x100;
for (ich = 0; ich <= 0xff; ich++)
{
code = ipl<<8 | ich;
idx = TT_Char_Index(cmap, code);
fprintf(out, "dup %d /%s put\n", ich, PS_GlyphName(idx, code));
}
}
else
{
for (ilow = 0; ilow < nLow; ilow++, pLow++)
{
if (!compact && !mapping)
cjk = pLow->start;
nGlyph += pLow->end - pLow->start + 1;
for (ich = pLow->start; ich <= pLow->end; ich++, cjk++)
{
code = ipl<<8 | ich;
idx = TT_Char_Index(cmap, code);
fprintf(out, "dup %d /%s put\n", cjk, PS_GlyphName(idx, code));
if (mapping && cjk == 0xFF)
goto done;
}
}
}
}
}
done:
Fputs("readonly def");
Fputs("/FontBBox [0 -300 1000 1000] readonly def");
fprintf(out, "/UniqueID %d def\n",UID);
Fputs("currentdict end");
Fputs("currentfile eexec");
Fputs("dup /Private 8 dict dup begin");
Fputs("/-| { string currentfile exch readstring pop } executeonly def");
Fputs("/|- { noaccess def } executeonly def");
Fputs("/| { noaccess put } executeonly def");
Fputs("/BlueValues [ ] |-");
Fputs("/ForceBold true def");
Fputs("/LanguageGroup 1 def");
Fputs("/RndStemUp false def");
Fputs("/MinFeature{16 16} |-");
/* Fputs("/password 5839 def"); */
fprintf(out, "/UniqueID %d def\n",UID);
Fputs("/Subrs 4 array");
Fputs("dup 0 { 3 0 callothersubr pop pop setcurrentpoint return } |");
Fputs("dup 1 { 0 1 callothersubr return } |");
Fputs("dup 2 { 0 2 callothersubr return } |");
Fputs("dup 3 { return } |");
Fputs("|-");
fprintf(out, "2 index /CharStrings %d dict dup begin\n", nGlyph + 1);
}
/*
* Tail of Type 1 font.
*/
void
PS_Tail(FILE *out)
{
Fputs("/.notdef { 0 250 hsbw endchar } |-");
Fputs("end end readonly put noaccess put");
Fputs("dup /FontName get exch definefont pop");
Fputs("mark currentfile closefile");
}
/*
* Use the `rrcurveto' command on more than one `off' points.
*/
void
PS_Curveto(FILE *out,
TT_F26Dot6 x,
TT_F26Dot6 y,
int s,
int e)
{
int N, i;
TT_F26Dot6 sx[3], sy[3], cx[4], cy[4];
N = e - s + 1;
cx[0] = lastpsx; cy[0] = lastpsy;
if (s == e)
{
cx[1] = (2 * outline.points[s].x + outline.points[s - 1].x) / 3;
cy[1] = (2 * outline.points[s].y + outline.points[s - 1].y) / 3;
cx[2] = (2 * outline.points[s].x + x) / 3;
cy[2] = (2 * outline.points[s].y + y) / 3;
cx[3] = x;
cy[3] = y;
fprintf(out, "%d %d %d %d %d %d rrcurveto\n",
Coord(cx[1] - cx[0]), Coord(cy[1] - cy[0]),
Coord(cx[2] - cx[1]), Coord(cy[2] - cy[1]),
Coord(cx[3] - cx[2]), Coord(cy[3] - cy[2]));
}
else
{
for(i = 0; i < N; i++)
{
sx[0] = (i == 0) ?
outline.points[s - 1].x :
(outline.points[i + s].x + outline.points[i + s - 1].x) / 2;
sy[0] = (i == 0) ?
outline.points[s - 1].y :
(outline.points[i + s].y + outline.points[i + s - 1].y) / 2;
sx[1] = outline.points[s + i].x;
sy[1] = outline.points[s + i].y;
sx[2] = (i == N - 1) ?
x :
(outline.points[s + i].x + outline.points[s + i + 1].x) / 2;
sy[2] = (i == N - 1) ?
y :
(outline.points[s + i].y + outline.points[s + i + 1].y) / 2;
cx[1] = (2 * sx[1] + sx[0]) / 3;
cy[1] = (2 * sy[1] + sy[0]) / 3;
cx[2] = (2 * sx[1] + sx[2]) / 3;
cy[2] = (2 * sy[1] + sy[2]) / 3;
cx[3] = sx[2];
cy[3] = sy[2];
fprintf(out, "%d %d %d %d %d %d rrcurveto\n",
Coord(cx[1] - cx[0]), Coord(cy[1] - cy[0]),
Coord(cx[2] - cx[1]), Coord(cy[2] - cy[1]),
Coord(cx[3] - cx[2]), Coord(cy[3] - cy[2]));
cx[0] = cx[3];
cy[0] = cy[3];
}
}
PS_LastPt(x, y);
}
#ifdef DEBUG
int debug_Char_Code = 0xFFFF;
FILE* tmpout;
int showlabel = FALSE;
int no_glyph = FALSE;
int no_control= FALSE;
#define Fputps(_msg_) fprintf(tmpout, "%s\n", _msg_)
void
tmp_out(FILE* tmpout)
{
int i, j;
Fputps("%!PS");
Fputps("%%% CharString debugging program.");
Fputps("%%% Generated by: ttf2pfb $Revision: 1.13 $");
Fputps("%%% plot char-string (pathes defined in /cjkxxxx)");
Fputps("");
Fputps("%%% user-defined parameter");
Fputps("/scalefactor .6 def");
Fputps("%% 0 black, 1 white");
Fputps("/glyph-outline-gray 0 def");
Fputps("/control-point-gray 0.7 def");
Fputps("");
Fputps("%%% calculate shifts and scale factor");
Fputps("currentpagedevice /PageSize get dup");
Fputps("0 get /pagewidth exch def");
Fputps("1 get /pageheight exch def");
Fputps("");
fprintf(tmpout,
"/llx %d.0 def /lly %d.0 def /urx %d.0 def /ury %d.0 def\n",
Coord(metrics.bbox.xMin / 64), Coord(metrics.bbox.yMin / 64),
Coord(metrics.bbox.xMax / 64), Coord(metrics.bbox.yMax / 64));
Fputps("/olwidth urx llx sub def");
Fputps("/olheight ury lly sub def");
Fputps("");
Fputps("/scale scalefactor pagewidth mul olwidth div def");
Fputps("/xshift pagewidth 1 scalefactor sub mul 2 div def");
Fputps("/yshift pageheight olheight scale mul sub 2 div def");
Fputps("");
Fputps("%% save old gray-scale value");
Fputps("/oldgray currentgray def");
Fputps("");
Fputps("%%% for point sequence label");
Fputps("/TimesRoman 8 selectfont");
Fputps("/i++ {i /i i 1 add def} def");
Fputps("/itos {4 string cvs} def");
Fputps("/point {2 copy i++ 3 1 roll 5 3 roll} def");
Fputps("/drawlabel");
Fputps(" {{moveto dup 0 eq {exit}");
Fputps(" {itos show} ifelse} loop pop} def");
Fputps("/nodrawlabel {clear} def");
Fputps("/i 0 def");
Fputps("");
Fputps("%%% for drawing glyph paths, redefine commands used in CharString");
Fputps("%% scaled to proper size");
Fputps("/addr {scale mul 3 -1 roll add 3 1 roll");
Fputps(" scale mul add exch 2 copy} def");
if (no_glyph)
{
Fputps("/rmoveto {addr pop pop point} def");
Fputps("/rlineto {addr pop pop point} def");
Fputps("/rrcurveto {8 4 roll addr 8 -2 roll addr 8 -2 roll addr");
Fputps(" 8 2 roll 6 {pop} repeat point} def");
}
else
{
Fputps("/rmoveto {addr moveto point} def");
Fputps("/rlineto {addr lineto point} def");
Fputps("/rrcurveto {8 4 roll addr 8 -2 roll addr 8 -2 roll addr");
Fputps(" 8 2 roll curveto point} def");
}
Fputps("/hsbw {pop pop");
Fputps(" xshift llx scale mul sub");
Fputps(" yshift lly scale mul sub} def");
Fputps("/endchar {stroke pop pop} def");
Fputps("");
Fputps("%%% for drawing control paths");
Fputps("/T {pop lly sub scale mul yshift add exch");
Fputps(" llx sub scale mul xshift add exch } def");
Fputps("/mt {T 2 copy moveto} def");
if (no_control)
Fputps("/lt {T} def");
else
Fputps("/lt {T 2 copy lineto} def");
Fputps("");
Fputps("1 setlinecap 1 setlinejoin");
Fputps("%%% draw control points and paths");
Fputps("control-point-gray setgray");
for (i = 0, j = 0; i < outline.n_contours; i++)
{
Fputps("");
fprintf(tmpout,
"%d %d %d %d mt\n",
j,
Coord(outline.points[j].x), Coord(outline.points[j].y),
outline.flags[j]);
j++;
for (; j <= outline.contours[i]; j++)
fprintf(tmpout,
"%d %d %d %d lt\n",
j,
Coord(outline.points[j].x), Coord(outline.points[j].y),
outline.flags[j]);
Fputps("closepath");
}
Fputps("stroke");
if (showlabel && !no_control)
Fputps("drawlabel");
else
Fputps("nodrawlabel");
Fputps("");
Fputps("%%% draw glyph outlines");
Fputps("glyph-outline-gray setgray");
Fputps("");
}
#endif
/*
* Construct CharString of a glyph.
*/
short
PS_CharString(FILE *out,
UShort char_Code)
{
int idx, i, j;
UShort start_offpt, end_offpt = 0, fst;
#if DEBUG
FILE* oldout = out;
int loop = 1;
#endif
if (force_enc == X)
char_Code = JIS_to_SJIS(char_Code);
idx = TT_Char_Index(cmap, char_Code);
if (idx == 0)
return FALSE;
if (!LoadTrueTypeChar(idx))
fatal("Couldn't load character with index %d (code %d)", idx, char_Code);
if (verbose)
printf("0x%04x (%05d): %s\n",
char_Code, idx, PS_GlyphName(idx, char_Code));
/* Begin string */
fprintf(out, "/%s {\n", PS_GlyphName(idx, char_Code));
#ifdef DEBUG
if (char_Code == debug_Char_Code)
{
tmp_out(tmpout);
out = tmpout;
loop = 0;
}
for (; loop < 2; loop++)
{
#endif
/* coordinates are all relative to (0,0) in FreeType */
fprintf(out, "0 %d hsbw\n", (int)(metrics.advance / 64));
/* Initialize ending contour point, relative coordinates */
lastpsx = lastpsy = 0;
for (i = 0, j = 0; i < outline.n_contours; i++)
{
fst = j;
PS_Moveto(outline.points[j].x, outline.points[j].y);
j++;
start_offpt = 0; /* start at least 1 */
/*
* data pts for all contours stored in one array.
* each round j init at last j + 1
*/
/*
* start_offpt means start of off points.
* 0 means no off points in record.
* N means the position of the off point.
* end_offpt means the ending off point.
* lastx, lasty is the last ON point from which Curve and Line
* shall start.
*/
/*
* start with j=0. into loop, j=1.
* if pt[1] off, if start_offpt == 0, toggle start_offpt
* next j=2. if on, now start_off != 0, run Curveto.
* if pt[1] on, start_off == 0, will run Lineto.
*/
for (; j <= outline.contours[i]; j++)
{
if (!(outline.flags[j] & TT_Flag_On_Curve))
{
if (!start_offpt)
start_offpt = end_offpt = j;
else
end_offpt++;
}
else
{ /* On Curve */
if (start_offpt)
{
/*
* start_offpt stuck at j, end_offpt++.
* end_offpt - start_offpt gives no of off pts.
* start_offpt gives start of sequence.
* why need outline.xCoord[j] outline.yCoord[j]?
*/
PS_Curveto(out,
outline.points[j].x, outline.points[j].y,
start_offpt, end_offpt);
start_offpt = 0;
/*
* also use start_offpt as indicator to save one variable!!
* after curveto, reset condition.
*/
}
else
PS_Lineto(outline.points[j].x, outline.points[j].y);
}
}
/*
* looks like closepath fst = first, i.e. go back to first
*/
if (start_offpt)
PS_Curveto(out,
outline.points[fst].x, outline.points[fst].y,
start_offpt, end_offpt);
else
Fputs("closepath");
}
Fputs("endchar");
#if DEBUG
out = oldout;
}
if (char_Code == debug_Char_Code)
{
if (showlabel && !no_glyph)
Fputps("drawlabel");
else
Fputps("nodrawlabel");
Fputps("");
Fputps("%%% end of drawing");
Fputps("oldgray setgray");
Fputps("showpage");
fclose(tmpout);
}
#endif
Fputs(" } |-");
return TRUE;
}
/*
* Get code ranges of an encoding scheme either from
* the eVecMap or a code range file.
*/
EncVec*
Get_EncVec(FILE *enc)
{
EncVec* encVec = NULL;
EVcRange* cRange = NULL;
EVLow* lByte = NULL;
UShort numCR = 0, numLow = 0;
int start, end;
int buflen = LINELEN, numAssigned;
char buf[LINELEN];
if (force_enc != 0)
return eVecMap_force[force_enc];
if (enc == NULL && eVecMap[pid][eid] != NULL)
return eVecMap[pid][eid];
/* parse each code range line */
while (fgets(buf, buflen, enc) != NULL)
{
if (buf[0] != '#' && buf[0] != '\n')
{
if (strrchr(buf,':') != NULL)
{
/* if there is no high value declared before low value */
if (lByte != NULL)
{
if (cRange == NULL)
{
/* default code range `0x00-0x00:' */
cRange = re_alloc(cRange, ++numCR * sizeof (EVcRange),
"Get_EncVec");
cRange->high.start = cRange->high.end = 0;
}
/* Assign the last low value */
(cRange + numCR - 1)->low = lByte;
(cRange + numCR - 1)->numLowRanges = numLow;
}
/* New high byte range */
cRange = re_alloc(cRange, ++numCR * sizeof (EVcRange), "Get_EncVec");
(cRange + numCR - 1)->numLowRanges = numLow = 0;
lByte = NULL;
/* Parse code range */
numAssigned = sscanf(buf, "%i %*40s %i", &start, &end);
if (numAssigned <= 0 || numAssigned > 2)
{
mesg("%s: Get_EncVec: Invalid high code range.\n", prog);
return NULL;
}
else
{
(cRange + numCR - 1)->high.start = start;
if (numAssigned == 1)
(cRange + numCR - 1)->high.end = start;
else
(cRange + numCR - 1)->high.end = end;
}
}
else
{
lByte = re_alloc(lByte, ++numLow * sizeof (EVLow), "Get_EncVec");
numAssigned = sscanf(buf, "%i %*40s %i", &start, &end);
if (numAssigned <= 0 || numAssigned > 2)
{
mesg("%s: Get_EncVec: Invalid long code range.\n", prog);
return NULL;
}
else
{
(lByte + numLow - 1)->start = start;
if (numAssigned == 1)
(lByte + numLow - 1)->end = start;
else
(lByte + numLow - 1)->end = end;
}
}
}
}
if (cRange == NULL)
{
cRange = re_alloc(cRange, ++numCR * sizeof (EVcRange), "Get_EncVec");
cRange->high.start = cRange->high.end = 0;
cRange->numLowRanges = 0;
}
if (lByte != NULL)
{
(cRange + numCR - 1)->low = lByte;
(cRange + numCR - 1)->numLowRanges = numLow;
}
encVec = re_alloc(encVec, 1 * sizeof (EncVec), "Get_EncVec");
encVec->numCodeRanges = numCR;
encVec->codeRange = cRange;
return encVec;
}
/*
* Match code ranges by a font plane.
*/
EncVec*
Get_PlaneEV(EncVec* encVec,
int plane)
{
UShort numCR = encVec->numCodeRanges;
EVcRange* cRange = encVec->codeRange;
EncVec* encV = NULL;
EVcRange* planeCR = NULL;
EVLow* planeLow = NULL;
UShort nCR = 0, nLow = 0;
int icr;
if (compact)
{
int iChar = 0; /* summed # of chars */
int nChar = (plane-1) * 256; /* the first char code ranges recorded */
int recording = 0;
/* if compact, plane starts from 1 to be */
/* compatible with the CJK package */
if (plane < 1 || plane > 99)
fatal("Get_PlaneEV: Given plane out of range");
for (icr = 0; icr < numCR; icr++, cRange++)
{
UShort numLow = cRange->numLowRanges;
int ipl;
for (ipl = cRange->high.start; ipl <= cRange->high.end; ipl++)
{
EVLow* pLow = cRange->low;
int ilow;
if (recording)
{ /* if we have made a hit */
if (planeLow != NULL)
{ /* if low byte range has not been saved */
(planeCR + nCR - 1)->low = planeLow;
(planeCR + nCR - 1)->numLowRanges = nLow;
planeLow = NULL;
}
/* each new plane starts a EVcRange if */
/* iChar is still less than nChar */
if (iChar <= nChar)
{
planeCR = re_alloc(planeCR, ++nCR * sizeof (EVcRange),
"Get_PlaneEV");
(planeCR + nCR - 1)->high.start =
(planeCR + nCR - 1)->high.end = ipl;
(planeCR + nCR - 1)->numLowRanges = nLow = 0;
}
}
/* scan each low byte range */
for (ilow = 0; ilow < (numLow == 0 ? 1 : numLow); ilow++, pLow++)
{
int start, end, nLowChar;
if (numLow == 0)
{ /* default range */
start = 0x0;
end = 0xff;
}
else
{
start = pLow->start;
end = pLow->end;
}
nLowChar = end - start + 1;
if (iChar + nLowChar > nChar)
{ /* a hit! */
int bchar = start + nChar - iChar;
if (planeCR == NULL)
{
/* the first time code range is recorded */
planeCR = re_alloc(planeCR, ++nCR * sizeof (EVcRange),
"Get_PlaneEV");
(planeCR + nCR - 1)->high.start = ipl;
(planeCR + nCR - 1)->high.end = ipl;
}
/* adjust range boundary */
if (recording == 0)
start = bchar;
else
end = bchar;
nChar += 0xff;
/* recording starts */
recording++;
}
iChar += nLowChar; /* next range */
if (recording)
{
/* a new low range */
if (iChar <= nChar)
{
planeLow = re_alloc(planeLow, ++nLow * sizeof (EVLow),
"Get_PlaneEV");
(planeLow + nLow - 1)->start = start;
(planeLow + nLow - 1)->end = end;
}
if (recording > 1 || iChar > nChar)
{
/* beyond recording range */
(planeCR + nCR - 1)->numLowRanges = nLow;
(planeCR + nCR - 1)->low = planeLow;
encV = re_alloc(encV, 1 * sizeof (EncVec), "Get_PlaneEV");
encV->numCodeRanges = nCR;
encV->codeRange = planeCR;
return encV;
}
}
}
}
}
/* we must finalize the ranges */
if (recording)
{
(planeCR + nCR - 1)->numLowRanges = nLow;
(planeCR + nCR - 1)->low = planeLow;
encV = re_alloc(encV, 1 * sizeof (EncVec), "Get_PlaneEV");
encV->numCodeRanges = nCR;
encV->codeRange = planeCR;
return encV;
}
}
else
{
for (icr = 0; icr < numCR; icr++, cRange++)
{
if (plane >= cRange->high.start && plane <= cRange->high.end)
{
encV = re_alloc(encV, 1 * sizeof (EncVec), "Get_PlaneEV");
planeCR = re_alloc(planeCR, 1 * sizeof (EVcRange), "Get_PlaneEV");
planeCR->high.start = planeCR->high.end = plane;
planeCR->numLowRanges = cRange->numLowRanges;
planeCR->low = cRange->low;
encV->numCodeRanges = 1;
encV->codeRange = planeCR;
return encV;
}
}
}
return NULL;
}
/*
* The main subroutine for generating Type 1 fonts.
* One subfont per call.
*/
short
Generate_Font(FILE *out,
int plane,
FILE *enc,
char *fname,
int UID)
{
EncVec* encVec = Get_EncVec(enc);
EncVec* planeEncVec;
EVcRange* cRange;
UShort numCR;
UShort code;
int ilow, iplan, ichar, irange;
if (verbose)
printf("Generating fonts...\n\n");
if (encVec == NULL)
return FALSE;
if (mapping)
planeEncVec = encVec;
else
if ((planeEncVec = Get_PlaneEV(encVec, plane)) == NULL)
{
mesg("%s: Can't find encoding vector for the font plane 0x%X.\n",
prog, plane);
return FALSE;
}
/* Header of Type1 font */
PS_Head(out, plane, planeEncVec, fname, UID);
numCR = planeEncVec->numCodeRanges;
cRange = planeEncVec->codeRange;
for (irange = 0; irange < numCR; irange++, cRange++)
{
EVLow* pLow = cRange->low;
UShort nLow = cRange->numLowRanges;
for (iplan = cRange->high.start; iplan <= cRange->high.end; iplan++)
{
if (nLow == 0)
{
for (ichar = 0; ichar <= 0xff; ichar++)
{
code = iplan << 8 | ichar;
PS_CharString(out, code);
}
}
else
{
for (ilow = 0; ilow < nLow; ilow++, pLow++)
{
for (ichar = pLow->start; ichar <= pLow->end; ichar++)
{
code = iplan << 8 | ichar;
PS_CharString(out, code);
}
}
}
}
}
PS_Tail(out);
return TRUE;
}
/*
* Main: process options, file I/O, etc.
*/
int
main(int argc,
char *argv[])
{
char *infile, *outfile, *encFile, *fname = "UNKNOWN";
FILE *out, *enc;
int result, plane = 0, UID = 4999999;
if ((prog = strrchr(argv[0], '/')))
prog++;
else
prog = argv[0];
/* set up known encoding vectors */
Known_Encodings();
out = stdout;
enc = NULL;
infile = outfile = encFile = NULL;
argc--;
argv++;
while (argc > 0)
{
if (argv[0][0] == '-')
{
switch (argv[0][1])
{
case 'v':
case 'V':
verbose = TRUE;
break;
case 'c':
case 'C':
compact = TRUE;
break;
case 'k':
case 'K':
keep = TRUE;
break;
case 'm':
case 'M':
mapping = TRUE;
break;
case 'p':
case 'P':
result = argv[0][2];
argc--;
argv++;
if (result == 'i' || result == 'I')
{
/* Set the platform ID. Assumed upper bound is 64 */
if ((pid = atoi(argv[0])) < 0 || pid > 64)
/* Check the platform and encoding IDs. */
fatal("Invalid platform ID %d", pid);
}
else if (result == 'l' || result == 'L')
{
result = 0;
while (argv[0][result] == '0' &&
toupper(argv[0][result + 1]) != 'X')
result++; /* no octal number */
sscanf(&argv[0][result], "%i", &plane);
}
break;
case 'e':
case 'E':
result = argv[0][2];
argc--;
argv++;
if (result == 'i' || result == 'I')
{
/* Set the encoding ID. */
if ((eid = atoi(argv[0])) < 0 || eid > 64)
fatal("Invalid encoding ID %d", eid);
}
else if (result == 'n' || result == 'N')
encFile = argv[0];
break;
case 'u':
case 'U':
argc--;
argv++;
UID = atoi(argv[0]);
break;
case 'f':
case 'F':
result = argv[0][2];
argc--;
argv++;
if (result == '\0')
fname = argv[0];
else if (result == 'o' || result == 'O')
{
switch (argv[0][0])
{
case 'g':
case 'G':
force_enc = GB;
break;
case 'k':
case 'K':
force_enc = KS;
break;
case 'b':
case 'B':
force_enc = Big5;
break;
case 'j':
case 'J':
result = argv[0][1];
if (result == 'o' || result == 'O')
force_enc = Johab;
else
force_enc = JIS;
break;
case 's':
case 'S':
force_enc = SJIS;
break;
case 'x':
case 'X':
force_enc = X;
}
}
break;
case 't': /* Get the TTF file name. */
case 'T':
argc--;
argv++;
infile = argv[0];
break;
case 'o': /* Set the output file name. */
case 'O':
argc--;
argv++;
outfile = argv[0];
break;
case 's': /* shift font bbox up or down */
case 'S':
argc--;
argv++;
sscanf(argv[0], "%f", &fontShift);
break;
#ifdef DEBUG
case 'd': /* character code for debugging */
case 'D':
argc--;
argv++;
sscanf(argv[0], "%i", &debug_Char_Code);
tmpout = fopen("ch-debug.ps", "wt");
mesg("You have specified the character code 0x%04x for debugging.\n",
debug_Char_Code);
mesg("A PostScript program named `ch-debug.ps' will be created.\n");
break;
case 'l':
case 'L':
showlabel = TRUE;
break;
case 'n':
case 'N':
result = argv[0][2];
if (result == 'g' || result == 'G')
no_glyph = TRUE;
else if (result == 'c' || result == 'C')
no_control = TRUE;
break;
#endif
default:
Usage(1);
}
}
else
/* Set the input file name. */
infile = argv[0];
argc--;
argv++;
}
/* Open the output file if specified. */
if (outfile != NULL)
/* Attempt to open the output file. */
if ((out = fopen(outfile, "wt")) == 0)
{
fatal("Unable to open the output file `%s'", outfile);
exit(FAILURE);
}
/* Validate the values passed on the command line. */
if (infile == NULL)
{
mesg("%s: No input TTF file provided\n", prog);
Usage(1);
}
if (encFile != NULL)
{
if ((enc = fopen(encFile, "rt")) == 0)
fatal("No input code range file");
}
/* Initialize font engine */
if (!Init_Font_Engine(infile))
{
if (out != stdout)
{
fclose(out);
if (!keep)
(void)unlink(outfile);
}
exit(FAILURE);
}
/* Generate the disassembled PFB font from the TrueType font */
if (Generate_Font(out, plane, enc, fname, UID))
result = 0;
else
result = 2;
if (out != stdout)
{
fclose(out);
if (result != 0)
{
mesg("%s: An error occurred while generating the font", prog);
if (!keep)
(void)unlink(outfile);
}
}
TT_Close_Face(face);
TT_Done_FreeType(engine);
exit(result);
return 0; /* never reached */
}
/* end of ttf2pfb.c */
Reference in New Issue View Git Blame Copy Permalink