#include "trenderer.h"

#include "trendererP.h"

// TnzCore includes

#include "tsystem.h"

#include "tthreadmessage.h"

#include "tthread.h"

#include "tconvert.h"

#include "tstream.h"

#include "trasterimage.h"

#include "trop.h"

#include "timagecache.h"

#include "tstopwatch.h"

// TnzBase includes

#include "trenderresourcemanager.h"

#include "tpredictivecachemanager.h"

// Qt includes

#include <qeventloop></qeventloop>

#include <qcoreapplication></qcoreapplication>

#include <qreadwritelock></qreadwritelock>

#include <qreadlocker></qreadlocker>

#include <qwritelocker></qwritelocker>

#include <qthreadstorage></qthreadstorage>

// tcg includes

#include "tcg/tcg_deleter_types.h"

//Debug

//#define DIAGNOSTICS

//#include "diagnostics.h"

#include <queue></queue>

#include <functional></functional>

using namespace TThread;

std::vector<const *="" tfx=""> calculateSortedFxs(TRasterFxP rootFx);</const>

//================================================================================

//    Preliminaries - Anonymous namespace

//================================================================================

namespace

{

//TRenderer-thread association storage. It provides TRenderers the per-thread

//singleton status from inside a rendering process.

QThreadStorage<trendererimp **=""> rendererStorage;</trendererimp>

//Same for render process ids.

QThreadStorage<unsigned *="" long=""> renderIdsStorage;</unsigned>

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

//Interlacing functions for field-based rendering

inline void interlace(TRasterP f0, const TRasterP &f1, int field)

{

	if (f0->getPixelSize() != f1->getPixelSize())

		throw TException("interlace: invalid raster combination");

	assert(f0->getBounds() == f1->getBounds());

	int outWrapBytes = f0->getWrap() * f0->getPixelSize();

	int inWrapBytes = f1->getWrap() * f1->getPixelSize();

	int outWrapBytes2 = outWrapBytes * 2;

	int inWrapBytes2 = inWrapBytes * 2;

	int rowSize = f0->getLx() * f0->getPixelSize();

	f1->lock();

	f0->lock();

	UCHAR *rowIn = f1->getRawData();

	UCHAR *rowOut = f0->getRawData();

	if (field)

		rowIn += inWrapBytes;

	int count = f0->getLy() / 2;

	while (--count) {

		memcpy(rowOut, rowIn, rowSize);

		rowIn += inWrapBytes2;

		rowOut += outWrapBytes2;

	}

	f1->unlock();

	f0->unlock();

}

} // anonymous namespace

//================================================================================

//    Preliminaries - output rasters management

//================================================================================

//===================

//    RasterItem

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

//! The RasterItem class represents a reusable output raster for rendering purposes.

//! RasterItems are used as TRenderer's output rasters in order to avoid the overhead

//! of allocating one raster for each rendered frame.

//! Each frame-rendering task will lock a RasterItem as preallocated output before starting the

//! render, therefore changing the \b RasterItem::m_busy attribute accordingly.

//! As each frame is rendered on a separate thread, the number of RasterItems that

//! TRenderer will allocate depends on the number of rendering threads specified to it.

//! \sa RasterPool, TRenderer classes

class RasterItem

{

	string m_rasterId;

public:

	int m_bpp;

	bool m_busy;

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

	RasterItem(const TDimension &size, int bpp, bool busyFlag)

		: m_rasterId(""), m_bpp(bpp), m_busy(busyFlag)

	{

		TRasterP raster;

		if (bpp == 32)

			raster = TRaster32P(size);

		else if (bpp == 64)

			raster = TRaster64P(size);

		else

			assert(false);

		m_rasterId = TImageCache::instance()->getUniqueId();

		TImageCache::instance()->add(m_rasterId, TRasterImageP(raster));

	}

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

	~RasterItem()

	{

		TImageCache::instance()->remove(m_rasterId);

	}

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

	TRasterP getRaster() const

	{

		TRasterImageP rimg = (TRasterImageP)TImageCache::instance()->get(m_rasterId, true);

		return rimg ? rimg->getRaster() : TRasterP();

	}

private:

	//not implemented

	RasterItem();

	RasterItem(const TRaster &RasterItem);

};

//================================================================================

//===================

//    RasterPool

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

//! Stores a list of RasterItems under TRenderer's requests.

class RasterPool

{

	TDimension m_size;

	int m_bpp;

	typedef std::list<rasteritem *=""> RasterRepository;</rasteritem>

	RasterRepository m_rasterRepository;

