// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "transform_stack.h"

//
//
//

#include <stdlib.h>
#include <math.h>

//
//
//

#undef NDEBUG
#include <assert.h>

//
//
//

#define TS_TRANSFORM_SUFFIX_EVAL(a)  a

#define TS_TRANSFORM_SUFFIX_CONCAT(func)                                \
  TS_TRANSFORM_SUFFIX_EVAL(func)##TS_TRANSFORM_SUFFIX_EVAL(TS_TRANSFORM_FLOAT_SUFFIX)

//
//
//

#define TS_TRANSFORM_SIN(x)  TS_TRANSFORM_SUFFIX_CONCAT(sin)(x)
#define TS_TRANSFORM_COS(x)  TS_TRANSFORM_SUFFIX_CONCAT(cos)(x)
#define TS_TRANSFORM_TAN(x)  TS_TRANSFORM_SUFFIX_CONCAT(tan)(x)

//
//
//
#define TS_TRANSFORM_ZERO    ((ts_transform_float_t)0.0)
#define TS_TRANSFORM_ONE     ((ts_transform_float_t)1.0)
#define TS_TRANSFORM_RCP(f)  (TS_TRANSFORM_ONE / (f))


//
//
//

union ts_transform_stack_3x3_u
{
  ts_transform_float_t   a8[8];

  struct {
    ts_transform_float_t sx;
    ts_transform_float_t shx;
    ts_transform_float_t tx;

    ts_transform_float_t shy;
    ts_transform_float_t sy;
    ts_transform_float_t ty;

    ts_transform_float_t w0;
    ts_transform_float_t w1;
    // w2 is always 1.0
  };

  struct {
    ts_transform_float_t a;
    ts_transform_float_t b;
    ts_transform_float_t c;

    ts_transform_float_t d;
    ts_transform_float_t e;
    ts_transform_float_t f;

    ts_transform_float_t g;
    ts_transform_float_t h;
    // i is always 1.0
  };
};

//
//
//

struct ts_transform_stack
{
  uint32_t                         size;
  uint32_t                         count;

  ts_transform_weakref_t         * weakrefs;
  union ts_transform_stack_3x3_u * transforms;
};

//
//
//

static
void
ts_transform_stack_resize(struct ts_transform_stack * const ts, uint32_t const size)
{
  ts->size       = size;
  ts->weakrefs   = realloc(ts->weakrefs,  size * sizeof(*ts->weakrefs));
  ts->transforms = realloc(ts->transforms,size * sizeof(*ts->transforms));
}

static
void
ts_transform_stack_ensure(struct ts_transform_stack * const ts)
{
  if (ts->count < ts->size)
    return;

  // increase by 50% and by at least 8
  ts_transform_stack_resize(ts,ts->size + max(ts->size/2,8));
}

//
//
//

struct ts_transform_stack *
ts_transform_stack_create(uint32_t const size)
{
  struct ts_transform_stack * ts = malloc(sizeof(*ts));

  ts->size       = size;
  ts->count      = 0;

  ts->transforms = NULL;
  ts->weakrefs   = NULL;

  ts_transform_stack_resize(ts,size);

  return ts;
}

void
ts_transform_stack_release(struct ts_transform_stack * const ts)
{
  free(ts->transforms);
  free(ts->weakrefs);

  free(ts);
}

//
//
//

uint32_t
ts_transform_stack_save(struct ts_transform_stack * const ts)
{
  return ts->count;
}

void
ts_transform_stack_restore(struct ts_transform_stack * const ts,
                           uint32_t                    const restore)
{
  ts->count = restore;
}

//
//
//

static
union ts_transform_stack_3x3_u *
ts_transform_stack_tos(struct ts_transform_stack * const ts)
{
  return ts->transforms + ts->count - 1;
}

//
//
//

static
void
ts_transform_stack_3x3_u_copy(union ts_transform_stack_3x3_u       * const __restrict dst,
                              union ts_transform_stack_3x3_u const * const __restrict src)
{
  *dst = *src;
}

//
// C = A * B
//
// FIXME -- can save affine vs. projective flags and save a few ops
//

