#include "canon.h"

#include "stopmotion.h"

#include "tapp.h"

#include "tenv.h"

#include "toonz/stage.h"

#include "toonz/tscenehandle.h"

#include "toonz/tcamera.h"

#include "toonz/toonzscene.h"

#include <qcoreapplication></qcoreapplication>

#include <qfile></qfile>

TEnv::IntVar StopMotionUseScaledImages("StopMotionUseScaledImages", 1);

namespace {

bool l_quitLoop = false;

}

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

Canon::Canon() {

  m_useScaledImages = StopMotionUseScaledImages;

#ifdef WITH_CANON

  buildAvMap();

  buildIsoMap();

  buildTvMap();

  buildModeMap();

  buildExposureMap();

  buildWhiteBalanceMap();

  buildColorTemperatures();

  buildImageQualityMap();

  buildPictureStyleMap();

#endif

}

Canon::~Canon() {}

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

void Canon::onImageReady(const bool& status) { m_converterSucceeded = status; }

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

void Canon::onFinished() { l_quitLoop = true; }

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

#ifdef WITH_CANON

EdsError Canon::initializeCanonSDK() {

  m_error = EdsInitializeSDK();

  if (m_error == EDS_ERR_OK) {

    m_isSDKLoaded = true;

  }

  if (!m_error)

    m_error =

        EdsSetCameraAddedHandler(Canon::handleCameraAddedEvent, (EdsVoid*)this);

  return m_error;

}

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

EdsCameraListRef Canon::getCameraList() {

  if (!m_isSDKLoaded) initializeCanonSDK();

  if (m_isSDKLoaded) {

    m_error = EdsGetCameraList(&m_cameraList);

  }

  return m_cameraList;

}

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

EdsError Canon::releaseCameraList() {

  if (m_cameraList != NULL) m_error = EdsRelease(m_cameraList);

  return m_error;

}

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

int Canon::getCameraCount() {

  if (m_cameraList == NULL) {

    getCameraList();

  }

  if (m_cameraList != NULL) {

    m_error = EdsGetChildCount(m_cameraList, &m_count);

    if (m_count == 0) {

      m_error = EDS_ERR_DEVICE_NOT_FOUND;

      if (m_sessionOpen) {

        StopMotion::instance()->m_liveViewStatus = 0;

        m_sessionOpen                            = false;

      }

    }

    return m_count;

  } else

    return -1;

}

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

EdsError Canon::getCamera(int index) {

  if (m_count == 0) {

    m_error = EDS_ERR_DEVICE_NOT_FOUND;

  }

  if (m_count > 0) {

    m_error = EdsGetChildAtIndex(m_cameraList, index, &m_camera);

  }

  return m_error;

}

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

EdsError Canon::releaseCamera() {

  if (m_camera != NULL) {

    m_error = EdsRelease(m_camera);

  }

  return m_error;

}

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

void Canon::cameraAdded() { StopMotion::instance()->refreshCameraList(); }

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

void Canon::closeCanonSDK() {

  if (m_isSDKLoaded) {

    EdsTerminateSDK();

  }

}

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

void Canon::closeAll() {

#ifdef WITH_CANON

  if (m_camera) releaseCamera();

  if (m_cameraList != NULL) releaseCameraList();

  if (m_isSDKLoaded) closeCanonSDK();

#endif

}

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

void Canon::resetCanon(bool liveViewOpen) {

#ifdef WITH_CANON

  m_proxyDpi             = TPointD(0.0, 0.0);

  m_proxyImageDimensions = TDimension(0, 0);

  if (m_sessionOpen && getCameraCount() > 0) {

    if (liveViewOpen) {

      endCanonLiveView();

    }

    closeCameraSession();

  }

#endif

}

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

EdsError Canon::openCameraSession() {

  if (m_camera != NULL) {

    m_error = EdsOpenSession(m_camera);

    if (m_error == EDS_ERR_OK) m_sessionOpen = true;

  }

  m_error = EdsSetObjectEventHandler(m_camera, kEdsObjectEvent_All,

                                     Canon::handleObjectEvent, (EdsVoid*)this);

  m_error =

      EdsSetPropertyEventHandler(m_camera, kEdsPropertyEvent_All,

                                 Canon::handlePropertyEvent, (EdsVoid*)this);

  m_error = EdsSetCameraStateEventHandler(

      m_camera, kEdsStateEvent_All, Canon::handleStateEvent, (EdsVoid*)this);

  // We can't handle raw images yet, so make sure we are getting jpgs

  if (getCurrentImageQuality().contains("RAW"))

    setImageQuality("Large Fine Jpeg");

  EdsUInt32 saveto        = kEdsSaveTo_Host;

  m_error                 = EdsSetPropertyData(m_camera, kEdsPropID_SaveTo, 0,

                               sizeof(EdsUInt32), &saveto);

  EdsCapacity newCapacity = {0x7FFFFFFF, 0x1000, 1};

  m_error                 = EdsSetCapacity(m_camera, newCapacity);

  return m_error;

}

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

