src/hb-open-file-private.hh

   1 /*
   2  * Copyright (C) 2007,2008,2009  Red Hat, 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  * Red Hat Author(s): Behdad Esfahbod
  25  */
  26
  27 #ifndef HB_OPEN_FILE_PRIVATE_HH
  28 #define HB_OPEN_FILE_PRIVATE_HH
  29
  30 #include "hb-open-type-private.hh"
  31
  32
  33 /*
  34  *
  35  * The OpenType Font File
  36  *
  37  */
  38
  39
  40 /*
  41  * Organization of an OpenType Font
  42  */
  43
  44 struct OpenTypeFontFile;
  45 struct OffsetTable;
  46 struct TTCHeader;
  47
  48 typedef struct TableDirectory
  49 {
  50   static inline unsigned int get_size () { return sizeof (TableDirectory); }
  51
  52   inline bool sanitize (SANITIZE_ARG_DEF) {
  53     TRACE_SANITIZE ();
  54     return SANITIZE_SELF ();
  55   }
  56
  57   Tag           tag;            /* 4-byte identifier. */
  58   CheckSum      checkSum;       /* CheckSum for this table. */
  59   ULONG         offset;         /* Offset from beginning of TrueType font
  60                                  * file. */
  61   ULONG         length;         /* Length of this table. */
  62 } OpenTypeTable;
  63 ASSERT_SIZE (TableDirectory, 16);
  64
  65 typedef struct OffsetTable
  66 {
  67   friend struct OpenTypeFontFile;
  68
  69   STATIC_DEFINE_GET_FOR_DATA (OffsetTable);
  70
  71   inline unsigned int get_table_count (void) const
  72   { return numTables; }
  73   inline const Tag& get_table_tag (unsigned int i) const
  74   {
  75     if (HB_UNLIKELY (i >= numTables)) return Null(Tag);
  76     return tableDir[i].tag;
  77   }
  78   inline const TableDirectory& get_table (unsigned int i) const
  79   {
  80     if (HB_UNLIKELY (i >= numTables)) return Null(TableDirectory);
  81     return tableDir[i];
  82   }
  83   inline bool find_table_index (hb_tag_t tag, unsigned int *table_index) const
  84   {
  85     Tag t;
  86     t.set (tag);
  87     /* TODO: bsearch (need to sort in sanitize) */
  88     unsigned int count = numTables;
  89     for (unsigned int i = 0; i < count; i++)
  90     {
  91       if (t == tableDir[i].tag)
  92       {
  93         if (table_index) *table_index = i;
  94         return true;
  95       }
  96     }
  97     if (table_index) *table_index = NO_INDEX;
  98     return false;
  99   }
 100   inline const TableDirectory& get_table_by_tag (hb_tag_t tag) const
 101   {
 102     unsigned int table_index;
 103     find_table_index (tag, &table_index);
 104     return get_table (table_index);
 105   }
 106
 107   public:
 108   inline bool sanitize (SANITIZE_ARG_DEF) {
 109     TRACE_SANITIZE ();
 110     return SANITIZE_SELF () && SANITIZE_ARRAY (tableDir, TableDirectory::get_size (), numTables);
 111   }
 112
 113   private:
 114   Tag           sfnt_version;   /* '\0\001\0\00' if TrueType / 'OTTO' if CFF */
 115   USHORT        numTables;      /* Number of tables. */
 116   USHORT        searchRange;    /* (Maximum power of 2 <= numTables) x 16 */
 117   USHORT        entrySelector;  /* Log2(maximum power of 2 <= numTables). */
 118   USHORT        rangeShift;     /* NumTables x 16-searchRange. */
 119   TableDirectory tableDir[VAR]; /* TableDirectory entries. numTables items */
 120 } OpenTypeFontFace;
 121 ASSERT_SIZE_VAR (OffsetTable, 12, TableDirectory);
 122
 123 /*
 124  * TrueType Collections
 125  */
 126
 127 struct TTCHeaderVersion1
 128 {
 129   friend struct TTCHeader;
 130
 131   inline unsigned int get_face_count (void) const { return table.len; }
 132   inline const OpenTypeFontFace& get_face (unsigned int i) const { return this+table[i]; }
 133
 134   inline bool sanitize (SANITIZE_ARG_DEF) {
 135     TRACE_SANITIZE ();
 136     return SANITIZE_THIS (table);
 137   }
 138
 139   private:
 140   Tag           ttcTag;         /* TrueType Collection ID string: 'ttcf' */
 141   FixedVersion  version;        /* Version of the TTC Header (1.0),
 142                                  * 0x00010000 */
 143   LongOffsetLongArrayOf<OffsetTable>
 144                 table;          /* Array of offsets to the OffsetTable for each font
 145                                  * from the beginning of the file */
 146 };
 147 ASSERT_SIZE (TTCHeaderVersion1, 12);
 148
 149 struct TTCHeader
 150 {
 151   friend struct OpenTypeFontFile;
 152
 153   private:
 154
 155   inline unsigned int get_face_count (void) const
 156   {
 157     switch (u.header.version) {
 158     case 2: /* version 2 is compatible with version 1 */
 159     case 1: return u.version1->get_face_count ();
 160     default:return 0;
 161     }
 162   }
 163   inline const OpenTypeFontFace& get_face (unsigned int i) const
 164   {
 165     switch (u.header.version) {
 166     case 2: /* version 2 is compatible with version 1 */
 167     case 1: return u.version1->get_face (i);
 168     default:return Null(OpenTypeFontFace);
 169     }
 170   }
 171
 172   inline bool sanitize (SANITIZE_ARG_DEF) {
 173     TRACE_SANITIZE ();
 174     if (!SANITIZE (u.header.version)) return false;
 175     switch (u.header.version) {
 176     case 2: /* version 2 is compatible with version 1 */
 177     case 1: return u.version1->sanitize (SANITIZE_ARG);
 178     default:return true;
 179     }
 180   }
 181
 182   private:
 183   union {
 184   struct {
 185   Tag           ttcTag;         /* TrueType Collection ID string: 'ttcf' */
 186   FixedVersion  version;        /* Version of the TTC Header (1.0 or 2.0),
 187                                  * 0x00010000 or 0x00020000 */
 188   }                     header;
 189   TTCHeaderVersion1     version1[VAR];
 190   } u;
 191 };
 192
 193
 194 /*
 195  * OpenType Font File
 196  */
 197
 198 struct OpenTypeFontFile
 199 {
 200   static const hb_tag_t CFFTag          = HB_TAG ('O','T','T','O');
 201   static const hb_tag_t TrueTypeTag     = HB_TAG ( 0 , 1 , 0 , 0 );
 202   static const hb_tag_t TTCTag          = HB_TAG ('t','t','c','f');
 203
 204   STATIC_DEFINE_GET_FOR_DATA (OpenTypeFontFile);
 205
 206   inline hb_tag_t get_tag (void) const { return u.tag; }
 207
 208   inline unsigned int get_face_count (void) const
 209   {
 210     switch (u.tag) {
 211     case CFFTag:        /* All the non-collection tags */
 212     case TrueTypeTag:   return 1;
 213     case TTCTag:        return u.ttcHeader->get_face_count ();
 214     default:            return 0;
 215     }
 216   }
 217   inline const OpenTypeFontFace& get_face (unsigned int i) const
 218   {
 219     switch (u.tag) {
 220     /* Note: for non-collection SFNT data we ignore index.  This is because
 221      * Apple dfont container is a container of SFNT's.  So each SFNT is a
 222      * non-TTC, but the index is more than zero. */
 223     case CFFTag:        /* All the non-collection tags */
 224     case TrueTypeTag:   return u.fontFace[0];
 225     case TTCTag:        return u.ttcHeader->get_face (i);
 226     default:            return Null(OpenTypeFontFace);
 227     }
 228   }
 229
 230   inline bool sanitize (SANITIZE_ARG_DEF) {
 231     TRACE_SANITIZE ();
 232     if (!SANITIZE (u.tag)) return false;
 233     switch (u.tag) {
 234     case CFFTag:        /* All the non-collection tags */
 235     case TrueTypeTag:   return u.fontFace->sanitize (SANITIZE_ARG);
 236     case TTCTag:        return u.ttcHeader->sanitize (SANITIZE_ARG);
 237     default:            return true;
 238     }
 239   }
 240
 241   private:
 242   union {
 243   Tag                   tag;            /* 4-byte identifier. */
 244   OpenTypeFontFace      fontFace[VAR];
 245   TTCHeader             ttcHeader[VAR];
 246   } u;
 247 };
 248 ASSERT_SIZE (OpenTypeFontFile, 4);
 249
 250
 251 #endif /* HB_OPEN_FILE_PRIVATE_HH */