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

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;

}

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

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

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

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

}

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

class MyOfstream final : 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 length;

  (*this) >> length;

  for (UINT i = 0; i < length; 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;

  }

}

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

#define CHECK_FOR_READ_ERROR(filePath)

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

  bool m_versionLocked = false;

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

  PliTag *readAutoCloseToleranceTag();

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

  TUINT32 writeAutoCloseToleranceTag(AutoCloseToleranceTag *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;

};

/* indirect inclusion of <math.h> causes 'abs' to return double on Linux */</math.h>

#if defined(LINUX) || (defined(_WIN32) && defined(__GNUC__))

template <typename t=""></typename>

T abs_workaround(T a) {

  return (a > 0) ? a : -a;

}

#define abs abs_workaround

#endif

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

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

}

#if defined(LINUX) || (defined(_WIN32) && defined(__GNUC__))

#undef abs

#endif

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

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

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

    m_iChan >> fileLength;

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

  m_iChan >> fileLength;

  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;

    }

  }

  return 0;

}

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

TagElem *ParsedPliImp::readTag() {

  UCHAR ucharTagType, tagLengthId;

  USHORT tagType;

  TUINT32 tagOffset = m_iChan.tellg();

  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: {