?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SyncFS] Use variadic template in callback_tracker_internal.h
[chromium-blink-merge.git] / third_party / harfbuzz-ng / src / hb-ot-cmap-table.hh
blobd53141157d0d5992ba876dcd5a9af634d70947bf
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 */