#define TS_TRANSFORM_MULTIPLY(A,B)                                    \
  A->sx  * B->sx   +  A->shx * B->shy  +  A->tx * B->w0,              \
  A->sx  * B->shx  +  A->shx * B->sy   +  A->tx * B->w1,              \
  A->sx  * B->tx   +  A->shx * B->ty   +  A->tx,                      \
  A->shy * B->sx   +  A->sy  * B->shy  +  A->ty * B->w0,              \
  A->shy * B->shx  +  A->sy  * B->sy   +  A->ty * B->w1,              \
  A->shy * B->tx   +  A->sy  * B->ty   +  A->ty,                      \
  A->w0  * B->sx   +  A->w1  * B->shy  +          B->w0,              \
  A->w0  * B->shx  +  A->w1  * B->sy   +          B->w1,              \
  A->w0  * B->tx   +  A->w1  * B->ty   +          TS_TRANSFORM_ONE

//
//
//

#define TS_IS_AFFINE(t) ((t->w0 == TS_TRANSFORM_ZERO) && (t->w1 == TS_TRANSFORM_ZERO))

static
ts_transform_type_e
ts_transform_stack_classify(struct ts_transform_stack * const ts)
{
  union ts_transform_stack_3x3_u const * const t = ts_transform_stack_tos(ts);

  if (TS_IS_AFFINE(t))
    return TS_TRANSFORM_TYPE_AFFINE;
  else
    return TS_TRANSFORM_TYPE_PROJECTIVE;
}

//
//
//

ts_transform_float_t *
ts_transform_stack_top_transform(struct ts_transform_stack * const ts)
{
  return ts_transform_stack_tos(ts)->a8;
}

ts_transform_weakref_t *
ts_transform_stack_top_weakref(struct ts_transform_stack * const ts)
{
  return ts->weakrefs + ts->count - 1;
}

//
//
//

void
ts_transform_stack_dup(struct ts_transform_stack * const ts)
{
  ts_transform_stack_ensure(ts);

  union ts_transform_stack_3x3_u * const tos = ts_transform_stack_tos(ts);

  ts_transform_stack_3x3_u_copy(tos+1,tos);

  ts->weakrefs[ts->count] = ts->weakrefs[ts->count-1];

  ts->count += 1;
}

void
ts_transform_stack_drop(struct ts_transform_stack * const ts)
{
  assert(ts->count >= 1);

  ts->count -= 1;
}

//
//
//

static
void
ts_transform_stack_swap_drop(struct ts_transform_stack * const ts)
{
  assert(ts->count >= 2);

  union ts_transform_stack_3x3_u * const tos = ts_transform_stack_tos(ts);

  ts_transform_stack_3x3_u_copy(tos-1,tos);

  ts->weakrefs[ts->count-2] = ts->weakrefs[ts->count-1];

  ts->count -= 1;
}

//
//
//

static
void
ts_transform_stack_store_matrix_8(struct ts_transform_stack * const ts,
                                  uint32_t                    const idx,
                                  ts_transform_float_t        const sx,
                                  ts_transform_float_t        const shx,
                                  ts_transform_float_t        const tx,
                                  ts_transform_float_t        const shy,
                                  ts_transform_float_t        const sy,
                                  ts_transform_float_t        const ty,
                                  ts_transform_float_t        const w0,
                                  ts_transform_float_t        const w1)
{
  union ts_transform_stack_3x3_u * t = ts->transforms + idx;

  t->sx  = sx;
  t->shx = shx;
  t->tx  = tx;

  t->shy = shy;
  t->sy  = sy;
  t->ty  = ty;

  t->w0  = w0;
  t->w1  = w1;

  ts->weakrefs[idx] = TS_TRANSFORM_WEAKREF_INVALID;
}

//
//
//

