#ifdef _WIN32

#ifndef UNICODE

#define UNICODE

#endif

#endif

#include "tbigmemorymanager.h"

#include "traster.h"

#include "trastercm.h"

//#include "tspecialstyleid.h"

#include "tpixel.h"

#include "tpixelgr.h"

#include "timagecache.h"

DEFINE_CLASS_CODE(TRaster, 1)

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

TRaster::TRaster(int lx, int ly, int pixelSize)

	: TSmartObject(m_classCode), m_pixelSize(pixelSize), m_lx(lx), m_ly(ly), m_wrap(lx), m_parent(0), m_bufferOwner(true), m_buffer(0), m_lockCount(0)

#ifdef _DEBUG

	  ,

	  m_cashed(false)

#endif

{

	//try

	{

		assert(pixelSize > 0);

		assert(lx > 0 && ly > 0);

		TBigMemoryManager::instance()->putRaster(this);

		//m_buffer = new UCHAR[lx*ly*pixelSize];

		if (!m_buffer) {

#ifdef _WIN32

			static bool firstTime = true;

			if (firstTime) {

				firstTime = false;

				unsigned long size = pixelSize * lx * ly;

				TImageCache::instance()->outputMap(size, "C:\\runout");

				(*TBigMemoryManager::instance()->m_runOutCallback)(size);

			}

#endif

			return;

		}

		// TBigMemoryManager::instance()->checkConsistency();

		//m_totalMemory += ((lx*ly*pixelSize)>>10);

	}

	/* catch(...) 

    {

    TImageCache::instance()->putAllOnDisk();

    m_buffer = BigMemoryManager.getMemoryChunk(lx*ly*pixelSize, this);

    //m_buffer = new UCHAR[lx*ly*pixelSize];

    m_totalMemory += ((lx*ly*pixelSize)>>10);

    #ifdef _WIN32

    MessageBox( NULL, "Run out of contiguos phisical memory: please save all and restart toonz!", "Warning", MB_OK);

    #endif

    }*/

}

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

TRaster::TRaster(int lx, int ly, int pixelSize,

				 int wrap, UCHAR *buffer, TRaster *parent, bool bufferOwner)

	: TSmartObject(m_classCode), m_pixelSize(pixelSize), m_lx(lx), m_ly(ly), m_wrap(wrap), m_buffer(buffer), m_bufferOwner(bufferOwner), m_lockCount(0)

#ifdef _DEBUG

	  ,

	  m_cashed(false)

#endif

{

	if (parent) {

		assert(bufferOwner == false);

		while (parent->m_parent)

			parent = parent->m_parent;

		parent->addRef();

	}

#ifdef _DEBUG

	else if (bufferOwner)

		TBigMemoryManager::instance()->m_totRasterMemInKb += ((m_lx * m_ly * m_pixelSize) >> 10);

#endif

	m_parent = parent;

	assert(pixelSize > 0);

	assert(lx > 0 && ly > 0);

	assert(wrap >= lx);

	assert(m_buffer);

	//if (parent)

	TBigMemoryManager::instance()->putRaster(this);

	//  TBigMemoryManager::instance()->checkConsistency();

}

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

//TAtomicVar TRaster::m_totalMemory;

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

//unsigned long TRaster::getTotalMemoryInKB(){ return m_totalMemory;}

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

TRaster::~TRaster()

{

	bool parent = false;

#ifdef _DEBUG

//TBigMemoryManager::instance()->checkConsistency();

#endif

	//bool ret =

	TBigMemoryManager::instance()->releaseRaster(this);

#ifdef _DEBUG

//TBigMemoryManager::instance()->checkConsistency();

#endif

	if (m_parent) {

		assert(!m_bufferOwner);

		m_parent->release();

		m_parent = 0;

		parent = true;

	}

	//if(m_buffer && m_bufferOwner)

	//  {

	//delete [] m_buffer;

	//m_totalMemory += -((m_lx*m_ly*m_pixelSize)>>10);

	//assert(m_totalMemory>=0);

	//  }

	//  UCHAR* aux = m_buffer;

	m_buffer = 0;

#ifdef _DEBUG

//TBigMemoryManager::instance()->checkConsistency();

#endif

}

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

void TRaster::beginRemapping()

{

	m_mutex.lock();

}

void TRaster::endRemapping()

{

	m_mutex.unlock();

}

/*

 void TRaster::lock() 

   {

   if (m_parent) m_parent->lock();

   else  ++m_lockCount;

   //TBigMemoryManager::instance()->lock(m_parent?(m_parent->m_buffer):m_buffer);

   }

 void TRaster::unlock()

   {

   if (m_parent) m_parent->unlock();

   else  

     {

     assert(m_lockCount>0);

     --m_lockCount;

     }

   //TBigMemoryManager::instance()->unlock(m_parent?(m_parent->m_buffer):m_buffer);

   }

*/

