src/hb-ot-cff2-table.hh

   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
  27 #ifndef HB_OT_CFF2_TABLE_HH
  28 #define HB_OT_CFF2_TABLE_HH
  29
  30 #include "hb-ot-cff-common.hh"
  31 #include "hb-subset-cff-common.hh"
  32 #include "hb-draw.hh"
  33 #include "hb-paint.hh"
  34
  35 namespace CFF {
  36
  37 /*
  38  * CFF2 -- Compact Font Format (CFF) Version 2
  39  * https://docs.microsoft.com/en-us/typography/opentype/spec/cff2
  40  */
  41 #define HB_OT_TAG_CFF2 HB_TAG('C','F','F','2')
  42
  43 typedef CFFIndex<HBUINT32>  CFF2Index;
  44
  45 typedef CFF2Index         CFF2CharStrings;
  46 typedef Subrs<HBUINT32>   CFF2Subrs;
  47
  48 typedef FDSelect3_4<HBUINT32, HBUINT16> FDSelect4;
  49 typedef FDSelect3_4_Range<HBUINT32, HBUINT16> FDSelect4_Range;
  50
  51 struct CFF2FDSelect
  52 {
  53   bool serialize (hb_serialize_context_t *c, const CFF2FDSelect &src, unsigned int num_glyphs)
  54   {
  55     TRACE_SERIALIZE (this);
  56     unsigned int size = src.get_size (num_glyphs);
  57     CFF2FDSelect *dest = c->allocate_size<CFF2FDSelect> (size);
  58     if (unlikely (!dest)) return_trace (false);
  59     hb_memcpy (dest, &src, size);
  60     return_trace (true);
  61   }
  62
  63   unsigned int get_size (unsigned int num_glyphs) const
  64   {
  65     switch (format)
  66     {
  67     case 0: return format.static_size + u.format0.get_size (num_glyphs);
  68     case 3: return format.static_size + u.format3.get_size ();
  69     case 4: return format.static_size + u.format4.get_size ();
  70     default:return 0;
  71     }
  72   }
  73
  74   hb_codepoint_t get_fd (hb_codepoint_t glyph) const
  75   {
  76     if (this == &Null (CFF2FDSelect))
  77       return 0;
  78
  79     switch (format)
  80     {
  81     case 0: return u.format0.get_fd (glyph);
  82     case 3: return u.format3.get_fd (glyph);
  83     case 4: return u.format4.get_fd (glyph);
  84     default:return 0;
  85     }
  86   }
  87
  88   bool sanitize (hb_sanitize_context_t *c, unsigned int fdcount) const
  89   {
  90     TRACE_SANITIZE (this);
  91     if (unlikely (!c->check_struct (this)))
  92       return_trace (false);
  93
  94     switch (format)
  95     {
  96     case 0: return_trace (u.format0.sanitize (c, fdcount));
  97     case 3: return_trace (u.format3.sanitize (c, fdcount));
  98     case 4: return_trace (u.format4.sanitize (c, fdcount));
  99     default:return_trace (false);
 100     }
 101   }
 102
 103   HBUINT8       format;
 104   union {
 105   FDSelect0     format0;
 106   FDSelect3     format3;
 107   FDSelect4     format4;
 108   } u;
 109   public:
 110   DEFINE_SIZE_MIN (2);
 111 };
 112
 113 struct CFF2VariationStore
 114 {
 115   bool sanitize (hb_sanitize_context_t *c) const
 116   {
 117     TRACE_SANITIZE (this);
 118     return_trace (likely (c->check_struct (this)) && c->check_range (&varStore, size) && varStore.sanitize (c));
 119   }
 120
 121   bool serialize (hb_serialize_context_t *c, const CFF2VariationStore *varStore)
 122   {
 123     TRACE_SERIALIZE (this);
 124     unsigned int size_ = varStore->get_size ();
 125     CFF2VariationStore *dest = c->allocate_size<CFF2VariationStore> (size_);
 126     if (unlikely (!dest)) return_trace (false);
 127     hb_memcpy (dest, varStore, size_);
 128     return_trace (true);
 129   }
 130
 131   unsigned int get_size () const { return HBUINT16::static_size + size; }
 132
 133   HBUINT16      size;
 134   VariationStore  varStore;
 135
 136   DEFINE_SIZE_MIN (2 + VariationStore::min_size);
 137 };
 138
 139 struct cff2_top_dict_values_t : top_dict_values_t<>
 140 {
 141   void init ()
 142   {
 143     top_dict_values_t<>::init ();
 144     vstoreOffset = 0;
 145     FDSelectOffset = 0;
 146   }
 147   void fini () { top_dict_values_t<>::fini (); }
 148
 149   unsigned int  vstoreOffset;
 150   unsigned int  FDSelectOffset;
 151 };
 152
 153 struct cff2_top_dict_opset_t : top_dict_opset_t<>
 154 {
 155   static void process_op (op_code_t op, num_interp_env_t& env, cff2_top_dict_values_t& dictval)
 156   {
 157     switch (op) {
 158       case OpCode_FontMatrix:
 159         {
 160           dict_val_t val;
 161           val.init ();
 162           dictval.add_op (op, env.str_ref);
 163           env.clear_args ();
 164         }
 165         break;
 166
 167       case OpCode_vstore:
 168         dictval.vstoreOffset = env.argStack.pop_uint ();
 169         env.clear_args ();
 170         break;
 171       case OpCode_FDSelect:
 172         dictval.FDSelectOffset = env.argStack.pop_uint ();
 173         env.clear_args ();
 174         break;
 175
 176       default:
 177         SUPER::process_op (op, env, dictval);
 178         /* Record this operand below if stack is empty, otherwise done */
 179         if (!env.argStack.is_empty ()) return;
 180     }
 181
 182     if (unlikely (env.in_error ())) return;
 183
 184     dictval.add_op (op, env.str_ref);
 185   }
 186
 187   typedef top_dict_opset_t<> SUPER;
 188 };
 189
 190 struct cff2_font_dict_values_t : dict_values_t<op_str_t>
 191 {
 192   void init ()
 193   {
 194     dict_values_t<op_str_t>::init ();
 195     privateDictInfo.init ();
 196   }
 197   void fini () { dict_values_t<op_str_t>::fini (); }
 198
 199   table_info_t    privateDictInfo;
 200 };
 201
 202 struct cff2_font_dict_opset_t : dict_opset_t
 203 {
 204   static void process_op (op_code_t op, num_interp_env_t& env, cff2_font_dict_values_t& dictval)
 205   {
 206     switch (op) {
 207       case OpCode_Private:
 208         dictval.privateDictInfo.offset = env.argStack.pop_uint ();
 209         dictval.privateDictInfo.size = env.argStack.pop_uint ();
 210         env.clear_args ();
 211         break;
 212
 213       default:
 214         SUPER::process_op (op, env);
 215         if (!env.argStack.is_empty ())
 216           return;
 217     }
 218
 219     if (unlikely (env.in_error ())) return;
 220
 221     dictval.add_op (op, env.str_ref);
 222   }
 223
 224   private:
 225   typedef dict_opset_t SUPER;
 226 };
 227
 228 template <typename VAL>
 229 struct cff2_private_dict_values_base_t : dict_values_t<VAL>
 230 {
 231   void init ()
 232   {
 233     dict_values_t<VAL>::init ();
 234     subrsOffset = 0;
 235     localSubrs = &Null (CFF2Subrs);
 236     ivs = 0;
 237   }
 238   void fini () { dict_values_t<VAL>::fini (); }
 239
 240   unsigned int      subrsOffset;
 241   const CFF2Subrs   *localSubrs;
 242   unsigned int      ivs;
 243 };
 244
 245 typedef cff2_private_dict_values_base_t<op_str_t> cff2_private_dict_values_subset_t;
 246 typedef cff2_private_dict_values_base_t<num_dict_val_t> cff2_private_dict_values_t;
 247
 248 struct cff2_priv_dict_interp_env_t : num_interp_env_t
 249 {
 250   cff2_priv_dict_interp_env_t (const hb_ubytes_t &str) :
 251     num_interp_env_t (str) {}
 252
 253   void process_vsindex ()
 254   {
 255     if (likely (!seen_vsindex))
 256     {
 257       set_ivs (argStack.pop_uint ());
 258     }
 259     seen_vsindex = true;
 260   }
 261
 262   unsigned int get_ivs () const { return ivs; }
 263   void   set_ivs (unsigned int ivs_) { ivs = ivs_; }
 264
 265   protected:
 266   unsigned int  ivs = 0;
 267   bool    seen_vsindex = false;
 268 };
 269
 270 struct cff2_private_dict_opset_t : dict_opset_t
 271 {
 272   static void process_op (op_code_t op, cff2_priv_dict_interp_env_t& env, cff2_private_dict_values_t& dictval)
 273   {
 274     num_dict_val_t val;
 275     val.init ();
 276
 277     switch (op) {
 278       case OpCode_StdHW:
 279       case OpCode_StdVW:
 280       case OpCode_BlueScale:
 281       case OpCode_BlueShift:
 282       case OpCode_BlueFuzz:
 283       case OpCode_ExpansionFactor:
 284       case OpCode_LanguageGroup:
 285       case OpCode_BlueValues:
 286       case OpCode_OtherBlues:
 287       case OpCode_FamilyBlues:
 288       case OpCode_FamilyOtherBlues:
 289       case OpCode_StemSnapH:
 290       case OpCode_StemSnapV:
 291         env.clear_args ();
 292         break;
 293       case OpCode_Subrs:
 294         dictval.subrsOffset = env.argStack.pop_uint ();
 295         env.clear_args ();
 296         break;
 297       case OpCode_vsindexdict:
 298         env.process_vsindex ();
 299         dictval.ivs = env.get_ivs ();
 300         env.clear_args ();
 301         break;
 302       case OpCode_blenddict:
 303         break;
 304
 305       default:
 306         dict_opset_t::process_op (op, env);
 307         if (!env.argStack.is_empty ()) return;
 308         break;
 309     }
 310
 311     if (unlikely (env.in_error ())) return;
 312
 313     dictval.add_op (op, env.str_ref, val);
 314   }
 315 };
 316
 317 struct cff2_private_dict_opset_subset_t : dict_opset_t
 318 {
 319   static void process_op (op_code_t op, cff2_priv_dict_interp_env_t& env, cff2_private_dict_values_subset_t& dictval)
 320   {
 321     switch (op) {
 322       case OpCode_BlueValues:
 323       case OpCode_OtherBlues:
 324       case OpCode_FamilyBlues:
 325       case OpCode_FamilyOtherBlues:
 326       case OpCode_StdHW:
 327       case OpCode_StdVW:
 328       case OpCode_BlueScale:
 329       case OpCode_BlueShift:
 330       case OpCode_BlueFuzz:
 331       case OpCode_StemSnapH:
 332       case OpCode_StemSnapV:
 333       case OpCode_LanguageGroup:
 334       case OpCode_ExpansionFactor:
 335         env.clear_args ();
 336         break;
 337
 338       case OpCode_blenddict:
 339         env.clear_args ();
 340         return;
 341
 342       case OpCode_Subrs:
 343         dictval.subrsOffset = env.argStack.pop_uint ();
 344         env.clear_args ();
 345         break;
 346
 347       default:
 348         SUPER::process_op (op, env);
 349         if (!env.argStack.is_empty ()) return;
 350         break;
 351     }
 352
 353     if (unlikely (env.in_error ())) return;
 354
 355     dictval.add_op (op, env.str_ref);
 356   }
 357
 358   private:
 359   typedef dict_opset_t SUPER;
 360 };
 361
 362 typedef dict_interpreter_t<cff2_top_dict_opset_t, cff2_top_dict_values_t> cff2_top_dict_interpreter_t;
 363 typedef dict_interpreter_t<cff2_font_dict_opset_t, cff2_font_dict_values_t> cff2_font_dict_interpreter_t;
 364
 365 struct CFF2FDArray : FDArray<HBUINT32>
 366 {
 367   /* FDArray::serialize does not compile without this partial specialization */
 368   template <typename ITER, typename OP_SERIALIZER>
 369   bool serialize (hb_serialize_context_t *c, ITER it, OP_SERIALIZER& opszr)
 370   { return FDArray<HBUINT32>::serialize<cff2_font_dict_values_t, table_info_t> (c, it, opszr); }
 371 };
 372
 373 } /* namespace CFF */
 374
 375 namespace OT {
 376
 377 using namespace CFF;
 378
 379 struct cff2
 380 {
 381   static constexpr hb_tag_t tableTag = HB_OT_TAG_CFF2;
 382
 383   bool sanitize (hb_sanitize_context_t *c) const
 384   {
 385     TRACE_SANITIZE (this);
 386     return_trace (c->check_struct (this) &&
 387                   likely (version.major == 2));
 388   }
 389
 390   template <typename PRIVOPSET, typename PRIVDICTVAL>
 391   struct accelerator_templ_t
 392   {
 393     static constexpr hb_tag_t tableTag = cff2::tableTag;
 394
 395     accelerator_templ_t (hb_face_t *face)
 396     {
 397       if (!face) return;
 398
 399       topDict.init ();
 400       fontDicts.init ();
 401       privateDicts.init ();
 402
 403       this->blob = sc.reference_table<cff2> (face);
 404
 405       /* setup for run-time santization */
 406       sc.init (this->blob);
 407       sc.start_processing ();
 408
 409       const OT::cff2 *cff2 = this->blob->template as<OT::cff2> ();
 410
 411       if (cff2 == &Null (OT::cff2))
 412         goto fail;
 413
 414       { /* parse top dict */
 415         hb_ubytes_t topDictStr = (cff2 + cff2->topDict).as_ubytes (cff2->topDictSize);
 416         if (unlikely (!topDictStr.sanitize (&sc))) goto fail;
 417         num_interp_env_t env (topDictStr);
 418         cff2_top_dict_interpreter_t top_interp (env);
 419         topDict.init ();
 420         if (unlikely (!top_interp.interpret (topDict))) goto fail;
 421       }
 422
 423       globalSubrs = &StructAtOffset<CFF2Subrs> (cff2, cff2->topDict + cff2->topDictSize);
 424       varStore = &StructAtOffsetOrNull<CFF2VariationStore> (cff2, topDict.vstoreOffset);
 425       charStrings = &StructAtOffsetOrNull<CFF2CharStrings> (cff2, topDict.charStringsOffset);
 426       fdArray = &StructAtOffsetOrNull<CFF2FDArray> (cff2, topDict.FDArrayOffset);
 427       fdSelect = &StructAtOffsetOrNull<CFF2FDSelect> (cff2, topDict.FDSelectOffset);
 428
 429       if (((varStore != &Null (CFF2VariationStore)) && unlikely (!varStore->sanitize (&sc))) ||
 430           (charStrings == &Null (CFF2CharStrings)) || unlikely (!charStrings->sanitize (&sc)) ||
 431           (globalSubrs == &Null (CFF2Subrs)) || unlikely (!globalSubrs->sanitize (&sc)) ||
 432           (fdArray == &Null (CFF2FDArray)) || unlikely (!fdArray->sanitize (&sc)) ||
 433           (((fdSelect != &Null (CFF2FDSelect)) && unlikely (!fdSelect->sanitize (&sc, fdArray->count)))))
 434         goto fail;
 435
 436       num_glyphs = charStrings->count;
 437       if (num_glyphs != sc.get_num_glyphs ())
 438         goto fail;
 439
 440       fdCount = fdArray->count;
 441       if (!privateDicts.resize (fdCount))
 442         goto fail;
 443
 444       /* parse font dicts and gather private dicts */
 445       for (unsigned int i = 0; i < fdCount; i++)
 446       {
 447         const hb_ubytes_t fontDictStr = (*fdArray)[i];
 448         if (unlikely (!fontDictStr.sanitize (&sc))) goto fail;
 449         cff2_font_dict_values_t  *font;
 450         num_interp_env_t env (fontDictStr);
 451         cff2_font_dict_interpreter_t font_interp (env);
 452         font = fontDicts.push ();
 453         if (unlikely (font == &Crap (cff2_font_dict_values_t))) goto fail;
 454         font->init ();
 455         if (unlikely (!font_interp.interpret (*font))) goto fail;
 456
 457         const hb_ubytes_t privDictStr = StructAtOffsetOrNull<UnsizedByteStr> (cff2, font->privateDictInfo.offset).as_ubytes (font->privateDictInfo.size);
 458         if (unlikely (!privDictStr.sanitize (&sc))) goto fail;
 459         cff2_priv_dict_interp_env_t env2 (privDictStr);
 460         dict_interpreter_t<PRIVOPSET, PRIVDICTVAL, cff2_priv_dict_interp_env_t> priv_interp (env2);
 461         privateDicts[i].init ();
 462         if (unlikely (!priv_interp.interpret (privateDicts[i]))) goto fail;
 463
 464         privateDicts[i].localSubrs = &StructAtOffsetOrNull<CFF2Subrs> (&privDictStr[0], privateDicts[i].subrsOffset);
 465         if (privateDicts[i].localSubrs != &Null (CFF2Subrs) &&
 466           unlikely (!privateDicts[i].localSubrs->sanitize (&sc)))
 467           goto fail;
 468       }
 469
 470       return;
 471
 472       fail:
 473         _fini ();
 474     }
 475     ~accelerator_templ_t () { _fini (); }
 476     void _fini ()
 477     {
 478       sc.end_processing ();
 479       topDict.fini ();
 480       fontDicts.fini ();
 481       privateDicts.fini ();
 482       hb_blob_destroy (blob);
 483       blob = nullptr;
 484     }
 485
 486     hb_vector_t<uint16_t> *create_glyph_to_sid_map () const
 487     {
 488       return nullptr;
 489     }
 490
 491     hb_blob_t *get_blob () const { return blob; }
 492
 493     bool is_valid () const { return blob; }
 494
 495     protected:
 496     hb_sanitize_context_t       sc;
 497
 498     public:
 499     hb_blob_t                   *blob = nullptr;
 500     cff2_top_dict_values_t      topDict;
 501     const CFF2Subrs             *globalSubrs = nullptr;
 502     const CFF2VariationStore    *varStore = nullptr;
 503     const CFF2CharStrings       *charStrings = nullptr;
 504     const CFF2FDArray           *fdArray = nullptr;
 505     const CFF2FDSelect          *fdSelect = nullptr;
 506     unsigned int                fdCount = 0;
 507
 508     hb_vector_t<cff2_font_dict_values_t>     fontDicts;
 509     hb_vector_t<PRIVDICTVAL>  privateDicts;
 510
 511     unsigned int              num_glyphs = 0;
 512   };
 513
 514   struct accelerator_t : accelerator_templ_t<cff2_private_dict_opset_t, cff2_private_dict_values_t>
 515   {
 516     accelerator_t (hb_face_t *face) : accelerator_templ_t (face) {}
 517
 518     HB_INTERNAL bool get_extents (hb_font_t *font,
 519                                   hb_codepoint_t glyph,
 520                                   hb_glyph_extents_t *extents) const;
 521     HB_INTERNAL bool paint_glyph (hb_font_t *font, hb_codepoint_t glyph, hb_paint_funcs_t *funcs, void *data, hb_color_t foreground) const;
 522     HB_INTERNAL bool get_path (hb_font_t *font, hb_codepoint_t glyph, hb_draw_session_t &draw_session) const;
 523   };
 524
 525   struct accelerator_subset_t : accelerator_templ_t<cff2_private_dict_opset_subset_t, cff2_private_dict_values_subset_t>
 526   {
 527     accelerator_subset_t (hb_face_t *face) : SUPER (face) {}
 528     ~accelerator_subset_t ()
 529     {
 530       if (cff_accelerator)
 531         cff_subset_accelerator_t::destroy (cff_accelerator);
 532     }
 533
 534     HB_INTERNAL bool subset (hb_subset_context_t *c) const;
 535     HB_INTERNAL bool serialize (hb_serialize_context_t *c,
 536                                 struct cff2_subset_plan &plan,
 537                                 hb_array_t<int> normalized_coords) const;
 538
 539     mutable CFF::cff_subset_accelerator_t* cff_accelerator = nullptr;
 540
 541     typedef accelerator_templ_t<cff2_private_dict_opset_subset_t, cff2_private_dict_values_subset_t> SUPER;
 542   };
 543
 544   public:
 545   FixedVersion<HBUINT8>         version;        /* Version of CFF2 table. set to 0x0200u */
 546   NNOffsetTo<TopDict, HBUINT8>  topDict;        /* headerSize = Offset to Top DICT. */
 547   HBUINT16                      topDictSize;    /* Top DICT size */
 548
 549   public:
 550   DEFINE_SIZE_STATIC (5);
 551 };
 552
 553 struct cff2_accelerator_t : cff2::accelerator_t {
 554   cff2_accelerator_t (hb_face_t *face) : cff2::accelerator_t (face) {}
 555 };
 556
 557 struct cff2_subset_accelerator_t : cff2::accelerator_subset_t {
 558   cff2_subset_accelerator_t (hb_face_t *face) : cff2::accelerator_subset_t (face) {}
 559 };
 560
 561 } /* namespace OT */
 562
 563 #endif /* HB_OT_CFF2_TABLE_HH */