X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fhb-ot-layout-common-private.hh;h=ce47e22a065e86c715c26e9cc64f9bc469d2a0df;hb=45412523dc295cb5ee12e096bfacb282cc925843;hp=fd224b79502d54d2a0f3a79018db7543776d63af;hpb=2cb08458f674301cde9d962c13911035a251f7c5;p=framework%2Fuifw%2Fharfbuzz.git

diff --git a/src/hb-ot-layout-common-private.hh b/src/hb-ot-layout-common-private.hh
index fd224b7..ce47e22 100644
--- a/src/hb-ot-layout-common-private.hh
+++ b/src/hb-ot-layout-common-private.hh
@@ -1,7 +1,8 @@
 /*
- * Copyright (C) 2007,2008,2009  Red Hat, Inc.
+ * Copyright © 2007,2008,2009  Red Hat, Inc.
+ * Copyright © 2010  Google, Inc.
  *
- *  This is part of HarfBuzz, an OpenType Layout engine library.
+ *  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
@@ -22,12 +23,13 @@
  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  *
  * Red Hat Author(s): Behdad Esfahbod
+ * Google Author(s): Behdad Esfahbod
  */
 
 #ifndef HB_OT_LAYOUT_COMMON_PRIVATE_HH
 #define HB_OT_LAYOUT_COMMON_PRIVATE_HH
 
-#include "hb-ot-layout-private.h"
+#include "hb-ot-layout-private.hh"
 
 #include "hb-open-type-private.hh"
 
@@ -36,6 +38,9 @@
 #define NOT_COVERED		((unsigned int) 0x110000)
 #define MAX_NESTING_LEVEL	8
 
+HB_BEGIN_DECLS
+HB_END_DECLS
+
 
 /*
  *
@@ -51,24 +56,32 @@
 template <typename Type>
 struct Record
 {
-  static inline unsigned int get_size () { return sizeof (Record<Type>); }
+  inline int cmp (hb_tag_t a) const {
+    return tag.cmp (a);
+  }
 
-  inline bool sanitize (SANITIZE_ARG_DEF, const void *base) {
+  inline bool sanitize (hb_sanitize_context_t *c, void *base) {
     TRACE_SANITIZE ();
-    return SANITIZE (tag) && SANITIZE_BASE (offset, base);
+    return c->check_struct (this)
+	&& offset.sanitize (c, base);
   }
 
   Tag		tag;		/* 4-byte Tag identifier */
   OffsetTo<Type>
 		offset;		/* Offset from beginning of object holding
 				 * the Record */
+  public:
+  DEFINE_SIZE_STATIC (6);
 };
 
 template <typename Type>
