1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 /*
25 * TrueTypeCreator method implementation
26 *
27 * @author: Alexander Gelfenbain
28 *
29 */
30
31 #if OSL_DEBUG_LEVEL == 0
32 # ifndef NDEBUG
33 # define NDEBUG
34 # endif
35 #endif
36 #include <assert.h>
37
38 #include "ttcr.hxx"
39 #include "list.h"
40 #include "string.h"
41
42
43
44 namespace vcl
45 {
46
47 /*
48 * Private Data Types
49 */
50
51 struct _TrueTypeCreator {
52 sal_uInt32 tag; /**< TrueType file tag */
53 list tables; /**< List of table tags and pointers */
54 };
55
56 /* These must be #defined so that they can be used in initializers */
57 #define T_maxp 0x6D617870
58 #define T_glyf 0x676C7966
59 #define T_head 0x68656164
60 #define T_loca 0x6C6F6361
61 #define T_name 0x6E616D65
62 #define T_hhea 0x68686561
63 #define T_hmtx 0x686D7478
64 #define T_cmap 0x636D6170
65 #define T_vhea 0x76686561
66 #define T_vmtx 0x766D7478
67 #define T_OS2 0x4F532F32
68 #define T_post 0x706F7374
69 #define T_kern 0x6B65726E
70 #define T_cvt 0x63767420
71
72 typedef struct {
73 sal_uInt32 tag;
74 sal_uInt32 length;
75 sal_uInt8 *data;
76 } TableEntry;
77
78 /*
79 * this is a duplicate code from sft.c but it is left here for performance reasons
80 */
81 #ifdef __GNUC__
82 #define _inline static __inline__
83 #else
84 #define _inline static
85 #endif
86
mkTag(sal_uInt8 a,sal_uInt8 b,sal_uInt8 c,sal_uInt8 d)87 _inline sal_uInt32 mkTag(sal_uInt8 a, sal_uInt8 b, sal_uInt8 c, sal_uInt8 d) {
88 return (a << 24) | (b << 16) | (c << 8) | d;
89 }
90
91 /*- Data access macros for data stored in big-endian or little-endian format */
GetInt16(const sal_uInt8 * ptr,sal_uInt32 offset,int bigendian)92 _inline sal_Int16 GetInt16( const sal_uInt8* ptr, sal_uInt32 offset, int bigendian)
93 {
94 sal_Int16 t;
95 assert(ptr != 0);
96
97 if (bigendian) {
98 t = (ptr+offset)[0] << 8 | (ptr+offset)[1];
99 } else {
100 t = (ptr+offset)[1] << 8 | (ptr+offset)[0];
101 }
102
103 return t;
104 }
105
GetUInt16(const sal_uInt8 * ptr,sal_uInt32 offset,int bigendian)106 _inline sal_uInt16 GetUInt16( const sal_uInt8* ptr, sal_uInt32 offset, int bigendian)
107 {
108 sal_uInt16 t;
109 assert(ptr != 0);
110
111 if (bigendian) {
112 t = (ptr+offset)[0] << 8 | (ptr+offset)[1];
113 } else {
114 t = (ptr+offset)[1] << 8 | (ptr+offset)[0];
115 }
116
117 return t;
118 }
119
GetInt32(const sal_uInt8 * ptr,sal_uInt32 offset,int bigendian)120 _inline sal_Int32 GetInt32( const sal_uInt8* ptr, sal_uInt32 offset, int bigendian)
121 {
122 sal_Int32 t;
123 assert(ptr != 0);
124
125 if (bigendian) {
126 t = (ptr+offset)[0] << 24 | (ptr+offset)[1] << 16 |
127 (ptr+offset)[2] << 8 | (ptr+offset)[3];
128 } else {
129 t = (ptr+offset)[3] << 24 | (ptr+offset)[2] << 16 |
130 (ptr+offset)[1] << 8 | (ptr+offset)[0];
131 }
132
133 return t;
134 }
135
GetUInt32(const sal_uInt8 * ptr,sal_uInt32 offset,int bigendian)136 _inline sal_uInt32 GetUInt32( const sal_uInt8* ptr, sal_uInt32 offset, int bigendian)
137 {
138 sal_uInt32 t;
139 assert(ptr != 0);
140
141
142 if (bigendian) {
143 t = (ptr+offset)[0] << 24 | (ptr+offset)[1] << 16 |
144 (ptr+offset)[2] << 8 | (ptr+offset)[3];
145 } else {
146 t = (ptr+offset)[3] << 24 | (ptr+offset)[2] << 16 |
147 (ptr+offset)[1] << 8 | (ptr+offset)[0];
148 }
149
150 return t;
151 }
152
153
PutInt16(sal_Int16 val,sal_uInt8 * ptr,sal_uInt32 offset,int bigendian)154 _inline void PutInt16(sal_Int16 val, sal_uInt8 *ptr, sal_uInt32 offset, int bigendian)
155 {
156 assert(ptr != 0);
157
158 if (bigendian) {
159 ptr[offset] = (sal_uInt8)((val >> 8) & 0xFF);
160 ptr[offset+1] = (sal_uInt8)(val & 0xFF);
161 } else {
162 ptr[offset+1] = (sal_uInt8)((val >> 8) & 0xFF);
163 ptr[offset] = (sal_uInt8)(val & 0xFF);
164 }
165 }
166
PutUInt16(sal_uInt16 val,sal_uInt8 * ptr,sal_uInt32 offset,int bigendian)167 _inline void PutUInt16(sal_uInt16 val, sal_uInt8 *ptr, sal_uInt32 offset, int bigendian)
168 {
169 assert(ptr != 0);
170
171 if (bigendian) {
172 ptr[offset] = (sal_uInt8)((val >> 8) & 0xFF);
173 ptr[offset+1] = (sal_uInt8)(val & 0xFF);
174 } else {
175 ptr[offset+1] = (sal_uInt8)((val >> 8) & 0xFF);
176 ptr[offset] = (sal_uInt8)(val & 0xFF);
177 }
178 }
179
PutUInt32(sal_uInt32 val,sal_uInt8 * ptr,sal_uInt32 offset,int bigendian)180 _inline void PutUInt32(sal_uInt32 val, sal_uInt8 *ptr, sal_uInt32 offset, int bigendian)
181 {
182 assert(ptr != 0);
183
184 if (bigendian) {
185 ptr[offset] = (sal_uInt8)((val >> 24) & 0xFF);
186 ptr[offset+1] = (sal_uInt8)((val >> 16) & 0xFF);
187 ptr[offset+2] = (sal_uInt8)((val >> 8) & 0xFF);
188 ptr[offset+3] = (sal_uInt8)(val & 0xFF);
189 } else {
190 ptr[offset+3] = (sal_uInt8)((val >> 24) & 0xFF);
191 ptr[offset+2] = (sal_uInt8)((val >> 16) & 0xFF);
192 ptr[offset+1] = (sal_uInt8)((val >> 8) & 0xFF);
193 ptr[offset] = (sal_uInt8)(val & 0xFF);
194 }
195
196 }
197
198
PutInt32(sal_Int32 val,sal_uInt8 * ptr,sal_uInt32 offset,int bigendian)199 _inline void PutInt32(sal_Int32 val, sal_uInt8 *ptr, sal_uInt32 offset, int bigendian)
200 {
201 assert(ptr != 0);
202
203 if (bigendian) {
204 ptr[offset] = (sal_uInt8)((val >> 24) & 0xFF);
205 ptr[offset+1] = (sal_uInt8)((val >> 16) & 0xFF);
206 ptr[offset+2] = (sal_uInt8)((val >> 8) & 0xFF);
207 ptr[offset+3] = (sal_uInt8)(val & 0xFF);
208 } else {
209 ptr[offset+3] = (sal_uInt8)((val >> 24) & 0xFF);
210 ptr[offset+2] = (sal_uInt8)((val >> 16) & 0xFF);
211 ptr[offset+1] = (sal_uInt8)((val >> 8) & 0xFF);
212 ptr[offset] = (sal_uInt8)(val & 0xFF);
213 }
214
215 }
216
TableEntryCompareF(const void * l,const void * r)217 static int TableEntryCompareF(const void *l, const void *r)
218 {
219 return ((const TableEntry *) l)->tag - ((const TableEntry *) r)->tag;
220 }
221
NameRecordCompareF(const void * l,const void * r)222 static int NameRecordCompareF(const void *l, const void *r)
223 {
224 NameRecord *ll = (NameRecord *) l;
225 NameRecord *rr = (NameRecord *) r;
226
227 if (ll->platformID != rr->platformID) {
228 return ll->platformID - rr->platformID;
229 } else if (ll->encodingID != rr->encodingID) {
230 return ll->encodingID - rr->encodingID;
231 } else if (ll->languageID != rr->languageID) {
232 return ll->languageID - rr->languageID;
233 } else if (ll->nameID != rr->nameID) {
234 return ll->nameID - rr->nameID;
235 }
236 return 0;
237 }
238
239
CheckSum(sal_uInt32 * ptr,sal_uInt32 length)240 static sal_uInt32 CheckSum(sal_uInt32 *ptr, sal_uInt32 length)
241 {
242 sal_uInt32 sum = 0;
243 sal_uInt32 *endptr = ptr + ((length + 3) & (sal_uInt32) ~3) / 4;
244
245 while (ptr < endptr) sum += *ptr++;
246
247 return sum;
248 }
249
smalloc(sal_uInt32 size)250 _inline void *smalloc(sal_uInt32 size)
251 {
252 void *res = malloc(size);
253 assert(res != 0);
254 return res;
255 }
256
scalloc(sal_uInt32 n,sal_uInt32 size)257 _inline void *scalloc(sal_uInt32 n, sal_uInt32 size)
258 {
259 void *res = calloc(n, size);
260 assert(res != 0);
261 return res;
262 }
263
264 /*
265 * Public functions
266 */
267
TrueTypeCreatorNewEmpty(sal_uInt32 tag,TrueTypeCreator ** _this)268 void TrueTypeCreatorNewEmpty(sal_uInt32 tag, TrueTypeCreator **_this)
269 {
270 TrueTypeCreator* ptr = (TrueTypeCreator*)smalloc(sizeof(TrueTypeCreator));
271
272 ptr->tables = listNewEmpty();
273 listSetElementDtor(ptr->tables, (list_destructor)TrueTypeTableDispose);
274
275 ptr->tag = tag;
276
277 *_this = ptr;
278 }
279
AddTable(TrueTypeCreator * _this,TrueTypeTable * table)280 int AddTable(TrueTypeCreator *_this, TrueTypeTable *table)
281 {
282 if (table != 0) {
283 listAppend(_this->tables, table);
284 }
285 return SF_OK;
286 }
287
RemoveTable(TrueTypeCreator * _this,sal_uInt32 tag)288 void RemoveTable(TrueTypeCreator *_this, sal_uInt32 tag)
289 {
290 int done = 0;
291
292 if (listCount(_this->tables)) {
293 listToFirst(_this->tables);
294 do {
295 if (((TrueTypeTable *) listCurrent(_this->tables))->tag == tag) {
296 listRemove(_this->tables);
297 } else {
298 if (listNext(_this->tables)) {
299 done = 1;
300 }
301 }
302 } while (!done);
303 }
304 }
305
306 static void ProcessTables(TrueTypeCreator *);
307
StreamToMemory(TrueTypeCreator * _this,sal_uInt8 ** ptr,sal_uInt32 * length)308 int StreamToMemory(TrueTypeCreator *_this, sal_uInt8 **ptr, sal_uInt32 *length)
309 {
310 sal_uInt16 numTables, searchRange=1, entrySelector=0, rangeShift;
311 sal_uInt32 s, offset, checkSumAdjustment = 0;
312 sal_uInt32 *p;
313 int i=0, n;
314 sal_uInt8 *head = NULL; /* saved pointer to the head table data for checkSumAdjustment calculation */
315
316 if ((n = listCount(_this->tables)) == 0) return SF_TTFORMAT;
317
318 ProcessTables(_this);
319
320 /* ProcessTables() adds 'loca' and 'hmtx' */
321
322 n = listCount(_this->tables);
323 numTables = (sal_uInt16) n;
324
325
326 TableEntry* te = (TableEntry*)scalloc(n, sizeof(TableEntry));
327
328 listToFirst(_this->tables);
329 for (i = 0; i < n; i++) {
330 GetRawData((TrueTypeTable *) listCurrent(_this->tables), &te[i].data, &te[i].length, &te[i].tag);
331 listNext(_this->tables);
332 }
333
334 qsort(te, n, sizeof(TableEntry), TableEntryCompareF);
335
336 do {
337 searchRange *= 2;
338 entrySelector++;
339 } while (searchRange <= numTables);
340
341 searchRange *= 8;
342 entrySelector--;
343 rangeShift = numTables * 16 - searchRange;
344
345 s = offset = 12 + 16 * n;
346
347 for (i = 0; i < n; i++) {
348 s += (te[i].length + 3) & (sal_uInt32) ~3;
349 /* if ((te[i].length & 3) != 0) s += (4 - (te[i].length & 3)) & 3; */
350 }
351
352 sal_uInt8* ttf = (sal_uInt8*)smalloc(s);
353
354 /* Offset Table */
355 PutUInt32(_this->tag, ttf, 0, 1);
356 PutUInt16(numTables, ttf, 4, 1);
357 PutUInt16(searchRange, ttf, 6, 1);
358 PutUInt16(entrySelector, ttf, 8, 1);
359 PutUInt16(rangeShift, ttf, 10, 1);
360
361 /* Table Directory */
362 for (i = 0; i < n; i++) {
363 PutUInt32(te[i].tag, ttf + 12, 16 * i, 1);
364 PutUInt32(CheckSum((sal_uInt32 *) te[i].data, te[i].length), ttf + 12, 16 * i + 4, 1);
365 PutUInt32(offset, ttf + 12, 16 * i + 8, 1);
366 PutUInt32(te[i].length, ttf + 12, 16 * i + 12, 1);
367
368 if (te[i].tag == T_head) {
369 head = ttf + offset;
370 }
371
372 memcpy(ttf+offset, te[i].data, (te[i].length + 3) & (sal_uInt32) ~3 );
373 offset += (te[i].length + 3) & (sal_uInt32) ~3;
374 /* if ((te[i].length & 3) != 0) offset += (4 - (te[i].length & 3)) & 3; */
375 }
376
377 free(te);
378
379 p = (sal_uInt32 *) ttf;
380 for (i = 0; i < (int)s / 4; i++) checkSumAdjustment += p[i];
381 PutUInt32(0xB1B0AFBA - checkSumAdjustment, head, 8, 1);
382
383 *ptr = ttf;
384 *length = s;
385
386 return SF_OK;
387 }
388
StreamToFile(TrueTypeCreator * _this,const char * fname)389 int StreamToFile(TrueTypeCreator *_this, const char* fname)
390 {
391 sal_uInt8 *ptr;
392 sal_uInt32 length;
393 int r;
394 FILE* fd;
395
396 if ((r = StreamToMemory(_this, &ptr, &length)) != SF_OK) return r;
397 if ((!fname) || ((fd = fopen(fname, "wb")) == NULL)) {
398 free(ptr);
399 return SF_BADFILE;
400 }
401 if (fwrite(ptr, 1, length, fd) != length) {
402 r = SF_FILEIO;
403 } else {
404 r = SF_OK;
405 }
406
407 fclose(fd);
408 free(ptr);
409 return r;
410 }
411
412
413
414 /*
415 * TrueTypeTable private methods
416 */
417
418 #define TABLESIZE_head 54
419 #define TABLESIZE_hhea 36
420 #define TABLESIZE_maxp 32
421
422
423
424 /* Table data points to
425 * --------------------------------------------
426 * generic tdata_generic struct
427 * 'head' TABLESIZE_head bytes of memory
428 * 'hhea' TABLESIZE_hhea bytes of memory
429 * 'loca' tdata_loca struct
430 * 'maxp' TABLESIZE_maxp bytes of memory
431 * 'glyf' list of GlyphData structs (defined in sft.h)
432 * 'name' list of NameRecord structs (defined in sft.h)
433 * 'post' tdata_post struct
434 *
435 */
436
437
438 #define CMAP_SUBTABLE_INIT 10
439 #define CMAP_SUBTABLE_INCR 10
440 #define CMAP_PAIR_INIT 500
441 #define CMAP_PAIR_INCR 500
442
443 typedef struct {
444 sal_uInt32 id; /* subtable ID (platform/encoding ID) */
445 sal_uInt32 n; /* number of used translation pairs */
446 sal_uInt32 m; /* number of allocated translation pairs */
447 sal_uInt32 *xc; /* character array */
448 sal_uInt32 *xg; /* glyph array */
449 } CmapSubTable;
450
451 typedef struct {
452 sal_uInt32 n; /* number of used CMAP sub-tables */
453 sal_uInt32 m; /* number of allocated CMAP sub-tables */
454 CmapSubTable *s; /* sorted array of sub-tables */
455 } table_cmap;
456
457 typedef struct {
458 sal_uInt32 tag;
459 sal_uInt32 nbytes;
460 sal_uInt8 *ptr;
461 } tdata_generic;
462
463 typedef struct {
464 sal_uInt32 nbytes; /* number of bytes in loca table */
465 sal_uInt8 *ptr; /* pointer to the data */
466 } tdata_loca;
467
468 typedef struct {
469 sal_uInt32 format;
470 sal_uInt32 italicAngle;
471 sal_Int16 underlinePosition;
472 sal_Int16 underlineThickness;
473 sal_uInt32 isFixedPitch;
474 void *ptr; /* format-specific pointer */
475 } tdata_post;
476
477
478 /* allocate memory for a TT table */
ttmalloc(sal_uInt32 nbytes)479 static sal_uInt8 *ttmalloc(sal_uInt32 nbytes)
480 {
481 sal_uInt32 n;
482
483 n = (nbytes + 3) & (sal_uInt32) ~3;
484 sal_uInt8* res = (sal_uInt8*)malloc(n);
485 assert(res != 0);
486 memset(res, 0, n);
487
488 return res;
489 }
490
FreeGlyphData(void * ptr)491 static void FreeGlyphData(void *ptr)
492 {
493 GlyphData *p = (GlyphData *) ptr;
494 if (p->ptr) free(p->ptr);
495 free(p);
496 }
497
TrueTypeTableDispose_generic(TrueTypeTable * _this)498 static void TrueTypeTableDispose_generic(TrueTypeTable *_this)
499 {
500 if (_this) {
501 if (_this->data) {
502 tdata_generic *pdata = (tdata_generic *) _this->data;
503 if (pdata->nbytes) free(pdata->ptr);
504 free(_this->data);
505 }
506 free(_this);
507 }
508 }
509
TrueTypeTableDispose_head(TrueTypeTable * _this)510 static void TrueTypeTableDispose_head(TrueTypeTable *_this)
511 {
512 if (_this) {
513 if (_this->data) free(_this->data);
514 free(_this);
515 }
516 }
517
TrueTypeTableDispose_hhea(TrueTypeTable * _this)518 static void TrueTypeTableDispose_hhea(TrueTypeTable *_this)
519 {
520 if (_this) {
521 if (_this->data) free(_this->data);
522 free(_this);
523 }
524 }
525
TrueTypeTableDispose_loca(TrueTypeTable * _this)526 static void TrueTypeTableDispose_loca(TrueTypeTable *_this)
527 {
528 if (_this) {
529 if (_this->data) {
530 tdata_loca *p = (tdata_loca *) _this->data;
531 if (p->ptr) free(p->ptr);
532 free(_this->data);
533 }
534 free(_this);
535 }
536 }
537
TrueTypeTableDispose_maxp(TrueTypeTable * _this)538 static void TrueTypeTableDispose_maxp(TrueTypeTable *_this)
539 {
540 if (_this) {
541 if (_this->data) free(_this->data);
542 free(_this);
543 }
544 }
545
TrueTypeTableDispose_glyf(TrueTypeTable * _this)546 static void TrueTypeTableDispose_glyf(TrueTypeTable *_this)
547 {
548 if (_this) {
549 if (_this->data) listDispose((list) _this->data);
550 free(_this);
551 }
552 }
553
TrueTypeTableDispose_cmap(TrueTypeTable * _this)554 static void TrueTypeTableDispose_cmap(TrueTypeTable *_this)
555 {
556 table_cmap *t;
557 CmapSubTable *s;
558 sal_uInt32 i;
559
560 if (_this) {
561 t = (table_cmap *) _this->data;
562 if (t) {
563 s = t->s;
564 if (s) {
565 for (i = 0; i < t->m; i++) {
566 if (s[i].xc) free(s[i].xc);
567 if (s[i].xg) free(s[i].xg);
568 }
569 free(s);
570 }
571 free(t);
572 }
573 free(_this);
574 }
575 }
576
TrueTypeTableDispose_name(TrueTypeTable * _this)577 static void TrueTypeTableDispose_name(TrueTypeTable *_this)
578 {
579 if (_this) {
580 if (_this->data) listDispose((list) _this->data);
581 free(_this);
582 }
583 }
584
TrueTypeTableDispose_post(TrueTypeTable * _this)585 static void TrueTypeTableDispose_post(TrueTypeTable *_this)
586 {
587 if (_this) {
588 tdata_post *p = (tdata_post *) _this->data;
589 if (p) {
590 if (p->format == 0x00030000) {
591 /* do nothing */
592 } else {
593 fprintf(stderr, "Unsupported format of a 'post' table: %08X.\n", (int)p->format);
594 }
595 free(p);
596 }
597 free(_this);
598 }
599 }
600
601 /* destructor vtable */
602
603 static struct {
604 sal_uInt32 tag;
605 void (*f)(TrueTypeTable *);
606 } vtable1[] =
607 {
608 {0, TrueTypeTableDispose_generic},
609 {T_head, TrueTypeTableDispose_head},
610 {T_hhea, TrueTypeTableDispose_hhea},
611 {T_loca, TrueTypeTableDispose_loca},
612 {T_maxp, TrueTypeTableDispose_maxp},
613 {T_glyf, TrueTypeTableDispose_glyf},
614 {T_cmap, TrueTypeTableDispose_cmap},
615 {T_name, TrueTypeTableDispose_name},
616 {T_post, TrueTypeTableDispose_post}
617
618 };
619
GetRawData_generic(TrueTypeTable * _this,sal_uInt8 ** ptr,sal_uInt32 * len,sal_uInt32 * tag)620 static int GetRawData_generic(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
621 {
622 assert(_this != 0);
623 assert(_this->data != 0);
624
625 *ptr = ((tdata_generic *) _this->data)->ptr;
626 *len = ((tdata_generic *) _this->data)->nbytes;
627 *tag = ((tdata_generic *) _this->data)->tag;
628
629 return TTCR_OK;
630 }
631
632
GetRawData_head(TrueTypeTable * _this,sal_uInt8 ** ptr,sal_uInt32 * len,sal_uInt32 * tag)633 static int GetRawData_head(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
634 {
635 *len = TABLESIZE_head;
636 *ptr = (sal_uInt8 *) _this->data;
637 *tag = T_head;
638
639 return TTCR_OK;
640 }
641
GetRawData_hhea(TrueTypeTable * _this,sal_uInt8 ** ptr,sal_uInt32 * len,sal_uInt32 * tag)642 static int GetRawData_hhea(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
643 {
644 *len = TABLESIZE_hhea;
645 *ptr = (sal_uInt8 *) _this->data;
646 *tag = T_hhea;
647
648 return TTCR_OK;
649 }
650
GetRawData_loca(TrueTypeTable * _this,sal_uInt8 ** ptr,sal_uInt32 * len,sal_uInt32 * tag)651 static int GetRawData_loca(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
652 {
653 tdata_loca *p;
654
655 assert(_this->data != 0);
656
657 p = (tdata_loca *) _this->data;
658
659 if (p->nbytes == 0) return TTCR_ZEROGLYPHS;
660
661 *ptr = p->ptr;
662 *len = p->nbytes;
663 *tag = T_loca;
664
665 return TTCR_OK;
666 }
667
GetRawData_maxp(TrueTypeTable * _this,sal_uInt8 ** ptr,sal_uInt32 * len,sal_uInt32 * tag)668 static int GetRawData_maxp(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
669 {
670 *len = TABLESIZE_maxp;
671 *ptr = (sal_uInt8 *) _this->data;
672 *tag = T_maxp;
673
674 return TTCR_OK;
675 }
676
GetRawData_glyf(TrueTypeTable * _this,sal_uInt8 ** ptr,sal_uInt32 * len,sal_uInt32 * tag)677 static int GetRawData_glyf(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
678 {
679 sal_uInt32 n, nbytes = 0;
680 list l = (list) _this->data;
681 /* sal_uInt16 curID = 0; */ /* to check if glyph IDs are sequential and start from zero */
682 sal_uInt8 *p;
683
684 *ptr = 0;
685 *len = 0;
686 *tag = 0;
687
688 if (listCount(l) == 0) return TTCR_ZEROGLYPHS;
689
690 listToFirst(l);
691 do {
692 /* if (((GlyphData *) listCurrent(l))->glyphID != curID++) return TTCR_GLYPHSEQ; */
693 nbytes += ((GlyphData *) listCurrent(l))->nbytes;
694 } while (listNext(l));
695
696 p = _this->rawdata = ttmalloc(nbytes);
697
698 listToFirst(l);
699 do {
700 n = ((GlyphData *) listCurrent(l))->nbytes;
701 if (n != 0) {
702 memcpy(p, ((GlyphData *) listCurrent(l))->ptr, n);
703 p += n;
704 }
705 } while (listNext(l));
706
707 *len = nbytes;
708 *ptr = _this->rawdata;
709 *tag = T_glyf;
710
711 return TTCR_OK;
712 }
713
714 /* cmap packers */
PackCmapType0(CmapSubTable * s,sal_uInt32 * length)715 static sal_uInt8 *PackCmapType0(CmapSubTable *s, sal_uInt32 *length)
716 {
717 sal_uInt8* ptr = (sal_uInt8*)smalloc(262);
718 sal_uInt8 *p = ptr + 6;
719 sal_uInt32 i, j;
720 sal_uInt16 g;
721
722 PutUInt16(0, ptr, 0, 1);
723 PutUInt16(262, ptr, 2, 1);
724 PutUInt16(0, ptr, 4, 1);
725
726 for (i = 0; i < 256; i++) {
727 g = 0;
728 for (j = 0; j < s->n; j++) {
729 if (s->xc[j] == i) {
730 g = (sal_uInt16) s->xg[j];
731 }
732 }
733 p[i] = (sal_uInt8) g;
734 }
735 *length = 262;
736 return ptr;
737 }
738
PackCmapType6(CmapSubTable * s,sal_uInt32 * length)739 static sal_uInt8 *PackCmapType6(CmapSubTable *s, sal_uInt32 *length)
740 {
741 sal_uInt8* ptr = (sal_uInt8*)smalloc(s->n*2 + 10);
742 sal_uInt8 *p = ptr + 10;
743 sal_uInt32 i, j;
744 sal_uInt16 g;
745
746 PutUInt16(6, ptr, 0, 1);
747 PutUInt16((sal_uInt16)(s->n*2+10), ptr, 2, 1);
748 PutUInt16(0, ptr, 4, 1);
749 PutUInt16(0, ptr, 6, 1);
750 PutUInt16((sal_uInt16)(s->n), ptr, 8, 1 );
751
752 for (i = 0; i < s->n; i++) {
753 g = 0;
754 for (j = 0; j < s->n; j++) {
755 if (s->xc[j] == i) {
756 g = (sal_uInt16) s->xg[j];
757 }
758 }
759 PutUInt16( g, p, 2*i, 1 );
760 }
761 *length = s->n*2+10;
762 return ptr;
763 }
764
765
766
767 /* XXX it only handles Format 0 encoding tables */
PackCmap(CmapSubTable * s,sal_uInt32 * length)768 static sal_uInt8 *PackCmap(CmapSubTable *s, sal_uInt32 *length)
769 {
770 if( s->xg[s->n-1] > 0xff )
771 return PackCmapType6(s, length);
772 else
773 return PackCmapType0(s, length);
774 }
775
GetRawData_cmap(TrueTypeTable * _this,sal_uInt8 ** ptr,sal_uInt32 * len,sal_uInt32 * tag)776 static int GetRawData_cmap(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
777 {
778 table_cmap *t;
779 sal_uInt32 i;
780 sal_uInt32 tlen = 0;
781 sal_uInt32 l;
782 sal_uInt32 cmapsize;
783 sal_uInt8 *cmap;
784 sal_uInt32 coffset;
785
786 assert(_this != 0);
787 t = (table_cmap *) _this->data;
788 assert(t != 0);
789 assert(t->n != 0);
790
791 sal_uInt8** subtables = (sal_uInt8**)scalloc(t->n, sizeof(sal_uInt8 *));
792 sal_uInt32* sizes = (sal_uInt32*)scalloc(t->n, sizeof(sal_uInt32));
793
794 for (i = 0; i < t->n; i++) {
795 subtables[i] = PackCmap(t->s+i, &l);
796 sizes[i] = l;
797 tlen += l;
798 }
799
800 cmapsize = tlen + 4 + 8 * t->n;
801 _this->rawdata = cmap = ttmalloc(cmapsize);
802
803 PutUInt16(0, cmap, 0, 1);
804 PutUInt16((sal_uInt16)t->n, cmap, 2, 1);
805 coffset = 4 + t->n * 8;
806
807 for (i = 0; i < t->n; i++) {
808 PutUInt16((sal_uInt16)(t->s[i].id >> 16), cmap + 4, i * 8, 1);
809 PutUInt16((sal_uInt16)(t->s[i].id & 0xFF), cmap + 4, 2 + i * 8, 1);
810 PutUInt32(coffset, cmap + 4, 4 + i * 8, 1);
811 memcpy(cmap + coffset, subtables[i], sizes[i]);
812 free(subtables[i]);
813 coffset += sizes[i];
814 }
815
816 free(subtables);
817 free(sizes);
818
819 *ptr = cmap;
820 *len = cmapsize;
821 *tag = T_cmap;
822
823 return TTCR_OK;
824 }
825
826
GetRawData_name(TrueTypeTable * _this,sal_uInt8 ** ptr,sal_uInt32 * len,sal_uInt32 * tag)827 static int GetRawData_name(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
828 {
829 list l;
830 sal_Int16 i=0, n; /* number of Name Records */
831 int stringLen = 0;
832 sal_uInt8 *p1, *p2;
833
834 *ptr = 0;
835 *len = 0;
836 *tag = 0;
837
838 assert(_this != 0);
839 l = (list) _this->data;
840 assert(l != 0);
841
842 if ((n = (sal_Int16)listCount(l)) == 0) return TTCR_NONAMES;
843
844 NameRecord* nr = (NameRecord*)scalloc(n, sizeof(NameRecord));
845
846 listToFirst(l);
847
848 do {
849 memcpy(nr+i, listCurrent(l), sizeof(NameRecord));
850 stringLen += nr[i].slen;
851 i++;
852 } while (listNext(l));
853
854 if (stringLen > 65535) {
855 free(nr);
856 return TTCR_NAMETOOLONG;
857 }
858
859 qsort(nr, n, sizeof(NameRecord), NameRecordCompareF);
860
861 int nameLen = stringLen + 12 * n + 6;
862 sal_uInt8* name = (sal_uInt8*)ttmalloc(nameLen);
863
864 PutUInt16(0, name, 0, 1);
865 PutUInt16(n, name, 2, 1);
866 PutUInt16((sal_uInt16)(6 + 12 * n), name, 4, 1);
867
868 p1 = name + 6;
869 p2 = p1 + 12 * n;
870
871 for (i = 0; i < n; i++) {
872 PutUInt16(nr[i].platformID, p1, 0, 1);
873 PutUInt16(nr[i].encodingID, p1, 2, 1);
874 PutUInt16(nr[i].languageID, p1, 4, 1);
875 PutUInt16(nr[i].nameID, p1, 6, 1);
876 PutUInt16(nr[i].slen, p1, 8, 1);
877 PutUInt16((sal_uInt16)(p2 - (name + 6 + 12 * n)), p1, 10, 1);
878 memcpy(p2, nr[i].sptr, nr[i].slen);
879 /* {int j; for(j=0; j<nr[i].slen; j++) printf("%c", nr[i].sptr[j]); printf("\n"); }; */
880 p2 += nr[i].slen;
881 p1 += 12;
882 }
883
884 free(nr);
885 _this->rawdata = name;
886
887 *ptr = name;
888 *len = (sal_uInt16)nameLen;
889 *tag = T_name;
890
891 /*{int j; for(j=0; j<nameLen; j++) printf("%c", name[j]); }; */
892
893 return TTCR_OK;
894 }
895
GetRawData_post(TrueTypeTable * _this,sal_uInt8 ** ptr,sal_uInt32 * len,sal_uInt32 * tag)896 static int GetRawData_post(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
897 {
898 tdata_post *p = (tdata_post *) _this->data;
899 sal_uInt8 *post = 0;
900 sal_uInt32 postLen = 0;
901 int ret;
902
903 if (_this->rawdata) free(_this->rawdata);
904
905 if (p->format == 0x00030000) {
906 postLen = 32;
907 post = ttmalloc(postLen);
908 PutUInt32(0x00030000, post, 0, 1);
909 PutUInt32(p->italicAngle, post, 4, 1);
910 PutUInt16(p->underlinePosition, post, 8, 1);
911 PutUInt16(p->underlineThickness, post, 10, 1);
912 PutUInt16((sal_uInt16)p->isFixedPitch, post, 12, 1);
913 ret = TTCR_OK;
914 } else {
915 fprintf(stderr, "Unrecognized format of a post table: %08X.\n", (int)p->format);
916 ret = TTCR_POSTFORMAT;
917 }
918
919 *ptr = _this->rawdata = post;
920 *len = postLen;
921 *tag = T_post;
922
923 return ret;
924 }
925
926
927
928
929
930 static struct {
931 sal_uInt32 tag;
932 int (*f)(TrueTypeTable *, sal_uInt8 **, sal_uInt32 *, sal_uInt32 *);
933 } vtable2[] =
934 {
935 {0, GetRawData_generic},
936 {T_head, GetRawData_head},
937 {T_hhea, GetRawData_hhea},
938 {T_loca, GetRawData_loca},
939 {T_maxp, GetRawData_maxp},
940 {T_glyf, GetRawData_glyf},
941 {T_cmap, GetRawData_cmap},
942 {T_name, GetRawData_name},
943 {T_post, GetRawData_post}
944
945
946 };
947
948 /*
949 * TrueTypeTable public methods
950 */
951
952 /* Note: Type42 fonts only need these tables:
953 * head, hhea, loca, maxp, cvt, prep, glyf, hmtx, fpgm
954 *
955 * Microsoft required tables
956 * cmap, glyf, head, hhea, hmtx, loca, maxp, name, post, OS/2
957 *
958 * Apple required tables
959 * cmap, glyf, head, hhea, hmtx, loca, maxp, name, post
960 *
961 */
962
TrueTypeTableNew(sal_uInt32 tag,sal_uInt32 nbytes,const sal_uInt8 * ptr)963 TrueTypeTable *TrueTypeTableNew(sal_uInt32 tag,
964 sal_uInt32 nbytes,
965 const sal_uInt8* ptr)
966 {
967 TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
968 tdata_generic* pdata = (tdata_generic*)smalloc(sizeof(tdata_generic));
969 pdata->nbytes = nbytes;
970 pdata->tag = tag;
971 if (nbytes) {
972 pdata->ptr = ttmalloc(nbytes);
973 memcpy(pdata->ptr, ptr, nbytes);
974 } else {
975 pdata->ptr = 0;
976 }
977
978 table->tag = 0;
979 table->data = pdata;
980 table->rawdata = 0;
981
982 return table;
983 }
984
TrueTypeTableNew_head(sal_uInt32 fontRevision,sal_uInt16 flags,sal_uInt16 unitsPerEm,const sal_uInt8 * created,sal_uInt16 macStyle,sal_uInt16 lowestRecPPEM,sal_Int16 fontDirectionHint)985 TrueTypeTable *TrueTypeTableNew_head(sal_uInt32 fontRevision,
986 sal_uInt16 flags,
987 sal_uInt16 unitsPerEm,
988 const sal_uInt8* created,
989 sal_uInt16 macStyle,
990 sal_uInt16 lowestRecPPEM,
991 sal_Int16 fontDirectionHint)
992 {
993 assert(created != 0);
994
995 TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
996 sal_uInt8* ptr = (sal_uInt8*)ttmalloc(TABLESIZE_head);
997
998
999 PutUInt32(0x00010000, ptr, 0, 1); /* version */
1000 PutUInt32(fontRevision, ptr, 4, 1);
1001 PutUInt32(0x5F0F3CF5, ptr, 12, 1); /* magic number */
1002 PutUInt16(flags, ptr, 16, 1);
1003 PutUInt16(unitsPerEm, ptr, 18, 1);
1004 memcpy(ptr+20, created, 8); /* Created Long Date */
1005 memset(ptr+28, 0, 8); /* Modified Long Date */
1006 PutUInt16(macStyle, ptr, 44, 1);
1007 PutUInt16(lowestRecPPEM, ptr, 46, 1);
1008 PutUInt16(fontDirectionHint, ptr, 48, 1);
1009 PutUInt16(0, ptr, 52, 1); /* glyph data format: 0 */
1010
1011 table->data = (void *) ptr;
1012 table->tag = T_head;
1013 table->rawdata = 0;
1014
1015 return table;
1016 }
1017
TrueTypeTableNew_hhea(sal_Int16 ascender,sal_Int16 descender,sal_Int16 linegap,sal_Int16 caretSlopeRise,sal_Int16 caretSlopeRun)1018 TrueTypeTable *TrueTypeTableNew_hhea(sal_Int16 ascender,
1019 sal_Int16 descender,
1020 sal_Int16 linegap,
1021 sal_Int16 caretSlopeRise,
1022 sal_Int16 caretSlopeRun)
1023 {
1024 TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
1025 sal_uInt8* ptr = (sal_uInt8*)ttmalloc(TABLESIZE_hhea);
1026
1027 PutUInt32(0x00010000, ptr, 0, 1); /* version */
1028 PutUInt16(ascender, ptr, 4, 1);
1029 PutUInt16(descender, ptr, 6, 1);
1030 PutUInt16(linegap, ptr, 8, 1);
1031 PutUInt16(caretSlopeRise, ptr, 18, 1);
1032 PutUInt16(caretSlopeRun, ptr, 20, 1);
1033 PutUInt16(0, ptr, 22, 1); /* reserved 1 */
1034 PutUInt16(0, ptr, 24, 1); /* reserved 2 */
1035 PutUInt16(0, ptr, 26, 1); /* reserved 3 */
1036 PutUInt16(0, ptr, 28, 1); /* reserved 4 */
1037 PutUInt16(0, ptr, 30, 1); /* reserved 5 */
1038 PutUInt16(0, ptr, 32, 1); /* metricDataFormat */
1039
1040 table->data = (void *) ptr;
1041 table->tag = T_hhea;
1042 table->rawdata = 0;
1043
1044 return table;
1045 }
1046
TrueTypeTableNew_loca(void)1047 TrueTypeTable *TrueTypeTableNew_loca(void)
1048 {
1049 TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
1050 table->data = smalloc(sizeof(tdata_loca));
1051
1052 ((tdata_loca *)table->data)->nbytes = 0;
1053 ((tdata_loca *)table->data)->ptr = 0;
1054
1055 table->tag = T_loca;
1056 table->rawdata = 0;
1057
1058 return table;
1059 }
1060
TrueTypeTableNew_maxp(const sal_uInt8 * maxp,int size)1061 TrueTypeTable *TrueTypeTableNew_maxp( const sal_uInt8* maxp, int size)
1062 {
1063 TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
1064 table->data = ttmalloc(TABLESIZE_maxp);
1065
1066 if (maxp && size == TABLESIZE_maxp) {
1067 memcpy(table->data, maxp, TABLESIZE_maxp);
1068 }
1069
1070 table->tag = T_maxp;
1071 table->rawdata = 0;
1072
1073 return table;
1074 }
1075
TrueTypeTableNew_glyf(void)1076 TrueTypeTable *TrueTypeTableNew_glyf(void)
1077 {
1078 TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
1079 list l = listNewEmpty();
1080
1081 assert(l != 0);
1082
1083 listSetElementDtor(l, (list_destructor)FreeGlyphData);
1084
1085 table->data = l;
1086 table->rawdata = 0;
1087 table->tag = T_glyf;
1088
1089 return table;
1090 }
1091
TrueTypeTableNew_cmap(void)1092 TrueTypeTable *TrueTypeTableNew_cmap(void)
1093 {
1094 TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
1095 table_cmap* cmap = (table_cmap*)smalloc(sizeof(table_cmap));
1096
1097 cmap->n = 0;
1098 cmap->m = CMAP_SUBTABLE_INIT;
1099 cmap->s = (CmapSubTable *) scalloc(CMAP_SUBTABLE_INIT, sizeof(CmapSubTable));
1100 memset(cmap->s, 0, sizeof(CmapSubTable) * CMAP_SUBTABLE_INIT);
1101
1102 table->data = (table_cmap *) cmap;
1103
1104 table->rawdata = 0;
1105 table->tag = T_cmap;
1106
1107 return table;
1108 }
1109
DisposeNameRecord(void * ptr)1110 static void DisposeNameRecord(void *ptr)
1111 {
1112 if (ptr != 0) {
1113 NameRecord *nr = (NameRecord *) ptr;
1114 if (nr->sptr) free(nr->sptr);
1115 free(ptr);
1116 }
1117 }
1118
NameRecordNewCopy(NameRecord * nr)1119 static NameRecord* NameRecordNewCopy(NameRecord *nr)
1120 {
1121 NameRecord* p = (NameRecord*)smalloc(sizeof(NameRecord));
1122
1123 memcpy(p, nr, sizeof(NameRecord));
1124
1125 if (p->slen) {
1126 p->sptr = (sal_uInt8*)smalloc(p->slen);
1127 memcpy(p->sptr, nr->sptr, p->slen);
1128 }
1129
1130 return p;
1131 }
1132
TrueTypeTableNew_name(int n,NameRecord * nr)1133 TrueTypeTable *TrueTypeTableNew_name(int n, NameRecord *nr)
1134 {
1135 TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
1136 list l = listNewEmpty();
1137
1138 assert(l != 0);
1139
1140 listSetElementDtor(l, (list_destructor)DisposeNameRecord);
1141
1142 if (n != 0) {
1143 int i;
1144 for (i = 0; i < n; i++) {
1145 listAppend(l, NameRecordNewCopy(nr+i));
1146 }
1147 }
1148
1149 table->data = l;
1150 table->rawdata = 0;
1151 table->tag = T_name;
1152
1153 return table;
1154 }
1155
TrueTypeTableNew_post(sal_uInt32 format,sal_uInt32 italicAngle,sal_Int16 underlinePosition,sal_Int16 underlineThickness,sal_uInt32 isFixedPitch)1156 TrueTypeTable *TrueTypeTableNew_post(sal_uInt32 format,
1157 sal_uInt32 italicAngle,
1158 sal_Int16 underlinePosition,
1159 sal_Int16 underlineThickness,
1160 sal_uInt32 isFixedPitch)
1161 {
1162 assert(format == 0x00030000); /* Only format 3.0 is supported at this time */
1163 TrueTypeTable* table = (TrueTypeTable*)smalloc(sizeof(TrueTypeTable));
1164 tdata_post* post = (tdata_post*)smalloc(sizeof(tdata_post));
1165
1166 post->format = format;
1167 post->italicAngle = italicAngle;
1168 post->underlinePosition = underlinePosition;
1169 post->underlineThickness = underlineThickness;
1170 post->isFixedPitch = isFixedPitch;
1171 post->ptr = 0;
1172
1173 table->data = post;
1174 table->rawdata = 0;
1175 table->tag = T_post;
1176
1177 return table;
1178 }
1179
GetRawData(TrueTypeTable * _this,sal_uInt8 ** ptr,sal_uInt32 * len,sal_uInt32 * tag)1180 int GetRawData(TrueTypeTable *_this, sal_uInt8 **ptr, sal_uInt32 *len, sal_uInt32 *tag)
1181 {
1182 /* XXX do a binary search */
1183 unsigned int i;
1184
1185 assert(_this != 0);
1186 assert(ptr != 0);
1187 assert(len != 0);
1188 assert(tag != 0);
1189
1190 *ptr = 0; *len = 0; *tag = 0;
1191
1192 if (_this->rawdata) {
1193 free(_this->rawdata);
1194 _this->rawdata = 0;
1195 }
1196
1197 for(i=0; i < sizeof(vtable2)/sizeof(*vtable2); i++) {
1198 if (_this->tag == vtable2[i].tag) {
1199 return vtable2[i].f(_this, ptr, len, tag);
1200 }
1201 }
1202
1203 assert(!"Unknown TrueType table.\n");
1204 return TTCR_UNKNOWN;
1205 }
1206
cmapAdd(TrueTypeTable * table,sal_uInt32 id,sal_uInt32 c,sal_uInt32 g)1207 void cmapAdd(TrueTypeTable *table, sal_uInt32 id, sal_uInt32 c, sal_uInt32 g)
1208 {
1209 sal_uInt32 i, found;
1210 table_cmap *t;
1211 CmapSubTable *s;
1212
1213 assert(table != 0);
1214 assert(table->tag == T_cmap);
1215 t = (table_cmap *) table->data; assert(t != 0);
1216 s = t->s; assert(s != 0);
1217
1218 found = 0;
1219
1220 for (i = 0; i < t->n; i++) {
1221 if (s[i].id == id) {
1222 found = 1;
1223 break;
1224 }
1225 }
1226
1227 if (!found) {
1228 if (t->n == t->m) {
1229 CmapSubTable* tmp = (CmapSubTable*)scalloc(t->m + CMAP_SUBTABLE_INCR, sizeof(CmapSubTable));
1230 memset(tmp, 0, t->m + CMAP_SUBTABLE_INCR * sizeof(CmapSubTable));
1231 memcpy(tmp, s, sizeof(CmapSubTable) * t->m);
1232 t->m += CMAP_SUBTABLE_INCR;
1233 free(s);
1234 s = tmp;
1235 t->s = s;
1236 }
1237
1238 for (i = 0; i < t->n; i++) {
1239 if (s[i].id > id) break;
1240 }
1241
1242 if (i < t->n) {
1243 memmove(s+i+1, s+i, t->n-i);
1244 }
1245
1246 t->n++;
1247
1248 s[i].id = id;
1249 s[i].n = 0;
1250 s[i].m = CMAP_PAIR_INIT;
1251 s[i].xc = (sal_uInt32*)scalloc(CMAP_PAIR_INIT, sizeof(sal_uInt32));
1252 s[i].xg = (sal_uInt32*)scalloc(CMAP_PAIR_INIT, sizeof(sal_uInt32));
1253 }
1254
1255 if (s[i].n == s[i].m) {
1256 sal_uInt32* tmp1 = (sal_uInt32*)scalloc(s[i].m + CMAP_PAIR_INCR, sizeof(sal_uInt32));
1257 sal_uInt32* tmp2 = (sal_uInt32*)scalloc(s[i].m + CMAP_PAIR_INCR, sizeof(sal_uInt32));
1258 assert(tmp1 != 0);
1259 assert(tmp2 != 0);
1260 memcpy(tmp1, s[i].xc, sizeof(sal_uInt32) * s[i].m);
1261 memcpy(tmp2, s[i].xg, sizeof(sal_uInt32) * s[i].m);
1262 s[i].m += CMAP_PAIR_INCR;
1263 free(s[i].xc);
1264 free(s[i].xg);
1265 s[i].xc = tmp1;
1266 s[i].xg = tmp2;
1267 }
1268
1269 s[i].xc[s[i].n] = c;
1270 s[i].xg[s[i].n] = g;
1271 s[i].n++;
1272 }
1273
glyfAdd(TrueTypeTable * table,GlyphData * glyphdata,TrueTypeFont * fnt)1274 sal_uInt32 glyfAdd(TrueTypeTable *table, GlyphData *glyphdata, TrueTypeFont *fnt)
1275 {
1276 list l;
1277 sal_uInt32 currentID;
1278 int ret, n, ncomponents;
1279 GlyphData *gd;
1280
1281 assert(table != 0);
1282 assert(table->tag == T_glyf);
1283
1284 if (!glyphdata) return (sal_uInt32)~0;
1285
1286 std::vector< sal_uInt32 > glyphlist;
1287
1288 ncomponents = GetTTGlyphComponents(fnt, glyphdata->glyphID, glyphlist);
1289
1290 l = (list) table->data;
1291 if (listCount(l) > 0) {
1292 listToLast(l);
1293 ret = n = ((GlyphData *) listCurrent(l))->newID + 1;
1294 } else {
1295 ret = n = 0;
1296 }
1297 glyphdata->newID = n++;
1298 listAppend(l, glyphdata);
1299
1300 if (ncomponents > 1 && glyphlist.size() > 1 )
1301 {
1302 std::vector< sal_uInt32 >::const_iterator it = glyphlist.begin();
1303 ++it;
1304 /* glyphData->glyphID is always the first glyph on the list */
1305 do
1306 {
1307 int found = 0;
1308 currentID = *it;
1309 /* XXX expensive! should be rewritten with sorted arrays! */
1310 listToFirst(l);
1311 do {
1312 if (((GlyphData *) listCurrent(l))->glyphID == currentID) {
1313 found = 1;
1314 break;
1315 }
1316 } while (listNext(l));
1317
1318 if (!found) {
1319 gd = GetTTRawGlyphData(fnt, currentID);
1320 gd->newID = n++;
1321 listAppend(l, gd);
1322 }
1323 } while( ++it != glyphlist.end() );
1324 }
1325
1326 return ret;
1327 }
1328
glyfCount(const TrueTypeTable * table)1329 sal_uInt32 glyfCount(const TrueTypeTable *table)
1330 {
1331 assert(table != 0);
1332 assert(table->tag == T_glyf);
1333 return listCount((list) table->data);
1334 }
1335
1336
nameAdd(TrueTypeTable * table,NameRecord * nr)1337 void nameAdd(TrueTypeTable *table, NameRecord *nr)
1338 {
1339 list l;
1340
1341 assert(table != 0);
1342 assert(table->tag == T_name);
1343
1344 l = (list) table->data;
1345
1346 listAppend(l, NameRecordNewCopy(nr));
1347 }
1348
FindTable(TrueTypeCreator * tt,sal_uInt32 tag)1349 static TrueTypeTable *FindTable(TrueTypeCreator *tt, sal_uInt32 tag)
1350 {
1351 if (listIsEmpty(tt->tables)) return 0;
1352
1353 listToFirst(tt->tables);
1354
1355 do {
1356 if (((TrueTypeTable *) listCurrent(tt->tables))->tag == tag) {
1357 return (TrueTypeTable*)listCurrent(tt->tables);
1358 }
1359 } while (listNext(tt->tables));
1360
1361 return 0;
1362 }
1363
1364 /* This function processes all the tables and synchronizes them before creating
1365 * the output TrueType stream.
1366 *
1367 * *** It adds two TrueType tables to the font: 'loca' and 'hmtx' ***
1368 *
1369 * It does:
1370 *
1371 * - Re-numbers glyph IDs and creates 'glyf', 'loca', and 'hmtx' tables.
1372 * - Calculates xMin, yMin, xMax, and yMax and stores values in 'head' table.
1373 * - Stores indexToLocFormat in 'head'
1374 * - updates 'maxp' table
1375 * - Calculates advanceWidthMax, minLSB, minRSB, xMaxExtent and numberOfHMetrics
1376 * in 'hhea' table
1377 *
1378 */
ProcessTables(TrueTypeCreator * tt)1379 static void ProcessTables(TrueTypeCreator *tt)
1380 {
1381 TrueTypeTable *glyf, *loca, *head, *maxp, *hhea;
1382 list glyphlist;
1383 sal_uInt32 nGlyphs, locaLen = 0, glyfLen = 0;
1384 sal_Int16 xMin = 0, yMin = 0, xMax = 0, yMax = 0;
1385 sal_uInt32 i = 0;
1386 sal_Int16 indexToLocFormat;
1387 sal_uInt8 *hmtxPtr, *hheaPtr;
1388 sal_uInt32 hmtxSize;
1389 sal_uInt8 *p1, *p2;
1390 sal_uInt16 maxPoints = 0, maxContours = 0, maxCompositePoints = 0, maxCompositeContours = 0;
1391 int nlsb = 0;
1392 sal_uInt32 *gid; /* array of old glyphIDs */
1393
1394 glyf = FindTable(tt, T_glyf);
1395 glyphlist = (list) glyf->data;
1396 nGlyphs = listCount(glyphlist);
1397 assert(nGlyphs != 0);
1398 gid = (sal_uInt32*)scalloc(nGlyphs, sizeof(sal_uInt32));
1399
1400 RemoveTable(tt, T_loca);
1401 RemoveTable(tt, T_hmtx);
1402
1403 /* XXX Need to make sure that composite glyphs do not break during glyph renumbering */
1404
1405 listToFirst(glyphlist);
1406 do {
1407 GlyphData *gd = (GlyphData *) listCurrent(glyphlist);
1408 sal_Int16 z;
1409 glyfLen += gd->nbytes;
1410 /* XXX if (gd->nbytes & 1) glyfLen++; */
1411
1412
1413 assert(gd->newID == i);
1414 gid[i++] = gd->glyphID;
1415 /* gd->glyphID = i++; */
1416
1417 /* printf("IDs: %d %d.\n", gd->glyphID, gd->newID); */
1418
1419 if (gd->nbytes != 0) {
1420 z = GetInt16(gd->ptr, 2, 1);
1421 if (z < xMin) xMin = z;
1422
1423 z = GetInt16(gd->ptr, 4, 1);
1424 if (z < yMin) yMin = z;
1425
1426 z = GetInt16(gd->ptr, 6, 1);
1427 if (z > xMax) xMax = z;
1428
1429 z = GetInt16(gd->ptr, 8, 1);
1430 if (z > yMax) yMax = z;
1431 }
1432
1433 if (gd->compflag == 0) { /* non-composite glyph */
1434 if (gd->npoints > maxPoints) maxPoints = gd->npoints;
1435 if (gd->ncontours > maxContours) maxContours = gd->ncontours;
1436 } else { /* composite glyph */
1437 if (gd->npoints > maxCompositePoints) maxCompositePoints = gd->npoints;
1438 if (gd->ncontours > maxCompositeContours) maxCompositeContours = gd->ncontours;
1439 }
1440
1441 } while (listNext(glyphlist));
1442
1443 indexToLocFormat = (glyfLen / 2 > 0xFFFF) ? 1 : 0;
1444 locaLen = indexToLocFormat ? (nGlyphs + 1) << 2 : (nGlyphs + 1) << 1;
1445
1446 sal_uInt8* glyfPtr = ttmalloc(glyfLen);
1447 sal_uInt8* locaPtr = ttmalloc(locaLen);
1448 TTSimpleGlyphMetrics* met = (TTSimpleGlyphMetrics*)scalloc(nGlyphs, sizeof(TTSimpleGlyphMetrics));
1449 i = 0;
1450
1451 listToFirst(glyphlist);
1452 p1 = glyfPtr;
1453 p2 = locaPtr;
1454 do {
1455 GlyphData *gd = (GlyphData *) listCurrent(glyphlist);
1456
1457 if (gd->compflag) { /* re-number all components */
1458 sal_uInt16 flags, index;
1459 sal_uInt8 *ptr = gd->ptr + 10;
1460 do {
1461 sal_uInt32 j;
1462 flags = GetUInt16(ptr, 0, 1);
1463 index = GetUInt16(ptr, 2, 1);
1464 /* XXX use the sorted array of old to new glyphID mapping and do a binary search */
1465 for (j = 0; j < nGlyphs; j++) {
1466 if (gid[j] == index) {
1467 break;
1468 }
1469 }
1470 /* printf("X: %d -> %d.\n", index, j); */
1471
1472 PutUInt16((sal_uInt16) j, ptr, 2, 1);
1473
1474 ptr += 4;
1475
1476 if (flags & ARG_1_AND_2_ARE_WORDS) {
1477 ptr += 4;
1478 } else {
1479 ptr += 2;
1480 }
1481
1482 if (flags & WE_HAVE_A_SCALE) {
1483 ptr += 2;
1484 } else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) {
1485 ptr += 4;
1486 } else if (flags & WE_HAVE_A_TWO_BY_TWO) {
1487 ptr += 8;
1488 }
1489 } while (flags & MORE_COMPONENTS);
1490 }
1491
1492 if (gd->nbytes != 0) {
1493 memcpy(p1, gd->ptr, gd->nbytes);
1494 }
1495 if (indexToLocFormat == 1) {
1496 PutUInt32(p1 - glyfPtr, p2, 0, 1);
1497 p2 += 4;
1498 } else {
1499 PutUInt16((sal_uInt16)((p1 - glyfPtr) >> 1), p2, 0, 1);
1500 p2 += 2;
1501 }
1502 p1 += gd->nbytes;
1503
1504 /* fill the array of metrics */
1505 met[i].adv = gd->aw;
1506 met[i].sb = gd->lsb;
1507 i++;
1508 } while (listNext(glyphlist));
1509
1510 free(gid);
1511
1512 if (indexToLocFormat == 1) {
1513 PutUInt32(p1 - glyfPtr, p2, 0, 1);
1514 } else {
1515 PutUInt16((sal_uInt16)((p1 - glyfPtr) >> 1), p2, 0, 1);
1516 }
1517
1518 glyf->rawdata = glyfPtr;
1519
1520 loca = TrueTypeTableNew_loca(); assert(loca != 0);
1521 ((tdata_loca *) loca->data)->ptr = locaPtr;
1522 ((tdata_loca *) loca->data)->nbytes = locaLen;
1523
1524 AddTable(tt, loca);
1525
1526 head = FindTable(tt, T_head);
1527 sal_uInt8* const pHeadData = (sal_uInt8*)head->data;
1528 PutInt16(xMin, pHeadData, 36, 1);
1529 PutInt16(yMin, pHeadData, 38, 1);
1530 PutInt16(xMax, pHeadData, 40, 1);
1531 PutInt16(yMax, pHeadData, 42, 1);
1532 PutInt16(indexToLocFormat, pHeadData, 50, 1);
1533
1534 maxp = FindTable(tt, T_maxp);
1535
1536 sal_uInt8* const pMaxpData = (sal_uInt8*)maxp->data;
1537 PutUInt16((sal_uInt16)nGlyphs, pMaxpData, 4, 1);
1538 PutUInt16(maxPoints, pMaxpData, 6, 1);
1539 PutUInt16(maxContours, pMaxpData, 8, 1);
1540 PutUInt16(maxCompositePoints, pMaxpData, 10, 1);
1541 PutUInt16(maxCompositeContours, pMaxpData, 12, 1);
1542
1543 #if 0
1544 /* XXX do not overwrite the existing data. Fix: re-calculate these numbers here */
1545 PutUInt16(2, maxp->data, 14, 1); /* maxZones is always 2 */
1546 PutUInt16(0, maxp->data, 16, 1); /* maxTwilightPoints */
1547 PutUInt16(0, maxp->data, 18, 1); /* maxStorage */
1548 PutUInt16(0, maxp->data, 20, 1); /* maxFunctionDefs */
1549 PutUint16(0, maxp->data, 22, 1); /* maxInstructionDefs */
1550 PutUint16(0, maxp->data, 24, 1); /* maxStackElements */
1551 PutUint16(0, maxp->data, 26, 1); /* maxSizeOfInstructions */
1552 PutUint16(0, maxp->data, 28, 1); /* maxComponentElements */
1553 PutUint16(0, maxp->data, 30, 1); /* maxComponentDepth */
1554 #endif
1555
1556 /*
1557 * Generate an htmx table and update hhea table
1558 */
1559 hhea = FindTable(tt, T_hhea); assert(hhea != 0);
1560 hheaPtr = (sal_uInt8 *) hhea->data;
1561 if (nGlyphs > 2) {
1562 for (i = nGlyphs - 1; i > 0; i--) {
1563 if (met[i].adv != met[i-1].adv) break;
1564 }
1565 nlsb = nGlyphs - 1 - i;
1566 }
1567 hmtxSize = (nGlyphs - nlsb) * 4 + nlsb * 2;
1568 hmtxPtr = ttmalloc(hmtxSize);
1569 p1 = hmtxPtr;
1570
1571 for (i = 0; i < nGlyphs; i++) {
1572 if (i < nGlyphs - nlsb) {
1573 PutUInt16(met[i].adv, p1, 0, 1);
1574 PutUInt16(met[i].sb, p1, 2, 1);
1575 p1 += 4;
1576 } else {
1577 PutUInt16(met[i].sb, p1, 0, 1);
1578 p1 += 2;
1579 }
1580 }
1581
1582 AddTable(tt, TrueTypeTableNew(T_hmtx, hmtxSize, hmtxPtr));
1583 PutUInt16((sal_uInt16)(nGlyphs - nlsb), hheaPtr, 34, 1);
1584 free(hmtxPtr);
1585 free(met);
1586 }
1587
1588 } // namespace vcl
1589
1590 extern "C"
1591 {
1592 /**
1593 * TrueTypeCreator destructor. It calls destructors for all TrueTypeTables added to it.
1594 */
TrueTypeCreatorDispose(vcl::TrueTypeCreator * _this)1595 void TrueTypeCreatorDispose(vcl::TrueTypeCreator *_this)
1596 {
1597 listDispose(_this->tables);
1598 free(_this);
1599 }
1600
1601
1602 /**
1603 * Destructor for the TrueTypeTable object.
1604 */
TrueTypeTableDispose(vcl::TrueTypeTable * _this)1605 void TrueTypeTableDispose(vcl::TrueTypeTable *_this)
1606 {
1607 /* XXX do a binary search */
1608 unsigned int i;
1609
1610 assert(_this != 0);
1611
1612 if (_this->rawdata) free(_this->rawdata);
1613
1614 for(i=0; i < sizeof(vcl::vtable1)/sizeof(*vcl::vtable1); i++) {
1615 if (_this->tag == vcl::vtable1[i].tag) {
1616 vcl::vtable1[i].f(_this);
1617 return;
1618 }
1619 }
1620 assert(!"Unknown TrueType table.\n");
1621 }
1622 }
1623
1624
1625 #ifdef TEST_TTCR
main(void)1626 int main(void)
1627 {
1628 TrueTypeCreator *ttcr;
1629 sal_uInt8 *t1, *t2, *t3, *t4, *t5, *t6, *t7;
1630
1631 TrueTypeCreatorNewEmpty(mkTag('t','r','u','e'), &ttcr);
1632
1633 t1 = malloc(1000); memset(t1, 'a', 1000);
1634 t2 = malloc(2000); memset(t2, 'b', 2000);
1635 t3 = malloc(3000); memset(t3, 'c', 3000);
1636 t4 = malloc(4000); memset(t4, 'd', 4000);
1637 t5 = malloc(5000); memset(t5, 'e', 5000);
1638 t6 = malloc(6000); memset(t6, 'f', 6000);
1639 t7 = malloc(7000); memset(t7, 'g', 7000);
1640
1641 AddTable(ttcr, TrueTypeTableNew(0x6D617870, 1000, t1));
1642 AddTable(ttcr, TrueTypeTableNew(0x4F532F32, 2000, t2));
1643 AddTable(ttcr, TrueTypeTableNew(0x636D6170, 3000, t3));
1644 AddTable(ttcr, TrueTypeTableNew(0x6C6F6361, 4000, t4));
1645 AddTable(ttcr, TrueTypeTableNew(0x68686561, 5000, t5));
1646 AddTable(ttcr, TrueTypeTableNew(0x676C7966, 6000, t6));
1647 AddTable(ttcr, TrueTypeTableNew(0x6B65726E, 7000, t7));
1648
1649 free(t1);
1650 free(t2);
1651 free(t3);
1652 free(t4);
1653 free(t5);
1654 free(t6);
1655 free(t7);
1656
1657
1658 StreamToFile(ttcr, "ttcrout.ttf");
1659
1660 TrueTypeCreatorDispose(ttcr);
1661 return 0;
1662 }
1663 #endif
1664
1665 /* vim: set noet sw=4 ts=4: */
1666