#include "tiffiop.h"

#include <assert.h></assert.h>

#include "toonztags.h"

#include "tnztypes.h"

#ifndef UCHAR

#define UCHAR unsigned char

#endif

#ifndef USHORT

#define USHORT unsigned short

#endif

#ifndef UINT

#define UINT TUINT32

#endif

extern "C" {

static int tif_toonz1_decode_cm24(UCHAR *buf_in, int *buf_in_len,

                                  TUINT32 *buf_out);

static int tif_toonz1_decode_cm16(UCHAR *buf_in, int *buf_in_len,

                                  USHORT *buf_out, int tone_bits,

                                  int color_offs, int color_bits,

                                  int pencil_offs, int pencil_bits,

                                  USHORT offset_mask);

static int Toonz1Decode(TIFF *tif, tidataval_t *buffer, tsize_t bytes,

                        tsample_t s);

static int TIFFInitToonz1(TIFF *tif, int) {

  tif->tif_decoderow   = Toonz1Decode;

  tif->tif_decodestrip = 0;

  tif->tif_decodetile  = 0;

  tif->tif_encoderow   = 0;  // Toonz1Encode;

  tif->tif_encodestrip = 0;

  tif->tif_encodetile  = 0;

  return 1;

}

//-------------------- DECODE

static int Toonz1Decode(TIFF *tif, tidataval_t *buffer, tsize_t bytes,

                        tsample_t s) {

  int enc, dec;

  short bitspersample;

  // USHORT *palette;

  int tone_bits, color_offs, color_bits, pencil_offs, pencil_bits;

  USHORT offset_mask;

  if (!TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bitspersample)) assert(0);

  enc = dec = 0;

  switch (bitspersample) {

  case 8:

    assert(!"Not Implemented");

    /*

dec = tif_toonz1_decode_extra ((UCHAR *)tif->tif_rawcp, &enc,

                       (UCHAR *)buffer);

*/

    break;

  case 16: {

    USHORT *palette;

    USHORT paletteCount;

    if (TIFFGetField(tif, TIFFTAG_TOONZPALETTE, &paletteCount, &palette)) {

      tone_bits   = palette[4];

      color_offs  = palette[5];

      color_bits  = palette[6];

      pencil_offs = palette[7];

      pencil_bits = palette[8];

      offset_mask = palette[9];

    } else {

      tone_bits   = 4;

      color_offs  = 4;

      color_bits  = 7;

      pencil_offs = 11;

      pencil_bits = 5;

      offset_mask = 0;

    }

    dec = tif_toonz1_decode_cm16(

        (UCHAR *)tif->tif_rawcp, &enc, (USHORT *)buffer, tone_bits, color_offs,

        color_bits, pencil_offs, pencil_bits, offset_mask);

  } break;

  case 32:

    dec = tif_toonz1_decode_cm24((UCHAR *)tif->tif_rawcp, &enc,

                                 (TUINT32 *)buffer);

    break;

  default:

    assert(0);

  }

  assert(enc);

  assert(dec * bitspersample == bytes * 8);

  tif->tif_rawcc += enc;

  tif->tif_rawcp += enc;

  return 1;

}

//-------------------- DECODE CM16 ----------------------------

static int tif_toonz1_decode_cm16(UCHAR *buf_in, int *buf_in_len,

                                  USHORT *buf_out, int tone_bits,

                                  int color_offs, int color_bits,

                                  int pencil_offs, int pencil_bits,

                                  USHORT offset_mask)

