/*

 * Copyright © 2007,2008,2009,2010  Red Hat, Inc.

 * Copyright © 2010,2012,2013  Google, Inc.

 *

 *  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.

 *

 * Red Hat Author(s): Behdad Esfahbod

 * Google Author(s): Behdad Esfahbod

 */

#ifndef HB_OT_LAYOUT_GPOS_TABLE_HH

#define HB_OT_LAYOUT_GPOS_TABLE_HH

#include "hb-ot-layout-gsubgpos-private.hh"

namespace OT {

/* buffer **position** var allocations */

#define attach_chain() var.i16[0] /* glyph to which this attaches to, relative to current glyphs; negative for going back, positive for forward. */

#define attach_type() var.u8[2] /* attachment type */

/* Note! if attach_chain() is zero, the value of attach_type() is irrelevant. */

enum attach_type_t {

  ATTACH_TYPE_NONE      = 0X00,

  /* Each attachment should be either a mark or a cursive; can't be both. */

  ATTACH_TYPE_MARK      = 0X01,

  ATTACH_TYPE_CURSIVE   = 0X02,

};

/* Shared Tables: ValueRecord, Anchor Table, and MarkArray */

typedef USHORT Value;

typedef Value ValueRecord[VAR];

struct ValueFormat : USHORT

{

  enum Flags {

    xPlacement  = 0x0001u,      /* Includes horizontal adjustment for placement */

    yPlacement  = 0x0002u,      /* Includes vertical adjustment for placement */

    xAdvance    = 0x0004u,      /* Includes horizontal adjustment for advance */

    yAdvance    = 0x0008u,      /* Includes vertical adjustment for advance */

    xPlaDevice  = 0x0010u,      /* Includes horizontal Device table for placement */

    yPlaDevice  = 0x0020u,      /* Includes vertical Device table for placement */

    xAdvDevice  = 0x0040u,      /* Includes horizontal Device table for advance */

    yAdvDevice  = 0x0080u,      /* Includes vertical Device table for advance */

    ignored     = 0x0F00u,      /* Was used in TrueType Open for MM fonts */

    reserved    = 0xF000u,      /* For future use */

    devices     = 0x00F0u       /* Mask for having any Device table */

  };

/* All fields are options.  Only those available advance the value pointer. */

#if 0

  SHORT         xPlacement;             /* Horizontal adjustment for

                                         * placement--in design units */

  SHORT         yPlacement;             /* Vertical adjustment for

                                         * placement--in design units */

  SHORT         xAdvance;               /* Horizontal adjustment for

                                         * advance--in design units (only used

                                         * for horizontal writing) */

  SHORT         yAdvance;               /* Vertical adjustment for advance--in

                                         * design units (only used for vertical

                                         * writing) */

  Offset        xPlaDevice;             /* Offset to Device table for

                                         * horizontal placement--measured from

                                         * beginning of PosTable (may be NULL) */

  Offset        yPlaDevice;             /* Offset to Device table for vertical

                                         * placement--measured from beginning

                                         * of PosTable (may be NULL) */

  Offset        xAdvDevice;             /* Offset to Device table for

                                         * horizontal advance--measured from

                                         * beginning of PosTable (may be NULL) */

  Offset        yAdvDevice;             /* Offset to Device table for vertical

                                         * advance--measured from beginning of

                                         * PosTable (may be NULL) */

#endif

  inline unsigned int get_len (void) const

  { return _hb_popcount32 ((unsigned int) *this); }

  inline unsigned int get_size (void) const

  { return get_len () * Value::static_size; }

  void apply_value (hb_apply_context_t   *c,

                    const void           *base,

                    const Value          *values,

                    hb_glyph_position_t  &glyph_pos) const

