#include "tiio_movX.h"

#include "traster.h"

#include "trasterimage.h"

#include "tsound.h"

#ifdef NOTE

Supportato solo RGBM32, sotto NT sarebbe possibile supportare anche 1bpp, ma

																			  mancano i TRaster opportuni...

	viene supportata

	solo(LA PRIMA) traccia video !!!!

#endif

	//namespace {

	enum QTLibError {

		QTNoError = 0x0000,

		QTCantCreateParams = 0x0101,

		QTCantSetParams = 0x0102,

		QTPixelTypeError = 0x0103,

		QTCheckLibError = 0x0104

	};

string buildQTErrorString(int ec)

{

	switch (ec) {

	case QTCantCreateParams:

		return "Unable to create default params";

	case QTCantSetParams:

		return "Unable to set default params";

	case QTPixelTypeError:

		return "Unsupported pixel type";

	case QTCheckLibError:

		return mvGetErrorStr(mvGetErrno());

	default:

		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)

{

	TRasterImageP image(img);

	int lx = image->getRaster()->getLx();

	int ly = image->getRaster()->getLy();

	void *buffer = image->getRaster()->getRawData();

	int pixSize = image->getRaster()->getPixelSize();

	if (pixSize != 4)

		throw TImageException(m_lwm->getFilePath(), "Unsupported pixel type");

	if (!m_lwm->m_initDone) {

		DMparams *imageTrackParams;

		if (dmParamsCreate(&imageTrackParams) != DM_SUCCESS)

			throw TImageException(m_lwm->getFilePath(), "Unable to create image track params");

		if (dmSetImageDefaults(imageTrackParams, lx, ly, DM_IMAGE_PACKING_XRGB) != DM_SUCCESS) {

			dmParamsDestroy(imageTrackParams);

			throw TImageException(m_lwm->getFilePath(), "Unable to set image defaults");

		}

		if (dmParamsSetFloat(imageTrackParams, DM_IMAGE_RATE, (double)m_lwm->m_rate) != DM_SUCCESS) {

			dmParamsDestroy(imageTrackParams);

			throw TImageException(m_lwm->getFilePath(), "Unable to set frame rate");

		}

		if (dmParamsSetEnum(imageTrackParams, DM_IMAGE_ORIENTATION, DM_TOP_TO_BOTTOM) != DM_SUCCESS) {

			dmParamsDestroy(imageTrackParams);

			throw TImageException(m_lwm->getFilePath(), "Unable to set frame rate");

		}

		if (dmParamsSetFloat(imageTrackParams, DM_IMAGE_QUALITY_SPATIAL, m_lwm->quality) != DM_SUCCESS) {

			dmParamsDestroy(imageTrackParams);

			throw TImageException(m_lwm->getFilePath(), "Unable to set quality");

		}

		if (dmParamsSetString(imageTrackParams, DM_IMAGE_COMPRESSION, m_lwm->compression) != DM_SUCCESS) {

			dmParamsDestroy(imageTrackParams);

			throw TImageException(m_lwm->getFilePath(), "Unable to set compression");

		}

		if (mvAddTrack(m_lwm->id, DM_IMAGE, imageTrackParams, NULL, &(m_lwm->imageTrack)) == DM_FAILURE) {

			dmParamsDestroy(imageTrackParams);

			throw TImageException(m_lwm->getFilePath(), "Unable to add image track to movie");

		}

		dmParamsDestroy(imageTrackParams);

		m_lwm->m_initDone = true;

	}

	if (mvInsertFrames(m_lwm->imageTrack, m_frameIndex, 1,

					   lx * ly * pixSize, buffer) != DM_SUCCESS) {

		throw TImageException(m_lwm->getFilePath(), "Unable to write image to movie");

	}

}

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

//        TLevelWriterMov

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

class TWriterInfoMov : public TWriterInfo

{

public:

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

	~TWriterInfoMov() {}

private:

};

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

TLevelWriterMov::TLevelWriterMov(const TFilePath &path)

	: TLevelWriter(path), m_initDone(false), m_rate(25), m_IOError(QTNoError), quality(DM_IMAGE_QUALITY_NORMAL), compression(DM_IMAGE_QT_ANIM), m_writerInfo(new TWriterInfoMov())

{

	DMparams *movieParams;

	if (dmParamsCreate(&movieParams) != DM_SUCCESS) {

		m_IOError = QTCantCreateParams;

		return;

	}

	if (mvSetMovieDefaults(movieParams, MV_FORMAT_QT) != DM_SUCCESS) {

		dmParamsDestroy(movieParams);

		m_IOError = QTCantCreateParams;

		return;

	}

	if (mvCreateFile(path.getFullPath().c_str(),

					 movieParams, NULL, &id) == DM_FAILURE) {

		static char m[1024];

		dmParamsDestroy(movieParams);

		m_IOError = QTCheckLibError;

		return;

	}

	dmParamsDestroy(movieParams);

}

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

void TLevelWriterMov::saveSoundTrack(TSoundTrack *)

{

	throw TImageException(m_path, "TLevelWriterMov::saveSoundTrack not Implemented");

}

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

TWriterInfo *TLevelWriterMov::getWriterInfo() const

{

	return m_writerInfo;

}

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

TLevelWriterMov::~TLevelWriterMov()

{

	bool rc = (mvClose(id) == DM_SUCCESS);

	//if (!rc)

	//  throw TImageException(getFilePath(), "Error closing mov file");

}

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

TImageWriterP TLevelWriterMov::getFrameWriter(TFrameId fid)

{

	if (m_IOError)

		throw TImageException(m_path, buildQTErrorString(m_IOError));

	if (fid.getLetter() != 0)

		return TImageWriterP(0);

	int index = fid.getNumber() - 1;

	TImageWriterMov *iwm = new TImageWriterMov(m_path, index, this);

	return TImageWriterP(iwm);

}

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

TLevelReaderMov::TLevelReaderMov(const TFilePath &path)

	: TLevelReader(path), IOError(QTNoError)

{

	m_status = mvOpenFile(path.getFullPath().c_str(), O_RDONLY, &movie);

	if (m_status != DM_SUCCESS) {

		IOError = QTCheckLibError;

		return;

	}

	track = 0;

	m_status = mvFindTrackByMedium(movie, DM_IMAGE, &track);

	if (m_status != DM_SUCCESS) {

		IOError = QTCheckLibError;

		return;

	}

	m_lx = mvGetImageWidth(track);

	m_ly = mvGetImageHeight(track);

	DMpacking packing = mvGetImagePacking(track);

	if (packing != DM_IMAGE_PACKING_XRGB) {

		IOError = QTPixelTypeError;

		return;

	}

}

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

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

// TImageReaderMov

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

TImageReaderMov::TImageReaderMov(const TFilePath &path, int frameIndex, TLevelReaderMov *lrm)

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

{

}

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

TLevelReaderMov::~TLevelReaderMov()

{

	mvClose(movie);

}

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

TLevelP TLevelReaderMov::loadInfo()

{

	TLevelP level;

	if (IOError != QTNoError)

		throw TImageException(m_path, buildQTErrorString(IOError));

	if (!track)

		throw TImageException(getFilePath().getFullPath().c_str(), " error reading info");

	MVframe nFrames = mvGetTrackLength(track);

	if (nFrames == -1)

		return level;

	for (int i = 1; i <= nFrames; i++)

		level->setFrame(TFrameId(i), TImageP());

	return level;

}

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

TImageP TImageReaderMov::load()

{

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

	DMstatus status = mvReadFrames(m_lrm->track, m_frameIndex, 1, m_lrm->m_lx * m_lrm->m_ly * 4, ret->getRawData());

	if (status != DM_SUCCESS) {

		throw TImageException(getFilePath().getFullPath().c_str(), mvGetErrorStr(mvGetErrno()));

	}

	// getImage()->setRaster(ret);

	return TRasterImageP(ret);

}

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

TImageReaderP TLevelReaderMov::getFrameReader(TFrameId fid)

{

	if (IOError != QTNoError)

		throw TImageException(m_path, buildQTErrorString(IOError));

	if (fid.getLetter() != 0)

		return TImageReaderP(0);

	int index = fid.getNumber() - 1;

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

	return TImageReaderP(irm);

}