#include <memory></memory>

#include "tmachine.h"

#include "pli_io.h"

#include "tcommon.h"

#include "timage_io.h"

#include "tvectorimage.h"

//#include "tstrokeoutline.h"

#include "tsimplecolorstyles.h"

#include "tcontenthistory.h"

#include "tfilepath_io.h"

//#include <fstream.h></fstream.h>

#include "../compatibility/tfile_io.h"

#include "tenv.h"

/*=====================================================================*/

#if defined(MACOSX)

#include <architecture i386="" io.h=""></architecture>

#elif defined(_WIN32)

#include <io.h></io.h>

#endif

using namespace std;

typedef TVectorImage::IntersectionBranch IntersectionBranch;

#if !defined(TNZ_LITTLE_ENDIAN)

TNZ_LITTLE_ENDIAN undefined !!

#endif

	static const int c_majorVersionNumber = 71;

static const int c_minorVersionNumber = 0;

/*=====================================================================*/

/*=====================================================================*/

/*=====================================================================*/

inline void ulongFromDouble1(double x, TUINT32 &hi, TUINT32 &lo)

{

	assert(x < 1.0);

	//x+=1.0;

	TUINT32 *l = (TUINT32 *)&x;

#if TNZ_LITTLE_ENDIAN

	hi = l[1], lo = l[0];

#else

	hi = l[0], lo = l[1];

#endif

	//return (hi&0XFFFFF)<<12 | ((lo&0xFFE00000)>>20);

}

/*=====================================================================*/

inline double doubleFromUlong1(TUINT32 hi, TUINT32 lo)

{

	//assert((lo&0X00000001)==0);

	TUINT32 l[2];

#if TNZ_LITTLE_ENDIAN

	l[1] = hi;

	l[0] = lo;

#else

	l[0] = hi;

	l[1] = lo;

#endif

	return *(double *)l; // - 1;

}

/*=====================================================================*/

TThickPoint operator*(const TAffine &aff, const TThickPoint &p)

{

	TPointD p1(p.x, p.y);

	return TThickPoint(aff * p1, p.thick);

}

/*=====================================================================*/

class MyOfstream : public Tofstream

{

public:

	MyOfstream(const TFilePath &path) : Tofstream(path) {}

	MyOfstream &operator<<(TUINT32 n)

	{

		TUINT32 app;

#if TNZ_LITTLE_ENDIAN

		app = n;

#else

		UCHAR *uc = (UCHAR *)&n;

		app = *(uc) | (*(uc + 1)) << 8 | (*(uc + 2)) << 16 | (*(uc + 3)) << 24;

#endif

		write((char *)&app, sizeof(TUINT32));

		return *this;

	}

	MyOfstream &operator<<(USHORT n)

	{

		USHORT app;

#if TNZ_LITTLE_ENDIAN

		app = n;

#else

		UCHAR *uc = (UCHAR *)&n;

		app = *(uc) | (*(uc + 1)) << 8;

#endif

		write((char *)&app, sizeof(USHORT));

		return *this;

	}

	MyOfstream &operator<<(UCHAR un)

	{

		write((char *)&un, sizeof(UCHAR));

		return *this;

	}

	MyOfstream &operator<<(char un)

	{

		write((char *)&un, sizeof(char));

		return *this;

	}

	MyOfstream &operator<<(const TRaster32P &r);

	MyOfstream &operator<<(const std::string &r);

	MyOfstream &writeBuf(void *un, UINT s)

	{

		write((char *)un, s);

		return *this;

	}

};

/*=====================================================================*/

MyOfstream &MyOfstream::operator<<(const TRaster32P &r)

{

	assert(r->getLx() == r->getWrap());

	(*this) << (USHORT)r->getLx();

	(*this) << (USHORT)r->getLy();

	r->lock();

	MyOfstream &ret = writeBuf(r->getRawData(), r->getLx() * r->getLy() * r->getPixelSize());

	r->unlock();

	return ret;

}

/*=====================================================================*/

