#include "trasterfx.h"

//Core-system includes

#include "tsystem.h"

#include "tthreadmessage.h"

//Fx basics

#include "tparamcontainer.h"

#include "tbasefx.h"

#include "tfxattributes.h"

//Images components

#include "timagecache.h"

#include "trasterimage.h"

#include "trop.h"

//Optimization components

#include "trenderresourcemanager.h"

#include "tfxcachemanager.h"

#include "trenderer.h"

//Diagnostics

//#define DIAGNOSTICS

#ifdef DIAGNOSTICS

#include "diagnostics.h"

#endif //DIAGNOSTICS

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

namespace

{

inline bool areEqual(const TRasterFxRenderDataP &d1, const TRasterFxRenderDataP &d2)

{

	return (*d1 == *d2);

}

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

inline int myCeil(double x)

{

	return ((x - (int)(x)) > TConsts::epsilon ? (int)(x) + 1 : (int)(x));

}

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

inline TRect myConvert(const TRectD &r, TPointD &dp)

{

	TRect ri(tfloor(r.x0), tfloor(r.y0), myCeil(r.x1), myCeil(r.y1));

	dp.x = r.x0 - ri.x0;

	dp.y = r.y0 - ri.y0;

	assert(dp.x >= 0 && dp.y >= 0);

	return ri;

}

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

inline bool myIsEmpty(const TRectD &r)

{

	return r.getLx() < 1 || r.getLy() < 1;

}

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

inline TRect myConvert(const TRectD &rect)

{

	return TRect(tround(rect.x0), tround(rect.y0), tround(rect.x1) - 1, tround(rect.y1) - 1);

}

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

inline TRectD myConvert(const TRect &rect)

{

	return TRectD(rect.x0, rect.y0, rect.x1 + 1, rect.y1 + 1);

}

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

inline void enlargeToI(TRectD &r)

{

	TRectD temp(tfloor(r.x0), tfloor(r.y0), tceil(r.x1), tceil(r.y1));

	//NOTE: If we enlarge a TConsts::infiniteRectD or one which trespass

	//ints' numerical bounds, the rect may become empty.

	if (!myIsEmpty(temp))

		r = temp;

}

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

//Calculates the 2-norm of the passed affine A - that is, the max modulus

//of A*A's eigenvalues (*A being the adjoint).

double norm2(const TAffine &aff)

{

	double a11 = aff.a11 * aff.a11 + aff.a12 * aff.a12;

	double a12 = aff.a11 * aff.a21 + aff.a12 * aff.a22;

	double a21 = aff.a21 * aff.a11 + aff.a22 * aff.a12;

	double a22 = aff.a21 * aff.a21 + aff.a22 * aff.a22;

	double a11plusa22 = a11 + a22;

	double delta = sq(a11 - a22) + 4 * a12 * a21;

	delta = sqrt(delta);

	double eig1 = a11plusa22 + delta;

	double eig2 = a11plusa22 - delta;

	return tmax(sqrt(eig1 / 2.0), sqrt(eig2 / 2.0));

}

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

inline int getResampleFilterRadius(const TRenderSettings &info)

{

	switch (info.m_quality) {

	case TRenderSettings::StandardResampleQuality:

		return 1;

		CASE TRenderSettings::ImprovedResampleQuality : return 2;

		CASE TRenderSettings::HighResampleQuality : return 3;

		CASE TRenderSettings::Triangle_FilterResampleQuality : return 1;

		CASE TRenderSettings::Mitchell_FilterResampleQuality : return 2;

		CASE TRenderSettings::Cubic5_FilterResampleQuality : return 2;

		CASE TRenderSettings::Cubic75_FilterResampleQuality : return 2;

		CASE TRenderSettings::Cubic1_FilterResampleQuality : return 2;

		CASE TRenderSettings::Hann2_FilterResampleQuality : return 2;

		CASE TRenderSettings::Hann3_FilterResampleQuality : return 3;

		CASE TRenderSettings::Hamming2_FilterResampleQuality : return 2;

		CASE TRenderSettings::Hamming3_FilterResampleQuality : return 3;

		CASE TRenderSettings::Lanczos2_FilterResampleQuality : return 2;

		CASE TRenderSettings::Lanczos3_FilterResampleQuality : return 3;

		CASE TRenderSettings::Gauss_FilterResampleQuality : return 2;

		CASE TRenderSettings::ClosestPixel_FilterResampleQuality : return 1;

		CASE TRenderSettings::Bilinear_FilterResampleQuality : return 1;

	DEFAULT:

		assert(false);

		return -1;

	}

}

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

inline QString traduce(const TRectD &rect)

{

	return "[" + QString::number(rect.x0) + " " + QString::number(rect.y0) + " " +

		   QString::number(rect.x1) + " " + QString::number(rect.y1) + "]";

}

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

inline QString traduce(const TRect &rect)

{

	return "[" + QString::number(rect.x0) + " " + QString::number(rect.y0) + " " +

		   QString::number(rect.x1) + " " + QString::number(rect.y1) + "]";

}

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

inline QString qTraduce(const TAffine &aff)

{

	return "[" +

		   QString::number(aff.a11, 'g', 15) + "," +

		   QString::number(aff.a12, 'g', 15) + "," +

		   QString::number(aff.a13, 'g', 15) + "," +

		   QString::number(aff.a21, 'g', 15) + "," +

		   QString::number(aff.a22, 'g', 15) + "," +

		   QString::number(aff.a23, 'g', 15) + "]";

}

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

inline std::string traduce(const TAffine &aff)

{

	return

		//Observe that toString distinguishes + and - 0. That is a problem

		//when comparing aliases - so near 0 values are explicitly rounded to 0.

		(areAlmostEqual(aff.a11, 0.0) ? "0" : toString(aff.a11, 5)) + "," +

		(areAlmostEqual(aff.a12, 0.0) ? "0" : toString(aff.a12, 5)) + "," +

		(areAlmostEqual(aff.a13, 0.0) ? "0" : toString(aff.a13, 5)) + "," +

		(areAlmostEqual(aff.a21, 0.0) ? "0" : toString(aff.a21, 5)) + "," +

		(areAlmostEqual(aff.a22, 0.0) ? "0" : toString(aff.a22, 5)) + "," +

		(areAlmostEqual(aff.a23, 0.0) ? "0" : toString(aff.a23, 5));

}

} // Local namespace

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