/*

template<class t=""></class>

  TRasterT<t>::TRasterT<t>(int lx, int ly) : TRaster(lx,ly,sizeof(T)) {}</t></t>

  // utilizzo di un raster preesistente

  template<class t=""></class>

  TRasterT<t>::TRasterT<t>(int lx, int ly, int wrap, T *buffer, TRasterT<t> *parent) </t></t></t>

     : TRaster(lx,ly,sizeof(T), wrap

     , reinterpret_cast<uchar*>(buffer), parent) {}</uchar*>

*/

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

void TRaster::fillRawData(const UCHAR *color)

{

	if (m_lx == 0 || m_ly == 0)

		return;

	// N.B. uso la convenzione stl per end()

	const int wrapSize = m_wrap * m_pixelSize;

	const int rowSize = m_lx * m_pixelSize;

	UCHAR *buf1 = m_parent ? m_parent->m_buffer : m_buffer;

	lock();

	unsigned char *firstPixel = getRawData();

	const unsigned char *lastPixel = firstPixel +

									 wrapSize * (m_ly - 1) + m_pixelSize * (m_lx - 1);

	// riempio la prima riga

	unsigned char *pixel = firstPixel;

	const unsigned char *endpixel = firstPixel + rowSize;

	while (pixel < endpixel) {

		assert(firstPixel <= pixel && pixel <= lastPixel);

		::memcpy(pixel, color, m_pixelSize);

		pixel += m_pixelSize;

	}

	// riempio le altre

	pixel += wrapSize - rowSize;

	const unsigned char *endrow = pixel + wrapSize * (m_ly - 1);

	while (pixel < endrow) {

		assert(firstPixel <= pixel && pixel + rowSize - m_pixelSize <= lastPixel);

		::memcpy(pixel, firstPixel, rowSize);

		pixel += wrapSize;

	}

	UCHAR *buf2 = m_parent ? m_parent->m_buffer : m_buffer;

	unlock();

}

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

void TRaster::fillRawDataOutside(const TRect &rect, const unsigned char *pixel)

{

	if (m_lx == 0 || m_ly == 0)

		return;

	TRect r = rect * getBounds();

	if (r.isEmpty())

		return;

	if (r.y0 > 0) // fascia "inferiore"

	{

		TRect bounds(0, 0, m_lx - 1, r.y0 - 1);

		extract(bounds)->fillRawData(pixel);

	}

	if (rect.y1 < m_ly - 1) // fascia "superiore"

	{

		TRect bounds(0, r.y1 + 1, m_lx - 1, m_ly - 1);

		extract(bounds)->fillRawData(pixel);

	}

	if (rect.x0 > 0) // zona "a sinistra"

	{

		TRect bounds(0, r.y0, r.x0 - 1, r.y1);

		extract(bounds)->fillRawData(pixel);

	}

	if (rect.x1 < m_lx - 1) // zona "a destra"

	{

		TRect bounds(r.x1 + 1, r.y0, m_lx - 1, r.y1);

		extract(bounds)->fillRawData(pixel);

	}

}

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

void TRaster::copy(const TRasterP &src0, const TPoint &offset)

{

	assert(m_pixelSize == src0->getPixelSize());

	TRect rect = getBounds() * (src0->getBounds() + offset);

	if (rect.isEmpty())

		return;

	TRasterP dst = extract(rect);

	TRect r(rect);

	r -= offset;

	//TRasterP src = src0->extract(rect - offset);

	TRasterP src = src0->extract(r);

	assert(dst->getSize() == src->getSize());

	dst->lock();

	src0->lock();

	if (dst->getLx() == dst->getWrap() && src->getLx() == src->getWrap()) {

		int size = rect.getLx() * rect.getLy() * m_pixelSize;

		::memcpy(dst->getRawData(), src->getRawData(), size);

	} else {

		int rowSize = dst->getLx() * m_pixelSize;

		int srcWrapSize = src->getWrap() * m_pixelSize;

		int dstWrapSize = dst->getWrap() * m_pixelSize;

		const UCHAR *srcRow = src->getRawData();

		UCHAR *dstRow = dst->getRawData();

		UCHAR *maxDstRow = dstRow + dstWrapSize * dst->getLy();

		while (dstRow < maxDstRow) {

			::memcpy(dstRow, srcRow, rowSize);

			dstRow += dstWrapSize;

			srcRow += srcWrapSize;

		}

	}

	dst->unlock();

	src0->unlock();

}

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

void TRaster::yMirror()

{

	const int rowSize = m_lx * m_pixelSize;

	const int wrapSize = m_wrap * m_pixelSize;

	std::unique_ptr<uchar[]> auxBuf(new UCHAR[rowSize]);</uchar[]>

	lock();

	UCHAR *buff1 = getRawData();

	UCHAR *buff2 = getRawData(0, (m_ly - 1));

	while (buff1 < buff2) {

		::memcpy(auxBuf.get(), buff1, rowSize);

		::memcpy(buff1, buff2, rowSize);

		::memcpy(buff2, auxBuf.get(), rowSize);

		buff1 += wrapSize;

		buff2 -= wrapSize;

	}

	unlock();

}

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