	TThread::Mutex m_repositoryLock;

public:

	RasterPool() : m_size(-1, -1) {}

	~RasterPool();

	void setRasterSpecs(const TDimension &size, int bpp);

	void getRasterSpecs(TDimension &size, int &bpp)

	{

		size = m_size;

		bpp = m_bpp;

	}

	TRasterP getRaster();

	TRasterP getRaster(const TDimension &size, int bpp);

	void releaseRaster(const TRasterP &r);

	void clear();

};

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

void RasterPool::clear()

{

	QMutexLocker sl(&m_repositoryLock);

	clearPointerContainer(m_rasterRepository);

}

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

void RasterPool::setRasterSpecs(const TDimension &size, int bpp)

{

	if (size != m_size || bpp != m_bpp) {

		m_size = size;

		m_bpp = bpp;

		clear();

	}

}

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

TRasterP RasterPool::getRaster(const TDimension &size, int bpp)

{

	assert(size == m_size && bpp == m_bpp);

	return getRaster();

}

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

//!Returns for the first not-busy raster

TRasterP RasterPool::getRaster()

{

	QMutexLocker sl(&m_repositoryLock);

	RasterRepository::iterator it = m_rasterRepository.begin();

	while (it != m_rasterRepository.end()) {

		RasterItem *rasItem = *it;

		if (rasItem->m_busy == false) {

			TRasterP raster = rasItem->getRaster();

			if (!raster) {

				delete rasItem;

				m_rasterRepository.erase(it++);

				continue;

			}

			rasItem->m_busy = true;

			raster->clear();

			return raster;

		}

		++it;

	}

	RasterItem *rasItem = new RasterItem(m_size, m_bpp, true);

	m_rasterRepository.push_back(rasItem);

	return rasItem->getRaster();

}

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

//!Cerca il raster \b r in m_rasterRepository; se lo trova setta a \b false il campo \b m_busy.

void RasterPool::releaseRaster(const TRasterP &r)

{

	if (!r)

		return;

	QMutexLocker sl(&m_repositoryLock);

	for (RasterRepository::iterator it = m_rasterRepository.begin();

		 it != m_rasterRepository.end();

		 ++it) {

		RasterItem *rasItem = *it;

		if (rasItem->getRaster()->getRawData() == r->getRawData()) {

			assert(rasItem->m_busy);

			rasItem->m_busy = false;

			return;

		}

	}

}

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

RasterPool::~RasterPool()

{

	/*if (m_rasterRepository.size())

    TSystem::outputDebug("~RasterPool: itemCount = " + toString ((int)m_rasterRepository.size())+" (should be 0)\n");*/

	//Release all raster items

	clear();

}

//================================================================================

//    Internal rendering classes declaration

//================================================================================

//=====================

//    TRendererImp

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

class TRendererImp : public TSmartObject

{

public:

	struct RenderInstanceInfos {

		int m_canceled;

		int m_activeTasks;

		int m_status;

		RenderInstanceInfos()

			: m_canceled(false), m_activeTasks(0), m_status(TRenderer::IDLE) {}

	};

public:

	typedef std::vector<trenderport *=""> PortContainer;</trenderport>

	typedef PortContainer::iterator PortContainerIterator;

	QReadWriteLock m_portsLock;

	PortContainer m_ports;

	QMutex m_renderInstancesMutex;

	std::map<unsigned long,="" renderinstanceinfos=""> m_activeInstances;</unsigned>

	//! The renderer Id is a number uniquely associated with a TRenderer instance.

	static unsigned long m_rendererIdCounter;

	//! The render Id is a number uniquely associated with a render process started

	//! with the startRendering() method.

	static unsigned long m_renderIdCounter;

	unsigned long m_rendererId;

	Executor m_executor;

	bool m_precomputingEnabled;

	RasterPool m_rasterPool;

	std::vector<trenderresourcemanager *=""> m_managers;</trenderresourcemanager>

	TAtomicVar m_undoneTasks;

	//std::vector<qeventloop*> m_waitingLoops;</qeventloop*>

	std::vector<bool *=""> m_waitingLoops;</bool>

	TRasterFxP rootFx;

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

	TRendererImp(int nThreads);

	~TRendererImp();

	void startRendering(unsigned long renderId, const std::vector<trenderer::renderdata> &renderDatas);</trenderer::renderdata>

	void notifyRasterStarted(const TRenderPort::RenderData &rd);

	void notifyRasterCompleted(const TRenderPort::RenderData &rd);

	void notifyRasterFailure(const TRenderPort::RenderData &rd, TException &e);