MyOfstream &MyOfstream::operator<<(const std::string &s)

{

	(*this) << (USHORT)s.size();

	for (UINT i = 0; i < s.size(); i++)

		(*this) << (UCHAR)(s[i]);

	return *this;

}

/*=====================================================================*/

class MyIfstream //The input is done without stl; it was crashing in release version loading textures!!

{

private:

	bool m_isIrixEndian;

	FILE *m_fp;

public:

	MyIfstream() : m_isIrixEndian(false) { m_fp = 0; }

	~MyIfstream()

	{

		if (m_fp)

			fclose(m_fp);

	}

	void setEndianess(bool isIrixEndian) { m_isIrixEndian = isIrixEndian; }

	MyIfstream &operator>>(TUINT32 &un);

	MyIfstream &operator>>(string &un);

	MyIfstream &operator>>(USHORT &un);

	MyIfstream &operator>>(UCHAR &un);

	MyIfstream &operator>>(char &un);

	void open(const TFilePath &filename);

	void close()

	{

		if (m_fp)

			fclose(m_fp);

		m_fp = 0;

	}

	TUINT32 tellg() { return (TUINT32)ftell(m_fp); }

	//void seekg(TUINT32 pos, ios_base::seek_dir type);

	void seekg(TUINT32 pos, int type);

	void read(char *m_buf, int length) { fread((void *)m_buf, sizeof(char), length, m_fp); }

};

/*=====================================================================*/

void MyIfstream::open(const TFilePath &filename)

{

	try {

		m_fp = fopen(filename, "rb");

	} catch (TException &) {

		throw TImageException(filename, "File not found");

	}

}

/*=====================================================================*/

void MyIfstream::seekg(TUINT32 pos, int type)

{

	if (type == ios_base::beg)

		fseek(m_fp, pos, SEEK_SET);

	else if (type == ios_base::cur)

		fseek(m_fp, pos, SEEK_CUR);

	else

		assert(false);

}

/*=====================================================================*/

inline MyIfstream &MyIfstream::operator>>(UCHAR &un)

{

	int ret = fread((void *)&un, sizeof(UCHAR), 1, m_fp);

	if (ret < 1)

		throw TException("corrupted pli file: unexpected end of file");

	//read((char *)&un, sizeof(UCHAR));

	return *this;

}

/*=====================================================================*/

inline MyIfstream &MyIfstream::operator>>(char &un)

{

	int ret = fread((void *)&un, sizeof(char), 1, m_fp);

	if (ret < 1)

		throw TException("corrupted pli file: unexpected end of file");

	//read((char *)&un, sizeof(char));

	return *this;

}

/*=====================================================================*/

inline MyIfstream &MyIfstream::operator>>(USHORT &un)

{

	int ret = fread((void *)&un, sizeof(USHORT), 1, m_fp);

	if (ret < 1)

		throw TException("corrupted pli file: unexpected end of file");

	//  read((char *)&un, sizeof(USHORT));

	if (m_isIrixEndian)

		un = ((un & 0xff00) >> 8) | ((un & 0x00ff) << 8);

	return *this;

}

/*=====================================================================*/

inline MyIfstream &MyIfstream::operator>>(TUINT32 &un)

{

	int ret = fread((void *)&un, sizeof(TUINT32), 1, m_fp);

	if (ret < 1)

		throw TException("corrupted pli file: unexpected end of file");

	// read((char *)&un, sizeof(TUINT32));

	if (m_isIrixEndian)

		un = ((un & 0xff000000) >> 24) | ((un & 0x00ff0000) >> 8) |

			 ((un & 0x0000ff00) << 8) | ((un & 0x000000ff) << 24);

	return *this;

}

/*=====================================================================*/

inline MyIfstream &MyIfstream::operator>>(string &un)

{

	string s = "";

	USHORT lenght;

	(*this) >> lenght;

	for (UINT i = 0; i < lenght; i++) {

		UCHAR ch;

		(*this) >> ch;

		s.append(1, ch);

	}

	un = s;

	return *this;

}

