/* * Copyright © 2007,2008,2009,2010 Red Hat, Inc. * Copyright © 2010,2012,2013 Google, Inc. * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Red Hat Author(s): Behdad Esfahbod * Google Author(s): Behdad Esfahbod */ #ifndef HB_OT_LAYOUT_GPOS_TABLE_HH #define HB_OT_LAYOUT_GPOS_TABLE_HH #include "hb-ot-layout-gsubgpos.hh" namespace OT { struct MarkArray; static void Markclass_closure_and_remap_indexes (const Coverage &mark_coverage, const MarkArray &mark_array, const hb_set_t &glyphset, hb_map_t* klass_mapping /* INOUT */); /* buffer **position** var allocations */ #define attach_chain() var.i16[0] /* glyph to which this attaches to, relative to current glyphs; negative for going back, positive for forward. */ #define attach_type() var.u8[2] /* attachment type */ /* Note! if attach_chain() is zero, the value of attach_type() is irrelevant. */ enum attach_type_t { ATTACH_TYPE_NONE = 0X00, /* Each attachment should be either a mark or a cursive; can't be both. */ ATTACH_TYPE_MARK = 0X01, ATTACH_TYPE_CURSIVE = 0X02, }; /* Shared Tables: ValueRecord, Anchor Table, and MarkArray */ typedef HBUINT16 Value; typedef UnsizedArrayOf ValueRecord; struct ValueFormat : HBUINT16 { enum Flags { xPlacement = 0x0001u, /* Includes horizontal adjustment for placement */ yPlacement = 0x0002u, /* Includes vertical adjustment for placement */ xAdvance = 0x0004u, /* Includes horizontal adjustment for advance */ yAdvance = 0x0008u, /* Includes vertical adjustment for advance */ xPlaDevice = 0x0010u, /* Includes horizontal Device table for placement */ yPlaDevice = 0x0020u, /* Includes vertical Device table for placement */ xAdvDevice = 0x0040u, /* Includes horizontal Device table for advance */ yAdvDevice = 0x0080u, /* Includes vertical Device table for advance */ ignored = 0x0F00u, /* Was used in TrueType Open for MM fonts */ reserved = 0xF000u, /* For future use */ devices = 0x00F0u /* Mask for having any Device table */ }; /* All fields are options. Only those available advance the value pointer. */ #if 0 HBINT16 xPlacement; /* Horizontal adjustment for * placement--in design units */ HBINT16 yPlacement; /* Vertical adjustment for * placement--in design units */ HBINT16 xAdvance; /* Horizontal adjustment for * advance--in design units (only used * for horizontal writing) */ HBINT16 yAdvance; /* Vertical adjustment for advance--in * design units (only used for vertical * writing) */ Offset16To xPlaDevice; /* Offset to Device table for * horizontal placement--measured from * beginning of PosTable (may be NULL) */ Offset16To yPlaDevice; /* Offset to Device table for vertical * placement--measured from beginning * of PosTable (may be NULL) */ Offset16To xAdvDevice; /* Offset to Device table for * horizontal advance--measured from * beginning of PosTable (may be NULL) */ Offset16To yAdvDevice; /* Offset to Device table for vertical * advance--measured from beginning of * PosTable (may be NULL) */ #endif IntType& operator = (uint16_t i) { v = i; return *this; } unsigned int get_len () const { return hb_popcount ((unsigned int) *this); } unsigned int get_size () const { return get_len () * Value::static_size; } bool apply_value (hb_ot_apply_context_t *c, const void *base, const Value *values, hb_glyph_position_t &glyph_pos) const { bool ret = false; unsigned int format = *this; if (!format) return ret; hb_font_t *font = c->font; bool horizontal = #ifndef HB_NO_VERTICAL HB_DIRECTION_IS_HORIZONTAL (c->direction) #else true #endif ; if (format & xPlacement) glyph_pos.x_offset += font->em_scale_x (get_short (values++, &ret)); if (format & yPlacement) glyph_pos.y_offset += font->em_scale_y (get_short (values++, &ret)); if (format & xAdvance) { if (likely (horizontal)) glyph_pos.x_advance += font->em_scale_x (get_short (values, &ret)); values++; } /* y_advance values grow downward but font-space grows upward, hence negation */ if (format & yAdvance) { if (unlikely (!horizontal)) glyph_pos.y_advance -= font->em_scale_y (get_short (values, &ret)); values++; } if (!has_device ()) return ret; bool use_x_device = font->x_ppem || font->num_coords; bool use_y_device = font->y_ppem || font->num_coords; if (!use_x_device && !use_y_device) return ret; const VariationStore &store = c->var_store; /* pixel -> fractional pixel */ if (format & xPlaDevice) { if (use_x_device) glyph_pos.x_offset += (base + get_device (values, &ret)).get_x_delta (font, store); values++; } if (format & yPlaDevice) { if (use_y_device) glyph_pos.y_offset += (base + get_device (values, &ret)).get_y_delta (font, store); values++; } if (format & xAdvDevice) { if (horizontal && use_x_device) glyph_pos.x_advance += (base + get_device (values, &ret)).get_x_delta (font, store); values++; } if (format & yAdvDevice) { /* y_advance values grow downward but font-space grows upward, hence negation */ if (!horizontal && use_y_device) glyph_pos.y_advance -= (base + get_device (values, &ret)).get_y_delta (font, store); values++; } return ret; } unsigned int get_effective_format (const Value *values) const { unsigned int format = *this; for (unsigned flag = xPlacement; flag <= yAdvDevice; flag = flag << 1) { if (format & flag) should_drop (*values++, (Flags) flag, &format); } return format; } template unsigned int get_effective_format (Iterator it) const { unsigned int new_format = 0; for (const hb_array_t& values : it) new_format = new_format | get_effective_format (&values); return new_format; } void copy_values (hb_serialize_context_t *c, unsigned int new_format, const void *base, const Value *values, const hb_map_t *layout_variation_idx_map) const { unsigned int format = *this; if (!format) return; if (format & xPlacement) copy_value (c, new_format, xPlacement, *values++); if (format & yPlacement) copy_value (c, new_format, yPlacement, *values++); if (format & xAdvance) copy_value (c, new_format, xAdvance, *values++); if (format & yAdvance) copy_value (c, new_format, yAdvance, *values++); if (format & xPlaDevice) copy_device (c, base, values++, layout_variation_idx_map); if (format & yPlaDevice) copy_device (c, base, values++, layout_variation_idx_map); if (format & xAdvDevice) copy_device (c, base, values++, layout_variation_idx_map); if (format & yAdvDevice) copy_device (c, base, values++, layout_variation_idx_map); } void copy_value (hb_serialize_context_t *c, unsigned int new_format, Flags flag, Value value) const { // Filter by new format. if (!(new_format & flag)) return; c->copy (value); } void collect_variation_indices (hb_collect_variation_indices_context_t *c, const void *base, const hb_array_t& values) const { unsigned format = *this; unsigned i = 0; if (format & xPlacement) i++; if (format & yPlacement) i++; if (format & xAdvance) i++; if (format & yAdvance) i++; if (format & xPlaDevice) { (base + get_device (&(values[i]))).collect_variation_indices (c->layout_variation_indices); i++; } if (format & ValueFormat::yPlaDevice) { (base + get_device (&(values[i]))).collect_variation_indices (c->layout_variation_indices); i++; } if (format & ValueFormat::xAdvDevice) { (base + get_device (&(values[i]))).collect_variation_indices (c->layout_variation_indices); i++; } if (format & ValueFormat::yAdvDevice) { (base + get_device (&(values[i]))).collect_variation_indices (c->layout_variation_indices); i++; } } private: bool sanitize_value_devices (hb_sanitize_context_t *c, const void *base, const Value *values) const { unsigned int format = *this; if (format & xPlacement) values++; if (format & yPlacement) values++; if (format & xAdvance) values++; if (format & yAdvance) values++; if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false; if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false; if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false; if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false; return true; } static inline Offset16To& get_device (Value* value) { return *static_cast *> (value); } static inline const Offset16To& get_device (const Value* value, bool *worked=nullptr) { if (worked) *worked |= bool (*value); return *static_cast *> (value); } bool copy_device (hb_serialize_context_t *c, const void *base, const Value *src_value, const hb_map_t *layout_variation_idx_map) const { Value *dst_value = c->copy (*src_value); if (!dst_value) return false; if (*dst_value == 0) return true; *dst_value = 0; c->push (); if ((base + get_device (src_value)).copy (c, layout_variation_idx_map)) { c->add_link (*dst_value, c->pop_pack ()); return true; } else { c->pop_discard (); return false; } } static inline const HBINT16& get_short (const Value* value, bool *worked=nullptr) { if (worked) *worked |= bool (*value); return *reinterpret_cast (value); } public: bool has_device () const { unsigned int format = *this; return (format & devices) != 0; } bool sanitize_value (hb_sanitize_context_t *c, const void *base, const Value *values) const { TRACE_SANITIZE (this); return_trace (c->check_range (values, get_size ()) && (!has_device () || sanitize_value_devices (c, base, values))); } bool sanitize_values (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count) const { TRACE_SANITIZE (this); unsigned int len = get_len (); if (!c->check_range (values, count, get_size ())) return_trace (false); if (!has_device ()) return_trace (true); for (unsigned int i = 0; i < count; i++) { if (!sanitize_value_devices (c, base, values)) return_trace (false); values += len; } return_trace (true); } /* Just sanitize referenced Device tables. Doesn't check the values themselves. */ bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count, unsigned int stride) const { TRACE_SANITIZE (this); if (!has_device ()) return_trace (true); for (unsigned int i = 0; i < count; i++) { if (!sanitize_value_devices (c, base, values)) return_trace (false); values += stride; } return_trace (true); } private: void should_drop (Value value, Flags flag, unsigned int* format) const { if (value) return; *format = *format & ~flag; } }; template static void SinglePos_serialize (hb_serialize_context_t *c, const SrcLookup *src, Iterator it, const hb_map_t *layout_variation_idx_map); struct AnchorFormat1 { void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED, float *x, float *y) const { hb_font_t *font = c->font; *x = font->em_fscale_x (xCoordinate); *y = font->em_fscale_y (yCoordinate); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this)); } AnchorFormat1* copy (hb_serialize_context_t *c) const { TRACE_SERIALIZE (this); AnchorFormat1* out = c->embed (this); if (!out) return_trace (out); out->format = 1; return_trace (out); } protected: HBUINT16 format; /* Format identifier--format = 1 */ FWORD xCoordinate; /* Horizontal value--in design units */ FWORD yCoordinate; /* Vertical value--in design units */ public: DEFINE_SIZE_STATIC (6); }; struct AnchorFormat2 { void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id, float *x, float *y) const { hb_font_t *font = c->font; #ifdef HB_NO_HINTING *x = font->em_fscale_x (xCoordinate); *y = font->em_fscale_y (yCoordinate); return; #endif unsigned int x_ppem = font->x_ppem; unsigned int y_ppem = font->y_ppem; hb_position_t cx = 0, cy = 0; bool ret; ret = (x_ppem || y_ppem) && font->get_glyph_contour_point_for_origin (glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy); *x = ret && x_ppem ? cx : font->em_fscale_x (xCoordinate); *y = ret && y_ppem ? cy : font->em_fscale_y (yCoordinate); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this)); } AnchorFormat2* copy (hb_serialize_context_t *c) const { TRACE_SERIALIZE (this); return_trace (c->embed (this)); } protected: HBUINT16 format; /* Format identifier--format = 2 */ FWORD xCoordinate; /* Horizontal value--in design units */ FWORD yCoordinate; /* Vertical value--in design units */ HBUINT16 anchorPoint; /* Index to glyph contour point */ public: DEFINE_SIZE_STATIC (8); }; struct AnchorFormat3 { void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED, float *x, float *y) const { hb_font_t *font = c->font; *x = font->em_fscale_x (xCoordinate); *y = font->em_fscale_y (yCoordinate); if (font->x_ppem || font->num_coords) *x += (this+xDeviceTable).get_x_delta (font, c->var_store); if (font->y_ppem || font->num_coords) *y += (this+yDeviceTable).get_y_delta (font, c->var_store); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && xDeviceTable.sanitize (c, this) && yDeviceTable.sanitize (c, this)); } AnchorFormat3* copy (hb_serialize_context_t *c, const hb_map_t *layout_variation_idx_map) const { TRACE_SERIALIZE (this); if (!layout_variation_idx_map) return_trace (nullptr); auto *out = c->embed (this); if (unlikely (!out)) return_trace (nullptr); out->xDeviceTable.serialize_copy (c, xDeviceTable, this, 0, hb_serialize_context_t::Head, layout_variation_idx_map); out->yDeviceTable.serialize_copy (c, yDeviceTable, this, 0, hb_serialize_context_t::Head, layout_variation_idx_map); return_trace (out); } void collect_variation_indices (hb_collect_variation_indices_context_t *c) const { (this+xDeviceTable).collect_variation_indices (c->layout_variation_indices); (this+yDeviceTable).collect_variation_indices (c->layout_variation_indices); } protected: HBUINT16 format; /* Format identifier--format = 3 */ FWORD xCoordinate; /* Horizontal value--in design units */ FWORD yCoordinate; /* Vertical value--in design units */ Offset16To xDeviceTable; /* Offset to Device table for X * coordinate-- from beginning of * Anchor table (may be NULL) */ Offset16To yDeviceTable; /* Offset to Device table for Y * coordinate-- from beginning of * Anchor table (may be NULL) */ public: DEFINE_SIZE_STATIC (10); }; struct Anchor { void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id, float *x, float *y) const { *x = *y = 0; switch (u.format) { case 1: u.format1.get_anchor (c, glyph_id, x, y); return; case 2: u.format2.get_anchor (c, glyph_id, x, y); return; case 3: u.format3.get_anchor (c, glyph_id, x, y); return; default: return; } } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); if (!u.format.sanitize (c)) return_trace (false); switch (u.format) { case 1: return_trace (u.format1.sanitize (c)); case 2: return_trace (u.format2.sanitize (c)); case 3: return_trace (u.format3.sanitize (c)); default:return_trace (true); } } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); switch (u.format) { case 1: return_trace (bool (reinterpret_cast (u.format1.copy (c->serializer)))); case 2: if (c->plan->flags & HB_SUBSET_FLAGS_NO_HINTING) { // AnchorFormat 2 just containins extra hinting information, so // if hints are being dropped convert to format 1. return_trace (bool (reinterpret_cast (u.format1.copy (c->serializer)))); } return_trace (bool (reinterpret_cast (u.format2.copy (c->serializer)))); case 3: return_trace (bool (reinterpret_cast (u.format3.copy (c->serializer, c->plan->layout_variation_idx_map)))); default:return_trace (false); } } void collect_variation_indices (hb_collect_variation_indices_context_t *c) const { switch (u.format) { case 1: case 2: return; case 3: u.format3.collect_variation_indices (c); return; default: return; } } protected: union { HBUINT16 format; /* Format identifier */ AnchorFormat1 format1; AnchorFormat2 format2; AnchorFormat3 format3; } u; public: DEFINE_SIZE_UNION (2, format); }; struct AnchorMatrix { const Anchor& get_anchor (unsigned int row, unsigned int col, unsigned int cols, bool *found) const { *found = false; if (unlikely (row >= rows || col >= cols)) return Null (Anchor); *found = !matrixZ[row * cols + col].is_null (); return this+matrixZ[row * cols + col]; } template void collect_variation_indices (hb_collect_variation_indices_context_t *c, Iterator index_iter) const { for (unsigned i : index_iter) (this+matrixZ[i]).collect_variation_indices (c); } template bool subset (hb_subset_context_t *c, unsigned num_rows, Iterator index_iter) const { TRACE_SUBSET (this); auto *out = c->serializer->start_embed (this); if (!index_iter) return_trace (false); if (unlikely (!c->serializer->extend_min (out))) return_trace (false); out->rows = num_rows; for (const unsigned i : index_iter) { auto *offset = c->serializer->embed (matrixZ[i]); if (!offset) return_trace (false); offset->serialize_subset (c, matrixZ[i], this); } return_trace (true); } bool sanitize (hb_sanitize_context_t *c, unsigned int cols) const { TRACE_SANITIZE (this); if (!c->check_struct (this)) return_trace (false); if (unlikely (hb_unsigned_mul_overflows (rows, cols))) return_trace (false); unsigned int count = rows * cols; if (!c->check_array (matrixZ.arrayZ, count)) return_trace (false); for (unsigned int i = 0; i < count; i++) if (!matrixZ[i].sanitize (c, this)) return_trace (false); return_trace (true); } HBUINT16 rows; /* Number of rows */ UnsizedArrayOf> matrixZ; /* Matrix of offsets to Anchor tables-- * from beginning of AnchorMatrix table */ public: DEFINE_SIZE_ARRAY (2, matrixZ); }; struct MarkRecord { friend struct MarkArray; unsigned get_class () const { return (unsigned) klass; } bool sanitize (hb_sanitize_context_t *c, const void *base) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && markAnchor.sanitize (c, base)); } MarkRecord *subset (hb_subset_context_t *c, const void *src_base, const hb_map_t *klass_mapping) const { TRACE_SUBSET (this); auto *out = c->serializer->embed (this); if (unlikely (!out)) return_trace (nullptr); out->klass = klass_mapping->get (klass); out->markAnchor.serialize_subset (c, markAnchor, src_base); return_trace (out); } void collect_variation_indices (hb_collect_variation_indices_context_t *c, const void *src_base) const { (src_base+markAnchor).collect_variation_indices (c); } protected: HBUINT16 klass; /* Class defined for this mark */ Offset16To markAnchor; /* Offset to Anchor table--from * beginning of MarkArray table */ public: DEFINE_SIZE_STATIC (4); }; struct MarkArray : Array16Of /* Array of MarkRecords--in Coverage order */ { bool apply (hb_ot_apply_context_t *c, unsigned int mark_index, unsigned int glyph_index, const AnchorMatrix &anchors, unsigned int class_count, unsigned int glyph_pos) const { TRACE_APPLY (this); hb_buffer_t *buffer = c->buffer; const MarkRecord &record = Array16Of::operator[](mark_index); unsigned int mark_class = record.klass; const Anchor& mark_anchor = this + record.markAnchor; bool found; const Anchor& glyph_anchor = anchors.get_anchor (glyph_index, mark_class, class_count, &found); /* If this subtable doesn't have an anchor for this base and this class, * return false such that the subsequent subtables have a chance at it. */ if (unlikely (!found)) return_trace (false); float mark_x, mark_y, base_x, base_y; buffer->unsafe_to_break (glyph_pos, buffer->idx); mark_anchor.get_anchor (c, buffer->cur().codepoint, &mark_x, &mark_y); glyph_anchor.get_anchor (c, buffer->info[glyph_pos].codepoint, &base_x, &base_y); hb_glyph_position_t &o = buffer->cur_pos(); o.x_offset = roundf (base_x - mark_x); o.y_offset = roundf (base_y - mark_y); o.attach_type() = ATTACH_TYPE_MARK; o.attach_chain() = (int) glyph_pos - (int) buffer->idx; buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT; buffer->idx++; return_trace (true); } template bool subset (hb_subset_context_t *c, Iterator coverage, const hb_map_t *klass_mapping) const { TRACE_SUBSET (this); const hb_set_t &glyphset = *c->plan->glyphset_gsub (); auto* out = c->serializer->start_embed (this); if (unlikely (!c->serializer->extend_min (out))) return_trace (false); auto mark_iter = + hb_zip (coverage, this->iter ()) | hb_filter (glyphset, hb_first) | hb_map (hb_second) ; unsigned new_length = 0; for (const auto& mark_record : mark_iter) { if (unlikely (!mark_record.subset (c, this, klass_mapping))) return_trace (false); new_length++; } if (unlikely (!c->serializer->check_assign (out->len, new_length, HB_SERIALIZE_ERROR_ARRAY_OVERFLOW))) return_trace (false); return_trace (true); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (Array16Of::sanitize (c, this)); } }; /* Lookups */ struct SinglePosFormat1 { bool intersects (const hb_set_t *glyphs) const { return (this+coverage).intersects (glyphs); } void closure_lookups (hb_closure_lookups_context_t *c) const {} void collect_variation_indices (hb_collect_variation_indices_context_t *c) const { if (!valueFormat.has_device ()) return; auto it = + hb_iter (this+coverage) | hb_filter (c->glyph_set) ; if (!it) return; valueFormat.collect_variation_indices (c, this, values.as_array (valueFormat.get_len ())); } void collect_glyphs (hb_collect_glyphs_context_t *c) const { if (unlikely (!(this+coverage).collect_coverage (c->input))) return; } const Coverage &get_coverage () const { return this+coverage; } ValueFormat get_value_format () const { return valueFormat; } bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); hb_buffer_t *buffer = c->buffer; unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint); if (likely (index == NOT_COVERED)) return_trace (false); valueFormat.apply_value (c, this, values, buffer->cur_pos()); buffer->idx++; return_trace (true); } template void serialize (hb_serialize_context_t *c, const SrcLookup *src, Iterator it, ValueFormat newFormat, const hb_map_t *layout_variation_idx_map) { if (unlikely (!c->extend_min (this))) return; if (unlikely (!c->check_assign (valueFormat, newFormat, HB_SERIALIZE_ERROR_INT_OVERFLOW))) return; for (const hb_array_t& _ : + it | hb_map (hb_second)) { src->get_value_format ().copy_values (c, newFormat, src, &_, layout_variation_idx_map); // Only serialize the first entry in the iterator, the rest are assumed to // be the same. break; } auto glyphs = + it | hb_map_retains_sorting (hb_first) ; coverage.serialize_serialize (c, glyphs); } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); const hb_set_t &glyphset = *c->plan->glyphset_gsub (); const hb_map_t &glyph_map = *c->plan->glyph_map; auto it = + hb_iter (this+coverage) | hb_filter (glyphset) | hb_map_retains_sorting (glyph_map) | hb_zip (hb_repeat (values.as_array (valueFormat.get_len ()))) ; bool ret = bool (it); SinglePos_serialize (c->serializer, this, it, c->plan->layout_variation_idx_map); return_trace (ret); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && coverage.sanitize (c, this) && valueFormat.sanitize_value (c, this, values)); } protected: HBUINT16 format; /* Format identifier--format = 1 */ Offset16To coverage; /* Offset to Coverage table--from * beginning of subtable */ ValueFormat valueFormat; /* Defines the types of data in the * ValueRecord */ ValueRecord values; /* Defines positioning * value(s)--applied to all glyphs in * the Coverage table */ public: DEFINE_SIZE_ARRAY (6, values); }; struct SinglePosFormat2 { bool intersects (const hb_set_t *glyphs) const { return (this+coverage).intersects (glyphs); } void closure_lookups (hb_closure_lookups_context_t *c) const {} void collect_variation_indices (hb_collect_variation_indices_context_t *c) const { if (!valueFormat.has_device ()) return; auto it = + hb_zip (this+coverage, hb_range ((unsigned) valueCount)) | hb_filter (c->glyph_set, hb_first) ; if (!it) return; unsigned sub_length = valueFormat.get_len (); const hb_array_t values_array = values.as_array (valueCount * sub_length); for (unsigned i : + it | hb_map (hb_second)) valueFormat.collect_variation_indices (c, this, values_array.sub_array (i * sub_length, sub_length)); } void collect_glyphs (hb_collect_glyphs_context_t *c) const { if (unlikely (!(this+coverage).collect_coverage (c->input))) return; } const Coverage &get_coverage () const { return this+coverage; } ValueFormat get_value_format () const { return valueFormat; } bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); hb_buffer_t *buffer = c->buffer; unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint); if (likely (index == NOT_COVERED)) return_trace (false); if (likely (index >= valueCount)) return_trace (false); valueFormat.apply_value (c, this, &values[index * valueFormat.get_len ()], buffer->cur_pos()); buffer->idx++; return_trace (true); } template void serialize (hb_serialize_context_t *c, const SrcLookup *src, Iterator it, ValueFormat newFormat, const hb_map_t *layout_variation_idx_map) { auto out = c->extend_min (this); if (unlikely (!out)) return; if (unlikely (!c->check_assign (valueFormat, newFormat, HB_SERIALIZE_ERROR_INT_OVERFLOW))) return; if (unlikely (!c->check_assign (valueCount, it.len (), HB_SERIALIZE_ERROR_ARRAY_OVERFLOW))) return; + it | hb_map (hb_second) | hb_apply ([&] (hb_array_t _) { src->get_value_format ().copy_values (c, newFormat, src, &_, layout_variation_idx_map); }) ; auto glyphs = + it | hb_map_retains_sorting (hb_first) ; coverage.serialize_serialize (c, glyphs); } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); const hb_set_t &glyphset = *c->plan->glyphset_gsub (); const hb_map_t &glyph_map = *c->plan->glyph_map; unsigned sub_length = valueFormat.get_len (); auto values_array = values.as_array (valueCount * sub_length); auto it = + hb_zip (this+coverage, hb_range ((unsigned) valueCount)) | hb_filter (glyphset, hb_first) | hb_map_retains_sorting ([&] (const hb_pair_t& _) { return hb_pair (glyph_map[_.first], values_array.sub_array (_.second * sub_length, sub_length)); }) ; bool ret = bool (it); SinglePos_serialize (c->serializer, this, it, c->plan->layout_variation_idx_map); return_trace (ret); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && coverage.sanitize (c, this) && valueFormat.sanitize_values (c, this, values, valueCount)); } protected: HBUINT16 format; /* Format identifier--format = 2 */ Offset16To coverage; /* Offset to Coverage table--from * beginning of subtable */ ValueFormat valueFormat; /* Defines the types of data in the * ValueRecord */ HBUINT16 valueCount; /* Number of ValueRecords */ ValueRecord values; /* Array of ValueRecords--positioning * values applied to glyphs */ public: DEFINE_SIZE_ARRAY (8, values); }; struct SinglePos { template unsigned get_format (Iterator glyph_val_iter_pairs) { hb_array_t first_val_iter = hb_second (*glyph_val_iter_pairs); for (const auto iter : glyph_val_iter_pairs) for (const auto _ : hb_zip (iter.second, first_val_iter)) if (_.first != _.second) return 2; return 1; } template void serialize (hb_serialize_context_t *c, const SrcLookup* src, Iterator glyph_val_iter_pairs, const hb_map_t *layout_variation_idx_map) { if (unlikely (!c->extend_min (u.format))) return; unsigned format = 2; ValueFormat new_format = src->get_value_format (); if (glyph_val_iter_pairs) { format = get_format (glyph_val_iter_pairs); new_format = src->get_value_format ().get_effective_format (+ glyph_val_iter_pairs | hb_map (hb_second)); } u.format = format; switch (u.format) { case 1: u.format1.serialize (c, src, glyph_val_iter_pairs, new_format, layout_variation_idx_map); return; case 2: u.format2.serialize (c, src, glyph_val_iter_pairs, new_format, layout_variation_idx_map); return; default:return; } } template typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const { TRACE_DISPATCH (this, u.format); if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); switch (u.format) { case 1: return_trace (c->dispatch (u.format1, std::forward (ds)...)); case 2: return_trace (c->dispatch (u.format2, std::forward (ds)...)); default:return_trace (c->default_return_value ()); } } protected: union { HBUINT16 format; /* Format identifier */ SinglePosFormat1 format1; SinglePosFormat2 format2; } u; }; template static void SinglePos_serialize (hb_serialize_context_t *c, const SrcLookup *src, Iterator it, const hb_map_t *layout_variation_idx_map) { c->start_embed ()->serialize (c, src, it, layout_variation_idx_map); } struct PairValueRecord { friend struct PairSet; int cmp (hb_codepoint_t k) const { return secondGlyph.cmp (k); } struct context_t { const void *base; const ValueFormat *valueFormats; const ValueFormat *newFormats; unsigned len1; /* valueFormats[0].get_len() */ const hb_map_t *glyph_map; const hb_map_t *layout_variation_idx_map; }; bool subset (hb_subset_context_t *c, context_t *closure) const { TRACE_SERIALIZE (this); auto *s = c->serializer; auto *out = s->start_embed (*this); if (unlikely (!s->extend_min (out))) return_trace (false); out->secondGlyph = (*closure->glyph_map)[secondGlyph]; closure->valueFormats[0].copy_values (s, closure->newFormats[0], closure->base, &values[0], closure->layout_variation_idx_map); closure->valueFormats[1].copy_values (s, closure->newFormats[1], closure->base, &values[closure->len1], closure->layout_variation_idx_map); return_trace (true); } void collect_variation_indices (hb_collect_variation_indices_context_t *c, const ValueFormat *valueFormats, const void *base) const { unsigned record1_len = valueFormats[0].get_len (); unsigned record2_len = valueFormats[1].get_len (); const hb_array_t values_array = values.as_array (record1_len + record2_len); if (valueFormats[0].has_device ()) valueFormats[0].collect_variation_indices (c, base, values_array.sub_array (0, record1_len)); if (valueFormats[1].has_device ()) valueFormats[1].collect_variation_indices (c, base, values_array.sub_array (record1_len, record2_len)); } bool intersects (const hb_set_t& glyphset) const { return glyphset.has(secondGlyph); } const Value* get_values_1 () const { return &values[0]; } const Value* get_values_2 (ValueFormat format1) const { return &values[format1.get_len ()]; } protected: HBGlyphID16 secondGlyph; /* GlyphID of second glyph in the * pair--first glyph is listed in the * Coverage table */ ValueRecord values; /* Positioning data for the first glyph * followed by for second glyph */ public: DEFINE_SIZE_ARRAY (2, values); }; struct PairSet { friend struct PairPosFormat1; bool intersects (const hb_set_t *glyphs, const ValueFormat *valueFormats) const { unsigned int len1 = valueFormats[0].get_len (); unsigned int len2 = valueFormats[1].get_len (); unsigned int record_size = HBUINT16::static_size * (1 + len1 + len2); const PairValueRecord *record = &firstPairValueRecord; unsigned int count = len; for (unsigned int i = 0; i < count; i++) { if (glyphs->has (record->secondGlyph)) return true; record = &StructAtOffset (record, record_size); } return false; } void collect_glyphs (hb_collect_glyphs_context_t *c, const ValueFormat *valueFormats) const { unsigned int len1 = valueFormats[0].get_len (); unsigned int len2 = valueFormats[1].get_len (); unsigned int record_size = HBUINT16::static_size * (1 + len1 + len2); const PairValueRecord *record = &firstPairValueRecord; c->input->add_array (&record->secondGlyph, len, record_size); } void collect_variation_indices (hb_collect_variation_indices_context_t *c, const ValueFormat *valueFormats) const { unsigned len1 = valueFormats[0].get_len (); unsigned len2 = valueFormats[1].get_len (); unsigned record_size = HBUINT16::static_size * (1 + len1 + len2); const PairValueRecord *record = &firstPairValueRecord; unsigned count = len; for (unsigned i = 0; i < count; i++) { if (c->glyph_set->has (record->secondGlyph)) { record->collect_variation_indices (c, valueFormats, this); } record = &StructAtOffset (record, record_size); } } bool apply (hb_ot_apply_context_t *c, const ValueFormat *valueFormats, unsigned int pos) const { TRACE_APPLY (this); hb_buffer_t *buffer = c->buffer; unsigned int len1 = valueFormats[0].get_len (); unsigned int len2 = valueFormats[1].get_len (); unsigned int record_size = HBUINT16::static_size * (1 + len1 + len2); const PairValueRecord *record = hb_bsearch (buffer->info[pos].codepoint, &firstPairValueRecord, len, record_size); if (record) { bool applied_first = valueFormats[0].apply_value (c, this, &record->values[0], buffer->cur_pos()); bool applied_second = valueFormats[1].apply_value (c, this, &record->values[len1], buffer->pos[pos]); if (applied_first || applied_second) buffer->unsafe_to_break (buffer->idx, pos + 1); if (len2) pos++; buffer->idx = pos; return_trace (true); } return_trace (false); } bool subset (hb_subset_context_t *c, const ValueFormat valueFormats[2], const ValueFormat newFormats[2]) const { TRACE_SUBSET (this); auto snap = c->serializer->snapshot (); auto *out = c->serializer->start_embed (*this); if (unlikely (!c->serializer->extend_min (out))) return_trace (false); out->len = 0; const hb_set_t &glyphset = *c->plan->glyphset_gsub (); const hb_map_t &glyph_map = *c->plan->glyph_map; unsigned len1 = valueFormats[0].get_len (); unsigned len2 = valueFormats[1].get_len (); unsigned record_size = HBUINT16::static_size + Value::static_size * (len1 + len2); PairValueRecord::context_t context = { this, valueFormats, newFormats, len1, &glyph_map, c->plan->layout_variation_idx_map }; const PairValueRecord *record = &firstPairValueRecord; unsigned count = len, num = 0; for (unsigned i = 0; i < count; i++) { if (glyphset.has (record->secondGlyph) && record->subset (c, &context)) num++; record = &StructAtOffset (record, record_size); } out->len = num; if (!num) c->serializer->revert (snap); return_trace (num); } struct sanitize_closure_t { const ValueFormat *valueFormats; unsigned int len1; /* valueFormats[0].get_len() */ unsigned int stride; /* 1 + len1 + len2 */ }; bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) const { TRACE_SANITIZE (this); if (!(c->check_struct (this) && c->check_range (&firstPairValueRecord, len, HBUINT16::static_size, closure->stride))) return_trace (false); unsigned int count = len; const PairValueRecord *record = &firstPairValueRecord; return_trace (closure->valueFormats[0].sanitize_values_stride_unsafe (c, this, &record->values[0], count, closure->stride) && closure->valueFormats[1].sanitize_values_stride_unsafe (c, this, &record->values[closure->len1], count, closure->stride)); } protected: HBUINT16 len; /* Number of PairValueRecords */ PairValueRecord firstPairValueRecord; /* Array of PairValueRecords--ordered * by GlyphID of the second glyph */ public: DEFINE_SIZE_MIN (2); }; struct PairPosFormat1 { bool intersects (const hb_set_t *glyphs) const { return + hb_zip (this+coverage, pairSet) | hb_filter (*glyphs, hb_first) | hb_map (hb_second) | hb_map ([glyphs, this] (const Offset16To &_) { return (this+_).intersects (glyphs, valueFormat); }) | hb_any ; } void closure_lookups (hb_closure_lookups_context_t *c) const {} void collect_variation_indices (hb_collect_variation_indices_context_t *c) const { if ((!valueFormat[0].has_device ()) && (!valueFormat[1].has_device ())) return; auto it = + hb_zip (this+coverage, pairSet) | hb_filter (c->glyph_set, hb_first) | hb_map (hb_second) ; if (!it) return; + it | hb_map (hb_add (this)) | hb_apply ([&] (const PairSet& _) { _.collect_variation_indices (c, valueFormat); }) ; } void collect_glyphs (hb_collect_glyphs_context_t *c) const { if (unlikely (!(this+coverage).collect_coverage (c->input))) return; unsigned int count = pairSet.len; for (unsigned int i = 0; i < count; i++) (this+pairSet[i]).collect_glyphs (c, valueFormat); } const Coverage &get_coverage () const { return this+coverage; } bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); hb_buffer_t *buffer = c->buffer; unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint); if (likely (index == NOT_COVERED)) return_trace (false); hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input; skippy_iter.reset (buffer->idx, 1); if (!skippy_iter.next ()) return_trace (false); return_trace ((this+pairSet[index]).apply (c, valueFormat, skippy_iter.idx)); } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); const hb_set_t &glyphset = *c->plan->glyphset_gsub (); const hb_map_t &glyph_map = *c->plan->glyph_map; auto *out = c->serializer->start_embed (*this); if (unlikely (!c->serializer->extend_min (out))) return_trace (false); out->format = format; out->valueFormat[0] = valueFormat[0]; out->valueFormat[1] = valueFormat[1]; if (c->plan->flags & HB_SUBSET_FLAGS_NO_HINTING) { hb_pair_t newFormats = compute_effective_value_formats (glyphset); out->valueFormat[0] = newFormats.first; out->valueFormat[1] = newFormats.second; } hb_sorted_vector_t new_coverage; + hb_zip (this+coverage, pairSet) | hb_filter (glyphset, hb_first) | hb_filter ([this, c, out] (const Offset16To& _) { auto snap = c->serializer->snapshot (); auto *o = out->pairSet.serialize_append (c->serializer); if (unlikely (!o)) return false; bool ret = o->serialize_subset (c, _, this, valueFormat, out->valueFormat); if (!ret) { out->pairSet.pop (); c->serializer->revert (snap); } return ret; }, hb_second) | hb_map (hb_first) | hb_map (glyph_map) | hb_sink (new_coverage) ; out->coverage.serialize_serialize (c->serializer, new_coverage.iter ()); return_trace (bool (new_coverage)); } hb_pair_t compute_effective_value_formats (const hb_set_t& glyphset) const { unsigned len1 = valueFormat[0].get_len (); unsigned len2 = valueFormat[1].get_len (); unsigned record_size = HBUINT16::static_size + Value::static_size * (len1 + len2); unsigned format1 = 0; unsigned format2 = 0; for (const Offset16To& _ : + hb_zip (this+coverage, pairSet) | hb_filter (glyphset, hb_first) | hb_map (hb_second)) { const PairSet& set = (this + _); const PairValueRecord *record = &set.firstPairValueRecord; for (unsigned i = 0; i < set.len; i++) { if (record->intersects (glyphset)) { format1 = format1 | valueFormat[0].get_effective_format (record->get_values_1 ()); format2 = format2 | valueFormat[1].get_effective_format (record->get_values_2 (valueFormat[0])); } record = &StructAtOffset (record, record_size); } } return hb_pair (format1, format2); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); if (!c->check_struct (this)) return_trace (false); unsigned int len1 = valueFormat[0].get_len (); unsigned int len2 = valueFormat[1].get_len (); PairSet::sanitize_closure_t closure = { valueFormat, len1, 1 + len1 + len2 }; return_trace (coverage.sanitize (c, this) && pairSet.sanitize (c, this, &closure)); } protected: HBUINT16 format; /* Format identifier--format = 1 */ Offset16To coverage; /* Offset to Coverage table--from * beginning of subtable */ ValueFormat valueFormat[2]; /* [0] Defines the types of data in * ValueRecord1--for the first glyph * in the pair--may be zero (0) */ /* [1] Defines the types of data in * ValueRecord2--for the second glyph * in the pair--may be zero (0) */ Array16OfOffset16To pairSet; /* Array of PairSet tables * ordered by Coverage Index */ public: DEFINE_SIZE_ARRAY (10, pairSet); }; struct PairPosFormat2 { bool intersects (const hb_set_t *glyphs) const { return (this+coverage).intersects (glyphs) && (this+classDef2).intersects (glyphs); } void closure_lookups (hb_closure_lookups_context_t *c) const {} void collect_variation_indices (hb_collect_variation_indices_context_t *c) const { if (!intersects (c->glyph_set)) return; if ((!valueFormat1.has_device ()) && (!valueFormat2.has_device ())) return; hb_set_t klass1_glyphs, klass2_glyphs; if (!(this+classDef1).collect_coverage (&klass1_glyphs)) return; if (!(this+classDef2).collect_coverage (&klass2_glyphs)) return; hb_set_t class1_set, class2_set; for (const unsigned cp : + c->glyph_set->iter () | hb_filter (this + coverage)) { if (!klass1_glyphs.has (cp)) class1_set.add (0); else { unsigned klass1 = (this+classDef1).get (cp); class1_set.add (klass1); } } class2_set.add (0); for (const unsigned cp : + c->glyph_set->iter () | hb_filter (klass2_glyphs)) { unsigned klass2 = (this+classDef2).get (cp); class2_set.add (klass2); } if (class1_set.is_empty () || class2_set.is_empty () || (class2_set.get_population() == 1 && class2_set.has(0))) return; unsigned len1 = valueFormat1.get_len (); unsigned len2 = valueFormat2.get_len (); const hb_array_t values_array = values.as_array ((unsigned)class1Count * (unsigned) class2Count * (len1 + len2)); for (const unsigned class1_idx : class1_set.iter ()) { for (const unsigned class2_idx : class2_set.iter ()) { unsigned start_offset = (class1_idx * (unsigned) class2Count + class2_idx) * (len1 + len2); if (valueFormat1.has_device ()) valueFormat1.collect_variation_indices (c, this, values_array.sub_array (start_offset, len1)); if (valueFormat2.has_device ()) valueFormat2.collect_variation_indices (c, this, values_array.sub_array (start_offset+len1, len2)); } } } void collect_glyphs (hb_collect_glyphs_context_t *c) const { if (unlikely (!(this+coverage).collect_coverage (c->input))) return; if (unlikely (!(this+classDef2).collect_coverage (c->input))) return; } const Coverage &get_coverage () const { return this+coverage; } bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); hb_buffer_t *buffer = c->buffer; unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint); if (likely (index == NOT_COVERED)) return_trace (false); hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input; skippy_iter.reset (buffer->idx, 1); if (!skippy_iter.next ()) return_trace (false); unsigned int len1 = valueFormat1.get_len (); unsigned int len2 = valueFormat2.get_len (); unsigned int record_len = len1 + len2; unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint); unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint); if (unlikely (klass1 >= class1Count || klass2 >= class2Count)) return_trace (false); const Value *v = &values[record_len * (klass1 * class2Count + klass2)]; bool applied_first = valueFormat1.apply_value (c, this, v, buffer->cur_pos()); bool applied_second = valueFormat2.apply_value (c, this, v + len1, buffer->pos[skippy_iter.idx]); if (applied_first || applied_second) buffer->unsafe_to_break (buffer->idx, skippy_iter.idx + 1); buffer->idx = skippy_iter.idx; if (len2) buffer->idx++; return_trace (true); } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); auto *out = c->serializer->start_embed (*this); if (unlikely (!c->serializer->extend_min (out))) return_trace (false); out->format = format; hb_map_t klass1_map; out->classDef1.serialize_subset (c, classDef1, this, &klass1_map, true, true, &(this + coverage)); out->class1Count = klass1_map.get_population (); hb_map_t klass2_map; out->classDef2.serialize_subset (c, classDef2, this, &klass2_map, true, false); out->class2Count = klass2_map.get_population (); unsigned len1 = valueFormat1.get_len (); unsigned len2 = valueFormat2.get_len (); hb_pair_t newFormats = hb_pair (valueFormat1, valueFormat2); if (c->plan->flags & HB_SUBSET_FLAGS_NO_HINTING) newFormats = compute_effective_value_formats (klass1_map, klass2_map); out->valueFormat1 = newFormats.first; out->valueFormat2 = newFormats.second; for (unsigned class1_idx : + hb_range ((unsigned) class1Count) | hb_filter (klass1_map)) { for (unsigned class2_idx : + hb_range ((unsigned) class2Count) | hb_filter (klass2_map)) { unsigned idx = (class1_idx * (unsigned) class2Count + class2_idx) * (len1 + len2); valueFormat1.copy_values (c->serializer, newFormats.first, this, &values[idx], c->plan->layout_variation_idx_map); valueFormat2.copy_values (c->serializer, newFormats.second, this, &values[idx + len1], c->plan->layout_variation_idx_map); } } const hb_set_t &glyphset = *c->plan->glyphset_gsub (); const hb_map_t &glyph_map = *c->plan->glyph_map; auto it = + hb_iter (this+coverage) | hb_filter (glyphset) | hb_map_retains_sorting (glyph_map) ; out->coverage.serialize_serialize (c->serializer, it); return_trace (out->class1Count && out->class2Count && bool (it)); } hb_pair_t compute_effective_value_formats (const hb_map_t& klass1_map, const hb_map_t& klass2_map) const { unsigned len1 = valueFormat1.get_len (); unsigned len2 = valueFormat2.get_len (); unsigned format1 = 0; unsigned format2 = 0; for (unsigned class1_idx : + hb_range ((unsigned) class1Count) | hb_filter (klass1_map)) { for (unsigned class2_idx : + hb_range ((unsigned) class2Count) | hb_filter (klass2_map)) { unsigned idx = (class1_idx * (unsigned) class2Count + class2_idx) * (len1 + len2); format1 = format1 | valueFormat1.get_effective_format (&values[idx]); format2 = format2 | valueFormat2.get_effective_format (&values[idx + len1]); } } return hb_pair (format1, format2); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); if (!(c->check_struct (this) && coverage.sanitize (c, this) && classDef1.sanitize (c, this) && classDef2.sanitize (c, this))) return_trace (false); unsigned int len1 = valueFormat1.get_len (); unsigned int len2 = valueFormat2.get_len (); unsigned int stride = len1 + len2; unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size (); unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count; return_trace (c->check_range ((const void *) values, count, record_size) && valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) && valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride)); } protected: HBUINT16 format; /* Format identifier--format = 2 */ Offset16To coverage; /* Offset to Coverage table--from * beginning of subtable */ ValueFormat valueFormat1; /* ValueRecord definition--for the * first glyph of the pair--may be zero * (0) */ ValueFormat valueFormat2; /* ValueRecord definition--for the * second glyph of the pair--may be * zero (0) */ Offset16To classDef1; /* Offset to ClassDef table--from * beginning of PairPos subtable--for * the first glyph of the pair */ Offset16To classDef2; /* Offset to ClassDef table--from * beginning of PairPos subtable--for * the second glyph of the pair */ HBUINT16 class1Count; /* Number of classes in ClassDef1 * table--includes Class0 */ HBUINT16 class2Count; /* Number of classes in ClassDef2 * table--includes Class0 */ ValueRecord values; /* Matrix of value pairs: * class1-major, class2-minor, * Each entry has value1 and value2 */ public: DEFINE_SIZE_ARRAY (16, values); }; struct PairPos { template typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const { TRACE_DISPATCH (this, u.format); if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); switch (u.format) { case 1: return_trace (c->dispatch (u.format1, std::forward (ds)...)); case 2: return_trace (c->dispatch (u.format2, std::forward (ds)...)); default:return_trace (c->default_return_value ()); } } protected: union { HBUINT16 format; /* Format identifier */ PairPosFormat1 format1; PairPosFormat2 format2; } u; }; struct EntryExitRecord { friend struct CursivePosFormat1; bool sanitize (hb_sanitize_context_t *c, const void *base) const { TRACE_SANITIZE (this); return_trace (entryAnchor.sanitize (c, base) && exitAnchor.sanitize (c, base)); } void collect_variation_indices (hb_collect_variation_indices_context_t *c, const void *src_base) const { (src_base+entryAnchor).collect_variation_indices (c); (src_base+exitAnchor).collect_variation_indices (c); } EntryExitRecord* subset (hb_subset_context_t *c, const void *src_base) const { TRACE_SERIALIZE (this); auto *out = c->serializer->embed (this); if (unlikely (!out)) return_trace (nullptr); out->entryAnchor.serialize_subset (c, entryAnchor, src_base); out->exitAnchor.serialize_subset (c, exitAnchor, src_base); return_trace (out); } protected: Offset16To entryAnchor; /* Offset to EntryAnchor table--from * beginning of CursivePos * subtable--may be NULL */ Offset16To exitAnchor; /* Offset to ExitAnchor table--from * beginning of CursivePos * subtable--may be NULL */ public: DEFINE_SIZE_STATIC (4); }; static void reverse_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction, unsigned int new_parent); struct CursivePosFormat1 { bool intersects (const hb_set_t *glyphs) const { return (this+coverage).intersects (glyphs); } void closure_lookups (hb_closure_lookups_context_t *c) const {} void collect_variation_indices (hb_collect_variation_indices_context_t *c) const { + hb_zip (this+coverage, entryExitRecord) | hb_filter (c->glyph_set, hb_first) | hb_map (hb_second) | hb_apply ([&] (const EntryExitRecord& record) { record.collect_variation_indices (c, this); }) ; } void collect_glyphs (hb_collect_glyphs_context_t *c) const { if (unlikely (!(this+coverage).collect_coverage (c->input))) return; } const Coverage &get_coverage () const { return this+coverage; } bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); hb_buffer_t *buffer = c->buffer; const EntryExitRecord &this_record = entryExitRecord[(this+coverage).get_coverage (buffer->cur().codepoint)]; if (!this_record.entryAnchor) return_trace (false); hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input; skippy_iter.reset (buffer->idx, 1); if (!skippy_iter.prev ()) return_trace (false); const EntryExitRecord &prev_record = entryExitRecord[(this+coverage).get_coverage (buffer->info[skippy_iter.idx].codepoint)]; if (!prev_record.exitAnchor) return_trace (false); unsigned int i = skippy_iter.idx; unsigned int j = buffer->idx; buffer->unsafe_to_break (i, j); float entry_x, entry_y, exit_x, exit_y; (this+prev_record.exitAnchor).get_anchor (c, buffer->info[i].codepoint, &exit_x, &exit_y); (this+this_record.entryAnchor).get_anchor (c, buffer->info[j].codepoint, &entry_x, &entry_y); hb_glyph_position_t *pos = buffer->pos; hb_position_t d; /* Main-direction adjustment */ switch (c->direction) { case HB_DIRECTION_LTR: pos[i].x_advance = roundf (exit_x) + pos[i].x_offset; d = roundf (entry_x) + pos[j].x_offset; pos[j].x_advance -= d; pos[j].x_offset -= d; break; case HB_DIRECTION_RTL: d = roundf (exit_x) + pos[i].x_offset; pos[i].x_advance -= d; pos[i].x_offset -= d; pos[j].x_advance = roundf (entry_x) + pos[j].x_offset; break; case HB_DIRECTION_TTB: pos[i].y_advance = roundf (exit_y) + pos[i].y_offset; d = roundf (entry_y) + pos[j].y_offset; pos[j].y_advance -= d; pos[j].y_offset -= d; break; case HB_DIRECTION_BTT: d = roundf (exit_y) + pos[i].y_offset; pos[i].y_advance -= d; pos[i].y_offset -= d; pos[j].y_advance = roundf (entry_y); break; case HB_DIRECTION_INVALID: default: break; } /* Cross-direction adjustment */ /* We attach child to parent (think graph theory and rooted trees whereas * the root stays on baseline and each node aligns itself against its * parent. * * Optimize things for the case of RightToLeft, as that's most common in * Arabic. */ unsigned int child = i; unsigned int parent = j; hb_position_t x_offset = entry_x - exit_x; hb_position_t y_offset = entry_y - exit_y; if (!(c->lookup_props & LookupFlag::RightToLeft)) { unsigned int k = child; child = parent; parent = k; x_offset = -x_offset; y_offset = -y_offset; } /* If child was already connected to someone else, walk through its old * chain and reverse the link direction, such that the whole tree of its * previous connection now attaches to new parent. Watch out for case * where new parent is on the path from old chain... */ reverse_cursive_minor_offset (pos, child, c->direction, parent); pos[child].attach_type() = ATTACH_TYPE_CURSIVE; pos[child].attach_chain() = (int) parent - (int) child; buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT; if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction))) pos[child].y_offset = y_offset; else pos[child].x_offset = x_offset; /* If parent was attached to child, separate them. * https://github.com/harfbuzz/harfbuzz/issues/2469 */ if (unlikely (pos[parent].attach_chain() == -pos[child].attach_chain())) pos[parent].attach_chain() = 0; buffer->idx++; return_trace (true); } template void serialize (hb_subset_context_t *c, Iterator it, const void *src_base) { if (unlikely (!c->serializer->extend_min ((*this)))) return; this->format = 1; this->entryExitRecord.len = it.len (); for (const EntryExitRecord& entry_record : + it | hb_map (hb_second)) entry_record.subset (c, src_base); auto glyphs = + it | hb_map_retains_sorting (hb_first) ; coverage.serialize_serialize (c->serializer, glyphs); } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); const hb_set_t &glyphset = *c->plan->glyphset_gsub (); const hb_map_t &glyph_map = *c->plan->glyph_map; auto *out = c->serializer->start_embed (*this); if (unlikely (!out)) return_trace (false); auto it = + hb_zip (this+coverage, entryExitRecord) | hb_filter (glyphset, hb_first) | hb_map_retains_sorting ([&] (hb_pair_t p) -> hb_pair_t { return hb_pair (glyph_map[p.first], p.second);}) ; bool ret = bool (it); out->serialize (c, it, this); return_trace (ret); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (coverage.sanitize (c, this) && entryExitRecord.sanitize (c, this)); } protected: HBUINT16 format; /* Format identifier--format = 1 */ Offset16To coverage; /* Offset to Coverage table--from * beginning of subtable */ Array16Of entryExitRecord; /* Array of EntryExit records--in * Coverage Index order */ public: DEFINE_SIZE_ARRAY (6, entryExitRecord); }; struct CursivePos { template typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const { TRACE_DISPATCH (this, u.format); if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); switch (u.format) { case 1: return_trace (c->dispatch (u.format1, std::forward (ds)...)); default:return_trace (c->default_return_value ()); } } protected: union { HBUINT16 format; /* Format identifier */ CursivePosFormat1 format1; } u; }; typedef AnchorMatrix BaseArray; /* base-major-- * in order of BaseCoverage Index--, * mark-minor-- * ordered by class--zero-based. */ static void Markclass_closure_and_remap_indexes (const Coverage &mark_coverage, const MarkArray &mark_array, const hb_set_t &glyphset, hb_map_t* klass_mapping /* INOUT */) { hb_set_t orig_classes; + hb_zip (mark_coverage, mark_array) | hb_filter (glyphset, hb_first) | hb_map (hb_second) | hb_map (&MarkRecord::get_class) | hb_sink (orig_classes) ; unsigned idx = 0; for (auto klass : orig_classes.iter ()) { if (klass_mapping->has (klass)) continue; klass_mapping->set (klass, idx); idx++; } } struct MarkBasePosFormat1 { bool intersects (const hb_set_t *glyphs) const { return (this+markCoverage).intersects (glyphs) && (this+baseCoverage).intersects (glyphs); } void closure_lookups (hb_closure_lookups_context_t *c) const {} void collect_variation_indices (hb_collect_variation_indices_context_t *c) const { + hb_zip (this+markCoverage, this+markArray) | hb_filter (c->glyph_set, hb_first) | hb_map (hb_second) | hb_apply ([&] (const MarkRecord& record) { record.collect_variation_indices (c, &(this+markArray)); }) ; hb_map_t klass_mapping; Markclass_closure_and_remap_indexes (this+markCoverage, this+markArray, *c->glyph_set, &klass_mapping); unsigned basecount = (this+baseArray).rows; auto base_iter = + hb_zip (this+baseCoverage, hb_range (basecount)) | hb_filter (c->glyph_set, hb_first) | hb_map (hb_second) ; hb_sorted_vector_t base_indexes; for (const unsigned row : base_iter) { + hb_range ((unsigned) classCount) | hb_filter (klass_mapping) | hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; }) | hb_sink (base_indexes) ; } (this+baseArray).collect_variation_indices (c, base_indexes.iter ()); } void collect_glyphs (hb_collect_glyphs_context_t *c) const { if (unlikely (!(this+markCoverage).collect_coverage (c->input))) return; if (unlikely (!(this+baseCoverage).collect_coverage (c->input))) return; } const Coverage &get_coverage () const { return this+markCoverage; } bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); hb_buffer_t *buffer = c->buffer; unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint); if (likely (mark_index == NOT_COVERED)) return_trace (false); /* Now we search backwards for a non-mark glyph */ hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input; skippy_iter.reset (buffer->idx, 1); skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks); do { if (!skippy_iter.prev ()) return_trace (false); /* We only want to attach to the first of a MultipleSubst sequence. * https://github.com/harfbuzz/harfbuzz/issues/740 * Reject others... * ...but stop if we find a mark in the MultipleSubst sequence: * https://github.com/harfbuzz/harfbuzz/issues/1020 */ if (!_hb_glyph_info_multiplied (&buffer->info[skippy_iter.idx]) || 0 == _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx]) || (skippy_iter.idx == 0 || _hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx - 1]) || _hb_glyph_info_get_lig_id (&buffer->info[skippy_iter.idx]) != _hb_glyph_info_get_lig_id (&buffer->info[skippy_iter.idx - 1]) || _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx]) != _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx - 1]) + 1 )) break; skippy_iter.reject (); } while (true); /* Checking that matched glyph is actually a base glyph by GDEF is too strong; disabled */ //if (!_hb_glyph_info_is_base_glyph (&buffer->info[skippy_iter.idx])) { return_trace (false); } unsigned int base_index = (this+baseCoverage).get_coverage (buffer->info[skippy_iter.idx].codepoint); if (base_index == NOT_COVERED) return_trace (false); return_trace ((this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, skippy_iter.idx)); } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); const hb_set_t &glyphset = *c->plan->glyphset_gsub (); const hb_map_t &glyph_map = *c->plan->glyph_map; auto *out = c->serializer->start_embed (*this); if (unlikely (!c->serializer->extend_min (out))) return_trace (false); out->format = format; hb_map_t klass_mapping; Markclass_closure_and_remap_indexes (this+markCoverage, this+markArray, glyphset, &klass_mapping); if (!klass_mapping.get_population ()) return_trace (false); out->classCount = klass_mapping.get_population (); auto mark_iter = + hb_zip (this+markCoverage, this+markArray) | hb_filter (glyphset, hb_first) ; hb_sorted_vector_t new_coverage; + mark_iter | hb_map (hb_first) | hb_map (glyph_map) | hb_sink (new_coverage) ; if (!out->markCoverage.serialize_serialize (c->serializer, new_coverage.iter ())) return_trace (false); out->markArray.serialize_subset (c, markArray, this, (this+markCoverage).iter (), &klass_mapping); unsigned basecount = (this+baseArray).rows; auto base_iter = + hb_zip (this+baseCoverage, hb_range (basecount)) | hb_filter (glyphset, hb_first) ; new_coverage.reset (); + base_iter | hb_map (hb_first) | hb_map (glyph_map) | hb_sink (new_coverage) ; if (!out->baseCoverage.serialize_serialize (c->serializer, new_coverage.iter ())) return_trace (false); hb_sorted_vector_t base_indexes; for (const unsigned row : + base_iter | hb_map (hb_second)) { + hb_range ((unsigned) classCount) | hb_filter (klass_mapping) | hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; }) | hb_sink (base_indexes) ; } out->baseArray.serialize_subset (c, baseArray, this, base_iter.len (), base_indexes.iter ()); return_trace (true); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && markCoverage.sanitize (c, this) && baseCoverage.sanitize (c, this) && markArray.sanitize (c, this) && baseArray.sanitize (c, this, (unsigned int) classCount)); } protected: HBUINT16 format; /* Format identifier--format = 1 */ Offset16To markCoverage; /* Offset to MarkCoverage table--from * beginning of MarkBasePos subtable */ Offset16To baseCoverage; /* Offset to BaseCoverage table--from * beginning of MarkBasePos subtable */ HBUINT16 classCount; /* Number of classes defined for marks */ Offset16To markArray; /* Offset to MarkArray table--from * beginning of MarkBasePos subtable */ Offset16To baseArray; /* Offset to BaseArray table--from * beginning of MarkBasePos subtable */ public: DEFINE_SIZE_STATIC (12); }; struct MarkBasePos { template typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const { TRACE_DISPATCH (this, u.format); if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); switch (u.format) { case 1: return_trace (c->dispatch (u.format1, std::forward (ds)...)); default:return_trace (c->default_return_value ()); } } protected: union { HBUINT16 format; /* Format identifier */ MarkBasePosFormat1 format1; } u; }; typedef AnchorMatrix LigatureAttach; /* component-major-- * in order of writing direction--, * mark-minor-- * ordered by class--zero-based. */ /* Array of LigatureAttach tables ordered by LigatureCoverage Index */ struct LigatureArray : List16OfOffset16To { template bool subset (hb_subset_context_t *c, Iterator coverage, unsigned class_count, const hb_map_t *klass_mapping) const { TRACE_SUBSET (this); const hb_set_t &glyphset = *c->plan->glyphset_gsub (); auto *out = c->serializer->start_embed (this); if (unlikely (!c->serializer->extend_min (out))) return_trace (false); for (const auto _ : + hb_zip (coverage, *this) | hb_filter (glyphset, hb_first)) { auto *matrix = out->serialize_append (c->serializer); if (unlikely (!matrix)) return_trace (false); const LigatureAttach& src = (this + _.second); auto indexes = + hb_range (src.rows * class_count) | hb_filter ([=] (unsigned index) { return klass_mapping->has (index % class_count); }) ; matrix->serialize_subset (c, _.second, this, src.rows, indexes); } return_trace (this->len); } }; struct MarkLigPosFormat1 { bool intersects (const hb_set_t *glyphs) const { return (this+markCoverage).intersects (glyphs) && (this+ligatureCoverage).intersects (glyphs); } void closure_lookups (hb_closure_lookups_context_t *c) const {} void collect_variation_indices (hb_collect_variation_indices_context_t *c) const { + hb_zip (this+markCoverage, this+markArray) | hb_filter (c->glyph_set, hb_first) | hb_map (hb_second) | hb_apply ([&] (const MarkRecord& record) { record.collect_variation_indices (c, &(this+markArray)); }) ; hb_map_t klass_mapping; Markclass_closure_and_remap_indexes (this+markCoverage, this+markArray, *c->glyph_set, &klass_mapping); unsigned ligcount = (this+ligatureArray).len; auto lig_iter = + hb_zip (this+ligatureCoverage, hb_range (ligcount)) | hb_filter (c->glyph_set, hb_first) | hb_map (hb_second) ; const LigatureArray& lig_array = this+ligatureArray; for (const unsigned i : lig_iter) { hb_sorted_vector_t lig_indexes; unsigned row_count = lig_array[i].rows; for (unsigned row : + hb_range (row_count)) { + hb_range ((unsigned) classCount) | hb_filter (klass_mapping) | hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; }) | hb_sink (lig_indexes) ; } lig_array[i].collect_variation_indices (c, lig_indexes.iter ()); } } void collect_glyphs (hb_collect_glyphs_context_t *c) const { if (unlikely (!(this+markCoverage).collect_coverage (c->input))) return; if (unlikely (!(this+ligatureCoverage).collect_coverage (c->input))) return; } const Coverage &get_coverage () const { return this+markCoverage; } bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); hb_buffer_t *buffer = c->buffer; unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint); if (likely (mark_index == NOT_COVERED)) return_trace (false); /* Now we search backwards for a non-mark glyph */ hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input; skippy_iter.reset (buffer->idx, 1); skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks); if (!skippy_iter.prev ()) return_trace (false); /* Checking that matched glyph is actually a ligature by GDEF is too strong; disabled */ //if (!_hb_glyph_info_is_ligature (&buffer->info[skippy_iter.idx])) { return_trace (false); } unsigned int j = skippy_iter.idx; unsigned int lig_index = (this+ligatureCoverage).get_coverage (buffer->info[j].codepoint); if (lig_index == NOT_COVERED) return_trace (false); const LigatureArray& lig_array = this+ligatureArray; const LigatureAttach& lig_attach = lig_array[lig_index]; /* Find component to attach to */ unsigned int comp_count = lig_attach.rows; if (unlikely (!comp_count)) return_trace (false); /* We must now check whether the ligature ID of the current mark glyph * is identical to the ligature ID of the found ligature. If yes, we * can directly use the component index. If not, we attach the mark * glyph to the last component of the ligature. */ unsigned int comp_index; unsigned int lig_id = _hb_glyph_info_get_lig_id (&buffer->info[j]); unsigned int mark_id = _hb_glyph_info_get_lig_id (&buffer->cur()); unsigned int mark_comp = _hb_glyph_info_get_lig_comp (&buffer->cur()); if (lig_id && lig_id == mark_id && mark_comp > 0) comp_index = hb_min (comp_count, _hb_glyph_info_get_lig_comp (&buffer->cur())) - 1; else comp_index = comp_count - 1; return_trace ((this+markArray).apply (c, mark_index, comp_index, lig_attach, classCount, j)); } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); const hb_set_t &glyphset = *c->plan->glyphset_gsub (); const hb_map_t &glyph_map = *c->plan->glyph_map; auto *out = c->serializer->start_embed (*this); if (unlikely (!c->serializer->extend_min (out))) return_trace (false); out->format = format; hb_map_t klass_mapping; Markclass_closure_and_remap_indexes (this+markCoverage, this+markArray, glyphset, &klass_mapping); if (!klass_mapping.get_population ()) return_trace (false); out->classCount = klass_mapping.get_population (); auto mark_iter = + hb_zip (this+markCoverage, this+markArray) | hb_filter (glyphset, hb_first) ; auto new_mark_coverage = + mark_iter | hb_map_retains_sorting (hb_first) | hb_map_retains_sorting (glyph_map) ; if (!out->markCoverage.serialize_serialize (c->serializer, new_mark_coverage)) return_trace (false); out->markArray.serialize_subset (c, markArray, this, (this+markCoverage).iter (), &klass_mapping); auto new_ligature_coverage = + hb_iter (this + ligatureCoverage) | hb_filter (glyphset) | hb_map_retains_sorting (glyph_map) ; if (!out->ligatureCoverage.serialize_serialize (c->serializer, new_ligature_coverage)) return_trace (false); out->ligatureArray.serialize_subset (c, ligatureArray, this, hb_iter (this+ligatureCoverage), classCount, &klass_mapping); return_trace (true); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && markCoverage.sanitize (c, this) && ligatureCoverage.sanitize (c, this) && markArray.sanitize (c, this) && ligatureArray.sanitize (c, this, (unsigned int) classCount)); } protected: HBUINT16 format; /* Format identifier--format = 1 */ Offset16To markCoverage; /* Offset to Mark Coverage table--from * beginning of MarkLigPos subtable */ Offset16To ligatureCoverage; /* Offset to Ligature Coverage * table--from beginning of MarkLigPos * subtable */ HBUINT16 classCount; /* Number of defined mark classes */ Offset16To markArray; /* Offset to MarkArray table--from * beginning of MarkLigPos subtable */ Offset16To ligatureArray; /* Offset to LigatureArray table--from * beginning of MarkLigPos subtable */ public: DEFINE_SIZE_STATIC (12); }; struct MarkLigPos { template typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const { TRACE_DISPATCH (this, u.format); if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); switch (u.format) { case 1: return_trace (c->dispatch (u.format1, std::forward (ds)...)); default:return_trace (c->default_return_value ()); } } protected: union { HBUINT16 format; /* Format identifier */ MarkLigPosFormat1 format1; } u; }; typedef AnchorMatrix Mark2Array; /* mark2-major-- * in order of Mark2Coverage Index--, * mark1-minor-- * ordered by class--zero-based. */ struct MarkMarkPosFormat1 { bool intersects (const hb_set_t *glyphs) const { return (this+mark1Coverage).intersects (glyphs) && (this+mark2Coverage).intersects (glyphs); } void closure_lookups (hb_closure_lookups_context_t *c) const {} void collect_variation_indices (hb_collect_variation_indices_context_t *c) const { + hb_zip (this+mark1Coverage, this+mark1Array) | hb_filter (c->glyph_set, hb_first) | hb_map (hb_second) | hb_apply ([&] (const MarkRecord& record) { record.collect_variation_indices (c, &(this+mark1Array)); }) ; hb_map_t klass_mapping; Markclass_closure_and_remap_indexes (this+mark1Coverage, this+mark1Array, *c->glyph_set, &klass_mapping); unsigned mark2_count = (this+mark2Array).rows; auto mark2_iter = + hb_zip (this+mark2Coverage, hb_range (mark2_count)) | hb_filter (c->glyph_set, hb_first) | hb_map (hb_second) ; hb_sorted_vector_t mark2_indexes; for (const unsigned row : mark2_iter) { + hb_range ((unsigned) classCount) | hb_filter (klass_mapping) | hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; }) | hb_sink (mark2_indexes) ; } (this+mark2Array).collect_variation_indices (c, mark2_indexes.iter ()); } void collect_glyphs (hb_collect_glyphs_context_t *c) const { if (unlikely (!(this+mark1Coverage).collect_coverage (c->input))) return; if (unlikely (!(this+mark2Coverage).collect_coverage (c->input))) return; } const Coverage &get_coverage () const { return this+mark1Coverage; } bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); hb_buffer_t *buffer = c->buffer; unsigned int mark1_index = (this+mark1Coverage).get_coverage (buffer->cur().codepoint); if (likely (mark1_index == NOT_COVERED)) return_trace (false); /* now we search backwards for a suitable mark glyph until a non-mark glyph */ hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input; skippy_iter.reset (buffer->idx, 1); skippy_iter.set_lookup_props (c->lookup_props & ~LookupFlag::IgnoreFlags); if (!skippy_iter.prev ()) return_trace (false); if (!_hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx])) { return_trace (false); } unsigned int j = skippy_iter.idx; unsigned int id1 = _hb_glyph_info_get_lig_id (&buffer->cur()); unsigned int id2 = _hb_glyph_info_get_lig_id (&buffer->info[j]); unsigned int comp1 = _hb_glyph_info_get_lig_comp (&buffer->cur()); unsigned int comp2 = _hb_glyph_info_get_lig_comp (&buffer->info[j]); if (likely (id1 == id2)) { if (id1 == 0) /* Marks belonging to the same base. */ goto good; else if (comp1 == comp2) /* Marks belonging to the same ligature component. */ goto good; } else { /* If ligature ids don't match, it may be the case that one of the marks * itself is a ligature. In which case match. */ if ((id1 > 0 && !comp1) || (id2 > 0 && !comp2)) goto good; } /* Didn't match. */ return_trace (false); good: unsigned int mark2_index = (this+mark2Coverage).get_coverage (buffer->info[j].codepoint); if (mark2_index == NOT_COVERED) return_trace (false); return_trace ((this+mark1Array).apply (c, mark1_index, mark2_index, this+mark2Array, classCount, j)); } bool subset (hb_subset_context_t *c) const { TRACE_SUBSET (this); const hb_set_t &glyphset = *c->plan->glyphset_gsub (); const hb_map_t &glyph_map = *c->plan->glyph_map; auto *out = c->serializer->start_embed (*this); if (unlikely (!c->serializer->extend_min (out))) return_trace (false); out->format = format; hb_map_t klass_mapping; Markclass_closure_and_remap_indexes (this+mark1Coverage, this+mark1Array, glyphset, &klass_mapping); if (!klass_mapping.get_population ()) return_trace (false); out->classCount = klass_mapping.get_population (); auto mark1_iter = + hb_zip (this+mark1Coverage, this+mark1Array) | hb_filter (glyphset, hb_first) ; hb_sorted_vector_t new_coverage; + mark1_iter | hb_map (hb_first) | hb_map (glyph_map) | hb_sink (new_coverage) ; if (!out->mark1Coverage.serialize_serialize (c->serializer, new_coverage.iter ())) return_trace (false); out->mark1Array.serialize_subset (c, mark1Array, this, (this+mark1Coverage).iter (), &klass_mapping); unsigned mark2count = (this+mark2Array).rows; auto mark2_iter = + hb_zip (this+mark2Coverage, hb_range (mark2count)) | hb_filter (glyphset, hb_first) ; new_coverage.reset (); + mark2_iter | hb_map (hb_first) | hb_map (glyph_map) | hb_sink (new_coverage) ; if (!out->mark2Coverage.serialize_serialize (c->serializer, new_coverage.iter ())) return_trace (false); hb_sorted_vector_t mark2_indexes; for (const unsigned row : + mark2_iter | hb_map (hb_second)) { + hb_range ((unsigned) classCount) | hb_filter (klass_mapping) | hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; }) | hb_sink (mark2_indexes) ; } out->mark2Array.serialize_subset (c, mark2Array, this, mark2_iter.len (), mark2_indexes.iter ()); return_trace (true); } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && mark1Coverage.sanitize (c, this) && mark2Coverage.sanitize (c, this) && mark1Array.sanitize (c, this) && mark2Array.sanitize (c, this, (unsigned int) classCount)); } protected: HBUINT16 format; /* Format identifier--format = 1 */ Offset16To mark1Coverage; /* Offset to Combining Mark1 Coverage * table--from beginning of MarkMarkPos * subtable */ Offset16To mark2Coverage; /* Offset to Combining Mark2 Coverage * table--from beginning of MarkMarkPos * subtable */ HBUINT16 classCount; /* Number of defined mark classes */ Offset16To mark1Array; /* Offset to Mark1Array table--from * beginning of MarkMarkPos subtable */ Offset16To mark2Array; /* Offset to Mark2Array table--from * beginning of MarkMarkPos subtable */ public: DEFINE_SIZE_STATIC (12); }; struct MarkMarkPos { template typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const { TRACE_DISPATCH (this, u.format); if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ()); switch (u.format) { case 1: return_trace (c->dispatch (u.format1, std::forward (ds)...)); default:return_trace (c->default_return_value ()); } } protected: union { HBUINT16 format; /* Format identifier */ MarkMarkPosFormat1 format1; } u; }; struct ContextPos : Context {}; struct ChainContextPos : ChainContext {}; struct ExtensionPos : Extension { typedef struct PosLookupSubTable SubTable; }; /* * PosLookup */ struct PosLookupSubTable { friend struct Lookup; friend struct PosLookup; enum Type { Single = 1, Pair = 2, Cursive = 3, MarkBase = 4, MarkLig = 5, MarkMark = 6, Context = 7, ChainContext = 8, Extension = 9 }; template typename context_t::return_t dispatch (context_t *c, unsigned int lookup_type, Ts&&... ds) const { TRACE_DISPATCH (this, lookup_type); switch (lookup_type) { case Single: return_trace (u.single.dispatch (c, std::forward (ds)...)); case Pair: return_trace (u.pair.dispatch (c, std::forward (ds)...)); case Cursive: return_trace (u.cursive.dispatch (c, std::forward (ds)...)); case MarkBase: return_trace (u.markBase.dispatch (c, std::forward (ds)...)); case MarkLig: return_trace (u.markLig.dispatch (c, std::forward (ds)...)); case MarkMark: return_trace (u.markMark.dispatch (c, std::forward (ds)...)); case Context: return_trace (u.context.dispatch (c, std::forward (ds)...)); case ChainContext: return_trace (u.chainContext.dispatch (c, std::forward (ds)...)); case Extension: return_trace (u.extension.dispatch (c, std::forward (ds)...)); default: return_trace (c->default_return_value ()); } } bool intersects (const hb_set_t *glyphs, unsigned int lookup_type) const { hb_intersects_context_t c (glyphs); return dispatch (&c, lookup_type); } protected: union { SinglePos single; PairPos pair; CursivePos cursive; MarkBasePos markBase; MarkLigPos markLig; MarkMarkPos markMark; ContextPos context; ChainContextPos chainContext; ExtensionPos extension; } u; public: DEFINE_SIZE_MIN (0); }; struct PosLookup : Lookup { typedef struct PosLookupSubTable SubTable; const SubTable& get_subtable (unsigned int i) const { return Lookup::get_subtable (i); } bool is_reverse () const { return false; } bool apply (hb_ot_apply_context_t *c) const { TRACE_APPLY (this); return_trace (dispatch (c)); } bool intersects (const hb_set_t *glyphs) const { hb_intersects_context_t c (glyphs); return dispatch (&c); } hb_collect_glyphs_context_t::return_t collect_glyphs (hb_collect_glyphs_context_t *c) const { return dispatch (c); } hb_closure_lookups_context_t::return_t closure_lookups (hb_closure_lookups_context_t *c, unsigned this_index) const { if (c->is_lookup_visited (this_index)) return hb_closure_lookups_context_t::default_return_value (); c->set_lookup_visited (this_index); if (!intersects (c->glyphs)) { c->set_lookup_inactive (this_index); return hb_closure_lookups_context_t::default_return_value (); } c->set_recurse_func (dispatch_closure_lookups_recurse_func); hb_closure_lookups_context_t::return_t ret = dispatch (c); return ret; } template void collect_coverage (set_t *glyphs) const { hb_collect_coverage_context_t c (glyphs); dispatch (&c); } static inline bool apply_recurse_func (hb_ot_apply_context_t *c, unsigned int lookup_index); template static typename context_t::return_t dispatch_recurse_func (context_t *c, unsigned int lookup_index); HB_INTERNAL static hb_closure_lookups_context_t::return_t dispatch_closure_lookups_recurse_func (hb_closure_lookups_context_t *c, unsigned this_index); template typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const { return Lookup::dispatch (c, std::forward (ds)...); } bool subset (hb_subset_context_t *c) const { return Lookup::subset (c); } bool sanitize (hb_sanitize_context_t *c) const { return Lookup::sanitize (c); } }; /* * GPOS -- Glyph Positioning * https://docs.microsoft.com/en-us/typography/opentype/spec/gpos */ struct GPOS : GSUBGPOS { static constexpr hb_tag_t tableTag = HB_OT_TAG_GPOS; const PosLookup& get_lookup (unsigned int i) const { return static_cast (GSUBGPOS::get_lookup (i)); } static inline void position_start (hb_font_t *font, hb_buffer_t *buffer); static inline void position_finish_advances (hb_font_t *font, hb_buffer_t *buffer); static inline void position_finish_offsets (hb_font_t *font, hb_buffer_t *buffer); bool subset (hb_subset_context_t *c) const { hb_subset_layout_context_t l (c, tableTag, c->plan->gpos_lookups, c->plan->gpos_langsys, c->plan->gpos_features); return GSUBGPOS::subset (&l); } bool sanitize (hb_sanitize_context_t *c) const { return GSUBGPOS::sanitize (c); } HB_INTERNAL bool is_blocklisted (hb_blob_t *blob, hb_face_t *face) const; void collect_variation_indices (hb_collect_variation_indices_context_t *c) const { for (unsigned i = 0; i < GSUBGPOS::get_lookup_count (); i++) { if (!c->gpos_lookups->has (i)) continue; const PosLookup &l = get_lookup (i); l.dispatch (c); } } void closure_lookups (hb_face_t *face, const hb_set_t *glyphs, hb_set_t *lookup_indexes /* IN/OUT */) const { GSUBGPOS::closure_lookups (face, glyphs, lookup_indexes); } typedef GSUBGPOS::accelerator_t accelerator_t; }; static void reverse_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction, unsigned int new_parent) { int chain = pos[i].attach_chain(), type = pos[i].attach_type(); if (likely (!chain || 0 == (type & ATTACH_TYPE_CURSIVE))) return; pos[i].attach_chain() = 0; unsigned int j = (int) i + chain; /* Stop if we see new parent in the chain. */ if (j == new_parent) return; reverse_cursive_minor_offset (pos, j, direction, new_parent); if (HB_DIRECTION_IS_HORIZONTAL (direction)) pos[j].y_offset = -pos[i].y_offset; else pos[j].x_offset = -pos[i].x_offset; pos[j].attach_chain() = -chain; pos[j].attach_type() = type; } static void propagate_attachment_offsets (hb_glyph_position_t *pos, unsigned int len, unsigned int i, hb_direction_t direction) { /* Adjusts offsets of attached glyphs (both cursive and mark) to accumulate * offset of glyph they are attached to. */ int chain = pos[i].attach_chain(), type = pos[i].attach_type(); if (likely (!chain)) return; pos[i].attach_chain() = 0; unsigned int j = (int) i + chain; if (unlikely (j >= len)) return; propagate_attachment_offsets (pos, len, j, direction); assert (!!(type & ATTACH_TYPE_MARK) ^ !!(type & ATTACH_TYPE_CURSIVE)); if (type & ATTACH_TYPE_CURSIVE) { if (HB_DIRECTION_IS_HORIZONTAL (direction)) pos[i].y_offset += pos[j].y_offset; else pos[i].x_offset += pos[j].x_offset; } else /*if (type & ATTACH_TYPE_MARK)*/ { pos[i].x_offset += pos[j].x_offset; pos[i].y_offset += pos[j].y_offset; assert (j < i); if (HB_DIRECTION_IS_FORWARD (direction)) for (unsigned int k = j; k < i; k++) { pos[i].x_offset -= pos[k].x_advance; pos[i].y_offset -= pos[k].y_advance; } else for (unsigned int k = j + 1; k < i + 1; k++) { pos[i].x_offset += pos[k].x_advance; pos[i].y_offset += pos[k].y_advance; } } } void GPOS::position_start (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer) { unsigned int count = buffer->len; for (unsigned int i = 0; i < count; i++) buffer->pos[i].attach_chain() = buffer->pos[i].attach_type() = 0; } void GPOS::position_finish_advances (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer HB_UNUSED) { //_hb_buffer_assert_gsubgpos_vars (buffer); } void GPOS::position_finish_offsets (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer) { _hb_buffer_assert_gsubgpos_vars (buffer); unsigned int len; hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, &len); hb_direction_t direction = buffer->props.direction; /* Handle attachments */ if (buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT) for (unsigned int i = 0; i < len; i++) propagate_attachment_offsets (pos, len, i, direction); } struct GPOS_accelerator_t : GPOS::accelerator_t {}; /* Out-of-class implementation for methods recursing */ #ifndef HB_NO_OT_LAYOUT template /*static*/ typename context_t::return_t PosLookup::dispatch_recurse_func (context_t *c, unsigned int lookup_index) { const PosLookup &l = c->face->table.GPOS.get_relaxed ()->table->get_lookup (lookup_index); return l.dispatch (c); } /*static*/ inline hb_closure_lookups_context_t::return_t PosLookup::dispatch_closure_lookups_recurse_func (hb_closure_lookups_context_t *c, unsigned this_index) { const PosLookup &l = c->face->table.GPOS.get_relaxed ()->table->get_lookup (this_index); return l.closure_lookups (c, this_index); } /*static*/ bool PosLookup::apply_recurse_func (hb_ot_apply_context_t *c, unsigned int lookup_index) { const PosLookup &l = c->face->table.GPOS.get_relaxed ()->table->get_lookup (lookup_index); unsigned int saved_lookup_props = c->lookup_props; unsigned int saved_lookup_index = c->lookup_index; c->set_lookup_index (lookup_index); c->set_lookup_props (l.get_props ()); bool ret = l.dispatch (c); c->set_lookup_index (saved_lookup_index); c->set_lookup_props (saved_lookup_props); return ret; } #endif } /* namespace OT */ #endif /* HB_OT_LAYOUT_GPOS_TABLE_HH */