src/hb-ot-color-sbix-table.hh

   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 {
  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 (!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 {
  83   static unsigned int get_size (unsigned num_glyphs)
  84   { return min_size + num_glyphs * HBUINT32::static_size; }
  85
  86   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
  93   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
 140   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<LOffsetTo<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
 199   bool has_data () const { return version; }
 200
 201   const SBIXStrike &get_strike (unsigned int i) const { return this+strikes[i]; }
 202
 203   struct accelerator_t
 204   {
 205     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     }
 210     void fini () { table.destroy (); }
 211
 212     bool has_data () const { return table->has_data (); }
 213
 214     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
 222     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
 236     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
 286     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
 334   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
 343   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
 351   bool serialize_strike_offsets (hb_subset_context_t *c) const
 352   {
 353     TRACE_SERIALIZE (this);
 354
 355     auto *out = c->serializer->start_embed<LOffsetLArrayOf<SBIXStrike>> ();
 356     if (unlikely (!out)) return_trace (false);
 357     if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
 358
 359     hb_vector_t<LOffsetTo<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
 387   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   LOffsetLArrayOf<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 */