/*=====================================================================*/

UINT TStyleParam::getSize()

{

	switch (m_type) {

	case SP_BYTE  : return 1;

	case SP_INT   : return 4;

	case SP_DOUBLE: return 4;

	case SP_USHORT: return 2;

	case SP_RASTER: return 2 + 2 + m_r->getLx() * m_r->getLy() * m_r->getPixelSize();

	case SP_STRING: return (m_string.size() + sizeof(USHORT));

	default:

		assert(false);

		return 0;

	}

}

/*=====================================================================*/

#ifdef _WIN32

#define CHECK_FOR_READ_ERROR(filePath)

#else

#define CHECK_FOR_READ_ERROR(filePath)                             \

	{                                                              \

		/*if (m_iChan.flags()&(ios::failbit|ios::eofbit))          \

		{                                                          \

		m_lastError = PREMATURE_EOF;                               \

		throw TImageException( filePath, "Error on reading file"); \

		}*/                                                        \

	}

#endif

#define CHECK_FOR_WRITE_ERROR(filePath)                               \

	{                                                                 \

		if (m_oChan->fail() /*m_oChan.flags()&(ios::failbit)*/) {     \

			m_lastError = WRITE_ERROR;                                \

			throw TImageException(filePath, "Error on writing file"); \

		}                                                             \

	}

const TUINT32 c_magicNt = 0x4D494C50;

const TUINT32 c_magicIrix = 0x504C494D;

class TagElem

{

public:

	PliTag *m_tag;

	TUINT32 m_offset;

	TagElem *m_next;

	TagElem(PliTag *tag, TUINT32 offset, TagElem *next = NULL)

		: m_tag(tag), m_offset(offset), m_next(next) {}

	TagElem(const TagElem &elem)

		: m_tag(elem.m_tag), m_offset(elem.m_offset), m_next(NULL) {}

	~TagElem()

	{

		if (m_tag)

			delete m_tag;

	}

};

/*=====================================================================*/

class TContentHistory;

class ParsedPliImp

{

public:

	UCHAR m_majorVersionNumber;

	UCHAR m_minorVersionNumber;

	USHORT m_framesNumber;

	double m_thickRatio;

	double m_maxThickness;

	double m_autocloseTolerance;

	bool m_isIrixEndian;

	TFilePath m_filePath;

	UCHAR m_currDinamicTypeBytesNum;

	TUINT32 m_tagLength;

	TUINT32 m_bufLength;

	std::unique_ptr<uchar[]> m_buf;</uchar[]>

	TAffine m_affine;

	int m_precisionScale;

	std::map<tframeid, int=""> m_frameOffsInFile;</tframeid,>

	PliTag *readTextTag();

	PliTag *readPaletteTag();

	PliTag *readPaletteWithAlphaTag();

	PliTag *readThickQuadraticChainTag(bool isLoop);

	PliTag *readColorTag();

	PliTag *readStyleTag();

	PliTag *readGroupTag();

	PliTag *readImageTag();

	PliTag *readGeometricTransformationTag();

	PliTag *readDoublePairTag();

	PliTag *readBitmapTag();

	PliTag *readIntersectionDataTag();

	PliTag *readOutlineOptionsTag();

	PliTag *readPrecisionScaleTag();

	inline void readDinamicData(TUINT32 &val, TUINT32 &bufOffs);

	inline bool readDinamicData(TINT32 &val, TUINT32 &bufOffs);

	inline void readFloatData(double &val, TUINT32 &bufOffs);

	inline UINT readRasterData(TRaster32P &r, TUINT32 &bufOffs);

	inline void writeFloatData(double val);

	inline void readUShortData(USHORT &val, TUINT32 &bufOffs);

	inline void readTUINT32Data(TUINT32 &val, TUINT32 &bufOffs);

	TUINT32 writeTagHeader(UCHAR type, UINT tagLength);

	TUINT32 writeTextTag(TextTag *tag);

