GOB: Clean up class DataIO
Removing the need for class DataStream and that handle mess. svn-id: r53984
This commit is contained in:
Sven Hesse
parent
88892dc982
commit
16a3cc8a84
20 changed files with 446 additions and 774 deletions
|
|
@ -24,7 +24,8 @@
|
|||
*/
|
||||
|
||||
#include "common/endian.h"
|
||||
#include "common/str.h"
|
||||
#include "common/types.h"
|
||||
#include "common/stream.h"
|
||||
|
||||
#include "gob/gob.h"
|
||||
#include "gob/dataio.h"
|
||||
|
|
@ -33,198 +34,91 @@
|
|||
|
||||
namespace Gob {
|
||||
|
||||
DataStream::DataStream(DataIO &io, int16 handle, uint32 dSize, bool dispose) {
|
||||
_io = &io;
|
||||
|
||||
_handle = handle;
|
||||
_size = dSize;
|
||||
_dispose = dispose;
|
||||
|
||||
_data = 0;
|
||||
_stream = 0;
|
||||
DataIO::File::File() : size(0), offset(0), packed(false), archive(0) {
|
||||
}
|
||||
|
||||
DataStream::DataStream(byte *buf, uint32 dSize, bool dispose) {
|
||||
_data = buf;
|
||||
_size = dSize;
|
||||
_stream = new Common::MemoryReadStream(_data, _size);
|
||||
_dispose = dispose;
|
||||
|
||||
_io = 0;
|
||||
_handle = -1;
|
||||
DataIO::File::File(const Common::String &n, uint32 s, uint32 o, bool p, Archive &a) :
|
||||
name(n), size(s), offset(o), packed(p), archive(&a) {
|
||||
}
|
||||
|
||||
DataStream::~DataStream() {
|
||||
delete _stream;
|
||||
|
||||
if (_dispose) {
|
||||
delete[] _data;
|
||||
if ((_handle >= 0) && _io)
|
||||
_io->closeData(_handle);
|
||||
}
|
||||
}
|
||||
|
||||
int32 DataStream::pos() const {
|
||||
if (_stream)
|
||||
return _stream->pos();
|
||||
|
||||
int32 resPos = _io->getChunkPos(_handle);
|
||||
if (resPos != -1)
|
||||
return resPos;
|
||||
|
||||
return _io->file_getHandle(_handle)->pos();
|
||||
}
|
||||
|
||||
int32 DataStream::size() const {
|
||||
if (_stream)
|
||||
return _stream->size();
|
||||
|
||||
return _size;
|
||||
}
|
||||
|
||||
bool DataStream::seek(int32 offset, int whence) {
|
||||
if (_stream)
|
||||
return _stream->seek(offset, whence);
|
||||
else if (!_io->isDataFileChunk(_handle))
|
||||
return _io->file_getHandle(_handle)->seek(offset, whence);
|
||||
else {
|
||||
_io->seekChunk(_handle, offset, whence);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool DataStream::eos() const {
|
||||
if (_stream)
|
||||
return _stream->eos();
|
||||
|
||||
return pos() >= size(); // FIXME (eos definition change)
|
||||
}
|
||||
|
||||
uint32 DataStream::read(void *dataPtr, uint32 dataSize) {
|
||||
if (_stream)
|
||||
return _stream->read(dataPtr, dataSize);
|
||||
|
||||
if (!_io->isDataFileChunk(_handle))
|
||||
return _io->file_getHandle(_handle)->read((byte *)dataPtr, dataSize);
|
||||
|
||||
byte *data = (byte *)dataPtr;
|
||||
uint32 haveRead = 0;
|
||||
while (dataSize > 0x3FFF) {
|
||||
_io->readChunk(_handle, (byte *)data, 0x3FFF);
|
||||
dataSize -= 0x3FFF;
|
||||
data += 0x3FFF;
|
||||
haveRead += 0x3FFF;
|
||||
}
|
||||
_io->readChunk(_handle, (byte *)data, dataSize);
|
||||
|
||||
return haveRead + dataSize;
|
||||
}
|
||||
|
||||
DataIO::DataIO(GobEngine *vm) : _vm(vm) {
|
||||
for (int i = 0; i < MAX_DATA_FILES; i++) {
|
||||
_dataFiles[i] = 0;
|
||||
_numDataChunks[i] = 0;
|
||||
_dataFileHandles[i] = -1;
|
||||
}
|
||||
DataIO::DataIO() {
|
||||
// Reserve memory for the standard max amount of archives
|
||||
_archives.reserve(kMaxArchives);
|
||||
for (int i = 0; i < kMaxArchives; i++)
|
||||
_archives.push_back(0);
|
||||
}
|
||||
|
||||
DataIO::~DataIO() {
|
||||
for (int i = 0; i < MAX_DATA_FILES; i++) {
|
||||
if (_dataFiles[i])
|
||||
file_getHandle(_dataFileHandles[i])->close();
|
||||
delete[] _dataFiles[i];
|
||||
// Close all archives
|
||||
for (Common::Array<Archive *>::iterator it = _archives.begin(); it != _archives.end(); ++it) {
|
||||
if (!*it)
|
||||
continue;
|
||||
|
||||
closeArchive(**it);
|
||||
delete *it;
|
||||
}
|
||||
}
|
||||
|
||||
bool DataIO::isDataFileChunk(int16 handle) const {
|
||||
return (handle >= 50) && (handle < 128);
|
||||
byte *DataIO::unpack(const byte *src, uint32 srcSize, int32 &size) {
|
||||
size = READ_LE_UINT32(src);
|
||||
|
||||
byte *data = new byte[size];
|
||||
|
||||
Common::MemoryReadStream srcStream(src + 4, srcSize - 4);
|
||||
unpack(srcStream, data, size);
|
||||
return data;
|
||||
}
|
||||
|
||||
bool DataIO::isPacked(int16 handle) const {
|
||||
if (!isDataFileChunk(handle))
|
||||
return false;
|
||||
Common::SeekableReadStream *DataIO::unpack(Common::SeekableReadStream &src) {
|
||||
uint32 size = src.readUint32LE();
|
||||
|
||||
return _chunk[getIndex(handle)]->packed != 0;
|
||||
byte *data = (byte *) malloc(size);
|
||||
|
||||
unpack(src, data, size);
|
||||
return new Common::MemoryReadStream(data, size, DisposeAfterUse::YES);
|
||||
}
|
||||
|
||||
int DataIO::getFile(int16 handle) const {
|
||||
if (!isDataFileChunk(handle))
|
||||
return -1;
|
||||
|
||||
return (handle - 50) / 10;
|
||||
}
|
||||
|
||||
int DataIO::getSlot(int16 handle) const {
|
||||
if (!isDataFileChunk(handle))
|
||||
return -1;
|
||||
|
||||
return (handle - 50) % 10;
|
||||
}
|
||||
|
||||
int DataIO::getIndex(int16 handle) const {
|
||||
if (!isDataFileChunk(handle))
|
||||
return -1;
|
||||
|
||||
return getIndex(getFile(handle), getSlot(handle));
|
||||
}
|
||||
|
||||
int DataIO::getIndex(int file, int slot) const {
|
||||
return file * MAX_SLOT_COUNT + slot;
|
||||
}
|
||||
|
||||
int16 DataIO::getHandle(int file, int slot) const {
|
||||
return file * 10 + slot + 50;
|
||||
}
|
||||
|
||||
int32 DataIO::unpackData(byte *src, byte *dest) {
|
||||
uint32 realSize;
|
||||
uint32 counter;
|
||||
uint16 cmd;
|
||||
byte *tmpBuf;
|
||||
int16 off;
|
||||
byte len;
|
||||
uint16 tmpIndex;
|
||||
|
||||
tmpBuf = new byte[4114];
|
||||
void DataIO::unpack(Common::SeekableReadStream &src, byte *dest, uint32 size) {
|
||||
byte *tmpBuf = new byte[4114];
|
||||
assert(tmpBuf);
|
||||
|
||||
counter = realSize = READ_LE_UINT32(src);
|
||||
uint32 counter = size;
|
||||
|
||||
for (int i = 0; i < 4078; i++)
|
||||
tmpBuf[i] = 0x20;
|
||||
tmpIndex = 4078;
|
||||
uint16 tmpIndex = 4078;
|
||||
|
||||
src += 4;
|
||||
|
||||
cmd = 0;
|
||||
uint16 cmd = 0;
|
||||
while (1) {
|
||||
cmd >>= 1;
|
||||
if ((cmd & 0x0100) == 0) {
|
||||
cmd = *src | 0xFF00;
|
||||
src++;
|
||||
}
|
||||
if ((cmd & 0x0100) == 0)
|
||||
cmd = src.readByte() | 0xFF00;
|
||||
|
||||
if ((cmd & 1) != 0) { /* copy */
|
||||
*dest++ = *src;
|
||||
tmpBuf[tmpIndex] = *src;
|
||||
src++;
|
||||
byte tmp = src.readByte();
|
||||
|
||||
*dest++ = tmp;
|
||||
tmpBuf[tmpIndex] = tmp;
|
||||
|
||||
tmpIndex++;
|
||||
tmpIndex %= 4096;
|
||||
counter--;
|
||||
if (counter == 0)
|
||||
break;
|
||||
} else { /* copy string */
|
||||
byte tmp1 = src.readByte();
|
||||
byte tmp2 = src.readByte();
|
||||
|
||||
off = *src++;
|
||||
off |= (*src & 0xF0) << 4;
|
||||
len = (*src & 0x0F) + 3;
|
||||
src++;
|
||||
int16 off = tmp1 | ((tmp2 & 0xF0) << 4);
|
||||
byte len = (tmp2 & 0x0F) + 3;
|
||||
|
||||
for (int i = 0; i < len; i++) {
|
||||
*dest++ = tmpBuf[(off + i) % 4096];
|
||||
counter--;
|
||||
if (counter == 0) {
|
||||
delete[] tmpBuf;
|
||||
return realSize;
|
||||
return;
|
||||
}
|
||||
tmpBuf[tmpIndex] = tmpBuf[(off + i) % 4096];
|
||||
tmpIndex++;
|
||||
|
|
@ -233,390 +127,251 @@ int32 DataIO::unpackData(byte *src, byte *dest) {
|
|||
|
||||
}
|
||||
}
|
||||
|
||||
delete[] tmpBuf;
|
||||
return realSize;
|
||||
}
|
||||
|
||||
Common::File *DataIO::file_getHandle(int16 handle) {
|
||||
return &_filesHandles[handle];
|
||||
}
|
||||
|
||||
const Common::File *DataIO::file_getHandle(int16 handle) const {
|
||||
return &_filesHandles[handle];
|
||||
}
|
||||
|
||||
int16 DataIO::file_open(const char *path) {
|
||||
int16 i;
|
||||
|
||||
for (i = 0; i < MAX_FILES; i++) {
|
||||
if (!file_getHandle(i)->isOpen())
|
||||
bool DataIO::openArchive(Common::String name, bool base) {
|
||||
// Look for a free archive slot
|
||||
Archive **archive = 0;
|
||||
int i = 0;
|
||||
for (Common::Array<Archive *>::iterator it = _archives.begin(); it != _archives.end(); ++it, i++) {
|
||||
if (!*it) {
|
||||
archive = &*it;
|
||||
break;
|
||||
}
|
||||
if (i == MAX_FILES)
|
||||
return -1;
|
||||
|
||||
if (file_getHandle(i)->open(path))
|
||||
return i;
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int16 DataIO::getChunk(const char *chunkName) {
|
||||
for (int16 file = 0; file < MAX_DATA_FILES; file++) {
|
||||
if (_dataFiles[file] == 0)
|
||||
return -1;
|
||||
|
||||
int16 slot;
|
||||
for (slot = 0; slot < MAX_SLOT_COUNT; slot++)
|
||||
if (_chunkPos[file * MAX_SLOT_COUNT + slot] == -1)
|
||||
break;
|
||||
|
||||
if (slot == MAX_SLOT_COUNT) {
|
||||
warning("Chunk slots full");
|
||||
return -1;
|
||||
}
|
||||
|
||||
ChunkDesc *dataDesc = _dataFiles[file];
|
||||
for (uint16 chunk = 0; chunk < _numDataChunks[file]; chunk++, dataDesc++) {
|
||||
if (scumm_stricmp(chunkName, dataDesc->chunkName) != 0)
|
||||
continue;
|
||||
|
||||
int index = getIndex(file, slot);
|
||||
|
||||
_isCurrentSlot[index] = false;
|
||||
_chunk [index] = dataDesc;
|
||||
_chunkPos [index] = 0;
|
||||
|
||||
return getHandle(file, slot);
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
char DataIO::freeChunk(int16 handle) {
|
||||
if (isDataFileChunk(handle)) {
|
||||
_chunkPos[getIndex(handle)] = -1;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int32 DataIO::readChunk(int16 handle, byte *buf, uint16 size) {
|
||||
if (!isDataFileChunk(handle))
|
||||
return -2;
|
||||
|
||||
int file = getFile(handle);
|
||||
int slot = getSlot(handle);
|
||||
int index = getIndex(file, slot);
|
||||
|
||||
_chunkPos[index] = CLIP<int32>(_chunkPos[index], 0, _chunk[index]->size);
|
||||
|
||||
if (!_isCurrentSlot[index]) {
|
||||
for (int16 i = 0; i < MAX_SLOT_COUNT; i++)
|
||||
_isCurrentSlot[file * MAX_SLOT_COUNT + i] = false;
|
||||
|
||||
int32 offset = _chunk[index]->offset + _chunkPos[index];
|
||||
|
||||
debugC(7, kDebugFileIO, "seek: %d, %d", _chunk[index]->offset, _chunkPos[index]);
|
||||
|
||||
file_getHandle(_dataFileHandles[file])->seek(offset, SEEK_SET);
|
||||
}
|
||||
|
||||
_isCurrentSlot[index] = true;
|
||||
if ((_chunkPos[index] + size) > (int32) (_chunk[index]->size))
|
||||
size = _chunk[index]->size - _chunkPos[index];
|
||||
|
||||
file_getHandle(_dataFileHandles[file])->read(buf, size);
|
||||
_chunkPos[index] += size;
|
||||
return size;
|
||||
}
|
||||
|
||||
int16 DataIO::seekChunk(int16 handle, int32 pos, int16 from) {
|
||||
if (!isDataFileChunk(handle))
|
||||
return -1;
|
||||
|
||||
int file = getFile(handle);
|
||||
int slot = getSlot(handle);
|
||||
int index = getIndex(file, slot);
|
||||
|
||||
_isCurrentSlot[index] = false;
|
||||
if (from == SEEK_SET)
|
||||
_chunkPos[index] = pos;
|
||||
else if (from == SEEK_CUR)
|
||||
_chunkPos[index] += pos;
|
||||
else if (from == SEEK_END)
|
||||
_chunkPos[index] = _chunk[index]->size - pos;
|
||||
|
||||
return _chunkPos[index];
|
||||
}
|
||||
|
||||
uint32 DataIO::getChunkPos(int16 handle) const {
|
||||
if (!isDataFileChunk(handle))
|
||||
return 0xFFFFFFFF;
|
||||
|
||||
int file = getFile(handle);
|
||||
int slot = getSlot(handle);
|
||||
|
||||
return _chunkPos[file * MAX_SLOT_COUNT + slot];
|
||||
}
|
||||
|
||||
int32 DataIO::getChunkSize(const char *chunkName, int32 &packSize) {
|
||||
packSize = -1;
|
||||
|
||||
for (int file = 0; file < MAX_DATA_FILES; file++) {
|
||||
if (_dataFiles[file] == 0)
|
||||
return -1;
|
||||
|
||||
ChunkDesc *dataDesc = _dataFiles[file];
|
||||
for (uint16 chunk = 0; chunk < _numDataChunks[file]; chunk++, dataDesc++) {
|
||||
if (scumm_stricmp(chunkName, dataDesc->chunkName) != 0)
|
||||
continue;
|
||||
|
||||
if (dataDesc->packed == 0)
|
||||
return dataDesc->size;
|
||||
|
||||
for (int16 slot = 0; slot < MAX_SLOT_COUNT; slot++)
|
||||
_isCurrentSlot[slot] = false;
|
||||
|
||||
int32 realSize;
|
||||
|
||||
file_getHandle(_dataFileHandles[file])->seek(dataDesc->offset, SEEK_SET);
|
||||
realSize = file_getHandle(_dataFileHandles[file])->readUint32LE();
|
||||
packSize = dataDesc->size;
|
||||
|
||||
return realSize;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
void DataIO::openDataFile(const char *src, bool itk) {
|
||||
char path[128];
|
||||
|
||||
Common::strlcpy(path, src, 128);
|
||||
if (!strchr(path, '.')) {
|
||||
path[123] = 0;
|
||||
strcat(path, ".stk");
|
||||
}
|
||||
|
||||
int16 file;
|
||||
for (file = 0; file < MAX_DATA_FILES; file++)
|
||||
if (_dataFiles[file] == 0)
|
||||
break;
|
||||
|
||||
if (file == MAX_DATA_FILES)
|
||||
error("DataIO::openDataFile(): Data file slots are full");
|
||||
|
||||
_dataFileHandles[file] = file_open(path);
|
||||
|
||||
if (_dataFileHandles[file] == -1)
|
||||
error("DataIO::openDataFile(): Can't open data file \"%s\"", path);
|
||||
|
||||
_dataFileItk [file] = itk;
|
||||
_numDataChunks[file] = file_getHandle(_dataFileHandles[file])->readUint16LE();
|
||||
|
||||
debugC(7, kDebugFileIO, "DataChunks: %d [for %s]", _numDataChunks[file], path);
|
||||
|
||||
ChunkDesc *dataDesc = new ChunkDesc[_numDataChunks[file]];
|
||||
_dataFiles[file] = dataDesc;
|
||||
|
||||
for (int i = 0; i < _numDataChunks[file]; i++) {
|
||||
file_getHandle(_dataFileHandles[file])->read(dataDesc[i].chunkName, 13);
|
||||
dataDesc[i].size = file_getHandle(_dataFileHandles[file])->readUint32LE();
|
||||
dataDesc[i].offset = file_getHandle(_dataFileHandles[file])->readUint32LE();
|
||||
dataDesc[i].packed = file_getHandle(_dataFileHandles[file])->readByte();
|
||||
|
||||
// Replacing cyrillic characters
|
||||
Util::replaceChar(dataDesc[i].chunkName, (char) 0x85, 'E');
|
||||
Util::replaceChar(dataDesc[i].chunkName, (char) 0x8A, 'K');
|
||||
Util::replaceChar(dataDesc[i].chunkName, (char) 0x8E, 'O');
|
||||
Util::replaceChar(dataDesc[i].chunkName, (char) 0x91, 'C');
|
||||
Util::replaceChar(dataDesc[i].chunkName, (char) 0x92, 'T');
|
||||
|
||||
// Geisha use 0ot files, which are compressed TOT files without the packed byte set.
|
||||
char *fakeTotPtr = strstr(dataDesc[i].chunkName, "0OT");
|
||||
if (fakeTotPtr != 0) {
|
||||
strncpy(fakeTotPtr, "TOT", 3);
|
||||
dataDesc[i].packed = 1;
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < _numDataChunks[file]; i++)
|
||||
debugC(7, kDebugFileIO, "%d: %s %d", i, dataDesc[i].chunkName, dataDesc[i].size);
|
||||
if (!archive) {
|
||||
// No free slot, create a new one
|
||||
|
||||
for (int i = 0; i < MAX_SLOT_COUNT; i++)
|
||||
_chunkPos[file * MAX_SLOT_COUNT + i] = -1;
|
||||
}
|
||||
warning("DataIO::openArchive(): Need to increase archive count to %d", _archives.size() + 1);
|
||||
_archives.push_back(0);
|
||||
|
||||
void DataIO::closeDataFile(bool itk) {
|
||||
for (int file = MAX_DATA_FILES - 1; file >= 0; file--) {
|
||||
if (_dataFiles[file] && (_dataFileItk[file] == itk)) {
|
||||
delete[] _dataFiles[file];
|
||||
_dataFiles[file] = 0;
|
||||
file_getHandle(_dataFileHandles[file])->close();
|
||||
return;
|
||||
}
|
||||
Common::Array<Archive *>::iterator it = _archives.end();
|
||||
archive = &*(--it);
|
||||
}
|
||||
}
|
||||
|
||||
byte *DataIO::getUnpackedData(const char *name) {
|
||||
int32 realSize;
|
||||
int32 packSize = -1;
|
||||
// Add extension if necessary
|
||||
if (!name.contains('.'))
|
||||
name += ".stk";
|
||||
|
||||
realSize = getChunkSize(name, packSize);
|
||||
|
||||
if ((packSize == -1) || (realSize == -1))
|
||||
return 0;
|
||||
|
||||
int16 chunk = getChunk(name);
|
||||
if (chunk == -1)
|
||||
return 0;
|
||||
|
||||
byte *unpackBuf = new byte[realSize];
|
||||
assert(unpackBuf);
|
||||
|
||||
byte *packBuf = new byte[packSize];
|
||||
assert(packBuf);
|
||||
|
||||
int32 sizeLeft = packSize;
|
||||
byte *ptr = packBuf;
|
||||
while (sizeLeft > 0x4000) {
|
||||
readChunk(chunk, ptr, 0x4000);
|
||||
sizeLeft -= 0x4000;
|
||||
ptr += 0x4000;
|
||||
}
|
||||
readChunk(chunk, ptr, sizeLeft);
|
||||
freeChunk(chunk);
|
||||
unpackData(packBuf, unpackBuf);
|
||||
|
||||
delete[] packBuf;
|
||||
return unpackBuf;
|
||||
}
|
||||
|
||||
void DataIO::closeData(int16 handle) {
|
||||
if (freeChunk(handle) != 0)
|
||||
file_getHandle(handle)->close();
|
||||
}
|
||||
|
||||
int16 DataIO::openData(const char *path) {
|
||||
int16 handle = getChunk(path);
|
||||
if (handle >= 0)
|
||||
return handle;
|
||||
|
||||
return file_open(path);
|
||||
}
|
||||
|
||||
bool DataIO::existData(const char *path) {
|
||||
if (!path || (path[0] == '\0'))
|
||||
// Try to open
|
||||
*archive = openArchive(name);
|
||||
if (!*archive)
|
||||
return false;
|
||||
|
||||
int16 handle = openData(path);
|
||||
if (handle < 0)
|
||||
return false;
|
||||
|
||||
closeData(handle);
|
||||
(*archive)->base = base;
|
||||
return true;
|
||||
}
|
||||
|
||||
DataStream *DataIO::openAsStream(int16 handle, bool dispose) {
|
||||
uint32 curPos = getPos(handle);
|
||||
seekData(handle, 0, SEEK_END);
|
||||
uint32 size = getPos(handle);
|
||||
seekData(handle, curPos, SEEK_SET);
|
||||
|
||||
return new DataStream(*this, handle, size, dispose);
|
||||
}
|
||||
|
||||
uint32 DataIO::getPos(int16 handle) {
|
||||
uint32 resPos = getChunkPos(handle);
|
||||
if (resPos != 0xFFFFFFFF)
|
||||
return resPos;
|
||||
|
||||
return file_getHandle(handle)->pos();
|
||||
}
|
||||
|
||||
void DataIO::seekData(int16 handle, int32 pos, int16 from) {
|
||||
int32 resPos = seekChunk(handle, pos, from);
|
||||
if (resPos != -1)
|
||||
return;
|
||||
|
||||
file_getHandle(handle)->seek(pos, from);
|
||||
}
|
||||
|
||||
int32 DataIO::readData(int16 handle, byte *buf, uint16 size) {
|
||||
int16 res = readChunk(handle, buf, size);
|
||||
if (res >= 0)
|
||||
return res;
|
||||
|
||||
return file_getHandle(handle)->read(buf, size);
|
||||
}
|
||||
|
||||
int32 DataIO::getDataSize(const char *name) {
|
||||
char buf[128];
|
||||
int32 chunkSize;
|
||||
int32 packSize = -1;
|
||||
|
||||
Common::strlcpy(buf, name, 128);
|
||||
|
||||
chunkSize = getChunkSize(buf, packSize);
|
||||
if (chunkSize >= 0)
|
||||
return chunkSize;
|
||||
|
||||
Common::File file;
|
||||
if (!file.open(buf))
|
||||
error("DataIO::getDataSize(): Can't find data \"%s\"", name);
|
||||
|
||||
chunkSize = file.size();
|
||||
file.close();
|
||||
|
||||
return chunkSize;
|
||||
}
|
||||
|
||||
byte *DataIO::getData(const char *path) {
|
||||
byte *data = getUnpackedData(path);
|
||||
if (data)
|
||||
return data;
|
||||
|
||||
int32 size = getDataSize(path);
|
||||
|
||||
data = new byte[size];
|
||||
assert(data);
|
||||
|
||||
int16 handle = openData(path);
|
||||
|
||||
byte *ptr = data;
|
||||
while (size > 0x4000) {
|
||||
readData(handle, ptr, 0x4000);
|
||||
size -= 0x4000;
|
||||
ptr += 0x4000;
|
||||
DataIO::Archive *DataIO::openArchive(const Common::String &name) {
|
||||
Archive *archive = new Archive;
|
||||
if (!archive->file.open(name)) {
|
||||
delete archive;
|
||||
return 0;
|
||||
}
|
||||
readData(handle, ptr, size);
|
||||
closeData(handle);
|
||||
return data;
|
||||
|
||||
archive->name = name;
|
||||
|
||||
uint16 fileCount = archive->file.readUint16LE();
|
||||
for (uint16 i = 0; i < fileCount; i++) {
|
||||
File file;
|
||||
|
||||
char fileName[14];
|
||||
|
||||
archive->file.read(fileName, 13);
|
||||
fileName[13] = '\0';
|
||||
|
||||
file.size = archive->file.readUint32LE();
|
||||
file.offset = archive->file.readUint32LE();
|
||||
file.packed = archive->file.readByte() != 0;
|
||||
|
||||
// Replacing cyrillic characters
|
||||
Util::replaceChar(fileName, (char) 0x85, 'E');
|
||||
Util::replaceChar(fileName, (char) 0x8A, 'K');
|
||||
Util::replaceChar(fileName, (char) 0x8E, 'O');
|
||||
Util::replaceChar(fileName, (char) 0x91, 'C');
|
||||
Util::replaceChar(fileName, (char) 0x92, 'T');
|
||||
|
||||
file.name = fileName;
|
||||
|
||||
// Geisha use 0ot files, which are compressed TOT files without the packed byte set.
|
||||
if (file.name.hasSuffix(".0OT")) {
|
||||
file.name.setChar(file.name.size() - 3, 'T');
|
||||
file.packed = true;
|
||||
}
|
||||
|
||||
file.archive = archive;
|
||||
archive->files.setVal(file.name, file);
|
||||
}
|
||||
|
||||
return archive;
|
||||
}
|
||||
|
||||
DataStream *DataIO::getDataStream(const char *path) {
|
||||
if (!existData(path))
|
||||
return 0;
|
||||
bool DataIO::closeArchive(bool base) {
|
||||
// Look for a matching archive and close it
|
||||
for (int archive = _archives.size() - 1; archive >= 0; archive--) {
|
||||
if (_archives[archive] && (_archives[archive]->base == base)) {
|
||||
closeArchive(*_archives[archive]);
|
||||
delete _archives[archive];
|
||||
_archives[archive] = 0;
|
||||
|
||||
int16 handle = openData(path);
|
||||
if (handle < 0)
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool DataIO::closeArchive(Archive &archive) {
|
||||
archive.file.close();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool DataIO::hasFile(const Common::String &name){
|
||||
// Look up the files in the opened archives
|
||||
if (findFile(name))
|
||||
return true;
|
||||
|
||||
// Else, look if a plain file that matches exists
|
||||
return Common::File::exists(name);
|
||||
}
|
||||
|
||||
int32 DataIO::fileSize(const Common::String &name) {
|
||||
// Try to find the file in the archives
|
||||
File *file = findFile(name);
|
||||
if (file) {
|
||||
if (!file->packed)
|
||||
return file->size;
|
||||
|
||||
// Sanity checks
|
||||
assert(file->size >= 4);
|
||||
assert(file->archive);
|
||||
assert(file->archive->file.isOpen());
|
||||
|
||||
// Read the full, unpacked size
|
||||
file->archive->file.seek(file->offset);
|
||||
return file->archive->file.readUint32LE();
|
||||
}
|
||||
|
||||
// Else, try to find a matching plain file
|
||||
Common::File f;
|
||||
if (!f.open(name))
|
||||
return -1;
|
||||
|
||||
return f.size();
|
||||
}
|
||||
|
||||
Common::SeekableReadStream *DataIO::getFile(const Common::String &name) {
|
||||
// Try to open the file in the archives
|
||||
File *file = findFile(name);
|
||||
if (file) {
|
||||
Common::SeekableReadStream *data = getFile(*file);
|
||||
if (data)
|
||||
return data;
|
||||
}
|
||||
|
||||
// Else, try to open a matching plain file
|
||||
Common::File f;
|
||||
if (!f.open(name))
|
||||
return 0;
|
||||
|
||||
if (isDataFileChunk(handle) && isPacked(handle)) {
|
||||
// It's a packed chunk in the data files, packed,
|
||||
// so we have to read it in completely and unpack it
|
||||
return f.readStream(f.size());
|
||||
}
|
||||
|
||||
closeData(handle);
|
||||
byte *DataIO::getFile(const Common::String &name, int32 &size) {
|
||||
// Try to open the file in the archives
|
||||
File *file = findFile(name);
|
||||
if (file) {
|
||||
byte *data = getFile(*file, size);
|
||||
if (data)
|
||||
return data;
|
||||
}
|
||||
|
||||
uint32 size = getDataSize(path);
|
||||
byte *data = getData(path);
|
||||
// Else, try to open a matching plain file
|
||||
Common::File f;
|
||||
if (!f.open(name))
|
||||
return 0;
|
||||
|
||||
return new DataStream(data, size);
|
||||
size = f.size();
|
||||
|
||||
} else
|
||||
// Otherwise, we can just return a stream
|
||||
return openAsStream(handle, true);
|
||||
byte *data = new byte[size];
|
||||
if (f.read(data, size) != ((uint32) size)) {
|
||||
delete[] data;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
DataIO::File *DataIO::findFile(const Common::String &name) {
|
||||
for (int i = _archives.size() - 1; i >= 0; i--) {
|
||||
Archive *archive = _archives[i];
|
||||
if (!archive)
|
||||
// Empty slot
|
||||
continue;
|
||||
|
||||
// Look up the file in the file map
|
||||
FileMap::iterator file = archive->files.find(name);
|
||||
if (file != archive->files.end())
|
||||
return &file->_value;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Common::SeekableReadStream *DataIO::getFile(File &file) {
|
||||
if (!file.archive)
|
||||
return 0;
|
||||
|
||||
if (!file.archive->file.isOpen())
|
||||
return 0;
|
||||
|
||||
if (!file.archive->file.seek(file.offset))
|
||||
return 0;
|
||||
|
||||
Common::SeekableReadStream *rawData = file.archive->file.readStream(file.size);
|
||||
if (!rawData)
|
||||
return 0;
|
||||
|
||||
if (!file.packed)
|
||||
return rawData;
|
||||
|
||||
Common::SeekableReadStream *unpackedData = unpack(*rawData);
|
||||
|
||||
delete rawData;
|
||||
|
||||
return unpackedData;
|
||||
}
|
||||
|
||||
byte *DataIO::getFile(File &file, int32 &size) {
|
||||
if (!file.archive)
|
||||
return 0;
|
||||
|
||||
if (!file.archive->file.isOpen())
|
||||
return 0;
|
||||
|
||||
if (!file.archive->file.seek(file.offset))
|
||||
return 0;
|
||||
|
||||
size = file.size;
|
||||
|
||||
byte *rawData = new byte[file.size];
|
||||
if (file.archive->file.read(rawData, file.size) != file.size) {
|
||||
delete[] rawData;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!file.packed)
|
||||
return rawData;
|
||||
|
||||
byte *unpackedData = unpack(rawData, file.size, size);
|
||||
|
||||
delete[] rawData;
|
||||
|
||||
return unpackedData;
|
||||
}
|
||||
|
||||
} // End of namespace Gob
|
||||
|
|
|
|||
|
|
@ -27,113 +27,74 @@
|
|||
#define GOB_DATAIO_H
|
||||
|
||||
#include "common/endian.h"
|
||||
#include "common/str.h"
|
||||
#include "common/hashmap.h"
|
||||
#include "common/array.h"
|
||||
#include "common/file.h"
|
||||
|
||||
namespace Common {
|
||||
class SeekableReadStream;
|
||||
}
|
||||
|
||||
namespace Gob {
|
||||
|
||||
#define MAX_FILES 30
|
||||
#define MAX_DATA_FILES 8
|
||||
#define MAX_SLOT_COUNT 8
|
||||
|
||||
class DataIO;
|
||||
|
||||
class DataStream : public Common::SeekableReadStream {
|
||||
public:
|
||||
DataStream(DataIO &io, int16 handle, uint32 dSize, bool dispose = false);
|
||||
DataStream(byte *buf, uint32 dSize, bool dispose = true);
|
||||
virtual ~DataStream();
|
||||
|
||||
virtual int32 pos() const;
|
||||
virtual int32 size() const;
|
||||
|
||||
virtual bool seek(int32 offset, int whence = SEEK_SET);
|
||||
|
||||
virtual bool eos() const;
|
||||
|
||||
virtual uint32 read(void *dataPtr, uint32 dataSize);
|
||||
|
||||
private:
|
||||
DataIO *_io;
|
||||
int16 _handle;
|
||||
uint32 _size;
|
||||
byte *_data;
|
||||
bool _dispose;
|
||||
Common::MemoryReadStream *_stream;
|
||||
};
|
||||
|
||||
class DataIO {
|
||||
public:
|
||||
struct ChunkDesc {
|
||||
char chunkName[13];
|
||||
uint32 size;
|
||||
uint32 offset;
|
||||
byte packed;
|
||||
ChunkDesc() : size(0), offset(0), packed(0) { chunkName[0] = 0; }
|
||||
};
|
||||
|
||||
int32 unpackData(byte *src, byte *dest);
|
||||
|
||||
void openDataFile(const char *src, bool itk = 0);
|
||||
void closeDataFile(bool itk = 0);
|
||||
|
||||
byte *getUnpackedData(const char *name);
|
||||
|
||||
void closeData(int16 handle);
|
||||
int16 openData(const char *path);
|
||||
bool existData(const char *path);
|
||||
|
||||
DataStream *openAsStream(int16 handle, bool dispose = false);
|
||||
|
||||
int32 getDataSize(const char *name);
|
||||
byte *getData(const char *path);
|
||||
DataStream *getDataStream(const char *path);
|
||||
|
||||
DataIO(class GobEngine *vm);
|
||||
DataIO();
|
||||
~DataIO();
|
||||
|
||||
protected:
|
||||
Common::File _filesHandles[MAX_FILES];
|
||||
bool openArchive(Common::String name, bool base);
|
||||
bool closeArchive(bool base);
|
||||
|
||||
ChunkDesc *_dataFiles [MAX_DATA_FILES];
|
||||
uint16 _numDataChunks [MAX_DATA_FILES];
|
||||
int16 _dataFileHandles[MAX_DATA_FILES];
|
||||
bool _dataFileItk [MAX_DATA_FILES];
|
||||
bool hasFile(const Common::String &name);
|
||||
|
||||
ChunkDesc *_chunk [MAX_SLOT_COUNT * MAX_DATA_FILES];
|
||||
int32 _chunkPos [MAX_SLOT_COUNT * MAX_DATA_FILES];
|
||||
bool _isCurrentSlot[MAX_SLOT_COUNT * MAX_DATA_FILES];
|
||||
int32 fileSize(const Common::String &name);
|
||||
|
||||
class GobEngine *_vm;
|
||||
Common::SeekableReadStream *getFile(const Common::String &name);
|
||||
byte *getFile(const Common::String &name, int32 &size);
|
||||
|
||||
bool isDataFileChunk(int16 handle) const;
|
||||
bool isPacked (int16 handle) const;
|
||||
static byte *unpack(const byte *src, uint32 srcSize, int32 &size);
|
||||
static Common::SeekableReadStream *unpack(Common::SeekableReadStream &src);
|
||||
|
||||
int getFile (int16 handle) const;
|
||||
int getSlot (int16 handle) const;
|
||||
int getIndex(int16 handle) const;
|
||||
private:
|
||||
static const int kMaxArchives = 8;
|
||||
|
||||
int getIndex (int file, int slot) const;
|
||||
int16 getHandle(int file, int slot) const;
|
||||
struct Archive;
|
||||
|
||||
int16 file_open(const char *path);
|
||||
Common::File *file_getHandle(int16 handle);
|
||||
const Common::File *file_getHandle(int16 handle) const;
|
||||
struct File {
|
||||
Common::String name;
|
||||
uint32 size;
|
||||
uint32 offset;
|
||||
bool packed;
|
||||
|
||||
int16 getChunk(const char *chunkName);
|
||||
char freeChunk(int16 handle);
|
||||
int32 readChunk(int16 handle, byte *buf, uint16 size);
|
||||
int16 seekChunk(int16 handle, int32 pos, int16 from);
|
||||
Archive *archive;
|
||||
|
||||
uint32 getChunkPos(int16 handle) const;
|
||||
File();
|
||||
File(const Common::String &n, uint32 s, uint32 o, bool p, Archive &a);
|
||||
};
|
||||
|
||||
int32 getChunkSize(const char *chunkName, int32 &packSize);
|
||||
typedef Common::HashMap<Common::String, File, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> FileMap;
|
||||
|
||||
uint32 getPos(int16 handle);
|
||||
void seekData(int16 handle, int32 pos, int16 from);
|
||||
struct Archive {
|
||||
Common::String name;
|
||||
Common::File file;
|
||||
|
||||
int32 readData(int16 handle, byte *buf, uint16 size);
|
||||
FileMap files;
|
||||
|
||||
friend class DataStream;
|
||||
bool base;
|
||||
};
|
||||
|
||||
Common::Array<Archive *> _archives;
|
||||
|
||||
Archive *openArchive(const Common::String &name);
|
||||
bool closeArchive(Archive &archive);
|
||||
|
||||
File *findFile(const Common::String &name);
|
||||
|
||||
Common::SeekableReadStream *getFile(File &file);
|
||||
byte *getFile(File &file, int32 &size);
|
||||
|
||||
static void unpack(Common::SeekableReadStream &src, byte *dest, uint32 size);
|
||||
};
|
||||
|
||||
} // End of namespace Gob
|
||||
|
|
|
|||
|
|
@ -639,10 +639,11 @@ void Draw::wobble(Surface &surfDesc) {
|
|||
}
|
||||
|
||||
Font *Draw::loadFont(const char *path) const {
|
||||
if (!_vm->_dataIO->existData(path))
|
||||
if (!_vm->_dataIO->hasFile(path))
|
||||
return 0;
|
||||
|
||||
byte *data = _vm->_dataIO->getData(path);
|
||||
int32 size;
|
||||
byte *data = _vm->_dataIO->getFile(path, size);
|
||||
|
||||
return new Font(data);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -370,7 +370,7 @@ bool GobEngine::initGameParts() {
|
|||
|
||||
_global = new Global(this);
|
||||
_util = new Util(this);
|
||||
_dataIO = new DataIO(this);
|
||||
_dataIO = new DataIO();
|
||||
_palAnim = new PalAnim(this);
|
||||
_vidPlayer = new VideoPlayer(this);
|
||||
_sound = new Sound(this);
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ void Init::cleanup() {
|
|||
|
||||
_vm->_sound->speakerOff();
|
||||
_vm->_sound->blasterStop(0);
|
||||
_vm->_dataIO->closeDataFile();
|
||||
_vm->_dataIO->closeArchive(true);
|
||||
}
|
||||
|
||||
void Init::doDemo() {
|
||||
|
|
@ -81,17 +81,12 @@ void Init::doDemo() {
|
|||
}
|
||||
|
||||
void Init::initGame() {
|
||||
byte *infBuf;
|
||||
char *infPtr;
|
||||
char *infEnd;
|
||||
char buffer[128];
|
||||
|
||||
initVideo();
|
||||
updateConfig();
|
||||
|
||||
if (!_vm->isDemo()) {
|
||||
if (_vm->_dataIO->existData(_vm->_startStk.c_str()))
|
||||
_vm->_dataIO->openDataFile(_vm->_startStk.c_str());
|
||||
if (_vm->_dataIO->hasFile(_vm->_startStk))
|
||||
_vm->_dataIO->openArchive(_vm->_startStk, true);
|
||||
}
|
||||
|
||||
_vm->_util->initInput();
|
||||
|
|
@ -126,37 +121,31 @@ void Init::initGame() {
|
|||
return;
|
||||
}
|
||||
|
||||
if (!_vm->_dataIO->existData("intro.inf")) {
|
||||
Common::SeekableReadStream *infFile = _vm->_dataIO->getFile("intro.inf");
|
||||
if (!infFile) {
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
_vm->_draw->loadFont(i, _fontNames[i]);
|
||||
|
||||
} else {
|
||||
infBuf = _vm->_dataIO->getData("intro.inf");
|
||||
infPtr = (char *)infBuf;
|
||||
|
||||
infEnd = (char *)(infBuf + _vm->_dataIO->getDataSize("intro.inf"));
|
||||
|
||||
for (int i = 0; i < 8; i++, infPtr++) {
|
||||
int j;
|
||||
|
||||
for (j = 0; infPtr < infEnd && *infPtr >= ' '; j++, infPtr++)
|
||||
buffer[j] = *infPtr;
|
||||
buffer[j] = 0;
|
||||
|
||||
strcat(buffer, ".let");
|
||||
|
||||
_vm->_draw->loadFont(i, buffer);
|
||||
|
||||
if ((infPtr + 1) >= infEnd)
|
||||
for (int i = 0; i < 8; i++) {
|
||||
if (infFile->eos())
|
||||
break;
|
||||
|
||||
infPtr++;
|
||||
Common::String font = infFile->readLine();
|
||||
if (infFile->eos() && font.empty())
|
||||
break;
|
||||
|
||||
font += ".let";
|
||||
|
||||
_vm->_draw->loadFont(i, font.c_str());
|
||||
}
|
||||
delete[] infBuf;
|
||||
|
||||
delete infFile;
|
||||
}
|
||||
|
||||
if (_vm->_dataIO->existData(_vm->_startTot.c_str())) {
|
||||
if (_vm->_dataIO->hasFile(_vm->_startTot)) {
|
||||
_vm->_inter->allocateVars(Script::getVariablesCount(_vm->_startTot.c_str(), _vm));
|
||||
|
||||
strcpy(_vm->_game->_curTotFile, _vm->_startTot.c_str());
|
||||
|
|
@ -165,7 +154,7 @@ void Init::initGame() {
|
|||
_vm->_sound->cdLoadLIC("gob.lic");
|
||||
|
||||
// Search for a Coktel logo animation or image to display
|
||||
if (_vm->_dataIO->existData("coktel.imd")) {
|
||||
if (_vm->_dataIO->hasFile("coktel.imd")) {
|
||||
_vm->_draw->initScreen();
|
||||
_vm->_draw->_cursorIndex = -1;
|
||||
|
||||
|
|
@ -179,26 +168,28 @@ void Init::initGame() {
|
|||
}
|
||||
|
||||
_vm->_draw->closeScreen();
|
||||
} else if (_vm->_dataIO->existData("coktel.clt")) {
|
||||
_vm->_draw->initScreen();
|
||||
_vm->_util->clearPalette();
|
||||
} else if (_vm->_dataIO->hasFile("coktel.clt")) {
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile("coktel.clt");
|
||||
if (stream) {
|
||||
_vm->_draw->initScreen();
|
||||
_vm->_util->clearPalette();
|
||||
|
||||
DataStream *stream = _vm->_dataIO->getDataStream("coktel.clt");
|
||||
stream->read((byte *)_vm->_draw->_vgaPalette, 768);
|
||||
delete stream;
|
||||
stream->read((byte *)_vm->_draw->_vgaPalette, 768);
|
||||
delete stream;
|
||||
|
||||
if (_vm->_dataIO->existData("coktel.ims")) {
|
||||
byte *sprBuf;
|
||||
int32 size;
|
||||
byte *sprite = _vm->_dataIO->getFile("coktel.ims", size);
|
||||
if (sprite) {
|
||||
_vm->_video->drawPackedSprite(sprite, 320, 200, 0, 0, 0,
|
||||
*_vm->_draw->_frontSurface);
|
||||
_vm->_palAnim->fade(_palDesc, 0, 0);
|
||||
_vm->_util->delay(500);
|
||||
|
||||
sprBuf = _vm->_dataIO->getData("coktel.ims");
|
||||
_vm->_video->drawPackedSprite(sprBuf, 320, 200, 0, 0, 0,
|
||||
*_vm->_draw->_frontSurface);
|
||||
_vm->_palAnim->fade(_palDesc, 0, 0);
|
||||
_vm->_util->delay(500);
|
||||
delete[] sprite;
|
||||
}
|
||||
|
||||
delete[] sprBuf;
|
||||
_vm->_draw->closeScreen();
|
||||
}
|
||||
_vm->_draw->closeScreen();
|
||||
}
|
||||
|
||||
_vm->_game->start();
|
||||
|
|
@ -209,7 +200,7 @@ void Init::initGame() {
|
|||
}
|
||||
|
||||
delete _palDesc;
|
||||
_vm->_dataIO->closeDataFile();
|
||||
_vm->_dataIO->closeArchive(true);
|
||||
_vm->_video->initPrimary(-1);
|
||||
cleanup();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -175,10 +175,12 @@ void Inter_Bargon::oBargon_intro3(OpGobParams ¶ms) {
|
|||
static const char *sndFiles[] = {"1INTROIV.snd", "2INTROIV.snd"};
|
||||
static const char *palFiles[] = {"2ou2.clt", "2ou3.clt", "2ou4.clt", "2ou5.clt"};
|
||||
|
||||
int32 size;
|
||||
|
||||
for (int i = 0; i < 2; i++)
|
||||
_vm->_sound->sampleLoad(&samples[i], SOUND_SND, sndFiles[i]);
|
||||
for (int i = 0; i < 4; i++)
|
||||
palettes[i] = _vm->_dataIO->getData(palFiles[i]);
|
||||
palettes[i] = _vm->_dataIO->getFile(palFiles[i], size);
|
||||
palBak = _vm->_global->_pPaletteDesc->vgaPal;
|
||||
|
||||
_vm->_sound->blasterPlayComposition(comp, 0, samples, 2);
|
||||
|
|
|
|||
|
|
@ -246,10 +246,10 @@ bool Inter_Playtoons::oPlaytoons_checkData(OpFuncParams ¶ms) {
|
|||
|
||||
mode = _vm->_saveLoad->getSaveMode(file);
|
||||
if (mode == SaveLoad::kSaveModeNone) {
|
||||
if (_vm->_dataIO->existData(file))
|
||||
size = _vm->_dataIO->getDataSize(file);
|
||||
else
|
||||
size = _vm->_dataIO->fileSize(file);
|
||||
if (size == -1)
|
||||
warning("File \"%s\" not found", file);
|
||||
|
||||
} else if (mode == SaveLoad::kSaveModeSave)
|
||||
size = _vm->_saveLoad->getSize(file);
|
||||
else if (mode == SaveLoad::kSaveModeExists)
|
||||
|
|
@ -272,7 +272,6 @@ bool Inter_Playtoons::oPlaytoons_readData(OpFuncParams ¶ms) {
|
|||
int32 size;
|
||||
int32 offset;
|
||||
uint16 dataVar;
|
||||
int16 handle;
|
||||
byte *buf;
|
||||
SaveLoad::SaveMode mode;
|
||||
|
||||
|
|
@ -329,13 +328,10 @@ bool Inter_Playtoons::oPlaytoons_readData(OpFuncParams ¶ms) {
|
|||
}
|
||||
|
||||
WRITE_VAR(1, 1);
|
||||
handle = _vm->_dataIO->openData(file);
|
||||
|
||||
if (handle < 0)
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(file);
|
||||
if (!stream)
|
||||
return false;
|
||||
|
||||
DataStream *stream = _vm->_dataIO->openAsStream(handle, true);
|
||||
|
||||
_vm->_draw->animateCursor(4);
|
||||
if (offset < 0)
|
||||
stream->seek(offset + 1, SEEK_END);
|
||||
|
|
@ -435,9 +431,9 @@ void Inter_Playtoons::oPlaytoons_openItk() {
|
|||
// Workaround for Bambou : In the script, the path is hardcoded (!!)
|
||||
if ((backSlash = strrchr(fileName, '\\'))) {
|
||||
debugC(2, kDebugFileIO, "Opening ITK file \"%s\" instead of \"%s\"", backSlash + 1, fileName);
|
||||
_vm->_dataIO->openDataFile(backSlash + 1, true);
|
||||
_vm->_dataIO->openArchive(backSlash + 1, false);
|
||||
} else
|
||||
_vm->_dataIO->openDataFile(fileName, true);
|
||||
_vm->_dataIO->openArchive(fileName, false);
|
||||
// All the other checks are meant to verify (if not found at the first try)
|
||||
// if the file is present on the CD or not. As everything is supposed to
|
||||
// be copied, those checks are skipped
|
||||
|
|
|
|||
|
|
@ -1630,18 +1630,17 @@ bool Inter_v1::o1_getFreeMem(OpFuncParams ¶ms) {
|
|||
}
|
||||
|
||||
bool Inter_v1::o1_checkData(OpFuncParams ¶ms) {
|
||||
int16 handle;
|
||||
int16 varOff;
|
||||
|
||||
_vm->_game->_script->evalExpr(0);
|
||||
varOff = _vm->_game->_script->readVarIndex();
|
||||
handle = _vm->_dataIO->openData(_vm->_game->_script->getResultStr());
|
||||
|
||||
WRITE_VAR_OFFSET(varOff, handle);
|
||||
if (handle >= 0)
|
||||
_vm->_dataIO->closeData(handle);
|
||||
else
|
||||
if (!_vm->_dataIO->hasFile(_vm->_game->_script->getResultStr())) {
|
||||
warning("File \"%s\" not found", _vm->_game->_script->getResultStr());
|
||||
WRITE_VAR_OFFSET(varOff, -1);
|
||||
} else
|
||||
WRITE_VAR_OFFSET(varOff, 50); // "handle" between 50 and 128 = in archive
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -1767,7 +1766,6 @@ bool Inter_v1::o1_readData(OpFuncParams ¶ms) {
|
|||
int16 size;
|
||||
int16 dataVar;
|
||||
int16 offset;
|
||||
int16 handle;
|
||||
|
||||
_vm->_game->_script->evalExpr(0);
|
||||
dataVar = _vm->_game->_script->readVarIndex();
|
||||
|
|
@ -1776,26 +1774,26 @@ bool Inter_v1::o1_readData(OpFuncParams ¶ms) {
|
|||
retSize = 0;
|
||||
|
||||
WRITE_VAR(1, 1);
|
||||
handle = _vm->_dataIO->openData(_vm->_game->_script->getResultStr());
|
||||
if (handle >= 0) {
|
||||
DataStream *stream = _vm->_dataIO->openAsStream(handle, true);
|
||||
|
||||
_vm->_draw->animateCursor(4);
|
||||
if (offset < 0)
|
||||
stream->seek(offset + 1, SEEK_END);
|
||||
else
|
||||
stream->seek(offset);
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(_vm->_game->_script->getResultStr());
|
||||
if (!stream)
|
||||
return false;
|
||||
|
||||
if (((dataVar >> 2) == 59) && (size == 4))
|
||||
WRITE_VAR(59, stream->readUint32LE());
|
||||
else
|
||||
retSize = stream->read((byte *)_variables->getAddressOff8(dataVar), size);
|
||||
_vm->_draw->animateCursor(4);
|
||||
if (offset < 0)
|
||||
stream->seek(offset + 1, SEEK_END);
|
||||
else
|
||||
stream->seek(offset);
|
||||
|
||||
if (retSize == size)
|
||||
WRITE_VAR(1, 0);
|
||||
if (((dataVar >> 2) == 59) && (size == 4))
|
||||
WRITE_VAR(59, stream->readUint32LE());
|
||||
else
|
||||
retSize = stream->read((byte *)_variables->getAddressOff8(dataVar), size);
|
||||
|
||||
delete stream;
|
||||
}
|
||||
if (retSize == size)
|
||||
WRITE_VAR(1, 0);
|
||||
|
||||
delete stream;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1824,9 +1822,9 @@ bool Inter_v1::o1_manageDataFile(OpFuncParams ¶ms) {
|
|||
_vm->_game->_script->evalExpr(0);
|
||||
|
||||
if (_vm->_game->_script->getResultStr()[0] != 0)
|
||||
_vm->_dataIO->openDataFile(_vm->_game->_script->getResultStr());
|
||||
_vm->_dataIO->openArchive(_vm->_game->_script->getResultStr(), true);
|
||||
else
|
||||
_vm->_dataIO->closeDataFile();
|
||||
_vm->_dataIO->closeArchive(true);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1035,11 +1035,11 @@ void Inter_v2::o2_openItk() {
|
|||
if (!strchr(fileName, '.'))
|
||||
strcat(fileName, ".ITK");
|
||||
|
||||
_vm->_dataIO->openDataFile(fileName, true);
|
||||
_vm->_dataIO->openArchive(fileName, false);
|
||||
}
|
||||
|
||||
void Inter_v2::o2_closeItk() {
|
||||
_vm->_dataIO->closeDataFile(true);
|
||||
_vm->_dataIO->closeArchive(false);
|
||||
}
|
||||
|
||||
void Inter_v2::o2_setImdFrontSurf() {
|
||||
|
|
@ -1292,7 +1292,6 @@ bool Inter_v2::o2_getFreeMem(OpFuncParams ¶ms) {
|
|||
}
|
||||
|
||||
bool Inter_v2::o2_checkData(OpFuncParams ¶ms) {
|
||||
int16 handle;
|
||||
int16 varOff;
|
||||
int32 size;
|
||||
SaveLoad::SaveMode mode;
|
||||
|
|
@ -1301,7 +1300,6 @@ bool Inter_v2::o2_checkData(OpFuncParams ¶ms) {
|
|||
varOff = _vm->_game->_script->readVarIndex();
|
||||
|
||||
size = -1;
|
||||
handle = 1;
|
||||
|
||||
char *file = _vm->_game->_script->getResultStr();
|
||||
|
||||
|
|
@ -1313,9 +1311,8 @@ bool Inter_v2::o2_checkData(OpFuncParams ¶ms) {
|
|||
mode = _vm->_saveLoad->getSaveMode(file);
|
||||
if (mode == SaveLoad::kSaveModeNone) {
|
||||
|
||||
if (_vm->_dataIO->existData(file))
|
||||
size = _vm->_dataIO->getDataSize(file);
|
||||
else
|
||||
size = _vm->_dataIO->fileSize(file);
|
||||
if (size == -1)
|
||||
warning("File \"%s\" not found", file);
|
||||
|
||||
} else if (mode == SaveLoad::kSaveModeSave)
|
||||
|
|
@ -1323,13 +1320,10 @@ bool Inter_v2::o2_checkData(OpFuncParams ¶ms) {
|
|||
else if (mode == SaveLoad::kSaveModeExists)
|
||||
size = 23;
|
||||
|
||||
if (size == -1)
|
||||
handle = -1;
|
||||
|
||||
debugC(2, kDebugFileIO, "Requested size of file \"%s\": %d",
|
||||
file, size);
|
||||
|
||||
WRITE_VAR_OFFSET(varOff, handle);
|
||||
WRITE_VAR_OFFSET(varOff, (size == -1) ? -1 : 50);
|
||||
WRITE_VAR(16, (uint32) size);
|
||||
|
||||
return false;
|
||||
|
|
@ -1340,7 +1334,6 @@ bool Inter_v2::o2_readData(OpFuncParams ¶ms) {
|
|||
int32 size;
|
||||
int32 offset;
|
||||
int16 dataVar;
|
||||
int16 handle;
|
||||
byte *buf;
|
||||
SaveLoad::SaveMode mode;
|
||||
|
||||
|
|
@ -1391,13 +1384,10 @@ bool Inter_v2::o2_readData(OpFuncParams ¶ms) {
|
|||
}
|
||||
|
||||
WRITE_VAR(1, 1);
|
||||
handle = _vm->_dataIO->openData(file);
|
||||
|
||||
if (handle < 0)
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(file);
|
||||
if (!file)
|
||||
return false;
|
||||
|
||||
DataStream *stream = _vm->_dataIO->openAsStream(handle, true);
|
||||
|
||||
_vm->_draw->animateCursor(4);
|
||||
if (offset < 0)
|
||||
stream->seek(offset + 1, SEEK_END);
|
||||
|
|
@ -1512,16 +1502,13 @@ void Inter_v2::o2_handleGoblins(OpGobParams ¶ms) {
|
|||
}
|
||||
|
||||
int16 Inter_v2::loadSound(int16 search) {
|
||||
byte *dataPtr;
|
||||
int16 id;
|
||||
int16 slot;
|
||||
uint16 slotIdMask;
|
||||
uint32 dataSize;
|
||||
SoundType type;
|
||||
|
||||
type = SOUND_SND;
|
||||
slotIdMask = 0;
|
||||
dataSize = 0;
|
||||
|
||||
if (!search) {
|
||||
slot = _vm->_game->_script->readValExpr();
|
||||
|
|
@ -1567,8 +1554,8 @@ int16 Inter_v2::loadSound(int16 search) {
|
|||
else
|
||||
strcat(sndfile, ".SND");
|
||||
|
||||
dataPtr = _vm->_dataIO->getData(sndfile);
|
||||
dataSize = _vm->_dataIO->getDataSize(sndfile);
|
||||
int32 dataSize;
|
||||
byte *dataPtr = _vm->_dataIO->getFile(sndfile, dataSize);
|
||||
if (!dataPtr)
|
||||
return 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -191,16 +191,16 @@ void Inter_v6::o6_openItk() {
|
|||
if (!strchr(fileName, '.'))
|
||||
strcat(fileName, ".ITK");
|
||||
|
||||
_vm->_dataIO->openDataFile(fileName, true);
|
||||
_vm->_dataIO->openArchive(fileName, false);
|
||||
|
||||
// WORKAROUND: The CD number detection in Urban Runner is quite daft
|
||||
// (it checks CD1.ITK - CD4.ITK and the first that's found determines
|
||||
// the CD number), while its NO_CD modus wants everything in CD1.ITK.
|
||||
// So we just open the other ITKs, too.
|
||||
if (_vm->_global->_noCd && !scumm_stricmp(fileName, "CD1.ITK")) {
|
||||
_vm->_dataIO->openDataFile("CD2.ITK", true);
|
||||
_vm->_dataIO->openDataFile("CD3.ITK", true);
|
||||
_vm->_dataIO->openDataFile("CD4.ITK", true);
|
||||
_vm->_dataIO->openArchive("CD2.ITK", false);
|
||||
_vm->_dataIO->openArchive("CD3.ITK", false);
|
||||
_vm->_dataIO->openArchive("CD4.ITK", false);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -439,7 +439,7 @@ void Inter_v6::probe16bitMusic(char *fileName) {
|
|||
|
||||
fileName[len - 1] = 'V';
|
||||
|
||||
if (_vm->_dataIO->existData(fileName))
|
||||
if (_vm->_dataIO->hasFile(fileName))
|
||||
return;
|
||||
|
||||
fileName[len - 1] = '8';
|
||||
|
|
|
|||
|
|
@ -75,13 +75,13 @@ void Map_v1::loadMapObjects(const char *avjFile) {
|
|||
strcpy(avoName, _sourceFile);
|
||||
strcat(avoName, ".avo");
|
||||
|
||||
if (_vm->_dataIO->existData(avoName)) {
|
||||
_loadFromAvo = true;
|
||||
dataBuf = _vm->_dataIO->getData(avoName);
|
||||
} else {
|
||||
int32 size;
|
||||
dataBuf = _vm->_dataIO->getFile(avoName, size);
|
||||
if (!dataBuf) {
|
||||
dataBuf = _vm->_dataIO->getFile(avjFile, size);
|
||||
_loadFromAvo = false;
|
||||
dataBuf = _vm->_dataIO->getData(avjFile);
|
||||
}
|
||||
} else
|
||||
_loadFromAvo = true;
|
||||
|
||||
Common::MemoryReadStream mapData(dataBuf, 4294967295U);
|
||||
|
||||
|
|
@ -165,7 +165,7 @@ void Map_v1::loadSounds(Common::SeekableReadStream &data) {
|
|||
_vm->_sound->sampleLoad(&_vm->_goblin->_soundData[14], SOUND_SND, "diamant1.snd");
|
||||
|
||||
for (int i = 0; i < count; i++) {
|
||||
if (!_vm->_dataIO->existData(sndNames[i]))
|
||||
if (!_vm->_dataIO->hasFile(sndNames[i]))
|
||||
continue;
|
||||
|
||||
_vm->_sound->sampleLoad(&_vm->_goblin->_soundData[i], SOUND_SND, sndNames[i]);
|
||||
|
|
|
|||
|
|
@ -293,7 +293,7 @@ bool Resources::loadTOTResourceTable() {
|
|||
bool Resources::loadEXTResourceTable() {
|
||||
_extResourceTable = new EXTResourceTable;
|
||||
|
||||
DataStream *stream = _vm->_dataIO->getDataStream(_extFile.c_str());
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(_extFile);
|
||||
if (!stream)
|
||||
return false;
|
||||
|
||||
|
|
@ -396,7 +396,7 @@ bool Resources::loadIMFile() {
|
|||
|
||||
imFile += num;
|
||||
|
||||
DataStream *stream = _vm->_dataIO->getDataStream(imFile.c_str());
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(imFile);
|
||||
if (!stream)
|
||||
return true;
|
||||
|
||||
|
|
@ -431,7 +431,7 @@ bool Resources::loadEXFile() {
|
|||
_exFile = "commun.ex";
|
||||
_exFile += totProps.exFileNumber + '0';
|
||||
|
||||
if (!_vm->_dataIO->existData(_exFile.c_str())) {
|
||||
if (!_vm->_dataIO->hasFile(_exFile)) {
|
||||
_exFile.clear();
|
||||
return true;
|
||||
}
|
||||
|
|
@ -473,7 +473,7 @@ Common::String Resources::getLocTextFile(const Common::String &fileBase,
|
|||
break;
|
||||
}
|
||||
|
||||
if (!_vm->_dataIO->existData(locTextFile.c_str()))
|
||||
if (!_vm->_dataIO->hasFile(locTextFile))
|
||||
locTextFile.clear();
|
||||
|
||||
return locTextFile;
|
||||
|
|
@ -525,8 +525,7 @@ byte *Resources::loadTOTLocTexts(const Common::String &fileBase, int32 &size) {
|
|||
if (locTextFile.empty())
|
||||
return 0;
|
||||
|
||||
size = _vm->_dataIO->getDataSize(locTextFile.c_str());
|
||||
return _vm->_dataIO->getData(locTextFile.c_str());
|
||||
return _vm->_dataIO->getFile(locTextFile, size);
|
||||
}
|
||||
|
||||
Resource *Resources::getResource(uint16 id, int16 *width, int16 *height) const {
|
||||
|
|
@ -682,10 +681,10 @@ Resource *Resources::getEXTResource(uint16 id) const {
|
|||
if (extItem.packed) {
|
||||
byte *packedData = data;
|
||||
|
||||
size = READ_LE_UINT32(packedData);
|
||||
data = new byte[size];
|
||||
int32 unpackSize;
|
||||
data = _vm->_dataIO->unpack(packedData, size, unpackSize);
|
||||
|
||||
_vm->_dataIO->unpackData(packedData, data);
|
||||
size = unpackSize;
|
||||
|
||||
delete[] packedData;
|
||||
}
|
||||
|
|
@ -724,7 +723,7 @@ byte *Resources::getIMData(TOTResourceItem &totItem) const {
|
|||
}
|
||||
|
||||
byte *Resources::getEXTData(EXTResourceItem &extItem, uint32 size) const {
|
||||
DataStream *stream = _vm->_dataIO->getDataStream(_extFile.c_str());
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(_extFile);
|
||||
if (!stream)
|
||||
return 0;
|
||||
|
||||
|
|
@ -745,7 +744,7 @@ byte *Resources::getEXTData(EXTResourceItem &extItem, uint32 size) const {
|
|||
}
|
||||
|
||||
byte *Resources::getEXData(EXTResourceItem &extItem, uint32 size) const {
|
||||
DataStream *stream = _vm->_dataIO->getDataStream(_exFile.c_str());
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(_exFile);
|
||||
if (!stream)
|
||||
return 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ Script::Script(GobEngine *vm) : _vm(vm) {
|
|||
_totPtr = 0;
|
||||
_totSize = 0;
|
||||
|
||||
_lomHandle = -1;
|
||||
_lom = 0;
|
||||
|
||||
memset(&_totProperties, 0, sizeof(TOTFile::Properties));
|
||||
}
|
||||
|
|
@ -380,20 +380,16 @@ bool Script::loadTOT(const Common::String &fileName) {
|
|||
bool Script::loadLOM(const Common::String &fileName) {
|
||||
warning("Stub: Script::loadLOM(%s)", _totFile.c_str());
|
||||
|
||||
_lomHandle = _vm->_dataIO->openData(_totFile.c_str());
|
||||
if (_lomHandle < 0)
|
||||
_lom = _vm->_dataIO->getFile(_totFile);
|
||||
if (!_lom)
|
||||
return false;
|
||||
|
||||
DataStream *stream = _vm->_dataIO->openAsStream(_lomHandle);
|
||||
|
||||
stream->seek(48);
|
||||
_totSize = stream->readUint32LE();
|
||||
stream->seek(0);
|
||||
_lom->seek(48);
|
||||
_totSize = _lom->readUint32LE();
|
||||
_lom->seek(0);
|
||||
|
||||
_totData = new byte[_totSize];
|
||||
stream->read(_totData, _totSize);
|
||||
|
||||
delete stream;
|
||||
_lom->read(_totData, _totSize);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
|
@ -403,8 +399,8 @@ void Script::unload() {
|
|||
}
|
||||
|
||||
void Script::unloadTOT() {
|
||||
if (_lomHandle >= 0)
|
||||
_vm->_dataIO->closeData(_lomHandle);
|
||||
delete _lom;
|
||||
_lom = 0;
|
||||
|
||||
// Unwind the call stack
|
||||
while (!_callStack.empty())
|
||||
|
|
@ -415,7 +411,6 @@ void Script::unloadTOT() {
|
|||
_totData = 0;
|
||||
_totSize = 0;
|
||||
_totPtr = 0;
|
||||
_lomHandle = -1;
|
||||
_totFile.clear();
|
||||
|
||||
_finished = true;
|
||||
|
|
@ -518,7 +513,7 @@ uint16 Script::getFunctionOffset(uint8 function) const {
|
|||
}
|
||||
|
||||
uint32 Script::getVariablesCount(const char *fileName, GobEngine *vm) {
|
||||
DataStream *stream = vm->_dataIO->getDataStream(fileName);
|
||||
Common::SeekableReadStream *stream = vm->_dataIO->getFile(fileName);
|
||||
if (!stream)
|
||||
return 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -150,7 +150,7 @@ private:
|
|||
byte *_totPtr;
|
||||
uint32 _totSize;
|
||||
|
||||
int16 _lomHandle;
|
||||
Common::SeekableReadStream *_lom;
|
||||
|
||||
TOTFile::Properties _totProperties;
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ CDROM::~CDROM() {
|
|||
stop();
|
||||
}
|
||||
|
||||
void CDROM::readLIC(DataStream &stream) {
|
||||
void CDROM::readLIC(Common::SeekableReadStream &stream) {
|
||||
uint16 version, startChunk, pos;
|
||||
|
||||
freeLICBuffer();
|
||||
|
|
|
|||
|
|
@ -28,14 +28,12 @@
|
|||
|
||||
namespace Gob {
|
||||
|
||||
class DataStream;
|
||||
|
||||
class CDROM {
|
||||
public:
|
||||
CDROM();
|
||||
~CDROM();
|
||||
|
||||
void readLIC(DataStream &stream);
|
||||
void readLIC(Common::SeekableReadStream &stream);
|
||||
void freeLICBuffer();
|
||||
|
||||
void startTrack(const char *trackName);
|
||||
|
|
|
|||
|
|
@ -114,19 +114,13 @@ bool Sound::sampleLoad(SoundDesc *sndDesc, SoundType type, const char *fileName,
|
|||
|
||||
debugC(2, kDebugSound, "Loading sample \"%s\"", fileName);
|
||||
|
||||
if (!_vm->_dataIO->existData(fileName)) {
|
||||
int32 size;
|
||||
byte *data = _vm->_dataIO->getFile(fileName, size);
|
||||
if (!data) {
|
||||
warning("Can't open sample file \"%s\"", fileName);
|
||||
return false;
|
||||
}
|
||||
|
||||
byte *data;
|
||||
uint32 size;
|
||||
|
||||
data = (byte *)_vm->_dataIO->getData(fileName);
|
||||
if (!data)
|
||||
return false;
|
||||
|
||||
size = _vm->_dataIO->getDataSize(fileName);
|
||||
return sndDesc->load(type, data, size);
|
||||
}
|
||||
|
||||
|
|
@ -279,13 +273,12 @@ bool Sound::adlibLoadMDY(const char *fileName) {
|
|||
|
||||
debugC(1, kDebugSound, "AdLib: Loading MDY data (\"%s\")", fileName);
|
||||
|
||||
if (!_vm->_dataIO->existData(fileName)) {
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(fileName);
|
||||
if (!stream) {
|
||||
warning("Can't open MDY file \"%s\"", fileName);
|
||||
return false;
|
||||
}
|
||||
|
||||
DataStream *stream = _vm->_dataIO->getDataStream(fileName);
|
||||
|
||||
bool loaded = _mdyPlayer->loadMDY(*stream);
|
||||
|
||||
delete stream;
|
||||
|
|
@ -300,15 +293,14 @@ bool Sound::adlibLoadTBR(const char *fileName) {
|
|||
if (!_mdyPlayer)
|
||||
_mdyPlayer = new MDYPlayer(*_vm->_mixer);
|
||||
|
||||
if (!_vm->_dataIO->existData(fileName)) {
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(fileName);
|
||||
if (!stream) {
|
||||
warning("Can't open TBR file \"%s\"", fileName);
|
||||
return false;
|
||||
}
|
||||
|
||||
debugC(1, kDebugSound, "AdLib: Loading MDY instruments (\"%s\")", fileName);
|
||||
|
||||
DataStream *stream = _vm->_dataIO->getDataStream(fileName);
|
||||
|
||||
bool loaded = _mdyPlayer->loadTBR(*stream);
|
||||
|
||||
delete stream;
|
||||
|
|
@ -522,13 +514,10 @@ void Sound::cdLoadLIC(const char *fname) {
|
|||
|
||||
debugC(1, kDebugSound, "CDROM: Loading LIC \"%s\"", fname);
|
||||
|
||||
if (!_vm->_dataIO->existData(fname))
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(fname);
|
||||
if (!stream)
|
||||
return;
|
||||
|
||||
_vm->_dataIO->getUnpackedData(fname);
|
||||
|
||||
DataStream *stream = _vm->_dataIO->getDataStream(fname);
|
||||
|
||||
_cdrom->readLIC(*stream);
|
||||
|
||||
delete stream;
|
||||
|
|
|
|||
|
|
@ -45,11 +45,11 @@ TOTFile::~TOTFile() {
|
|||
|
||||
bool TOTFile::load(const Common::String &fileName) {
|
||||
// Trying to open normally
|
||||
_stream = _vm->_dataIO->getDataStream(fileName.c_str());
|
||||
_stream = _vm->_dataIO->getFile(fileName);
|
||||
|
||||
if (!_stream)
|
||||
// Trying to open from video
|
||||
_stream = _vm->_vidPlayer->getEmbeddedFile(fileName.c_str());
|
||||
_stream = _vm->_vidPlayer->getEmbeddedFile(fileName);
|
||||
|
||||
if (!_stream)
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -331,9 +331,9 @@ void Video::drawPackedSprite(byte *sprBuf, int16 width, int16 height,
|
|||
}
|
||||
|
||||
void Video::drawPackedSprite(const char *path, Surface &dest, int width) {
|
||||
byte *data;
|
||||
int32 size;
|
||||
byte *data = _vm->_dataIO->getFile(path, size);
|
||||
|
||||
data = _vm->_dataIO->getData(path);
|
||||
drawPackedSprite(data, width, dest.getHeight(), 0, 0, 0, dest);
|
||||
delete[] data;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -686,7 +686,7 @@ Common::String VideoPlayer::findFile(const Common::String &file, Properties &pro
|
|||
if ((properties.type == kVideoTypeTry) || (properties.type == ((Type) i))) {
|
||||
fileName = base + "." + _extensions[i];
|
||||
|
||||
if (_vm->_dataIO->existData(fileName.c_str())) {
|
||||
if (_vm->_dataIO->hasFile(fileName)) {
|
||||
properties.type = (Type) i;
|
||||
break;
|
||||
}
|
||||
|
|
@ -707,7 +707,7 @@ Graphics::CoktelDecoder *VideoPlayer::openVideo(const Common::String &file, Prop
|
|||
if (fileName.empty())
|
||||
return 0;
|
||||
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getDataStream(fileName.c_str());
|
||||
Common::SeekableReadStream *stream = _vm->_dataIO->getFile(fileName);
|
||||
if (!stream)
|
||||
return 0;
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue