#include "tsystem.h"

#include "tcachedlevel.h"

#include "tcodec.h"

#include "texception.h"

//#include "tcachedlevel.h"

//#include "tcodec.h"

#include "tconvert.h"

#ifdef LINUX

#include "texception.h"

//#include "tsystem.h"

#include <unistd.h></unistd.h>

#include <sys mman.h=""></sys>

#include <sys types.h=""></sys>

#include <sys stat.h=""></sys>

#include <fcntl.h></fcntl.h>

#endif

#ifdef MACOSX

#include "sys/mman.h"

#include "sys/errno.h"

#endif

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

#define DWORDLONG_LO_DWORD(dwl64) ((DWORD)(dwl64))

#define DWORDLONG_HI_DWORD(dwl64) ((DWORD)(dwl64 >> 32))

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

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

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

//              TDiskCachePersist

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

class ImpPD

{

public:

	ImpPD(const TFilePath &fn)

		: m_fname(fn), m_chunkSize(0), m_currentFileSize(0), m_fileMapAddress(0), m_mapOffset(0)

	{

		TFileStatus fileStatus(fn);

		if (fileStatus.doesExist())

			m_currentFileSize = fileStatus.getSize();

		else

			m_currentFileSize = ImpPD::m_defaultFileSize;

	};

	virtual ~ImpPD() {}

	virtual void openFile(const TFilePath &, TINT64 fileSize) = 0;

	virtual void setCurrentView(int pos, int &newLowPos, int &newHiPos) = 0;

	TFilePath m_fname;

	TINT64 m_chunkSize;

	TINT64 m_currentFileSize;

	void *m_fileMapAddress;

	TINT64 m_mapOffset;

	// quantita' espresse in byte

	static TINT64 m_defaultFileSize;

	TUINT32 m_viewSize;

	TINT64 m_reallocSize;

};

TINT64 ImpPD::m_defaultFileSize(100 * 1024 * 1024);

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

class TDiskCachePersist::Imp

{

public:

	Imp(const TFilePath &fp);

	~Imp();

	bool put(int frame, UCHAR *data, TUINT32 dataSize);

	UCHAR *get(int pos, TUINT32 *size);

	void openFile(const TFilePath &fp, TINT64 fileSize);

	void setCurrentView(int frame)

	{

		if (!m_force && ((m_lowFrame <= frame) && (frame < m_hiFrame)))

			return; //la vista corrente gia' copre il frame

		m_force = false;

		m_impPD->setCurrentView(frame, m_lowFrame, m_hiFrame);

	}

	ImpPD *m_impPD;

	int m_lowFrame, m_hiFrame;

	TThread::Mutex m_mutex;

	bool m_force;

};

#ifdef WIN32

class ImpPDW : public ImpPD

{

private:

	string getLastErrorMessage()

	{

		LPVOID lpMsgBuf;

		DWORD err = GetLastError();

		FormatMessage(

			FORMAT_MESSAGE_ALLOCATE_BUFFER |

				FORMAT_MESSAGE_FROM_SYSTEM |

				FORMAT_MESSAGE_IGNORE_INSERTS,

			NULL,

			err,

			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language

			(LPTSTR)&lpMsgBuf,

			0,

			NULL);

		string msg((LPCTSTR)lpMsgBuf);

		// Free the buffer.

		LocalFree(lpMsgBuf);

		return msg;

	}

public:

	ImpPDW(const TFilePath &fp);

	~ImpPDW();

	void openFile(const TFilePath &fname, TINT64 fileSize);

	void setCurrentView(int pos, int &newLowPos, int &newHiPos);

private:

	HANDLE m_hFile;

	HANDLE m_hMap;

	SYSTEM_INFO m_systemInfo;

};

#else

class ImpPDX : public ImpPD

{

private:

	class TCachedLevelException : public TException

	{

		static string msgFromErrorCode(int errorCode)