  {

    unsigned int format = *this;

    if (!format) return;

    hb_font_t *font = c->font;

    hb_bool_t horizontal = HB_DIRECTION_IS_HORIZONTAL (c->direction);

    if (format & xPlacement) glyph_pos.x_offset  += font->em_scale_x (get_short (values++));

    if (format & yPlacement) glyph_pos.y_offset  += font->em_scale_y (get_short (values++));

    if (format & xAdvance) {

      if (likely (horizontal)) glyph_pos.x_advance += font->em_scale_x (get_short (values));

      values++;

    }

    /* y_advance values grow downward but font-space grows upward, hence negation */

    if (format & yAdvance) {

      if (unlikely (!horizontal)) glyph_pos.y_advance -= font->em_scale_y (get_short (values));

      values++;

    }

    if (!has_device ()) return;

    bool use_x_device = font->x_ppem || font->num_coords;

    bool use_y_device = font->y_ppem || font->num_coords;

    if (!use_x_device && !use_y_device) return;

    const VariationStore &store = c->var_store;

    /* pixel -> fractional pixel */

    if (format & xPlaDevice) {

      if (use_x_device) glyph_pos.x_offset  += (base + get_device (values)).get_x_delta (font, store);

      values++;

    }

    if (format & yPlaDevice) {

      if (use_y_device) glyph_pos.y_offset  += (base + get_device (values)).get_y_delta (font, store);

      values++;

    }

    if (format & xAdvDevice) {

      if (horizontal && use_x_device) glyph_pos.x_advance += (base + get_device (values)).get_x_delta (font, store);

      values++;

    }

    if (format & yAdvDevice) {

      /* y_advance values grow downward but font-space grows upward, hence negation */

      if (!horizontal && use_y_device) glyph_pos.y_advance -= (base + get_device (values)).get_y_delta (font, store);

      values++;

    }

  }

  private:

  inline bool sanitize_value_devices (hb_sanitize_context_t *c, const void *base, const Value *values) const

  {

    unsigned int format = *this;

    if (format & xPlacement) values++;

    if (format & yPlacement) values++;

    if (format & xAdvance)   values++;

    if (format & yAdvance)   values++;

    if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false;

    if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false;

    if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false;

    if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false;

    return true;

  }

  static inline OffsetTo<Device>& get_device (Value* value)

  { return *CastP<OffsetTo<Device> > (value); }

  static inline const OffsetTo<Device>& get_device (const Value* value)

  { return *CastP<OffsetTo<Device> > (value); }

  static inline const SHORT& get_short (const Value* value)

  { return *CastP<SHORT> (value); }

  public:

  inline bool has_device (void) const {

    unsigned int format = *this;

    return (format & devices) != 0;

  }

  inline bool sanitize_value (hb_sanitize_context_t *c, const void *base, const Value *values) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_range (values, get_size ()) && (!has_device () || sanitize_value_devices (c, base, values)));

  }

  inline bool sanitize_values (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count) const

  {

    TRACE_SANITIZE (this);

    unsigned int len = get_len ();

    if (!c->check_array (values, get_size (), count)) return_trace (false);

    if (!has_device ()) return_trace (true);

    for (unsigned int i = 0; i < count; i++) {

      if (!sanitize_value_devices (c, base, values))

        return_trace (false);

      values += len;

    }

    return_trace (true);

  }

  /* Just sanitize referenced Device tables.  Doesn't check the values themselves. */

  inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count, unsigned int stride) const

  {

    TRACE_SANITIZE (this);

    if (!has_device ()) return_trace (true);

    for (unsigned int i = 0; i < count; i++) {

      if (!sanitize_value_devices (c, base, values))

        return_trace (false);

      values += stride;

    }

    return_trace (true);

  }

};

struct AnchorFormat1

{

  inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,

                          hb_position_t *x, hb_position_t *y) const

  {

    hb_font_t *font = c->font;

    *x = font->em_scale_x (xCoordinate);

    *y = font->em_scale_y (yCoordinate);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this));

  }

  protected:

  USHORT        format;                 /* Format identifier--format = 1 */

  SHORT         xCoordinate;            /* Horizontal value--in design units */

  SHORT         yCoordinate;            /* Vertical value--in design units */

  public:

  DEFINE_SIZE_STATIC (6);

};

