// TnzCore includes
#include "tsystem.h"
#include "tstopwatch.h"
#include "tthreadmessage.h"
#include "timagecache.h"
#include "tlevel_io.h"
#include "trasterimage.h"
#include "timageinfo.h"
#include "trop.h"
#include "tsop.h"
 
// TnzLib includes
#include "toonz/toonzscene.h"
#include "toonz/sceneproperties.h"
#include "toonz/txsheet.h"
#include "toonz/tcamera.h"
#include "toonz/preferences.h"
#include "toonz/trasterimageutils.h"
#include "toonz/levelupdater.h"
#include "toutputproperties.h"
 
// tcg includes
#include "tcg/tcg_macros.h"
 
// Qt includes
#include <QCoreApplication>
 
#include "toonz/movierenderer.h"
 
//**************************************************************************
//    Local Namespace  stuff
//**************************************************************************
 
namespace
{
 
int RenderSessionId = 0;
 
//---------------------------------------------------------
 
void addMark(const TRasterP &mark, TRasterImageP img)
{
	TRasterP raster = img->getRaster();
 
	if (raster->getLx() >= mark->getLx() && raster->getLy() >= mark->getLy()) {
		TRasterP ras = raster->clone();
 
		int borderx = troundp(0.035 * (ras->getLx() - mark->getLx()));
		int bordery = troundp(0.035 * (ras->getLy() - mark->getLy()));
 
		TRect rect = TRect(borderx, bordery, borderx + mark->getLx() - 1, bordery + mark->getLy() - 1);
		TRop::over(ras->extract(rect), mark);
 
		img->setRaster(ras);
	}
}
 
//---------------------------------------------------------
 
void getRange(ToonzScene *scene, bool isPreview, int &from, int &to)
{
	TSceneProperties *sprop = scene->getProperties();
 
	int step;
	if (isPreview)
		sprop->getPreviewProperties()->getRange(from, to, step);
	else
		sprop->getOutputProperties()->getRange(from, to, step);
 
	if (to < 0) {
		TXsheet *xs = scene->getXsheet();
 
		// NOTE: Use of numeric_limits::min is justified since the type is *INTERGRAL*.
		from = (std::numeric_limits<int>::max)(), to = (std::numeric_limits<int>::min)();
 
		for (int k = 0; k < xs->getColumnCount(); ++k) {
			int r0, r1;
			xs->getCellRange(k, r0, r1);
 
			from = tmin(from, r0), to = tmax(to, r1);
		}
	}
}
 
//---------------------------------------------------------
 
QString getPreviewName(unsigned long renderSessionId)
{
	return "previewed" + QString::number(renderSessionId) + ".noext";
}
 
} // namespace
 
//**************************************************************************
//    MovieRenderer::Imp  definition
//**************************************************************************
 
class MovieRenderer::Imp : public TRenderPort, public TSmartObject
{
public:
	ToonzScene *m_scene;
	TRenderer m_renderer;
	TFilePath m_fp;
 
	TRenderSettings m_renderSettings;
	TDimension m_frameSize;
	double m_xDpi, m_yDpi;
 
	std::set<MovieRenderer::Listener *> m_listeners;
	std::auto_ptr<LevelUpdater> m_levelUpdaterA, m_levelUpdaterB;
	TSoundTrackP m_st;
 
	std::map<double, std::pair<TRasterP, TRasterP>> m_toBeSaved;
	std::vector<pair<double, TFxPair>> m_framesToBeRendered;
	std::string m_renderCacheId;
	/*--- 同じラスタのキャッシュを使いまわすとき、
		最初のものだけガンマをかけ、以降はそれを使いまわすようにする。
	---*/
	std::map<double, bool> m_toBeAppliedGamma;
 
	TThread::Mutex m_mutex;
 
	int m_renderSessionId;
	long m_whiteSample;
 
	int m_nextFrameIdxToSave;
	int m_savingThreadsCount;
	bool m_firstCompletedRaster;
	bool m_failure;
	bool m_cacheResults;
	bool m_preview;
	bool m_movieType;
 
public:
	Imp(ToonzScene *scene, const TFilePath &moviePath, int threadCount, bool cacheResults);
	~Imp();
 
