/* ScummVM Tools * * ScummVM Tools is the legal property of its developers, whose names * are too numerous to list here. Please refer to the COPYRIGHT * file distributed with this source distribution. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * */ /* Mohawk file constructor */ #include "common/scummsys.h" #include "common/array.h" #include "common/file.h" #include "common/str.h" #include "common/util.h" #include "engines/mohawk/archive.h" #include "engines/mohawk/utils.h" uint32 _fileSize; struct RSRC_HeaderConstruct { uint16 version; uint16 compaction; uint32 filesize; uint32 abs_offset; uint16 file_table_offset; uint16 file_table_size; }; RSRC_HeaderConstruct _rsrc; TypeTable _typeTable; struct TypeConstructResourceEntries { uint16 id; uint16 index; }; struct TypeConstructNameEntries { uint16 offset; uint16 index; // Name List Common::String name; }; struct TypeConstruct { //Type Table uint32 tag; uint16 resource_table_offset; uint16 name_table_offset; struct ResourceTable { uint16 resources; Common::Array entries; } resTable; struct NameTable { uint16 num; Common::Array entries; } nameTable; }; struct ResourceFile { Common::Filename filename; uint32 index; int flags; Common::String typeTagStr; uint32 typeTag; uint16 id; Common::String name; uint32 size; }; Common::Array _types; Common::Array _fileTable; int16 getTypeIndex(uint32 tag) { for (uint16 i = 0; i < _typeTable.resource_types; i++) if (_types[i].tag == tag) return i; return -1; // not found } int16 getIdIndex(int16 typeIndex, uint16 id) { for (uint16 i = 0; i < _types[typeIndex].resTable.resources; i++) if (_types[typeIndex].resTable.entries[i].id == id) return i; return -1; // not found } Common::String tag2string(uint32 tag) { char str[5]; str[0] = (char)(tag >> 24); str[1] = (char)(tag >> 16); str[2] = (char)(tag >> 8); str[3] = (char)tag; str[4] = '\0'; // Replace non-printable chars by dot for (int i = 0; i < 4; ++i) { if (!isprint(str[i])) str[i] = '.'; } return Common::String(str); } uint32 string2tag(const char *str) { uint32 ret = 0; ret += str[0] << 24; ret += str[1] << 16; ret += str[2] << 8; ret += str[3]; return ret; } void initMohawkArchive() { // Initialize Mohawk Archive Parameters with parameters for empty archive _fileSize = 28; _rsrc.version = 256; // BCD 1.0 _rsrc.compaction = 1; _rsrc.filesize = 36; _rsrc.abs_offset = 28; _rsrc.file_table_offset = 4; _rsrc.file_table_size = 4; _typeTable.name_offset = 4; _typeTable.resource_types = 0; } void updateTypeTableOffsets() { for (uint16 i = 0; i < _typeTable.resource_types; i++) { _types[i].resource_table_offset = 4 + (_typeTable.resource_types * 8); for (uint16 j = 0; j < i; j++) { _types[i].resource_table_offset += 2 + (_types[j].resTable.resources * 4); _types[i].resource_table_offset += 2 + (_types[j].nameTable.num * 4); } _types[i].name_table_offset = _types[i].resource_table_offset + 2 + (_types[i].resTable.resources * 4); } } void addTypeToMohawkArchive(const char *resourceTag) { TypeConstruct newType; newType.tag = string2tag(resourceTag); newType.resource_table_offset = 0; newType.name_table_offset = 0; newType.resTable.resources = 0; newType.nameTable.num = 0; _fileSize += 12; _rsrc.filesize += 12; _rsrc.file_table_offset += 12; _typeTable.name_offset += 12; _typeTable.resource_types++; _types.push_back(newType); updateTypeTableOffsets(); } void addFileToMohawkArchive(const ResourceFile &file) { int16 typeIndex = getTypeIndex(file.typeTag); if (typeIndex == -1) { // Add New Type to typeTable addTypeToMohawkArchive(file.typeTagStr.c_str()); typeIndex = getTypeIndex(file.typeTag); } else { if (getIdIndex(typeIndex, file.id) != -1) { printf("Error : Duplicate Resource Type \'%s\' Id %d\n", file.typeTagStr.c_str(), file.id); return; } } // Update Resource Table TypeConstructResourceEntries newTypeResource; newTypeResource.id = file.id; newTypeResource.index = file.index + 1; _fileSize += 4; _rsrc.filesize += 4; _rsrc.file_table_offset += 4; _typeTable.name_offset += 4; // Insert in Resource Table ordered by id uint16 j; for (j = 0; j < _types[typeIndex].resTable.entries.size(); j++) { if (_types[typeIndex].resTable.entries[j].id > newTypeResource.id) break; } _types[typeIndex].resTable.resources++; _types[typeIndex].resTable.entries.insert_at(j, newTypeResource); updateTypeTableOffsets(); // Update Name Table if name is present if (!file.name.empty()) { TypeConstructNameEntries newTypeName; if (_types[typeIndex].nameTable.entries.empty()) newTypeName.offset = 0; else newTypeName.offset = _types[typeIndex].nameTable.entries.back().offset + _types[typeIndex].nameTable.entries.back().name.size() + 1; newTypeName.index = file.index + 1; newTypeName.name = file.name; _fileSize += 4 + file.name.size() + 1; _rsrc.filesize += 4 + file.name.size() + 1; _rsrc.file_table_offset += 4 + file.name.size() + 1; _typeTable.name_offset += 4; _types[typeIndex].nameTable.num++; _types[typeIndex].nameTable.entries.push_back(newTypeName); updateTypeTableOffsets(); } // TODO: Error if duplicate file table ids // TODO: Error if missing file table ids // Add file data parameters to fileTable uint32 fileItemOffset = 36; for (uint16 i = 0; i < _fileTable.size(); i++) fileItemOffset += _fileTable[i].dataSize; FileTable fileTableItem; fileTableItem.offset = fileItemOffset; fileTableItem.dataSize = file.size; fileTableItem.flags = file.flags; fileTableItem.unk = 0; _fileSize += 10; _rsrc.filesize += 10; _rsrc.file_table_size += 10; _fileTable.push_back(fileTableItem); _fileSize += file.size; _rsrc.filesize += file.size; _rsrc.abs_offset += file.size; } void sortTypeTable(Common::Array *tempTypeTable) { uint16 i, j; // Insert in Resource Type Table ordered Alphabetically by Resource Tag for (i = 0; i < _types.size(); i++) { for (j = 0; j < tempTypeTable->size(); j++) { if ((*tempTypeTable)[j].tag > _types[i].tag) break; } tempTypeTable->insert_at(j, _types[i]); } } // Original Archiver seems to treat '_' as greater than all alphanumerics which is not // the same as ASCII ordering and thus String '>' operator. This corrects for this. bool stringGreaterThan(Common::String *test, Common::String *ref) { // Normal Function if just ASCII ordering.. //return *test > *ref; // Function with correction for underscore ordered after Alphanumerics... for (uint16 i = 0; i < MIN(test->size(), ref->size()); i++) { if ((*test)[i] == '_' && (*ref)[i] != '_') return true; else if ((*test)[i] > (*ref)[i]) return true; else if ((*test)[i] < (*ref)[i]) return false; } if(test->size() > ref->size()) return true; else return false; } void sortNameTable(Common::Array *tempNameTable, uint16 i) { uint16 k, j; // Insert in Type Name Table ordered Alphabetically by Name for (k = 0; k < _types[i].nameTable.num; k++) { for (j = 0; j < tempNameTable->size(); j++) { if (stringGreaterThan(&((*tempNameTable)[j].name), &(_types[i].nameTable.entries[k].name))) break; } tempNameTable->insert_at(j, _types[i].nameTable.entries[k]); } assert(tempNameTable->size() == _types[i].nameTable.num); } void rewriteMovieOffsets(Common::File *resourceIn, Common::File *mohawkFile) { adjustQuickTimeAtomOffsets(resourceIn, resourceIn->size(), mohawkFile->pos(), mohawkFile); } void writeMohawkArchive(const Common::Array &files, Common::File *mohawkFile) { // Gap between RSRC and File Data.. _fileSize += 8; _rsrc.filesize += 8; _rsrc.abs_offset += 8; mohawkFile->writeUint32BE(ID_MHWK); mohawkFile->writeUint32BE(_fileSize); mohawkFile->writeUint32BE(ID_RSRC); mohawkFile->writeUint16BE(_rsrc.version); mohawkFile->writeUint16BE(_rsrc.compaction); mohawkFile->writeUint32BE(_rsrc.filesize); mohawkFile->writeUint32BE(_rsrc.abs_offset); mohawkFile->writeUint16BE(_rsrc.file_table_offset); mohawkFile->writeUint16BE(_rsrc.file_table_size); // Gap between RSRC and File Data... mohawkFile->writeUint16BE(4); // Not sure what this is... mohawkFile->writeUint16BE(0); mohawkFile->writeUint16BE(0); mohawkFile->writeUint16BE(0); for (uint i = 0; i < files.size(); i++) { const ResourceFile &file = files[i]; Common::File *resourceIn = new Common::File(file.filename, "rb"); if (!resourceIn->isOpen()) { printf("Could not open file \"%s\"\n", file.filename.getName().c_str()); delete resourceIn; return; } if (file.typeTag == ID_TMOV) { rewriteMovieOffsets(resourceIn, mohawkFile); } else { copyBytes(resourceIn, mohawkFile, resourceIn->size()); } resourceIn->close(); delete resourceIn; } // _rsrc.abs_offset points here... mohawkFile->writeUint16BE(_typeTable.name_offset); mohawkFile->writeUint16BE(_typeTable.resource_types); Common::Array tempTypeTable; // _types sorted into Resource Tag Alphabetical order into tempTypeTable sortTypeTable(&tempTypeTable); for (uint16 i = 0; i < _typeTable.resource_types; i++) { mohawkFile->writeUint32BE(tempTypeTable[i].tag); mohawkFile->writeUint16BE(tempTypeTable[i].resource_table_offset); mohawkFile->writeUint16BE(tempTypeTable[i].name_table_offset); } for (uint16 i = 0; i < _typeTable.resource_types; i++) { mohawkFile->writeUint16BE(_types[i].resTable.resources); for (uint16 j = 0; j < _types[i].resTable.resources; j++) { mohawkFile->writeUint16BE(_types[i].resTable.entries[j].id); mohawkFile->writeUint16BE(_types[i].resTable.entries[j].index); } mohawkFile->writeUint16BE(_types[i].nameTable.num); Common::Array tempNameTable; // _types[i].nameTable.entries sorted into alphabetical order by name into tempNameTable sortNameTable(&tempNameTable, i); for (uint16 j = 0; j < _types[i].nameTable.num; j++) { mohawkFile->writeUint16BE(tempNameTable[j].offset); mohawkFile->writeUint16BE(tempNameTable[j].index); } } for (uint16 i = 0; i < _typeTable.resource_types; i++) { for (uint16 j = 0; j < _types[i].nameTable.num; j++) { mohawkFile->write(_types[i].nameTable.entries[j].name.c_str(), _types[i].nameTable.entries[j].name.size()+1); } } // _rsrc.file_table_offset is added to _rsrc.abs_offset to get here... mohawkFile->writeUint32BE(_fileTable.size()); for (uint32 i = 0; i < _fileTable.size(); i++) { mohawkFile->writeUint32BE(_fileTable[i].offset); mohawkFile->writeUint16BE(_fileTable[i].dataSize & 0xFFFF); mohawkFile->writeByte((_fileTable[i].dataSize >> 16) & 0xFF); mohawkFile->writeByte(((_fileTable[i].dataSize >> 24) & 0x07) | (_fileTable[i].flags & 0xF8)); mohawkFile->writeUint16BE(_fileTable[i].unk); } } void printUsage(const char *appName) { printf("Usage: %s [options] [binary resource file #2] ...\n", appName); printf("Options :\n"); } int main(int argc, char *argv[]) { int archiveArg; // Parse parameters for (archiveArg = 1; archiveArg < argc; archiveArg++) { Common::String current = Common::String(argv[archiveArg]); if(!current.hasPrefix("--")) break; // Decode options printf("Unknown argument : \"%s\"\n", argv[archiveArg]); printUsage(argv[0]); return 1; } if (argc == 1 || archiveArg == argc - 1) { printUsage(argv[0]); return 1; } Common::Filename mohawkFilename = Common::Filename(argv[archiveArg]); if (mohawkFilename.exists()) { printf ("File \'%s\' already exists!\n", argv[archiveArg]); return 1; } Common::File *mohawkFile = new Common::File(mohawkFilename, "wb+"); if (!mohawkFile->isOpen()) { printf("Could not open Mohawk Archive \'%s\' for output\n", argv[archiveArg]); mohawkFile->close(); return 1; } Common::Array inputFiles; // Loop over remaining parameters, treating them as resource filenames for (int i = archiveArg + 1; i < argc; i++) { printf("Resource %d : \"%s\"\n", i - archiveArg - 1, argv[i]); ResourceFile file; file.filename = Common::Filename(argv[i]); if (!file.filename.exists()) { printf("Can not open resource file \"%s\"\n", argv[i]); return 1; } if (!file.filename.hasExtension("bin")) { printf("Resource file \"%s\" not in raw binary format\n", argv[i]); return 1; } char resourceFilename[100]; strncpy(resourceFilename, file.filename.getName().c_str(), sizeof(resourceFilename)); // Parse for file index, Resource Type, Resource Id and Name file.index = atoi(Common::String(resourceFilename, 4).c_str()); printf("fileIndex : %d\n", file.index); if (resourceFilename[4] != '_') printf("Filename format mismatch\n"); sscanf(resourceFilename+5, "%02x", &file.flags); printf("fileFlags : 0x%02x\n", file.flags); if (resourceFilename[7] != '_') printf("Filename format mismatch\n"); file.typeTagStr = Common::String(resourceFilename+8, 4); file.typeTag = string2tag(file.typeTagStr.c_str()); printf("resourceTag : \"%s\"\n", file.typeTagStr.c_str()); if (resourceFilename[12] != '_') printf("Filename format mismatch\n"); int nameStart = 13; while (resourceFilename[nameStart] != '\0' && resourceFilename[nameStart] != '_') nameStart++; file.id = atoi(Common::String(resourceFilename+13, nameStart-12).c_str()); printf("resourceId : %d\n", file.id); if (resourceFilename[nameStart] == '_') { file.name = Common::String(resourceFilename+nameStart+1, resourceFilename+strlen(resourceFilename)); for (uint j = 0; j < file.name.size(); j++) { //printf("DEBUG: j: %d resourceName[j]: %c\n", j, resourceName[j]); if (file.name[j] == '\\') { if (j+1 < file.name.size() && file.name[j+1] == '\\') { //printf("\tUnpadded \ at %d\n", j); file.name.deleteChar(j); } else { //printf("\tReplaced \ at %d with %c\n", j, '/'); file.name.setChar('/', j); } } } } printf("resourceName : \"%s\"\n", file.name.c_str()); Common::File resourceIn(file.filename, "rb"); if (!resourceIn.isOpen()) { printf("Could not open file \"%s\"\n", file.filename.getName().c_str()); return 1; } file.size = resourceIn.size(); resourceIn.close(); inputFiles.push_back(file); } initMohawkArchive(); for (uint i = 0; i < inputFiles.size(); i++) { addFileToMohawkArchive(inputFiles[i]); } writeMohawkArchive(inputFiles, mohawkFile); printf("Done!\n"); mohawkFile->close(); delete mohawkFile; return 0; }