#pragma once

#ifndef TNZCAMERA_H

#define TNZCAMERA_H

#include "tcommon.h"

#include "timage.h"

#include "tiio.h"

#include "tthread.h"

#include "toonz/toonzscene.h"

//#define WRITE_LOG_FILE

//#define CHECK_VIDEO_FRAME_INTERVALL

//#define USE_OPENGL_SHARED

#undef DVAPI

#undef DVVAR

#ifdef TCAMERA_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

// forward declaration

class CameraLevelManager;

class CameraConnect;

class QImage;

class CaptureParameters;

class TXshSimpleLevel;

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

// CameraImageViewer

class DVAPI CameraImageViewer {

public:

  CameraImageViewer() {}

  virtual void setImage(TRasterP ras) = 0;

};

// void processImage(unsigned char* m_ptr, int camWidth, int camHeight);

#ifndef USE_OPENGL_SHARED

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

// ImageProcessing

class ImageProcessing : public TThread::Runnable {

  Q_OBJECT

  unsigned char *m_ptr;

  int m_camWidth;

  int m_camHeight;

  enum AcquireType { ACQUIRE_FRAME, ACQUIRE_WHITE_IMAGE, NONE } m_acquireType;

public:

  ImageProcessing();

  ~ImageProcessing();

  void setData(unsigned char *dataPtr);

  void setImageSize(int camWidth, int camHeight) {

    m_camWidth  = camWidth;

    m_camHeight = camHeight;

  }

  void run();

  void onFinished(TThread::RunnableP task);

};

#endif

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

// CameraTest

class DVAPI TnzCamera : public QObject {

  Q_OBJECT

  CameraImageViewer *m_viewer;

  CameraLevelManager *m_cameraLevelManager;

  CameraConnect *m_cameraConnection;

  QList<qstring> m_devices;</qstring>

  bool m_isCameraConnected;

  bool m_acquireFrame;

  bool m_acquireWhiteImage;

  ToonzScene *m_scene;

  TDimension m_deviceResolution;

  TPixel32 m_linesColor;

  bool m_startedImageProcessing;

#ifndef USE_OPENGL_SHARED

  TThread::Executor *m_imageProcessingExecutor;

#else

#endif

  bool m_freeze;

#ifdef CHECK_VIDEO_FRAME_INTERVALL

  double m_videoFrameIntervall;

#endif

  TnzCamera();

public:

  static TnzCamera *instance();

  bool initTnzCamera();

  ~TnzCamera();

#ifdef USE_OPENGL_SHARED

  void notifyImageChanged(int camWidth, int camHeight, unsigned char *ptr) {

    Q_EMIT imageChanged(camWidth, camHeight, ptr);

  }

#else

  TThread::Executor *getImageProcessingExecutor() const {

    return m_imageProcessingExecutor;

  }

#endif

  bool &startedImageProcessing() { return m_startedImageProcessing; }

  bool isFreezed() const { return m_freeze; }

  void freeze(bool freeze) { m_freeze = freeze; }

  void setScene(ToonzScene *scene);

  TDimension getDeviceResolution() const { return m_deviceResolution; }

  CaptureParameters *getCaptureParameters() const;

  TXshSimpleLevel *getCurrentLevel() const;

  TFrameId getCurrentFid() const;

#ifdef CHECK_VIDEO_FRAME_INTERVALL

  double getVideoFrameIntervall() const { return m_videoFrameIntervall; }

  void setVideoFrameIntervall(double intervall);

#endif

  bool isAcquireFrame() const { return m_acquireFrame; }

  bool isAcquireWhiteImage() const { return m_acquireWhiteImage; }

  void setViewImage(TRaster32P img);

  void setAcquiredImage(TRaster32P img);

  void setAcquiredWhiteImage(TRasterGR8P img);

  TRasterGR8P getWhiteImage();

  bool isCameraConnected() const { return m_isCameraConnected; }

  void updateDeviceResolution(int width, int height);

  bool setCurrentImageSize(int width, int height);

  int getImageWidth() const;

  int getImageHeight() const;

  int getContrast() const;

  int getBrightness() const;

  bool isSubtractWhiteImage() const;

  void removeWhiteImage();

  bool getUpsideDown() const;

  bool saveWithoutAlpha() const;

  TPixel32 getLinesColor() const { return m_linesColor; }

  void setLinesColor(TPixel32 color) { m_linesColor = color; }

  bool findConnectedCameras(QList<qstring> &cameras);</qstring>

  bool cameraConnect(wstring deviceName);

  void cameraDisconnect();

  bool onViewfinder(CameraImageViewer *viewer);

  bool onRelease(TFrameId frameId, wstring fileName, int row = 0, int col = 0,

                 bool keepWhiteImage = false);

  int saveType() const;

  void setSaveType(int value);

  // Utility function

  void keepWhiteImage();

  void notifyCameraShutDown() { Q_EMIT cameraShutDown(); }

  void notifyAbort() { Q_EMIT abort(); }

#ifdef USE_OPENGL_SHARED

protected Q_SLOTS:

  void processImage(int camWidth, int camHeight, unsigned char *ptr);

#endif

Q_SIGNALS:

  void cameraShutDown();

  void abort();

  void devicePropChanged();

  void captureFinished();

  void imageViewChanged(TRaster *ras);

  void imageSizeUpdated();

#ifdef USE_OPENGL_SHARED

  void imageChanged(int camWidth, int camHeight, unsigned char *ptr);

#endif

};

#ifdef WRITE_LOG_FILE

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

// LogWriter

#include "tfilepath_io.h"

class LogWriter  // Singleton

{

  Tofstream m_os;

public:

  LogWriter(TFilePath fp);

  void write(QString str);

public:

  static LogWriter *instance();

  ~LogWriter();

};

#endif

#endif  // TNZCAMERA_H