Line data    Source code

       1             : /*
       2             :  * Copyright © 2017  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): Behdad Esfahbod
      25             :  */
      26             : 
      27             : #ifndef HB_OT_VAR_AVAR_TABLE_HH
      28             : #define HB_OT_VAR_AVAR_TABLE_HH
      29             : 
      30             : #include "hb-open-type-private.hh"
      31             : 
      32             : namespace OT {
      33             : 
      34             : 
      35             : struct AxisValueMap
      36             : {
      37             :   inline bool sanitize (hb_sanitize_context_t *c) const
      38             :   {
      39             :     TRACE_SANITIZE (this);
      40             :     return_trace (c->check_struct (this));
      41             :   }
      42             : 
      43             :   public:
      44             :   F2DOT14       fromCoord;      /* A normalized coordinate value obtained using
      45             :                                  * default normalization. */
      46             :   F2DOT14       toCoord;        /* The modified, normalized coordinate value. */
      47             : 
      48             :   public:
      49             :   DEFINE_SIZE_STATIC (4);
      50             : };
      51             : 
      52             : struct SegmentMaps : ArrayOf<AxisValueMap>
      53             : {
      54           0 :   inline int map (int value) const
      55             :   {
      56             :     /* The following special-cases are not part of OpenType, which requires
      57             :      * that at least -1, 0, and +1 must be mapped. But we include these as
      58             :      * part of a better error recovery scheme. */
      59             : 
      60           0 :     if (!len)
      61           0 :       return value;
      62             : 
      63           0 :     if (value <= array[0].fromCoord)
      64           0 :       return value - array[0].fromCoord + array[0].toCoord;
      65             : 
      66             :     unsigned int i;
      67           0 :     unsigned int count = len;
      68           0 :     for (i = 1; i < count && value > array[i].fromCoord; i++)
      69             :       ;
      70             : 
      71           0 :     if (value >= array[i].fromCoord)
      72           0 :       return value - array[i].fromCoord + array[i].toCoord;
      73             : 
      74           0 :     if (unlikely (array[i-1].fromCoord == array[i].fromCoord))
      75           0 :       return array[i-1].toCoord;
      76             : 
      77           0 :     int denom = array[i].fromCoord - array[i-1].fromCoord;
      78           0 :     return array[i-1].toCoord +
      79           0 :            (array[i].toCoord - array[i-1].toCoord) *
      80           0 :            (value - array[i-1].fromCoord + denom/2) / denom;
      81             :   }
      82             : 
      83             :   DEFINE_SIZE_ARRAY (2, array);
      84             : };
      85             : 
      86             : /*
      87             :  * avar — Axis Variations Table
      88             :  */
      89             : 
      90             : #define HB_OT_TAG_avar HB_TAG('a','v','a','r')
      91             : 
      92             : struct avar
      93             : {
      94             :   static const hb_tag_t tableTag        = HB_OT_TAG_avar;
      95             : 
      96           0 :   inline bool sanitize (hb_sanitize_context_t *c) const
      97             :   {
      98           0 :     TRACE_SANITIZE (this);
      99           0 :     if (unlikely (!(version.sanitize (c) &&
     100             :                     version.major == 1 &&
     101             :                     c->check_struct (this))))
     102           0 :       return_trace (false);
     103             : 
     104           0 :     const SegmentMaps *map = &axisSegmentMapsZ;
     105           0 :     unsigned int count = axisCount;
     106           0 :     for (unsigned int i = 0; i < count; i++)
     107             :     {
     108           0 :       if (unlikely (!map->sanitize (c)))
     109           0 :         return_trace (false);
     110           0 :       map = &StructAfter<SegmentMaps> (*map);
     111             :     }
     112             : 
     113           0 :     return_trace (true);
     114             :   }
     115             : 
     116           0 :   inline void map_coords (int *coords, unsigned int coords_length) const
     117             :   {
     118           0 :     unsigned int count = MIN<unsigned int> (coords_length, axisCount);
     119             : 
     120           0 :     const SegmentMaps *map = &axisSegmentMapsZ;
     121           0 :     for (unsigned int i = 0; i < count; i++)
     122             :     {
     123           0 :       coords[i] = map->map (coords[i]);
     124           0 :       map = &StructAfter<SegmentMaps> (*map);
     125             :     }
     126           0 :   }
     127             : 
     128             :   protected:
     129             :   FixedVersion<>version;  /* Version of the avar table
     130             :                                  * initially set to 0x00010000u */
     131             :   USHORT        reserved;       /* This field is permanently reserved. Set to 0. */
     132             :   USHORT        axisCount;      /* The number of variation axes in the font. This
     133             :                                  * must be the same number as axisCount in the
     134             :                                  * 'fvar' table. */
     135             :   SegmentMaps   axisSegmentMapsZ;
     136             : 
     137             :   public:
     138             :   DEFINE_SIZE_MIN (8);
     139             : };
     140             : 
     141             : } /* namespace OT */
     142             : 
     143             : 
     144             : #endif /* HB_OT_VAR_AVAR_TABLE_HH */