#include <sstream></sstream>

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

        ostringstream os;

        os << errorCode << '\0';

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

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

  return true;

}

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

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

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

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

    m_imp->m_cacheSize -= it->second->m_size;

    delete it->second;

    m_imp->m_chunks.erase(it);

  }

  UCHAR *outData     = 0;

  TINT32 outDataSize = 0;

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

  m_imp->m_cacheSize += outDataSize;

  Imp::CompressedChunk *cc = new Imp::CompressedChunk(outData, outDataSize);

  m_imp->m_chunks.insert(Imp::CompressedChunks::value_type(frame, cc));

  return true;

}

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

void TRamCachePersist::onInvalidate() {

  for (Imp::CompressedChunks::iterator it = m_imp->m_chunks.begin();

       it != m_imp->m_chunks.end(); ++it) {

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

    m_imp->m_cacheSize -= cc->m_size;

    delete cc;

  }

  m_imp->m_chunks.clear();

}

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

void TRamCachePersist::onInvalidate(int startFrame,

                                    int endFrame) {  // ottimizzabile

  assert(startFrame <= endFrame);

  for (int frame = startFrame; frame <= endFrame; ++frame) {

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

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

      m_imp->m_cacheSize -= it->second->m_size;

      delete it->second;

      m_imp->m_chunks.erase(it);

    }

  }

}

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

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

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

  if (it == m_imp->m_chunks.end()) return 0;

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

  assert(cc);

  return m_codec->removeHeader(cc->m_buffer, cc->m_size, size, lx, ly);

}

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