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

   1 /*
   2  * Copyright © 2016  Google, Inc.
   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  * Google Author(s): Seigo Nonaka
  25  */
  26
  27 #ifndef HB_OT_COLOR_CBDT_TABLE_HH
  28 #define HB_OT_COLOR_CBDT_TABLE_HH
  29
  30 #include "hb-open-type-private.hh"
  31
  32 /*
  33  * CBLC -- Color Bitmap Location
  34  * https://docs.microsoft.com/en-us/typography/opentype/spec/cblc
  35  * https://docs.microsoft.com/en-us/typography/opentype/spec/eblc
  36  * CBDT -- Color Bitmap Data
  37  * https://docs.microsoft.com/en-us/typography/opentype/spec/cbdt
  38  * https://docs.microsoft.com/en-us/typography/opentype/spec/ebdt
  39  */
  40 #define HB_OT_TAG_CBLC HB_TAG('C','B','L','C')
  41 #define HB_OT_TAG_CBDT HB_TAG('C','B','D','T')
  42
  43
  44 namespace OT {
  45
  46 struct SmallGlyphMetrics
  47 {
  48   inline bool sanitize (hb_sanitize_context_t *c) const
  49   {
  50     TRACE_SANITIZE (this);
  51     return_trace (c->check_struct (this));
  52   }
  53
  54   inline void get_extents (hb_glyph_extents_t *extents) const
  55   {
  56     extents->x_bearing = bearingX;
  57     extents->y_bearing = bearingY;
  58     extents->width = width;
  59     extents->height = -height;
  60   }
  61
  62   HBUINT8       height;
  63   HBUINT8       width;
  64   HBINT8        bearingX;
  65   HBINT8        bearingY;
  66   HBUINT8       advance;
  67   public:
  68   DEFINE_SIZE_STATIC(5);
  69 };
  70
  71 struct BigGlyphMetrics : SmallGlyphMetrics
  72 {
  73   HBINT8        vertBearingX;
  74   HBINT8        vertBearingY;
  75   HBUINT8       vertAdvance;
  76   public:
  77   DEFINE_SIZE_STATIC(8);
  78 };
  79
  80 struct SBitLineMetrics
  81 {
  82   inline bool sanitize (hb_sanitize_context_t *c) const
  83   {
  84     TRACE_SANITIZE (this);
  85     return_trace (c->check_struct (this));
  86   }
  87
  88   HBINT8        ascender;
  89   HBINT8        decender;
  90   HBUINT8       widthMax;
  91   HBINT8        caretSlopeNumerator;
  92   HBINT8        caretSlopeDenominator;
  93   HBINT8        caretOffset;
  94   HBINT8        minOriginSB;
  95   HBINT8        minAdvanceSB;
  96   HBINT8        maxBeforeBL;
  97   HBINT8        minAfterBL;
  98   HBINT8        padding1;
  99   HBINT8        padding2;
 100   public:
 101   DEFINE_SIZE_STATIC(12);
 102 };
 103
 104
 105 /*
 106  * Index Subtables.
 107  */
 108
 109 struct IndexSubtableHeader
 110 {
 111   inline bool sanitize (hb_sanitize_context_t *c) const
 112   {
 113     TRACE_SANITIZE (this);
 114     return_trace (c->check_struct (this));
 115   }
 116
 117   HBUINT16      indexFormat;
 118   HBUINT16      imageFormat;
 119   HBUINT32      imageDataOffset;
 120   public:
 121   DEFINE_SIZE_STATIC(8);
 122 };
 123
 124 template <typename OffsetType>
 125 struct IndexSubtableFormat1Or3
 126 {
 127   inline bool sanitize (hb_sanitize_context_t *c, unsigned int glyph_count) const
 128   {
 129     TRACE_SANITIZE (this);
 130     return_trace (c->check_struct (this) &&
 131                   c->check_array (offsetArrayZ, offsetArrayZ[0].static_size, glyph_count + 1));
 132   }
 133
 134   bool get_image_data (unsigned int idx,
 135                        unsigned int *offset,
 136                        unsigned int *length) const
 137   {
 138     if (unlikely (offsetArrayZ[idx + 1] <= offsetArrayZ[idx]))
 139       return false;
 140
 141     *offset = header.imageDataOffset + offsetArrayZ[idx];
 142     *length = offsetArrayZ[idx + 1] - offsetArrayZ[idx];
 143     return true;
 144   }
 145
 146   IndexSubtableHeader   header;
 147   Offset<OffsetType>    offsetArrayZ[VAR];
 148   public:
 149   DEFINE_SIZE_ARRAY(8, offsetArrayZ);
 150 };
 151
 152 struct IndexSubtableFormat1 : IndexSubtableFormat1Or3<HBUINT32> {};
 153 struct IndexSubtableFormat3 : IndexSubtableFormat1Or3<HBUINT16> {};
 154
 155 struct IndexSubtable
 156 {
 157   inline bool sanitize (hb_sanitize_context_t *c, unsigned int glyph_count) const
 158   {
 159     TRACE_SANITIZE (this);
 160     if (!u.header.sanitize (c)) return_trace (false);
 161     switch (u.header.indexFormat) {
 162     case 1: return_trace (u.format1.sanitize (c, glyph_count));
 163     case 3: return_trace (u.format3.sanitize (c, glyph_count));
 164     default:return_trace (true);
 165     }
 166   }
 167
 168   inline bool get_extents (hb_glyph_extents_t *extents) const
 169   {
 170     switch (u.header.indexFormat) {
 171     case 2: case 5: /* TODO */
 172     case 1: case 3: case 4: /* Variable-metrics formats do not have metrics here. */
 173     default:return (false);
 174     }
 175   }
 176
 177   bool get_image_data (unsigned int idx,
 178                        unsigned int *offset,
 179                        unsigned int *length,
 180                        unsigned int *format) const
 181   {
 182     *format = u.header.imageFormat;
 183     switch (u.header.indexFormat) {
 184     case 1: return u.format1.get_image_data (idx, offset, length);
 185     case 3: return u.format3.get_image_data (idx, offset, length);
 186     default: return false;
 187     }
 188   }
 189
 190   protected:
 191   union {
 192   IndexSubtableHeader   header;
 193   IndexSubtableFormat1  format1;
 194   IndexSubtableFormat3  format3;
 195   /* TODO: Format 2, 4, 5. */
 196   } u;
 197   public:
 198   DEFINE_SIZE_UNION (8, header);
 199 };
 200
 201 struct IndexSubtableRecord
 202 {
 203   inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
 204   {
 205     TRACE_SANITIZE (this);
 206     return_trace (c->check_struct (this) &&
 207                   firstGlyphIndex <= lastGlyphIndex &&
 208                   offsetToSubtable.sanitize (c, this, lastGlyphIndex - firstGlyphIndex + 1));
 209   }
 210
 211   inline bool get_extents (hb_glyph_extents_t *extents) const
 212   {
 213     return (this+offsetToSubtable).get_extents (extents);
 214   }
 215
 216   bool get_image_data (unsigned int gid,
 217                        unsigned int *offset,
 218                        unsigned int *length,
 219                        unsigned int *format) const
 220   {
 221     if (gid < firstGlyphIndex || gid > lastGlyphIndex)
 222     {
 223       return false;
 224     }
 225     return (this+offsetToSubtable).get_image_data (gid - firstGlyphIndex,
 226                                                    offset, length, format);
 227   }
 228
 229   GlyphID                       firstGlyphIndex;
 230   GlyphID                       lastGlyphIndex;
 231   LOffsetTo<IndexSubtable>      offsetToSubtable;
 232   public:
 233   DEFINE_SIZE_STATIC(8);
 234 };
 235
 236 struct IndexSubtableArray
 237 {
 238   friend struct CBDT;
 239
 240   inline bool sanitize (hb_sanitize_context_t *c, unsigned int count) const
 241   {
 242     TRACE_SANITIZE (this);
 243     if (unlikely (!c->check_array (&indexSubtablesZ, indexSubtablesZ[0].static_size, count)))
 244       return_trace (false);
 245     for (unsigned int i = 0; i < count; i++)
 246       if (unlikely (!indexSubtablesZ[i].sanitize (c, this)))
 247         return_trace (false);
 248     return_trace (true);
 249   }
 250
 251   public:
 252   const IndexSubtableRecord* find_table (hb_codepoint_t glyph, unsigned int numTables) const
 253   {
 254     for (unsigned int i = 0; i < numTables; ++i)
 255     {
 256       unsigned int firstGlyphIndex = indexSubtablesZ[i].firstGlyphIndex;
 257       unsigned int lastGlyphIndex = indexSubtablesZ[i].lastGlyphIndex;
 258       if (firstGlyphIndex <= glyph && glyph <= lastGlyphIndex) {
 259         return &indexSubtablesZ[i];
 260       }
 261     }
 262     return nullptr;
 263   }
 264
 265   protected:
 266   IndexSubtableRecord   indexSubtablesZ[VAR];
 267   public:
 268   DEFINE_SIZE_ARRAY(0, indexSubtablesZ);
 269 };
 270
 271 struct BitmapSizeTable
 272 {
 273   friend struct CBLC;
 274   friend struct CBDT;
 275
 276   inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
 277   {
 278     TRACE_SANITIZE (this);
 279     return_trace (c->check_struct (this) &&
 280                   indexSubtableArrayOffset.sanitize (c, base, numberOfIndexSubtables) &&
 281                   c->check_range (&(base+indexSubtableArrayOffset), indexTablesSize) &&
 282                   horizontal.sanitize (c) &&
 283                   vertical.sanitize (c));
 284   }
 285
 286   const IndexSubtableRecord *find_table (hb_codepoint_t glyph, const void *base) const
 287   {
 288     return (base+indexSubtableArrayOffset).find_table (glyph, numberOfIndexSubtables);
 289   }
 290
 291   protected:
 292   LOffsetTo<IndexSubtableArray>
 293                         indexSubtableArrayOffset;
 294   HBUINT32              indexTablesSize;
 295   HBUINT32              numberOfIndexSubtables;
 296   HBUINT32              colorRef;
 297   SBitLineMetrics       horizontal;
 298   SBitLineMetrics       vertical;
 299   GlyphID               startGlyphIndex;
 300   GlyphID               endGlyphIndex;
 301   HBUINT8               ppemX;
 302   HBUINT8               ppemY;
 303   HBUINT8               bitDepth;
 304   HBINT8                flags;
 305   public:
 306   DEFINE_SIZE_STATIC(48);
 307 };
 308
 309
 310 /*
 311  * Glyph Bitmap Data Formats.
 312  */
 313
 314 struct GlyphBitmapDataFormat17
 315 {
 316   SmallGlyphMetrics     glyphMetrics;
 317   LArrayOf<HBUINT8>     data;
 318   public:
 319   DEFINE_SIZE_ARRAY(9, data);
 320 };
 321
 322 struct GlyphBitmapDataFormat18
 323 {
 324   BigGlyphMetrics       glyphMetrics;
 325   LArrayOf<HBUINT8>     data;
 326   public:
 327   DEFINE_SIZE_ARRAY(12, data);
 328 };
 329
 330 struct GlyphBitmapDataFormat19
 331 {
 332   LArrayOf<HBUINT8>     data;
 333   public:
 334   DEFINE_SIZE_ARRAY(4, data);
 335 };
 336
 337 struct CBLC
 338 {
 339   friend struct CBDT;
 340
 341   static const hb_tag_t tableTag = HB_OT_TAG_CBLC;
 342
 343   inline bool sanitize (hb_sanitize_context_t *c) const
 344   {
 345     TRACE_SANITIZE (this);
 346     return_trace (c->check_struct (this) &&
 347                   likely (version.major == 2 || version.major == 3) &&
 348                   sizeTables.sanitize (c, this));
 349   }
 350
 351   protected:
 352   const IndexSubtableRecord *find_table (hb_codepoint_t glyph,
 353                                          unsigned int *x_ppem, unsigned int *y_ppem) const
 354   {
 355     /* TODO: Make it possible to select strike. */
 356
 357     unsigned int count = sizeTables.len;
 358     for (uint32_t i = 0; i < count; ++i)
 359     {
 360       unsigned int startGlyphIndex = sizeTables.arrayZ[i].startGlyphIndex;
 361       unsigned int endGlyphIndex = sizeTables.arrayZ[i].endGlyphIndex;
 362       if (startGlyphIndex <= glyph && glyph <= endGlyphIndex)
 363       {
 364         *x_ppem = sizeTables[i].ppemX;
 365         *y_ppem = sizeTables[i].ppemY;
 366         return sizeTables[i].find_table (glyph, this);
 367       }
 368     }
 369
 370     return nullptr;
 371   }
 372
 373   protected:
 374   FixedVersion<>                version;
 375   LArrayOf<BitmapSizeTable>     sizeTables;
 376   public:
 377   DEFINE_SIZE_ARRAY(8, sizeTables);
 378 };
 379
 380 struct CBDT
 381 {
 382   static const hb_tag_t tableTag = HB_OT_TAG_CBDT;
 383
 384   inline bool sanitize (hb_sanitize_context_t *c) const
 385   {
 386     TRACE_SANITIZE (this);
 387     return_trace (c->check_struct (this) &&
 388                   likely (version.major == 2 || version.major == 3));
 389   }
 390
 391   struct accelerator_t
 392   {
 393     inline void init (hb_face_t *face)
 394     {
 395       upem = hb_face_get_upem (face);
 396
 397       cblc_blob = Sanitizer<CBLC>().sanitize (face->reference_table (HB_OT_TAG_CBLC));
 398       cbdt_blob = Sanitizer<CBDT>().sanitize (face->reference_table (HB_OT_TAG_CBDT));
 399       cbdt_len = hb_blob_get_length (cbdt_blob);
 400
 401       if (hb_blob_get_length (cblc_blob) == 0) {
 402         cblc = nullptr;
 403         cbdt = nullptr;
 404         return;  /* Not a bitmap font. */
 405       }
 406       cblc = cblc_blob->as<CBLC> ();
 407       cbdt = cbdt_blob->as<CBDT> ();
 408
 409     }
 410
 411     inline void fini (void)
 412     {
 413       hb_blob_destroy (this->cblc_blob);
 414       hb_blob_destroy (this->cbdt_blob);
 415     }
 416
 417     inline bool get_extents (hb_codepoint_t glyph, hb_glyph_extents_t *extents) const
 418     {
 419       unsigned int x_ppem = upem, y_ppem = upem; /* TODO Use font ppem if available. */
 420
 421       if (!cblc)
 422         return false;  // Not a color bitmap font.
 423
 424       const IndexSubtableRecord *subtable_record = this->cblc->find_table(glyph, &x_ppem, &y_ppem);
 425       if (!subtable_record || !x_ppem || !y_ppem)
 426         return false;
 427
 428       if (subtable_record->get_extents (extents))
 429         return true;
 430
 431       unsigned int image_offset = 0, image_length = 0, image_format = 0;
 432       if (!subtable_record->get_image_data (glyph, &image_offset, &image_length, &image_format))
 433         return false;
 434
 435       {
 436         if (unlikely (image_offset > cbdt_len || cbdt_len - image_offset < image_length))
 437           return false;
 438
 439         switch (image_format)
 440         {
 441           case 17: {
 442             if (unlikely (image_length < GlyphBitmapDataFormat17::min_size))
 443               return false;
 444
 445             const GlyphBitmapDataFormat17& glyphFormat17 =
 446                 StructAtOffset<GlyphBitmapDataFormat17> (this->cbdt, image_offset);
 447             glyphFormat17.glyphMetrics.get_extents (extents);
 448           }
 449           break;
 450           default:
 451             // TODO: Support other image formats.
 452             return false;
 453         }
 454       }
 455
 456       /* Convert to the font units. */
 457       extents->x_bearing *= upem / (float) x_ppem;
 458       extents->y_bearing *= upem / (float) y_ppem;
 459       extents->width *= upem / (float) x_ppem;
 460       extents->height *= upem / (float) y_ppem;
 461
 462       return true;
 463     }
 464
 465     inline void dump (void (*callback) (const uint8_t* data, unsigned int length,
 466         unsigned int group, unsigned int gid)) const
 467     {
 468       if (!cblc)
 469         return;  // Not a color bitmap font.
 470
 471       for (unsigned int i = 0; i < cblc->sizeTables.len; ++i)
 472       {
 473         const BitmapSizeTable &sizeTable = cblc->sizeTables[i];
 474         const IndexSubtableArray &subtable_array = cblc+sizeTable.indexSubtableArrayOffset;
 475         for (unsigned int j = 0; j < sizeTable.numberOfIndexSubtables; ++j)
 476         {
 477           const IndexSubtableRecord &subtable_record = subtable_array.indexSubtablesZ[j];
 478           for (unsigned int gid = subtable_record.firstGlyphIndex;
 479                 gid <= subtable_record.lastGlyphIndex; ++gid)
 480           {
 481             unsigned int image_offset = 0, image_length = 0, image_format = 0;
 482
 483             if (!subtable_record.get_image_data (gid,
 484                   &image_offset, &image_length, &image_format))
 485               continue;
 486
 487             switch (image_format)
 488             {
 489             case 17: {
 490               const GlyphBitmapDataFormat17& glyphFormat17 =
 491                 StructAtOffset<GlyphBitmapDataFormat17> (this->cbdt, image_offset);
 492               callback ((const uint8_t *) &glyphFormat17.data.arrayZ,
 493                 glyphFormat17.data.len, i, gid);
 494             }
 495             break;
 496             case 18: {
 497               const GlyphBitmapDataFormat18& glyphFormat18 =
 498                 StructAtOffset<GlyphBitmapDataFormat18> (this->cbdt, image_offset);
 499               callback ((const uint8_t *) &glyphFormat18.data.arrayZ,
 500                 glyphFormat18.data.len, i, gid);
 501             }
 502             break;
 503             case 19: {
 504               const GlyphBitmapDataFormat19& glyphFormat19 =
 505                 StructAtOffset<GlyphBitmapDataFormat19> (this->cbdt, image_offset);
 506               callback ((const uint8_t *) &glyphFormat19.data.arrayZ,
 507                 glyphFormat19.data.len, i, gid);
 508             }
 509             break;
 510             default:
 511               continue;
 512             }
 513           }
 514         }
 515       }
 516     }
 517
 518     private:
 519     hb_blob_t *cblc_blob;
 520     hb_blob_t *cbdt_blob;
 521     const CBLC *cblc;
 522     const CBDT *cbdt;
 523
 524     unsigned int cbdt_len;
 525     unsigned int upem;
 526   };
 527
 528
 529   protected:
 530   FixedVersion<>        version;
 531   HBUINT8               dataZ[VAR];
 532   public:
 533   DEFINE_SIZE_ARRAY(4, dataZ);
 534 };
 535
 536 } /* namespace OT */
 537
 538 #endif /* HB_OT_COLOR_CBDT_TABLE_HH */