#ifndef _DEBUG

#undef _STLP_DEBUG

#else

#define _STLP_DEBUG 1

#endif

#ifdef TNZCORE_LIGHT

#ifdef _DEBUGTOONZ

#undef _DEBUGTOONZ

#endif

#else

#ifdef _DEBUG

#define _DEBUGTOONZ _DEBUG

#endif

#endif

#include "timagecache.h"

#include "trasterimage.h"

#ifndef TNZCORE_LIGHT

#include "tvectorimage.h"

#include "trastercm.h"

#include "tropcm.h"

#endif

#include "tcodec.h"

#include "tfilepath_io.h"

#include "tconvert.h"

#include "tsystem.h"

#include "traster.h"

//#include "tstopwatch.h"

#include "tconvert.h"

#include "tbigmemorymanager.h"

#include "tstream.h"

#include "tenv.h"

#include <deque></deque>

#include <numeric></numeric>

#include <sstream></sstream>

#ifdef WIN32

#include <crtdbg.h></crtdbg.h>

#endif

// Qt includes

#include <qthreadstorage></qthreadstorage>

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

#undef DVAPI

#undef DVVAR

#ifdef TSYSTEM_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

class ImageBuilder;

class ImageInfo;

//std::ofstream os("C:\\cache.txt");

TUINT32 HistoryCount = 0;

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

class TheCodec : public TRasterCodecLz4

{

public:

	static TheCodec *instance()

	{

		if (!_instance)

			_instance = new TheCodec();

		return _instance;

	}

	void reset()

	{

		if (_instance)

			_instance->TRasterCodecLz4::reset();

	}

private:

	static TheCodec *_instance;

	TheCodec() : TRasterCodecLz4("Lz4_Codec", false) {}

};

TheCodec *TheCodec::_instance = 0;

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

class CacheItem : public TSmartObject

{

	DECLARE_CLASS_CODE

public:

	CacheItem()

		: m_cantCompress(false), m_builder(0), m_imageInfo(0), m_modified(false) {}

	CacheItem(ImageBuilder *builder, ImageInfo *imageInfo)

		: m_cantCompress(false), m_builder(builder), m_imageInfo(imageInfo), m_historyCount(0), m_modified(false)

	{

	}

	virtual ~CacheItem() {}

	virtual TUINT32 getSize() const = 0;

	// getImage restituisce un'immagine non compressa

	virtual TImageP getImage() const = 0;

	bool m_cantCompress;

	ImageBuilder *m_builder;

	ImageInfo *m_imageInfo;

	string m_id;

	TUINT32 m_historyCount;

	bool m_modified;

};

#ifdef WIN32

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

#endif

typedef TSmartPointerT<cacheitem> CacheItemP;</cacheitem>

DEFINE_CLASS_CODE(CacheItem, 101)

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

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

class ImageInfo

{

public:

	TDimension m_size;

	ImageInfo(const TDimension &size) : m_size(size) {}

	virtual ~ImageInfo() {}

	virtual ImageInfo *clone() = 0;

};

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

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

class ImageBuilder

{

public:

	virtual ~ImageBuilder() {}

	virtual ImageBuilder *clone() = 0;

	virtual TImageP build(ImageInfo *info, const TRasterP &ras) = 0;

};

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

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

class RasterImageInfo : public ImageInfo

{

public:

	RasterImageInfo(const TRasterImageP &ri);

	void setInfo(const TRasterImageP &ri);

	ImageInfo *clone();

	double m_dpix, m_dpiy;

	string m_name;

	TRect m_savebox;

	bool m_isOpaque;

	TPoint m_offset;

	int m_subs;

};

RasterImageInfo::RasterImageInfo(const TRasterImageP &ri)

	: ImageInfo(ri->getRaster()->getSize())

{

	ri->getDpi(m_dpix, m_dpiy);

	m_name = ri->getName();

	m_savebox = ri->getSavebox();

	m_isOpaque = ri->isOpaque();

	m_offset = ri->getOffset();

	m_subs = ri->getSubsampling();

}

void RasterImageInfo::setInfo(const TRasterImageP &ri)