static
void
ts_transform_stack_store_matrix(struct ts_transform_stack * const ts,
                                uint32_t                    const idx,
                                ts_transform_float_t        const sx,
                                ts_transform_float_t        const shx,
                                ts_transform_float_t        const tx,
                                ts_transform_float_t        const shy,
                                ts_transform_float_t        const sy,
                                ts_transform_float_t        const ty,
                                ts_transform_float_t        const w0,
                                ts_transform_float_t        const w1,
                                ts_transform_float_t        const w2)
{
  if (w2 == TS_TRANSFORM_ONE)
    {
      ts_transform_stack_store_matrix_8(ts,idx,
                                        sx, shx,tx,
                                        shy,sy, ty,
                                        w0, w1);
    }
  else
    {
      // normalize
      ts_transform_float_t d = TS_TRANSFORM_RCP(w2);

      ts_transform_stack_store_matrix_8(ts,idx,
                                        sx  * d, shx * d, tx * d,
                                        shy * d, sy  * d, ty * d,
                                        w0  * d, w1  * d);
    }
}

//
//
//

static
void
ts_transform_stack_push_matrix_8(struct ts_transform_stack * const ts,
                                 ts_transform_float_t        const sx,
                                 ts_transform_float_t        const shx,
                                 ts_transform_float_t        const tx,
                                 ts_transform_float_t        const shy,
                                 ts_transform_float_t        const sy,
                                 ts_transform_float_t        const ty,
                                 ts_transform_float_t        const w0,
                                 ts_transform_float_t        const w1)
{
  ts_transform_stack_ensure(ts);

  ts_transform_stack_store_matrix_8(ts,ts->count++,
                                    sx, shx,tx,
                                    shy,sy, ty,
                                    w0, w1);
}

//
//
//

void
ts_transform_stack_push_matrix(struct ts_transform_stack * const ts,
                               ts_transform_float_t        const sx,
                               ts_transform_float_t        const shx,
                               ts_transform_float_t        const tx,
                               ts_transform_float_t        const shy,
                               ts_transform_float_t        const sy,
                               ts_transform_float_t        const ty,
                               ts_transform_float_t        const w0,
                               ts_transform_float_t        const w1,
                               ts_transform_float_t        const w2)
{
  if (w2 == TS_TRANSFORM_ONE)
    {
      ts_transform_stack_push_matrix_8(ts,
                                       sx, shx,tx,
                                       shy,sy, ty,
                                       w0, w1);
    }
  else
    {
      // normalize
      ts_transform_float_t d = TS_TRANSFORM_RCP(w2);

      ts_transform_stack_push_matrix_8(ts,
                                       sx  * d, shx * d, tx * d,
                                       shy * d, sy  * d, ty * d,
                                       w0  * d, w1  * d);
    }
}

//
//
//

void
ts_transform_stack_push_identity(struct ts_transform_stack * const ts)
{
  ts_transform_stack_push_matrix_8(ts,
                                   1.0, 0.0, 0.0,
                                   0.0, 1.0, 0.0,
                                   0.0, 0.0);
}

void
ts_transform_stack_push_affine(struct ts_transform_stack * const ts,
                               ts_transform_float_t        const sx,
                               ts_transform_float_t        const shx,
                               ts_transform_float_t        const tx,
                               ts_transform_float_t        const shy,
                               ts_transform_float_t        const sy,
                               ts_transform_float_t        const ty)
{
  ts_transform_stack_push_matrix_8(ts,
                                   sx,  shx, tx,
                                   shy, sy,  ty,
                                   0.0, 0.0);
}

void
ts_transform_stack_push_translate(struct ts_transform_stack * const ts,
                                  ts_transform_float_t        const tx,
                                  ts_transform_float_t        const ty)
{
  ts_transform_stack_push_matrix_8(ts,
                                   1.0, 0.0, tx,
                                   0.0, 1.0, ty,
                                   0.0, 0.0);
}

void
ts_transform_stack_push_scale(struct ts_transform_stack * const ts,
                              ts_transform_float_t        const sx,
                              ts_transform_float_t        const sy)
{
  ts_transform_stack_push_matrix_8(ts,
                                   sx,  0.0, 0.0,
                                   0.0, sy,  0.0,
                                   0.0, 0.0);
}

