#include "tcodec.h"

#include "trastercm.h"

#include "tpixel.h"

#include "tbigmemorymanager.h"

#include "tsystem.h"

//#include "tstopwatch.h"

#include "timagecache.h"

#include "trasterimage.h"

//#include "snappy-c.h"

#if defined(LZ4_STATIC)

#include "lz4frame_static.h"

#else

#include "lz4frame.h"

#endif

#include <qdir></qdir>

#include <qprocess></qprocess>

#include <qcoreapplication></qcoreapplication>

using namespace std;

namespace {

class Header {

  enum RasType {

    Raster32RGBM,

    Raster64RGBM,

    Raster32CM,

    RasterGR8,

    RasterGR16,

    RasterUnknown

  };

public:

  Header(const TRasterP &ras);

  ~Header() {}

  TRasterP createRaster() const;

  int getRasterSize() const;

  int m_lx;

  int m_ly;

  RasType m_rasType;

  Header(void *mem) { memcpy(this, mem, sizeof(Header)); }

private:

  Header();  // not implemented

};

//------------------------------------------------------------------------------

Header::Header(const TRasterP &ras) {

  assert(ras);

  m_lx = ras->getLx();

  m_ly = ras->getLy();

  TRaster32P ras32(ras);

  if (ras32)

    m_rasType = Raster32RGBM;

  else {

    TRasterCM32P rasCM32(ras);

    if (rasCM32)

      m_rasType = Raster32CM;

    else {

      TRaster64P ras64(ras);

      if (ras64)

        m_rasType = Raster64RGBM;

      else {

        TRasterGR8P rasGR8(ras);

        if (rasGR8)

          m_rasType = RasterGR8;

        else {

          TRasterGR16P rasGR16(ras);

          if (rasGR16)

            m_rasType = RasterGR16;

          else {

            assert(!"Unknown RasterType");

            m_rasType = RasterUnknown;

          }

        }

      }

    }

  }

}

//------------------------------------------------------------------------------

TRasterP Header::createRaster() const {

  switch (m_rasType) {

  case Raster32RGBM:

    return TRaster32P(m_lx, m_ly);

    break;

  case Raster32CM:

    return TRasterCM32P(m_lx, m_ly);

    break;

  case Raster64RGBM:

    return TRaster64P(m_lx, m_ly);

    break;

  case RasterGR8:

    return TRasterGR8P(m_lx, m_ly);

    break;

  case RasterGR16:

    return TRasterGR16P(m_lx, m_ly);

    break;

  default:

    assert(0);

    return TRasterP();

    break;

  }

  return TRasterP();

}

//------------------------------------------------------------------------------

int Header::getRasterSize() const {

  switch (m_rasType) {

  case Raster32RGBM:

    return 4 * m_lx * m_ly;

    break;

  case Raster32CM:

    return 4 * m_lx * m_ly;

    break;

  case Raster64RGBM:

    return 8 * m_lx * m_ly;

    break;

  case RasterGR8:

    return m_lx * m_ly;

    break;

  default:

    assert(0);

    return 0;

    break;

  }

}

//------------------------------------------------------------------------------

}  // anonymous namespace

//------------------------------------------------------------------------------

//	TRasterCodecSnappy

//------------------------------------------------------------------------------

