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