void
ts_transform_stack_push_shear(struct ts_transform_stack * const ts,
                              ts_transform_float_t        const shx,
                              ts_transform_float_t        const shy)
{
  ts_transform_stack_push_matrix_8(ts,
                                   1.0, shx, 0.0,
                                   shy, 1.0, 0.0,
                                   0.0, 0.0);
}

void
ts_transform_stack_push_skew_x(struct ts_transform_stack * const ts,
                               ts_transform_float_t        const theta)
{
  ts_transform_float_t        const tan_theta = TS_TRANSFORM_TAN(theta); // replace with tanpi if available

  ts_transform_stack_push_matrix_8(ts,
                                   1.0, tan_theta,0.0,
                                   0.0, 1.0,      0.0,
                                   0.0, 0.0);
}

void
ts_transform_stack_push_skew_y(struct ts_transform_stack * const ts,
                               ts_transform_float_t        const theta)
{
  ts_transform_float_t const tan_theta = TS_TRANSFORM_TAN(theta); // replace with tanpi if available

  ts_transform_stack_push_matrix_8(ts,
                                   1.0,       0.0, 0.0,
                                   tan_theta, 1.0, 0.0,
                                   0.0,       0.0);
}

void
ts_transform_stack_push_rotate(struct ts_transform_stack * const ts,
                               ts_transform_float_t        const theta)
{
  ts_transform_float_t const cos_theta = TS_TRANSFORM_COS(theta); // replace with cospi if available
  ts_transform_float_t const sin_theta = TS_TRANSFORM_SIN(theta); // replace with sinpi if available

  ts_transform_stack_push_matrix_8(ts,
                                   cos_theta,-sin_theta, 0.0,
                                   sin_theta, cos_theta, 0.0,
                                   0.0,       0.0);
}

void
ts_transform_stack_push_rotate_xy2(struct ts_transform_stack * const ts,
                                   ts_transform_float_t        const theta,
                                   ts_transform_float_t        const cx,
                                   ts_transform_float_t        const cy,
                                   ts_transform_float_t        const tx,
                                   ts_transform_float_t        const ty)
{
  ts_transform_float_t const cos_theta = TS_TRANSFORM_COS(theta); // replace with cospi if available
  ts_transform_float_t const sin_theta = TS_TRANSFORM_SIN(theta); // replace with sinpi if available

  ts_transform_stack_push_matrix_8(ts,
                                   cos_theta,-sin_theta, tx - (cx * cos_theta) + (cy * sin_theta),
                                   sin_theta, cos_theta, ty - (cx * sin_theta) - (cy * cos_theta),
                                   0.0,       0.0);
}

void
ts_transform_stack_push_rotate_xy(struct ts_transform_stack * const ts,
                                  ts_transform_float_t        const theta,
                                  ts_transform_float_t        const cx,
                                  ts_transform_float_t        const cy)
{
  ts_transform_stack_push_rotate_xy2(ts,theta,cx,cy,cx,cy);
}

void
ts_transform_stack_push_rotate_scale_xy(struct ts_transform_stack * const ts,
                                        ts_transform_float_t        const theta,
                                        ts_transform_float_t        const sx,
                                        ts_transform_float_t        const sy,
                                        ts_transform_float_t        const cx,
                                        ts_transform_float_t        const cy)
{
  ts_transform_float_t const cos_theta = TS_TRANSFORM_COS(theta); // replace with cospi if available
  ts_transform_float_t const sin_theta = TS_TRANSFORM_SIN(theta); // replace with sinpi if available

  ts_transform_stack_push_matrix_8(ts,
                                   sx*cos_theta,-sx*sin_theta, cx - cx*sx*cos_theta + cy*sy*sin_theta,
                                   sy*sin_theta, sy*cos_theta, cy - cy*sy*cos_theta - cx*sx*sin_theta,
                                   0.0,          0.0);
}

//
// See: "Fundamentals of Texture Mapping and Image Warping" by Paul S. Heckbert (1989)
//

#define DET(a,b,c,d)  (a * d - b * c)

#define X(v,i)        v[i*2]
#define Y(v,i)        v[i*2+1]

//
//
//