{

	ri->setDpi(m_dpix, m_dpiy);

	ri->setName(m_name);

	ri->setSavebox(m_savebox);

	ri->setOpaqueFlag(m_isOpaque);

	ri->setOffset(m_offset);

	ri->setSubsampling(m_subs);

}

ImageInfo *RasterImageInfo::clone()

{

	return new RasterImageInfo(*this);

}

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

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

#ifndef TNZCORE_LIGHT

#include "tpalette.h"

#include "ttoonzimage.h"

class ToonzImageInfo : public ImageInfo

{

public:

	ToonzImageInfo(const TToonzImageP &ti);

	~ToonzImageInfo()

	{

		if (m_palette)

			m_palette->release();

	}

	ImageInfo *clone()

	{

		ToonzImageInfo *ret = new ToonzImageInfo(*this);

		if (ret->m_palette)

			ret->m_palette->addRef();

		return ret;

	}

	void setInfo(const TToonzImageP &ti);

	double m_dpix, m_dpiy;

	string m_name;

	TRect m_savebox;

	TPoint m_offset;

	int m_subs;

	TPalette *m_palette;

};

ToonzImageInfo::ToonzImageInfo(const TToonzImageP &ti) : ImageInfo(ti->getSize())

{

	m_palette = ti->getPalette();

	if (m_palette)

		m_palette->addRef();

	ti->getDpi(m_dpix, m_dpiy);

	m_savebox = ti->getSavebox();

	m_offset = ti->getOffset();

	m_subs = ti->getSubsampling();

}

void ToonzImageInfo::setInfo(const TToonzImageP &ti)

{

	ti->setPalette(m_palette);

	ti->setDpi(m_dpix, m_dpiy);

	ti->setOffset(m_offset);

	ti->setSubsampling(m_subs);

}

#endif

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

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

class RasterImageBuilder : public ImageBuilder

{

public:

	ImageBuilder *clone()

	{

		return new RasterImageBuilder(*this);

	}

	TImageP build(ImageInfo *info, const TRasterP &ras);

};

TImageP RasterImageBuilder::build(ImageInfo *info, const TRasterP &ras)

{

	RasterImageInfo *riInfo = dynamic_cast<rasterimageinfo *="">(info);</rasterimageinfo>

	assert(riInfo);

	int rcount = ras->getRefCount();

	TRasterImageP ri = new TRasterImage();

#ifdef _DEBUGTOONZ

	ras->m_cashed = true;

#endif

	ri->setRaster(ras);

	riInfo->setInfo(ri);

	assert(ras->getRefCount() > rcount);

	return ri;

}

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

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

#ifndef TNZCORE_LIGHT

class ToonzImageBuilder : public ImageBuilder

{

public:

	ImageBuilder *clone()

	{

		return new ToonzImageBuilder(*this);

	}

	TImageP build(ImageInfo *info, const TRasterP &ras);

};

TImageP ToonzImageBuilder::build(ImageInfo *info, const TRasterP &ras)

{

	ToonzImageInfo *tiInfo = dynamic_cast<toonzimageinfo *="">(info);</toonzimageinfo>

	assert(tiInfo);

	TRasterCM32P rasCM32 = ras;

	assert(rasCM32);

	TRasterCM32P imgRasCM32;

	assert(TRect(tiInfo->m_size).contains(tiInfo->m_savebox));

	if (ras->getSize() != tiInfo->m_size) {

		TRasterCM32P fullRas(tiInfo->m_size);

		TRect rectToExtract(tiInfo->m_savebox);

		TPixelCM32 bgColor;

		fullRas->fillOutside(tiInfo->m_savebox, bgColor);

		fullRas->extractT(rectToExtract)->copy(ras);

		assert(rectToExtract == tiInfo->m_savebox);

		imgRasCM32 = fullRas;

	} else

		imgRasCM32 = rasCM32;

#ifdef _DEBUG

	imgRasCM32->m_cashed = true;

#endif

	TToonzImageP ti = new TToonzImage(imgRasCM32, tiInfo->m_savebox);

	tiInfo->setInfo(ti);

	return ti;

}

#endif

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

class UncompressedOnMemoryCacheItem : public CacheItem

{

public:

	UncompressedOnMemoryCacheItem(const TImageP &image) : m_image(image)

