1 /*
2 * Copyright © 2007,2008,2009,2010 Red Hat, Inc.
3 * Copyright © 2010,2012,2013 Google, Inc.
4 *
5 * This is part of HarfBuzz, a text shaping library.
6 *
7 * Permission is hereby granted, without written agreement and without
8 * license or royalty fees, to use, copy, modify, and distribute this
9 * software and its documentation for any purpose, provided that the
10 * above copyright notice and the following two paragraphs appear in
11 * all copies of this software.
12 *
13 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
14 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
15 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
16 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
17 * DAMAGE.
18 *
19 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
20 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
21 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
22 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
23 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
24 *
25 * Red Hat Author(s): Behdad Esfahbod
26 * Google Author(s): Behdad Esfahbod
27 */
28
29 #ifndef HB_OT_LAYOUT_GPOS_TABLE_HH
30 #define HB_OT_LAYOUT_GPOS_TABLE_HH
31
32 #include "hb-ot-layout-gsubgpos.hh"
33
34
35 namespace OT {
36
37
38 /* buffer **position** var allocations */
39 #define attach_chain() var.i16[0] /* glyph to which this attaches to, relative to current glyphs; negative for going back, positive for forward. */
40 #define attach_type() var.u8[2] /* attachment type */
41 /* Note! if attach_chain() is zero, the value of attach_type() is irrelevant. */
42
43 enum attach_type_t {
44 ATTACH_TYPE_NONE = 0X00,
45
46 /* Each attachment should be either a mark or a cursive; can't be both. */
47 ATTACH_TYPE_MARK = 0X01,
48 ATTACH_TYPE_CURSIVE = 0X02,
49 };
50
51
52 /* Shared Tables: ValueRecord, Anchor Table, and MarkArray */
53
54 typedef HBUINT16 Value;
55
56 typedef UnsizedArrayOf<Value> ValueRecord;
57
58 struct ValueFormat : HBUINT16
59 {
60 enum Flags {
61 xPlacement = 0x0001u, /* Includes horizontal adjustment for placement */
62 yPlacement = 0x0002u, /* Includes vertical adjustment for placement */
63 xAdvance = 0x0004u, /* Includes horizontal adjustment for advance */
64 yAdvance = 0x0008u, /* Includes vertical adjustment for advance */
65 xPlaDevice = 0x0010u, /* Includes horizontal Device table for placement */
66 yPlaDevice = 0x0020u, /* Includes vertical Device table for placement */
67 xAdvDevice = 0x0040u, /* Includes horizontal Device table for advance */
68 yAdvDevice = 0x0080u, /* Includes vertical Device table for advance */
69 ignored = 0x0F00u, /* Was used in TrueType Open for MM fonts */
70 reserved = 0xF000u, /* For future use */
71
72 devices = 0x00F0u /* Mask for having any Device table */
73 };
74
75 /* All fields are options. Only those available advance the value pointer. */
76 #if 0
77 HBINT16 xPlacement; /* Horizontal adjustment for
78 * placement--in design units */
79 HBINT16 yPlacement; /* Vertical adjustment for
80 * placement--in design units */
81 HBINT16 xAdvance; /* Horizontal adjustment for
82 * advance--in design units (only used
83 * for horizontal writing) */
84 HBINT16 yAdvance; /* Vertical adjustment for advance--in
85 * design units (only used for vertical
86 * writing) */
87 OffsetTo<Device> xPlaDevice; /* Offset to Device table for
88 * horizontal placement--measured from
89 * beginning of PosTable (may be NULL) */
90 OffsetTo<Device> yPlaDevice; /* Offset to Device table for vertical
91 * placement--measured from beginning
92 * of PosTable (may be NULL) */
93 OffsetTo<Device> xAdvDevice; /* Offset to Device table for
94 * horizontal advance--measured from
95 * beginning of PosTable (may be NULL) */
96 OffsetTo<Device> yAdvDevice; /* Offset to Device table for vertical
97 * advance--measured from beginning of
98 * PosTable (may be NULL) */
99 #endif
100
101 unsigned int get_len () const { return hb_popcount ((unsigned int) *this); }
102 unsigned int get_size () const { return get_len () * Value::static_size; }
103
104 bool apply_value (hb_ot_apply_context_t *c,
105 const void *base,
106 const Value *values,
107 hb_glyph_position_t &glyph_pos) const
108 {
109 bool ret = false;
110 unsigned int format = *this;
111 if (!format) return ret;
112
113 hb_font_t *font = c->font;
114 bool horizontal = HB_DIRECTION_IS_HORIZONTAL (c->direction);
115
116 if (format & xPlacement) glyph_pos.x_offset += font->em_scale_x (get_short (values++, &ret));
117 if (format & yPlacement) glyph_pos.y_offset += font->em_scale_y (get_short (values++, &ret));
118 if (format & xAdvance) {
119 if (likely (horizontal)) glyph_pos.x_advance += font->em_scale_x (get_short (values, &ret));
120 values++;
121 }
122 /* y_advance values grow downward but font-space grows upward, hence negation */
123 if (format & yAdvance) {
124 if (unlikely (!horizontal)) glyph_pos.y_advance -= font->em_scale_y (get_short (values, &ret));
125 values++;
126 }
127
128 if (!has_device ()) return ret;
129
130 bool use_x_device = font->x_ppem || font->num_coords;
131 bool use_y_device = font->y_ppem || font->num_coords;
132
133 if (!use_x_device && !use_y_device) return ret;
134
135 const VariationStore &store = c->var_store;
136
137 /* pixel -> fractional pixel */
138 if (format & xPlaDevice) {
139 if (use_x_device) glyph_pos.x_offset += (base + get_device (values, &ret)).get_x_delta (font, store);
140 values++;
141 }
142 if (format & yPlaDevice) {
143 if (use_y_device) glyph_pos.y_offset += (base + get_device (values, &ret)).get_y_delta (font, store);
144 values++;
145 }
146 if (format & xAdvDevice) {
147 if (horizontal && use_x_device) glyph_pos.x_advance += (base + get_device (values, &ret)).get_x_delta (font, store);
148 values++;
149 }
150 if (format & yAdvDevice) {
151 /* y_advance values grow downward but font-space grows upward, hence negation */
152 if (!horizontal && use_y_device) glyph_pos.y_advance -= (base + get_device (values, &ret)).get_y_delta (font, store);
153 values++;
154 }
155 return ret;
156 }
157
158 private:
159 bool sanitize_value_devices (hb_sanitize_context_t *c, const void *base, const Value *values) const
160 {
161 unsigned int format = *this;
162
163 if (format & xPlacement) values++;
164 if (format & yPlacement) values++;
165 if (format & xAdvance) values++;
166 if (format & yAdvance) values++;
167
168 if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
169 if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
170 if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
171 if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
172
173 return true;
174 }
175
176 static OffsetTo<Device>& get_device (Value* value)
177 { return *CastP<OffsetTo<Device> > (value); }
178 static const OffsetTo<Device>& get_device (const Value* value, bool *worked=nullptr)
179 {
180 if (worked) *worked |= bool (*value);
181 return *CastP<OffsetTo<Device> > (value);
182 }
183
184 static const HBINT16& get_short (const Value* value, bool *worked=nullptr)
185 {
186 if (worked) *worked |= bool (*value);
187 return *CastP<HBINT16> (value);
188 }
189
190 public:
191
192 bool has_device () const
193 {
194 unsigned int format = *this;
195 return (format & devices) != 0;
196 }
197
198 bool sanitize_value (hb_sanitize_context_t *c, const void *base, const Value *values) const
199 {
200 TRACE_SANITIZE (this);
201 return_trace (c->check_range (values, get_size ()) && (!has_device () || sanitize_value_devices (c, base, values)));
202 }
203
204 bool sanitize_values (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count) const
205 {
206 TRACE_SANITIZE (this);
207 unsigned int len = get_len ();
208
209 if (!c->check_range (values, count, get_size ())) return_trace (false);
210
211 if (!has_device ()) return_trace (true);
212
213 for (unsigned int i = 0; i < count; i++) {
214 if (!sanitize_value_devices (c, base, values))
215 return_trace (false);
216 values += len;
217 }
218
219 return_trace (true);
220 }
221
222 /* Just sanitize referenced Device tables. Doesn't check the values themselves. */
223 bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count, unsigned int stride) const
224 {
225 TRACE_SANITIZE (this);
226
227 if (!has_device ()) return_trace (true);
228
229 for (unsigned int i = 0; i < count; i++) {
230 if (!sanitize_value_devices (c, base, values))
231 return_trace (false);
232 values += stride;
233 }
234
235 return_trace (true);
236 }
237 };
238
239
240 struct AnchorFormat1
241 {
242 void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,
243 float *x, float *y) const
244 {
245 hb_font_t *font = c->font;
246 *x = font->em_fscale_x (xCoordinate);
247 *y = font->em_fscale_y (yCoordinate);
248 }
249
250 bool sanitize (hb_sanitize_context_t *c) const
251 {
252 TRACE_SANITIZE (this);
253 return_trace (c->check_struct (this));
254 }
255
256 protected:
257 HBUINT16 format; /* Format identifier--format = 1 */
258 FWORD xCoordinate; /* Horizontal value--in design units */
259 FWORD yCoordinate; /* Vertical value--in design units */
260 public:
261 DEFINE_SIZE_STATIC (6);
262 };
263
264 struct AnchorFormat2
265 {
266 void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id,
267 float *x, float *y) const
268 {
269 hb_font_t *font = c->font;
270 unsigned int x_ppem = font->x_ppem;
271 unsigned int y_ppem = font->y_ppem;
272 hb_position_t cx = 0, cy = 0;
273 bool ret;
274
275 ret = (x_ppem || y_ppem) &&
276 font->get_glyph_contour_point_for_origin (glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy);
277 *x = ret && x_ppem ? cx : font->em_fscale_x (xCoordinate);
278 *y = ret && y_ppem ? cy : font->em_fscale_y (yCoordinate);
279 }
280
281 bool sanitize (hb_sanitize_context_t *c) const
282 {
283 TRACE_SANITIZE (this);
284 return_trace (c->check_struct (this));
285 }
286
287 protected:
288 HBUINT16 format; /* Format identifier--format = 2 */
289 FWORD xCoordinate; /* Horizontal value--in design units */
290 FWORD yCoordinate; /* Vertical value--in design units */
291 HBUINT16 anchorPoint; /* Index to glyph contour point */
292 public:
293 DEFINE_SIZE_STATIC (8);
294 };
295
296 struct AnchorFormat3
297 {
298 void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,
299 float *x, float *y) const
300 {
301 hb_font_t *font = c->font;
302 *x = font->em_fscale_x (xCoordinate);
303 *y = font->em_fscale_y (yCoordinate);
304
305 if (font->x_ppem || font->num_coords)
306 *x += (this+xDeviceTable).get_x_delta (font, c->var_store);
307 if (font->y_ppem || font->num_coords)
308 *y += (this+yDeviceTable).get_y_delta (font, c->var_store);
309 }
310
311 bool sanitize (hb_sanitize_context_t *c) const
312 {
313 TRACE_SANITIZE (this);
314 return_trace (c->check_struct (this) && xDeviceTable.sanitize (c, this) && yDeviceTable.sanitize (c, this));
315 }
316
317 protected:
318 HBUINT16 format; /* Format identifier--format = 3 */
319 FWORD xCoordinate; /* Horizontal value--in design units */
320 FWORD yCoordinate; /* Vertical value--in design units */
321 OffsetTo<Device>
322 xDeviceTable; /* Offset to Device table for X
323 * coordinate-- from beginning of
324 * Anchor table (may be NULL) */
325 OffsetTo<Device>
326 yDeviceTable; /* Offset to Device table for Y
327 * coordinate-- from beginning of
328 * Anchor table (may be NULL) */
329 public:
330 DEFINE_SIZE_STATIC (10);
331 };
332
333 struct Anchor
334 {
335 void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id,
336 float *x, float *y) const
337 {
338 *x = *y = 0;
339 switch (u.format) {
340 case 1: u.format1.get_anchor (c, glyph_id, x, y); return;
341 case 2: u.format2.get_anchor (c, glyph_id, x, y); return;
342 case 3: u.format3.get_anchor (c, glyph_id, x, y); return;
343 default: return;
344 }
345 }
346
347 bool sanitize (hb_sanitize_context_t *c) const
348 {
349 TRACE_SANITIZE (this);
350 if (!u.format.sanitize (c)) return_trace (false);
351 switch (u.format) {
352 case 1: return_trace (u.format1.sanitize (c));
353 case 2: return_trace (u.format2.sanitize (c));
354 case 3: return_trace (u.format3.sanitize (c));
355 default:return_trace (true);
356 }
357 }
358
359 protected:
360 union {
361 HBUINT16 format; /* Format identifier */
362 AnchorFormat1 format1;
363 AnchorFormat2 format2;
364 AnchorFormat3 format3;
365 } u;
366 public:
367 DEFINE_SIZE_UNION (2, format);
368 };
369
370
371 struct AnchorMatrix
372 {
373 const Anchor& get_anchor (unsigned int row, unsigned int col,
374 unsigned int cols, bool *found) const
375 {
376 *found = false;
377 if (unlikely (row >= rows || col >= cols)) return Null(Anchor);
378 *found = !matrixZ[row * cols + col].is_null ();
379 return this+matrixZ[row * cols + col];
380 }
381
382 bool sanitize (hb_sanitize_context_t *c, unsigned int cols) const
383 {
384 TRACE_SANITIZE (this);
385 if (!c->check_struct (this)) return_trace (false);
386 if (unlikely (hb_unsigned_mul_overflows (rows, cols))) return_trace (false);
387 unsigned int count = rows * cols;
388 if (!c->check_array (matrixZ.arrayZ, count)) return_trace (false);
389 for (unsigned int i = 0; i < count; i++)
390 if (!matrixZ[i].sanitize (c, this)) return_trace (false);
391 return_trace (true);
392 }
393
394 HBUINT16 rows; /* Number of rows */
395 protected:
396 UnsizedArrayOf<OffsetTo<Anchor> >
397 matrixZ; /* Matrix of offsets to Anchor tables--
398 * from beginning of AnchorMatrix table */
399 public:
400 DEFINE_SIZE_ARRAY (2, matrixZ);
401 };
402
403
404 struct MarkRecord
405 {
406 friend struct MarkArray;
407
408 bool sanitize (hb_sanitize_context_t *c, const void *base) const
409 {
410 TRACE_SANITIZE (this);
411 return_trace (c->check_struct (this) && markAnchor.sanitize (c, base));
412 }
413
414 protected:
415 HBUINT16 klass; /* Class defined for this mark */
416 OffsetTo<Anchor>
417 markAnchor; /* Offset to Anchor table--from
418 * beginning of MarkArray table */
419 public:
420 DEFINE_SIZE_STATIC (4);
421 };
422
423 struct MarkArray : ArrayOf<MarkRecord> /* Array of MarkRecords--in Coverage order */
424 {
425 bool apply (hb_ot_apply_context_t *c,
426 unsigned int mark_index, unsigned int glyph_index,
427 const AnchorMatrix &anchors, unsigned int class_count,
428 unsigned int glyph_pos) const
429 {
430 TRACE_APPLY (this);
431 hb_buffer_t *buffer = c->buffer;
432 const MarkRecord &record = ArrayOf<MarkRecord>::operator[](mark_index);
433 unsigned int mark_class = record.klass;
434
435 const Anchor& mark_anchor = this + record.markAnchor;
436 bool found;
437 const Anchor& glyph_anchor = anchors.get_anchor (glyph_index, mark_class, class_count, &found);
438 /* If this subtable doesn't have an anchor for this base and this class,
439 * return false such that the subsequent subtables have a chance at it. */
440 if (unlikely (!found)) return_trace (false);
441
442 float mark_x, mark_y, base_x, base_y;
443
444 buffer->unsafe_to_break (glyph_pos, buffer->idx);
445 mark_anchor.get_anchor (c, buffer->cur().codepoint, &mark_x, &mark_y);
446 glyph_anchor.get_anchor (c, buffer->info[glyph_pos].codepoint, &base_x, &base_y);
447
448 hb_glyph_position_t &o = buffer->cur_pos();
449 o.x_offset = round (base_x - mark_x);
450 o.y_offset = round (base_y - mark_y);
451 o.attach_type() = ATTACH_TYPE_MARK;
452 o.attach_chain() = (int) glyph_pos - (int) buffer->idx;
453 buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
454
455 buffer->idx++;
456 return_trace (true);
457 }
458
459 bool sanitize (hb_sanitize_context_t *c) const
460 {
461 TRACE_SANITIZE (this);
462 return_trace (ArrayOf<MarkRecord>::sanitize (c, this));
463 }
464 };
465
466
467 /* Lookups */
468
469 struct SinglePosFormat1
470 {
471 bool intersects (const hb_set_t *glyphs) const
472 { return (this+coverage).intersects (glyphs); }
473
474 void collect_glyphs (hb_collect_glyphs_context_t *c) const
475 { if (unlikely (!(this+coverage).add_coverage (c->input))) return; }
476
477 const Coverage &get_coverage () const { return this+coverage; }
478
479 bool apply (hb_ot_apply_context_t *c) const
480 {
481 TRACE_APPLY (this);
482 hb_buffer_t *buffer = c->buffer;
483 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
484 if (likely (index == NOT_COVERED)) return_trace (false);
485
486 valueFormat.apply_value (c, this, values, buffer->cur_pos());
487
488 buffer->idx++;
489 return_trace (true);
490 }
491
492 bool subset (hb_subset_context_t *c) const
493 {
494 TRACE_SUBSET (this);
495 // TODO(subset)
496 return_trace (false);
497 }
498
499 bool sanitize (hb_sanitize_context_t *c) const
500 {
501 TRACE_SANITIZE (this);
502 return_trace (c->check_struct (this) &&
503 coverage.sanitize (c, this) &&
504 valueFormat.sanitize_value (c, this, values));
505 }
506
507 protected:
508 HBUINT16 format; /* Format identifier--format = 1 */
509 OffsetTo<Coverage>
510 coverage; /* Offset to Coverage table--from
511 * beginning of subtable */
512 ValueFormat valueFormat; /* Defines the types of data in the
513 * ValueRecord */
514 ValueRecord values; /* Defines positioning
515 * value(s)--applied to all glyphs in
516 * the Coverage table */
517 public:
518 DEFINE_SIZE_ARRAY (6, values);
519 };
520
521 struct SinglePosFormat2
522 {
523 bool intersects (const hb_set_t *glyphs) const
524 { return (this+coverage).intersects (glyphs); }
525
526 void collect_glyphs (hb_collect_glyphs_context_t *c) const
527 { if (unlikely (!(this+coverage).add_coverage (c->input))) return; }
528
529 const Coverage &get_coverage () const { return this+coverage; }
530
531 bool apply (hb_ot_apply_context_t *c) const
532 {
533 TRACE_APPLY (this);
534 hb_buffer_t *buffer = c->buffer;
535 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
536 if (likely (index == NOT_COVERED)) return_trace (false);
537
538 if (likely (index >= valueCount)) return_trace (false);
539
540 valueFormat.apply_value (c, this,
541 &values[index * valueFormat.get_len ()],
542 buffer->cur_pos());
543
544 buffer->idx++;
545 return_trace (true);
546 }
547
548 bool subset (hb_subset_context_t *c) const
549 {
550 TRACE_SUBSET (this);
551 // TODO(subset)
552 return_trace (false);
553 }
554
555 bool sanitize (hb_sanitize_context_t *c) const
556 {
557 TRACE_SANITIZE (this);
558 return_trace (c->check_struct (this) &&
559 coverage.sanitize (c, this) &&
560 valueFormat.sanitize_values (c, this, values, valueCount));
561 }
562
563 protected:
564 HBUINT16 format; /* Format identifier--format = 2 */
565 OffsetTo<Coverage>
566 coverage; /* Offset to Coverage table--from
567 * beginning of subtable */
568 ValueFormat valueFormat; /* Defines the types of data in the
569 * ValueRecord */
570 HBUINT16 valueCount; /* Number of ValueRecords */
571 ValueRecord values; /* Array of ValueRecords--positioning
572 * values applied to glyphs */
573 public:
574 DEFINE_SIZE_ARRAY (8, values);
575 };
576
577 struct SinglePos
578 {
579 template <typename context_t>
580 typename context_t::return_t dispatch (context_t *c) const
581 {
582 TRACE_DISPATCH (this, u.format);
583 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
584 switch (u.format) {
585 case 1: return_trace (c->dispatch (u.format1));
586 case 2: return_trace (c->dispatch (u.format2));
587 default:return_trace (c->default_return_value ());
588 }
589 }
590
591 protected:
592 union {
593 HBUINT16 format; /* Format identifier */
594 SinglePosFormat1 format1;
595 SinglePosFormat2 format2;
596 } u;
597 };
598
599
600 struct PairValueRecord
601 {
602 friend struct PairSet;
603
604 protected:
605 GlyphID secondGlyph; /* GlyphID of second glyph in the
606 * pair--first glyph is listed in the
607 * Coverage table */
608 ValueRecord values; /* Positioning data for the first glyph
609 * followed by for second glyph */
610 public:
611 DEFINE_SIZE_ARRAY (2, values);
612 };
613
614 struct PairSet
615 {
616 friend struct PairPosFormat1;
617
618 bool intersects (const hb_set_t *glyphs,
619 const ValueFormat *valueFormats) const
620 {
621 unsigned int len1 = valueFormats[0].get_len ();
622 unsigned int len2 = valueFormats[1].get_len ();
623 unsigned int record_size = HBUINT16::static_size * (1 + len1 + len2);
624
625 const PairValueRecord *record = &firstPairValueRecord;
626 unsigned int count = len;
627 for (unsigned int i = 0; i < count; i++)
628 {
629 if (glyphs->has (record->secondGlyph))
630 return true;
631 record = &StructAtOffset<const PairValueRecord> (record, record_size);
632 }
633 return false;
634 }
635
636 void collect_glyphs (hb_collect_glyphs_context_t *c,
637 const ValueFormat *valueFormats) const
638 {
639 unsigned int len1 = valueFormats[0].get_len ();
640 unsigned int len2 = valueFormats[1].get_len ();
641 unsigned int record_size = HBUINT16::static_size * (1 + len1 + len2);
642
643 const PairValueRecord *record = &firstPairValueRecord;
644 c->input->add_array (&record->secondGlyph, len, record_size);
645 }
646
647 bool apply (hb_ot_apply_context_t *c,
648 const ValueFormat *valueFormats,
649 unsigned int pos) const
650 {
651 TRACE_APPLY (this);
652 hb_buffer_t *buffer = c->buffer;
653 unsigned int len1 = valueFormats[0].get_len ();
654 unsigned int len2 = valueFormats[1].get_len ();
655 unsigned int record_size = HBUINT16::static_size * (1 + len1 + len2);
656
657 unsigned int count = len;
658
659 /* Hand-coded bsearch. */
660 if (unlikely (!count))
661 return_trace (false);
662 hb_codepoint_t x = buffer->info[pos].codepoint;
663 int min = 0, max = (int) count - 1;
664 while (min <= max)
665 {
666 int mid = ((unsigned int) min + (unsigned int) max) / 2;
667 const PairValueRecord *record = &StructAtOffset<PairValueRecord> (&firstPairValueRecord, record_size * mid);
668 hb_codepoint_t mid_x = record->secondGlyph;
669 if (x < mid_x)
670 max = mid - 1;
671 else if (x > mid_x)
672 min = mid + 1;
673 else
674 {
675 /* Note the intentional use of "|" instead of short-circuit "||". */
676 if (valueFormats[0].apply_value (c, this, &record->values[0], buffer->cur_pos()) |
677 valueFormats[1].apply_value (c, this, &record->values[len1], buffer->pos[pos]))
678 buffer->unsafe_to_break (buffer->idx, pos + 1);
679 if (len2)
680 pos++;
681 buffer->idx = pos;
682 return_trace (true);
683 }
684 }
685
686 return_trace (false);
687 }
688
689 struct sanitize_closure_t
690 {
691 const void *base;
692 const ValueFormat *valueFormats;
693 unsigned int len1; /* valueFormats[0].get_len() */
694 unsigned int stride; /* 1 + len1 + len2 */
695 };
696
697 bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) const
698 {
699 TRACE_SANITIZE (this);
700 if (!(c->check_struct (this)
701 && c->check_range (&firstPairValueRecord,
702 len,
703 HBUINT16::static_size,
704 closure->stride))) return_trace (false);
705
706 unsigned int count = len;
707 const PairValueRecord *record = &firstPairValueRecord;
708 return_trace (closure->valueFormats[0].sanitize_values_stride_unsafe (c, closure->base, &record->values[0], count, closure->stride) &&
709 closure->valueFormats[1].sanitize_values_stride_unsafe (c, closure->base, &record->values[closure->len1], count, closure->stride));
710 }
711
712 protected:
713 HBUINT16 len; /* Number of PairValueRecords */
714 PairValueRecord firstPairValueRecord;
715 /* Array of PairValueRecords--ordered
716 * by GlyphID of the second glyph */
717 public:
718 DEFINE_SIZE_MIN (2);
719 };
720
721 struct PairPosFormat1
722 {
723 bool intersects (const hb_set_t *glyphs) const
724 {
725 unsigned int count = pairSet.len;
726 for (Coverage::Iter iter (this+coverage); iter.more (); iter.next ())
727 {
728 if (unlikely (iter.get_coverage () >= count))
729 break; /* Work around malicious fonts. https://github.com/harfbuzz/harfbuzz/issues/363 */
730 if (glyphs->has (iter.get_glyph ()) &&
731 (this+pairSet[iter.get_coverage ()]).intersects (glyphs, valueFormat))
732 return true;
733 }
734 return false;
735 }
736
737 void collect_glyphs (hb_collect_glyphs_context_t *c) const
738 {
739 if (unlikely (!(this+coverage).add_coverage (c->input))) return;
740 unsigned int count = pairSet.len;
741 for (unsigned int i = 0; i < count; i++)
742 (this+pairSet[i]).collect_glyphs (c, valueFormat);
743 }
744
745 const Coverage &get_coverage () const { return this+coverage; }
746
747 bool apply (hb_ot_apply_context_t *c) const
748 {
749 TRACE_APPLY (this);
750 hb_buffer_t *buffer = c->buffer;
751 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
752 if (likely (index == NOT_COVERED)) return_trace (false);
753
754 hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
755 skippy_iter.reset (buffer->idx, 1);
756 if (!skippy_iter.next ()) return_trace (false);
757
758 return_trace ((this+pairSet[index]).apply (c, valueFormat, skippy_iter.idx));
759 }
760
761 bool subset (hb_subset_context_t *c) const
762 {
763 TRACE_SUBSET (this);
764 // TODO(subset)
765 return_trace (false);
766 }
767
768 bool sanitize (hb_sanitize_context_t *c) const
769 {
770 TRACE_SANITIZE (this);
771
772 if (!c->check_struct (this)) return_trace (false);
773
774 unsigned int len1 = valueFormat[0].get_len ();
775 unsigned int len2 = valueFormat[1].get_len ();
776 PairSet::sanitize_closure_t closure =
777 {
778 this,
779 valueFormat,
780 len1,
781 1 + len1 + len2
782 };
783
784 return_trace (coverage.sanitize (c, this) && pairSet.sanitize (c, this, &closure));
785 }
786
787 protected:
788 HBUINT16 format; /* Format identifier--format = 1 */
789 OffsetTo<Coverage>
790 coverage; /* Offset to Coverage table--from
791 * beginning of subtable */
792 ValueFormat valueFormat[2]; /* [0] Defines the types of data in
793 * ValueRecord1--for the first glyph
794 * in the pair--may be zero (0) */
795 /* [1] Defines the types of data in
796 * ValueRecord2--for the second glyph
797 * in the pair--may be zero (0) */
798 OffsetArrayOf<PairSet>
799 pairSet; /* Array of PairSet tables
800 * ordered by Coverage Index */
801 public:
802 DEFINE_SIZE_ARRAY (10, pairSet);
803 };
804
805 struct PairPosFormat2
806 {
807 bool intersects (const hb_set_t *glyphs) const
808 {
809 return (this+coverage).intersects (glyphs) &&
810 (this+classDef2).intersects (glyphs);
811 }
812
813 void collect_glyphs (hb_collect_glyphs_context_t *c) const
814 {
815 if (unlikely (!(this+coverage).add_coverage (c->input))) return;
816 if (unlikely (!(this+classDef2).add_coverage (c->input))) return;
817 }
818
819 const Coverage &get_coverage () const { return this+coverage; }
820
821 bool apply (hb_ot_apply_context_t *c) const
822 {
823 TRACE_APPLY (this);
824 hb_buffer_t *buffer = c->buffer;
825 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
826 if (likely (index == NOT_COVERED)) return_trace (false);
827
828 hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
829 skippy_iter.reset (buffer->idx, 1);
830 if (!skippy_iter.next ()) return_trace (false);
831
832 unsigned int len1 = valueFormat1.get_len ();
833 unsigned int len2 = valueFormat2.get_len ();
834 unsigned int record_len = len1 + len2;
835
836 unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint);
837 unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint);
838 if (unlikely (klass1 >= class1Count || klass2 >= class2Count)) return_trace (false);
839
840 const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
841 /* Note the intentional use of "|" instead of short-circuit "||". */
842 if (valueFormat1.apply_value (c, this, v, buffer->cur_pos()) |
843 valueFormat2.apply_value (c, this, v + len1, buffer->pos[skippy_iter.idx]))
844 buffer->unsafe_to_break (buffer->idx, skippy_iter.idx + 1);
845
846 buffer->idx = skippy_iter.idx;
847 if (len2)
848 buffer->idx++;
849
850 return_trace (true);
851 }
852
853 bool subset (hb_subset_context_t *c) const
854 {
855 TRACE_SUBSET (this);
856 // TODO(subset)
857 return_trace (false);
858 }
859
860 bool sanitize (hb_sanitize_context_t *c) const
861 {
862 TRACE_SANITIZE (this);
863 if (!(c->check_struct (this)
864 && coverage.sanitize (c, this)
865 && classDef1.sanitize (c, this)
866 && classDef2.sanitize (c, this))) return_trace (false);
867
868 unsigned int len1 = valueFormat1.get_len ();
869 unsigned int len2 = valueFormat2.get_len ();
870 unsigned int stride = len1 + len2;
871 unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size ();
872 unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count;
873 return_trace (c->check_range ((const void *) values,
874 count,
875 record_size) &&
876 valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) &&
877 valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride));
878 }
879
880 protected:
881 HBUINT16 format; /* Format identifier--format = 2 */
882 OffsetTo<Coverage>
883 coverage; /* Offset to Coverage table--from
884 * beginning of subtable */
885 ValueFormat valueFormat1; /* ValueRecord definition--for the
886 * first glyph of the pair--may be zero
887 * (0) */
888 ValueFormat valueFormat2; /* ValueRecord definition--for the
889 * second glyph of the pair--may be
890 * zero (0) */
891 OffsetTo<ClassDef>
892 classDef1; /* Offset to ClassDef table--from
893 * beginning of PairPos subtable--for
894 * the first glyph of the pair */
895 OffsetTo<ClassDef>
896 classDef2; /* Offset to ClassDef table--from
897 * beginning of PairPos subtable--for
898 * the second glyph of the pair */
899 HBUINT16 class1Count; /* Number of classes in ClassDef1
900 * table--includes Class0 */
901 HBUINT16 class2Count; /* Number of classes in ClassDef2
902 * table--includes Class0 */
903 ValueRecord values; /* Matrix of value pairs:
904 * class1-major, class2-minor,
905 * Each entry has value1 and value2 */
906 public:
907 DEFINE_SIZE_ARRAY (16, values);
908 };
909
910 struct PairPos
911 {
912 template <typename context_t>
913 typename context_t::return_t dispatch (context_t *c) const
914 {
915 TRACE_DISPATCH (this, u.format);
916 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
917 switch (u.format) {
918 case 1: return_trace (c->dispatch (u.format1));
919 case 2: return_trace (c->dispatch (u.format2));
920 default:return_trace (c->default_return_value ());
921 }
922 }
923
924 protected:
925 union {
926 HBUINT16 format; /* Format identifier */
927 PairPosFormat1 format1;
928 PairPosFormat2 format2;
929 } u;
930 };
931
932
933 struct EntryExitRecord
934 {
935 friend struct CursivePosFormat1;
936
937 bool sanitize (hb_sanitize_context_t *c, const void *base) const
938 {
939 TRACE_SANITIZE (this);
940 return_trace (entryAnchor.sanitize (c, base) && exitAnchor.sanitize (c, base));
941 }
942
943 protected:
944 OffsetTo<Anchor>
945 entryAnchor; /* Offset to EntryAnchor table--from
946 * beginning of CursivePos
947 * subtable--may be NULL */
948 OffsetTo<Anchor>
949 exitAnchor; /* Offset to ExitAnchor table--from
950 * beginning of CursivePos
951 * subtable--may be NULL */
952 public:
953 DEFINE_SIZE_STATIC (4);
954 };
955
956 static void
957 reverse_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction, unsigned int new_parent);
958
959 struct CursivePosFormat1
960 {
961 bool intersects (const hb_set_t *glyphs) const
962 { return (this+coverage).intersects (glyphs); }
963
964 void collect_glyphs (hb_collect_glyphs_context_t *c) const
965 { if (unlikely (!(this+coverage).add_coverage (c->input))) return; }
966
967 const Coverage &get_coverage () const { return this+coverage; }
968
969 bool apply (hb_ot_apply_context_t *c) const
970 {
971 TRACE_APPLY (this);
972 hb_buffer_t *buffer = c->buffer;
973
974 const EntryExitRecord &this_record = entryExitRecord[(this+coverage).get_coverage (buffer->cur().codepoint)];
975 if (!this_record.entryAnchor) return_trace (false);
976
977 hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
978 skippy_iter.reset (buffer->idx, 1);
979 if (!skippy_iter.prev ()) return_trace (false);
980
981 const EntryExitRecord &prev_record = entryExitRecord[(this+coverage).get_coverage (buffer->info[skippy_iter.idx].codepoint)];
982 if (!prev_record.exitAnchor) return_trace (false);
983
984 unsigned int i = skippy_iter.idx;
985 unsigned int j = buffer->idx;
986
987 buffer->unsafe_to_break (i, j);
988 float entry_x, entry_y, exit_x, exit_y;
989 (this+prev_record.exitAnchor).get_anchor (c, buffer->info[i].codepoint, &exit_x, &exit_y);
990 (this+this_record.entryAnchor).get_anchor (c, buffer->info[j].codepoint, &entry_x, &entry_y);
991
992 hb_glyph_position_t *pos = buffer->pos;
993
994 hb_position_t d;
995 /* Main-direction adjustment */
996 switch (c->direction) {
997 case HB_DIRECTION_LTR:
998 pos[i].x_advance = round (exit_x) + pos[i].x_offset;
999
1000 d = round (entry_x) + pos[j].x_offset;
1001 pos[j].x_advance -= d;
1002 pos[j].x_offset -= d;
1003 break;
1004 case HB_DIRECTION_RTL:
1005 d = round (exit_x) + pos[i].x_offset;
1006 pos[i].x_advance -= d;
1007 pos[i].x_offset -= d;
1008
1009 pos[j].x_advance = round (entry_x) + pos[j].x_offset;
1010 break;
1011 case HB_DIRECTION_TTB:
1012 pos[i].y_advance = round (exit_y) + pos[i].y_offset;
1013
1014 d = round (entry_y) + pos[j].y_offset;
1015 pos[j].y_advance -= d;
1016 pos[j].y_offset -= d;
1017 break;
1018 case HB_DIRECTION_BTT:
1019 d = round (exit_y) + pos[i].y_offset;
1020 pos[i].y_advance -= d;
1021 pos[i].y_offset -= d;
1022
1023 pos[j].y_advance = round (entry_y);
1024 break;
1025 case HB_DIRECTION_INVALID:
1026 default:
1027 break;
1028 }
1029
1030 /* Cross-direction adjustment */
1031
1032 /* We attach child to parent (think graph theory and rooted trees whereas
1033 * the root stays on baseline and each node aligns itself against its
1034 * parent.
1035 *
1036 * Optimize things for the case of RightToLeft, as that's most common in
1037 * Arabic. */
1038 unsigned int child = i;
1039 unsigned int parent = j;
1040 hb_position_t x_offset = entry_x - exit_x;
1041 hb_position_t y_offset = entry_y - exit_y;
1042 if (!(c->lookup_props & LookupFlag::RightToLeft))
1043 {
1044 unsigned int k = child;
1045 child = parent;
1046 parent = k;
1047 x_offset = -x_offset;
1048 y_offset = -y_offset;
1049 }
1050
1051 /* If child was already connected to someone else, walk through its old
1052 * chain and reverse the link direction, such that the whole tree of its
1053 * previous connection now attaches to new parent. Watch out for case
1054 * where new parent is on the path from old chain...
1055 */
1056 reverse_cursive_minor_offset (pos, child, c->direction, parent);
1057
1058 pos[child].attach_type() = ATTACH_TYPE_CURSIVE;
1059 pos[child].attach_chain() = (int) parent - (int) child;
1060 buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
1061 if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction)))
1062 pos[child].y_offset = y_offset;
1063 else
1064 pos[child].x_offset = x_offset;
1065
1066 buffer->idx++;
1067 return_trace (true);
1068 }
1069
1070 bool subset (hb_subset_context_t *c) const
1071 {
1072 TRACE_SUBSET (this);
1073 // TODO(subset)
1074 return_trace (false);
1075 }
1076
1077 bool sanitize (hb_sanitize_context_t *c) const
1078 {
1079 TRACE_SANITIZE (this);
1080 return_trace (coverage.sanitize (c, this) && entryExitRecord.sanitize (c, this));
1081 }
1082
1083 protected:
1084 HBUINT16 format; /* Format identifier--format = 1 */
1085 OffsetTo<Coverage>
1086 coverage; /* Offset to Coverage table--from
1087 * beginning of subtable */
1088 ArrayOf<EntryExitRecord>
1089 entryExitRecord; /* Array of EntryExit records--in
1090 * Coverage Index order */
1091 public:
1092 DEFINE_SIZE_ARRAY (6, entryExitRecord);
1093 };
1094
1095 struct CursivePos
1096 {
1097 template <typename context_t>
1098 typename context_t::return_t dispatch (context_t *c) const
1099 {
1100 TRACE_DISPATCH (this, u.format);
1101 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1102 switch (u.format) {
1103 case 1: return_trace (c->dispatch (u.format1));
1104 default:return_trace (c->default_return_value ());
1105 }
1106 }
1107
1108 protected:
1109 union {
1110 HBUINT16 format; /* Format identifier */
1111 CursivePosFormat1 format1;
1112 } u;
1113 };
1114
1115
1116 typedef AnchorMatrix BaseArray; /* base-major--
1117 * in order of BaseCoverage Index--,
1118 * mark-minor--
1119 * ordered by class--zero-based. */
1120
1121 struct MarkBasePosFormat1
1122 {
1123 bool intersects (const hb_set_t *glyphs) const
1124 { return (this+markCoverage).intersects (glyphs) &&
1125 (this+baseCoverage).intersects (glyphs); }
1126
1127 void collect_glyphs (hb_collect_glyphs_context_t *c) const
1128 {
1129 if (unlikely (!(this+markCoverage).add_coverage (c->input))) return;
1130 if (unlikely (!(this+baseCoverage).add_coverage (c->input))) return;
1131 }
1132
1133 const Coverage &get_coverage () const { return this+markCoverage; }
1134
1135 bool apply (hb_ot_apply_context_t *c) const
1136 {
1137 TRACE_APPLY (this);
1138 hb_buffer_t *buffer = c->buffer;
1139 unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint);
1140 if (likely (mark_index == NOT_COVERED)) return_trace (false);
1141
1142 /* Now we search backwards for a non-mark glyph */
1143 hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1144 skippy_iter.reset (buffer->idx, 1);
1145 skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
1146 do {
1147 if (!skippy_iter.prev ()) return_trace (false);
1148 /* We only want to attach to the first of a MultipleSubst sequence.
1149 * https://github.com/harfbuzz/harfbuzz/issues/740
1150 * Reject others...
1151 * ...but stop if we find a mark in the MultipleSubst sequence:
1152 * https://github.com/harfbuzz/harfbuzz/issues/1020 */
1153 if (!_hb_glyph_info_multiplied (&buffer->info[skippy_iter.idx]) ||
1154 0 == _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx]) ||
1155 (skippy_iter.idx == 0 ||
1156 _hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx - 1]) ||
1157 _hb_glyph_info_get_lig_id (&buffer->info[skippy_iter.idx]) !=
1158 _hb_glyph_info_get_lig_id (&buffer->info[skippy_iter.idx - 1]) ||
1159 _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx]) !=
1160 _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx - 1]) + 1
1161 ))
1162 break;
1163 skippy_iter.reject ();
1164 } while (true);
1165
1166 /* Checking that matched glyph is actually a base glyph by GDEF is too strong; disabled */
1167 //if (!_hb_glyph_info_is_base_glyph (&buffer->info[skippy_iter.idx])) { return_trace (false); }
1168
1169 unsigned int base_index = (this+baseCoverage).get_coverage (buffer->info[skippy_iter.idx].codepoint);
1170 if (base_index == NOT_COVERED) return_trace (false);
1171
1172 return_trace ((this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, skippy_iter.idx));
1173 }
1174
1175 bool subset (hb_subset_context_t *c) const
1176 {
1177 TRACE_SUBSET (this);
1178 // TODO(subset)
1179 return_trace (false);
1180 }
1181
1182 bool sanitize (hb_sanitize_context_t *c) const
1183 {
1184 TRACE_SANITIZE (this);
1185 return_trace (c->check_struct (this) &&
1186 markCoverage.sanitize (c, this) &&
1187 baseCoverage.sanitize (c, this) &&
1188 markArray.sanitize (c, this) &&
1189 baseArray.sanitize (c, this, (unsigned int) classCount));
1190 }
1191
1192 protected:
1193 HBUINT16 format; /* Format identifier--format = 1 */
1194 OffsetTo<Coverage>
1195 markCoverage; /* Offset to MarkCoverage table--from
1196 * beginning of MarkBasePos subtable */
1197 OffsetTo<Coverage>
1198 baseCoverage; /* Offset to BaseCoverage table--from
1199 * beginning of MarkBasePos subtable */
1200 HBUINT16 classCount; /* Number of classes defined for marks */
1201 OffsetTo<MarkArray>
1202 markArray; /* Offset to MarkArray table--from
1203 * beginning of MarkBasePos subtable */
1204 OffsetTo<BaseArray>
1205 baseArray; /* Offset to BaseArray table--from
1206 * beginning of MarkBasePos subtable */
1207 public:
1208 DEFINE_SIZE_STATIC (12);
1209 };
1210
1211 struct MarkBasePos
1212 {
1213 template <typename context_t>
1214 typename context_t::return_t dispatch (context_t *c) const
1215 {
1216 TRACE_DISPATCH (this, u.format);
1217 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1218 switch (u.format) {
1219 case 1: return_trace (c->dispatch (u.format1));
1220 default:return_trace (c->default_return_value ());
1221 }
1222 }
1223
1224 protected:
1225 union {
1226 HBUINT16 format; /* Format identifier */
1227 MarkBasePosFormat1 format1;
1228 } u;
1229 };
1230
1231
1232 typedef AnchorMatrix LigatureAttach; /* component-major--
1233 * in order of writing direction--,
1234 * mark-minor--
1235 * ordered by class--zero-based. */
1236
1237 typedef OffsetListOf<LigatureAttach> LigatureArray;
1238 /* Array of LigatureAttach
1239 * tables ordered by
1240 * LigatureCoverage Index */
1241
1242 struct MarkLigPosFormat1
1243 {
1244 bool intersects (const hb_set_t *glyphs) const
1245 { return (this+markCoverage).intersects (glyphs) &&
1246 (this+ligatureCoverage).intersects (glyphs); }
1247
1248 void collect_glyphs (hb_collect_glyphs_context_t *c) const
1249 {
1250 if (unlikely (!(this+markCoverage).add_coverage (c->input))) return;
1251 if (unlikely (!(this+ligatureCoverage).add_coverage (c->input))) return;
1252 }
1253
1254 const Coverage &get_coverage () const { return this+markCoverage; }
1255
1256 bool apply (hb_ot_apply_context_t *c) const
1257 {
1258 TRACE_APPLY (this);
1259 hb_buffer_t *buffer = c->buffer;
1260 unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint);
1261 if (likely (mark_index == NOT_COVERED)) return_trace (false);
1262
1263 /* Now we search backwards for a non-mark glyph */
1264 hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1265 skippy_iter.reset (buffer->idx, 1);
1266 skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
1267 if (!skippy_iter.prev ()) return_trace (false);
1268
1269 /* Checking that matched glyph is actually a ligature by GDEF is too strong; disabled */
1270 //if (!_hb_glyph_info_is_ligature (&buffer->info[skippy_iter.idx])) { return_trace (false); }
1271
1272 unsigned int j = skippy_iter.idx;
1273 unsigned int lig_index = (this+ligatureCoverage).get_coverage (buffer->info[j].codepoint);
1274 if (lig_index == NOT_COVERED) return_trace (false);
1275
1276 const LigatureArray& lig_array = this+ligatureArray;
1277 const LigatureAttach& lig_attach = lig_array[lig_index];
1278
1279 /* Find component to attach to */
1280 unsigned int comp_count = lig_attach.rows;
1281 if (unlikely (!comp_count)) return_trace (false);
1282
1283 /* We must now check whether the ligature ID of the current mark glyph
1284 * is identical to the ligature ID of the found ligature. If yes, we
1285 * can directly use the component index. If not, we attach the mark
1286 * glyph to the last component of the ligature. */
1287 unsigned int comp_index;
1288 unsigned int lig_id = _hb_glyph_info_get_lig_id (&buffer->info[j]);
1289 unsigned int mark_id = _hb_glyph_info_get_lig_id (&buffer->cur());
1290 unsigned int mark_comp = _hb_glyph_info_get_lig_comp (&buffer->cur());
1291 if (lig_id && lig_id == mark_id && mark_comp > 0)
1292 comp_index = MIN (comp_count, _hb_glyph_info_get_lig_comp (&buffer->cur())) - 1;
1293 else
1294 comp_index = comp_count - 1;
1295
1296 return_trace ((this+markArray).apply (c, mark_index, comp_index, lig_attach, classCount, j));
1297 }
1298
1299 bool subset (hb_subset_context_t *c) const
1300 {
1301 TRACE_SUBSET (this);
1302 // TODO(subset)
1303 return_trace (false);
1304 }
1305
1306 bool sanitize (hb_sanitize_context_t *c) const
1307 {
1308 TRACE_SANITIZE (this);
1309 return_trace (c->check_struct (this) &&
1310 markCoverage.sanitize (c, this) &&
1311 ligatureCoverage.sanitize (c, this) &&
1312 markArray.sanitize (c, this) &&
1313 ligatureArray.sanitize (c, this, (unsigned int) classCount));
1314 }
1315
1316 protected:
1317 HBUINT16 format; /* Format identifier--format = 1 */
1318 OffsetTo<Coverage>
1319 markCoverage; /* Offset to Mark Coverage table--from
1320 * beginning of MarkLigPos subtable */
1321 OffsetTo<Coverage>
1322 ligatureCoverage; /* Offset to Ligature Coverage
1323 * table--from beginning of MarkLigPos
1324 * subtable */
1325 HBUINT16 classCount; /* Number of defined mark classes */
1326 OffsetTo<MarkArray>
1327 markArray; /* Offset to MarkArray table--from
1328 * beginning of MarkLigPos subtable */
1329 OffsetTo<LigatureArray>
1330 ligatureArray; /* Offset to LigatureArray table--from
1331 * beginning of MarkLigPos subtable */
1332 public:
1333 DEFINE_SIZE_STATIC (12);
1334 };
1335
1336 struct MarkLigPos
1337 {
1338 template <typename context_t>
1339 typename context_t::return_t dispatch (context_t *c) const
1340 {
1341 TRACE_DISPATCH (this, u.format);
1342 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1343 switch (u.format) {
1344 case 1: return_trace (c->dispatch (u.format1));
1345 default:return_trace (c->default_return_value ());
1346 }
1347 }
1348
1349 protected:
1350 union {
1351 HBUINT16 format; /* Format identifier */
1352 MarkLigPosFormat1 format1;
1353 } u;
1354 };
1355
1356
1357 typedef AnchorMatrix Mark2Array; /* mark2-major--
1358 * in order of Mark2Coverage Index--,
1359 * mark1-minor--
1360 * ordered by class--zero-based. */
1361
1362 struct MarkMarkPosFormat1
1363 {
1364 bool intersects (const hb_set_t *glyphs) const
1365 { return (this+mark1Coverage).intersects (glyphs) &&
1366 (this+mark2Coverage).intersects (glyphs); }
1367
1368 void collect_glyphs (hb_collect_glyphs_context_t *c) const
1369 {
1370 if (unlikely (!(this+mark1Coverage).add_coverage (c->input))) return;
1371 if (unlikely (!(this+mark2Coverage).add_coverage (c->input))) return;
1372 }
1373
1374 const Coverage &get_coverage () const { return this+mark1Coverage; }
1375
1376 bool apply (hb_ot_apply_context_t *c) const
1377 {
1378 TRACE_APPLY (this);
1379 hb_buffer_t *buffer = c->buffer;
1380 unsigned int mark1_index = (this+mark1Coverage).get_coverage (buffer->cur().codepoint);
1381 if (likely (mark1_index == NOT_COVERED)) return_trace (false);
1382
1383 /* now we search backwards for a suitable mark glyph until a non-mark glyph */
1384 hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1385 skippy_iter.reset (buffer->idx, 1);
1386 skippy_iter.set_lookup_props (c->lookup_props & ~LookupFlag::IgnoreFlags);
1387 if (!skippy_iter.prev ()) return_trace (false);
1388
1389 if (!_hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx])) { return_trace (false); }
1390
1391 unsigned int j = skippy_iter.idx;
1392
1393 unsigned int id1 = _hb_glyph_info_get_lig_id (&buffer->cur());
1394 unsigned int id2 = _hb_glyph_info_get_lig_id (&buffer->info[j]);
1395 unsigned int comp1 = _hb_glyph_info_get_lig_comp (&buffer->cur());
1396 unsigned int comp2 = _hb_glyph_info_get_lig_comp (&buffer->info[j]);
1397
1398 if (likely (id1 == id2)) {
1399 if (id1 == 0) /* Marks belonging to the same base. */
1400 goto good;
1401 else if (comp1 == comp2) /* Marks belonging to the same ligature component. */
1402 goto good;
1403 } else {
1404 /* If ligature ids don't match, it may be the case that one of the marks
1405 * itself is a ligature. In which case match. */
1406 if ((id1 > 0 && !comp1) || (id2 > 0 && !comp2))
1407 goto good;
1408 }
1409
1410 /* Didn't match. */
1411 return_trace (false);
1412
1413 good:
1414 unsigned int mark2_index = (this+mark2Coverage).get_coverage (buffer->info[j].codepoint);
1415 if (mark2_index == NOT_COVERED) return_trace (false);
1416
1417 return_trace ((this+mark1Array).apply (c, mark1_index, mark2_index, this+mark2Array, classCount, j));
1418 }
1419
1420 bool subset (hb_subset_context_t *c) const
1421 {
1422 TRACE_SUBSET (this);
1423 // TODO(subset)
1424 return_trace (false);
1425 }
1426
1427 bool sanitize (hb_sanitize_context_t *c) const
1428 {
1429 TRACE_SANITIZE (this);
1430 return_trace (c->check_struct (this) &&
1431 mark1Coverage.sanitize (c, this) &&
1432 mark2Coverage.sanitize (c, this) &&
1433 mark1Array.sanitize (c, this) &&
1434 mark2Array.sanitize (c, this, (unsigned int) classCount));
1435 }
1436
1437 protected:
1438 HBUINT16 format; /* Format identifier--format = 1 */
1439 OffsetTo<Coverage>
1440 mark1Coverage; /* Offset to Combining Mark1 Coverage
1441 * table--from beginning of MarkMarkPos
1442 * subtable */
1443 OffsetTo<Coverage>
1444 mark2Coverage; /* Offset to Combining Mark2 Coverage
1445 * table--from beginning of MarkMarkPos
1446 * subtable */
1447 HBUINT16 classCount; /* Number of defined mark classes */
1448 OffsetTo<MarkArray>
1449 mark1Array; /* Offset to Mark1Array table--from
1450 * beginning of MarkMarkPos subtable */
1451 OffsetTo<Mark2Array>
1452 mark2Array; /* Offset to Mark2Array table--from
1453 * beginning of MarkMarkPos subtable */
1454 public:
1455 DEFINE_SIZE_STATIC (12);
1456 };
1457
1458 struct MarkMarkPos
1459 {
1460 template <typename context_t>
1461 typename context_t::return_t dispatch (context_t *c) const
1462 {
1463 TRACE_DISPATCH (this, u.format);
1464 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1465 switch (u.format) {
1466 case 1: return_trace (c->dispatch (u.format1));
1467 default:return_trace (c->default_return_value ());
1468 }
1469 }
1470
1471 protected:
1472 union {
1473 HBUINT16 format; /* Format identifier */
1474 MarkMarkPosFormat1 format1;
1475 } u;
1476 };
1477
1478
1479 struct ContextPos : Context {};
1480
1481 struct ChainContextPos : ChainContext {};
1482
1483 struct ExtensionPos : Extension<ExtensionPos>
1484 {
1485 typedef struct PosLookupSubTable SubTable;
1486 };
1487
1488
1489
1490 /*
1491 * PosLookup
1492 */
1493
1494
1495 struct PosLookupSubTable
1496 {
1497 friend struct Lookup;
1498 friend struct PosLookup;
1499
1500 enum Type {
1501 Single = 1,
1502 Pair = 2,
1503 Cursive = 3,
1504 MarkBase = 4,
1505 MarkLig = 5,
1506 MarkMark = 6,
1507 Context = 7,
1508 ChainContext = 8,
1509 Extension = 9
1510 };
1511
1512 template <typename context_t>
1513 typename context_t::return_t dispatch (context_t *c, unsigned int lookup_type) const
1514 {
1515 TRACE_DISPATCH (this, lookup_type);
1516 switch (lookup_type) {
1517 case Single: return_trace (u.single.dispatch (c));
1518 case Pair: return_trace (u.pair.dispatch (c));
1519 case Cursive: return_trace (u.cursive.dispatch (c));
1520 case MarkBase: return_trace (u.markBase.dispatch (c));
1521 case MarkLig: return_trace (u.markLig.dispatch (c));
1522 case MarkMark: return_trace (u.markMark.dispatch (c));
1523 case Context: return_trace (u.context.dispatch (c));
1524 case ChainContext: return_trace (u.chainContext.dispatch (c));
1525 case Extension: return_trace (u.extension.dispatch (c));
1526 default: return_trace (c->default_return_value ());
1527 }
1528 }
1529
1530 protected:
1531 union {
1532 SinglePos single;
1533 PairPos pair;
1534 CursivePos cursive;
1535 MarkBasePos markBase;
1536 MarkLigPos markLig;
1537 MarkMarkPos markMark;
1538 ContextPos context;
1539 ChainContextPos chainContext;
1540 ExtensionPos extension;
1541 } u;
1542 public:
1543 DEFINE_SIZE_MIN (0);
1544 };
1545
1546
1547 struct PosLookup : Lookup
1548 {
1549 typedef struct PosLookupSubTable SubTable;
1550
1551 const SubTable& get_subtable (unsigned int i) const
1552 { return Lookup::get_subtable<SubTable> (i); }
1553
1554 bool is_reverse () const
1555 {
1556 return false;
1557 }
1558
1559 bool apply (hb_ot_apply_context_t *c) const
1560 {
1561 TRACE_APPLY (this);
1562 return_trace (dispatch (c));
1563 }
1564
1565 bool intersects (const hb_set_t *glyphs) const
1566 {
1567 hb_intersects_context_t c (glyphs);
1568 return dispatch (&c);
1569 }
1570
1571 hb_collect_glyphs_context_t::return_t collect_glyphs (hb_collect_glyphs_context_t *c) const
1572 { return dispatch (c); }
1573
1574 template <typename set_t>
1575 void add_coverage (set_t *glyphs) const
1576 {
1577 hb_add_coverage_context_t<set_t> c (glyphs);
1578 dispatch (&c);
1579 }
1580
1581 static bool apply_recurse_func (hb_ot_apply_context_t *c, unsigned int lookup_index);
1582
1583 template <typename context_t>
1584 static typename context_t::return_t dispatch_recurse_func (context_t *c, unsigned int lookup_index);
1585
1586 template <typename context_t>
1587 typename context_t::return_t dispatch (context_t *c) const
1588 { return Lookup::dispatch<SubTable> (c); }
1589
1590 bool subset (hb_subset_context_t *c) const
1591 { return Lookup::subset<SubTable> (c); }
1592
1593 bool sanitize (hb_sanitize_context_t *c) const
1594 { return Lookup::sanitize<SubTable> (c); }
1595 };
1596
1597 /*
1598 * GPOS -- Glyph Positioning
1599 * https://docs.microsoft.com/en-us/typography/opentype/spec/gpos
1600 */
1601
1602 struct GPOS : GSUBGPOS
1603 {
1604 static constexpr hb_tag_t tableTag = HB_OT_TAG_GPOS;
1605
1606 const PosLookup& get_lookup (unsigned int i) const
1607 { return CastR<PosLookup> (GSUBGPOS::get_lookup (i)); }
1608
1609 static inline void position_start (hb_font_t *font, hb_buffer_t *buffer);
1610 static inline void position_finish_advances (hb_font_t *font, hb_buffer_t *buffer);
1611 static inline void position_finish_offsets (hb_font_t *font, hb_buffer_t *buffer);
1612
1613 bool subset (hb_subset_context_t *c) const
1614 { return GSUBGPOS::subset<PosLookup> (c); }
1615
1616 bool sanitize (hb_sanitize_context_t *c) const
1617 { return GSUBGPOS::sanitize<PosLookup> (c); }
1618
1619 HB_INTERNAL bool is_blacklisted (hb_blob_t *blob,
1620 hb_face_t *face) const;
1621
1622 typedef GSUBGPOS::accelerator_t<GPOS> accelerator_t;
1623 };
1624
1625
1626 static void
1627 reverse_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction, unsigned int new_parent)
1628 {
1629 int chain = pos[i].attach_chain(), type = pos[i].attach_type();
1630 if (likely (!chain || 0 == (type & ATTACH_TYPE_CURSIVE)))
1631 return;
1632
1633 pos[i].attach_chain() = 0;
1634
1635 unsigned int j = (int) i + chain;
1636
1637 /* Stop if we see new parent in the chain. */
1638 if (j == new_parent)
1639 return;
1640
1641 reverse_cursive_minor_offset (pos, j, direction, new_parent);
1642
1643 if (HB_DIRECTION_IS_HORIZONTAL (direction))
1644 pos[j].y_offset = -pos[i].y_offset;
1645 else
1646 pos[j].x_offset = -pos[i].x_offset;
1647
1648 pos[j].attach_chain() = -chain;
1649 pos[j].attach_type() = type;
1650 }
1651 static void
1652 propagate_attachment_offsets (hb_glyph_position_t *pos,
1653 unsigned int len,
1654 unsigned int i,
1655 hb_direction_t direction)
1656 {
1657 /* Adjusts offsets of attached glyphs (both cursive and mark) to accumulate
1658 * offset of glyph they are attached to. */
1659 int chain = pos[i].attach_chain(), type = pos[i].attach_type();
1660 if (likely (!chain))
1661 return;
1662
1663 pos[i].attach_chain() = 0;
1664
1665 unsigned int j = (int) i + chain;
1666
1667 if (unlikely (j >= len))
1668 return;
1669
1670 propagate_attachment_offsets (pos, len, j, direction);
1671
1672 assert (!!(type & ATTACH_TYPE_MARK) ^ !!(type & ATTACH_TYPE_CURSIVE));
1673
1674 if (type & ATTACH_TYPE_CURSIVE)
1675 {
1676 if (HB_DIRECTION_IS_HORIZONTAL (direction))
1677 pos[i].y_offset += pos[j].y_offset;
1678 else
1679 pos[i].x_offset += pos[j].x_offset;
1680 }
1681 else /*if (type & ATTACH_TYPE_MARK)*/
1682 {
1683 pos[i].x_offset += pos[j].x_offset;
1684 pos[i].y_offset += pos[j].y_offset;
1685
1686 assert (j < i);
1687 if (HB_DIRECTION_IS_FORWARD (direction))
1688 for (unsigned int k = j; k < i; k++) {
1689 pos[i].x_offset -= pos[k].x_advance;
1690 pos[i].y_offset -= pos[k].y_advance;
1691 }
1692 else
1693 for (unsigned int k = j + 1; k < i + 1; k++) {
1694 pos[i].x_offset += pos[k].x_advance;
1695 pos[i].y_offset += pos[k].y_advance;
1696 }
1697 }
1698 }
1699
1700 void
1701 GPOS::position_start (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
1702 {
1703 unsigned int count = buffer->len;
1704 for (unsigned int i = 0; i < count; i++)
1705 buffer->pos[i].attach_chain() = buffer->pos[i].attach_type() = 0;
1706 }
1707
1708 void
1709 GPOS::position_finish_advances (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer HB_UNUSED)
1710 {
1711 //_hb_buffer_assert_gsubgpos_vars (buffer);
1712 }
1713
1714 void
1715 GPOS::position_finish_offsets (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
1716 {
1717 _hb_buffer_assert_gsubgpos_vars (buffer);
1718
1719 unsigned int len;
1720 hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, &len);
1721 hb_direction_t direction = buffer->props.direction;
1722
1723 /* Handle attachments */
1724 if (buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT)
1725 for (unsigned int i = 0; i < len; i++)
1726 propagate_attachment_offsets (pos, len, i, direction);
1727 }
1728
1729
1730 struct GPOS_accelerator_t : GPOS::accelerator_t {};
1731
1732
1733 /* Out-of-class implementation for methods recursing */
1734
1735 template <typename context_t>
1736 /*static*/ inline typename context_t::return_t PosLookup::dispatch_recurse_func (context_t *c, unsigned int lookup_index)
1737 {
1738 const PosLookup &l = c->face->table.GPOS.get_relaxed ()->table->get_lookup (lookup_index);
1739 return l.dispatch (c);
1740 }
1741
1742 /*static*/ inline bool PosLookup::apply_recurse_func (hb_ot_apply_context_t *c, unsigned int lookup_index)
1743 {
1744 const PosLookup &l = c->face->table.GPOS.get_relaxed ()->table->get_lookup (lookup_index);
1745 unsigned int saved_lookup_props = c->lookup_props;
1746 unsigned int saved_lookup_index = c->lookup_index;
1747 c->set_lookup_index (lookup_index);
1748 c->set_lookup_props (l.get_props ());
1749 bool ret = l.dispatch (c);
1750 c->set_lookup_index (saved_lookup_index);
1751 c->set_lookup_props (saved_lookup_props);
1752 return ret;
1753 }
1754
1755
1756 } /* namespace OT */
1757
1758
1759 #endif /* HB_OT_LAYOUT_GPOS_TABLE_HH */