modeco80
/
jmmt_tools
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

more cleanup 

I am probably going to take a break from this project for at least a little while (probably a week or two, which despite github commit dates, has been about the time I've spent on this project), because even though I got through, I've been feeling really overworked (especially due to the fact I've been.. pressured? to say the least, to do this at a way quicker pace than I really wanted to.), and it's affecting my personal life (in a not-so-good way.).

This doesn't mean I'm completely dropping the project, if I were I'd be offering maintainership to someone else and/or moving/archiving the repository. Rather, I just need a breather.
This commit is contained in:
Lily Tsuru 2022-07-10 02:45:07 -05:00
parent 535f8c0571
commit dc6be07ec9
1 changed files with 49 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
src/tools/jmmt_pack_extractor.cpp
View File

@ -25,8 +25,25 @@ T LameRead(std::istream& is) {
return t;
}
std::string ReadString(std::istream& is) {
std::string s;
char c {};
if(!is)
return "";
while(true) {
c = is.get();
if(c == '\0')
return s;
s.push_back(c);
}
}
/**
* Reads package files.
* Reader for a package file.
*/
struct PackageReader {
@ -44,57 +61,33 @@ struct PackageReader {
void Init() {
is.seekg(-sizeof(jmmt::PackageEofHeader), std::istream::end);
eofHeader = LameRead<jmmt::PackageEofHeader>(is);
// We ideally should be at the end of file after reading the eof header.
auto fileSize = is.tellg();
// Seek to the header start and read the pgrp.
is.seekg(static_cast<std::streamsize>(eofHeader.headerStartOffset), std::istream::beg);
group = LameRead<jmmt::PackageGroup>(is);
group = LameRead<jmmt::PackageGroup>(is);
if(group.magic != jmmt::PackageGroup::TypeMagic) {
fileInvalid = true;
return;
}
// Read the string table, and hash every string out into a map.
// This is used to build our crc->filename mapping for this archive.
// Read the string table, and hash every string in it into a map of CRC to string.
{
is.seekg(static_cast<std::streamsize>(eofHeader.headerStartOffset) + static_cast<std::streamsize>(eofHeader.headerSize), std::istream::beg);
auto ReadString = [&]() {
std::string s;
char c {};
while(true) {
c = is.get();
if(c == '\0')
return s;
s.push_back(c);
}
};
auto l = is.tellg();
// seek ahead of the "header" of the debug info/string table,
// since we don't care about it (we read strings until we "stop". though
// it might be smart to trust it? idk.)
is.seekg(sizeof(uint32_t), std::istream::cur);
while(l != fileSize - static_cast<std::streamsize>(sizeof(eofHeader))) {
auto string = ReadString();
auto string = ReadString(is);
crcToFilename[jmmt::HashString(string.c_str())] = string;
l = is.tellg();
// print out the creation of the crc/filename map for debugging
#if 0
std::printf("%s -> 0x%x\n", string.c_str(), jmmt::HashString(string.c_str()));
#endif
}
}
@ -125,14 +118,8 @@ struct PackageReader {
std::exit(1);
}
// Setup some variables
// If we finished a file, the work buffer is empty.
if(fileWorkBuffer.empty()) {
// TODO: Implement CRC-based fallback, if required.
// It PROBABLY isn't.
currFileName = crcToFilename[currChunk.filenameCrc];
//std::cout << "Reading \"" << currFileName << "\".\n";
@ -143,21 +130,19 @@ struct PackageReader {
std::vector<std::uint8_t> compressedBuffer(currChunk.compressedChunkSize);
// Read into temporary buffer.
auto old = is.tellg();
is.seekg(currChunk.dataOffset, std::istream::beg);
is.read(reinterpret_cast<char*>(compressedBuffer.data()), currChunk.compressedChunkSize);
is.seekg(old, std::istream::beg);
// If the chunk isn't actually compressed, just copy it into the work buffer.
// If it is, decompress it.
// If it is, decompress it into the work buffer.
if(currChunk.compressedChunkSize == currChunk.chunkSize) {
memcpy(fileWorkBuffer.data() + currChunk.blockOffset, compressedBuffer.data(), currChunk.chunkSize);
} else {
jmmt::DecompressLzss(nullptr, compressedBuffer.data(), currChunk.compressedChunkSize, fileWorkBuffer.data() + currChunk.blockOffset);
}
// Seek back to the old place the stream was before reading and decompress
is.seekg(old, std::istream::beg);
}
/**
@ -169,7 +154,7 @@ struct PackageReader {
ReadFileChunk();
// Read additional chunks required to complete the file,
// if we (, well) have to.
// if we (well) have to.
for(auto i = 0; i < chunksLeft; ++i) {
//std::cout << "Reading additional chunk " << i + 1 << '/' << chunksLeft << ".\n";
ReadFileChunk();
@ -205,12 +190,19 @@ struct PackageReader {
// Set to true on any invalid file data.
bool fileInvalid = false;
/**
* EOF header.
*/
jmmt::PackageEofHeader eofHeader {};
/**
* Group header.
*/
jmmt::PackageGroup group {};
/**
* CRC->sensible filename map.
* CRC->sensible string map.
* Might be worth renaming.
*/
std::map<jmmt::crc32_t, std::string> crcToFilename;
@ -219,16 +211,21 @@ struct PackageReader {
*/
uint32_t chunksLeft {};
// The name of the file we are processing.
/**
* Filename from crcToFilename of the file we're reading.
*/
std::string currFileName;
// The current chunk the reader is reading.
/**
* The current chunk the reader is reading.
*/
jmmt::PackageFile currChunk {};
// File-sized work buffer used to store the file
// we're currently working on.
//
// Freed when a file is extracted completely (after being copied).
/**
* Work buffer used to store the file we are currently trying to read.
*
* Freed when a file is extracted.
*/
std::vector<std::uint8_t> fileWorkBuffer;
};
@ -258,6 +255,8 @@ int main(int argc, char** argv) {
reader.ReadFiles([&](const auto& file) {
auto outpath = path / file.filename;
if(!fs::exists(outpath.parent_path()))
fs::create_directories(outpath.parent_path());
std::ofstream ofs(outpath.string(), std::ofstream::binary);