From baf2ccf1471856f948ed8d2d46e4d68b0c0b739a Mon Sep 17 00:00:00 2001 From: Michiharu Ariza Date: Fri, 1 Mar 2019 15:14:22 -0800 Subject: [PATCH] calculate VF advance widths from gvar & glyf --- src/hb-ot-glyf-table.hh | 151 +++++++++++++ src/hb-ot-hmtx-table.hh | 23 +- src/hb-ot-var-gvar-table.hh | 412 ++++++++++++++++++++++++++++++++---- 3 files changed, 543 insertions(+), 43 deletions(-) diff --git a/src/hb-ot-glyf-table.hh b/src/hb-ot-glyf-table.hh index c2b38b05b..028722c49 100644 --- a/src/hb-ot-glyf-table.hh +++ b/src/hb-ot-glyf-table.hh @@ -22,6 +22,7 @@ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Google Author(s): Behdad Esfahbod + * Adobe Author(s): Michiharu Ariza */ #ifndef HB_OT_GLYF_TABLE_HH @@ -281,6 +282,156 @@ struct glyf FLAG_RESERVED2 = 0x80 }; + enum phantom_point_index_t { + PHANTOM_LEFT = 0, + PHANTOM_RIGHT = 1, + PHANTOM_TOP = 2, + PHANTOM_BOTTOM = 3, + PHANTOM_COUNT = 4 + }; + + struct contour_point_t + { + void init () { flag = 0; x = y = 0.0f; } + uint8_t flag; + float x, y; + }; + + struct range_checker_t + { + range_checker_t (const void *_table, unsigned int _start_offset, unsigned int _end_offset) + : table ((const char*)_table), start_offset (_start_offset), end_offset (_end_offset) {} + + template + bool in_range (const T *p) const + { + return ((const char *) p) >= table + start_offset + && ((const char *) (p + T::static_size)) <= table + end_offset; + } + + protected: + const char *table; + const unsigned int start_offset; + const unsigned int end_offset; + }; + + struct x_setter_t + { + void set (contour_point_t &point, float v) const { point.x = v; } + bool is_short (uint8_t flag) const { return (flag & FLAG_X_SHORT) != 0; } + bool is_same (uint8_t flag) const { return (flag & FLAG_X_SAME) != 0; } + }; + + struct y_setter_t + { + void set (contour_point_t &point, float v) const { point.y = v; } + bool is_short (uint8_t flag) const { return (flag & FLAG_Y_SHORT) != 0; } + bool is_same (uint8_t flag) const { return (flag & FLAG_Y_SAME) != 0; } + }; + + template + static bool read_points (const HBUINT8 *&p /* IN/OUT */, + hb_vector_t &_points /* IN/OUT */, + const range_checker_t &checker) + { + const T coord_setter; + float v = 0; + for (unsigned int i = 0; i < _points.length - PHANTOM_COUNT; i++) + { + uint8_t flag = _points[i].flag; + if (coord_setter.is_short (flag)) + { + if (unlikely (!checker.in_range (p))) return false; + if (coord_setter.is_same (flag)) + v += *p++; + else + v -= *p++; + } + else + { + if (unlikely (!checker.in_range ((const HBUINT16 *)p))) return false; + if (!coord_setter.is_same (flag)) + { + v = *(const HBINT16 *)p; + p += HBINT16::static_size; + } + } + coord_setter.set (_points[i], v); + } + return true; + }; + + /* for a simple glyph, return contour end points, flags, along with coordinate points + * for a composite glyph, return pseudo component points + * in both cases points trailed with four phantom points + */ + bool get_contour_points (hb_codepoint_t glyph, + bool phantom_only, + hb_vector_t &_points /* OUT */, + hb_vector_t &_end_points /* OUT */) const + { + unsigned int num_points = 0; + unsigned int start_offset, end_offset; + if (unlikely (!get_offsets (glyph, &start_offset, &end_offset))) + return false; + if (end_offset - start_offset < GlyphHeader::static_size) + return false; + + const GlyphHeader &glyph_header = StructAtOffset (glyf_table, start_offset); + if (unlikely (glyph_header.numberOfContours < 0)) return false; + int16_t num_contours = (int16_t) glyph_header.numberOfContours; + const HBUINT16 *end_pts = &StructAfter (glyph_header); + + range_checker_t checker (glyf_table, start_offset, end_offset); + num_points = 0; + if (num_contours > 0) + { + if (unlikely (!checker.in_range (&end_pts[num_contours + 1]))) return false; + num_points = end_pts[num_contours - 1] + 1; + } + else if (num_contours < 0) + { + CompositeGlyphHeader::Iterator composite; + if (!get_composite (glyph, &composite)) return false; + do + { + num_points++; + } while (composite.move_to_next()); + } + + _points.resize (num_points + PHANTOM_COUNT); + for (unsigned int i = 0; i < _points.length; i++) _points[i].init (); + if ((num_contours <= 0) || phantom_only) return true; + + /* Read simple glyph points if !phantom_only */ + _end_points.resize (num_contours); + + for (int16_t i = 0; i < num_contours; i++) + _end_points[i] = end_pts[i]; + + /* Skip instructions */ + const HBUINT8 *p = &StructAtOffset (&end_pts[num_contours+1], end_pts[num_contours]); + + /* Read flags */ + for (unsigned int i = 0; i < num_points; i++) + { + if (unlikely (!checker.in_range (p))) return false; + uint8_t flag = *p++; + _points[i].flag = flag; + if ((flag & FLAG_REPEAT) != 0) + { + if (unlikely (!checker.in_range (p))) return false; + unsigned int repeat_count = *p++; + while ((repeat_count-- > 0) && (++i < num_points)) + _points[i].flag = flag; + } + } + + /* Read x & y coordinates */ + return (!read_points (p, _points, checker) && + !read_points (p, _points, checker)); + } + /* based on FontTools _g_l_y_f.py::trim */ bool remove_padding (unsigned int start_offset, unsigned int *end_offset) const diff --git a/src/hb-ot-hmtx-table.hh b/src/hb-ot-hmtx-table.hh index 9ef1f5716..4c1693f48 100644 --- a/src/hb-ot-hmtx-table.hh +++ b/src/hb-ot-hmtx-table.hh @@ -31,6 +31,7 @@ #include "hb-ot-hhea-table.hh" #include "hb-ot-os2-table.hh" #include "hb-ot-var-hvar-table.hh" +#include "hb-ot-var-gvar-table.hh" /* * hmtx -- Horizontal Metrics @@ -163,6 +164,7 @@ struct hmtxvmtx void init (hb_face_t *face, unsigned int default_advance_ = 0) { + memset (this, 0, sizeof (*this)); default_advance = default_advance_ ? default_advance_ : hb_face_get_upem (face); bool got_font_extents = false; @@ -206,12 +208,24 @@ struct hmtxvmtx } var_table = hb_sanitize_context_t().reference_table (face, T::variationsTag); + + /* If a TrueType variable font has no HVAR/VVAR table, gvar & glyf table is required for metrics calculation */ + if (var_table.get_blob () == hb_blob_get_empty ()) + { + hb_blob_ptr_t fvar_table = hb_sanitize_context_t().reference_table (face, HB_OT_TAG_fvar); + if (fvar_table.get_blob () != hb_blob_get_empty ()) + { + gvar_accel.init (face); + } + fvar_table.destroy (); + } } void fini () { table.destroy (); var_table.destroy (); + gvar_accel.fini (); } /* TODO Add variations version. */ @@ -249,7 +263,13 @@ struct hmtxvmtx unsigned int advance = get_advance (glyph); if (likely (glyph < num_metrics)) { - advance += (font->num_coords ? var_table->get_advance_var (glyph, font->coords, font->num_coords) : 0); // TODO Optimize?! + if (font->num_coords) + { + if (var_table.get_blob () != hb_blob_get_empty ()) + advance += var_table->get_advance_var (glyph, font->coords, font->num_coords); // TODO Optimize?! + else + advance += gvar_accel.get_advance_var (glyph, font->coords, font->num_coords, T::tableTag==HB_OT_TAG_vmtx); + } } return advance; } @@ -294,6 +314,7 @@ struct hmtxvmtx private: hb_blob_ptr_t table; hb_blob_ptr_t var_table; + gvar::accelerator_t gvar_accel; }; protected: diff --git a/src/hb-ot-var-gvar-table.hh b/src/hb-ot-var-gvar-table.hh index de672ed7f..bba8f9b23 100644 --- a/src/hb-ot-var-gvar-table.hh +++ b/src/hb-ot-var-gvar-table.hh @@ -28,6 +28,8 @@ #define HB_OT_VAR_GVAR_TABLE_HH #include "hb-open-type.hh" +#include "hb-ot-glyf-table.hh" +#include "hb-ot-var-fvar-table.hh" /* * gvar -- Glyph Variation Table @@ -41,12 +43,6 @@ struct Tuple : UnsizedArrayOf {}; struct TuppleIndex : HBUINT16 { - bool has_peak () const { return ((*this) & EmbeddedPeakTuple) != 0; } - bool has_intermediate () const { return ((*this) & IntermediateRegion) != 0; } - bool has_private_points () const { return ((*this) & PrivatePointNumbers) != 0; } - unsigned int get_index () const { return (*this) & TupleIndexMask; } - - protected: enum Flags { EmbeddedPeakTuple = 0x8000u, IntermediateRegion = 0x4000u, @@ -54,7 +50,6 @@ struct TuppleIndex : HBUINT16 TupleIndexMask = 0x0FFFu }; - public: DEFINE_SIZE_STATIC (2); }; @@ -63,17 +58,77 @@ struct TupleVarHeader unsigned int get_size (unsigned int axis_count) const { return min_size + - (tupleIndex.has_peak ()? get_peak_tuple ().get_size (axis_count): 0) + - (tupleIndex.has_intermediate ()? (get_start_tuple (axis_count).get_size (axis_count) + - get_end_tuple (axis_count).get_size (axis_count)): 0); + (has_peak ()? get_peak_tuple ().get_size (axis_count): 0) + + (has_intermediate ()? (get_start_tuple (axis_count).get_size (axis_count) + + get_end_tuple (axis_count).get_size (axis_count)): 0); } + const TupleVarHeader &get_next (unsigned int axis_count) const + { return StructAtOffset (this, get_size (axis_count)); } + + float calculate_scalar (const int *coords, unsigned int coord_count, + const hb_array_t shared_tuples) const + { + const F2DOT14 *peak_tuple; + + if (has_peak ()) + peak_tuple = &(get_peak_tuple ()[0]); + else + { + unsigned int index = get_index (); + if (unlikely (index * coord_count >= shared_tuples.length)) + return 0.f; + peak_tuple = &shared_tuples[coord_count * index]; + } + + const F2DOT14 *start_tuple = nullptr; + const F2DOT14 *end_tuple = nullptr; + if (has_intermediate ()) + { + start_tuple = get_start_tuple (coord_count); + end_tuple = get_end_tuple (coord_count); + } + + float scalar = 1.f; + for (unsigned int i = 0; i < coord_count; i++) + { + int v = coords[i]; + int peak = peak_tuple[i]; + if (!peak || v == peak) continue; + + if (has_intermediate ()) + { + int start = start_tuple[i]; + int end = end_tuple[i]; + if (unlikely (start > peak || peak > end || + start < 0 && end > 0 && peak)) continue; + if (v < start || v > end) return 0.f; + if (v < peak) + { if (peak != start) scalar *= (float)(v - start) / (peak - start); } + else + { if (peak != end) scalar *= (float)(end - v) / (end - peak); } + } + else if (!v || v < MIN (0, peak) || v > MAX (0, peak)) return 0.f; + else + scalar *= (float)v / peak; + } + return scalar; + } + + unsigned int get_data_size () const { return varDataSize; } + + bool has_peak () const { return (tupleIndex & TuppleIndex::EmbeddedPeakTuple) != 0; } + bool has_intermediate () const { return (tupleIndex & TuppleIndex::IntermediateRegion) != 0; } + bool has_private_points () const { return (tupleIndex & TuppleIndex::PrivatePointNumbers) != 0; } + unsigned int get_index () const { return (tupleIndex & TuppleIndex::TupleIndexMask); } + + protected: const Tuple &get_peak_tuple () const { return StructAfter (tupleIndex); } const Tuple &get_start_tuple (unsigned int axis_count) const - { return StructAfter (get_peak_tuple ()[tupleIndex.has_peak ()? axis_count: 0]); } + { return StructAfter (get_peak_tuple ()[has_peak ()? axis_count: 0]); } const Tuple &get_end_tuple (unsigned int axis_count) const - { return StructAfter (get_peak_tuple ()[tupleIndex.has_peak ()? (axis_count * 2): 0]); } + { return StructAfter (get_peak_tuple ()[has_peak ()? (axis_count * 2): 0]); } HBUINT16 varDataSize; TuppleIndex tupleIndex; @@ -81,6 +136,7 @@ struct TupleVarHeader /* UnsizedArrayOf intermediateStartTuple - optional */ /* UnsizedArrayOf intermediateEndTuple - optional */ + public: DEFINE_SIZE_MIN (4); }; @@ -101,30 +157,72 @@ struct TupleVarCount : HBUINT16 struct GlyphVarData { - bool check_size (unsigned int axis_count, unsigned int len) const - { return (get_header_size (axis_count) <= len) && (data <= len); } + const TupleVarHeader &get_tuple_var_header (void) const + { return StructAfter(data); } - unsigned int get_header_size (unsigned int axis_count) const + struct tuple_iterator_t { - unsigned int size = min_size; - for (unsigned int i = 0; i < tupleVarCount.get_count (); i++) - size += get_tuple_var_header (axis_count, i).get_size (axis_count); // FIX THIS O(n^2) - - return size; + void init (const GlyphVarData *_var_data, unsigned int _length, unsigned int _axis_count) + { + var_data = _var_data; + length = _length; + index = 0; + axis_count = _axis_count; + current_tuple = &var_data->get_tuple_var_header (); + data_offset = 0; + } + + bool is_valid () const + { + return (index < var_data->tupleVarCount.get_count ()) && + in_range (current_tuple) && + current_tuple->get_size (axis_count); + }; + + bool move_to_next () + { + data_offset += current_tuple->get_data_size (); + current_tuple = ¤t_tuple->get_next (axis_count); + index++; + return is_valid (); + } + + bool in_range (const void *p, unsigned int l) const + { return (const char*)p >= (const char*)var_data && (const char*)p+l <= (const char*)var_data + length; } + + template bool in_range (const T *p) const { return in_range (p, sizeof (*p)); } + + const HBUINT8 *get_serialized_data () const + { return &(var_data+var_data->data) + data_offset; } + + private: + const GlyphVarData *var_data; + unsigned int length; + unsigned int index; + unsigned int axis_count; + unsigned int data_offset; + + public: + const TupleVarHeader *current_tuple; + }; + + static bool get_tuple_iterator (const GlyphVarData *var_data, + unsigned int length, + unsigned int axis_count, + tuple_iterator_t *iterator /* OUT */) + { + iterator->init (var_data, length, axis_count); + return iterator->is_valid (); } - const TupleVarHeader &get_tuple_var_header (unsigned int axis_count, unsigned int i) const - { - const TupleVarHeader *header = &StructAfter(data); - while (i-- > 0) - header = &StructAtOffset (header, header->get_size (axis_count)); - return *header; - } + bool has_shared_point_numbers () const { return tupleVarCount.has_shared_point_numbers (); } + protected: TupleVarCount tupleVarCount; OffsetTo data; /* TupleVarHeader tupleVarHeaders[] */ + public: DEFINE_SIZE_MIN (4); }; @@ -169,13 +267,13 @@ struct gvar { unsigned int old_gid; if (!c->plan->old_gid_for_new_gid (gid, &old_gid)) continue; - subset_data_size += get_data_length (old_gid); + subset_data_size += get_glyph_var_data_length (old_gid); } bool long_offset = subset_data_size & ~0xFFFFu; out->flags.set (long_offset? 1: 0); - HBUINT8 *subset_offsets = c->serializer->allocate_size ((long_offset?HBUINT32::static_size: HBUINT16::static_size) * (num_glyphs+1)); + HBUINT8 *subset_offsets = c->serializer->allocate_size ((long_offset? 4: 2) * (num_glyphs+1)); if (!subset_offsets) return_trace (false); char *subset_data = c->serializer->allocate_size(subset_data_size); @@ -186,7 +284,7 @@ struct gvar for (hb_codepoint_t gid = 0; gid < num_glyphs; gid++) { unsigned int old_gid; - unsigned int length = c->plan->old_gid_for_new_gid (gid, &old_gid)? get_data_length (old_gid): 0; + unsigned int length = c->plan->old_gid_for_new_gid (gid, &old_gid)? get_glyph_var_data_length (old_gid): 0; if (long_offset) ((HBUINT32 *)subset_offsets)[gid].set (glyph_offset); @@ -218,37 +316,267 @@ struct gvar } protected: - const GlyphVarData *get_glyph_var_data (unsigned int gid) const + const GlyphVarData *get_glyph_var_data (hb_codepoint_t glyph) const { - unsigned int start_offset = get_offset (gid); - unsigned int end_offset = get_offset (gid+1); + unsigned int start_offset = get_offset (glyph); + unsigned int end_offset = get_offset (glyph+1); if ((start_offset == end_offset) || unlikely ((start_offset > get_offset (glyphCount)) || (start_offset + GlyphVarData::min_size > end_offset))) return &Null(GlyphVarData); - const GlyphVarData *var_data = &(((unsigned char *)this+start_offset)+dataZ); - if (unlikely (!var_data->check_size (axisCount, end_offset - start_offset))) - return &Null (GlyphVarData); - return var_data; + return &(((unsigned char *)this+start_offset)+dataZ); } bool is_long_offset () const { return (flags & 1)!=0; } - unsigned int get_offset (unsigned int gid) const + unsigned int get_offset (unsigned int i) const { if (is_long_offset ()) - return get_long_offset_array ()[gid]; + return get_long_offset_array ()[i]; else - return get_short_offset_array ()[gid] * 2; + return get_short_offset_array ()[i] * 2; } - unsigned int get_data_length (unsigned int gid) const - { return get_offset (gid+1) - get_offset (gid); } + unsigned int get_glyph_var_data_length (unsigned int glyph) const + { return get_offset (glyph+1) - get_offset (glyph); } const HBUINT32 *get_long_offset_array () const { return (const HBUINT32 *)&offsetZ; } const HBUINT16 *get_short_offset_array () const { return (const HBUINT16 *)&offsetZ; } + typedef glyf::accelerator_t::contour_point_t contour_point_t; + typedef glyf::accelerator_t::phantom_point_index_t pp_t; + typedef glyf::accelerator_t::range_checker_t range_checker_t; + + public: + struct accelerator_t + { + void init (hb_face_t *face) + { + memset (this, 0, sizeof (accelerator_t)); + + gvar_table = hb_sanitize_context_t ().reference_table (face); + glyf.init (face); + hb_blob_ptr_t fvar_table = hb_sanitize_context_t ().reference_table (face); + unsigned int axis_count = fvar_table->get_axis_count (); + fvar_table.destroy (); + + if (unlikely ((gvar_table->glyphCount != face->get_num_glyphs ()) || + (gvar_table->axisCount != axis_count))) + fini (); + + unsigned int num_shared_coord = gvar_table->sharedTupleCount * gvar_table->axisCount; + shared_tuples.resize (num_shared_coord); + for (unsigned int i = 0; i < num_shared_coord; i++) + shared_tuples[i] = (&(gvar_table+gvar_table->sharedTuples))[i]; + } + + void fini () + { + gvar_table.destroy (); + glyf.fini (); + } + + bool apply_deltas_to_points (hb_codepoint_t glyph, + const int *coords, unsigned int coord_count, + const hb_array_t points, + const hb_array_t end_points) const + { + if (unlikely (coord_count != gvar_table->axisCount)) return false; + + const GlyphVarData *var_data = gvar_table->get_glyph_var_data (glyph); + GlyphVarData::tuple_iterator_t iterator; + if (!GlyphVarData::get_tuple_iterator (var_data, + gvar_table->get_glyph_var_data_length (glyph), + gvar_table->axisCount, + &iterator)) + return false; + + do { + float scalar = iterator.current_tuple->calculate_scalar (coords, coord_count, shared_tuples.as_array ()); + if (scalar == 0.f) continue; + const HBUINT8 *p = iterator.get_serialized_data (); + unsigned int length = iterator.current_tuple->get_data_size (); + if (unlikely (!iterator.in_range (p, length))) return false; + + range_checker_t checker (p, 0, length); + hb_vector_t shared_indices; + if (var_data->has_shared_point_numbers () && + !unpack_points (p, shared_indices, checker)) return false; + hb_vector_t private_indices; + if (iterator.current_tuple->has_private_points () && + !unpack_points (p, private_indices, checker)) return false; + const hb_array_t &indices = shared_indices.length? shared_indices: private_indices; + + bool apply_to_all = (indices.length == 0); + unsigned int num_deltas = apply_to_all? points.length: indices.length; + hb_vector_t x_deltas; + x_deltas.resize (num_deltas); + if (!unpack_deltas (p, x_deltas, checker)) return false; + hb_vector_t y_deltas; + y_deltas.resize (num_deltas); + if (!unpack_deltas (p, y_deltas, checker)) return false; + + for (unsigned int i = 0; i < num_deltas; i++) + { + unsigned int pt_index = apply_to_all? i: indices[i]; + points[pt_index].x += x_deltas[i] * scalar; + points[pt_index].y += y_deltas[i] * scalar; + } + /* TODO: interpolate untouched points for glyph extents */ + } while (iterator.move_to_next ()); + + return true; + } + + /* Note: Recursively calls itself. Who's checking recursively nested composite glyph BTW? */ + bool get_var_metrics (hb_codepoint_t glyph, + const int *coords, unsigned int coord_count, + hb_vector_t &phantoms) const + { + hb_vector_t points; + hb_vector_t end_points; + if (!glyf.get_contour_points (glyph, true, points, end_points)) return false; + if (!apply_deltas_to_points (glyph, coords, coord_count, points.as_array (), end_points.as_array ())) return false; + + for (unsigned int i = 0; i < pp_t::PHANTOM_COUNT; i++) + phantoms[i] = points[points.length - pp_t::PHANTOM_COUNT + i]; + + glyf::CompositeGlyphHeader::Iterator composite; + if (!glyf.get_composite (glyph, &composite)) return true; /* simple glyph */ + do + { + /* TODO: support component scale/transformation */ + if (((composite.current->flags & glyf::CompositeGlyphHeader::USE_MY_METRICS) != 0) && + !get_var_metrics (composite.current->glyphIndex, coords, coord_count, phantoms)) + return false; + } while (composite.move_to_next()); + return true; + } + + float get_advance_var (hb_codepoint_t glyph, + const int *coords, unsigned int coord_count, + bool vertical) const + { + float advance = 0.f; + if (coord_count != gvar_table->axisCount) return advance; + + hb_vector_t points; + points.resize (pp_t::PHANTOM_COUNT); + + if (!get_var_metrics (glyph, coords, coord_count, points)) + return advance; + + if (vertical) + return -(points[pp_t::PHANTOM_BOTTOM].y - points[pp_t::PHANTOM_TOP].y); // is this sign correct? + else + return points[pp_t::PHANTOM_RIGHT].x - points[pp_t::PHANTOM_LEFT].x; + } + + protected: + const GlyphVarData *get_glyph_var_data (hb_codepoint_t glyph) const + { return gvar_table->get_glyph_var_data (glyph); } + + static bool unpack_points (const HBUINT8 *&p /* IN/OUT */, + hb_vector_t &points /* OUT */, + const range_checker_t &check) + { + enum packed_point_flag_t + { + POINTS_ARE_WORDS = 0x80, + POINT_RUN_COUNT_MASK = 0x7F + }; + + if (!check.in_range (p)) return false; + uint16_t count = *p++; + if ((count & POINTS_ARE_WORDS) != 0) + { + if (!check.in_range (p)) return false; + count = ((count & POINT_RUN_COUNT_MASK) << 8) | *p++; + } + points.resize (count); + + uint16_t i = 0; + while (i < count) + { + if (!check.in_range (p)) return false; + uint16_t j; + uint8_t control = *p++; + uint16_t run_count = (control & POINT_RUN_COUNT_MASK) + 1; + if ((control & POINTS_ARE_WORDS) != 0) + { + for (j = 0; j < run_count && i < count; j++, i++) + { + if (!check.in_range ((const HBUINT16 *)p)) return false; + points[i] = *(const HBUINT16 *)p; + p += HBUINT16::static_size; + } + } + else + { + for (j = 0; j < run_count && i < count; j++, i++) + { + if (!check.in_range (p)) return false; + points[i] = *p++; + } + } + if (j < run_count) return false; + } + return true; + } + + static bool unpack_deltas (const HBUINT8 *&p /* IN/OUT */, + hb_vector_t &deltas /* IN/OUT */, + const range_checker_t &check) + { + enum packed_delta_flag_t + { + DELTAS_ARE_ZERO = 0x80, + DELTAS_ARE_WORDS = 0x40, + DELTA_RUN_COUNT_MASK = 0x3F + }; + + unsigned int i = 0; + unsigned int count = deltas.length; + while (i < count) + { + if (!check.in_range (p)) return false; + uint16_t j; + uint8_t control = *p++; + uint16_t run_count = (control & DELTA_RUN_COUNT_MASK) + 1; + if ((control & DELTAS_ARE_ZERO) != 0) + { + for (j = 0; j < run_count && i < count; j++, i++) + deltas[i] = 0; + } + else if ((control & DELTAS_ARE_WORDS) != 0) + { + for (j = 0; j < run_count && i < count; j++, i++) + { + if (!check.in_range ((const HBUINT16 *)p)) return false; + deltas[i] = *(const HBINT16 *)p; + p += HBUINT16::static_size; + } + } + else + { + for (j = 0; j < run_count && i < count; j++, i++) + { + if (!check.in_range (p)) return false; + deltas[i] = *(const HBINT8 *)p++; + } + } + if (j < run_count) return false; + } + return true; + } + + private: + hb_blob_ptr_t gvar_table; + hb_vector_t shared_tuples; + glyf::accelerator_t glyf; + }; + protected: FixedVersion<> version; /* Version of gvar table. Set to 0x00010000u. */ HBUINT16 axisCount;