{

  UCHAR *in;

  USHORT *out;

  int count, col_offs, pen_offs;

  UINT inval, in0, in1, tmp, not_colmask, not_penmask;

  UINT outval, maxtone, outval_maxtone;

#define GET_IN0 (inval = *in++, in1 = inval & 0xF, in0 = inval >> 4)

  maxtone     = (1U << tone_bits) - 1U;

  col_offs    = color_offs;

  pen_offs    = pencil_offs;

  not_colmask = ~(((1U << color_bits) - 1U) << color_offs);

  not_penmask = ~(((1U << pencil_bits) - 1U) << pencil_offs);

  assert(maxtone <= 0xF);

  outval         = offset_mask;

  outval_maxtone = outval | maxtone;

  in  = buf_in;

  out = buf_out;

  goto start_from_in0;

count_out_and_start_from_in0:

  outval_maxtone         = outval | maxtone;

  *out++                 = (USHORT)outval_maxtone;

  while (count--) *out++ = (USHORT)outval_maxtone;

start_from_in0:

  if (GET_IN0 == 0xF) {

    switch (in1) {

    case 0x0:

      *out++ = (USHORT)(outval | maxtone);

      goto start_from_in0;

      break;

    case 0x1:

      count = GET_IN0;

      goto count_out_and_start_from_in1;

      break;

    case 0x2:

      count = *in++;

      goto count_out_and_start_from_in0;

      break;

    case 0x3:

      count = *in++ << 4;

      count += GET_IN0;

      goto count_out_and_start_from_in1;

      break;

    case 0x4:

      count = *in++ << 8;

      count += *in++;

      goto count_out_and_start_from_in0;

      break;

    case 0x5:

      count = *in++ << 12;

      count += *in++ << 4;

      count += GET_IN0;

      goto count_out_and_start_from_in1;

      break;

    case 0x6:

      count = *in++ << 16;

      count += *in++ << 8;

      count += *in++;

      goto count_out_and_start_from_in0;

      break;

    case 0x7:

      count = *in++ << 20;

      count += *in++ << 12;

      count += *in++ << 4;

      count += GET_IN0;

      goto count_out_and_start_from_in1;

      break;

    case 0x8:

      outval &= not_colmask;

      goto start_from_in0;

      break;

    case 0x9:

      outval &= not_penmask;

      goto start_from_in0;

      break;

    case 0xA:

      outval = outval & not_colmask | GET_IN0 << col_offs;

      goto start_from_in1;

      break;

    case 0xB:

      outval = outval & not_penmask | GET_IN0 << pen_offs;

      goto start_from_in1;

      break;

    case 0xC:

      outval = outval & not_colmask | *in++ << col_offs;

      goto start_from_in0;

      break;

    case 0xD:

      outval = outval & not_penmask | *in++ << pen_offs;

      goto start_from_in0;

      break;

    case 0xE:

      *out++ = (USHORT)(outval | maxtone);

      goto end_rle_decoding;

      break;

    case 0xF:

      switch (GET_IN0) {

      case 0:

        break;

      case 1:

        tmp    = in1 << 12 | *in++ << 4;

        *out++ = (USHORT)(tmp | GET_IN0);

        break;

      default:

        goto rle_decoding_error;

      }

      goto end_rle_decoding;

      break;

    default:

      goto rle_decoding_error;

    }

  } else {

    *out++ = (USHORT)(outval | in0);

    goto start_from_in1;

  }

count_out_and_start_from_in1:

  outval_maxtone         = outval | maxtone;

  *out++                 = (USHORT)(outval_maxtone);

  while (count--) *out++ = (USHORT)(outval_maxtone);

start_from_in1:

  if (in1 == 0xF) {

    switch (GET_IN0) {

    case 0x0:

      *out++ = (USHORT)(outval | maxtone);

      goto start_from_in1;

      break;

    case 0x1:

      count = in1;

      goto count_out_and_start_from_in0;

      break;

    case 0x2:

      count = in1 << 4;

      count += GET_IN0;

      goto count_out_and_start_from_in1;

      break;

    case 0x3:

      count = in1 << 8;

      count += *in++;

      goto count_out_and_start_from_in0;

      break;

    case 0x4:

      count = in1 << 12;

      count += *in++ << 4;

      count += GET_IN0;

      goto count_out_and_start_from_in1;

      break;

    case 0x5:

      count = in1 << 16;

      count += *in++ << 8;

      count += *in++;

      goto count_out_and_start_from_in0;

      break;

    case 0x6:

      count = in1 << 20;

      count += *in++ << 12;

      count += *in++ << 4;

      count += GET_IN0;

      goto count_out_and_start_from_in1;

      break;

    case 0x7:

      count = in1 << 24;

      count += *in++ << 16;

      count += *in++ << 8;

      count += *in++;

      goto count_out_and_start_from_in0;

      break;

    case 0x8:

      outval &= not_colmask;

      goto start_from_in1;

      break;

    case 0x9:

      outval &= not_penmask;

      goto start_from_in1;

      break;

    case 0xA:

      outval = outval & not_colmask | in1 << col_offs;

      goto start_from_in0;

      break;

    case 0xB:

      outval = outval & not_penmask | in1 << pen_offs;

      goto start_from_in0;

      break;

    case 0xC:

      tmp    = in1 << 4;

      outval = outval & not_colmask | (tmp | GET_IN0) << col_offs;

      goto start_from_in1;

      break;

    case 0xD:

      tmp    = in1 << 4;

      outval = outval & not_penmask | (tmp | GET_IN0) << pen_offs;

      goto start_from_in1;

      break;

    case 0xE:

      *out++ = (USHORT)(outval | maxtone);

      goto end_rle_decoding;

      break;

    case 0xF:

      switch (in1) {

      case 0:

        break;

      case 1:

        tmp    = *in++ << 8;

        *out++ = (USHORT)(tmp | *in++);

        break;

      default:

        goto rle_decoding_error;

      }

      goto end_rle_decoding;

      break;

    default:

      return 0;

    }

  } else {

    *out++ = (USHORT)(outval | in1);

    goto start_from_in0;

  }

end_rle_decoding:

  if (buf_in_len) *buf_in_len = (int)(in - buf_in);

  return (int)(out - buf_out);

rle_decoding_error:

  if (buf_in_len) *buf_in_len = 0;

  return 0;

}

