#include <openquicktime.h></openquicktime.h>

#include <colormodels.h></colormodels.h>

#include "tiio_movL.h"

#include "traster.h"

#include "trasterimage.h"

#include "tsound.h"

#include "tconvert.h"

#include "trop.h"

#include "tsystem.h"

//#define DUMP_KEYFRAMES

bool IsQuickTimeInstalled() { return true; }

enum {

  QTNoError = 0,

  QTUnableToOpenFile,

  QTUnableToSeekToKeyFrame,

  QTNoSuchFile,

  QTUnsupportedVideoFormat

};

class TQTException : public TImageException {

public:

  TQTException(const TFilePath &fp, int ec)

      : TImageException(fp, getErrorMessage(ec)) {}

  TQTException(const TFilePath &fp, int ec, int v)

      : TImageException(fp, getErrorMessage(ec) + toString(v)) {}

  ~TQTException() {}

  static string getErrorMessage(int ec) {

    switch (ec) {

    case QTNoError:

      return "No error";

    case QTUnableToOpenFile:

      return "unable to open file";

    case QTUnableToSeekToKeyFrame:

      return "unable to seek to keyframe";

    case QTNoSuchFile:

      return "no such file";

    case QTUnsupportedVideoFormat:

      return "Unsupported video format";

    }

    return "unknown error";

  }

};

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

//  TImageWriterMov

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

class TImageWriterMov : public TImageWriter {

public:

  TImageWriterMov(const TFilePath &, int frameIndex, TLevelWriterMov *);

  ~TImageWriterMov() {}

  bool is64bitOutputSupported() { return false; }

private:

  // not implemented

  TImageWriterMov(const TImageWriterMov &);

  TImageWriterMov &operator=(const TImageWriterMov &src);

public:

  void save(const TImageP &);

  int m_frameIndex;

private:

  TLevelWriterMov *m_lwm;

};

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

//  TImageReaderMov

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

class TImageReaderMov : public TImageReader {

public:

  TImageReaderMov(const TFilePath &, int frameIndex, TLevelReaderMov *);

  ~TImageReaderMov() {}

private:

  // not implemented

  TImageReaderMov(const TImageReaderMov &);

  TImageReaderMov &operator=(const TImageReaderMov &src);

public:

  TImageP load();

  int m_frameIndex;

  TDimension getSize() const { return TDimension(m_lrm->m_lx, m_lrm->m_ly); }

  TRect getBBox() const {

    return TRect(0, 0, m_lrm->m_lx - 1, m_lrm->m_ly - 1);

  }

private:

  TLevelReaderMov *m_lrm;

};

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

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

//        TImageWriterMov

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

TImageWriterMov::TImageWriterMov(const TFilePath &path, int frameIndex,

                                 TLevelWriterMov *lwm)

    : TImageWriter(path), m_lwm(lwm), m_frameIndex(frameIndex) {}

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

void TImageWriterMov::save(const TImageP &img) { assert(false); }

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

//        TLevelWriterMov

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

/*

class TWriterInfoMov : public TWriterInfo {

public:

  TWriterInfoMov() : TWriterInfo() { assert(!"Not implemented"); }

  ~TWriterInfoMov() {}

private:

};

*/

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

TLevelWriterMov::TLevelWriterMov(const TFilePath &path, TWriterInfo *info)

    : TLevelWriter(path, info)

//,m_initDone(false)

//,m_rate(25)

//,m_IOError(QTNoError)

//,quality(DM_IMAGE_QUALITY_NORMAL)

//,compression(DM_IMAGE_QT_ANIM)

//,m_writerInfo(new TWriterInfoMov())

{

  assert(false);

}

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

void TLevelWriterMov::saveSoundTrack(TSoundTrack *) {

  throw TImageException(m_path,

                        "TLevelWriterMov::saveSoundTrack not Implemented");

}

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

/*

TWriterInfo *TLevelWriterMov::getWriterInfo() const

{

return m_writerInfo;

}

*/

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

TLevelWriterMov::~TLevelWriterMov() { assert(0); }

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

TImageWriterP TLevelWriterMov::getFrameWriter(TFrameId fid) { assert(false); }

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

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

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

// TImageReaderMov

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

