1/*
2 * Copyright © 2018 Ebrahim Byagowi
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
25#ifndef HB_OT_COLOR_SBIX_TABLE_HH
26#define HB_OT_COLOR_SBIX_TABLE_HH
27
28#include "hb-open-type.hh"
29
30/*
31 * sbix -- Standard Bitmap Graphics
32 * https://docs.microsoft.com/en-us/typography/opentype/spec/sbix
33 * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6sbix.html
34 */
35#define HB_OT_TAG_sbix HB_TAG('s','b','i','x')
36
37
38namespace OT {
39
40
41struct SBIXGlyph
42{
43 HBINT16 xOffset; /* The horizontal (x-axis) offset from the left
44 * edge of the graphic to the glyph’s origin.
45 * That is, the x-coordinate of the point on the
46 * baseline at the left edge of the glyph. */
47 HBINT16 yOffset; /* The vertical (y-axis) offset from the bottom
48 * edge of the graphic to the glyph’s origin.
49 * That is, the y-coordinate of the point on the
50 * baseline at the left edge of the glyph. */
51 Tag graphicType; /* Indicates the format of the embedded graphic
52 * data: one of 'jpg ', 'png ' or 'tiff', or the
53 * special format 'dupe'. */
54 UnsizedArrayOf<HBUINT8>
55 data; /* The actual embedded graphic data. The total
56 * length is inferred from sequential entries in
57 * the glyphDataOffsets array and the fixed size
58 * (8 bytes) of the preceding fields. */
59 public:
60 DEFINE_SIZE_ARRAY (8, data);
61};
62
63struct SBIXStrike
64{
65 bool sanitize (hb_sanitize_context_t *c) const
66 {
67 TRACE_SANITIZE (this);
68 return_trace (c->check_struct (this) &&
69 imageOffsetsZ.sanitize_shallow (c, c->get_num_glyphs () + 1));
70 }
71
72 hb_blob_t *get_glyph_blob (unsigned int glyph_id,
73 hb_blob_t *sbix_blob,
74 hb_tag_t file_type,
75 int *x_offset,
76 int *y_offset,
77 unsigned int num_glyphs,
78 unsigned int *strike_ppem) const
79 {
80 if (unlikely (!ppem)) return hb_blob_get_empty (); /* To get Null() object out of the way. */
81
82 unsigned int retry_count = 8;
83 unsigned int sbix_len = sbix_blob->length;
84 unsigned int strike_offset = (const char *) this - (const char *) sbix_blob->data;
85 assert (strike_offset < sbix_len);
86
87 retry:
88 if (unlikely (glyph_id >= num_glyphs ||
89 imageOffsetsZ[glyph_id + 1] <= imageOffsetsZ[glyph_id] ||
90 imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] <= SBIXGlyph::min_size ||
91 (unsigned int) imageOffsetsZ[glyph_id + 1] > sbix_len - strike_offset))
92 return hb_blob_get_empty ();
93
94 unsigned int glyph_offset = strike_offset + (unsigned int) imageOffsetsZ[glyph_id] + SBIXGlyph::min_size;
95 unsigned int glyph_length = imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] - SBIXGlyph::min_size;
96
97 const SBIXGlyph *glyph = &(this+imageOffsetsZ[glyph_id]);
98
99 if (glyph->graphicType == HB_TAG ('d','u','p','e'))
100 {
101 if (glyph_length >= 2)
102 {
103 glyph_id = *((HBUINT16 *) &glyph->data);
104 if (retry_count--)
105 goto retry;
106 }
107 return hb_blob_get_empty ();
108 }
109
110 if (unlikely (file_type != glyph->graphicType))
111 return hb_blob_get_empty ();
112
113 if (strike_ppem) *strike_ppem = ppem;
114 if (x_offset) *x_offset = glyph->xOffset;
115 if (y_offset) *y_offset = glyph->yOffset;
116 return hb_blob_create_sub_blob (sbix_blob, glyph_offset, glyph_length);
117 }
118
119 public:
120 HBUINT16 ppem; /* The PPEM size for which this strike was designed. */
121 HBUINT16 resolution; /* The device pixel density (in PPI) for which this
122 * strike was designed. (E.g., 96 PPI, 192 PPI.) */
123 protected:
124 UnsizedArrayOf<LOffsetTo<SBIXGlyph>>
125 imageOffsetsZ; /* Offset from the beginning of the strike data header
126 * to bitmap data for an individual glyph ID. */
127 public:
128 DEFINE_SIZE_ARRAY (4, imageOffsetsZ);
129};
130
131struct sbix
132{
133 static constexpr hb_tag_t tableTag = HB_OT_TAG_sbix;
134
135 bool has_data () const { return version; }
136
137 const SBIXStrike &get_strike (unsigned int i) const { return this+strikes[i]; }
138
139 struct accelerator_t
140 {
141 void init (hb_face_t *face)
142 {
143 table = hb_sanitize_context_t().reference_table<sbix> (face);
144 num_glyphs = face->get_num_glyphs ();
145 }
146 void fini () { table.destroy (); }
147
148 bool has_data () const { return table->has_data (); }
149
150 bool get_extents (hb_font_t *font,
151 hb_codepoint_t glyph,
152 hb_glyph_extents_t *extents) const
153 {
154 /* We only support PNG right now, and following function checks type. */
155 return get_png_extents (font, glyph, extents);
156 }
157
158 hb_blob_t *reference_png (hb_font_t *font,
159 hb_codepoint_t glyph_id,
160 int *x_offset,
161 int *y_offset,
162 unsigned int *available_ppem) const
163 {
164 return choose_strike (font).get_glyph_blob (glyph_id, table.get_blob (),
165 HB_TAG ('p','n','g',' '),
166 x_offset, y_offset,
167 num_glyphs, available_ppem);
168 }
169
170 private:
171
172 const SBIXStrike &choose_strike (hb_font_t *font) const
173 {
174 unsigned count = table->strikes.len;
175 if (unlikely (!count))
176 return Null(SBIXStrike);
177
178 unsigned int requested_ppem = hb_max (font->x_ppem, font->y_ppem);
179 if (!requested_ppem)
180 requested_ppem = 1<<30; /* Choose largest strike. */
181 /* TODO Add DPI sensitivity as well? */
182 unsigned int best_i = 0;
183 unsigned int best_ppem = table->get_strike (0).ppem;
184
185 for (unsigned int i = 1; i < count; i++)
186 {
187 unsigned int ppem = (table->get_strike (i)).ppem;
188 if ((requested_ppem <= ppem && ppem < best_ppem) ||
189 (requested_ppem > best_ppem && ppem > best_ppem))
190 {
191 best_i = i;
192 best_ppem = ppem;
193 }
194 }
195
196 return table->get_strike (best_i);
197 }
198
199 struct PNGHeader
200 {
201 HBUINT8 signature[8];
202 struct
203 {
204 struct
205 {
206 HBUINT32 length;
207 Tag type;
208 } header;
209 HBUINT32 width;
210 HBUINT32 height;
211 HBUINT8 bitDepth;
212 HBUINT8 colorType;
213 HBUINT8 compressionMethod;
214 HBUINT8 filterMethod;
215 HBUINT8 interlaceMethod;
216 } IHDR;
217
218 public:
219 DEFINE_SIZE_STATIC (29);
220 };
221
222 bool get_png_extents (hb_font_t *font,
223 hb_codepoint_t glyph,
224 hb_glyph_extents_t *extents) const
225 {
226 /* Following code is safe to call even without data.
227 * But faster to short-circuit. */
228 if (!has_data ())
229 return false;
230
231 int x_offset = 0, y_offset = 0;
232 unsigned int strike_ppem = 0;
233 hb_blob_t *blob = reference_png (font, glyph, &x_offset, &y_offset, &strike_ppem);
234
235 const PNGHeader &png = *blob->as<PNGHeader>();
236
237 extents->x_bearing = x_offset;
238 extents->y_bearing = png.IHDR.height + y_offset;
239 extents->width = png.IHDR.width;
240 extents->height = -png.IHDR.height;
241
242 /* Convert to font units. */
243 if (strike_ppem)
244 {
245 float scale = font->face->get_upem () / (float) strike_ppem;
246 extents->x_bearing = font->em_scalef_x (extents->x_bearing * scale);
247 extents->y_bearing = font->em_scalef_y (extents->y_bearing * scale);
248 extents->width = font->em_scalef_x (extents->width * scale);
249 extents->height = font->em_scalef_y (extents->height * scale);
250 }
251 else
252 {
253 extents->x_bearing = font->em_scale_x (extents->x_bearing);
254 extents->y_bearing = font->em_scale_y (extents->y_bearing);
255 extents->width = font->em_scale_x (extents->width);
256 extents->height = font->em_scale_y (extents->height);
257 }
258
259 hb_blob_destroy (blob);
260
261 return strike_ppem;
262 }
263
264 private:
265 hb_blob_ptr_t<sbix> table;
266
267 unsigned int num_glyphs;
268 };
269
270 bool sanitize (hb_sanitize_context_t *c) const
271 {
272 TRACE_SANITIZE (this);
273 return_trace (likely (c->check_struct (this) &&
274 version >= 1 &&
275 strikes.sanitize (c, this)));
276 }
277
278 protected:
279 HBUINT16 version; /* Table version number — set to 1 */
280 HBUINT16 flags; /* Bit 0: Set to 1. Bit 1: Draw outlines.
281 * Bits 2 to 15: reserved (set to 0). */
282 LOffsetLArrayOf<SBIXStrike>
283 strikes; /* Offsets from the beginning of the 'sbix'
284 * table to data for each individual bitmap strike. */
285 public:
286 DEFINE_SIZE_ARRAY (8, strikes);
287};
288
289struct sbix_accelerator_t : sbix::accelerator_t {};
290
291} /* namespace OT */
292
293#endif /* HB_OT_COLOR_SBIX_TABLE_HH */
294