-struct RecordArrayOf : ArrayOf<Record<Type> > {
+struct RecordArrayOf : SortedArrayOf<Record<Type> > {
   inline const Tag& get_tag (unsigned int i) const
   {
-    if (HB_UNLIKELY (i >= this->len)) return Null(Tag);
+    /* We cheat slightly and don't define separate Null objects
+     * for Record types.  Instead, we return the correct Null(Tag)
+     * here. */
+    if (unlikely (i >= this->len)) return Null(Tag);
     return (*this)[i].tag;
   }
   inline unsigned int get_tags (unsigned int start_offset,
@@ -76,30 +89,23 @@ struct RecordArrayOf : ArrayOf<Record<Type> > {
 				hb_tag_t     *record_tags /* OUT */) const
   {
     if (record_count) {
-      const Record<Type> *array = this->const_sub_array (start_offset, record_count);
+      const Record<Type> *arr = this->sub_array (start_offset, record_count);
       unsigned int count = *record_count;
       for (unsigned int i = 0; i < count; i++)
-	record_tags[i] = array[i].tag;
+	record_tags[i] = arr[i].tag;
     }
     return this->len;
   }
   inline bool find_index (hb_tag_t tag, unsigned int *index) const
   {
-    Tag t;
-    t.set (tag);
-    // TODO bsearch
-    const Record<Type> *a = this->array();
-    unsigned int count = this->len;
-    for (unsigned int i = 0; i < count; i++)
-    {
-      if (t == a[i].tag)
-      {
+    int i = this->search (tag);
+    if (i != -1) {
         if (index) *index = i;
         return true;
-      }
+    } else {
+      if (index) *index = Index::NOT_FOUND_INDEX;
+      return false;
     }
-    if (index) *index = NO_INDEX;
-    return false;
   }
 };
 
@@ -109,30 +115,45 @@ struct RecordListOf : RecordArrayOf<Type>
   inline const Type& operator [] (unsigned int i) const
   { return this+RecordArrayOf<Type>::operator [](i).offset; }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return RecordArrayOf<Type>::sanitize (SANITIZE_ARG, ConstCharP(this));
+    return RecordArrayOf<Type>::sanitize (c, this);
   }
 };
 
 
-struct IndexArray : ArrayOf<USHORT>
+struct RangeRecord
 {
-  inline unsigned int operator [] (unsigned int i) const
-  {
-    if (HB_UNLIKELY (i >= this->len))
-      return NO_INDEX;
-    return this->array()[i];
+  inline int cmp (hb_codepoint_t g) const {
+    hb_codepoint_t a = start, b = end;
+    return g < a ? -1 : g <= b ? 0 : +1 ;
   }
+
+  inline bool sanitize (hb_sanitize_context_t *c) {
+    TRACE_SANITIZE ();
+    return c->check_struct (this);
+  }
+
+  GlyphID	start;		/* First GlyphID in the range */
+  GlyphID	end;		/* Last GlyphID in the range */
+  USHORT	value;		/* Value */
+  public:
+  DEFINE_SIZE_STATIC (6);
+};
+DEFINE_NULL_DATA (RangeRecord, "\000\001");
+
+
+struct IndexArray : ArrayOf<Index>
+{
   inline unsigned int get_indexes (unsigned int start_offset,
 				   unsigned int *_count /* IN/OUT */,
 				   unsigned int *_indexes /* OUT */) const
   {
     if (_count) {
-      const USHORT *array = this->const_sub_array (start_offset, _count);
+      const USHORT *arr = this->sub_array (start_offset, _count);
       unsigned int count = *_count;
       for (unsigned int i = 0; i < count; i++)
-	_indexes[i] = array[i];
+	_indexes[i] = arr[i];
     }
     return this->len;
   }
@@ -156,16 +177,17 @@ struct LangSys
   { return featureIndex.get_indexes (start_offset, feature_count, feature_indexes); }
 
   inline bool has_required_feature (void) const { return reqFeatureIndex != 0xffff; }
-  inline int get_required_feature_index (void) const
+  inline unsigned int get_required_feature_index (void) const
   {
     if (reqFeatureIndex == 0xffff)
-      return NO_INDEX;
+      return Index::NOT_FOUND_INDEX;
    return reqFeatureIndex;;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return SANITIZE_SELF () && SANITIZE (featureIndex);
+    return c->check_struct (this)
+	&& featureIndex.sanitize (c);
   }
 
   Offset	lookupOrder;	/* = Null (reserved for an offset to a
@@ -174,9 +196,10 @@ struct LangSys
 				 * language system--if no required features
 				 * = 0xFFFF */
   IndexArray	featureIndex;	/* Array of indices into the FeatureList */
+  public:
+  DEFINE_SIZE_ARRAY (6, featureIndex);
 };
-ASSERT_SIZE (LangSys, 6);
-DEFINE_NULL_DATA (LangSys, 6, "\0\0\xFF\xFF");
+DEFINE_NULL_DATA (LangSys, "\0\0\xFF\xFF");
 
 
 struct Script
@@ -191,7 +214,7 @@ struct Script
   { return langSys.get_tags (start_offset, lang_sys_count, lang_sys_tags); }
   inline const LangSys& get_lang_sys (unsigned int i) const
   {
-    if (i == NO_INDEX) return get_default_lang_sys ();
+    if (i == Index::NOT_FOUND_INDEX) return get_default_lang_sys ();
     return this+langSys[i].offset;
   }
   inline bool find_lang_sys_index (hb_tag_t tag, unsigned int *index) const
@@ -200,9 +223,10 @@ struct Script
   inline bool has_default_lang_sys (void) const { return defaultLangSys != 0; }
   inline const LangSys& get_default_lang_sys (void) const { return this+defaultLangSys; }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return SANITIZE_THIS (defaultLangSys) && SANITIZE_THIS (langSys);
+    return defaultLangSys.sanitize (c, this)
+	&& langSys.sanitize (c, this);
   }
 
   private:
@@ -212,11 +236,11 @@ struct Script
   RecordArrayOf<LangSys>
 		langSys;	/* Array of LangSysRecords--listed
 				 * alphabetically by LangSysTag */
+  public:
+  DEFINE_SIZE_ARRAY (4, langSys);
 };
