#include "tiio_tzl.h"

#include "tmachine.h"

#include "tsystem.h"

#include "ttoonzimage.h"

#include "tstream.h"

#include "tfilepath_io.h"

#include "tpixelcm.h"

#include "tpalette.h"

#include "tcodec.h"

#include <stdio.h>
</stdio.h>

#include "trastercm.h"

#include "timageinfo.h"

#include "timagecache.h"

#include "tcontenthistory.h"

#include "tropcm.h"

#include "tenv.h"

#include "tconvert.h"

#include "trasterimage.h"

#include <qbytearray>
</qbytearray>

#if !defined(TNZ_LITTLE_ENDIAN)

TNZ_LITTLE_ENDIAN undefined !!

#endif

    const int CURRENT_VERSION = 14;

const int CREATOR_LENGTH      = 40;

namespace {

char *reverse(char *buffer, int size) {

  char *start = buffer;

  char *end   = start + size;

  while (start < --end) {

    char tmp = *start;

    *start++ = *end;

    *end     = tmp;

  }

  return buffer;

}

}  // namespace

static int tfwrite(const char *data, const unsigned int count, FILE *f) {

  return fwrite(data, sizeof(char), count, f);

}

static int tfwrite(UCHAR *data, const unsigned int count, FILE *f) {

  return fwrite(data, sizeof(char), count, f);

}

static int tfwrite(TINT32 *data, const unsigned int count, FILE *f) {

  if (count == 1) {

#if !TNZ_LITTLE_ENDIAN

    TUINT32 dataToWrite = swapTINT32(*data);

#else

    TUINT32 dataToWrite = *data;

#endif

    return fwrite(&dataToWrite, sizeof(TINT32), 1, f);

  }

  assert(0);

  return 0;

}

static int tfwrite(TUINT32 *data, const unsigned int count, FILE *f) {

  if (count == 1) {

#if !TNZ_LITTLE_ENDIAN

    TUINT32 dataToWrite = swapTINT32(*data);

#else

    TUINT32 dataToWrite = *data;

#endif

    return fwrite(&dataToWrite, sizeof(TINT32), 1, f);

  }

  assert(0);

  return 0;

}

static int tfwrite(double *data, unsigned int count, FILE *f) {

  if (count == 1) {

    double v  = *data;

    char *ptr = (char *)&v;

#if !TNZ_LITTLE_ENDIAN

    ptr = reverse((char *)&v, sizeof(double));

#endif

    return fwrite(ptr, sizeof(double), 1, f);

  }

  assert(0);

  return 0;

}

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

//

// TImageReaderTzl

//

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

