/*
 * Interplay MVE Video Decoder (16 bit)
 * Copyright (C) 2003 the ffmpeg project, Mike Melanson
 *           (C) 2006 Jens Granseuer
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * For more information about the Interplay MVE format, visit:
 *   http://www.pcisys.net/~melanson/codecs/interplay-mve.txt
 */

#include "gstmvedemux.h"
#include <string.h>

#define PIXEL(s) GST_READ_UINT16_LE (s)

#define CHECK_STREAM(l, n) \
  do { \
    if (G_UNLIKELY (*(l) < (n))) { \
      GST_ERROR ("wanted to read %d bytes from stream, %d available", (n), *(l)); \
      return -1; \
    } \
    *(l) -= (n); \
  } while (0)

/* copy an 8x8 block from the stream to the frame buffer */
static int
ipvideo_copy_block (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned short *src, int offset)
{
  int i;
  int frame_offset;

  frame_offset = frame - (unsigned short *) s->back_buf1 + offset;

  if (G_UNLIKELY (frame_offset < 0)) {
    GST_ERROR ("frame offset < 0 (%d)", frame_offset);
    return -1;
  } else if (G_UNLIKELY (frame_offset > s->max_block_offset)) {
    GST_ERROR ("frame offset above limit (%d > %u)",
        frame_offset, s->max_block_offset);
    return -1;
  }

  for (i = 0; i < 8; ++i) {
    memcpy (frame, src, 16);
    frame += s->width;
    src += s->width;
  }

  return 0;
}

static int
ipvideo_decode_0x2 (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  unsigned char B;
  int x, y;
  int offset;

  /* copy block from 2 frames ago using a motion vector */
  CHECK_STREAM (len, 1);
  B = *(*data)++;

  if (B < 56) {
    x = 8 + (B % 7);
    y = B / 7;
  } else {
    x = -14 + ((B - 56) % 29);
    y = 8 + ((B - 56) / 29);
  }
  offset = y * s->width + x;

  return ipvideo_copy_block (s, frame, frame + offset, offset);
}

static int
ipvideo_decode_0x3 (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  unsigned char B;
  int x, y;
  int offset;

  /* copy 8x8 block from current frame from an up/left block */
  CHECK_STREAM (len, 1);
  B = *(*data)++;

  if (B < 56) {
    x = -(8 + (B % 7));
    y = -(B / 7);
  } else {
    x = -(-14 + ((B - 56) % 29));
    y = -(8 + ((B - 56) / 29));
  }
  offset = y * s->width + x;

  return ipvideo_copy_block (s, frame, frame + offset, offset);
}

static int
ipvideo_decode_0x4 (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  int x, y;
  unsigned char B;
  int offset;

  /* copy a block from the previous frame */
  CHECK_STREAM (len, 1);
  B = *(*data)++;
  x = -8 + (B & 0x0F);
  y = -8 + (B >> 4);
  offset = y * s->width + x;

  return ipvideo_copy_block (s, frame, frame +
      ((unsigned short *) s->back_buf2 - (unsigned short *) s->back_buf1) +
      offset, offset);
}

static int
ipvideo_decode_0x5 (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  signed char x, y;
  int offset;

  /* copy a block from the previous frame using an expanded range */
  CHECK_STREAM (len, 2);
  x = (signed char) *(*data)++;
  y = (signed char) *(*data)++;
  offset = y * s->width + x;

  return ipvideo_copy_block (s, frame, frame +
      ((unsigned short *) s->back_buf2 - (unsigned short *) s->back_buf1) +
      offset, offset);
}

static int
ipvideo_decode_0x7 (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  int x, y;
  unsigned short P0, P1;
  unsigned int flags;
  int bitmask;

  /* 2-color encoding */
  CHECK_STREAM (len, 4 + 2);
  P0 = PIXEL (*data);
  (*data) += 2;
  P1 = PIXEL (*data);
  (*data) += 2;

  if (!(P0 & 0x8000)) {

    /* need 8 more bytes from the stream */
    CHECK_STREAM (len, 8 - 2);

    for (y = 0; y < 8; ++y) {
      flags = *(*data)++;
      for (x = 0x01; x <= 0x80; x <<= 1) {
        if (flags & x)
          *frame++ = P1;
        else
          *frame++ = P0;
      }
      frame += s->width - 8;
    }

  } else {
    P0 &= ~0x8000;

    /* need 2 more bytes from the stream */

    flags = ((*data)[1] << 8) | (*data)[0];
    (*data) += 2;
    bitmask = 0x0001;
    for (y = 0; y < 8; y += 2) {
      for (x = 0; x < 8; x += 2, bitmask <<= 1) {
        if (flags & bitmask) {
          *(frame + x) = P1;
          *(frame + x + 1) = P1;
          *(frame + s->width + x) = P1;
          *(frame + s->width + x + 1) = P1;
        } else {
          *(frame + x) = P0;
          *(frame + x + 1) = P0;
          *(frame + s->width + x) = P0;
          *(frame + s->width + x + 1) = P0;
        }
      }
      frame += s->width * 2;
    }
  }

  return 0;
}