-ASSERT_SIZE (Script, 4);
 
 typedef RecordListOf<Script> ScriptList;
-ASSERT_SIZE (ScriptList, 2);
 
 
 struct Feature
@@ -230,23 +254,22 @@ struct Feature
 					  unsigned int *lookup_tags /* OUT */) const
   { return lookupIndex.get_indexes (start_index, lookup_count, lookup_tags); }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return SANITIZE_SELF () && SANITIZE (lookupIndex);
+    return c->check_struct (this)
+	&& lookupIndex.sanitize (c);
   }
 
-  /* TODO: implement get_feature_parameters() */
-  /* TODO: implement FeatureSize and other special features? */
   Offset	featureParams;	/* Offset to Feature Parameters table (if one
 				 * has been defined for the feature), relative
 				 * to the beginning of the Feature Table; = Null
 				 * if not required */
   IndexArray	 lookupIndex;	/* Array of LookupList indices */
+  public:
+  DEFINE_SIZE_ARRAY (4, lookupIndex);
 };
-ASSERT_SIZE (Feature, 4);
 
 typedef RecordListOf<Feature> FeatureList;
-ASSERT_SIZE (FeatureList, 2);
 
 
 struct LookupFlag : USHORT
@@ -261,31 +284,23 @@ struct LookupFlag : USHORT
     Reserved		= 0x00E0u,
     MarkAttachmentType	= 0xFF00u
   };
+  public:
+  DEFINE_SIZE_STATIC (2);
 };
-ASSERT_SIZE (LookupFlag, 2);
-
-struct LookupSubTable
-{
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    TRACE_SANITIZE ();
-    return SANITIZE_SELF ();
-  }
-
-  private:
-  USHORT	format;		/* Subtable format.  Different for GSUB and GPOS */
-};
-ASSERT_SIZE (LookupSubTable, 2);
 
 struct Lookup
 {
-  inline const LookupSubTable& get_subtable (unsigned int i) const { return this+subTable[i]; }
   inline unsigned int get_subtable_count (void) const { return subTable.len; }
 
   inline unsigned int get_type (void) const { return lookupType; }
-  inline unsigned int get_flag (void) const
+
+  /* lookup_props is a 32-bit integer where the lower 16-bit is LookupFlag and
+   * higher 16-bit is mark-filtering-set if the lookup uses one.
+   * Not to be confused with glyph_props which is very similar. */
+  inline uint32_t get_props (void) const
   {
     unsigned int flag = lookupFlag;
-    if (HB_UNLIKELY (flag & LookupFlag::UseMarkFilteringSet))
+    if (unlikely (flag & LookupFlag::UseMarkFilteringSet))
     {
       const USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
       flag += (markFilteringSet << 16);
@@ -293,29 +308,31 @@ struct Lookup
     return flag;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!(SANITIZE (lookupType) && SANITIZE (lookupFlag) && SANITIZE_THIS (subTable))) return false;
-    if (HB_UNLIKELY (lookupFlag & LookupFlag::UseMarkFilteringSet))
+    /* Real sanitize of the subtables is done by GSUB/GPOS/... */
+    if (!(c->check_struct (this)
+       && subTable.sanitize (c))) return false;
+    if (unlikely (lookupFlag & LookupFlag::UseMarkFilteringSet))
     {
       USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
-      if (!SANITIZE (markFilteringSet)) return false;
+      if (!markFilteringSet.sanitize (c)) return false;
     }
     return true;
   }
 
   USHORT	lookupType;		/* Different enumerations for GSUB and GPOS */
   USHORT	lookupFlag;		/* Lookup qualifiers */
-  OffsetArrayOf<LookupSubTable>
+  ArrayOf<Offset>
 		subTable;		/* Array of SubTables */
   USHORT	markFilteringSetX[VAR];	/* Index (base 0) into GDEF mark glyph sets
 					 * structure. This field is only present if bit
 					 * UseMarkFilteringSet of lookup flags is set. */
+  public:
+  DEFINE_SIZE_ARRAY2 (6, subTable, markFilteringSetX);
 };
