1 /*
2 * Copyright © 2018 Adobe 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 * Adobe Author(s): Michiharu Ariza
25 */
26 #ifndef HB_OT_CFF_COMMON_HH
27 #define HB_OT_CFF_COMMON_HH
28
29 #include "hb-open-type.hh"
30 #include "hb-bimap.hh"
31 #include "hb-ot-layout-common.hh"
32 #include "hb-cff-interp-dict-common.hh"
33 #include "hb-subset-plan.hh"
34
35 namespace CFF {
36
37 using namespace OT;
38
39 #define CFF_UNDEF_CODE 0xFFFFFFFF
40
41 using objidx_t = hb_serialize_context_t::objidx_t;
42 using whence_t = hb_serialize_context_t::whence_t;
43
44 /* utility macro */
45 template<typename Type>
StructAtOffsetOrNull(const void * P,unsigned int offset)46 static inline const Type& StructAtOffsetOrNull (const void *P, unsigned int offset)
47 { return offset ? StructAtOffset<Type> (P, offset) : Null (Type); }
48
calcOffSize(unsigned int dataSize)49 inline unsigned int calcOffSize (unsigned int dataSize)
50 {
51 unsigned int size = 1;
52 unsigned int offset = dataSize + 1;
53 while (offset & ~0xFF)
54 {
55 size++;
56 offset >>= 8;
57 }
58 /* format does not support size > 4; caller should handle it as an error */
59 return size;
60 }
61
62 struct code_pair_t
63 {
64 hb_codepoint_t code;
65 hb_codepoint_t glyph;
66 };
67
68 typedef hb_vector_t<unsigned char> str_buff_t;
69 struct str_buff_vec_t : hb_vector_t<str_buff_t>
70 {
finiCFF::str_buff_vec_t71 void fini () { SUPER::fini_deep (); }
72
total_sizeCFF::str_buff_vec_t73 unsigned int total_size () const
74 {
75 unsigned int size = 0;
76 for (unsigned int i = 0; i < length; i++)
77 size += (*this)[i].length;
78 return size;
79 }
80
81 private:
82 typedef hb_vector_t<str_buff_t> SUPER;
83 };
84
85 /* CFF INDEX */
86 template <typename COUNT>
87 struct CFFIndex
88 {
calculate_offset_array_sizeCFF::CFFIndex89 static unsigned int calculate_offset_array_size (unsigned int offSize, unsigned int count)
90 { return offSize * (count + 1); }
91
offset_array_sizeCFF::CFFIndex92 unsigned int offset_array_size () const
93 { return calculate_offset_array_size (offSize, count); }
94
copyCFF::CFFIndex95 CFFIndex *copy (hb_serialize_context_t *c) const
96 {
97 TRACE_SERIALIZE (this);
98 unsigned int size = get_size ();
99 CFFIndex *out = c->allocate_size<CFFIndex> (size);
100 if (likely (out))
101 memcpy (out, this, size);
102 return_trace (out);
103 }
104
serializeCFF::CFFIndex105 bool serialize (hb_serialize_context_t *c, const CFFIndex &src)
106 {
107 TRACE_SERIALIZE (this);
108 unsigned int size = src.get_size ();
109 CFFIndex *dest = c->allocate_size<CFFIndex> (size);
110 if (unlikely (!dest)) return_trace (false);
111 memcpy (dest, &src, size);
112 return_trace (true);
113 }
114
serializeCFF::CFFIndex115 bool serialize (hb_serialize_context_t *c,
116 unsigned int offSize_,
117 const byte_str_array_t &byteArray)
118 {
119 TRACE_SERIALIZE (this);
120 if (byteArray.length == 0)
121 {
122 COUNT *dest = c->allocate_min<COUNT> ();
123 if (unlikely (!dest)) return_trace (false);
124 *dest = 0;
125 }
126 else
127 {
128 /* serialize CFFIndex header */
129 if (unlikely (!c->extend_min (this))) return_trace (false);
130 this->count = byteArray.length;
131 this->offSize = offSize_;
132 if (unlikely (!c->allocate_size<HBUINT8> (offSize_ * (byteArray.length + 1))))
133 return_trace (false);
134
135 /* serialize indices */
136 unsigned int offset = 1;
137 unsigned int i = 0;
138 for (; i < byteArray.length; i++)
139 {
140 set_offset_at (i, offset);
141 offset += byteArray[i].get_size ();
142 }
143 set_offset_at (i, offset);
144
145 /* serialize data */
146 for (unsigned int i = 0; i < byteArray.length; i++)
147 {
148 const byte_str_t &bs = byteArray[i];
149 unsigned char *dest = c->allocate_size<unsigned char> (bs.length);
150 if (unlikely (!dest)) return_trace (false);
151 memcpy (dest, &bs[0], bs.length);
152 }
153 }
154 return_trace (true);
155 }
156
serializeCFF::CFFIndex157 bool serialize (hb_serialize_context_t *c,
158 unsigned int offSize_,
159 const str_buff_vec_t &buffArray)
160 {
161 byte_str_array_t byteArray;
162 byteArray.init ();
163 byteArray.resize (buffArray.length);
164 for (unsigned int i = 0; i < byteArray.length; i++)
165 byteArray[i] = byte_str_t (buffArray[i].arrayZ, buffArray[i].length);
166 bool result = this->serialize (c, offSize_, byteArray);
167 byteArray.fini ();
168 return result;
169 }
170
171 template <typename Iterator,
172 hb_requires (hb_is_iterator (Iterator))>
serializeCFF::CFFIndex173 bool serialize (hb_serialize_context_t *c,
174 Iterator it)
175 {
176 TRACE_SERIALIZE (this);
177 if (it.len () == 0)
178 {
179 COUNT *dest = c->allocate_min<COUNT> ();
180 if (unlikely (!dest)) return_trace (false);
181 *dest = 0;
182 }
183 else
184 {
185 serialize_header(c, + it | hb_map ([] (const byte_str_t &_) { return _.length; }));
186 for (const auto &_ : +it)
187 _.copy (c);
188 }
189 return_trace (true);
190 }
191
serializeCFF::CFFIndex192 bool serialize (hb_serialize_context_t *c,
193 const byte_str_array_t &byteArray)
194 { return serialize (c, + hb_iter (byteArray)); }
195
serializeCFF::CFFIndex196 bool serialize (hb_serialize_context_t *c,
197 const str_buff_vec_t &buffArray)
198 {
199 auto it =
200 + hb_iter (buffArray)
201 | hb_map ([] (const str_buff_t &_) { return byte_str_t (_.arrayZ, _.length); })
202 ;
203 return serialize (c, it);
204 }
205
206 template <typename Iterator,
207 hb_requires (hb_is_iterator (Iterator))>
serialize_headerCFF::CFFIndex208 bool serialize_header (hb_serialize_context_t *c,
209 Iterator it)
210 {
211 TRACE_SERIALIZE (this);
212
213 unsigned total = + it | hb_reduce (hb_add, 0);
214 unsigned off_size = calcOffSize (total);
215
216 /* serialize CFFIndex header */
217 if (unlikely (!c->extend_min (this))) return_trace (false);
218 this->count = it.len ();
219 this->offSize = off_size;
220 if (unlikely (!c->allocate_size<HBUINT8> (off_size * (it.len () + 1))))
221 return_trace (false);
222
223 /* serialize indices */
224 unsigned int offset = 1;
225 unsigned int i = 0;
226 for (unsigned _ : +it)
227 {
228 CFFIndex<COUNT>::set_offset_at (i++, offset);
229 offset += _;
230 }
231 CFFIndex<COUNT>::set_offset_at (i, offset);
232
233 return_trace (true);
234 }
235
set_offset_atCFF::CFFIndex236 void set_offset_at (unsigned int index, unsigned int offset)
237 {
238 HBUINT8 *p = offsets + offSize * index + offSize;
239 unsigned int size = offSize;
240 for (; size; size--)
241 {
242 --p;
243 *p = offset & 0xFF;
244 offset >>= 8;
245 }
246 }
247
offset_atCFF::CFFIndex248 unsigned int offset_at (unsigned int index) const
249 {
250 assert (index <= count);
251 const HBUINT8 *p = offsets + offSize * index;
252 unsigned int size = offSize;
253 unsigned int offset = 0;
254 for (; size; size--)
255 offset = (offset << 8) + *p++;
256 return offset;
257 }
258
length_atCFF::CFFIndex259 unsigned int length_at (unsigned int index) const
260 {
261 if (unlikely ((offset_at (index + 1) < offset_at (index)) ||
262 (offset_at (index + 1) > offset_at (count))))
263 return 0;
264 return offset_at (index + 1) - offset_at (index);
265 }
266
data_baseCFF::CFFIndex267 const unsigned char *data_base () const
268 { return (const unsigned char *) this + min_size + offset_array_size (); }
269
data_sizeCFF::CFFIndex270 unsigned int data_size () const { return HBINT8::static_size; }
271
operator []CFF::CFFIndex272 byte_str_t operator [] (unsigned int index) const
273 {
274 if (unlikely (index >= count)) return Null (byte_str_t);
275 return byte_str_t (data_base () + offset_at (index) - 1, length_at (index));
276 }
277
get_sizeCFF::CFFIndex278 unsigned int get_size () const
279 {
280 if (this == &Null (CFFIndex)) return 0;
281 if (count > 0)
282 return min_size + offset_array_size () + (offset_at (count) - 1);
283 return count.static_size; /* empty CFFIndex contains count only */
284 }
285
sanitizeCFF::CFFIndex286 bool sanitize (hb_sanitize_context_t *c) const
287 {
288 TRACE_SANITIZE (this);
289 return_trace (likely ((c->check_struct (this) && count == 0) || /* empty INDEX */
290 (c->check_struct (this) && offSize >= 1 && offSize <= 4 &&
291 c->check_array (offsets, offSize, count + 1) &&
292 c->check_array ((const HBUINT8*) data_base (), 1, max_offset () - 1))));
293 }
294
295 protected:
max_offsetCFF::CFFIndex296 unsigned int max_offset () const
297 {
298 unsigned int max = 0;
299 for (unsigned int i = 0; i < count + 1u; i++)
300 {
301 unsigned int off = offset_at (i);
302 if (off > max) max = off;
303 }
304 return max;
305 }
306
307 public:
308 COUNT count; /* Number of object data. Note there are (count+1) offsets */
309 HBUINT8 offSize; /* The byte size of each offset in the offsets array. */
310 HBUINT8 offsets[HB_VAR_ARRAY];
311 /* The array of (count + 1) offsets into objects array (1-base). */
312 /* HBUINT8 data[HB_VAR_ARRAY]; Object data */
313 public:
314 DEFINE_SIZE_ARRAY (COUNT::static_size + HBUINT8::static_size, offsets);
315 };
316
317 template <typename COUNT, typename TYPE>
318 struct CFFIndexOf : CFFIndex<COUNT>
319 {
operator []CFF::CFFIndexOf320 const byte_str_t operator [] (unsigned int index) const
321 {
322 if (likely (index < CFFIndex<COUNT>::count))
323 return byte_str_t (CFFIndex<COUNT>::data_base () + CFFIndex<COUNT>::offset_at (index) - 1, CFFIndex<COUNT>::length_at (index));
324 return Null (byte_str_t);
325 }
326
327 template <typename DATA, typename PARAM1, typename PARAM2>
serializeCFF::CFFIndexOf328 bool serialize (hb_serialize_context_t *c,
329 unsigned int offSize_,
330 const DATA *dataArray,
331 unsigned int dataArrayLen,
332 const hb_vector_t<unsigned int> &dataSizeArray,
333 const PARAM1 ¶m1,
334 const PARAM2 ¶m2)
335 {
336 TRACE_SERIALIZE (this);
337 /* serialize CFFIndex header */
338 if (unlikely (!c->extend_min (this))) return_trace (false);
339 this->count = dataArrayLen;
340 this->offSize = offSize_;
341 if (unlikely (!c->allocate_size<HBUINT8> (offSize_ * (dataArrayLen + 1))))
342 return_trace (false);
343
344 /* serialize indices */
345 unsigned int offset = 1;
346 unsigned int i = 0;
347 for (; i < dataArrayLen; i++)
348 {
349 CFFIndex<COUNT>::set_offset_at (i, offset);
350 offset += dataSizeArray[i];
351 }
352 CFFIndex<COUNT>::set_offset_at (i, offset);
353
354 /* serialize data */
355 for (unsigned int i = 0; i < dataArrayLen; i++)
356 {
357 TYPE *dest = c->start_embed<TYPE> ();
358 if (unlikely (!dest || !dest->serialize (c, dataArray[i], param1, param2)))
359 return_trace (false);
360 }
361 return_trace (true);
362 }
363 };
364
365 /* Top Dict, Font Dict, Private Dict */
366 struct Dict : UnsizedByteStr
367 {
368 template <typename DICTVAL, typename OP_SERIALIZER, typename ...Ts>
serializeCFF::Dict369 bool serialize (hb_serialize_context_t *c,
370 const DICTVAL &dictval,
371 OP_SERIALIZER& opszr,
372 Ts&&... ds)
373 {
374 TRACE_SERIALIZE (this);
375 for (unsigned int i = 0; i < dictval.get_count (); i++)
376 if (unlikely (!opszr.serialize (c, dictval[i], std::forward<Ts> (ds)...)))
377 return_trace (false);
378
379 return_trace (true);
380 }
381
382 template <typename T, typename V>
serialize_int_opCFF::Dict383 static bool serialize_int_op (hb_serialize_context_t *c, op_code_t op, V value, op_code_t intOp)
384 {
385 // XXX: not sure why but LLVM fails to compile the following 'unlikely' macro invocation
386 if (/*unlikely*/ (!serialize_int<T, V> (c, intOp, value)))
387 return false;
388
389 TRACE_SERIALIZE (this);
390 /* serialize the opcode */
391 HBUINT8 *p = c->allocate_size<HBUINT8> (OpCode_Size (op));
392 if (unlikely (!p)) return_trace (false);
393 if (Is_OpCode_ESC (op))
394 {
395 *p = OpCode_escape;
396 op = Unmake_OpCode_ESC (op);
397 p++;
398 }
399 *p = op;
400 return_trace (true);
401 }
402
403 template <typename V>
serialize_int4_opCFF::Dict404 static bool serialize_int4_op (hb_serialize_context_t *c, op_code_t op, V value)
405 { return serialize_int_op<HBINT32> (c, op, value, OpCode_longintdict); }
406
407 template <typename V>
serialize_int2_opCFF::Dict408 static bool serialize_int2_op (hb_serialize_context_t *c, op_code_t op, V value)
409 { return serialize_int_op<HBINT16> (c, op, value, OpCode_shortint); }
410
411 template <typename T, int int_op>
serialize_link_opCFF::Dict412 static bool serialize_link_op (hb_serialize_context_t *c, op_code_t op, objidx_t link, whence_t whence)
413 {
414 T &ofs = *(T *) (c->head + OpCode_Size (int_op));
415 if (unlikely (!serialize_int_op<T> (c, op, 0, int_op))) return false;
416 c->add_link (ofs, link, whence);
417 return true;
418 }
419
serialize_link4_opCFF::Dict420 static bool serialize_link4_op (hb_serialize_context_t *c, op_code_t op, objidx_t link, whence_t whence = whence_t::Head)
421 { return serialize_link_op<HBINT32, OpCode_longintdict> (c, op, link, whence); }
422
serialize_link2_opCFF::Dict423 static bool serialize_link2_op (hb_serialize_context_t *c, op_code_t op, objidx_t link, whence_t whence = whence_t::Head)
424 { return serialize_link_op<HBINT16, OpCode_shortint> (c, op, link, whence); }
425 };
426
427 struct TopDict : Dict {};
428 struct FontDict : Dict {};
429 struct PrivateDict : Dict {};
430
431 struct table_info_t
432 {
initCFF::table_info_t433 void init () { offset = size = 0; link = 0; }
434
435 unsigned int offset;
436 unsigned int size;
437 objidx_t link;
438 };
439
440 template <typename COUNT>
441 struct FDArray : CFFIndexOf<COUNT, FontDict>
442 {
443 template <typename DICTVAL, typename INFO, typename Iterator, typename OP_SERIALIZER>
serializeCFF::FDArray444 bool serialize (hb_serialize_context_t *c,
445 Iterator it,
446 OP_SERIALIZER& opszr)
447 {
448 TRACE_SERIALIZE (this);
449
450 /* serialize INDEX data */
451 hb_vector_t<unsigned> sizes;
452 c->push ();
453 + it
454 | hb_map ([&] (const hb_pair_t<const DICTVAL&, const INFO&> &_)
455 {
456 FontDict *dict = c->start_embed<FontDict> ();
457 dict->serialize (c, _.first, opszr, _.second);
458 return c->head - (const char*)dict;
459 })
460 | hb_sink (sizes)
461 ;
462 c->pop_pack (false);
463
464 /* serialize INDEX header */
465 return_trace (CFFIndex<COUNT>::serialize_header (c, hb_iter (sizes)));
466 }
467 };
468
469 /* FDSelect */
470 struct FDSelect0 {
sanitizeCFF::FDSelect0471 bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const
472 {
473 TRACE_SANITIZE (this);
474 if (unlikely (!(c->check_struct (this))))
475 return_trace (false);
476 for (unsigned int i = 0; i < c->get_num_glyphs (); i++)
477 if (unlikely (!fds[i].sanitize (c)))
478 return_trace (false);
479
480 return_trace (true);
481 }
482
get_fdCFF::FDSelect0483 hb_codepoint_t get_fd (hb_codepoint_t glyph) const
484 { return (hb_codepoint_t) fds[glyph]; }
485
get_sizeCFF::FDSelect0486 unsigned int get_size (unsigned int num_glyphs) const
487 { return HBUINT8::static_size * num_glyphs; }
488
489 HBUINT8 fds[HB_VAR_ARRAY];
490
491 DEFINE_SIZE_MIN (0);
492 };
493
494 template <typename GID_TYPE, typename FD_TYPE>
495 struct FDSelect3_4_Range
496 {
sanitizeCFF::FDSelect3_4_Range497 bool sanitize (hb_sanitize_context_t *c, const void * /*nullptr*/, unsigned int fdcount) const
498 {
499 TRACE_SANITIZE (this);
500 return_trace (first < c->get_num_glyphs () && (fd < fdcount));
501 }
502
503 GID_TYPE first;
504 FD_TYPE fd;
505 public:
506 DEFINE_SIZE_STATIC (GID_TYPE::static_size + FD_TYPE::static_size);
507 };
508
509 template <typename GID_TYPE, typename FD_TYPE>
510 struct FDSelect3_4
511 {
get_sizeCFF::FDSelect3_4512 unsigned int get_size () const
513 { return GID_TYPE::static_size * 2 + ranges.get_size (); }
514
sanitizeCFF::FDSelect3_4515 bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const
516 {
517 TRACE_SANITIZE (this);
518 if (unlikely (!c->check_struct (this) || !ranges.sanitize (c, nullptr, fdcount) ||
519 (nRanges () == 0) || ranges[0].first != 0))
520 return_trace (false);
521
522 for (unsigned int i = 1; i < nRanges (); i++)
523 if (unlikely (ranges[i - 1].first >= ranges[i].first))
524 return_trace (false);
525
526 if (unlikely (!sentinel().sanitize (c) || (sentinel() != c->get_num_glyphs ())))
527 return_trace (false);
528
529 return_trace (true);
530 }
531
get_fdCFF::FDSelect3_4532 hb_codepoint_t get_fd (hb_codepoint_t glyph) const
533 {
534 unsigned int i;
535 for (i = 1; i < nRanges (); i++)
536 if (glyph < ranges[i].first)
537 break;
538
539 return (hb_codepoint_t) ranges[i - 1].fd;
540 }
541
nRangesCFF::FDSelect3_4542 GID_TYPE &nRanges () { return ranges.len; }
nRangesCFF::FDSelect3_4543 GID_TYPE nRanges () const { return ranges.len; }
sentinelCFF::FDSelect3_4544 GID_TYPE &sentinel () { return StructAfter<GID_TYPE> (ranges[nRanges () - 1]); }
sentinelCFF::FDSelect3_4545 const GID_TYPE &sentinel () const { return StructAfter<GID_TYPE> (ranges[nRanges () - 1]); }
546
547 ArrayOf<FDSelect3_4_Range<GID_TYPE, FD_TYPE>, GID_TYPE> ranges;
548 /* GID_TYPE sentinel */
549
550 DEFINE_SIZE_ARRAY (GID_TYPE::static_size, ranges);
551 };
552
553 typedef FDSelect3_4<HBUINT16, HBUINT8> FDSelect3;
554 typedef FDSelect3_4_Range<HBUINT16, HBUINT8> FDSelect3_Range;
555
556 struct FDSelect
557 {
serializeCFF::FDSelect558 bool serialize (hb_serialize_context_t *c, const FDSelect &src, unsigned int num_glyphs)
559 {
560 TRACE_SERIALIZE (this);
561 unsigned int size = src.get_size (num_glyphs);
562 FDSelect *dest = c->allocate_size<FDSelect> (size);
563 if (unlikely (!dest)) return_trace (false);
564 memcpy (dest, &src, size);
565 return_trace (true);
566 }
567
get_sizeCFF::FDSelect568 unsigned int get_size (unsigned int num_glyphs) const
569 {
570 switch (format)
571 {
572 case 0: return format.static_size + u.format0.get_size (num_glyphs);
573 case 3: return format.static_size + u.format3.get_size ();
574 default:return 0;
575 }
576 }
577
get_fdCFF::FDSelect578 hb_codepoint_t get_fd (hb_codepoint_t glyph) const
579 {
580 if (this == &Null (FDSelect)) return 0;
581
582 switch (format)
583 {
584 case 0: return u.format0.get_fd (glyph);
585 case 3: return u.format3.get_fd (glyph);
586 default:return 0;
587 }
588 }
589
sanitizeCFF::FDSelect590 bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const
591 {
592 TRACE_SANITIZE (this);
593 if (unlikely (!c->check_struct (this)))
594 return_trace (false);
595
596 switch (format)
597 {
598 case 0: return_trace (u.format0.sanitize (c, fdcount));
599 case 3: return_trace (u.format3.sanitize (c, fdcount));
600 default:return_trace (false);
601 }
602 }
603
604 HBUINT8 format;
605 union {
606 FDSelect0 format0;
607 FDSelect3 format3;
608 } u;
609 public:
610 DEFINE_SIZE_MIN (1);
611 };
612
613 template <typename COUNT>
614 struct Subrs : CFFIndex<COUNT>
615 {
616 typedef COUNT count_type;
617 typedef CFFIndex<COUNT> SUPER;
618 };
619
620 } /* namespace CFF */
621
622 #endif /* HB_OT_CFF_COMMON_HH */
623