	// TRenderPort methods
 
	void onRenderRasterCompleted(const RenderData &renderData);
	void onRenderFailure(const RenderData &renderData, TException &e);
 
	/*-- キャンセル時にはm_overallRenderedRegionを更新しない --*/
	virtual void onRenderFinished(bool isCanceled = false);
 
	void doRenderRasterCompleted(const RenderData &renderData);
	void doPreviewRasterCompleted(const RenderData &renderData);
 
	// Helper methods
 
	void prepareForStart();
	void addSoundtrack(int r0, int r1, double fps);
	void postProcessImage(const TRasterImageP &img, bool has64bitOutputSupport, const TRasterP &mark, int frame);
 
	//! Saves the specified rasters at the specified time; returns whether the frames were successfully saved, and
	//! the associated time-adjusted level frame.
	std::pair<bool, int> saveFrame(double frame, const std::pair<TRasterP, TRasterP> &rasters);
	std::string getRenderCacheId();
};
 
//---------------------------------------------------------
 
MovieRenderer::Imp::Imp(ToonzScene *scene,
						const TFilePath &moviePath,
						int threadCount,
						bool cacheResults)
	: m_scene(scene), m_renderer(threadCount), m_fp(moviePath), m_frameSize(scene->getCurrentCamera()->getRes()), m_xDpi(72), m_yDpi(72), m_renderSessionId(RenderSessionId++), m_nextFrameIdxToSave(0), m_savingThreadsCount(0), m_whiteSample(0), m_firstCompletedRaster(true) //< I know, sounds weird - it's just set to false
	  ,
	  m_failure(false) //  AFTER the first completed raster gets processed
	  ,
	  m_cacheResults(cacheResults), m_preview(moviePath.isEmpty()), m_movieType(isMovieType(moviePath))
{
	m_renderCacheId = m_fp.withName(m_fp.getName() + "#RENDERID" + QString::number(m_renderSessionId).toStdString())
						  .getLevelName();
 
	m_renderer.addPort(this);
}
 
//---------------------------------------------------------
 
MovieRenderer::Imp::~Imp()
{
	m_renderer.removePort(this); // Please, note: a TRenderer instance is currently a shared-pointer-like
} // object to a private worker. *That* object may outlive the TRenderer instance.
 
//---------------------------------------------------------
 
