#include "config.h"

#include "broadway-buffer.h"

#include <string.h>

/* This code is based on some code from weston with this license:
 *
 * Copyright © 2012 Intel Corporation
 *
 * Permission to use, copy, modify, distribute, and sell this software and
 * its documentation for any purpose is hereby granted without fee, provided
 * that the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of the copyright holders not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.  The copyright holders make
 * no representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

struct entry {
  int count;
  int matches;
  guint32 hash;
  int x, y;
  int index;
};

struct _BroadwayBuffer {
  guint8 *data;
  struct entry *table;
  int width, height, stride;
  int encoded;
  int block_stride, length, block_count, shift;
  int stats[5];
  int clashes;
};

static const guint32 prime = 0x1f821e2d;
static const guint32 end_prime = 0xf907ec81;	/* prime^block_size */
#if 0
static const guint32 vprime = 0x0137b89d;
static const guint32 end_vprime = 0xaea9a281;	/* vprime^block_size */
#else
static const guint32 vprime = 0xf907ec81;
static const guint32 end_vprime = 0xcdb99001;	/* vprime^block_size */
#endif
static const guint32 step = 0x0ac93019;
static const int block_size = 32, block_mask = 31;

static gboolean
verify_block_match (BroadwayBuffer *buffer, int x, int y,
                    BroadwayBuffer *prev, struct entry *entry)
{
  int i;
  void *old, *match;
  int w1, w2, h1, h2;

  w1 = block_size;
  if (x + block_size > buffer->width)
    w1 = buffer->width - x;

  h1 = block_size;
  if (y + block_size > buffer->height)
    h1 = buffer->height - y;

  w2 = block_size;
  if (entry->x + block_size > prev->width)
    w2 = prev->width - entry->x;

  h2 = block_size;
  if (entry->y + block_size > prev->height)
    h2 = prev->height - entry->y;

  if (w1 != w2 || h1 != h2)
    return FALSE;

  for (i = 0; i < h1; i++)
    {
      match = buffer->data + (y + i) * buffer->stride + x * 4;
      old = prev->data + (entry->y + i) * prev->stride + entry->x * 4;
      if (memcmp (match, old, w1 * 4) != 0)
        {
          buffer->clashes++;
          return FALSE;
        }
    }

  return TRUE;
}

static void
insert_block (BroadwayBuffer *buffer, guint32 h, int x, int y)
{
  struct entry *entry;
  int i;
  guint32 collision = 0;

  entry = &buffer->table[h >> buffer->shift];
  for (i = step; entry->count > 0 && entry->hash != h; i += step)
    {
      entry = &buffer->table[(h + i) >> buffer->shift];
      collision++;
    }

  entry->hash = h;
  entry->count++;
  entry->x = x;
  entry->y = y;
  entry->index = (buffer->block_stride * y + x) / block_size;

  if (collision > G_N_ELEMENTS (buffer->stats) - 1)
    collision = G_N_ELEMENTS (buffer->stats) - 1;
  buffer->stats[collision]++;
}

static struct entry *
lookup_block (BroadwayBuffer *prev, guint32 h)
{
  guint32 i;
  struct entry *entry;
  int shift = prev->shift;

  for (i = h;
       entry = &prev->table[i >> shift], entry->count > 0;
       i += step)
    {
      if (entry->hash == h)
        return entry;
    }

  return NULL;
}

struct encoder {
  guint32 color;
  guint32 color_run;
  guint32 delta;
  guint32 delta_run;
  GString *dest;
  int bytes;
};

/* Encoding:
 *
 *  - all 1 pixel colors are encoded literally
 *
 *  - We don’t need to support colors with alpha 0 and non-zero
 *    color components, as they mean the same on the canvas anyway.
 *    So we use these as special codes:
 *
 *     - 0x00 00 00 00 : one alpha 0 pixel
 *     - 0xaa rr gg bb : one color pixel, alpha > 0
 *     - 0x00 1x xx xx : delta 0 run, x is length, (20 bits)
 *     - 0x00 2x xx xx 0x xxxx yyyy: block ref, block number x (20 bits) at x, y
 *     - 0x00 3x xx xx 0xaarrggbb : solid color run, length x
 *     - 0x00 4x xx xx 0xaarrggbb : delta run, length x
 *
 */

static void
emit (struct encoder *encoder, guint32 symbol)
{
  g_string_append_len (encoder->dest, (char *)&symbol, sizeof (guint32));
  encoder->bytes += sizeof (guint32);
}

static void
encode_run (struct encoder *encoder)
{
  if (encoder->color_run == 0 && encoder->delta_run == 0)
    return;

  if (encoder->color_run >= encoder->delta_run)
    {
      if (encoder->color_run == 1)
        emit (encoder, encoder->color);
      else
        {
          emit (encoder, 0x00300000 | encoder->color_run);
          emit (encoder, encoder->color);
        }
    }
  else
    {
      if (encoder->delta == 0)
        emit(encoder, 0x00100000 | encoder->delta_run);
      else
        {
          emit(encoder, 0x00400000 | encoder->delta_run);
          emit(encoder, encoder->delta);
        }
    }
}

