Mercurial > hgrepos > Python2 > PyMuPDF
comparison mupdf-source/thirdparty/harfbuzz/src/OT/glyf/SimpleGlyph.hh @ 2:b50eed0cc0ef upstream
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_GLYF_SIMPLEGLYPH_HH | |
| 2 #define OT_GLYF_SIMPLEGLYPH_HH | |
| 3 | |
| 4 | |
| 5 #include "../../hb-open-type.hh" | |
| 6 | |
| 7 | |
| 8 namespace OT { | |
| 9 namespace glyf_impl { | |
| 10 | |
| 11 | |
| 12 struct SimpleGlyph | |
| 13 { | |
| 14 enum simple_glyph_flag_t | |
| 15 { | |
| 16 FLAG_ON_CURVE = 0x01, | |
| 17 FLAG_X_SHORT = 0x02, | |
| 18 FLAG_Y_SHORT = 0x04, | |
| 19 FLAG_REPEAT = 0x08, | |
| 20 FLAG_X_SAME = 0x10, | |
| 21 FLAG_Y_SAME = 0x20, | |
| 22 FLAG_OVERLAP_SIMPLE = 0x40, | |
| 23 FLAG_RESERVED2 = 0x80 | |
| 24 }; | |
| 25 | |
| 26 const GlyphHeader &header; | |
| 27 hb_bytes_t bytes; | |
| 28 SimpleGlyph (const GlyphHeader &header_, hb_bytes_t bytes_) : | |
| 29 header (header_), bytes (bytes_) {} | |
| 30 | |
| 31 unsigned int instruction_len_offset () const | |
| 32 { return GlyphHeader::static_size + 2 * header.numberOfContours; } | |
| 33 | |
| 34 unsigned int length (unsigned int instruction_len) const | |
| 35 { return instruction_len_offset () + 2 + instruction_len; } | |
| 36 | |
| 37 unsigned int instructions_length () const | |
| 38 { | |
| 39 unsigned int instruction_length_offset = instruction_len_offset (); | |
| 40 if (unlikely (instruction_length_offset + 2 > bytes.length)) return 0; | |
| 41 | |
| 42 const HBUINT16 &instructionLength = StructAtOffset<HBUINT16> (&bytes, instruction_length_offset); | |
| 43 /* Out of bounds of the current glyph */ | |
| 44 if (unlikely (length (instructionLength) > bytes.length)) return 0; | |
| 45 return instructionLength; | |
| 46 } | |
| 47 | |
| 48 const hb_bytes_t trim_padding () const | |
| 49 { | |
| 50 /* based on FontTools _g_l_y_f.py::trim */ | |
| 51 const uint8_t *glyph = (uint8_t*) bytes.arrayZ; | |
| 52 const uint8_t *glyph_end = glyph + bytes.length; | |
| 53 /* simple glyph w/contours, possibly trimmable */ | |
| 54 glyph += instruction_len_offset (); | |
| 55 | |
| 56 if (unlikely (glyph + 2 >= glyph_end)) return hb_bytes_t (); | |
| 57 unsigned int num_coordinates = StructAtOffset<HBUINT16> (glyph - 2, 0) + 1; | |
| 58 unsigned int num_instructions = StructAtOffset<HBUINT16> (glyph, 0); | |
| 59 | |
| 60 glyph += 2 + num_instructions; | |
| 61 | |
| 62 unsigned int coord_bytes = 0; | |
| 63 unsigned int coords_with_flags = 0; | |
| 64 while (glyph < glyph_end) | |
| 65 { | |
| 66 uint8_t flag = *glyph; | |
| 67 glyph++; | |
| 68 | |
| 69 unsigned int repeat = 1; | |
| 70 if (flag & FLAG_REPEAT) | |
| 71 { | |
| 72 if (unlikely (glyph >= glyph_end)) return hb_bytes_t (); | |
| 73 repeat = *glyph + 1; | |
| 74 glyph++; | |
| 75 } | |
| 76 | |
| 77 unsigned int xBytes, yBytes; | |
| 78 xBytes = yBytes = 0; | |
| 79 if (flag & FLAG_X_SHORT) xBytes = 1; | |
| 80 else if ((flag & FLAG_X_SAME) == 0) xBytes = 2; | |
| 81 | |
| 82 if (flag & FLAG_Y_SHORT) yBytes = 1; | |
| 83 else if ((flag & FLAG_Y_SAME) == 0) yBytes = 2; | |
| 84 | |
| 85 coord_bytes += (xBytes + yBytes) * repeat; | |
| 86 coords_with_flags += repeat; | |
| 87 if (coords_with_flags >= num_coordinates) break; | |
| 88 } | |
| 89 | |
| 90 if (unlikely (coords_with_flags != num_coordinates)) return hb_bytes_t (); | |
| 91 return bytes.sub_array (0, bytes.length + coord_bytes - (glyph_end - glyph)); | |
| 92 } | |
| 93 | |
| 94 /* zero instruction length */ | |
| 95 void drop_hints () | |
| 96 { | |
| 97 GlyphHeader &glyph_header = const_cast<GlyphHeader &> (header); | |
| 98 (HBUINT16 &) StructAtOffset<HBUINT16> (&glyph_header, instruction_len_offset ()) = 0; | |
| 99 } | |
| 100 | |
| 101 void drop_hints_bytes (hb_bytes_t &dest_start, hb_bytes_t &dest_end) const | |
| 102 { | |
| 103 unsigned int instructions_len = instructions_length (); | |
| 104 unsigned int glyph_length = length (instructions_len); | |
| 105 dest_start = bytes.sub_array (0, glyph_length - instructions_len); | |
| 106 dest_end = bytes.sub_array (glyph_length, bytes.length - glyph_length); | |
| 107 } | |
| 108 | |
| 109 void set_overlaps_flag () | |
| 110 { | |
| 111 if (unlikely (!header.numberOfContours)) return; | |
| 112 | |
| 113 unsigned flags_offset = length (instructions_length ()); | |
| 114 if (unlikely (flags_offset + 1 > bytes.length)) return; | |
| 115 | |
| 116 HBUINT8 &first_flag = (HBUINT8 &) StructAtOffset<HBUINT16> (&bytes, flags_offset); | |
| 117 first_flag = (uint8_t) first_flag | FLAG_OVERLAP_SIMPLE; | |
| 118 } | |
| 119 | |
| 120 static bool read_flags (const HBUINT8 *&p /* IN/OUT */, | |
| 121 contour_point_vector_t &points_ /* IN/OUT */, | |
| 122 const HBUINT8 *end) | |
| 123 { | |
| 124 unsigned count = points_.length; | |
| 125 for (unsigned int i = 0; i < count;) | |
| 126 { | |
| 127 if (unlikely (p + 1 > end)) return false; | |
| 128 uint8_t flag = *p++; | |
| 129 points_.arrayZ[i++].flag = flag; | |
| 130 if (flag & FLAG_REPEAT) | |
| 131 { | |
| 132 if (unlikely (p + 1 > end)) return false; | |
| 133 unsigned int repeat_count = *p++; | |
| 134 unsigned stop = hb_min (i + repeat_count, count); | |
| 135 for (; i < stop; i++) | |
| 136 points_.arrayZ[i].flag = flag; | |
| 137 } | |
| 138 } | |
| 139 return true; | |
| 140 } | |
| 141 | |
| 142 static bool read_points (const HBUINT8 *&p /* IN/OUT */, | |
| 143 contour_point_vector_t &points_ /* IN/OUT */, | |
| 144 const HBUINT8 *end, | |
| 145 float contour_point_t::*m, | |
| 146 const simple_glyph_flag_t short_flag, | |
| 147 const simple_glyph_flag_t same_flag) | |
| 148 { | |
| 149 int v = 0; | |
| 150 | |
| 151 unsigned count = points_.length; | |
| 152 for (unsigned i = 0; i < count; i++) | |
| 153 { | |
| 154 unsigned flag = points_[i].flag; | |
| 155 if (flag & short_flag) | |
| 156 { | |
| 157 if (unlikely (p + 1 > end)) return false; | |
| 158 if (flag & same_flag) | |
| 159 v += *p++; | |
| 160 else | |
| 161 v -= *p++; | |
| 162 } | |
| 163 else | |
| 164 { | |
| 165 if (!(flag & same_flag)) | |
| 166 { | |
| 167 if (unlikely (p + HBINT16::static_size > end)) return false; | |
| 168 v += *(const HBINT16 *) p; | |
| 169 p += HBINT16::static_size; | |
| 170 } | |
| 171 } | |
| 172 points_.arrayZ[i].*m = v; | |
| 173 } | |
| 174 return true; | |
| 175 } | |
| 176 | |
| 177 bool get_contour_points (contour_point_vector_t &points_ /* OUT */, | |
| 178 bool phantom_only = false) const | |
| 179 { | |
| 180 const HBUINT16 *endPtsOfContours = &StructAfter<HBUINT16> (header); | |
| 181 int num_contours = header.numberOfContours; | |
| 182 assert (num_contours); | |
| 183 /* One extra item at the end, for the instruction-count below. */ | |
| 184 if (unlikely (!bytes.check_range (&endPtsOfContours[num_contours]))) return false; | |
| 185 unsigned int num_points = endPtsOfContours[num_contours - 1] + 1; | |
| 186 | |
| 187 points_.alloc (num_points + 4); // Allocate for phantom points, to avoid a possible copy | |
| 188 if (!points_.resize (num_points)) return false; | |
| 189 if (phantom_only) return true; | |
| 190 | |
| 191 for (int i = 0; i < num_contours; i++) | |
| 192 points_[endPtsOfContours[i]].is_end_point = true; | |
| 193 | |
| 194 /* Skip instructions */ | |
| 195 const HBUINT8 *p = &StructAtOffset<HBUINT8> (&endPtsOfContours[num_contours + 1], | |
| 196 endPtsOfContours[num_contours]); | |
| 197 | |
| 198 if (unlikely ((const char *) p < bytes.arrayZ)) return false; /* Unlikely overflow */ | |
| 199 const HBUINT8 *end = (const HBUINT8 *) (bytes.arrayZ + bytes.length); | |
| 200 if (unlikely (p >= end)) return false; | |
| 201 | |
| 202 /* Read x & y coordinates */ | |
| 203 return read_flags (p, points_, end) | |
| 204 && read_points (p, points_, end, &contour_point_t::x, | |
| 205 FLAG_X_SHORT, FLAG_X_SAME) | |
| 206 && read_points (p, points_, end, &contour_point_t::y, | |
| 207 FLAG_Y_SHORT, FLAG_Y_SAME); | |
| 208 } | |
| 209 | |
| 210 static void encode_coord (int value, | |
| 211 uint8_t &flag, | |
| 212 const simple_glyph_flag_t short_flag, | |
| 213 const simple_glyph_flag_t same_flag, | |
| 214 hb_vector_t<uint8_t> &coords /* OUT */) | |
| 215 { | |
| 216 if (value == 0) | |
| 217 { | |
| 218 flag |= same_flag; | |
| 219 } | |
| 220 else if (value >= -255 && value <= 255) | |
| 221 { | |
| 222 flag |= short_flag; | |
| 223 if (value > 0) flag |= same_flag; | |
| 224 else value = -value; | |
| 225 | |
| 226 coords.arrayZ[coords.length++] = (uint8_t) value; | |
| 227 } | |
| 228 else | |
| 229 { | |
| 230 int16_t val = value; | |
| 231 coords.arrayZ[coords.length++] = val >> 8; | |
| 232 coords.arrayZ[coords.length++] = val & 0xff; | |
| 233 } | |
| 234 } | |
| 235 | |
| 236 static void encode_flag (uint8_t &flag, | |
| 237 uint8_t &repeat, | |
| 238 uint8_t lastflag, | |
| 239 hb_vector_t<uint8_t> &flags /* OUT */) | |
| 240 { | |
| 241 if (flag == lastflag && repeat != 255) | |
| 242 { | |
| 243 repeat++; | |
| 244 if (repeat == 1) | |
| 245 { | |
| 246 /* We know there's room. */ | |
| 247 flags.arrayZ[flags.length++] = flag; | |
| 248 } | |
| 249 else | |
| 250 { | |
| 251 unsigned len = flags.length; | |
| 252 flags.arrayZ[len-2] = flag | FLAG_REPEAT; | |
| 253 flags.arrayZ[len-1] = repeat; | |
| 254 } | |
| 255 } | |
| 256 else | |
| 257 { | |
| 258 repeat = 0; | |
| 259 flags.push (flag); | |
| 260 } | |
| 261 } | |
| 262 | |
| 263 bool compile_bytes_with_deltas (const contour_point_vector_t &all_points, | |
| 264 bool no_hinting, | |
| 265 hb_bytes_t &dest_bytes /* OUT */) | |
| 266 { | |
| 267 if (header.numberOfContours == 0 || all_points.length <= 4) | |
| 268 { | |
| 269 dest_bytes = hb_bytes_t (); | |
| 270 return true; | |
| 271 } | |
| 272 unsigned num_points = all_points.length - 4; | |
| 273 | |
| 274 hb_vector_t<uint8_t> flags, x_coords, y_coords; | |
| 275 if (unlikely (!flags.alloc (num_points))) return false; | |
| 276 if (unlikely (!x_coords.alloc (2*num_points))) return false; | |
| 277 if (unlikely (!y_coords.alloc (2*num_points))) return false; | |
| 278 | |
| 279 uint8_t lastflag = 255, repeat = 0; | |
| 280 int prev_x = 0, prev_y = 0; | |
| 281 | |
| 282 for (unsigned i = 0; i < num_points; i++) | |
| 283 { | |
| 284 uint8_t flag = all_points.arrayZ[i].flag; | |
| 285 flag &= FLAG_ON_CURVE + FLAG_OVERLAP_SIMPLE; | |
| 286 | |
| 287 int cur_x = roundf (all_points.arrayZ[i].x); | |
| 288 int cur_y = roundf (all_points.arrayZ[i].y); | |
| 289 encode_coord (cur_x - prev_x, flag, FLAG_X_SHORT, FLAG_X_SAME, x_coords); | |
| 290 encode_coord (cur_y - prev_y, flag, FLAG_Y_SHORT, FLAG_Y_SAME, y_coords); | |
| 291 encode_flag (flag, repeat, lastflag, flags); | |
| 292 | |
| 293 prev_x = cur_x; | |
| 294 prev_y = cur_y; | |
| 295 lastflag = flag; | |
| 296 } | |
| 297 | |
| 298 unsigned len_before_instrs = 2 * header.numberOfContours + 2; | |
| 299 unsigned len_instrs = instructions_length (); | |
| 300 unsigned total_len = len_before_instrs + flags.length + x_coords.length + y_coords.length; | |
| 301 | |
| 302 if (!no_hinting) | |
| 303 total_len += len_instrs; | |
| 304 | |
| 305 char *p = (char *) hb_malloc (total_len); | |
| 306 if (unlikely (!p)) return false; | |
| 307 | |
| 308 const char *src = bytes.arrayZ + GlyphHeader::static_size; | |
| 309 char *cur = p; | |
| 310 hb_memcpy (p, src, len_before_instrs); | |
| 311 | |
| 312 cur += len_before_instrs; | |
| 313 src += len_before_instrs; | |
| 314 | |
| 315 if (!no_hinting) | |
| 316 { | |
| 317 hb_memcpy (cur, src, len_instrs); | |
| 318 cur += len_instrs; | |
| 319 } | |
| 320 | |
| 321 hb_memcpy (cur, flags.arrayZ, flags.length); | |
| 322 cur += flags.length; | |
| 323 | |
| 324 hb_memcpy (cur, x_coords.arrayZ, x_coords.length); | |
| 325 cur += x_coords.length; | |
| 326 | |
| 327 hb_memcpy (cur, y_coords.arrayZ, y_coords.length); | |
| 328 | |
| 329 dest_bytes = hb_bytes_t (p, total_len); | |
| 330 return true; | |
| 331 } | |
| 332 }; | |
| 333 | |
| 334 | |
| 335 } /* namespace glyf_impl */ | |
| 336 } /* namespace OT */ | |
| 337 | |
| 338 | |
| 339 #endif /* OT_GLYF_SIMPLEGLYPH_HH */ |