void MovieRenderer::Imp::prepareForStart()
{
	struct locals {
		static void eraseUncompatibleExistingLevel(const TFilePath &fp, const TDimension &imageSize) // nothrow
		{
			assert(!fp.isEmpty());
 
			if (TSystem::doesExistFileOrLevel(fp)) {
				bool remove = false;
 
				// In case the raster specifics are different from those of a currently
				// existing movie, erase it
				try {
					TLevelReaderP lr(fp);
					lr->loadInfo();
 
					const TImageInfo *info = lr->getImageInfo();
					if (!info || info->m_lx != imageSize.lx || info->m_ly != imageSize.ly)
						TSystem::removeFileOrLevel(fp); // nothrow
				} catch (...) {
					// Same if the level could not be read/opened
					TSystem::removeFileOrLevel(fp); // nothrow
				}
 
				// NOTE: The level removal procedure could still fail.
				// In this case, no signaling takes place. The level readers will throw
				// when the time to write on the file comes, leading to a render failure.
			}
		}
	};
 
	TOutputProperties *oprop = m_scene->getProperties()->getOutputProperties();
	double frameRate = (double)oprop->getFrameRate();
 
	/*-- Frame rate の stretch --*/
	double stretchFactor = oprop->getRenderSettings().m_timeStretchTo / oprop->getRenderSettings().m_timeStretchFrom;
	frameRate *= stretchFactor;
 
	// Get the shrink
	int shrinkX = m_renderSettings.m_shrinkX, shrinkY = m_renderSettings.m_shrinkY;
 
	//Build the render area
	TPointD cameraPos(-0.5 * m_frameSize.lx, -0.5 * m_frameSize.ly);
	TDimensionD cameraRes(double(m_frameSize.lx) / shrinkX, double(m_frameSize.ly) / shrinkY);
	TDimension cameraResI(cameraRes.lx, cameraRes.ly);
 
	TRectD renderArea(cameraPos.x, cameraPos.y, cameraPos.x + cameraRes.lx, cameraPos.y + cameraRes.ly);
	setRenderArea(renderArea);
 
	if (!m_fp.isEmpty()) {
		try // Construction of a LevelUpdater may throw (well, almost ANY operation on a LevelUpdater
		{   // could throw). But due to backward compatibility this function is assumed to be non-throwing.
			if (!m_renderSettings.m_stereoscopic) {
				locals::eraseUncompatibleExistingLevel(m_fp, cameraResI);
 
				m_levelUpdaterA.reset(new LevelUpdater(m_fp, oprop->getFileFormatProperties(m_fp.getType())));
				m_levelUpdaterA->getLevelWriter()->setFrameRate(frameRate);
			} else {
				TFilePath leftFp = m_fp.withName(m_fp.getName() + "_l");
				TFilePath rightFp = m_fp.withName(m_fp.getName() + "_r");
 
				locals::eraseUncompatibleExistingLevel(leftFp, cameraResI);
				locals::eraseUncompatibleExistingLevel(rightFp, cameraResI);
 
				m_levelUpdaterA.reset(new LevelUpdater(leftFp, oprop->getFileFormatProperties(leftFp.getType())));
				m_levelUpdaterA->getLevelWriter()->setFrameRate(frameRate);
 
				m_levelUpdaterB.reset(new LevelUpdater(rightFp, oprop->getFileFormatProperties(rightFp.getType())));
				m_levelUpdaterB->getLevelWriter()->setFrameRate(frameRate);
			}
		} catch (...) {
			// If we get here, it's because one of the LevelUpdaters could not be created. So, let's say
			// that if one could not be created, then ALL OF THEM couldn't (ie saving is not possible at all).
			m_levelUpdaterA.reset();
			m_levelUpdaterB.reset();
		}
	}
}
 
//---------------------------------------------------------
 
void MovieRenderer::Imp::addSoundtrack(int r0, int r1, double fps)
{
	TCG_ASSERT(r0 <= r1, return );
 
	TXsheet::SoundProperties *prop = new TXsheet::SoundProperties(); // Ownership will be surrendered ...
	prop->m_frameRate = fps;
 
	TSoundTrack *snd = m_scene->getXsheet()->makeSound(prop); // ... here
	if (!snd) {
		// No soundtrack
		m_whiteSample = (r1 - r0 + 1) * 918; // 918?? wtf... I don't think it has
		return;								 // any arcane meaning - but i'm not touching it.
	}										 // My impression would be that... no sound implies
											 // no access to m_whiteSample, no?
 
	double samplePerFrame = snd->getSampleRate() / fps;
 
	// Extract the useful part of scene soundtrack
	TSoundTrackP snd1 = snd->extract((TINT32)(r0 * samplePerFrame),
									 (TINT32)(r1 * samplePerFrame));
	assert(!m_st);
	if (!m_st) {
		// First, add white sound before the 'from' instant
		m_st = TSoundTrack::create(snd1->getFormat(), m_whiteSample);
		m_whiteSample = 0; // Why?  Probably being pedantic here... I guess
	}
 
	// Then, add the rest
	TINT32 fromSample = m_st->getSampleCount();
	TINT32 numSample = tmax(TINT32((r1 - r0 + 1) * samplePerFrame),
							snd1->getSampleCount());
 
	m_st = TSop::insertBlank(m_st, fromSample, numSample + m_whiteSample);
	m_st->copy(snd1, TINT32(fromSample + m_whiteSample));
 
	m_whiteSample = 0;
}
 
//---------------------------------------------------------
 
void MovieRenderer::Imp::onRenderRasterCompleted(const RenderData &renderData)
{
	if (m_preview)
		doPreviewRasterCompleted(renderData);
	else
		doRenderRasterCompleted(renderData);
}
 
//---------------------------------------------------------
 