struct AnchorFormat2

{

  inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id,

                          hb_position_t *x, hb_position_t *y) const

  {

    hb_font_t *font = c->font;

    unsigned int x_ppem = font->x_ppem;

    unsigned int y_ppem = font->y_ppem;

    hb_position_t cx, cy;

    hb_bool_t ret;

    ret = (x_ppem || y_ppem) &&

           font->get_glyph_contour_point_for_origin (glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy);

    *x = ret && x_ppem ? cx : font->em_scale_x (xCoordinate);

    *y = ret && y_ppem ? cy : font->em_scale_y (yCoordinate);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this));

  }

  protected:

  USHORT        format;                 /* Format identifier--format = 2 */

  SHORT         xCoordinate;            /* Horizontal value--in design units */

  SHORT         yCoordinate;            /* Vertical value--in design units */

  USHORT        anchorPoint;            /* Index to glyph contour point */

  public:

  DEFINE_SIZE_STATIC (8);

};

struct AnchorFormat3

{

  inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,

                          hb_position_t *x, hb_position_t *y) const

  {

    hb_font_t *font = c->font;

    *x = font->em_scale_x (xCoordinate);

    *y = font->em_scale_y (yCoordinate);

    if (font->x_ppem || font->num_coords)

      *x += (this+xDeviceTable).get_x_delta (font, c->var_store);

    if (font->y_ppem || font->num_coords)

      *y += (this+yDeviceTable).get_y_delta (font, c->var_store);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) && xDeviceTable.sanitize (c, this) && yDeviceTable.sanitize (c, this));

  }

  protected:

  USHORT        format;                 /* Format identifier--format = 3 */

  SHORT         xCoordinate;            /* Horizontal value--in design units */

  SHORT         yCoordinate;            /* Vertical value--in design units */

  OffsetTo<Device>

                xDeviceTable;           /* Offset to Device table for X

                                         * coordinate-- from beginning of

                                         * Anchor table (may be NULL) */

  OffsetTo<Device>

                yDeviceTable;           /* Offset to Device table for Y

                                         * coordinate-- from beginning of

                                         * Anchor table (may be NULL) */

  public:

  DEFINE_SIZE_STATIC (10);

};

struct Anchor

{

  inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id,

                          hb_position_t *x, hb_position_t *y) const

  {

    *x = *y = 0;

    switch (u.format) {

    case 1: u.format1.get_anchor (c, glyph_id, x, y); return;

    case 2: u.format2.get_anchor (c, glyph_id, x, y); return;

    case 3: u.format3.get_anchor (c, glyph_id, x, y); return;

    default:                                             return;

    }

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    if (!u.format.sanitize (c)) return_trace (false);

    switch (u.format) {

    case 1: return_trace (u.format1.sanitize (c));

    case 2: return_trace (u.format2.sanitize (c));

    case 3: return_trace (u.format3.sanitize (c));

    default:return_trace (true);

    }

  }

  protected:

  union {

  USHORT                format;         /* Format identifier */

  AnchorFormat1         format1;

  AnchorFormat2         format2;

  AnchorFormat3         format3;

  } u;

  public:

  DEFINE_SIZE_UNION (2, format);

};

struct AnchorMatrix

{

  inline const Anchor& get_anchor (unsigned int row, unsigned int col, unsigned int cols, bool *found) const {

    *found = false;

    if (unlikely (row >= rows || col >= cols)) return Null(Anchor);

    *found = !matrixZ[row * cols + col].is_null ();

    return this+matrixZ[row * cols + col];

  }

  inline bool sanitize (hb_sanitize_context_t *c, unsigned int cols) const

