mirror of
https://github.com/scummvm/scummvm.git
synced 2025-04-02 10:52:32 -04:00
147 lines
3.9 KiB
C++
147 lines
3.9 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 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 <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "common/file.h"
|
|
#include "common/memstream.h"
|
|
#include "got/utils/compression.h"
|
|
#include "got/utils/res_archive.h"
|
|
|
|
namespace Got {
|
|
|
|
static const char *RES_FILENAME = "gotres.dat";
|
|
|
|
void resInit() {
|
|
ResArchive *a = new ResArchive();
|
|
SearchMan.add("Res", a);
|
|
}
|
|
|
|
void ResHeader::load(Common::SeekableReadStream *src) {
|
|
char buf[10];
|
|
src->read(buf, 9);
|
|
buf[9] = '\0';
|
|
_name = buf;
|
|
|
|
_offset = src->readUint32LE();
|
|
_size = src->readUint32LE();
|
|
_originalSize = src->readUint32LE();
|
|
_key = src->readUint16LE();
|
|
}
|
|
|
|
ResArchive::ResArchive() {
|
|
Common::File f;
|
|
if (!f.open(RES_FILENAME))
|
|
error("Could not open %s", RES_FILENAME);
|
|
|
|
// Read in header data and decrypt it
|
|
byte buf[RES_MAX_ENTRIES * RES_HEADER_ENTRY_SIZE];
|
|
if (f.read(buf, RES_MAX_ENTRIES * RES_HEADER_ENTRY_SIZE) !=
|
|
(RES_MAX_ENTRIES * RES_HEADER_ENTRY_SIZE))
|
|
error("Could not read in resource headers");
|
|
|
|
decrypt(buf, RES_MAX_ENTRIES * RES_HEADER_ENTRY_SIZE, 128);
|
|
|
|
// Load headers
|
|
Common::MemoryReadStream hdrData(buf, RES_MAX_ENTRIES * RES_HEADER_ENTRY_SIZE);
|
|
for (int i = 0; i < RES_MAX_ENTRIES; ++i) {
|
|
ResHeader hdr;
|
|
hdr.load(&hdrData);
|
|
if (!(hdr._offset == 0 && hdr._size == 0))
|
|
_headers.push_back(hdr);
|
|
}
|
|
}
|
|
|
|
void ResArchive::decrypt(byte *buf, size_t len, byte key) const {
|
|
for (size_t i = 0; i < len; ++i)
|
|
*buf++ ^= key++;
|
|
}
|
|
|
|
int ResArchive::indexOf(const Common::String &name) const {
|
|
for (uint i = 0; i < _headers.size(); ++i) {
|
|
if (_headers[i]._name.equalsIgnoreCase(name))
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
bool ResArchive::hasFile(const Common::Path &path) const {
|
|
return indexOf(path.baseName()) != -1;
|
|
}
|
|
|
|
int ResArchive::listMembers(Common::ArchiveMemberList &list) const {
|
|
int count = 0;
|
|
|
|
for (uint i = 0; i < _headers.size(); ++i) {
|
|
list.push_back(Common::ArchiveMemberList::value_type(
|
|
new Common::GenericArchiveMember(_headers[i]._name, *this)));
|
|
++count;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
const Common::ArchiveMemberPtr ResArchive::getMember(const Common::Path &path) const {
|
|
if (!hasFile(path))
|
|
return Common::ArchiveMemberPtr();
|
|
|
|
return Common::ArchiveMemberPtr(new Common::GenericArchiveMember(path, *this));
|
|
}
|
|
|
|
Common::SeekableReadStream *ResArchive::createReadStreamForMember(const Common::Path &path) const {
|
|
// Get the index of the header entry for this file
|
|
const int hdrIndex = indexOf(path.baseName());
|
|
if (hdrIndex == -1)
|
|
return nullptr;
|
|
|
|
Common::File f;
|
|
if (!f.open(RES_FILENAME))
|
|
error("Error reading resource");
|
|
|
|
// Set up buffers
|
|
const ResHeader &hdr = _headers[hdrIndex];
|
|
byte *buf = (byte *)malloc(hdr._size);
|
|
|
|
f.seek(hdr._offset);
|
|
if (f.read(buf, hdr._size) != hdr._size)
|
|
error("Error reading resource");
|
|
|
|
// Decrypt if necessary
|
|
if (hdr._key != 0) {
|
|
byte *temp = buf;
|
|
buf = (byte *)malloc(hdr._originalSize);
|
|
|
|
lzssDecompress(temp, buf);
|
|
free(temp);
|
|
}
|
|
|
|
return new Common::MemoryReadStream(buf, hdr._originalSize,
|
|
DisposeAfterUse::YES);
|
|
}
|
|
|
|
void ResArchive::lzssDecompress(const byte *src, byte *dest) const {
|
|
const uint16 size = READ_LE_UINT16(src);
|
|
assert(READ_LE_UINT16(src + 2) == 1);
|
|
src += 4;
|
|
|
|
decompressLzss(src, dest, size);
|
|
}
|
|
|
|
} // namespace Got
|