bool writeHeader(NxI8 a, NxI8 b, NxI8 c, NxI8 d, NxU32 version, bool mismatch, NxStream& stream)
{
// Store endianness
NxI8 streamFlags = littleEndian();
if(mismatch) streamFlags^=1;
// Export header
saveChunk('N', 'X', 'S', streamFlags, stream); // "Novodex stream" identifier
saveChunk(a, b, c, d, stream); // Chunk identifier
// stream.storeDword(version); // Version number
writeDword(version, mismatch, stream);
return true;
}
void VstPlugin::saveSettings( QDomDocument & _doc, QDomElement & _this )
{
if( pluginWidget() != NULL )
{
_this.setAttribute( "guivisible", pluginWidget()->isVisible() );
}
// try to save all settings in a chunk
QByteArray chunk = saveChunk();
if( !chunk.isEmpty() )
{
_this.setAttribute( "chunk", QString( chunk.toBase64() ) );
}
else
{
// plugin doesn't seem to support chunks, therefore save
// individual parameters
const QMap<QString, QString> & dump = parameterDump();
_this.setAttribute( "numparams", dump.size() );
for( QMap<QString, QString>::const_iterator it = dump.begin();
it != dump.end(); ++it )
{
_this.setAttribute( it.key(), it.value() );
}
}
_this.setAttribute( "program", currentProgram() );
}
void Downloader::onDownloadTaskFinished(int num, Range range, QByteArray *data) {
QMutexLocker locker{&finishedMutex};
chunksMap[range.first] = data;
downloadCount++;
saveChunk();
emit chunkFinished(num, range);
}
void cWorld::saveAll()
{
for (int y = 0; y < LIMIT_MAP; y++)
{
for (int x = 0; x < LIMIT_MAP; x++)
{
if (map[x][y].isLoaded) {
saveChunk(vec2i(x, y));
}
}
}
}
int send_rr_app(int equalize, int segmentNumber, char* buf) {
int i = 0;
if(equalize == 0) {
for(i = 0; i < ll.sequenceNumber; i++)
ll.compFrame[i] = buf[i];
return llwrite(equalize,buf,0);
}
else if (equalize == 1) {
if(checkFrames(buf) == 0) {
if(segmentNumber > 0)
saveChunk(buf,ll.sequenceNumber);
}
return llwrite(equalize,buf,0);
}
return -1;
}
int FileWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: newScene(); break;
case 1: addChunk(); break;
case 2: addTile(); break;
case 3: saveChunk(); break;
case 4: saveTile(); break;
default: ;
}
_id -= 5;
}
return _id;
}
FileWidget::FileWidget()
: QWidget(0)
{
newSceneBtn = new QPushButton("New Scene");
chunkCmb = new QComboBox();
addChunkToSceneBtn = new QPushButton("Add Scene");
tileCmb = new QComboBox();
addTileToSceneBtn = new QPushButton("Add Tile");
saveAsChunkBtn = new QPushButton("Save as Scene");
saveAsTileBtn = new QPushButton("Save as Tile");
QVBoxLayout *mainLayout = new QVBoxLayout;
QHBoxLayout *chunkLayout = new QHBoxLayout;
QHBoxLayout *tileLayout = new QHBoxLayout;
QHBoxLayout *saveLayout = new QHBoxLayout;
chunkLayout->addWidget(chunkCmb);
chunkLayout->addWidget(addChunkToSceneBtn);
saveLayout->addWidget(saveAsChunkBtn);
mainLayout->addWidget(newSceneBtn);
mainLayout->addLayout(chunkLayout);
mainLayout->addLayout(saveLayout);
mainLayout->setContentsMargins(0,0,0,0);
setLayout(mainLayout);
connect(newSceneBtn, SIGNAL(clicked()),this, SLOT(newScene()));
connect(addChunkToSceneBtn, SIGNAL(clicked()),this, SLOT(addChunk()));
connect(addTileToSceneBtn, SIGNAL(clicked()),this, SLOT(addTile()));
connect(saveAsChunkBtn, SIGNAL(clicked()),this, SLOT(saveChunk()));
connect(saveAsTileBtn, SIGNAL(clicked()),this, SLOT(saveTile()));
setFixedHeight(sizeHint().height());
setFixedWidth(400);
}
void Downloader::saveChunk() {
// Lock on chunks map is required to be acquired going into this
// method!
if (chunksMap.isEmpty()) {
// Wait for commit thread to be done.
return;
}
auto key = chunksMap.firstKey();
const auto *value = chunksMap[key];
if (value != nullptr) {
emit chunkToThread(value, chunksMap.size() == 1);
if (!commitThread.isRunning()) {
commitThread.start();
}
chunksMap.remove(key);
}
// If everything has been downloaded then call method again.
if (rangeCount == downloadCount) {
saveChunk();
}
}
void FPTWriter::flexSave( std::string filepath, ChunkChunkList * globalChunks )
{
DEBUG << "saving " + filepath;
ops::msole::FileWriter * writer = new ops::msole::FileWriter();
writer->open( filepath );
{
int32_t handler = writer->fileOpen( "Future Pinball/File Version" );
ChunkChunkList * chunks = (ChunkChunkList*)getChunkByLabel( globalChunks, CHUNK_FILE_VERSION.label );
ChunkRawData * chunkRawData = (ChunkRawData*)getChunkByLabel( chunks, CHUNK_FILE_VERSION_DATA.label );
writer->fileWrite( handler, &chunkRawData->value );
writer->fileClose( handler );
}
{
int32_t handler = writer->fileOpen( "Future Pinball/Table MAC" );
#ifdef _WIN32
ops::RawData dataMAC(16, true);
calcMAC(globalChunks, dataMAC.data, dataMAC.len);
writer->fileWrite( handler, &dataMAC );
#else
WARNING << "Can't rebuild table MAC"
ChunkChunkList * chunks = (ChunkChunkList*)getChunkByLabel( globalChunks, CHUNK_TABLE_MAC.label );
ChunkRawData * chunkRawData = (ChunkRawData*)getChunkByLabel( chunks, CHUNK_TABLE_MAC_DATA.label );
writer->fileWrite( handler, &chunkRawData->value );
#endif
writer->fileClose( handler );
}
{
int32_t handler = writer->fileOpen( "Future Pinball/Table Data" );
ChunkChunkList * chunks = (ChunkChunkList*)getChunkByLabel( globalChunks, CHUNK_TABLE_DATA.label );
saveChunk( writer, handler, chunks );
writer->fileClose( handler );
}
{
ChunkChunkList * chunksList = (ChunkChunkList*)getChunksByLabel( globalChunks, CHUNK_IMAGE.label );
for( uint32_t i = 0; i < chunksList->value.size(); i++ )
{
ChunkChunkList * currentChunk = (ChunkChunkList *)chunksList->value[i];
std::string name = "Future Pinball/Image ";
std::stringstream ss;
std::string number;
ss << ( i + 1 );
ss >> number;
int32_t handler = writer->fileOpen( name + number );
saveChunk( writer, handler, currentChunk );
writer->fileClose( handler );
}
}
{
ChunkChunkList * chunksList = (ChunkChunkList*)getChunksByLabel( globalChunks, CHUNK_SOUND.label );
for( uint32_t i = 0; i < chunksList->value.size(); i++ )
{
ChunkChunkList * currentChunk = (ChunkChunkList *)chunksList->value[i];
std::string name = "Future Pinball/Sound ";
std::stringstream ss;
std::string number;
ss << ( i + 1 );
ss >> number;
int32_t handler = writer->fileOpen( name + number );
saveChunk( writer, handler, currentChunk );
writer->fileClose( handler );
}
}
{
ChunkChunkList * chunksList = (ChunkChunkList*)getChunksByLabel( globalChunks, CHUNK_MUSIC.label );
for( uint32_t i = 0; i < chunksList->value.size(); i++ )
{
ChunkChunkList * currentChunk = (ChunkChunkList *)chunksList->value[i];
std::string name = "Future Pinball/Music ";
std::stringstream ss;
std::string number;
ss << ( i + 1 );
ss >> number;
int32_t handler = writer->fileOpen( name + number );
saveChunk( writer, handler, currentChunk );
writer->fileClose( handler );
}
}
{
ChunkChunkList * chunksList = (ChunkChunkList*)getChunksByLabel( globalChunks, CHUNK_DMDFONT.label );
for( uint32_t i = 0; i < chunksList->value.size(); i++ )
{
ChunkChunkList * currentChunk = (ChunkChunkList *)chunksList->value[i];
std::string name = "Future Pinball/DmdFont ";
std::stringstream ss;
std::string number;
ss << ( i + 1 );
ss >> number;
int32_t handler = writer->fileOpen( name + number );
saveChunk( writer, handler, currentChunk );
writer->fileClose( handler );
}
}
{
ChunkChunkList * chunksList = (ChunkChunkList*)getChunksByLabel( globalChunks, CHUNK_PINMODEL.label );
for( uint32_t i = 0; i < chunksList->value.size(); i++ )
{
ChunkChunkList * currentChunk = (ChunkChunkList *)chunksList->value[i];
std::string name = "Future Pinball/PinModel ";
std::stringstream ss;
std::string number;
ss << ( i + 1 );
ss >> number;
int32_t handler = writer->fileOpen( name + number );
saveChunk( writer, handler, currentChunk );
writer->fileClose( handler );
}
}
{
ChunkChunkList * chunksList = (ChunkChunkList*)getChunksByLabel( globalChunks, CHUNK_IMAGELIST.label );
for( uint32_t i = 0; i < chunksList->value.size(); i++ )
{
ChunkChunkList * currentChunk = (ChunkChunkList *)chunksList->value[i];
std::string name = "Future Pinball/ImageList ";
std::stringstream ss;
std::string number;
ss << ( i + 1 );
ss >> number;
int32_t handler = writer->fileOpen( name + number );
saveChunk( writer, handler, currentChunk );
writer->fileClose( handler );
}
}
{
ChunkChunkList * chunksList = (ChunkChunkList*)getChunksByLabel( globalChunks, CHUNK_LIGHTLIST.label );
for( uint32_t i = 0; i < chunksList->value.size(); i++ )
{
ChunkChunkList * currentChunk = (ChunkChunkList *)chunksList->value[i];
std::string name = "Future Pinball/LightList ";
std::stringstream ss;
std::string number;
ss << ( i + 1 );
ss >> number;
int32_t handler = writer->fileOpen( name + number );
saveChunk( writer, handler, currentChunk );
writer->fileClose( handler );
}
}
{
ChunkChunkList * chunksList = (ChunkChunkList*)getChunksByLabel( globalChunks, CHUNK_TABLE_ELEMENT.label );
for( uint32_t i = 0; i < chunksList->value.size(); i++ )
{
ChunkChunkList * currentChunk = (ChunkChunkList *)chunksList->value[i];
std::string name = "Future Pinball/Table Element ";
std::stringstream ss;
std::string number;
ss << ( i + 1 );
ss >> number;
int32_t handler = writer->fileOpen( name + number );
saveChunk( writer, handler, currentChunk );
writer->fileClose( handler );
}
}
writer->close();
DEBUG << filepath + " saved";
}
void FPTWriter::saveChunk( ops::msole::FileWriter * writer, int32_t handler, ChunkGeneric * chunk )
{
static int nCount =0;
nCount++;
switch( chunk->descriptor.type )
{
case T_CHUNK_CHUNKLIST:
if( chunk->descriptor.label == "shape_point" || chunk->descriptor.label == "ramp_point" )
{
saveTagChunk( writer, handler, chunk->originalChunk );
}
for( uint32_t i = 0; i < ((ChunkChunkList*)chunk )->value.size(); i++ )
{
saveChunk( writer, handler, ((ChunkChunkList*)chunk )->value[i] );
}
return;
break;
case T_CHUNK_GENERIC:
saveTagChunk( writer, handler, chunk->originalChunk );
break;
case T_CHUNK_COLLISIONDATA:
case T_CHUNK_RAWDATA:
//sk1 saveRawDataChunk( writer, handler, chunk->originalChunk, ((ChunkRawData*)chunk )->value.data, ((ChunkRawData*)chunk )->value.len, false, ((ChunkRawData*)chunk )->value.len );
saveRawDataChunk( writer, handler, chunk->originalChunk, ((ChunkRawData*)chunk )->value.data, ((ChunkRawData*)chunk )->value.len, ((ChunkRawData*)chunk )->value.ispacked(), ((ChunkRawData*)chunk )->value.len );
break;
case T_CHUNK_INT:
if( chunk->descriptor.chunk == CHUNK_ELEMENT_TYPE.chunk
&& chunk->descriptor.label == CHUNK_ELEMENT_TYPE.label
&& chunk->descriptor.type == CHUNK_ELEMENT_TYPE.type
)
{
writer->fileWrite( handler, (uint8_t*)&(((ChunkInt*)chunk )->value ), (uint32_t)sizeof( uint32_t ));
}
else
{
saveUInt32Chunk( writer, handler, chunk->originalChunk, ((ChunkInt*)chunk )->value );
}
break;
case T_CHUNK_COLOR:
saveUInt32Chunk( writer, handler, chunk->originalChunk, ((ChunkColor*)chunk )->value );
break;
case T_CHUNK_VALUELIST:
saveUInt32Chunk( writer, handler, chunk->originalChunk, ((ChunkValueList*)chunk )->value );
break;
case T_CHUNK_FLOAT:
saveFloatChunk( writer, handler, chunk->originalChunk, ((ChunkFloat*)chunk )->value );
break;
case T_CHUNK_VECTOR2D:
saveVector2DChunk( writer, handler, chunk->originalChunk, ((ChunkVector2D*)chunk )->value );
break;
case T_CHUNK_STRING:
saveStringChunk( writer, handler, chunk->originalChunk, ((ChunkString*)chunk )->value );
break;
case T_CHUNK_WSTRING:
saveWStringChunk( writer, handler, chunk->originalChunk, ((ChunkWString*)chunk )->value );
break;
case T_CHUNK_STRINGLIST:
{
saveStringListChunk( writer, handler, chunk->originalChunk, ((ChunkStringList*)chunk )->value );
}
break;
case T_CHUNK_SCRIPT:
{
ChunkScript* s = (ChunkScript*)chunk;
if( s->value.len > 4 )
{
if( memcmp( &s->value.data[4], "zLZO", 4 ) == 0 )
{
// save chunk len
uint32_t chunkLen = 4;
writer->fileWrite( handler, (uint8_t*)&chunkLen, (uint32_t)sizeof( uint32_t ));
// save chunk type
writer->fileWrite( handler, (uint8_t*)&chunk->originalChunk, (uint32_t)sizeof( uint32_t ));
// save compressed len
uint32_t len = s->value.len-4;
writer->fileWrite( handler, (uint8_t*)&len, (uint32_t)sizeof( uint32_t ));
// save compressed bytes
writer->fileWrite( handler, (uint8_t*)&s->value.data[4], (uint32_t) s->value.len-4 );
break;
}
}
// save chunk len
uint32_t chunkLen = 4;
writer->fileWrite( handler, (uint8_t*)&chunkLen, (uint32_t)sizeof( uint32_t ));
// save chunk
writer->fileWrite( handler, (uint8_t*)&chunk->originalChunk, (uint32_t)sizeof( uint32_t ));
// save uncompressed bytes
writer->fileWrite( handler, (uint8_t*)s->value.data, (uint32_t)s->value.len );
break;
}
default:
std::cout << " TODO " << std::endl;
break;
}
}
void PFPFile::save(const String &filename)
/*!\brief PFP-File speichern
*
* Mit dieser Funktion wird der Inhalt der PFPFile-Klasse in eine Datei geschrieben.
* Dabei wird der Header und sämtliche Chunks zusammengefasst, gegebenenfalls komprimiert
* (siehe PFPFile::SetCompression) und im Filesystem gespeichert. Der genaue Aufbau der Datei
* wird weiter unten beschrieben.
*
* \param filename Die Funktion bekommt als einzigen Parameter einen Pointer auf den Dateinamen.
* Es ist zu beachten, dass eine eventuell vorhandene gleichnamige Datei überschrieben wird.
* \exception EmptyFileException Das File enthält keine Chunks, es gibt nichts zu speichern
*
* \remarks
* Die Funktion stellt sicher, dass die Chunks in einer bestimmten Reihenfolge geschrieben
* werden. Die vordefinierten Chunks mit Name, Author, Copyright und Beschreibung werden in
* jedem Fall zuerst gespeichert, dann die restlichen Chunks.
*
* \par Aufbau der PFP-Datei
*
* \copydoc PFPFileVersion3
*
* \since Version 6.1.0
*/
{
// Gespeichert wird nur, wenn die Datei Chunks enthält
if (Chunks.num()==0) throw EmptyFileException();
File ff;
// Wir benötigen zuerst die Gesamtgröße aller Chunks
size_t size=24;
Iterator it;
Chunks.reset(it);
PFPChunk *chunk;
try {
while(Chunks.getNext(it)) {
size+=8;
size+=it.value()->chunksize;
}
} catch (...) {
}
// plus ENDF-Chunk
size+=8;
// Datei zusammenbauen
char *p=(char*)malloc(size);
if (!p) throw OutOfMemoryException();
size_t hsize=24;
strcpy(p,"PFP-File");
Poke8(p+8,3);
Poke8(p+9,hsize);
for (int i=0;i<4;i++) Poke8((p+10+i),(unsigned int)id[i]);
Poke8(p+15,mainversion);
Poke8(p+14,subversion);
Poke8(p+16,comp);
Poke8(p+17,0);
Poke8(p+18,0);
Poke8(p+19,0);
Poke32(p+20,(ppluint32)GetTime());
size_t pp=hsize;
// Chunks zusammenfassen
// Zuerst die vordefinierten, die wir am Anfang des Files wollen
Chunks.reset(it);
chunk=findFirstChunk(it,"NAME");
if (chunk) saveChunk(p,pp,chunk);
chunk=findFirstChunk(it,"AUTH");
if (chunk) saveChunk(p,pp,chunk);
chunk=findFirstChunk(it,"DESC");
if (chunk) saveChunk(p,pp,chunk);
chunk=findFirstChunk(it,"COPY");
if (chunk) saveChunk(p,pp,chunk);
// Restliche Chunks
Chunks.reset(it);
try {
while(Chunks.getNext(it)) {
PFPChunk *chunk=it.value();
String cn=chunk->chunkname;
// Vordefinierte Chunks müssen übergangen werden, da diese weiter oben schon
// ausgelesen wurden
if (cn!="NAME" && cn!="AUTH" && cn!="DESC" && cn!="COPY") {
saveChunk(p,pp,chunk);
}
}
} catch (...) {
}
strncpy(p+pp,"ENDF",4);
Poke32(p+pp+4,0);
pp+=8;
void *save=NULL;
size_t savesize=pp-hsize;
// Komprimierung?
Compression c;
if (comp) {
size_t dstlen=savesize+64;
save=malloc(dstlen);
if (!save) {
free(p);
throw OutOfMemoryException();
}
try {
c.init(comp,Compression::Level_High);
c.compress(save,&dstlen,p+hsize,savesize);
} catch (...) {
free(save);
free(p);
throw;
}
savesize=dstlen;
}
try {
ff.open(filename,File::WRITE);
} catch (...) {
if (save) free(save);
free(p);
throw;
}
ff.write(p,hsize);
if (comp) {
char t[8];
Poke32(t,pp-hsize);
Poke32(t+4,savesize);
ff.write(t,8);
ff.write(save,savesize);
} else {
ff.write(p+hsize,pp-hsize);
}
ff.close();
if (save) free(save);
free(p);
}
