1 /* 2 * Copyright © 2007,2008,2009 Red Hat, Inc. 3 * Copyright © 2010,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_OT_LAYOUT_COMMON_PRIVATE_HH 30 #define HB_OT_LAYOUT_COMMON_PRIVATE_HH 31 32 #include "hb-private.hh" 33 #include "hb-debug.hh" 34 #include "hb-ot-layout-private.hh" 35 #include "hb-open-type-private.hh" 36 #include "hb-set-private.hh" 37 38 39 #ifndef HB_MAX_NESTING_LEVEL 40 #define HB_MAX_NESTING_LEVEL 6 41 #endif 42 #ifndef HB_MAX_CONTEXT_LENGTH 43 #define HB_MAX_CONTEXT_LENGTH 64 44 #endif 45 46 47 namespace OT { 48 49 50 #define NOT_COVERED ((unsigned int) -1) 51 52 53 54 /* 55 * 56 * OpenType Layout Common Table Formats 57 * 58 */ 59 60 61 /* 62 * Script, ScriptList, LangSys, Feature, FeatureList, Lookup, LookupList 63 */ 64 65 template <typename Type> 66 struct Record 67 { 68 inline int cmp (hb_tag_t a) const { 69 return tag.cmp (a); 70 } 71 72 struct sanitize_closure_t { 73 hb_tag_t tag; 74 const void *list_base; 75 }; 76 inline bool sanitize (hb_sanitize_context_t *c, const void *base) const 77 { 78 TRACE_SANITIZE (this); 79 const sanitize_closure_t closure = {tag, base}; 80 return_trace (c->check_struct (this) && offset.sanitize (c, base, &closure)); 81 } 82 83 Tag tag; /* 4-byte Tag identifier */ 84 OffsetTo<Type> 85 offset; /* Offset from beginning of object holding 86 * the Record */ 87 public: 88 DEFINE_SIZE_STATIC (6); 89 }; 90 91 template <typename Type> 92 struct RecordArrayOf : SortedArrayOf<Record<Type> > { 93 inline const Tag& get_tag (unsigned int i) const 94 { 95 /* We cheat slightly and don't define separate Null objects 96 * for Record types. Instead, we return the correct Null(Tag) 97 * here. */ 98 if (unlikely (i >= this->len)) return Null(Tag); 99 return (*this)[i].tag; 100 } 101 inline unsigned int get_tags (unsigned int start_offset, 102 unsigned int *record_count /* IN/OUT */, 103 hb_tag_t *record_tags /* OUT */) const 104 { 105 if (record_count) { 106 const Record<Type> *arr = this->sub_array (start_offset, record_count); 107 unsigned int count = *record_count; 108 for (unsigned int i = 0; i < count; i++) 109 record_tags[i] = arr[i].tag; 110 } 111 return this->len; 112 } 113 inline bool find_index (hb_tag_t tag, unsigned int *index) const 114 { 115 /* If we want to allow non-sorted data, we can lsearch(). */ 116 int i = this->/*lsearch*/bsearch (tag); 117 if (i != -1) { 118 if (index) *index = i; 119 return true; 120 } else { 121 if (index) *index = Index::NOT_FOUND_INDEX; 122 return false; 123 } 124 } 125 }; 126 127 template <typename Type> 128 struct RecordListOf : RecordArrayOf<Type> 129 { 130 inline const Type& operator [] (unsigned int i) const 131 { return this+RecordArrayOf<Type>::operator [](i).offset; } 132 133 inline bool sanitize (hb_sanitize_context_t *c) const 134 { 135 TRACE_SANITIZE (this); 136 return_trace (RecordArrayOf<Type>::sanitize (c, this)); 137 } 138 }; 139 140 141 struct RangeRecord 142 { 143 inline int cmp (hb_codepoint_t g) const { 144 return g < start ? -1 : g <= end ? 0 : +1 ; 145 } 146 147 inline bool sanitize (hb_sanitize_context_t *c) const 148 { 149 TRACE_SANITIZE (this); 150 return_trace (c->check_struct (this)); 151 } 152 153 inline bool intersects (const hb_set_t *glyphs) const { 154 return glyphs->intersects (start, end); 155 } 156 157 template <typename set_t> 158 inline void add_coverage (set_t *glyphs) const { 159 glyphs->add_range (start, end); 160 } 161 162 GlyphID start; /* First GlyphID in the range */ 163 GlyphID end; /* Last GlyphID in the range */ 164 USHORT value; /* Value */ 165 public: 166 DEFINE_SIZE_STATIC (6); 167 }; 168 DEFINE_NULL_DATA (RangeRecord, "\000\001"); 169 170 171 struct IndexArray : ArrayOf<Index> 172 { 173 inline unsigned int get_indexes (unsigned int start_offset, 174 unsigned int *_count /* IN/OUT */, 175 unsigned int *_indexes /* OUT */) const 176 { 177 if (_count) { 178 const USHORT *arr = this->sub_array (start_offset, _count); 179 unsigned int count = *_count; 180 for (unsigned int i = 0; i < count; i++) 181 _indexes[i] = arr[i]; 182 } 183 return this->len; 184 } 185 }; 186 187 188 struct Script; 189 struct LangSys; 190 struct Feature; 191 192 193 struct LangSys 194 { 195 inline unsigned int get_feature_count (void) const 196 { return featureIndex.len; } 197 inline hb_tag_t get_feature_index (unsigned int i) const 198 { return featureIndex[i]; } 199 inline unsigned int get_feature_indexes (unsigned int start_offset, 200 unsigned int *feature_count /* IN/OUT */, 201 unsigned int *feature_indexes /* OUT */) const 202 { return featureIndex.get_indexes (start_offset, feature_count, feature_indexes); } 203 204 inline bool has_required_feature (void) const { return reqFeatureIndex != 0xFFFFu; } 205 inline unsigned int get_required_feature_index (void) const 206 { 207 if (reqFeatureIndex == 0xFFFFu) 208 return Index::NOT_FOUND_INDEX; 209 return reqFeatureIndex;; 210 } 211 212 inline bool sanitize (hb_sanitize_context_t *c, 213 const Record<LangSys>::sanitize_closure_t * = nullptr) const 214 { 215 TRACE_SANITIZE (this); 216 return_trace (c->check_struct (this) && featureIndex.sanitize (c)); 217 } 218 219 Offset<> lookupOrderZ; /* = Null (reserved for an offset to a 220 * reordering table) */ 221 USHORT reqFeatureIndex;/* Index of a feature required for this 222 * language system--if no required features 223 * = 0xFFFFu */ 224 IndexArray featureIndex; /* Array of indices into the FeatureList */ 225 public: 226 DEFINE_SIZE_ARRAY (6, featureIndex); 227 }; 228 DEFINE_NULL_DATA (LangSys, "\0\0\xFF\xFF"); 229 230 231 struct Script 232 { 233 inline unsigned int get_lang_sys_count (void) const 234 { return langSys.len; } 235 inline const Tag& get_lang_sys_tag (unsigned int i) const 236 { return langSys.get_tag (i); } 237 inline unsigned int get_lang_sys_tags (unsigned int start_offset, 238 unsigned int *lang_sys_count /* IN/OUT */, 239 hb_tag_t *lang_sys_tags /* OUT */) const 240 { return langSys.get_tags (start_offset, lang_sys_count, lang_sys_tags); } 241 inline const LangSys& get_lang_sys (unsigned int i) const 242 { 243 if (i == Index::NOT_FOUND_INDEX) return get_default_lang_sys (); 244 return this+langSys[i].offset; 245 } 246 inline bool find_lang_sys_index (hb_tag_t tag, unsigned int *index) const 247 { return langSys.find_index (tag, index); } 248 249 inline bool has_default_lang_sys (void) const { return defaultLangSys != 0; } 250 inline const LangSys& get_default_lang_sys (void) const { return this+defaultLangSys; } 251 252 inline bool sanitize (hb_sanitize_context_t *c, 253 const Record<Script>::sanitize_closure_t * = nullptr) const 254 { 255 TRACE_SANITIZE (this); 256 return_trace (defaultLangSys.sanitize (c, this) && langSys.sanitize (c, this)); 257 } 258 259 protected: 260 OffsetTo<LangSys> 261 defaultLangSys; /* Offset to DefaultLangSys table--from 262 * beginning of Script table--may be Null */ 263 RecordArrayOf<LangSys> 264 langSys; /* Array of LangSysRecords--listed 265 * alphabetically by LangSysTag */ 266 public: 267 DEFINE_SIZE_ARRAY (4, langSys); 268 }; 269 270 typedef RecordListOf<Script> ScriptList; 271 272 273 /* http://www.microsoft.com/typography/otspec/features_pt.htm#size */ 274 struct FeatureParamsSize 275 { 276 inline bool sanitize (hb_sanitize_context_t *c) const 277 { 278 TRACE_SANITIZE (this); 279 if (unlikely (!c->check_struct (this))) return_trace (false); 280 281 /* This subtable has some "history", if you will. Some earlier versions of 282 * Adobe tools calculated the offset of the FeatureParams sutable from the 283 * beginning of the FeatureList table! Now, that is dealt with in the 284 * Feature implementation. But we still need to be able to tell junk from 285 * real data. Note: We don't check that the nameID actually exists. 286 * 287 * Read Roberts wrote on 9/15/06 on opentype-list@indx.co.uk : 288 * 289 * Yes, it is correct that a new version of the AFDKO (version 2.0) will be 290 * coming out soon, and that the makeotf program will build a font with a 291 * 'size' feature that is correct by the specification. 292 * 293 * The specification for this feature tag is in the "OpenType Layout Tag 294 * Registry". You can see a copy of this at: 295 * http://partners.adobe.com/public/developer/opentype/index_tag8.html#size 296 * 297 * Here is one set of rules to determine if the 'size' feature is built 298 * correctly, or as by the older versions of MakeOTF. You may be able to do 299 * better. 300 * 301 * Assume that the offset to the size feature is according to specification, 302 * and make the following value checks. If it fails, assume the the size 303 * feature is calculated as versions of MakeOTF before the AFDKO 2.0 built it. 304 * If this fails, reject the 'size' feature. The older makeOTF's calculated the 305 * offset from the beginning of the FeatureList table, rather than from the 306 * beginning of the 'size' Feature table. 307 * 308 * If "design size" == 0: 309 * fails check 310 * 311 * Else if ("subfamily identifier" == 0 and 312 * "range start" == 0 and 313 * "range end" == 0 and 314 * "range start" == 0 and 315 * "menu name ID" == 0) 316 * passes check: this is the format used when there is a design size 317 * specified, but there is no recommended size range. 318 * 319 * Else if ("design size" < "range start" or 320 * "design size" > "range end" or 321 * "range end" <= "range start" or 322 * "menu name ID" < 256 or 323 * "menu name ID" > 32767 or 324 * menu name ID is not a name ID which is actually in the name table) 325 * fails test 326 * Else 327 * passes test. 328 */ 329 330 if (!designSize) 331 return_trace (false); 332 else if (subfamilyID == 0 && 333 subfamilyNameID == 0 && 334 rangeStart == 0 && 335 rangeEnd == 0) 336 return_trace (true); 337 else if (designSize < rangeStart || 338 designSize > rangeEnd || 339 subfamilyNameID < 256 || 340 subfamilyNameID > 32767) 341 return_trace (false); 342 else 343 return_trace (true); 344 } 345 346 USHORT designSize; /* Represents the design size in 720/inch 347 * units (decipoints). The design size entry 348 * must be non-zero. When there is a design 349 * size but no recommended size range, the 350 * rest of the array will consist of zeros. */ 351 USHORT subfamilyID; /* Has no independent meaning, but serves 352 * as an identifier that associates fonts 353 * in a subfamily. All fonts which share a 354 * Preferred or Font Family name and which 355 * differ only by size range shall have the 356 * same subfamily value, and no fonts which 357 * differ in weight or style shall have the 358 * same subfamily value. If this value is 359 * zero, the remaining fields in the array 360 * will be ignored. */ 361 USHORT subfamilyNameID;/* If the preceding value is non-zero, this 362 * value must be set in the range 256 - 32767 363 * (inclusive). It records the value of a 364 * field in the name table, which must 365 * contain English-language strings encoded 366 * in Windows Unicode and Macintosh Roman, 367 * and may contain additional strings 368 * localized to other scripts and languages. 369 * Each of these strings is the name an 370 * application should use, in combination 371 * with the family name, to represent the 372 * subfamily in a menu. Applications will 373 * choose the appropriate version based on 374 * their selection criteria. */ 375 USHORT rangeStart; /* Large end of the recommended usage range 376 * (inclusive), stored in 720/inch units 377 * (decipoints). */ 378 USHORT rangeEnd; /* Small end of the recommended usage range 379 (exclusive), stored in 720/inch units 380 * (decipoints). */ 381 public: 382 DEFINE_SIZE_STATIC (10); 383 }; 384 385 /* http://www.microsoft.com/typography/otspec/features_pt.htm#ssxx */ 386 struct FeatureParamsStylisticSet 387 { 388 inline bool sanitize (hb_sanitize_context_t *c) const 389 { 390 TRACE_SANITIZE (this); 391 /* Right now minorVersion is at zero. Which means, any table supports 392 * the uiNameID field. */ 393 return_trace (c->check_struct (this)); 394 } 395 396 USHORT version; /* (set to 0): This corresponds to a “minor” 397 * version number. Additional data may be 398 * added to the end of this Feature Parameters 399 * table in the future. */ 400 401 USHORT uiNameID; /* The 'name' table name ID that specifies a 402 * string (or strings, for multiple languages) 403 * for a user-interface label for this 404 * feature. The values of uiLabelNameId and 405 * sampleTextNameId are expected to be in the 406 * font-specific name ID range (256-32767), 407 * though that is not a requirement in this 408 * Feature Parameters specification. The 409 * user-interface label for the feature can 410 * be provided in multiple languages. An 411 * English string should be included as a 412 * fallback. The string should be kept to a 413 * minimal length to fit comfortably with 414 * different application interfaces. */ 415 public: 416 DEFINE_SIZE_STATIC (4); 417 }; 418 419 /* http://www.microsoft.com/typography/otspec/features_ae.htm#cv01-cv99 */ 420 struct FeatureParamsCharacterVariants 421 { 422 inline bool sanitize (hb_sanitize_context_t *c) const 423 { 424 TRACE_SANITIZE (this); 425 return_trace (c->check_struct (this) && 426 characters.sanitize (c)); 427 } 428 429 USHORT format; /* Format number is set to 0. */ 430 USHORT featUILableNameID; /* The ‘name’ table name ID that 431 * specifies a string (or strings, 432 * for multiple languages) for a 433 * user-interface label for this 434 * feature. (May be nullptr.) */ 435 USHORT featUITooltipTextNameID;/* The ‘name’ table name ID that 436 * specifies a string (or strings, 437 * for multiple languages) that an 438 * application can use for tooltip 439 * text for this feature. (May be 440 * nullptr.) */ 441 USHORT sampleTextNameID; /* The ‘name’ table name ID that 442 * specifies sample text that 443 * illustrates the effect of this 444 * feature. (May be nullptr.) */ 445 USHORT numNamedParameters; /* Number of named parameters. (May 446 * be zero.) */ 447 USHORT firstParamUILabelNameID;/* The first ‘name’ table name ID 448 * used to specify strings for 449 * user-interface labels for the 450 * feature parameters. (Must be zero 451 * if numParameters is zero.) */ 452 ArrayOf<UINT24> 453 characters; /* Array of the Unicode Scalar Value 454 * of the characters for which this 455 * feature provides glyph variants. 456 * (May be zero.) */ 457 public: 458 DEFINE_SIZE_ARRAY (14, characters); 459 }; 460 461 struct FeatureParams 462 { 463 inline bool sanitize (hb_sanitize_context_t *c, hb_tag_t tag) const 464 { 465 TRACE_SANITIZE (this); 466 if (tag == HB_TAG ('s','i','z','e')) 467 return_trace (u.size.sanitize (c)); 468 if ((tag & 0xFFFF0000u) == HB_TAG ('s','s','\0','\0')) /* ssXX */ 469 return_trace (u.stylisticSet.sanitize (c)); 470 if ((tag & 0xFFFF0000u) == HB_TAG ('c','v','\0','\0')) /* cvXX */ 471 return_trace (u.characterVariants.sanitize (c)); 472 return_trace (true); 473 } 474 475 inline const FeatureParamsSize& get_size_params (hb_tag_t tag) const 476 { 477 if (tag == HB_TAG ('s','i','z','e')) 478 return u.size; 479 return Null(FeatureParamsSize); 480 } 481 482 private: 483 union { 484 FeatureParamsSize size; 485 FeatureParamsStylisticSet stylisticSet; 486 FeatureParamsCharacterVariants characterVariants; 487 } u; 488 DEFINE_SIZE_STATIC (17); 489 }; 490 491 struct Feature 492 { 493 inline unsigned int get_lookup_count (void) const 494 { return lookupIndex.len; } 495 inline hb_tag_t get_lookup_index (unsigned int i) const 496 { return lookupIndex[i]; } 497 inline unsigned int get_lookup_indexes (unsigned int start_index, 498 unsigned int *lookup_count /* IN/OUT */, 499 unsigned int *lookup_tags /* OUT */) const 500 { return lookupIndex.get_indexes (start_index, lookup_count, lookup_tags); } 501 502 inline const FeatureParams &get_feature_params (void) const 503 { return this+featureParams; } 504 505 inline bool sanitize (hb_sanitize_context_t *c, 506 const Record<Feature>::sanitize_closure_t *closure = nullptr) const 507 { 508 TRACE_SANITIZE (this); 509 if (unlikely (!(c->check_struct (this) && lookupIndex.sanitize (c)))) 510 return_trace (false); 511 512 /* Some earlier versions of Adobe tools calculated the offset of the 513 * FeatureParams subtable from the beginning of the FeatureList table! 514 * 515 * If sanitizing "failed" for the FeatureParams subtable, try it with the 516 * alternative location. We would know sanitize "failed" if old value 517 * of the offset was non-zero, but it's zeroed now. 518 * 519 * Only do this for the 'size' feature, since at the time of the faulty 520 * Adobe tools, only the 'size' feature had FeatureParams defined. 521 */ 522 523 OffsetTo<FeatureParams> orig_offset = featureParams; 524 if (unlikely (!featureParams.sanitize (c, this, closure ? closure->tag : HB_TAG_NONE))) 525 return_trace (false); 526 527 if (likely (orig_offset.is_null ())) 528 return_trace (true); 529 530 if (featureParams == 0 && closure && 531 closure->tag == HB_TAG ('s','i','z','e') && 532 closure->list_base && closure->list_base < this) 533 { 534 unsigned int new_offset_int = (unsigned int) orig_offset - 535 (((char *) this) - ((char *) closure->list_base)); 536 537 OffsetTo<FeatureParams> new_offset; 538 /* Check that it did not overflow. */ 539 new_offset.set (new_offset_int); 540 if (new_offset == new_offset_int && 541 c->try_set (&featureParams, new_offset) && 542 !featureParams.sanitize (c, this, closure ? closure->tag : HB_TAG_NONE)) 543 return_trace (false); 544 545 if (c->edit_count > 1) 546 c->edit_count--; /* This was a "legitimate" edit; don't contribute to error count. */ 547 } 548 549 return_trace (true); 550 } 551 552 OffsetTo<FeatureParams> 553 featureParams; /* Offset to Feature Parameters table (if one 554 * has been defined for the feature), relative 555 * to the beginning of the Feature Table; = Null 556 * if not required */ 557 IndexArray lookupIndex; /* Array of LookupList indices */ 558 public: 559 DEFINE_SIZE_ARRAY (4, lookupIndex); 560 }; 561 562 typedef RecordListOf<Feature> FeatureList; 563 564 565 struct LookupFlag : USHORT 566 { 567 enum Flags { 568 RightToLeft = 0x0001u, 569 IgnoreBaseGlyphs = 0x0002u, 570 IgnoreLigatures = 0x0004u, 571 IgnoreMarks = 0x0008u, 572 IgnoreFlags = 0x000Eu, 573 UseMarkFilteringSet = 0x0010u, 574 Reserved = 0x00E0u, 575 MarkAttachmentType = 0xFF00u 576 }; 577 public: 578 DEFINE_SIZE_STATIC (2); 579 }; 580 581 } /* namespace OT */ 582 /* This has to be outside the namespace. */ 583 HB_MARK_AS_FLAG_T (OT::LookupFlag::Flags); 584 namespace OT { 585 586 struct Lookup 587 { 588 inline unsigned int get_subtable_count (void) const { return subTable.len; } 589 590 template <typename SubTableType> 591 inline const SubTableType& get_subtable (unsigned int i) const 592 { return this+CastR<OffsetArrayOf<SubTableType> > (subTable)[i]; } 593 594 template <typename SubTableType> 595 inline const OffsetArrayOf<SubTableType>& get_subtables (void) const 596 { return CastR<OffsetArrayOf<SubTableType> > (subTable); } 597 template <typename SubTableType> 598 inline OffsetArrayOf<SubTableType>& get_subtables (void) 599 { return CastR<OffsetArrayOf<SubTableType> > (subTable); } 600 601 inline unsigned int get_type (void) const { return lookupType; } 602 603 /* lookup_props is a 32-bit integer where the lower 16-bit is LookupFlag and 604 * higher 16-bit is mark-filtering-set if the lookup uses one. 605 * Not to be confused with glyph_props which is very similar. */ 606 inline uint32_t get_props (void) const 607 { 608 unsigned int flag = lookupFlag; 609 if (unlikely (flag & LookupFlag::UseMarkFilteringSet)) 610 { 611 const USHORT &markFilteringSet = StructAfter<USHORT> (subTable); 612 flag += (markFilteringSet << 16); 613 } 614 return flag; 615 } 616 617 template <typename SubTableType, typename context_t> 618 inline typename context_t::return_t dispatch (context_t *c) const 619 { 620 unsigned int lookup_type = get_type (); 621 TRACE_DISPATCH (this, lookup_type); 622 unsigned int count = get_subtable_count (); 623 for (unsigned int i = 0; i < count; i++) { 624 typename context_t::return_t r = get_subtable<SubTableType> (i).dispatch (c, lookup_type); 625 if (c->stop_sublookup_iteration (r)) 626 return_trace (r); 627 } 628 return_trace (c->default_return_value ()); 629 } 630 631 inline bool serialize (hb_serialize_context_t *c, 632 unsigned int lookup_type, 633 uint32_t lookup_props, 634 unsigned int num_subtables) 635 { 636 TRACE_SERIALIZE (this); 637 if (unlikely (!c->extend_min (*this))) return_trace (false); 638 lookupType.set (lookup_type); 639 lookupFlag.set (lookup_props & 0xFFFFu); 640 if (unlikely (!subTable.serialize (c, num_subtables))) return_trace (false); 641 if (lookupFlag & LookupFlag::UseMarkFilteringSet) 642 { 643 USHORT &markFilteringSet = StructAfter<USHORT> (subTable); 644 markFilteringSet.set (lookup_props >> 16); 645 } 646 return_trace (true); 647 } 648 649 inline bool sanitize (hb_sanitize_context_t *c) const 650 { 651 TRACE_SANITIZE (this); 652 /* Real sanitize of the subtables is done by GSUB/GPOS/... */ 653 if (!(c->check_struct (this) && subTable.sanitize (c))) return_trace (false); 654 if (lookupFlag & LookupFlag::UseMarkFilteringSet) 655 { 656 const USHORT &markFilteringSet = StructAfter<USHORT> (subTable); 657 if (!markFilteringSet.sanitize (c)) return_trace (false); 658 } 659 return_trace (true); 660 } 661 662 private: 663 USHORT lookupType; /* Different enumerations for GSUB and GPOS */ 664 USHORT lookupFlag; /* Lookup qualifiers */ 665 ArrayOf<Offset<> > 666 subTable; /* Array of SubTables */ 667 USHORT markFilteringSetX[VAR]; /* Index (base 0) into GDEF mark glyph sets 668 * structure. This field is only present if bit 669 * UseMarkFilteringSet of lookup flags is set. */ 670 public: 671 DEFINE_SIZE_ARRAY2 (6, subTable, markFilteringSetX); 672 }; 673 674 typedef OffsetListOf<Lookup> LookupList; 675 676 677 /* 678 * Coverage Table 679 */ 680 681 struct CoverageFormat1 682 { 683 friend struct Coverage; 684 685 private: 686 inline unsigned int get_coverage (hb_codepoint_t glyph_id) const 687 { 688 int i = glyphArray.bsearch (glyph_id); 689 static_assert ((((unsigned int) -1) == NOT_COVERED), ""); 690 return i; 691 } 692 693 inline bool serialize (hb_serialize_context_t *c, 694 Supplier<GlyphID> &glyphs, 695 unsigned int num_glyphs) 696 { 697 TRACE_SERIALIZE (this); 698 if (unlikely (!c->extend_min (*this))) return_trace (false); 699 glyphArray.len.set (num_glyphs); 700 if (unlikely (!c->extend (glyphArray))) return_trace (false); 701 for (unsigned int i = 0; i < num_glyphs; i++) 702 glyphArray[i] = glyphs[i]; 703 glyphs.advance (num_glyphs); 704 return_trace (true); 705 } 706 707 inline bool sanitize (hb_sanitize_context_t *c) const 708 { 709 TRACE_SANITIZE (this); 710 return_trace (glyphArray.sanitize (c)); 711 } 712 713 inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const { 714 return glyphs->has (glyphArray[index]); 715 } 716 717 template <typename set_t> 718 inline void add_coverage (set_t *glyphs) const { 719 unsigned int count = glyphArray.len; 720 for (unsigned int i = 0; i < count; i++) 721 glyphs->add (glyphArray[i]); 722 } 723 724 public: 725 /* Older compilers need this to be public. */ 726 struct Iter { 727 inline void init (const struct CoverageFormat1 &c_) { c = &c_; i = 0; }; 728 inline bool more (void) { return i < c->glyphArray.len; } 729 inline void next (void) { i++; } 730 inline hb_codepoint_t get_glyph (void) { return c->glyphArray[i]; } 731 inline unsigned int get_coverage (void) { return i; } 732 733 private: 734 const struct CoverageFormat1 *c; 735 unsigned int i; 736 }; 737 private: 738 739 protected: 740 USHORT coverageFormat; /* Format identifier--format = 1 */ 741 SortedArrayOf<GlyphID> 742 glyphArray; /* Array of GlyphIDs--in numerical order */ 743 public: 744 DEFINE_SIZE_ARRAY (4, glyphArray); 745 }; 746 747 struct CoverageFormat2 748 { 749 friend struct Coverage; 750 751 private: 752 inline unsigned int get_coverage (hb_codepoint_t glyph_id) const 753 { 754 int i = rangeRecord.bsearch (glyph_id); 755 if (i != -1) { 756 const RangeRecord &range = rangeRecord[i]; 757 return (unsigned int) range.value + (glyph_id - range.start); 758 } 759 return NOT_COVERED; 760 } 761 762 inline bool serialize (hb_serialize_context_t *c, 763 Supplier<GlyphID> &glyphs, 764 unsigned int num_glyphs) 765 { 766 TRACE_SERIALIZE (this); 767 if (unlikely (!c->extend_min (*this))) return_trace (false); 768 769 if (unlikely (!num_glyphs)) 770 { 771 rangeRecord.len.set (0); 772 return_trace (true); 773 } 774 775 unsigned int num_ranges = 1; 776 for (unsigned int i = 1; i < num_glyphs; i++) 777 if (glyphs[i - 1] + 1 != glyphs[i]) 778 num_ranges++; 779 rangeRecord.len.set (num_ranges); 780 if (unlikely (!c->extend (rangeRecord))) return_trace (false); 781 782 unsigned int range = 0; 783 rangeRecord[range].start = glyphs[0]; 784 rangeRecord[range].value.set (0); 785 for (unsigned int i = 1; i < num_glyphs; i++) 786 if (glyphs[i - 1] + 1 != glyphs[i]) { 787 range++; 788 rangeRecord[range].start = glyphs[i]; 789 rangeRecord[range].value.set (i); 790 rangeRecord[range].end = glyphs[i]; 791 } else { 792 rangeRecord[range].end = glyphs[i]; 793 } 794 glyphs.advance (num_glyphs); 795 return_trace (true); 796 } 797 798 inline bool sanitize (hb_sanitize_context_t *c) const 799 { 800 TRACE_SANITIZE (this); 801 return_trace (rangeRecord.sanitize (c)); 802 } 803 804 inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const { 805 unsigned int i; 806 unsigned int count = rangeRecord.len; 807 for (i = 0; i < count; i++) { 808 const RangeRecord &range = rangeRecord[i]; 809 if (range.value <= index && 810 index < (unsigned int) range.value + (range.end - range.start) && 811 range.intersects (glyphs)) 812 return true; 813 else if (index < range.value) 814 return false; 815 } 816 return false; 817 } 818 819 template <typename set_t> 820 inline void add_coverage (set_t *glyphs) const { 821 unsigned int count = rangeRecord.len; 822 for (unsigned int i = 0; i < count; i++) 823 rangeRecord[i].add_coverage (glyphs); 824 } 825 826 public: 827 /* Older compilers need this to be public. */ 828 struct Iter 829 { 830 inline void init (const CoverageFormat2 &c_) 831 { 832 c = &c_; 833 coverage = 0; 834 i = 0; 835 j = c->rangeRecord.len ? c_.rangeRecord[0].start : 0; 836 } 837 inline bool more (void) { return i < c->rangeRecord.len; } 838 inline void next (void) 839 { 840 if (j >= c->rangeRecord[i].end) 841 { 842 i++; 843 if (more ()) 844 { 845 j = c->rangeRecord[i].start; 846 coverage = c->rangeRecord[i].value; 847 } 848 return; 849 } 850 coverage++; 851 j++; 852 } 853 inline hb_codepoint_t get_glyph (void) { return j; } 854 inline unsigned int get_coverage (void) { return coverage; } 855 856 private: 857 const struct CoverageFormat2 *c; 858 unsigned int i, j, coverage; 859 }; 860 private: 861 862 protected: 863 USHORT coverageFormat; /* Format identifier--format = 2 */ 864 SortedArrayOf<RangeRecord> 865 rangeRecord; /* Array of glyph ranges--ordered by 866 * Start GlyphID. rangeCount entries 867 * long */ 868 public: 869 DEFINE_SIZE_ARRAY (4, rangeRecord); 870 }; 871 872 struct Coverage 873 { 874 inline unsigned int get_coverage (hb_codepoint_t glyph_id) const 875 { 876 switch (u.format) { 877 case 1: return u.format1.get_coverage(glyph_id); 878 case 2: return u.format2.get_coverage(glyph_id); 879 default:return NOT_COVERED; 880 } 881 } 882 883 inline bool serialize (hb_serialize_context_t *c, 884 Supplier<GlyphID> &glyphs, 885 unsigned int num_glyphs) 886 { 887 TRACE_SERIALIZE (this); 888 if (unlikely (!c->extend_min (*this))) return_trace (false); 889 unsigned int num_ranges = 1; 890 for (unsigned int i = 1; i < num_glyphs; i++) 891 if (glyphs[i - 1] + 1 != glyphs[i]) 892 num_ranges++; 893 u.format.set (num_glyphs * 2 < num_ranges * 3 ? 1 : 2); 894 switch (u.format) { 895 case 1: return_trace (u.format1.serialize (c, glyphs, num_glyphs)); 896 case 2: return_trace (u.format2.serialize (c, glyphs, num_glyphs)); 897 default:return_trace (false); 898 } 899 } 900 901 inline bool sanitize (hb_sanitize_context_t *c) const 902 { 903 TRACE_SANITIZE (this); 904 if (!u.format.sanitize (c)) return_trace (false); 905 switch (u.format) { 906 case 1: return_trace (u.format1.sanitize (c)); 907 case 2: return_trace (u.format2.sanitize (c)); 908 default:return_trace (true); 909 } 910 } 911 912 inline bool intersects (const hb_set_t *glyphs) const { 913 /* TODO speed this up */ 914 Coverage::Iter iter; 915 for (iter.init (*this); iter.more (); iter.next ()) { 916 if (glyphs->has (iter.get_glyph ())) 917 return true; 918 } 919 return false; 920 } 921 922 inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const { 923 switch (u.format) { 924 case 1: return u.format1.intersects_coverage (glyphs, index); 925 case 2: return u.format2.intersects_coverage (glyphs, index); 926 default:return false; 927 } 928 } 929 930 template <typename set_t> 931 inline void add_coverage (set_t *glyphs) const { 932 switch (u.format) { 933 case 1: u.format1.add_coverage (glyphs); break; 934 case 2: u.format2.add_coverage (glyphs); break; 935 default: break; 936 } 937 } 938 939 struct Iter { 940 Iter (void) : format (0), u () {}; 941 inline void init (const Coverage &c_) { 942 format = c_.u.format; 943 switch (format) { 944 case 1: u.format1.init (c_.u.format1); return; 945 case 2: u.format2.init (c_.u.format2); return; 946 default: return; 947 } 948 } 949 inline bool more (void) { 950 switch (format) { 951 case 1: return u.format1.more (); 952 case 2: return u.format2.more (); 953 default:return false; 954 } 955 } 956 inline void next (void) { 957 switch (format) { 958 case 1: u.format1.next (); break; 959 case 2: u.format2.next (); break; 960 default: break; 961 } 962 } 963 inline hb_codepoint_t get_glyph (void) { 964 switch (format) { 965 case 1: return u.format1.get_glyph (); 966 case 2: return u.format2.get_glyph (); 967 default:return 0; 968 } 969 } 970 inline unsigned int get_coverage (void) { 971 switch (format) { 972 case 1: return u.format1.get_coverage (); 973 case 2: return u.format2.get_coverage (); 974 default:return -1; 975 } 976 } 977 978 private: 979 unsigned int format; 980 union { 981 CoverageFormat2::Iter format2; /* Put this one first since it's larger; helps shut up compiler. */ 982 CoverageFormat1::Iter format1; 983 } u; 984 }; 985 986 protected: 987 union { 988 USHORT format; /* Format identifier */ 989 CoverageFormat1 format1; 990 CoverageFormat2 format2; 991 } u; 992 public: 993 DEFINE_SIZE_UNION (2, format); 994 }; 995 996 997 /* 998 * Class Definition Table 999 */ 1000 1001 struct ClassDefFormat1 1002 { 1003 friend struct ClassDef; 1004 1005 private: 1006 inline unsigned int get_class (hb_codepoint_t glyph_id) const 1007 { 1008 unsigned int i = (unsigned int) (glyph_id - startGlyph); 1009 if (unlikely (i < classValue.len)) 1010 return classValue[i]; 1011 return 0; 1012 } 1013 1014 inline bool sanitize (hb_sanitize_context_t *c) const 1015 { 1016 TRACE_SANITIZE (this); 1017 return_trace (c->check_struct (this) && classValue.sanitize (c)); 1018 } 1019 1020 template <typename set_t> 1021 inline void add_class (set_t *glyphs, unsigned int klass) const { 1022 unsigned int count = classValue.len; 1023 for (unsigned int i = 0; i < count; i++) 1024 if (classValue[i] == klass) 1025 glyphs->add (startGlyph + i); 1026 } 1027 1028 inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const { 1029 unsigned int count = classValue.len; 1030 if (klass == 0) 1031 { 1032 /* Match if there's any glyph that is not listed! */ 1033 hb_codepoint_t g = -1; 1034 if (!hb_set_next (glyphs, &g)) 1035 return false; 1036 if (g < startGlyph) 1037 return true; 1038 g = startGlyph + count - 1; 1039 if (hb_set_next (glyphs, &g)) 1040 return true; 1041 /* Fall through. */ 1042 } 1043 for (unsigned int i = 0; i < count; i++) 1044 if (classValue[i] == klass && glyphs->has (startGlyph + i)) 1045 return true; 1046 return false; 1047 } 1048 1049 protected: 1050 USHORT classFormat; /* Format identifier--format = 1 */ 1051 GlyphID startGlyph; /* First GlyphID of the classValueArray */ 1052 ArrayOf<USHORT> 1053 classValue; /* Array of Class Values--one per GlyphID */ 1054 public: 1055 DEFINE_SIZE_ARRAY (6, classValue); 1056 }; 1057 1058 struct ClassDefFormat2 1059 { 1060 friend struct ClassDef; 1061 1062 private: 1063 inline unsigned int get_class (hb_codepoint_t glyph_id) const 1064 { 1065 int i = rangeRecord.bsearch (glyph_id); 1066 if (unlikely (i != -1)) 1067 return rangeRecord[i].value; 1068 return 0; 1069 } 1070 1071 inline bool sanitize (hb_sanitize_context_t *c) const 1072 { 1073 TRACE_SANITIZE (this); 1074 return_trace (rangeRecord.sanitize (c)); 1075 } 1076 1077 template <typename set_t> 1078 inline void add_class (set_t *glyphs, unsigned int klass) const { 1079 unsigned int count = rangeRecord.len; 1080 for (unsigned int i = 0; i < count; i++) 1081 if (rangeRecord[i].value == klass) 1082 rangeRecord[i].add_coverage (glyphs); 1083 } 1084 1085 inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const { 1086 unsigned int count = rangeRecord.len; 1087 if (klass == 0) 1088 { 1089 /* Match if there's any glyph that is not listed! */ 1090 hb_codepoint_t g = (hb_codepoint_t) -1; 1091 for (unsigned int i = 0; i < count; i++) 1092 { 1093 if (!hb_set_next (glyphs, &g)) 1094 break; 1095 if (g < rangeRecord[i].start) 1096 return true; 1097 g = rangeRecord[i].end; 1098 } 1099 if (g != (hb_codepoint_t) -1 && hb_set_next (glyphs, &g)) 1100 return true; 1101 /* Fall through. */ 1102 } 1103 for (unsigned int i = 0; i < count; i++) 1104 if (rangeRecord[i].value == klass && rangeRecord[i].intersects (glyphs)) 1105 return true; 1106 return false; 1107 } 1108 1109 protected: 1110 USHORT classFormat; /* Format identifier--format = 2 */ 1111 SortedArrayOf<RangeRecord> 1112 rangeRecord; /* Array of glyph ranges--ordered by 1113 * Start GlyphID */ 1114 public: 1115 DEFINE_SIZE_ARRAY (4, rangeRecord); 1116 }; 1117 1118 struct ClassDef 1119 { 1120 inline unsigned int get_class (hb_codepoint_t glyph_id) const 1121 { 1122 switch (u.format) { 1123 case 1: return u.format1.get_class(glyph_id); 1124 case 2: return u.format2.get_class(glyph_id); 1125 default:return 0; 1126 } 1127 } 1128 1129 inline bool sanitize (hb_sanitize_context_t *c) const 1130 { 1131 TRACE_SANITIZE (this); 1132 if (!u.format.sanitize (c)) return_trace (false); 1133 switch (u.format) { 1134 case 1: return_trace (u.format1.sanitize (c)); 1135 case 2: return_trace (u.format2.sanitize (c)); 1136 default:return_trace (true); 1137 } 1138 } 1139 1140 inline void add_class (hb_set_t *glyphs, unsigned int klass) const { 1141 switch (u.format) { 1142 case 1: u.format1.add_class (glyphs, klass); return; 1143 case 2: u.format2.add_class (glyphs, klass); return; 1144 default:return; 1145 } 1146 } 1147 1148 inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const { 1149 switch (u.format) { 1150 case 1: return u.format1.intersects_class (glyphs, klass); 1151 case 2: return u.format2.intersects_class (glyphs, klass); 1152 default:return false; 1153 } 1154 } 1155 1156 protected: 1157 union { 1158 USHORT format; /* Format identifier */ 1159 ClassDefFormat1 format1; 1160 ClassDefFormat2 format2; 1161 } u; 1162 public: 1163 DEFINE_SIZE_UNION (2, format); 1164 }; 1165 1166 1167 /* 1168 * Item Variation Store 1169 */ 1170 1171 struct VarRegionAxis 1172 { 1173 inline float evaluate (int coord) const 1174 { 1175 int start = startCoord, peak = peakCoord, end = endCoord; 1176 1177 /* TODO Move these to sanitize(). */ 1178 if (unlikely (start > peak || peak > end)) 1179 return 1.; 1180 if (unlikely (start < 0 && end > 0 && peak != 0)) 1181 return 1.; 1182 1183 if (peak == 0 || coord == peak) 1184 return 1.; 1185 1186 if (coord <= start || end <= coord) 1187 return 0.; 1188 1189 /* Interpolate */ 1190 if (coord < peak) 1191 return float (coord - start) / (peak - start); 1192 else 1193 return float (end - coord) / (end - peak); 1194 } 1195 1196 inline bool sanitize (hb_sanitize_context_t *c) const 1197 { 1198 TRACE_SANITIZE (this); 1199 return_trace (c->check_struct (this)); 1200 /* TODO Handle invalid start/peak/end configs, so we don't 1201 * have to do that at runtime. */ 1202 } 1203 1204 public: 1205 F2DOT14 startCoord; 1206 F2DOT14 peakCoord; 1207 F2DOT14 endCoord; 1208 public: 1209 DEFINE_SIZE_STATIC (6); 1210 }; 1211 1212 struct VarRegionList 1213 { 1214 inline float evaluate (unsigned int region_index, 1215 int *coords, unsigned int coord_len) const 1216 { 1217 if (unlikely (region_index >= regionCount)) 1218 return 0.; 1219 1220 const VarRegionAxis *axes = axesZ + (region_index * axisCount); 1221 1222 float v = 1.; 1223 unsigned int count = MIN (coord_len, (unsigned int) axisCount); 1224 for (unsigned int i = 0; i < count; i++) 1225 { 1226 float factor = axes[i].evaluate (coords[i]); 1227 if (factor == 0.) 1228 return 0.; 1229 v *= factor; 1230 } 1231 return v; 1232 } 1233 1234 inline bool sanitize (hb_sanitize_context_t *c) const 1235 { 1236 TRACE_SANITIZE (this); 1237 return_trace (c->check_struct (this) && 1238 c->check_array (axesZ, axesZ[0].static_size, 1239 (unsigned int) axisCount * (unsigned int) regionCount)); 1240 } 1241 1242 protected: 1243 USHORT axisCount; 1244 USHORT regionCount; 1245 VarRegionAxis axesZ[VAR]; 1246 public: 1247 DEFINE_SIZE_ARRAY (4, axesZ); 1248 }; 1249 1250 struct VarData 1251 { 1252 inline unsigned int get_row_size (void) const 1253 { return shortCount + regionIndices.len; } 1254 1255 inline unsigned int get_size (void) const 1256 { return itemCount * get_row_size (); } 1257 1258 inline float get_delta (unsigned int inner, 1259 int *coords, unsigned int coord_count, 1260 const VarRegionList ®ions) const 1261 { 1262 if (unlikely (inner >= itemCount)) 1263 return 0.; 1264 1265 unsigned int count = regionIndices.len; 1266 unsigned int scount = shortCount; 1267 1268 const BYTE *bytes = &StructAfter<BYTE> (regionIndices); 1269 const BYTE *row = bytes + inner * (scount + count); 1270 1271 float delta = 0.; 1272 unsigned int i = 0; 1273 1274 const SHORT *scursor = reinterpret_cast<const SHORT *> (row); 1275 for (; i < scount; i++) 1276 { 1277 float scalar = regions.evaluate (regionIndices.array[i], coords, coord_count); 1278 delta += scalar * *scursor++; 1279 } 1280 const INT8 *bcursor = reinterpret_cast<const INT8 *> (scursor); 1281 for (; i < count; i++) 1282 { 1283 float scalar = regions.evaluate (regionIndices.array[i], coords, coord_count); 1284 delta += scalar * *bcursor++; 1285 } 1286 1287 return delta; 1288 } 1289 1290 inline bool sanitize (hb_sanitize_context_t *c) const 1291 { 1292 TRACE_SANITIZE (this); 1293 return_trace (c->check_struct (this) && 1294 regionIndices.sanitize(c) && 1295 shortCount <= regionIndices.len && 1296 c->check_array (&StructAfter<BYTE> (regionIndices), 1297 get_row_size (), itemCount)); 1298 } 1299 1300 protected: 1301 USHORT itemCount; 1302 USHORT shortCount; 1303 ArrayOf<USHORT> regionIndices; 1304 BYTE bytesX[VAR]; 1305 public: 1306 DEFINE_SIZE_ARRAY2 (6, regionIndices, bytesX); 1307 }; 1308 1309 struct VariationStore 1310 { 1311 inline float get_delta (unsigned int outer, unsigned int inner, 1312 int *coords, unsigned int coord_count) const 1313 { 1314 if (unlikely (outer >= dataSets.len)) 1315 return 0.; 1316 1317 return (this+dataSets[outer]).get_delta (inner, 1318 coords, coord_count, 1319 this+regions); 1320 } 1321 1322 inline float get_delta (unsigned int index, 1323 int *coords, unsigned int coord_count) const 1324 { 1325 unsigned int outer = index >> 16; 1326 unsigned int inner = index & 0xFFFF; 1327 return get_delta (outer, inner, coords, coord_count); 1328 } 1329 1330 inline bool sanitize (hb_sanitize_context_t *c) const 1331 { 1332 TRACE_SANITIZE (this); 1333 return_trace (c->check_struct (this) && 1334 format == 1 && 1335 regions.sanitize (c, this) && 1336 dataSets.sanitize (c, this)); 1337 } 1338 1339 protected: 1340 USHORT format; 1341 LOffsetTo<VarRegionList> regions; 1342 OffsetArrayOf<VarData, ULONG> dataSets; 1343 public: 1344 DEFINE_SIZE_ARRAY (8, dataSets); 1345 }; 1346 1347 /* 1348 * Feature Variations 1349 */ 1350 1351 struct ConditionFormat1 1352 { 1353 friend struct Condition; 1354 1355 private: 1356 inline bool evaluate (const int *coords, unsigned int coord_len) const 1357 { 1358 int coord = axisIndex < coord_len ? coords[axisIndex] : 0; 1359 return filterRangeMinValue <= coord && coord <= filterRangeMaxValue; 1360 } 1361 1362 inline bool sanitize (hb_sanitize_context_t *c) const 1363 { 1364 TRACE_SANITIZE (this); 1365 return_trace (c->check_struct (this)); 1366 } 1367 1368 protected: 1369 USHORT format; /* Format identifier--format = 1 */ 1370 USHORT axisIndex; 1371 F2DOT14 filterRangeMinValue; 1372 F2DOT14 filterRangeMaxValue; 1373 public: 1374 DEFINE_SIZE_STATIC (8); 1375 }; 1376 1377 struct Condition 1378 { 1379 inline bool evaluate (const int *coords, unsigned int coord_len) const 1380 { 1381 switch (u.format) { 1382 case 1: return u.format1.evaluate (coords, coord_len); 1383 default:return false; 1384 } 1385 } 1386 1387 inline bool sanitize (hb_sanitize_context_t *c) const 1388 { 1389 TRACE_SANITIZE (this); 1390 if (!u.format.sanitize (c)) return_trace (false); 1391 switch (u.format) { 1392 case 1: return_trace (u.format1.sanitize (c)); 1393 default:return_trace (true); 1394 } 1395 } 1396 1397 protected: 1398 union { 1399 USHORT format; /* Format identifier */ 1400 ConditionFormat1 format1; 1401 } u; 1402 public: 1403 DEFINE_SIZE_UNION (2, format); 1404 }; 1405 1406 struct ConditionSet 1407 { 1408 inline bool evaluate (const int *coords, unsigned int coord_len) const 1409 { 1410 unsigned int count = conditions.len; 1411 for (unsigned int i = 0; i < count; i++) 1412 if (!(this+conditions.array[i]).evaluate (coords, coord_len)) 1413 return false; 1414 return true; 1415 } 1416 1417 inline bool sanitize (hb_sanitize_context_t *c) const 1418 { 1419 TRACE_SANITIZE (this); 1420 return_trace (conditions.sanitize (c, this)); 1421 } 1422 1423 protected: 1424 OffsetArrayOf<Condition, ULONG> conditions; 1425 public: 1426 DEFINE_SIZE_ARRAY (2, conditions); 1427 }; 1428 1429 struct FeatureTableSubstitutionRecord 1430 { 1431 friend struct FeatureTableSubstitution; 1432 1433 inline bool sanitize (hb_sanitize_context_t *c, const void *base) const 1434 { 1435 TRACE_SANITIZE (this); 1436 return_trace (c->check_struct (this) && feature.sanitize (c, base)); 1437 } 1438 1439 protected: 1440 USHORT featureIndex; 1441 LOffsetTo<Feature> feature; 1442 public: 1443 DEFINE_SIZE_STATIC (6); 1444 }; 1445 1446 struct FeatureTableSubstitution 1447 { 1448 inline const Feature *find_substitute (unsigned int feature_index) const 1449 { 1450 unsigned int count = substitutions.len; 1451 for (unsigned int i = 0; i < count; i++) 1452 { 1453 const FeatureTableSubstitutionRecord &record = substitutions.array[i]; 1454 if (record.featureIndex == feature_index) 1455 return &(this+record.feature); 1456 } 1457 return nullptr; 1458 } 1459 1460 inline bool sanitize (hb_sanitize_context_t *c) const 1461 { 1462 TRACE_SANITIZE (this); 1463 return_trace (version.sanitize (c) && 1464 likely (version.major == 1) && 1465 substitutions.sanitize (c, this)); 1466 } 1467 1468 protected: 1469 FixedVersion<> version; /* Version--0x00010000u */ 1470 ArrayOf<FeatureTableSubstitutionRecord> 1471 substitutions; 1472 public: 1473 DEFINE_SIZE_ARRAY (6, substitutions); 1474 }; 1475 1476 struct FeatureVariationRecord 1477 { 1478 friend struct FeatureVariations; 1479 1480 inline bool sanitize (hb_sanitize_context_t *c, const void *base) const 1481 { 1482 TRACE_SANITIZE (this); 1483 return_trace (conditions.sanitize (c, base) && 1484 substitutions.sanitize (c, base)); 1485 } 1486 1487 protected: 1488 LOffsetTo<ConditionSet> 1489 conditions; 1490 LOffsetTo<FeatureTableSubstitution> 1491 substitutions; 1492 public: 1493 DEFINE_SIZE_STATIC (8); 1494 }; 1495 1496 struct FeatureVariations 1497 { 1498 static const unsigned int NOT_FOUND_INDEX = 0xFFFFFFFFu; 1499 1500 inline bool find_index (const int *coords, unsigned int coord_len, 1501 unsigned int *index) const 1502 { 1503 unsigned int count = varRecords.len; 1504 for (unsigned int i = 0; i < count; i++) 1505 { 1506 const FeatureVariationRecord &record = varRecords.array[i]; 1507 if ((this+record.conditions).evaluate (coords, coord_len)) 1508 { 1509 *index = i; 1510 return true; 1511 } 1512 } 1513 *index = NOT_FOUND_INDEX; 1514 return false; 1515 } 1516 1517 inline const Feature *find_substitute (unsigned int variations_index, 1518 unsigned int feature_index) const 1519 { 1520 const FeatureVariationRecord &record = varRecords[variations_index]; 1521 return (this+record.substitutions).find_substitute (feature_index); 1522 } 1523 1524 inline bool sanitize (hb_sanitize_context_t *c) const 1525 { 1526 TRACE_SANITIZE (this); 1527 return_trace (version.sanitize (c) && 1528 likely (version.major == 1) && 1529 varRecords.sanitize (c, this)); 1530 } 1531 1532 protected: 1533 FixedVersion<> version; /* Version--0x00010000u */ 1534 LArrayOf<FeatureVariationRecord> 1535 varRecords; 1536 public: 1537 DEFINE_SIZE_ARRAY (8, varRecords); 1538 }; 1539 1540 1541 /* 1542 * Device Tables 1543 */ 1544 1545 struct HintingDevice 1546 { 1547 friend struct Device; 1548 1549 private: 1550 1551 inline hb_position_t get_x_delta (hb_font_t *font) const 1552 { return get_delta (font->x_ppem, font->x_scale); } 1553 1554 inline hb_position_t get_y_delta (hb_font_t *font) const 1555 { return get_delta (font->y_ppem, font->y_scale); } 1556 1557 inline unsigned int get_size (void) const 1558 { 1559 unsigned int f = deltaFormat; 1560 if (unlikely (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::static_size; 1561 return USHORT::static_size * (4 + ((endSize - startSize) >> (4 - f))); 1562 } 1563 1564 inline bool sanitize (hb_sanitize_context_t *c) const 1565 { 1566 TRACE_SANITIZE (this); 1567 return_trace (c->check_struct (this) && c->check_range (this, this->get_size ())); 1568 } 1569 1570 private: 1571 1572 inline int get_delta (unsigned int ppem, int scale) const 1573 { 1574 if (!ppem) return 0; 1575 1576 int pixels = get_delta_pixels (ppem); 1577 1578 if (!pixels) return 0; 1579 1580 return (int) (pixels * (int64_t) scale / ppem); 1581 } 1582 inline int get_delta_pixels (unsigned int ppem_size) const 1583 { 1584 unsigned int f = deltaFormat; 1585 if (unlikely (f < 1 || f > 3)) 1586 return 0; 1587 1588 if (ppem_size < startSize || ppem_size > endSize) 1589 return 0; 1590 1591 unsigned int s = ppem_size - startSize; 1592 1593 unsigned int byte = deltaValue[s >> (4 - f)]; 1594 unsigned int bits = (byte >> (16 - (((s & ((1 << (4 - f)) - 1)) + 1) << f))); 1595 unsigned int mask = (0xFFFFu >> (16 - (1 << f))); 1596 1597 int delta = bits & mask; 1598 1599 if ((unsigned int) delta >= ((mask + 1) >> 1)) 1600 delta -= mask + 1; 1601 1602 return delta; 1603 } 1604 1605 protected: 1606 USHORT startSize; /* Smallest size to correct--in ppem */ 1607 USHORT endSize; /* Largest size to correct--in ppem */ 1608 USHORT deltaFormat; /* Format of DeltaValue array data: 1, 2, or 3 1609 * 1 Signed 2-bit value, 8 values per uint16 1610 * 2 Signed 4-bit value, 4 values per uint16 1611 * 3 Signed 8-bit value, 2 values per uint16 1612 */ 1613 USHORT deltaValue[VAR]; /* Array of compressed data */ 1614 public: 1615 DEFINE_SIZE_ARRAY (6, deltaValue); 1616 }; 1617 1618 struct VariationDevice 1619 { 1620 friend struct Device; 1621 1622 private: 1623 1624 inline hb_position_t get_x_delta (hb_font_t *font, const VariationStore &store) const 1625 { return font->em_scalef_x (get_delta (font, store)); } 1626 1627 inline hb_position_t get_y_delta (hb_font_t *font, const VariationStore &store) const 1628 { return font->em_scalef_y (get_delta (font, store)); } 1629 1630 inline bool sanitize (hb_sanitize_context_t *c) const 1631 { 1632 TRACE_SANITIZE (this); 1633 return_trace (c->check_struct (this)); 1634 } 1635 1636 private: 1637 1638 inline float get_delta (hb_font_t *font, const VariationStore &store) const 1639 { 1640 return store.get_delta (outerIndex, innerIndex, font->coords, font->num_coords); 1641 } 1642 1643 protected: 1644 USHORT outerIndex; 1645 USHORT innerIndex; 1646 USHORT deltaFormat; /* Format identifier for this table: 0x0x8000 */ 1647 public: 1648 DEFINE_SIZE_STATIC (6); 1649 }; 1650 1651 struct DeviceHeader 1652 { 1653 protected: 1654 USHORT reserved1; 1655 USHORT reserved2; 1656 public: 1657 USHORT format; /* Format identifier */ 1658 public: 1659 DEFINE_SIZE_STATIC (6); 1660 }; 1661 1662 struct Device 1663 { 1664 inline hb_position_t get_x_delta (hb_font_t *font, const VariationStore &store=Null(VariationStore)) const 1665 { 1666 switch (u.b.format) 1667 { 1668 case 1: case 2: case 3: 1669 return u.hinting.get_x_delta (font); 1670 case 0x8000: 1671 return u.variation.get_x_delta (font, store); 1672 default: 1673 return 0; 1674 } 1675 } 1676 inline hb_position_t get_y_delta (hb_font_t *font, const VariationStore &store=Null(VariationStore)) const 1677 { 1678 switch (u.b.format) 1679 { 1680 case 1: case 2: case 3: 1681 return u.hinting.get_y_delta (font); 1682 case 0x8000: 1683 return u.variation.get_y_delta (font, store); 1684 default: 1685 return 0; 1686 } 1687 } 1688 1689 inline bool sanitize (hb_sanitize_context_t *c) const 1690 { 1691 TRACE_SANITIZE (this); 1692 if (!u.b.format.sanitize (c)) return_trace (false); 1693 switch (u.b.format) { 1694 case 1: case 2: case 3: 1695 return_trace (u.hinting.sanitize (c)); 1696 case 0x8000: 1697 return_trace (u.variation.sanitize (c)); 1698 default: 1699 return_trace (true); 1700 } 1701 } 1702 1703 protected: 1704 union { 1705 DeviceHeader b; 1706 HintingDevice hinting; 1707 VariationDevice variation; 1708 } u; 1709 public: 1710 DEFINE_SIZE_UNION (6, b); 1711 }; 1712 1713 1714 } /* namespace OT */ 1715 1716 1717 #endif /* HB_OT_LAYOUT_COMMON_PRIVATE_HH */