namespace {

bool erasedFrame;  // Vera se è stato rimosso almeno un frame.

bool writeVersionAndCreator(FILE *chan, const char *version, QString creator) {

  if (!chan) return false;

  tfwrite(version, strlen(version), chan);

  // creator : CREATOR_LENGTH characater

  char s[CREATOR_LENGTH];

  if (creator.length() == 0) creator = "UNKNOWN";

  memset(s, 0, sizeof s);

  if (creator.length() > CREATOR_LENGTH - 1)

#if QT_VERSION >= 0x050000

    memcpy(s, creator.toLatin1(), CREATOR_LENGTH - 1);

#else

    memcpy(s, creator.toAscii(), CREATOR_LENGTH - 1);

#endif

  else

#if QT_VERSION >= 0x050000

    memcpy(s, creator.toLatin1(), creator.length());

#else

    memcpy(s, creator.toAscii(), creator.length());

#endif

  tfwrite(s, CREATOR_LENGTH, chan);

  return true;

}

bool readVersion(FILE *chan, int &version) {

  char magic[8];

  memset(magic, 0, sizeof(magic));

  fread(&magic, sizeof(char), 8, chan);

  if (memcmp(magic, "TLV10", 5) == 0) {

    version = 10;

  } else if (memcmp(magic, "TLV11", 5) == 0) {

    version = 11;

  } else if (memcmp(magic, "TLV12", 5) == 0) {

    version = 12;

  } else if (memcmp(magic, "TLV13", 5) == 0) {

    version = 13;

  } else if (memcmp(magic, "TLV14", 5) == 0) {

    version = 14;

  } else {

    return false;

  }

  return true;

}

bool readHeaderAndOffsets(FILE *chan, TzlOffsetMap &frameOffsTable,

                          TzlOffsetMap &iconOffsTable, TDimension &res,

                          int &version, QString &creator, TINT32 *_frameCount,

                          TINT32 *_offsetTablePos, TINT32 *_iconOffsetTablePos,

                          TLevelP level) {

  TINT32 hdrSize;

  TINT32 lx = 0, ly = 0, frameCount = 0;

  char codec[4];

  TINT32 offsetTablePos;

  TINT32 iconOffsetTablePos;

  // char magic[8];

  assert(frameOffsTable.empty());

  assert(iconOffsTable.empty());

  if (!readVersion(chan, version)) return false;

  // read creator

  if (version == 14) {

    char buffer[CREATOR_LENGTH + 1];

    memset(buffer, 0, sizeof buffer);

    fread(&buffer, sizeof(char), CREATOR_LENGTH, chan);

    creator = buffer;

  }

  fread(&hdrSize, sizeof(TINT32), 1, chan);

  fread(&lx, sizeof(TINT32), 1, chan);

  fread(&ly, sizeof(TINT32), 1, chan);

  fread(&frameCount, sizeof(TINT32), 1, chan);

  if (version > 10) {

    fread(&offsetTablePos, sizeof(TINT32), 1, chan);

    fread(&iconOffsetTablePos, sizeof(TINT32), 1, chan);

#if !TNZ_LITTLE_ENDIAN

    offsetTablePos     = swapTINT32(offsetTablePos);

    iconOffsetTablePos = swapTINT32(iconOffsetTablePos);

#endif

  }

  fread(&codec, 4, 1, chan);

#if !TNZ_LITTLE_ENDIAN

  hdrSize    = swapTINT32(hdrSize);

  lx         = swapTINT32(lx);

  ly         = swapTINT32(ly);

  frameCount = swapTINT32(frameCount);

#endif

  assert(0 < frameCount && frameCount < 60000);

  if (version > 10 && offsetTablePos != 0 && iconOffsetTablePos != 0) {

    // assert(offsetTablePos>0);

    assert(frameCount > 0);

    fseek(chan, offsetTablePos, SEEK_SET);

    TFrameId oldFid(TFrameId::EMPTY_FRAME);

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

      TINT32 number, offs, length;

      char letter;

      fread(&number, sizeof(TINT32), 1, chan);

      fread(&letter, sizeof(char), 1, chan);

      fread(&offs, sizeof(TINT32), 1, chan);

      if (version >= 12) fread(&length, sizeof(TINT32), 1, chan);

#if !TNZ_LITTLE_ENDIAN

      number = swapTINT32(number);

      offs   = swapTINT32(offs);

      if (version == 12) length = swapTINT32(length);

#endif

      //		std::cout << "#" << i << std::hex << " n 0x" << number

      //<< " l 0x" << letter << " o 0x" << offs << std::dec << std::endl;

      TFrameId fid(number, letter);

      // assert(i==0 || oldFid

      if (version >= 12) {

        frameOffsTable[fid] = TzlChunk(offs, length);

      } else {

        frameOffsTable[fid] = TzlChunk(offs, 0);

        if (i > 0) {

          frameOffsTable[oldFid].m_length =

              offs - frameOffsTable[oldFid].m_offs;

          assert(frameOffsTable[oldFid].m_length > 0);

        }

        if (i == frameCount - 1) {

          frameOffsTable[fid].m_length = offsetTablePos - offs;

          assert(frameOffsTable[fid].m_length > 0);

        }

      }

      oldFid = fid;

      if (level) level->setFrame(fid, TImageP());

    }

    if (version >= 13) {

      // Build IconOffsetTable

      fseek(chan, iconOffsetTablePos, SEEK_SET);

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

        TINT32 number, thumbnailOffs, thumbnailLength;

        char letter;

        fread(&number, sizeof(TINT32), 1, chan);

        fread(&letter, sizeof(char), 1, chan);

        fread(&thumbnailOffs, sizeof(TINT32), 1, chan);

        fread(&thumbnailLength, sizeof(TINT32), 1, chan);

#if !TNZ_LITTLE_ENDIAN

        number          = swapTINT32(number);

        thumbnailOffs   = swapTINT32(thumbnailOffs);

        thumbnailLength = swapTINT32(thumbnailLength);

#endif

        TFrameId fid(number, letter);

        iconOffsTable[fid] = TzlChunk(thumbnailOffs, thumbnailLength);

      }

    }

  } else {

    // m_frameOffsTable.resize(frameCount);

    frameOffsTable[TFrameId(1)] = TzlChunk(ftell(chan), 0);

    iconOffsTable[TFrameId(1)]  = TzlChunk(ftell(chan), 0);

    int i;

    for (i = 2; i <= (int)frameCount; i++) {

      frameOffsTable[TFrameId(i)] = TzlChunk(0, 0);

      iconOffsTable[TFrameId(i)]  = TzlChunk(0, 0);

    }

    if (level)

      for (i = 1; i <= (int)frameCount; i++)

        level->setFrame(TFrameId(i), TImageP());

  }

  res.lx = lx;

  res.ly = ly;

  if (_offsetTablePos) *_offsetTablePos = offsetTablePos;

  if (_iconOffsetTablePos) *_iconOffsetTablePos = iconOffsetTablePos;

  if (_frameCount) *_frameCount = frameCount;

  return true;

}

}  // namespace

