| /* |
| * Copyright © 2007,2008,2009 Red Hat, Inc. |
| * Copyright © 2012 Google, Inc. |
| * |
| * This is part of HarfBuzz, a text shaping library. |
| * |
| * Permission is hereby granted, without written agreement and without |
| * license or royalty fees, to use, copy, modify, and distribute this |
| * software and its documentation for any purpose, provided that the |
| * above copyright notice and the following two paragraphs appear in |
| * all copies of this software. |
| * |
| * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
| * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
| * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
| * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
| * DAMAGE. |
| * |
| * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
| * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
| * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
| * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
| * |
| * Red Hat Author(s): Behdad Esfahbod |
| * Google Author(s): Behdad Esfahbod |
| */ |
| |
| #ifndef HB_OPEN_FILE_HH |
| #define HB_OPEN_FILE_HH |
| |
| #include "hb-open-type.hh" |
| #include "hb-ot-head-table.hh" |
| |
| |
| namespace OT { |
| |
| /* |
| * |
| * The OpenType Font File |
| * |
| */ |
| |
| |
| /* |
| * Organization of an OpenType Font |
| */ |
| |
| struct OpenTypeFontFile; |
| struct OpenTypeOffsetTable; |
| struct TTCHeader; |
| |
| |
| typedef struct TableRecord |
| { |
| int cmp (Tag t) const { return -t.cmp (tag); } |
| |
| HB_INTERNAL static int cmp (const void *pa, const void *pb) |
| { |
| const TableRecord *a = (const TableRecord *) pa; |
| const TableRecord *b = (const TableRecord *) pb; |
| return b->cmp (a->tag); |
| } |
| |
| bool sanitize (hb_sanitize_context_t *c) const |
| { |
| TRACE_SANITIZE (this); |
| return_trace (c->check_struct (this)); |
| } |
| |
| Tag tag; /* 4-byte identifier. */ |
| CheckSum checkSum; /* CheckSum for this table. */ |
| Offset32 offset; /* Offset from beginning of TrueType font |
| * file. */ |
| HBUINT32 length; /* Length of this table. */ |
| public: |
| DEFINE_SIZE_STATIC (16); |
| } OpenTypeTable; |
| |
| typedef struct OpenTypeOffsetTable |
| { |
| friend struct OpenTypeFontFile; |
| |
| unsigned int get_table_count () const { return tables.len; } |
| const TableRecord& get_table (unsigned int i) const |
| { return tables[i]; } |
| unsigned int get_table_tags (unsigned int start_offset, |
| unsigned int *table_count, /* IN/OUT */ |
| hb_tag_t *table_tags /* OUT */) const |
| { |
| if (table_count) |
| { |
| + tables.sub_array (start_offset, table_count) |
| | hb_map (&TableRecord::tag) |
| | hb_sink (hb_array (table_tags, *table_count)) |
| ; |
| } |
| return tables.len; |
| } |
| bool find_table_index (hb_tag_t tag, unsigned int *table_index) const |
| { |
| Tag t; |
| t = tag; |
| /* Use lfind for small fonts; there are fonts that have unsorted table entries; |
| * those tend to work in other tools, so tolerate them. |
| * https://github.com/harfbuzz/harfbuzz/issues/3065 */ |
| if (tables.len < 16) |
| return tables.lfind (t, table_index, HB_NOT_FOUND_STORE, Index::NOT_FOUND_INDEX); |
| else |
| return tables.bfind (t, table_index, HB_NOT_FOUND_STORE, Index::NOT_FOUND_INDEX); |
| } |
| const TableRecord& get_table_by_tag (hb_tag_t tag) const |
| { |
| unsigned int table_index; |
| find_table_index (tag, &table_index); |
| return get_table (table_index); |
| } |
| |
| public: |
| |
| template <typename Iterator, |
| hb_requires ((hb_is_source_of<Iterator, hb_pair_t<hb_tag_t, hb_blob_t *>>::value))> |
| bool serialize (hb_serialize_context_t *c, |
| hb_tag_t sfnt_tag, |
| Iterator it) |
| { |
| TRACE_SERIALIZE (this); |
| /* Alloc 12 for the OTHeader. */ |
| if (unlikely (!c->extend_min (this))) return_trace (false); |
| /* Write sfntVersion (bytes 0..3). */ |
| sfnt_version = sfnt_tag; |
| /* Take space for numTables, searchRange, entrySelector, RangeShift |
| * and the TableRecords themselves. */ |
| unsigned num_items = it.len (); |
| if (unlikely (!tables.serialize (c, num_items))) return_trace (false); |
| |
| const char *dir_end = (const char *) c->head; |
| HBUINT32 *checksum_adjustment = nullptr; |
| |
| /* Write OffsetTables, alloc for and write actual table blobs. */ |
| unsigned i = 0; |
| for (hb_pair_t<hb_tag_t, hb_blob_t*> entry : it) |
| { |
| hb_blob_t *blob = entry.second; |
| unsigned len = blob->length; |
| |
| /* Allocate room for the table and copy it. */ |
| char *start = (char *) c->allocate_size<void> (len); |
| if (unlikely (!start)) return false; |
| |
| TableRecord &rec = tables.arrayZ[i]; |
| rec.tag = entry.first; |
| rec.length = len; |
| rec.offset = 0; |
| if (unlikely (!c->check_assign (rec.offset, |
| (unsigned) ((char *) start - (char *) this), |
| HB_SERIALIZE_ERROR_OFFSET_OVERFLOW))) |
| return_trace (false); |
| |
| if (likely (len)) |
| memcpy (start, blob->data, len); |
| |
| /* 4-byte alignment. */ |
| c->align (4); |
| const char *end = (const char *) c->head; |
| |
| if (entry.first == HB_OT_TAG_head && |
| (unsigned) (end - start) >= head::static_size) |
| { |
| head *h = (head *) start; |
| checksum_adjustment = &h->checkSumAdjustment; |
| *checksum_adjustment = 0; |
| } |
| |
| rec.checkSum.set_for_data (start, end - start); |
| i++; |
| } |
| |
| tables.qsort (); |
| |
| if (checksum_adjustment) |
| { |
| CheckSum checksum; |
| |
| /* The following line is a slower version of the following block. */ |
| //checksum.set_for_data (this, (const char *) c->head - (const char *) this); |
| checksum.set_for_data (this, dir_end - (const char *) this); |
| for (unsigned int i = 0; i < num_items; i++) |
| { |
| TableRecord &rec = tables.arrayZ[i]; |
| checksum = checksum + rec.checkSum; |
| } |
| |
| *checksum_adjustment = 0xB1B0AFBAu - checksum; |
| } |
| |
| return_trace (true); |
| } |
| |
| bool sanitize (hb_sanitize_context_t *c) const |
| { |
| TRACE_SANITIZE (this); |
| return_trace (c->check_struct (this) && tables.sanitize (c)); |
| } |
| |
| protected: |
| Tag sfnt_version; /* '\0\001\0\00' if TrueType / 'OTTO' if CFF */ |
| BinSearchArrayOf<TableRecord> |
| tables; |
| public: |
| DEFINE_SIZE_ARRAY (12, tables); |
| } OpenTypeFontFace; |
| |
| |
| /* |
| * TrueType Collections |
| */ |
| |
| struct TTCHeaderVersion1 |
| { |
| friend struct TTCHeader; |
| |
| unsigned int get_face_count () const { return table.len; } |
| const OpenTypeFontFace& get_face (unsigned int i) const { return this+table[i]; } |
| |
| bool sanitize (hb_sanitize_context_t *c) const |
| { |
| TRACE_SANITIZE (this); |
| return_trace (table.sanitize (c, this)); |
| } |
| |
| protected: |
| Tag ttcTag; /* TrueType Collection ID string: 'ttcf' */ |
| FixedVersion<>version; /* Version of the TTC Header (1.0), |
| * 0x00010000u */ |
| Array32Of<Offset32To<OpenTypeOffsetTable>> |
| table; /* Array of offsets to the OffsetTable for each font |
| * from the beginning of the file */ |
| public: |
| DEFINE_SIZE_ARRAY (12, table); |
| }; |
| |
| struct TTCHeader |
| { |
| friend struct OpenTypeFontFile; |
| |
| private: |
| |
| unsigned int get_face_count () const |
| { |
| switch (u.header.version.major) { |
| case 2: /* version 2 is compatible with version 1 */ |
| case 1: return u.version1.get_face_count (); |
| default:return 0; |
| } |
| } |
| const OpenTypeFontFace& get_face (unsigned int i) const |
| { |
| switch (u.header.version.major) { |
| case 2: /* version 2 is compatible with version 1 */ |
| case 1: return u.version1.get_face (i); |
| default:return Null (OpenTypeFontFace); |
| } |
| } |
| |
| bool sanitize (hb_sanitize_context_t *c) const |
| { |
| TRACE_SANITIZE (this); |
| if (unlikely (!u.header.version.sanitize (c))) return_trace (false); |
| switch (u.header.version.major) { |
| case 2: /* version 2 is compatible with version 1 */ |
| case 1: return_trace (u.version1.sanitize (c)); |
| default:return_trace (true); |
| } |
| } |
| |
| protected: |
| union { |
| struct { |
| Tag ttcTag; /* TrueType Collection ID string: 'ttcf' */ |
| FixedVersion<>version; /* Version of the TTC Header (1.0 or 2.0), |
| * 0x00010000u or 0x00020000u */ |
| } header; |
| TTCHeaderVersion1 version1; |
| } u; |
| }; |
| |
| /* |
| * Mac Resource Fork |
| * |
| * http://mirror.informatimago.com/next/developer.apple.com/documentation/mac/MoreToolbox/MoreToolbox-99.html |
| */ |
| |
| struct ResourceRecord |
| { |
| const OpenTypeFontFace & get_face (const void *data_base) const |
| { return * reinterpret_cast<const OpenTypeFontFace *> ((data_base+offset).arrayZ); } |
| |
| bool sanitize (hb_sanitize_context_t *c, |
| const void *data_base) const |
| { |
| TRACE_SANITIZE (this); |
| return_trace (c->check_struct (this) && |
| offset.sanitize (c, data_base) && |
| get_face (data_base).sanitize (c)); |
| } |
| |
| protected: |
| HBUINT16 id; /* Resource ID. */ |
| HBINT16 nameOffset; /* Offset from beginning of resource name list |
| * to resource name, -1 means there is none. */ |
| HBUINT8 attrs; /* Resource attributes */ |
| NNOffset24To<Array32Of<HBUINT8>> |
| offset; /* Offset from beginning of data block to |
| * data for this resource */ |
| HBUINT32 reserved; /* Reserved for handle to resource */ |
| public: |
| DEFINE_SIZE_STATIC (12); |
| }; |
| |
| #define HB_TAG_sfnt HB_TAG ('s','f','n','t') |
| |
| struct ResourceTypeRecord |
| { |
| unsigned int get_resource_count () const |
| { return tag == HB_TAG_sfnt ? resCountM1 + 1 : 0; } |
| |
| bool is_sfnt () const { return tag == HB_TAG_sfnt; } |
| |
| const ResourceRecord& get_resource_record (unsigned int i, |
| const void *type_base) const |
| { return (type_base+resourcesZ).as_array (get_resource_count ())[i]; } |
| |
| bool sanitize (hb_sanitize_context_t *c, |
| const void *type_base, |
| const void *data_base) const |
| { |
| TRACE_SANITIZE (this); |
| return_trace (c->check_struct (this) && |
| resourcesZ.sanitize (c, type_base, |
| get_resource_count (), |
| data_base)); |
| } |
| |
| protected: |
| Tag tag; /* Resource type. */ |
| HBUINT16 resCountM1; /* Number of resources minus 1. */ |
| NNOffset16To<UnsizedArrayOf<ResourceRecord>> |
| resourcesZ; /* Offset from beginning of resource type list |
| * to reference item list for this type. */ |
| public: |
| DEFINE_SIZE_STATIC (8); |
| }; |
| |
| struct ResourceMap |
| { |
| unsigned int get_face_count () const |
| { |
| unsigned int count = get_type_count (); |
| for (unsigned int i = 0; i < count; i++) |
| { |
| const ResourceTypeRecord& type = get_type_record (i); |
| if (type.is_sfnt ()) |
| return type.get_resource_count (); |
| } |
| return 0; |
| } |
| |
| const OpenTypeFontFace& get_face (unsigned int idx, |
| const void *data_base) const |
| { |
| unsigned int count = get_type_count (); |
| for (unsigned int i = 0; i < count; i++) |
| { |
| const ResourceTypeRecord& type = get_type_record (i); |
| /* The check for idx < count is here because ResourceRecord is NOT null-safe. |
| * Because an offset of 0 there does NOT mean null. */ |
| if (type.is_sfnt () && idx < type.get_resource_count ()) |
| return type.get_resource_record (idx, &(this+typeList)).get_face (data_base); |
| } |
| return Null (OpenTypeFontFace); |
| } |
| |
| bool sanitize (hb_sanitize_context_t *c, const void *data_base) const |
| { |
| TRACE_SANITIZE (this); |
| return_trace (c->check_struct (this) && |
| typeList.sanitize (c, this, |
| &(this+typeList), |
| data_base)); |
| } |
| |
| private: |
| unsigned int get_type_count () const { return (this+typeList).lenM1 + 1; } |
| |
| const ResourceTypeRecord& get_type_record (unsigned int i) const |
| { return (this+typeList)[i]; } |
| |
| protected: |
| HBUINT8 reserved0[16]; /* Reserved for copy of resource header */ |
| HBUINT32 reserved1; /* Reserved for handle to next resource map */ |
| HBUINT16 resreved2; /* Reserved for file reference number */ |
| HBUINT16 attrs; /* Resource fork attribute */ |
| NNOffset16To<ArrayOfM1<ResourceTypeRecord>> |
| typeList; /* Offset from beginning of map to |
| * resource type list */ |
| Offset16 nameList; /* Offset from beginning of map to |
| * resource name list */ |
| public: |
| DEFINE_SIZE_STATIC (28); |
| }; |
| |
| struct ResourceForkHeader |
| { |
| unsigned int get_face_count () const |
| { return (this+map).get_face_count (); } |
| |
| const OpenTypeFontFace& get_face (unsigned int idx, |
| unsigned int *base_offset = nullptr) const |
| { |
| const OpenTypeFontFace &face = (this+map).get_face (idx, &(this+data)); |
| if (base_offset) |
| *base_offset = (const char *) &face - (const char *) this; |
| return face; |
| } |
| |
| bool sanitize (hb_sanitize_context_t *c) const |
| { |
| TRACE_SANITIZE (this); |
| return_trace (c->check_struct (this) && |
| data.sanitize (c, this, dataLen) && |
| map.sanitize (c, this, &(this+data))); |
| } |
| |
| protected: |
| NNOffset32To<UnsizedArrayOf<HBUINT8>> |
| data; /* Offset from beginning of resource fork |
| * to resource data */ |
| NNOffset32To<ResourceMap > |
| map; /* Offset from beginning of resource fork |
| * to resource map */ |
| HBUINT32 dataLen; /* Length of resource data */ |
| HBUINT32 mapLen; /* Length of resource map */ |
| public: |
| DEFINE_SIZE_STATIC (16); |
| }; |
| |
| /* |
| * OpenType Font File |
| */ |
| |
| struct OpenTypeFontFile |
| { |
| enum { |
| CFFTag = HB_TAG ('O','T','T','O'), /* OpenType with Postscript outlines */ |
| TrueTypeTag = HB_TAG ( 0 , 1 , 0 , 0 ), /* OpenType with TrueType outlines */ |
| TTCTag = HB_TAG ('t','t','c','f'), /* TrueType Collection */ |
| DFontTag = HB_TAG ( 0 , 0 , 1 , 0 ), /* DFont Mac Resource Fork */ |
| TrueTag = HB_TAG ('t','r','u','e'), /* Obsolete Apple TrueType */ |
| Typ1Tag = HB_TAG ('t','y','p','1') /* Obsolete Apple Type1 font in SFNT container */ |
| }; |
| |
| hb_tag_t get_tag () const { return u.tag; } |
| |
| unsigned int get_face_count () const |
| { |
| switch (u.tag) { |
| case CFFTag: /* All the non-collection tags */ |
| case TrueTag: |
| case Typ1Tag: |
| case TrueTypeTag: return 1; |
| case TTCTag: return u.ttcHeader.get_face_count (); |
| case DFontTag: return u.rfHeader.get_face_count (); |
| default: return 0; |
| } |
| } |
| const OpenTypeFontFace& get_face (unsigned int i, unsigned int *base_offset = nullptr) const |
| { |
| if (base_offset) |
| *base_offset = 0; |
| switch (u.tag) { |
| /* Note: for non-collection SFNT data we ignore index. This is because |
| * Apple dfont container is a container of SFNT's. So each SFNT is a |
| * non-TTC, but the index is more than zero. */ |
| case CFFTag: /* All the non-collection tags */ |
| case TrueTag: |
| case Typ1Tag: |
| case TrueTypeTag: return u.fontFace; |
| case TTCTag: return u.ttcHeader.get_face (i); |
| case DFontTag: return u.rfHeader.get_face (i, base_offset); |
| default: return Null (OpenTypeFontFace); |
| } |
| } |
| |
| template <typename Iterator, |
| hb_requires ((hb_is_source_of<Iterator, hb_pair_t<hb_tag_t, hb_blob_t *>>::value))> |
| bool serialize_single (hb_serialize_context_t *c, |
| hb_tag_t sfnt_tag, |
| Iterator items) |
| { |
| TRACE_SERIALIZE (this); |
| assert (sfnt_tag != TTCTag); |
| if (unlikely (!c->extend_min (this))) return_trace (false); |
| return_trace (u.fontFace.serialize (c, sfnt_tag, items)); |
| } |
| |
| bool sanitize (hb_sanitize_context_t *c) const |
| { |
| TRACE_SANITIZE (this); |
| if (unlikely (!u.tag.sanitize (c))) return_trace (false); |
| switch (u.tag) { |
| case CFFTag: /* All the non-collection tags */ |
| case TrueTag: |
| case Typ1Tag: |
| case TrueTypeTag: return_trace (u.fontFace.sanitize (c)); |
| case TTCTag: return_trace (u.ttcHeader.sanitize (c)); |
| case DFontTag: return_trace (u.rfHeader.sanitize (c)); |
| default: return_trace (true); |
| } |
| } |
| |
| protected: |
| union { |
| Tag tag; /* 4-byte identifier. */ |
| OpenTypeFontFace fontFace; |
| TTCHeader ttcHeader; |
| ResourceForkHeader rfHeader; |
| } u; |
| public: |
| DEFINE_SIZE_UNION (4, tag); |
| }; |
| |
| |
| } /* namespace OT */ |
| |
| |
| #endif /* HB_OPEN_FILE_HH */ |