//The following should be cleared - and its functionalities surrendered directly

//to an appropriate resource manager...

//!Declares an image to be kept in cache until the render ends or is canceled.

void addRenderCache(const std::string &alias, TImageP image)

{

	TFxCacheManager::instance()->add(alias, image);

}

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

//!The inverse function to addRenderCache.

void removeRenderCache(const std::string &alias)

{

	TFxCacheManager::instance()->remove(alias);

}

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

//

// TrFx   (Affine Transformer Fx)

//

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

//! Internal fx node which applies the implicit affine stored in the TRenderSettings structure,

//! replacing the old TRasterFx::doCompute.

class TrFx : public TBaseRasterFx

{

	FX_DECLARATION(TrFx)

	TRasterFx *m_fx;

public:

	TrFx() {}

	~TrFx() {}

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

	void setFx(TRasterFx *fx) { m_fx = fx; }

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

	bool isCachable() const { return true; } //Currently cachable as a test. Observe that it was NOT in Toonz 6.1

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

	bool canHandle(const TRenderSettings &info, double frame) { return true; }

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

	string getAlias(double frame, const TRenderSettings &info) const

	{

		//NOTE: TrFx are not present at this recursive level. Affines dealing is currently handled by inserting the

		//rendering affine AFTER a getAlias call. Ever.

		string alias = getFxType();

		return alias + "[" + m_fx->getAlias(frame, info) + "]";

	}

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

	bool doGetBBox(double frame, TRectD &bBox, const TRenderSettings &info)

	{

		//NOTE: TrFx are not present at this recursive level. Affines dealing is still handled by TGeometryFxs here....

		return m_fx->doGetBBox(frame, bBox, info);

	}

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