static bool adjustIconAspectRatio(TDimension &outDimension,

                                  TDimension inDimension, TDimension imageRes) {

  TINT32 iconLx = inDimension.lx, iconLy = inDimension.ly;

  assert(iconLx > 0 && iconLy > 0);

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

  if (iconLx <= 0 || iconLy <= 0 || imageRes.lx <= 0 || imageRes.ly <= 0)

    return false;

  int lx = imageRes.lx;

  int ly = imageRes.ly;

  if (std::max(double(lx) / inDimension.lx, double(ly) / inDimension.ly) ==

      double(ly) / inDimension.ly)

    iconLx = tround((double(lx) * inDimension.ly) / ly);

  else

    iconLy = tround((double(ly) * inDimension.lx) / lx);

  outDimension = TDimension(iconLx, iconLy);

  return true;

}

static void getThumbnail(TRasterP ras, int shrink, TRasterP &thumbnail) {

  int j          = 0;

  int y          = 0;

  TPixel32 *pix2 = (TPixel32 *)thumbnail->getRawData();

  for (j = 0; j < thumbnail->getLy(); j++) {

    ras->lock();

    TPixel32 *pix    = (TPixel32 *)ras->getRawData() + y * ras->getLx();

    TPixel32 *endPix = pix2 + thumbnail->getLx();

    while (pix2 < endPix) {

      *pix2++ = *pix;

      pix += shrink;

    }

    y += shrink;

    ras->unlock();

  }

}

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

class TImageReaderTzl final : public TImageReader {

public:

  TImageReaderTzl(const TFilePath &f, const TFrameId &fid, TLevelReaderTzl *);

  ~TImageReaderTzl() {}

private:

  // not implemented

  TImageReaderTzl(const TImageReaderTzl &);

  TImageReaderTzl &operator=(const TImageReaderTzl &src);

  TImageP load10();

  TImageP load11();

  TImageP load13();  // Aggiunta iconcine

  TImageP load14();  //	Aggiunto creator con lunghezza fissa

  const TImageInfo *getImageInfo10() const;

  const TImageInfo *getImageInfo11() const;  // vale anche le versioni > di 11

public:

  //! Indice del frame del livello

  TFrameId m_fid;

  TImageP load() override;

  TImageP loadIcon() override {

    m_isIcon = true;

    return load();

  }

