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