322 lines
7.5 KiB
C++
322 lines
7.5 KiB
C++
|
|
||
|
|
||
|
#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);
|
||
|
}
|