The Tor Browser / file comparison
comparison: gfx/harfbuzz/src/hb-ot-map.cc
gfx/harfbuzz/src/hb-ot-map.cc
- branch
- TOR_BUG_9701
- changeset 14
- 925c144e1f1f
equal
deleted
inserted
replaced
| -1:000000000000 | 0:8de6ba8b86ef |
|---|---|
| 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 | |
| 35 hb_ot_map_t::add_lookups (hb_face_t *face, | |
| 36 unsigned int table_index, | |
| 37 unsigned int feature_index, | |
| 38 hb_mask_t mask, | |
| 39 bool auto_zwj) | |
| 40 { | |
| 41 unsigned int lookup_indices[32]; | |
| 42 unsigned int offset, len; | |
| 43 unsigned int table_lookup_count; | |
| 44 | |
| 45 table_lookup_count = hb_ot_layout_table_get_lookup_count (face, table_tags[table_index]); | |
| 46 | |
| 47 offset = 0; | |
| 48 do { | |
| 49 len = ARRAY_LENGTH (lookup_indices); | |
| 50 hb_ot_layout_feature_get_lookups (face, | |
| 51 table_tags[table_index], | |
| 52 feature_index, | |
| 53 offset, &len, | |
| 54 lookup_indices); | |
| 55 | |
| 56 for (unsigned int i = 0; i < len; i++) | |
| 57 { | |
| 58 if (lookup_indices[i] >= table_lookup_count) | |
| 59 continue; | |
| 60 hb_ot_map_t::lookup_map_t *lookup = lookups[table_index].push (); | |
| 61 if (unlikely (!lookup)) | |
| 62 return; | |
| 63 lookup->mask = mask; | |
| 64 lookup->index = lookup_indices[i]; | |
| 65 lookup->auto_zwj = auto_zwj; | |
| 66 } | |
| 67 | |
| 68 offset += len; | |
| 69 } while (len == ARRAY_LENGTH (lookup_indices)); | |
| 70 } | |
| 71 | |
| 72 hb_ot_map_builder_t::hb_ot_map_builder_t (hb_face_t *face_, | |
| 73 const hb_segment_properties_t *props_) | |
| 74 { | |
| 75 memset (this, 0, sizeof (*this)); | |
| 76 | |
| 77 face = face_; | |
| 78 props = *props_; | |
| 79 | |
| 80 | |
| 81 /* Fetch script/language indices for GSUB/GPOS. We need these later to skip | |
| 82 * features not available in either table and not waste precious bits for them. */ | |
| 83 | |
| 84 hb_tag_t script_tags[3] = {HB_TAG_NONE, HB_TAG_NONE, HB_TAG_NONE}; | |
| 85 hb_tag_t language_tag; | |
| 86 | |
| 87 hb_ot_tags_from_script (props.script, &script_tags[0], &script_tags[1]); | |
| 88 language_tag = hb_ot_tag_from_language (props.language); | |
| 89 | |
| 90 for (unsigned int table_index = 0; table_index < 2; table_index++) { | |
| 91 hb_tag_t table_tag = table_tags[table_index]; | |
| 92 found_script[table_index] = hb_ot_layout_table_choose_script (face, table_tag, script_tags, &script_index[table_index], &chosen_script[table_index]); | |
| 93 hb_ot_layout_script_find_language (face, table_tag, script_index[table_index], language_tag, &language_index[table_index]); | |
| 94 } | |
| 95 } | |
| 96 | |
| 97 void hb_ot_map_builder_t::add_feature (hb_tag_t tag, unsigned int value, | |
| 98 hb_ot_map_feature_flags_t flags) | |
| 99 { | |
| 100 feature_info_t *info = feature_infos.push(); | |
| 101 if (unlikely (!info)) return; | |
| 102 info->tag = tag; | |
| 103 info->seq = feature_infos.len; | |
| 104 info->max_value = value; | |
| 105 info->flags = flags; | |
| 106 info->default_value = (flags & F_GLOBAL) ? value : 0; | |
| 107 info->stage[0] = current_stage[0]; | |
| 108 info->stage[1] = current_stage[1]; | |
| 109 } | |
| 110 | |
| 111 | |
| 112 void hb_ot_map_t::collect_lookups (unsigned int table_index, hb_set_t *lookups_out) const | |
| 113 { | |
| 114 for (unsigned int i = 0; i < lookups[table_index].len; i++) | |
| 115 hb_set_add (lookups_out, lookups[table_index][i].index); | |
| 116 } | |
| 117 | |
| 118 void hb_ot_map_builder_t::add_pause (unsigned int table_index, hb_ot_map_t::pause_func_t pause_func) | |
| 119 { | |
| 120 stage_info_t *s = stages[table_index].push (); | |
| 121 if (likely (s)) { | |
| 122 s->index = current_stage[table_index]; | |
| 123 s->pause_func = pause_func; | |
| 124 } | |
| 125 | |
| 126 current_stage[table_index]++; | |
| 127 } | |
| 128 | |
| 129 void | |
| 130 hb_ot_map_builder_t::compile (hb_ot_map_t &m) | |
| 131 { | |
| 132 m.global_mask = 1; | |
| 133 | |
| 134 for (unsigned int table_index = 0; table_index < 2; table_index++) { | |
| 135 m.chosen_script[table_index] = chosen_script[table_index]; | |
| 136 m.found_script[table_index] = found_script[table_index]; | |
| 137 } | |
| 138 | |
| 139 if (!feature_infos.len) | |
| 140 return; | |
| 141 | |
| 142 /* Sort features and merge duplicates */ | |
| 143 { | |
| 144 feature_infos.sort (); | |
| 145 unsigned int j = 0; | |
| 146 for (unsigned int i = 1; i < feature_infos.len; i++) | |
| 147 if (feature_infos[i].tag != feature_infos[j].tag) | |
| 148 feature_infos[++j] = feature_infos[i]; | |
| 149 else { | |
| 150 if (feature_infos[i].flags & F_GLOBAL) { | |
| 151 feature_infos[j].flags |= F_GLOBAL; | |
| 152 feature_infos[j].max_value = feature_infos[i].max_value; | |
| 153 feature_infos[j].default_value = feature_infos[i].default_value; | |
| 154 } else { | |
| 155 feature_infos[j].flags &= ~F_GLOBAL; | |
| 156 feature_infos[j].max_value = MAX (feature_infos[j].max_value, feature_infos[i].max_value); | |
| 157 /* Inherit default_value from j */ | |
| 158 } | |
| 159 feature_infos[j].flags |= (feature_infos[i].flags & F_HAS_FALLBACK); | |
| 160 feature_infos[j].stage[0] = MIN (feature_infos[j].stage[0], feature_infos[i].stage[0]); | |
| 161 feature_infos[j].stage[1] = MIN (feature_infos[j].stage[1], feature_infos[i].stage[1]); | |
| 162 } | |
| 163 feature_infos.shrink (j + 1); | |
| 164 } | |
| 165 | |
| 166 | |
| 167 /* Allocate bits now */ | |
| 168 unsigned int next_bit = 1; | |
| 169 for (unsigned int i = 0; i < feature_infos.len; i++) { | |
| 170 const feature_info_t *info = &feature_infos[i]; | |
| 171 | |
| 172 unsigned int bits_needed; | |
| 173 | |
| 174 if ((info->flags & F_GLOBAL) && info->max_value == 1) | |
| 175 /* Uses the global bit */ | |
| 176 bits_needed = 0; | |
| 177 else | |
| 178 bits_needed = _hb_bit_storage (info->max_value); | |
| 179 | |
| 180 if (!info->max_value || next_bit + bits_needed > 8 * sizeof (hb_mask_t)) | |
| 181 continue; /* Feature disabled, or not enough bits. */ | |
| 182 | |
| 183 | |
| 184 hb_bool_t found = false; | |
| 185 unsigned int feature_index[2]; | |
| 186 for (unsigned int table_index = 0; table_index < 2; table_index++) | |
| 187 found |= hb_ot_layout_language_find_feature (face, | |
| 188 table_tags[table_index], | |
| 189 script_index[table_index], | |
| 190 language_index[table_index], | |
| 191 info->tag, | |
| 192 &feature_index[table_index]); | |
| 193 if (!found && !(info->flags & F_HAS_FALLBACK)) | |
| 194 continue; | |
| 195 | |
| 196 | |
| 197 hb_ot_map_t::feature_map_t *map = m.features.push (); | |
| 198 if (unlikely (!map)) | |
| 199 break; | |
| 200 | |
| 201 map->tag = info->tag; | |
| 202 map->index[0] = feature_index[0]; | |
| 203 map->index[1] = feature_index[1]; | |
| 204 map->stage[0] = info->stage[0]; | |
| 205 map->stage[1] = info->stage[1]; | |
| 206 map->auto_zwj = !(info->flags & F_MANUAL_ZWJ); | |
| 207 if ((info->flags & F_GLOBAL) && info->max_value == 1) { | |
| 208 /* Uses the global bit */ | |
| 209 map->shift = 0; | |
| 210 map->mask = 1; | |
| 211 } else { | |
| 212 map->shift = next_bit; | |
| 213 map->mask = (1 << (next_bit + bits_needed)) - (1 << next_bit); | |
| 214 next_bit += bits_needed; | |
| 215 m.global_mask |= (info->default_value << map->shift) & map->mask; | |
| 216 } | |
| 217 map->_1_mask = (1 << map->shift) & map->mask; | |
| 218 map->needs_fallback = !found; | |
| 219 | |
| 220 } | |
| 221 feature_infos.shrink (0); /* Done with these */ | |
| 222 | |
| 223 | |
| 224 add_gsub_pause (NULL); | |
| 225 add_gpos_pause (NULL); | |
| 226 | |
| 227 for (unsigned int table_index = 0; table_index < 2; table_index++) { | |
| 228 hb_tag_t table_tag = table_tags[table_index]; | |
| 229 | |
| 230 /* Collect lookup indices for features */ | |
| 231 | |
| 232 unsigned int required_feature_index; | |
| 233 if (hb_ot_layout_language_get_required_feature_index (face, | |
| 234 table_tag, | |
| 235 script_index[table_index], | |
| 236 language_index[table_index], | |
| 237 &required_feature_index)) | |
| 238 m.add_lookups (face, table_index, required_feature_index, 1, true); | |
| 239 | |
| 240 unsigned int stage_index = 0; | |
| 241 unsigned int last_num_lookups = 0; | |
| 242 for (unsigned stage = 0; stage < current_stage[table_index]; stage++) | |
| 243 { | |
| 244 for (unsigned i = 0; i < m.features.len; i++) | |
| 245 if (m.features[i].stage[table_index] == stage) | |
| 246 m.add_lookups (face, table_index, | |
| 247 m.features[i].index[table_index], | |
| 248 m.features[i].mask, | |
| 249 m.features[i].auto_zwj); | |
| 250 | |
| 251 /* Sort lookups and merge duplicates */ | |
| 252 if (last_num_lookups < m.lookups[table_index].len) | |
| 253 { | |
| 254 m.lookups[table_index].sort (last_num_lookups, m.lookups[table_index].len); | |
| 255 | |
| 256 unsigned int j = last_num_lookups; | |
| 257 for (unsigned int i = j + 1; i < m.lookups[table_index].len; i++) | |
| 258 if (m.lookups[table_index][i].index != m.lookups[table_index][j].index) | |
| 259 m.lookups[table_index][++j] = m.lookups[table_index][i]; | |
| 260 else | |
| 261 { | |
| 262 m.lookups[table_index][j].mask |= m.lookups[table_index][i].mask; | |
| 263 m.lookups[table_index][j].auto_zwj &= m.lookups[table_index][i].auto_zwj; | |
| 264 } | |
| 265 m.lookups[table_index].shrink (j + 1); | |
| 266 } | |
| 267 | |
| 268 last_num_lookups = m.lookups[table_index].len; | |
| 269 | |
| 270 if (stage_index < stages[table_index].len && stages[table_index][stage_index].index == stage) { | |
| 271 hb_ot_map_t::stage_map_t *stage_map = m.stages[table_index].push (); | |
| 272 if (likely (stage_map)) { | |
| 273 stage_map->last_lookup = last_num_lookups; | |
| 274 stage_map->pause_func = stages[table_index][stage_index].pause_func; | |
| 275 } | |
| 276 | |
| 277 stage_index++; | |
| 278 } | |
| 279 } | |
| 280 } | |
| 281 } |
