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 {
total_sizeCFF::str_buff_vec_t71 unsigned int total_size () const
72 {
73 unsigned int size = 0;
74 for (unsigned int i = 0; i < length; i++)
75 size += (*this)[i].length;
76 return size;
77 }
78
79 private:
80 typedef hb_vector_t<str_buff_t> SUPER;
81 };
82
83 /* CFF INDEX */
84 template <typename COUNT>
85 struct CFFIndex
86 {
calculate_offset_array_sizeCFF::CFFIndex87 static unsigned int calculate_offset_array_size (unsigned int offSize, unsigned int count)
88 { return offSize * (count + 1); }
89
offset_array_sizeCFF::CFFIndex90 unsigned int offset_array_size () const
91 { return calculate_offset_array_size (offSize, count); }
92
copyCFF::CFFIndex93 CFFIndex *copy (hb_serialize_context_t *c) const
94 {
95 TRACE_SERIALIZE (this);
96 unsigned int size = get_size ();
97 CFFIndex *out = c->allocate_size<CFFIndex> (size);
98 if (likely (out))
99 memcpy (out, this, size);
100 return_trace (out);
101 }
102
serializeCFF::CFFIndex103 bool serialize (hb_serialize_context_t *c, const CFFIndex &src)
104 {
105 TRACE_SERIALIZE (this);
106 unsigned int size = src.get_size ();
107 CFFIndex *dest = c->allocate_size<CFFIndex> (size);
108 if (unlikely (!dest)) return_trace (false);
109 memcpy (dest, &src, size);
110 return_trace (true);
111 }
112
serializeCFF::CFFIndex113 bool serialize (hb_serialize_context_t *c,
114 unsigned int offSize_,
115 const byte_str_array_t &byteArray)
116 {
117 TRACE_SERIALIZE (this);
118 if (byteArray.length == 0)
119 {
120 COUNT *dest = c->allocate_min<COUNT> ();
121 if (unlikely (!dest)) return_trace (false);
122 *dest = 0;
123 }
124 else
125 {
126 /* serialize CFFIndex header */
127 if (unlikely (!c->extend_min (this))) return_trace (false);
128 this->count = byteArray.length;
129 this->offSize = offSize_;
130 if (unlikely (!c->allocate_size<HBUINT8> (offSize_ * (byteArray.length + 1))))
131 return_trace (false);
132
133 /* serialize indices */
134 unsigned int offset = 1;
135 unsigned int i = 0;
136 for (; i < byteArray.length; i++)
137 {
138 set_offset_at (i, offset);
139 offset += byteArray[i].get_size ();
140 }
141 set_offset_at (i, offset);
142
143 /* serialize data */
144 for (unsigned int i = 0; i < byteArray.length; i++)
145 {
146 const byte_str_t &bs = byteArray[i];
147 unsigned char *dest = c->allocate_size<unsigned char> (bs.length);
148 if (unlikely (!dest)) return_trace (false);
149 memcpy (dest, &bs[0], bs.length);
150 }
151 }
152 return_trace (true);
153 }
154
serializeCFF::CFFIndex155 bool serialize (hb_serialize_context_t *c,
156 unsigned int offSize_,
157 const str_buff_vec_t &buffArray)
158 {
159 byte_str_array_t byteArray;
160 byteArray.init ();
161 byteArray.resize (buffArray.length);
162 for (unsigned int i = 0; i < byteArray.length; i++)
163 byteArray[i] = byte_str_t (buffArray[i].arrayZ, buffArray[i].length);
164 bool result = this->serialize (c, offSize_, byteArray);
165 byteArray.fini ();
166 return result;
167 }
168
169 template <typename Iterator,
170 hb_requires (hb_is_iterator (Iterator))>
serializeCFF::CFFIndex171 bool serialize (hb_serialize_context_t *c,
172 Iterator it)
173 {
174 TRACE_SERIALIZE (this);
175 if (it.len () == 0)
176 {
177 COUNT *dest = c->allocate_min<COUNT> ();
178 if (unlikely (!dest)) return_trace (false);
179 *dest = 0;
180 }
181 else
182 {
183 serialize_header(c, + it | hb_map ([] (const byte_str_t &_) { return _.length; }));
184 for (const auto &_ : +it)
185 _.copy (c);
186 }
187 return_trace (true);
188 }
189
serializeCFF::CFFIndex190 bool serialize (hb_serialize_context_t *c,
191 const byte_str_array_t &byteArray)
192 { return serialize (c, + hb_iter (byteArray)); }
193
serializeCFF::CFFIndex194 bool serialize (hb_serialize_context_t *c,
195 const str_buff_vec_t &buffArray)
196 {
197 auto it =
198 + hb_iter (buffArray)
199 | hb_map ([] (const str_buff_t &_) { return byte_str_t (_.arrayZ, _.length); })
200 ;
201 return serialize (c, it);
202 }
203
204 template <typename Iterator,
205 hb_requires (hb_is_iterator (Iterator))>
serialize_headerCFF::CFFIndex206 bool serialize_header (hb_serialize_context_t *c,
207 Iterator it)
208 {
209 TRACE_SERIALIZE (this);
210
211 unsigned total = + it | hb_reduce (hb_add, 0);
212 unsigned off_size = calcOffSize (total);
213
214 /* serialize CFFIndex header */
215 if (unlikely (!c->extend_min (this))) return_trace (false);
216 this->count = it.len ();
217 this->offSize = off_size;
218 if (unlikely (!c->allocate_size<HBUINT8> (off_size * (it.len () + 1))))
219 return_trace (false);
220
221 /* serialize indices */
222 unsigned int offset = 1;
223 unsigned int i = 0;
224 for (unsigned _ : +it)
225 {
226 CFFIndex<COUNT>::set_offset_at (i++, offset);
227 offset += _;
228 }
229 CFFIndex<COUNT>::set_offset_at (i, offset);
230
231 return_trace (true);
232 }
233
set_offset_atCFF::CFFIndex234 void set_offset_at (unsigned int index, unsigned int offset)
235 {
236 HBUINT8 *p = offsets + offSize * index + offSize;
237 unsigned int size = offSize;
238 for (; size; size--)
239 {
240 --p;
241 *p = offset & 0xFF;
242 offset >>= 8;
243 }
244 }
245
offset_atCFF::CFFIndex246 unsigned int offset_at (unsigned int index) const
247 {
248 assert (index <= count);
249 const HBUINT8 *p = offsets + offSize * index;
250 unsigned int size = offSize;
251 unsigned int offset = 0;
252 for (; size; size--)
253 offset = (offset << 8) + *p++;
254 return offset;
255 }
256
length_atCFF::CFFIndex257 unsigned int length_at (unsigned int index) const
258 {
259 if (unlikely ((offset_at (index + 1) < offset_at (index)) ||
260 (offset_at (index + 1) > offset_at (count))))
261 return 0;
262 return offset_at (index + 1) - offset_at (index);
263 }
264
data_baseCFF::CFFIndex265 const unsigned char *data_base () const
266 { return (const unsigned char *) this + min_size + offset_array_size (); }
267
data_sizeCFF::CFFIndex268 unsigned int data_size () const { return HBINT8::static_size; }
269
operator []CFF::CFFIndex270 byte_str_t operator [] (unsigned int index) const
271 {
272 if (unlikely (index >= count)) return Null (byte_str_t);
273 return byte_str_t (data_base () + offset_at (index) - 1, length_at (index));
274 }
275
get_sizeCFF::CFFIndex276 unsigned int get_size () const
277 {
278 if (this == &Null (CFFIndex)) return 0;
279 if (count > 0)
280 return min_size + offset_array_size () + (offset_at (count) - 1);
281 return count.static_size; /* empty CFFIndex contains count only */
282 }
283
sanitizeCFF::CFFIndex284 bool sanitize (hb_sanitize_context_t *c) const
285 {
286 TRACE_SANITIZE (this);
287 return_trace (likely ((c->check_struct (this) && count == 0) || /* empty INDEX */
288 (c->check_struct (this) && offSize >= 1 && offSize <= 4 &&
289 c->check_array (offsets, offSize, count + 1) &&
290 c->check_array ((const HBUINT8*) data_base (), 1, max_offset () - 1))));
291 }
292
293 protected:
max_offsetCFF::CFFIndex294 unsigned int max_offset () const
295 {
296 unsigned int max = 0;
297 for (unsigned int i = 0; i < count + 1u; i++)
298 {
299 unsigned int off = offset_at (i);
300 if (off > max) max = off;
301 }
302 return max;
303 }
304
305 public:
306 COUNT count; /* Number of object data. Note there are (count+1) offsets */
307 HBUINT8 offSize; /* The byte size of each offset in the offsets array. */
308 HBUINT8 offsets[HB_VAR_ARRAY];
309 /* The array of (count + 1) offsets into objects array (1-base). */
310 /* HBUINT8 data[HB_VAR_ARRAY]; Object data */
311 public:
312 DEFINE_SIZE_ARRAY (COUNT::static_size + HBUINT8::static_size, offsets);
313 };
314
315 template <typename COUNT, typename TYPE>
316 struct CFFIndexOf : CFFIndex<COUNT>
317 {
operator []CFF::CFFIndexOf318 const byte_str_t operator [] (unsigned int index) const
319 {
320 if (likely (index < CFFIndex<COUNT>::count))
321 return byte_str_t (CFFIndex<COUNT>::data_base () + CFFIndex<COUNT>::offset_at (index) - 1, CFFIndex<COUNT>::length_at (index));
322 return Null (byte_str_t);
323 }
324
325 template <typename DATA, typename PARAM1, typename PARAM2>
serializeCFF::CFFIndexOf326 bool serialize (hb_serialize_context_t *c,
327 unsigned int offSize_,
328 const DATA *dataArray,
329 unsigned int dataArrayLen,
330 const hb_vector_t<unsigned int> &dataSizeArray,
331 const PARAM1 ¶m1,
332 const PARAM2 ¶m2)
333 {
334 TRACE_SERIALIZE (this);
335 /* serialize CFFIndex header */
336 if (unlikely (!c->extend_min (this))) return_trace (false);
337 this->count = dataArrayLen;
338 this->offSize = offSize_;
339 if (unlikely (!c->allocate_size<HBUINT8> (offSize_ * (dataArrayLen + 1))))
340 return_trace (false);
341
342 /* serialize indices */
343 unsigned int offset = 1;
344 unsigned int i = 0;
345 for (; i < dataArrayLen; i++)
346 {
347 CFFIndex<COUNT>::set_offset_at (i, offset);
348 offset += dataSizeArray[i];
349 }
350 CFFIndex<COUNT>::set_offset_at (i, offset);
351
352 /* serialize data */
353 for (unsigned int i = 0; i < dataArrayLen; i++)
354 {
355 TYPE *dest = c->start_embed<TYPE> ();
356 if (unlikely (!dest || !dest->serialize (c, dataArray[i], param1, param2)))
357 return_trace (false);
358 }
359 return_trace (true);
360 }
361 };
362
363 /* Top Dict, Font Dict, Private Dict */
364 struct Dict : UnsizedByteStr
365 {
366 template <typename DICTVAL, typename OP_SERIALIZER, typename ...Ts>
serializeCFF::Dict367 bool serialize (hb_serialize_context_t *c,
368 const DICTVAL &dictval,
369 OP_SERIALIZER& opszr,
370 Ts&&... ds)
371 {
372 TRACE_SERIALIZE (this);
373 for (unsigned int i = 0; i < dictval.get_count (); i++)
374 if (unlikely (!opszr.serialize (c, dictval[i], std::forward<Ts> (ds)...)))
375 return_trace (false);
376
377 return_trace (true);
378 }
379
380 template <typename T, typename V>
serialize_int_opCFF::Dict381 static bool serialize_int_op (hb_serialize_context_t *c, op_code_t op, V value, op_code_t intOp)
382 {
383 // XXX: not sure why but LLVM fails to compile the following 'unlikely' macro invocation
384 if (/*unlikely*/ (!serialize_int<T, V> (c, intOp, value)))
385 return false;
386
387 TRACE_SERIALIZE (this);
388 /* serialize the opcode */
389 HBUINT8 *p = c->allocate_size<HBUINT8> (OpCode_Size (op));
390 if (unlikely (!p)) return_trace (false);
391 if (Is_OpCode_ESC (op))
392 {
393 *p = OpCode_escape;
394 op = Unmake_OpCode_ESC (op);
395 p++;
396 }
397 *p = op;
398 return_trace (true);
399 }
400
401 template <typename V>
serialize_int4_opCFF::Dict402 static bool serialize_int4_op (hb_serialize_context_t *c, op_code_t op, V value)
403 { return serialize_int_op<HBINT32> (c, op, value, OpCode_longintdict); }
404
405 template <typename V>
serialize_int2_opCFF::Dict406 static bool serialize_int2_op (hb_serialize_context_t *c, op_code_t op, V value)
407 { return serialize_int_op<HBINT16> (c, op, value, OpCode_shortint); }
408
409 template <typename T, int int_op>
serialize_link_opCFF::Dict410 static bool serialize_link_op (hb_serialize_context_t *c, op_code_t op, objidx_t link, whence_t whence)
411 {
412 T &ofs = *(T *) (c->head + OpCode_Size (int_op));
413 if (unlikely (!serialize_int_op<T> (c, op, 0, int_op))) return false;
414 c->add_link (ofs, link, whence);
415 return true;
416 }
417
serialize_link4_opCFF::Dict418 static bool serialize_link4_op (hb_serialize_context_t *c, op_code_t op, objidx_t link, whence_t whence = whence_t::Head)
419 { return serialize_link_op<HBINT32, OpCode_longintdict> (c, op, link, whence); }
420
serialize_link2_opCFF::Dict421 static bool serialize_link2_op (hb_serialize_context_t *c, op_code_t op, objidx_t link, whence_t whence = whence_t::Head)
422 { return serialize_link_op<HBINT16, OpCode_shortint> (c, op, link, whence); }
423 };
424
425 struct TopDict : Dict {};
426 struct FontDict : Dict {};
427 struct PrivateDict : Dict {};
428
429 struct table_info_t
430 {
initCFF::table_info_t431 void init () { offset = size = 0; link = 0; }
432
433 unsigned int offset;
434 unsigned int size;
435 objidx_t link;
436 };
437
438 template <typename COUNT>
439 struct FDArray : CFFIndexOf<COUNT, FontDict>
440 {
441 template <typename DICTVAL, typename INFO, typename Iterator, typename OP_SERIALIZER>
serializeCFF::FDArray442 bool serialize (hb_serialize_context_t *c,
443 Iterator it,
444 OP_SERIALIZER& opszr)
445 {
446 TRACE_SERIALIZE (this);
447
448 /* serialize INDEX data */
449 hb_vector_t<unsigned> sizes;
450 c->push ();
451 + it
452 | hb_map ([&] (const hb_pair_t<const DICTVAL&, const INFO&> &_)
453 {
454 FontDict *dict = c->start_embed<FontDict> ();
455 dict->serialize (c, _.first, opszr, _.second);
456 return c->head - (const char*)dict;
457 })
458 | hb_sink (sizes)
459 ;
460 c->pop_pack (false);
461
462 /* serialize INDEX header */
463 return_trace (CFFIndex<COUNT>::serialize_header (c, hb_iter (sizes)));
464 }
465 };
466
467 /* FDSelect */
468 struct FDSelect0 {
sanitizeCFF::FDSelect0469 bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const
470 {
471 TRACE_SANITIZE (this);
472 if (unlikely (!(c->check_struct (this))))
473 return_trace (false);
474 for (unsigned int i = 0; i < c->get_num_glyphs (); i++)
475 if (unlikely (!fds[i].sanitize (c)))
476 return_trace (false);
477
478 return_trace (true);
479 }
480
get_fdCFF::FDSelect0481 hb_codepoint_t get_fd (hb_codepoint_t glyph) const
482 { return (hb_codepoint_t) fds[glyph]; }
483
get_sizeCFF::FDSelect0484 unsigned int get_size (unsigned int num_glyphs) const
485 { return HBUINT8::static_size * num_glyphs; }
486
487 HBUINT8 fds[HB_VAR_ARRAY];
488
489 DEFINE_SIZE_MIN (0);
490 };
491
492 template <typename GID_TYPE, typename FD_TYPE>
493 struct FDSelect3_4_Range
494 {
sanitizeCFF::FDSelect3_4_Range495 bool sanitize (hb_sanitize_context_t *c, const void * /*nullptr*/, unsigned int fdcount) const
496 {
497 TRACE_SANITIZE (this);
498 return_trace (first < c->get_num_glyphs () && (fd < fdcount));
499 }
500
501 GID_TYPE first;
502 FD_TYPE fd;
503 public:
504 DEFINE_SIZE_STATIC (GID_TYPE::static_size + FD_TYPE::static_size);
505 };
506
507 template <typename GID_TYPE, typename FD_TYPE>
508 struct FDSelect3_4
509 {
get_sizeCFF::FDSelect3_4510 unsigned int get_size () const
511 { return GID_TYPE::static_size * 2 + ranges.get_size (); }
512
sanitizeCFF::FDSelect3_4513 bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const
514 {
515 TRACE_SANITIZE (this);
516 if (unlikely (!c->check_struct (this) || !ranges.sanitize (c, nullptr, fdcount) ||
517 (nRanges () == 0) || ranges[0].first != 0))
518 return_trace (false);
519
520 for (unsigned int i = 1; i < nRanges (); i++)
521 if (unlikely (ranges[i - 1].first >= ranges[i].first))
522 return_trace (false);
523
524 if (unlikely (!sentinel().sanitize (c) || (sentinel() != c->get_num_glyphs ())))
525 return_trace (false);
526
527 return_trace (true);
528 }
529
get_fdCFF::FDSelect3_4530 hb_codepoint_t get_fd (hb_codepoint_t glyph) const
531 {
532 unsigned int i;
533 for (i = 1; i < nRanges (); i++)
534 if (glyph < ranges[i].first)
535 break;
536
537 return (hb_codepoint_t) ranges[i - 1].fd;
538 }
539
nRangesCFF::FDSelect3_4540 GID_TYPE &nRanges () { return ranges.len; }
nRangesCFF::FDSelect3_4541 GID_TYPE nRanges () const { return ranges.len; }
sentinelCFF::FDSelect3_4542 GID_TYPE &sentinel () { return StructAfter<GID_TYPE> (ranges[nRanges () - 1]); }
sentinelCFF::FDSelect3_4543 const GID_TYPE &sentinel () const { return StructAfter<GID_TYPE> (ranges[nRanges () - 1]); }
544
545 ArrayOf<FDSelect3_4_Range<GID_TYPE, FD_TYPE>, GID_TYPE> ranges;
546 /* GID_TYPE sentinel */
547
548 DEFINE_SIZE_ARRAY (GID_TYPE::static_size, ranges);
549 };
550
551 typedef FDSelect3_4<HBUINT16, HBUINT8> FDSelect3;
552 typedef FDSelect3_4_Range<HBUINT16, HBUINT8> FDSelect3_Range;
553
554 struct FDSelect
555 {
serializeCFF::FDSelect556 bool serialize (hb_serialize_context_t *c, const FDSelect &src, unsigned int num_glyphs)
557 {
558 TRACE_SERIALIZE (this);
559 unsigned int size = src.get_size (num_glyphs);
560 FDSelect *dest = c->allocate_size<FDSelect> (size);
561 if (unlikely (!dest)) return_trace (false);
562 memcpy (dest, &src, size);
563 return_trace (true);
564 }
565
get_sizeCFF::FDSelect566 unsigned int get_size (unsigned int num_glyphs) const
567 {
568 switch (format)
569 {
570 case 0: return format.static_size + u.format0.get_size (num_glyphs);
571 case 3: return format.static_size + u.format3.get_size ();
572 default:return 0;
573 }
574 }
575
get_fdCFF::FDSelect576 hb_codepoint_t get_fd (hb_codepoint_t glyph) const
577 {
578 if (this == &Null (FDSelect)) return 0;
579
580 switch (format)
581 {
582 case 0: return u.format0.get_fd (glyph);
583 case 3: return u.format3.get_fd (glyph);
584 default:return 0;
585 }
586 }
587
sanitizeCFF::FDSelect588 bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const
589 {
590 TRACE_SANITIZE (this);
591 if (unlikely (!c->check_struct (this)))
592 return_trace (false);
593
594 switch (format)
595 {
596 case 0: return_trace (u.format0.sanitize (c, fdcount));
597 case 3: return_trace (u.format3.sanitize (c, fdcount));
598 default:return_trace (false);
599 }
600 }
601
602 HBUINT8 format;
603 union {
604 FDSelect0 format0;
605 FDSelect3 format3;
606 } u;
607 public:
608 DEFINE_SIZE_MIN (1);
609 };
610
611 template <typename COUNT>
612 struct Subrs : CFFIndex<COUNT>
613 {
614 typedef COUNT count_type;
615 typedef CFFIndex<COUNT> SUPER;
616 };
617
618 } /* namespace CFF */
619
620 #endif /* HB_OT_CFF_COMMON_HH */
621