1/*
2 * Copyright © 2018 Ebrahim Byagowi
3 * Copyright © 2020 Google, Inc.
4 *
5 * This is part of HarfBuzz, a text shaping library.
6 *
7 * Permission is hereby granted, without written agreement and without
8 * license or royalty fees, to use, copy, modify, and distribute this
9 * software and its documentation for any purpose, provided that the
10 * above copyright notice and the following two paragraphs appear in
11 * all copies of this software.
12 *
13 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
14 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
15 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
16 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
17 * DAMAGE.
18 *
19 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
20 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
21 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
22 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
23 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
24 *
25 * Google Author(s): Calder Kitagawa
26 */
27
28#ifndef OT_COLOR_SBIX_SBIX_HH
29#define OT_COLOR_SBIX_SBIX_HH
30
31#include "../../../hb-open-type.hh"
32#include "../../../hb-paint.hh"
33
34/*
35 * sbix -- Standard Bitmap Graphics
36 * https://docs.microsoft.com/en-us/typography/opentype/spec/sbix
37 * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6sbix.html
38 */
39#define HB_OT_TAG_sbix HB_TAG('s','b','i','x')
40
41
42namespace OT {
43
44
45struct SBIXGlyph
46{
47 SBIXGlyph* copy (hb_serialize_context_t *c, unsigned int data_length) const
48 {
49 TRACE_SERIALIZE (this);
50 SBIXGlyph* new_glyph = c->start_embed<SBIXGlyph> ();
51 if (unlikely (!c->extend_min (new_glyph))) return_trace (nullptr);
52
53 new_glyph->xOffset = xOffset;
54 new_glyph->yOffset = yOffset;
55 new_glyph->graphicType = graphicType;
56 data.copy (c, data_length);
57 return_trace (new_glyph);
58 }
59
60 HBINT16 xOffset; /* The horizontal (x-axis) offset from the left
61 * edge of the graphic to the glyph’s origin.
62 * That is, the x-coordinate of the point on the
63 * baseline at the left edge of the glyph. */
64 HBINT16 yOffset; /* The vertical (y-axis) offset from the bottom
65 * edge of the graphic to the glyph’s origin.
66 * That is, the y-coordinate of the point on the
67 * baseline at the left edge of the glyph. */
68 Tag graphicType; /* Indicates the format of the embedded graphic
69 * data: one of 'jpg ', 'png ' or 'tiff', or the
70 * special format 'dupe'. */
71 UnsizedArrayOf<HBUINT8>
72 data; /* The actual embedded graphic data. The total
73 * length is inferred from sequential entries in
74 * the glyphDataOffsets array and the fixed size
75 * (8 bytes) of the preceding fields. */
76 public:
77 DEFINE_SIZE_ARRAY (8, data);
78};
79
80struct SBIXStrike
81{
82 static unsigned int get_size (unsigned num_glyphs)
83 { return min_size + num_glyphs * HBUINT32::static_size; }
84
85 bool sanitize (hb_sanitize_context_t *c) const
86 {
87 TRACE_SANITIZE (this);
88 return_trace (c->check_struct (this) &&
89 imageOffsetsZ.sanitize_shallow (c, c->get_num_glyphs () + 1));
90 }
91
92 hb_blob_t *get_glyph_blob (unsigned int glyph_id,
93 hb_blob_t *sbix_blob,
94 hb_tag_t file_type,
95 int *x_offset,
96 int *y_offset,
97 unsigned int num_glyphs,
98 unsigned int *strike_ppem) const
99 {
100 if (unlikely (!ppem)) return hb_blob_get_empty (); /* To get Null() object out of the way. */
101
102 unsigned int retry_count = 8;
103 unsigned int sbix_len = sbix_blob->length;
104 unsigned int strike_offset = (const char *) this - (const char *) sbix_blob->data;
105 assert (strike_offset < sbix_len);
106
107 retry:
108 if (unlikely (glyph_id >= num_glyphs ||
109 imageOffsetsZ[glyph_id + 1] <= imageOffsetsZ[glyph_id] ||
110 imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] <= SBIXGlyph::min_size ||
111 (unsigned int) imageOffsetsZ[glyph_id + 1] > sbix_len - strike_offset))
112 return hb_blob_get_empty ();
113
114 unsigned int glyph_offset = strike_offset + (unsigned int) imageOffsetsZ[glyph_id] + SBIXGlyph::min_size;
115 unsigned int glyph_length = imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] - SBIXGlyph::min_size;
116
117 const SBIXGlyph *glyph = &(this+imageOffsetsZ[glyph_id]);
118
119 if (glyph->graphicType == HB_TAG ('d','u','p','e'))
120 {
121 if (glyph_length >= 2)
122 {
123 glyph_id = *((HBUINT16 *) &glyph->data);
124 if (retry_count--)
125 goto retry;
126 }
127 return hb_blob_get_empty ();
128 }
129
130 if (unlikely (file_type != glyph->graphicType))
131 return hb_blob_get_empty ();
132
133 if (strike_ppem) *strike_ppem = ppem;
134 if (x_offset) *x_offset = glyph->xOffset;
135 if (y_offset) *y_offset = glyph->yOffset;
136 return hb_blob_create_sub_blob (sbix_blob, glyph_offset, glyph_length);
137 }
138
139 bool subset (hb_subset_context_t *c, unsigned int available_len) const
140 {
141 TRACE_SUBSET (this);
142 unsigned int num_output_glyphs = c->plan->num_output_glyphs ();
143
144 auto* out = c->serializer->start_embed<SBIXStrike> ();
145 auto snap = c->serializer->snapshot ();
146 if (unlikely (!c->serializer->extend (out, num_output_glyphs + 1))) return_trace (false);
147 out->ppem = ppem;
148 out->resolution = resolution;
149 HBUINT32 head;
150 head = get_size (num_output_glyphs + 1);
151
152 bool has_glyphs = false;
153 for (unsigned new_gid = 0; new_gid < num_output_glyphs; new_gid++)
154 {
155 hb_codepoint_t old_gid;
156 if (!c->plan->old_gid_for_new_gid (new_gid, &old_gid) ||
157 unlikely (imageOffsetsZ[old_gid].is_null () ||
158 imageOffsetsZ[old_gid + 1].is_null () ||
159 imageOffsetsZ[old_gid + 1] <= imageOffsetsZ[old_gid] ||
160 imageOffsetsZ[old_gid + 1] - imageOffsetsZ[old_gid] <= SBIXGlyph::min_size) ||
161 (unsigned int) imageOffsetsZ[old_gid + 1] > available_len)
162 {
163 out->imageOffsetsZ[new_gid] = head;
164 continue;
165 }
166 has_glyphs = true;
167 unsigned int delta = imageOffsetsZ[old_gid + 1] - imageOffsetsZ[old_gid];
168 unsigned int glyph_data_length = delta - SBIXGlyph::min_size;
169 if (!(this+imageOffsetsZ[old_gid]).copy (c->serializer, glyph_data_length))
170 return_trace (false);
171 out->imageOffsetsZ[new_gid] = head;
172 head += delta;
173 }
174 if (has_glyphs)
175 out->imageOffsetsZ[num_output_glyphs] = head;
176 else
177 c->serializer->revert (snap);
178 return_trace (has_glyphs);
179 }
180
181 public:
182 HBUINT16 ppem; /* The PPEM size for which this strike was designed. */
183 HBUINT16 resolution; /* The device pixel density (in PPI) for which this
184 * strike was designed. (E.g., 96 PPI, 192 PPI.) */
185 protected:
186 UnsizedArrayOf<Offset32To<SBIXGlyph>>
187 imageOffsetsZ; /* Offset from the beginning of the strike data header
188 * to bitmap data for an individual glyph ID. */
189 public:
190 DEFINE_SIZE_ARRAY (4, imageOffsetsZ);
191};
192
193struct sbix
194{
195 static constexpr hb_tag_t tableTag = HB_OT_TAG_sbix;
196
197 bool has_data () const { return version; }
198
199 const SBIXStrike &get_strike (unsigned int i) const { return this+strikes[i]; }
200
201 struct accelerator_t
202 {
203 accelerator_t (hb_face_t *face)
204 {
205 table = hb_sanitize_context_t ().reference_table<sbix> (face);
206 num_glyphs = face->get_num_glyphs ();
207 }
208 ~accelerator_t () { table.destroy (); }
209
210 bool has_data () const { return table->has_data (); }
211
212 bool get_extents (hb_font_t *font,
213 hb_codepoint_t glyph,
214 hb_glyph_extents_t *extents,
215 bool scale = true) const
216 {
217 /* We only support PNG right now, and following function checks type. */
218 return get_png_extents (font, glyph, extents, scale);
219 }
220
221 hb_blob_t *reference_png (hb_font_t *font,
222 hb_codepoint_t glyph_id,
223 int *x_offset,
224 int *y_offset,
225 unsigned int *available_ppem) const
226 {
227 return choose_strike (font).get_glyph_blob (glyph_id, table.get_blob (),
228 HB_TAG ('p','n','g',' '),
229 x_offset, y_offset,
230 num_glyphs, available_ppem);
231 }
232
233 bool paint_glyph (hb_font_t *font, hb_codepoint_t glyph, hb_paint_funcs_t *funcs, void *data) const
234 {
235 if (!has_data ())
236 return false;
237
238 int x_offset = 0, y_offset = 0;
239 unsigned int strike_ppem = 0;
240 hb_blob_t *blob = reference_png (font, glyph, &x_offset, &y_offset, &strike_ppem);
241 hb_glyph_extents_t extents;
242 hb_glyph_extents_t pixel_extents;
243
244 if (blob == hb_blob_get_empty ())
245 return false;
246
247 if (!hb_font_get_glyph_extents (font, glyph, &extents))
248 return false;
249
250 if (unlikely (!get_extents (font, glyph, &pixel_extents, false)))
251 return false;
252
253 bool ret = funcs->image (data,
254 blob,
255 pixel_extents.width, -pixel_extents.height,
256 HB_PAINT_IMAGE_FORMAT_PNG,
257 font->slant_xy,
258 &extents);
259
260 hb_blob_destroy (blob);
261 return ret;
262 }
263
264 private:
265
266 const SBIXStrike &choose_strike (hb_font_t *font) const
267 {
268 unsigned count = table->strikes.len;
269 if (unlikely (!count))
270 return Null (SBIXStrike);
271
272 unsigned int requested_ppem = hb_max (font->x_ppem, font->y_ppem);
273 if (!requested_ppem)
274 requested_ppem = 1<<30; /* Choose largest strike. */
275 /* TODO Add DPI sensitivity as well? */
276 unsigned int best_i = 0;
277 unsigned int best_ppem = table->get_strike (0).ppem;
278
279 for (unsigned int i = 1; i < count; i++)
280 {
281 unsigned int ppem = (table->get_strike (i)).ppem;
282 if ((requested_ppem <= ppem && ppem < best_ppem) ||
283 (requested_ppem > best_ppem && ppem > best_ppem))
284 {
285 best_i = i;
286 best_ppem = ppem;
287 }
288 }
289
290 return table->get_strike (best_i);
291 }
292
293 struct PNGHeader
294 {
295 HBUINT8 signature[8];
296 struct
297 {
298 struct
299 {
300 HBUINT32 length;
301 Tag type;
302 } header;
303 HBUINT32 width;
304 HBUINT32 height;
305 HBUINT8 bitDepth;
306 HBUINT8 colorType;
307 HBUINT8 compressionMethod;
308 HBUINT8 filterMethod;
309 HBUINT8 interlaceMethod;
310 } IHDR;
311
312 public:
313 DEFINE_SIZE_STATIC (29);
314 };
315
316 bool get_png_extents (hb_font_t *font,
317 hb_codepoint_t glyph,
318 hb_glyph_extents_t *extents,
319 bool scale = true) const
320 {
321 /* Following code is safe to call even without data.
322 * But faster to short-circuit. */
323 if (!has_data ())
324 return false;
325
326 int x_offset = 0, y_offset = 0;
327 unsigned int strike_ppem = 0;
328 hb_blob_t *blob = reference_png (font, glyph, &x_offset, &y_offset, &strike_ppem);
329
330 const PNGHeader &png = *blob->as<PNGHeader>();
331
332 if (png.IHDR.height >= 65536 || png.IHDR.width >= 65536)
333 {
334 hb_blob_destroy (blob);
335 return false;
336 }
337
338 extents->x_bearing = x_offset;
339 extents->y_bearing = png.IHDR.height + y_offset;
340 extents->width = png.IHDR.width;
341 extents->height = -1 * png.IHDR.height;
342
343 /* Convert to font units. */
344 if (strike_ppem && scale)
345 {
346 float scale = font->face->get_upem () / (float) strike_ppem;
347 extents->x_bearing = roundf (extents->x_bearing * scale);
348 extents->y_bearing = roundf (extents->y_bearing * scale);
349 extents->width = roundf (extents->width * scale);
350 extents->height = roundf (extents->height * scale);
351 }
352
353 if (scale)
354 font->scale_glyph_extents (extents);
355
356 hb_blob_destroy (blob);
357
358 return strike_ppem;
359 }
360
361 private:
362 hb_blob_ptr_t<sbix> table;
363
364 unsigned int num_glyphs;
365 };
366
367 bool sanitize (hb_sanitize_context_t *c) const
368 {
369 TRACE_SANITIZE (this);
370 return_trace (likely (c->check_struct (this) &&
371 version >= 1 &&
372 strikes.sanitize (c, this)));
373 }
374
375 bool
376 add_strike (hb_subset_context_t *c, unsigned i) const
377 {
378 if (strikes[i].is_null () || c->source_blob->length < (unsigned) strikes[i])
379 return false;
380
381 return (this+strikes[i]).subset (c, c->source_blob->length - (unsigned) strikes[i]);
382 }
383
384 bool serialize_strike_offsets (hb_subset_context_t *c) const
385 {
386 TRACE_SERIALIZE (this);
387
388 auto *out = c->serializer->start_embed<Array32OfOffset32To<SBIXStrike>> ();
389 if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
390
391 hb_vector_t<Offset32To<SBIXStrike>*> new_strikes;
392 hb_vector_t<hb_serialize_context_t::objidx_t> objidxs;
393 for (int i = strikes.len - 1; i >= 0; --i)
394 {
395 auto* o = out->serialize_append (c->serializer);
396 if (unlikely (!o)) return_trace (false);
397 *o = 0;
398 auto snap = c->serializer->snapshot ();
399 c->serializer->push ();
400 bool ret = add_strike (c, i);
401 if (!ret)
402 {
403 c->serializer->pop_discard ();
404 out->pop ();
405 c->serializer->revert (snap);
406 }
407 else
408 {
409 objidxs.push (c->serializer->pop_pack ());
410 new_strikes.push (o);
411 }
412 }
413 for (unsigned int i = 0; i < new_strikes.length; ++i)
414 c->serializer->add_link (*new_strikes[i], objidxs[new_strikes.length - 1 - i]);
415
416 return_trace (true);
417 }
418
419 bool subset (hb_subset_context_t* c) const
420 {
421 TRACE_SUBSET (this);
422
423 if (unlikely (!c->serializer->embed (this->version))) return_trace (false);
424 if (unlikely (!c->serializer->embed (this->flags))) return_trace (false);
425
426 return_trace (serialize_strike_offsets (c));
427 }
428
429 protected:
430 HBUINT16 version; /* Table version number — set to 1 */
431 HBUINT16 flags; /* Bit 0: Set to 1. Bit 1: Draw outlines.
432 * Bits 2 to 15: reserved (set to 0). */
433 Array32OfOffset32To<SBIXStrike>
434 strikes; /* Offsets from the beginning of the 'sbix'
435 * table to data for each individual bitmap strike. */
436 public:
437 DEFINE_SIZE_ARRAY (8, strikes);
438};
439
440struct sbix_accelerator_t : sbix::accelerator_t {
441 sbix_accelerator_t (hb_face_t *face) : sbix::accelerator_t (face) {}
442};
443
444
445} /* namespace OT */
446
447#endif /* OT_COLOR_SBIX_SBIX_HH */
448