// 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></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)();</int></int>

		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;</movierenderer::listener>

	std::auto_ptr<levelupdater> m_levelUpdaterA, m_levelUpdaterB;</levelupdater>

	TSoundTrackP m_st;

	std::map<double, std::pair<trasterp,="" trasterp="">> m_toBeSaved;</double,>

	std::vector<std::pair<double, tfxpair="">> m_framesToBeRendered;</std::pair<double,>

	std::string m_renderCacheId;

	/*--- 同じラスタのキャッシュを使いまわすとき、

		最初のものだけガンマをかけ、以降はそれを使いまわすようにする。

	---*/

	std::map<double, bool=""> m_toBeAppliedGamma;</double,>

	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);</trasterp,></bool,>

	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)</trasterp,></bool,>

{

	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;</double>

	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();</double,>

		// 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;</trasterp,>

		++m_nextFrameIdxToSave;

		m_toBeSaved.erase(ft);

		// Save current frame

		std::pair<bool, int=""> savedFrame;</bool,>

		{

			// 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();</movierenderer::listener>

		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;</double>

		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();</movierenderer::listener>

	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();</double,>

	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();</movierenderer::listener>

		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;</movierenderer::listener>

		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;

}