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 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 (!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 80 struct SBIXStrike 81 { get_sizeOT::SBIXStrike82 static unsigned int get_size (unsigned num_glyphs) 83 { return min_size + num_glyphs * HBUINT32::static_size; } 84 sanitizeOT::SBIXStrike85 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 get_glyph_blobOT::SBIXStrike92 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 subsetOT::SBIXStrike139 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 193 struct sbix 194 { 195 static constexpr hb_tag_t tableTag = HB_OT_TAG_sbix; 196 has_dataOT::sbix197 bool has_data () const { return version; } 198 get_strikeOT::sbix199 const SBIXStrike &get_strike (unsigned int i) const { return this+strikes[i]; } 200 201 struct accelerator_t 202 { accelerator_tOT::sbix::accelerator_t203 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 } ~accelerator_tOT::sbix::accelerator_t208 ~accelerator_t () { table.destroy (); } 209 has_dataOT::sbix::accelerator_t210 bool has_data () const { return table->has_data (); } 211 get_extentsOT::sbix::accelerator_t212 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 reference_pngOT::sbix::accelerator_t221 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 paint_glyphOT::sbix::accelerator_t233 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 choose_strikeOT::sbix::accelerator_t266 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 get_png_extentsOT::sbix::accelerator_t316 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 sanitizeOT::sbix367 bool sanitize (hb_sanitize_context_t *c) const 368 { 369 TRACE_SANITIZE (this); 370 return_trace (likely (c->check_struct (this) && 371 hb_barrier () && 372 version >= 1 && 373 strikes.sanitize (c, this))); 374 } 375 376 bool add_strikeOT::sbix377 add_strike (hb_subset_context_t *c, unsigned i) const 378 { 379 if (strikes[i].is_null () || c->source_blob->length < (unsigned) strikes[i]) 380 return false; 381 382 return (this+strikes[i]).subset (c, c->source_blob->length - (unsigned) strikes[i]); 383 } 384 serialize_strike_offsetsOT::sbix385 bool serialize_strike_offsets (hb_subset_context_t *c) const 386 { 387 TRACE_SERIALIZE (this); 388 389 auto *out = c->serializer->start_embed<Array32OfOffset32To<SBIXStrike>> (); 390 if (unlikely (!c->serializer->extend_min (out))) return_trace (false); 391 392 hb_vector_t<Offset32To<SBIXStrike>*> new_strikes; 393 hb_vector_t<hb_serialize_context_t::objidx_t> objidxs; 394 for (int i = strikes.len - 1; i >= 0; --i) 395 { 396 auto* o = out->serialize_append (c->serializer); 397 if (unlikely (!o)) return_trace (false); 398 *o = 0; 399 auto snap = c->serializer->snapshot (); 400 c->serializer->push (); 401 bool ret = add_strike (c, i); 402 if (!ret) 403 { 404 c->serializer->pop_discard (); 405 out->pop (); 406 c->serializer->revert (snap); 407 } 408 else 409 { 410 objidxs.push (c->serializer->pop_pack ()); 411 new_strikes.push (o); 412 } 413 } 414 for (unsigned int i = 0; i < new_strikes.length; ++i) 415 c->serializer->add_link (*new_strikes[i], objidxs[new_strikes.length - 1 - i]); 416 417 return_trace (true); 418 } 419 subsetOT::sbix420 bool subset (hb_subset_context_t* c) const 421 { 422 TRACE_SUBSET (this); 423 424 if (unlikely (!c->serializer->embed (this->version))) return_trace (false); 425 if (unlikely (!c->serializer->embed (this->flags))) return_trace (false); 426 427 return_trace (serialize_strike_offsets (c)); 428 } 429 430 protected: 431 HBUINT16 version; /* Table version number — set to 1 */ 432 HBUINT16 flags; /* Bit 0: Set to 1. Bit 1: Draw outlines. 433 * Bits 2 to 15: reserved (set to 0). */ 434 Array32OfOffset32To<SBIXStrike> 435 strikes; /* Offsets from the beginning of the 'sbix' 436 * table to data for each individual bitmap strike. */ 437 public: 438 DEFINE_SIZE_ARRAY (8, strikes); 439 }; 440 441 struct sbix_accelerator_t : sbix::accelerator_t { sbix_accelerator_tOT::sbix_accelerator_t442 sbix_accelerator_t (hb_face_t *face) : sbix::accelerator_t (face) {} 443 }; 444 445 446 } /* namespace OT */ 447 448 #endif /* OT_COLOR_SBIX_SBIX_HH */ 449