1 /* 2 * Copyright 2014 Google, Inc. 3 * 4 * This is part of HarfBuzz, a text shaping library. 5 * 6 * Permission is hereby granted, without written agreement and without 7 * license or royalty fees, to use, copy, modify, and distribute this 8 * software and its documentation for any purpose, provided that the 9 * above copyright notice and the following two paragraphs appear in 10 * all copies of this software. 11 * 12 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR 13 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 14 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN 15 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 16 * DAMAGE. 17 * 18 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, 19 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 20 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS 21 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO 22 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 23 * 24 * Google Author(s): Behdad Esfahbod 25 */ 26 27 #ifndef HB_OT_CMAP_TABLE_HH 28 #define HB_OT_CMAP_TABLE_HH 29 30 #include "hb-open-type-private.hh" 31 32 33 namespace OT { 34 35 36 /* 37 * cmap -- Character To Glyph Index Mapping Table 38 */ 39 40 #define HB_OT_TAG_cmap HB_TAG('c','m','a','p') 41 42 43 struct CmapSubtableFormat0 44 { 45 inline bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const 46 { 47 hb_codepoint_t gid = codepoint < 256 ? glyphIdArray[codepoint] : 0; 48 if (!gid) 49 return false; 50 *glyph = gid; 51 return true; 52 } 53 54 inline bool sanitize (hb_sanitize_context_t *c) { 55 TRACE_SANITIZE (this); 56 return TRACE_RETURN (c->check_struct (this)); 57 } 58 59 protected: 60 USHORT format; /* Format number is set to 0. */ 61 USHORT lengthZ; /* Byte length of this subtable. */ 62 USHORT languageZ; /* Ignore. */ 63 BYTE glyphIdArray[256];/* An array that maps character 64 * code to glyph index values. */ 65 public: 66 DEFINE_SIZE_STATIC (6 + 256); 67 }; 68 69 struct CmapSubtableFormat4 70 { 71 inline bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const 72 { 73 unsigned int segCount; 74 const USHORT *endCount; 75 const USHORT *startCount; 76 const USHORT *idDelta; 77 const USHORT *idRangeOffset; 78 const USHORT *glyphIdArray; 79 unsigned int glyphIdArrayLength; 80 81 segCount = this->segCountX2 / 2; 82 endCount = this->values; 83 startCount = endCount + segCount + 1; 84 idDelta = startCount + segCount; 85 idRangeOffset = idDelta + segCount; 86 glyphIdArray = idRangeOffset + segCount; 87 glyphIdArrayLength = (this->length - 16 - 8 * segCount) / 2; 88 89 /* Custom two-array bsearch. */ 90 int min = 0, max = (int) segCount - 1; 91 unsigned int i; 92 while (min <= max) 93 { 94 int mid = (min + max) / 2; 95 if (codepoint < startCount[mid]) 96 max = mid - 1; 97 else if (codepoint > endCount[mid]) 98 min = mid + 1; 99 else 100 { 101 i = mid; 102 goto found; 103 } 104 } 105 return false; 106 107 found: 108 hb_codepoint_t gid; 109 unsigned int rangeOffset = idRangeOffset[i]; 110 if (rangeOffset == 0) 111 gid = codepoint + idDelta[i]; 112 else 113 { 114 /* Somebody has been smoking... */ 115 unsigned int index = rangeOffset / 2 + (codepoint - startCount[i]) + i - segCount; 116 if (unlikely (index >= glyphIdArrayLength)) 117 return false; 118 gid = glyphIdArray[index]; 119 if (unlikely (!gid)) 120 return false; 121 gid += idDelta[i]; 122 } 123 124 *glyph = gid & 0xFFFFu; 125 return true; 126 } 127 128 inline bool sanitize (hb_sanitize_context_t *c) 129 { 130 TRACE_SANITIZE (this); 131 if (unlikely (!c->check_struct (this))) 132 return TRACE_RETURN (false); 133 134 if (unlikely (!c->check_range (this, length))) 135 { 136 /* Some broken fonts have too long of a "length" value. 137 * If that is the case, just change the value to truncate 138 * the subtable at the end of the blob. */ 139 uint16_t new_length = (uint16_t) MIN ((uintptr_t) 65535, 140 (uintptr_t) (c->end - 141 (char *) this)); 142 if (!c->try_set (&length, new_length)) 143 return TRACE_RETURN (false); 144 } 145 146 return TRACE_RETURN (16 + 4 * (unsigned int) segCountX2 <= length); 147 } 148 149 protected: 150 USHORT format; /* Format number is set to 4. */ 151 USHORT length; /* This is the length in bytes of the 152 * subtable. */ 153 USHORT languageZ; /* Ignore. */ 154 USHORT segCountX2; /* 2 x segCount. */ 155 USHORT searchRangeZ; /* 2 * (2**floor(log2(segCount))) */ 156 USHORT entrySelectorZ; /* log2(searchRange/2) */ 157 USHORT rangeShiftZ; /* 2 x segCount - searchRange */ 158 159 USHORT values[VAR]; 160 #if 0 161 USHORT endCount[segCount]; /* End characterCode for each segment, 162 * last=0xFFFFu. */ 163 USHORT reservedPad; /* Set to 0. */ 164 USHORT startCount[segCount]; /* Start character code for each segment. */ 165 SHORT idDelta[segCount]; /* Delta for all character codes in segment. */ 166 USHORT idRangeOffset[segCount];/* Offsets into glyphIdArray or 0 */ 167 USHORT glyphIdArray[VAR]; /* Glyph index array (arbitrary length) */ 168 #endif 169 170 public: 171 DEFINE_SIZE_ARRAY (14, values); 172 }; 173 174 struct CmapSubtableLongGroup 175 { 176 friend struct CmapSubtableFormat12; 177 friend struct CmapSubtableFormat13; 178 179 int cmp (hb_codepoint_t codepoint) const 180 { 181 if (codepoint < startCharCode) return -1; 182 if (codepoint > endCharCode) return +1; 183 return 0; 184 } 185 186 inline bool sanitize (hb_sanitize_context_t *c) { 187 TRACE_SANITIZE (this); 188 return TRACE_RETURN (c->check_struct (this)); 189 } 190 191 private: 192 ULONG startCharCode; /* First character code in this group. */ 193 ULONG endCharCode; /* Last character code in this group. */ 194 ULONG glyphID; /* Glyph index; interpretation depends on 195 * subtable format. */ 196 public: 197 DEFINE_SIZE_STATIC (12); 198 }; 199 200 template <typename UINT> 201 struct CmapSubtableTrimmed 202 { 203 inline bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const 204 { 205 /* Rely on our implicit array bound-checking. */ 206 hb_codepoint_t gid = glyphIdArray[codepoint - startCharCode]; 207 if (!gid) 208 return false; 209 *glyph = gid; 210 return true; 211 } 212 213 inline bool sanitize (hb_sanitize_context_t *c) { 214 TRACE_SANITIZE (this); 215 return TRACE_RETURN (c->check_struct (this) && glyphIdArray.sanitize (c)); 216 } 217 218 protected: 219 UINT formatReserved; /* Subtable format and (maybe) padding. */ 220 UINT lengthZ; /* Byte length of this subtable. */ 221 UINT languageZ; /* Ignore. */ 222 UINT startCharCode; /* First character code covered. */ 223 ArrayOf<GlyphID, UINT> 224 glyphIdArray; /* Array of glyph index values for character 225 * codes in the range. */ 226 public: 227 DEFINE_SIZE_ARRAY (5 * sizeof (UINT), glyphIdArray); 228 }; 229 230 struct CmapSubtableFormat6 : CmapSubtableTrimmed<USHORT> {}; 231 struct CmapSubtableFormat10 : CmapSubtableTrimmed<ULONG > {}; 232 233 template <typename T> 234 struct CmapSubtableLongSegmented 235 { 236 inline bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const 237 { 238 int i = groups.bsearch (codepoint); 239 if (i == -1) 240 return false; 241 *glyph = T::group_get_glyph (groups[i], codepoint); 242 return true; 243 } 244 245 inline bool sanitize (hb_sanitize_context_t *c) { 246 TRACE_SANITIZE (this); 247 return TRACE_RETURN (c->check_struct (this) && groups.sanitize (c)); 248 } 249 250 protected: 251 USHORT format; /* Subtable format; set to 12. */ 252 USHORT reservedZ; /* Reserved; set to 0. */ 253 ULONG lengthZ; /* Byte length of this subtable. */ 254 ULONG languageZ; /* Ignore. */ 255 SortedArrayOf<CmapSubtableLongGroup, ULONG> 256 groups; /* Groupings. */ 257 public: 258 DEFINE_SIZE_ARRAY (16, groups); 259 }; 260 261 struct CmapSubtableFormat12 : CmapSubtableLongSegmented<CmapSubtableFormat12> 262 { 263 static inline hb_codepoint_t group_get_glyph (const CmapSubtableLongGroup &group, 264 hb_codepoint_t u) 265 { return group.glyphID + (u - group.startCharCode); } 266 }; 267 268 struct CmapSubtableFormat13 : CmapSubtableLongSegmented<CmapSubtableFormat13> 269 { 270 static inline hb_codepoint_t group_get_glyph (const CmapSubtableLongGroup &group, 271 hb_codepoint_t u HB_UNUSED) 272 { return group.glyphID; } 273 }; 274 275 typedef enum 276 { 277 GLYPH_VARIANT_NOT_FOUND = 0, 278 GLYPH_VARIANT_FOUND = 1, 279 GLYPH_VARIANT_USE_DEFAULT = 2 280 } glyph_variant_t; 281 282 struct UnicodeValueRange 283 { 284 inline int cmp (const hb_codepoint_t &codepoint) const 285 { 286 if (codepoint < startUnicodeValue) return -1; 287 if (codepoint > startUnicodeValue + additionalCount) return +1; 288 return 0; 289 } 290 291 inline bool sanitize (hb_sanitize_context_t *c) { 292 TRACE_SANITIZE (this); 293 return TRACE_RETURN (c->check_struct (this)); 294 } 295 296 UINT24 startUnicodeValue; /* First value in this range. */ 297 BYTE additionalCount; /* Number of additional values in this 298 * range. */ 299 public: 300 DEFINE_SIZE_STATIC (4); 301 }; 302 303 typedef SortedArrayOf<UnicodeValueRange, ULONG> DefaultUVS; 304 305 struct UVSMapping 306 { 307 inline int cmp (const hb_codepoint_t &codepoint) const 308 { 309 return unicodeValue.cmp (codepoint); 310 } 311 312 inline bool sanitize (hb_sanitize_context_t *c) { 313 TRACE_SANITIZE (this); 314 return TRACE_RETURN (c->check_struct (this)); 315 } 316 317 UINT24 unicodeValue; /* Base Unicode value of the UVS */ 318 GlyphID glyphID; /* Glyph ID of the UVS */ 319 public: 320 DEFINE_SIZE_STATIC (5); 321 }; 322 323 typedef SortedArrayOf<UVSMapping, ULONG> NonDefaultUVS; 324 325 struct VariationSelectorRecord 326 { 327 inline glyph_variant_t get_glyph (hb_codepoint_t codepoint, 328 hb_codepoint_t *glyph, 329 const void *base) const 330 { 331 int i; 332 const DefaultUVS &defaults = base+defaultUVS; 333 i = defaults.bsearch (codepoint); 334 if (i != -1) 335 return GLYPH_VARIANT_USE_DEFAULT; 336 const NonDefaultUVS &nonDefaults = base+nonDefaultUVS; 337 i = nonDefaults.bsearch (codepoint); 338 if (i != -1) 339 { 340 *glyph = nonDefaults[i].glyphID; 341 return GLYPH_VARIANT_FOUND; 342 } 343 return GLYPH_VARIANT_NOT_FOUND; 344 } 345 346 inline int cmp (const hb_codepoint_t &variation_selector) const 347 { 348 return varSelector.cmp (variation_selector); 349 } 350 351 inline bool sanitize (hb_sanitize_context_t *c, void *base) { 352 TRACE_SANITIZE (this); 353 return TRACE_RETURN (c->check_struct (this) && 354 defaultUVS.sanitize (c, base) && 355 nonDefaultUVS.sanitize (c, base)); 356 } 357 358 UINT24 varSelector; /* Variation selector. */ 359 OffsetTo<DefaultUVS, ULONG> 360 defaultUVS; /* Offset to Default UVS Table. May be 0. */ 361 OffsetTo<NonDefaultUVS, ULONG> 362 nonDefaultUVS; /* Offset to Non-Default UVS Table. May be 0. */ 363 public: 364 DEFINE_SIZE_STATIC (11); 365 }; 366 367 struct CmapSubtableFormat14 368 { 369 inline glyph_variant_t get_glyph_variant (hb_codepoint_t codepoint, 370 hb_codepoint_t variation_selector, 371 hb_codepoint_t *glyph) const 372 { 373 return record[record.bsearch(variation_selector)].get_glyph (codepoint, glyph, this); 374 } 375 376 inline bool sanitize (hb_sanitize_context_t *c) { 377 TRACE_SANITIZE (this); 378 return TRACE_RETURN (c->check_struct (this) && 379 record.sanitize (c, this)); 380 } 381 382 protected: 383 USHORT format; /* Format number is set to 0. */ 384 ULONG lengthZ; /* Byte length of this subtable. */ 385 SortedArrayOf<VariationSelectorRecord, ULONG> 386 record; /* Variation selector records; sorted 387 * in increasing order of `varSelector'. */ 388 public: 389 DEFINE_SIZE_ARRAY (10, record); 390 }; 391 392 struct CmapSubtable 393 { 394 /* Note: We intentionally do NOT implement subtable formats 2 and 8. */ 395 396 inline bool get_glyph (hb_codepoint_t codepoint, 397 hb_codepoint_t *glyph) const 398 { 399 switch (u.format) { 400 case 0: return u.format0 .get_glyph(codepoint, glyph); 401 case 4: return u.format4 .get_glyph(codepoint, glyph); 402 case 6: return u.format6 .get_glyph(codepoint, glyph); 403 case 10: return u.format10.get_glyph(codepoint, glyph); 404 case 12: return u.format12.get_glyph(codepoint, glyph); 405 case 13: return u.format13.get_glyph(codepoint, glyph); 406 case 14: 407 default: return false; 408 } 409 } 410 411 inline glyph_variant_t get_glyph_variant (hb_codepoint_t codepoint, 412 hb_codepoint_t variation_selector, 413 hb_codepoint_t *glyph) const 414 { 415 switch (u.format) { 416 case 14: return u.format14.get_glyph_variant(codepoint, variation_selector, glyph); 417 default: return GLYPH_VARIANT_NOT_FOUND; 418 } 419 } 420 421 inline bool sanitize (hb_sanitize_context_t *c) { 422 TRACE_SANITIZE (this); 423 if (!u.format.sanitize (c)) return TRACE_RETURN (false); 424 switch (u.format) { 425 case 0: return TRACE_RETURN (u.format0 .sanitize (c)); 426 case 4: return TRACE_RETURN (u.format4 .sanitize (c)); 427 case 6: return TRACE_RETURN (u.format6 .sanitize (c)); 428 case 10: return TRACE_RETURN (u.format10.sanitize (c)); 429 case 12: return TRACE_RETURN (u.format12.sanitize (c)); 430 case 13: return TRACE_RETURN (u.format13.sanitize (c)); 431 case 14: return TRACE_RETURN (u.format14.sanitize (c)); 432 default:return TRACE_RETURN (true); 433 } 434 } 435 436 protected: 437 union { 438 USHORT format; /* Format identifier */ 439 CmapSubtableFormat0 format0; 440 CmapSubtableFormat4 format4; 441 CmapSubtableFormat6 format6; 442 CmapSubtableFormat10 format10; 443 CmapSubtableFormat12 format12; 444 CmapSubtableFormat13 format13; 445 CmapSubtableFormat14 format14; 446 } u; 447 public: 448 DEFINE_SIZE_UNION (2, format); 449 }; 450 451 452 struct EncodingRecord 453 { 454 inline int cmp (const EncodingRecord &other) const 455 { 456 int ret; 457 ret = platformID.cmp (other.platformID); 458 if (ret) return ret; 459 ret = encodingID.cmp (other.encodingID); 460 if (ret) return ret; 461 return 0; 462 } 463 464 inline bool sanitize (hb_sanitize_context_t *c, void *base) { 465 TRACE_SANITIZE (this); 466 return TRACE_RETURN (c->check_struct (this) && 467 subtable.sanitize (c, base)); 468 } 469 470 USHORT platformID; /* Platform ID. */ 471 USHORT encodingID; /* Platform-specific encoding ID. */ 472 OffsetTo<CmapSubtable, ULONG> 473 subtable; /* Byte offset from beginning of table to the subtable for this encoding. */ 474 public: 475 DEFINE_SIZE_STATIC (8); 476 }; 477 478 struct cmap 479 { 480 static const hb_tag_t tableTag = HB_OT_TAG_cmap; 481 482 inline const CmapSubtable *find_subtable (unsigned int platform_id, 483 unsigned int encoding_id) const 484 { 485 EncodingRecord key; 486 key.platformID.set (platform_id); 487 key.encodingID.set (encoding_id); 488 489 /* Note: We can use bsearch, but since it has no performance 490 * implications, we use lsearch and as such accept fonts with 491 * unsorted subtable list. */ 492 int result = encodingRecord./*bsearch*/lsearch (key); 493 if (result == -1 || !encodingRecord[result].subtable) 494 return NULL; 495 496 return &(this+encodingRecord[result].subtable); 497 } 498 499 inline bool sanitize (hb_sanitize_context_t *c) { 500 TRACE_SANITIZE (this); 501 return TRACE_RETURN (c->check_struct (this) && 502 likely (version == 0) && 503 encodingRecord.sanitize (c, this)); 504 } 505 506 USHORT version; /* Table version number (0). */ 507 SortedArrayOf<EncodingRecord> 508 encodingRecord; /* Encoding tables. */ 509 public: 510 DEFINE_SIZE_ARRAY (4, encodingRecord); 511 }; 512 513 514 } /* namespace OT */ 515 516 517 #endif /* HB_OT_CMAP_TABLE_HH */ 518