	TUINT32 writePaletteTag(PaletteTag *tag);

	TUINT32 writePaletteWithAlphaTag(PaletteWithAlphaTag *tag);

	TUINT32 writeThickQuadraticChainTag(ThickQuadraticChainTag *tag);

	TUINT32 writeGroupTag(GroupTag *tag);

	TUINT32 writeImageTag(ImageTag *tag);

	TUINT32 writeColorTag(ColorTag *tag);

	TUINT32 writeStyleTag(StyleTag *tag);

	TUINT32 writeGeometricTransformationTag(GeometricTransformationTag *tag);

	TUINT32 writeDoublePairTag(DoublePairTag *tag);

	TUINT32 writeBitmapTag(BitmapTag *tag);

	TUINT32 writeIntersectionDataTag(IntersectionDataTag *tag);

	TUINT32 writeOutlineOptionsTag(StrokeOutlineOptionsTag *tag);

	TUINT32 writePrecisionScaleTag(PrecisionScaleTag *tag);

	inline void writeDinamicData(TUINT32 val);

	inline void writeDinamicData(TINT32 val, bool isNegative);

	inline void setDinamicTypeBytesNum(int minval, int maxval);

	PliTag *findTagFromOffset(UINT tagOffs);

	UINT findOffsetFromTag(PliTag *tag);

	TagElem *findTag(PliTag *tag);

	USHORT readTagHeader();

public:

	enum errorType {

		NO__ERROR = 0,

		NO_FILE,

		BAD_MAGIC,

		PREMATURE_EOF,

		WRITE_ERROR,

		ERRORTYPE_HOW_MANY

	};

	errorType m_lastError;

	string m_creator;

	TagElem *m_firstTag;

	TagElem *m_lastTag;

	TagElem *m_currTag;

	MyIfstream m_iChan;

	MyOfstream *m_oChan;

	ParsedPliImp();

	ParsedPliImp(UCHAR majorVersionNumber,

				 UCHAR minorVersionNumber,

				 USHORT framesNumber,

				 UCHAR precision,

				 UCHAR maxThickness,

				 double autocloseTolerance);

	ParsedPliImp(const TFilePath &filename, bool readInfo);

	~ParsedPliImp();

	void setFrameCount(int frameCount);

	int getFrameCount();

	void loadInfo(bool readPalette, TPalette *&palette, TContentHistory *&history);

	ImageTag *loadFrame(const TFrameId &frameNumber);

	TagElem *readTag();

	void writeTag(TagElem *tag);

	bool addTag(PliTag *tag, bool addFront = false);

	bool addTag(const TagElem &tag, bool addFront = false);

	bool writePli(const TFilePath &filename);

	inline void WRITE_UCHAR_FROM_DOUBLE(double dval);

	inline void WRITE_SHORT_FROM_DOUBLE(double dval);

};

/*=====================================================================*/

double ParsedPli::getMaxThickness() const { return imp->m_maxThickness; };

void ParsedPli::setMaxThickness(double maxThickness)

{

	imp->m_maxThickness = maxThickness;

};

/*=====================================================================*/

static inline UCHAR complement1(char val, bool isNegative = false)

{

	if (val == 0)

		return isNegative ? 0x80 : 0;

	return (UCHAR)(abs(val) | (val & 0x80));

}

/*=====================================================================*/

static inline USHORT complement1(short val, bool isNegative = false)

{

	if (val == 0)

		return isNegative ? 0x8000 : 0;

	return (USHORT)(abs(val) | (val & 0x8000));

}

/*=====================================================================*/

static inline TUINT32 complement1(TINT32 val, bool isNegative = false)

{

	if (val == 0)

		return isNegative ? 0x80000000 : 0;

	return (TUINT32)(abs(val) | (val & 0x80000000));

}

/*=====================================================================*/

static inline short complement2(USHORT val)

{

	return (val & 0x8000) ? -(val & 0x7fff) : (val & 0x7fff);

}

/*=====================================================================*/