  const TImageInfo *getImageInfo() const override;

  // TImageP doLoad();

  TDimension getSize() const;

  TRect getBBox() const;

private:

  //! Size of image

  int m_lx, m_ly;

  bool m_isIcon;

  //! Reference to level reader

  TLevelReaderTzl *m_lrp;

};

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

//

// TImageWriterTzl

//

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

class TImageWriterTzl final : public TImageWriter {

  //! Reference to level writer

  TLevelWriterTzl *m_lwp;

  TFrameId m_fid;

  TDimension

      m_iconSize;  // Dimensioni dell'iconcina salvata all'interno del file tlv

  //	In genere questo parametro viene settato come quello impostato

  // dall'utente

  // nelle preferenze.

public:

  TImageWriterTzl(TLevelWriterTzl *lw, TFrameId fid)

      : TImageWriter(TFilePath())

      , m_lwp(lw)

      , m_fid(fid)

      , m_iconSize(TDimension(80, 60)) {}

  ~TImageWriterTzl() {}

private:

  // not implemented

  TImageWriterTzl(const TImageWriterTzl &);

  TImageWriterTzl &operator=(const TImageWriterTzl &src);

public:

  void save(const TImageP &img) override { m_lwp->save(img, m_fid); }

};

/*

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

//

// TWriterInfo

//

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

TWriterInfo *TWriterInfoTzl::create(const std::string &ext)

{

  return new TWriterInfoTzl();

}

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

TWriterInfo *TWriterInfoTzl::clone() const

{

  return new TWriterInfoTzl(*this);

}

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

*/

namespace {

class Header {

public:

  enum RasType {

    Raster32RGBM,

    Raster64RGBM,

    Raster32CM,

    RasterGR8,

    RasterUnknown

  };

  int m_lx;

  int m_ly;

  RasType m_rasType;

};

}  // namespace

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

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

void TLevelWriterTzl::buildFreeChunksTable() {

  std::set<tzlchunk> occupiedChunks;
</tzlchunk>

  TzlOffsetMap::const_iterator it1 = m_frameOffsTable.begin();

  TINT32 lastOccupiedPos = 0;  // ultima posizione all'interno del file occupata

                               // dall'ultima immagine(grande o icona)

  while (it1 != m_frameOffsTable.end()) {

    occupiedChunks.insert(TzlChunk(it1->second.m_offs, it1->second.m_length));

    if (it1->second.m_offs + it1->second.m_length > lastOccupiedPos)

      lastOccupiedPos = it1->second.m_offs + it1->second.m_length - 1;

    it1++;

  }

  TzlOffsetMap::const_iterator iconIt1 = m_iconOffsTable.begin();

  while (iconIt1 != m_iconOffsTable.end()) {

    occupiedChunks.insert(

        TzlChunk(iconIt1->second.m_offs, iconIt1->second.m_length));

    if (iconIt1->second.m_offs + iconIt1->second.m_length > lastOccupiedPos)

      lastOccupiedPos = iconIt1->second.m_offs + iconIt1->second.m_length - 1;

    iconIt1++;

  }

  std::set<tzlchunk>::const_iterator it2 = occupiedChunks.begin();
</tzlchunk>

  TINT32 curPos;  // prima posizione utile nel file in cui vengono memorizzati i

                  // dati relativi alle immagini

  if (m_version == 13)

    curPos = 6 * sizeof(TINT32) + 4 * sizeof(char) + 8 * sizeof(char);

  else if (m_version == 14)

    curPos = 6 * sizeof(TINT32) + 4 * sizeof(char) + 8 * sizeof(char) +

             CREATOR_LENGTH * sizeof(char);

  else

    curPos = it2->m_offs;

  while (it2 != occupiedChunks.end()) {

    assert(it2->m_offs >= curPos);

    if (it2->m_offs > curPos)

      m_freeChunks.insert(TzlChunk(curPos, it2->m_offs - curPos));

    curPos = it2->m_offs + it2->m_length;

    it2++;

  }

  assert(lastOccupiedPos < m_offsetTablePos);

  if (lastOccupiedPos + 1 < m_offsetTablePos)

    m_freeChunks.insert(

        TzlChunk(lastOccupiedPos + 1, m_offsetTablePos - lastOccupiedPos));

}

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

