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 HB_OT_COLOR_SBIX_TABLE_HH 29 #define HB_OT_COLOR_SBIX_TABLE_HH 30 31 #include "hb-open-type.hh" 32 #include "hb-ot-layout-common.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 42 namespace OT { 43 44 45 struct SBIXGlyph 46 { copyOT::SBIXGlyph47 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 (!new_glyph)) return_trace (nullptr); 52 if (unlikely (!c->extend_min (new_glyph))) return_trace (nullptr); 53 54 new_glyph->xOffset = xOffset; 55 new_glyph->yOffset = yOffset; 56 new_glyph->graphicType = graphicType; 57 data.copy (c, data_length); 58 return_trace (new_glyph); 59 } 60 61 HBINT16 xOffset; /* The horizontal (x-axis) offset from the left 62 * edge of the graphic to the glyph’s origin. 63 * That is, the x-coordinate of the point on the 64 * baseline at the left edge of the glyph. */ 65 HBINT16 yOffset; /* The vertical (y-axis) offset from the bottom 66 * edge of the graphic to the glyph’s origin. 67 * That is, the y-coordinate of the point on the 68 * baseline at the left edge of the glyph. */ 69 Tag graphicType; /* Indicates the format of the embedded graphic 70 * data: one of 'jpg ', 'png ' or 'tiff', or the 71 * special format 'dupe'. */ 72 UnsizedArrayOf<HBUINT8> 73 data; /* The actual embedded graphic data. The total 74 * length is inferred from sequential entries in 75 * the glyphDataOffsets array and the fixed size 76 * (8 bytes) of the preceding fields. */ 77 public: 78 DEFINE_SIZE_ARRAY (8, data); 79 }; 80 81 struct SBIXStrike 82 { get_sizeOT::SBIXStrike83 static unsigned int get_size (unsigned num_glyphs) 84 { return min_size + num_glyphs * HBUINT32::static_size; } 85 sanitizeOT::SBIXStrike86 bool sanitize (hb_sanitize_context_t *c) const 87 { 88 TRACE_SANITIZE (this); 89 return_trace (c->check_struct (this) && 90 imageOffsetsZ.sanitize_shallow (c, c->get_num_glyphs () + 1)); 91 } 92 get_glyph_blobOT::SBIXStrike93 hb_blob_t *get_glyph_blob (unsigned int glyph_id, 94 hb_blob_t *sbix_blob, 95 hb_tag_t file_type, 96 int *x_offset, 97 int *y_offset, 98 unsigned int num_glyphs, 99 unsigned int *strike_ppem) const 100 { 101 if (unlikely (!ppem)) return hb_blob_get_empty (); /* To get Null() object out of the way. */ 102 103 unsigned int retry_count = 8; 104 unsigned int sbix_len = sbix_blob->length; 105 unsigned int strike_offset = (const char *) this - (const char *) sbix_blob->data; 106 assert (strike_offset < sbix_len); 107 108 retry: 109 if (unlikely (glyph_id >= num_glyphs || 110 imageOffsetsZ[glyph_id + 1] <= imageOffsetsZ[glyph_id] || 111 imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] <= SBIXGlyph::min_size || 112 (unsigned int) imageOffsetsZ[glyph_id + 1] > sbix_len - strike_offset)) 113 return hb_blob_get_empty (); 114 115 unsigned int glyph_offset = strike_offset + (unsigned int) imageOffsetsZ[glyph_id] + SBIXGlyph::min_size; 116 unsigned int glyph_length = imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] - SBIXGlyph::min_size; 117 118 const SBIXGlyph *glyph = &(this+imageOffsetsZ[glyph_id]); 119 120 if (glyph->graphicType == HB_TAG ('d','u','p','e')) 121 { 122 if (glyph_length >= 2) 123 { 124 glyph_id = *((HBUINT16 *) &glyph->data); 125 if (retry_count--) 126 goto retry; 127 } 128 return hb_blob_get_empty (); 129 } 130 131 if (unlikely (file_type != glyph->graphicType)) 132 return hb_blob_get_empty (); 133 134 if (strike_ppem) *strike_ppem = ppem; 135 if (x_offset) *x_offset = glyph->xOffset; 136 if (y_offset) *y_offset = glyph->yOffset; 137 return hb_blob_create_sub_blob (sbix_blob, glyph_offset, glyph_length); 138 } 139 subsetOT::SBIXStrike140 bool subset (hb_subset_context_t *c, unsigned int available_len) const 141 { 142 TRACE_SUBSET (this); 143 unsigned int num_output_glyphs = c->plan->num_output_glyphs (); 144 145 auto* out = c->serializer->start_embed<SBIXStrike> (); 146 if (unlikely (!out)) return_trace (false); 147 auto snap = c->serializer->snapshot (); 148 if (unlikely (!c->serializer->extend (*out, num_output_glyphs + 1))) return_trace (false); 149 out->ppem = ppem; 150 out->resolution = resolution; 151 HBUINT32 head; 152 head = get_size (num_output_glyphs + 1); 153 154 bool has_glyphs = false; 155 for (unsigned new_gid = 0; new_gid < num_output_glyphs; new_gid++) 156 { 157 hb_codepoint_t old_gid; 158 if (!c->plan->old_gid_for_new_gid (new_gid, &old_gid) || 159 unlikely (imageOffsetsZ[old_gid].is_null () || 160 imageOffsetsZ[old_gid + 1].is_null () || 161 imageOffsetsZ[old_gid + 1] <= imageOffsetsZ[old_gid] || 162 imageOffsetsZ[old_gid + 1] - imageOffsetsZ[old_gid] <= SBIXGlyph::min_size) || 163 (unsigned int) imageOffsetsZ[old_gid + 1] > available_len) 164 { 165 out->imageOffsetsZ[new_gid] = head; 166 continue; 167 } 168 has_glyphs = true; 169 unsigned int delta = imageOffsetsZ[old_gid + 1] - imageOffsetsZ[old_gid]; 170 unsigned int glyph_data_length = delta - SBIXGlyph::min_size; 171 if (!(this+imageOffsetsZ[old_gid]).copy (c->serializer, glyph_data_length)) 172 return_trace (false); 173 out->imageOffsetsZ[new_gid] = head; 174 head += delta; 175 } 176 if (has_glyphs) 177 out->imageOffsetsZ[num_output_glyphs] = head; 178 else 179 c->serializer->revert (snap); 180 return_trace (has_glyphs); 181 } 182 183 public: 184 HBUINT16 ppem; /* The PPEM size for which this strike was designed. */ 185 HBUINT16 resolution; /* The device pixel density (in PPI) for which this 186 * strike was designed. (E.g., 96 PPI, 192 PPI.) */ 187 protected: 188 UnsizedArrayOf<Offset32To<SBIXGlyph>> 189 imageOffsetsZ; /* Offset from the beginning of the strike data header 190 * to bitmap data for an individual glyph ID. */ 191 public: 192 DEFINE_SIZE_ARRAY (4, imageOffsetsZ); 193 }; 194 195 struct sbix 196 { 197 static constexpr hb_tag_t tableTag = HB_OT_TAG_sbix; 198 has_dataOT::sbix199 bool has_data () const { return version; } 200 get_strikeOT::sbix201 const SBIXStrike &get_strike (unsigned int i) const { return this+strikes[i]; } 202 203 struct accelerator_t 204 { initOT::sbix::accelerator_t205 void init (hb_face_t *face) 206 { 207 table = hb_sanitize_context_t ().reference_table<sbix> (face); 208 num_glyphs = face->get_num_glyphs (); 209 } finiOT::sbix::accelerator_t210 void fini () { table.destroy (); } 211 has_dataOT::sbix::accelerator_t212 bool has_data () const { return table->has_data (); } 213 get_extentsOT::sbix::accelerator_t214 bool get_extents (hb_font_t *font, 215 hb_codepoint_t glyph, 216 hb_glyph_extents_t *extents) const 217 { 218 /* We only support PNG right now, and following function checks type. */ 219 return get_png_extents (font, glyph, extents); 220 } 221 reference_pngOT::sbix::accelerator_t222 hb_blob_t *reference_png (hb_font_t *font, 223 hb_codepoint_t glyph_id, 224 int *x_offset, 225 int *y_offset, 226 unsigned int *available_ppem) const 227 { 228 return choose_strike (font).get_glyph_blob (glyph_id, table.get_blob (), 229 HB_TAG ('p','n','g',' '), 230 x_offset, y_offset, 231 num_glyphs, available_ppem); 232 } 233 234 private: 235 choose_strikeOT::sbix::accelerator_t236 const SBIXStrike &choose_strike (hb_font_t *font) const 237 { 238 unsigned count = table->strikes.len; 239 if (unlikely (!count)) 240 return Null (SBIXStrike); 241 242 unsigned int requested_ppem = hb_max (font->x_ppem, font->y_ppem); 243 if (!requested_ppem) 244 requested_ppem = 1<<30; /* Choose largest strike. */ 245 /* TODO Add DPI sensitivity as well? */ 246 unsigned int best_i = 0; 247 unsigned int best_ppem = table->get_strike (0).ppem; 248 249 for (unsigned int i = 1; i < count; i++) 250 { 251 unsigned int ppem = (table->get_strike (i)).ppem; 252 if ((requested_ppem <= ppem && ppem < best_ppem) || 253 (requested_ppem > best_ppem && ppem > best_ppem)) 254 { 255 best_i = i; 256 best_ppem = ppem; 257 } 258 } 259 260 return table->get_strike (best_i); 261 } 262 263 struct PNGHeader 264 { 265 HBUINT8 signature[8]; 266 struct 267 { 268 struct 269 { 270 HBUINT32 length; 271 Tag type; 272 } header; 273 HBUINT32 width; 274 HBUINT32 height; 275 HBUINT8 bitDepth; 276 HBUINT8 colorType; 277 HBUINT8 compressionMethod; 278 HBUINT8 filterMethod; 279 HBUINT8 interlaceMethod; 280 } IHDR; 281 282 public: 283 DEFINE_SIZE_STATIC (29); 284 }; 285 get_png_extentsOT::sbix::accelerator_t286 bool get_png_extents (hb_font_t *font, 287 hb_codepoint_t glyph, 288 hb_glyph_extents_t *extents) const 289 { 290 /* Following code is safe to call even without data. 291 * But faster to short-circuit. */ 292 if (!has_data ()) 293 return false; 294 295 int x_offset = 0, y_offset = 0; 296 unsigned int strike_ppem = 0; 297 hb_blob_t *blob = reference_png (font, glyph, &x_offset, &y_offset, &strike_ppem); 298 299 const PNGHeader &png = *blob->as<PNGHeader>(); 300 301 extents->x_bearing = x_offset; 302 extents->y_bearing = png.IHDR.height + y_offset; 303 extents->width = png.IHDR.width; 304 extents->height = -1 * png.IHDR.height; 305 306 /* Convert to font units. */ 307 if (strike_ppem) 308 { 309 float scale = font->face->get_upem () / (float) strike_ppem; 310 extents->x_bearing = font->em_scalef_x (extents->x_bearing * scale); 311 extents->y_bearing = font->em_scalef_y (extents->y_bearing * scale); 312 extents->width = font->em_scalef_x (extents->width * scale); 313 extents->height = font->em_scalef_y (extents->height * scale); 314 } 315 else 316 { 317 extents->x_bearing = font->em_scale_x (extents->x_bearing); 318 extents->y_bearing = font->em_scale_y (extents->y_bearing); 319 extents->width = font->em_scale_x (extents->width); 320 extents->height = font->em_scale_y (extents->height); 321 } 322 323 hb_blob_destroy (blob); 324 325 return strike_ppem; 326 } 327 328 private: 329 hb_blob_ptr_t<sbix> table; 330 331 unsigned int num_glyphs; 332 }; 333 sanitizeOT::sbix334 bool sanitize (hb_sanitize_context_t *c) const 335 { 336 TRACE_SANITIZE (this); 337 return_trace (likely (c->check_struct (this) && 338 version >= 1 && 339 strikes.sanitize (c, this))); 340 } 341 342 bool add_strikeOT::sbix343 add_strike (hb_subset_context_t *c, unsigned i) const 344 { 345 if (strikes[i].is_null () || c->source_blob->length < (unsigned) strikes[i]) 346 return false; 347 348 return (this+strikes[i]).subset (c, c->source_blob->length - (unsigned) strikes[i]); 349 } 350 serialize_strike_offsetsOT::sbix351 bool serialize_strike_offsets (hb_subset_context_t *c) const 352 { 353 TRACE_SERIALIZE (this); 354 355 auto *out = c->serializer->start_embed<Array32OfOffset32To<SBIXStrike>> (); 356 if (unlikely (!out)) return_trace (false); 357 if (unlikely (!c->serializer->extend_min (out))) return_trace (false); 358 359 hb_vector_t<Offset32To<SBIXStrike>*> new_strikes; 360 hb_vector_t<hb_serialize_context_t::objidx_t> objidxs; 361 for (int i = strikes.len - 1; i >= 0; --i) 362 { 363 auto* o = out->serialize_append (c->serializer); 364 if (unlikely (!o)) return_trace (false); 365 *o = 0; 366 auto snap = c->serializer->snapshot (); 367 c->serializer->push (); 368 bool ret = add_strike (c, i); 369 if (!ret) 370 { 371 c->serializer->pop_discard (); 372 out->pop (); 373 c->serializer->revert (snap); 374 } 375 else 376 { 377 objidxs.push (c->serializer->pop_pack ()); 378 new_strikes.push (o); 379 } 380 } 381 for (unsigned int i = 0; i < new_strikes.length; ++i) 382 c->serializer->add_link (*new_strikes[i], objidxs[new_strikes.length - 1 - i]); 383 384 return_trace (true); 385 } 386 subsetOT::sbix387 bool subset (hb_subset_context_t* c) const 388 { 389 TRACE_SUBSET (this); 390 391 sbix *sbix_prime = c->serializer->start_embed<sbix> (); 392 if (unlikely (!sbix_prime)) return_trace (false); 393 if (unlikely (!c->serializer->embed (this->version))) return_trace (false); 394 if (unlikely (!c->serializer->embed (this->flags))) return_trace (false); 395 396 return_trace (serialize_strike_offsets (c)); 397 } 398 399 protected: 400 HBUINT16 version; /* Table version number — set to 1 */ 401 HBUINT16 flags; /* Bit 0: Set to 1. Bit 1: Draw outlines. 402 * Bits 2 to 15: reserved (set to 0). */ 403 Array32OfOffset32To<SBIXStrike> 404 strikes; /* Offsets from the beginning of the 'sbix' 405 * table to data for each individual bitmap strike. */ 406 public: 407 DEFINE_SIZE_ARRAY (8, strikes); 408 }; 409 410 struct sbix_accelerator_t : sbix::accelerator_t {}; 411 412 } /* namespace OT */ 413 414 #endif /* HB_OT_COLOR_SBIX_TABLE_HH */ 415