/*TRasterCodecSnappy::TRasterCodecSnappy(const std::string &name, bool useCache)

  : TRasterCodec(name)

  , m_raster()

  , m_useCache(useCache)

  , m_cacheId("")

{

}

//------------------------------------------------------------------------------

TRasterCodecSnappy::~TRasterCodecSnappy()

{

  if (m_useCache)

    TImageCache::instance()->remove(m_cacheId);

  else

    m_raster = TRasterGR8P();

}

//------------------------------------------------------------------------------

UINT TRasterCodecSnappy::doCompress(const TRasterP &inRas, int allocUnit,

TRasterGR8P& outRas)

{

  assert(inRas);

  assert(inRas->getLx() == inRas->getWrap());

  size_t inDataSize = inRas->getLx() * inRas->getLy() * inRas->getPixelSize();

  size_t maxReqSize = snappy_max_compressed_length(inDataSize);

  if (m_useCache)

    {

    if (m_cacheId=="")

      m_cacheId = TImageCache::instance()->getUniqueId();

    else

      outRas = ((TRasterImageP)TImageCache::instance()->get(m_cacheId,

true))->getRaster();

    }

  else

    outRas = m_raster;

  if (!outRas || outRas->getLx()<(int)maxReqSize)

  {

    outRas = TRasterGR8P();

    m_raster = TRasterGR8P();

    if (m_useCache)

      TImageCache::instance()->remove(m_cacheId);

    outRas = TRasterGR8P(maxReqSize, 1);

    if (m_useCache)

      TImageCache::instance()->add(m_cacheId, TRasterImageP(outRas), true);

    else

      m_raster = outRas;

  }

  outRas->lock();

  char* buffer = (char*) outRas->getRawData();

  if (!buffer)

    return 0;

  inRas->lock();

  char* inData = (char*) inRas->getRawData();

  size_t outSize = maxReqSize;

  snappy_status r = snappy_compress(inData, inDataSize, buffer, &outSize);

  outRas->unlock();

  inRas->unlock();

  if(r != SNAPPY_OK)

    throw TException("compress... something goes bad");

  return outSize;

 }

//------------------------------------------------------------------------------

TRasterP TRasterCodecSnappy::compress(const TRasterP &inRas, int allocUnit,

TINT32 &outDataSize)

{

  TRasterGR8P rasOut;

  UINT outSize = doCompress(inRas, allocUnit, rasOut);

  if (outSize==0)

    return TRasterP();

  UINT headerSize = sizeof(Header);

  if (TBigMemoryManager::instance()->isActive() &&

      TBigMemoryManager::instance()->getAvailableMemoryinKb()<((outSize +

headerSize)>>10))

        return TRasterP();

  TRasterGR8P r8(outSize + headerSize, 1);

  r8->lock();

  UCHAR *memoryChunk = r8->getRawData();

  if (!memoryChunk)

    return TRasterP();

  Header head(inRas);

  memcpy(memoryChunk, &head, headerSize);

  UCHAR *tmp = memoryChunk + headerSize;

  rasOut->lock();

  memcpy(tmp, rasOut->getRawData(), outSize);

  r8->unlock();

  rasOut->unlock();

  outDataSize = outSize + headerSize;

  return r8;

}

//------------------------------------------------------------------------------

bool TRasterCodecSnappy::decompress(const UCHAR* inData, TINT32 inDataSize,

TRasterP &outRas, bool safeMode)

{

  int headerSize = sizeof(Header);

  Header *header= (Header *)inData;

  if (!outRas)

    {

    outRas = header->createRaster();

    if (!outRas)

      throw TException();

    }

  else

    {

    if (outRas->getLx() != outRas->getWrap())

      throw TException();

    }

  int outDataSize = header->getRasterSize();

  char* mc = (char*) inData + headerSize;

  int ds = inDataSize - headerSize;

  size_t outSize;

  snappy_uncompressed_length(mc, ds, &outSize);

  outRas->lock();

  snappy_status rc = snappy_uncompress(mc, ds, (char*) outRas->getRawData(),

&outSize);

  outRas->unlock();

  if (rc != SNAPPY_OK)

    {

    if (safeMode)

      return false;

    else

      {

      throw TException("decompress... something goes bad");

      return false;

      }

    }

  assert(outSize == (size_t)outDataSize);

  return true;

}

//------------------------------------------------------------------------------

void TRasterCodecSnappy::decompress(const TRasterP & compressedRas, TRasterP

&outRas)

{

  int headerSize = sizeof(Header);

  assert(compressedRas->getLy()==1 && compressedRas->getPixelSize()==1);

  UINT inDataSize = compressedRas->getLx();

  compressedRas->lock();

  UCHAR* inData = compressedRas->getRawData();

  Header header(inData);

  if (!outRas)

    {

    outRas = header.createRaster();

    if (!outRas)

      throw TException();

    }

  else

    {

    if (outRas->getLx() != outRas->getWrap())

      throw TException();

    }

  int outDataSize = header.getRasterSize();

  char* mc = (char*) inData + headerSize;

  int ds = inDataSize - headerSize;

  size_t outSize;

  snappy_uncompressed_length(mc, ds, &outSize);

  char* outData = (char*) outRas->getRawData();

  outRas->lock();

  snappy_status rc = snappy_uncompress(mc, ds, outData, &outSize);

  outRas->unlock();

  compressedRas->unlock();

  if (rc != SNAPPY_OK)

    throw TException("decompress... something goes bad");

  assert(outSize == (size_t)outDataSize);

}*/

//------------------------------------------------------------------------------

//	TRasterCodecLz4

//------------------------------------------------------------------------------