	void doCompute(TTile &tile, double frame, const TRenderSettings &info)

	{

		const TRectD &rectOut = myConvert(tile.getRaster()->getBounds()) + tile.m_pos;

		TRectD rectIn;

		TRenderSettings infoIn(info);

		TAffine appliedAff;

		if (!buildInput(rectOut, frame, info, rectIn, infoIn, appliedAff))

			return;

		const TRect &rectInI = myConvert(rectIn);

		// rasIn e' un raster dello stesso tipo di tile.getRaster()

		TTile inTile;

		m_fx->allocateAndCompute(inTile, rectIn.getP00(), TDimension(rectInI.getLx(), rectInI.getLy()),

								 tile.getRaster(), frame, infoIn);

		infoIn.m_affine = appliedAff;

		TRasterFx::applyAffine(tile, inTile, infoIn);

	}

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

	void doDryCompute(TRectD &rect, double frame, const TRenderSettings &info)

	{

		TRectD rectIn;

		TRenderSettings infoIn(info);

		TAffine appliedAff;

		if (!buildInput(rect, frame, info, rectIn, infoIn, appliedAff))

			return;

		m_fx->dryCompute(rectIn, frame, infoIn);

	}

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

	int getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info)

	{

		TRectD rectIn;

		TRenderSettings infoIn(info);

		TAffine appliedAff;

		if (!buildInput(rect, frame, info, rectIn, infoIn, appliedAff))

			return 0;

		return TRasterFx::memorySize(rectIn, info.m_bpp);

	}

private:

	bool buildInput(const TRectD &rectOut, double frame, const TRenderSettings &infoOut,

					TRectD &rectIn, TRenderSettings &infoIn, TAffine &appliedAff)

	{

		if (myIsEmpty(rectOut))

			return false;

		// Build the affines

		infoIn.m_affine = m_fx->handledAffine(infoOut, frame);

		appliedAff = infoOut.m_affine * infoIn.m_affine.inv();

		// Quick fix - prevent near-singular transforms.

		// NOTE: This check **SHOULD BE REMOVED** and dealt with at the RESAMPLING level.

		//       Observe how the tolerance value is quite arbitrary! Yeah I know it's shameful... :(

		if (fabs(appliedAff.det()) < 1e-6) // TO BE REMOVED

			return false;				   // TO BE REMOVED

		// Build the input rect

		const TAffine &appliedAffInv = appliedAff.inv();

		int filterRadius = getResampleFilterRadius(infoOut);

		TRectD bbox;

		m_fx->getBBox(frame, bbox, infoIn);

		rectIn = ((appliedAffInv * rectOut).enlarge(filterRadius) + // The filter size applies in input during

				  (appliedAffInv * rectOut.enlarge(filterRadius))) *

				 bbox; // magnifications, and in output during

					   // minifications. Thus, they basically cumulate.

		if (myIsEmpty(rectIn))

			return false;

		enlargeToI(rectIn);

		return true;

	}

};

FX_IDENTIFIER_IS_HIDDEN(TrFx, "trFx")

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

//

// FxResourceBuilder

//

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

// This class is the internal interface with the cache regarding intermediate render

// results. Please refer to the ResourceBuilder documentation in tfxcachemanager.cpp

class FxResourceBuilder : public ResourceBuilder

{

	TRasterFxP m_rfx;

	double m_frame;

	const TRenderSettings *m_rs;

	TTile *m_outTile;

	TTile *m_currTile;

	TTile m_newTile;

	TRectD m_outRect;

public:

	FxResourceBuilder(const string &resourceName,

					  const TRasterFxP &fx, const TRenderSettings &rs, double frame)

		: ResourceBuilder(resourceName, fx.getPointer(), frame, rs), m_rfx(fx), m_frame(frame), m_rs(&rs), m_currTile(0) {}

	inline void build(TTile &tile);

protected:

	void simCompute(const TRectD &rect)

	{

		TRectD rectCpy(rect); //Why the hell dryCompute(..) has non-const TRectD& input ????

		m_rfx->doDryCompute(rectCpy, m_frame, *m_rs);

	}