ParsedPliImp::ParsedPliImp()

	: m_majorVersionNumber(0)

	, m_minorVersionNumber(0)

	, m_framesNumber(0)

	, m_thickRatio(1.0)

	, m_maxThickness(0.0)

	, m_firstTag(NULL)

	, m_lastTag(NULL)

	, m_currTag(NULL)

	, m_iChan()

	, m_oChan(0)

	, m_bufLength(0)

	, m_affine()

	, m_precisionScale(REGION_COMPUTING_PRECISION)

	, m_creator("")

{

}

/*=====================================================================*/

ParsedPliImp::ParsedPliImp(UCHAR majorVersionNumber,

						   UCHAR minorVersionNumber,

						   USHORT framesNumber,

						   UCHAR precision,

						   UCHAR maxThickness,

						   double autocloseTolerance)

	: m_majorVersionNumber(majorVersionNumber)

	, m_minorVersionNumber(minorVersionNumber)

	, m_framesNumber(framesNumber)

	, m_maxThickness(maxThickness)

	, m_autocloseTolerance(autocloseTolerance)

	, m_thickRatio(maxThickness / 255.0)

	, m_firstTag(NULL)

	, m_lastTag(NULL)

	, m_currTag(NULL)

	, m_iChan()

	, m_oChan(0)

	, m_bufLength(0)

	, m_affine(TScale(1.0 / pow(10.0, precision)))

	, m_precisionScale(REGION_COMPUTING_PRECISION)

	, m_creator("")

{

}

/*=====================================================================*/

ParsedPliImp::ParsedPliImp(const TFilePath &filename, bool readInfo)

	: m_majorVersionNumber(0), m_minorVersionNumber(0)

	, m_framesNumber(0)

	, m_thickRatio(1.0)

	, m_maxThickness(0)

	, m_firstTag(NULL)

	, m_lastTag(NULL)

	, m_currTag(NULL)

	, m_iChan()

	, m_oChan(0)

	, m_bufLength(0)

	, m_precisionScale(REGION_COMPUTING_PRECISION)

	, m_creator("")

{

	TUINT32 magic;

	//  TUINT32 fileLenght;

	TagElem *tagElem;

	UCHAR maxThickness;

	// cerr<

	//#ifdef _WIN32

	m_iChan.open(filename);

	//m_iChan.exceptions( ios::failbit | ios::badbit);

	//#else

	//  m_iChan.open(filename.c_str(), ios::in);

	//#endif

	m_iChan >> magic;

	CHECK_FOR_READ_ERROR(filename);

	if (magic == c_magicNt) {

#if TNZ_LITTLE_ENDIAN

		m_isIrixEndian = false;

#else

		m_isIrixEndian = true;

#endif

		m_iChan.setEndianess(false);

	} else if (magic == c_magicIrix) {

#if TNZ_LITTLE_ENDIAN

		m_isIrixEndian = true;

#else

		m_isIrixEndian = false;

#endif

		m_iChan.setEndianess(true);

	} else {

		m_lastError = BAD_MAGIC;

		throw TImageException(filename, "Error on reading magic number");

	}

	m_iChan >> m_majorVersionNumber;

	m_iChan >> m_minorVersionNumber;

	//Loading pli versions AFTER current one is NOT SUPPORTED. This means that an

	//exception is directly called at this point.

	if (m_majorVersionNumber > c_majorVersionNumber ||

		(m_majorVersionNumber == c_majorVersionNumber && m_minorVersionNumber > c_minorVersionNumber))

		throw TImageVersionException(filename, m_majorVersionNumber, m_minorVersionNumber);

	if (m_majorVersionNumber > 5 || m_majorVersionNumber == 5 && m_minorVersionNumber >= 8)

		m_iChan >> m_creator;

	if (m_majorVersionNumber < 5) {

		TUINT32 fileLenght;

		m_iChan >> fileLenght;

		m_iChan >> m_framesNumber;

		m_iChan >> maxThickness;

		m_thickRatio = maxThickness / 255.0;

		if (readInfo)

			return;

		CHECK_FOR_READ_ERROR(filename);

		m_currDinamicTypeBytesNum = 2;

		while ((tagElem = readTag())) {

			if (!m_firstTag)

				m_firstTag = m_lastTag = tagElem;

			else {

				m_lastTag->m_next = tagElem;

				m_lastTag = m_lastTag->m_next;

			}

		}

		for (tagElem = m_firstTag; tagElem; tagElem = tagElem->m_next)

			tagElem->m_offset = 0;

		m_iChan.close();

	}

}

