#include "jpgconverter.h"

#include <qfile></qfile>

#include <qdatastream></qdatastream>

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

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

JpgConverter::JpgConverter() {}

JpgConverter::~JpgConverter() {}

#ifdef WITH_CANON

void JpgConverter::setStream(EdsStreamRef stream) { m_stream = stream; }

void JpgConverter::convertFromJpg() {

#ifdef MACOSX

  UInt64 mySize = 0;

#else

  unsigned __int64 mySize = 0;

#endif

  unsigned char* data = NULL;

  EdsError err        = EdsGetPointer(m_stream, (EdsVoid**)&data);

  err                 = EdsGetLength(m_stream, &mySize);

  int width, height, pixelFormat;

  int inSubsamp, inColorspace;

  tjhandle tjInstance   = NULL;

  unsigned char* imgBuf = NULL;

  tjInstance            = tjInitDecompress();

  tjDecompressHeader3(tjInstance, data, mySize, &width, &height, &inSubsamp,

                      &inColorspace);

  if (width < 0 || height < 0) {

    emit(imageReady(false));

    return;

  }

  pixelFormat = TJPF_BGRX;

  imgBuf = (unsigned char*)tjAlloc(width * height * tjPixelSize[pixelFormat]);

  int flags = 0;

  flags |= TJFLAG_BOTTOMUP;

  int factorsNum;

  tjscalingfactor scalingFactor = {1, 1};

  tjscalingfactor* factor       = tjGetScalingFactors(&factorsNum);

  int i                         = 0;

  int tempWidth, tempHeight;

  while (i < factorsNum) {

    scalingFactor = factor[i];

    i++;

    tempWidth  = TJSCALED(width, scalingFactor);

    tempHeight = TJSCALED(height, scalingFactor);

  }

  tjDecompress2(tjInstance, data, mySize, imgBuf, width,

                width * tjPixelSize[pixelFormat], height, pixelFormat, flags);

  m_finalImage = TRaster32P(width, height);

  m_finalImage->lock();

  uchar* rawData = m_finalImage->getRawData();

  memcpy(rawData, imgBuf, width * height * tjPixelSize[pixelFormat]);

  m_finalImage->unlock();

  tjFree(imgBuf);

  imgBuf = NULL;

  tjDestroy(tjInstance);

  tjInstance = NULL;

  if (m_stream != NULL) {

    EdsRelease(m_stream);

    m_stream = NULL;

  }

  data = NULL;

  emit(imageReady(true));

}

void JpgConverter::run() { convertFromJpg(); }

#endif

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

void JpgConverter::saveJpg(TRaster32P image, TFilePath path) {

  unsigned char* jpegBuf = NULL; /* Dynamically allocate the JPEG buffer */

  unsigned long jpegSize = 0;

  int pixelFormat        = TJPF_BGRX;

  int outQual            = 95;

  int subSamp            = TJSAMP_411;

  bool success           = false;

  tjhandle tjInstance;

  int width  = image->getLx();

  int height = image->getLy();

  int flags  = 0;

  flags |= TJFLAG_BOTTOMUP;

  image->lock();

  uchar* rawData = image->getRawData();

  if ((tjInstance = tjInitCompress()) != NULL) {

    if (tjCompress2(tjInstance, rawData, width, 0, height, pixelFormat,

                    &jpegBuf, &jpegSize, subSamp, outQual, flags) >= 0) {

      success = true;

    }

  }

  image->unlock();

  tjDestroy(tjInstance);

  tjInstance = NULL;

  if (success) {

    /* Write the JPEG image to disk. */

    QFile fullImage(path.getQString());

    fullImage.open(QIODevice::WriteOnly);

    QDataStream dataStream(&fullImage);

    dataStream.writeRawData((const char*)jpegBuf, jpegSize);

    fullImage.close();

  }

  tjFree(jpegBuf);

  jpegBuf = NULL;

}

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

bool JpgConverter::loadJpg(TFilePath path, TRaster32P& image) {

  long size;

  int inSubsamp, inColorspace, width, height;

  unsigned long jpegSize;

  unsigned char* jpegBuf;

  FILE* jpegFile;

  QString qPath      = path.getQString();

  QByteArray ba      = qPath.toLocal8Bit();

  const char* c_path = ba.data();

  bool success       = true;

  tjhandle tjInstance;

  /* Read the JPEG file into memory. */

  if ((jpegFile = fopen(c_path, "rb")) == NULL) success = false;

  if (success && fseek(jpegFile, 0, SEEK_END) < 0 ||

      ((size = ftell(jpegFile)) < 0) || fseek(jpegFile, 0, SEEK_SET) < 0)

    success = false;

  if (success && size == 0) success = false;

  jpegSize = (unsigned long)size;

  if (success && (jpegBuf = (unsigned char*)tjAlloc(jpegSize)) == NULL)

    success = false;

  if (success && fread(jpegBuf, jpegSize, 1, jpegFile) < 1) success = false;

  fclose(jpegFile);

  jpegFile = NULL;

  if (success && (tjInstance = tjInitDecompress()) == NULL) success = false;

  if (success && tjDecompressHeader3(tjInstance, jpegBuf, jpegSize, &width,

                                     &height, &inSubsamp, &inColorspace) < 0)

    success = false;

  int pixelFormat       = TJPF_BGRX;

  unsigned char* imgBuf = NULL;

  if (success &&

      (imgBuf = tjAlloc(width * height * tjPixelSize[pixelFormat])) == NULL)

    success = false;

  int flags = 0;

  flags |= TJFLAG_BOTTOMUP;

  if (success && tjDecompress2(tjInstance, jpegBuf, jpegSize, imgBuf, width, 0,

                               height, pixelFormat, flags) < 0)

    success = false;

  tjFree(jpegBuf);

  jpegBuf = NULL;

  tjDestroy(tjInstance);

  tjInstance = NULL;

  image = TRaster32P(width, height);

  image->lock();

  uchar* rawData = image->getRawData();

  memcpy(rawData, imgBuf, width * height * tjPixelSize[pixelFormat]);

  image->unlock();

  tjFree(imgBuf);

  imgBuf = NULL;

  return success;

}