1 /* 2 * Copyright 2016 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): Seigo Nonaka 25 */ 26 27 #ifndef HB_OT_CBDT_TABLE_HH 28 #define HB_OT_CBDT_TABLE_HH 29 30 #include "hb-open-type-private.hh" 31 32 namespace OT { 33 34 struct SmallGlyphMetrics 35 { 36 inline bool sanitize (hb_sanitize_context_t *c) const 37 { 38 TRACE_SANITIZE (this); 39 return_trace (c->check_struct (this)); 40 } 41 42 inline void get_extents (hb_glyph_extents_t *extents) const 43 { 44 extents->x_bearing = bearingX; 45 extents->y_bearing = bearingY; 46 extents->width = width; 47 extents->height = -height; 48 } 49 50 BYTE height; 51 BYTE width; 52 CHAR bearingX; 53 CHAR bearingY; 54 BYTE advance; 55 56 DEFINE_SIZE_STATIC(5); 57 }; 58 59 struct BigGlyphMetrics : SmallGlyphMetrics 60 { 61 CHAR vertBearingX; 62 CHAR vertBearingY; 63 BYTE vertAdvance; 64 65 DEFINE_SIZE_STATIC(8); 66 }; 67 68 struct SBitLineMetrics 69 { 70 inline bool sanitize (hb_sanitize_context_t *c) const 71 { 72 TRACE_SANITIZE (this); 73 return_trace (c->check_struct (this)); 74 } 75 76 CHAR ascender; 77 CHAR decender; 78 BYTE widthMax; 79 CHAR caretSlopeNumerator; 80 CHAR caretSlopeDenominator; 81 CHAR caretOffset; 82 CHAR minOriginSB; 83 CHAR minAdvanceSB; 84 CHAR maxBeforeBL; 85 CHAR minAfterBL; 86 CHAR padding1; 87 CHAR padding2; 88 89 DEFINE_SIZE_STATIC(12); 90 }; 91 92 93 /* 94 * Index Subtables. 95 */ 96 97 struct IndexSubtableHeader 98 { 99 inline bool sanitize (hb_sanitize_context_t *c) const 100 { 101 TRACE_SANITIZE (this); 102 return_trace (c->check_struct (this)); 103 } 104 105 USHORT indexFormat; 106 USHORT imageFormat; 107 ULONG imageDataOffset; 108 109 DEFINE_SIZE_STATIC(8); 110 }; 111 112 template <typename OffsetType> 113 struct IndexSubtableFormat1Or3 114 { 115 inline bool sanitize (hb_sanitize_context_t *c, unsigned int glyph_count) const 116 { 117 TRACE_SANITIZE (this); 118 return_trace (c->check_struct (this) && 119 c->check_array (offsetArrayZ, offsetArrayZ[0].static_size, glyph_count + 1)); 120 } 121 122 bool get_image_data (unsigned int idx, 123 unsigned int *offset, 124 unsigned int *length) const 125 { 126 if (unlikely (offsetArrayZ[idx + 1] <= offsetArrayZ[idx])) 127 return false; 128 129 *offset = header.imageDataOffset + offsetArrayZ[idx]; 130 *length = offsetArrayZ[idx + 1] - offsetArrayZ[idx]; 131 return true; 132 } 133 134 IndexSubtableHeader header; 135 Offset<OffsetType> offsetArrayZ[VAR]; 136 137 DEFINE_SIZE_ARRAY(8, offsetArrayZ); 138 }; 139 140 struct IndexSubtableFormat1 : IndexSubtableFormat1Or3<ULONG> {}; 141 struct IndexSubtableFormat3 : IndexSubtableFormat1Or3<USHORT> {}; 142 143 struct IndexSubtable 144 { 145 inline bool sanitize (hb_sanitize_context_t *c, unsigned int glyph_count) const 146 { 147 TRACE_SANITIZE (this); 148 if (!u.header.sanitize (c)) return_trace (false); 149 switch (u.header.indexFormat) { 150 case 1: return_trace (u.format1.sanitize (c, glyph_count)); 151 case 3: return_trace (u.format3.sanitize (c, glyph_count)); 152 default:return_trace (true); 153 } 154 } 155 156 inline bool get_extents (hb_glyph_extents_t *extents) const 157 { 158 switch (u.header.indexFormat) { 159 case 2: case 5: /* TODO */ 160 case 1: case 3: case 4: /* Variable-metrics formats do not have metrics here. */ 161 default:return (false); 162 } 163 } 164 165 bool get_image_data (unsigned int idx, 166 unsigned int *offset, 167 unsigned int *length, 168 unsigned int *format) const 169 { 170 *format = u.header.imageFormat; 171 switch (u.header.indexFormat) { 172 case 1: return u.format1.get_image_data (idx, offset, length); 173 case 3: return u.format3.get_image_data (idx, offset, length); 174 default: return false; 175 } 176 } 177 178 protected: 179 union { 180 IndexSubtableHeader header; 181 IndexSubtableFormat1 format1; 182 IndexSubtableFormat3 format3; 183 /* TODO: Format 2, 4, 5. */ 184 } u; 185 public: 186 DEFINE_SIZE_UNION (8, header); 187 }; 188 189 struct IndexSubtableRecord 190 { 191 inline bool sanitize (hb_sanitize_context_t *c, const void *base) const 192 { 193 TRACE_SANITIZE (this); 194 return_trace (c->check_struct (this) && 195 firstGlyphIndex <= lastGlyphIndex && 196 offsetToSubtable.sanitize (c, this, lastGlyphIndex - firstGlyphIndex + 1)); 197 } 198 199 inline bool get_extents (hb_glyph_extents_t *extents) const 200 { 201 return (this+offsetToSubtable).get_extents (extents); 202 } 203 204 bool get_image_data (unsigned int gid, 205 unsigned int *offset, 206 unsigned int *length, 207 unsigned int *format) const 208 { 209 if (gid < firstGlyphIndex || gid > lastGlyphIndex) 210 { 211 return false; 212 } 213 return (this+offsetToSubtable).get_image_data (gid - firstGlyphIndex, 214 offset, length, format); 215 } 216 217 USHORT firstGlyphIndex; 218 USHORT lastGlyphIndex; 219 LOffsetTo<IndexSubtable> offsetToSubtable; 220 221 DEFINE_SIZE_STATIC(8); 222 }; 223 224 struct IndexSubtableArray 225 { 226 inline bool sanitize (hb_sanitize_context_t *c, unsigned int count) const 227 { 228 TRACE_SANITIZE (this); 229 if (unlikely (!c->check_array (&indexSubtablesZ, indexSubtablesZ[0].static_size, count))) 230 return_trace (false); 231 for (unsigned int i = 0; i < count; i++) 232 if (unlikely (!indexSubtablesZ[i].sanitize (c, this))) 233 return_trace (false); 234 return_trace (true); 235 } 236 237 public: 238 const IndexSubtableRecord* find_table (hb_codepoint_t glyph, unsigned int numTables) const 239 { 240 for (unsigned int i = 0; i < numTables; ++i) 241 { 242 unsigned int firstGlyphIndex = indexSubtablesZ[i].firstGlyphIndex; 243 unsigned int lastGlyphIndex = indexSubtablesZ[i].lastGlyphIndex; 244 if (firstGlyphIndex <= glyph && glyph <= lastGlyphIndex) { 245 return &indexSubtablesZ[i]; 246 } 247 } 248 return NULL; 249 } 250 251 protected: 252 IndexSubtableRecord indexSubtablesZ[VAR]; 253 254 public: 255 DEFINE_SIZE_ARRAY(0, indexSubtablesZ); 256 }; 257 258 struct BitmapSizeTable 259 { 260 friend struct CBLC; 261 262 inline bool sanitize (hb_sanitize_context_t *c, const void *base) const 263 { 264 TRACE_SANITIZE (this); 265 return_trace (c->check_struct (this) && 266 indexSubtableArrayOffset.sanitize (c, base, numberOfIndexSubtables) && 267 c->check_range (&(base+indexSubtableArrayOffset), indexTablesSize) && 268 horizontal.sanitize (c) && 269 vertical.sanitize (c)); 270 } 271 272 const IndexSubtableRecord *find_table (hb_codepoint_t glyph, const void *base) const 273 { 274 return (base+indexSubtableArrayOffset).find_table (glyph, numberOfIndexSubtables); 275 } 276 277 protected: 278 LOffsetTo<IndexSubtableArray> indexSubtableArrayOffset; 279 ULONG indexTablesSize; 280 ULONG numberOfIndexSubtables; 281 ULONG colorRef; 282 SBitLineMetrics horizontal; 283 SBitLineMetrics vertical; 284 USHORT startGlyphIndex; 285 USHORT endGlyphIndex; 286 BYTE ppemX; 287 BYTE ppemY; 288 BYTE bitDepth; 289 CHAR flags; 290 291 public: 292 DEFINE_SIZE_STATIC(48); 293 }; 294 295 296 /* 297 * Glyph Bitmap Data Formats. 298 */ 299 300 struct GlyphBitmapDataFormat17 301 { 302 SmallGlyphMetrics glyphMetrics; 303 ULONG dataLen; 304 BYTE dataZ[VAR]; 305 306 DEFINE_SIZE_ARRAY(9, dataZ); 307 }; 308 309 310 /* 311 * CBLC -- Color Bitmap Location Table 312 */ 313 314 #define HB_OT_TAG_CBLC HB_TAG('C','B','L','C') 315 316 struct CBLC 317 { 318 static const hb_tag_t tableTag = HB_OT_TAG_CBLC; 319 320 inline bool sanitize (hb_sanitize_context_t *c) const 321 { 322 TRACE_SANITIZE (this); 323 return_trace (c->check_struct (this) && 324 likely (version.major == 2 || version.major == 3) && 325 sizeTables.sanitize (c, this)); 326 } 327 328 public: 329 const IndexSubtableRecord *find_table (hb_codepoint_t glyph, 330 unsigned int *x_ppem, unsigned int *y_ppem) const 331 { 332 /* TODO: Make it possible to select strike. */ 333 334 unsigned int count = sizeTables.len; 335 for (uint32_t i = 0; i < count; ++i) 336 { 337 unsigned int startGlyphIndex = sizeTables.array[i].startGlyphIndex; 338 unsigned int endGlyphIndex = sizeTables.array[i].endGlyphIndex; 339 if (startGlyphIndex <= glyph && glyph <= endGlyphIndex) 340 { 341 *x_ppem = sizeTables[i].ppemX; 342 *y_ppem = sizeTables[i].ppemY; 343 return sizeTables[i].find_table (glyph, this); 344 } 345 } 346 347 return NULL; 348 } 349 350 protected: 351 FixedVersion<> version; 352 LArrayOf<BitmapSizeTable> sizeTables; 353 354 public: 355 DEFINE_SIZE_ARRAY(8, sizeTables); 356 }; 357 358 /* 359 * CBDT -- Color Bitmap Data Table 360 */ 361 #define HB_OT_TAG_CBDT HB_TAG('C','B','D','T') 362 363 struct CBDT 364 { 365 static const hb_tag_t tableTag = HB_OT_TAG_CBDT; 366 367 inline bool sanitize (hb_sanitize_context_t *c) const 368 { 369 TRACE_SANITIZE (this); 370 return_trace (c->check_struct (this) && 371 likely (version.major == 2 || version.major == 3)); 372 } 373 374 protected: 375 FixedVersion<>version; 376 BYTE dataZ[VAR]; 377 378 public: 379 DEFINE_SIZE_ARRAY(4, dataZ); 380 }; 381 382 } /* namespace OT */ 383 384 #endif /* HB_OT_CBDT_TABLE_HH */ 385
