1 | /* |
2 | * Copyright © 2009,2010 Red Hat, Inc. |
3 | * Copyright © 2010,2011,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 | #include "hb-ot-map-private.hh" |
30 | |
31 | #include "hb-ot-layout-private.hh" |
32 | |
33 | |
34 | void hb_ot_map_t::collect_lookups (unsigned int table_index, hb_set_t *lookups_out) const |
35 | { |
36 | for (unsigned int i = 0; i < lookups[table_index].len; i++) |
37 | hb_set_add (set: lookups_out, codepoint: lookups[table_index][i].index); |
38 | } |
39 | |
40 | |
41 | hb_ot_map_builder_t::hb_ot_map_builder_t (hb_face_t *face_, |
42 | const hb_segment_properties_t *props_) |
43 | { |
44 | memset (s: this, c: 0, n: sizeof (*this)); |
45 | |
46 | face = face_; |
47 | props = *props_; |
48 | |
49 | |
50 | /* Fetch script/language indices for GSUB/GPOS. We need these later to skip |
51 | * features not available in either table and not waste precious bits for them. */ |
52 | |
53 | hb_tag_t script_tags[3] = {HB_TAG_NONE, HB_TAG_NONE, HB_TAG_NONE}; |
54 | hb_tag_t language_tag; |
55 | |
56 | hb_ot_tags_from_script (script: props.script, script_tag_1: &script_tags[0], script_tag_2: &script_tags[1]); |
57 | language_tag = hb_ot_tag_from_language (language: props.language); |
58 | |
59 | for (unsigned int table_index = 0; table_index < 2; table_index++) { |
60 | hb_tag_t table_tag = table_tags[table_index]; |
61 | found_script[table_index] = (bool) hb_ot_layout_table_choose_script (face, table_tag, script_tags, script_index: &script_index[table_index], chosen_script: &chosen_script[table_index]); |
62 | hb_ot_layout_script_find_language (face, table_tag, script_index: script_index[table_index], language_tag, language_index: &language_index[table_index]); |
63 | } |
64 | } |
65 | |
66 | void hb_ot_map_builder_t::add_feature (hb_tag_t tag, unsigned int value, |
67 | hb_ot_map_feature_flags_t flags) |
68 | { |
69 | feature_info_t *info = feature_infos.push(); |
70 | if (unlikely (!info)) return; |
71 | if (unlikely (!tag)) return; |
72 | info->tag = tag; |
73 | info->seq = feature_infos.len; |
74 | info->max_value = value; |
75 | info->flags = flags; |
76 | info->default_value = (flags & F_GLOBAL) ? value : 0; |
77 | info->stage[0] = current_stage[0]; |
78 | info->stage[1] = current_stage[1]; |
79 | } |
80 | |
81 | void |
82 | hb_ot_map_builder_t::add_lookups (hb_ot_map_t &m, |
83 | hb_face_t *face, |
84 | unsigned int table_index, |
85 | unsigned int feature_index, |
86 | unsigned int variations_index, |
87 | hb_mask_t mask, |
88 | bool auto_zwnj, |
89 | bool auto_zwj) |
90 | { |
91 | unsigned int lookup_indices[32]; |
92 | unsigned int offset, len; |
93 | unsigned int table_lookup_count; |
94 | |
95 | table_lookup_count = hb_ot_layout_table_get_lookup_count (face, table_tag: table_tags[table_index]); |
96 | |
97 | offset = 0; |
98 | do { |
99 | len = ARRAY_LENGTH (lookup_indices); |
100 | hb_ot_layout_feature_with_variations_get_lookups (face, |
101 | table_tag: table_tags[table_index], |
102 | feature_index, |
103 | variations_index, |
104 | start_offset: offset, lookup_count: &len, |
105 | lookup_indexes: lookup_indices); |
106 | |
107 | for (unsigned int i = 0; i < len; i++) |
108 | { |
109 | if (lookup_indices[i] >= table_lookup_count) |
110 | continue; |
111 | hb_ot_map_t::lookup_map_t *lookup = m.lookups[table_index].push (); |
112 | if (unlikely (!lookup)) |
113 | return; |
114 | lookup->mask = mask; |
115 | lookup->index = lookup_indices[i]; |
116 | lookup->auto_zwnj = auto_zwnj; |
117 | lookup->auto_zwj = auto_zwj; |
118 | } |
119 | |
120 | offset += len; |
121 | } while (len == ARRAY_LENGTH (lookup_indices)); |
122 | } |
123 | |
124 | |
125 | void hb_ot_map_builder_t::add_pause (unsigned int table_index, hb_ot_map_t::pause_func_t pause_func) |
126 | { |
127 | stage_info_t *s = stages[table_index].push (); |
128 | if (likely (s)) { |
129 | s->index = current_stage[table_index]; |
130 | s->pause_func = pause_func; |
131 | } |
132 | |
133 | current_stage[table_index]++; |
134 | } |
135 | |
136 | void |
137 | hb_ot_map_builder_t::compile (hb_ot_map_t &m, |
138 | const int *coords, |
139 | unsigned int num_coords) |
140 | { |
141 | static_assert ((!(HB_GLYPH_FLAG_DEFINED & (HB_GLYPH_FLAG_DEFINED + 1))), "" ); |
142 | unsigned int global_bit_mask = HB_GLYPH_FLAG_DEFINED + 1; |
143 | unsigned int global_bit_shift = _hb_popcount32 (mask: HB_GLYPH_FLAG_DEFINED); |
144 | |
145 | m.global_mask = global_bit_mask; |
146 | |
147 | unsigned int required_feature_index[2]; |
148 | hb_tag_t required_feature_tag[2]; |
149 | /* We default to applying required feature in stage 0. If the required |
150 | * feature has a tag that is known to the shaper, we apply required feature |
151 | * in the stage for that tag. |
152 | */ |
153 | unsigned int required_feature_stage[2] = {0, 0}; |
154 | |
155 | for (unsigned int table_index = 0; table_index < 2; table_index++) |
156 | { |
157 | m.chosen_script[table_index] = chosen_script[table_index]; |
158 | m.found_script[table_index] = found_script[table_index]; |
159 | |
160 | hb_ot_layout_language_get_required_feature (face, |
161 | table_tag: table_tags[table_index], |
162 | script_index: script_index[table_index], |
163 | language_index: language_index[table_index], |
164 | feature_index: &required_feature_index[table_index], |
165 | feature_tag: &required_feature_tag[table_index]); |
166 | } |
167 | |
168 | if (!feature_infos.len) |
169 | return; |
170 | |
171 | /* Sort features and merge duplicates */ |
172 | { |
173 | feature_infos.qsort (); |
174 | unsigned int j = 0; |
175 | for (unsigned int i = 1; i < feature_infos.len; i++) |
176 | if (feature_infos[i].tag != feature_infos[j].tag) |
177 | feature_infos[++j] = feature_infos[i]; |
178 | else { |
179 | if (feature_infos[i].flags & F_GLOBAL) { |
180 | feature_infos[j].flags |= F_GLOBAL; |
181 | feature_infos[j].max_value = feature_infos[i].max_value; |
182 | feature_infos[j].default_value = feature_infos[i].default_value; |
183 | } else { |
184 | feature_infos[j].flags &= ~F_GLOBAL; |
185 | feature_infos[j].max_value = MAX (a: feature_infos[j].max_value, b: feature_infos[i].max_value); |
186 | /* Inherit default_value from j */ |
187 | } |
188 | feature_infos[j].flags |= (feature_infos[i].flags & F_HAS_FALLBACK); |
189 | feature_infos[j].stage[0] = MIN (a: feature_infos[j].stage[0], b: feature_infos[i].stage[0]); |
190 | feature_infos[j].stage[1] = MIN (a: feature_infos[j].stage[1], b: feature_infos[i].stage[1]); |
191 | } |
192 | feature_infos.shrink (l: j + 1); |
193 | } |
194 | |
195 | |
196 | /* Allocate bits now */ |
197 | unsigned int next_bit = global_bit_shift + 1; |
198 | |
199 | for (unsigned int i = 0; i < feature_infos.len; i++) |
200 | { |
201 | const feature_info_t *info = &feature_infos[i]; |
202 | |
203 | unsigned int bits_needed; |
204 | |
205 | if ((info->flags & F_GLOBAL) && info->max_value == 1) |
206 | /* Uses the global bit */ |
207 | bits_needed = 0; |
208 | else |
209 | /* Limit to 8 bits per feature. */ |
210 | bits_needed = MIN(a: 8u, b: _hb_bit_storage (number: info->max_value)); |
211 | |
212 | if (!info->max_value || next_bit + bits_needed > 8 * sizeof (hb_mask_t)) |
213 | continue; /* Feature disabled, or not enough bits. */ |
214 | |
215 | |
216 | hb_bool_t found = false; |
217 | unsigned int feature_index[2]; |
218 | for (unsigned int table_index = 0; table_index < 2; table_index++) |
219 | { |
220 | if (required_feature_tag[table_index] == info->tag) |
221 | required_feature_stage[table_index] = info->stage[table_index]; |
222 | |
223 | found |= hb_ot_layout_language_find_feature (face, |
224 | table_tag: table_tags[table_index], |
225 | script_index: script_index[table_index], |
226 | language_index: language_index[table_index], |
227 | feature_tag: info->tag, |
228 | feature_index: &feature_index[table_index]); |
229 | } |
230 | if (!found && (info->flags & F_GLOBAL_SEARCH)) |
231 | { |
232 | for (unsigned int table_index = 0; table_index < 2; table_index++) |
233 | { |
234 | found |= hb_ot_layout_table_find_feature (face, |
235 | table_tag: table_tags[table_index], |
236 | feature_tag: info->tag, |
237 | feature_index: &feature_index[table_index]); |
238 | } |
239 | } |
240 | if (!found && !(info->flags & F_HAS_FALLBACK)) |
241 | continue; |
242 | |
243 | |
244 | hb_ot_map_t::feature_map_t *map = m.features.push (); |
245 | if (unlikely (!map)) |
246 | break; |
247 | |
248 | map->tag = info->tag; |
249 | map->index[0] = feature_index[0]; |
250 | map->index[1] = feature_index[1]; |
251 | map->stage[0] = info->stage[0]; |
252 | map->stage[1] = info->stage[1]; |
253 | map->auto_zwnj = !(info->flags & F_MANUAL_ZWNJ); |
254 | map->auto_zwj = !(info->flags & F_MANUAL_ZWJ); |
255 | if ((info->flags & F_GLOBAL) && info->max_value == 1) { |
256 | /* Uses the global bit */ |
257 | map->shift = global_bit_shift; |
258 | map->mask = global_bit_mask; |
259 | } else { |
260 | map->shift = next_bit; |
261 | map->mask = (1u << (next_bit + bits_needed)) - (1u << next_bit); |
262 | next_bit += bits_needed; |
263 | m.global_mask |= (info->default_value << map->shift) & map->mask; |
264 | } |
265 | map->_1_mask = (1u << map->shift) & map->mask; |
266 | map->needs_fallback = !found; |
267 | |
268 | } |
269 | feature_infos.shrink (l: 0); /* Done with these */ |
270 | |
271 | |
272 | add_gsub_pause (pause_func: nullptr); |
273 | add_gpos_pause (pause_func: nullptr); |
274 | |
275 | for (unsigned int table_index = 0; table_index < 2; table_index++) |
276 | { |
277 | /* Collect lookup indices for features */ |
278 | |
279 | unsigned int variations_index; |
280 | hb_ot_layout_table_find_feature_variations (face, |
281 | table_tag: table_tags[table_index], |
282 | coords, |
283 | num_coords, |
284 | variations_index: &variations_index); |
285 | |
286 | unsigned int stage_index = 0; |
287 | unsigned int last_num_lookups = 0; |
288 | for (unsigned stage = 0; stage < current_stage[table_index]; stage++) |
289 | { |
290 | if (required_feature_index[table_index] != HB_OT_LAYOUT_NO_FEATURE_INDEX && |
291 | required_feature_stage[table_index] == stage) |
292 | add_lookups (m, face, table_index, |
293 | feature_index: required_feature_index[table_index], |
294 | variations_index, |
295 | mask: global_bit_mask); |
296 | |
297 | for (unsigned i = 0; i < m.features.len; i++) |
298 | if (m.features[i].stage[table_index] == stage) |
299 | add_lookups (m, face, table_index, |
300 | feature_index: m.features[i].index[table_index], |
301 | variations_index, |
302 | mask: m.features[i].mask, |
303 | auto_zwnj: m.features[i].auto_zwnj, |
304 | auto_zwj: m.features[i].auto_zwj); |
305 | |
306 | /* Sort lookups and merge duplicates */ |
307 | if (last_num_lookups < m.lookups[table_index].len) |
308 | { |
309 | m.lookups[table_index].qsort (start: last_num_lookups, end: m.lookups[table_index].len); |
310 | |
311 | unsigned int j = last_num_lookups; |
312 | for (unsigned int i = j + 1; i < m.lookups[table_index].len; i++) |
313 | if (m.lookups[table_index][i].index != m.lookups[table_index][j].index) |
314 | m.lookups[table_index][++j] = m.lookups[table_index][i]; |
315 | else |
316 | { |
317 | m.lookups[table_index][j].mask |= m.lookups[table_index][i].mask; |
318 | m.lookups[table_index][j].auto_zwnj &= m.lookups[table_index][i].auto_zwnj; |
319 | m.lookups[table_index][j].auto_zwj &= m.lookups[table_index][i].auto_zwj; |
320 | } |
321 | m.lookups[table_index].shrink (l: j + 1); |
322 | } |
323 | |
324 | last_num_lookups = m.lookups[table_index].len; |
325 | |
326 | if (stage_index < stages[table_index].len && stages[table_index][stage_index].index == stage) { |
327 | hb_ot_map_t::stage_map_t *stage_map = m.stages[table_index].push (); |
328 | if (likely (stage_map)) { |
329 | stage_map->last_lookup = last_num_lookups; |
330 | stage_map->pause_func = stages[table_index][stage_index].pause_func; |
331 | } |
332 | |
333 | stage_index++; |
334 | } |
335 | } |
336 | } |
337 | } |
338 | |