namespace {

bool lz4decompress(LZ4F_decompressionContext_t lz4dctx, char *out,

                   size_t *out_len_res, const char *in, size_t in_len) {

  size_t out_len = *out_len_res, in_read, out_written;

  *out_len_res = 0;

  while (in_len) {

    out_written = out_len;

    in_read     = in_len;

    size_t res = LZ4F_decompress(lz4dctx, (void *)out, &out_written,

                                 (const void *)in, &in_read, NULL);

    if (LZ4F_isError(res)) return false;

    *out_len_res += out_written;

    out += out_written;

    out_len -= out_written;

    in += in_read;

    in_len -= in_read;

  }

  return true;

}

}  // namespace

TRasterCodecLz4::TRasterCodecLz4(const std::string &name, bool useCache)

    : TRasterCodec(name), m_raster(), m_useCache(useCache), m_cacheId("") {}

//------------------------------------------------------------------------------

TRasterCodecLz4::~TRasterCodecLz4() {

  if (m_useCache)

    TImageCache::instance()->remove(m_cacheId);

  else

    m_raster = TRasterGR8P();

}

//------------------------------------------------------------------------------

UINT TRasterCodecLz4::doCompress(const TRasterP &inRas, int allocUnit,

                                 TRasterGR8P &outRas) {

  assert(inRas);

  assert(inRas->getLx() == inRas->getWrap());

  size_t inDataSize = inRas->getLx() * inRas->getLy() * inRas->getPixelSize();

  size_t maxReqSize = LZ4F_compressFrameBound(inDataSize, NULL);

  if (m_useCache) {

    if (m_cacheId == "")

      m_cacheId = TImageCache::instance()->getUniqueId();

    else

      outRas = ((TRasterImageP)TImageCache::instance()->get(m_cacheId, true))

                   ->getRaster();

  } else

    outRas = m_raster;

  if (!outRas || outRas->getLx() < (int)maxReqSize) {

    outRas   = TRasterGR8P();

    m_raster = TRasterGR8P();

    if (m_useCache) TImageCache::instance()->remove(m_cacheId);

    outRas = TRasterGR8P(maxReqSize, 1);

    if (m_useCache)

      TImageCache::instance()->add(m_cacheId, TRasterImageP(outRas), true);

    else

      m_raster = outRas;

  }

  outRas->lock();

  void *buffer = (void *)outRas->getRawData();

  if (!buffer) return 0;

  inRas->lock();

  const void *inData = (const void *)inRas->getRawData();

  size_t outSize =

      LZ4F_compressFrame(buffer, maxReqSize, inData, inDataSize, NULL);

  outRas->unlock();

  inRas->unlock();

  if (LZ4F_isError(outSize)) throw TException("compress... something goes bad");

  return outSize;

}

//------------------------------------------------------------------------------

TRasterP TRasterCodecLz4::compress(const TRasterP &inRas, int allocUnit,

                                   TINT32 &outDataSize) {

  TRasterGR8P rasOut;

  UINT outSize = doCompress(inRas, allocUnit, rasOut);

  if (outSize == 0) return TRasterP();

  UINT headerSize = sizeof(Header);

  if (TBigMemoryManager::instance()->isActive() &&

      TBigMemoryManager::instance()->getAvailableMemoryinKb() <

          ((outSize + headerSize) >> 10))

    return TRasterP();

  TRasterGR8P r8(outSize + headerSize, 1);

  r8->lock();

  UCHAR *memoryChunk = r8->getRawData();

  if (!memoryChunk) return TRasterP();

  Header head(inRas);

  memcpy(memoryChunk, &head, headerSize);

  UCHAR *tmp = memoryChunk + headerSize;

  rasOut->lock();

  memcpy(tmp, rasOut->getRawData(), outSize);

  r8->unlock();

  rasOut->unlock();

  outDataSize = outSize + headerSize;

  return r8;

}

//------------------------------------------------------------------------------

bool TRasterCodecLz4::decompress(const UCHAR *inData, TINT32 inDataSize,

                                 TRasterP &outRas, bool safeMode) {

  int headerSize = sizeof(Header);

  Header *header = (Header *)inData;

  if (!outRas) {

    outRas = header->createRaster();

    if (!outRas) throw TException();

  } else {

    if (outRas->getLx() != outRas->getWrap()) throw TException();

  }

  LZ4F_decompressionContext_t lz4dctx;

  LZ4F_errorCode_t err =

      LZ4F_createDecompressionContext(&lz4dctx, LZ4F_VERSION);

  if (LZ4F_isError(err)) throw TException("compress... something goes bad");

  int outDataSize = header->getRasterSize();

  const char *mc = (const char *)(inData + headerSize);

  size_t ds      = inDataSize - headerSize;

  size_t outSize = outDataSize;

  char *outData  = (char *)outRas->getRawData();

  outRas->lock();

  // err = LZ4F_decompress(lz4dctx, outData, &outSize, mc, &ds, NULL);

  bool ok = lz4decompress(lz4dctx, outData, &outSize, mc, ds);

  LZ4F_freeDecompressionContext(lz4dctx);

  outRas->unlock();

  if (!ok) {

    if (safeMode)

      return false;

    else {

      throw TException("decompress... something goes bad");

      return false;

    }

  }

  assert(outSize == (size_t)outDataSize);

  return true;

}