	void buildTileToCalculate(const TRectD &tileRect);

	void compute(const TRectD &tileRect);

	void upload(TCacheResourceP &resource);

	bool download(TCacheResourceP &resource);

};

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

inline void FxResourceBuilder::build(TTile &tile)

{

	m_outTile = &tile;

	TDimension dim(tile.getRaster()->getSize());

	m_outRect = TRectD(tile.m_pos, TDimensionD(dim.lx, dim.ly));

	ResourceBuilder::build(m_outRect);

}

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

void FxResourceBuilder::buildTileToCalculate(const TRectD &tileGeom)

{

	if (tileGeom == m_outRect) {

		m_currTile = m_outTile;

		return;

	}

	m_newTile.m_pos = tileGeom.getP00();

	TRasterP outRas(m_outTile->getRaster());

	//If possible, try to reuse outRas's buffer.

	TDimension outputSize(outRas->getSize());

	TDimension requiredSize(tceil(tileGeom.getLx()), tceil(tileGeom.getLy()));

	TRasterP ras;

	if (outputSize.lx >= requiredSize.lx && outputSize.ly >= requiredSize.ly) {

		//Reuse fxOutput's buffer

		TRect rect(0, 0, requiredSize.lx - 1, requiredSize.ly - 1);

		ras = outRas->extract(rect);

		ras->clear();

	} else

		ras = outRas->create(requiredSize.lx, requiredSize.ly);

	m_newTile.setRaster(ras);

	m_currTile = &m_newTile;

}

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

void FxResourceBuilder::compute(const TRectD &tileRect)

{

#ifdef DIAGNOSTICS

	TStopWatch sw;

	sw.start();

#endif

	buildTileToCalculate(tileRect);

	m_rfx->doCompute(*m_currTile, m_frame, *m_rs);

#ifdef DIAGNOSTICS

	sw.stop();

	DIAGNOSTICS_THRSET("FComputeTime", sw.getTotalTime());

#endif

}

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

void FxResourceBuilder::upload(TCacheResourceP &resource)

{

	resource->upload(*m_currTile);

	if (m_currTile == &m_newTile)

		m_newTile.setRaster(0);

}

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

bool FxResourceBuilder::download(TCacheResourceP &resource)

{

	//In case the output tile was used to calculate the fx, avoid downloading

	if (m_currTile == m_outTile)

		return true;

	return resource->downloadAll(*m_outTile);

}

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

//

// TRasterFx

//

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

class TRasterFx::TRasterFxImp

{

public:

	bool m_cacheEnabled;

	TTile m_cachedTile;

	double m_frame;

	bool m_isEnabled;

	TRenderSettings m_info;

	string m_interactiveCacheId;

	mutable TThread::Mutex m_mutex; //brutto

	TRasterFxImp() : m_cacheEnabled(false), m_isEnabled(true), m_cachedTile(0)

	{

	}

	~TRasterFxImp() {}

	void enableCache(bool on)

	{

		QMutexLocker sl(&m_mutex);

		m_cacheEnabled = on;

		if (!m_cacheEnabled) {

			m_interactiveCacheId = "";

			m_frame = 0;

			m_info = TRenderSettings();

			m_cachedTile.setRaster(0);

			m_cachedTile.m_pos = TPointD();

		}

	}

	bool isCacheEnabled() const

	{

		return m_cacheEnabled;

	}

	bool isEnabled() const

	{

		QMutexLocker sl(&m_mutex); // a che serve??

		return m_isEnabled;

	}

	void enable(bool on)

	{

		QMutexLocker sl(&m_mutex); // a che serve

		m_isEnabled = on;

	}

};

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

TRasterFx::TRasterFx()

	: m_rasFxImp(new TRasterFxImp)

{

}

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

TRasterFx::~TRasterFx()

{

	delete m_rasFxImp;

}

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

TAffine TRasterFx::handledAffine(const TRenderSettings &info, double frame)