//

// TLevelWriterTzl

//

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

TLevelWriterTzl::TLevelWriterTzl(const TFilePath &path, TPropertyGroup *info)

    : TLevelWriter(path, info)

    , m_headerWritten(false)

    , m_creatorWritten(false)

    , m_chan(0)

    , m_frameCountPos(0)

    , m_frameCount(0)

    , m_palette(0)

    , m_res(0, 0)

    , m_exists(false)

    , m_version(CURRENT_VERSION)

    , m_updatedIconsSize(false)

    , m_currentIconSize(0, 0)

    , m_iconSize(TDimension(80, 60))

    , m_userIconSize(TDimension(80, 60))

    , m_adjustRatio(false)

    , m_codec(new TRasterCodecLZO("LZO", true))

    , m_overwritePaletteFlag(true) {

  m_path        = path;

  m_palettePath = path.withNoFrame().withType("tpl");

  TFileStatus fs(path);

  m_magic     = "TLV14B1a";  // actual version

  erasedFrame = false;

  // version TLV10B1a: first version

  // version TLV11B1a: added frameIds

  // version TLV12B1a: incremental writings

  // version TLV13B1a: added thumbnails

  // version TLV15B1a: add creator string (fixed size = CREATOR_LENGTH char)

  if (fs.doesExist()) {

    // if (!fs.isWritable())

    m_chan = fopen(path, "rb+");

    /*--- 誰かが開いている、または権限が無いとき ---*/

    if (!m_chan) {

      throw TSystemException(path, "can't fopen.");

    }

    /*--- TLVファイルのヘッダが正しく読めなかった場合 ---*/

    if (!readHeaderAndOffsets(m_chan, m_frameOffsTable, m_iconOffsTable, m_res,

                              m_version, m_creator, &m_frameCount,

                              &m_offsetTablePos, &m_iconOffsetTablePos, 0)) {

      throw TSystemException(path, "can't readHeaderAndOffsets.");

    } else {

      if (m_version >= 12) buildFreeChunksTable();

      m_headerWritten = true;

      m_exists        = true;

      if (m_version == 14)

        m_frameCountPos = 8 + CREATOR_LENGTH + 3 * sizeof(TINT32);

      else

        m_frameCountPos = 8 + 3 * sizeof(TINT32);

    }

  }

  if (!m_exists) {

    TFilePath parentDir = path.getParentDir();

    if (!TFileStatus(parentDir).doesExist()) {

      try {

        TSystem::mkDir(parentDir);

      } catch (...) {

        return;

      }

    }

    m_chan = fopen(path, "wb");

    if (!m_chan) return;

    if (!writeVersionAndCreator(m_chan, m_magic, m_creator)) return;

  }

}

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

