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
32namespace CFF {
33
34using namespace OT;
35
36struct 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
76typedef interp_env_t<blend_arg_t> BlendInterpEnv;
77typedef biased_subrs_t<CFF2Subrs> cff2_biased_subrs_t;
78
79struct 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};
196template <typename OPSET, typename PARAM, typename PATH=path_procs_null_t<cff2_cs_interp_env_t, PARAM> >
197struct 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
266template <typename OPSET, typename PARAM>
267struct 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 */
272