-ASSERT_SIZE_VAR (Lookup, 6, USHORT);
 
 typedef OffsetListOf<Lookup> LookupList;
-ASSERT_SIZE (LookupList, 2);
 
 
 /*
@@ -329,58 +346,24 @@ struct CoverageFormat1
   private:
   inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
   {
-    if (HB_UNLIKELY (glyph_id > 0xFFFF))
-      return NOT_COVERED;
-    GlyphID gid;
-    gid.set (glyph_id);
-    // TODO: bsearch
-    unsigned int num_glyphs = glyphArray.len;
-    for (unsigned int i = 0; i < num_glyphs; i++)
-      if (gid == glyphArray[i])
+    int i = glyphArray.search (glyph_id);
+    if (i != -1)
         return i;
     return NOT_COVERED;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return SANITIZE (glyphArray);
+    return glyphArray.sanitize (c);
   }
 
   private:
   USHORT	coverageFormat;	/* Format identifier--format = 1 */
-  ArrayOf<GlyphID>
+  SortedArrayOf<GlyphID>
 		glyphArray;	/* Array of GlyphIDs--in numerical order */
-};
-ASSERT_SIZE (CoverageFormat1, 4);
-
-struct CoverageRangeRecord
-{
-  friend struct CoverageFormat2;
-
-  static inline unsigned int get_size () { return sizeof (CoverageRangeRecord); }
-
-  private:
-  inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
-  {
-    if (glyph_id >= start && glyph_id <= end)
-      return (unsigned int) startCoverageIndex + (glyph_id - start);
-    return NOT_COVERED;
-  }
-
   public:
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    TRACE_SANITIZE ();
-    return SANITIZE_SELF ();
-  }
-
-  private:
-  GlyphID	start;			/* First GlyphID in the range */
-  GlyphID	end;			/* Last GlyphID in the range */
-  USHORT	startCoverageIndex;	/* Coverage Index of first GlyphID in
-					 * range */
+  DEFINE_SIZE_ARRAY (4, glyphArray);
 };
-ASSERT_SIZE (CoverageRangeRecord, 6);
-DEFINE_NULL_DATA (CoverageRangeRecord, 6, "\000\001");
 
 struct CoverageFormat2
 {
@@ -389,30 +372,28 @@ struct CoverageFormat2
   private:
   inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
   {
-    // TODO: bsearch
-    unsigned int count = rangeRecord.len;
-    for (unsigned int i = 0; i < count; i++)
-    {
-      unsigned int coverage = rangeRecord[i].get_coverage (glyph_id);
-      if (coverage != NOT_COVERED)
-        return coverage;
+    int i = rangeRecord.search (glyph_id);
+    if (i != -1) {
+      const RangeRecord &range = rangeRecord[i];
+      return (unsigned int) range.value + (glyph_id - range.start);
     }
     return NOT_COVERED;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return SANITIZE (rangeRecord);
+    return rangeRecord.sanitize (c);
   }
 
   private:
   USHORT	coverageFormat;	/* Format identifier--format = 2 */
-  ArrayOf<CoverageRangeRecord>
+  SortedArrayOf<RangeRecord>
 		rangeRecord;	/* Array of glyph ranges--ordered by
 				 * Start GlyphID. rangeCount entries
 				 * long */
+  public:
+  DEFINE_SIZE_ARRAY (4, rangeRecord);
 };
-ASSERT_SIZE (CoverageFormat2, 4);
 
 struct Coverage
 {
@@ -421,18 +402,18 @@ struct Coverage
   inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
   {
     switch (u.format) {
-    case 1: return u.format1->get_coverage(glyph_id);
-    case 2: return u.format2->get_coverage(glyph_id);
+    case 1: return u.format1.get_coverage(glyph_id);
+    case 2: return u.format2.get_coverage(glyph_id);
     default:return NOT_COVERED;
     }
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!SANITIZE (u.format)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1->sanitize (SANITIZE_ARG);
-    case 2: return u.format2->sanitize (SANITIZE_ARG);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
     default:return true;
     }
   }
@@ -440,9 +421,11 @@ struct Coverage
   private:
   union {
   USHORT		format;		/* Format identifier */
-  CoverageFormat1	format1[VAR];
-  CoverageFormat2	format2[VAR];
+  CoverageFormat1	format1;
+  CoverageFormat2	format2;
   } u;
+  public:
+  DEFINE_SIZE_UNION (2, format);
 };
 
 