{

	return (

			   info.m_affine.a11 == info.m_affine.a22 &&

			   info.m_affine.a12 == 0 && info.m_affine.a21 == 0 &&

			   info.m_affine.a13 == 0 && info.m_affine.a23 == 0)

			   ? info.m_affine

			   : TScale(norm2(info.m_affine));

}

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

bool TRasterFx::getBBox(double frame, TRectD &bBox, const TRenderSettings &info)

{

	bool ret = doGetBBox(frame, bBox, info);

	bBox = info.m_affine * bBox;

	enlargeToI(bBox);

	return ret;

}

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

void TRasterFx::transform(double frame,

						  int port,

						  const TRectD &rectOnOutput,

						  const TRenderSettings &infoOnOutput,

						  TRectD &rectOnInput,

						  TRenderSettings &infoOnInput)

{

	rectOnInput = rectOnOutput;

	infoOnInput = infoOnOutput;

}

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

int TRasterFx::memorySize(const TRectD &rect, int bpp)

{

	if (rect.x1 <= rect.x0 || rect.y1 <= rect.y0)

		return 0;

	return (unsigned long)(rect.getLx() + 1) * (unsigned long)(rect.getLy() + 1) * (bpp >> 3) >> 20;

}

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

//! Specifies the approximate size (in MegaBytes) of the maximum allocation instance that this fx

//! will need to perform in order to render the passed input.

//! This method should be reimplemented in order to make the Toonz rendering process aware of

//! the use of big raster memory chunks, at least.

//! Observe that the passed tile geometry is implicitly  already allocated <\i> for the fx output.

//! \n

//! The default implementation returns 0, assuming that the passed implicit memory size is passed

//! below in node computation without further allocation of resources. Fxs can reimplement this

//! to -1 to explicitly disable the Toonz's smart memory handling.

//! \n \n

//! \note The rendering process ensures that the passed render settings are \a handled

//! by the fx before this function is invoked - do not waste code for it.

//! \sa TRasterFx::memorySize and TRasterFx::canHandle methods.

int TRasterFx::getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info)

{

	return 0;

}

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

string TRasterFx::getAlias(double frame, const TRenderSettings &info) const

{

	string alias = getFxType();

	alias += "[";

	// alias degli effetti connessi alle porte di input separati da virgole

	// una porta non connessa da luogo a un alias vuoto (stringa vuota)

	int i;

	for (i = 0; i < getInputPortCount(); i++) {

		TFxPort *port = getInputPort(i);

		if (port->isConnected()) {

			TRasterFxP ifx = port->getFx();

			assert(ifx);

			alias += ifx->getAlias(frame, info);

		}

		alias += ",";

	}

	// alias dei valori dei parametri dell'effetto al frame dato

	for (i = 0; i < getParams()->getParamCount(); i++) {

		TParam *param = getParams()->getParam(i);

		alias += param->getName() + "=" + param->getValueAlias(frame, 3);

	}

	alias += "]";

	return alias;

}

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

void TRasterFx::dryCompute(TRectD &rect,

						   double frame,

						   const TRenderSettings &info)

