Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / vcl / source / fontsubset / ttcr.cxx
blob: 79cfde87643f871c96752105213815e096b59771 [file] [log] [blame]
/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
/*
* TrueTypeCreator method implementation
*
* @author: Alexander Gelfenbain
*
*/
#if OSL_DEBUG_LEVEL == 0
# ifndef NDEBUG
# define NDEBUG
# endif
#endif
#include <assert.h>
#include "ttcr.hxx"
#include "list.h"
#include "string.h"
namespace vcl
{
/*
* Private Data Types
*/
struct _TrueTypeCreator {
sal_uInt32 tag; /**< TrueType file tag */
list tables; /**< List of table tags and pointers */
};
/* These must be #defined so that they can be used in initializers */
#define T_maxp 0x6D617870
#define T_glyf 0x676C7966
#define T_head 0x68656164
#define T_loca 0x6C6F6361
#define T_name 0x6E616D65
#define T_hhea 0x68686561
#define T_hmtx 0x686D7478
#define T_cmap 0x636D6170
#define T_vhea 0x76686561
#define T_vmtx 0x766D7478
#define T_OS2 0x4F532F32
#define T_post 0x706F7374
#define T_kern 0x6B65726E
#define T_cvt 0x63767420
typedef struct {
sal_uInt32 tag;
sal_uInt32 length;
sal_uInt8 *data;
} TableEntry;
/*
* this is a duplicate code from sft.c but it is left here for performance reasons
*/
#ifdef __GNUC__
#define _inline static __inline__
#else
#define _inline static
#endif
_inline sal_uInt32 mkTag(sal_uInt8 a, sal_uInt8 b, sal_uInt8 c, sal_uInt8 d) {
return (a << 24) | (b << 16) | (c << 8) | d;
}
/*- Data access macros for data stored in big-endian or little-endian format */
_inline sal_Int16 GetInt16( const sal_uInt8* ptr, sal_uInt32 offset, int bigendian)
{
sal_Int16 t;
assert(ptr != 0);
if (bigendian) {
t = (ptr+offset)[0] << 8 | (ptr+offset)[1];
} else {
t = (ptr+offset)[1] << 8 | (ptr+offset)[0];
}
return t;
}
_inline sal_uInt16 GetUInt16( const sal_uInt8* ptr, sal_uInt32 offset, int bigendian)
{
sal_uInt16 t;
assert(ptr != 0);
if (bigendian) {
t = (ptr+offset)[0] << 8 | (ptr+offset)[1];
} else {
t = (ptr+offset)[1] << 8 | (ptr+offset)[0];
}
return t;
}
_inline sal_Int32 GetInt32( const sal_uInt8* ptr, sal_uInt32 offset, int bigendian)
{
sal_Int32 t;
assert(ptr != 0);
if (bigendian) {
t = (ptr+offset)[0] << 24 | (ptr+offset)[1] << 16 |
(ptr+offset)[2] << 8 | (ptr+offset)[3];
} else {
t = (ptr+offset)[3] << 24 | (ptr+offset)[2] << 16 |
(ptr+offset)[1] << 8 | (ptr+offset)[0];
}
return t;
}
_inline sal_uInt32 GetUInt32( const sal_uInt8* ptr, sal_uInt32 offset, int bigendian)
{
sal_uInt32 t;
assert(ptr != 0);
if (bigendian) {
t = (ptr+offset)[0] << 24 | (ptr+offset)[1] << 16 |
(ptr+offset)[2] << 8 | (ptr+offset)[3];
} else {
t = (ptr+offset)[3] << 24 | (ptr+offset)[2] << 16 |
(ptr+offset)[1] << 8 | (ptr+offset)[0];
}
return t;
}
_inline void PutInt16(sal_Int16 val, sal_uInt8 *ptr, sal_uInt32 offset, int bigendian)
{
assert(ptr != 0);
if (bigendian) {
ptr[offset] = (sal_uInt8)((val >> 8) & 0xFF);
ptr[offset+1] = (sal_uInt8)(val & 0xFF);
} else {
ptr[offset+1] = (sal_uInt8)((val >> 8) & 0xFF);
ptr[offset] = (sal_uInt8)(val & 0xFF);
}
}
_inline void PutUInt16(sal_uInt16 val, sal_uInt8 *ptr, sal_uInt32 offset, int bigendian)
{
assert(ptr != 0);
if (bigendian) {
ptr[offset] = (sal_uInt8)((val >> 8) & 0xFF);
ptr[offset+1] = (sal_uInt8)(val & 0xFF);
} else {
ptr[offset+1] = (sal_uInt8)((val >> 8) & 0xFF);
ptr[offset] = (sal_uInt8)(val & 0xFF);
}
}
_inline void PutUInt32(sal_uInt32 val, sal_uInt8 *ptr, sal_uInt32 offset, int bigendian)
{
assert(ptr != 0);
if (bigendian) {
ptr[offset] = (sal_uInt8)((val >> 24) & 0xFF);
ptr[offset+1] = (sal_uInt8)((val >> 16) & 0xFF);
ptr[offset+2] = (sal_uInt8)((val >> 8) & 0xFF);
ptr[offset+3] = (sal_uInt8)(val & 0xFF);
} else {
ptr[offset+3] = (sal_uInt8)((val >> 24) & 0xFF);
ptr[offset+2] = (sal_uInt8)((val >> 16) & 0xFF);
ptr[offset+1] = (sal_uInt8)((val >> 8) & 0xFF);
ptr[offset] = (sal_uInt8)(val & 0xFF);
}
}
_inline void PutInt32(sal_Int32 val, sal_uInt8 *ptr, sal_uInt32 offset, int bigendian)
{
assert(ptr != 0);
if (bigendian) {
ptr[offset] = (sal_uInt8)((val >> 24) & 0xFF);
ptr[offset+1] = (sal_uInt8)((val >> 16) & 0xFF);
ptr[offset+2] = (sal_uInt8)((val >> 8) & 0xFF);
ptr[offset+3] = (sal_uInt8)(val & 0xFF);
} else {
ptr[offset+3] = (sal_uInt8)((val >> 24) & 0xFF);
ptr[offset+2] = (sal_uInt8)((val >> 16) & 0xFF);
ptr[offset+1] = (sal_uInt8)((val >> 8) & 0xFF);
ptr[offset] = (sal_uInt8)(val & 0xFF);
}
}
static int TableEntryCompareF(const void *l, const void *r)
{
return ((const TableEntry *) l)->tag - ((const TableEntry *) r)->tag;
}
static int NameRecordCompareF(const void *l, const void *r)
{
NameRecord *ll = (NameRecord *) l;
NameRecord *rr = (NameRecord *) r;
if (ll->platformID != rr->platformID) {
return ll->platformID - rr->platformID;
} else if (ll->encodingID != rr->encodingID) {
return ll->encodingID - rr->encodingID;
} else if (ll->languageID != rr->languageID) {
return ll->languageID - rr->languageID;
} else if (ll->nameID != rr->nameID) {
return ll->nameID - rr->nameID;
}
return 0;
}
static sal_uInt32 CheckSum(sal_uInt32 *ptr, sal_uInt32 length)
{
sal_uInt32 sum = 0;
sal_uInt32 *endptr = ptr + ((length + 3) & (sal_uInt32) ~3) / 4;
while (ptr < endptr) sum += *ptr++;
return sum;
}
_inline void *smalloc(sal_uInt32 size)
{
void *res = malloc(size);
assert(res != 0);
return res;
}
_inline void *scalloc(sal_uInt32 n, sal_uInt32 size)
{
void *res = calloc(n, size);
assert(res != 0);
return res;
}
/*
* Public functions
*/
void TrueTypeCreatorNewEmpty(sal_uInt32 tag, TrueTypeCreator **_this)
{
TrueTypeCreator* ptr = (TrueTypeCreator*)smalloc(sizeof(TrueTypeCreator));
ptr->tables = listNewEmpty();
listSetElementDtor(ptr->tables, (list_destructor)TrueTypeTableDispose);
ptr->tag = tag;
*_this = ptr;
}
int AddTable(TrueTypeCreator *_this, TrueTypeTable *table)
{
if (table != 0) {
listAppend(_this->tables, table);
}
return SF_OK;
}
void RemoveTable(TrueTypeCreator *_this, sal_uInt32 tag)
{
int done = 0;
if (listCount(_this->tables)) {
listToFirst(_this->tables);
do {
if (((TrueTypeTable *) listCurrent(_this->tables))->tag == tag) {
listRemove(_this->tables);
} else {
if (listNext(_this->tables)) {
done = 1;
}
}
} while (!done);
}
}
static void ProcessTables(TrueTypeCreator *);
int StreamToMemory(TrueTypeCreator *_this, sal_uInt8 **ptr, sal_uInt32 *length)
{
sal_uInt16 numTables, searchRange=1, entrySelector=0, rangeShift;
sal_uInt32 s, offset, checkSumAdjustment = 0;
sal_uInt32 *p;
int i=0, n;
sal_uInt8 *head = NULL; /* saved pointer to the head table data for checkSumAdjustment calculation */
if ((n = listCount(_this->tables)) == 0) return SF_TTFORMAT;
ProcessTables(_this);
/* ProcessTables() adds 'loca' and 'hmtx' */
n = listCount(_this->tables);
numTables = (sal_uInt16) n;
TableEntry* te = (TableEntry*)scalloc(n, sizeof(TableEntry));
listToFirst(_this->tables);
for (i = 0; i < n; i++) {
GetRawData((TrueTypeTable *) listCurrent(_this->tables), &te[i].data, &te[i].length, &te[i].tag);
listNext(_this->tables);
}
qsort(te, n, sizeof(TableEntry), TableEntryCompareF);
do {
searchRange *= 2;
entrySelector++;
} while (searchRange <= numTables);
searchRange *= 8;
entrySelector--;
rangeShift = numTables * 16 - searchRange;
s = offset = 12 + 16 * n;
for (i = 0; i < n; i++) {
s += (te[i].length + 3) & (sal_uInt32) ~3;
/* if ((te[i].length & 3) != 0) s += (4 - (te[i].length & 3)) & 3; */
}
sal_uInt8* ttf = (sal_uInt8*)smalloc(s);
/* Offset Table */
PutUInt32(_this->tag, ttf, 0, 1);
PutUInt16(numTables, ttf, 4, 1);
PutUInt16(searchRange, ttf, 6, 1);
PutUInt16(entrySelector, ttf, 8, 1);
PutUInt16(rangeShift, ttf, 10, 1);
/* Table Directory */
for (i = 0; i < n; i++) {
PutUInt32(te[i].tag, ttf + 12, 16 * i, 1);
PutUInt32(CheckSum((sal_uInt32 *) te[i].data, te[i].length), ttf + 12, 16 * i + 4, 1);
PutUInt32(offset, ttf + 12, 16 * i + 8, 1);
PutUInt32(te[i].length, ttf + 12, 16 * i + 12, 1);
if (te[i].tag == T_head) {
head = ttf + offset;
}
memcpy(ttf+offset, te[i].data, (te[i].length + 3) & (sal_uInt32) ~3 );
offset += (te[i].length + 3) & (sal_uInt32) ~3;
/* if ((te[i].length & 3) != 0) offset += (4 - (te[i].length & 3)) & 3; */
}
free(te);
p = (sal_uInt32 *) ttf;
for (i = 0; i < (int)s / 4; i++) checkSumAdjustment += p[i];
PutUInt32(0xB1B0AFBA - checkSumAdjustment, head, 8, 1);
*ptr = ttf;
*length = s;
return SF_OK;
}
int StreamToFile(TrueTypeCreator *_this, const char* fname)
{
sal_uInt8 *ptr;
sal_uInt32 length;
int r;
FILE* fd;
if ((r = StreamToMemory(_this, &ptr, &length)) != SF_OK) return r;
if (!fname) return SF_BADFILE;
if ((fd = fopen(fname, "wb")) == NULL) return SF_BADFILE;
if (fwrite(ptr, 1, length, fd) != length) {
r = SF_FILEIO;
} else {
r = SF_OK;
}
fclose(fd);
free(ptr);
return r;
}
/*
* TrueTypeTable private methods
*/
#define TABLESIZE_head 54
#define TABLESIZE_hhea 36
#define TABLESIZE_maxp 32
/* Table data points to
* --------------------------------------------
* generic tdata_generic struct
* 'head' TABLESIZE_head bytes of memory
* 'hhea' TABLESIZE_hhea bytes of memory
* 'loca' tdata_loca struct
* 'maxp' TABLESIZE_maxp bytes of memory
* 'glyf' list of GlyphData structs (defined in sft.h)
* 'name' list of NameRecord structs (defined in sft.h)
* 'post' tdata_post struct
*
*/
#define CMAP_SUBTABLE_INIT 10
#define CMAP_SUBTABLE_INCR 10
#define CMAP_PAIR_INIT 500
#define CMAP_PAIR_INCR 500
typedef struct {
sal_uInt32 id; /* subtable ID (platform/encoding ID) */
sal_uInt32 n; /* number of used translation pairs */
sal_uInt32 m; /* number of allocated translation pairs */
sal_uInt32 *xc; /* character array */
sal_uInt32 *xg; /* glyph array */
} CmapSubTable;
typedef struct {
sal_uInt32 n; /* number of used CMAP sub-tables */
sal_uInt32 m; /* number of allocated CMAP sub-tables */
CmapSubTable *s; /* sotred array of sub-tables */
} table_cmap;
typedef struct {
sal_uInt32 tag;
sal_uInt32 nbytes;
sal_uInt8 *ptr;
} tdata_generic;
typedef struct {
sal_uInt32 nbytes; /* number of bytes in loca table */
sal_uInt8 *ptr; /* pointer to the data */
} tdata_loca;
typedef struct {
sal_uInt32 format;
sal_uInt32 italicAngle;
sal_Int16 underlinePosition;
sal_Int16 underlineThickness;
sal_uInt32 isFixedPitch;
void *ptr; /* format-specific pointer */
} tdata_post;
/* allocate memory for a TT table */
static sal_uInt8 *ttmalloc(sal_uInt32 nbytes)
{
sal_uInt32 n;
n = (nbytes + 3) & (sal_uInt32) ~3;
sal_uInt8* res = (sal_uInt8*)malloc(n);
assert(res != 0);
memset(res, 0, n);
return res;
}
static void FreeGlyphData(void *ptr)
{
GlyphData *p = (GlyphData *) ptr;
if (p->ptr) free(p->ptr);
free(p);
}
static void TrueTypeTableDispose_generic(TrueTypeTable *_this)
{
if (_this) {
if (_this->data) {
tdata_generic *pdata = (tdata_generic *) _this->data;
if (pdata->nbytes) free(pdata->ptr);
free(_this->data);
}
free(_this);
}
}
static void TrueTypeTableDispose_head(TrueTypeTable *_this)
{
if (_this) {
if (_this->data) free(_this->data);
free(_this);
}
}
static void TrueTypeTableDispose_hhea(TrueTypeTable *_this)
{
if (_this) {
if (_this->data) free(_this->data);
free(_this);
}
}
static void TrueTypeTableDispose_loca(TrueTypeTable *_this)
{
if (_this) {
if (_this->data) {
tdata_loca *p = (tdata_loca *) _this->data;
if (p->ptr) free(p->ptr);
free(_this->data);
}
free(_this);
}
}
static void TrueTypeTableDispose_maxp(TrueTypeTable *_this)
{
if (_this) {
if (_this->data) free(_this->data);
free(_this);
}
}
static void TrueTypeTableDispose_glyf(TrueTypeTable *_this)
{
if (_this) {
if (_this->data) listDispose((list) _this->data);
free(_this);
}
}
static void TrueTypeTableDispose_cmap(TrueTypeTable *_this)
{
table_cmap *t;
CmapSubTable *s;
sal_uInt32 i;
if (_this) {
t = (table_cmap *) _this->data;
if (t) {
s = t->s;
if (s) {
for (i = 0; i < t->m; i++) {
if (s[i].xc) free(s[i].xc);
if (s[i].xg) free(s[i].xg);
}
free(s);
}
free(t);
}
free(_this);
}
}
static void TrueTypeTableDispose_name(TrueTypeTable *_this)
{
if (_this) {
if (_this->data) listDispose((list) _this->data);
free(_this);
}
}
static void TrueTypeTableDispose_post(TrueTypeTable *_this)
{
if (_this) {
tdata_post *p = (tdata_post *) _this->data;
if (p) {
if (p->format == 0x00030000) {
/* do nothing */
} else {
fprintf(stderr, "Unsupported format of a 'post' table: %08X.\n", (int)p->format);
}
free(p);
}
free(_this);
}
}
/* destructor vtable */
static struct {
sal_uInt32 tag;
void (*f)(TrueTypeTable *);
} vtable1[] =
{
{0, TrueTypeTableDispose_generic},
{T_head, TrueTypeTableDispose_head},
{T_hhea, TrueTypeTableDispose_hhea},
{T_loca, TrueTypeTableDispose_loca},
{T_maxp, TrueTypeTableDispose_maxp},
{T_glyf, TrueTypeTableDispose_glyf},
{T_cmap, TrueTypeTableDispose_cmap},
{T_name, TrueTypeTableDispose_name},
{T_post, TrueTypeTableDispose_post}
};
static int GetRawData_generic(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
{
assert(_this != 0);
assert(_this->data != 0);
*ptr = ((tdata_generic *) _this->data)->ptr;
*len = ((tdata_generic *) _this->data)->nbytes;
*tag = ((tdata_generic *) _this->data)->tag;
return TTCR_OK;
}
static int GetRawData_head(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
{
*len = TABLESIZE_head;
*ptr = (sal_uInt8 *) _this->data;
*tag = T_head;
return TTCR_OK;
}
static int GetRawData_hhea(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
{
*len = TABLESIZE_hhea;
*ptr = (sal_uInt8 *) _this->data;
*tag = T_hhea;
return TTCR_OK;
}
static int GetRawData_loca(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
{
tdata_loca *p;
assert(_this->data != 0);
p = (tdata_loca *) _this->data;
if (p->nbytes == 0) return TTCR_ZEROGLYPHS;
*ptr = p->ptr;
*len = p->nbytes;
*tag = T_loca;
return TTCR_OK;
}
static int GetRawData_maxp(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
{
*len = TABLESIZE_maxp;
*ptr = (sal_uInt8 *) _this->data;
*tag = T_maxp;
return TTCR_OK;
}
static int GetRawData_glyf(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
{
sal_uInt32 n, nbytes = 0;
list l = (list) _this->data;
/* sal_uInt16 curID = 0; */ /* to check if glyph IDs are sequential and start from zero */
sal_uInt8 *p;
*ptr = 0;
*len = 0;
*tag = 0;
if (listCount(l) == 0) return TTCR_ZEROGLYPHS;
listToFirst(l);
do {
/* if (((GlyphData *) listCurrent(l))->glyphID != curID++) return TTCR_GLYPHSEQ; */
nbytes += ((GlyphData *) listCurrent(l))->nbytes;
} while (listNext(l));
p = _this->rawdata = ttmalloc(nbytes);
listToFirst(l);
do {
n = ((GlyphData *) listCurrent(l))->nbytes;
if (n != 0) {
memcpy(p, ((GlyphData *) listCurrent(l))->ptr, n);
p += n;
}
} while (listNext(l));
*len = nbytes;
*ptr = _this->rawdata;
*tag = T_glyf;
return TTCR_OK;
}
/* cmap packers */
static sal_uInt8 *PackCmapType0(CmapSubTable *s, sal_uInt32 *length)
{
sal_uInt8* ptr = (sal_uInt8*)smalloc(262);
sal_uInt8 *p = ptr + 6;
sal_uInt32 i, j;
sal_uInt16 g;
PutUInt16(0, ptr, 0, 1);
PutUInt16(262, ptr, 2, 1);
PutUInt16(0, ptr, 4, 1);
for (i = 0; i < 256; i++) {
g = 0;
for (j = 0; j < s->n; j++) {
if (s->xc[j] == i) {
g = (sal_uInt16) s->xg[j];
}
}
p[i] = (sal_uInt8) g;
}
*length = 262;
return ptr;
}
static sal_uInt8 *PackCmapType6(CmapSubTable *s, sal_uInt32 *length)
{
sal_uInt8* ptr = (sal_uInt8*)smalloc(s->n*2 + 10);
sal_uInt8 *p = ptr + 10;
sal_uInt32 i, j;
sal_uInt16 g;
PutUInt16(6, ptr, 0, 1);
PutUInt16((sal_uInt16)(s->n*2+10), ptr, 2, 1);
PutUInt16(0, ptr, 4, 1);
PutUInt16(0, ptr, 6, 1);
PutUInt16((sal_uInt16)(s->n), ptr, 8, 1 );
for (i = 0; i < s->n; i++) {
g = 0;
for (j = 0; j < s->n; j++) {
if (s->xc[j] == i) {
g = (sal_uInt16) s->xg[j];
}
}
PutUInt16( g, p, 2*i, 1 );
}
*length = s->n*2+10;
return ptr;
}
/* XXX it only handles Format 0 encoding tables */
static sal_uInt8 *PackCmap(CmapSubTable *s, sal_uInt32 *length)
{
if( s->xg[s->n-1] > 0xff )
return PackCmapType6(s, length);
else
return PackCmapType0(s, length);
}
static int GetRawData_cmap(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
{
table_cmap *t;
sal_uInt32 i;
sal_uInt32 tlen = 0;
sal_uInt32 l;
sal_uInt32 cmapsize;
sal_uInt8 *cmap;
sal_uInt32 coffset;
assert(_this != 0);
t = (table_cmap *) _this->data;
assert(t != 0);
assert(t->n != 0);
sal_uInt8** subtables = (sal_uInt8**)scalloc(t->n, sizeof(sal_uInt8 *));
sal_uInt32* sizes = (sal_uInt32*)scalloc(t->n, sizeof(sal_uInt32));
for (i = 0; i < t->n; i++) {
subtables[i] = PackCmap(t->s+i, &l);
sizes[i] = l;
tlen += l;
}
cmapsize = tlen + 4 + 8 * t->n;
_this->rawdata = cmap = ttmalloc(cmapsize);
PutUInt16(0, cmap, 0, 1);
PutUInt16((sal_uInt16)t->n, cmap, 2, 1);
coffset = 4 + t->n * 8;
for (i = 0; i < t->n; i++) {
PutUInt16((sal_uInt16)(t->s[i].id >> 16), cmap + 4, i * 8, 1);
PutUInt16((sal_uInt16)(t->s[i].id & 0xFF), cmap + 4, 2 + i * 8, 1);
PutUInt32(coffset, cmap + 4, 4 + i * 8, 1);
memcpy(cmap + coffset, subtables[i], sizes[i]);
free(subtables[i]);
coffset += sizes[i];
}
free(subtables);
free(sizes);
*ptr = cmap;
*len = cmapsize;
*tag = T_cmap;
return TTCR_OK;
}
static int GetRawData_name(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
{
list l;
sal_Int16 i=0, n; /* number of Name Records */
int stringLen = 0;
sal_uInt8 *p1, *p2;
*ptr = 0;
*len = 0;
*tag = 0;
assert(_this != 0);
l = (list) _this->data;
assert(l != 0);
if ((n = (sal_Int16)listCount(l)) == 0) return TTCR_NONAMES;
NameRecord* nr = (NameRecord*)scalloc(n, sizeof(NameRecord));
listToFirst(l);
do {
memcpy(nr+i, listCurrent(l), sizeof(NameRecord));
stringLen += nr[i].slen;
i++;
} while (listNext(l));
if (stringLen > 65535) {
free(nr);
return TTCR_NAMETOOLONG;
}
qsort(nr, n, sizeof(NameRecord), NameRecordCompareF);
int nameLen = stringLen + 12 * n + 6;
sal_uInt8* name = (sal_uInt8*)ttmalloc(nameLen);
PutUInt16(0, name, 0, 1);
PutUInt16(n, name, 2, 1);
PutUInt16((sal_uInt16)(6 + 12 * n), name, 4, 1);
p1 = name + 6;
p2 = p1 + 12 * n;
for (i = 0; i < n; i++) {
PutUInt16(nr[i].platformID, p1, 0, 1);
PutUInt16(nr[i].encodingID, p1, 2, 1);
PutUInt16(nr[i].languageID, p1, 4, 1);
PutUInt16(nr[i].nameID, p1, 6, 1);
PutUInt16(nr[i].slen, p1, 8, 1);
PutUInt16((sal_uInt16)(p2 - (name + 6 + 12 * n)), p1, 10, 1);
memcpy(p2, nr[i].sptr, nr[i].slen);
/* {int j; for(j=0; j<nr[i].slen; j++) printf("%c", nr[i].sptr[j]); printf("\n"); }; */
p2 += nr[i].slen;
p1 += 12;
}
free(nr);
_this->rawdata = name;
*ptr = name;
*len = (sal_uInt16)nameLen;
*tag = T_name;
/*{int j; for(j=0; j<nameLen; j++) printf("%c", name[j]); }; */
return TTCR_OK;
}
static int GetRawData_post(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
{
tdata_post *p = (tdata_post *) _this->data;
sal_uInt8 *post = 0;
sal_uInt32 postLen = 0;
int ret;
if (_this->rawdata) free(_this->rawdata);
if (p->format == 0x00030000) {
postLen = 32;
post = ttmalloc(postLen);
PutUInt32(0x00030000, post, 0, 1);
PutUInt32(p->italicAngle, post, 4, 1);
PutUInt16(p->underlinePosition, post, 8, 1);
PutUInt16(p->underlineThickness, post, 10, 1);
PutUInt16((sal_uInt16)p->isFixedPitch, post, 12, 1);
ret = TTCR_OK;
} else {
fprintf(stderr, "Unrecognized format of a post table: %08X.\n", (int)p->format);
ret = TTCR_POSTFORMAT;
}
*ptr = _this->rawdata = post;
*len = postLen;
*tag = T_post;
return ret;
}
static struct {
sal_uInt32 tag;
int (*f)(TrueTypeTable *, sal_uInt8 **, sal_uInt32 *, sal_uInt32 *);
} vtable2[] =
{
{0, GetRawData_generic},
{T_head, GetRawData_head},
{T_hhea, GetRawData_hhea},
{T_loca, GetRawData_loca},
{T_maxp, GetRawData_maxp},
{T_glyf, GetRawData_glyf},
{T_cmap, GetRawData_cmap},
{T_name, GetRawData_name},
{T_post, GetRawData_post}
};
/*
* TrueTypeTable public methods
*/
/* Note: Type42 fonts only need these tables:
* head, hhea, loca, maxp, cvt, prep, glyf, hmtx, fpgm
*
* Microsoft required tables
* cmap, glyf, head, hhea, hmtx, loca, maxp, name, post, OS/2
*
* Apple required tables
* cmap, glyf, head, hhea, hmtx, loca, maxp, name, post
*
*/
TrueTypeTable *TrueTypeTableNew(sal_uInt32 tag,
sal_uInt32 nbytes,
const sal_uInt8* ptr)
{
TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
tdata_generic* pdata = (tdata_generic*)smalloc(sizeof(tdata_generic));
pdata->nbytes = nbytes;
pdata->tag = tag;
if (nbytes) {
pdata->ptr = ttmalloc(nbytes);
memcpy(pdata->ptr, ptr, nbytes);
} else {
pdata->ptr = 0;
}
table->tag = 0;
table->data = pdata;
table->rawdata = 0;
return table;
}
TrueTypeTable *TrueTypeTableNew_head(sal_uInt32 fontRevision,
sal_uInt16 flags,
sal_uInt16 unitsPerEm,
const sal_uInt8* created,
sal_uInt16 macStyle,
sal_uInt16 lowestRecPPEM,
sal_Int16 fontDirectionHint)
{
assert(created != 0);
TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
sal_uInt8* ptr = (sal_uInt8*)ttmalloc(TABLESIZE_head);
PutUInt32(0x00010000, ptr, 0, 1); /* version */
PutUInt32(fontRevision, ptr, 4, 1);
PutUInt32(0x5F0F3CF5, ptr, 12, 1); /* magic number */
PutUInt16(flags, ptr, 16, 1);
PutUInt16(unitsPerEm, ptr, 18, 1);
memcpy(ptr+20, created, 8); /* Created Long Date */
memset(ptr+28, 0, 8); /* Modified Long Date */
PutUInt16(macStyle, ptr, 44, 1);
PutUInt16(lowestRecPPEM, ptr, 46, 1);
PutUInt16(fontDirectionHint, ptr, 48, 1);
PutUInt16(0, ptr, 52, 1); /* glyph data format: 0 */
table->data = (void *) ptr;
table->tag = T_head;
table->rawdata = 0;
return table;
}
TrueTypeTable *TrueTypeTableNew_hhea(sal_Int16 ascender,
sal_Int16 descender,
sal_Int16 linegap,
sal_Int16 caretSlopeRise,
sal_Int16 caretSlopeRun)
{
TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
sal_uInt8* ptr = (sal_uInt8*)ttmalloc(TABLESIZE_hhea);
PutUInt32(0x00010000, ptr, 0, 1); /* version */
PutUInt16(ascender, ptr, 4, 1);
PutUInt16(descender, ptr, 6, 1);
PutUInt16(linegap, ptr, 8, 1);
PutUInt16(caretSlopeRise, ptr, 18, 1);
PutUInt16(caretSlopeRun, ptr, 20, 1);
PutUInt16(0, ptr, 22, 1); /* reserved 1 */
PutUInt16(0, ptr, 24, 1); /* reserved 2 */
PutUInt16(0, ptr, 26, 1); /* reserved 3 */
PutUInt16(0, ptr, 28, 1); /* reserved 4 */
PutUInt16(0, ptr, 30, 1); /* reserved 5 */
PutUInt16(0, ptr, 32, 1); /* metricDataFormat */
table->data = (void *) ptr;
table->tag = T_hhea;
table->rawdata = 0;
return table;
}
TrueTypeTable *TrueTypeTableNew_loca(void)
{
TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
table->data = smalloc(sizeof(tdata_loca));
((tdata_loca *)table->data)->nbytes = 0;
((tdata_loca *)table->data)->ptr = 0;
table->tag = T_loca;
table->rawdata = 0;
return table;
}
TrueTypeTable *TrueTypeTableNew_maxp( const sal_uInt8* maxp, int size)
{
TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
table->data = ttmalloc(TABLESIZE_maxp);
if (maxp && size == TABLESIZE_maxp) {
memcpy(table->data, maxp, TABLESIZE_maxp);
}
table->tag = T_maxp;
table->rawdata = 0;
return table;
}
TrueTypeTable *TrueTypeTableNew_glyf(void)
{
TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
list l = listNewEmpty();
assert(l != 0);
listSetElementDtor(l, (list_destructor)FreeGlyphData);
table->data = l;
table->rawdata = 0;
table->tag = T_glyf;
return table;
}
TrueTypeTable *TrueTypeTableNew_cmap(void)
{
TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
table_cmap* cmap = (table_cmap*)smalloc(sizeof(table_cmap));
cmap->n = 0;
cmap->m = CMAP_SUBTABLE_INIT;
cmap->s = (CmapSubTable *) scalloc(CMAP_SUBTABLE_INIT, sizeof(CmapSubTable));
memset(cmap->s, 0, sizeof(CmapSubTable) * CMAP_SUBTABLE_INIT);
table->data = (table_cmap *) cmap;
table->rawdata = 0;
table->tag = T_cmap;
return table;
}
static void DisposeNameRecord(void *ptr)
{
if (ptr != 0) {
NameRecord *nr = (NameRecord *) ptr;
if (nr->sptr) free(nr->sptr);
free(ptr);
}
}
static NameRecord* NameRecordNewCopy(NameRecord *nr)
{
NameRecord* p = (NameRecord*)smalloc(sizeof(NameRecord));
memcpy(p, nr, sizeof(NameRecord));
if (p->slen) {
p->sptr = (sal_uInt8*)smalloc(p->slen);
memcpy(p->sptr, nr->sptr, p->slen);
}
return p;
}
TrueTypeTable *TrueTypeTableNew_name(int n, NameRecord *nr)
{
TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
list l = listNewEmpty();
assert(l != 0);
listSetElementDtor(l, (list_destructor)DisposeNameRecord);
if (n != 0) {
int i;
for (i = 0; i < n; i++) {
listAppend(l, NameRecordNewCopy(nr+i));
}
}
table->data = l;
table->rawdata = 0;
table->tag = T_name;
return table;
}
TrueTypeTable *TrueTypeTableNew_post(sal_uInt32 format,
sal_uInt32 italicAngle,
sal_Int16 underlinePosition,
sal_Int16 underlineThickness,
sal_uInt32 isFixedPitch)
{
assert(format == 0x00030000); /* Only format 3.0 is supported at this time */
TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
tdata_post* post = (tdata_post*)smalloc(sizeof(tdata_post));
post->format = format;
post->italicAngle = italicAngle;
post->underlinePosition = underlinePosition;
post->underlineThickness = underlineThickness;
post->isFixedPitch = isFixedPitch;
post->ptr = 0;
table->data = post;
table->rawdata = 0;
table->tag = T_post;
return table;
}
int GetRawData(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
{
/* XXX do a binary search */
unsigned int i;
assert(_this != 0);
assert(ptr != 0);
assert(len != 0);
assert(tag != 0);
*ptr = 0; *len = 0; *tag = 0;
if (_this->rawdata) {
free(_this->rawdata);
_this->rawdata = 0;
}
for(i=0; i < sizeof(vtable2)/sizeof(*vtable2); i++) {
if (_this->tag == vtable2[i].tag) {
return vtable2[i].f(_this, ptr, len, tag);
}
}
assert(!"Unknwon TrueType table.\n");
return TTCR_UNKNOWN;
}
void cmapAdd(TrueTypeTable *table, sal_uInt32 id, sal_uInt32 c, sal_uInt32 g)
{
sal_uInt32 i, found;
table_cmap *t;
CmapSubTable *s;
assert(table != 0);
assert(table->tag == T_cmap);
t = (table_cmap *) table->data; assert(t != 0);
s = t->s; assert(s != 0);
found = 0;
for (i = 0; i < t->n; i++) {
if (s[i].id == id) {
found = 1;
break;
}
}
if (!found) {
if (t->n == t->m) {
CmapSubTable* tmp = (CmapSubTable*)scalloc(t->m + CMAP_SUBTABLE_INCR, sizeof(CmapSubTable));
memset(tmp, 0, t->m + CMAP_SUBTABLE_INCR * sizeof(CmapSubTable));
memcpy(tmp, s, sizeof(CmapSubTable) * t->m);
t->m += CMAP_SUBTABLE_INCR;
free(s);
s = tmp;
t->s = s;
}
for (i = 0; i < t->n; i++) {
if (s[i].id > id) break;
}
if (i < t->n) {
memmove(s+i+1, s+i, t->n-i);
}
t->n++;
s[i].id = id;
s[i].n = 0;
s[i].m = CMAP_PAIR_INIT;
s[i].xc = (sal_uInt32*)scalloc(CMAP_PAIR_INIT, sizeof(sal_uInt32));
s[i].xg = (sal_uInt32*)scalloc(CMAP_PAIR_INIT, sizeof(sal_uInt32));
}
if (s[i].n == s[i].m) {
sal_uInt32* tmp1 = (sal_uInt32*)scalloc(s[i].m + CMAP_PAIR_INCR, sizeof(sal_uInt32));
sal_uInt32* tmp2 = (sal_uInt32*)scalloc(s[i].m + CMAP_PAIR_INCR, sizeof(sal_uInt32));
assert(tmp1 != 0);
assert(tmp2 != 0);
memcpy(tmp1, s[i].xc, sizeof(sal_uInt32) * s[i].m);
memcpy(tmp2, s[i].xg, sizeof(sal_uInt32) * s[i].m);
s[i].m += CMAP_PAIR_INCR;
free(s[i].xc);
free(s[i].xg);
s[i].xc = tmp1;
s[i].xg = tmp2;
}
s[i].xc[s[i].n] = c;
s[i].xg[s[i].n] = g;
s[i].n++;
}
sal_uInt32 glyfAdd(TrueTypeTable *table, GlyphData *glyphdata, TrueTypeFont *fnt)
{
list l;
sal_uInt32 currentID;
int ret, n, ncomponents;
GlyphData *gd;
assert(table != 0);
assert(table->tag == T_glyf);
if (!glyphdata) return (sal_uInt32)~0;
std::vector< sal_uInt32 > glyphlist;
ncomponents = GetTTGlyphComponents(fnt, glyphdata->glyphID, glyphlist);
l = (list) table->data;
if (listCount(l) > 0) {
listToLast(l);
ret = n = ((GlyphData *) listCurrent(l))->newID + 1;
} else {
ret = n = 0;
}
glyphdata->newID = n++;
listAppend(l, glyphdata);
if (ncomponents > 1 && glyphlist.size() > 1 )
{
std::vector< sal_uInt32 >::const_iterator it = glyphlist.begin();
++it;
/* glyphData->glyphID is always the first glyph on the list */
do
{
int found = 0;
currentID = *it;
/* XXX expensive! should be rewritten with sorted arrays! */
listToFirst(l);
do {
if (((GlyphData *) listCurrent(l))->glyphID == currentID) {
found = 1;
break;
}
} while (listNext(l));
if (!found) {
gd = GetTTRawGlyphData(fnt, currentID);
gd->newID = n++;
listAppend(l, gd);
}
} while( ++it != glyphlist.end() );
}
return ret;
}
sal_uInt32 glyfCount(const TrueTypeTable *table)
{
assert(table != 0);
assert(table->tag == T_glyf);
return listCount((list) table->data);
}
void nameAdd(TrueTypeTable *table, NameRecord *nr)
{
list l;
assert(table != 0);
assert(table->tag == T_name);
l = (list) table->data;
listAppend(l, NameRecordNewCopy(nr));
}
static TrueTypeTable *FindTable(TrueTypeCreator *tt, sal_uInt32 tag)
{
if (listIsEmpty(tt->tables)) return 0;
listToFirst(tt->tables);
do {
if (((TrueTypeTable *) listCurrent(tt->tables))->tag == tag) {
return (TrueTypeTable*)listCurrent(tt->tables);
}
} while (listNext(tt->tables));
return 0;
}
/* This function processes all the tables and synchronizes them before creating
* the output TrueType stream.
*
* *** It adds two TrueType tables to the font: 'loca' and 'hmtx' ***
*
* It does:
*
* - Re-numbers glyph IDs and creates 'glyf', 'loca', and 'hmtx' tables.
* - Calculates xMin, yMin, xMax, and yMax and stores values in 'head' table.
* - Stores indexToLocFormat in 'head'
* - updates 'maxp' table
* - Calculates advanceWidthMax, minLSB, minRSB, xMaxExtent and numberOfHMetrics
* in 'hhea' table
*
*/
static void ProcessTables(TrueTypeCreator *tt)
{
TrueTypeTable *glyf, *loca, *head, *maxp, *hhea;
list glyphlist;
sal_uInt32 nGlyphs, locaLen = 0, glyfLen = 0;
sal_Int16 xMin = 0, yMin = 0, xMax = 0, yMax = 0;
sal_uInt32 i = 0;
sal_Int16 indexToLocFormat;
sal_uInt8 *hmtxPtr, *hheaPtr;
sal_uInt32 hmtxSize;
sal_uInt8 *p1, *p2;
sal_uInt16 maxPoints = 0, maxContours = 0, maxCompositePoints = 0, maxCompositeContours = 0;
int nlsb = 0;
sal_uInt32 *gid; /* array of old glyphIDs */
glyf = FindTable(tt, T_glyf);
glyphlist = (list) glyf->data;
nGlyphs = listCount(glyphlist);
assert(nGlyphs != 0);
gid = (sal_uInt32*)scalloc(nGlyphs, sizeof(sal_uInt32));
RemoveTable(tt, T_loca);
RemoveTable(tt, T_hmtx);
/* XXX Need to make sure that composite glyphs do not break during glyph renumbering */
listToFirst(glyphlist);
do {
GlyphData *gd = (GlyphData *) listCurrent(glyphlist);
sal_Int16 z;
glyfLen += gd->nbytes;
/* XXX if (gd->nbytes & 1) glyfLen++; */
assert(gd->newID == i);
gid[i++] = gd->glyphID;
/* gd->glyphID = i++; */
/* printf("IDs: %d %d.\n", gd->glyphID, gd->newID); */
if (gd->nbytes != 0) {
z = GetInt16(gd->ptr, 2, 1);
if (z < xMin) xMin = z;
z = GetInt16(gd->ptr, 4, 1);
if (z < yMin) yMin = z;
z = GetInt16(gd->ptr, 6, 1);
if (z > xMax) xMax = z;
z = GetInt16(gd->ptr, 8, 1);
if (z > yMax) yMax = z;
}
if (gd->compflag == 0) { /* non-composite glyph */
if (gd->npoints > maxPoints) maxPoints = gd->npoints;
if (gd->ncontours > maxContours) maxContours = gd->ncontours;
} else { /* composite glyph */
if (gd->npoints > maxCompositePoints) maxCompositePoints = gd->npoints;
if (gd->ncontours > maxCompositeContours) maxCompositeContours = gd->ncontours;
}
} while (listNext(glyphlist));
indexToLocFormat = (glyfLen / 2 > 0xFFFF) ? 1 : 0;
locaLen = indexToLocFormat ? (nGlyphs + 1) << 2 : (nGlyphs + 1) << 1;
sal_uInt8* glyfPtr = ttmalloc(glyfLen);
sal_uInt8* locaPtr = ttmalloc(locaLen);
TTSimpleGlyphMetrics* met = (TTSimpleGlyphMetrics*)scalloc(nGlyphs, sizeof(TTSimpleGlyphMetrics));
i = 0;
listToFirst(glyphlist);
p1 = glyfPtr;
p2 = locaPtr;
do {
GlyphData *gd = (GlyphData *) listCurrent(glyphlist);
if (gd->compflag) { /* re-number all components */
sal_uInt16 flags, index;
sal_uInt8 *ptr = gd->ptr + 10;
do {
sal_uInt32 j;
flags = GetUInt16(ptr, 0, 1);
index = GetUInt16(ptr, 2, 1);
/* XXX use the sorted array of old to new glyphID mapping and do a binary search */
for (j = 0; j < nGlyphs; j++) {
if (gid[j] == index) {
break;
}
}
/* printf("X: %d -> %d.\n", index, j); */
PutUInt16((sal_uInt16) j, ptr, 2, 1);
ptr += 4;
if (flags & ARG_1_AND_2_ARE_WORDS) {
ptr += 4;
} else {
ptr += 2;
}
if (flags & WE_HAVE_A_SCALE) {
ptr += 2;
} else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) {
ptr += 4;
} else if (flags & WE_HAVE_A_TWO_BY_TWO) {
ptr += 8;
}
} while (flags & MORE_COMPONENTS);
}
if (gd->nbytes != 0) {
memcpy(p1, gd->ptr, gd->nbytes);
}
if (indexToLocFormat == 1) {
PutUInt32(p1 - glyfPtr, p2, 0, 1);
p2 += 4;
} else {
PutUInt16((sal_uInt16)((p1 - glyfPtr) >> 1), p2, 0, 1);
p2 += 2;
}
p1 += gd->nbytes;
/* fill the array of metrics */
met[i].adv = gd->aw;
met[i].sb = gd->lsb;
i++;
} while (listNext(glyphlist));
free(gid);
if (indexToLocFormat == 1) {
PutUInt32(p1 - glyfPtr, p2, 0, 1);
} else {
PutUInt16((sal_uInt16)((p1 - glyfPtr) >> 1), p2, 0, 1);
}
glyf->rawdata = glyfPtr;
loca = TrueTypeTableNew_loca(); assert(loca != 0);
((tdata_loca *) loca->data)->ptr = locaPtr;
((tdata_loca *) loca->data)->nbytes = locaLen;
AddTable(tt, loca);
head = FindTable(tt, T_head);
sal_uInt8* const pHeadData = (sal_uInt8*)head->data;
PutInt16(xMin, pHeadData, 36, 1);
PutInt16(yMin, pHeadData, 38, 1);
PutInt16(xMax, pHeadData, 40, 1);
PutInt16(yMax, pHeadData, 42, 1);
PutInt16(indexToLocFormat, pHeadData, 50, 1);
maxp = FindTable(tt, T_maxp);
sal_uInt8* const pMaxpData = (sal_uInt8*)maxp->data;
PutUInt16((sal_uInt16)nGlyphs, pMaxpData, 4, 1);
PutUInt16(maxPoints, pMaxpData, 6, 1);
PutUInt16(maxContours, pMaxpData, 8, 1);
PutUInt16(maxCompositePoints, pMaxpData, 10, 1);
PutUInt16(maxCompositeContours, pMaxpData, 12, 1);
#if 0
/* XXX do not overwrite the existing data. Fix: re-calculate these numbers here */
PutUInt16(2, maxp->data, 14, 1); /* maxZones is always 2 */
PutUInt16(0, maxp->data, 16, 1); /* maxTwilightPoints */
PutUInt16(0, maxp->data, 18, 1); /* maxStorage */
PutUInt16(0, maxp->data, 20, 1); /* maxFunctionDefs */
PutUint16(0, maxp->data, 22, 1); /* maxInstructionDefs */
PutUint16(0, maxp->data, 24, 1); /* maxStackElements */
PutUint16(0, maxp->data, 26, 1); /* maxSizeOfInstructions */
PutUint16(0, maxp->data, 28, 1); /* maxComponentElements */
PutUint16(0, maxp->data, 30, 1); /* maxComponentDepth */
#endif
/*
* Generate an htmx table and update hhea table
*/
hhea = FindTable(tt, T_hhea); assert(hhea != 0);
hheaPtr = (sal_uInt8 *) hhea->data;
if (nGlyphs > 2) {
for (i = nGlyphs - 1; i > 0; i--) {
if (met[i].adv != met[i-1].adv) break;
}
nlsb = nGlyphs - 1 - i;
}
hmtxSize = (nGlyphs - nlsb) * 4 + nlsb * 2;
hmtxPtr = ttmalloc(hmtxSize);
p1 = hmtxPtr;
for (i = 0; i < nGlyphs; i++) {
if (i < nGlyphs - nlsb) {
PutUInt16(met[i].adv, p1, 0, 1);
PutUInt16(met[i].sb, p1, 2, 1);
p1 += 4;
} else {
PutUInt16(met[i].sb, p1, 0, 1);
p1 += 2;
}
}
AddTable(tt, TrueTypeTableNew(T_hmtx, hmtxSize, hmtxPtr));
PutUInt16((sal_uInt16)(nGlyphs - nlsb), hheaPtr, 34, 1);
free(hmtxPtr);
free(met);
}
} // namespace vcl
extern "C"
{
/**
* TrueTypeCreator destructor. It calls destructors for all TrueTypeTables added to it.
*/
void TrueTypeCreatorDispose(vcl::TrueTypeCreator *_this)
{
listDispose(_this->tables);
free(_this);
}
/**
* Destructor for the TrueTypeTable object.
*/
void TrueTypeTableDispose(vcl::TrueTypeTable *_this)
{
/* XXX do a binary search */
unsigned int i;
assert(_this != 0);
if (_this->rawdata) free(_this->rawdata);
for(i=0; i < sizeof(vcl::vtable1)/sizeof(*vcl::vtable1); i++) {
if (_this->tag == vcl::vtable1[i].tag) {
vcl::vtable1[i].f(_this);
return;
}
}
assert(!"Unknown TrueType table.\n");
}
}
#ifdef TEST_TTCR
int main(void)
{
TrueTypeCreator *ttcr;
sal_uInt8 *t1, *t2, *t3, *t4, *t5, *t6, *t7;
TrueTypeCreatorNewEmpty(mkTag('t','r','u','e'), &ttcr);
t1 = malloc(1000); memset(t1, 'a', 1000);
t2 = malloc(2000); memset(t2, 'b', 2000);
t3 = malloc(3000); memset(t3, 'c', 3000);
t4 = malloc(4000); memset(t4, 'd', 4000);
t5 = malloc(5000); memset(t5, 'e', 5000);
t6 = malloc(6000); memset(t6, 'f', 6000);
t7 = malloc(7000); memset(t7, 'g', 7000);
AddTable(ttcr, TrueTypeTableNew(0x6D617870, 1000, t1));
AddTable(ttcr, TrueTypeTableNew(0x4F532F32, 2000, t2));
AddTable(ttcr, TrueTypeTableNew(0x636D6170, 3000, t3));
AddTable(ttcr, TrueTypeTableNew(0x6C6F6361, 4000, t4));
AddTable(ttcr, TrueTypeTableNew(0x68686561, 5000, t5));
AddTable(ttcr, TrueTypeTableNew(0x676C7966, 6000, t6));
AddTable(ttcr, TrueTypeTableNew(0x6B65726E, 7000, t7));
free(t1);
free(t2);
free(t3);
free(t4);
free(t5);
free(t6);
free(t7);
StreamToFile(ttcr, "ttcrout.ttf");
TrueTypeCreatorDispose(ttcr);
return 0;
}
#endif