341 lines
8.8 KiB
C++
341 lines
8.8 KiB
C++
|
|
|
|
#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(), §orsPerCluster, &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
|