mirror of
https://github.com/vcmi/vcmi.git
synced 2024-12-14 10:12:59 +02:00
254 lines
7.4 KiB
C++
254 lines
7.4 KiB
C++
/*
|
|
* CArchiveLoader.cpp, part of VCMI engine
|
|
*
|
|
* Authors: listed in file AUTHORS in main folder
|
|
*
|
|
* License: GNU General Public License v2.0 or later
|
|
* Full text of license available in license.txt file, in main folder
|
|
*
|
|
*/
|
|
#include "StdInc.h"
|
|
#include "CArchiveLoader.h"
|
|
|
|
#include "VCMIDirs.h"
|
|
#include "CFileInputStream.h"
|
|
#include "CCompressedStream.h"
|
|
|
|
#include "CBinaryReader.h"
|
|
|
|
VCMI_LIB_NAMESPACE_BEGIN
|
|
|
|
ArchiveEntry::ArchiveEntry()
|
|
: offset(0), fullSize(0), compressedSize(0)
|
|
{
|
|
|
|
}
|
|
|
|
CArchiveLoader::CArchiveLoader(std::string _mountPoint, boost::filesystem::path _archive, bool _extractArchives) :
|
|
archive(std::move(_archive)),
|
|
mountPoint(std::move(_mountPoint)),
|
|
extractArchives(_extractArchives)
|
|
{
|
|
// Open archive file(.snd, .vid, .lod)
|
|
CFileInputStream fileStream(archive);
|
|
|
|
// Fake .lod file with no data has to be silently ignored.
|
|
if(fileStream.getSize() < 10)
|
|
return;
|
|
|
|
// Retrieve file extension of archive in uppercase
|
|
const std::string ext = boost::to_upper_copy(archive.extension().string());
|
|
|
|
// Init the specific lod container format
|
|
if(ext == ".LOD" || ext == ".PAC")
|
|
initLODArchive(mountPoint, fileStream);
|
|
else if(ext == ".VID")
|
|
initVIDArchive(mountPoint, fileStream);
|
|
else if(ext == ".SND")
|
|
initSNDArchive(mountPoint, fileStream);
|
|
else
|
|
throw std::runtime_error("LOD archive format unknown. Cannot deal with " + archive.string());
|
|
|
|
logGlobal->trace("%sArchive \"%s\" loaded (%d files found).", ext, archive.filename(), entries.size());
|
|
}
|
|
|
|
void CArchiveLoader::initLODArchive(const std::string &mountPoint, CFileInputStream & fileStream)
|
|
{
|
|
// Read count of total files
|
|
CBinaryReader reader(&fileStream);
|
|
|
|
fileStream.seek(8);
|
|
ui32 totalFiles = reader.readUInt32();
|
|
|
|
// Get all entries from file
|
|
fileStream.seek(0x5c);
|
|
|
|
// Insert entries to list
|
|
for(ui32 i = 0; i < totalFiles; ++i)
|
|
{
|
|
char filename[16];
|
|
reader.read(reinterpret_cast<ui8*>(filename), 16);
|
|
|
|
// Create archive entry
|
|
ArchiveEntry entry;
|
|
entry.name = filename;
|
|
entry.offset = reader.readUInt32();
|
|
entry.fullSize = reader.readUInt32();
|
|
fileStream.skip(4); // unused, unknown
|
|
entry.compressedSize = reader.readUInt32();
|
|
|
|
// Add lod entry to local entries map
|
|
entries[ResourcePath(mountPoint + entry.name)] = entry;
|
|
|
|
if(extractArchives)
|
|
{
|
|
si64 currentPosition = fileStream.tell(); // save filestream position
|
|
|
|
std::string fName = filename;
|
|
boost::to_upper(fName);
|
|
|
|
if(fName.find(".PCX") != std::string::npos)
|
|
extractToFolder("IMAGES", mountPoint, entry);
|
|
else if ((fName.find(".DEF") != std::string::npos ) || (fName.find(".MSK") != std::string::npos) || (fName.find(".FNT") != std::string::npos) || (fName.find(".PAL") != std::string::npos))
|
|
extractToFolder("SPRITES", mountPoint, entry);
|
|
else if ((fName.find(".H3C") != std::string::npos))
|
|
extractToFolder("SPRITES", mountPoint, entry);
|
|
else
|
|
extractToFolder("MISC", mountPoint, entry);
|
|
|
|
fileStream.seek(currentPosition); // restore filestream position
|
|
}
|
|
}
|
|
}
|
|
|
|
void CArchiveLoader::initVIDArchive(const std::string &mountPoint, CFileInputStream & fileStream)
|
|
{
|
|
|
|
// Read count of total files
|
|
CBinaryReader reader(&fileStream);
|
|
fileStream.seek(0);
|
|
ui32 totalFiles = reader.readUInt32();
|
|
|
|
std::set<int> offsets;
|
|
|
|
// Insert entries to list
|
|
for(ui32 i = 0; i < totalFiles; ++i)
|
|
{
|
|
char filename[40];
|
|
reader.read(reinterpret_cast<ui8*>(filename), 40);
|
|
|
|
ArchiveEntry entry;
|
|
entry.name = filename;
|
|
entry.offset = reader.readInt32();
|
|
entry.compressedSize = 0;
|
|
|
|
offsets.insert(entry.offset);
|
|
entries[ResourcePath(mountPoint + entry.name)] = entry;
|
|
}
|
|
offsets.insert(static_cast<int>(fileStream.getSize()));
|
|
|
|
// now when we know position of all files their sizes can be set correctly
|
|
for (auto & entry : entries)
|
|
{
|
|
auto it = offsets.find(entry.second.offset);
|
|
it++;
|
|
entry.second.fullSize = *it - entry.second.offset;
|
|
|
|
if(extractArchives)
|
|
extractToFolder("VIDEO", fileStream, entry.second);
|
|
}
|
|
}
|
|
|
|
void CArchiveLoader::initSNDArchive(const std::string &mountPoint, CFileInputStream & fileStream)
|
|
{
|
|
// Read count of total files
|
|
CBinaryReader reader(&fileStream);
|
|
fileStream.seek(0);
|
|
ui32 totalFiles = reader.readUInt32();
|
|
|
|
// Insert entries to list
|
|
for(ui32 i = 0; i < totalFiles; ++i)
|
|
{
|
|
char filename[40];
|
|
reader.read(reinterpret_cast<ui8*>(filename), 40);
|
|
|
|
// for some reason entries in snd have format NAME\0WAVRUBBISH....
|
|
// and Polish version does not have extension at all
|
|
// we need to replace first \0 with dot and add wav extension manuall - we don't expect other types here anyway
|
|
ArchiveEntry entry;
|
|
entry.name = filename; // till 1st \0
|
|
entry.name += ".wav";
|
|
|
|
entry.offset = reader.readInt32();
|
|
entry.fullSize = reader.readInt32();
|
|
entry.compressedSize = 0;
|
|
entries[ResourcePath(mountPoint + entry.name)] = entry;
|
|
|
|
if(extractArchives)
|
|
extractToFolder("SOUND", fileStream, entry);
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<CInputStream> CArchiveLoader::load(const ResourcePath & resourceName) const
|
|
{
|
|
assert(existsResource(resourceName));
|
|
|
|
const ArchiveEntry & entry = entries.at(resourceName);
|
|
|
|
if (entry.compressedSize != 0) //compressed data
|
|
{
|
|
auto fileStream = std::make_unique<CFileInputStream>(archive, entry.offset, entry.compressedSize);
|
|
|
|
return std::make_unique<CCompressedStream>(std::move(fileStream), false, entry.fullSize);
|
|
}
|
|
else
|
|
{
|
|
return std::make_unique<CFileInputStream>(archive, entry.offset, entry.fullSize);
|
|
}
|
|
}
|
|
|
|
bool CArchiveLoader::existsResource(const ResourcePath & resourceName) const
|
|
{
|
|
return entries.count(resourceName) != 0;
|
|
}
|
|
|
|
std::string CArchiveLoader::getMountPoint() const
|
|
{
|
|
return mountPoint;
|
|
}
|
|
|
|
const std::unordered_map<ResourcePath, ArchiveEntry> & CArchiveLoader::getEntries() const
|
|
{
|
|
return entries;
|
|
}
|
|
|
|
std::unordered_set<ResourcePath> CArchiveLoader::getFilteredFiles(std::function<bool(const ResourcePath &)> filter) const
|
|
{
|
|
std::unordered_set<ResourcePath> foundID;
|
|
|
|
for(const auto & file : entries)
|
|
{
|
|
if (filter(file.first))
|
|
foundID.insert(file.first);
|
|
}
|
|
return foundID;
|
|
}
|
|
|
|
void CArchiveLoader::extractToFolder(const std::string & outputSubFolder, CInputStream & fileStream, const ArchiveEntry & entry, bool absolute) const
|
|
{
|
|
si64 currentPosition = fileStream.tell(); // save filestream position
|
|
|
|
std::vector<ui8> data(entry.fullSize);
|
|
fileStream.seek(entry.offset);
|
|
fileStream.read(data.data(), entry.fullSize);
|
|
|
|
boost::filesystem::path extractedFilePath = createExtractedFilePath(outputSubFolder, entry.name, absolute);
|
|
|
|
// writeToOutputFile
|
|
std::ofstream out(extractedFilePath.string(), std::ofstream::binary);
|
|
out.exceptions(std::ifstream::failbit | std::ifstream::badbit);
|
|
out.write(reinterpret_cast<char *>(data.data()), entry.fullSize);
|
|
|
|
fileStream.seek(currentPosition); // restore filestream position
|
|
}
|
|
|
|
void CArchiveLoader::extractToFolder(const std::string & outputSubFolder, const std::string & mountPoint, ArchiveEntry entry, bool absolute) const
|
|
{
|
|
std::unique_ptr<CInputStream> inputStream = load(ResourcePath(mountPoint + entry.name));
|
|
|
|
entry.offset = 0;
|
|
extractToFolder(outputSubFolder, *inputStream, entry, absolute);
|
|
}
|
|
|
|
boost::filesystem::path createExtractedFilePath(const std::string & outputSubFolder, const std::string & entryName, bool absolute)
|
|
{
|
|
boost::filesystem::path extractionFolderPath = absolute ? outputSubFolder : VCMIDirs::get().userExtractedPath() / outputSubFolder;
|
|
boost::filesystem::path extractedFilePath = extractionFolderPath / entryName;
|
|
|
|
boost::filesystem::create_directories(extractionFolderPath);
|
|
|
|
return extractedFilePath;
|
|
}
|
|
|
|
VCMI_LIB_NAMESPACE_END
|