@@ -455,102 +438,72 @@ struct ClassDefFormat1
   friend struct ClassDef;
 
   private:
-  inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
+  inline unsigned int get_class (hb_codepoint_t glyph_id) const
   {
     if ((unsigned int) (glyph_id - startGlyph) < classValue.len)
       return classValue[glyph_id - startGlyph];
     return 0;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return SANITIZE_SELF () && SANITIZE (classValue);
+    return c->check_struct (this)
+	&& classValue.sanitize (c);
   }
 
   USHORT	classFormat;		/* Format identifier--format = 1 */
   GlyphID	startGlyph;		/* First GlyphID of the classValueArray */
   ArrayOf<USHORT>
 		classValue;		/* Array of Class Values--one per GlyphID */
-};
-ASSERT_SIZE (ClassDefFormat1, 6);
-
-struct ClassRangeRecord
-{
-  friend struct ClassDefFormat2;
-
-  static inline unsigned int get_size () { return sizeof (ClassRangeRecord); }
-
-  private:
-  inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
-  {
-    if (glyph_id >= start && glyph_id <= end)
-      return classValue;
-    return 0;
-  }
-
   public:
-  inline bool sanitize (SANITIZE_ARG_DEF) {
-    TRACE_SANITIZE ();
-    return SANITIZE_SELF ();
-  }
-
-  private:
-  GlyphID	start;		/* First GlyphID in the range */
-  GlyphID	end;		/* Last GlyphID in the range */
-  USHORT	classValue;	/* Applied to all glyphs in the range */
+  DEFINE_SIZE_ARRAY (6, classValue);
 };
-ASSERT_SIZE (ClassRangeRecord, 6);
-DEFINE_NULL_DATA (ClassRangeRecord, 6, "\000\001");
 
 struct ClassDefFormat2
 {
   friend struct ClassDef;
 
   private:
-  inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
+  inline unsigned int get_class (hb_codepoint_t glyph_id) const
   {
-    // TODO: bsearch
-    unsigned int count = rangeRecord.len;
-    for (unsigned int i = 0; i < count; i++)
-    {
-      int classValue = rangeRecord[i].get_class (glyph_id);
-      if (classValue > 0)
-        return classValue;
-    }
+    int i = rangeRecord.search (glyph_id);
+    if (i != -1)
+      return rangeRecord[i].value;
     return 0;
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return SANITIZE (rangeRecord);
+    return rangeRecord.sanitize (c);
   }
 
   USHORT	classFormat;	/* Format identifier--format = 2 */
-  ArrayOf<ClassRangeRecord>
+  SortedArrayOf<RangeRecord>
 		rangeRecord;	/* Array of glyph ranges--ordered by
 				 * Start GlyphID */
+  public:
+  DEFINE_SIZE_ARRAY (4, rangeRecord);
 };