void MovieRenderer::Imp::postProcessImage(const TRasterImageP &img, bool has64bitOutputSupport, const TRasterP &mark, int frame)
{
	img->setDpi(m_xDpi, m_yDpi);
 
	if (img->getRaster()->getPixelSize() == 8 && !has64bitOutputSupport) {
		TRaster32P aux(img->getRaster()->getLx(), img->getRaster()->getLy());
		TRop::convert(aux, img->getRaster());
		img->setRaster(aux);
	}
 
	if (mark)
		addMark(mark, img);
 
	if (Preferences::instance()->isSceneNumberingEnabled())
		TRasterImageUtils::addGlobalNumbering(img, m_scene->getSceneName(), frame);
}
 
//---------------------------------------------------------------------
 
std::pair<bool, int> MovieRenderer::Imp::saveFrame(double frame, const std::pair<TRasterP, TRasterP> &rasters)
{
	bool success = false;
 
	// Build the frame number to write to
	double stretchFac = double(m_renderSettings.m_timeStretchTo) / m_renderSettings.m_timeStretchFrom;
 
	int fr = (stretchFac != 1) ? tround(frame * stretchFac) : int(frame);
	TFrameId fid(fr + 1);
 
	if (m_levelUpdaterA.get()) {
		assert(m_levelUpdaterB.get() || !rasters.second);
 
		// Analyze writer
		bool has64bitOutputSupport = false;
		{
			if (TImageWriterP writerA = m_levelUpdaterA->getLevelWriter()->getFrameWriter(fid))
				has64bitOutputSupport = writerA->is64bitOutputSupported();
 
			// NOTE: If the writer could not be retrieved, the updater will throw.
			// Failure will be catched then.
		}
 
		// Prepare the images to be flushed
		TRasterP rasterA = rasters.first, rasterB = rasters.second;
		assert(rasterA);
 
		/*--- 同じラスタのキャッシュを使いまわすとき、
		最初のものだけガンマをかけ、以降はそれを使いまわすようにする。
	---*/
		if (m_renderSettings.m_gamma != 1.0 && m_toBeAppliedGamma[frame]) {
			TRop::gammaCorrect(rasterA, m_renderSettings.m_gamma);
			if (rasterB)
				TRop::gammaCorrect(rasterB, m_renderSettings.m_gamma);
		}
 
		// Flush images
		try {
			TRasterImageP imgA(rasterA);
			postProcessImage(imgA, has64bitOutputSupport, m_renderSettings.m_mark, fid.getNumber());
 
			m_levelUpdaterA->update(fid, imgA);
 
			if (rasterB) {
				TRasterImageP imgB(rasterB);
				postProcessImage(imgB, has64bitOutputSupport, m_renderSettings.m_mark, fid.getNumber());
 
				m_levelUpdaterB->update(fid, imgB);
			}
 
			// Should no more throw from here on
 
			if (m_cacheResults) {
				if (imgA->getRaster()->getPixelSize() == 8) {
					// Convert 64-bit images to 32 - cached images are supposed to be 32-bit
					TRaster32P aux(imgA->getRaster()->getLx(), imgA->getRaster()->getLy());
 
					TRop::convert(aux, imgA->getRaster());
					imgA->setRaster(aux);
				}
 
				TImageCache::instance()->add(m_renderCacheId + toString(fid.getNumber()), imgA);
			}
 
			success = true;
		} catch (...) {
			// Nothing. The images could not be saved for whatever reason.
			// Failure is reported.
		}
	}
 
	return std::make_pair(success, fr);
}
 
//---------------------------------------------------------------------
 