	void notifyRenderFinished(bool isCanceled = false);

	void addPort(TRenderPort *port);

	void removePort(TRenderPort *port);

	void abortRendering(unsigned long renderId);

	void stopRendering(bool waitForCompleteStop);

	bool hasToDie(unsigned long renderId);

	int getRenderStatus(unsigned long renderId);

	void enablePrecomputing(bool on) { m_precomputingEnabled = on; }

	bool isPrecomputingEnabled() const { return m_precomputingEnabled; }

	void setThreadsCount(int nThreads) { m_executor.setMaxActiveTasks(nThreads); }

	inline void declareRenderStart(unsigned long renderId);

	inline void declareRenderEnd(unsigned long renderId);

	inline void declareFrameStart(double frame);

	inline void declareFrameEnd(double frame);

	inline void declareStatusStart(int renderStatus);

	inline void declareStatusEnd(int renderStatus);

	void quitWaitingLoops();

};

#ifdef WIN32

template class DVAPI TSmartPointerT<trendererimp>;</trendererimp>

#endif

typedef TSmartPointerT<trendererimp> TRendererImpP;</trendererimp>

unsigned long TRendererImp::m_rendererIdCounter = 0;

unsigned long TRendererImp::m_renderIdCounter = 0;

//================================================================================

//===================

//    RenderTask

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

class RenderTask : public TThread::Runnable

{

	std::vector<double> m_frames;</double>

	unsigned long m_taskId;

	unsigned long m_renderId;

	TRendererImpP m_rendererImp;

	TFxPair m_fx;

	TPointD m_framePos;

	TDimension m_frameSize;

	TRenderSettings m_info;

	bool m_fieldRender, m_stereoscopic;

	Mutex m_rasterGuard;

	TTile m_tileA; //in normal and field rendering, Rendered at given frame; in stereoscopic, rendered left frame

	TTile m_tileB; //in  field rendering, rendered at frame + 0.5; in stereoscopic, rendered right frame

public:

	RenderTask(unsigned long renderId, unsigned long taskId,

			   double frame, const TRenderSettings &ri, const TFxPair &fx,

			   const TPointD &framePos, const TDimension &frameSize,

			   const TRendererImpP &rendererImp);

	~RenderTask() {}

	void addFrame(double frame) { m_frames.push_back(frame); }

	void buildTile(TTile &tile);

	void releaseTiles();

	void onFrameStarted();

	void onFrameCompleted();

	void onFrameFailed(TException &e);

	void preRun();

	void run();

	int taskLoad() { return 100; }

	void onFinished(TThread::RunnableP);

};

//================================================================================

//    Implementations

//================================================================================

//==================

//    TRenderer

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

TRenderer::TRenderer(int nThread)

{

	m_imp = new TRendererImp(nThread); //Already adds a ref

}

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

TRenderer::TRenderer(TRendererImp *imp)

	: m_imp(imp)

{

	if (m_imp)

		m_imp->addRef();

}

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

TRenderer::TRenderer(const TRenderer &r)

	: m_imp(r.m_imp)

{

	if (m_imp)

		m_imp->addRef();

}

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

void TRenderer::operator=(const TRenderer &r)

{

	m_imp = r.m_imp;

	if (m_imp)

		m_imp->addRef();

}

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

TRenderer::~TRenderer()

{

	if (m_imp)

		m_imp->release();

}

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

//! The static method is intended for use inside a rendering thread only. It returns

//! a copy of the eventual TRenderer interface installed on the thread -

//! or an empty TRenderer if none happened to be. It can be set using the

//! install() and uninstall() methods.

TRenderer TRenderer::instance()

{

	TRendererImp **lData = rendererStorage.localData();

	if (lData)

		return TRenderer(*lData);

	return 0;

}

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

//! Returns the renderer id.

unsigned long TRenderer::rendererId()

{

	return m_imp->m_rendererId;

}

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

//! Returns the rendering process id currently running on the invoking

//! thread.

unsigned long TRenderer::renderId()

{

	unsigned long *lData = renderIdsStorage.localData();

	return lData ? *lData : -1;

}

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

//! Builds and returns an id for starting a new rendering process.

unsigned long TRenderer::buildRenderId()

{

	return TRendererImp::m_renderIdCounter++;

}

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

//! Returns the renderId that will be used by the next startRendering() call.

//! This method can be used to retrieve the renderId of a rendering instance

//! before it is actually started - provided that no other render instance

//! is launched inbetween.

unsigned long TRenderer::nextRenderId()

{

	return TRendererImp::m_renderIdCounter;

}

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