  {

    TRACE_SANITIZE (this);

    if (!c->check_struct (this)) return_trace (false);

    if (unlikely (_hb_unsigned_int_mul_overflows (rows, cols))) return_trace (false);

    unsigned int count = rows * cols;

    if (!c->check_array (matrixZ, matrixZ[0].static_size, count)) return_trace (false);

    for (unsigned int i = 0; i < count; i++)

      if (!matrixZ[i].sanitize (c, this)) return_trace (false);

    return_trace (true);

  }

  USHORT        rows;                   /* Number of rows */

  protected:

  OffsetTo<Anchor>

                matrixZ[VAR];           /* Matrix of offsets to Anchor tables--

                                         * from beginning of AnchorMatrix table */

  public:

  DEFINE_SIZE_ARRAY (2, matrixZ);

};

struct MarkRecord

{

  friend struct MarkArray;

  inline bool sanitize (hb_sanitize_context_t *c, const void *base) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) && markAnchor.sanitize (c, base));

  }

  protected:

  USHORT        klass;                  /* Class defined for this mark */

  OffsetTo<Anchor>

                markAnchor;             /* Offset to Anchor table--from

                                         * beginning of MarkArray table */

  public:

  DEFINE_SIZE_STATIC (4);

};

struct MarkArray : ArrayOf<MarkRecord>  /* Array of MarkRecords--in Coverage order */

{

  inline bool apply (hb_apply_context_t *c,

                     unsigned int mark_index, unsigned int glyph_index,

                     const AnchorMatrix &anchors, unsigned int class_count,

                     unsigned int glyph_pos) const

  {

    TRACE_APPLY (this);

    hb_buffer_t *buffer = c->buffer;

    const MarkRecord &record = ArrayOf<MarkRecord>::operator[](mark_index);

    unsigned int mark_class = record.klass;

    const Anchor& mark_anchor = this + record.markAnchor;

    bool found;

    const Anchor& glyph_anchor = anchors.get_anchor (glyph_index, mark_class, class_count, &found);

    /* If this subtable doesn't have an anchor for this base and this class,

     * return false such that the subsequent subtables have a chance at it. */

    if (unlikely (!found)) return_trace (false);

    hb_position_t mark_x, mark_y, base_x, base_y;

    mark_anchor.get_anchor (c, buffer->cur().codepoint, &mark_x, &mark_y);

    glyph_anchor.get_anchor (c, buffer->info[glyph_pos].codepoint, &base_x, &base_y);

    hb_glyph_position_t &o = buffer->cur_pos();

    o.x_offset = base_x - mark_x;

    o.y_offset = base_y - mark_y;

    o.attach_type() = ATTACH_TYPE_MARK;

    o.attach_chain() = (int) glyph_pos - (int) buffer->idx;

    buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;

    buffer->idx++;

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (ArrayOf<MarkRecord>::sanitize (c, this));

  }

};

/* Lookups */

struct SinglePosFormat1

{

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    (this+coverage).add_coverage (c->input);

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_buffer_t *buffer = c->buffer;

    unsigned int index = (this+coverage).get_coverage  (buffer->cur().codepoint);

    if (likely (index == NOT_COVERED)) return_trace (false);

    valueFormat.apply_value (c, this, values, buffer->cur_pos());

    buffer->idx++;

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (c->check_struct (this) &&

                  coverage.sanitize (c, this) &&

                  valueFormat.sanitize_value (c, this, values));

  }

  protected:

  USHORT        format;                 /* Format identifier--format = 1 */

  OffsetTo<Coverage>

                coverage;               /* Offset to Coverage table--from

                                         * beginning of subtable */

  ValueFormat   valueFormat;            /* Defines the types of data in the

                                         * ValueRecord */

  ValueRecord   values;                 /* Defines positioning

                                         * value(s)--applied to all glyphs in

                                         * the Coverage table */

  public:

  DEFINE_SIZE_ARRAY (6, values);

};

struct SinglePosFormat2

{

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    (this+coverage).add_coverage (c->input);

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool apply (hb_apply_context_t *c) const