src/hb-cff2-interp-cs.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 #ifndef HB_CFF2_INTERP_CS_HH
  27 #define HB_CFF2_INTERP_CS_HH
  28
  29 #include "hb.hh"
  30 #include "hb-cff-interp-cs-common.hh"
  31
  32 namespace CFF {
  33
  34 using namespace OT;
  35
  36 struct blend_arg_t : number_t
  37 {
  38   void init ()
  39   {
  40     number_t::init ();
  41     deltas.init ();
  42   }
  43
  44   void fini ()
  45   {
  46     number_t::fini ();
  47     deltas.fini_deep ();
  48   }
  49
  50   void set_int (int v) { reset_blends (); number_t::set_int (v); }
  51   void set_fixed (int32_t v) { reset_blends (); number_t::set_fixed (v); }
  52   void set_real (double v) { reset_blends (); number_t::set_real (v); }
  53
  54   void set_blends (unsigned int numValues_, unsigned int valueIndex_,
  55                           unsigned int numBlends, hb_array_t<const blend_arg_t> blends_)
  56   {
  57     numValues = numValues_;
  58     valueIndex = valueIndex_;
  59     deltas.resize (numBlends);
  60     for (unsigned int i = 0; i < numBlends; i++)
  61       deltas[i] = blends_[i];
  62   }
  63
  64   bool blending () const { return deltas.length > 0; }
  65   void reset_blends ()
  66   {
  67     numValues = valueIndex = 0;
  68     deltas.resize (0);
  69   }
  70
  71   unsigned int numValues;
  72   unsigned int valueIndex;
  73   hb_vector_t<number_t> deltas;
  74 };
  75
  76 typedef interp_env_t<blend_arg_t> BlendInterpEnv;
  77 typedef biased_subrs_t<CFF2Subrs>   cff2_biased_subrs_t;
  78
  79 struct cff2_cs_interp_env_t : cs_interp_env_t<blend_arg_t, CFF2Subrs>
  80 {
  81   template <typename ACC>
  82   void init (const byte_str_t &str, ACC &acc, unsigned int fd,
  83                     const int *coords_=nullptr, unsigned int num_coords_=0)
  84   {
  85     SUPER::init (str, *acc.globalSubrs, *acc.privateDicts[fd].localSubrs);
  86
  87     coords = coords_;
  88     num_coords = num_coords_;
  89     varStore = acc.varStore;
  90     seen_blend = false;
  91     seen_vsindex_ = false;
  92     scalars.init ();
  93     do_blend = (coords != nullptr) && num_coords && (varStore != &Null(CFF2VariationStore));
  94     set_ivs (acc.privateDicts[fd].ivs);
  95   }
  96
  97   void fini ()
  98   {
  99     scalars.fini ();
 100     SUPER::fini ();
 101   }
 102
 103   op_code_t fetch_op ()
 104   {
 105     if (this->str_ref.avail ())
 106       return SUPER::fetch_op ();
 107
 108     /* make up return or endchar op */
 109     if (this->callStack.is_empty ())
 110       return OpCode_endchar;
 111     else
 112       return OpCode_return;
 113   }
 114
 115   const blend_arg_t& eval_arg (unsigned int i)
 116   {
 117     blend_arg_t  &arg = argStack[i];
 118     blend_arg (arg);
 119     return arg;
 120   }
 121
 122   const blend_arg_t& pop_arg ()
 123   {
 124     blend_arg_t  &arg = argStack.pop ();
 125     blend_arg (arg);
 126     return arg;
 127   }
 128
 129   void process_blend ()
 130   {
 131     if (!seen_blend)
 132     {
 133       region_count = varStore->varStore.get_region_index_count (get_ivs ());
 134       if (do_blend)
 135       {
 136         scalars.resize (region_count);
 137         varStore->varStore.get_scalars (get_ivs (),
 138                                         (int *)coords, num_coords,
 139                                         &scalars[0], region_count);
 140       }
 141       seen_blend = true;
 142     }
 143   }
 144
 145   void process_vsindex ()
 146   {
 147     unsigned int  index = argStack.pop_uint ();
 148     if (unlikely (seen_vsindex () || seen_blend))
 149     {
 150       set_error ();
 151     }
 152     else
 153     {
 154       set_ivs (index);
 155     }
 156     seen_vsindex_ = true;
 157   }
 158
 159   unsigned int get_region_count () const { return region_count; }
 160   void   set_region_count (unsigned int region_count_) { region_count = region_count_; }
 161   unsigned int get_ivs () const { return ivs; }
 162   void   set_ivs (unsigned int ivs_) { ivs = ivs_; }
 163   bool   seen_vsindex () const { return seen_vsindex_; }
 164
 165   protected:
 166   void blend_arg (blend_arg_t &arg)
 167   {
 168     if (do_blend && arg.blending ())
 169     {
 170       if (likely (scalars.length == arg.deltas.length))
 171       {
 172         double v = arg.to_real ();
 173         for (unsigned int i = 0; i < scalars.length; i++)
 174         {
 175           v += (double)scalars[i] * arg.deltas[i].to_real ();
 176         }
 177         arg.set_real (v);
 178         arg.deltas.resize (0);
 179       }
 180     }
 181   }
 182
 183   protected:
 184   const int     *coords;
 185   unsigned int  num_coords;
 186   const  CFF2VariationStore *varStore;
 187   unsigned int  region_count;
 188   unsigned int  ivs;
 189   hb_vector_t<float>  scalars;
 190   bool    do_blend;
 191   bool    seen_vsindex_;
 192   bool    seen_blend;
 193
 194   typedef cs_interp_env_t<blend_arg_t, CFF2Subrs> SUPER;
 195 };
 196 template <typename OPSET, typename PARAM, typename PATH=path_procs_null_t<cff2_cs_interp_env_t, PARAM> >
 197 struct cff2_cs_opset_t : cs_opset_t<blend_arg_t, OPSET, cff2_cs_interp_env_t, PARAM, PATH>
 198 {
 199   static void process_op (op_code_t op, cff2_cs_interp_env_t &env, PARAM& param)
 200   {
 201     switch (op) {
 202       case OpCode_callsubr:
 203       case OpCode_callgsubr:
 204         /* a subroutine number shoudln't be a blended value */
 205         if (unlikely (env.argStack.peek ().blending ()))
 206         {
 207           env.set_error ();
 208           break;
 209         }
 210         SUPER::process_op (op, env, param);
 211         break;
 212
 213       case OpCode_blendcs:
 214         OPSET::process_blend (env, param);
 215         break;
 216
 217       case OpCode_vsindexcs:
 218         if (unlikely (env.argStack.peek ().blending ()))
 219         {
 220           env.set_error ();
 221           break;
 222         }
 223         OPSET::process_vsindex (env, param);
 224         break;
 225
 226       default:
 227         SUPER::process_op (op, env, param);
 228     }
 229   }
 230
 231   static void process_blend (cff2_cs_interp_env_t &env, PARAM& param)
 232   {
 233     unsigned int n, k;
 234
 235     env.process_blend ();
 236     k = env.get_region_count ();
 237     n = env.argStack.pop_uint ();
 238     /* copy the blend values into blend array of the default values */
 239     unsigned int start = env.argStack.get_count () - ((k+1) * n);
 240     /* let an obvious error case fail, but note CFF2 spec doesn't forbid n==0 */
 241     if (unlikely (start > env.argStack.get_count ()))
 242     {
 243       env.set_error ();
 244       return;
 245     }
 246     for (unsigned int i = 0; i < n; i++)
 247     {
 248       const hb_array_t<const blend_arg_t>       blends = env.argStack.get_subarray (start + n + (i * k));
 249       env.argStack[start + i].set_blends (n, i, k, blends);
 250     }
 251
 252     /* pop off blend values leaving default values now adorned with blend values */
 253     env.argStack.pop (k * n);
 254   }
 255
 256   static void process_vsindex (cff2_cs_interp_env_t &env, PARAM& param)
 257   {
 258     env.process_vsindex ();
 259     env.clear_args ();
 260   }
 261
 262   private:
 263   typedef cs_opset_t<blend_arg_t, OPSET, cff2_cs_interp_env_t, PARAM, PATH>  SUPER;
 264 };
 265
 266 template <typename OPSET, typename PARAM>
 267 struct cff2_cs_interpreter_t : cs_interpreter_t<cff2_cs_interp_env_t, OPSET, PARAM> {};
 268
 269 } /* namespace CFF */
 270
 271 #endif /* HB_CFF2_INTERP_CS_HH */