inline void TRendererImp::declareRenderStart(unsigned long renderId)

{

	//Inform the resource managers

	for (unsigned int i = 0; i < m_managers.size(); ++i)

		m_managers[i]->onRenderInstanceStart(renderId);

}

//! Declares that the render process of passed renderId is about to start.

void TRenderer::declareRenderStart(unsigned long renderId)

{

	m_imp->declareRenderStart(renderId);

}

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

inline void TRendererImp::declareRenderEnd(unsigned long renderId)

{

	//Inform the resource managers

	for (int i = m_managers.size() - 1; i >= 0; --i)

		m_managers[i]->onRenderInstanceEnd(renderId);

}

//! Declares that the render process of passed renderId has ended.

void TRenderer::declareRenderEnd(unsigned long renderId)

{

	m_imp->declareRenderEnd(renderId);

}

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

inline void TRendererImp::declareFrameStart(double frame)

{

	//Inform the resource managers

	for (unsigned int i = 0; i < m_managers.size(); ++i)

		m_managers[i]->onRenderFrameStart(frame);

}

//! Declares that render of passed frame is about to start.

void TRenderer::declareFrameStart(double frame)

{

	m_imp->declareFrameStart(frame);

}

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

inline void TRendererImp::declareFrameEnd(double frame)

{

	//Inform the resource managers

	for (int i = m_managers.size() - 1; i >= 0; --i)

		m_managers[i]->onRenderFrameEnd(frame);

}

//! Declares that render of passed has ended.

void TRenderer::declareFrameEnd(double frame)

{

	m_imp->declareFrameEnd(frame);

}

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

inline void TRendererImp::declareStatusStart(int renderStatus)

{

	//Inform the resource managers

	for (unsigned int i = 0; i < m_managers.size(); ++i)

		m_managers[i]->onRenderStatusStart(renderStatus);

}

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

inline void TRendererImp::declareStatusEnd(int renderStatus)

{

	//Inform the resource managers

	for (int i = m_managers.size() - 1; i >= 0; --i)

		m_managers[i]->onRenderStatusEnd(renderStatus);

}

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

//! Installs the specified render process on the invoking thread.

void TRenderer::install(unsigned long renderId)

{

	m_imp->addRef();

	rendererStorage.setLocalData(new (TRendererImp *)(m_imp));

	renderIdsStorage.setLocalData(new unsigned long(renderId));

}

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

//! Uninstalls any rendering process active on the invoking thread.

void TRenderer::uninstall()

{

	rendererStorage.setLocalData(0);

	renderIdsStorage.setLocalData(0);

	m_imp->release();

}

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

TRenderResourceManager *TRenderer::getManager(unsigned int id) const

{

	return m_imp->m_managers[id];

}

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

void TRenderer::enablePrecomputing(bool on)

{

	m_imp->enablePrecomputing(on);

}

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

bool TRenderer::isPrecomputingEnabled() const

{

	return m_imp->isPrecomputingEnabled();

}

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

void TRenderer::setThreadsCount(int nThreads)

{

	m_imp->setThreadsCount(nThreads);

}

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

void TRenderer::addPort(TRenderPort *port)

{

	m_imp->addPort(port);

}

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

void TRenderer::removePort(TRenderPort *port)

{

	m_imp->removePort(port);

}

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

unsigned long TRenderer::startRendering(

	double f,

	const TRenderSettings &info,

	const TFxPair &actualRoot)

{

	assert(f >= 0);

	std::vector<renderdata> *rds = new std::vector<renderdata>;</renderdata></renderdata>

	rds->push_back(RenderData(f, info, actualRoot));

	return startRendering(rds);

}

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

//! Queues a rendering event in the main event loop.

//! NOTE: The passed pointer is owned by the TRenderer after it is submitted for rendering -

//! do not delete it later.

unsigned long TRenderer::startRendering(const std::vector<renderdata> *renderDatas)</renderdata>

{

	if (renderDatas->empty()) {

		delete renderDatas;

		return -1;

	}

	//Build a new render Id

	unsigned long renderId = m_imp->m_renderIdCounter++;

	TRendererStartInvoker::StartInvokerRenderData srd;

	srd.m_renderId = renderId;

	srd.m_renderDataVector = renderDatas;

	TRendererStartInvoker::instance()->emitStartRender(m_imp, srd);

	return renderId;

}

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

void TRenderer::abortRendering(unsigned long renderId)

{

	m_imp->abortRendering(renderId);

}

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

void TRenderer::stopRendering(bool waitForCompleteStop)

{

	m_imp->stopRendering(waitForCompleteStop);

}

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

