Source code
Revision control
Copy as Markdown
Other Tools
/*
* Copyright © 2018 Ebrahim Byagowi
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*/
#ifndef HB_OT_STAT_TABLE_HH
#define HB_OT_STAT_TABLE_HH
#include "hb-open-type.hh"
#include "hb-ot-layout-common.hh"
/*
* STAT -- Style Attributes
*/
#define HB_OT_TAG_STAT HB_TAG('S','T','A','T')
namespace OT {
enum
{
OLDER_SIBLING_FONT_ATTRIBUTE = 0x0001, /* If set, this axis value table
* provides axis value information
* that is applicable to other fonts
* within the same font family. This
* is used if the other fonts were
* released earlier and did not include
* information about values for some axis.
* If newer versions of the other
* fonts include the information
* themselves and are present,
* then this record is ignored. */
ELIDABLE_AXIS_VALUE_NAME = 0x0002 /* If set, it indicates that the axis
* value represents the “normal” value
* for the axis and may be omitted when
* composing name strings. */
// Reserved = 0xFFFC /* Reserved for future use — set to zero. */
};
static bool axis_value_is_outside_axis_range (hb_tag_t axis_tag, float axis_value,
const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location)
{
if (!user_axes_location->has (axis_tag))
return false;
double axis_value_double = static_cast<double>(axis_value);
Triple axis_range = user_axes_location->get (axis_tag);
return (axis_value_double < axis_range.minimum || axis_value_double > axis_range.maximum);
}
struct StatAxisRecord
{
int cmp (hb_tag_t key) const { return tag.cmp (key); }
hb_ot_name_id_t get_name_id () const { return nameID; }
hb_tag_t get_axis_tag () const { return tag; }
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (likely (c->check_struct (this)));
}
protected:
Tag tag; /* A tag identifying the axis of design variation. */
NameID nameID; /* The name ID for entries in the 'name' table that
* provide a display string for this axis. */
HBUINT16 ordering; /* A value that applications can use to determine
* primary sorting of face names, or for ordering
* of descriptors when composing family or face names. */
public:
DEFINE_SIZE_STATIC (8);
};
struct AxisValueFormat1
{
unsigned int get_axis_index () const { return axisIndex; }
float get_value () const { return value.to_float (); }
hb_ot_name_id_t get_value_name_id () const { return valueNameID; }
hb_tag_t get_axis_tag (const hb_array_t<const StatAxisRecord> axis_records) const
{
unsigned axis_idx = get_axis_index ();
return axis_records[axis_idx].get_axis_tag ();
}
bool keep_axis_value (const hb_array_t<const StatAxisRecord> axis_records,
const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location) const
{
hb_tag_t axis_tag = get_axis_tag (axis_records);
float axis_value = get_value ();
return !axis_value_is_outside_axis_range (axis_tag, axis_value, user_axes_location);
}
bool subset (hb_subset_context_t *c,
const hb_array_t<const StatAxisRecord> axis_records) const
{
TRACE_SUBSET (this);
const hb_hashmap_t<hb_tag_t, Triple>* user_axes_location = &c->plan->user_axes_location;
if (keep_axis_value (axis_records, user_axes_location))
return_trace (c->serializer->embed (this));
return_trace (false);
}
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this));
}
protected:
HBUINT16 format; /* Format identifier — set to 1. */
HBUINT16 axisIndex; /* Zero-base index into the axis record array
* identifying the axis of design variation
* to which the axis value record applies.
* Must be less than designAxisCount. */
HBUINT16 flags; /* Flags — see below for details. */
NameID valueNameID; /* The name ID for entries in the 'name' table
* that provide a display string for this
* attribute value. */
F16DOT16 value; /* A numeric value for this attribute value. */
public:
DEFINE_SIZE_STATIC (12);
};
struct AxisValueFormat2
{
unsigned int get_axis_index () const { return axisIndex; }
float get_value () const { return nominalValue.to_float (); }
hb_ot_name_id_t get_value_name_id () const { return valueNameID; }
hb_tag_t get_axis_tag (const hb_array_t<const StatAxisRecord> axis_records) const
{
unsigned axis_idx = get_axis_index ();
return axis_records[axis_idx].get_axis_tag ();
}
bool keep_axis_value (const hb_array_t<const StatAxisRecord> axis_records,
const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location) const
{
hb_tag_t axis_tag = get_axis_tag (axis_records);
float axis_value = get_value ();
return !axis_value_is_outside_axis_range (axis_tag, axis_value, user_axes_location);
}
bool subset (hb_subset_context_t *c,
const hb_array_t<const StatAxisRecord> axis_records) const
{
TRACE_SUBSET (this);
const hb_hashmap_t<hb_tag_t, Triple>* user_axes_location = &c->plan->user_axes_location;
if (keep_axis_value (axis_records, user_axes_location))
return_trace (c->serializer->embed (this));
return_trace (false);
}
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this));
}
protected:
HBUINT16 format; /* Format identifier — set to 2. */
HBUINT16 axisIndex; /* Zero-base index into the axis record array
* identifying the axis of design variation
* to which the axis value record applies.
* Must be less than designAxisCount. */
HBUINT16 flags; /* Flags — see below for details. */
NameID valueNameID; /* The name ID for entries in the 'name' table
* that provide a display string for this
* attribute value. */
F16DOT16 nominalValue; /* A numeric value for this attribute value. */
F16DOT16 rangeMinValue; /* The minimum value for a range associated
* with the specified name ID. */
F16DOT16 rangeMaxValue; /* The maximum value for a range associated
* with the specified name ID. */
public:
DEFINE_SIZE_STATIC (20);
};
struct AxisValueFormat3
{
unsigned int get_axis_index () const { return axisIndex; }
float get_value () const { return value.to_float (); }
hb_ot_name_id_t get_value_name_id () const { return valueNameID; }
hb_tag_t get_axis_tag (const hb_array_t<const StatAxisRecord> axis_records) const
{
unsigned axis_idx = get_axis_index ();
return axis_records[axis_idx].get_axis_tag ();
}
bool keep_axis_value (const hb_array_t<const StatAxisRecord> axis_records,
const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location) const
{
hb_tag_t axis_tag = get_axis_tag (axis_records);
float axis_value = get_value ();
return !axis_value_is_outside_axis_range (axis_tag, axis_value, user_axes_location);
}
bool subset (hb_subset_context_t *c,
const hb_array_t<const StatAxisRecord> axis_records) const
{
TRACE_SUBSET (this);
const hb_hashmap_t<hb_tag_t, Triple>* user_axes_location = &c->plan->user_axes_location;
if (keep_axis_value (axis_records, user_axes_location))
return_trace (c->serializer->embed (this));
return_trace (false);
}
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this));
}
protected:
HBUINT16 format; /* Format identifier — set to 3. */
HBUINT16 axisIndex; /* Zero-base index into the axis record array
* identifying the axis of design variation
* to which the axis value record applies.
* Must be less than designAxisCount. */
HBUINT16 flags; /* Flags — see below for details. */
NameID valueNameID; /* The name ID for entries in the 'name' table
* that provide a display string for this
* attribute value. */
F16DOT16 value; /* A numeric value for this attribute value. */
F16DOT16 linkedValue; /* The numeric value for a style-linked mapping
* from this value. */
public:
DEFINE_SIZE_STATIC (16);
};
struct AxisValueRecord
{
unsigned int get_axis_index () const { return axisIndex; }
float get_value () const { return value.to_float (); }
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this));
}
protected:
HBUINT16 axisIndex; /* Zero-base index into the axis record array
* identifying the axis to which this value
* applies. Must be less than designAxisCount. */
F16DOT16 value; /* A numeric value for this attribute value. */
public:
DEFINE_SIZE_STATIC (6);
};
struct AxisValueFormat4
{
const AxisValueRecord &get_axis_record (unsigned int axis_index) const
{ return axisValues.as_array (axisCount)[axis_index]; }
bool keep_axis_value (const hb_array_t<const StatAxisRecord> axis_records,
const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location) const
{
hb_array_t<const AxisValueRecord> axis_value_records = axisValues.as_array (axisCount);
for (const auto& rec : axis_value_records)
{
unsigned axis_idx = rec.get_axis_index ();
float axis_value = rec.get_value ();
hb_tag_t axis_tag = axis_records[axis_idx].get_axis_tag ();
if (axis_value_is_outside_axis_range (axis_tag, axis_value, user_axes_location))
return false;
}
return true;
}
bool subset (hb_subset_context_t *c,
const hb_array_t<const StatAxisRecord> axis_records) const
{
TRACE_SUBSET (this);
const hb_hashmap_t<hb_tag_t, Triple> *user_axes_location = &c->plan->user_axes_location;
if (!keep_axis_value (axis_records, user_axes_location))
return_trace (false);
unsigned total_size = min_size + axisCount * AxisValueRecord::static_size;
auto *out = c->serializer->allocate_size<AxisValueFormat4> (total_size);
if (unlikely (!out)) return_trace (false);
hb_memcpy (out, this, total_size);
return_trace (true);
}
hb_ot_name_id_t get_value_name_id () const { return valueNameID; }
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (likely (c->check_struct (this) &&
hb_barrier () &&
axisValues.sanitize (c, axisCount)));
}
protected:
HBUINT16 format; /* Format identifier — set to 4. */
HBUINT16 axisCount; /* The total number of axes contributing to
* this axis-values combination. */
HBUINT16 flags; /* Flags — see below for details. */
NameID valueNameID; /* The name ID for entries in the 'name' table
* that provide a display string for this
* attribute value. */
UnsizedArrayOf<AxisValueRecord>
axisValues; /* Array of AxisValue records that provide the
* combination of axis values, one for each
* contributing axis. */
public:
DEFINE_SIZE_ARRAY (8, axisValues);
};
struct AxisValue
{
float get_value (unsigned int axis_index) const
{
switch (u.format)
{
case 1: hb_barrier (); return u.format1.get_value ();
case 2: hb_barrier (); return u.format2.get_value ();
case 3: hb_barrier (); return u.format3.get_value ();
case 4: hb_barrier (); return u.format4.get_axis_record (axis_index).get_value ();
default:return 0.f;
}
}
unsigned int get_axis_index () const
{
switch (u.format)
{
case 1: hb_barrier (); return u.format1.get_axis_index ();
case 2: hb_barrier (); return u.format2.get_axis_index ();
case 3: hb_barrier (); return u.format3.get_axis_index ();
/* case 4: Makes more sense for variable fonts which are handled by fvar in hb-style */
default:return -1;
}
}
hb_ot_name_id_t get_value_name_id () const
{
switch (u.format)
{
case 1: hb_barrier (); return u.format1.get_value_name_id ();
case 2: hb_barrier (); return u.format2.get_value_name_id ();
case 3: hb_barrier (); return u.format3.get_value_name_id ();
case 4: hb_barrier (); return u.format4.get_value_name_id ();
default:return HB_OT_NAME_ID_INVALID;
}
}
template <typename context_t, typename ...Ts>
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
{
if (unlikely (!c->may_dispatch (this, &u.format))) return c->no_dispatch_return_value ();
TRACE_DISPATCH (this, u.format);
switch (u.format) {
case 1: hb_barrier (); return_trace (c->dispatch (u.format1, std::forward<Ts> (ds)...));
case 2: hb_barrier (); return_trace (c->dispatch (u.format2, std::forward<Ts> (ds)...));
case 3: hb_barrier (); return_trace (c->dispatch (u.format3, std::forward<Ts> (ds)...));
case 4: hb_barrier (); return_trace (c->dispatch (u.format4, std::forward<Ts> (ds)...));
default:return_trace (c->default_return_value ());
}
}
bool keep_axis_value (const hb_array_t<const StatAxisRecord> axis_records,
hb_hashmap_t<hb_tag_t, Triple> *user_axes_location) const
{
switch (u.format)
{
case 1: hb_barrier (); return u.format1.keep_axis_value (axis_records, user_axes_location);
case 2: hb_barrier (); return u.format2.keep_axis_value (axis_records, user_axes_location);
case 3: hb_barrier (); return u.format3.keep_axis_value (axis_records, user_axes_location);
case 4: hb_barrier (); return u.format4.keep_axis_value (axis_records, user_axes_location);
default:return false;
}
}
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
if (unlikely (!c->check_struct (this)))
return_trace (false);
hb_barrier ();
switch (u.format)
{
case 1: hb_barrier (); return_trace (u.format1.sanitize (c));
case 2: hb_barrier (); return_trace (u.format2.sanitize (c));
case 3: hb_barrier (); return_trace (u.format3.sanitize (c));
case 4: hb_barrier (); return_trace (u.format4.sanitize (c));
default:return_trace (true);
}
}
protected:
union
{
HBUINT16 format;
AxisValueFormat1 format1;
AxisValueFormat2 format2;
AxisValueFormat3 format3;
AxisValueFormat4 format4;
} u;
public:
DEFINE_SIZE_UNION (2, format);
};
struct AxisValueOffsetArray: UnsizedArrayOf<Offset16To<AxisValue>>
{
bool subset (hb_subset_context_t *c,
unsigned axisValueCount,
unsigned& count,
const hb_array_t<const StatAxisRecord> axis_records) const
{
TRACE_SUBSET (this);
auto axisValueOffsets = as_array (axisValueCount);
count = 0;
for (const auto& offset : axisValueOffsets)
{
if (!offset) continue;
auto o_snap = c->serializer->snapshot ();
auto *o = c->serializer->embed (offset);
if (!o) return_trace (false);
if (!o->serialize_subset (c, offset, this, axis_records))
{
c->serializer->revert (o_snap);
continue;
}
count++;
}
return_trace (count);
}
};
struct STAT
{
static constexpr hb_tag_t tableTag = HB_OT_TAG_STAT;
bool has_data () const { return version.to_int (); }
bool get_value (hb_tag_t tag, float *value) const
{
unsigned int axis_index;
if (!get_design_axes ().lfind (tag, &axis_index)) return false;
hb_array_t<const Offset16To<AxisValue>> axis_values = get_axis_value_offsets ();
for (unsigned int i = 0; i < axis_values.length; i++)
{
const AxisValue& axis_value = this+offsetToAxisValueOffsets+axis_values[i];
if (axis_value.get_axis_index () == axis_index)
{
if (value)
*value = axis_value.get_value (axis_index);
return true;
}
}
return false;
}
unsigned get_design_axis_count () const { return designAxisCount; }
hb_ot_name_id_t get_axis_record_name_id (unsigned axis_record_index) const
{
if (unlikely (axis_record_index >= designAxisCount)) return HB_OT_NAME_ID_INVALID;
const StatAxisRecord &axis_record = get_design_axes ()[axis_record_index];
return axis_record.get_name_id ();
}
unsigned get_axis_value_count () const { return axisValueCount; }
hb_ot_name_id_t get_axis_value_name_id (unsigned axis_value_index) const
{
if (unlikely (axis_value_index >= axisValueCount)) return HB_OT_NAME_ID_INVALID;
const AxisValue &axis_value = (this + get_axis_value_offsets ()[axis_value_index]);
return axis_value.get_value_name_id ();
}
void collect_name_ids (hb_hashmap_t<hb_tag_t, Triple> *user_axes_location,
hb_set_t *nameids_to_retain /* OUT */) const
{
if (!has_data ()) return;
+ get_design_axes ()
| hb_map (&StatAxisRecord::get_name_id)
| hb_sink (nameids_to_retain)
;
auto designAxes = get_design_axes ();
+ get_axis_value_offsets ()
| hb_map (hb_add (&(this + offsetToAxisValueOffsets)))
| hb_filter ([&] (const AxisValue& _)
{ return _.keep_axis_value (designAxes, user_axes_location); })
| hb_map (&AxisValue::get_value_name_id)
| hb_sink (nameids_to_retain)
;
nameids_to_retain->add (elidedFallbackNameID);
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
STAT *out = c->serializer->embed (this);
if (unlikely (!out)) return_trace (false);
auto designAxes = get_design_axes ();
for (unsigned i = 0; i < (unsigned)designAxisCount; i++)
if (unlikely (!c->serializer->embed (designAxes[i])))
return_trace (false);
if (designAxisCount)
c->serializer->check_assign (out->designAxesOffset, this->get_size (),
HB_SERIALIZE_ERROR_INT_OVERFLOW);
unsigned count = 0;
out->offsetToAxisValueOffsets.serialize_subset (c, offsetToAxisValueOffsets, this,
axisValueCount, count, designAxes);
return_trace (c->serializer->check_assign (out->axisValueCount, count, HB_SERIALIZE_ERROR_INT_OVERFLOW));
}
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (likely (c->check_struct (this) &&
hb_barrier () &&
version.major == 1 &&
version.minor > 0 &&
designAxesOffset.sanitize (c, this, designAxisCount) &&
offsetToAxisValueOffsets.sanitize (c, this, axisValueCount, &(this+offsetToAxisValueOffsets))));
}
protected:
hb_array_t<const StatAxisRecord> const get_design_axes () const
{ return (this+designAxesOffset).as_array (designAxisCount); }
hb_array_t<const Offset16To<AxisValue>> const get_axis_value_offsets () const
{ return (this+offsetToAxisValueOffsets).as_array (axisValueCount); }
protected:
FixedVersion<>version; /* Version of the stat table
* initially set to 0x00010002u */
HBUINT16 designAxisSize; /* The size in bytes of each axis record. */
HBUINT16 designAxisCount;/* The number of design axis records. In a
* font with an 'fvar' table, this value must be
* greater than or equal to the axisCount value
* in the 'fvar' table. In all fonts, must
* be greater than zero if axisValueCount
* is greater than zero. */
NNOffset32To<UnsizedArrayOf<StatAxisRecord>>
designAxesOffset;
/* Offset in bytes from the beginning of
* the STAT table to the start of the design
* axes array. If designAxisCount is zero,
* set to zero; if designAxisCount is greater
* than zero, must be greater than zero. */
HBUINT16 axisValueCount; /* The number of axis value tables. */
NNOffset32To<AxisValueOffsetArray>
offsetToAxisValueOffsets;
/* Offset in bytes from the beginning of
* the STAT table to the start of the design
* axes value offsets array. If axisValueCount
* is zero, set to zero; if axisValueCount is
* greater than zero, must be greater than zero. */
NameID elidedFallbackNameID;
/* Name ID used as fallback when projection of
* names into a particular font model produces
* a subfamily name containing only elidable
* elements. */
public:
DEFINE_SIZE_STATIC (20);
};
} /* namespace OT */
#endif /* HB_OT_STAT_TABLE_HH */