void MovieRenderer::Imp::doRenderRasterCompleted(const RenderData &renderData)
{
	assert(!(m_cacheResults && m_levelUpdaterB.get())); // Cannot cache results on stereoscopy
 
	QMutexLocker locker(&m_mutex);
 
	// Build soundtrack at the first time a frame is completed - and the filetype is that of a movie.
	if (m_firstCompletedRaster && m_movieType && !m_st) {
		int from, to;
		getRange(m_scene, false, from, to);
 
		TLevelP oldLevel(m_levelUpdaterA->getInputLevel());
		if (oldLevel) {
			from = tmin(from, oldLevel->begin()->first.getNumber() - 1);
			to = tmax(to, (--oldLevel->end())->first.getNumber() - 1);
		}
 
		addSoundtrack(from, to, m_scene->getProperties()->getOutputProperties()->getFrameRate());
 
		if (m_st) {
			m_levelUpdaterA->getLevelWriter()->saveSoundTrack(m_st.getPointer());
			if (m_levelUpdaterB.get())
				m_levelUpdaterB->getLevelWriter()->saveSoundTrack(m_st.getPointer());
		}
	}
 
	// Output frames must be *cloned*, since the supplied rasters will be overwritten by m_renderer
	TRasterP toBeSavedRasA = renderData.m_rasA->clone();
	TRasterP toBeSavedRasB = renderData.m_rasB ? renderData.m_rasB->clone() : TRasterP();
 
	m_toBeSaved[renderData.m_frames[0]] = std::make_pair(toBeSavedRasA, toBeSavedRasB);
 
	m_toBeAppliedGamma[renderData.m_frames[0]] = true;
 
	// Prepare the cluster's frames to be saved (possibly in the future)
	std::vector<double>::const_iterator jt;
	for (jt = renderData.m_frames.begin(), ++jt; jt != renderData.m_frames.end(); ++jt) {
		m_toBeSaved[*jt] = std::make_pair(toBeSavedRasA, toBeSavedRasB);
		m_toBeAppliedGamma[*jt] = false;
	}
 
	// Attempt flushing as many frames as possible to the level updater(s)
	while (!m_toBeSaved.empty()) {
		std::map<double, std::pair<TRasterP, TRasterP>>::iterator ft = m_toBeSaved.begin();
 
		// In the *movie type* case, frames must be saved sequentially.
		// If the frame is not the next one in the sequence, wait until *that* frame is available.
		if (m_movieType && (ft->first != m_framesToBeRendered[m_nextFrameIdxToSave].first))
			break;
 
		// This thread will be the one processing ft - remove it from the map to prevent another
		// thread from interfering
		double frame = ft->first;
		std::pair<TRasterP, TRasterP> rasters = ft->second;
 
		++m_nextFrameIdxToSave;
		m_toBeSaved.erase(ft);
 
		// Save current frame
		std::pair<bool, int> savedFrame;
		{
			// Time the saving procedure
			struct SaveTimer {
				int &m_count;
				SaveTimer(int &count) : m_count(count)
				{
					if (m_count++ == 0)
						TStopWatch::global(0).start();
				}
				~SaveTimer()
				{
					if (--m_count == 0)
						TStopWatch::global(0).stop();
				}
			} saveTimer(m_savingThreadsCount);
 
			// Unlock the mutex only in case this is NOT a movie type. Single images can be saved concurrently.
			struct MutexUnlocker {
				QMutexLocker *m_locker;
				~MutexUnlocker()
				{
					if (m_locker)
						m_locker->relock();
				}
			} unlocker = {m_movieType ? (QMutexLocker *)0 : (locker.unlock(), &locker)};
 
			savedFrame = saveFrame(frame, rasters);
		}
 
		// Report status and deal with responses
		bool okToContinue = true;
 
		std::set<MovieRenderer::Listener *>::iterator lt = m_listeners.begin();
 
		if (savedFrame.first) {
			for (; lt != m_listeners.end(); ++lt)
				okToContinue &= (*lt)->onFrameCompleted(savedFrame.second);
		} else {
			for (; lt != m_listeners.end(); ++lt) {
				TException e;
				okToContinue &= (*lt)->onFrameFailed(savedFrame.second, e);
			}
		}
 
		if (!okToContinue) {
			// Some listener invoked termination of the render procedure. It seems it's their right
			// to do so. I wonder what happens if two listeners would disagree on the matter...
			// BTW stop the rendering, alright.
 
			{
				int from, to;
				getRange(m_scene, false, from, to); // It's ok since cancels can only happen from Toonz...
 
				for (int i = from; i < to; i++)
					TImageCache::instance()->remove(m_renderCacheId + toString(i + 1));
			}
 
			m_renderer.stopRendering();
 
			m_levelUpdaterA.reset(); // No more saving. Further attempts to save images
			m_levelUpdaterB.reset(); // will be rejected and treated as failures.
		}
	}
 
	m_firstCompletedRaster = false;
}
 