static int
ipvideo_decode_0x8 (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  int x, y;
  unsigned short P[8];
  unsigned char B[8];
  unsigned int flags = 0;
  unsigned int bitmask = 0;
  unsigned short P0 = 0, P1 = 0;
  int lower_half = 0;

  /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
   * either top and bottom or left and right halves */
  CHECK_STREAM (len, 6 + 10);

  P[0] = PIXEL (*data);
  (*data) += 2;
  P[1] = PIXEL (*data);
  (*data) += 2;
  B[0] = *(*data)++;
  B[1] = *(*data)++;

  if (!(P[0] & 0x8000)) {

    /* need 18 more bytes */
    CHECK_STREAM (len, 18 - 10);

    P[2] = PIXEL (*data);
    (*data) += 2;
    P[3] = PIXEL (*data);
    (*data) += 2;
    B[2] = *(*data)++;
    B[3] = *(*data)++;
    P[4] = PIXEL (*data);
    (*data) += 2;
    P[5] = PIXEL (*data);
    (*data) += 2;
    B[4] = *(*data)++;
    B[5] = *(*data)++;
    P[6] = PIXEL (*data);
    (*data) += 2;
    P[7] = PIXEL (*data);
    (*data) += 2;
    B[6] = *(*data)++;
    B[7] = *(*data)++;

    flags =
        ((B[0] & 0xF0) << 4) | ((B[4] & 0xF0) << 8) |
        ((B[0] & 0x0F)) | ((B[4] & 0x0F) << 4) |
        ((B[1] & 0xF0) << 20) | ((B[5] & 0xF0) << 24) |
        ((B[1] & 0x0F) << 16) | ((B[5] & 0x0F) << 20);
    bitmask = 0x00000001;
    lower_half = 0;             /* still on top half */

    for (y = 0; y < 8; ++y) {

      /* time to reload flags? */
      if (y == 4) {
        flags =
            ((B[2] & 0xF0) << 4) | ((B[6] & 0xF0) << 8) |
            ((B[2] & 0x0F)) | ((B[6] & 0x0F) << 4) |
            ((B[3] & 0xF0) << 20) | ((B[7] & 0xF0) << 24) |
            ((B[3] & 0x0F) << 16) | ((B[7] & 0x0F) << 20);
        bitmask = 0x00000001;
        lower_half = 2;
      }

      /* get the pixel values ready for this quadrant */
      P0 = P[lower_half + 0];
      P1 = P[lower_half + 1];

      for (x = 0; x < 8; ++x, bitmask <<= 1) {
        if (x == 4) {
          P0 = P[lower_half + 4];
          P1 = P[lower_half + 5];
        }

        if (flags & bitmask)
          *frame++ = P1;
        else
          *frame++ = P0;
      }
      frame += s->width - 8;
    }

  } else {
    P[0] &= ~0x8000;

    /* need 10 more bytes */
    B[2] = *(*data)++;
    B[3] = *(*data)++;
    P[2] = PIXEL (*data);
    (*data) += 2;
    P[3] = PIXEL (*data);
    (*data) += 2;
    B[4] = *(*data)++;
    B[5] = *(*data)++;
    B[6] = *(*data)++;
    B[7] = *(*data)++;

    if (!(P[2] & 0x8000)) {
      /* vertical split; left & right halves are 2-color encoded */

      flags =
          ((B[0] & 0xF0) << 4) | ((B[4] & 0xF0) << 8) |
          ((B[0] & 0x0F)) | ((B[4] & 0x0F) << 4) |
          ((B[1] & 0xF0) << 20) | ((B[5] & 0xF0) << 24) |
          ((B[1] & 0x0F) << 16) | ((B[5] & 0x0F) << 20);
      bitmask = 0x00000001;

      for (y = 0; y < 8; ++y) {

        /* time to reload flags? */
        if (y == 4) {
          flags =
              ((B[2] & 0xF0) << 4) | ((B[6] & 0xF0) << 8) |
              ((B[2] & 0x0F)) | ((B[6] & 0x0F) << 4) |
              ((B[3] & 0xF0) << 20) | ((B[7] & 0xF0) << 24) |
              ((B[3] & 0x0F) << 16) | ((B[7] & 0x0F) << 20);
          bitmask = 0x00000001;
        }

        /* get the pixel values ready for this half */
        P0 = P[0];
        P1 = P[1];

        for (x = 0; x < 8; ++x, bitmask <<= 1) {
          if (x == 4) {
            P0 = P[2];
            P1 = P[3];
          }

          if (flags & bitmask)
            *frame++ = P1;
          else
            *frame++ = P0;
        }
        frame += s->width - 8;
      }

    } else {
      /* horizontal split; top & bottom halves are 2-color encoded */

      P0 = P[0];
      P1 = P[1];

      for (y = 0; y < 8; ++y) {

        flags = B[y];
        if (y == 4) {
          P0 = P[2] & ~0x8000;
          P1 = P[3];
        }

        for (bitmask = 0x01; bitmask <= 0x80; bitmask <<= 1) {

          if (flags & bitmask)
            *frame++ = P1;
          else
            *frame++ = P0;
        }
        frame += s->width - 8;
      }
    }
  }

  return 0;
}