TLevelWriterTzl::~TLevelWriterTzl() {

  if (m_version < CURRENT_VERSION) {

    if (!convertToLatestVersion()) return;

    assert(m_version == CURRENT_VERSION);

  }

  delete m_codec;

  TINT32 offsetMapPos     = 0;

  TINT32 iconOffsetMapPos = 0;

  if (!m_chan) return;

  assert(m_frameCount == (int)m_frameOffsTable.size());

  assert(m_frameCount == (int)m_iconOffsTable.size());

  offsetMapPos = (m_exists ? m_offsetTablePos : ftell(m_chan));

  fseek(m_chan, offsetMapPos, SEEK_SET);

  TzlOffsetMap::iterator it = m_frameOffsTable.begin();

  for (; it != m_frameOffsTable.end(); ++it) {

    TFrameId fid  = it->first;

    TINT32 num    = fid.getNumber();

    char letter   = fid.getLetter();

    TINT32 offs   = it->second.m_offs;

    TINT32 length = it->second.m_length;

    tfwrite(&num, 1, m_chan);

    tfwrite(&letter, 1, m_chan);

    tfwrite(&offs, 1, m_chan);

    tfwrite(&length, 1, m_chan);

  }

  // Write Icon Offset Table after frameOffsTable

  iconOffsetMapPos =

      ftell(m_chan);  //(m_exists?m_iconOffsetTablePos: ftell(m_chan));

  fseek(m_chan, iconOffsetMapPos, SEEK_SET);

  TzlOffsetMap::iterator iconIt = m_iconOffsTable.begin();

  for (; iconIt != m_iconOffsTable.end(); ++iconIt) {

    TFrameId fid           = iconIt->first;

    TINT32 num             = fid.getNumber();

    char letter            = fid.getLetter();

    TINT32 thumbnailOffs   = iconIt->second.m_offs;

    TINT32 thumbnailLength = iconIt->second.m_length;

    tfwrite(&num, 1, m_chan);

    tfwrite(&letter, 1, m_chan);

    tfwrite(&thumbnailOffs, 1, m_chan);

    tfwrite(&thumbnailLength, 1, m_chan);

  }

  fseek(m_chan, m_frameCountPos, SEEK_SET);

  TINT32 frameCount = m_frameCount;

  tfwrite(&frameCount, 1, m_chan);

  tfwrite(&offsetMapPos, 1, m_chan);

  tfwrite(&iconOffsetMapPos, 1, m_chan);

  fclose(m_chan);

  m_chan = 0;

  if (m_palette && m_overwritePaletteFlag &&

      (m_palette->getDirtyFlag() ||

       !TSystem::doesExistFileOrLevel(m_palettePath))) {

    TOStream os(m_palettePath);

    os << m_palette;

    m_palette->release();

  }

  if (m_contentHistory) {

    TFilePath historyFp = m_path.withNoFrame().withType("hst");

    FILE *historyChan   = fopen(historyFp, "w");

    if (historyChan) {

      std::string historyData = m_contentHistory->serialize().toStdString();

      fwrite(&historyData[0], 1, historyData.length(), historyChan);

      fclose(historyChan);

    }

  }

  // Se lo spazio libero (cioè la somma di tutti i buchi che si sono creati tra

  // i frame)

  // è maggiore di una certa soglia oppure è stato rimosso almeno un frame

  // allora ottimizzo il file

  // (in pratica risalvo il file da capo senza buchi).

  if (getFreeSpace() > 0.3 || erasedFrame) optimize();

}

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

TImageWriterP TLevelWriterTzl::getFrameWriter(TFrameId fid) {

  return new TImageWriterTzl(this, fid);

}

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

void TLevelWriterTzl::writeHeader(const TDimension &size) {

  m_headerWritten   = true;

  const char *codec = "LZO ";

  int codecLen      = strlen(codec);

  TINT32 hdrSize    = 3 * sizeof(TINT32) + codecLen;

  TINT32 lx = size.lx, ly = size.ly, intval = 1;

  tfwrite(&hdrSize, 1, m_chan);

  tfwrite(&lx, 1, m_chan);

  tfwrite(&ly, 1, m_chan);

  m_frameCountPos = ftell(m_chan);

  assert(m_frameCountPos == 8 + CREATOR_LENGTH + 3 * sizeof(TINT32));

  // I put the place for the frameCount, which I will write in this position at

  // the end  (see in the distructor)

  tfwrite(&intval, 1, m_chan);

  // I put the place for the offsetTableOffset, which I will write in this

  // position at the end  (see in the distructor)

  intval = 0;

  tfwrite(&intval, 1, m_chan);

  // I put the place for the iconOffsetTableOffset, which I will write in this

  // position at the end  (see in the distructor)

  tfwrite(&intval, 1, m_chan);

  tfwrite(codec, codecLen, m_chan);

}

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