	{

		TRasterImageP ri = m_image;

		if (ri)

			m_imageInfo = new RasterImageInfo(ri);

#ifndef TNZCORE_LIGHT

		else {

			TToonzImageP ti = m_image;

			if (ti)

				m_imageInfo = new ToonzImageInfo(ti);

			else

				m_imageInfo = 0;

		}

#else

		else

			m_imageInfo = 0;

#endif

	}

	~UncompressedOnMemoryCacheItem()

	{

		if (m_imageInfo)

			delete m_imageInfo;

	}

	TUINT32 getSize() const;

	TImageP getImage() const { return m_image; }

	TImageP m_image;

};

#ifdef WIN32

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

template class DVAPI TDerivedSmartPointerT<uncompressedonmemorycacheitem, cacheitem="">;</uncompressedonmemorycacheitem,>

#endif

typedef TDerivedSmartPointerT<uncompressedonmemorycacheitem, cacheitem=""> UncompressedOnMemoryCacheItemP;</uncompressedonmemorycacheitem,>

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

TUINT32 UncompressedOnMemoryCacheItem::getSize() const

{

	TRasterImageP ri = m_image;

	if (ri) {

		TRasterP ras = ri->getRaster();

		if (ras)

			return ras->getLy() * ras->getRowSize();

		else

			return 0;

	} else {

#ifndef TNZCORE_LIGHT

		TToonzImageP ti = m_image;

		if (ti) {

			TDimension size = ti->getSize();

			return size.lx * size.ly * sizeof(TPixelCM32);

		}

#endif

	}

	return 0;

}

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

class CompressedOnMemoryCacheItem : public CacheItem

{

public:

	CompressedOnMemoryCacheItem(const TImageP &img);

	CompressedOnMemoryCacheItem(const TRasterP &compressedRas,

								ImageBuilder *builder,

								ImageInfo *info);

	~CompressedOnMemoryCacheItem();

	TUINT32 getSize() const;

	TImageP getImage() const;

	TRasterP m_compressedRas;

};

#ifdef WIN32

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

template class DVAPI TDerivedSmartPointerT<compressedonmemorycacheitem, cacheitem="">;</compressedonmemorycacheitem,>

#endif

typedef TDerivedSmartPointerT<compressedonmemorycacheitem, cacheitem=""> CompressedOnMemoryCacheItemP;</compressedonmemorycacheitem,>

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

CompressedOnMemoryCacheItem::CompressedOnMemoryCacheItem(const TImageP &img)

	: m_compressedRas()

{

	TRasterImageP ri = img;

	if (ri) {

		m_imageInfo = new RasterImageInfo(ri);

		m_builder = new RasterImageBuilder();

		TINT32 buffSize = 0;

		m_compressedRas = TheCodec::instance()->compress(ri->getRaster(), 1, buffSize);

	}

#ifndef TNZCORE_LIGHT

	else {

		TToonzImageP ti = img;

		if (ti) {

			m_imageInfo = new ToonzImageInfo(ti);

			m_builder = new ToonzImageBuilder();

			TRasterCM32P rasCM32 = ti->getRaster();

			TINT32 buffSize = 0;

			m_compressedRas = TheCodec::instance()->compress(rasCM32, 1, buffSize);

		} else

			assert(false);

	}

#else

	else

		assert(false);

#endif

}

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

CompressedOnMemoryCacheItem::CompressedOnMemoryCacheItem(const TRasterP &ras,

														 ImageBuilder *builder,

														 ImageInfo *info)

	: CacheItem(builder, info), m_compressedRas(ras)

{

}

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

CompressedOnMemoryCacheItem::~CompressedOnMemoryCacheItem()

{

	delete m_imageInfo;

}

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

TUINT32 CompressedOnMemoryCacheItem::getSize() const

{

	if (m_compressedRas)

		return m_compressedRas->getLx();

	else

		return 0;

}

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

TImageP CompressedOnMemoryCacheItem::getImage() const

