PackFile.cpp

//
// Copyright (c) 2020-present Caps Collective & contributors
// Originally authored by Jonathan Moallem (@jonjondev) & Aryeh Zinn (@Raelr)
//
// This code is released under an unmodified zlib license.
// For conditions of distribution and use, please see:
//     https://opensource.org/licenses/Zlib
//

#include "PackFile.h"

#include <utils/FileSystem.h>
#include <utils/Logging.h>

#include <fstream>
#include <iostream>
#include <map>

namespace Siege
{

PackFile::PackFile(const String& filepath)
{
    LoadFromPath(filepath);
}

bool PackFile::LoadFromPath(const String& filepath)
{
    std::ifstream inputFileStream;
    inputFileStream.open(filepath, std::ios::in | std::ios::binary);
    inputFileStream.read(reinterpret_cast<char*>(&header), sizeof(Header));

    body = reinterpret_cast<char*>(malloc(header.bodySize));
    inputFileStream.read(body, (uint32_t) header.bodySize);
    inputFileStream.close();

    char* tocStart = body + header.tocOffset;
    CC_ASSERT(memcmp(tocStart, &PACKER_MAGIC_NUMBER_TOC, 4) == 0, "Failed to find magic number!")

    char* tocCurr = tocStart + PACKER_MAGIC_NUMBER_SIZE;
    char* tocEnd = body + header.bodySize;
    while (tocCurr < tocEnd)
    {
        TocEntry* toc = reinterpret_cast<TocEntry*>(tocCurr);
        if (!toc)
        {
            break;
        }
        tocCurr += toc->GetDataSize();
        entries.emplace(toc->name, toc);
    }
    return true;
}

std::shared_ptr<PackFileData> PackFile::FindData(const String& filepath)
{
    const TocEntry* toc = entries[filepath];
    if (!toc)
    {
        return nullptr;
    }

    uLongf bodyDataSizeUncompressed = toc->dataSize;
    uLongf bodyDataSizeCompressed = toc->dataSizeCompressed;

    PackFileData* packFileData = new (malloc(bodyDataSizeUncompressed)) PackFileData();
    int result = uncompress(reinterpret_cast<Bytef*>(packFileData),
                            &bodyDataSizeUncompressed,
                            reinterpret_cast<Bytef*>(body + toc->dataOffset),
                            bodyDataSizeCompressed);
    CC_ASSERT(result == Z_OK, "Decompression failed for filepath: " + filepath);

    return {packFileData, free};
}

const std::map<String, PackFile::TocEntry*>& PackFile::GetEntries()
{
    return entries;
}

const PackFile::Header& PackFile::GetHeader()
{
    return header;
}

PackFile::TocEntry* PackFile::TocEntry::Create(const String& name,
                                               uint32_t dataOffset,
                                               uint32_t dataSize)
{
    uint32_t nameDataSize = name.Size() + 1;
    void* mem = malloc(sizeof(TocEntry) + nameDataSize);

    TocEntry* tocEntry = new (mem) TocEntry();
    tocEntry->dataOffset = dataOffset;
    tocEntry->dataSize = dataSize;
    strcpy(&tocEntry->name[0], name.Str());

    return tocEntry;
}

} // namespace Siege

namespace std
{

std::ostream& operator<<(std::ostream& os, const Siege::PackFile::MagicNumber& magicNumber)
{
    os << magicNumber.string;
    return os;
}

std::ostream& operator<<(std::ostream& os, const Siege::PackFile::Header& header)
{
    os << "PackFile::Header: {";
    os << "magic: " << header.magic << ", ";
    os << "version: " << header.version << ", ";
    os << "bodySize: " << header.bodySize << ", ";
    os << "tocOffset: " << header.tocOffset << "}";
    return os;
}

std::ostream& operator<<(std::ostream& os, const Siege::PackFile::TocEntry& tocEntry)
{
    os << "PackFile::TocEntry: {";
    os << "dataOffset: " << tocEntry.dataOffset << ", ";
    os << "dataSize: " << tocEntry.dataSize << ", ";
    os << "name: " << tocEntry.name << "}";
    return os;
}

} // namespace std