void TLevelWriterTzl::addFreeChunk(TINT32 offs, TINT32 length) {

  std::set<tzlchunk>::iterator it = m_freeChunks.begin();
</tzlchunk>

  while (it != m_freeChunks.end()) {

    // if (it->m_offs>offs+length+1)

    //  break;

    if (it->m_offs + it->m_length == offs)  // accorpo due chunks in uno

    {

      TzlChunk chunk(it->m_offs, it->m_length + length);

      m_freeChunks.erase(it);

      m_freeChunks.insert(chunk);

      // it->m_length += length;

      return;

    } else if (offs + length == it->m_offs) {

      TzlChunk chunk(offs, it->m_length + length);

      m_freeChunks.erase(it);

      m_freeChunks.insert(chunk);

      // it->m_offs = offs;

      // it->m_length += length;

      return;

    }

    it++;

  }

  if (it == m_freeChunks.end()) m_freeChunks.insert(TzlChunk(offs, length));

}

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

TINT32 TLevelWriterTzl::findSavingChunk(const TFrameId &fid, TINT32 length,

                                        bool isIcon) {

  TzlOffsetMap::iterator it;

  // prima libero il chunk del fid, se c'e'. accorpo con altro chunk se trovo

  // uno contiguo.

  if (!isIcon) {

    if ((it = m_frameOffsTable.find(fid)) != m_frameOffsTable.end()) {

      addFreeChunk(it->second.m_offs, it->second.m_length);

      m_frameOffsTable.erase(it);

    } else

      m_frameCount++;

  } else {

    if ((it = m_iconOffsTable.find(fid)) != m_iconOffsTable.end()) {

      addFreeChunk(it->second.m_offs, it->second.m_length);

      m_iconOffsTable.erase(it);

    }

  }

  // ora cerco un cioncone libero con la piu' piccola memoria sufficiente

  std::set<tzlchunk>::iterator it1   = m_freeChunks.begin(),
</tzlchunk>

                               found = m_freeChunks.end();

  for (; it1 != m_freeChunks.end(); it1++) {

    //   TINT32 _length = it1->m_length;

    if (it1->m_length >= length &&

        (found == m_freeChunks.end() || found->m_length > it1->m_length))

      found = it1;

  }

  if (found != m_freeChunks.end()) {

    //  TINT32 _length = found->m_length;

    TINT32 _offset = found->m_offs;

    if (found->m_length > length) {

      TzlChunk chunk(found->m_offs + length, found->m_length - length);

      m_freeChunks.insert(chunk);

      // found->m_offs+=length;

      // found->m_length-=length;

    } else

      assert(found->m_length == length);

    m_freeChunks.erase(found);

    return _offset;

  } else {

    m_offsetTablePos += length;

    return m_offsetTablePos - length;

  }

}

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

