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
45namespace OT {
46
47struct 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
64static 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
76struct 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
104struct BigGlyphMetrics : SmallGlyphMetrics
105{
106 HBINT8 vertBearingX;
107 HBINT8 vertBearingY;
108 HBUINT8 vertAdvance;
109 public:
110 DEFINE_SIZE_STATIC (8);
111};
112
113struct 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
142struct IndexSubtableHeader
143{
144 bool sanitize (hb_sanitize_context_t *c) const
145 {
146 TRACE_SANITIZE (this);
147 return_trace (c->check_struct (this));
148 }
149
150 HBUINT16 indexFormat;
151 HBUINT16 imageFormat;
152 HBUINT32 imageDataOffset;
153 public:
154 DEFINE_SIZE_STATIC (8);
155};
156
157template <typename OffsetType>
158struct 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 header;
192 UnsizedArrayOf<Offset<OffsetType>>
193 offsetArrayZ;
194 public:
195 DEFINE_SIZE_ARRAY (8, offsetArrayZ);
196};
197
198struct IndexSubtableFormat1 : IndexSubtableFormat1Or3<HBUINT32> {};
199struct IndexSubtableFormat3 : IndexSubtableFormat1Or3<HBUINT16> {};
200
201struct 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 *header_prime = 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* get_header () const { return &u.header; }
338
339 void populate_header (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 header;
357 IndexSubtableFormat1 format1;
358 IndexSubtableFormat3 format3;
359 /* TODO: Format 2, 4, 5. */
360 } u;
361 public:
362 DEFINE_SIZE_UNION (8, header);
363};
364
365struct 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_header = 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_header = 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
531struct 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
629struct 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
708struct GlyphBitmapDataFormat17
709{
710 SmallGlyphMetrics glyphMetrics;
711 Array32Of<HBUINT8> data;
712 public:
713 DEFINE_SIZE_ARRAY (9, data);
714};
715
716struct GlyphBitmapDataFormat18
717{
718 BigGlyphMetrics glyphMetrics;
719 Array32Of<HBUINT8> data;
720 public:
721 DEFINE_SIZE_ARRAY (12, data);
722};
723
724struct GlyphBitmapDataFormat19
725{
726 Array32Of<HBUINT8> data;
727 public:
728 DEFINE_SIZE_ARRAY (4, data);
729};
730
731struct 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
817struct 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
988inline bool
989CBLC::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
1018struct 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