//------------------------------------------------------------------------------

void TRasterCodecLz4::decompress(const TRasterP &compressedRas,

                                 TRasterP &outRas) {

  int headerSize = sizeof(Header);

  assert(compressedRas->getLy() == 1 && compressedRas->getPixelSize() == 1);

  UINT inDataSize = compressedRas->getLx();

  compressedRas->lock();

  UCHAR *inData = compressedRas->getRawData();

  Header header(inData);

  if (!outRas) {

    outRas = header.createRaster();

    if (!outRas) throw TException();

  } else {

    if (outRas->getLx() != outRas->getWrap()) throw TException();

  }

  LZ4F_decompressionContext_t lz4dctx;

  LZ4F_errorCode_t err =

      LZ4F_createDecompressionContext(&lz4dctx, LZ4F_VERSION);

  if (LZ4F_isError(err)) throw TException("compress... something goes bad");

  int outDataSize = header.getRasterSize();

  const char *mc = (const char *)(inData + headerSize);

  size_t ds      = inDataSize - headerSize;

  size_t outSize = outDataSize;

  char *outData  = (char *)outRas->getRawData();

  outRas->lock();

  // err = LZ4F_decompress(lz4dctx, outData, &outSize, mc, &ds, NULL);

  bool ok = lz4decompress(lz4dctx, outData, &outSize, mc, ds);

  LZ4F_freeDecompressionContext(lz4dctx);

  outRas->unlock();

  compressedRas->unlock();

  if (!ok) throw TException("decompress... something goes bad");

  assert(outSize == (size_t)outDataSize);

}

//------------------------------------------------------------------------------

//	TRasterCodecLZO

//------------------------------------------------------------------------------

namespace {

bool lzoCompress(const QByteArray src, QByteArray &dst) {

  QDir exeDir(QCoreApplication::applicationDirPath());

  QString compressExe = exeDir.filePath("lzocompress");

  QProcess process;

  process.start(compressExe, QStringList() << QString::number(src.size()));

  if (!process.waitForStarted()) return false;

  process.write(src);

  if (!process.waitForFinished()) return false;

  dst = process.readAll();

  return process.exitCode() == 0;

}

bool lzoDecompress(const QByteArray src, int dstSize, QByteArray &dst) {

  QDir exeDir(QCoreApplication::applicationDirPath());

  QString decompressExe = exeDir.filePath("lzodecompress");

  QProcess process;

  process.start(decompressExe, QStringList() << QString::number(dstSize)

                                             << QString::number(src.size()));

  if (!process.waitForStarted()) return false;

  process.write(src);

  if (!process.waitForFinished()) return false;

  dst = process.readAll();

  return process.exitCode() == 0 && dst.size() == dstSize;

}

}

//------------------------------------------------------------------------------

TRasterCodecLZO::TRasterCodecLZO(const std::string &name, bool useCache)

    : TRasterCodec(name), m_raster(), m_useCache(useCache), m_cacheId("") {}

//------------------------------------------------------------------------------

TRasterCodecLZO::~TRasterCodecLZO() {

  if (m_useCache)

    TImageCache::instance()->remove(m_cacheId);

  else

    m_raster = TRasterGR8P();

}

//------------------------------------------------------------------------------

UINT TRasterCodecLZO::doCompress(const TRasterP &inRas, int allocUnit,

                                 TRasterGR8P &outRas) {

  assert(inRas);

  assert(inRas->getLx() == inRas->getWrap());

  size_t inDataSize = inRas->getLx() * inRas->getLy() * inRas->getPixelSize();

  // compress data

  inRas->lock();

  char *inData = (char *)inRas->getRawData();

  QByteArray compressedBuffer;

  if (!lzoCompress(QByteArray(inData, inDataSize), compressedBuffer))

    throw TException("LZO compression failed");

  inRas->unlock();

  size_t maxReqSize = compressedBuffer.size();  // we have just done the

                                                // compression: we know the

                                                // actual size

  if (m_useCache) {

    if (m_cacheId == "")

      m_cacheId = TImageCache::instance()->getUniqueId();

    else

      outRas = ((TRasterImageP)TImageCache::instance()->get(m_cacheId, true))

                   ->getRaster();

  } else

    outRas = m_raster;

  if (!outRas || outRas->getLx() < (int)maxReqSize) {

    outRas   = TRasterGR8P();

    m_raster = TRasterGR8P();

    if (m_useCache) TImageCache::instance()->remove(m_cacheId);

    outRas = TRasterGR8P(maxReqSize, 1);

    if (m_useCache)

      TImageCache::instance()->add(m_cacheId, TRasterImageP(outRas), true);

    else

      m_raster = outRas;

  }

  size_t outSize = maxReqSize;

  outRas->lock();

  char *buffer = (char *)outRas->getRawData();  // Change cast types, if needed

  if (!buffer) {

    outRas->unlock();

    return 0;

  }

  memcpy(buffer, compressedBuffer.data(), outSize);

  outRas->unlock();

  return outSize;

}