static int
ipvideo_decode_0x9 (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  int x, y;
  unsigned short P[4];
  unsigned char B[4];
  unsigned int flags = 0;
  int shifter = 0;
  unsigned short pix;

  /* 4-color encoding */
  CHECK_STREAM (len, 8 + 4);

  P[0] = PIXEL (*data);
  (*data) += 2;
  P[1] = PIXEL (*data);
  (*data) += 2;
  P[2] = PIXEL (*data);
  (*data) += 2;
  P[3] = PIXEL (*data);
  (*data) += 2;

  if (!(P[0] & 0x8000) && !(P[2] & 0x8000)) {

    /* 1 of 4 colors for each pixel, need 16 more bytes */
    CHECK_STREAM (len, 16 - 4);

    for (y = 0; y < 8; ++y) {
      /* get the next set of 8 2-bit flags */
      flags = ((*data)[1] << 8) | (*data)[0];
      (*data) += 2;
      for (x = 0, shifter = 0; x < 8; ++x, shifter += 2) {
        *frame++ = P[(flags >> shifter) & 0x03];
      }
      frame += s->width - 8;
    }

  } else if (!(P[0] & 0x8000) && (P[2] & 0x8000)) {
    P[2] &= ~0x8000;

    /* 1 of 4 colors for each 2x2 block, need 4 more bytes */

    B[0] = *(*data)++;
    B[1] = *(*data)++;
    B[2] = *(*data)++;
    B[3] = *(*data)++;
    flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0];
    shifter = 0;

    for (y = 0; y < 8; y += 2) {
      for (x = 0; x < 8; x += 2, shifter += 2) {
        pix = P[(flags >> shifter) & 0x03];
        *(frame + x) = pix;
        *(frame + x + 1) = pix;
        *(frame + s->width + x) = pix;
        *(frame + s->width + x + 1) = pix;
      }
      frame += s->width * 2;
    }

  } else if ((P[0] & 0x8000) && !(P[2] & 0x8000)) {
    P[0] &= ~0x8000;

    /* 1 of 4 colors for each 2x1 block, need 8 more bytes */

    CHECK_STREAM (len, 8 - 4);
    for (y = 0; y < 8; ++y) {
      /* time to reload flags? */
      if ((y == 0) || (y == 4)) {
        B[0] = *(*data)++;
        B[1] = *(*data)++;
        B[2] = *(*data)++;
        B[3] = *(*data)++;
        flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0];
        shifter = 0;
      }
      for (x = 0; x < 8; x += 2, shifter += 2) {
        pix = P[(flags >> shifter) & 0x03];
        *(frame + x) = pix;
        *(frame + x + 1) = pix;
      }
      frame += s->width;
    }

  } else {
    P[0] &= ~0x8000;
    P[2] &= ~0x8000;

    /* 1 of 4 colors for each 1x2 block, need 8 more bytes */
    CHECK_STREAM (len, 8 - 4);

    for (y = 0; y < 8; y += 2) {
      /* time to reload flags? */
      if ((y == 0) || (y == 4)) {
        B[0] = *(*data)++;
        B[1] = *(*data)++;
        B[2] = *(*data)++;
        B[3] = *(*data)++;
        flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0];
        shifter = 0;
      }
      for (x = 0; x < 8; ++x, shifter += 2) {
        pix = P[(flags >> shifter) & 0x03];
        *(frame + x) = pix;
        *(frame + s->width + x) = pix;
      }
      frame += s->width * 2;
    }
  }

  return 0;
}