{

	if (checkActiveTimeRegion() && !getActiveTimeRegion().contains(frame))

		return;

	if (!getAttributes()->isEnabled() || !m_rasFxImp->isEnabled()) {

		if (getInputPortCount() == 0)

			return;

		TFxPort *port = getInputPort(getPreferredInputPort());

		if (port->isConnected())

			TRasterFxP(port->getFx())->dryCompute(rect, frame, info);

		return;

	}

	//If the input tile has a fractionary position, it is passed to the

	//rendersettings' accumulated affine.

	TPoint intTilePos(tfloor(rect.x0), tfloor(rect.y0));

	TPointD fracTilePos(rect.x0 - intTilePos.x, rect.y0 - intTilePos.y);

	TPointD fracInfoTranslation(

		info.m_affine.a13 - fracTilePos.x,

		info.m_affine.a23 - fracTilePos.y);

	TPoint intInfoTranslation(tfloor(fracInfoTranslation.x), tfloor(fracInfoTranslation.y));

	TPointD newTilePos(intTilePos.x - intInfoTranslation.x, intTilePos.y - intInfoTranslation.y);

	if (rect.getP00() != newTilePos) {

		TRenderSettings newInfo(info);

		newInfo.m_affine.a13 = fracInfoTranslation.x - intInfoTranslation.x;

		newInfo.m_affine.a23 = fracInfoTranslation.y - intInfoTranslation.y;

		TRectD newRect(newTilePos, rect.getSize());

		dryCompute(newRect, frame, newInfo);

		return;

	}

	//If the fx can't handle the whole affine passed with the TRenderSettings, the part

	//of it that the fx can't handle is retained and applied by an affine transformer fx (TrFx)

	//after the node has been computed.

	bool canHandleAffine = canHandle(info, frame) || (handledAffine(info, frame) == info.m_affine);

	if (!info.m_affine.isIdentity() && !canHandleAffine) {

		TrFx *transformerFx = new TrFx;

		TFxP locker(transformerFx);

		transformerFx->setFx(this);

		transformerFx->dryCompute(rect, frame, info);

		return;

	}

	string alias = getAlias(frame, info) + "[" + ::traduce(info.m_affine) + "][" + ::toString(info.m_bpp) + "]";

	int renderStatus = TRenderer::instance().getRenderStatus(TRenderer::renderId());

	TFxCacheManager *cacheManager = TFxCacheManager::instance();

	if (renderStatus == TRenderer::FIRSTRUN) {

		TRectD bbox;

		//ret = getBBox... puo' darsi che l'enlarge del trFx (o naturale del bbox) faccia

		//diventare TRectD() non vuoto!!

		getBBox(frame, bbox, info);

		enlargeToI(bbox);

		TRectD interestingRect(rect * bbox);

		if (myIsEmpty(interestingRect))

			return;

		//Declare the tile to the tiles manager

		ResourceBuilder::declareResource(

			alias, this,

			interestingRect, frame, info);

		doDryCompute(interestingRect, frame, info);

	} else {

		TRectD bbox;

		getBBox(frame, bbox, info);

		enlargeToI(bbox);

		TRectD interestingRect(rect * bbox);

		if (myIsEmpty(interestingRect))

			return;

		//Invoke the fx-specific simulation process

		FxResourceBuilder rBuilder(alias, this, info, frame);

		rBuilder.simBuild(interestingRect);

	}

}

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

//! Declares the computation scheme of this fx for rendering optimization purposes.

//! This is an important function of the Toonz rendering API, and should be reimplemented

//! with the necessary care.

//! The Toonz rendering process makes use of this function to enact most of the

//! optimization steps about the fx computation, in particular fx caching.

//! A correct implementation of this method should follow these rules:

//! 
 The invocation of child node computations should be faithfully reproduced.

//! 
 TRasterFx::compute and TRasterFx::allocateAndCompute calls have to be

//!      translated to TRasterFx::dryCompute calls.

//! 
 This fx is intended for precomputation stage, so the hard rendering code

//!      should be skipped here.

//! By default, this method raises a dryCompute call to each input port in increasing

//! order, using the TRasterFx::transform method to identify the tiles to be passed

//! on input precomputation.

void TRasterFx::doDryCompute(TRectD &rect,

							 double frame,

							 const TRenderSettings &info)

{

	int inputPortCount = getInputPortCount();

	for (int i = 0; i < inputPortCount; ++i) {

		TFxPort *port = getInputPort(i);

		if (port->isConnected()) {

			TRectD rectOnInput;

			TRenderSettings infoOnInput;

			TRasterFxP fx = port->getFx();

			transform(frame, i, rect, info, rectOnInput, infoOnInput);

			if (!myIsEmpty(rectOnInput))

				fx->dryCompute(rectOnInput, frame, infoOnInput);

		}

	}

}

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

//! This is an overloaded member function that deals with

//! the allocation of an input tile before invoking the TRasterFx::compute

//! method on it.

void TRasterFx::allocateAndCompute(

	TTile &tile,

	const TPointD &pos, const TDimension &size,

	TRasterP templateRas, double frame,

	const TRenderSettings &info)