//------------------------------------------------------------------------------

TRasterP TRasterCodecLZO::compress(const TRasterP &inRas, int allocUnit,

                                   TINT32 &outDataSize) {

  TRasterGR8P rasOut;

  UINT outSize = doCompress(inRas, allocUnit, rasOut);

  if (outSize == 0) return TRasterP();

  UINT headerSize = sizeof(Header);

  if (TBigMemoryManager::instance()->isActive() &&

      TBigMemoryManager::instance()->getAvailableMemoryinKb() <

          ((outSize + headerSize) >> 10))

    return TRasterP();

  TRasterGR8P r8(outSize + headerSize, 1);

  r8->lock();

  UCHAR *memoryChunk = r8->getRawData();

  if (!memoryChunk) return TRasterP();

  Header head(inRas);

  memcpy(memoryChunk, &head, headerSize);

  UCHAR *tmp = memoryChunk + headerSize;

  rasOut->lock();

  memcpy(tmp, rasOut->getRawData(), outSize);

  r8->unlock();

  rasOut->unlock();

  outDataSize = outSize + headerSize;

  return r8;

}

//------------------------------------------------------------------------------

bool TRasterCodecLZO::decompress(const UCHAR *inData, TINT32 inDataSize,

                                 TRasterP &outRas, bool safeMode) {

  int headerSize = sizeof(Header);

  Header *header = (Header *)inData;

  if (!outRas) {

    outRas = header->createRaster();

    if (!outRas) throw TException();

  } else {

    if (outRas->getLx() != outRas->getWrap()) throw TException();

  }

  int outDataSize = header->getRasterSize();

  char *mc = (char *)inData + headerSize;

  int ds   = inDataSize - headerSize;

  size_t outSize = outDataSize;  // Calculate output buffer size

  QByteArray decompressedBuffer;

  if (!lzoDecompress(QByteArray(mc, ds), outSize, decompressedBuffer))

    throw TException("LZO decompression failed");

  outRas->lock();

  memcpy(outRas->getRawData(), decompressedBuffer.data(),

         decompressedBuffer.size());

  bool rc = true;

  outRas->unlock();

  /*

if (rc != true)                                     // Check success code here

{

if (safeMode)

return false;

else

{

throw TException("decompress... something goes bad");

return false;

}

}

  */

  assert(outSize == (size_t)outDataSize);

  return true;

}

//------------------------------------------------------------------------------

void TRasterCodecLZO::decompress(const TRasterP &compressedRas,

                                 TRasterP &outRas) {

  int headerSize = sizeof(Header);

  assert(compressedRas->getLy() == 1 && compressedRas->getPixelSize() == 1);

  UINT inDataSize = compressedRas->getLx();

  compressedRas->lock();

  UCHAR *inData = compressedRas->getRawData();

  Header header(inData);

  if (!outRas) {

    outRas = header.createRaster();

    if (!outRas) throw TException();

  } else {

    if (outRas->getLx() != outRas->getWrap()) throw TException();

  }

  int outDataSize = header.getRasterSize();

  char *mc = (char *)inData + headerSize;

  int ds   = inDataSize - headerSize;

  size_t outSize = outDataSize;  // Calculate output buffer size

  char *outData = (char *)outRas->getRawData();

  QByteArray decompressedBuffer;

  if (!lzoDecompress(QByteArray(mc, ds), outSize, decompressedBuffer))

    throw TException("LZO decompression failed");

  outRas->lock();

  memcpy(outRas->getRawData(), decompressedBuffer.data(),

         decompressedBuffer.size());

  bool rc = true;

  outRas->unlock();

  compressedRas->unlock();

  if (rc != true)  // Check success code here

    throw TException("decompress... something goes bad");

  assert(outSize == (size_t)outDataSize);

}