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 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_vcl.hxx"
26
27 /*
28 * Sun Font Tools
29 *
30 * Author: Alexander Gelfenbain
31 *
32 */
33
34 #if OSL_DEBUG_LEVEL == 0
35 # ifndef NDEBUG
36 # define NDEBUG
37 # endif
38 #endif
39 #include <assert.h>
40
41 #include <stdlib.h>
42 #include <string.h>
43 #include <fcntl.h>
44 #ifdef UNX
45 #include <sys/mman.h>
46 #include <sys/stat.h>
47 #endif
48 #include "sft.hxx"
49 #include "gsub.h"
50 #if ! (defined(NO_TTCR) && defined(NO_TYPE42))
51 #include "ttcr.hxx"
52 #endif
53 #ifndef NO_MAPPERS /* include MapChar() and MapString() */
54 #include "xlat.hxx"
55 #endif
56 #ifndef NO_TYPE3 /* include CreateT3FromTTGlyphs() */
57 #include <rtl/crc.h>
58 #endif
59
60 #include <osl/endian.h>
61 #include <algorithm>
62
63 #ifdef TEST7
64 #include <ctype.h>
65 #endif
66
67 namespace vcl
68 {
69
70 /*- module identification */
71
72 static const char *modname = "SunTypeTools-TT";
73 static const char *modver = "1.0";
74 static const char *modextra = "gelf";
75
76 /*- private functions, constants and data types */ /*FOLD00*/
77
78 enum PathSegmentType {
79 PS_NOOP = 0,
80 PS_MOVETO = 1,
81 PS_LINETO = 2,
82 PS_CURVETO = 3,
83 PS_CLOSEPATH = 4
84 };
85
86 struct PSPathElement
87 {
88 PathSegmentType type;
89 int x1, y1;
90 int x2, y2;
91 int x3, y3;
92
PSPathElementvcl::PSPathElement93 PSPathElement( PathSegmentType i_eType ) : type( i_eType ),
94 x1( 0 ), y1( 0 ),
95 x2( 0 ), y2( 0 ),
96 x3( 0 ), y3( 0 )
97 {
98 }
99 };
100
101 /*- In horisontal writing mode right sidebearing is calculated using this formula
102 *- rsb = aw - (lsb + xMax - xMin) -*/
103 typedef struct {
104 sal_Int16 xMin;
105 sal_Int16 yMin;
106 sal_Int16 xMax;
107 sal_Int16 yMax;
108 sal_uInt16 aw; /*- Advance Width (horisontal writing mode) */
109 sal_Int16 lsb; /*- Left sidebearing (horisontal writing mode) */
110 sal_uInt16 ah; /*- advance height (vertical writing mode) */
111 sal_Int16 tsb; /*- top sidebearing (vertical writing mode) */
112 } TTGlyphMetrics;
113
114 #define HFORMAT_LINELEN 64
115
116 typedef struct {
117 FILE *o;
118 char buffer[HFORMAT_LINELEN];
119 int bufpos;
120 int total;
121 } HexFmt;
122
123 typedef struct {
124 sal_uInt32 nGlyphs; /* number of glyphs in the font + 1 */
125 sal_uInt32 *offs; /* array of nGlyphs offsets */
126 } GlyphOffsets;
127
128 /* private tags */
129 static const sal_uInt32 TTFontClassTag = 0x74746663; /* 'ttfc' */
130
131 static const sal_uInt32 T_true = 0x74727565; /* 'true' */
132 static const sal_uInt32 T_ttcf = 0x74746366; /* 'ttcf' */
133 static const sal_uInt32 T_otto = 0x4f54544f; /* 'OTTO' */
134
135 /* standard TrueType table tags */
136 #define T_maxp 0x6D617870
137 #define T_glyf 0x676C7966
138 #define T_head 0x68656164
139 #define T_loca 0x6C6F6361
140 #define T_name 0x6E616D65
141 #define T_hhea 0x68686561
142 #define T_hmtx 0x686D7478
143 #define T_cmap 0x636D6170
144 #define T_vhea 0x76686561
145 #define T_vmtx 0x766D7478
146 #define T_OS2 0x4F532F32
147 #define T_post 0x706F7374
148 #define T_kern 0x6B65726E
149 #define T_cvt 0x63767420
150 #define T_prep 0x70726570
151 #define T_fpgm 0x6670676D
152 #define T_gsub 0x47535542
153 #define T_CFF 0x43464620
154
155 #define LAST_URANGE_BIT 69
156 const char *ulcodes[LAST_URANGE_BIT+2] = {
157 /* 0 */ "Basic Latin",
158 /* 1 */ "Latin-1 Supplement",
159 /* 2 */ "Latin Extended-A",
160 /* 3 */ "Latin Extended-B",
161 /* 4 */ "IPA Extensions",
162 /* 5 */ "Spacing Modifier Letters",
163 /* 6 */ "Combining Diacritical Marks",
164 /* 7 */ "Basic Greek",
165 /* 8 */ "Greek Symbols And Coptic",
166 /* 9 */ "Cyrillic",
167 /* 10 */ "Armenian",
168 /* 11 */ "Basic Hebrew",
169 /* 12 */ "Hebrew Extended (A and B blocks combined)",
170 /* 13 */ "Basic Arabic",
171 /* 14 */ "Arabic Extended",
172 /* 15 */ "Devanagari",
173 /* 16 */ "Bengali",
174 /* 17 */ "Gurmukhi",
175 /* 18 */ "Gujarati",
176 /* 19 */ "Oriya",
177 /* 20 */ "Tamil",
178 /* 21 */ "Telugu",
179 /* 22 */ "Kannada",
180 /* 23 */ "Malayalam",
181 /* 24 */ "Thai",
182 /* 25 */ "Lao",
183 /* 26 */ "Basic Georgian",
184 /* 27 */ "Georgian Extended",
185 /* 28 */ "Hangul Jamo",
186 /* 29 */ "Latin Extended Additional",
187 /* 30 */ "Greek Extended",
188 /* 31 */ "General Punctuation",
189 /* 32 */ "Superscripts And Subscripts",
190 /* 33 */ "Currency Symbols",
191 /* 34 */ "Combining Diacritical Marks For Symbols",
192 /* 35 */ "Letterlike Symbols",
193 /* 36 */ "Number Forms",
194 /* 37 */ "Arrows",
195 /* 38 */ "Mathematical Operators",
196 /* 39 */ "Miscellaneous Technical",
197 /* 40 */ "Control Pictures",
198 /* 41 */ "Optical Character Recognition",
199 /* 42 */ "Enclosed Alphanumerics",
200 /* 43 */ "Box Drawing",
201 /* 44 */ "Block Elements",
202 /* 45 */ "Geometric Shapes",
203 /* 46 */ "Miscellaneous Symbols",
204 /* 47 */ "Dingbats",
205 /* 48 */ "CJK Symbols And Punctuation",
206 /* 49 */ "Hiragana",
207 /* 50 */ "Katakana",
208 /* 51 */ "Bopomofo",
209 /* 52 */ "Hangul Compatibility Jamo",
210 /* 53 */ "CJK Miscellaneous",
211 /* 54 */ "Enclosed CJK Letters And Months",
212 /* 55 */ "CJK Compatibility",
213 /* 56 */ "Hangul",
214 /* 57 */ "Reserved for Unicode SubRanges",
215 /* 58 */ "Reserved for Unicode SubRanges",
216 /* 59 */ "CJK Unified Ideographs",
217 /* 60 */ "Private Use Area",
218 /* 61 */ "CJK Compatibility Ideographs",
219 /* 62 */ "Alphabetic Presentation Forms",
220 /* 63 */ "Arabic Presentation Forms-A",
221 /* 64 */ "Combining Half Marks",
222 /* 65 */ "CJK Compatibility Forms",
223 /* 66 */ "Small Form Variants",
224 /* 67 */ "Arabic Presentation Forms-B",
225 /* 68 */ "Halfwidth And Fullwidth Forms",
226 /* 69 */ "Specials",
227 /*70-127*/ "Reserved for Unicode SubRanges"
228 };
229
230
231
232 /*- inline functions */ /*FOLD01*/
233 #ifdef __GNUC__
234 #define _inline static __inline__
235 #else
236 #define _inline static
237 #endif
238
smalloc(size_t size)239 _inline void *smalloc(size_t size)
240 {
241 void *res = malloc(size);
242 assert(res != 0);
243 return res;
244 }
245
scalloc(size_t n,size_t size)246 _inline void *scalloc(size_t n, size_t size)
247 {
248 void *res = calloc(n, size);
249 assert(res != 0);
250 return res;
251 }
252
mkTag(sal_uInt8 a,sal_uInt8 b,sal_uInt8 c,sal_uInt8 d)253 _inline sal_uInt32 mkTag(sal_uInt8 a, sal_uInt8 b, sal_uInt8 c, sal_uInt8 d) {
254 return (a << 24) | (b << 16) | (c << 8) | d;
255 }
256
257 /*- Data access macros for data stored in big-endian or little-endian format */
GetInt16(const sal_uInt8 * ptr,size_t offset,int bigendian)258 _inline sal_Int16 GetInt16(const sal_uInt8 *ptr, size_t offset, int bigendian)
259 {
260 sal_Int16 t;
261 assert(ptr != 0);
262
263 if (bigendian) {
264 t = (ptr+offset)[0] << 8 | (ptr+offset)[1];
265 } else {
266 t = (ptr+offset)[1] << 8 | (ptr+offset)[0];
267 }
268
269 return t;
270 }
271
GetUInt16(const sal_uInt8 * ptr,size_t offset,int bigendian)272 _inline sal_uInt16 GetUInt16(const sal_uInt8 *ptr, size_t offset, int bigendian)
273 {
274 sal_uInt16 t;
275 assert(ptr != 0);
276
277 if (bigendian) {
278 t = (ptr+offset)[0] << 8 | (ptr+offset)[1];
279 } else {
280 t = (ptr+offset)[1] << 8 | (ptr+offset)[0];
281 }
282
283 return t;
284 }
285
GetInt32(const sal_uInt8 * ptr,size_t offset,int bigendian)286 _inline sal_Int32 GetInt32(const sal_uInt8 *ptr, size_t offset, int bigendian)
287 {
288 sal_Int32 t;
289 assert(ptr != 0);
290
291 if (bigendian) {
292 t = (ptr+offset)[0] << 24 | (ptr+offset)[1] << 16 |
293 (ptr+offset)[2] << 8 | (ptr+offset)[3];
294 } else {
295 t = (ptr+offset)[3] << 24 | (ptr+offset)[2] << 16 |
296 (ptr+offset)[1] << 8 | (ptr+offset)[0];
297 }
298
299 return t;
300 }
301
GetUInt32(const sal_uInt8 * ptr,size_t offset,int bigendian)302 _inline sal_uInt32 GetUInt32(const sal_uInt8 *ptr, size_t offset, int bigendian)
303 {
304 sal_uInt32 t;
305 assert(ptr != 0);
306
307
308 if (bigendian) {
309 t = (ptr+offset)[0] << 24 | (ptr+offset)[1] << 16 |
310 (ptr+offset)[2] << 8 | (ptr+offset)[3];
311 } else {
312 t = (ptr+offset)[3] << 24 | (ptr+offset)[2] << 16 |
313 (ptr+offset)[1] << 8 | (ptr+offset)[0];
314 }
315
316 return t;
317 }
318
PutInt16(sal_Int16 val,sal_uInt8 * ptr,size_t offset,int bigendian)319 _inline void PutInt16(sal_Int16 val, sal_uInt8 *ptr, size_t offset, int bigendian)
320 {
321 assert(ptr != 0);
322
323 if (bigendian) {
324 ptr[offset] = (sal_uInt8)((val >> 8) & 0xFF);
325 ptr[offset+1] = (sal_uInt8)(val & 0xFF);
326 } else {
327 ptr[offset+1] = (sal_uInt8)((val >> 8) & 0xFF);
328 ptr[offset] = (sal_uInt8)(val & 0xFF);
329 }
330
331 }
332
333 #if defined(OSL_BIGENDIAN)
334 #define Int16FromMOTA(a) (a)
335 #define Int32FromMOTA(a) (a)
336 #else
Int16FromMOTA(sal_uInt16 a)337 static sal_uInt16 Int16FromMOTA(sal_uInt16 a) {
338 return (sal_uInt16) (((sal_uInt8)((a) >> 8)) | ((sal_uInt8)(a) << 8));
339 }
Int32FromMOTA(sal_uInt32 a)340 static sal_uInt32 Int32FromMOTA(sal_uInt32 a) {
341 return ((a>>24)&0xFF) | (((a>>8)&0xFF00) | ((a&0xFF00)<<8) | ((a&0xFF)<<24));
342 }
343 #endif
344
fixedMul(F16Dot16 a,F16Dot16 b)345 _inline F16Dot16 fixedMul(F16Dot16 a, F16Dot16 b)
346 {
347 unsigned int a1, b1;
348 unsigned int a2, b2;
349 F16Dot16 res;
350 int sign;
351
352 sign = (a & 0x80000000) ^ (b & 0x80000000);
353 if (a < 0) a = -a;
354 if (b < 0) b = -b;
355
356 a1 = a >> 16;
357 b1 = a & 0xFFFF;
358 a2 = b >> 16;
359 b2 = b & 0xFFFF;
360
361 res = a1 * a2;
362
363 /* if (res > 0x7FFF) assert(!"fixedMul: F16Dot16 overflow"); */
364
365 res <<= 16;
366 res += a1 * b2 + b1 * a2 + ((b1 * b2) >> 16);
367
368 return sign ? -res : res;
369 }
370
371
fixedDiv(F16Dot16 a,F16Dot16 b)372 _inline F16Dot16 fixedDiv(F16Dot16 a, F16Dot16 b)
373 {
374 unsigned int f, r;
375 F16Dot16 res;
376 int sign;
377
378 sign = (a & 0x80000000) ^ (b & 0x80000000);
379 if (a < 0) a = -a;
380 if (b < 0) b = -b;
381
382 f = a / b;
383 r = a % b;
384
385 /* if (f > 0x7FFFF) assert(!"fixedDiv: F16Dot16 overflow"); */
386
387 while (r > 0xFFFF) {
388 r >>= 1;
389 b >>= 1;
390 }
391
392 res = (f << 16) + (r << 16) / b;
393
394 return sign ? -res : res;
395 }
396
397 /*- returns a * b / c -*/
398 /* XXX provide a real implementation that preserves accuracy */
fixedMulDiv(F16Dot16 a,F16Dot16 b,F16Dot16 c)399 _inline F16Dot16 fixedMulDiv(F16Dot16 a, F16Dot16 b, F16Dot16 c)
400 {
401 F16Dot16 res;
402
403 res = fixedMul(a, b);
404 return fixedDiv(res, c);
405 }
406
407 /*- Translate units from TT to PS (standard 1/1000) -*/
XUnits(int unitsPerEm,int n)408 _inline int XUnits(int unitsPerEm, int n)
409 {
410 return (n * 1000) / unitsPerEm;
411 }
412
UnicodeRangeName(sal_uInt16 bit)413 _inline const char *UnicodeRangeName(sal_uInt16 bit)
414 {
415 if (bit > LAST_URANGE_BIT) bit = LAST_URANGE_BIT+1;
416
417 return ulcodes[bit];
418 }
419
getTable(TrueTypeFont * ttf,sal_uInt32 ord)420 _inline const sal_uInt8* getTable( TrueTypeFont *ttf, sal_uInt32 ord)
421 {
422 return (sal_uInt8*)ttf->tables[ord];
423 }
424
getTableSize(TrueTypeFont * ttf,sal_uInt32 ord)425 _inline sal_uInt32 getTableSize(TrueTypeFont *ttf, sal_uInt32 ord)
426 {
427 return ttf->tlens[ord];
428 }
429
430 #ifndef NO_TYPE42
431 /* Hex Formatter functions */
432 static char HexChars[] = "0123456789ABCDEF";
433
HexFmtNew(FILE * outf)434 static HexFmt *HexFmtNew(FILE *outf)
435 {
436 HexFmt* res = (HexFmt*)smalloc(sizeof(HexFmt));
437 res->bufpos = res->total = 0;
438 res->o = outf;
439 return res;
440 }
441
HexFmtFlush(HexFmt * _this)442 static void HexFmtFlush(HexFmt *_this)
443 {
444 if (_this->bufpos) {
445 fwrite(_this->buffer, 1, _this->bufpos, _this->o);
446 _this->bufpos = 0;
447 }
448 }
449
450
HexFmtOpenString(HexFmt * _this)451 _inline void HexFmtOpenString(HexFmt *_this)
452 {
453 fputs("<\n", _this->o);
454 }
455
HexFmtCloseString(HexFmt * _this)456 _inline void HexFmtCloseString(HexFmt *_this)
457 {
458 HexFmtFlush(_this);
459 fputs("00\n>\n", _this->o);
460 }
461
HexFmtDispose(HexFmt * _this)462 _inline void HexFmtDispose(HexFmt *_this)
463 {
464 HexFmtFlush(_this);
465 free(_this);
466 }
467
HexFmtBlockWrite(HexFmt * _this,const void * ptr,sal_uInt32 size)468 static void HexFmtBlockWrite(HexFmt *_this, const void *ptr, sal_uInt32 size)
469 {
470 sal_uInt8 Ch;
471 sal_uInt32 i;
472
473 if (_this->total + size > 65534) {
474 HexFmtFlush(_this);
475 HexFmtCloseString(_this);
476 _this->total = 0;
477 HexFmtOpenString(_this);
478 }
479 for (i=0; i<size; i++) {
480 Ch = ((sal_uInt8 *) ptr)[i];
481 _this->buffer[_this->bufpos++] = HexChars[Ch >> 4];
482 _this->buffer[_this->bufpos++] = HexChars[Ch & 0xF];
483 if (_this->bufpos == HFORMAT_LINELEN) {
484 HexFmtFlush(_this);
485 fputc('\n', _this->o);
486 }
487
488 }
489 _this->total += size;
490 }
491 #endif
492
493
494
495 /* Outline Extraction functions */ /*FOLD01*/
496
497 /* fills the aw and lsb entries of the TTGlyphMetrics structure from hmtx table -*/
GetMetrics(TrueTypeFont * ttf,sal_uInt32 glyphID,TTGlyphMetrics * metrics)498 static void GetMetrics(TrueTypeFont *ttf, sal_uInt32 glyphID, TTGlyphMetrics *metrics)
499 {
500 const sal_uInt8* table = getTable( ttf, O_hmtx );
501
502 metrics->aw = metrics->lsb = metrics->ah = metrics->tsb = 0;
503 if (!table || !ttf->numberOfHMetrics) return;
504
505 if (glyphID < ttf->numberOfHMetrics) {
506 metrics->aw = GetUInt16(table, 4 * glyphID, 1);
507 metrics->lsb = GetInt16(table, 4 * glyphID + 2, 1);
508 } else {
509 metrics->aw = GetUInt16(table, 4 * (ttf->numberOfHMetrics - 1), 1);
510 metrics->lsb = GetInt16(table + ttf->numberOfHMetrics * 4, (glyphID - ttf->numberOfHMetrics) * 2, 1);
511 }
512
513 table = getTable(ttf, O_vmtx);
514 if( !table || !ttf->numOfLongVerMetrics )
515 return;
516
517 if (glyphID < ttf->numOfLongVerMetrics) {
518 metrics->ah = GetUInt16(table, 4 * glyphID, 1);
519 metrics->tsb = GetInt16(table, 4 * glyphID + 2, 1);
520 } else {
521 metrics->ah = GetUInt16(table, 4 * (ttf->numOfLongVerMetrics - 1), 1);
522 metrics->tsb = GetInt16(table + ttf->numOfLongVerMetrics * 4, (glyphID - ttf->numOfLongVerMetrics) * 2, 1);
523 }
524 }
525
526 static int GetTTGlyphOutline(TrueTypeFont *, sal_uInt32 , ControlPoint **, TTGlyphMetrics *, std::vector< sal_uInt32 >* );
527
528 /* returns the number of control points, allocates the pointArray */
GetSimpleTTOutline(TrueTypeFont * ttf,sal_uInt32 glyphID,ControlPoint ** pointArray,TTGlyphMetrics * metrics)529 static int GetSimpleTTOutline(TrueTypeFont *ttf, sal_uInt32 glyphID, ControlPoint **pointArray, TTGlyphMetrics *metrics) /*FOLD02*/
530 {
531 const sal_uInt8* table = getTable( ttf, O_glyf );
532 sal_uInt8 flag, n;
533 sal_uInt16 t, lastPoint=0;
534 int i, j, z;
535
536 *pointArray = 0;
537
538 /* printf("GetSimpleTTOutline(%d)\n", glyphID); */
539
540 if( glyphID >= ttf->nglyphs ) /*- glyph is not present in the font */
541 return 0;
542 const sal_uInt8* ptr = table + ttf->goffsets[glyphID];
543 const sal_Int16 numberOfContours = GetInt16(ptr, 0, 1);
544 if( numberOfContours <= 0 ) /*- glyph is not simple */
545 return 0;
546
547 if (metrics) { /*- GetCompoundTTOutline() calls this function with NULL metrics -*/
548 metrics->xMin = GetInt16(ptr, 2, 1);
549 metrics->yMin = GetInt16(ptr, 4, 1);
550 metrics->xMax = GetInt16(ptr, 6, 1);
551 metrics->yMax = GetInt16(ptr, 8, 1);
552 GetMetrics(ttf, glyphID, metrics);
553 }
554
555 /* determine the last point and be extra safe about it. But probably this code is not needed */
556
557 for (i=0; i<numberOfContours; i++) {
558 if ((t = GetUInt16(ptr, 10+i*2, 1)) > lastPoint) lastPoint = t;
559 }
560
561 sal_uInt16 instLen = GetUInt16(ptr, 10 + numberOfContours*2, 1);
562 const sal_uInt8* p = ptr + 10 + 2 * numberOfContours + 2 + instLen;
563 ControlPoint* pa = (ControlPoint*)calloc(lastPoint+1, sizeof(ControlPoint));
564
565 i = 0;
566 while (i <= lastPoint) {
567 pa[i++].flags = (sal_uInt32) (flag = *p++);
568 if (flag & 8) { /*- repeat flag */
569 n = *p++;
570 for (j=0; j<n; j++) {
571 if (i > lastPoint) { /*- if the font is really broken */
572 free(pa);
573 return 0;
574 }
575 pa[i++].flags = flag;
576 }
577 }
578 }
579
580 /*- Process the X coordinate */
581 z = 0;
582 for (i = 0; i <= lastPoint; i++) {
583 if (pa[i].flags & 0x02) {
584 if (pa[i].flags & 0x10) {
585 z += (int) (*p++);
586 } else {
587 z -= (int) (*p++);
588 }
589 } else if ( !(pa[i].flags & 0x10)) {
590 z += GetInt16(p, 0, 1);
591 p += 2;
592 }
593 pa[i].x = (sal_Int16)z;
594 }
595
596 /*- Process the Y coordinate */
597 z = 0;
598 for (i = 0; i <= lastPoint; i++) {
599 if (pa[i].flags & 0x04) {
600 if (pa[i].flags & 0x20) {
601 z += *p++;
602 } else {
603 z -= *p++;
604 }
605 } else if ( !(pa[i].flags & 0x20)) {
606 z += GetInt16(p, 0, 1);
607 p += 2;
608 }
609 pa[i].y = (sal_Int16)z;
610 }
611
612 for (i=0; i<numberOfContours; i++) {
613 pa[GetUInt16(ptr, 10 + i * 2, 1)].flags |= 0x00008000; /*- set the end contour flag */
614 }
615
616 *pointArray = pa;
617 return lastPoint + 1;
618 }
619
GetCompoundTTOutline(TrueTypeFont * ttf,sal_uInt32 glyphID,ControlPoint ** pointArray,TTGlyphMetrics * metrics,std::vector<sal_uInt32> & glyphlist)620 static int GetCompoundTTOutline(TrueTypeFont *ttf, sal_uInt32 glyphID, ControlPoint **pointArray, TTGlyphMetrics *metrics, std::vector< sal_uInt32 >& glyphlist) /*FOLD02*/
621 {
622 sal_uInt16 flags, index;
623 sal_Int16 e, f, numberOfContours;
624 const sal_uInt8* table = getTable( ttf, O_glyf );
625 std::vector<ControlPoint> myPoints;
626 ControlPoint *nextComponent, *pa;
627 int i, np;
628 F16Dot16 a = 0x10000, b = 0, c = 0, d = 0x10000, m, n, abs1, abs2, abs3;
629
630 *pointArray = 0;
631 /* printf("GetCompoundTTOutline(%d)\n", glyphID); */
632
633 if (glyphID >= ttf->nglyphs) /*- incorrect glyphID */
634 return 0;
635
636 const sal_uInt8* ptr = table + ttf->goffsets[glyphID];
637 if ((numberOfContours = GetInt16(ptr, 0, 1)) != -1) /*- glyph is not compound */
638 return 0;
639
640 if (metrics) {
641 metrics->xMin = GetInt16(ptr, 2, 1);
642 metrics->yMin = GetInt16(ptr, 4, 1);
643 metrics->xMax = GetInt16(ptr, 6, 1);
644 metrics->yMax = GetInt16(ptr, 8, 1);
645 GetMetrics(ttf, glyphID, metrics);
646 }
647
648 ptr += 10;
649
650 do {
651 flags = GetUInt16(ptr, 0, 1);
652 /* printf("flags: 0x%X\n", flags); */
653 index = GetUInt16(ptr, 2, 1);
654 ptr += 4;
655
656 if( std::find( glyphlist.begin(), glyphlist.end(), index ) != glyphlist.end() )
657 {
658 #if OSL_DEBUG_LEVEL > 1
659 fprintf(stderr, "Endless loop found in a compound glyph.\n");
660 fprintf(stderr, "%d -> ", index);
661 fprintf(stderr," [");
662 for( std::vector< sal_uInt32 >::const_iterator it = glyphlist.begin();
663 it != glyphlist.end(); ++it )
664 {
665 fprintf( stderr,"%d ", (int) *it );
666 }
667 fprintf(stderr,"]\n");
668 /**/
669 #endif
670 }
671
672 glyphlist.push_back( index );
673
674 #ifdef DEBUG2
675 fprintf(stderr,"glyphlist: += %d\n", index);
676 #endif
677
678 if ((np = GetTTGlyphOutline(ttf, index, &nextComponent, 0, &glyphlist)) == 0)
679 {
680 /* XXX that probably indicates a corrupted font */
681 #if OSL_DEBUG_LEVEL > 1
682 fprintf(stderr, "An empty compound!\n");
683 /* assert(!"An empty compound"); */
684 #endif
685 }
686
687 #ifdef DEBUG2
688 fprintf(stderr,"%d [", (int)glyphlist.size() );
689 for( std::vector< sal_uInt32 >::const_iterator it = glyphlist.begin();
690 it != glyphlist.end(); ++it )
691 {
692 fprintf( stderr,"%d ", (int) *it );
693 }
694 fprintf(stderr, "]\n");
695 if( ! glyphlist.empty() )
696 fprintf(stderr, "glyphlist: -= %d\n", (int) glyphlist.back());
697
698 #endif
699 if( ! glyphlist.empty() )
700 glyphlist.pop_back();
701
702 if (flags & USE_MY_METRICS) {
703 if (metrics) GetMetrics(ttf, index, metrics);
704 }
705
706 if (flags & ARG_1_AND_2_ARE_WORDS) {
707 e = GetInt16(ptr, 0, 1);
708 f = GetInt16(ptr, 2, 1);
709 /* printf("ARG_1_AND_2_ARE_WORDS: %d %d\n", e & 0xFFFF, f & 0xFFFF); */
710 ptr += 4;
711 } else {
712 if (flags & ARGS_ARE_XY_VALUES) { /* args are signed */
713 e = (sal_Int8) *ptr++;
714 f = (sal_Int8) *ptr++;
715 /* printf("ARGS_ARE_XY_VALUES: %d %d\n", e & 0xFF, f & 0xFF); */
716 } else { /* args are unsigned */
717 /* printf("!ARGS_ARE_XY_VALUES\n"); */
718 e = *ptr++;
719 f = *ptr++;
720 }
721
722 }
723
724 a = d = 0x10000;
725 b = c = 0;
726
727 if (flags & WE_HAVE_A_SCALE) {
728 #ifdef DEBUG2
729 fprintf(stderr, "WE_HAVE_A_SCALE\n");
730 #endif
731 a = GetInt16(ptr, 0, 1) << 2;
732 d = a;
733 ptr += 2;
734 } else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) {
735 #ifdef DEBUG2
736 fprintf(stderr, "WE_HAVE_AN_X_AND_Y_SCALE\n");
737 #endif
738 a = GetInt16(ptr, 0, 1) << 2;
739 d = GetInt16(ptr, 2, 1) << 2;
740 ptr += 4;
741 } else if (flags & WE_HAVE_A_TWO_BY_TWO) {
742 #ifdef DEBUG2
743 fprintf(stderr, "WE_HAVE_A_TWO_BY_TWO\n");
744 #endif
745 a = GetInt16(ptr, 0, 1) << 2;
746 b = GetInt16(ptr, 2, 1) << 2;
747 c = GetInt16(ptr, 4, 1) << 2;
748 d = GetInt16(ptr, 6, 1) << 2;
749 ptr += 8;
750 }
751
752 abs1 = (a < 0) ? -a : a;
753 abs2 = (b < 0) ? -b : b;
754 m = (abs1 > abs2) ? abs1 : abs2;
755 abs3 = abs1 - abs2;
756 if (abs3 < 0) abs3 = -abs3;
757 if (abs3 <= 33) m *= 2;
758
759 abs1 = (c < 0) ? -c : c;
760 abs2 = (d < 0) ? -d : d;
761 n = (abs1 > abs2) ? abs1 : abs2;
762 abs3 = abs1 - abs2;
763 if (abs3 < 0) abs3 = -abs3;
764 if (abs3 <= 33) n *= 2;
765
766 if (!ARGS_ARE_XY_VALUES) { /* match the points */
767 assert(!"ARGS_ARE_XY_VALUES is not implemented!!!\n");
768 }
769
770 #ifdef DEBUG2
771 fprintf(stderr, "a: %f, b: %f, c: %f, d: %f, e: %f, f: %f, m: %f, n: %f\n",
772 ((double) a) / 65536,
773 ((double) b) / 65536,
774 ((double) c) / 65536,
775 ((double) d) / 65536,
776 ((double) e) / 65536,
777 ((double) f) / 65536,
778 ((double) m) / 65536,
779 ((double) n) / 65536);
780 #endif
781
782 for (i=0; i<np; i++) {
783 F16Dot16 t;
784 ControlPoint cp;
785 cp.flags = nextComponent[i].flags;
786 t = fixedMulDiv(a, nextComponent[i].x << 16, m) + fixedMulDiv(c, nextComponent[i].y << 16, m) + (e << 16);
787 cp.x = (sal_Int16)(fixedMul(t, m) >> 16);
788 t = fixedMulDiv(b, nextComponent[i].x << 16, n) + fixedMulDiv(d, nextComponent[i].y << 16, n) + (f << 16);
789 cp.y = (sal_Int16)(fixedMul(t, n) >> 16);
790
791 #ifdef DEBUG2
792 fprintf(stderr, "( %d %d ) -> ( %d %d )\n", nextComponent[i].x, nextComponent[i].y, cp.x, cp.y);
793 #endif
794
795 myPoints.push_back( cp );
796 }
797
798 free(nextComponent);
799
800 } while (flags & MORE_COMPONENTS);
801
802 // #i123417# some fonts like IFAOGrec have no outline points in some compound glyphs
803 // so this unlikely but possible scenario should be handled gracefully
804 if( myPoints.empty() )
805 return 0;
806
807 np = myPoints.size();
808
809 pa = (ControlPoint*)calloc(np, sizeof(ControlPoint));
810 assert(pa != 0);
811
812 memcpy( pa, &myPoints[0], np*sizeof(ControlPoint) );
813
814 *pointArray = pa;
815 return np;
816 }
817
818 /* NOTE: GetTTGlyphOutline() returns -1 if the glyphID is incorrect,
819 * but Get{Simple|Compound}GlyphOutline returns 0 in such a case.
820 *
821 * NOTE: glyphlist is the stack of glyphs traversed while constructing
822 * a composite glyph. This is a safequard against endless recursion
823 * in corrupted fonts.
824 */
GetTTGlyphOutline(TrueTypeFont * ttf,sal_uInt32 glyphID,ControlPoint ** pointArray,TTGlyphMetrics * metrics,std::vector<sal_uInt32> * glyphlist)825 static int GetTTGlyphOutline(TrueTypeFont *ttf, sal_uInt32 glyphID, ControlPoint **pointArray, TTGlyphMetrics *metrics, std::vector< sal_uInt32 >* glyphlist)
826 {
827 const sal_uInt8 *table = getTable( ttf, O_glyf );
828 sal_Int16 numberOfContours;
829 int res;
830 *pointArray = 0;
831
832 if (metrics) {
833 memset(metrics, 0, sizeof(TTGlyphMetrics)); /*- metrics is initialized to all zeroes */
834 }
835
836 if (glyphID >= ttf->nglyphs) return -1; /**/
837
838 const sal_uInt8* ptr = table + ttf->goffsets[glyphID];
839 int length = ttf->goffsets[glyphID+1] - ttf->goffsets[glyphID];
840
841 if (length == 0) { /*- empty glyphs still have hmtx and vmtx metrics values */
842 if (metrics) GetMetrics(ttf, glyphID, metrics);
843 return 0;
844 }
845
846 numberOfContours = GetInt16(ptr, 0, 1);
847
848 if (numberOfContours >= 0)
849 {
850 res=GetSimpleTTOutline(ttf, glyphID, pointArray, metrics);
851 }
852 else
853 {
854 std::vector< sal_uInt32 > aPrivList;
855 aPrivList.push_back( glyphID );
856 res = GetCompoundTTOutline(ttf, glyphID, pointArray, metrics, glyphlist ? *glyphlist : aPrivList );
857 }
858
859 #ifdef DEBUG3
860 {
861 int i;
862 FILE *out = fopen("points.dat", "a");
863 assert(out != 0);
864 fprintf(out, "Glyph: %d\nPoints: %d\n", glyphID, res);
865 for (i=0; i<res; i++) {
866 fprintf(out, "%c ", ((*pointArray)[i].flags & 0x8000) ? 'X' : '.');
867 fprintf(out, "%c ", ((*pointArray)[i].flags & 1) ? '+' : '-');
868 fprintf(out, "%d %d\n", (*pointArray)[i].x, (*pointArray)[i].y);
869 }
870 fclose(out);
871 }
872 #endif
873
874 return res;
875 }
876
877 #ifndef NO_TYPE3
878
879 /*- returns the number of items in the path -*/
880
BSplineToPSPath(ControlPoint * srcA,int srcCount,PSPathElement ** path)881 static int BSplineToPSPath(ControlPoint *srcA, int srcCount, PSPathElement **path)
882 {
883 std::vector< PSPathElement > aPathList;
884 int nPathCount = 0;
885 PSPathElement p( PS_NOOP );
886
887 int x0 = 0, y0 = 0, x1 = 0, y1 = 0, x2, y2, curx, cury;
888 int lastOff = 0; /*- last point was off-contour */
889 int scflag = 1; /*- start contour flag */
890 int ecflag = 0; /*- end contour flag */
891 int cp = 0; /*- current point */
892 int StartContour = 0, EndContour = 1;
893
894 *path = 0;
895
896 /* if (srcCount > 0) for(;;) */
897 while (srcCount > 0) { /*- srcCount does not get changed inside the loop. */
898 if (scflag) {
899 int l = cp;
900 StartContour = cp;
901 while (!(srcA[l].flags & 0x8000)) l++;
902 EndContour = l;
903 if (StartContour == EndContour) {
904 if (cp + 1 < srcCount) {
905 cp++;
906 continue;
907 } else {
908 break;
909 }
910 }
911 p = PSPathElement(PS_MOVETO);
912 if (!(srcA[cp].flags & 1)) {
913 if (!(srcA[EndContour].flags & 1)) {
914 p.x1 = x0 = (srcA[cp].x + srcA[EndContour].x + 1) / 2;
915 p.y1 = y0 = (srcA[cp].y + srcA[EndContour].y + 1) / 2;
916 } else {
917 p.x1 = x0 = srcA[EndContour].x;
918 p.y1 = y0 = srcA[EndContour].y;
919 }
920 } else {
921 p.x1 = x0 = srcA[cp].x;
922 p.y1 = y0 = srcA[cp].y;
923 cp++;
924 }
925 aPathList.push_back( p );
926 lastOff = 0;
927 scflag = 0;
928 }
929
930 curx = srcA[cp].x;
931 cury = srcA[cp].y;
932
933 if (srcA[cp].flags & 1)
934 {
935 if (lastOff)
936 {
937 p = PSPathElement(PS_CURVETO);
938 p.x1 = x0 + (2 * (x1 - x0) + 1) / 3;
939 p.y1 = y0 + (2 * (y1 - y0) + 1) / 3;
940 p.x2 = x1 + (curx - x1 + 1) / 3;
941 p.y2 = y1 + (cury - y1 + 1) / 3;
942 p.x3 = curx;
943 p.y3 = cury;
944 aPathList.push_back( p );
945 }
946 else
947 {
948 if (!(x0 == curx && y0 == cury))
949 { /* eliminate empty lines */
950 p = PSPathElement(PS_LINETO);
951 p.x1 = curx;
952 p.y1 = cury;
953 aPathList.push_back( p );
954 }
955 }
956 x0 = curx; y0 = cury; lastOff = 0;
957 }
958 else
959 {
960 if (lastOff)
961 {
962 x2 = (x1 + curx + 1) / 2;
963 y2 = (y1 + cury + 1) / 2;
964 p = PSPathElement(PS_CURVETO);
965 p.x1 = x0 + (2 * (x1 - x0) + 1) / 3;
966 p.y1 = y0 + (2 * (y1 - y0) + 1) / 3;
967 p.x2 = x1 + (x2 - x1 + 1) / 3;
968 p.y2 = y1 + (y2 - y1 + 1) / 3;
969 p.x3 = x2;
970 p.y3 = y2;
971 aPathList.push_back( p );
972 x0 = x2; y0 = y2;
973 x1 = curx; y1 = cury;
974 } else {
975 x1 = curx; y1 = cury;
976 }
977 lastOff = true;
978 }
979
980 if (ecflag) {
981 aPathList.push_back( PSPathElement(PS_CLOSEPATH) );
982 scflag = 1;
983 ecflag = 0;
984 cp = EndContour + 1;
985 if (cp >= srcCount) break;
986 continue;
987 }
988
989
990 if (cp == EndContour) {
991 cp = StartContour;
992 ecflag = true;
993 } else {
994 cp++;
995 }
996 }
997
998 if( (nPathCount = (int)aPathList.size()) > 0)
999 {
1000 *path = (PSPathElement*)calloc(nPathCount, sizeof(PSPathElement));
1001 assert(*path != 0);
1002 memcpy( *path, &aPathList[0], nPathCount * sizeof(PSPathElement) );
1003 }
1004
1005 return nPathCount;
1006 }
1007
1008 #endif
1009
1010 /*- Extracts a string from the name table and allocates memory for it -*/
1011
nameExtract(const sal_uInt8 * name,int nTableSize,int n,int dbFlag,sal_uInt16 ** ucs2result)1012 static char *nameExtract( const sal_uInt8* name, int nTableSize, int n, int dbFlag, sal_uInt16** ucs2result )
1013 {
1014 int i;
1015 char *res;
1016 const sal_uInt8* ptr = name + GetUInt16(name, 4, 1) + GetUInt16(name + 6, 12 * n + 10, 1);
1017 int len = GetUInt16(name+6, 12 * n + 8, 1);
1018
1019 // sanity check
1020 if( (len <= 0) || ((ptr+len) > (name+nTableSize)) )
1021 {
1022 if( ucs2result )
1023 *ucs2result = NULL;
1024 return NULL;
1025 }
1026
1027 if( ucs2result )
1028 *ucs2result = NULL;
1029 if (dbFlag) {
1030 res = (char*)malloc(1 + len/2);
1031 assert(res != 0);
1032 for (i = 0; i < len/2; i++) res[i] = *(ptr + i * 2 + 1);
1033 res[len/2] = 0;
1034 if( ucs2result )
1035 {
1036 *ucs2result = (sal_uInt16*)malloc( len+2 );
1037 for (i = 0; i < len/2; i++ ) (*ucs2result)[i] = GetUInt16( ptr, 2*i, 1 );
1038 (*ucs2result)[len/2] = 0;
1039 }
1040 } else {
1041 res = (char*)malloc(1 + len);
1042 assert(res != 0);
1043 memcpy(res, ptr, len);
1044 res[len] = 0;
1045 }
1046
1047 return res;
1048 }
1049
findname(const sal_uInt8 * name,sal_uInt16 n,sal_uInt16 platformID,sal_uInt16 encodingID,sal_uInt16 languageID,sal_uInt16 nameID)1050 static int findname( const sal_uInt8 *name, sal_uInt16 n, sal_uInt16 platformID,
1051 sal_uInt16 encodingID, sal_uInt16 languageID, sal_uInt16 nameID )
1052 {
1053 int l = 0, r = n-1, i;
1054 sal_uInt32 t1, t2;
1055 sal_uInt32 m1, m2;
1056
1057 if (n == 0) return -1;
1058
1059 m1 = (platformID << 16) | encodingID;
1060 m2 = (languageID << 16) | nameID;
1061
1062 do {
1063 i = (l + r) >> 1;
1064 t1 = GetUInt32(name + 6, i * 12 + 0, 1);
1065 t2 = GetUInt32(name + 6, i * 12 + 4, 1);
1066
1067 if (! ((m1 < t1) || ((m1 == t1) && (m2 < t2)))) l = i + 1;
1068 if (! ((m1 > t1) || ((m1 == t1) && (m2 > t2)))) r = i - 1;
1069 } while (l <= r);
1070
1071 if (l - r == 2) {
1072 return l - 1;
1073 }
1074
1075 return -1;
1076 }
1077
1078 /* XXX marlett.ttf uses (3, 0, 1033) instead of (3, 1, 1033) and does not have any Apple tables.
1079 * Fix: if (3, 1, 1033) is not found - need to check for (3, 0, 1033)
1080 *
1081 * /d/fonts/ttzh_tw/Big5/Hanyi/ma6b5p uses (1, 0, 19) for English strings, instead of (1, 0, 0)
1082 * and does not have (3, 1, 1033)
1083 * Fix: if (1, 0, 0) and (3, 1, 1033) are not found need to look for (1, 0, *) - that will
1084 * require a change in algorithm
1085 *
1086 * /d/fonts/fdltest/Korean/h2drrm has unsorted names and a an unknown (to me) Mac LanguageID,
1087 * but (1, 0, 1042) strings usable
1088 * Fix: change algorithm, and use (1, 0, *) if both standard Mac and MS strings are not found
1089 */
1090
GetNames(TrueTypeFont * t)1091 static void GetNames(TrueTypeFont *t)
1092 {
1093 const sal_uInt8* table = getTable( t, O_name );
1094 int nTableSize = getTableSize(t, O_name);
1095
1096 if (nTableSize < 4)
1097 {
1098 #if OSL_DEBUG_LEVEL > 1
1099 fprintf(stderr, "O_name table too small\n");
1100 #endif
1101 return;
1102 }
1103
1104 sal_uInt16 n = GetUInt16(table, 2, 1);
1105 int i, r;
1106 sal_Bool bPSNameOK = sal_True;
1107
1108 /* #129743# simple sanity check for name table entry count */
1109 if( nTableSize <= n * 12 + 6 )
1110 n = 0;
1111
1112 /* PostScript name: preferred Microsoft */
1113 t->psname = NULL;
1114 if ((r = findname(table, n, 3, 1, 0x0409, 6)) != -1)
1115 t->psname = nameExtract(table, nTableSize, r, 1, NULL);
1116 if ( ! t->psname && (r = findname(table, n, 1, 0, 0, 6)) != -1)
1117 t->psname = nameExtract(table, nTableSize, r, 0, NULL);
1118 if ( ! t->psname && (r = findname(table, n, 3, 0, 0x0409, 6)) != -1)
1119 {
1120 // some symbol fonts like Marlett have a 3,0 name!
1121 t->psname = nameExtract(table, nTableSize, r, 1, NULL);
1122 }
1123 // for embedded font in Ghostscript PDFs
1124 if ( ! t->psname && (r = findname(table, n, 2, 2, 0, 6)) != -1)
1125 {
1126 t->psname = nameExtract(table, nTableSize, r, 0, NULL);
1127 }
1128 if ( ! t->psname )
1129 {
1130 if ( t->fname )
1131 {
1132 char* pReverse = t->fname + strlen(t->fname);
1133 /* take only last token of filename */
1134 while(pReverse != t->fname && *pReverse != '/') pReverse--;
1135 if(*pReverse == '/') pReverse++;
1136 t->psname = strdup(pReverse);
1137 assert(t->psname != 0);
1138 for (i=strlen(t->psname) - 1; i > 0; i--)
1139 {
1140 /*- Remove the suffix -*/
1141 if (t->psname[i] == '.' ) {
1142 t->psname[i] = 0;
1143 break;
1144 }
1145 }
1146 }
1147 else
1148 t->psname = strdup( "Unknown" );
1149 }
1150
1151 /* Font family and subfamily names: preferred Apple */
1152 t->family = NULL;
1153 if ((r = findname(table, n, 0, 0, 0, 1)) != -1)
1154 t->family = nameExtract(table, nTableSize, r, 1, &t->ufamily);
1155 if ( ! t->family && (r = findname(table, n, 3, 1, 0x0409, 1)) != -1)
1156 t->family = nameExtract(table, nTableSize, r, 1, &t->ufamily);
1157 if ( ! t->family && (r = findname(table, n, 1, 0, 0, 1)) != -1)
1158 t->family = nameExtract(table, nTableSize, r, 0, NULL);
1159 if ( ! t->family && (r = findname(table, n, 3, 1, 0x0411, 1)) != -1)
1160 t->family = nameExtract(table, nTableSize, r, 1, &t->ufamily);
1161 if ( ! t->family && (r = findname(table, n, 3, 0, 0x0409, 1)) != -1)
1162 t->family = nameExtract(table, nTableSize, r, 1, &t->ufamily);
1163 if ( ! t->family )
1164 {
1165 t->family = strdup(t->psname);
1166 assert(t->family != 0);
1167 }
1168
1169 t->subfamily = NULL;
1170 t->usubfamily = NULL;
1171 if ((r = findname(table, n, 1, 0, 0, 2)) != -1)
1172 t->subfamily = nameExtract(table, nTableSize, r, 0, &t->usubfamily);
1173 if ( ! t->subfamily && (r = findname(table, n, 3, 1, 0x0409, 2)) != -1)
1174 t->subfamily = nameExtract(table, nTableSize, r, 1, &t->usubfamily);
1175 if ( ! t->subfamily )
1176 {
1177 t->subfamily = strdup("");
1178 }
1179
1180 /* #i60349# sanity check psname
1181 * psname parctically has to be 7bit ascii and should not contains spaces
1182 * there is a class of broken fonts which do not fullfill that at all, so let's try
1183 * if the family name is 7bit ascii and take it instead if so
1184 */
1185 /* check psname */
1186 for( i = 0; t->psname[i] != 0 && bPSNameOK; i++ )
1187 if( t->psname[ i ] < 33 || (t->psname[ i ] & 0x80) )
1188 bPSNameOK = sal_False;
1189 if( bPSNameOK == sal_False )
1190 {
1191 sal_Bool bReplace = sal_True;
1192 /* check if family is a suitable replacement */
1193 if( t->ufamily && t->family )
1194 {
1195 for( i = 0; t->ufamily[ i ] != 0 && bReplace; i++ )
1196 if( t->ufamily[ i ] < 33 || t->ufamily[ i ] > 127 )
1197 bReplace = sal_False;
1198 if( bReplace )
1199 {
1200 free( t->psname );
1201 t->psname = strdup( t->family );
1202 }
1203 }
1204 }
1205 }
1206
1207 enum cmapType {
1208 CMAP_NOT_USABLE = -1,
1209 CMAP_MS_Symbol = 10,
1210 CMAP_MS_Unicode = 11,
1211 CMAP_MS_ShiftJIS = 12,
1212 CMAP_MS_Big5 = 13,
1213 CMAP_MS_PRC = 14,
1214 CMAP_MS_Wansung = 15,
1215 CMAP_MS_Johab = 16
1216 };
1217
1218 #define MISSING_GLYPH_INDEX 0
1219
1220 /*
1221 * getGlyph[0246]() functions and freinds are implemented by:
1222 * @author Manpreet Singh
1223 * getGlyph12() function and friends by:
1224 * @author HDU
1225 */
getGlyph0(const sal_uInt8 * cmap,sal_uInt32 c)1226 static sal_uInt32 getGlyph0(const sal_uInt8* cmap, sal_uInt32 c) {
1227 if (c <= 255) {
1228 return *(cmap + 6 + c);
1229 } else {
1230 return MISSING_GLYPH_INDEX;
1231 }
1232 }
1233
1234 typedef struct _subHeader2 {
1235 sal_uInt16 firstCode;
1236 sal_uInt16 entryCount;
1237 sal_uInt16 idDelta;
1238 sal_uInt16 idRangeOffset;
1239 } subHeader2;
1240
getGlyph2(const sal_uInt8 * cmap,sal_uInt32 c)1241 static sal_uInt32 getGlyph2(const sal_uInt8 *cmap, sal_uInt32 c) {
1242 sal_uInt16 *CMAP2 = (sal_uInt16 *) cmap;
1243 sal_uInt8 theHighByte;
1244
1245 sal_uInt8 theLowByte;
1246 subHeader2* subHeader2s;
1247 sal_uInt16* subHeader2Keys;
1248 sal_uInt16 firstCode;
1249 int k;
1250 sal_uInt32 ToReturn;
1251
1252 theHighByte = (sal_uInt8)((c >> 8) & 0x00ff);
1253 theLowByte = (sal_uInt8)(c & 0x00ff);
1254 subHeader2Keys = CMAP2 + 3;
1255 subHeader2s = (subHeader2 *)(subHeader2Keys + 256);
1256 k = Int16FromMOTA(subHeader2Keys[theHighByte]) / 8;
1257
1258 if(k == 0) {
1259 firstCode = Int16FromMOTA(subHeader2s[k].firstCode);
1260 if(theLowByte >= firstCode && theLowByte < (firstCode + Int16FromMOTA(subHeader2s[k].entryCount))) {
1261 return *((&(subHeader2s[0].idRangeOffset))
1262 + (Int16FromMOTA(subHeader2s[0].idRangeOffset)/2) /* + offset */
1263 + theLowByte /* + to_look */
1264 - Int16FromMOTA(subHeader2s[0].firstCode)
1265 );
1266 } else {
1267 return MISSING_GLYPH_INDEX;
1268 }
1269 } else if (k > 0) {
1270 firstCode = Int16FromMOTA(subHeader2s[k].firstCode);
1271 if(theLowByte >= firstCode && theLowByte < (firstCode + Int16FromMOTA(subHeader2s[k].entryCount))) {
1272 ToReturn = *((&(subHeader2s[k].idRangeOffset))
1273 + (Int16FromMOTA(subHeader2s[k].idRangeOffset)/2)
1274 + theLowByte - firstCode);
1275 if(ToReturn == 0) {
1276 return MISSING_GLYPH_INDEX;
1277 } else {
1278 ToReturn += Int16FromMOTA(subHeader2s[k].idDelta);
1279 return (ToReturn & 0xFFFF);
1280 }
1281 } else {
1282 return MISSING_GLYPH_INDEX;
1283 }
1284 } else {
1285 return MISSING_GLYPH_INDEX;
1286 }
1287 }
1288
getGlyph6(const sal_uInt8 * cmap,sal_uInt32 c)1289 static sal_uInt32 getGlyph6(const sal_uInt8 *cmap, sal_uInt32 c) {
1290 sal_uInt16 firstCode, lastCode, count;
1291 sal_uInt16 *CMAP6 = (sal_uInt16 *) cmap;
1292
1293 firstCode = Int16FromMOTA(*(CMAP6 + 3));
1294 count = Int16FromMOTA(*(CMAP6 + 4));
1295 lastCode = firstCode + count - 1;
1296 if (c < firstCode || c > lastCode) {
1297 return MISSING_GLYPH_INDEX;
1298 } else {
1299 return *((CMAP6 + 5)/*glyphIdArray*/ + (c - firstCode));
1300 }
1301 }
1302
GEbinsearch(sal_uInt16 * ar,sal_uInt16 length,sal_uInt16 toSearch)1303 static sal_uInt16 GEbinsearch(sal_uInt16 *ar, sal_uInt16 length, sal_uInt16 toSearch) {
1304 signed int low, mid, high, lastfound = 0xffff;
1305 sal_uInt16 res;
1306 if(length == (sal_uInt16)0 || length == (sal_uInt16)0xFFFF) {
1307 return (sal_uInt16)0xFFFF;
1308 }
1309 low = 0;
1310 high = length - 1;
1311 while(high >= low) {
1312 mid = (high + low)/2;
1313 res = Int16FromMOTA(*(ar+mid));
1314 if(res >= toSearch) {
1315 lastfound = mid;
1316 high = --mid;
1317 } else {
1318 low = ++mid;
1319 }
1320 }
1321 return (sal_uInt16)lastfound;
1322 }
1323
1324
getGlyph4(const sal_uInt8 * cmap,sal_uInt32 c)1325 static sal_uInt32 getGlyph4(const sal_uInt8 *cmap, sal_uInt32 c) {
1326 sal_uInt16 i;
1327 int ToReturn;
1328 sal_uInt16 segCount;
1329 sal_uInt16 * startCode;
1330 sal_uInt16 * endCode;
1331 sal_uInt16 * idDelta;
1332 /* sal_uInt16 * glyphIdArray; */
1333 sal_uInt16 * idRangeOffset;
1334 sal_uInt16 * glyphIndexArray;
1335 sal_uInt16 *CMAP4 = (sal_uInt16 *) cmap;
1336 /* sal_uInt16 GEbinsearch(sal_uInt16 *ar, sal_uInt16 length, sal_uInt16 toSearch); */
1337
1338 segCount = Int16FromMOTA(*(CMAP4 + 3))/2;
1339 endCode = CMAP4 + 7;
1340 i = GEbinsearch(endCode, segCount, (sal_uInt16)c);
1341
1342 if (i == (sal_uInt16) 0xFFFF) {
1343 return MISSING_GLYPH_INDEX;
1344 }
1345 startCode = endCode + segCount + 1;
1346
1347 if(Int16FromMOTA(startCode[i]) > c) {
1348 return MISSING_GLYPH_INDEX;
1349 }
1350 idDelta = startCode + segCount;
1351 idRangeOffset = idDelta + segCount;
1352 glyphIndexArray = idRangeOffset + segCount;
1353
1354 if(Int16FromMOTA(idRangeOffset[i]) != 0) {
1355 c = Int16FromMOTA(*(&(idRangeOffset[i]) + (Int16FromMOTA(idRangeOffset[i])/2 + (c - Int16FromMOTA(startCode[i])))));
1356 }
1357
1358 ToReturn = (Int16FromMOTA(idDelta[i]) + c) & 0xFFFF;
1359 return ToReturn;
1360 }
1361
getGlyph12(const sal_uInt8 * pCmap,sal_uInt32 cChar)1362 static sal_uInt32 getGlyph12(const sal_uInt8 *pCmap, sal_uInt32 cChar) {
1363 const sal_uInt32* pCMAP12 = (const sal_uInt32*)pCmap;
1364 int nLength = Int32FromMOTA( pCMAP12[1] );
1365 int nGroups = Int32FromMOTA( pCMAP12[3] );
1366 int nLower = 0;
1367 int nUpper = nGroups;
1368
1369 if( nUpper > (nLength-16)/12 )
1370 nUpper = (nLength-16)/12;
1371
1372 /* binary search in "segmented coverage" subtable */
1373 while( nLower < nUpper ) {
1374 int nIndex = (nLower + nUpper) / 2;
1375 const sal_uInt32* pEntry = &pCMAP12[ 4 + 3*nIndex ];
1376 sal_uInt32 cStart = Int32FromMOTA( pEntry[0] );
1377 sal_uInt32 cLast = Int32FromMOTA( pEntry[1] );
1378 if( cChar < cStart )
1379 nUpper = nIndex;
1380 else if( cChar > cLast )
1381 nLower = nIndex + 1;
1382 else { /* found matching entry! */
1383 sal_uInt32 nGlyph = Int32FromMOTA( pEntry[2] );
1384 nGlyph += cChar - cStart;
1385 return nGlyph;
1386 }
1387 }
1388
1389 return MISSING_GLYPH_INDEX;
1390 }
1391
1392
FindCmap(TrueTypeFont * ttf)1393 static void FindCmap(TrueTypeFont *ttf)
1394 {
1395 const sal_uInt8* table = getTable(ttf, O_cmap);
1396 sal_uInt32 table_size = getTableSize(ttf, O_cmap);
1397 sal_uInt16 ncmaps = GetUInt16(table, 2, 1);
1398 unsigned int i;
1399 sal_uInt32 AppleUni = 0; // Apple Unicode
1400 sal_uInt32 ThreeZero = 0; /* MS Symbol */
1401 sal_uInt32 ThreeOne = 0; /* MS UCS-2 */
1402 sal_uInt32 ThreeTwo = 0; /* MS ShiftJIS */
1403 sal_uInt32 ThreeThree = 0; /* MS Big5 */
1404 sal_uInt32 ThreeFour = 0; /* MS PRC */
1405 sal_uInt32 ThreeFive = 0; /* MS Wansung */
1406 sal_uInt32 ThreeSix = 0; /* MS Johab */
1407
1408 for (i = 0; i < ncmaps; i++) {
1409 sal_uInt32 offset;
1410 sal_uInt16 pID, eID;
1411
1412 /* sanity check, cmap entry must lie within table */
1413 if( i*8+4 > table_size )
1414 break;
1415
1416 pID = GetUInt16(table, 4 + i * 8, 1);
1417 eID = GetUInt16(table, 6 + i * 8, 1);
1418 offset = GetUInt32(table, 8 + i * 8, 1);
1419
1420 /* sanity check, cmap must lie within file */
1421 if( (table - ttf->ptr) + offset > (sal_uInt32)ttf->fsize )
1422 continue;
1423
1424 /* Unicode tables in Apple fonts */
1425 if (pID == 0) {
1426 AppleUni = offset;
1427 }
1428
1429 if (pID == 3) {
1430 switch (eID) {
1431 case 0: ThreeZero = offset; break;
1432 case 10: // UCS-4
1433 case 1: ThreeOne = offset; break;
1434 case 2: ThreeTwo = offset; break;
1435 case 3: ThreeThree = offset; break;
1436 case 4: ThreeFour = offset; break;
1437 case 5: ThreeFive = offset; break;
1438 case 6: ThreeSix = offset; break;
1439 }
1440 }
1441 }
1442
1443 // fall back to AppleUnicode if there are no ThreeOne/Threezero tables
1444 if( AppleUni && !ThreeZero && !ThreeOne)
1445 ThreeOne = AppleUni;
1446
1447 if (ThreeOne) {
1448 ttf->cmapType = CMAP_MS_Unicode;
1449 ttf->cmap = table + ThreeOne;
1450 } else if (ThreeTwo) {
1451 ttf->cmapType = CMAP_MS_ShiftJIS;
1452 ttf->cmap = table + ThreeTwo;
1453 } else if (ThreeThree) {
1454 ttf->cmapType = CMAP_MS_Big5;
1455 ttf->cmap = table + ThreeThree;
1456 } else if (ThreeFour) {
1457 ttf->cmapType = CMAP_MS_PRC;
1458 ttf->cmap = table + ThreeFour;
1459 } else if (ThreeFive) {
1460 ttf->cmapType = CMAP_MS_Wansung;
1461 ttf->cmap = table + ThreeFive;
1462 } else if (ThreeSix) {
1463 ttf->cmapType = CMAP_MS_Johab;
1464 ttf->cmap = table + ThreeSix;
1465 } else if (ThreeZero) {
1466 ttf->cmapType = CMAP_MS_Symbol;
1467 ttf->cmap = table + ThreeZero;
1468 } else {
1469 ttf->cmapType = CMAP_NOT_USABLE;
1470 ttf->cmap = 0;
1471 }
1472
1473 if (ttf->cmapType != CMAP_NOT_USABLE) {
1474 switch (GetUInt16(ttf->cmap, 0, 1)) {
1475 case 0: ttf->mapper = getGlyph0; break;
1476 case 2: ttf->mapper = getGlyph2; break;
1477 case 4: ttf->mapper = getGlyph4; break;
1478 case 6: ttf->mapper = getGlyph6; break;
1479 case 12: ttf->mapper= getGlyph12; break;
1480 default:
1481 #if OSL_DEBUG_LEVEL > 1
1482 /*- if the cmap table is really broken */
1483 printf("%s: %d is not a recognized cmap format.\n", ttf->fname, GetUInt16(ttf->cmap, 0, 1));
1484 #endif
1485 ttf->cmapType = CMAP_NOT_USABLE;
1486 ttf->cmap = 0;
1487 ttf->mapper = 0;
1488 }
1489 }
1490 }
1491
GetKern(TrueTypeFont * ttf)1492 static void GetKern(TrueTypeFont *ttf)
1493 {
1494 const sal_uInt8* table = getTable(ttf, O_kern);
1495 const sal_uInt8 *ptr;
1496
1497 if( !table )
1498 goto badtable;
1499
1500 if (GetUInt16(table, 0, 1) == 0) { /* Traditional Microsoft style table with sal_uInt16 version and nTables fields */
1501 ttf->nkern = GetUInt16(table, 2, 1);
1502 ttf->kerntables = (const sal_uInt8**)calloc(ttf->nkern, sizeof(sal_uInt8 *));
1503 assert(ttf->kerntables != 0);
1504 memset(ttf->kerntables, 0, ttf->nkern * sizeof(sal_uInt8 *));
1505 ttf->kerntype = KT_MICROSOFT;
1506 ptr = table + 4;
1507 for( unsigned i = 0; i < ttf->nkern; ++i) {
1508 ttf->kerntables[i] = ptr;
1509 ptr += GetUInt16(ptr, 2, 1);
1510 /* sanity check */
1511 if( ptr > ttf->ptr+ttf->fsize )
1512 {
1513 free( ttf->kerntables );
1514 goto badtable;
1515 }
1516 }
1517 return;
1518 }
1519
1520 if (GetUInt32(table, 0, 1) == 0x00010000) { /* MacOS style kern tables: fixed32 version and sal_uInt32 nTables fields */
1521 ttf->nkern = GetUInt32(table, 4, 1);
1522 ttf->kerntables = (const sal_uInt8**)calloc(ttf->nkern, sizeof(sal_uInt8*));
1523 assert(ttf->kerntables != 0);
1524 memset(ttf->kerntables, 0, ttf->nkern * sizeof(sal_uInt8 *));
1525 ttf->kerntype = KT_APPLE_NEW;
1526 ptr = table + 8;
1527 for( unsigned i = 0; i < ttf->nkern; ++i) {
1528 ttf->kerntables[i] = ptr;
1529 ptr += GetUInt32(ptr, 0, 1);
1530 /* sanity check; there are some fonts that are broken in this regard */
1531 if( ptr > ttf->ptr+ttf->fsize )
1532 {
1533 free( ttf->kerntables );
1534 goto badtable;
1535 }
1536 }
1537 return;
1538 }
1539
1540 badtable:
1541 ttf->kerntype = KT_NONE;
1542 ttf->kerntables = 0;
1543
1544 return;
1545 }
1546
1547 #ifdef TEST5
1548 /* KernGlyphsPrim?() functions expect the caller to ensure the validity of their arguments and
1549 * that x and y elements of the kern array are initialized to zeroes
1550 */
KernGlyphsPrim1(TrueTypeFont * ttf,sal_uInt16 * glyphs,int nglyphs,int wmode,KernData * kern)1551 static void KernGlyphsPrim1(TrueTypeFont *ttf, sal_uInt16 *glyphs, int nglyphs, int wmode, KernData *kern)
1552 {
1553 (void)ttf; /* avoid warning */
1554 (void)glyphs; /* avoid warning */
1555 (void)nglyphs; /* avoid warning */
1556 (void)wmode; /* avoid warning */
1557 (void)nglyphs; /* avoid warning */
1558 (void)kern; /* avoid warning */
1559 fprintf(stderr, "MacOS kerning tables have not been implemented yet!\n");
1560 }
1561
KernGlyphsPrim2(TrueTypeFont * ttf,sal_uInt16 * glyphs,int nglyphs,int wmode,KernData * kern)1562 static void KernGlyphsPrim2(TrueTypeFont *ttf, sal_uInt16 *glyphs, int nglyphs, int wmode, KernData *kern)
1563 {
1564 sal_uInt32 i, j;
1565 sal_uInt32 gpair;
1566
1567 if( ! nglyphs )
1568 return;
1569
1570 for (i = 0; i < (sal_uInt32)nglyphs - 1; i++) {
1571 gpair = (glyphs[i] << 16) | glyphs[i+1];
1572 #ifdef DEBUG2
1573 /* All fonts with MS kern table that I've seen so far contain just one kern subtable.
1574 * MS kern documentation is very poor and I doubt that font developers will be using
1575 * several subtables. I expect them to be using OpenType tables instead.
1576 * According to MS documention, format 2 subtables are not supported by Windows and OS/2.
1577 */
1578 if (ttf->nkern > 1) {
1579 fprintf(stderr, "KernGlyphsPrim2: %d kern tables found.\n", ttf->nkern);
1580 }
1581 #endif
1582 for (j = 0; j < ttf->nkern; j++) {
1583 sal_uInt16 coverage = GetUInt16(ttf->kerntables[j], 4, 1);
1584 sal_uInt8 *ptr;
1585 int npairs;
1586 sal_uInt32 t;
1587 int l, r, k;
1588
1589 if (! ((coverage & 1) ^ wmode)) continue;
1590 if ((coverage & 0xFFFE) != 0) {
1591 #ifdef DEBUG2
1592 fprintf(stderr, "KernGlyphsPrim2: coverage flags are not supported: %04X.\n", coverage);
1593 #endif
1594 continue;
1595 }
1596 ptr = ttf->kerntables[j];
1597 npairs = GetUInt16(ptr, 6, 1);
1598 ptr += 14;
1599 l = 0;
1600 r = npairs;
1601 do {
1602 k = (l + r) >> 1;
1603 t = GetUInt32(ptr, k * 6, 1);
1604 if (gpair >= t) l = k + 1;
1605 if (gpair <= t) r = k - 1;
1606 } while (l <= r);
1607 if (l - r == 2) {
1608 if (!wmode) {
1609 kern[i].x = XUnits(ttf->unitsPerEm, GetInt16(ptr, 4 + (l-1) * 6, 1));
1610 } else {
1611 kern[i].y = XUnits(ttf->unitsPerEm, GetInt16(ptr, 4 + (l-1) * 6, 1));
1612 }
1613 /* !wmode ? kern[i].x : kern[i].y = GetInt16(ptr, 4 + (l-1) * 6, 1); */
1614 }
1615 }
1616 }
1617 }
1618 #endif
1619
1620 /*- Public functions */ /*FOLD00*/
1621
CountTTCFonts(const char * fname)1622 int CountTTCFonts(const char* fname)
1623 {
1624 int nFonts = 0;
1625 sal_uInt8 buffer[12];
1626 FILE* fd = fopen(fname, "rb");
1627 if( fd ) {
1628 if (fread(buffer, 1, 12, fd) == 12) {
1629 if(GetUInt32(buffer, 0, 1) == T_ttcf )
1630 nFonts = GetUInt32(buffer, 8, 1);
1631 }
1632 fclose(fd);
1633 }
1634 return nFonts;
1635 }
1636
allocTrueTypeFont(TrueTypeFont ** ttf)1637 static void allocTrueTypeFont( TrueTypeFont** ttf )
1638 {
1639 *ttf = (TrueTypeFont*)calloc(1,sizeof(TrueTypeFont));
1640 if( *ttf != NULL )
1641 {
1642 (*ttf)->tag = 0;
1643 (*ttf)->fname = 0;
1644 (*ttf)->fsize = -1;
1645 (*ttf)->ptr = 0;
1646 (*ttf)->nglyphs = 0xFFFFFFFF;
1647 (*ttf)->pGSubstitution = 0;
1648 }
1649 }
1650
1651 /* forward declariotn for the two entry points to use*/
1652 static int doOpenTTFont( sal_uInt32 facenum, TrueTypeFont* t );
1653
1654 #if !defined(WIN32) && !defined(OS2)
OpenTTFontFile(const char * fname,sal_uInt32 facenum,TrueTypeFont ** ttf)1655 int OpenTTFontFile( const char* fname, sal_uInt32 facenum, TrueTypeFont** ttf )
1656 {
1657 int ret, fd = -1;
1658 struct stat st;
1659
1660 if (!fname || !*fname) return SF_BADFILE;
1661
1662 allocTrueTypeFont( ttf );
1663 if( ! *ttf )
1664 return SF_MEMORY;
1665
1666 (*ttf)->fname = strdup(fname);
1667 if( ! (*ttf)->fname )
1668 {
1669 ret = SF_MEMORY;
1670 goto cleanup;
1671 }
1672
1673 fd = open(fname, O_RDONLY);
1674
1675 if (fd == -1) {
1676 ret = SF_BADFILE;
1677 goto cleanup;
1678 }
1679
1680 if (fstat(fd, &st) == -1) {
1681 ret = SF_FILEIO;
1682 goto cleanup;
1683 }
1684
1685 (*ttf)->fsize = st.st_size;
1686
1687 /* On Mac OS, most likely will happen if a Mac user renames a font file
1688 * to be .ttf when its really a Mac resource-based font.
1689 * Size will be 0, but fonts smaller than 4 bytes would be broken anyway.
1690 */
1691 if ((*ttf)->fsize == 0) {
1692 ret = SF_BADFILE;
1693 goto cleanup;
1694 }
1695
1696 if (((*ttf)->ptr = (sal_uInt8 *) mmap(0, (*ttf)->fsize, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
1697 ret = SF_MEMORY;
1698 goto cleanup;
1699 }
1700 close(fd);
1701
1702 return doOpenTTFont( facenum, *ttf );
1703
1704 cleanup:
1705 if (fd != -1) close(fd);
1706 /*- t and t->fname have been allocated! */
1707 free((*ttf)->fname);
1708 free(*ttf);
1709 *ttf = NULL;
1710 return ret;
1711 }
1712 #endif
1713
OpenTTFontBuffer(void * pBuffer,sal_uInt32 nLen,sal_uInt32 facenum,TrueTypeFont ** ttf)1714 int OpenTTFontBuffer(void* pBuffer, sal_uInt32 nLen, sal_uInt32 facenum, TrueTypeFont** ttf)
1715 {
1716 allocTrueTypeFont( ttf );
1717 if( *ttf == NULL )
1718 return SF_MEMORY;
1719
1720 (*ttf)->fname = NULL;
1721 (*ttf)->fsize = nLen;
1722 (*ttf)->ptr = (sal_uInt8*)pBuffer;
1723
1724 return doOpenTTFont( facenum, *ttf );
1725 }
1726
doOpenTTFont(sal_uInt32 facenum,TrueTypeFont * t)1727 static int doOpenTTFont( sal_uInt32 facenum, TrueTypeFont* t )
1728 {
1729 int i;
1730 sal_uInt32 length, tag;
1731 sal_uInt32 tdoffset = 0; /* offset to TableDirectory in a TTC file. For TTF files is 0 */
1732 int indexfmt, k;
1733
1734 sal_uInt32 version = GetInt32(t->ptr, 0, 1);
1735
1736 if ((version == 0x00010000) || (version == T_true)) {
1737 tdoffset = 0;
1738 } else if (version == T_otto) { /* PS-OpenType font */
1739 tdoffset = 0;
1740 } else if (version == T_ttcf) { /* TrueType collection */
1741 if (GetUInt32(t->ptr, 4, 1) != 0x00010000) {
1742 CloseTTFont(t);
1743 return SF_TTFORMAT;
1744 }
1745 if (facenum >= GetUInt32(t->ptr, 8, 1)) {
1746 CloseTTFont(t);
1747 return SF_FONTNO;
1748 }
1749 tdoffset = GetUInt32(t->ptr, 12 + 4 * facenum, 1);
1750 } else {
1751 CloseTTFont(t);
1752 return SF_TTFORMAT;
1753 }
1754
1755 #ifdef DEBUG2
1756 fprintf(stderr, "tdoffset: %d\n", tdoffset);
1757 #endif
1758
1759 /* magic number */
1760 t->tag = TTFontClassTag;
1761
1762 t->ntables = GetUInt16(t->ptr + tdoffset, 4, 1);
1763 if( t->ntables >= 128 )
1764 return SF_TTFORMAT;
1765
1766 t->tables = (const sal_uInt8**)calloc(NUM_TAGS, sizeof(sal_uInt8*));
1767 assert(t->tables != 0);
1768 t->tlens = (sal_uInt32*)calloc(NUM_TAGS, sizeof(sal_uInt32));
1769 assert(t->tlens != 0);
1770
1771 memset(t->tables, 0, NUM_TAGS * sizeof(void *));
1772 memset(t->tlens, 0, NUM_TAGS * sizeof(sal_uInt32));
1773
1774 /* parse the tables */
1775 for (i=0; i<(int)t->ntables; i++) {
1776 int nIndex;
1777 tag = GetUInt32(t->ptr + tdoffset + 12, 16 * i, 1);
1778 switch( tag ) {
1779 case T_maxp: nIndex = O_maxp; break;
1780 case T_glyf: nIndex = O_glyf; break;
1781 case T_head: nIndex = O_head; break;
1782 case T_loca: nIndex = O_loca; break;
1783 case T_name: nIndex = O_name; break;
1784 case T_hhea: nIndex = O_hhea; break;
1785 case T_hmtx: nIndex = O_hmtx; break;
1786 case T_cmap: nIndex = O_cmap; break;
1787 case T_vhea: nIndex = O_vhea; break;
1788 case T_vmtx: nIndex = O_vmtx; break;
1789 case T_OS2 : nIndex = O_OS2; break;
1790 case T_post: nIndex = O_post; break;
1791 case T_kern: nIndex = O_kern; break;
1792 case T_cvt : nIndex = O_cvt; break;
1793 case T_prep: nIndex = O_prep; break;
1794 case T_fpgm: nIndex = O_fpgm; break;
1795 case T_gsub: nIndex = O_gsub; break;
1796 case T_CFF: nIndex = O_CFF; break;
1797 default: nIndex = -1; break;
1798 }
1799 if( nIndex >= 0 ) {
1800 sal_uInt32 nTableOffset = GetUInt32(t->ptr + tdoffset + 12, 16 * i + 8, 1);
1801 length = GetUInt32(t->ptr + tdoffset + 12, 16 * i + 12, 1);
1802 t->tables[nIndex] = t->ptr + nTableOffset;
1803 t->tlens[nIndex] = length;
1804 }
1805 }
1806
1807 /* Fixup offsets when only a TTC extract was provided */
1808 if( facenum == (sal_uInt32)~0 ) {
1809 sal_uInt8* pHead = (sal_uInt8*)t->tables[O_head];
1810 if( !pHead )
1811 return SF_TTFORMAT;
1812 /* limit Head candidate to TTC extract's limits */
1813 if( pHead > t->ptr + (t->fsize - 54) )
1814 pHead = t->ptr + (t->fsize - 54);
1815 /* TODO: find better method than searching head table's magic */
1816 sal_uInt8* p = NULL;
1817 for( p = pHead + 12; p > t->ptr; --p ) {
1818 if( p[0]==0x5F && p[1]==0x0F && p[2]==0x3C && p[3]==0xF5 ) {
1819 int nDelta = (pHead + 12) - p, j;
1820 if( nDelta )
1821 for( j=0; j<NUM_TAGS; ++j )
1822 if( t->tables[j] )
1823 *(char**)&t->tables[j] -= nDelta;
1824 break;
1825 }
1826 }
1827 if( p <= t->ptr )
1828 return SF_TTFORMAT;
1829 }
1830
1831 /* Check the table offsets after TTC correction */
1832 for (i=0; i<NUM_TAGS; i++) {
1833 /* sanity check: table must lay completely within the file
1834 * at this point one could check the checksum of all contained
1835 * tables, but this would be quite time intensive.
1836 * Try to fix tables, so we can cope with minor problems.
1837 */
1838
1839 if( (sal_uInt8*)t->tables[i] < t->ptr )
1840 {
1841 #if OSL_DEBUG_LEVEL > 1
1842 if( t->tables[i] )
1843 fprintf( stderr, "font file %s has bad table offset %d (tagnum=%d)\n", t->fname, (sal_uInt8*)t->tables[i]-t->ptr, i );
1844 #endif
1845 t->tlens[i] = 0;
1846 t->tables[i] = NULL;
1847 }
1848 else if( (sal_uInt8*)t->tables[i] + t->tlens[i] > t->ptr + t->fsize )
1849 {
1850 int nMaxLen = (t->ptr + t->fsize) - (sal_uInt8*)t->tables[i];
1851 if( nMaxLen < 0 )
1852 nMaxLen = 0;
1853 t->tlens[i] = nMaxLen;
1854 #if OSL_DEBUG_LEVEL > 1
1855 fprintf( stderr, "font file %s has too big table (tagnum=%d)\n", t->fname, i );
1856 #endif
1857 }
1858 }
1859
1860 /* At this point TrueTypeFont is constructed, now need to verify the font format
1861 and read the basic font properties */
1862
1863 /* The following tables are absolutely required:
1864 * maxp, head, name, cmap
1865 */
1866
1867 if( !(getTable(t, O_maxp) && getTable(t, O_head) && getTable(t, O_name) && getTable(t, O_cmap)) ) {
1868 CloseTTFont(t);
1869 return SF_TTFORMAT;
1870 }
1871
1872 const sal_uInt8* table = getTable(t, O_maxp);
1873 t->nglyphs = GetUInt16(table, 4, 1);
1874
1875 table = getTable(t, O_head);
1876 t->unitsPerEm = GetUInt16(table, 18, 1);
1877 indexfmt = GetInt16(table, 50, 1);
1878
1879 if( ((indexfmt != 0) && (indexfmt != 1)) || (t->unitsPerEm <= 0) ) {
1880 CloseTTFont(t);
1881 return SF_TTFORMAT;
1882 }
1883
1884 if( getTable(t, O_glyf) && getTable(t, O_loca) ) { /* TTF or TTF-OpenType */
1885 k = (getTableSize(t, O_loca) / (indexfmt ? 4 : 2)) - 1;
1886 if( k < (int)t->nglyphs ) /* Hack for broken Chinese fonts */
1887 t->nglyphs = k;
1888
1889 table = getTable(t, O_loca);
1890 t->goffsets = (sal_uInt32 *) calloc(1+t->nglyphs, sizeof(sal_uInt32));
1891 assert(t->goffsets != 0);
1892
1893 for( i = 0; i <= (int)t->nglyphs; ++i )
1894 t->goffsets[i] = indexfmt ? GetUInt32(table, i << 2, 1) : (sal_uInt32)GetUInt16(table, i << 1, 1) << 1;
1895 } else if( getTable(t, O_CFF) ) { /* PS-OpenType */
1896 t->goffsets = (sal_uInt32 *) calloc(1+t->nglyphs, sizeof(sal_uInt32));
1897 /* TODO: implement to get subsetting */
1898 assert(t->goffsets != 0);
1899 } else {
1900 CloseTTFont(t);
1901 return SF_TTFORMAT;
1902 }
1903
1904 table = getTable(t, O_hhea);
1905 t->numberOfHMetrics = (table != 0) ? GetUInt16(table, 34, 1) : 0;
1906
1907 table = getTable(t, O_vhea);
1908 t->numOfLongVerMetrics = (table != 0) ? GetUInt16(table, 34, 1) : 0;
1909
1910 GetNames(t);
1911 FindCmap(t);
1912 GetKern(t);
1913 ReadGSUB( t, 0, 0 );
1914
1915 return SF_OK;
1916 }
1917
CloseTTFont(TrueTypeFont * ttf)1918 void CloseTTFont(TrueTypeFont *ttf) /*FOLD01*/
1919 {
1920 if (ttf->tag != TTFontClassTag) return;
1921
1922 #if !defined(WIN32) && !defined(OS2)
1923 if( ttf->fname )
1924 munmap((char *) ttf->ptr, ttf->fsize);
1925 #endif
1926 free(ttf->fname);
1927 free(ttf->goffsets);
1928 free(ttf->psname);
1929 free(ttf->family);
1930 if( ttf->ufamily )
1931 free( ttf->ufamily );
1932 free(ttf->subfamily);
1933 if( ttf->usubfamily )
1934 free( ttf->usubfamily );
1935 free(ttf->tables);
1936 free(ttf->tlens);
1937 free(ttf->kerntables);
1938
1939 ReleaseGSUB(ttf);
1940
1941 free(ttf);
1942 return;
1943 }
1944
GetTTGlyphPoints(TrueTypeFont * ttf,sal_uInt32 glyphID,ControlPoint ** pointArray)1945 int GetTTGlyphPoints(TrueTypeFont *ttf, sal_uInt32 glyphID, ControlPoint **pointArray)
1946 {
1947 return GetTTGlyphOutline(ttf, glyphID, pointArray, 0, 0);
1948 }
1949
GetTTGlyphComponents(TrueTypeFont * ttf,sal_uInt32 glyphID,std::vector<sal_uInt32> & glyphlist)1950 int GetTTGlyphComponents(TrueTypeFont *ttf, sal_uInt32 glyphID, std::vector< sal_uInt32 >& glyphlist)
1951 {
1952 int n = 1;
1953
1954 if( glyphID >= ttf->nglyphs )
1955 return 0;
1956
1957 const sal_uInt8* glyf = getTable(ttf, O_glyf);
1958 const sal_uInt8* ptr = glyf + ttf->goffsets[glyphID];
1959
1960 glyphlist.push_back( glyphID );
1961
1962 if (GetInt16(ptr, 0, 1) == -1) {
1963 sal_uInt16 flags, index;
1964 ptr += 10;
1965 do {
1966 flags = GetUInt16(ptr, 0, 1);
1967 index = GetUInt16(ptr, 2, 1);
1968
1969 ptr += 4;
1970 n += GetTTGlyphComponents(ttf, index, glyphlist);
1971
1972 if (flags & ARG_1_AND_2_ARE_WORDS) {
1973 ptr += 4;
1974 } else {
1975 ptr += 2;
1976 }
1977
1978 if (flags & WE_HAVE_A_SCALE) {
1979 ptr += 2;
1980 } else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) {
1981 ptr += 4;
1982 } else if (flags & WE_HAVE_A_TWO_BY_TWO) {
1983 ptr += 8;
1984 }
1985 } while (flags & MORE_COMPONENTS);
1986 }
1987
1988 return n;
1989 }
1990
1991 #ifndef NO_TYPE3
CreateT3FromTTGlyphs(TrueTypeFont * ttf,FILE * outf,const char * fname,sal_uInt16 * glyphArray,sal_uInt8 * encoding,int nGlyphs,int wmode)1992 int CreateT3FromTTGlyphs(TrueTypeFont *ttf, FILE *outf, const char *fname, /*FOLD00*/
1993 sal_uInt16 *glyphArray, sal_uInt8 *encoding, int nGlyphs,
1994 int wmode)
1995 {
1996 ControlPoint *pa;
1997 PSPathElement *path;
1998 int i, j, r, n;
1999 const sal_uInt8* table = getTable(ttf, O_head);
2000 TTGlyphMetrics metrics;
2001 int UPEm = ttf->unitsPerEm;
2002
2003 const char *h01 = "%%!PS-AdobeFont-%d.%d-%d.%d\n";
2004 const char *h02 = "%% Creator: %s %s %s\n";
2005 const char *h09 = "%% Original font name: %s\n";
2006
2007 const char *h10 =
2008 "30 dict begin\n"
2009 "/PaintType 0 def\n"
2010 "/FontType 3 def\n"
2011 "/StrokeWidth 0 def\n";
2012
2013 const char *h11 = "/FontName (%s) cvn def\n";
2014
2015 /*
2016 const char *h12 = "%/UniqueID %d def\n";
2017 */
2018 const char *h13 = "/FontMatrix [.001 0 0 .001 0 0] def\n";
2019 const char *h14 = "/FontBBox [%d %d %d %d] def\n";
2020
2021 const char *h15=
2022 "/Encoding 256 array def\n"
2023 " 0 1 255 {Encoding exch /.notdef put} for\n";
2024
2025 const char *h16 = " Encoding %d /glyph%d put\n";
2026 const char *h17 = "/XUID [103 0 0 16#%08X %d 16#%08X 16#%08X] def\n";
2027
2028 const char *h30 = "/CharProcs %d dict def\n";
2029 const char *h31 = " CharProcs begin\n";
2030 const char *h32 = " /.notdef {} def\n";
2031 const char *h33 = " /glyph%d {\n";
2032 const char *h34 = " } bind def\n";
2033 const char *h35 = " end\n";
2034
2035 const char *h40 =
2036 "/BuildGlyph {\n"
2037 " exch /CharProcs get exch\n"
2038 " 2 copy known not\n"
2039 " {pop /.notdef} if\n"
2040 " get exec\n"
2041 "} bind def\n"
2042 "/BuildChar {\n"
2043 " 1 index /Encoding get exch get\n"
2044 " 1 index /BuildGlyph get exec\n"
2045 "} bind def\n"
2046 "currentdict end\n";
2047
2048 const char *h41 = "(%s) cvn exch definefont pop\n";
2049
2050
2051 if (!((nGlyphs > 0) && (nGlyphs <= 256))) return SF_GLYPHNUM;
2052 if (!glyphArray) return SF_BADARG;
2053 if (!fname) fname = ttf->psname;
2054
2055 fprintf(outf, h01, GetInt16(table, 0, 1), GetUInt16(table, 2, 1), GetInt16(table, 4, 1), GetUInt16(table, 6, 1));
2056 fprintf(outf, h02, modname, modver, modextra);
2057 fprintf(outf, h09, ttf->psname);
2058
2059 fprintf(outf, h10);
2060 fprintf(outf, h11, fname);
2061 /* fprintf(outf, h12, 4000000); */
2062
2063 /* XUID generation:
2064 * 103 0 0 C1 C2 C3 C4
2065 * C1 - CRC-32 of the entire source TrueType font
2066 * C2 - number of glyphs in the subset
2067 * C3 - CRC-32 of the glyph array
2068 * C4 - CRC-32 of the encoding array
2069 *
2070 * All CRC-32 numbers are presented as hexadecimal numbers
2071 */
2072
2073 fprintf(outf, h17, rtl_crc32(0, ttf->ptr, ttf->fsize), nGlyphs, rtl_crc32(0, glyphArray, nGlyphs * 2), rtl_crc32(0, encoding, nGlyphs));
2074 fprintf(outf, h13);
2075 fprintf(outf, h14, XUnits(UPEm, GetInt16(table, 36, 1)), XUnits(UPEm, GetInt16(table, 38, 1)), XUnits(UPEm, GetInt16(table, 40, 1)), XUnits(UPEm, GetInt16(table, 42, 1)));
2076 fprintf(outf, h15);
2077
2078 for (i = 0; i < nGlyphs; i++) {
2079 fprintf(outf, h16, encoding[i], i);
2080 }
2081
2082 fprintf(outf, h30, nGlyphs+1);
2083 fprintf(outf, h31);
2084 fprintf(outf, h32);
2085
2086 for (i = 0; i < nGlyphs; i++) {
2087 fprintf(outf, h33, i);
2088 r = GetTTGlyphOutline(ttf, glyphArray[i] < ttf->nglyphs ? glyphArray[i] : 0, &pa, &metrics, 0);
2089
2090 if (r > 0) {
2091 n = BSplineToPSPath(pa, r, &path);
2092 } else {
2093 n = 0; /* glyph might have zero contours but valid metrics ??? */
2094 path = 0;
2095 if (r < 0) { /* glyph is not present in the font - pa array was not allocated, so no need to free it */
2096 continue;
2097 }
2098 }
2099 fprintf(outf, "\t%d %d %d %d %d %d setcachedevice\n",
2100 wmode == 0 ? XUnits(UPEm, metrics.aw) : 0,
2101 wmode == 0 ? 0 : -XUnits(UPEm, metrics.ah),
2102 XUnits(UPEm, metrics.xMin),
2103 XUnits(UPEm, metrics.yMin),
2104 XUnits(UPEm, metrics.xMax),
2105 XUnits(UPEm, metrics.yMax));
2106
2107 for (j = 0; j < n; j++)
2108 {
2109 switch (path[j].type)
2110 {
2111 case PS_MOVETO:
2112 fprintf(outf, "\t%d %d moveto\n", XUnits(UPEm, path[j].x1), XUnits(UPEm, path[j].y1));
2113 break;
2114
2115 case PS_LINETO:
2116 fprintf(outf, "\t%d %d lineto\n", XUnits(UPEm, path[j].x1), XUnits(UPEm, path[j].y1));
2117 break;
2118
2119 case PS_CURVETO:
2120 fprintf(outf, "\t%d %d %d %d %d %d curveto\n", XUnits(UPEm, path[j].x1), XUnits(UPEm, path[j].y1), XUnits(UPEm, path[j].x2), XUnits(UPEm, path[j].y2), XUnits(UPEm, path[j].x3), XUnits(UPEm, path[j].y3));
2121 break;
2122
2123 case PS_CLOSEPATH:
2124 fprintf(outf, "\tclosepath\n");
2125 break;
2126 case PS_NOOP:
2127 break;
2128 }
2129 }
2130 if (n > 0) fprintf(outf, "\tfill\n"); /* if glyph is not a whitespace character */
2131
2132 fprintf(outf, h34);
2133
2134 free(pa);
2135 free(path);
2136 }
2137 fprintf(outf, h35);
2138
2139 fprintf(outf, h40);
2140 fprintf(outf, h41, fname);
2141
2142 return SF_OK;
2143 }
2144 #endif
2145
2146 #ifndef NO_TTCR
CreateTTFromTTGlyphs(TrueTypeFont * ttf,const char * fname,sal_uInt16 * glyphArray,sal_uInt8 * encoding,int nGlyphs,int nNameRecs,NameRecord * nr,sal_uInt32 flags)2147 int CreateTTFromTTGlyphs(TrueTypeFont *ttf,
2148 const char *fname,
2149 sal_uInt16 *glyphArray,
2150 sal_uInt8 *encoding,
2151 int nGlyphs,
2152 int nNameRecs,
2153 NameRecord *nr,
2154 sal_uInt32 flags)
2155 {
2156 TrueTypeCreator *ttcr;
2157 TrueTypeTable *head=0, *hhea=0, *maxp=0, *cvt=0, *prep=0, *glyf=0, *fpgm=0, *cmap=0, *name=0, *post = 0, *os2 = 0;
2158 int i;
2159 int res;
2160
2161 TrueTypeCreatorNewEmpty(T_true, &ttcr);
2162
2163 /** name **/
2164
2165 if (flags & TTCF_AutoName) {
2166 /* not implemented yet
2167 NameRecord *names;
2168 NameRecord newname;
2169 int n = GetTTNameRecords(ttf, &names);
2170 int n1 = 0, n2 = 0, n3 = 0, n4 = 0, n5 = 0, n6 = 0;
2171 sal_uInt8 *cp1;
2172 sal_uInt8 suffix[32];
2173 sal_uInt32 c1 = crc32(glyphArray, nGlyphs * 2);
2174 sal_uInt32 c2 = crc32(encoding, nGlyphs);
2175 int len;
2176 snprintf(suffix, 31, "S%08X%08X-%d", c1, c2, nGlyphs);
2177
2178 name = TrueTypeTableNew_name(0, 0);
2179 for (i = 0; i < n; i++) {
2180 if (names[i].platformID == 1 && names[i].encodingID == 0 && names[i].languageID == 0 && names[i].nameID == 1) {
2181
2182 memcpy(newname, names+i, sizeof(NameRecord));
2183 newname.slen = name[i].slen + strlen(suffix);
2184 */
2185 const sal_uInt8 ptr[] = {0,'T',0,'r',0,'u',0,'e',0,'T',0,'y',0,'p',0,'e',0,'S',0,'u',0,'b',0,'s',0,'e',0,'t'};
2186 NameRecord n1 = {1, 0, 0, 6, 14, (sal_uInt8*)"TrueTypeSubset"};
2187 NameRecord n2 = {3, 1, 1033, 6, 28, 0};
2188 n2.sptr = (sal_uInt8 *) ptr;
2189 name = TrueTypeTableNew_name(0, 0);
2190 nameAdd(name, &n1);
2191 nameAdd(name, &n2);
2192 } else {
2193 if (nNameRecs == 0) {
2194 NameRecord *names;
2195 int n = GetTTNameRecords(ttf, &names);
2196 name = TrueTypeTableNew_name(n, names);
2197 DisposeNameRecords(names, n);
2198 } else {
2199 name = TrueTypeTableNew_name(nNameRecs, nr);
2200 }
2201 }
2202
2203 /** maxp **/
2204 maxp = TrueTypeTableNew_maxp(getTable(ttf, O_maxp), getTableSize(ttf, O_maxp));
2205
2206 /** hhea **/
2207 const sal_uInt8* p = getTable(ttf, O_hhea);
2208 if (p) {
2209 hhea = TrueTypeTableNew_hhea(GetUInt16(p, 4, 1), GetUInt16(p, 6, 1), GetUInt16(p, 8, 1), GetUInt16(p, 18, 1), GetUInt16(p, 20, 1));
2210 } else {
2211 hhea = TrueTypeTableNew_hhea(0, 0, 0, 0, 0);
2212 }
2213
2214 /** head **/
2215
2216 p = getTable(ttf, O_head);
2217 assert(p != 0);
2218 head = TrueTypeTableNew_head(GetUInt32(p, 4, 1),
2219 GetUInt16(p, 16, 1),
2220 GetUInt16(p, 18, 1),
2221 p+20,
2222 GetUInt16(p, 44, 1),
2223 GetUInt16(p, 46, 1),
2224 GetInt16(p, 48, 1));
2225
2226
2227 /** glyf **/
2228
2229 glyf = TrueTypeTableNew_glyf();
2230 sal_uInt32* gID = (sal_uInt32*)scalloc(nGlyphs, sizeof(sal_uInt32));
2231
2232 for (i = 0; i < nGlyphs; i++) {
2233 gID[i] = glyfAdd(glyf, GetTTRawGlyphData(ttf, glyphArray[i]), ttf);
2234 }
2235
2236 /** cmap **/
2237 cmap = TrueTypeTableNew_cmap();
2238
2239 for (i=0; i < nGlyphs; i++) {
2240 cmapAdd(cmap, 0x010000, encoding[i], gID[i]);
2241 }
2242
2243 /** cvt **/
2244 if ((p = getTable(ttf, O_cvt)) != 0) {
2245 cvt = TrueTypeTableNew(T_cvt, getTableSize(ttf, O_cvt), p);
2246 }
2247
2248 /** prep **/
2249 if ((p = getTable(ttf, O_prep)) != 0) {
2250 prep = TrueTypeTableNew(T_prep, getTableSize(ttf, O_prep), p);
2251 }
2252
2253 /** fpgm **/
2254 if ((p = getTable(ttf, O_fpgm)) != 0) {
2255 fpgm = TrueTypeTableNew(T_fpgm, getTableSize(ttf, O_fpgm), p);
2256 }
2257
2258 /** post **/
2259 if ((p = getTable(ttf, O_post)) != 0) {
2260 post = TrueTypeTableNew_post(0x00030000,
2261 GetUInt32(p, 4, 1),
2262 GetUInt16(p, 8, 1),
2263 GetUInt16(p, 10, 1),
2264 GetUInt16(p, 12, 1));
2265 } else {
2266 post = TrueTypeTableNew_post(0x00030000, 0, 0, 0, 0);
2267 }
2268
2269 if (flags & TTCF_IncludeOS2) {
2270 if ((p = getTable(ttf, O_OS2)) != 0) {
2271 os2 = TrueTypeTableNew(T_OS2, getTableSize(ttf, O_OS2), p);
2272 }
2273 }
2274
2275 AddTable(ttcr, name); AddTable(ttcr, maxp); AddTable(ttcr, hhea);
2276 AddTable(ttcr, head); AddTable(ttcr, glyf); AddTable(ttcr, cmap);
2277 AddTable(ttcr, cvt ); AddTable(ttcr, prep); AddTable(ttcr, fpgm);
2278 AddTable(ttcr, post); AddTable(ttcr, os2);
2279
2280 if ((res = StreamToFile(ttcr, fname)) != SF_OK) {
2281 #if OSL_DEBUG_LEVEL > 1
2282 fprintf(stderr, "StreamToFile: error code: %d.\n", res);
2283 #endif
2284 }
2285
2286 TrueTypeCreatorDispose(ttcr);
2287 free(gID);
2288
2289 return res;
2290 }
2291 #endif
2292
2293
2294 #ifndef NO_TYPE42
GlyphOffsetsNew(sal_uInt8 * sfntP)2295 static GlyphOffsets *GlyphOffsetsNew(sal_uInt8 *sfntP)
2296 {
2297 GlyphOffsets* res = (GlyphOffsets*)smalloc(sizeof(GlyphOffsets));
2298 sal_uInt8 *loca = NULL;
2299 sal_uInt16 i, numTables = GetUInt16(sfntP, 4, 1);
2300 sal_uInt32 locaLen = 0;
2301 sal_Int16 indexToLocFormat = 0;
2302
2303 for (i = 0; i < numTables; i++) {
2304 sal_uInt32 tag = GetUInt32(sfntP + 12, 16 * i, 1);
2305 sal_uInt32 off = GetUInt32(sfntP + 12, 16 * i + 8, 1);
2306 sal_uInt32 len = GetUInt32(sfntP + 12, 16 * i + 12, 1);
2307
2308 if (tag == T_loca) {
2309 loca = sfntP + off;
2310 locaLen = len;
2311 } else if (tag == T_head) {
2312 indexToLocFormat = GetInt16(sfntP + off, 50, 1);
2313 }
2314 }
2315
2316 res->nGlyphs = locaLen / ((indexToLocFormat == 1) ? 4 : 2);
2317 assert(res->nGlyphs != 0);
2318 res->offs = (sal_uInt32*)scalloc(res->nGlyphs, sizeof(sal_uInt32));
2319
2320 for (i = 0; i < res->nGlyphs; i++) {
2321 if (indexToLocFormat == 1) {
2322 res->offs[i] = GetUInt32(loca, i * 4, 1);
2323 } else {
2324 res->offs[i] = GetUInt16(loca, i * 2, 1) << 1;
2325 }
2326 }
2327 return res;
2328 }
2329
GlyphOffsetsDispose(GlyphOffsets * _this)2330 static void GlyphOffsetsDispose(GlyphOffsets *_this)
2331 {
2332 if (_this) {
2333 free(_this->offs);
2334 free(_this);
2335 }
2336 }
2337
DumpSfnts(FILE * outf,sal_uInt8 * sfntP)2338 static void DumpSfnts(FILE *outf, sal_uInt8 *sfntP)
2339 {
2340 HexFmt *h = HexFmtNew(outf);
2341 sal_uInt16 i, numTables = GetUInt16(sfntP, 4, 1);
2342 GlyphOffsets *go = GlyphOffsetsNew(sfntP);
2343 sal_uInt8 pad[] = {0,0,0,0}; /* zeroes */
2344
2345 assert(numTables <= 9); /* Type42 has 9 required tables */
2346
2347 sal_uInt32* offs = (sal_uInt32*)scalloc(numTables, sizeof(sal_uInt32));
2348 // sal_uInt32* lens = (sal_uInt32*)scalloc(numTables, sizeof(sal_uInt32));
2349
2350 fputs("/sfnts [", outf);
2351 HexFmtOpenString(h);
2352 HexFmtBlockWrite(h, sfntP, 12); /* stream out the Offset Table */
2353 HexFmtBlockWrite(h, sfntP+12, 16 * numTables); /* stream out the Table Directory */
2354
2355 for (i=0; i<numTables; i++) {
2356 sal_uInt32 tag = GetUInt32(sfntP + 12, 16 * i, 1);
2357 sal_uInt32 off = GetUInt32(sfntP + 12, 16 * i + 8, 1);
2358 sal_uInt32 len = GetUInt32(sfntP + 12, 16 * i + 12, 1);
2359
2360 if (tag != T_glyf) {
2361 HexFmtBlockWrite(h, sfntP + off, len);
2362 } else {
2363 sal_uInt8 *glyf = sfntP + off;
2364 sal_uInt32 o, l, j;
2365 for (j = 0; j < go->nGlyphs - 1; j++) {
2366 o = go->offs[j];
2367 l = go->offs[j + 1] - o;
2368 HexFmtBlockWrite(h, glyf + o, l);
2369 }
2370 }
2371 HexFmtBlockWrite(h, pad, (4 - (len & 3)) & 3);
2372 }
2373 HexFmtCloseString(h);
2374 fputs("] def\n", outf);
2375 GlyphOffsetsDispose(go);
2376 HexFmtDispose(h);
2377 free(offs);
2378 // free(lens);
2379 }
2380
CreateT42FromTTGlyphs(TrueTypeFont * ttf,FILE * outf,const char * psname,sal_uInt16 * glyphArray,sal_uInt8 * encoding,int nGlyphs)2381 int CreateT42FromTTGlyphs(TrueTypeFont *ttf,
2382 FILE *outf,
2383 const char *psname,
2384 sal_uInt16 *glyphArray,
2385 sal_uInt8 *encoding,
2386 int nGlyphs)
2387 {
2388 TrueTypeCreator *ttcr;
2389 TrueTypeTable *head=0, *hhea=0, *maxp=0, *cvt=0, *prep=0, *glyf=0, *fpgm=0;
2390 int i;
2391 int res;
2392
2393 sal_uInt32 ver, rev;
2394
2395 sal_uInt8 *sfntP;
2396 sal_uInt32 sfntLen;
2397 int UPEm = ttf->unitsPerEm;
2398
2399 if (nGlyphs >= 256) return SF_GLYPHNUM;
2400
2401 assert(psname != 0);
2402
2403 TrueTypeCreatorNewEmpty(T_true, &ttcr);
2404
2405 /* head */
2406 const sal_uInt8* p = getTable(ttf, O_head);
2407 const sal_uInt8* headP = p;
2408 assert(p != 0);
2409 head = TrueTypeTableNew_head(GetUInt32(p, 4, 1), GetUInt16(p, 16, 1), GetUInt16(p, 18, 1), p+20, GetUInt16(p, 44, 1), GetUInt16(p, 46, 1), GetInt16(p, 48, 1));
2410 ver = GetUInt32(p, 0, 1);
2411 rev = GetUInt32(p, 4, 1);
2412
2413 /** hhea **/
2414 p = getTable(ttf, O_hhea);
2415 if (p) {
2416 hhea = TrueTypeTableNew_hhea(GetUInt16(p, 4, 1), GetUInt16(p, 6, 1), GetUInt16(p, 8, 1), GetUInt16(p, 18, 1), GetUInt16(p, 20, 1));
2417 } else {
2418 hhea = TrueTypeTableNew_hhea(0, 0, 0, 0, 0);
2419 }
2420
2421 /** maxp **/
2422 maxp = TrueTypeTableNew_maxp(getTable(ttf, O_maxp), getTableSize(ttf, O_maxp));
2423
2424 /** cvt **/
2425 if ((p = getTable(ttf, O_cvt)) != 0) {
2426 cvt = TrueTypeTableNew(T_cvt, getTableSize(ttf, O_cvt), p);
2427 }
2428
2429 /** prep **/
2430 if ((p = getTable(ttf, O_prep)) != 0) {
2431 prep = TrueTypeTableNew(T_prep, getTableSize(ttf, O_prep), p);
2432 }
2433
2434 /** fpgm **/
2435 if ((p = getTable(ttf, O_fpgm)) != 0) {
2436 fpgm = TrueTypeTableNew(T_fpgm, getTableSize(ttf, O_fpgm), p);
2437 }
2438
2439 /** glyf **/
2440 glyf = TrueTypeTableNew_glyf();
2441 sal_uInt16* gID = (sal_uInt16*)scalloc(nGlyphs, sizeof(sal_uInt32));
2442
2443 for (i = 0; i < nGlyphs; i++) {
2444 gID[i] = (sal_uInt16)glyfAdd(glyf, GetTTRawGlyphData(ttf, glyphArray[i]), ttf);
2445 }
2446
2447 AddTable(ttcr, head); AddTable(ttcr, hhea); AddTable(ttcr, maxp); AddTable(ttcr, cvt);
2448 AddTable(ttcr, prep); AddTable(ttcr, glyf); AddTable(ttcr, fpgm);
2449
2450 if ((res = StreamToMemory(ttcr, &sfntP, &sfntLen)) != SF_OK) {
2451 TrueTypeCreatorDispose(ttcr);
2452 free(gID);
2453 return res;
2454 }
2455
2456 fprintf(outf, "%%!PS-TrueTypeFont-%d.%d-%d.%d\n", (int)(ver>>16), (int)(ver & 0xFFFF), (int)(rev>>16), (int)(rev & 0xFFFF));
2457 fprintf(outf, "%%%%Creator: %s %s %s\n", modname, modver, modextra);
2458 fprintf(outf, "%%- Font subset generated from a source font file: '%s'\n", ttf->fname);
2459 fprintf(outf, "%%- Original font name: %s\n", ttf->psname);
2460 fprintf(outf, "%%- Original font family: %s\n", ttf->family);
2461 fprintf(outf, "%%- Original font sub-family: %s\n", ttf->subfamily);
2462 fprintf(outf, "11 dict begin\n");
2463 fprintf(outf, "/FontName (%s) cvn def\n", psname);
2464 fprintf(outf, "/PaintType 0 def\n");
2465 fprintf(outf, "/FontMatrix [1 0 0 1 0 0] def\n");
2466 fprintf(outf, "/FontBBox [%d %d %d %d] def\n", XUnits(UPEm, GetInt16(headP, 36, 1)), XUnits(UPEm, GetInt16(headP, 38, 1)), XUnits(UPEm, GetInt16(headP, 40, 1)), XUnits(UPEm, GetInt16(headP, 42, 1)));
2467 fprintf(outf, "/FontType 42 def\n");
2468 fprintf(outf, "/Encoding 256 array def\n");
2469 fprintf(outf, " 0 1 255 {Encoding exch /.notdef put} for\n");
2470
2471 for (i = 1; i<nGlyphs; i++) {
2472 fprintf(outf, "Encoding %d /glyph%d put\n", encoding[i], gID[i]);
2473 }
2474 fprintf(outf, "/XUID [103 0 1 16#%08X %d 16#%08X 16#%08X] def\n", (unsigned int)rtl_crc32(0, ttf->ptr, ttf->fsize), (unsigned int)nGlyphs, (unsigned int)rtl_crc32(0, glyphArray, nGlyphs * 2), (unsigned int)rtl_crc32(0, encoding, nGlyphs));
2475
2476 DumpSfnts(outf, sfntP);
2477
2478 /* dump charstrings */
2479 fprintf(outf, "/CharStrings %d dict dup begin\n", nGlyphs);
2480 fprintf(outf, "/.notdef 0 def\n");
2481 for (i = 1; i < (int)glyfCount(glyf); i++) {
2482 fprintf(outf,"/glyph%d %d def\n", i, i);
2483 }
2484 fprintf(outf, "end readonly def\n");
2485
2486 fprintf(outf, "FontName currentdict end definefont pop\n");
2487 TrueTypeCreatorDispose(ttcr);
2488 free(gID);
2489 free(sfntP);
2490 return SF_OK;
2491 }
2492 #endif
2493
2494
2495 #ifndef NO_MAPPERS
MapString(TrueTypeFont * ttf,sal_uInt16 * str,int nchars,sal_uInt16 * glyphArray,int bvertical)2496 int MapString(TrueTypeFont *ttf, sal_uInt16 *str, int nchars, sal_uInt16 *glyphArray, int bvertical)
2497 {
2498 int i;
2499 sal_uInt16 *cp;
2500
2501 if (ttf->cmapType == CMAP_NOT_USABLE ) return -1;
2502 if (!nchars) return 0;
2503
2504 if (glyphArray == 0) {
2505 cp = str;
2506 } else {
2507 cp = glyphArray;
2508 }
2509
2510 switch (ttf->cmapType) {
2511 case CMAP_MS_Symbol:
2512 if( ttf->mapper == getGlyph0 ) {
2513 sal_uInt16 aChar;
2514 for( i = 0; i < nchars; i++ ) {
2515 aChar = str[i];
2516 if( ( aChar & 0xf000 ) == 0xf000 )
2517 aChar &= 0x00ff;
2518 cp[i] = aChar;
2519 }
2520 }
2521 else if( glyphArray )
2522 memcpy(glyphArray, str, nchars * 2);
2523 break;
2524
2525 case CMAP_MS_Unicode:
2526 if (glyphArray != 0) {
2527 memcpy(glyphArray, str, nchars * 2);
2528 }
2529 break;
2530
2531 case CMAP_MS_ShiftJIS: TranslateString12(str, cp, nchars); break;
2532 case CMAP_MS_Big5: TranslateString13(str, cp, nchars); break;
2533 case CMAP_MS_PRC: TranslateString14(str, cp, nchars); break;
2534 case CMAP_MS_Wansung: TranslateString15(str, cp, nchars); break;
2535 case CMAP_MS_Johab: TranslateString16(str, cp, nchars); break;
2536 }
2537
2538 for (i = 0; i < nchars; i++) {
2539 cp[i] = (sal_uInt16)ttf->mapper(ttf->cmap, cp[i]);
2540 if (cp[i]!=0 && bvertical!=0)
2541 cp[i] = (sal_uInt16)UseGSUB(ttf,cp[i],bvertical);
2542 }
2543 return nchars;
2544 }
2545
MapChar(TrueTypeFont * ttf,sal_uInt16 ch,int bvertical)2546 sal_uInt16 MapChar(TrueTypeFont *ttf, sal_uInt16 ch, int bvertical)
2547 {
2548 switch (ttf->cmapType) {
2549 case CMAP_MS_Symbol:
2550
2551 if( ttf->mapper == getGlyph0 && ( ch & 0xf000 ) == 0xf000 )
2552 ch &= 0x00ff;
2553 return (sal_uInt16)ttf->mapper(ttf->cmap, ch );
2554
2555 case CMAP_MS_Unicode: break;
2556 case CMAP_MS_ShiftJIS: ch = TranslateChar12(ch); break;
2557 case CMAP_MS_Big5: ch = TranslateChar13(ch); break;
2558 case CMAP_MS_PRC: ch = TranslateChar14(ch); break;
2559 case CMAP_MS_Wansung: ch = TranslateChar15(ch); break;
2560 case CMAP_MS_Johab: ch = TranslateChar16(ch); break;
2561 default: return 0;
2562 }
2563 ch = (sal_uInt16)ttf->mapper(ttf->cmap, ch);
2564 if (ch!=0 && bvertical!=0)
2565 ch = (sal_uInt16)UseGSUB(ttf,ch,bvertical);
2566 return ch;
2567 }
2568
DoesVerticalSubstitution(TrueTypeFont * ttf,int bvertical)2569 int DoesVerticalSubstitution( TrueTypeFont *ttf, int bvertical)
2570 {
2571 int nRet = 0;
2572 if( bvertical)
2573 nRet = HasVerticalGSUB( ttf);
2574 return nRet;
2575 }
2576
2577 #endif
2578
GetTTGlyphCount(TrueTypeFont * ttf)2579 int GetTTGlyphCount( TrueTypeFont* ttf )
2580 {
2581 return ttf->nglyphs;
2582 }
2583
GetSfntTable(TrueTypeFont * ttf,int nSubtableIndex,const sal_uInt8 ** ppRawBytes,int * pRawLength)2584 bool GetSfntTable( TrueTypeFont* ttf, int nSubtableIndex,
2585 const sal_uInt8** ppRawBytes, int* pRawLength )
2586 {
2587 if( (nSubtableIndex < 0) || (nSubtableIndex >= NUM_TAGS) )
2588 return false;
2589 *pRawLength = ttf->tlens[ nSubtableIndex ];
2590 *ppRawBytes = ttf->tables[ nSubtableIndex ];
2591 bool bOk = (*pRawLength > 0) && (ppRawBytes != NULL);
2592 return bOk;
2593 }
2594
GetTTSimpleGlyphMetrics(TrueTypeFont * ttf,sal_uInt16 * glyphArray,int nGlyphs,int mode)2595 TTSimpleGlyphMetrics *GetTTSimpleGlyphMetrics(TrueTypeFont *ttf, sal_uInt16 *glyphArray, int nGlyphs, int mode)
2596 {
2597 const sal_uInt8* pTable;
2598 sal_uInt32 n;
2599 int nTableSize;
2600
2601 if (mode == 0) {
2602 n = ttf->numberOfHMetrics;
2603 pTable = getTable( ttf, O_hmtx );
2604 nTableSize = getTableSize( ttf, O_hmtx );
2605 } else {
2606 n = ttf->numOfLongVerMetrics;
2607 pTable = getTable( ttf, O_vmtx );
2608 nTableSize = getTableSize( ttf, O_vmtx );
2609 }
2610
2611 if (!nGlyphs || !glyphArray) return 0; /* invalid parameters */
2612 if (!n || !pTable) return 0; /* the font does not contain the requested metrics */
2613
2614 TTSimpleGlyphMetrics* res = (TTSimpleGlyphMetrics*)calloc(nGlyphs, sizeof(TTSimpleGlyphMetrics));
2615 assert(res != 0);
2616
2617 const int UPEm = ttf->unitsPerEm;
2618 for( int i = 0; i < nGlyphs; ++i) {
2619 int nAdvOffset, nLsbOffset;
2620 sal_uInt16 glyphID = glyphArray[i];
2621
2622 if (glyphID < n) {
2623 nAdvOffset = 4 * glyphID;
2624 nLsbOffset = nAdvOffset + 2;
2625 } else {
2626 nAdvOffset = 4 * (n - 1);
2627 if( glyphID < ttf->nglyphs )
2628 nLsbOffset = 4 * n + 2 * (glyphID - n);
2629 else /* font is broken -> use lsb of last hmetrics */
2630 nLsbOffset = nAdvOffset + 2;
2631 }
2632
2633 if( nAdvOffset >= nTableSize)
2634 res[i].adv = 0; /* better than a crash for buggy fonts */
2635 else
2636 res[i].adv = static_cast<sal_uInt16>(
2637 XUnits( UPEm, GetUInt16( pTable, nAdvOffset, 1) ) );
2638
2639 if( nLsbOffset >= nTableSize)
2640 res[i].sb = 0; /* better than a crash for buggy fonts */
2641 else
2642 res[i].sb = static_cast<sal_Int16>(
2643 XUnits( UPEm, GetInt16( pTable, nLsbOffset, 1) ) );
2644 }
2645
2646 return res;
2647 }
2648
2649 #ifndef NO_MAPPERS
GetTTSimpleCharMetrics(TrueTypeFont * ttf,sal_uInt16 firstChar,int nChars,int mode)2650 TTSimpleGlyphMetrics *GetTTSimpleCharMetrics(TrueTypeFont * ttf, sal_uInt16 firstChar, int nChars, int mode)
2651 {
2652 TTSimpleGlyphMetrics *res = 0;
2653 int i, n;
2654
2655 sal_uInt16* str = (sal_uInt16*)malloc(nChars * 2);
2656 assert(str != 0);
2657
2658 for (i=0; i<nChars; i++) str[i] = (sal_uInt16)(firstChar + i);
2659 if ((n = MapString(ttf, str, nChars, 0, mode)) != -1) {
2660 res = GetTTSimpleGlyphMetrics(ttf, str, n, mode);
2661 }
2662
2663 free(str);
2664
2665 return res;
2666 }
2667 #endif
2668
GetTTGlobalFontInfo(TrueTypeFont * ttf,TTGlobalFontInfo * info)2669 void GetTTGlobalFontInfo(TrueTypeFont *ttf, TTGlobalFontInfo *info)
2670 {
2671 int UPEm = ttf->unitsPerEm;
2672
2673 memset(info, 0, sizeof(TTGlobalFontInfo));
2674
2675 info->family = ttf->family;
2676 info->ufamily = ttf->ufamily;
2677 info->subfamily = ttf->subfamily;
2678 info->usubfamily = ttf->usubfamily;
2679 info->psname = ttf->psname;
2680 info->symbolEncoded = (ttf->cmapType == CMAP_MS_Symbol);
2681
2682 const sal_uInt8* table = getTable(ttf, O_OS2);
2683 if (table) {
2684 info->weight = GetUInt16(table, 4, 1);
2685 info->width = GetUInt16(table, 6, 1);
2686
2687 /* There are 3 different versions of OS/2 table: original (68 bytes long),
2688 * Microsoft old (78 bytes long) and Microsoft new (86 bytes long,)
2689 * Apple's documentation recommends looking at the table length.
2690 */
2691 if (getTableSize(ttf, O_OS2) > 68) {
2692 info->typoAscender = XUnits(UPEm,GetInt16(table, 68, 1));
2693 info->typoDescender = XUnits(UPEm, GetInt16(table, 70, 1));
2694 info->typoLineGap = XUnits(UPEm, GetInt16(table, 72, 1));
2695 info->winAscent = XUnits(UPEm, GetUInt16(table, 74, 1));
2696 info->winDescent = XUnits(UPEm, GetUInt16(table, 76, 1));
2697 /* sanity check; some fonts treat winDescent as signed
2698 * violating the standard */
2699 if( info->winDescent > 5*UPEm )
2700 info->winDescent = XUnits(UPEm, GetInt16(table, 76,1));
2701 }
2702 if (ttf->cmapType == CMAP_MS_Unicode) {
2703 info->rangeFlag = 1;
2704 info->ur1 = GetUInt32(table, 42, 1);
2705 info->ur2 = GetUInt32(table, 46, 1);
2706 info->ur3 = GetUInt32(table, 50, 1);
2707 info->ur4 = GetUInt32(table, 54, 1);
2708 }
2709 memcpy(info->panose, table + 32, 10);
2710 info->typeFlags = GetUInt16( table, 8, 1 );
2711 if( getTable(ttf, O_CFF) )
2712 info->typeFlags |= TYPEFLAG_PS_OPENTYPE;
2713 }
2714
2715 table = getTable(ttf, O_post);
2716 if (table && getTableSize(ttf, O_post) >= 12+sizeof(sal_uInt32)) {
2717 info->pitch = GetUInt32(table, 12, 1);
2718 info->italicAngle = GetInt32(table, 4, 1);
2719 }
2720
2721 table = getTable(ttf, O_head); /* 'head' tables is always there */
2722 info->xMin = XUnits(UPEm, GetInt16(table, 36, 1));
2723 info->yMin = XUnits(UPEm, GetInt16(table, 38, 1));
2724 info->xMax = XUnits(UPEm, GetInt16(table, 40, 1));
2725 info->yMax = XUnits(UPEm, GetInt16(table, 42, 1));
2726 info->macStyle = GetInt16(table, 44, 1);
2727
2728 table = getTable(ttf, O_hhea);
2729 if (table) {
2730 info->ascender = XUnits(UPEm, GetInt16(table, 4, 1));
2731 info->descender = XUnits(UPEm, GetInt16(table, 6, 1));
2732 info->linegap = XUnits(UPEm, GetInt16(table, 8, 1));
2733 }
2734
2735 table = getTable(ttf, O_vhea);
2736 if (table) {
2737 info->vascent = XUnits(UPEm, GetInt16(table, 4, 1));
2738 info->vdescent = XUnits(UPEm, GetInt16(table, 6, 1));
2739 }
2740 }
2741
2742 #ifdef TEST5
KernGlyphs(TrueTypeFont * ttf,sal_uInt16 * glyphs,int nglyphs,int wmode,KernData * kern)2743 void KernGlyphs(TrueTypeFont *ttf, sal_uInt16 *glyphs, int nglyphs, int wmode, KernData *kern)
2744 {
2745 int i;
2746
2747 if (!nglyphs || !glyphs || !kern) return;
2748
2749 for (i = 0; i < nglyphs-1; i++) kern[i].x = kern[i].y = 0;
2750
2751 switch (ttf->kerntype) {
2752 case KT_APPLE_NEW: KernGlyphsPrim1(ttf, glyphs, nglyphs, wmode, kern); return;
2753 case KT_MICROSOFT: KernGlyphsPrim2(ttf, glyphs, nglyphs, wmode, kern); return;
2754 default: return;
2755 }
2756 }
2757 #endif
2758
GetTTRawGlyphData(TrueTypeFont * ttf,sal_uInt32 glyphID)2759 GlyphData *GetTTRawGlyphData(TrueTypeFont *ttf, sal_uInt32 glyphID)
2760 {
2761 const sal_uInt8* glyf = getTable(ttf, O_glyf);
2762 const sal_uInt8* hmtx = getTable(ttf, O_hmtx);
2763 int i, n, m;
2764
2765 if( glyphID >= ttf->nglyphs )
2766 return 0;
2767
2768 /* #127161# check the glyph offsets */
2769 sal_uInt32 length = getTableSize( ttf, O_glyf );
2770 if( length < ttf->goffsets[ glyphID+1 ] )
2771 return 0;
2772
2773 length = ttf->goffsets[glyphID+1] - ttf->goffsets[glyphID];
2774
2775 GlyphData* d = (GlyphData*)malloc(sizeof(GlyphData)); assert(d != 0);
2776
2777 if (length > 0) {
2778 const sal_uInt8* srcptr = glyf + ttf->goffsets[glyphID];
2779 d->ptr = (sal_uInt8*)malloc((length + 1) & ~1); assert(d->ptr != 0);
2780 memcpy( d->ptr, srcptr, length );
2781 d->compflag = (GetInt16( srcptr, 0, 1 ) < 0);
2782 } else {
2783 d->ptr = 0;
2784 d->compflag = 0;
2785 }
2786
2787 d->glyphID = glyphID;
2788 d->nbytes = (sal_uInt16)((length + 1) & ~1);
2789
2790 /* now calculate npoints and ncontours */
2791 ControlPoint *cp;
2792 n = GetTTGlyphPoints(ttf, glyphID, &cp);
2793 if( n > 0) {
2794 m = 0;
2795 for (i = 0; i < n; i++) {
2796 if (cp[i].flags & 0x8000) m++;
2797 }
2798 d->npoints = (sal_uInt16)n;
2799 d->ncontours = (sal_uInt16)m;
2800 free(cp);
2801 } else {
2802 d->npoints = 0;
2803 d->ncontours = 0;
2804 }
2805
2806 /* get advance width and left sidebearing */
2807 if (glyphID < ttf->numberOfHMetrics) {
2808 d->aw = GetUInt16(hmtx, 4 * glyphID, 1);
2809 d->lsb = GetInt16(hmtx, 4 * glyphID + 2, 1);
2810 } else {
2811 d->aw = GetUInt16(hmtx, 4 * (ttf->numberOfHMetrics - 1), 1);
2812 d->lsb = GetInt16(hmtx + ttf->numberOfHMetrics * 4, (glyphID - ttf->numberOfHMetrics) * 2, 1);
2813 }
2814
2815 return d;
2816 }
2817
GetTTNameRecords(TrueTypeFont * ttf,NameRecord ** nr)2818 int GetTTNameRecords(TrueTypeFont *ttf, NameRecord **nr)
2819 {
2820 const sal_uInt8* table = getTable(ttf, O_name);
2821 int nTableSize = getTableSize(ttf, O_name );
2822
2823 if (nTableSize < 6)
2824 {
2825 #if OSL_DEBUG_LEVEL > 1
2826 fprintf(stderr, "O_name table too small\n");
2827 #endif
2828 return 0;
2829 }
2830
2831 sal_uInt16 n = GetUInt16(table, 2, 1);
2832 int nStrBase = GetUInt16(table, 4, 1);
2833 int i;
2834
2835 *nr = 0;
2836 if (n == 0) return 0;
2837
2838 NameRecord* rec = (NameRecord*)calloc(n, sizeof(NameRecord));
2839
2840 for (i = 0; i < n; i++) {
2841 int nStrOffset = GetUInt16(table + 6, 10 + 12 * i, 1);
2842 rec[i].platformID = GetUInt16(table + 6, 12 * i, 1);
2843 rec[i].encodingID = GetUInt16(table + 6, 2 + 12 * i, 1);
2844 rec[i].languageID = GetUInt16(table + 6, 4 + 12 * i, 1);
2845 rec[i].nameID = GetUInt16(table + 6, 6 + 12 * i, 1);
2846 rec[i].slen = GetUInt16(table + 6, 8 + 12 * i, 1);
2847 if (rec[i].slen) {
2848 if( nStrBase+nStrOffset+rec[i].slen >= nTableSize ) {
2849 rec[i].sptr = 0;
2850 rec[i].slen = 0;
2851 continue;
2852 }
2853
2854 const sal_uInt8* rec_string = table + nStrBase + nStrOffset;
2855 // sanity check
2856 if( rec_string > (sal_uInt8*)ttf->ptr && rec_string < ((sal_uInt8*)ttf->ptr + ttf->fsize - rec[i].slen ) )
2857 {
2858 rec[i].sptr = (sal_uInt8 *) malloc(rec[i].slen); assert(rec[i].sptr != 0);
2859 memcpy(rec[i].sptr, rec_string, rec[i].slen);
2860 }
2861 else
2862 {
2863 #ifdef DEBUG
2864 fprintf( stderr, "found invalid name record %d with name id %d for file %s\n",
2865 i, rec[i].nameID, ttf->fname );
2866 #endif
2867 rec[i].sptr = 0;
2868 rec[i].slen = 0;
2869 }
2870 } else {
2871 rec[i].sptr = 0;
2872 }
2873 // some fonts have 3.0 names => fix them to 3.1
2874 if( (rec[i].platformID == 3) && (rec[i].encodingID == 0) )
2875 rec[i].encodingID = 1;
2876 }
2877
2878 *nr = rec;
2879 return n;
2880 }
2881
DisposeNameRecords(NameRecord * nr,int n)2882 void DisposeNameRecords(NameRecord* nr, int n)
2883 {
2884 int i;
2885 for (i = 0; i < n; i++) {
2886 if (nr[i].sptr) free(nr[i].sptr);
2887 }
2888 free(nr);
2889 }
2890
2891 } // namespace vcl
2892
2893
2894 #ifdef TEST1
2895 /* This example creates a subset of a TrueType font with two encoded characters */
main(int ac,char ** av)2896 int main(int ac, char **av)
2897 {
2898 TrueTypeFont *fnt;
2899 int r;
2900
2901 /* Array of Unicode source characters */
2902 sal_uInt16 chars[2];
2903
2904 /* Encoding vector maps character encoding to the ordinal number
2905 * of the glyph in the output file */
2906 sal_uInt8 encoding[2];
2907
2908 /* This array is for glyph IDs that source characters map to */
2909 sal_uInt16 g[2];
2910
2911
2912 if (ac < 2) return 0;
2913
2914 if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) {
2915 fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]);
2916 return 0;
2917 }
2918
2919
2920 /* We want to create the output file that only contains two Unicode characters:
2921 * L'a' and L'A' */
2922
2923 chars[0] = L'a';
2924 chars[1] = L'A';
2925
2926 /* Figure out what glyphs do these characters map in our font */
2927 MapString(fnt, chars, 2, g);
2928
2929 /* Encode the characters. Value of encoding[i] is the number 0..255 which maps to glyph i of the
2930 * newly generated font */
2931 encoding[0] = chars[0];
2932 encoding[1] = chars[1];
2933
2934
2935 /* Generate a subset */
2936 CreateT3FromTTGlyphs(fnt, stdout, 0, g, encoding, 2, 0);
2937
2938 /* Now call the dtor for the font */
2939 CloseTTFont(fnt);
2940 return 0;
2941 }
2942 #endif
2943
2944 #ifdef TEST2
2945 /* This example extracts first 224 glyphs from a TT fonts and encodes them starting at 32 */
main(int ac,char ** av)2946 int main(int ac, char **av)
2947 {
2948 TrueTypeFont *fnt;
2949 int i, r;
2950
2951 /* Array of Unicode source characters */
2952 sal_uInt16 glyphs[224];
2953
2954 /* Encoding vector maps character encoding to the ordinal number
2955 * of the glyph in the output file */
2956 sal_uInt8 encoding[224];
2957
2958
2959
2960 for (i=0; i<224; i++) {
2961 glyphs[i] = i;
2962 encoding[i] = 32 + i;
2963 }
2964
2965 if (ac < 2) return 0;
2966
2967 if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) {
2968 fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]);
2969 return 0;
2970 }
2971
2972
2973 /* Encode the characters. Value of encoding[i] is the number 0..255 which maps to glyph i of the
2974 * newly generated font */
2975
2976 /* Generate a subset */
2977 CreateT3FromTTGlyphs(fnt, stdout, 0, glyphs, encoding, 224, 0);
2978
2979 /* Now call the dtor for the font */
2980 CloseTTFont(fnt);
2981 return 0;
2982 }
2983 #endif
2984
2985 #ifdef TEST3
2986 /* Glyph metrics example */
main(int ac,char ** av)2987 int main(int ac, char **av)
2988 {
2989 TrueTypeFont *fnt;
2990 int i, r;
2991 sal_uInt16 glyphs[224];
2992 TTSimpleGlyphMetrics *m;
2993
2994 for (i=0; i<224; i++) {
2995 glyphs[i] = i;
2996 }
2997
2998 if (ac < 2) return 0;
2999
3000 if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) {
3001 fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]);
3002 return 0;
3003 }
3004
3005 if ((m = GetTTSimpleGlyphMetrics(fnt, glyphs, 224, 0)) == 0) {
3006 printf("Requested metrics is not available\n");
3007 } else {
3008 for (i=0; i<224; i++) {
3009 printf("%d. advWid: %5d, LSBear: %5d\n", i, m[i].adv, m[i].sb);
3010 }
3011 }
3012
3013 /* Now call the dtor for the font */
3014 free(m);
3015 CloseTTFont(fnt);
3016 return 0;
3017 }
3018 #endif
3019
3020 #ifdef TEST4
main(int ac,char ** av)3021 int main(int ac, char **av)
3022 {
3023 TrueTypeFont *fnt;
3024 TTGlobalFontInfo info;
3025 int i, r;
3026
3027
3028 if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) {
3029 fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]);
3030 return 0;
3031 }
3032
3033 printf("Font file: %s\n", av[1]);
3034
3035 #ifdef PRINT_KERN
3036 switch (fnt->kerntype) {
3037 case KT_MICROSOFT:
3038 printf("\tkern: MICROSOFT, ntables: %d.", fnt->nkern);
3039 if (fnt->nkern) {
3040 printf(" [");
3041 for (i=0; i<fnt->nkern; i++) {
3042 printf("%04X ", GetUInt16(fnt->kerntables[i], 4, 1));
3043 }
3044 printf("]");
3045 }
3046 printf("\n");
3047 break;
3048
3049 case KT_APPLE_NEW:
3050 printf("\tkern: APPLE_NEW, ntables: %d.", fnt->nkern);
3051 if (fnt->nkern) {
3052 printf(" [");
3053 for (i=0; i<fnt->nkern; i++) {
3054 printf("%04X ", GetUInt16(fnt->kerntables[i], 4, 1));
3055 }
3056 printf("]");
3057 }
3058 printf("\n");
3059 break;
3060
3061 case KT_NONE:
3062 printf("\tkern: none.\n");
3063 break;
3064
3065 default:
3066 printf("\tkern: unrecoginzed.\n");
3067 break;
3068 }
3069 printf("\n");
3070 #endif
3071
3072 GetTTGlobalFontInfo(fnt, &info);
3073 printf("\tfamily name: `%s`\n", info.family);
3074 printf("\tsubfamily name: `%s`\n", info.subfamily);
3075 printf("\tpostscript name: `%s`\n", info.psname);
3076 printf("\tweight: %d\n", info.weight);
3077 printf("\twidth: %d\n", info.width);
3078 printf("\tpitch: %d\n", info.pitch);
3079 printf("\titalic angle: %d\n", info.italicAngle);
3080 printf("\tbouding box: [%d %d %d %d]\n", info.xMin, info.yMin, info.xMax, info.yMax);
3081 printf("\tascender: %d\n", info.ascender);
3082 printf("\tdescender: %d\n", info.descender);
3083 printf("\tlinegap: %d\n", info.linegap);
3084 printf("\tvascent: %d\n", info.vascent);
3085 printf("\tvdescent: %d\n", info.vdescent);
3086 printf("\ttypoAscender: %d\n", info.typoAscender);
3087 printf("\ttypoDescender: %d\n", info.typoDescender);
3088 printf("\ttypoLineGap: %d\n", info.typoLineGap);
3089 printf("\twinAscent: %d\n", info.winAscent);
3090 printf("\twinDescent: %d\n", info.winDescent);
3091 printf("\tUnicode ranges:\n");
3092 for (i = 0; i < 32; i++) {
3093 if ((info.ur1 >> i) & 1) {
3094 printf("\t\t\t%s\n", UnicodeRangeName(i));
3095 }
3096 }
3097 for (i = 0; i < 32; i++) {
3098 if ((info.ur2 >> i) & 1) {
3099 printf("\t\t\t%s\n", UnicodeRangeName(i+32));
3100 }
3101 }
3102 for (i = 0; i < 32; i++) {
3103 if ((info.ur3 >> i) & 1) {
3104 printf("\t\t\t%s\n", UnicodeRangeName(i+64));
3105 }
3106 }
3107 for (i = 0; i < 32; i++) {
3108 if ((info.ur4 >> i) & 1) {
3109 printf("\t\t\t%s\n", UnicodeRangeName(i+96));
3110 }
3111 }
3112
3113 CloseTTFont(fnt);
3114 return 0;
3115 }
3116 #endif
3117
3118 #ifdef TEST5
3119 /* Kerning example */
main(int ac,char ** av)3120 int main(int ac, char **av)
3121 {
3122 TrueTypeFont *fnt;
3123 sal_uInt16 g[224];
3124 KernData d[223];
3125 int r, i, k = 0;
3126
3127 g[k++] = 11;
3128 g[k++] = 36;
3129 g[k++] = 11;
3130 g[k++] = 98;
3131 g[k++] = 11;
3132 g[k++] = 144;
3133 g[k++] = 41;
3134 g[k++] = 171;
3135 g[k++] = 51;
3136 g[k++] = 15;
3137
3138 if (ac < 2) return 0;
3139
3140 if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) {
3141 fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]);
3142 return 0;
3143 }
3144
3145 KernGlyphs(fnt, g, k, 0, d);
3146
3147 for (i = 0; i < k-1; i++) {
3148 printf("%3d %3d: [%3d %3d]\n", g[i], g[i+1], d[i].x, d[i].y);
3149 }
3150
3151 CloseTTFont(fnt);
3152 return 0;
3153 }
3154 #endif
3155
3156
3157
3158 #ifdef TEST6
3159 /* This example extracts a single glyph from a font */
main(int ac,char ** av)3160 int main(int ac, char **av)
3161 {
3162 TrueTypeFont *fnt;
3163 int r, i;
3164
3165 sal_uInt16 glyphs[256];
3166 sal_uInt8 encoding[256];
3167
3168 for (i=0; i<256; i++) {
3169 glyphs[i] = 512 + i;
3170 encoding[i] = i;
3171 }
3172
3173 #if 0
3174 i=0;
3175 glyphs[i++] = 2001;
3176 glyphs[i++] = 2002;
3177 glyphs[i++] = 2003;
3178 glyphs[i++] = 2004;
3179 glyphs[i++] = 2005;
3180 glyphs[i++] = 2006;
3181 glyphs[i++] = 2007;
3182 glyphs[i++] = 2008;
3183 glyphs[i++] = 2009;
3184 glyphs[i++] = 2010;
3185 glyphs[i++] = 2011;
3186 glyphs[i++] = 2012;
3187 glyphs[i++] = 2013;
3188 glyphs[i++] = 2014;
3189 glyphs[i++] = 2015;
3190 glyphs[i++] = 2016;
3191 glyphs[i++] = 2017;
3192 glyphs[i++] = 2018;
3193 glyphs[i++] = 2019;
3194 glyphs[i++] = 2020;
3195
3196
3197 r = 97;
3198 i = 0;
3199 encoding[i++] = r++;
3200 encoding[i++] = r++;
3201 encoding[i++] = r++;
3202 encoding[i++] = r++;
3203 encoding[i++] = r++;
3204 encoding[i++] = r++;
3205 encoding[i++] = r++;
3206 encoding[i++] = r++;
3207 encoding[i++] = r++;
3208 encoding[i++] = r++;
3209 encoding[i++] = r++;
3210 encoding[i++] = r++;
3211 encoding[i++] = r++;
3212 encoding[i++] = r++;
3213 encoding[i++] = r++;
3214 encoding[i++] = r++;
3215 encoding[i++] = r++;
3216 encoding[i++] = r++;
3217 encoding[i++] = r++;
3218 encoding[i++] = r++;
3219 #endif
3220
3221 if (ac < 2) return 0;
3222
3223 if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) {
3224 fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]);
3225 return 0;
3226 }
3227
3228 /* Generate a subset */
3229 CreateT3FromTTGlyphs(fnt, stdout, 0, glyphs, encoding, 256, 0);
3230
3231 fprintf(stderr, "UnitsPerEm: %d.\n", fnt->unitsPerEm);
3232
3233 /* Now call the dtor for the font */
3234 CloseTTFont(fnt);
3235 return 0;
3236 }
3237 #endif
3238
3239 #ifdef TEST7
3240 /* NameRecord extraction example */
main(int ac,char ** av)3241 int main(int ac, char **av)
3242 {
3243 TrueTypeFont *fnt;
3244 int r, i, j, n;
3245 NameRecord *nr;
3246
3247 if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) {
3248 fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]);
3249 return 0;
3250 }
3251
3252 if ((n = GetTTNameRecords(fnt, &nr)) == 0) {
3253 fprintf(stderr, "No name records in the font.\n");
3254 return 0;
3255 }
3256
3257 printf("Number of name records: %d.\n", n);
3258 for (i = 0; i < n; i++) {
3259 printf("%d %d %04X %d [", nr[i].platformID, nr[i].encodingID, nr[i].languageID, nr[i].nameID);
3260 for (j=0; j<nr[i].slen; j++) {
3261 printf("%c", isprint(nr[i].sptr[j]) ? nr[i].sptr[j] : '.');
3262 }
3263 printf("]\n");
3264 }
3265
3266
3267 DisposeNameRecords(nr, n);
3268 CloseTTFont(fnt);
3269 return 0;
3270 }
3271 #endif
3272
3273 #ifdef TEST8
3274 /* TrueType -> TrueType subsetting */
main(int ac,char ** av)3275 int main(int ac, char **av)
3276 {
3277 TrueTypeFont *fnt;
3278 sal_uInt16 glyphArray[] = { 0, 98, 99, 22, 24, 25, 26, 27, 28, 29, 30, 31, 1270, 1289, 34};
3279 sal_uInt8 encoding[] = {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46};
3280 int r;
3281
3282 if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) {
3283 fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]);
3284 return 0;
3285 }
3286
3287 CreateTTFromTTGlyphs(fnt, "subfont.ttf", glyphArray, encoding, 15, 0, 0, TTCF_AutoName | TTCF_IncludeOS2);
3288
3289
3290 CloseTTFont(fnt);
3291
3292 return 0;
3293 }
3294 #endif
3295
3296 #ifdef TEST9
3297 /* TrueType -> Type42 subsetting */
main(int ac,char ** av)3298 int main(int ac, char **av)
3299 {
3300 TrueTypeFont *fnt;
3301 /*
3302 sal_uInt16 glyphArray[] = { 0, 20, 21, 22, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34};
3303 sal_uInt8 encoding[] = {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46};
3304 */
3305 sal_uInt16 glyphArray[] = { 0, 6711, 6724, 11133, 11144, 14360, 26, 27, 28, 29, 30, 31, 1270, 1289, 34};
3306 sal_uInt8 encoding[] = {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46};
3307 int r;
3308
3309 if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) {
3310 fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]);
3311 return 0;
3312 }
3313
3314 CreateT42FromTTGlyphs(fnt, stdout, "testfont", glyphArray, encoding, 15);
3315
3316 CloseTTFont(fnt);
3317
3318 return 0;
3319 }
3320 #endif
3321
3322 #ifdef TEST10
3323 /* Component glyph test */
main(int ac,char ** av)3324 int main(int ac, char **av)
3325 {
3326 TrueTypeFont *fnt;
3327 int r, i;
3328 list glyphlist = listNewEmpty();
3329
3330
3331 if ((r = OpenTTFont(av[1], 0, &fnt)) != SF_OK) {
3332 fprintf(stderr, "Error %d opening font file: `%s`.\n", r, av[1]);
3333 return 0;
3334 }
3335
3336 for (i = 0; i < fnt->nglyphs; i++) {
3337 r = GetTTGlyphComponents(fnt, i, glyphlist);
3338 if (r > 1) {
3339 printf("%d -> ", i);
3340 listToFirst(glyphlist);
3341 do {
3342 printf("%d ", (int) listCurrent(glyphlist));
3343 } while (listNext(glyphlist));
3344 printf("\n");
3345 } else {
3346 printf("%d: single glyph.\n", i);
3347 }
3348 listClear(glyphlist);
3349 }
3350
3351 CloseTTFont(fnt);
3352 listDispose(glyphlist);
3353
3354 return 0;
3355 }
3356 #endif
3357
3358
3359