EdsError Canon::closeCameraSession() {

  if (m_camera != NULL) {

    m_error       = EdsCloseSession(m_camera);

    m_sessionOpen = false;

  }

  return m_error;

}

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

void Canon::refreshOptions() {

  getAvailableShutterSpeeds();

  getAvailableIso();

  getAvailableApertures();

  getAvailableExposureCompensations();

  getAvailableWhiteBalances();

  buildColorTemperatures();

  getAvailableImageQualities();

  getAvailablePictureStyles();

}

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

std::string Canon::getCameraName() {

  EdsChar name[EDS_MAX_NAME];

  EdsError err = EDS_ERR_OK;

  EdsDataType dataType;

  EdsUInt32 dataSize;

  m_error = EdsGetPropertySize(m_camera, kEdsPropID_ProductName, 0, &dataType,

                               &dataSize);

  if (m_error == EDS_ERR_OK) {

    m_error =

        EdsGetPropertyData(m_camera, kEdsPropID_ProductName, 0, dataSize, name);

  }

  m_cameraName = name;

  return m_cameraName;

}

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

QString Canon::getMode() {

  EdsError err = EDS_ERR_OK;

  EdsDataType modeType;

  EdsUInt32 size;

  EdsUInt32 data;

  err = EdsGetPropertySize(m_camera, kEdsPropID_AEMode, 0, &modeType, &size);

  err = EdsGetPropertyData(m_camera, kEdsPropID_AEMode, 0, sizeof(size), &data);

  return QString::fromStdString(m_modeMap[data]);

}

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

EdsError Canon::getAvailableIso() {

  EdsPropertyDesc* IsoDesc = new EdsPropertyDesc;

  EdsError err             = EDS_ERR_OK;

  m_isoOptions.clear();

  err       = EdsGetPropertyDesc(m_camera, kEdsPropID_ISOSpeed, IsoDesc);

  int count = IsoDesc->numElements;

  if (count > 0) {

    int i = 0;

    while (i < count) {

      m_isoOptions.push_back(

          QString::fromStdString(m_isoMap[IsoDesc->propDesc[i]]));

      i++;

    }

  }

  delete IsoDesc;

  return err;

}

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

EdsError Canon::getAvailableShutterSpeeds() {

  EdsPropertyDesc* TvDesc = new EdsPropertyDesc;

  EdsError err            = EDS_ERR_OK;

  m_shutterSpeedOptions.clear();

  err       = EdsGetPropertyDesc(m_camera, kEdsPropID_Tv, TvDesc);

  int count = TvDesc->numElements;

  if (count > 0) {

    int i = 0;

    while (i < count) {

      m_shutterSpeedOptions.push_back(

          QString::fromStdString(m_tvMap[TvDesc->propDesc[i]]));

      i++;

    }

  }

  delete TvDesc;

  return err;

}

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

EdsError Canon::getAvailableApertures() {

  EdsPropertyDesc* AvDesc = new EdsPropertyDesc;

  EdsError err            = EDS_ERR_OK;

  m_apertureOptions.clear();

  err       = EdsGetPropertyDesc(m_camera, kEdsPropID_Av, AvDesc);

  int count = AvDesc->numElements;

  if (count > 0) {

    int i = 0;

    while (i < count) {

      m_apertureOptions.push_back(

          QString::fromStdString(m_avMap[AvDesc->propDesc[i]]));

      i++;

    }

  }

  delete AvDesc;

  return err;

}

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

EdsError Canon::getAvailableExposureCompensations() {

  EdsPropertyDesc* exposureDesc = new EdsPropertyDesc;

  EdsError err                  = EDS_ERR_OK;

  m_exposureOptions.clear();

  err       = EdsGetPropertyDesc(m_camera, kEdsPropID_ExposureCompensation,

                           exposureDesc);

  int count = exposureDesc->numElements;

  if (count > 0) {

    int i = 0;

    while (i < count) {

      m_exposureOptions.push_back(

          QString::fromStdString(m_exposureMap[exposureDesc->propDesc[i]]));

      i++;

    }

  }

  delete exposureDesc;

  return err;

}

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