bool TRenderer::isAborted(unsigned long renderId) const

{

	return m_imp->hasToDie(renderId);

}

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

int TRenderer::getRenderStatus(unsigned long renderId) const

{

	return m_imp->getRenderStatus(renderId);

}

//================================================================================

//=====================

//    TRendererImp

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

TRendererImp::TRendererImp(int nThreads)

	: m_executor(), m_undoneTasks(), m_rendererId(m_rendererIdCounter++), m_precomputingEnabled(true)

{

	m_executor.setMaxActiveTasks(nThreads);

	std::vector<trenderresourcemanagergenerator *=""> &generators =</trenderresourcemanagergenerator>

		TRenderResourceManagerGenerator::generators(false);

	//May be adopted by other TRenderers from now on.

	addRef();

	rendererStorage.setLocalData(new (TRendererImp *)(this));

	unsigned int i;

	for (i = 0; i < generators.size(); ++i) {

		TRenderResourceManager *manager = (*generators[i])();

		if (manager)

			m_managers.push_back(manager);

	}

	rendererStorage.setLocalData(0);

}

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

TRendererImp::~TRendererImp()

{

	rendererStorage.setLocalData(new (TRendererImp *)(this));

	int i;

	for (i = m_managers.size() - 1; i >= 0; --i)

		if (m_managers[i]->renderHasOwnership())

			delete m_managers[i];

	rendererStorage.setLocalData(0);

}

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

void TRendererImp::addPort(TRenderPort *port)

{

	QWriteLocker sl(&m_portsLock);

	PortContainerIterator it = std::find(m_ports.begin(), m_ports.end(), port);

	if (it == m_ports.end())

		m_ports.push_back(port);

}

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

void TRendererImp::removePort(TRenderPort *port)

{

	QWriteLocker sl(&m_portsLock);

	PortContainerIterator it = std::find(m_ports.begin(), m_ports.end(), port);

	if (it != m_ports.end())

		m_ports.erase(it);

}

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

bool TRendererImp::hasToDie(unsigned long renderId)

{

	QMutexLocker sl(&m_renderInstancesMutex);

	std::map<unsigned long,="" renderinstanceinfos="">::iterator it = m_activeInstances.find(renderId);</unsigned>

	assert(it != m_activeInstances.end());

	return it == m_activeInstances.end() ? true : it->second.m_canceled;

}

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

int TRendererImp::getRenderStatus(unsigned long renderId)

{

	QMutexLocker sl(&m_renderInstancesMutex);

	std::map<unsigned long,="" renderinstanceinfos="">::iterator it = m_activeInstances.find(renderId);</unsigned>

	assert(it != m_activeInstances.end());

	return it == m_activeInstances.end() ? true : it->second.m_status;

}

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

void TRendererImp::abortRendering(unsigned long renderId)

{

	QMutexLocker sl(&m_renderInstancesMutex);

	std::map<unsigned long,="" renderinstanceinfos="">::iterator it = m_activeInstances.find(renderId);</unsigned>

	if (it != m_activeInstances.end())

		it->second.m_canceled = true;

}

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

void TRendererImp::stopRendering(bool waitForCompleteStop)

{

	QMutexLocker sl(&m_renderInstancesMutex);

	{

		//Tasks already stop rendering on their own when they don't find their render ids here.

		std::map<unsigned long,="" renderinstanceinfos="">::iterator it;</unsigned>

		for (it = m_activeInstances.begin(); it != m_activeInstances.end(); ++it)

			it->second.m_canceled = true;

	}

	if (waitForCompleteStop && m_undoneTasks > 0) {

		//Sometimes, QEventLoop suddenly stops processing slots (especially those notifications

		//from active rendering instances) - therefore resulting in a block of the application.

		//I've not figured out why (#QTBUG-11649?) - but substituting with a plain while

		//seems to do the trick...

		/*QEventLoop eventLoop;

    m_waitingLoops.push_back(&eventLoop);

    eventLoop.exec();*/

		bool loopQuit = false;

		m_waitingLoops.push_back(&loopQuit);

		sl.unlock();

		while (!loopQuit)

			QCoreApplication::processEvents(QEventLoop::AllEvents | QEventLoop::WaitForMoreEvents);

	}

}

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

void TRendererImp::quitWaitingLoops()

{

	//Make the stopRendering waiting loops quit

	while (!m_waitingLoops.empty()) {

		//rendererImp->m_waitingLoops.back()->quit();

		*m_waitingLoops.back() = true;

		m_waitingLoops.pop_back();

	}

}