{

	assert(m_compressedRas);

	// PER IL MOMENTO DISCRIMINO: DA ELIMINARE

	TRasterP ras;

	TheCodec::instance()->decompress(m_compressedRas, ras);

#ifdef _DEBUGTOONZ

	ras->m_cashed = true;

#endif

#ifndef TNZCORE_LIGHT

	ToonzImageBuilder *tibuilder = dynamic_cast<toonzimagebuilder *="">(m_builder);</toonzimagebuilder>

	if (tibuilder)

		return tibuilder->build(m_imageInfo, ras);

	else

#endif

		return m_builder->build(m_imageInfo, ras);

}

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

class CompressedOnDiskCacheItem : public CacheItem

{

public:

	CompressedOnDiskCacheItem(const TFilePath &fp,

							  const TRasterP &compressedRas,

							  ImageBuilder *builder,

							  ImageInfo *info);

	~CompressedOnDiskCacheItem();

	TUINT32 getSize() const { return 0; }

	TImageP getImage() const;

	TFilePath m_fp;

};

#ifdef WIN32

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

template class DVAPI TDerivedSmartPointerT<compressedondiskcacheitem, cacheitem="">;</compressedondiskcacheitem,>

#endif

typedef TDerivedSmartPointerT<compressedondiskcacheitem, cacheitem=""> CompressedOnDiskCacheItemP;</compressedondiskcacheitem,>

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

CompressedOnDiskCacheItem::CompressedOnDiskCacheItem(const TFilePath &fp,

													 const TRasterP &compressedRas,

													 ImageBuilder *builder,

													 ImageInfo *info)

	: CacheItem(builder, info), m_fp(fp)

{

	compressedRas->lock();

	Tofstream oss(m_fp);

	assert(compressedRas->getLy() == 1 && compressedRas->getPixelSize() == 1);

	TUINT32 size = compressedRas->getLx();

	oss.write((char *)&size, sizeof(TUINT32));

	oss.write((char *)compressedRas->getRawData(), size);

	assert(!oss.fail());

	compressedRas->unlock();

}

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

CompressedOnDiskCacheItem::~CompressedOnDiskCacheItem()

{

	delete m_imageInfo;

	TSystem::deleteFile(m_fp);

}

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

TImageP CompressedOnDiskCacheItem::getImage() const

{

	Tifstream is(m_fp);

	TUINT32 dataSize;

	is.read((char *)&dataSize, sizeof(TUINT32));

	TRasterGR8P ras(dataSize, 1);

	ras->lock();

	UCHAR *data = ras->getRawData();

	is.read((char *)data, dataSize);

	assert(!is.fail());

	ras->unlock();

	CompressedOnMemoryCacheItem item(ras, m_builder->clone(), m_imageInfo->clone());

	return item.getImage();

}

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

class UncompressedOnDiskCacheItem : public CacheItem

{

	int m_pixelsize;

public:

	UncompressedOnDiskCacheItem(const TFilePath &fp,

								const TImageP &img);

	~UncompressedOnDiskCacheItem();

	TUINT32 getSize() const { return 0; }

	TImageP getImage() const;

	//TRaster32P getRaster32() const;

	TFilePath m_fp;

};

#ifdef WIN32

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

template class DVAPI TDerivedSmartPointerT<uncompressedondiskcacheitem, cacheitem="">;</uncompressedondiskcacheitem,>

#endif

typedef TDerivedSmartPointerT<uncompressedondiskcacheitem, cacheitem=""> UncompressedOnDiskCacheItemP;</uncompressedondiskcacheitem,>

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

UncompressedOnDiskCacheItem::UncompressedOnDiskCacheItem(const TFilePath &fp,

														 const TImageP &image)

	: CacheItem(0, 0), m_fp(fp)

{

	TRasterImageP ri = image;

	TRasterP ras;

	if (ri) {

		m_imageInfo = new RasterImageInfo(ri);

		ras = ri->getRaster();

	}

#ifndef TNZCORE_LIGHT

	else {

		TToonzImageP ti = image;

		if (ti) {

			m_imageInfo = new ToonzImageInfo(ti);

			ras = ti->getRaster();

		} else

			assert(false);

	}

#else

	else

		assert(false);

#endif

	m_builder = 0;

	int dataSize = ras->getLx() * ras->getLy() * ras->getPixelSize();

	int lx = ras->getLx();

	int ly = ras->getLy();

	int wrap = ras->getWrap();

	m_pixelsize = ras->getPixelSize();

	Tofstream oss(m_fp);

	//oss.write((char*)&dataSize, sizeof(TUINT32));

	//assert(!oss.fail());

	ras->lock();

	if (lx == wrap) {

		oss.write((char *)ras->getRawData(), dataSize);

		assert(!oss.fail());

	} else {

		char *buf = (char *)ras->getRawData();

		for (int i = 0; i < ly; i++, buf += wrap) {

			oss.write(buf, lx * m_pixelsize);

			assert(!oss.fail());

		}

	}

	ras->unlock();

}

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