EdsError Canon::getAvailableWhiteBalances() {

  EdsPropertyDesc* whiteBalanceDesc = new EdsPropertyDesc;

  EdsError err                      = EDS_ERR_OK;

  m_whiteBalanceOptions.clear();

  err = EdsGetPropertyDesc(m_camera, kEdsPropID_WhiteBalance, whiteBalanceDesc);

  int count = whiteBalanceDesc->numElements;

  if (count > 0) {

    int i = 0;

    while (i < count) {

      m_whiteBalanceOptions.push_back(QString::fromStdString(

          m_whiteBalanceMap[whiteBalanceDesc->propDesc[i]]));

      i++;

    }

  }

  delete whiteBalanceDesc;

  return err;

}

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

EdsError Canon::getAvailableImageQualities() {

  EdsPropertyDesc* imageQualityDesc = new EdsPropertyDesc;

  EdsError err                      = EDS_ERR_OK;

  m_imageQualityOptions.clear();

  err = EdsGetPropertyDesc(m_camera, kEdsPropID_ImageQuality, imageQualityDesc);

  int count = imageQualityDesc->numElements;

  if (count > 0) {

    int i = 0;

    while (i < count) {

      QString quality = QString::fromStdString(

          m_imageQualityMap[imageQualityDesc->propDesc[i]]);

      if (!quality.contains("RAW")) {

        m_imageQualityOptions.push_back(quality);

      }

      i++;

    }

  }

  delete imageQualityDesc;

  return err;

}

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

EdsError Canon::getAvailablePictureStyles() {

  EdsPropertyDesc* pictureStyleDesc = new EdsPropertyDesc;

  EdsError err                      = EDS_ERR_OK;

  m_pictureStyleOptions.clear();

  err = EdsGetPropertyDesc(m_camera, kEdsPropID_PictureStyle, pictureStyleDesc);

  int count = pictureStyleDesc->numElements;

  if (count > 0) {

    int i = 0;

    while (i < count) {

      m_pictureStyleOptions.push_back(QString::fromStdString(

          m_pictureStyleMap[pictureStyleDesc->propDesc[i]]));

      i++;

    }

  }

  delete pictureStyleDesc;

  return err;

}

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

void Canon::buildColorTemperatures() {

  m_colorTempOptions.clear();

  int i = 2800;

  while (i <= 10000) {

    m_colorTempOptions.push_back(QString::number(i));

    i += 100;

  }

}

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

QString Canon::getCurrentShutterSpeed() {

  EdsError err = EDS_ERR_OK;

  EdsDataType tvType;

  EdsUInt32 size;

  EdsUInt32 data;

  err = EdsGetPropertySize(m_camera, kEdsPropID_Tv, 0, &tvType, &size);

  err = EdsGetPropertyData(m_camera, kEdsPropID_Tv, 0, sizeof(size), &data);

  return QString::fromStdString(m_tvMap[data]);

}

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

QString Canon::getCurrentIso() {

  EdsError err = EDS_ERR_OK;

  EdsDataType isoType;

  EdsUInt32 size;

  EdsUInt32 data;

  err = EdsGetPropertySize(m_camera, kEdsPropID_ISOSpeed, 0, &isoType, &size);

  err =

      EdsGetPropertyData(m_camera, kEdsPropID_ISOSpeed, 0, sizeof(size), &data);

  return QString::fromStdString(m_isoMap[data]);

}

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

QString Canon::getCurrentAperture() {

  EdsError err = EDS_ERR_OK;

  EdsDataType avType;

  EdsUInt32 size;

  EdsUInt32 data;

  err = EdsGetPropertySize(m_camera, kEdsPropID_Av, 0, &avType, &size);

  err = EdsGetPropertyData(m_camera, kEdsPropID_Av, 0, sizeof(size), &data);

  return QString::fromStdString(m_avMap[data]);

}

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

QString Canon::getCurrentExposureCompensation() {

  EdsError err = EDS_ERR_OK;

  EdsDataType exposureType;

  EdsUInt32 size;

  EdsUInt32 data;

  err = EdsGetPropertySize(m_camera, kEdsPropID_ExposureCompensation, 0,

                           &exposureType, &size);

  err = EdsGetPropertyData(m_camera, kEdsPropID_ExposureCompensation, 0,

                           sizeof(size), &data);

  return QString::fromStdString(m_exposureMap[data]);

}

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