		{

			switch (errorCode) {

			case EBADF:

				return " fd is not a valid file descriptor  (and  MAP_ANONY­MOUS was not set).";

				break;

			/*

    case EACCES_MAP_PRIVATE:

      return "Map private was requested, but fd is not open for reading. Or MAP_SHARED was requested and PROT_WRITE is set, but fd is not open in read/write O_RDWR) mode.";

    break;

*/

			case EINVAL:

				return "We don't like start or length  or  offset.   (E.g., they  are  too  large, or not aligned on a PAGESIZE boundary.)";

				break;

			case ETXTBSY:

				return "MAP_DENYWRITE was set but the object  specified  by fd is open for writing.";

				break;

			case EAGAIN:

				return "The  file  has  been locked, or too much memory has been locked.";

				break;

			case ENOMEM:

				return "No memory is available.";

				break;

			default:

				char *sysErr = strerror(errorCode);

				ostrstream os;

				os << errorCode << '\0';

				os.freeze(false);

				return string(sysErr) + "(" + os.str() + ")";

				break;

			}

			return "";

		}

	public:

		TCachedLevelException(int errorCode)

			: TException(msgFromErrorCode(errorCode))

		{

		}

		~TCachedLevelException() {}

	};

public:

	ImpPDX(const TFilePath &fp);

	~ImpPDX();

	void openFile(const TFilePath &fname, TINT64 fileSize);

	void setCurrentView(int pos, int &newLowPos, int &newHiPos);

private:

	int m_fd;

	size_t m_pageSize;

};

#endif

//  HIGH

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

TDiskCachePersist::TDiskCachePersist(TRasterCodec *codec, const TFilePath &fp)

	: TCachePersist(codec), m_imp(new Imp(fp))

{

}

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

TDiskCachePersist::~TDiskCachePersist()

{

	delete m_imp;

}

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

void TDiskCachePersist::setFrameSize(int lx, int ly, int bpp)

{

	m_imp->m_impPD->m_chunkSize = lx * ly * (bpp >> 3) + m_codec->getHeaderSize();

	m_imp->m_force = true;

}

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

TRasterP TDiskCachePersist::doGetRaster(int frame)

{

	TRasterP rasP;

	TUINT32 size;

	UCHAR *src = m_imp->get(frame, &size);

	m_codec->decompress(src, size, rasP);

	delete[] src;

	return rasP;

}

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

bool TDiskCachePersist::doGetRaster(int frame, TRaster32P &ras) const

{

	assert(false);

	return false;

}

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

bool TDiskCachePersist::doPutRaster(int frame, const TRasterP &ras)

{

	UCHAR *outData = 0;

	TINT32 outDataSize = 0;

	m_codec->compress(ras, 1, &outData, outDataSize);

	bool cached = m_imp->put(frame, outData, outDataSize);

	delete[] outData;

	return cached;

}

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

UCHAR *TDiskCachePersist::getRawData(int frame, TINT32 &size, int &lx, int &ly)

{

	TUINT32 inDataSize;

	UCHAR *src = m_imp->get(frame, &inDataSize);

	return m_codec->removeHeader(src, inDataSize, size, lx, ly);

}

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

// MEDIUM

TDiskCachePersist::Imp::Imp(const TFilePath &fp)

	: m_impPD(0)

{

#ifdef WIN32

	m_impPD = new ImpPDW(fp);

#else

	m_impPD = new ImpPDX(fp);

#endif

	m_impPD->m_currentFileSize = TFileStatus(fp).doesExist() ? TFileStatus(fp).getSize() : 0; // per gli arrotondamenti...

}

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

TDiskCachePersist::Imp::~Imp()

{

	delete m_impPD;

}

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

// LOW

#ifdef WIN32

ImpPDW::ImpPDW(const TFilePath &fp)

	: ImpPD(fp), m_hFile(0), m_hMap(0)

{

	GetSystemInfo(&m_systemInfo);

	m_viewSize = 100 * 1024 * 1024;

	m_reallocSize = 250 * 1024 * 1024;

	TINT64 allocUnitCount = m_reallocSize / m_systemInfo.dwAllocationGranularity;

	// rendo m_reallocSize multiplo di m_systemInfo.dwAllocationGranularity

	if ((m_reallocSize % m_systemInfo.dwAllocationGranularity) != 0)

		++allocUnitCount;

	m_reallocSize = allocUnitCount * m_systemInfo.dwAllocationGranularity;

	TINT64 fileSize = m_defaultFileSize;

	TFileStatus fileStatus(fp);

	if (fileStatus.doesExist())

		fileSize = fileStatus.getSize();

	try {

		openFile(fp, fileSize);

	} catch (TException &e) {

		m_currentFileSize = 0;

		throw e;

	}

	m_currentFileSize = fileSize;

}

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