static int
ipvideo_decode_0xa (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  int x, y;
  unsigned short P[16];
  unsigned char B[16];
  int flags = 0;
  int shifter = 0;
  int index;
  int split;
  int lower_half;

  /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
   * either top and bottom or left and right halves */
  CHECK_STREAM (len, 8 + 24);

  P[0] = PIXEL (*data);
  (*data) += 2;
  P[1] = PIXEL (*data);
  (*data) += 2;
  P[2] = PIXEL (*data);
  (*data) += 2;
  P[3] = PIXEL (*data);
  (*data) += 2;

  if (!(P[0] & 0x8000)) {

    /* 4-color encoding for each quadrant; need 40 more bytes */
    CHECK_STREAM (len, 40 - 24);

    B[0] = *(*data)++;
    B[1] = *(*data)++;
    B[2] = *(*data)++;
    B[3] = *(*data)++;
    for (y = 4; y < 16; y += 4) {
      for (x = y; x < y + 4; ++x) {
        P[x] = PIXEL (*data);
        (*data) += 2;
      }
      for (x = y; x < y + 4; ++x)
        B[x] = *(*data)++;
    }

    for (y = 0; y < 8; ++y) {

      lower_half = (y >= 4) ? 4 : 0;
      flags = (B[y + 8] << 8) | B[y];

      for (x = 0, shifter = 0; x < 8; ++x, shifter += 2) {
        split = (x >= 4) ? 8 : 0;
        index = split + lower_half + ((flags >> shifter) & 0x03);
        *frame++ = P[index];
      }

      frame += s->width - 8;
    }

  } else {
    P[0] &= ~0x8000;

    /* 4-color encoding for either left and right or top and bottom
     * halves; need 24 more bytes */

    memcpy (&B[0], *data, 8);
    (*data) += 8;
    P[4] = PIXEL (*data);
    (*data) += 2;
    P[5] = PIXEL (*data);
    (*data) += 2;
    P[6] = PIXEL (*data);
    (*data) += 2;
    P[7] = PIXEL (*data);
    (*data) += 2;
    memcpy (&B[8], *data, 8);
    (*data) += 8;

    if (!(P[4] & 0x8000)) {

      /* block is divided into left and right halves */
      for (y = 0; y < 8; ++y) {

        flags = (B[y + 8] << 8) | B[y];
        split = 0;

        for (x = 0, shifter = 0; x < 8; ++x, shifter += 2) {
          if (x == 4)
            split = 4;
          *frame++ = P[split + ((flags >> shifter) & 0x03)];
        }

        frame += s->width - 8;
      }

    } else {
      P[4] &= ~0x8000;

      /* block is divided into top and bottom halves */
      split = 0;
      for (y = 0; y < 8; ++y) {

        flags = (B[y * 2 + 1] << 8) | B[y * 2];
        if (y == 4)
          split = 4;

        for (x = 0, shifter = 0; x < 8; ++x, shifter += 2)
          *frame++ = P[split + ((flags >> shifter) & 0x03)];

        frame += s->width - 8;
      }
    }
  }

  return 0;
}

static int
ipvideo_decode_0xb (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  int x, y;

  /* 64-color encoding (each pixel in block is a different color) */
  CHECK_STREAM (len, 128);

  for (y = 0; y < 8; ++y) {
    for (x = 0; x < 8; ++x) {
      *frame++ = PIXEL (*data);
      (*data) += 2;
    }
    frame += s->width - 8;
  }

  return 0;
}

static int
ipvideo_decode_0xc (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  int x, y;
  unsigned short pix;

  /* 16-color block encoding: each 2x2 block is a different color */
  CHECK_STREAM (len, 32);

  for (y = 0; y < 8; y += 2) {
    for (x = 0; x < 8; x += 2) {
      pix = PIXEL (*data);
      (*data) += 2;
      *(frame + x) = pix;
      *(frame + x + 1) = pix;
      *(frame + s->width + x) = pix;
      *(frame + s->width + x + 1) = pix;
    }
    frame += s->width * 2;
  }

  return 0;
}

static int
ipvideo_decode_0xd (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  int x, y;
  unsigned short P[4];
  unsigned char index = 0;

  /* 4-color block encoding: each 4x4 block is a different color */
  CHECK_STREAM (len, 8);

  P[0] = PIXEL (*data);
  (*data) += 2;
  P[1] = PIXEL (*data);
  (*data) += 2;
  P[2] = PIXEL (*data);
  (*data) += 2;
  P[3] = PIXEL (*data);
  (*data) += 2;

  for (y = 0; y < 8; ++y) {
    if (y < 4)
      index = 0;
    else
      index = 2;

    for (x = 0; x < 8; ++x) {
      if (x == 4)
        ++index;
      *frame++ = P[index];
    }
    frame += s->width - 8;
  }

  return 0;
}