void TRaster::xMirror()

{

	const int wrapSize = m_wrap * m_pixelSize;

	const int lastPixelOffset = (m_lx - 1) * m_pixelSize;

	std::unique_ptr<uchar[]> auxBuf(new UCHAR[m_pixelSize]);</uchar[]>

	lock();

	UCHAR *row = getRawData();

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

		UCHAR *a = row, *b = row + lastPixelOffset;

		while (a < b) {

			::memcpy(auxBuf.get(), a, m_pixelSize);

			::memcpy(a, b, m_pixelSize);

			::memcpy(b, auxBuf.get(), m_pixelSize);

			a += m_pixelSize;

			b -= m_pixelSize;

		}

		row += wrapSize;

	}

	unlock();

}

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

void TRaster::rotate180()

{

	//const int rowSize = m_lx * m_pixelSize;

	const int wrapSize = m_wrap * m_pixelSize;

	std::unique_ptr<uchar[]> auxBuf(new UCHAR[m_pixelSize]);</uchar[]>

	lock();

	UCHAR *buff1 = getRawData();

	UCHAR *buff2 = buff1 + wrapSize * (m_ly - 1) + m_pixelSize * (m_lx - 1);

	if (m_wrap == m_lx) {

		while (buff1 < buff2) {

			::memcpy(auxBuf.get(), buff1, m_pixelSize);

			::memcpy(buff1, buff2, m_pixelSize);

			::memcpy(buff2, auxBuf.get(), m_pixelSize);

			buff1 += m_pixelSize;

			buff2 -= m_pixelSize;

		}

	} else {

		for (int y = 0; y < m_ly / 2; y++) {

			UCHAR *a = buff1, *b = buff2;

			for (int x = 0; x < m_lx; x++) {

				::memcpy(auxBuf.get(), a, m_pixelSize);

				::memcpy(a, b, m_pixelSize);

				::memcpy(b, auxBuf.get(), m_pixelSize);

				a += m_pixelSize;

				b -= m_pixelSize;

			}

			buff1 += wrapSize;

			buff2 -= wrapSize;

		}

	}

	unlock();

}

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

void TRaster::rotate90()

{

	/*

	UCHAR *auxBuf= new UCHAR[m_pixelSize];

  for(int y=m_ly;y>0;y--)

  {

	UCHAR *a = getRawData() + wrapSize * (y-1) + m_pixelSize * (m_lx-1);

    for (int x=m_lx-1;x>=0;x--)

	{

	  UCHAR *b = a - (m_ly-1)*m_pixelSize *(m_lx-x);

	  ::memcpy(auxBuf,  a,   m_pixelSize);

	  ::memcpy(a,       b,   m_pixelSize);

	  ::memcpy(b,    auxBuf, m_pixelSize); 

	  a-=m_pixelSize;

	}

  }

 */

}

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

void TRaster::clear()

{

	TRasterCM32 *ras = dynamic_cast<trastercm32 *="">(this);</trastercm32>

	if (ras) {

		// ras->fill(TPixelCM32(0,BackgroundStyle,TPixelCM32::getMaxTone()));

		ras->fill(TPixelCM32());

	} else {

		const int rowSize = getRowSize();

		lock();

		if (m_wrap == m_lx) {

			int bufferSize = rowSize * m_ly;

			memset(getRawData(), 0, bufferSize);

		} else

			for (int y = m_ly - 1; y >= 0; y--) {

				UCHAR *buffer = getRawData(0, y);

				memset(buffer, 0, rowSize);

			}

		unlock();

	}

}

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

void TRaster::remap(UCHAR *newLocation)

{

	if (m_parent) {

		assert(m_parent->m_buffer > newLocation);

		assert(m_parent->m_parent == 0);

		int offset = (int)(m_buffer - m_parent->m_buffer);

		assert(offset >= 0);

		//m_parent->remap(newLocation);

		m_buffer = newLocation + offset;

	} else {

		assert(m_buffer > newLocation);

		m_buffer = newLocation;

	}

}

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

void TRaster::clearOutside(const TRect &rect)

{

	if (m_lx == 0 || m_ly == 0)

		return;

	TRect r = rect * getBounds();

	if (r.isEmpty())

		return;

	if (r.y0 > 0) // fascia "inferiore"

	{

		TRect bounds(0, 0, m_lx - 1, r.y0 - 1);

		extract(bounds)->clear();

	}

	if (rect.y1 < m_ly - 1) // fascia "superiore"

	{

		TRect bounds(0, r.y1 + 1, m_lx - 1, m_ly - 1);

		extract(bounds)->clear();

	}

	if (rect.x0 > 0) // zona "a sinistra"

	{

		TRect bounds(0, r.y0, r.x0 - 1, r.y1);

		extract(bounds)->clear();

	}

	if (rect.x1 < m_lx - 1) // zona "a destra"

	{

		TRect bounds(r.x1 + 1, r.y0, m_lx - 1, r.y1);

		extract(bounds)->clear();

	}

}