//-------------------- DECODE CM24 ----------------------------

static int tif_toonz1_decode_cm24(UCHAR *buf_in, int *buf_in_len,

                                  TUINT32 *buf_out) {

  UCHAR *in;

  TUINT32 *out;

  int count;

  TUINT32 inval, tmp;

  TUINT32 outval, outval_maxtone;

  const int col_offs        = 8;

  const int pen_offs        = 16;

  const int xub_offs        = 24;

  const TUINT32 not_colmask = 0xffff00ff;

  const TUINT32 not_penmask = 0xff00ffff;

  const TUINT32 not_xubmask = 0x00ffffff;

  const TUINT32 maxtone     = 0x000000ff;

  outval         = 0;

  outval_maxtone = outval | maxtone;

  in  = buf_in;

  out = buf_out;

  for (;;) {

    inval = *in++;

    switch (inval) {

    case 0xF6:

      outval = outval & not_xubmask | *in++ << xub_offs;

      break;

    case 0xF7:

      count = *in++;

      goto count_out;

      break;

    case 0xF8:

      count = *in++ << 8;

      count += *in++;

      goto count_out;

      break;

    case 0xF9:

      count = *in++ << 16;

      count += *in++ << 8;

      count += *in++;

      goto count_out;

      break;

    case 0xFA:

      outval &= not_colmask;

      break;

    case 0xFB:

      outval &= not_penmask;

      break;

    case 0xFC:

      outval = outval & not_colmask | *in++ << col_offs;

      break;

    case 0xFD:

      outval = outval & not_penmask | *in++ << pen_offs;

      break;

    case 0xFE:

      switch (*in++) {

      case 0:

        break;

      case 1:

        *out++ = outval | maxtone;

        break;

      case 2:

        tmp    = *in++;

        tmp    = tmp << 8 | *in++;

        tmp    = tmp << 8 | *in++;

        *out++ = tmp << 8 | *in++;

        break;

      default:

        goto rle_decoding_error;

      }

      goto end_rle_decoding;

      break;

    case 0xFF:

      *out++ = outval | *in++;

      break;

    default:

      *out++ = outval | inval;

    }

    continue;

  count_out:

    outval_maxtone         = outval | maxtone;

    *out++                 = outval_maxtone;

    while (count--) *out++ = outval_maxtone;

  }

end_rle_decoding:

  if (buf_in_len) *buf_in_len = (int)(in - buf_in);

  return (int)(out - buf_out);

rle_decoding_error:

  if (buf_in_len) *buf_in_len = 0;

  return 0;

}

}

//=============================================================================

namespace {

class ToonzRleCodecRegisterer {

  static TIFFCodec *m_codec;

public:

  ToonzRleCodecRegisterer() {

    uint16 scheme    = 32881;

    const char *name = "TOONZ4RLE";

    m_codec          = TIFFRegisterCODEC(scheme, name, &TIFFInitToonz1);

  }

  ~ToonzRleCodecRegisterer() {

    TIFFUnRegisterCODEC(m_codec);

    m_codec = 0;

  }

};

TIFFCodec *ToonzRleCodecRegisterer::m_codec = 0;

ToonzRleCodecRegisterer registerer;

}

//=============================================================================