ts_transform_type_e
ts_transform_stack_adjoint(struct ts_transform_stack * const ts)
{
  union ts_transform_stack_3x3_u * const t = ts_transform_stack_tos(ts);

#if 0
  // save for determinant
  ts_transform_float_t const a = t->a;
  ts_transform_float_t const b = t->b;
  ts_transform_float_t const c = t->c;
#endif

  ts_transform_stack_store_matrix(ts,ts->count-1,

                                  +DET(t->e, t->f, t->h,             TS_TRANSFORM_ONE),
                                  -DET(t->b, t->c, t->h,             TS_TRANSFORM_ONE),
                                  +DET(t->b, t->c, t->e,             t->f),

                                  -DET(t->d, t->f, t->g,             TS_TRANSFORM_ONE),
                                  +DET(t->a, t->c, t->g,             TS_TRANSFORM_ONE),
                                  -DET(t->a, t->c, t->d,             t->f),

                                  +DET(t->d, t->e, t->g,             t->h),
                                  -DET(t->a, t->b, t->g,             t->h),
                                  +DET(t->a, t->b, t->d,             t->e));

#if 0
  // determinant of t
  ts_transform_float_t const det = a * t->a + b * t->d + c * t->g;
#endif

  return ts_transform_stack_classify(ts);
}

//
//
//

ts_transform_type_e
ts_transform_stack_push_unit_to_quad(struct ts_transform_stack * const ts,
                                     ts_transform_float_t        const quad[8])
{
  ts_transform_float_t const x0  = X(quad,0);
  ts_transform_float_t const y0  = Y(quad,0);

  ts_transform_float_t const x1  = X(quad,1);
  ts_transform_float_t const y1  = Y(quad,1);

  ts_transform_float_t const x2  = X(quad,2);
  ts_transform_float_t const y2  = Y(quad,2);

  ts_transform_float_t const x3  = X(quad,3);
  ts_transform_float_t const y3  = Y(quad,3);

  ts_transform_float_t       sx  = x1 - x0;
  ts_transform_float_t       shy = y1 - y0;

  ts_transform_float_t const dx2 = x3 - x2;
  ts_transform_float_t const dy2 = y3 - y2;

  ts_transform_float_t const dx3 = -sx  - dx2;
  ts_transform_float_t const dy3 = -shy - dy2;

  // if both zero then quad_dst is a parallelogram and affine
  if ((dx3 == TS_TRANSFORM_ZERO) && (dy3 == TS_TRANSFORM_ZERO))
    {
      ts_transform_float_t const shx = x2 - x1;
      ts_transform_float_t const sy  = y2 - y1;

      ts_transform_stack_push_matrix_8(ts,
                                       sx,  shx, x0,
                                       shy, sy,  y0,
                                       0.0, 0.0);

      return TS_TRANSFORM_TYPE_AFFINE;
    }
  else
    {
      ts_transform_float_t const dx1    = x1 - x2;
      ts_transform_float_t const dy1    = y1 - y2;

      ts_transform_float_t const wx_den = dx1 * dy2 - dx2 * dy1;

      if (wx_den == TS_TRANSFORM_ZERO)
        return TS_TRANSFORM_TYPE_INVALID;

      ts_transform_float_t const w0_num = dx3 * dy2 - dx2 * dy3;
      ts_transform_float_t const w1_num = dx1 * dy3 - dx3 * dy1;

      ts_transform_float_t const w0     = w0_num / wx_den;
      ts_transform_float_t const w1     = w1_num / wx_den;

      sx                 += w0 * x1;
      ts_transform_float_t const shx    = x3 - x0 + w1 * x3;

      shy                += w0 * y1;
      ts_transform_float_t const sy     = y3 - y0 + w1 * y3;

      ts_transform_stack_push_matrix_8(ts,
                                       sx,  shx, x0,
                                       shy, sy,  y0,
                                       w0,  w1);

      return TS_TRANSFORM_TYPE_PROJECTIVE;
    }
}

//
//
//