static int
ipvideo_decode_0xe (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  int x, y;
  unsigned short pix;

  /* 1-color encoding: the whole block is 1 solid color */
  CHECK_STREAM (len, 2);

  pix = PIXEL (*data);
  (*data) += 2;

  for (y = 0; y < 8; ++y) {
    for (x = 0; x < 8; ++x) {
      *frame++ = pix;
    }
    frame += s->width - 8;
  }

  return 0;
}

static int
ipvideo_decode_0xf (const GstMveDemuxStream * s, unsigned short *frame,
    const unsigned char **data, unsigned short *len)
{
  int x, y;
  unsigned short P[2];

  /* dithered encoding */
  CHECK_STREAM (len, 4);

  P[0] = PIXEL (*data);
  (*data) += 2;
  P[1] = PIXEL (*data);
  (*data) += 2;

  for (y = 0; y < 8; ++y) {
    for (x = 0; x < 4; ++x) {
      *frame++ = P[y & 1];
      *frame++ = P[(y & 1) ^ 1];
    }
    frame += s->width - 8;
  }

  return 0;
}

int
ipvideo_decode_frame16 (const GstMveDemuxStream * s, const unsigned char *data,
    unsigned short len)
{
  int rc = 0;
  int x, y, xx, yy;
  int index = 0;
  unsigned short offset;
  unsigned char opcode;
  unsigned short *frame;
  const unsigned char *data2;
  unsigned short len2;

  CHECK_STREAM (&len, 2);

  offset = (data[1] << 8) | data[0];
  data2 = data + offset;
  len2 = len - offset + 2;
  data += 2;

  frame = (unsigned short *) s->back_buf1;

  /* decoding is done in 8x8 blocks */
  xx = s->width >> 3;
  yy = s->height >> 3;

  for (y = 0; y < yy; ++y) {
    for (x = 0; x < xx; ++x) {
      /* decoding map contains 4 bits of information per 8x8 block */
      /* bottom nibble first, then top nibble */
      if (index & 1)
        opcode = s->code_map[index >> 1] >> 4;
      else
        opcode = s->code_map[index >> 1] & 0x0F;
      ++index;

      /* GST_DEBUG ("block @ (%3d, %3d): encoding 0x%X, data ptr @ %p",
         x, y, opcode, data); */

      switch (opcode) {
        case 0x0:
          /* copy a block from the previous frame */
          rc = ipvideo_copy_block (s, frame, frame +
              ((unsigned short *) s->back_buf2 -
                  (unsigned short *) s->back_buf1), 0);
          break;
        case 0x1:
          /* copy block from 2 frames ago; since we switched the back
           * buffers we don't actually have to do anything here */
          break;
        case 0x2:
          rc = ipvideo_decode_0x2 (s, frame, &data2, &len2);
          break;
        case 0x3:
          rc = ipvideo_decode_0x3 (s, frame, &data2, &len2);
          break;
        case 0x4:
          rc = ipvideo_decode_0x4 (s, frame, &data2, &len2);
          break;
        case 0x5:
          rc = ipvideo_decode_0x5 (s, frame, &data, &len);
          break;
        case 0x6:
          /* mystery opcode? skip multiple blocks? */
          GST_WARNING ("encountered unsupported opcode 0x6");
          rc = -1;
          break;
        case 0x7:
          rc = ipvideo_decode_0x7 (s, frame, &data, &len);
          break;
        case 0x8:
          rc = ipvideo_decode_0x8 (s, frame, &data, &len);
          break;
        case 0x9:
          rc = ipvideo_decode_0x9 (s, frame, &data, &len);
          break;
        case 0xa:
          rc = ipvideo_decode_0xa (s, frame, &data, &len);
          break;
        case 0xb:
          rc = ipvideo_decode_0xb (s, frame, &data, &len);
          break;
        case 0xc:
          rc = ipvideo_decode_0xc (s, frame, &data, &len);
          break;
        case 0xd:
          rc = ipvideo_decode_0xd (s, frame, &data, &len);
          break;
        case 0xe:
          rc = ipvideo_decode_0xe (s, frame, &data, &len);
          break;
        case 0xf:
          rc = ipvideo_decode_0xf (s, frame, &data, &len);
          break;
      }

      if (rc != 0)
        return rc;

      frame += 8;
    }
    frame += 7 * s->width;
  }

  return 0;
}