ImpPDW::~ImpPDW()

{

	if (m_fileMapAddress)

		UnmapViewOfFile(m_fileMapAddress);

	CloseHandle(m_hMap);

	CloseHandle(m_hFile);

}

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

void ImpPDW::openFile(const TFilePath &fname, TINT64 fileSize)

{

	DWORD dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;

	DWORD dwShareMode = 0; // dwShareMode == 0 --> accesso esclusivo

	// lpSecurityAttributes == NULL --> l'handle non puo' essere

	// ereditato da processi figli

	LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL;

	DWORD dwCreationDisposition = OPEN_ALWAYS;				//CREATE_ALWAYS;

	DWORD dwFlagsAndAttributes = FILE_FLAG_SEQUENTIAL_SCAN; //FILE_ATTRIBUTE_NORMAL;//

	HANDLE hTemplateFile = NULL;

	m_hFile = CreateFileW(

		fname.getWideString().c_str(), // file name

		dwDesiredAccess,			   // access mode

		dwShareMode,				   // share mode

		NULL,						   // SD

		dwCreationDisposition,		   // how to create

		dwFlagsAndAttributes,		   // file attributes

		hTemplateFile				   // handle to template file

		);

	if (m_hFile == INVALID_HANDLE_VALUE) {

		string errMsg = getLastErrorMessage();

		throw TException(wstring(L"Unable to open cache file: ") + fname.getWideString() + L"\n" + toWideString(errMsg));

	}

	DWORD flProtect = PAGE_READWRITE;

	DWORD dwMaximumSizeHigh = DWORDLONG_HI_DWORD(fileSize);

	DWORD dwMaximumSizeLow = DWORDLONG_LO_DWORD(fileSize);

	LPCTSTR lpName = NULL; // l'oggetto non ha nome

	m_hMap = CreateFileMapping(

		m_hFile,		   // handle to file

		NULL,			   // security

		flProtect,		   // protection

		dwMaximumSizeHigh, // high-order DWORD of size

		dwMaximumSizeLow,  // low-order DWORD of size

		lpName			   // object name

		);

	if (m_hMap == NULL) {

		string errMsg = getLastErrorMessage();

		CloseHandle(m_hFile);

		m_hFile = 0;

		throw TException("Unable to create file mapping. " + errMsg);

	}

}

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

void ImpPDW::setCurrentView(int frame, int &newLowFrame, int &newHiFrame)

{

	if (m_fileMapAddress)

		UnmapViewOfFile(m_fileMapAddress);

	newLowFrame = frame;

	newHiFrame = newLowFrame + TINT32(m_viewSize / m_chunkSize);

	DWORD allocGranularity = m_systemInfo.dwAllocationGranularity;

	TINT64 viewOffset = (TINT64(newLowFrame * m_chunkSize) / allocGranularity) * allocGranularity;

	m_mapOffset = newLowFrame * m_chunkSize - viewOffset;

	TINT64 fileSize = newHiFrame * m_chunkSize;

	if ((fileSize > m_currentFileSize) || !m_hMap) // devo riallocare!

	{

		CloseHandle(m_hMap);

		m_hMap = 0;

		CloseHandle(m_hFile);

		m_hFile = 0;

		TINT64 allocUnitCount = fileSize / m_reallocSize;

		// rendo fileSize multiplo di m_reallocSize

		if ((fileSize % m_reallocSize) != 0)

			++allocUnitCount;

		fileSize = allocUnitCount * m_reallocSize;

		openFile(m_fname, fileSize);

		m_currentFileSize = fileSize;

	}

	DWORD dwDesiredAccess = FILE_MAP_WRITE;

	m_fileMapAddress = MapViewOfFile(m_hMap,						 // handle to file-mapping object

									 dwDesiredAccess,				 // access mode: Write permission

									 DWORDLONG_HI_DWORD(viewOffset), // high-order DWORD of offset: Max. object size.

									 DWORDLONG_LO_DWORD(viewOffset), // low-order DWORD of offset: Size of hFile.

									 m_viewSize);					 // number of bytes to map

	if (m_fileMapAddress == NULL) {

		string errMsg = getLastErrorMessage();

		CloseHandle(m_hMap);

		m_hMap = 0;

		CloseHandle(m_hFile);

		m_hFile = 0;

		throw TException("Unable to memory map cache file. " + errMsg);

	}

}