#if 0

/*

Queste stanno qui piu' che altro per memoria...

*/

extern "C" {

/*===========================================================================*/

/*---------------------------------------------------------------------------*/

#define GET_INVAL                                                              \

  {                                                                            \

    inval = *in++;                                                             \

    remain--;                                                                  \

  }

#define PUT_OUTVAL                                                             \

  { *out++ = (UCHAR)outval; }

/*---------------------------------------------------------------------------*/

int tif_toonz1_safe_bytes_for_pixels (int n_pix, int pixbytes)

{

if (n_pix < 0)

  return 0;

switch (pixbytes)

  {

  case 1: return 2 * n_pix + 1;

  case 2: return 5 * n_pix + 2;   /* == 2.5 * n_bytes + 2 */

  case 4: return 8 * n_pix + 6;   /* == 2   * n_bytes + 6 */

  }

return 0;

}

/*---------------------------------------------------------------------------*/

static int tif_toonz1_encode_cm16 (USHORT *buf_in, int buf_in_len,

                                   UCHAR  *buf_out,

				   int tone_bits,

				   int color_offs, int color_bits,

				   int pencil_offs, int pencil_bits,

				   USHORT offset_mask)

{

int  count, prevremain, remain;

UINT inval, outval;

UINT lastcol__, lastpen__, lastval, lastcolpen;

int  col_offs, pen_offs;

UINT colpenmask, colmask, penmask, maxtone;

UINT incolpen, incol__, incol, inpen__, inpen, tone;

USHORT *in, save;

UCHAR *out;

maxtone  = (1U << tone_bits) - 1U;

col_offs = color_offs;

pen_offs = pencil_offs;

colmask  = ((1U << color_bits)  - 1U) << color_offs;

penmask  = ((1U << pencil_bits) - 1U) << pencil_offs;

colpenmask = colmask | penmask;

remain    = buf_in_len;

lastcol__ = 0;

lastpen__ = 0;

lastval   = offset_mask | maxtone;

lastcolpen = 0;

in  = buf_in;

out = buf_out;

if (buf_in_len <= 1)

  {

  if (buf_in_len < 0)

    return 0;

  if (buf_in_len == 0)

    {

    outval = 0xFF;

    PUT_OUTVAL

    outval = 0x00;

    PUT_OUTVAL

    }

  else

    {

    GET_INVAL

    if (inval == (offset_mask | maxtone))

      {

      outval = 0xFE;

      PUT_OUTVAL

      }

    else

      {

      outval = 0xFF;

      PUT_OUTVAL

      outval = 0x10 | inval >> 12;

      PUT_OUTVAL

      outval = inval >> 4;

      PUT_OUTVAL

      outval = inval << 4;

      PUT_OUTVAL

      }

    }

  return out - buf_out;

  }

save = buf_in[buf_in_len - 1];

       buf_in[buf_in_len - 1] = buf_in[buf_in_len - 2] ^ colpenmask;

GET_INVAL

check_colpen_on_out0:

incolpen = inval & colpenmask;

if (incolpen == lastcolpen)

  goto check_tone_on_out0;

lastcolpen = incolpen;

if ( !remain)

  goto end_toonz1_encoding_on_out0;

/*check_col_on_out0:*/

incol__ = inval & colmask;

if (incol__ != lastcol__)

  {

  lastcol__ = incol__;

  if (incol__ == 0)

    {

    outval = (0xF << 4) | 0x8;

    PUT_OUTVAL

    goto check_pen_on_out0;

    }

  else

    {

    incol = incol__ >> col_offs;

    if (incol <= 0xF)

      {

      outval = (0xF << 4) | 0xA;

      PUT_OUTVAL

      outval = incol << 4;

      goto check_pen_on_out1;

      }

    else

      {

      outval = (0xF << 4) | 0xC;

      PUT_OUTVAL

      outval = incol;

      PUT_OUTVAL

      goto check_pen_on_out0;

      }

    }

  }

check_pen_on_out0:

inpen__ = inval & penmask;

if (inpen__ != lastpen__)

  {

  lastpen__ = inpen__;

  if (inpen__ == 0)

    {

    outval = (0xF << 4) | 0x9;

    PUT_OUTVAL

    goto check_tone_on_out0;

    }

  else

    {

    inpen = inpen__ >> pen_offs;

    if (inpen <= 0xF)

      {

      outval = (0xF << 4) | 0xB;

      PUT_OUTVAL

      outval = inpen << 4;

      goto check_tone_on_out1;

      }

    else

      {

      outval = (0xF << 4) | 0xD;

      PUT_OUTVAL

      outval = inpen;

      PUT_OUTVAL

      goto check_tone_on_out0;

      }

    }

  }

check_tone_on_out0:

tone = inval & maxtone;

if (tone == maxtone)

  {

  lastval = inval;

  prevremain = remain;

  do

    GET_INVAL

    while (inval == lastval);

  count = prevremain - remain - 1;

  if (count <= 0xF)

    if (count == 0)

      {

      outval = (0xF << 4) | 0x0;

      PUT_OUTVAL

      goto check_colpen_on_out0;

      }

    else

      {

      outval = (0xF << 4) | 0x1;

      PUT_OUTVAL

      outval = count << 4;

      goto check_colpen_on_out1;

      }

  else if (count <= 0xFF)

    {

    outval = (0xF << 4) | 0x2;

    PUT_OUTVAL

    outval = count;

    PUT_OUTVAL

    goto check_colpen_on_out0;

    }

  else if (count <= 0xFFF)

    {

    outval = (0xF << 4) | 0x3;

    PUT_OUTVAL

    outval = count >> 4;

    PUT_OUTVAL

    outval = count << 4;

    goto check_colpen_on_out1;

    }

  else if (count <= 0xFFFF)

    {

    outval = (0xF << 4) | 0x4;

    PUT_OUTVAL

    outval = count >> 8;

    PUT_OUTVAL

    outval = count;

    PUT_OUTVAL

    goto check_colpen_on_out0;

    }

  else if (count <= 0xFFFFF)

    {

    outval = (0xF << 4) | 0x5;

    PUT_OUTVAL

    outval = count >> 12;

    PUT_OUTVAL

    outval = count >> 4;

    PUT_OUTVAL

    outval = count << 4;

    goto check_colpen_on_out1;

    }

  else if (count <= 0xFFFFFF)

    {

    outval = (0xF << 4) | 0x6;

    PUT_OUTVAL

    outval = count >> 16;

    PUT_OUTVAL

    outval = count >> 8;

    PUT_OUTVAL

    outval = count;

    PUT_OUTVAL

    goto check_colpen_on_out0;

    }

  else if (count <= 0xFFFFFFF)

    {

    outval = (0xF << 4) | 0x7;

    PUT_OUTVAL

    outval = count >> 20;

    PUT_OUTVAL

    outval = count >> 12;

    PUT_OUTVAL

    outval = count >> 4;

    PUT_OUTVAL

    outval = count << 4;

    goto check_colpen_on_out1;

    }

  else

    {

    buf_in[buf_in_len - 1] = save;

    return 0;

    }

  }

else

  {

  outval = tone << 4;

  GET_INVAL

  /*goto check_colpen_on_out1;*/

  }

check_colpen_on_out1:

incolpen = inval & colpenmask;

if (incolpen == lastcolpen)

  goto check_tone_on_out1;

lastcolpen = incolpen;

if ( !remain)

  goto end_toonz1_encoding_on_out1;

/*check_col_on_out1:*/

incol__ = inval & colmask;

if (incol__ != lastcol__)

  {

  lastcol__ = incol__;

  outval |= 0xF;

  PUT_OUTVAL

  if (incol__ == 0)

    {

    outval = 0x8 << 4;

    goto check_pen_on_out1;

    }

  else

    {

    incol = incol__ >> col_offs;

    if (incol <= 0xF)

      {

      outval = (0xA << 4) | incol;

      PUT_OUTVAL

      goto check_pen_on_out0;

      }

    else

      {

      outval = (0xC << 4) | (incol >> 4);

      PUT_OUTVAL

      outval = incol << 4;

      goto check_pen_on_out1;

      }

    }

  }

check_pen_on_out1:

inpen__ = inval & penmask;

if (inpen__ != lastpen__)

  {

  lastpen__ = inpen__;

  outval |= 0xF;

  PUT_OUTVAL

  if (inpen__ == 0)

    {

    outval = 0x9 << 4;

    goto check_tone_on_out1;

    }

  else

    {

    inpen = inpen__ >> pen_offs;

    if (inpen <= 0xF)

      {

      outval = (0xB << 4) | inpen;