static void
encode_pixel (struct encoder *encoder, guint32 color, guint32 prev_color)
{
  guint32 delta = 0;
  guint32 a, r, g, b;

  if (color == prev_color)
    delta = 0;
  else if (prev_color == 0)
    delta = color;
  else
    {
      a = ((color & 0xff000000) - (prev_color & 0xff000000)) & 0xff000000;
      r = ((color & 0x00ff0000) - (prev_color & 0x00ff0000)) & 0x00ff0000;
      g = ((color & 0x0000ff00) - (prev_color & 0x0000ff00)) & 0x0000ff00;
      b = ((color & 0x000000ff) - (prev_color & 0x000000ff)) & 0x000000ff;

      delta = a | r | g | b;
    }

  if ((encoder->color != color &&
       encoder->color_run > encoder->delta_run) ||

      (encoder->delta != delta &&
       encoder->delta_run > encoder->color_run) ||

      (encoder->delta != delta && encoder->color != color) ||

      (encoder->delta_run == 0xFFFFF || encoder->color_run == 0xFFFFF))
    {
      encode_run (encoder);

      encoder->color_run = 1;
      encoder->color = color;
      encoder->delta_run = 1;
      encoder->delta = delta;
      return;
    }

  if (encoder->color == color)
    encoder->color_run++;
  else
    {
      encoder->color_run = 1;
      encoder->color = color;
    }

  if (encoder->delta == delta)
    encoder->delta_run++;
  else
    {
      encoder->delta_run = 1;
      encoder->delta = delta;
    }
}

void
encoder_flush (struct encoder *encoder)
{
  encode_run (encoder);
}


static void
encode_block (struct encoder *encoder, struct entry *entry, int x, int y)
{
  /* 0x00 2x xx xx 0x xxxx yyyy:
   *	block ref, block number x (20 bits) at x, y */

  /* FIXME: Maybe don't encode pixels under blocks and just emit
   * blocks at their position within the stream. */

  emit (encoder, 0x00200000 | entry->index);
  emit (encoder, (x << 16) | y);
}

void
broadway_buffer_destroy (BroadwayBuffer *buffer)
{
  g_free (buffer->data);
  g_free (buffer->table);
  g_free (buffer);
}

int
broadway_buffer_get_width (BroadwayBuffer *buffer)
{
  return buffer->width;
}

int
broadway_buffer_get_height (BroadwayBuffer *buffer)
{
  return buffer->height;
}