//---------------------------------------------------------
 
void MovieRenderer::Imp::doPreviewRasterCompleted(const RenderData &renderData)
{
	// Most probably unused now. I'm not reviewing this.
 
	assert(!m_levelUpdaterA.get());
 
	QMutexLocker sl(&m_mutex);
 
	QString name = getPreviewName(m_renderSessionId);
 
	TRasterP ras = renderData.m_rasA->clone();
	if (renderData.m_rasB) {
		assert(m_renderSettings.m_stereoscopic);
		TRop::makeStereoRaster(ras, renderData.m_rasB);
	}
 
	TRasterImageP img(ras);
	img->setDpi(m_xDpi, m_yDpi);
 
	try {
		if (renderData.m_info.m_mark != TRasterP())
			addMark(renderData.m_info.m_mark, img);
 
		if (img->getRaster()->getPixelSize() == 8) {
			TRaster32P aux(img->getRaster()->getLx(), img->getRaster()->getLy());
			TRop::convert(aux, img->getRaster());
			img->setRaster(aux);
		}
 
		QString frameName = name + QString::number(renderData.m_frames[0] + 1);
 
		TImageCache::instance()->add(frameName.toStdString(), img);
 
		//controlla se ci sono frame(uguali ad altri) da mettere in cache
 
		std::vector<double>::const_iterator jt;
		for (jt = renderData.m_frames.begin(), ++jt; jt != renderData.m_frames.end(); ++jt) {
			frameName = name + QString::number(*jt + 1);
			TImageCache::instance()->add(frameName.toStdString(), img);
		}
	} catch (...) {
	}
 
	std::set<MovieRenderer::Listener *>::iterator listenerIt = m_listeners.begin();
 
	bool okToContinue = true;
 
	for (; listenerIt != m_listeners.end(); ++listenerIt)
		okToContinue &= (*listenerIt)->onFrameCompleted(renderData.m_frames[0]);
 
	if (!okToContinue) {
		// Svuoto la cache nel caso in cui si esce dal render prima della fine
		int from, to;
		getRange(m_scene, true, from, to);
		for (int i = from; i < to; i++) {
			QString frameName = name + QString::number(i + 1);
			TImageCache::instance()->remove(frameName.toStdString());
		}
 
		m_renderer.stopRendering();
	}
 
	m_firstCompletedRaster = false;
}
 
//---------------------------------------------------------
 
void MovieRenderer::Imp::onRenderFailure(const RenderData &renderData, TException &e)
{
	QMutexLocker sl(&m_mutex); // Lock as soon as possible.
							   // No sense making it later in this case!
	m_failure = true;
 
	// If the saver object has already been destroyed - or it was never
	// created to begin with, nothing to be done
	if (!m_levelUpdaterA.get())
		return; // The preview case would fall here
 
	// Flush out as much as we can of the frames that were already rendered
	m_toBeSaved[0.0] = std::make_pair(TRasterP(), TRasterP()); // ?? Why is this ??
 
	std::map<double, std::pair<TRasterP, TRasterP>>::iterator it = m_toBeSaved.begin();
	while (it != m_toBeSaved.end()) {
		if (m_movieType && (it->first != m_framesToBeRendered[m_nextFrameIdxToSave].first))
			break;
 
		// o_o!
		// I would have expected that at least those frames that were computed could
		// attempt saving! Why is this not addressed? They're even marked as 'failed'!
 
		double stretchFac = (double)renderData.m_info.m_timeStretchTo / renderData.m_info.m_timeStretchFrom;
 
		int fr;
		if (stretchFac != 1)
			fr = tround(it->first * stretchFac);
		else
			fr = (int)it->first;
 
		// No saving? Really?
 
		std::set<MovieRenderer::Listener *>::iterator lt = m_listeners.begin();
		bool okToContinue = true;
 
		for (; lt != m_listeners.end(); ++lt)
			okToContinue &= (*lt)->onFrameFailed((int)it->first, e);
 
		if (!okToContinue)
			m_renderer.stopRendering();
 
		++m_nextFrameIdxToSave;
		m_toBeSaved.erase(it++);
	}
}
 
