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

}

}

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

{

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

}

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

{

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

}

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;

}

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;

}

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 (std::string(magic).substr(0, 5) == "TLV10")

		version = 10;

	else if (std::string(magic, 5) == "TLV11")

		version = 11;

	else if (std::string(magic, 5) == "TLV12")

		version = 12;

	else if (std::string(magic, 5) == "TLV13")

		version = 13;

	else if (std::string(magic, 5) == "TLV14")

		version = 14;

	else {

		fclose(chan);

		chan = 0;

		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;

}

}

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 (tmax(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;

}

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

	TImageP loadIcon()

	{

		m_isIcon = true;

		return load();

	}

	const TImageInfo *getImageInfo() const;

	//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 : 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) { 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(), found = m_freeChunks.end();
</tzlchunk>

	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;