ts_transform_type_e
ts_transform_stack_push_quad_to_unit(struct ts_transform_stack * const ts,
                                     float                        const quad[8])
{
  if (ts_transform_stack_push_unit_to_quad(ts,quad) == TS_TRANSFORM_TYPE_INVALID)
    return TS_TRANSFORM_TYPE_INVALID;

  return ts_transform_stack_adjoint(ts);
}

//
//
//

ts_transform_type_e
ts_transform_stack_push_quad_to_quad(struct ts_transform_stack * const ts,
                                     ts_transform_float_t        const quad_src[8],
                                     ts_transform_float_t        const quad_dst[8])
{
  if (ts_transform_stack_push_unit_to_quad(ts,quad_dst) == TS_TRANSFORM_TYPE_INVALID)
    return TS_TRANSFORM_TYPE_INVALID;

  if (ts_transform_stack_push_quad_to_unit(ts,quad_src) == TS_TRANSFORM_TYPE_INVALID)
    return TS_TRANSFORM_TYPE_INVALID;

  ts_transform_stack_multiply(ts);

  return ts_transform_stack_classify(ts);
}

//
//
//

ts_transform_type_e
ts_transform_stack_push_rect_to_quad(struct ts_transform_stack * const ts,
                                     ts_transform_float_t        const x0,
                                     ts_transform_float_t        const y0,
                                     ts_transform_float_t        const x1,
                                     ts_transform_float_t        const y1,
                                     ts_transform_float_t        const quad_dst[8])
{
  if (ts_transform_stack_push_unit_to_quad(ts,quad_dst) == TS_TRANSFORM_TYPE_INVALID)
    return TS_TRANSFORM_TYPE_INVALID;

  ts_transform_stack_push_matrix_8(ts,
                                   TS_TRANSFORM_RCP(x1-x0),
                                   0.0,
                                   -x0,
                                   0.0,
                                   TS_TRANSFORM_RCP(y1-y0),
                                   -y0,
                                   0.0,
                                   0.0);

  ts_transform_stack_multiply(ts);

  return ts_transform_stack_classify(ts);
}

//
// The second matrix on the stack (TOS[-1]) is post-multiplied by the
// top matrix on the stack (TOS[0]).
//
// The result replaces TOS[0] and TOS[-1] is unmodified.
//
// The stack effect of concat is:
//
//   | B |    | A*B |
//   | A |    |  A  |
//   | . | => |  .  |
//   | . |    |  .  |
//   | . |    |  .  |
//
void
ts_transform_stack_concat(struct ts_transform_stack * const ts)
{
  assert(ts->count >= 2);

  // get A and B
  union ts_transform_stack_3x3_u const * const B = ts_transform_stack_tos(ts);
  union ts_transform_stack_3x3_u const * const A = B - 1;

  ts_transform_stack_store_matrix(ts,ts->count-1,TS_TRANSFORM_MULTIPLY(A,B));
}

//
// The second matrix on the stack (TOS[-1]) is post-multiplied by the
// top matrix on the stack (TOS[0]).
//
// The result replaces both matrices.
//
// The stack effect of multiply is:
//
//   | B |    | A*B |
//   | A |    |  .  |
//   | . | => |  .  |
//   | . |    |  .  |
//   | . |    |  .  |
//
void
ts_transform_stack_multiply(struct ts_transform_stack * const ts)
{
  assert(ts->count >= 2);

  // get A and B
  union ts_transform_stack_3x3_u const * const B = ts_transform_stack_tos(ts);
  union ts_transform_stack_3x3_u const * const A = B - 1;

  ts_transform_stack_store_matrix(ts,ts->count-- - 2,TS_TRANSFORM_MULTIPLY(A,B));
}

//
//
//

void
ts_transform_stack_transform_xy(struct ts_transform_stack * const ts,
                                ts_transform_float_t        const x,
                                ts_transform_float_t        const y,
                                ts_transform_float_t      * const xp,
                                ts_transform_float_t      * const yp)
{
  union ts_transform_stack_3x3_u const * const t = ts_transform_stack_tos(ts);

  *xp = x * t->sx  + y * t->shx + t->tx;
  *yp = x * t->shy + y * t->sy  + t->ty;

  if (!TS_IS_AFFINE(t))
    {
      ts_transform_float_t const d = TS_TRANSFORM_RCP(x * t->w0 + y * t->w1 + TS_TRANSFORM_ONE);

      *xp *= d;
      *yp *= d;
    }
}

