Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/harfbuzz/src/OT/Layout/GPOS/PairPosFormat1.hh @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 #ifndef OT_LAYOUT_GPOS_PAIRPOSFORMAT1_HH
2 #define OT_LAYOUT_GPOS_PAIRPOSFORMAT1_HH
3
4 #include "PairSet.hh"
5
6 namespace OT {
7 namespace Layout {
8 namespace GPOS_impl {
9
10
11 template <typename Types>
12 struct PairPosFormat1_3
13 {
14 using PairSet = GPOS_impl::PairSet<Types>;
15 using PairValueRecord = GPOS_impl::PairValueRecord<Types>;
16
17 protected:
18 HBUINT16 format; /* Format identifier--format = 1 */
19 typename Types::template OffsetTo<Coverage>
20 coverage; /* Offset to Coverage table--from
21 * beginning of subtable */
22 ValueFormat valueFormat[2]; /* [0] Defines the types of data in
23 * ValueRecord1--for the first glyph
24 * in the pair--may be zero (0) */
25 /* [1] Defines the types of data in
26 * ValueRecord2--for the second glyph
27 * in the pair--may be zero (0) */
28 Array16Of<typename Types::template OffsetTo<PairSet>>
29 pairSet; /* Array of PairSet tables
30 * ordered by Coverage Index */
31 public:
32 DEFINE_SIZE_ARRAY (8 + Types::size, pairSet);
33
34 bool sanitize (hb_sanitize_context_t *c) const
35 {
36 TRACE_SANITIZE (this);
37
38 if (!c->check_struct (this)) return_trace (false);
39
40 unsigned int len1 = valueFormat[0].get_len ();
41 unsigned int len2 = valueFormat[1].get_len ();
42 typename PairSet::sanitize_closure_t closure =
43 {
44 valueFormat,
45 len1,
46 1 + len1 + len2
47 };
48
49 return_trace (coverage.sanitize (c, this) && pairSet.sanitize (c, this, &closure));
50 }
51
52 bool intersects (const hb_set_t *glyphs) const
53 {
54 auto &cov = this+coverage;
55
56 if (pairSet.len > glyphs->get_population () * hb_bit_storage ((unsigned) pairSet.len) / 4)
57 {
58 for (hb_codepoint_t g = HB_SET_VALUE_INVALID; glyphs->next (&g);)
59 {
60 unsigned i = cov.get_coverage (g);
61 if ((this+pairSet[i]).intersects (glyphs, valueFormat))
62 return true;
63 }
64 return false;
65 }
66
67 return
68 + hb_zip (cov, pairSet)
69 | hb_filter (*glyphs, hb_first)
70 | hb_map (hb_second)
71 | hb_map ([glyphs, this] (const typename Types::template OffsetTo<PairSet> &_)
72 { return (this+_).intersects (glyphs, valueFormat); })
73 | hb_any
74 ;
75 }
76
77 void closure_lookups (hb_closure_lookups_context_t *c) const {}
78 void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
79 {
80 if ((!valueFormat[0].has_device ()) && (!valueFormat[1].has_device ())) return;
81
82 auto it =
83 + hb_zip (this+coverage, pairSet)
84 | hb_filter (c->glyph_set, hb_first)
85 | hb_map (hb_second)
86 ;
87
88 if (!it) return;
89 + it
90 | hb_map (hb_add (this))
91 | hb_apply ([&] (const PairSet& _) { _.collect_variation_indices (c, valueFormat); })
92 ;
93 }
94
95 void collect_glyphs (hb_collect_glyphs_context_t *c) const
96 {
97 if (unlikely (!(this+coverage).collect_coverage (c->input))) return;
98 unsigned int count = pairSet.len;
99 for (unsigned int i = 0; i < count; i++)
100 (this+pairSet[i]).collect_glyphs (c, valueFormat);
101 }
102
103 const Coverage &get_coverage () const { return this+coverage; }
104
105 bool apply (hb_ot_apply_context_t *c) const
106 {
107 TRACE_APPLY (this);
108 hb_buffer_t *buffer = c->buffer;
109 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
110 if (likely (index == NOT_COVERED)) return_trace (false);
111
112 hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
113 skippy_iter.reset (buffer->idx, 1);
114 unsigned unsafe_to;
115 if (!skippy_iter.next (&unsafe_to))
116 {
117 buffer->unsafe_to_concat (buffer->idx, unsafe_to);
118 return_trace (false);
119 }
120
121 return_trace ((this+pairSet[index]).apply (c, valueFormat, skippy_iter.idx));
122 }
123
124 bool subset (hb_subset_context_t *c) const
125 {
126 TRACE_SUBSET (this);
127
128 const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
129 const hb_map_t &glyph_map = *c->plan->glyph_map;
130
131 auto *out = c->serializer->start_embed (*this);
132 if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
133 out->format = format;
134 out->valueFormat[0] = valueFormat[0];
135 out->valueFormat[1] = valueFormat[1];
136 if (c->plan->flags & HB_SUBSET_FLAGS_NO_HINTING)
137 {
138 hb_pair_t<unsigned, unsigned> newFormats = compute_effective_value_formats (glyphset);
139 out->valueFormat[0] = newFormats.first;
140 out->valueFormat[1] = newFormats.second;
141 }
142
143 if (c->plan->all_axes_pinned)
144 {
145 out->valueFormat[0] = out->valueFormat[0].drop_device_table_flags ();
146 out->valueFormat[1] = out->valueFormat[1].drop_device_table_flags ();
147 }
148
149 hb_sorted_vector_t<hb_codepoint_t> new_coverage;
150
151 + hb_zip (this+coverage, pairSet)
152 | hb_filter (glyphset, hb_first)
153 | hb_filter ([this, c, out] (const typename Types::template OffsetTo<PairSet>& _)
154 {
155 auto snap = c->serializer->snapshot ();
156 auto *o = out->pairSet.serialize_append (c->serializer);
157 if (unlikely (!o)) return false;
158 bool ret = o->serialize_subset (c, _, this, valueFormat, out->valueFormat);
159 if (!ret)
160 {
161 out->pairSet.pop ();
162 c->serializer->revert (snap);
163 }
164 return ret;
165 },
166 hb_second)
167 | hb_map (hb_first)
168 | hb_map (glyph_map)
169 | hb_sink (new_coverage)
170 ;
171
172 out->coverage.serialize_serialize (c->serializer, new_coverage.iter ());
173
174 return_trace (bool (new_coverage));
175 }
176
177
178 hb_pair_t<unsigned, unsigned> compute_effective_value_formats (const hb_set_t& glyphset) const
179 {
180 unsigned len1 = valueFormat[0].get_len ();
181 unsigned len2 = valueFormat[1].get_len ();
182 unsigned record_size = HBUINT16::static_size + Value::static_size * (len1 + len2);
183
184 unsigned format1 = 0;
185 unsigned format2 = 0;
186 for (const auto & _ :
187 + hb_zip (this+coverage, pairSet)
188 | hb_filter (glyphset, hb_first)
189 | hb_map (hb_second)
190 )
191 {
192 const PairSet& set = (this + _);
193 const PairValueRecord *record = &set.firstPairValueRecord;
194
195 unsigned count = set.len;
196 for (unsigned i = 0; i < count; i++)
197 {
198 if (record->intersects (glyphset))
199 {
200 format1 = format1 | valueFormat[0].get_effective_format (record->get_values_1 ());
201 format2 = format2 | valueFormat[1].get_effective_format (record->get_values_2 (valueFormat[0]));
202 }
203 record = &StructAtOffset<const PairValueRecord> (record, record_size);
204 }
205
206 if (format1 == valueFormat[0] && format2 == valueFormat[1])
207 break;
208 }
209
210 return hb_pair (format1, format2);
211 }
212 };
213
214
215 }
216 }
217 }
218
219 #endif // OT_LAYOUT_GPOS_PAIRPOSFORMAT1_HH