tahoma2d/toonz/sources/image/mov/tiio_movL.cpp

#include <openquicktime.h>
#include <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);
}