bool TLevelWriterTzl::convertToLatestVersion() {

  TFileStatus fs(m_path);

  // se il file è di una versione precedente deve necessariamente già esistere

  // su disco

  assert(fs.doesExist());

  if (!fs.doesExist()) return false;

  m_exists         = false;

  m_frameCount     = 0;

  m_frameOffsTable = TzlOffsetMap();

  m_iconOffsTable  = TzlOffsetMap();

  m_headerWritten  = false;

  fclose(m_chan);

  m_chan = 0;

  std::string tempName = "~" + m_path.getName() + "tmp&.tlv";

  TFilePath tempPath   = TSystem::getTempDir() + tempName;

  if (TSystem::doesExistFileOrLevel(m_path)) {

    assert(m_path != tempPath);

    if (TSystem::doesExistFileOrLevel(tempPath)) TSystem::deleteFile(tempPath);

    TSystem::copyFile(tempPath, m_path);

  } else

    return false;

  m_chan = fopen(m_path, "rb+");

  if (!m_chan) return false;

  if (!writeVersionAndCreator(m_chan, m_magic, m_creator)) return false;

  m_creatorWritten = true;

  m_version        = CURRENT_VERSION;

  TLevelReaderP lr(tempPath);

  if (!lr) return false;

  TLevelP level = lr->loadInfo();

  for (TLevel::Iterator it = level->begin(); it != level->end(); ++it) {

    save(lr->getFrameReader(it->first)->load(), it->first);

  }

  lr = TLevelReaderP();

  if (TSystem::doesExistFileOrLevel(tempPath)) {

    TSystem::deleteFile(tempPath);

  }

  TINT32 offsetMapPos     = 0;

  TINT32 iconOffsetMapPos = 0;

  if (!m_chan) return false;

  assert(m_frameCount == (int)m_frameOffsTable.size());

  assert(m_frameCount == (int)m_iconOffsTable.size());

  offsetMapPos = (m_exists ? m_offsetTablePos : ftell(m_chan));

  fseek(m_chan, offsetMapPos, SEEK_SET);

  TzlOffsetMap::iterator it2 = m_frameOffsTable.begin();

  for (; it2 != m_frameOffsTable.end(); ++it2) {

    TFrameId fid  = it2->first;

    TINT32 num    = fid.getNumber();

    char letter   = fid.getLetter();

    TINT32 offs   = it2->second.m_offs;

    TINT32 length = it2->second.m_length;

    tfwrite(&num, 1, m_chan);

    tfwrite(&letter, 1, m_chan);

    tfwrite(&offs, 1, m_chan);

    tfwrite(&length, 1, m_chan);

  }

  iconOffsetMapPos = ftell(m_chan);

  fseek(m_chan, iconOffsetMapPos, SEEK_SET);

  TzlOffsetMap::iterator iconIt = m_iconOffsTable.begin();

  for (; iconIt != m_iconOffsTable.end(); ++iconIt) {

    TFrameId fid           = iconIt->first;

    TINT32 num             = fid.getNumber();

    char letter            = fid.getLetter();

    TINT32 thumbnailOffs   = iconIt->second.m_offs;

    TINT32 thumbnailLength = iconIt->second.m_length;

    tfwrite(&num, 1, m_chan);

    tfwrite(&letter, 1, m_chan);

    tfwrite(&thumbnailOffs, 1, m_chan);

    tfwrite(&thumbnailLength, 1, m_chan);

  }

  fseek(m_chan, m_frameCountPos, SEEK_SET);

  TINT32 frameCount = m_frameCount;

  tfwrite(&frameCount, 1, m_chan);

  tfwrite(&offsetMapPos, 1, m_chan);

  tfwrite(&iconOffsetMapPos, 1, m_chan);

  m_frameOffsTable = TzlOffsetMap();

  m_iconOffsTable  = TzlOffsetMap();

  m_frameCount     = 0;

  m_res            = TDimension();

  fclose(m_chan);

  m_chan = 0;

  if (m_palette && (m_palette->getDirtyFlag() ||

                    !TSystem::doesExistFileOrLevel(m_palettePath))) {

    TOStream os(m_palettePath);

    os << m_palette;

  }

  // else

  //	m_palette = 0;

  m_chan = fopen(m_path, "rb+");

  if (!m_chan) return false;

  if (!readHeaderAndOffsets(m_chan, m_frameOffsTable, m_iconOffsTable, m_res,

                            m_version, m_creator, &m_frameCount,

                            &m_offsetTablePos, &m_iconOffsetTablePos, 0))

    return false;

  m_freeChunks.clear();

  buildFreeChunksTable();

  m_headerWritten = true;

  m_exists        = true;

  m_frameCountPos = 8 + CREATOR_LENGTH + 3 * sizeof(TINT32);

  assert(m_version == CURRENT_VERSION);

  if (!m_renumberTable.empty()) renumberFids(m_renumberTable);

  return true;

}

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

void TLevelWriterTzl::saveImage(const TImageP &img, const TFrameId &_fid,

                                bool isIcon) {

  TFrameId fid = _fid;

  if (!m_chan) return;

  // se il file è di una versione precedente allora lo converto prima

  if (m_version < CURRENT_VERSION) {

    if (!convertToLatestVersion()) return;

    assert(m_version == CURRENT_VERSION);

  }

  if (!m_updatedIconsSize && m_exists)

    m_updatedIconsSize = checkIconSize(getIconSize());

  TToonzImageP ti = img;