QString Canon::getCurrentWhiteBalance() {

  EdsError err = EDS_ERR_OK;

  EdsDataType whiteBalanceType;

  EdsUInt32 size;

  EdsUInt32 data;

  err = EdsGetPropertySize(m_camera, kEdsPropID_WhiteBalance, 0,

                           &whiteBalanceType, &size);

  err = EdsGetPropertyData(m_camera, kEdsPropID_WhiteBalance, 0, sizeof(size),

                           &data);

  std::string wbString = m_whiteBalanceMap[data];

  return QString::fromStdString(m_whiteBalanceMap[data]);

}

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

QString Canon::getCurrentImageQuality() {

  EdsError err = EDS_ERR_OK;

  EdsDataType imageQualityType;

  EdsUInt32 size;

  EdsUInt32 data;

  err = EdsGetPropertySize(m_camera, kEdsPropID_ImageQuality, 0,

                           &imageQualityType, &size);

  err = EdsGetPropertyData(m_camera, kEdsPropID_ImageQuality, 0, sizeof(size),

                           &data);

  std::string wbString = m_imageQualityMap[data];

  return QString::fromStdString(m_imageQualityMap[data]);

}

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

QString Canon::getCurrentPictureStyle() {

  EdsError err = EDS_ERR_OK;

  EdsDataType pictureStyleType;

  EdsUInt32 size;

  EdsUInt32 data;

  err = EdsGetPropertySize(m_camera, kEdsPropID_PictureStyle, 0,

                           &pictureStyleType, &size);

  err = EdsGetPropertyData(m_camera, kEdsPropID_PictureStyle, 0, sizeof(size),

                           &data);

  std::string wbString = m_pictureStyleMap[data];

  return QString::fromStdString(m_pictureStyleMap[data]);

}

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

QString Canon::getCurrentColorTemperature() {

  EdsError err = EDS_ERR_OK;

  EdsDataType colorTempType;

  EdsUInt32 size;

  EdsUInt32 data;

  err = EdsGetPropertySize(m_camera, kEdsPropID_ColorTemperature, 0,

                           &colorTempType, &size);

  err = EdsGetPropertyData(m_camera, kEdsPropID_ColorTemperature, 0,

                           sizeof(size), &data);

  return QString::number(data);

}

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

QString Canon::getCurrentBatteryLevel() {

  EdsError err = EDS_ERR_OK;

  EdsDataType batteryLevelType;

  EdsUInt32 size;

  EdsUInt32 data;

  QString result;

  err = EdsGetPropertySize(m_camera, kEdsPropID_BatteryLevel, 0,

                           &batteryLevelType, &size);

  err = EdsGetPropertyData(m_camera, kEdsPropID_BatteryLevel, 0, sizeof(size),

                           &data);

  if (data == 0xffffffff) {

    result = tr("AC Power");

  } else if (data >= 80) {

    result = tr("Full");

  } else {

    // at least  the 60D reports battery values as 59, 49. . .

    // round up

    if (data % 10 == 9) data += 1;

    result = QString::number(data) + "%";

  }

  return result;

}

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

EdsError Canon::setShutterSpeed(QString shutterSpeed) {

  EdsError err = EDS_ERR_OK;

  EdsUInt32 value;

  auto it = m_tvMap.begin();

  while (it != m_tvMap.end()) {

    if (it->second == shutterSpeed.toStdString()) {

      value = it->first;

      break;

    }

    it++;

  }

  err = EdsSetPropertyData(m_camera, kEdsPropID_Tv, 0, sizeof(value), &value);

  emit(shutterSpeedChangedSignal(shutterSpeed));

  return err;

}

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

EdsError Canon::setIso(QString iso) {

  EdsError err = EDS_ERR_OK;

  EdsUInt32 value;

  auto it = m_isoMap.begin();

  while (it != m_isoMap.end()) {

    if (it->second == iso.toStdString()) {

      value = it->first;

      break;

    }

    it++;

  }

  err = EdsSetPropertyData(m_camera, kEdsPropID_ISOSpeed, 0, sizeof(value),

                           &value);

  emit(isoChangedSignal(iso));

  return err;

}

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