-ASSERT_SIZE (ClassDefFormat2, 4);
 
 struct ClassDef
 {
-  inline hb_ot_layout_class_t operator () (hb_codepoint_t glyph_id) const { return get_class (glyph_id); }
+  inline unsigned int operator () (hb_codepoint_t glyph_id) const { return get_class (glyph_id); }
 
-  inline hb_ot_layout_class_t get_class (hb_codepoint_t glyph_id) const
+  inline unsigned int get_class (hb_codepoint_t glyph_id) const
   {
     switch (u.format) {
-    case 1: return u.format1->get_class(glyph_id);
-    case 2: return u.format2->get_class(glyph_id);
+    case 1: return u.format1.get_class(glyph_id);
+    case 2: return u.format2.get_class(glyph_id);
     default:return 0;
     }
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    if (!SANITIZE (u.format)) return false;
+    if (!u.format.sanitize (c)) return false;
     switch (u.format) {
-    case 1: return u.format1->sanitize (SANITIZE_ARG);
-    case 2: return u.format2->sanitize (SANITIZE_ARG);
+    case 1: return u.format1.sanitize (c);
+    case 2: return u.format2.sanitize (c);
     default:return true;
     }
   }
@@ -558,9 +511,11 @@ struct ClassDef
   private:
   union {
   USHORT		format;		/* Format identifier */
-  ClassDefFormat1	format1[VAR];
-  ClassDefFormat2	format2[VAR];
+  ClassDefFormat1	format1;
+  ClassDefFormat2	format2;
   } u;
+  public:
+  DEFINE_SIZE_UNION (2, format);
 };
 
 
@@ -570,12 +525,29 @@ struct ClassDef
 
 struct Device
 {
-  inline int operator () (unsigned int ppem_size) const { return get_delta (ppem_size); }
 
-  inline int get_delta (unsigned int ppem_size) const
+  inline hb_position_t get_x_delta (hb_font_t *font) const
+  { return get_delta (font->x_ppem, font->x_scale); }
+
+  inline hb_position_t get_y_delta (hb_font_t *font) const
+  { return get_delta (font->y_ppem, font->y_scale); }
+
+  inline int get_delta (unsigned int ppem, int scale) const
+  {
+    if (!ppem) return 0;
+
+    int pixels = get_delta_pixels (ppem);
+
+    if (!pixels) return 0;
+
+    return pixels * (int64_t) scale / ppem;
+  }
+
+
+  inline int get_delta_pixels (unsigned int ppem_size) const
   {
     unsigned int f = deltaFormat;
-    if (HB_UNLIKELY (f < 1 || f > 3))
+    if (unlikely (f < 1 || f > 3))
       return 0;
 
     if (ppem_size < startSize || ppem_size > endSize)
@@ -595,25 +567,34 @@ struct Device
     return delta;
   }
 
-  inline unsigned int get_size () const
+  inline unsigned int get_size (void) const
   {
     unsigned int f = deltaFormat;
-    if (HB_UNLIKELY (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::get_size ();
-    return 3 * USHORT::get_size () + ((endSize - startSize + (1 << (4 - f)) - 1) >> (4 - f));
+    if (unlikely (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::static_size;
+    return USHORT::static_size * (4 + ((endSize - startSize) >> (4 - f)));
   }
 
-  inline bool sanitize (SANITIZE_ARG_DEF) {
+  inline bool sanitize (hb_sanitize_context_t *c) {
     TRACE_SANITIZE ();
-    return SANITIZE_GET_SIZE ();
+    return c->check_struct (this)
+	&& c->check_range (this, this->get_size ());
   }
 
   private:
-  USHORT	startSize;	/* Smallest size to correct--in ppem */
-  USHORT	endSize;	/* Largest size to correct--in ppem */
-  USHORT	deltaFormat;	/* Format of DeltaValue array data: 1, 2, or 3 */
+  USHORT	startSize;		/* Smallest size to correct--in ppem */
+  USHORT	endSize;		/* Largest size to correct--in ppem */
+  USHORT	deltaFormat;		/* Format of DeltaValue array data: 1, 2, or 3
+					 * 1	Signed 2-bit value, 8 values per uint16
+					 * 2	Signed 4-bit value, 4 values per uint16
+					 * 3	Signed 8-bit value, 2 values per uint16
+					 */
   USHORT	deltaValue[VAR];	/* Array of compressed data */
+  public:
+  DEFINE_SIZE_ARRAY (6, deltaValue);
 };
-ASSERT_SIZE_VAR (Device, 6, USHORT);
 
 
+HB_BEGIN_DECLS
+HB_END_DECLS
+
 #endif /* HB_OT_LAYOUT_COMMON_PRIVATE_HH */