/*=====================================================================*/

extern TPalette *readPalette(GroupTag *paletteTag, int majorVersion, int minorVersion);

/*=====================================================================*/

const TFrameId &ParsedPli::getFrameNumber(int index)

{

	assert(imp->m_frameOffsInFile.size() == imp->m_framesNumber);

	std::map<tframeid, int="">::iterator it = imp->m_frameOffsInFile.begin();</tframeid,>

	std::advance(it, index);

	return it->first;

}

/*=====================================================================*/

void ParsedPliImp::loadInfo(bool readPlt, TPalette *&palette, TContentHistory *&history)

{

	TUINT32 fileLenght;

	m_iChan >> fileLenght;

	m_iChan >> m_framesNumber;

	if (!((m_majorVersionNumber == 5 && m_minorVersionNumber >= 7) || (m_majorVersionNumber > 5))) {

		UCHAR maxThickness;

		m_iChan >> maxThickness;

		m_thickRatio = maxThickness / 255.0;

	} else

		m_thickRatio = 0;

	UCHAR ii, d, s = 2;

	if (m_majorVersionNumber > 6 || (m_majorVersionNumber == 6 && m_minorVersionNumber >= 5))

		m_iChan >> s;

	m_iChan >> ii;

	m_iChan >> d;

	m_autocloseTolerance = ((double)(s - 1)) * (ii + 0.01 * d);

	m_currDinamicTypeBytesNum = 2;

	//m_frameOffsInFile = new int[m_framesNumber];

	//for (int i=0; i

	//  m_frameOffsInFile[i] = -1;

	TUINT32 pos = m_iChan.tellg();

	USHORT type;

	while ((type = readTagHeader()) != PliTag::END_CNTRL) {

		if (type == PliTag::IMAGE_BEGIN_GOBJ) {

			USHORT frame;

			m_iChan >> frame;

			char letter = 0;

			if (m_majorVersionNumber > 6 || (m_majorVersionNumber == 6 && m_minorVersionNumber >= 6))

				m_iChan >> letter;

			m_frameOffsInFile[TFrameId(frame, letter)] = m_iChan.tellg();

			//m_iChan.seekg(m_tagLength, ios::cur);

			m_iChan.seekg(m_tagLength - 2, ios::cur);

		} else if (type == PliTag::STYLE_NGOBJ) {

			m_iChan.seekg(pos, ios::beg);

			TagElem *tagElem = readTag();

			addTag(*tagElem);

			tagElem->m_tag = 0;

			delete tagElem;

		} else if (type == PliTag::TEXT) {

			m_iChan.seekg(pos, ios::beg);

			TagElem *tagElem = readTag();

			TextTag *textTag = (TextTag *)tagElem->m_tag;

			history = new TContentHistory(true);

			history->deserialize(QString::fromStdString(textTag->m_text));

			delete tagElem;

		}

		else if (type == PliTag::GROUP_GOBJ && readPlt) //la paletta!!!

		{

			m_iChan.seekg(pos, ios::beg);

			TagElem *tagElem = readTag();

			GroupTag *grouptag = (GroupTag *)tagElem->m_tag;

			if (grouptag->m_type == (UCHAR)GroupTag::PALETTE) {

				readPlt = false;

				palette = readPalette((GroupTag *)tagElem->m_tag,

									  m_majorVersionNumber, m_minorVersionNumber);

			} else

				assert(grouptag->m_type == (UCHAR)GroupTag::STROKE);

			delete tagElem;

		} else {

			m_iChan.seekg(m_tagLength, ios::cur);

			switch (type) {

			case PliTag::SET_DATA_8_CNTRL:

				m_currDinamicTypeBytesNum = 1;

				break;

			case PliTag::SET_DATA_16_CNTRL:

				m_currDinamicTypeBytesNum = 2;

				break;

			case PliTag::SET_DATA_32_CNTRL:

				m_currDinamicTypeBytesNum = 4;

				break;

			default:

				break;

			}

		}

		pos = m_iChan.tellg();

	}

	assert(m_frameOffsInFile.size() == m_framesNumber);

	//palette = new TPalette();

	//for (int i=0; i<256; i++)

	//  palette->getPage(0)->addStyle(TPixel::Black);

}