{

	if (templateRas) {

		TRaster32P ras32(templateRas);

		TRaster64P ras64(templateRas);

		templateRas = 0; //Release the reference to templateRas before allocation

		TRasterP tileRas;

		if (ras32)

			tileRas = TRaster32P(size.lx, size.ly);

		else if (ras64)

			tileRas = TRaster64P(size.lx, size.ly);

		else {

			assert(false);

			return;

		}

		tile.setRaster(tileRas);

	} else {

		if (info.m_bpp == 32) {

			TRaster32P tileRas(size.lx, size.ly);

			tile.setRaster(tileRas);

		} else if (info.m_bpp == 64) {

			TRaster64P tileRas(size.lx, size.ly);

			tile.setRaster(tileRas);

		} else

			assert(false);

	}

	tile.m_pos = pos;

	compute(tile, frame, info);

}

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

//! This method supplies the actual fx rendering code.

void TRasterFx::compute(TTile &tile, double frame,

						const TRenderSettings &info)

{

	//If the render was aborted, avoid everything

	//if(TRenderer::instance().isAborted(TRenderer::renderId()))

	//  throw TException("Render canceled");

	if (checkActiveTimeRegion() && !getActiveTimeRegion().contains(frame))

		return;

	if (!getAttributes()->isEnabled() || !m_rasFxImp->isEnabled()) {

		if (getInputPortCount() == 0)

			return;

		TFxPort *port = getInputPort(0);

		//la porta 0 non deve essere una porta di controllo

		assert(port->isaControlPort() == false);

		if (port->isConnected()) {

			TRasterFxP(port->getFx())->compute(tile, frame, info);

			return;

		}

		return;

	}

	//If the input tile has a fractionary position, it is passed to the

	//rendersettings' accumulated affine. At the same time, the integer part of

	//such affine is transferred to the tile.

	TPoint intTilePos(tfloor(tile.m_pos.x), tfloor(tile.m_pos.y));

	TPointD fracTilePos(tile.m_pos.x - intTilePos.x, tile.m_pos.y - intTilePos.y);

	TPointD fracInfoTranslation(

		info.m_affine.a13 - fracTilePos.x,

		info.m_affine.a23 - fracTilePos.y);

	TPoint intInfoTranslation(tfloor(fracInfoTranslation.x), tfloor(fracInfoTranslation.y));

	TPointD newTilePos(intTilePos.x - intInfoTranslation.x, intTilePos.y - intInfoTranslation.y);

	/*-- 入力タイルの位置が、小数値を持っていた場合 --*/

	if (tile.m_pos != newTilePos) {

		/*-- RenderSettingsのaffine行列に位置ずれを足しこむ --*/

		TRenderSettings newInfo(info);

		newInfo.m_affine.a13 = fracInfoTranslation.x - intInfoTranslation.x;

		newInfo.m_affine.a23 = fracInfoTranslation.y - intInfoTranslation.y;

		/*-- タイルの位置は整数値にする --*/

		TPointD oldPos(tile.m_pos);

		tile.m_pos = newTilePos;

		compute(tile, frame, newInfo);

		tile.m_pos = oldPos;

		return;

	}

	bool canHandleAffine = canHandle(info, frame) || (handledAffine(info, frame) == info.m_affine);

	if (!info.m_affine.isIdentity() && !canHandleAffine) {

		TrFx *transformerFx = new TrFx;

		TFxP locker(transformerFx);

		transformerFx->setFx(this);

		transformerFx->compute(tile, frame, info);

		return;

	}

	//Retrieve tile's geometry

	TRectD tilePlacement = myConvert(tile.getRaster()->getBounds()) + tile.m_pos;

	//Build the fx result alias (in other words, its name)

	string alias = getAlias(frame, info) + "[" + ::traduce(info.m_affine) + "][" + ::toString(info.m_bpp) + "]"; //To be moved below

	TRectD bbox;

	getBBox(frame, bbox, info);

	enlargeToI(bbox);