EdsError Canon::setAperture(QString aperture) {

  EdsError err = EDS_ERR_OK;

  EdsUInt32 value;

  auto it = m_avMap.begin();

  while (it != m_avMap.end()) {

    if (it->second == aperture.toStdString()) {

      value = it->first;

      err =

          EdsSetPropertyData(m_camera, kEdsPropID_Av, 0, sizeof(value), &value);

      if (err == EDS_ERR_OK) {

        break;

      } else {

        // some aperture values have two entries in the avMap

        it++;

        value = it->first;

        err   = EdsSetPropertyData(m_camera, kEdsPropID_Av, 0, sizeof(value),

                                 &value);

        break;

      }

    }

    it++;

  }

  emit(apertureChangedSignal(aperture));

  return err;

}

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

EdsError Canon::setExposureCompensation(QString exposure) {

  EdsError err = EDS_ERR_OK;

  EdsUInt32 value;

  auto it = m_exposureMap.begin();

  while (it != m_exposureMap.end()) {

    if (it->second == exposure.toStdString()) {

      value = it->first;

      break;

    }

    it++;

  }

  err = EdsSetPropertyData(m_camera, kEdsPropID_ExposureCompensation, 0,

                           sizeof(value), &value);

  emit(exposureChangedSignal(exposure));

  return err;

}

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

EdsError Canon::setWhiteBalance(QString whiteBalance) {

  EdsError err = EDS_ERR_OK;

  EdsUInt32 value;

  auto it = m_whiteBalanceMap.begin();

  while (it != m_whiteBalanceMap.end()) {

    if (it->second == whiteBalance.toStdString()) {

      value = it->first;

      break;

    }

    it++;

  }

  err = EdsSetPropertyData(m_camera, kEdsPropID_WhiteBalance, 0, sizeof(value),

                           &value);

  emit(whiteBalanceChangedSignal(whiteBalance));

  return err;

}

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

EdsError Canon::setImageQuality(QString quality) {

  EdsError err = EDS_ERR_OK;

  EdsUInt32 value;

  auto it = m_imageQualityMap.begin();

  while (it != m_imageQualityMap.end()) {

    if (it->second == quality.toStdString()) {

      value = it->first;

      break;

    }

    it++;

  }

  err = EdsSetPropertyData(m_camera, kEdsPropID_ImageQuality, 0, sizeof(value),

                           &value);

  emit(imageQualityChangedSignal(quality));

  m_proxyImageDimensions = TDimension(0, 0);

  m_proxyDpi             = TPointD(0.0, 0.0);

  return err;

}

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

EdsError Canon::setPictureStyle(QString style) {

  EdsError err = EDS_ERR_OK;

  EdsUInt32 value;

  auto it = m_pictureStyleMap.begin();

  while (it != m_pictureStyleMap.end()) {

    if (it->second == style.toStdString()) {

      value = it->first;

      break;

    }

    it++;

  }

  err = EdsSetPropertyData(m_camera, kEdsPropID_PictureStyle, 0, sizeof(value),

                           &value);

  err = EdsSetPropertyData(m_camera, kEdsPropID_PictureStyle, 0, sizeof(value),

                           &value);

  emit(pictureStyleChangedSignal(style));

  return err;

}

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

EdsError Canon::setColorTemperature(QString temp) {

  EdsError err = EDS_ERR_OK;

  EdsUInt32 value;

  value = temp.toInt();

  err = EdsSetPropertyData(m_camera, kEdsPropID_ColorTemperature, 0,

                           sizeof(value), &value);

  err = EdsSetPropertyData(m_camera, kEdsPropID_Evf_ColorTemperature, 0,

                           sizeof(value), &value);

  emit(colorTemperatureChangedSignal(temp));

  return err;

}

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

void Canon::setUseScaledImages(bool on) {

  m_useScaledImages         = on;

  StopMotionUseScaledImages = int(on);

  emit(scaleFullSizeImagesSignal(on));

}

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