//
// test it!
//

#ifdef TS_DEBUG

#include <stdio.h>

#define TS_DEBUG_SCALE 32.0

//
//
//

void
ts_transform_stack_tos_debug(struct ts_transform_stack * const ts)
{
  union ts_transform_stack_3x3_u const * const t = ts_transform_stack_tos(ts);

  printf("{ { %13.5f, %13.5f, %13.5f },\n"
         "  { %13.5f, %13.5f, %13.5f },\n"
         "  { %13.5f, %13.5f, %13.5f } }\n",
         t->a8[0],
         t->a8[1],
         t->a8[2],
         t->a8[3],
         t->a8[4],
         t->a8[5],
         t->a8[6],
         t->a8[7],
         TS_TRANSFORM_ONE);
}

//
//
//

void
ts_debug(struct ts_transform_stack * const ts,
         ts_transform_float_t        const quad[8])
{
  ts_transform_stack_tos_debug(ts);

  for (int ii=0; ii<8; ii+=2)
    {
      ts_transform_float_t xp,yp;

      ts_transform_stack_transform_xy(ts,
                                      quad[ii],quad[ii+1],
                                      &xp,&yp);

      printf("( %13.2f, %13.2f ) \t-> ( %13.2f, %13.2f )\n",
             xp,yp,xp/TS_DEBUG_SCALE,yp/TS_DEBUG_SCALE);
    }
}

//
//
//

int
main(int argc, char * argv[])
{
  struct ts_transform_stack * const ts = ts_transform_stack_create(32);

  ts_transform_float_t const w = 1000;
  ts_transform_float_t const h = 1000;

#if 1
  ts_transform_stack_push_scale(ts,TS_DEBUG_SCALE,TS_DEBUG_SCALE);

  // OpenGL'ism
  ts_transform_stack_push_affine(ts,
                                 1.0f, 0.0f,0.0f,
                                 0.0f,-1.0f,h);
  // multiply
  ts_transform_stack_concat(ts);
#else
  ts_transform_stack_push_identity(ts);
#endif

  uint32_t const restore = ts_transform_stack_save(ts);

  //
  //
  //
  ts_transform_float_t const quad_src[8] = { 0.0f,0.0f,
                                             w,   0.0f,
                                             w,   h,
                                             0.0f,h };

  ts_transform_float_t const quad_dst[8] = { 300.0f,   0.0f,
                                             w-300.0f, 0.0f,
                                             w,        h,
                                             0.0f,     h };

  ts_transform_float_t const quad_tst[8] = { 50,   50,
                                             1550, 50,
                                             1550, 1550,
                                             50,   1550 };
  //
  // RECT TO QUAD
  //
  printf("type = %d\n",
         ts_transform_stack_push_rect_to_quad(ts,
                                              0.0, 0.0,
                                              w,   h,
                                              quad_dst));
  ts_transform_stack_concat(ts);

  ts_debug(ts,quad_src);

  //
  // QUAD TO QUAD
  //
  ts_transform_stack_restore(ts,restore);

  printf("type = %d\n",
         ts_transform_stack_push_quad_to_quad(ts,
                                              quad_src,
                                              quad_dst));
  ts_transform_stack_concat(ts);

  ts_debug(ts,quad_src);

  //
  // DIRECT
  //
  ts_transform_stack_restore(ts,restore);

  ts_transform_stack_push_matrix(ts,
                                 0.87004626f, -0.35519487f,   72.14745f,
                                 0.0f,         0.2600208f,    86.16314f,
                                 0.0f,        -0.0029599573f, 1.0f);

  ts_transform_stack_concat(ts);

  ts_transform_float_t const quad_foo[8] = { -10,  10,
                                             130,  10,
                                             130,  110,
                                             -10,  110 };

  ts_debug(ts,quad_foo);

  return EXIT_SUCCESS;
}

#endif

//
//
//