tahoma2d/toonz/sources/image/zcc/tiio_zcc.cpp

#include "tiio_zcc.h"
//#include "tparam.h"
#include "tsystem.h"

#ifdef DOPO_LO_FACCIAMO

#define PID_TAG(X)                                                             \
  (((X) >> 24) | ((X >> 8) & 0x0000FF00) | ((X << 8) & 0x00FF0000) |           \
   ((X) << 24))

/*

HEADER 'HDR '  32 bytes >
  0 |  4  |  Magic number 'ZCC '
  4 |  4  |  Major revision
  8 |  4  |  Minor revision
 12 |  4  |  Frame rate num
 16 |  4  |  Frame rate den
 20 |  4  |  Frame count
 24 |  4  |  Compressor type ( 'YUV2', 'RGBM' )
 28 |  4  |  Padding (future use)
<HEADER


FRAMEDATA 'FRME' >
  0 FRAMEDESCRIPTOR 'DSCR' 16 bytes >
     0 |  4  |  Frame ID
     4 |  4  |  Width
     8 |  4  |  Height
    12 |  4  |  RawData size
   <FRAMEDESCRIPTOR

  16 RAWDATA 'DATA' RawDataSize >
     0 |
   <RAWDATA

<FRAMEDATA

*/

/*
class ZCCParser {
TFile &m_file;
public:
  ZCCParser(TFile&file) : m_file(file)
    {
    m_file.seek(0);
    string tag = readTag();
    }
private:
  string readTag()
    {


    }
};

*/
//-----------------------------------------------------------

TReaderWriterInfo *TReaderWriterInfoZCC::create(const string &) {
  return new TReaderWriterInfoZCC();
}

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

TReaderWriterInfoZCC::TReaderWriterInfoZCC() {
  int c               = 0;
  TIntEnumParamP type = new TIntEnumParam();

  type->addItem(c++, "RGBM Uncompressed");
  type->addItem(c++, "YUV  Uncompressed");
  addParam("codec", type.getPointer());
}

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

TReaderWriterInfo *TReaderWriterInfoZCC::clone() const {
  return new TReaderWriterInfoZCC(*this);
}

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

TReaderWriterInfoZCC::~TReaderWriterInfoZCC() {}

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

TReaderWriterInfoZCC::TReaderWriterInfoZCC(const TReaderWriterInfoZCC &src)
    : TReaderWriterInfo(src) {}

//===========================================================
class TImageReaderWriterZCC : public TImageReaderWriter {
public:
  TImageReaderWriterZCC(const TFilePath &fp, int index,
                        TLevelReaderWriterZCC *lrw);

private:
  // not implemented
  TImageReaderWriterZCC(const TImageReaderWriterZCC &);
  TImageReaderWriterZCC &operator=(const TImageReaderWriterZCC &src);

public:
  void save(const TImageP &);
  TImageP load();
  void load(const TRasterP &ras, const TPoint &pos = TPoint(0, 0),
            int shrinkX = 1, int shrinkY = 1);
  int m_index;

private:
  TLevelReaderWriterZCC *m_lrw;
};

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

using namespace TFileConsts;
TLevelReaderWriterZCC::TLevelReaderWriterZCC(const TFilePath &path,
                                             TReaderWriterInfo *winfo)
    : TLevelReaderWriter(path, winfo)
    , m_file(path, kReadWrite | kUnbuffered | kOpenAlways)
    , m_indexFile(path.withType("ndx"), kReadWrite | kOpenAlways)
    , m_initDone(false)
    , m_blockSize(0) {
  if (!m_file.isOpen()) throw TImageException(path, m_file.getLastError());

  TFilePathSet fps = TSystem::getDisks();
  TFilePath disk;

  for (TFilePathSet::iterator it = fps.begin(); it != fps.end(); it++) {
    disk = *it;
    if (disk.isAncestorOf(m_path)) {
      DWORD sectorsPerCluster;
      // DWORD bytesPerSector;
      DWORD numberOfFreeClusters;
      DWORD totalNumberOfClusters;

      BOOL rc = GetDiskFreeSpaceW(
          disk.getWideString().c_str(), &sectorsPerCluster, &m_blockSize,
          &numberOfFreeClusters, &totalNumberOfClusters);
      break;
    }
  }
  assert(m_blockSize);
}

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

void TLevelReaderWriterZCC::saveSoundTrack(TSoundTrack *st) {}
//-----------------------------------------------------------

TLevelP TLevelReaderWriterZCC::loadInfo() {
  TLevelP level;
  if (!m_file.size()) return level;

  m_file.seek(0);
  UCHAR *buffer = new UCHAR[m_blockSize];

  m_file.read(buffer, m_blockSize);

  ULONG magicNumber = *(ULONG *)&buffer[0];
  assert(magicNumber == PID_TAG('ZCC '));
  ULONG majorRevision  = *(ULONG *)&buffer[4];
  ULONG minorRevision  = *(ULONG *)&buffer[8];
  ULONG frameRateNum   = *(ULONG *)&buffer[12];
  ULONG frameRateDen   = *(ULONG *)&buffer[16];
  ULONG frameCount     = *(ULONG *)&buffer[20];
  ULONG compressorType = *(ULONG *)&buffer[24];

  delete[] buffer;

  TINT64 offset = m_blockSize;
  TINT64 fs     = m_file.size();
  while (offset < fs) {
    m_file.seek(offset);
    m_file.read(buffer, m_blockSize);

    ULONG frameId     = *(ULONG *)&buffer[0];
    ULONG width       = *(ULONG *)&buffer[4];
    ULONG height      = *(ULONG *)&buffer[8];
    ULONG rawDataSize = *(ULONG *)&buffer[12];

    TINT64 d = rawDataSize + 16;

    int headerSize = 16;
    int dataSize   = rawDataSize + headerSize;

    long bufferSize = tceil(dataSize / (double)m_blockSize) * m_blockSize;

    m_map[frameId] = C(offset, bufferSize, width, height);
    level->setFrame(TFrameId(frameId), TImageP());

    offset += bufferSize;
  }
  return level;
}

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

