src/hb-ot-hdmx-table.hh

   1 /*
   2  * Copyright © 2018  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): Garret Rieger
  25  */
  26
  27 #ifndef HB_OT_HDMX_TABLE_HH
  28 #define HB_OT_HDMX_TABLE_HH
  29
  30 #include "hb-open-type.hh"
  31
  32 /*
  33  * hdmx -- Horizontal Device Metrics
  34  * https://docs.microsoft.com/en-us/typography/opentype/spec/hdmx
  35  */
  36 #define HB_OT_TAG_hdmx HB_TAG('h','d','m','x')
  37
  38
  39 namespace OT {
  40
  41
  42 struct DeviceRecord
  43 {
  44   static unsigned int get_size (unsigned count)
  45   { return hb_ceil_to_4 (min_size + count * HBUINT8::static_size); }
  46
  47   template<typename Iterator,
  48            hb_requires (hb_is_iterator (Iterator))>
  49   bool serialize (hb_serialize_context_t *c,
  50                   unsigned pixelSize,
  51                   Iterator it,
  52                   const hb_vector_t<hb_codepoint_pair_t> new_to_old_gid_list,
  53                   unsigned num_glyphs)
  54   {
  55     TRACE_SERIALIZE (this);
  56
  57     if (unlikely (!c->extend (this, num_glyphs)))  return_trace (false);
  58
  59     this->pixelSize = pixelSize;
  60     this->maxWidth =
  61     + it
  62     | hb_reduce (hb_max, 0u);
  63
  64     for (auto &_ : new_to_old_gid_list)
  65       widthsZ[_.first] = *it++;
  66
  67     return_trace (true);
  68   }
  69
  70   bool sanitize (hb_sanitize_context_t *c, unsigned sizeDeviceRecord) const
  71   {
  72     TRACE_SANITIZE (this);
  73     return_trace (likely (c->check_struct (this) &&
  74                           c->check_range (this, sizeDeviceRecord)));
  75   }
  76
  77   HBUINT8                       pixelSize;      /* Pixel size for following widths (as ppem). */
  78   HBUINT8                       maxWidth;       /* Maximum width. */
  79   UnsizedArrayOf<HBUINT8>       widthsZ;        /* Array of widths (numGlyphs is from the 'maxp' table). */
  80   public:
  81   DEFINE_SIZE_UNBOUNDED (2);
  82 };
  83
  84
  85 struct hdmx
  86 {
  87   static constexpr hb_tag_t tableTag = HB_OT_TAG_hdmx;
  88
  89   unsigned int get_size () const
  90   { return min_size + numRecords * sizeDeviceRecord; }
  91
  92   template<typename Iterator,
  93            hb_requires (hb_is_iterator (Iterator))>
  94   bool serialize (hb_serialize_context_t *c,
  95                   unsigned version,
  96                   Iterator it,
  97                   const hb_vector_t<hb_codepoint_pair_t> &new_to_old_gid_list,
  98                   unsigned num_glyphs)
  99   {
 100     TRACE_SERIALIZE (this);
 101
 102     if (unlikely (!c->extend_min ((*this))))  return_trace (false);
 103
 104     this->version = version;
 105     this->numRecords = it.len ();
 106     this->sizeDeviceRecord = DeviceRecord::get_size (num_glyphs);
 107
 108     for (const hb_item_type<Iterator>& _ : +it)
 109       c->start_embed<DeviceRecord> ()->serialize (c, _.first, _.second, new_to_old_gid_list, num_glyphs);
 110
 111     return_trace (c->successful ());
 112   }
 113
 114
 115   bool subset (hb_subset_context_t *c) const
 116   {
 117     TRACE_SUBSET (this);
 118
 119     auto *hdmx_prime = c->serializer->start_embed <hdmx> ();
 120
 121     unsigned num_input_glyphs = get_num_glyphs ();
 122     auto it =
 123     + hb_range ((unsigned) numRecords)
 124     | hb_map ([c, num_input_glyphs, this] (unsigned _)
 125         {
 126           const DeviceRecord *device_record =
 127             &StructAtOffset<DeviceRecord> (&firstDeviceRecord,
 128                                            _ * sizeDeviceRecord);
 129           auto row =
 130             + hb_iter (c->plan->new_to_old_gid_list)
 131             | hb_map ([num_input_glyphs, device_record] (hb_codepoint_pair_t _)
 132                       {
 133                         return device_record->widthsZ.as_array (num_input_glyphs) [_.second];
 134                       })
 135             ;
 136           return hb_pair ((unsigned) device_record->pixelSize, +row);
 137         })
 138     ;
 139
 140     hdmx_prime->serialize (c->serializer, version, it,
 141                            c->plan->new_to_old_gid_list,
 142                            c->plan->num_output_glyphs ());
 143     return_trace (true);
 144   }
 145
 146   unsigned get_num_glyphs () const
 147   {
 148     return sizeDeviceRecord - DeviceRecord::min_size;
 149   }
 150
 151   bool sanitize (hb_sanitize_context_t *c) const
 152   {
 153     TRACE_SANITIZE (this);
 154     return_trace (c->check_struct (this) &&
 155                   !hb_unsigned_mul_overflows (numRecords, sizeDeviceRecord) &&
 156                   min_size + numRecords * sizeDeviceRecord > numRecords * sizeDeviceRecord &&
 157                   sizeDeviceRecord >= DeviceRecord::min_size &&
 158                   c->check_range (this, get_size ()));
 159   }
 160
 161   protected:
 162   HBUINT16      version;        /* Table version number (0) */
 163   HBUINT16      numRecords;     /* Number of device records. */
 164   HBUINT32      sizeDeviceRecord;
 165                                 /* Size of a device record, 32-bit aligned. */
 166   DeviceRecord  firstDeviceRecord;
 167                                 /* Array of device records. */
 168   public:
 169   DEFINE_SIZE_MIN (8);
 170 };
 171
 172 } /* namespace OT */
 173
 174
 175 #endif /* HB_OT_HDMX_TABLE_HH */