UncompressedOnDiskCacheItem::~UncompressedOnDiskCacheItem()

{

	delete m_imageInfo;

	TSystem::deleteFile(m_fp);

}

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

TImageP UncompressedOnDiskCacheItem::getImage() const

{

	Tifstream is(m_fp);

	TUINT32 dataSize = m_imageInfo->m_size.lx * m_imageInfo->m_size.ly * m_pixelsize;

	//is.read((char*)&dataSize, sizeof(TUINT32));

	//assert(unsigned(m_lx*m_ly*m_pixelsize)==dataSize);

	TRasterP ras;

	RasterImageInfo *rii = dynamic_cast<rasterimageinfo *="">(m_imageInfo);</rasterimageinfo>

	if (rii) {

		if (m_pixelsize == 4)

			ras = (TRasterP)(TRaster32P(rii->m_size));

		else if (m_pixelsize == 8)

			ras = (TRasterP)(TRaster64P(rii->m_size));

		else if (m_pixelsize == 1)

			ras = (TRasterP)(TRasterGR8P(rii->m_size));

		else if (m_pixelsize == 2)

			ras = (TRasterP)(TRasterGR16P(rii->m_size));

		else

			assert(false);

		ras->lock();

		char *data = (char *)ras->getRawData();

		is.read(data, dataSize);

		ras->unlock();

#ifdef _DEBUGTOONZ

		ras->m_cashed = true;

#endif

		return RasterImageBuilder().build(m_imageInfo, ras);

	}

#ifndef TNZCORE_LIGHT

	else {

		ToonzImageInfo *tii = dynamic_cast<toonzimageinfo *="">(m_imageInfo);</toonzimageinfo>

		if (tii) {

			ras = (TRasterP)(TRasterCM32P(tii->m_size));

			ras->lock();

			char *data = (char *)ras->getRawData();

			is.read(data, dataSize);

			ras->unlock();

#ifdef _DEBUG

			ras->m_cashed = true;

#endif

			return ToonzImageBuilder().build(m_imageInfo, ras);

		} else {

			assert(false);

			return 0;

		}

	}

#else

	else {

		assert(false);

		return 0;

	}

#endif

}

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

string TImageCache::getUniqueId(void)

{

	static TAtomicVar count;

	std::stringstream ss;

	ss << ++count;

	return "IMAGECACHEUNIQUEID" + ss.str();

}

class TImageCache::Imp

{

public:

	Imp() : m_rootDir()

	{

		//ATTENZIONE: e' molto piu' veloce se si usa memoria fisica

		//invece che virtuale: la virtuale e' tanta, non c'e' quindi bisogno

		//di comprimere le immagini, che grandi come sono vengono swappate su disco

		if (TBigMemoryManager::instance()->isActive())

			return;

		m_reservedMemory = (TINT64)(TSystem::getMemorySize(true) * 0.10);

		if (m_reservedMemory < 64 * 1024)

			m_reservedMemory = 64 * 1024;

	}

	~Imp()

	{

		if (m_rootDir != TFilePath())

			TSystem::rmDirTree(m_rootDir);

	}

	bool inline notEnoughMemory()

	{

		if (TBigMemoryManager::instance()->isActive())

			return TBigMemoryManager::instance()->getAvailableMemoryinKb() < 50 * 1024;

		else

			return TSystem::memoryShortage();

	}

	void doCompress();

	void doCompress(string id);

	UCHAR *compressAndMalloc(TUINT32 requestedSize); // compress in the cache till it can nallocate the requested memory

	void outputMap(UINT chunkRequested, string filename);