static void
unpremultiply_line (void *destp, void *srcp, int width)
{
  guint32 *src = srcp;
  guint32 *dest = destp;
  guint32 *end = src + width;
  while (src < end)
    {
      guint32 pixel;
      guint8 alpha, r, g, b;

      pixel = *src++;

      alpha = (pixel & 0xff000000) >> 24;

      if (alpha == 0xff)
        *dest++ = pixel;
      else if (alpha == 0)
        *dest++ = 0;
      else
        {
          r = (((pixel & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
          g = (((pixel & 0x00ff00) >>  8) * 255 + alpha / 2) / alpha;
          b = (((pixel & 0x0000ff) >>  0) * 255 + alpha / 2) / alpha;
          *dest++ = (guint32)alpha << 24 | (guint32)r << 16 | (guint32)g << 8 | (guint32)b;
        }
    }
}

BroadwayBuffer *
broadway_buffer_create (int width, int height, guint8 *data, int stride)
{
  BroadwayBuffer *buffer;
  int y, bits_required;

  buffer = g_new0 (BroadwayBuffer, 1);
  buffer->width = width;
  buffer->stride = width * 4;
  buffer->height = height;

  buffer->block_stride = (width + block_size - 1) / block_size;
  buffer->block_count =
    buffer->block_stride * ((height + block_size - 1) / block_size);
  bits_required = g_bit_storage (buffer->block_count * 4);
  buffer->shift = 32 - bits_required;
  buffer->length = 1 << bits_required;

  buffer->table = g_malloc0 (buffer->length * sizeof buffer->table[0]);

  memset (buffer->stats, 0, sizeof buffer->stats);
  buffer->clashes = 0;

  buffer->data = g_malloc (buffer->stride * height);

  for (y = 0; y < height; y++)
    unpremultiply_line (buffer->data + y * buffer->stride, data + y * stride, width);

  return buffer;
}

void
broadway_buffer_encode (BroadwayBuffer *buffer, BroadwayBuffer *prev, GString *dest)
{
  struct entry *entry;
  int i, j, k;
  int x0, x1, y0, y1;
  guint32 *block_hashes;
  guint32 hash, bottom_hash, h, *line, *bottom, *prev_line;
  int width, height;
  struct encoder encoder = { 0 };
  int *skyline, skyline_pixels;
  int matches;

  width = buffer->width;
  height = buffer->height;
  x0 = 0;
  x1 = width;
  y0 = 0;
  y1 = height;

  skyline = g_malloc0 ((width + block_size) * sizeof skyline[0]);

  block_hashes = g_malloc0 (width * sizeof block_hashes[0]);

  matches = 0;
  encoder.dest = dest;

  // Calculate the block hashes for the first row
  for (i = y0; i < MIN(y1, y0 + block_size); i++)
    {
      line = (guint32 *)(buffer->data + i * buffer->stride);
      hash = 0;
      for (j = x0; j < MIN(x1, x0 + block_size); j++)
        hash = hash * prime + line[j];
      for (j = j; j < x0 + block_size; j++)
        hash = hash * prime;

      for (j = x0; j < x1; j++)
        {
          block_hashes[j] = block_hashes[j] * vprime + hash;

          hash = hash * prime - line[j] * end_prime;
          if (j + block_size < width)
            hash += line[j + block_size];
        }
    }
  // Do the last rows if height < block_size
  for (i = i; i < y0 + block_size; i++)
    {
      for (j = x0; j < x1; j++)
        block_hashes[j] = block_hashes[j] * vprime;
    }

  for (i = y0; i < y1; i++)
    {
      line = (guint32 *) (buffer->data + i * buffer->stride);
      bottom = (guint32 *) (buffer->data + (i + block_size) * buffer->stride);
      bottom_hash = 0;
      hash = 0;
      skyline_pixels = 0;

      if (prev && i < prev->height)
        prev_line = (guint32 *) (prev->data + i * prev->stride);
      else
        prev_line = NULL;

      for (j = x0; j < x0 + block_size; j++)
        {
          hash = hash * prime;
          if (j < width)
            hash += line[j];
          if (i + block_size < height)
            {
              bottom_hash = bottom_hash * prime;
              if (j < width)
                bottom_hash += bottom[j];
            }
          if (i < skyline[j])
            skyline_pixels = 0;
          else
            skyline_pixels++;
        }

      for (j = x0; j < x1; j++)
        {
          if (i < skyline[j])
            encode_pixel (&encoder, line[j], line[j]);
          else if (prev)
            {
              /* FIXME: Add back overlap exception
               * for consecutive blocks */

              h = block_hashes[j];
              entry = lookup_block (prev, h);
              if (entry && entry->count < 2 &&
                  skyline_pixels >= block_size &&
                  verify_block_match (buffer, j, i, prev, entry) &&
                  (entry->x != j || entry->y != i))
                {
                  matches++;
                  encode_block (&encoder, entry, j, i);

                  for (k = 0; k < block_size; k++)
                    skyline[j + k] = i + block_size;

                  encode_pixel (&encoder, line[j], line[j]);
                }
              else
                {
                  if (prev_line && j < prev->width)
                    encode_pixel (&encoder, line[j],
                                  prev_line[j]);
                  else
                    encode_pixel (&encoder, line[j], 0);
                }
            }
          else
            encode_pixel (&encoder, line[j], 0);

          if (i < skyline[j + block_size])
            skyline_pixels = 0;
          else
            skyline_pixels++;

          /* Insert block in hash table if we're on a
           * grid point. */
          if (((i | j) & block_mask) == 0 && !buffer->encoded)
            insert_block (buffer, block_hashes[j], j, i);

          /* Update sliding block hash */
          block_hashes[j] =
            block_hashes[j] * vprime + bottom_hash -
            hash * end_vprime;

          if (i + block_size < height)
            {
              bottom_hash = bottom_hash * prime - bottom[j] * end_prime;
              if (j + block_size < width)
                bottom_hash += bottom[j + block_size];
            }
          hash = hash * prime - line[j] * end_prime;
          if  (j + block_size < width)
            hash += line[j + block_size] ;
        }
    }

  encoder_flush (&encoder);

#if 0
  fprintf(stderr, "collision stats:");
  for (i = 0; i < (int) G_N_ELEMENTS(buffer->stats); i++)
    fprintf(stderr, "%c%d", i == 0 ? ' ' : '/', buffer->stats[i]);
  fprintf(stderr, "\n");

  fprintf(stderr, "%d / %d blocks (%d%%) matched, %d clashes\n",
          matches, buffer->block_count,
          100 * matches / buffer->block_count, buffer->clashes);

  fprintf(stderr, "output stream %d bytes, raw buffer %d bytes (%d%%)\n",
          encoder.bytes, height * buffer->stride,
          100 * encoder.bytes / (height * buffer->stride));
#endif

  g_free (skyline);
  g_free (block_hashes);

  buffer->encoded = TRUE;
}