TImageReaderMov::TImageReaderMov(const TFilePath &path, int frameIndex,

                                 TLevelReaderMov *lrm)

    : TImageReader(path), m_lrm(lrm), m_frameIndex(frameIndex) {}

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

using namespace std;

TLevelReaderMov::TLevelReaderMov(const TFilePath &path)

    : TLevelReader(path)

    , m_IOError(QTNoError)

    , m_lastFrameDecoded(-1)

    , m_fileMov(0)

    , m_lx(0)

    , m_ly(0) {

  if (!TFileStatus(path).doesExist()) {

    m_IOError = QTNoSuchFile;

    return;

  }

  m_fileMov = oqt_open((char *)path.getString().c_str());

  if (!m_fileMov) {

    m_IOError = QTUnableToOpenFile;

    return;

  }

  oqt_read_headers(m_fileMov);

  /*

if(!oqt_get_video_track_count(m_fileMov))

{

m_status = !DM_SUCCESS;

m_IOError = QTCheckLibError;

return;

}

*/

  m_lx = oqt_get_video_width(m_fileMov, 0);

  m_ly = oqt_get_video_height(m_fileMov, 0);

  /*

char *vc = oqt_get_video_compressor(m_fileMov, 0);

cout << "video compressor = " << vc[0] << vc[1] << vc[2] << vc[3] << endl;

*/

}

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

TLevelReaderMov::~TLevelReaderMov() {

  if (m_fileMov) oqt_close(m_fileMov);

}

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

TLevelP TLevelReaderMov::loadInfo() {

  TLevelP level;

  if (m_IOError != QTNoError) {

    throw TQTException(m_path, m_IOError);

  }

  if (oqt_supported_video(m_fileMov, 0) == 0) {

    m_IOError = QTUnsupportedVideoFormat;

    throw TQTException(m_path, m_IOError);

  }

  int frameCount = oqt_get_video_length(m_fileMov, 0);

  for (int i = 1; i <= frameCount; i++) level->setFrame(TFrameId(i), TImageP());

#ifdef DUMP_KEYFRAMES

  for (int k = 1; k < frameCount; k++) {

    cout << "frame = " << k << "; keyframe before = "

         << oqt_get_video_keyframe_before(m_fileMov, 0, k)

         << "; keyframe after = "

         << oqt_get_video_keyframe_after(m_fileMov, 0, k) << endl;

  }

#endif

  return level;

}

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

TImageP TImageReaderMov::load() {

  if (m_lrm->m_IOError != QTNoError)

    throw TQTException(m_path, m_lrm->m_IOError);

  TThread::ScopedLock sl(m_lrm->m_mutex);

  int rc;

  TRaster32P ret(m_lrm->m_lx, m_lrm->m_ly);

  unsigned char **data =

      (unsigned char **)malloc(m_lrm->m_ly * sizeof(unsigned char *));

  for (int i = 0; i < m_lrm->m_ly; ++i) {

    unsigned char *ptr = (unsigned char *)ret->pixels(i);

    data[i]            = ptr;

  }

  int cmodel = BC_RGBA8888;

  int frame;

  if (m_lrm->m_lastFrameDecoded != (m_frameIndex - 1)) {

    oqt_int64_t kfb =

        oqt_get_video_keyframe_before(m_lrm->m_fileMov, 0, m_frameIndex);

    assert(kfb <= m_frameIndex);

    rc = oqt_set_video_position(m_lrm->m_fileMov, 0, kfb);

    if (rc) {

      throw TQTException(m_lrm->m_path, QTUnableToSeekToKeyFrame, kfb);

    }

    frame = kfb - 1;

  } else

    frame = m_lrm->m_lastFrameDecoded;

  do {

    rc = oqt_decode_video(m_lrm->m_fileMov, 0, cmodel, data);

    frame++;

  } while (frame != m_frameIndex);

  m_lrm->m_lastFrameDecoded = m_frameIndex;

  ret->yMirror();

  free(data);

  return TRasterImageP(ret);

}

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

TImageReaderP TLevelReaderMov::getFrameReader(TFrameId fid) {

  if (m_IOError != QTNoError) {

    throw TQTException(m_path, m_IOError);

  }

  if (fid.getLetter() != 0) return TImageReaderP(0);

  int index = fid.getNumber() - 1;

  TImageReaderMov *irm = new TImageReaderMov(m_path, index, this);

  return TImageReaderP(irm);

}