#else

ImpPDX::ImpPDX(const TFilePath &fp)

	: ImpPD(fp), m_fd(-1)

{

	//std::cout << "cache file " << toString(m_fname.getFullPath()) << std::endl;

	m_pageSize = getpagesize();

	openFile(m_fname, 0);

	assert(m_fd >= 0);

}

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

ImpPDX::~ImpPDX()

{

	if (m_fileMapAddress)

		munmap(m_fileMapAddress, m_viewSize);

	close(m_fd);

	m_fd = 0;

}

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

void ImpPDX::openFile(const TFilePath &fname, TINT64 fileSize)

{

	assert(0);

	/*

string fn(toString(fname.getWideString()));

std::cout << "open " << fn << std::endl;

m_fd = open(fn.c_str(), O_RDWR|O_CREAT, 00666);

assert(m_fd >=0);

*/

}

void ImpPDX::setCurrentView(int pos, int &newLowPos, int &newHiPos)

{

	newLowPos = pos;

	newHiPos = newLowPos + (m_viewSize / m_chunkSize);

	assert(m_fd >= 0);

	if (m_fileMapAddress) //previous view...

		if (munmap(m_fileMapAddress, m_viewSize) != 0)

			throw TCachedLevelException(errno);

	void *start = 0;

	int flags = MAP_SHARED;

	size_t viewOffset = ((newLowPos * m_chunkSize) / m_pageSize) * m_pageSize;

	m_mapOffset = newLowPos * m_chunkSize - viewOffset;

	assert(!"controllare le dimensioni");

	unsigned long lastByte = (unsigned long)(((newHiPos * m_chunkSize) / (double)m_pageSize + 0.5) * m_pageSize);

	if (lastByte > m_currentFileSize) // devo riallocare!

	{

		unsigned long bu = (unsigned long)((lastByte / (double)m_reallocSize + 0.5) * m_reallocSize);

		bu = (unsigned long)((bu / (double)m_pageSize + 0.5) * m_pageSize);

		//m_maxFileSize = tmax(m_maxFileSize + m_reallocFileSize, lastByte);

		m_currentFileSize += bu;

		std::cout << "new cache size " << m_currentFileSize << std::endl;

		if (lseek(m_fd, m_currentFileSize, SEEK_SET) == -1)

			throw TCachedLevelException(errno);

		if (write(m_fd, "", 1) == -1)

			throw TCachedLevelException(errno);

		if (ftruncate(m_fd, m_currentFileSize) == -1)

			throw TCachedLevelException(errno);

	}

	m_fileMapAddress = mmap(start, m_viewSize, PROT_READ | PROT_WRITE, flags, m_fd, viewOffset);

	if (m_fileMapAddress == (void *)-1)

		throw TCachedLevelException(errno);

}

#endif

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

#ifndef WIN32

#define ULONGLONG unsigned long long

#endif

bool TDiskCachePersist::Imp::put(int frame, UCHAR *data, TUINT32 dataSize)

{

	if (dataSize != m_impPD->m_chunkSize)

		return false;

	TThread::ScopedLock sl(m_mutex);

	setCurrentView(frame);

	ULONGLONG offset = (frame - m_lowFrame) * m_impPD->m_chunkSize;

	UCHAR *dst = (UCHAR *)m_impPD->m_fileMapAddress + offset;

	memcpy(dst + m_impPD->m_mapOffset, data, dataSize);

	return true;

}

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

UCHAR *TDiskCachePersist::Imp::get(int pos, TUINT32 *size)

{

	UCHAR *ret = new UCHAR[TINT32(m_impPD->m_chunkSize)];

	TThread::ScopedLock sl(m_mutex);

	setCurrentView(pos);

	ULONGLONG offset = (pos - m_lowFrame) * m_impPD->m_chunkSize;

	UCHAR *src = (UCHAR *)m_impPD->m_fileMapAddress + offset + m_impPD->m_mapOffset;

	memcpy(ret, src, TINT32(m_impPD->m_chunkSize));

	*size = TUINT32(m_impPD->m_chunkSize);

	return ret;

}

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

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

// TRasterCache

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

class TRasterCache::Data

{

public:

	Data(TCachePersist *cp)

		: m_cp(cp), m_size(0, 0), m_prefetchEnabled(false), m_prefetchedFrame(-1), m_frameToPrefetch(-1), m_preLoader(1, true)

	{

	}

	~Data() {}

	class FrameData

	{

	public:

		bool m_valid;

		//  int m_size; // dimensione in byte del raster codificato

		~FrameData() {}

	};

	bool isFrameCached(int frame) const;

	TDimension m_size; // dimensioni dei raster in cache

	int m_bpp;

	typedef map<int, framedata=""> Status;</int,>

	Status m_status;

	TCachePersist *m_cp;

	TThread::Mutex m_accessMutex;

	TThread::Executor m_preLoader;

	bool m_prefetchEnabled;

	int m_prefetchedFrame;

	int m_frameToPrefetch;

	TRasterP m_prefetchedRas;

};

bool TRasterCache::Data::isFrameCached(int frame) const

{

	// volutamente senza ScopedLock

	Data::Status::const_iterator it = m_status.find(frame);

	if (it == m_status.end())

		return false;

	Data::FrameData fd = it->second;

	return fd.m_valid;

}

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

namespace

{

class Load : public TThread::Runnable

{

public:

	Load(int frameToPrefetch, TCachePersist *cp, int &prefetchedFrame, TRasterP &prefetchedRas)

		: m_frame(frameToPrefetch), m_cp(cp), m_prefetchedFrame(prefetchedFrame), m_prefetchedRas(prefetchedRas) {}

	void run();

private:

	int m_frame;

	TCachePersist *m_cp;

	int &m_prefetchedFrame;

	TRasterP &m_prefetchedRas;

};

void Load::run()

{

	m_prefetchedRas = m_cp->doGetRaster(m_frame);

	m_prefetchedFrame = m_frame;

}

};

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

TRasterCache::TRasterCache(TCachePersist *cp)

	: m_data(new Data(cp))

{

}

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

TRasterCache::~TRasterCache()

{

	delete m_data;

}

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

void TRasterCache::setMode(const TDimension &size, int bpp)

{

	TThread::ScopedLock sl(m_data->m_accessMutex);

	m_data->m_size = size; // dimensioni dei raster in cache

	m_data->m_bpp = bpp;

	m_data->m_cp->setFrameSize(size.lx, size.ly, bpp);

	invalidate();

}

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

void TRasterCache::getMode(TDimension &size, int &bpp) const

{

	size = m_data->m_size; // dimensioni dei raster in cache

	bpp = m_data->m_bpp;

}

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

TRasterP TRasterCache::getRaster(int frame) const

{

	TThread::ScopedLock sl(m_data->m_accessMutex);

	if (m_data->m_prefetchEnabled) {

		/*

    if (frame == m_data->m_frameToPrefetch)

      m_data->m_preLoader.wait();

    else

  */

		{

			m_data->m_preLoader.clear();

			//m_data->m_preLoader.cancel();

		}

		TRasterP ras;

		if (frame == m_data->m_prefetchedFrame)

			ras = m_data->m_prefetchedRas;

		else

			ras = m_data->m_cp->doGetRaster(frame);

		if (isFrameCached(frame + 1)) {

			// il frame successivo a quello richiesto e' nella cache

			// -> avvia il prefetch di tale raster

			m_data->m_frameToPrefetch = frame + 1;

			m_data->m_preLoader.addTask(

				new Load(m_data->m_frameToPrefetch, m_data->m_cp,

						 m_data->m_prefetchedFrame, m_data->m_prefetchedRas));

		}

		return ras;

	} else {

		return m_data->m_cp->doGetRaster(frame);

	}

}

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

bool TRasterCache::getRaster(int frame, TRaster32P &ras) const

{

	TThread::ScopedLock sl(m_data->m_accessMutex);

	if (m_data->isFrameCached(frame)) {

		bool rc = m_data->m_cp->doGetRaster(frame, ras);

		assert(rc);

		return true;

	} else

		return false;

}

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

void TRasterCache::putRaster(int frame, const TRasterP &ras)