TImageReaderWriterP TLevelReaderWriterZCC::getFrameReaderWriter(TFrameId id) {
  TImageReaderWriterZCC *iwm =
      new TImageReaderWriterZCC(m_path, id.getNumber(), this);
  return TImageReaderWriterP(iwm);
}

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

TLevelReaderWriterZCC::~TLevelReaderWriterZCC() {
  m_file.seek(0);
  UCHAR *buffer = new UCHAR[m_blockSize];
  memset(buffer, 0, m_blockSize);

  ULONG *magicNumber = (ULONG *)&buffer[0];
  *magicNumber       = PID_TAG('ZCC ');

  ULONG *majorRevision = (ULONG *)&buffer[4];
  *majorRevision       = 0x0001;

  ULONG *minorRevision = (ULONG *)&buffer[8];
  *minorRevision       = 0x0000;

  ULONG *frameRateNum = (ULONG *)&buffer[12];
  *frameRateNum       = 25;

  ULONG *frameRateDen = (ULONG *)&buffer[16];
  *frameRateDen       = 1;

  ULONG *frameCount = (ULONG *)&buffer[20];
  *frameCount       = 0xffff;

  ULONG *compressorType = (ULONG *)&buffer[24];
  *compressorType       = PID_TAG('RGBM');

  m_file.write(buffer, m_blockSize);
  delete[] buffer;
}

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

TImageReaderWriterZCC::TImageReaderWriterZCC(const TFilePath &fp, int index,
                                             TLevelReaderWriterZCC *lrw)
    : TImageReaderWriter(fp), m_lrw(lrw), m_index(index) {}

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

void TImageReaderWriterZCC::save(const TImageP &img) {
  TFile &file = m_lrw->m_file;

  TRaster32P ras = TRasterImageP(img)->getRaster();

  int rasDataSize = ras->getRowSize() * ras->getLy();
  int headerSize  = 16;
  int dataSize    = rasDataSize + headerSize;

  int bufferSize =
      tceil(dataSize / (double)m_lrw->m_blockSize) * m_lrw->m_blockSize;

  TINT64 offset         = bufferSize * m_index + m_lrw->m_blockSize;
  m_lrw->m_map[m_index] = C(offset, bufferSize, ras->getLx(), ras->getLy());

  if (!file.seek(offset /*per l'header*/))
    throw TImageException(m_path, file.getLastError());

  TRasterImageP rasImage = img;

  UCHAR *buffer = new UCHAR[bufferSize];

  ULONG *frameId = (ULONG *)&buffer[0];
  *frameId       = m_index;

  ULONG *width = (ULONG *)&buffer[4];
  *width       = ras->getLx();

  ULONG *height           = (ULONG *)&buffer[8];
  *height                 = ras->getLy();
  bwww ULONG *rawDataSize = (ULONG *)&buffer[12];
  *rawDataSize            = rasDataSize;
  memcpy(&buffer[16], ras->getRawData(), rasDataSize);

  if (!file.write(buffer, bufferSize))
    throw TImageException(m_path, file.getLastError());
  delete[] buffer;
}

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

TImageP TImageReaderWriterZCC::load() {
  C c = m_lrw->m_map[m_index];

  TRaster32P ras(c.m_lx, c.m_ly);
  load(ras);
  return TImageP(TRasterImageP(ras));
}

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

void TImageReaderWriterZCC::load(const TRasterP &ras, const TPoint &pos,
                                 int shrinkX, int shrinkY) {
  if (!m_lrw->m_initDone) {
    //
    // write header
    //
    m_lrw->m_initDone = true;
  }
  TFile &file = m_lrw->m_file;

  /*
std::map<int, C>::iterator it = std::find(m_lrw->m_map.begin(),
m_lrw->m_map.end(), m_index);
if (it == m_lrw->m_map.end())
return;
*/

  C c = m_lrw->m_map[m_index];

  if (!file.seek(c.m_offset))
    throw TImageException(m_path, file.getLastError());

  UCHAR *buffer = new UCHAR[c.m_size];

  if (!file.read(buffer, c.m_size))
    throw TImageException(m_path, file.getLastError());

  ULONG *frameId = (ULONG *)&buffer[0];
  assert(*frameId == (ULONG)m_index);

  ULONG *width = (ULONG *)&buffer[4];

  ULONG *height = (ULONG *)&buffer[8];

  ULONG *rawDataSize = (ULONG *)&buffer[12];

  assert((ULONG)ras->getLx() == *width);
  assert((ULONG)ras->getLy() == *height);

  memcpy(ras->getRawData(), &buffer[16], *rawDataSize);

  delete[] buffer;
}

#endif