//---------------------------------------------------------
 
void MovieRenderer::Imp::onRenderFinished(bool isCanceled)
{
	TFilePath levelName(m_levelUpdaterA.get() ? m_fp : TFilePath(getPreviewName(m_renderSessionId).toStdWString()));
 
	// Close updaters. After this, the output levels should be finalized on disk.
	m_levelUpdaterA.reset();
	m_levelUpdaterB.reset();
 
	if (!m_failure) {
		// Inform listeners of the render completion
		std::set<MovieRenderer::Listener *>::iterator it;
		for (it = m_listeners.begin(); it != m_listeners.end(); ++it)
			(*it)->onSequenceCompleted(levelName);
 
		// I wonder why listeners are not informed of a failed sequence, btw...
	}
 
	release(); // The movieRenderer is released by the render process. It could eventually be deleted.
}
 
//======================================================================================
 
//======================
//    MovieRenderer
//----------------------
 
MovieRenderer::MovieRenderer(ToonzScene *scene, const TFilePath &moviePath, int threadCount, bool cacheResults)
	: m_imp(new Imp(scene, moviePath, threadCount, cacheResults))
{
	m_imp->addRef(); // See MovieRenderer::start(). Can't just delete it in the dtor.
}
 
//---------------------------------------------------------
 
MovieRenderer::~MovieRenderer()
{
	m_imp->release();
}
 
//---------------------------------------------------------
 
void MovieRenderer::setRenderSettings(const TRenderSettings &renderSettings)
{
	m_imp->m_renderSettings = renderSettings;
}
 
//---------------------------------------------------------
 
void MovieRenderer::setDpi(double xDpi, double yDpi)
{
	m_imp->m_xDpi = xDpi;
	m_imp->m_yDpi = yDpi;
}
 
//---------------------------------------------------------
 
void MovieRenderer::addListener(Listener *listener)
{
	m_imp->m_listeners.insert(listener);
}
 
//---------------------------------------------------------
 
void MovieRenderer::addFrame(double frame, const TFxPair &fxPair)
{
	m_imp->m_framesToBeRendered.push_back(std::make_pair(frame, fxPair));
}
 
//---------------------------------------------------------
 
void MovieRenderer::enablePrecomputing(bool on)
{
	m_imp->m_renderer.enablePrecomputing(on);
}
 
//---------------------------------------------------------
 
bool MovieRenderer::isPrecomputingEnabled() const
{
	return m_imp->m_renderer.isPrecomputingEnabled();
}
 
//---------------------------------------------------------
 
void MovieRenderer::start()
{
	m_imp->prepareForStart();
 
	//Add a reference to MovieRenderer's Imp. The reference is 'owned' by TRenderer's render process - when it
	//ends (that is, when notifies onRenderFinished), the reference is released. As to TRenderer's specifics,
	//this is ensured to happen only after all the other port notifications for each frame have been invoked.
	m_imp->addRef();
 
	//Prepare the TRenderer::RenderDatas to render
	RenderDataVector *datasToBeRendered = new RenderDataVector;
	size_t i, size = m_imp->m_framesToBeRendered.size();
	for (i = 0; i < size; ++i)
		datasToBeRendered->push_back(TRenderer::RenderData(
			m_imp->m_framesToBeRendered[i].first,
			m_imp->m_renderSettings,
			m_imp->m_framesToBeRendered[i].second));
 
	m_imp->m_renderer.startRendering(datasToBeRendered);
}
 
//---------------------------------------------------------
 
void MovieRenderer::onCanceled()
{
	m_imp->m_renderer.stopRendering(true);
}
 
//---------------------------------------------------------
 
TRenderer *MovieRenderer::getTRenderer()
{
	// Again, this is somewhat BAD. The pointed-to object dies together with the MovieRenderer instance.
	// Since a TRenderer is already smart-pointer-like, we could just return a copy - however, it really
	// shouln't be that way. Maybe one day we'll revert that and actually use a smart pointer class.
 
	// For now, no use of this function seems to access the returned pointer beyond the lifespan of the
	// associated MovieRenderer instance - so I'm not gonna touch the class interface.
	return &m_imp->m_renderer;
}