/*=====================================================================*/

USHORT ParsedPliImp::readTagHeader()

{

	UCHAR ucharTagType, tagLengthId;

	USHORT tagType;

// unused variable

#if 0

  TUINT32 tagOffset = m_iChan.tellg();

#endif

	m_iChan >> ucharTagType;

	if (ucharTagType == 0xFF) {

		m_iChan >> tagType;

		tagLengthId = tagType >> 14;

		tagType &= 0x3FFF;

	} else {

		tagType = ucharTagType;

		tagLengthId = tagType >> 6;

		tagType &= 0x3F;

	}

	m_tagLength = 0;

	switch (tagLengthId) {

	case 0x0:

		m_tagLength = 0;

		break;

	case 0x1: {

		UCHAR clength;

		m_iChan >> clength;

		m_tagLength = clength;

		break;

	}

	case 0x2: {

		USHORT slength;

		m_iChan >> slength;

		m_tagLength = slength;

		break;

	}

	case 0x3:

		m_iChan >> m_tagLength;

		break;

	default:

		assert(false);

		break;

	}

	return tagType;

}

/*=====================================================================*/

ImageTag *ParsedPliImp::loadFrame(const TFrameId &frameNumber)

{

	m_currDinamicTypeBytesNum = 2;

	TagElem *tagElem = m_firstTag;

	while (tagElem) {

		TagElem *auxTag = tagElem;

		tagElem = tagElem->m_next;

		delete auxTag;

	}

	m_firstTag = 0;

	//PliTag *tag;

	USHORT type = PliTag::IMAGE_BEGIN_GOBJ;

	USHORT frame;

	char letter;

	TFrameId frameId;

	// cerco il frame

	std::map<tframeid, int="">::iterator it;</tframeid,>

	it = m_frameOffsInFile.find(frameNumber);

	if (it != m_frameOffsInFile.end()) {

		m_iChan.seekg(it->second, ios::beg);

		frameId = it->first;

	} else

		while ((type = readTagHeader()) != PliTag::END_CNTRL) {

			if (type == PliTag::IMAGE_BEGIN_GOBJ) {

				m_iChan >> frame;

				if (m_majorVersionNumber > 6 || (m_majorVersionNumber == 6 && m_minorVersionNumber >= 6))

					m_iChan >> letter;

				else

					letter = 0;

				frameId = TFrameId(frame, letter);

				m_frameOffsInFile[frameId] = m_iChan.tellg();

				if (frameId == frameNumber)

					break;

			} else

				m_iChan.seekg(m_tagLength, ios::cur);

		}

	if (type == PliTag::END_CNTRL) {

		throw TImageException(TFilePath(), "Pli: frame not found");

		return 0;

	}

	//trovato; leggo i suoi tag

	while ((tagElem = readTag())) {

		if (!m_firstTag)

			m_firstTag = m_lastTag = tagElem;

		else {

			m_lastTag->m_next = tagElem;

			m_lastTag = m_lastTag->m_next;

		}

		if (tagElem->m_tag->m_type == PliTag::IMAGE_GOBJ) {

			assert(((ImageTag *)(tagElem->m_tag))->m_numFrame == frameId);

			return (ImageTag *)tagElem->m_tag;