#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;

  std::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() override;

  double m_dpix, m_dpiy;

  std::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() override {

    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;

  std::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() override { return new RasterImageBuilder(*this); }

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

};

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() override { return new ToonzImageBuilder(*this); }

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

};

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 override;

  TImageP getImage() const override { 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=""></uncompressedonmemorycacheitem,>

    UncompressedOnMemoryCacheItemP;

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

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 override;

  TImageP getImage() const override;

  TRasterP m_compressedRas;

};

#ifdef _WIN32

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

template class DVAPI

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

#endif

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

    CompressedOnMemoryCacheItemP;

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

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 override { return 0; }

  TImageP getImage() const override;

  TFilePath m_fp;

};

#ifdef _WIN32

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

template class DVAPI

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

#endif

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

    CompressedOnDiskCacheItemP;

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

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 override { return 0; }

  TImageP getImage() const override;

  // 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=""></uncompressedondiskcacheitem,>

    UncompressedOnDiskCacheItemP;

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

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

}

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

std::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(std::string id);

  UCHAR *compressAndMalloc(TUINT32 requestedSize);  // compress in the cache

                                                    // till it can nallocate the

                                                    // requested memory

  void outputMap(UINT chunkRequested, std::string filename);

  void remove(const std::string &id);

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

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

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

  TFilePath m_rootDir;

#ifndef TNZCORE_LIGHT

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

#else

  bool m_isEnabled;

#endif

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

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

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

  std::map<void *,="" std::string=""></void>

      m_itemsByImagePointer;  // items ordered by ImageP.getPointer()

  std::map<std::string, std::string=""> m_duplicatedItems;  // for duplicated items</std::string,>

                                                         // (when id1!=id2 but

                                                         // image1==image2) in

                                                         // the map: key is dup

                                                         // id, value is main id

  // 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 std::max(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, std::string="">::iterator itu = m_itemHistory.begin();</tuint32,>

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

    std::map<std::string, cacheitemp="">::iterator it =</std::string,>

        m_uncompressedItems.find(itu->second);

    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;

    }

    std::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, std::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(std::to_string(TImageCache::Imp::m_fileid++));

        newItem = new UncompressedOnDiskCacheItem(fp, item->getImage());

      }

      m_compressedItems[id] = newItem;

      item                  = CacheItemP();

      uitem                 = UncompressedOnMemoryCacheItemP();

      // doCompress();//restart, since interators can have been changed (see

      // comment above)

      // return;

      itu = m_itemHistory.begin();

    }

  }

  // se il quantitativo di memoria utilizzata e' superiore a un dato valore,

  // sposto

  // su disco alcune immagini compresse in modo da liberare memoria

  if (itu != m_itemHistory.end())  // memory is enough!

    return;

  std::map<std::string, cacheitemp="">::iterator itc = m_compressedItems.begin();</std::string,>

  for (; itc != m_compressedItems.end() && notEnoughMemory(); ++itc) {

    CacheItemP item = itc->second;

    if (item->m_cantCompress) continue;

    CompressedOnMemoryCacheItemP citem = itc->second;

    if (citem) {

      assert(m_rootDir != TFilePath());

      TFilePath fp =

          m_rootDir + TFilePath(std::to_string(TImageCache::Imp::m_fileid++));

      CacheItemP newItem = new CompressedOnDiskCacheItem(

          fp, citem->m_compressedRas, citem->m_builder->clone(),

          citem->m_imageInfo->clone());

      itc->second                   = 0;

      m_compressedItems[itc->first] = newItem;

    }

  }

}

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