1 | /* |
2 | * Copyright © 2016 Google, Inc. |
3 | * |
4 | * This is part of HarfBuzz, a text shaping library. |
5 | * |
6 | * Permission is hereby granted, without written agreement and without |
7 | * license or royalty fees, to use, copy, modify, and distribute this |
8 | * software and its documentation for any purpose, provided that the |
9 | * above copyright notice and the following two paragraphs appear in |
10 | * all copies of this software. |
11 | * |
12 | * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
13 | * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
14 | * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
15 | * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
16 | * DAMAGE. |
17 | * |
18 | * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
19 | * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
20 | * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
21 | * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
22 | * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
23 | * |
24 | * Google Author(s): Seigo Nonaka, Calder Kitagawa |
25 | */ |
26 | |
27 | #ifndef OT_COLOR_CBDT_CBDT_HH |
28 | #define OT_COLOR_CBDT_CBDT_HH |
29 | |
30 | #include "../../../hb-open-type.hh" |
31 | #include "../../../hb-paint.hh" |
32 | |
33 | /* |
34 | * CBLC -- Color Bitmap Location |
35 | * https://docs.microsoft.com/en-us/typography/opentype/spec/cblc |
36 | * https://docs.microsoft.com/en-us/typography/opentype/spec/eblc |
37 | * CBDT -- Color Bitmap Data |
38 | * https://docs.microsoft.com/en-us/typography/opentype/spec/cbdt |
39 | * https://docs.microsoft.com/en-us/typography/opentype/spec/ebdt |
40 | */ |
41 | #define HB_OT_TAG_CBLC HB_TAG('C','B','L','C') |
42 | #define HB_OT_TAG_CBDT HB_TAG('C','B','D','T') |
43 | |
44 | |
45 | namespace OT { |
46 | |
47 | struct cblc_bitmap_size_subset_context_t |
48 | { |
49 | const char *cbdt; |
50 | unsigned int cbdt_length; |
51 | hb_vector_t<char> *cbdt_prime; |
52 | unsigned int size; /* INOUT |
53 | * Input: old size of IndexSubtable |
54 | * Output: new size of IndexSubtable |
55 | */ |
56 | unsigned int num_tables; /* INOUT |
57 | * Input: old number of subtables. |
58 | * Output: new number of subtables. |
59 | */ |
60 | hb_codepoint_t start_glyph; /* OUT */ |
61 | hb_codepoint_t end_glyph; /* OUT */ |
62 | }; |
63 | |
64 | static inline bool |
65 | _copy_data_to_cbdt (hb_vector_t<char> *cbdt_prime, |
66 | const void *data, |
67 | unsigned length) |
68 | { |
69 | unsigned int new_len = cbdt_prime->length + length; |
70 | if (unlikely (!cbdt_prime->alloc (new_len))) return false; |
71 | hb_memcpy (cbdt_prime->arrayZ + cbdt_prime->length, data, length); |
72 | cbdt_prime->length = new_len; |
73 | return true; |
74 | } |
75 | |
76 | struct SmallGlyphMetrics |
77 | { |
78 | bool sanitize (hb_sanitize_context_t *c) const |
79 | { |
80 | TRACE_SANITIZE (this); |
81 | return_trace (c->check_struct (this)); |
82 | } |
83 | |
84 | void get_extents (hb_font_t *font, hb_glyph_extents_t *extents, bool scale) const |
85 | { |
86 | extents->x_bearing = bearingX; |
87 | extents->y_bearing = bearingY; |
88 | extents->width = width; |
89 | extents->height = -static_cast<int> (height); |
90 | |
91 | if (scale) |
92 | font->scale_glyph_extents (extents); |
93 | } |
94 | |
95 | HBUINT8 height; |
96 | HBUINT8 width; |
97 | HBINT8 bearingX; |
98 | HBINT8 bearingY; |
99 | HBUINT8 advance; |
100 | public: |
101 | DEFINE_SIZE_STATIC (5); |
102 | }; |
103 | |
104 | struct BigGlyphMetrics : SmallGlyphMetrics |
105 | { |
106 | HBINT8 vertBearingX; |
107 | HBINT8 vertBearingY; |
108 | HBUINT8 vertAdvance; |
109 | public: |
110 | DEFINE_SIZE_STATIC (8); |
111 | }; |
112 | |
113 | struct SBitLineMetrics |
114 | { |
115 | bool sanitize (hb_sanitize_context_t *c) const |
116 | { |
117 | TRACE_SANITIZE (this); |
118 | return_trace (c->check_struct (this)); |
119 | } |
120 | |
121 | HBINT8 ascender; |
122 | HBINT8 decender; |
123 | HBUINT8 widthMax; |
124 | HBINT8 caretSlopeNumerator; |
125 | HBINT8 caretSlopeDenominator; |
126 | HBINT8 caretOffset; |
127 | HBINT8 minOriginSB; |
128 | HBINT8 minAdvanceSB; |
129 | HBINT8 maxBeforeBL; |
130 | HBINT8 minAfterBL; |
131 | HBINT8 padding1; |
132 | HBINT8 padding2; |
133 | public: |
134 | DEFINE_SIZE_STATIC (12); |
135 | }; |
136 | |
137 | |
138 | /* |
139 | * Index Subtables. |
140 | */ |
141 | |
142 | struct |
143 | { |
144 | bool (hb_sanitize_context_t *c) const |
145 | { |
146 | TRACE_SANITIZE (this); |
147 | return_trace (c->check_struct (this)); |
148 | } |
149 | |
150 | HBUINT16 ; |
151 | HBUINT16 ; |
152 | HBUINT32 ; |
153 | public: |
154 | DEFINE_SIZE_STATIC (8); |
155 | }; |
156 | |
157 | template <typename OffsetType> |
158 | struct IndexSubtableFormat1Or3 |
159 | { |
160 | bool sanitize (hb_sanitize_context_t *c, unsigned int glyph_count) const |
161 | { |
162 | TRACE_SANITIZE (this); |
163 | return_trace (c->check_struct (this) && |
164 | offsetArrayZ.sanitize (c, glyph_count + 1)); |
165 | } |
166 | |
167 | bool get_image_data (unsigned int idx, |
168 | unsigned int *offset, |
169 | unsigned int *length) const |
170 | { |
171 | if (unlikely (offsetArrayZ[idx + 1] <= offsetArrayZ[idx])) |
172 | return false; |
173 | |
174 | *offset = header.imageDataOffset + offsetArrayZ[idx]; |
175 | *length = offsetArrayZ[idx + 1] - offsetArrayZ[idx]; |
176 | return true; |
177 | } |
178 | |
179 | bool add_offset (hb_serialize_context_t *c, |
180 | unsigned int offset, |
181 | unsigned int *size /* OUT (accumulated) */) |
182 | { |
183 | TRACE_SERIALIZE (this); |
184 | Offset<OffsetType> embedded_offset; |
185 | embedded_offset = offset; |
186 | *size += sizeof (OffsetType); |
187 | auto *o = c->embed (embedded_offset); |
188 | return_trace ((bool) o); |
189 | } |
190 | |
191 | IndexSubtableHeader ; |
192 | UnsizedArrayOf<Offset<OffsetType>> |
193 | offsetArrayZ; |
194 | public: |
195 | DEFINE_SIZE_ARRAY (8, offsetArrayZ); |
196 | }; |
197 | |
198 | struct IndexSubtableFormat1 : IndexSubtableFormat1Or3<HBUINT32> {}; |
199 | struct IndexSubtableFormat3 : IndexSubtableFormat1Or3<HBUINT16> {}; |
200 | |
201 | struct IndexSubtable |
202 | { |
203 | bool sanitize (hb_sanitize_context_t *c, unsigned int glyph_count) const |
204 | { |
205 | TRACE_SANITIZE (this); |
206 | if (!u.header.sanitize (c)) return_trace (false); |
207 | switch (u.header.indexFormat) |
208 | { |
209 | case 1: return_trace (u.format1.sanitize (c, glyph_count)); |
210 | case 3: return_trace (u.format3.sanitize (c, glyph_count)); |
211 | default:return_trace (true); |
212 | } |
213 | } |
214 | |
215 | bool |
216 | finish_subtable (hb_serialize_context_t *c, |
217 | unsigned int cbdt_prime_len, |
218 | unsigned int num_glyphs, |
219 | unsigned int *size /* OUT (accumulated) */) |
220 | { |
221 | TRACE_SERIALIZE (this); |
222 | |
223 | unsigned int local_offset = cbdt_prime_len - u.header.imageDataOffset; |
224 | switch (u.header.indexFormat) |
225 | { |
226 | case 1: return_trace (u.format1.add_offset (c, local_offset, size)); |
227 | case 3: { |
228 | if (!u.format3.add_offset (c, local_offset, size)) |
229 | return_trace (false); |
230 | if (!(num_glyphs & 0x01)) // Pad to 32-bit alignment if needed. |
231 | return_trace (u.format3.add_offset (c, 0, size)); |
232 | return_trace (true); |
233 | } |
234 | // TODO: implement 2, 4, 5. |
235 | case 2: case 4: // No-op. |
236 | case 5: // Pad to 32-bit aligned. |
237 | default: return_trace (false); |
238 | } |
239 | } |
240 | |
241 | bool |
242 | fill_missing_glyphs (hb_serialize_context_t *c, |
243 | unsigned int cbdt_prime_len, |
244 | unsigned int num_missing, |
245 | unsigned int *size /* OUT (accumulated) */, |
246 | unsigned int *num_glyphs /* OUT (accumulated) */) |
247 | { |
248 | TRACE_SERIALIZE (this); |
249 | |
250 | unsigned int local_offset = cbdt_prime_len - u.header.imageDataOffset; |
251 | switch (u.header.indexFormat) |
252 | { |
253 | case 1: { |
254 | for (unsigned int i = 0; i < num_missing; i++) |
255 | { |
256 | if (unlikely (!u.format1.add_offset (c, local_offset, size))) |
257 | return_trace (false); |
258 | *num_glyphs += 1; |
259 | } |
260 | return_trace (true); |
261 | } |
262 | case 3: { |
263 | for (unsigned int i = 0; i < num_missing; i++) |
264 | { |
265 | if (unlikely (!u.format3.add_offset (c, local_offset, size))) |
266 | return_trace (false); |
267 | *num_glyphs += 1; |
268 | } |
269 | return_trace (true); |
270 | } |
271 | // TODO: implement 2, 4, 5. |
272 | case 2: // Add empty space in cbdt_prime?. |
273 | case 4: case 5: // No-op as sparse is supported. |
274 | default: return_trace (false); |
275 | } |
276 | } |
277 | |
278 | bool |
279 | copy_glyph_at_idx (hb_serialize_context_t *c, unsigned int idx, |
280 | const char *cbdt, unsigned int cbdt_length, |
281 | hb_vector_t<char> *cbdt_prime /* INOUT */, |
282 | IndexSubtable *subtable_prime /* INOUT */, |
283 | unsigned int *size /* OUT (accumulated) */) const |
284 | { |
285 | TRACE_SERIALIZE (this); |
286 | |
287 | unsigned int offset, length, format; |
288 | if (unlikely (!get_image_data (idx, &offset, &length, &format))) return_trace (false); |
289 | if (unlikely (offset > cbdt_length || cbdt_length - offset < length)) return_trace (false); |
290 | |
291 | auto * = subtable_prime->get_header (); |
292 | unsigned int new_local_offset = cbdt_prime->length - (unsigned int) header_prime->imageDataOffset; |
293 | if (unlikely (!_copy_data_to_cbdt (cbdt_prime, cbdt + offset, length))) return_trace (false); |
294 | |
295 | return_trace (subtable_prime->add_offset (c, new_local_offset, size)); |
296 | } |
297 | |
298 | bool |
299 | add_offset (hb_serialize_context_t *c, unsigned int local_offset, |
300 | unsigned int *size /* OUT (accumulated) */) |
301 | { |
302 | TRACE_SERIALIZE (this); |
303 | switch (u.header.indexFormat) |
304 | { |
305 | case 1: return_trace (u.format1.add_offset (c, local_offset, size)); |
306 | case 3: return_trace (u.format3.add_offset (c, local_offset, size)); |
307 | // TODO: Implement tables 2, 4, 5 |
308 | case 2: // Should be a no-op. |
309 | case 4: case 5: // Handle sparse cases. |
310 | default: return_trace (false); |
311 | } |
312 | } |
313 | |
314 | bool get_extents (hb_glyph_extents_t *extents HB_UNUSED, bool scale HB_UNUSED) const |
315 | { |
316 | switch (u.header.indexFormat) |
317 | { |
318 | case 2: case 5: /* TODO */ |
319 | case 1: case 3: case 4: /* Variable-metrics formats do not have metrics here. */ |
320 | default:return (false); |
321 | } |
322 | } |
323 | |
324 | bool |
325 | get_image_data (unsigned int idx, unsigned int *offset, |
326 | unsigned int *length, unsigned int *format) const |
327 | { |
328 | *format = u.header.imageFormat; |
329 | switch (u.header.indexFormat) |
330 | { |
331 | case 1: return u.format1.get_image_data (idx, offset, length); |
332 | case 3: return u.format3.get_image_data (idx, offset, length); |
333 | default: return false; |
334 | } |
335 | } |
336 | |
337 | const IndexSubtableHeader* () const { return &u.header; } |
338 | |
339 | void (unsigned index_format, |
340 | unsigned image_format, |
341 | unsigned int image_data_offset, |
342 | unsigned int *size) |
343 | { |
344 | u.header.indexFormat = index_format; |
345 | u.header.imageFormat = image_format; |
346 | u.header.imageDataOffset = image_data_offset; |
347 | switch (u.header.indexFormat) |
348 | { |
349 | case 1: *size += IndexSubtableFormat1::min_size; break; |
350 | case 3: *size += IndexSubtableFormat3::min_size; break; |
351 | } |
352 | } |
353 | |
354 | protected: |
355 | union { |
356 | IndexSubtableHeader ; |
357 | IndexSubtableFormat1 format1; |
358 | IndexSubtableFormat3 format3; |
359 | /* TODO: Format 2, 4, 5. */ |
360 | } u; |
361 | public: |
362 | DEFINE_SIZE_UNION (8, header); |
363 | }; |
364 | |
365 | struct IndexSubtableRecord |
366 | { |
367 | /* XXX Remove this and fix by not inserting it into vector. */ |
368 | IndexSubtableRecord& operator = (const IndexSubtableRecord &o) |
369 | { |
370 | firstGlyphIndex = o.firstGlyphIndex; |
371 | lastGlyphIndex = o.lastGlyphIndex; |
372 | offsetToSubtable = (unsigned) o.offsetToSubtable; |
373 | assert (offsetToSubtable.is_null ()); |
374 | return *this; |
375 | } |
376 | |
377 | bool sanitize (hb_sanitize_context_t *c, const void *base) const |
378 | { |
379 | TRACE_SANITIZE (this); |
380 | return_trace (c->check_struct (this) && |
381 | firstGlyphIndex <= lastGlyphIndex && |
382 | offsetToSubtable.sanitize (c, base, lastGlyphIndex - firstGlyphIndex + 1)); |
383 | } |
384 | |
385 | const IndexSubtable* get_subtable (const void *base) const |
386 | { |
387 | return &(base+offsetToSubtable); |
388 | } |
389 | |
390 | bool add_new_subtable (hb_subset_context_t* c, |
391 | cblc_bitmap_size_subset_context_t *bitmap_size_context, |
392 | IndexSubtableRecord *record, |
393 | const hb_vector_t<hb_pair_t<hb_codepoint_t, const IndexSubtableRecord*>> *lookup, /* IN */ |
394 | const void *base, |
395 | unsigned int *start /* INOUT */) const |
396 | { |
397 | TRACE_SERIALIZE (this); |
398 | |
399 | auto *subtable = c->serializer->start_embed<IndexSubtable> (); |
400 | if (unlikely (!c->serializer->extend_min (subtable))) return_trace (false); |
401 | |
402 | auto *old_subtable = get_subtable (base); |
403 | auto * = old_subtable->get_header (); |
404 | |
405 | subtable->populate_header (old_header->indexFormat, |
406 | old_header->imageFormat, |
407 | bitmap_size_context->cbdt_prime->length, |
408 | &bitmap_size_context->size); |
409 | |
410 | unsigned int num_glyphs = 0; |
411 | bool early_exit = false; |
412 | for (unsigned int i = *start; i < lookup->length; i++) |
413 | { |
414 | hb_codepoint_t new_gid = (*lookup)[i].first; |
415 | const IndexSubtableRecord *next_record = (*lookup)[i].second; |
416 | const IndexSubtable *next_subtable = next_record->get_subtable (base); |
417 | auto * = next_subtable->get_header (); |
418 | if (next_header != old_header) |
419 | { |
420 | *start = i; |
421 | early_exit = true; |
422 | break; |
423 | } |
424 | unsigned int num_missing = record->add_glyph_for_subset (new_gid); |
425 | if (unlikely (!subtable->fill_missing_glyphs (c->serializer, |
426 | bitmap_size_context->cbdt_prime->length, |
427 | num_missing, |
428 | &bitmap_size_context->size, |
429 | &num_glyphs))) |
430 | return_trace (false); |
431 | |
432 | hb_codepoint_t old_gid = 0; |
433 | c->plan->old_gid_for_new_gid (new_gid, &old_gid); |
434 | if (old_gid < next_record->firstGlyphIndex) |
435 | return_trace (false); |
436 | |
437 | unsigned int old_idx = (unsigned int) old_gid - next_record->firstGlyphIndex; |
438 | if (unlikely (!next_subtable->copy_glyph_at_idx (c->serializer, |
439 | old_idx, |
440 | bitmap_size_context->cbdt, |
441 | bitmap_size_context->cbdt_length, |
442 | bitmap_size_context->cbdt_prime, |
443 | subtable, |
444 | &bitmap_size_context->size))) |
445 | return_trace (false); |
446 | num_glyphs += 1; |
447 | } |
448 | if (!early_exit) |
449 | *start = lookup->length; |
450 | if (unlikely (!subtable->finish_subtable (c->serializer, |
451 | bitmap_size_context->cbdt_prime->length, |
452 | num_glyphs, |
453 | &bitmap_size_context->size))) |
454 | return_trace (false); |
455 | return_trace (true); |
456 | } |
457 | |
458 | bool add_new_record (hb_subset_context_t *c, |
459 | cblc_bitmap_size_subset_context_t *bitmap_size_context, |
460 | const hb_vector_t<hb_pair_t<hb_codepoint_t, const IndexSubtableRecord*>> *lookup, /* IN */ |
461 | const void *base, |
462 | unsigned int *start, /* INOUT */ |
463 | hb_vector_t<IndexSubtableRecord>* records /* INOUT */) const |
464 | { |
465 | TRACE_SERIALIZE (this); |
466 | auto snap = c->serializer->snapshot (); |
467 | unsigned int old_size = bitmap_size_context->size; |
468 | unsigned int old_cbdt_prime_length = bitmap_size_context->cbdt_prime->length; |
469 | |
470 | // Set to invalid state to indicate filling glyphs is not yet started. |
471 | if (unlikely (!c->serializer->check_success (records->resize (records->length + 1)))) |
472 | return_trace (false); |
473 | |
474 | records->tail ().firstGlyphIndex = 1; |
475 | records->tail ().lastGlyphIndex = 0; |
476 | bitmap_size_context->size += IndexSubtableRecord::min_size; |
477 | |
478 | c->serializer->push (); |
479 | |
480 | if (unlikely (!add_new_subtable (c, bitmap_size_context, &(records->tail ()), lookup, base, start))) |
481 | { |
482 | c->serializer->pop_discard (); |
483 | c->serializer->revert (snap); |
484 | bitmap_size_context->cbdt_prime->shrink (old_cbdt_prime_length); |
485 | bitmap_size_context->size = old_size; |
486 | records->resize (records->length - 1); |
487 | return_trace (false); |
488 | } |
489 | |
490 | bitmap_size_context->num_tables += 1; |
491 | return_trace (true); |
492 | } |
493 | |
494 | unsigned int add_glyph_for_subset (hb_codepoint_t gid) |
495 | { |
496 | if (firstGlyphIndex > lastGlyphIndex) |
497 | { |
498 | firstGlyphIndex = gid; |
499 | lastGlyphIndex = gid; |
500 | return 0; |
501 | } |
502 | // TODO maybe assert? this shouldn't occur. |
503 | if (lastGlyphIndex > gid) |
504 | return 0; |
505 | unsigned int num_missing = (unsigned int) (gid - lastGlyphIndex - 1); |
506 | lastGlyphIndex = gid; |
507 | return num_missing; |
508 | } |
509 | |
510 | bool get_extents (hb_glyph_extents_t *extents, const void *base, bool scale) const |
511 | { return (base+offsetToSubtable).get_extents (extents, scale); } |
512 | |
513 | bool get_image_data (unsigned int gid, |
514 | const void *base, |
515 | unsigned int *offset, |
516 | unsigned int *length, |
517 | unsigned int *format) const |
518 | { |
519 | if (gid < firstGlyphIndex || gid > lastGlyphIndex) return false; |
520 | return (base+offsetToSubtable).get_image_data (gid - firstGlyphIndex, |
521 | offset, length, format); |
522 | } |
523 | |
524 | HBGlyphID16 firstGlyphIndex; |
525 | HBGlyphID16 lastGlyphIndex; |
526 | Offset32To<IndexSubtable> offsetToSubtable; |
527 | public: |
528 | DEFINE_SIZE_STATIC (8); |
529 | }; |
530 | |
531 | struct IndexSubtableArray |
532 | { |
533 | friend struct CBDT; |
534 | |
535 | bool sanitize (hb_sanitize_context_t *c, unsigned int count) const |
536 | { |
537 | TRACE_SANITIZE (this); |
538 | return_trace (indexSubtablesZ.sanitize (c, count, this)); |
539 | } |
540 | |
541 | void |
542 | build_lookup (hb_subset_context_t *c, cblc_bitmap_size_subset_context_t *bitmap_size_context, |
543 | hb_vector_t<hb_pair_t<hb_codepoint_t, |
544 | const IndexSubtableRecord*>> *lookup /* OUT */) const |
545 | { |
546 | bool start_glyph_is_set = false; |
547 | unsigned num_glyphs = c->plan->num_output_glyphs (); |
548 | for (hb_codepoint_t new_gid = 0; new_gid < num_glyphs; new_gid++) |
549 | { |
550 | hb_codepoint_t old_gid; |
551 | if (unlikely (!c->plan->old_gid_for_new_gid (new_gid, &old_gid))) continue; |
552 | |
553 | const IndexSubtableRecord* record = find_table (old_gid, bitmap_size_context->num_tables); |
554 | if (unlikely (!record)) continue; |
555 | |
556 | // Don't add gaps to the lookup. The best way to determine if a glyph is a |
557 | // gap is that it has no image data. |
558 | unsigned int offset, length, format; |
559 | if (unlikely (!record->get_image_data (old_gid, this, &offset, &length, &format))) continue; |
560 | |
561 | lookup->push (hb_pair_t<hb_codepoint_t, const IndexSubtableRecord*> (new_gid, record)); |
562 | |
563 | if (!start_glyph_is_set) |
564 | { |
565 | bitmap_size_context->start_glyph = new_gid; |
566 | start_glyph_is_set = true; |
567 | } |
568 | |
569 | bitmap_size_context->end_glyph = new_gid; |
570 | } |
571 | } |
572 | |
573 | bool |
574 | subset (hb_subset_context_t *c, |
575 | cblc_bitmap_size_subset_context_t *bitmap_size_context) const |
576 | { |
577 | TRACE_SUBSET (this); |
578 | |
579 | hb_vector_t<hb_pair_t<hb_codepoint_t, const IndexSubtableRecord*>> lookup; |
580 | build_lookup (c, bitmap_size_context, &lookup); |
581 | if (unlikely (!c->serializer->propagate_error (lookup))) |
582 | return false; |
583 | |
584 | bitmap_size_context->size = 0; |
585 | bitmap_size_context->num_tables = 0; |
586 | hb_vector_t<IndexSubtableRecord> records; |
587 | for (unsigned int start = 0; start < lookup.length;) |
588 | { |
589 | if (unlikely (!lookup[start].second->add_new_record (c, bitmap_size_context, &lookup, this, &start, &records))) |
590 | { |
591 | // Discard any leftover pushes to the serializer from successful records. |
592 | for (unsigned int i = 0; i < records.length; i++) |
593 | c->serializer->pop_discard (); |
594 | return_trace (false); |
595 | } |
596 | } |
597 | |
598 | /* Workaround to ensure offset ordering is from least to greatest when |
599 | * resolving links. */ |
600 | hb_vector_t<hb_serialize_context_t::objidx_t> objidxs; |
601 | for (unsigned int i = 0; i < records.length; i++) |
602 | objidxs.push (c->serializer->pop_pack ()); |
603 | for (unsigned int i = 0; i < records.length; i++) |
604 | { |
605 | IndexSubtableRecord* record = c->serializer->embed (records[i]); |
606 | if (unlikely (!record)) return_trace (false); |
607 | c->serializer->add_link (record->offsetToSubtable, objidxs[records.length - 1 - i]); |
608 | } |
609 | return_trace (true); |
610 | } |
611 | |
612 | public: |
613 | const IndexSubtableRecord* find_table (hb_codepoint_t glyph, unsigned int numTables) const |
614 | { |
615 | for (unsigned int i = 0; i < numTables; ++i) |
616 | { |
617 | unsigned int firstGlyphIndex = indexSubtablesZ[i].firstGlyphIndex; |
618 | unsigned int lastGlyphIndex = indexSubtablesZ[i].lastGlyphIndex; |
619 | if (firstGlyphIndex <= glyph && glyph <= lastGlyphIndex) |
620 | return &indexSubtablesZ[i]; |
621 | } |
622 | return nullptr; |
623 | } |
624 | |
625 | protected: |
626 | UnsizedArrayOf<IndexSubtableRecord> indexSubtablesZ; |
627 | }; |
628 | |
629 | struct BitmapSizeTable |
630 | { |
631 | friend struct CBLC; |
632 | friend struct CBDT; |
633 | |
634 | bool sanitize (hb_sanitize_context_t *c, const void *base) const |
635 | { |
636 | TRACE_SANITIZE (this); |
637 | return_trace (c->check_struct (this) && |
638 | indexSubtableArrayOffset.sanitize (c, base, numberOfIndexSubtables) && |
639 | horizontal.sanitize (c) && |
640 | vertical.sanitize (c)); |
641 | } |
642 | |
643 | const IndexSubtableRecord * |
644 | find_table (hb_codepoint_t glyph, const void *base, const void **out_base) const |
645 | { |
646 | *out_base = &(base+indexSubtableArrayOffset); |
647 | return (base+indexSubtableArrayOffset).find_table (glyph, numberOfIndexSubtables); |
648 | } |
649 | |
650 | bool |
651 | subset (hb_subset_context_t *c, const void *base, |
652 | const char *cbdt, unsigned int cbdt_length, |
653 | hb_vector_t<char> *cbdt_prime /* INOUT */) const |
654 | { |
655 | TRACE_SUBSET (this); |
656 | auto *out_table = c->serializer->embed (this); |
657 | if (unlikely (!out_table)) return_trace (false); |
658 | |
659 | cblc_bitmap_size_subset_context_t bitmap_size_context; |
660 | bitmap_size_context.cbdt = cbdt; |
661 | bitmap_size_context.cbdt_length = cbdt_length; |
662 | bitmap_size_context.cbdt_prime = cbdt_prime; |
663 | bitmap_size_context.size = indexTablesSize; |
664 | bitmap_size_context.num_tables = numberOfIndexSubtables; |
665 | bitmap_size_context.start_glyph = 1; |
666 | bitmap_size_context.end_glyph = 0; |
667 | |
668 | if (!out_table->indexSubtableArrayOffset.serialize_subset (c, |
669 | indexSubtableArrayOffset, |
670 | base, |
671 | &bitmap_size_context)) |
672 | return_trace (false); |
673 | if (!bitmap_size_context.size || |
674 | !bitmap_size_context.num_tables || |
675 | bitmap_size_context.start_glyph > bitmap_size_context.end_glyph) |
676 | return_trace (false); |
677 | |
678 | out_table->indexTablesSize = bitmap_size_context.size; |
679 | out_table->numberOfIndexSubtables = bitmap_size_context.num_tables; |
680 | out_table->startGlyphIndex = bitmap_size_context.start_glyph; |
681 | out_table->endGlyphIndex = bitmap_size_context.end_glyph; |
682 | return_trace (true); |
683 | } |
684 | |
685 | protected: |
686 | NNOffset32To<IndexSubtableArray> |
687 | indexSubtableArrayOffset; |
688 | HBUINT32 indexTablesSize; |
689 | HBUINT32 numberOfIndexSubtables; |
690 | HBUINT32 colorRef; |
691 | SBitLineMetrics horizontal; |
692 | SBitLineMetrics vertical; |
693 | HBGlyphID16 startGlyphIndex; |
694 | HBGlyphID16 endGlyphIndex; |
695 | HBUINT8 ppemX; |
696 | HBUINT8 ppemY; |
697 | HBUINT8 bitDepth; |
698 | HBINT8 flags; |
699 | public: |
700 | DEFINE_SIZE_STATIC (48); |
701 | }; |
702 | |
703 | |
704 | /* |
705 | * Glyph Bitmap Data Formats. |
706 | */ |
707 | |
708 | struct GlyphBitmapDataFormat17 |
709 | { |
710 | SmallGlyphMetrics glyphMetrics; |
711 | Array32Of<HBUINT8> data; |
712 | public: |
713 | DEFINE_SIZE_ARRAY (9, data); |
714 | }; |
715 | |
716 | struct GlyphBitmapDataFormat18 |
717 | { |
718 | BigGlyphMetrics glyphMetrics; |
719 | Array32Of<HBUINT8> data; |
720 | public: |
721 | DEFINE_SIZE_ARRAY (12, data); |
722 | }; |
723 | |
724 | struct GlyphBitmapDataFormat19 |
725 | { |
726 | Array32Of<HBUINT8> data; |
727 | public: |
728 | DEFINE_SIZE_ARRAY (4, data); |
729 | }; |
730 | |
731 | struct CBLC |
732 | { |
733 | friend struct CBDT; |
734 | |
735 | static constexpr hb_tag_t tableTag = HB_OT_TAG_CBLC; |
736 | |
737 | bool sanitize (hb_sanitize_context_t *c) const |
738 | { |
739 | TRACE_SANITIZE (this); |
740 | return_trace (c->check_struct (this) && |
741 | likely (version.major == 2 || version.major == 3) && |
742 | sizeTables.sanitize (c, this)); |
743 | } |
744 | |
745 | static bool |
746 | sink_cbdt (hb_subset_context_t *c, hb_vector_t<char>* cbdt_prime) |
747 | { |
748 | hb_blob_t *cbdt_prime_blob = hb_blob_create (cbdt_prime->arrayZ, |
749 | cbdt_prime->length, |
750 | HB_MEMORY_MODE_WRITABLE, |
751 | cbdt_prime->arrayZ, |
752 | hb_free); |
753 | cbdt_prime->init (); // Leak arrayZ to the blob. |
754 | bool ret = c->plan->add_table (HB_OT_TAG_CBDT, cbdt_prime_blob); |
755 | hb_blob_destroy (cbdt_prime_blob); |
756 | return ret; |
757 | } |
758 | |
759 | bool |
760 | subset_size_table (hb_subset_context_t *c, const BitmapSizeTable& table, |
761 | const char *cbdt /* IN */, unsigned int cbdt_length, |
762 | CBLC *cblc_prime /* INOUT */, hb_vector_t<char> *cbdt_prime /* INOUT */) const |
763 | { |
764 | TRACE_SUBSET (this); |
765 | cblc_prime->sizeTables.len++; |
766 | |
767 | auto snap = c->serializer->snapshot (); |
768 | auto cbdt_prime_len = cbdt_prime->length; |
769 | |
770 | if (!table.subset (c, this, cbdt, cbdt_length, cbdt_prime)) |
771 | { |
772 | cblc_prime->sizeTables.len--; |
773 | c->serializer->revert (snap); |
774 | cbdt_prime->shrink (cbdt_prime_len); |
775 | return_trace (false); |
776 | } |
777 | return_trace (true); |
778 | } |
779 | |
780 | // Implemented in cc file as it depends on definition of CBDT. |
781 | HB_INTERNAL bool subset (hb_subset_context_t *c) const; |
782 | |
783 | protected: |
784 | const BitmapSizeTable &choose_strike (hb_font_t *font) const |
785 | { |
786 | unsigned count = sizeTables.len; |
787 | if (unlikely (!count)) |
788 | return Null (BitmapSizeTable); |
789 | |
790 | unsigned int requested_ppem = hb_max (font->x_ppem, font->y_ppem); |
791 | if (!requested_ppem) |
792 | requested_ppem = 1<<30; /* Choose largest strike. */ |
793 | unsigned int best_i = 0; |
794 | unsigned int best_ppem = hb_max (sizeTables[0].ppemX, sizeTables[0].ppemY); |
795 | |
796 | for (unsigned int i = 1; i < count; i++) |
797 | { |
798 | unsigned int ppem = hb_max (sizeTables[i].ppemX, sizeTables[i].ppemY); |
799 | if ((requested_ppem <= ppem && ppem < best_ppem) || |
800 | (requested_ppem > best_ppem && ppem > best_ppem)) |
801 | { |
802 | best_i = i; |
803 | best_ppem = ppem; |
804 | } |
805 | } |
806 | |
807 | return sizeTables[best_i]; |
808 | } |
809 | |
810 | protected: |
811 | FixedVersion<> version; |
812 | Array32Of<BitmapSizeTable> sizeTables; |
813 | public: |
814 | DEFINE_SIZE_ARRAY (8, sizeTables); |
815 | }; |
816 | |
817 | struct CBDT |
818 | { |
819 | static constexpr hb_tag_t tableTag = HB_OT_TAG_CBDT; |
820 | |
821 | struct accelerator_t |
822 | { |
823 | accelerator_t (hb_face_t *face) |
824 | { |
825 | this->cblc = hb_sanitize_context_t ().reference_table<CBLC> (face); |
826 | this->cbdt = hb_sanitize_context_t ().reference_table<CBDT> (face); |
827 | |
828 | upem = hb_face_get_upem (face); |
829 | } |
830 | ~accelerator_t () |
831 | { |
832 | this->cblc.destroy (); |
833 | this->cbdt.destroy (); |
834 | } |
835 | |
836 | bool |
837 | get_extents (hb_font_t *font, hb_codepoint_t glyph, hb_glyph_extents_t *extents, bool scale = true) const |
838 | { |
839 | const void *base; |
840 | const BitmapSizeTable &strike = this->cblc->choose_strike (font); |
841 | const IndexSubtableRecord *subtable_record = strike.find_table (glyph, cblc, &base); |
842 | if (!subtable_record || !strike.ppemX || !strike.ppemY) |
843 | return false; |
844 | |
845 | if (subtable_record->get_extents (extents, base, scale)) |
846 | return true; |
847 | |
848 | unsigned int image_offset = 0, image_length = 0, image_format = 0; |
849 | if (!subtable_record->get_image_data (glyph, base, &image_offset, &image_length, &image_format)) |
850 | return false; |
851 | |
852 | unsigned int cbdt_len = cbdt.get_length (); |
853 | if (unlikely (image_offset > cbdt_len || cbdt_len - image_offset < image_length)) |
854 | return false; |
855 | |
856 | switch (image_format) |
857 | { |
858 | case 17: { |
859 | if (unlikely (image_length < GlyphBitmapDataFormat17::min_size)) |
860 | return false; |
861 | auto &glyphFormat17 = StructAtOffset<GlyphBitmapDataFormat17> (this->cbdt, image_offset); |
862 | glyphFormat17.glyphMetrics.get_extents (font, extents, scale); |
863 | break; |
864 | } |
865 | case 18: { |
866 | if (unlikely (image_length < GlyphBitmapDataFormat18::min_size)) |
867 | return false; |
868 | auto &glyphFormat18 = StructAtOffset<GlyphBitmapDataFormat18> (this->cbdt, image_offset); |
869 | glyphFormat18.glyphMetrics.get_extents (font, extents, scale); |
870 | break; |
871 | } |
872 | default: return false; /* TODO: Support other image formats. */ |
873 | } |
874 | |
875 | /* Convert to font units. */ |
876 | if (scale) |
877 | { |
878 | float x_scale = upem / (float) strike.ppemX; |
879 | float y_scale = upem / (float) strike.ppemY; |
880 | extents->x_bearing = roundf (extents->x_bearing * x_scale); |
881 | extents->y_bearing = roundf (extents->y_bearing * y_scale); |
882 | extents->width = roundf (extents->width * x_scale); |
883 | extents->height = roundf (extents->height * y_scale); |
884 | } |
885 | |
886 | return true; |
887 | } |
888 | |
889 | hb_blob_t* |
890 | reference_png (hb_font_t *font, hb_codepoint_t glyph) const |
891 | { |
892 | const void *base; |
893 | const BitmapSizeTable &strike = this->cblc->choose_strike (font); |
894 | const IndexSubtableRecord *subtable_record = strike.find_table (glyph, cblc, &base); |
895 | if (!subtable_record || !strike.ppemX || !strike.ppemY) |
896 | return hb_blob_get_empty (); |
897 | |
898 | unsigned int image_offset = 0, image_length = 0, image_format = 0; |
899 | if (!subtable_record->get_image_data (glyph, base, &image_offset, &image_length, &image_format)) |
900 | return hb_blob_get_empty (); |
901 | |
902 | unsigned int cbdt_len = cbdt.get_length (); |
903 | if (unlikely (image_offset > cbdt_len || cbdt_len - image_offset < image_length)) |
904 | return hb_blob_get_empty (); |
905 | |
906 | switch (image_format) |
907 | { |
908 | case 17: |
909 | { |
910 | if (unlikely (image_length < GlyphBitmapDataFormat17::min_size)) |
911 | return hb_blob_get_empty (); |
912 | auto &glyphFormat17 = StructAtOffset<GlyphBitmapDataFormat17> (this->cbdt, image_offset); |
913 | return hb_blob_create_sub_blob (cbdt.get_blob (), |
914 | image_offset + GlyphBitmapDataFormat17::min_size, |
915 | glyphFormat17.data.len); |
916 | } |
917 | case 18: |
918 | { |
919 | if (unlikely (image_length < GlyphBitmapDataFormat18::min_size)) |
920 | return hb_blob_get_empty (); |
921 | auto &glyphFormat18 = StructAtOffset<GlyphBitmapDataFormat18> (this->cbdt, image_offset); |
922 | return hb_blob_create_sub_blob (cbdt.get_blob (), |
923 | image_offset + GlyphBitmapDataFormat18::min_size, |
924 | glyphFormat18.data.len); |
925 | } |
926 | case 19: |
927 | { |
928 | if (unlikely (image_length < GlyphBitmapDataFormat19::min_size)) |
929 | return hb_blob_get_empty (); |
930 | auto &glyphFormat19 = StructAtOffset<GlyphBitmapDataFormat19> (this->cbdt, image_offset); |
931 | return hb_blob_create_sub_blob (cbdt.get_blob (), |
932 | image_offset + GlyphBitmapDataFormat19::min_size, |
933 | glyphFormat19.data.len); |
934 | } |
935 | default: return hb_blob_get_empty (); /* TODO: Support other image formats. */ |
936 | } |
937 | } |
938 | |
939 | bool has_data () const { return cbdt.get_length (); } |
940 | |
941 | bool paint_glyph (hb_font_t *font, hb_codepoint_t glyph, hb_paint_funcs_t *funcs, void *data) const |
942 | { |
943 | hb_glyph_extents_t extents; |
944 | hb_glyph_extents_t pixel_extents; |
945 | hb_blob_t *blob = reference_png (font, glyph); |
946 | |
947 | if (unlikely (blob == hb_blob_get_empty ())) |
948 | return false; |
949 | |
950 | if (unlikely (!hb_font_get_glyph_extents (font, glyph, &extents))) |
951 | return false; |
952 | |
953 | if (unlikely (!get_extents (font, glyph, &pixel_extents, false))) |
954 | return false; |
955 | |
956 | bool ret = funcs->image (data, |
957 | blob, |
958 | pixel_extents.width, -pixel_extents.height, |
959 | HB_PAINT_IMAGE_FORMAT_PNG, |
960 | font->slant_xy, |
961 | &extents); |
962 | |
963 | hb_blob_destroy (blob); |
964 | return ret; |
965 | } |
966 | |
967 | private: |
968 | hb_blob_ptr_t<CBLC> cblc; |
969 | hb_blob_ptr_t<CBDT> cbdt; |
970 | |
971 | unsigned int upem; |
972 | }; |
973 | |
974 | bool sanitize (hb_sanitize_context_t *c) const |
975 | { |
976 | TRACE_SANITIZE (this); |
977 | return_trace (c->check_struct (this) && |
978 | likely (version.major == 2 || version.major == 3)); |
979 | } |
980 | |
981 | protected: |
982 | FixedVersion<> version; |
983 | UnsizedArrayOf<HBUINT8> dataZ; |
984 | public: |
985 | DEFINE_SIZE_ARRAY (4, dataZ); |
986 | }; |
987 | |
988 | inline bool |
989 | CBLC::subset (hb_subset_context_t *c) const |
990 | { |
991 | TRACE_SUBSET (this); |
992 | |
993 | // Use a vector as a secondary buffer as the tables need to be built in parallel. |
994 | hb_vector_t<char> cbdt_prime; |
995 | |
996 | auto *cblc_prime = c->serializer->start_embed<CBLC> (); |
997 | if (unlikely (!c->serializer->extend_min (cblc_prime))) return_trace (false); |
998 | cblc_prime->version = version; |
999 | |
1000 | hb_blob_t* cbdt_blob = hb_sanitize_context_t ().reference_table<CBDT> (c->plan->source); |
1001 | unsigned int cbdt_length; |
1002 | CBDT* cbdt = (CBDT *) hb_blob_get_data (cbdt_blob, &cbdt_length); |
1003 | if (unlikely (cbdt_length < CBDT::min_size)) |
1004 | { |
1005 | hb_blob_destroy (cbdt_blob); |
1006 | return_trace (false); |
1007 | } |
1008 | _copy_data_to_cbdt (&cbdt_prime, cbdt, CBDT::min_size); |
1009 | |
1010 | for (const BitmapSizeTable& table : + sizeTables.iter ()) |
1011 | subset_size_table (c, table, (const char *) cbdt, cbdt_length, cblc_prime, &cbdt_prime); |
1012 | |
1013 | hb_blob_destroy (cbdt_blob); |
1014 | |
1015 | return_trace (CBLC::sink_cbdt (c, &cbdt_prime)); |
1016 | } |
1017 | |
1018 | struct CBDT_accelerator_t : CBDT::accelerator_t { |
1019 | CBDT_accelerator_t (hb_face_t *face) : CBDT::accelerator_t (face) {} |
1020 | }; |
1021 | |
1022 | |
1023 | } /* namespace OT */ |
1024 | |
1025 | #endif /* OT_COLOR_CBDT_CBDT_HH */ |
1026 | |