bool Canon::downloadImage(EdsBaseRef object) {

  EdsError err        = EDS_ERR_OK;

  EdsStreamRef stream = NULL;

  EdsDirectoryItemInfo dirItemInfo;

  err = EdsGetDirectoryItemInfo(object, &dirItemInfo);

  err = EdsCreateMemoryStream(0, &stream);

  err = EdsDownload(object, dirItemInfo.size, stream);

  EdsDownloadComplete(object);

  // tj code

#ifdef MACOSX

  UInt64 mySize = 0;

#else

  unsigned __int64 mySize = 0;

#endif

  unsigned char* data = NULL;

  err                 = EdsGetPointer(stream, (EdsVoid**)&data);

  err                 = EdsGetLength(stream, &mySize);

  int width, height, pixelFormat;

  // long size;

  int inSubsamp, inColorspace;

  // unsigned long jpegSize;

  tjhandle tjInstance   = NULL;

  unsigned char* imgBuf = NULL;

  tjInstance            = tjInitDecompress();

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

                      &inColorspace);

  pixelFormat = TJPF_BGRX;

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

  int flags = 0;

  flags |= TJFLAG_BOTTOMUP;

  int tempWidth, tempHeight;

  if (m_useScaledImages) {

    int factorsNum;

    tjscalingfactor scalingFactor = {1, 1};

    tjscalingfactor* factor       = tjGetScalingFactors(&factorsNum);

    int intRatio                  = (float)width / (float)height * 100.0;

    int i                         = 0;

    TCamera* camera =

        TApp::instance()->getCurrentScene()->getScene()->getCurrentCamera();

    TDimension res = camera->getRes();

    // find the scaling factor that is at least as big as the current camera

    while (i < factorsNum) {

      scalingFactor = factor[i];

      tempWidth     = TJSCALED(width, scalingFactor);

      if (tempWidth < res.lx && i > 0) {

        scalingFactor = factor[i - 1];

        break;

      }

      i++;

    }

    // make sure the scaling factor has the right aspect ratio

    while (i >= 0) {

      tempWidth  = TJSCALED(width, scalingFactor);

      tempHeight = TJSCALED(height, scalingFactor);

      if ((int)((float)tempWidth / (float)tempHeight * 100.0) == intRatio) {

        break;

      }

      i--;

      scalingFactor = factor[i];

    }

  } else {

    tempWidth  = width;

    tempHeight = height;

  }

  if (m_useScaledImages || !getCurrentImageQuality().contains("Large")) {

    TCamera* camera =

        TApp::instance()->getCurrentScene()->getScene()->getCurrentCamera();

    TDimensionD size       = camera->getSize();

    m_proxyImageDimensions = TDimension(tempWidth, tempHeight);

    double minimumDpi      = std::min(m_proxyImageDimensions.lx / size.lx,

                                 m_proxyImageDimensions.ly / size.ly);

    m_proxyDpi             = TPointD(minimumDpi, minimumDpi);

  }

  tjDecompress2(tjInstance, data, mySize, imgBuf, tempWidth,

                tempWidth * tjPixelSize[pixelFormat], tempHeight, pixelFormat,

                flags);

  StopMotion::instance()->m_newImage = TRaster32P(tempWidth, tempHeight);

  StopMotion::instance()->m_newImage->lock();

  uchar* rawData = StopMotion::instance()->m_newImage->getRawData();

  memcpy(rawData, imgBuf, tempWidth * tempHeight * tjPixelSize[pixelFormat]);

  StopMotion::instance()->m_newImage->unlock();

  tjFree(imgBuf);

  imgBuf = NULL;

  tjDestroy(tjInstance);

  tjInstance = NULL;

  // end tj code

  if (m_useScaledImages) {

    QFile fullImage(StopMotion::instance()->m_tempFile);

    fullImage.open(QIODevice::WriteOnly);

    QDataStream dataStream(&fullImage);

    dataStream.writeRawData((const char*)data, mySize);

    fullImage.close();

  }

  EdsRelease(stream);

  stream = NULL;

  if (object) EdsRelease(object);

  if (err == EDS_ERR_OK) {

    emit(newCanonImageReady());

  }

  return err;

}

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

EdsError Canon::takePicture() {

  EdsError err;

  err = EdsSendCommand(m_camera, kEdsCameraCommand_PressShutterButton,

                       kEdsCameraCommand_ShutterButton_Completely_NonAF);

  err = EdsSendCommand(m_camera, kEdsCameraCommand_PressShutterButton,

                       kEdsCameraCommand_ShutterButton_OFF);

  return err;

}

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

void Canon::extendCameraOnTime() {

  EdsError err;

  EdsInt32 param = 0;

  err = EdsSendCommand(m_camera, kEdsCameraCommand_ExtendShutDownTimer, param);

}

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

EdsError Canon::startCanonLiveView() {

  if (m_camera && m_sessionOpen) {

    EdsError err = EDS_ERR_OK;

    // Get the output device for the live view image

    EdsUInt32 device;

    err = EdsGetPropertyData(m_camera, kEdsPropID_Evf_OutputDevice, 0,

                             sizeof(device), &device);

    // PC live view starts by setting the PC as the output device for the live

    // view image.

    if (err == EDS_ERR_OK) {