--- /dev/null
+/*
+ * Copyright © 2018 Google, Inc.
+ * 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.
+ *
+ * Google Author(s): Behdad Esfahbod
+ */
+
+#ifndef HB_AAT_LAYOUT_KERX_TABLE_HH
+#define HB_AAT_LAYOUT_KERX_TABLE_HH
+
+#include "hb-aat-layout-common-private.hh"
+
+namespace AAT {
+
+
+/*
+ * kerx -- Kerning
+ */
+
+#define HB_AAT_TAG_kerx HB_TAG('k','e','r','x')
+
+struct hb_glyph_pair_t
+{
+ hb_codepoint_t left;
+ hb_codepoint_t right;
+};
+
+struct KerxPair
+{
+ inline int get_kerning (void) const
+ { return value; }
+
+ inline int cmp (const hb_glyph_pair_t &o) const
+ {
+ int ret = left.cmp (o.left);
+ if (ret) return ret;
+ return right.cmp (o.right);
+ }
+
+ inline bool sanitize (hb_sanitize_context_t *c) const
+ {
+ TRACE_SANITIZE (this);
+ return_trace (c->check_struct (this));
+ }
+
+ protected:
+ GlyphID left;
+ GlyphID right;
+ FWORD value;
+ HBUINT16 pad;
+ public:
+ DEFINE_SIZE_STATIC (8);
+};
+
+struct KerxSubTableFormat0
+{
+ inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const
+ {
+ hb_glyph_pair_t pair = {left, right};
+ //int i = pairs.bsearch (pair);
+ //if (i == -1)
+ return 0;
+ //return pairs[i].get_kerning ();
+ }
+
+ inline bool sanitize (hb_sanitize_context_t *c) const
+ {
+ TRACE_SANITIZE (this);
+ return_trace (pairs.sanitize (c));
+ }
+
+ protected:
+ BinSearchArrayOf<KerxPair> pairs; /* Array of kerning pairs. */
+ //FIXME: BinSearchArrayOf and its BinSearchHeader should be
+ //modified in a way to accept uint32s
+ public:
+ //DEFINE_SIZE_ARRAY (16, pairs);
+};
+
+struct KerxAction
+{
+ HBUINT16 index;
+};
+
+struct KerxSubTableFormat1
+{
+ inline bool sanitize (hb_sanitize_context_t *c) const
+ {
+ //TRACE_SANITIZE (this);
+ //return_trace (stateHeader.sanitize (c));
+ return false;
+ }
+
+ protected:
+ StateTable<KerxAction> stateHeader;
+ OffsetTo<ArrayOf<HBUINT16>, HBUINT32> valueTable;
+
+ public:
+ //DEFINE_SIZE_MIN (4);
+};
+
+//FIXME: Maybe this can be replaced with Lookup<HBUINT16>?
+struct KerxClassTable
+{
+ inline unsigned int get_class (hb_codepoint_t g) const { return classes[g - firstGlyph]; }
+
+ inline bool sanitize (hb_sanitize_context_t *c) const
+ {
+ TRACE_SANITIZE (this);
+ return_trace (firstGlyph.sanitize (c) && classes.sanitize (c));
+ }
+
+ protected:
+ HBUINT16 firstGlyph; /* First glyph in class range. */
+ ArrayOf<HBUINT16> classes; /* Glyph classes. */
+ public:
+ DEFINE_SIZE_ARRAY (4, classes);
+};
+
+struct KerxSubTableFormat2
+{
+ inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right, const char *end) const
+ {
+ unsigned int l = (this+leftClassTable).get_class (left);
+ unsigned int r = (this+leftClassTable).get_class (left);
+ unsigned int offset = l * rowWidth + r * sizeof (FWORD);
+ const FWORD *arr = &(this+array);
+ if (unlikely ((const void *) arr < (const void *) this || (const void *) arr >= (const void *) end))
+ return 0;
+ const FWORD *v = &StructAtOffset<FWORD> (arr, offset);
+ if (unlikely ((const void *) v < (const void *) arr || (const void *) (v + 1) > (const void *) end))
+ return 0;
+ return *v;
+ }
+
+ inline bool sanitize (hb_sanitize_context_t *c) const
+ {
+ TRACE_SANITIZE (this);
+ return_trace (rowWidth.sanitize (c) &&
+ leftClassTable.sanitize (c, this) &&
+ rightClassTable.sanitize (c, this) &&
+ array.sanitize (c, this));
+ }
+
+ protected:
+ HBUINT32 rowWidth; /* The width, in bytes, of a row in the table. */
+ LOffsetTo<KerxClassTable>
+ leftClassTable; /* Offset from beginning of this subtable to
+ * left-hand class table. */
+ LOffsetTo<KerxClassTable>
+ rightClassTable;/* Offset from beginning of this subtable to
+ * right-hand class table. */
+ LOffsetTo<FWORD>
+ array; /* Offset from beginning of this subtable to
+ * the start of the kerning array. */
+ public:
+ DEFINE_SIZE_MIN (16);
+};
+
+struct KerxSubTableFormat4
+{
+ inline bool sanitize (hb_sanitize_context_t *c) const
+ {
+ TRACE_SANITIZE (this);
+ return_trace (rowWidth.sanitize (c) &&
+ leftClassTable.sanitize (c, this) &&
+ rightClassTable.sanitize (c, this) &&
+ array.sanitize (c, this));
+ }
+
+ protected:
+ HBUINT32 rowWidth; /* The width, in bytes, of a row in the table. */
+ LOffsetTo<KerxClassTable>
+ leftClassTable; /* Offset from beginning of this subtable to
+ * left-hand class table. */
+ LOffsetTo<KerxClassTable>
+ rightClassTable;/* Offset from beginning of this subtable to
+ * right-hand class table. */
+ LOffsetTo<FWORD>
+ array; /* Offset from beginning of this subtable to
+ * the start of the kerning array. */
+ public:
+ DEFINE_SIZE_MIN (16);
+};
+
+struct KerxSubTableFormat6
+{
+ inline bool sanitize (hb_sanitize_context_t *c) const
+ {
+ //TRACE_SANITIZE (this);
+ //return_trace ;
+ return false;
+ }
+
+ protected:
+ HBUINT32 flags;
+ HBUINT16 rowCount;
+ HBUINT16 columnCount;
+ HBUINT32 rowIndexTableOffset;
+ HBUINT32 columnIndexTableOffset;
+ HBUINT32 kerningArrayOffset;
+ HBUINT32 kerningVectorOffset;
+
+ public:
+ DEFINE_SIZE_MIN (24);
+};
+
+struct KerxSubTable
+{
+ inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right, const char *end, unsigned int format) const
+ {
+ switch (format) {
+ case 0: return u.format0.get_kerning (left, right);
+ case 2: return u.format2.get_kerning (left, right, end);
+ default:return 0;
+ }
+ }
+
+ inline bool sanitize (hb_sanitize_context_t *c, unsigned int format) const
+ {
+ TRACE_SANITIZE (this);
+ switch (format) {
+ case 0: return_trace (u.format0.sanitize (c));
+ case 2: return_trace (u.format2.sanitize (c));
+ default:return_trace (true);
+ }
+ }
+
+ protected:
+ union {
+ KerxSubTableFormat0 format0;
+ KerxSubTableFormat2 format2;
+ KerxSubTableFormat4 format4;
+ KerxSubTableFormat6 format6;
+ } u;
+ public:
+ DEFINE_SIZE_MIN (0);
+};
+
+
+
+struct kerx
+{
+ static const hb_tag_t tableTag = HB_AAT_TAG_kerx;
+
+ struct SubTableWrapper
+ {
+ enum coverage_flags_t {
+ COVERAGE_VERTICAL_FLAG = 0x8000u,
+ COVERAGE_CROSSSTREAM_FLAG = 0x4000u,
+ COVERAGE_VARIATION_FLAG = 0x2000u,
+
+ COVERAGE_OVERRIDE_FLAG = 0x0000u, /* Not supported. */
+
+ COVERAGE_CHECK_FLAGS = 0x0700u, //FIXME: Where these two come from?
+ COVERAGE_CHECK_HORIZONTAL = 0x0100u
+ };
+
+ protected:
+ HBUINT32 length; /* Length of the subtable (including this header). */
+ HBUINT16 coverage; /* Coverage bits. */
+ HBUINT16 format; /* Subtable format. */
+ HBUINT32 tupleIndex; /* The tuple index (used for variations fonts).
+ * This value specifies which tuple this subtable covers. */
+ KerxSubTable subtable; /* Subtable data. */
+ public:
+ inline bool is_horizontal (void) const
+ { return (coverage & COVERAGE_CHECK_FLAGS) == COVERAGE_CHECK_HORIZONTAL; }
+
+ inline bool is_override (void) const
+ { return bool (coverage & COVERAGE_OVERRIDE_FLAG); }
+
+ inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right, const char *end) const
+ { return subtable.get_kerning (left, right, end, format); }
+
+ inline int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right, const char *end) const
+ { return is_horizontal () ? get_kerning (left, right, end) : 0; }
+
+ inline unsigned int get_size (void) const { return length; }
+
+ inline bool sanitize (hb_sanitize_context_t *c) const
+ {
+ TRACE_SANITIZE (this);
+ return_trace (c->check_struct (this) &&
+ length >= min_size &&
+ c->check_array (this, 1, length) &&
+ subtable.sanitize (c, format));
+ }
+ DEFINE_SIZE_MIN (12);
+ };
+
+ inline int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right, unsigned int table_length) const
+ {
+ int v = 0;
+ const SubTableWrapper *st = (SubTableWrapper *) data;
+ unsigned int count = nTables;
+ for (unsigned int i = 0; i < count; i++)
+ {
+ if (st->is_override ())
+ v = 0;
+ v += st->get_h_kerning (left, right, table_length + (const char *) this);
+ st = (SubTableWrapper *) st;
+ }
+ return v;
+ }
+
+ inline bool sanitize (hb_sanitize_context_t *c) const
+ {
+ TRACE_SANITIZE (this);
+ const SubTableWrapper *st = (SubTableWrapper *) data;
+ unsigned int count = nTables;
+ for (unsigned int i = 0; i < count; i++)
+ {
+ if (unlikely (!st->sanitize (c)))
+ return_trace (false);
+ st = (SubTableWrapper *) st;
+ }
+
+ return_trace (true);
+ }
+
+ struct accelerator_t
+ {
+ inline void init (hb_face_t *face)
+ {
+ blob = Sanitizer<kerx>().sanitize (face->reference_table (HB_AAT_TAG_kerx));
+ table = Sanitizer<kerx>::lock_instance (blob);
+ table_length = hb_blob_get_length (blob);
+ }
+ inline void fini (void)
+ {
+ hb_blob_destroy (blob);
+ }
+
+ inline int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right) const
+ { return table->get_h_kerning (left, right, table_length); }
+
+ private:
+ hb_blob_t *blob;
+ const kerx *table;
+ unsigned int table_length;
+ };
+
+ protected:
+ HBUINT16 version;
+ HBUINT16 padding;
+ HBUINT32 nTables; /* Number of subtables in the kerning table. */
+ HBUINT8 data[VAR];
+ //ArrayOf<GlyphCoverageArray> subtableGlyphCoverageArray;
+ public:
+ DEFINE_SIZE_ARRAY (8, data);
+};
+
+} /* namespace AAT */
+
+
+#endif /* HB_AAT_LAYOUT_KERX_TABLE_HH */
projects / platform / upstream / libHarfBuzzSharp.git / commitdiff