{

	TThread::ScopedLock sl(m_data->m_accessMutex);

	Data::Status::iterator it = m_data->m_status.find(frame);

	bool cached = false;

	try {

		cached = m_data->m_cp->doPutRaster(frame, ras);

	} catch (TException &e) {

		if (it != m_data->m_status.end()) {

			Data::FrameData fd;

			fd.m_valid = false;

			m_data->m_status[frame] = fd;

		}

		throw e;

	}

	if (cached) {

		Data::FrameData fd;

		fd.m_valid = true;

		m_data->m_status[frame] = fd;

	}

}

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

UCHAR *TRasterCache::getRawData(int frame, TINT32 &size, int &lx, int &ly) const

{

	return m_data->m_cp->getRawData(frame, size, lx, ly);

}

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

bool TRasterCache::isFrameCached(int frame) const

{

	TThread::ScopedLock sl(m_data->m_accessMutex);

	return m_data->isFrameCached(frame);

}

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

void TRasterCache::invalidate()

{

	TThread::ScopedLock sl(m_data->m_accessMutex);

	m_data->m_status.clear();

	m_data->m_cp->onInvalidate();

}

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

void TRasterCache::invalidate(int startFrame, int endFrame)

{

	assert(startFrame <= endFrame);

	TThread::ScopedLock sl(m_data->m_accessMutex);

	Data::Status::iterator low = m_data->m_status.lower_bound(startFrame);

	Data::Status::iterator hi = m_data->m_status.upper_bound(endFrame);

#ifdef _DEBUG

	int count = m_data->m_status.size();

	if (low != m_data->m_status.end() && hi != m_data->m_status.end()) {

		int ll = low->first;

		int hh = hi->first;

		assert(ll <= hh);

	}

#endif

	if (low != m_data->m_status.end()) {

		m_data->m_status.erase(low, hi);

		m_data->m_cp->onInvalidate(startFrame, endFrame);

	}

}

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

void TRasterCache::enablePrefetch(bool newState)

{

	m_data->m_prefetchEnabled = newState;

}

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

bool TRasterCache::isPrefetchEnabled() const

{

	return m_data->m_prefetchEnabled;

}

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

TUINT64 TRasterCache::getUsedSpace()

{

	return m_data->m_cp->getUsedSpace();

}

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

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

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

//              TRamCachePersist

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

class TRamCachePersist::Imp

{

	friend class TRamCachePersist;

public:

	Imp()

		: m_cacheSize(0), m_chunks()

	{

	}

	~Imp()

	{

		for (CompressedChunks::iterator it = m_chunks.begin(); it != m_chunks.end(); ++it) {

			CompressedChunk *cc = it->second;

			m_cacheSize -= cc->m_size;

			delete cc;

		}

		assert(m_cacheSize == 0); // se m_cacheSize > 0 mi sono perso qualche chunk

								  // se m_cacheSize < 0 ho liberato 2 volte qualche chunk

		m_chunks.clear();

	}

	class CompressedChunk

	{

	public:

		CompressedChunk(UCHAR *buffer, int size) : m_buffer(buffer), m_size(size) {}

		~CompressedChunk()

		{

			delete[] m_buffer;

		}

		UCHAR *m_buffer;

		int m_size;

	};

	typedef map<int, *="" compressedchunk=""> CompressedChunks;</int,>

	CompressedChunks m_chunks;

	TUINT64 m_cacheSize;

};

TRamCachePersist::TRamCachePersist(TRasterCodec *codec)

	: TCachePersist(codec), m_imp(new Imp)

{

}

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

TRamCachePersist::~TRamCachePersist()

{

	delete m_imp;

}

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

TRasterP TRamCachePersist::doGetRaster(int frame)

//void TRamCachePersist::doGetRaster(int frame, const TRasterP &ras)

{

	Imp::CompressedChunks::const_iterator it = m_imp->m_chunks.find(frame);

	if (it == m_imp->m_chunks.end())

		return TRasterP();

	Imp::CompressedChunk *cc = it->second;

	assert(cc);

	TRasterP rasP;

	m_codec->decompress(cc->m_buffer, cc->m_size, rasP);

	return rasP;

}

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

bool TRamCachePersist::doGetRaster(int frame, TRaster32P &ras) const

{

	Imp::CompressedChunks::const_iterator it = m_imp->m_chunks.find(frame);

	if (it == m_imp->m_chunks.end())

		return false;

	Imp::CompressedChunk *cc = it->second;

	assert(cc);

	TRasterP rasP(ras);