	void remove(const string &id);

	void remap(const string &dstId, const string &srcId);

	TImageP get(const string &id, bool toBeModified);

	void add(const string &id, const TImageP &img, bool overwrite);

	TFilePath m_rootDir;

#ifndef TNZCORE_LIGHT

	QThreadStorage<bool *=""> m_isEnabled;</bool>

#else

	bool m_isEnabled;

#endif

	map<string, cacheitemp=""> m_uncompressedItems;</string,>

	map<tuint32, string=""> m_itemHistory;</tuint32,>

	map<string, cacheitemp=""> m_compressedItems;</string,>

	map<void *,="" string=""> m_itemsByImagePointer; //items ordered by ImageP.getPointer()</void>

	map<string, string=""> m_duplicatedItems;	 //for duplicated items (when id1!=id2 but image1==image2) in the map: key is dup id, value is main id</string,>

											   //memoria fisica totale della macchina che non puo' essere utilizzata;

	TINT64 m_reservedMemory;

	TThread::Mutex m_mutex;

	static int m_fileid;

};

int TImageCache::Imp::m_fileid;

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

namespace

{

inline void *getPointer(const TImageP &img)

{

	TRasterImageP rimg = img;

	if (rimg)

		return rimg->getRaster().getPointer();

#ifndef TNZCORE_LIGHT

	TToonzImageP timg = img;

	if (timg)

		return timg->getRaster().getPointer();

#endif

	return img.getPointer();

}

// Returns true or false whether the image or its eventual raster are

// referenced by someone other than Toonz cache.

inline TINT32 hasExternalReferences(const TImageP &img)

{

	int refCount;

	{

		TRasterImageP rimg = img;

		if (rimg)

			refCount = rimg->getRaster()->getRefCount();

	}

#ifndef TNZCORE_LIGHT

	{

		TToonzImageP timg = img;

		if (timg)

			refCount = timg->getRaster()->getRefCount() - 1; //!!! the TToonzImage::getRaster method increments raster refCount!(the TRasterImage::getRaster don't)

	}

#endif

	return tmax(refCount, img->getRefCount()) > 1;

}

}

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

void TImageCache::Imp::doCompress()

{

	// se la memoria usata per mantenere le immagini decompresse e' superiore

	// a un dato valore, comprimo alcune immagini non compresse non checked-out

	// in modo da liberare memoria

	// per il momento scorre tutte le immagini alla ricerca di immagini

	// non compresse non checked-out

	TThread::MutexLocker sl(&m_mutex);

	std::map<tuint32, string="">::iterator itu = m_itemHistory.begin();</tuint32,>

	for (; itu != m_itemHistory.end() && notEnoughMemory();) {

		std::map<string, cacheitemp="">::iterator it = m_uncompressedItems.find(itu->second);</string,>

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

		CacheItemP item = it->second;

		UncompressedOnMemoryCacheItemP uitem = item;

		if (item->m_cantCompress ||

			(uitem && (!uitem->m_image || hasExternalReferences(uitem->m_image)))) {

			++itu;

			continue;

		}

		string id = it->first;

#ifdef WIN32

		assert(itu->first == it->second->m_historyCount);

		itu = m_itemHistory.erase(itu);

		m_itemsByImagePointer.erase(getPointer(item->getImage()));

		m_uncompressedItems.erase(it);

#else

		std::map<tuint32, string="">::iterator itu2 = itu;</tuint32,>

		itu++;

		m_itemHistory.erase(itu2);

		m_itemsByImagePointer.erase(item->getImage().getPointer());

		m_uncompressedItems.erase(it);

#endif

		if (m_compressedItems.find(id) == m_compressedItems.end()) {

			assert(uitem);

			item->m_cantCompress = true;

			CacheItemP newItem = new CompressedOnMemoryCacheItem(item->getImage()); //WARNING the codec buffer  allocation can CHANGE the cache.

			item->m_cantCompress = false;

			if (newItem->getSize() == 0) ///non c'era memoria sufficiente per il buffer compresso....

			{

				assert(m_rootDir != TFilePath());

				TFilePath fp = m_rootDir + TFilePath(toString(TImageCache::Imp::m_fileid++));