1 /* 2 * Copyright © 2007,2008,2009 Red Hat, Inc. 3 * Copyright © 2012 Google, Inc. 4 * 5 * This is part of HarfBuzz, a text shaping library. 6 * 7 * Permission is hereby granted, without written agreement and without 8 * license or royalty fees, to use, copy, modify, and distribute this 9 * software and its documentation for any purpose, provided that the 10 * above copyright notice and the following two paragraphs appear in 11 * all copies of this software. 12 * 13 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR 14 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 15 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN 16 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 17 * DAMAGE. 18 * 19 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, 20 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 21 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS 22 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO 23 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 24 * 25 * Red Hat Author(s): Behdad Esfahbod 26 * Google Author(s): Behdad Esfahbod 27 */ 28 29 #ifndef HB_OPEN_FILE_PRIVATE_HH 30 #define HB_OPEN_FILE_PRIVATE_HH 31 32 #include "hb-open-type-private.hh" 33 #include "hb-ot-head-table.hh" 34 35 36 namespace OT { 37 38 39 /* 40 * 41 * The OpenType Font File 42 * 43 */ 44 45 46 /* 47 * Organization of an OpenType Font 48 */ 49 50 struct OpenTypeFontFile; 51 struct OffsetTable; 52 struct TTCHeader; 53 54 55 typedef struct TableRecord 56 { 57 int cmp (Tag t) const 58 { return -t.cmp (tag); } 59 60 static int cmp (const void *pa, const void *pb) 61 { 62 const TableRecord *a = (const TableRecord *) pa; 63 const TableRecord *b = (const TableRecord *) pb; 64 return b->cmp (a->tag); 65 } 66 67 inline bool sanitize (hb_sanitize_context_t *c) const 68 { 69 TRACE_SANITIZE (this); 70 return_trace (c->check_struct (this)); 71 } 72 73 Tag tag; /* 4-byte identifier. */ 74 CheckSum checkSum; /* CheckSum for this table. */ 75 Offset32 offset; /* Offset from beginning of TrueType font 76 * file. */ 77 HBUINT32 length; /* Length of this table. */ 78 public: 79 DEFINE_SIZE_STATIC (16); 80 } OpenTypeTable; 81 82 typedef struct OffsetTable 83 { 84 friend struct OpenTypeFontFile; 85 86 inline unsigned int get_table_count (void) const 87 { return tables.len; } 88 inline const TableRecord& get_table (unsigned int i) const 89 { 90 return tables[i]; 91 } 92 inline unsigned int get_table_tags (unsigned int start_offset, 93 unsigned int *table_count, /* IN/OUT */ 94 hb_tag_t *table_tags /* OUT */) const 95 { 96 if (table_count) 97 { 98 if (start_offset >= tables.len) 99 *table_count = 0; 100 else 101 *table_count = MIN<unsigned int> (*table_count, tables.len - start_offset); 102 103 const TableRecord *sub_tables = tables.arrayZ + start_offset; 104 unsigned int count = *table_count; 105 for (unsigned int i = 0; i < count; i++) 106 table_tags[i] = sub_tables[i].tag; 107 } 108 return tables.len; 109 } 110 inline bool find_table_index (hb_tag_t tag, unsigned int *table_index) const 111 { 112 Tag t; 113 t.set (tag); 114 /* Linear-search for small tables to work around fonts with unsorted 115 * table list. */ 116 int i = tables.len < 64 ? tables.lsearch (t) : tables.bsearch (t); 117 if (table_index) 118 *table_index = i == -1 ? Index::NOT_FOUND_INDEX : (unsigned int) i; 119 return i != -1; 120 } 121 inline const TableRecord& get_table_by_tag (hb_tag_t tag) const 122 { 123 unsigned int table_index; 124 find_table_index (tag, &table_index); 125 return get_table (table_index); 126 } 127 128 public: 129 130 inline bool serialize (hb_serialize_context_t *c, 131 hb_tag_t sfnt_tag, 132 Supplier<hb_tag_t> &tags, 133 Supplier<hb_blob_t *> &blobs, 134 unsigned int table_count) 135 { 136 TRACE_SERIALIZE (this); 137 /* Alloc 12 for the OTHeader. */ 138 if (unlikely (!c->extend_min (*this))) return_trace (false); 139 /* Write sfntVersion (bytes 0..3). */ 140 sfnt_version.set (sfnt_tag); 141 /* Take space for numTables, searchRange, entrySelector, RangeShift 142 * and the TableRecords themselves. */ 143 if (unlikely (!tables.serialize (c, table_count))) return_trace (false); 144 145 const char *dir_end = (const char *) c->head; 146 HBUINT32 *checksum_adjustment = nullptr; 147 148 /* Write OffsetTables, alloc for and write actual table blobs. */ 149 for (unsigned int i = 0; i < table_count; i++) 150 { 151 TableRecord &rec = tables.arrayZ[i]; 152 hb_blob_t *blob = blobs[i]; 153 rec.tag.set (tags[i]); 154 rec.length.set (hb_blob_get_length (blob)); 155 rec.offset.serialize (c, this); 156 157 /* Allocate room for the table and copy it. */ 158 char *start = (char *) c->allocate_size<void> (rec.length); 159 if (unlikely (!start)) {return false;} 160 161 memcpy (start, hb_blob_get_data (blob, nullptr), rec.length); 162 163 /* 4-byte allignment. */ 164 if (rec.length % 4) 165 c->allocate_size<void> (4 - rec.length % 4); 166 const char *end = (const char *) c->head; 167 168 if (tags[i] == HB_OT_TAG_head && end - start >= head::static_size) 169 { 170 head *h = (head *) start; 171 checksum_adjustment = &h->checkSumAdjustment; 172 checksum_adjustment->set (0); 173 } 174 175 rec.checkSum.set_for_data (start, end - start); 176 } 177 tags += table_count; 178 blobs += table_count; 179 180 tables.qsort (); 181 182 if (checksum_adjustment) 183 { 184 CheckSum checksum; 185 186 /* The following line is a slower version of the following block. */ 187 //checksum.set_for_data (this, (const char *) c->head - (const char *) this); 188 checksum.set_for_data (this, dir_end - (const char *) this); 189 for (unsigned int i = 0; i < table_count; i++) 190 { 191 TableRecord &rec = tables.arrayZ[i]; 192 checksum.set (checksum + rec.checkSum); 193 } 194 195 checksum_adjustment->set (0xB1B0AFBAu - checksum); 196 } 197 198 return_trace (true); 199 } 200 201 inline bool sanitize (hb_sanitize_context_t *c) const 202 { 203 TRACE_SANITIZE (this); 204 return_trace (c->check_struct (this) && tables.sanitize (c)); 205 } 206 207 protected: 208 Tag sfnt_version; /* '\0\001\0\00' if TrueType / 'OTTO' if CFF */ 209 BinSearchArrayOf<TableRecord> 210 tables; 211 public: 212 DEFINE_SIZE_ARRAY (12, tables); 213 } OpenTypeFontFace; 214 215 216 /* 217 * TrueType Collections 218 */ 219 220 struct TTCHeaderVersion1 221 { 222 friend struct TTCHeader; 223 224 inline unsigned int get_face_count (void) const { return table.len; } 225 inline const OpenTypeFontFace& get_face (unsigned int i) const { return this+table[i]; } 226 227 inline bool sanitize (hb_sanitize_context_t *c) const 228 { 229 TRACE_SANITIZE (this); 230 return_trace (table.sanitize (c, this)); 231 } 232 233 protected: 234 Tag ttcTag; /* TrueType Collection ID string: 'ttcf' */ 235 FixedVersion<>version; /* Version of the TTC Header (1.0), 236 * 0x00010000u */ 237 LArrayOf<LOffsetTo<OffsetTable> > 238 table; /* Array of offsets to the OffsetTable for each font 239 * from the beginning of the file */ 240 public: 241 DEFINE_SIZE_ARRAY (12, table); 242 }; 243 244 struct TTCHeader 245 { 246 friend struct OpenTypeFontFile; 247 248 private: 249 250 inline unsigned int get_face_count (void) const 251 { 252 switch (u.header.version.major) { 253 case 2: /* version 2 is compatible with version 1 */ 254 case 1: return u.version1.get_face_count (); 255 default:return 0; 256 } 257 } 258 inline const OpenTypeFontFace& get_face (unsigned int i) const 259 { 260 switch (u.header.version.major) { 261 case 2: /* version 2 is compatible with version 1 */ 262 case 1: return u.version1.get_face (i); 263 default:return Null(OpenTypeFontFace); 264 } 265 } 266 267 inline bool sanitize (hb_sanitize_context_t *c) const 268 { 269 TRACE_SANITIZE (this); 270 if (unlikely (!u.header.version.sanitize (c))) return_trace (false); 271 switch (u.header.version.major) { 272 case 2: /* version 2 is compatible with version 1 */ 273 case 1: return_trace (u.version1.sanitize (c)); 274 default:return_trace (true); 275 } 276 } 277 278 protected: 279 union { 280 struct { 281 Tag ttcTag; /* TrueType Collection ID string: 'ttcf' */ 282 FixedVersion<>version; /* Version of the TTC Header (1.0 or 2.0), 283 * 0x00010000u or 0x00020000u */ 284 } header; 285 TTCHeaderVersion1 version1; 286 } u; 287 }; 288 289 290 /* 291 * OpenType Font File 292 */ 293 294 struct OpenTypeFontFile 295 { 296 static const hb_tag_t tableTag = HB_TAG ('_','_','_','_'); /* Sanitizer needs this. */ 297 298 enum { 299 CFFTag = HB_TAG ('O','T','T','O'), /* OpenType with Postscript outlines */ 300 TrueTypeTag = HB_TAG ( 0 , 1 , 0 , 0 ), /* OpenType with TrueType outlines */ 301 TTCTag = HB_TAG ('t','t','c','f'), /* TrueType Collection */ 302 TrueTag = HB_TAG ('t','r','u','e'), /* Obsolete Apple TrueType */ 303 Typ1Tag = HB_TAG ('t','y','p','1') /* Obsolete Apple Type1 font in SFNT container */ 304 }; 305 306 inline hb_tag_t get_tag (void) const { return u.tag; } 307 308 inline unsigned int get_face_count (void) const 309 { 310 switch (u.tag) { 311 case CFFTag: /* All the non-collection tags */ 312 case TrueTag: 313 case Typ1Tag: 314 case TrueTypeTag: return 1; 315 case TTCTag: return u.ttcHeader.get_face_count (); 316 default: return 0; 317 } 318 } 319 inline const OpenTypeFontFace& get_face (unsigned int i) const 320 { 321 switch (u.tag) { 322 /* Note: for non-collection SFNT data we ignore index. This is because 323 * Apple dfont container is a container of SFNT's. So each SFNT is a 324 * non-TTC, but the index is more than zero. */ 325 case CFFTag: /* All the non-collection tags */ 326 case TrueTag: 327 case Typ1Tag: 328 case TrueTypeTag: return u.fontFace; 329 case TTCTag: return u.ttcHeader.get_face (i); 330 default: return Null(OpenTypeFontFace); 331 } 332 } 333 334 inline bool serialize_single (hb_serialize_context_t *c, 335 hb_tag_t sfnt_tag, 336 Supplier<hb_tag_t> &tags, 337 Supplier<hb_blob_t *> &blobs, 338 unsigned int table_count) 339 { 340 TRACE_SERIALIZE (this); 341 assert (sfnt_tag != TTCTag); 342 if (unlikely (!c->extend_min (*this))) return_trace (false); 343 return_trace (u.fontFace.serialize (c, sfnt_tag, tags, blobs, table_count)); 344 } 345 346 inline bool sanitize (hb_sanitize_context_t *c) const 347 { 348 TRACE_SANITIZE (this); 349 if (unlikely (!u.tag.sanitize (c))) return_trace (false); 350 switch (u.tag) { 351 case CFFTag: /* All the non-collection tags */ 352 case TrueTag: 353 case Typ1Tag: 354 case TrueTypeTag: return_trace (u.fontFace.sanitize (c)); 355 case TTCTag: return_trace (u.ttcHeader.sanitize (c)); 356 default: return_trace (true); 357 } 358 } 359 360 protected: 361 union { 362 Tag tag; /* 4-byte identifier. */ 363 OpenTypeFontFace fontFace; 364 TTCHeader ttcHeader; 365 } u; 366 public: 367 DEFINE_SIZE_UNION (4, tag); 368 }; 369 370 371 } /* namespace OT */ 372 373 374 #endif /* HB_OPEN_FILE_PRIVATE_HH */