scummvm/engines/sword1/resman.cpp
2011-05-12 01:16:22 +02:00

533 lines
16 KiB
C++

/* ScummVM - Graphic Adventure Engine
*
* ScummVM 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include "common/debug.h"
#include "common/textconsole.h"
#include "sword1/memman.h"
#include "sword1/resman.h"
#include "sword1/swordres.h"
#include "gui/message.h"
namespace Sword1 {
void guiFatalError(char *msg) {
// Displays a dialog on-screen before terminating the engine.
// TODO: We really need to setup a special palette for cases when
// the engine is erroring before setting one... otherwise invisible cursor :)
GUI::MessageDialog dialog(msg);
dialog.runModal();
error("%s", msg);
}
#define MAX_PATH_LEN 260
ResMan::ResMan(const char *fileName, bool isMacFile) {
_openCluStart = _openCluEnd = NULL;
_openClus = 0;
_isBigEndian = isMacFile;
_memMan = new MemMan();
loadCluDescript(fileName);
}
ResMan::~ResMan() {
#if 0
for (uint32 clusCnt = 0; clusCnt < _prj.noClu; clusCnt++) {
Clu *cluster = _prj.clu[clusCnt];
if (cluster) {
for (uint32 grpCnt = 0; grpCnt < cluster->noGrp; grpCnt++) {
Grp *group = cluster->grp[grpCnt];
if (group) {
for (uint32 resCnt = 0; resCnt < group->noRes; resCnt++) {
if (group->resHandle[resCnt].cond == MEM_DONT_FREE) {
warning("ResMan::~ResMan: Resource %02X.%04X.%02X is still open",
clusCnt + 1, grpCnt, resCnt);
}
}
}
}
}
}
debug(0, "ResMan closed\n");
#endif
flush();
freeCluDescript();
delete _memMan;
}
void ResMan::loadCluDescript(const char *fileName) {
// The cluster description file is always little endian (even on the mac version, whose cluster files are big endian)
Common::File file;
file.open(fileName);
if (!file.isOpen()) {
char msg[512];
sprintf(msg, "Couldn't open CLU description '%s'\n\nIf you are running from CD, please ensure you have read the ScummVM documentation regarding multi-cd games.", fileName);
guiFatalError(msg);
}
_prj.noClu = file.readUint32LE();
_prj.clu = new Clu[_prj.noClu];
memset(_prj.clu, 0, _prj.noClu * sizeof(Clu));
uint32 *cluIndex = (uint32*)malloc(_prj.noClu * 4);
file.read(cluIndex, _prj.noClu * 4);
for (uint32 clusCnt = 0; clusCnt < _prj.noClu; clusCnt++)
if (cluIndex[clusCnt]) {
Clu *cluster = _prj.clu + clusCnt;
file.read(cluster->label, MAX_LABEL_SIZE);
cluster->file = NULL;
cluster->noGrp = file.readUint32LE();
cluster->grp = new Grp[cluster->noGrp];
cluster->nextOpen = NULL;
memset(cluster->grp, 0, cluster->noGrp * sizeof(Grp));
cluster->refCount = 0;
uint32 *grpIndex = (uint32*)malloc(cluster->noGrp * 4);
file.read(grpIndex, cluster->noGrp * 4);
for (uint32 grpCnt = 0; grpCnt < cluster->noGrp; grpCnt++)
if (grpIndex[grpCnt]) {
Grp *group = cluster->grp + grpCnt;
group->noRes = file.readUint32LE();
group->resHandle = new MemHandle[group->noRes];
group->offset = new uint32[group->noRes];
group->length = new uint32[group->noRes];
uint32 *resIdIdx = (uint32*)malloc(group->noRes * 4);
file.read(resIdIdx, group->noRes * 4);
for (uint32 resCnt = 0; resCnt < group->noRes; resCnt++) {
if (resIdIdx[resCnt]) {
group->offset[resCnt] = file.readUint32LE();
group->length[resCnt] = file.readUint32LE();
_memMan->initHandle(group->resHandle + resCnt);
} else {
group->offset[resCnt] = 0xFFFFFFFF;
group->length[resCnt] = 0;
_memMan->initHandle(group->resHandle + resCnt);
}
}
free(resIdIdx);
}
free(grpIndex);
}
free(cluIndex);
if (_prj.clu[3].grp[5].noRes == 29)
for (uint8 cnt = 0; cnt < 29; cnt++)
_srIdList[cnt] = 0x04050000 | cnt;
}
void ResMan::freeCluDescript() {
for (uint32 clusCnt = 0; clusCnt < _prj.noClu; clusCnt++) {
Clu *cluster = _prj.clu + clusCnt;
for (uint32 grpCnt = 0; grpCnt < cluster->noGrp; grpCnt++) {
Grp *group = cluster->grp + grpCnt;
if (group->resHandle != NULL) {
for (uint32 resCnt = 0; resCnt < group->noRes; resCnt++)
_memMan->freeNow(group->resHandle + resCnt);
delete[] group->resHandle;
delete[] group->offset;
delete[] group->length;
}
}
delete[] cluster->grp;
delete cluster->file;
}
delete[] _prj.clu;
}
void ResMan::flush() {
for (uint32 clusCnt = 0; clusCnt < _prj.noClu; clusCnt++) {
Clu *cluster = _prj.clu + clusCnt;
for (uint32 grpCnt = 0; grpCnt < cluster->noGrp; grpCnt++) {
Grp *group = cluster->grp + grpCnt;
for (uint32 resCnt = 0; resCnt < group->noRes; resCnt++)
if (group->resHandle[resCnt].cond != MEM_FREED) {
_memMan->setCondition(group->resHandle + resCnt, MEM_CAN_FREE);
group->resHandle[resCnt].refCount = 0;
}
}
if (cluster->file) {
cluster->file->close();
delete cluster->file;
cluster->file = NULL;
cluster->refCount = 0;
}
}
_openClus = 0;
_openCluStart = _openCluEnd = NULL;
// the memory manager cached the blocks we asked it to free, so explicitly make it free them
_memMan->flush();
}
void *ResMan::fetchRes(uint32 id) {
MemHandle *memHandle = resHandle(id);
if (!memHandle) {
warning("fetchRes:: resource %d out of bounds", id);
return NULL;
}
if (!memHandle->data)
error("fetchRes:: resource %d is not open", id);
return memHandle->data;
}
void *ResMan::openFetchRes(uint32 id) {
resOpen(id);
return fetchRes(id);
}
void ResMan::dumpRes(uint32 id) {
char outn[30];
sprintf(outn, "DUMP%08X.BIN", id);
Common::DumpFile outf;
if (outf.open(outn)) {
resOpen(id);
MemHandle *memHandle = resHandle(id);
if (memHandle) {
outf.write(memHandle->data, memHandle->size);
outf.close();
}
resClose(id);
}
}
Header *ResMan::lockScript(uint32 scrID) {
if (!_scriptList[scrID / ITM_PER_SEC])
error("Script id %d not found", scrID);
scrID = _scriptList[scrID / ITM_PER_SEC];
#ifdef SCUMM_BIG_ENDIAN
openScriptResourceBigEndian(scrID);
#else
openScriptResourceLittleEndian(scrID);
#endif
return (Header*)resHandle(scrID)->data;
}
void ResMan::unlockScript(uint32 scrID) {
resClose(_scriptList[scrID / ITM_PER_SEC]);
}
void *ResMan::cptResOpen(uint32 id) {
#ifdef SCUMM_BIG_ENDIAN
openCptResourceBigEndian(id);
#else
openCptResourceLittleEndian(id);
#endif
MemHandle *handle = resHandle(id);
return handle != NULL ? handle->data : NULL;
}
void ResMan::resOpen(uint32 id) { // load resource ID into memory
MemHandle *memHandle = resHandle(id);
if (!memHandle)
return;
if (memHandle->cond == MEM_FREED) { // memory has been freed
uint32 size = resLength(id);
_memMan->alloc(memHandle, size);
Common::File *clusFile = resFile(id);
assert(clusFile);
clusFile->seek(resOffset(id));
clusFile->read(memHandle->data, size);
if (clusFile->err() || clusFile->eos()) {
error("Can't read %d bytes from offset %d from cluster file %s\nResource ID: %d (%08X)", size, resOffset(id), _prj.clu[(id >> 24) - 1].label, id, id);
}
} else
_memMan->setCondition(memHandle, MEM_DONT_FREE);
memHandle->refCount++;
if (memHandle->refCount > 20) {
debug(1, "%d references to id %d. Guess there's something wrong.", memHandle->refCount, id);
}
}
void ResMan::resClose(uint32 id) {
MemHandle *handle = resHandle(id);
if (!handle)
return;
if (!handle->refCount) {
warning("Resource Manager fail: unlocking object with refCount 0. Id: %d", id);
} else {
handle->refCount--;
if (!handle->refCount)
_memMan->setCondition( handle, MEM_CAN_FREE);
}
}
FrameHeader *ResMan::fetchFrame(void *resourceData, uint32 frameNo) {
uint8 *frameFile = (uint8*)resourceData;
uint8 *idxData = frameFile + sizeof(Header);
if (_isBigEndian) {
if (frameNo >= READ_BE_UINT32(idxData))
error("fetchFrame:: frame %d doesn't exist in resource.", frameNo);
frameFile += READ_BE_UINT32(idxData + (frameNo+1) * 4);
} else {
if (frameNo >= READ_LE_UINT32(idxData))
error("fetchFrame:: frame %d doesn't exist in resource.", frameNo);
frameFile += READ_LE_UINT32(idxData + (frameNo+1) * 4);
}
return (FrameHeader*)frameFile;
}
Common::File *ResMan::resFile(uint32 id) {
Clu *cluster = _prj.clu + ((id >> 24) - 1);
if (cluster->file == NULL) {
_openClus++;
if (_openCluEnd == NULL) {
_openCluStart = _openCluEnd = cluster;
} else {
_openCluEnd->nextOpen = cluster;
_openCluEnd = cluster;
}
cluster->file = new Common::File();
char fileName[15];
// Supposes that big endian means mac cluster file and little endian means PC cluster file.
// This works, but we may want to separate the file name from the endianess or try .CLM extension if opening.clu file fail.
if (_isBigEndian)
sprintf(fileName, "%s.CLM", _prj.clu[(id >> 24)-1].label);
else
sprintf(fileName, "%s.CLU", _prj.clu[(id >> 24)-1].label);
cluster->file->open(fileName);
if (!cluster->file->isOpen()) {
char msg[512];
sprintf(msg, "Couldn't open game cluster file '%s'\n\nIf you are running from CD, please ensure you have read the ScummVM documentation regarding multi-cd games.", fileName);
guiFatalError(msg);
}
while (_openClus > MAX_OPEN_CLUS) {
assert(_openCluStart);
Clu *closeClu = _openCluStart;
_openCluStart = _openCluStart->nextOpen;
if (closeClu) {
if (closeClu->file)
closeClu->file->close();
delete closeClu->file;
closeClu->file = NULL;
closeClu->nextOpen = NULL;
}
_openClus--;
}
}
return cluster->file;
}
MemHandle *ResMan::resHandle(uint32 id) {
if ((id >> 16) == 0x0405)
id = _srIdList[id & 0xFFFF];
uint8 cluster = (uint8)((id >> 24) - 1);
uint8 group = (uint8)(id >> 16);
// There is a know case of reading beyond array boundaries when trying to use
// portuguese subtitles (cluster file 2, group 6) with a version that do not
// contain subtitles for this languages (i.e. has only 6 languages and not 7).
if (cluster >= _prj.noClu || group >= _prj.clu[cluster].noGrp)
return NULL;
return &(_prj.clu[cluster].grp[group].resHandle[id & 0xFFFF]);
}
uint32 ResMan::resLength(uint32 id) {
if ((id >> 16) == 0x0405)
id = _srIdList[id & 0xFFFF];
uint8 cluster = (uint8)((id >> 24) - 1);
uint8 group = (uint8)(id >> 16);
if (cluster >= _prj.noClu || group >= _prj.clu[cluster].noGrp)
return 0;
return _prj.clu[cluster].grp[group].length[id & 0xFFFF];
}
uint32 ResMan::resOffset(uint32 id) {
if ((id >> 16) == 0x0405)
id = _srIdList[id & 0xFFFF];
uint8 cluster = (uint8)((id >> 24) - 1);
uint8 group = (uint8)(id >> 16);
if (cluster >= _prj.noClu || group >= _prj.clu[cluster].noGrp)
return 0;
return _prj.clu[cluster].grp[group].offset[id & 0xFFFF];
}
void ResMan::openCptResourceBigEndian(uint32 id) {
bool needByteSwap = false;
if (!_isBigEndian) {
// Cluster files are in little endian fomat.
// If the resource are not in memory anymore, and therefore will be read
// from disk, they will need to be byte swaped.
MemHandle *memHandle = resHandle(id);
if (memHandle)
needByteSwap = (memHandle->cond == MEM_FREED);
}
resOpen(id);
if (needByteSwap) {
MemHandle *handle = resHandle(id);
if (!handle)
return;
uint32 totSize = handle->size;
uint32 *data = (uint32*)((uint8*)handle->data + sizeof(Header));
totSize -= sizeof(Header);
if (totSize & 3)
error("Illegal compact size for id %d: %d", id, totSize);
totSize /= 4;
for (uint32 cnt = 0; cnt < totSize; cnt++) {
*data = READ_LE_UINT32(data);
data++;
}
}
}
void ResMan::openCptResourceLittleEndian(uint32 id) {
bool needByteSwap = false;
if (_isBigEndian) {
// Cluster files are in big endian fomat.
// If the resource are not in memory anymore, and therefore will be read
// from disk, they will need to be byte swaped.
MemHandle *memHandle = resHandle(id);
if (memHandle)
needByteSwap = (memHandle->cond == MEM_FREED);
}
resOpen(id);
if (needByteSwap) {
MemHandle *handle = resHandle(id);
if (!handle)
return;
uint32 totSize = handle->size;
uint32 *data = (uint32*)((uint8*)handle->data + sizeof(Header));
totSize -= sizeof(Header);
if (totSize & 3)
error("Illegal compact size for id %d: %d", id, totSize);
totSize /= 4;
for (uint32 cnt = 0; cnt < totSize; cnt++) {
*data = READ_BE_UINT32(data);
data++;
}
}
}
void ResMan::openScriptResourceBigEndian(uint32 id) {
bool needByteSwap = false;
if (!_isBigEndian) {
// Cluster files are in little endian fomat.
// If the resource are not in memory anymore, and therefore will be read
// from disk, they will need to be byte swaped.
MemHandle *memHandle = resHandle(id);
if (memHandle)
needByteSwap = (memHandle->cond == MEM_FREED);
}
resOpen(id);
if (needByteSwap) {
MemHandle *handle = resHandle(id);
if (!handle)
return;
// uint32 totSize = handle->size;
Header *head = (Header*)handle->data;
head->comp_length = FROM_LE_32(head->comp_length);
head->decomp_length = FROM_LE_32(head->decomp_length);
head->version = FROM_LE_16(head->version);
uint32 *data = (uint32*)((uint8*)handle->data + sizeof(Header));
uint32 size = handle->size - sizeof(Header);
if (size & 3)
error("Odd size during script endian conversion. Resource ID =%d, size = %d", id, size);
size >>= 2;
for (uint32 cnt = 0; cnt < size; cnt++) {
*data = READ_LE_UINT32(data);
data++;
}
}
}
void ResMan::openScriptResourceLittleEndian(uint32 id) {
bool needByteSwap = false;
if (_isBigEndian) {
// Cluster files are in big endian fomat.
// If the resource are not in memory anymore, and therefore will be read
// from disk, they will need to be byte swaped.
MemHandle *memHandle = resHandle(id);
if (memHandle)
needByteSwap = (memHandle->cond == MEM_FREED);
}
resOpen(id);
if (needByteSwap) {
MemHandle *handle = resHandle(id);
if (!handle)
return;
// uint32 totSize = handle->size;
Header *head = (Header*)handle->data;
head->comp_length = FROM_BE_32(head->comp_length);
head->decomp_length = FROM_BE_32(head->decomp_length);
head->version = FROM_BE_16(head->version);
uint32 *data = (uint32*)((uint8*)handle->data + sizeof(Header));
uint32 size = handle->size - sizeof(Header);
if (size & 3)
error("Odd size during script endian conversion. Resource ID =%d, size = %d", id, size);
size >>= 2;
for (uint32 cnt = 0; cnt < size; cnt++) {
*data = READ_BE_UINT32(data);
data++;
}
}
}
uint32 ResMan::_srIdList[29] = { // the file numbers differ for the control panel file IDs, so we need this array
OTHER_SR_FONT, // SR_FONT
0x04050000, // SR_BUTTON
OTHER_SR_REDFONT, // SR_REDFONT
0x04050001, // SR_PALETTE
0x04050002, // SR_PANEL_ENGLISH
0x04050003, // SR_PANEL_FRENCH
0x04050004, // SR_PANEL_GERMAN
0x04050005, // SR_PANEL_ITALIAN
0x04050006, // SR_PANEL_SPANISH
0x04050007, // SR_PANEL_AMERICAN
0x04050008, // SR_TEXT_BUTTON
0x04050009, // SR_SPEED
0x0405000A, // SR_SCROLL1
0x0405000B, // SR_SCROLL2
0x0405000C, // SR_CONFIRM
0x0405000D, // SR_VOLUME
0x0405000E, // SR_VLIGHT
0x0405000F, // SR_VKNOB
0x04050010, // SR_WINDOW
0x04050011, // SR_SLAB1
0x04050012, // SR_SLAB2
0x04050013, // SR_SLAB3
0x04050014, // SR_SLAB4
0x04050015, // SR_BUTUF
0x04050016, // SR_BUTUS
0x04050017, // SR_BUTDS
0x04050018, // SR_BUTDF
0x04050019, // SR_DEATHPANEL
0,
};
} // End of namespace Sword1