1 /*
2 * Copyright © 2016 Elie Roux <elie.roux@telecom-bretagne.eu>
3 * Copyright © 2018 Google, Inc.
4 * Copyright © 2018 Ebrahim Byagowi
5 *
6 * This is part of HarfBuzz, a text shaping library.
7 *
8 * Permission is hereby granted, without written agreement and without
9 * license or royalty fees, to use, copy, modify, and distribute this
10 * software and its documentation for any purpose, provided that the
11 * above copyright notice and the following two paragraphs appear in
12 * all copies of this software.
13 *
14 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
15 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
16 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
17 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
18 * DAMAGE.
19 *
20 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
21 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
22 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
23 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
24 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
25 *
26 * Google Author(s): Behdad Esfahbod
27 */
28
29 #ifndef HB_OT_LAYOUT_BASE_TABLE_HH
30 #define HB_OT_LAYOUT_BASE_TABLE_HH
31
32 #include "hb-open-type.hh"
33 #include "hb-ot-layout-common.hh"
34
35 /* To be removed */
36 typedef hb_tag_t hb_ot_layout_baseline_t;
37
38 namespace OT {
39
40 /*
41 * BASE -- Baseline
42 * https://docs.microsoft.com/en-us/typography/opentype/spec/base
43 */
44
45 struct BaseCoordFormat1
46 {
47 hb_position_t get_coord () const { return coordinate; }
48
49 bool sanitize (hb_sanitize_context_t *c) const
50 {
51 TRACE_SANITIZE (this);
52 return_trace (likely (c->check_struct (this)));
53 }
54
55 protected:
56 HBUINT16 format; /* Format identifier--format = 1 */
57 FWORD coordinate; /* X or Y value, in design units */
58 public:
59 DEFINE_SIZE_STATIC (4);
60 };
61
62 struct BaseCoordFormat2
63 {
64 hb_position_t get_coord () const
65 {
66 /* TODO */
67 return coordinate;
68 }
69
70 bool sanitize (hb_sanitize_context_t *c) const
71 {
72 TRACE_SANITIZE (this);
73 return_trace (c->check_struct (this));
74 }
75
76 protected:
77 HBUINT16 format; /* Format identifier--format = 2 */
78 FWORD coordinate; /* X or Y value, in design units */
79 GlyphID referenceGlyph; /* Glyph ID of control glyph */
80 HBUINT16 coordPoint; /* Index of contour point on the
81 * reference glyph */
82 public:
83 DEFINE_SIZE_STATIC (8);
84 };
85
86 struct BaseCoordFormat3
87 {
88 hb_position_t get_coord (hb_font_t *font,
89 const VariationStore &var_store,
90 hb_direction_t direction) const
91 {
92 const Device &device = this+deviceTable;
93 return coordinate + (HB_DIRECTION_IS_VERTICAL (direction) ?
94 device.get_y_delta (font, var_store) :
95 device.get_x_delta (font, var_store));
96 }
97
98
99 bool sanitize (hb_sanitize_context_t *c) const
100 {
101 TRACE_SANITIZE (this);
102 return_trace (likely (c->check_struct (this) &&
103 deviceTable.sanitize (c, this)));
104 }
105
106 protected:
107 HBUINT16 format; /* Format identifier--format = 3 */
108 FWORD coordinate; /* X or Y value, in design units */
109 OffsetTo<Device>
110 deviceTable; /* Offset to Device table for X or
111 * Y value, from beginning of
112 * BaseCoord table (may be NULL). */
113 public:
114 DEFINE_SIZE_STATIC (6);
115 };
116
117 struct BaseCoord
118 {
119 hb_position_t get_coord (hb_font_t *font,
120 const VariationStore &var_store,
121 hb_direction_t direction) const
122 {
123 switch (u.format) {
124 case 1: return u.format1.get_coord ();
125 case 2: return u.format2.get_coord ();
126 case 3: return u.format3.get_coord (font, var_store, direction);
127 default:return 0;
128 }
129 }
130
131 bool sanitize (hb_sanitize_context_t *c) const
132 {
133 TRACE_SANITIZE (this);
134 if (unlikely (!u.format.sanitize (c))) return_trace (false);
135 switch (u.format) {
136 case 1: return_trace (u.format1.sanitize (c));
137 case 2: return_trace (u.format2.sanitize (c));
138 case 3: return_trace (u.format3.sanitize (c));
139 default:return_trace (false);
140 }
141 }
142
143 protected:
144 union {
145 HBUINT16 format;
146 BaseCoordFormat1 format1;
147 BaseCoordFormat2 format2;
148 BaseCoordFormat3 format3;
149 } u;
150 public:
151 DEFINE_SIZE_UNION (2, format);
152 };
153
154 struct FeatMinMaxRecord
155 {
156 static int cmp (const void *key_, const void *entry_)
157 {
158 hb_tag_t key = * (hb_tag_t *) key_;
159 const FeatMinMaxRecord &entry = * (const FeatMinMaxRecord *) entry_;
160 return key < (unsigned int) entry.tag ? -1 :
161 key > (unsigned int) entry.tag ? 1 :
162 0;
163 }
164
165 void get_min_max (const BaseCoord **min, const BaseCoord **max) const
166 {
167 if (likely (min)) *min = &(this+minCoord);
168 if (likely (max)) *max = &(this+maxCoord);
169 }
170
171 bool sanitize (hb_sanitize_context_t *c, const void *base) const
172 {
173 TRACE_SANITIZE (this);
174 return_trace (likely (c->check_struct (this) &&
175 minCoord.sanitize (c, this) &&
176 maxCoord.sanitize (c, this)));
177 }
178
179 protected:
180 Tag tag; /* 4-byte feature identification tag--must
181 * match feature tag in FeatureList */
182 OffsetTo<BaseCoord>
183 minCoord; /* Offset to BaseCoord table that defines
184 * the minimum extent value, from beginning
185 * of MinMax table (may be NULL) */
186 OffsetTo<BaseCoord>
187 maxCoord; /* Offset to BaseCoord table that defines
188 * the maximum extent value, from beginning
189 * of MinMax table (may be NULL) */
190 public:
191 DEFINE_SIZE_STATIC (8);
192
193 };
194
195 struct MinMax
196 {
197 void get_min_max (hb_tag_t feature_tag,
198 const BaseCoord **min,
199 const BaseCoord **max) const
200 {
201 /* TODO Replace hb_bsearch() with .bsearch(). */
202 const FeatMinMaxRecord *minMaxCoord = (const FeatMinMaxRecord *)
203 hb_bsearch (&feature_tag, featMinMaxRecords.arrayZ,
204 featMinMaxRecords.len,
205 FeatMinMaxRecord::static_size,
206 FeatMinMaxRecord::cmp);
207 if (minMaxCoord)
208 minMaxCoord->get_min_max (min, max);
209 else
210 {
211 if (likely (min)) *min = &(this+minCoord);
212 if (likely (max)) *max = &(this+maxCoord);
213 }
214 }
215
216 bool sanitize (hb_sanitize_context_t *c) const
217 {
218 TRACE_SANITIZE (this);
219 return_trace (likely (c->check_struct (this) &&
220 minCoord.sanitize (c, this) &&
221 maxCoord.sanitize (c, this) &&
222 featMinMaxRecords.sanitize (c, this)));
223 }
224
225 protected:
226 OffsetTo<BaseCoord>
227 minCoord; /* Offset to BaseCoord table that defines
228 * minimum extent value, from the beginning
229 * of MinMax table (may be NULL) */
230 OffsetTo<BaseCoord>
231 maxCoord; /* Offset to BaseCoord table that defines
232 * maximum extent value, from the beginning
233 * of MinMax table (may be NULL) */
234 SortedArrayOf<FeatMinMaxRecord>
235 featMinMaxRecords;
236 /* Array of FeatMinMaxRecords, in alphabetical
237 * order by featureTableTag */
238 public:
239 DEFINE_SIZE_ARRAY (6, featMinMaxRecords);
240 };
241
242 struct BaseValues
243 {
244 const BaseCoord &get_base_coord (int baseline_tag_index) const
245 {
246 if (baseline_tag_index == -1) baseline_tag_index = defaultIndex;
247 return this+baseCoords[baseline_tag_index];
248 }
249
250 bool sanitize (hb_sanitize_context_t *c) const
251 {
252 TRACE_SANITIZE (this);
253 return_trace (likely (c->check_struct (this) &&
254 baseCoords.sanitize (c, this)));
255 }
256
257 protected:
258 Index defaultIndex; /* Index number of default baseline for this
259 * script — equals index position of baseline tag
260 * in baselineTags array of the BaseTagList */
261 OffsetArrayOf<BaseCoord>
262 baseCoords; /* Number of BaseCoord tables defined — should equal
263 * baseTagCount in the BaseTagList
264 *
265 * Array of offsets to BaseCoord tables, from beginning of
266 * BaseValues table — order matches baselineTags array in
267 * the BaseTagList */
268 public:
269 DEFINE_SIZE_ARRAY (4, baseCoords);
270 };
271
272 struct BaseLangSysRecord
273 {
274 static int cmp (const void *key_, const void *entry_)
275 {
276 hb_tag_t key = * (hb_tag_t *) key_;
277 const BaseLangSysRecord &entry = * (const BaseLangSysRecord *) entry_;
278 return key < (unsigned int) entry.baseLangSysTag ? -1 :
279 key > (unsigned int) entry.baseLangSysTag ? 1 :
280 0;
281 }
282
283 const MinMax &get_min_max () const
284 { return this+minMax; }
285
286 bool sanitize (hb_sanitize_context_t *c, const void *base) const
287 {
288 TRACE_SANITIZE (this);
289 return_trace (likely (c->check_struct (this) &&
290 minMax.sanitize (c, this)));
291 }
292
293 protected:
294 Tag baseLangSysTag; /* 4-byte language system identification tag */
295 OffsetTo<MinMax>
296 minMax; /* Offset to MinMax table, from beginning
297 * of BaseScript table */
298 public:
299 DEFINE_SIZE_STATIC (6);
300 };
301
302 struct BaseScript
303 {
304 const MinMax &get_min_max (hb_tag_t language_tag) const
305 {
306 /* TODO Replace hb_bsearch() with .bsearch(). */
307 const BaseLangSysRecord* record = (const BaseLangSysRecord *)
308 hb_bsearch (&language_tag, baseLangSysRecords.arrayZ,
309 baseLangSysRecords.len,
310 BaseLangSysRecord::static_size,
311 BaseLangSysRecord::cmp);
312 return record ? record->get_min_max () : this+defaultMinMax;
313 }
314
315 const BaseCoord &get_base_coord (int baseline_tag_index) const
316 { return (this+baseValues).get_base_coord (baseline_tag_index); }
317
318 bool is_empty () const { return !baseValues; }
319
320 bool sanitize (hb_sanitize_context_t *c) const
321 {
322 TRACE_SANITIZE (this);
323 return_trace (likely (c->check_struct (this) &&
324 baseValues.sanitize (c, this) &&
325 defaultMinMax.sanitize (c, this) &&
326 baseLangSysRecords.sanitize (c, this)));
327 }
328
329 protected:
330 OffsetTo<BaseValues>
331 baseValues; /* Offset to BaseValues table, from beginning
332 * of BaseScript table (may be NULL) */
333 OffsetTo<MinMax>
334 defaultMinMax; /* Offset to MinMax table, from beginning of
335 * BaseScript table (may be NULL) */
336 SortedArrayOf<BaseLangSysRecord>
337 baseLangSysRecords;
338 /* Number of BaseLangSysRecords
339 * defined — may be zero (0) */
340
341 public:
342 DEFINE_SIZE_ARRAY (6, baseLangSysRecords);
343 };
344
345 struct BaseScriptList;
346 struct BaseScriptRecord
347 {
348 static int cmp (const void *key_, const void *entry_)
349 {
350 hb_tag_t key = * (hb_tag_t *) key_;
351 const BaseScriptRecord &entry = * (const BaseScriptRecord *) entry_;
352 return key < (unsigned int) entry.baseScriptTag ? -1 :
353 key > (unsigned int) entry.baseScriptTag ? 1 :
354 0;
355 }
356
357 const BaseScript &get_base_script (const BaseScriptList *list) const
358 { return list+baseScript; }
359
360 bool sanitize (hb_sanitize_context_t *c, const void *base) const
361 {
362 TRACE_SANITIZE (this);
363 return_trace (likely (c->check_struct (this) &&
364 baseScript.sanitize (c, base)));
365 }
366
367 protected:
368 Tag baseScriptTag; /* 4-byte script identification tag */
369 OffsetTo<BaseScript>
370 baseScript; /* Offset to BaseScript table, from beginning
371 * of BaseScriptList */
372
373 public:
374 DEFINE_SIZE_STATIC (6);
375 };
376
377 struct BaseScriptList
378 {
379 const BaseScriptRecord *find_record (hb_tag_t script) const
380 {
381 /* TODO Replace hb_bsearch() with .bsearch(). */
382 return (const BaseScriptRecord *) hb_bsearch (&script, baseScriptRecords.arrayZ,
383 baseScriptRecords.len,
384 BaseScriptRecord::static_size,
385 BaseScriptRecord::cmp);
386 }
387
388 /* TODO: Or client should handle fallback? */
389 const BaseScript &get_base_script (hb_tag_t script) const
390 {
391 const BaseScriptRecord *record = find_record (script);
392 if (!record) record = find_record ((hb_script_t) HB_TAG ('D','F','L','T'));
393
394 return record ? record->get_base_script (this) : Null (BaseScript);
395 }
396
397 bool sanitize (hb_sanitize_context_t *c) const
398 {
399 TRACE_SANITIZE (this);
400 return_trace (c->check_struct (this) &&
401 baseScriptRecords.sanitize (c, this));
402 }
403
404 protected:
405 SortedArrayOf<BaseScriptRecord>
406 baseScriptRecords;
407
408 public:
409 DEFINE_SIZE_ARRAY (2, baseScriptRecords);
410 };
411
412 struct Axis
413 {
414 bool get_baseline (hb_ot_layout_baseline_t baseline,
415 hb_tag_t script_tag,
416 hb_tag_t language_tag,
417 const BaseCoord **coord) const
418 {
419 const BaseScript &base_script = (this+baseScriptList).get_base_script (script_tag);
420 if (base_script.is_empty ()) return false;
421
422 if (likely (coord)) *coord = &base_script.get_base_coord ((this+baseTagList).bsearch (baseline));
423
424 return true;
425 }
426
427 bool get_min_max (hb_tag_t script_tag,
428 hb_tag_t language_tag,
429 hb_tag_t feature_tag,
430 const BaseCoord **min_coord,
431 const BaseCoord **max_coord) const
432 {
433 const BaseScript &base_script = (this+baseScriptList).get_base_script (script_tag);
434 if (base_script.is_empty ()) return false;
435
436 base_script.get_min_max (language_tag).get_min_max (feature_tag, min_coord, max_coord);
437
438 return true;
439 }
440
441 bool sanitize (hb_sanitize_context_t *c) const
442 {
443 TRACE_SANITIZE (this);
444 return_trace (likely (c->check_struct (this) &&
445 (this+baseTagList).sanitize (c) &&
446 (this+baseScriptList).sanitize (c)));
447 }
448
449 protected:
450 OffsetTo<SortedArrayOf<Tag> >
451 baseTagList; /* Offset to BaseTagList table, from beginning
452 * of Axis table (may be NULL)
453 * Array of 4-byte baseline identification tags — must
454 * be in alphabetical order */
455 OffsetTo<BaseScriptList>
456 baseScriptList; /* Offset to BaseScriptList table, from beginning
457 * of Axis table
458 * Array of BaseScriptRecords, in alphabetical order
459 * by baseScriptTag */
460
461 public:
462 DEFINE_SIZE_STATIC (4);
463 };
464
465 struct BASE
466 {
467 static constexpr hb_tag_t tableTag = HB_OT_TAG_BASE;
468
469 const Axis &get_axis (hb_direction_t direction) const
470 { return HB_DIRECTION_IS_VERTICAL (direction) ? this+vAxis : this+hAxis; }
471
472 const VariationStore &get_var_store () const
473 { return version.to_int () < 0x00010001u ? Null (VariationStore) : this+varStore; }
474
475 bool get_baseline (hb_font_t *font,
476 hb_ot_layout_baseline_t baseline,
477 hb_direction_t direction,
478 hb_tag_t script_tag,
479 hb_tag_t language_tag,
480 hb_position_t *base) const
481 {
482 const BaseCoord *base_coord;
483 if (!get_axis (direction).get_baseline (baseline, script_tag, language_tag, &base_coord))
484 return false;
485
486 if (likely (base && base_coord)) *base = base_coord->get_coord (font,
487 get_var_store (),
488 direction);
489 return true;
490 }
491
492 /* TODO: Expose this separately sometime? */
493 bool get_min_max (hb_font_t *font,
494 hb_direction_t direction,
495 hb_tag_t script_tag,
496 hb_tag_t language_tag,
497 hb_tag_t feature_tag,
498 hb_position_t *min,
499 hb_position_t *max)
500 {
501 const BaseCoord *min_coord, *max_coord;
502 if (!get_axis (direction).get_min_max (script_tag, language_tag, feature_tag,
503 &min_coord, &max_coord))
504 return false;
505
506 const VariationStore &var_store = get_var_store ();
507 if (likely (min && min_coord)) *min = min_coord->get_coord (font, var_store, direction);
508 if (likely (max && max_coord)) *max = max_coord->get_coord (font, var_store, direction);
509 return true;
510 }
511
512 bool sanitize (hb_sanitize_context_t *c) const
513 {
514 TRACE_SANITIZE (this);
515 return_trace (likely (c->check_struct (this) &&
516 likely (version.major == 1) &&
517 hAxis.sanitize (c, this) &&
518 vAxis.sanitize (c, this) &&
519 (version.to_int () < 0x00010001u || varStore.sanitize (c, this))));
520 }
521
522 protected:
523 FixedVersion<>version; /* Version of the BASE table */
524 OffsetTo<Axis>hAxis; /* Offset to horizontal Axis table, from beginning
525 * of BASE table (may be NULL) */
526 OffsetTo<Axis>vAxis; /* Offset to vertical Axis table, from beginning
527 * of BASE table (may be NULL) */
528 LOffsetTo<VariationStore>
529 varStore; /* Offset to the table of Item Variation
530 * Store--from beginning of BASE
531 * header (may be NULL). Introduced
532 * in version 0x00010001. */
533 public:
534 DEFINE_SIZE_MIN (8);
535 };
536
537
538 } /* namespace OT */
539
540
541 #endif /* HB_OT_LAYOUT_BASE_TABLE_HH */