ChunkReader.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <string>
#include <vector>
 
namespace ChunkReader
{
#pragma pack(push, 1)
    struct ChunkHeader
    {
        char     magic[4];
        uint32_t size;
    };
#pragma pack(pop)
 
    struct ChunkInfo
    {
        std::string  magic;    
        uint32_t     start;    
        uint32_t     size;     
    };
 
    inline const std::vector<std::string>& knownFirstChunks()
    {
        static const std::vector<std::string> chunks =
        {
            // M2 model chunks
            "PFID", "SFID", "AFID", "BFID", "MD21",
            "TXAC", "EXPT", "EXP2", "PABC", "PADC",
            "PSBC", "PEDC", "SKID", "TXID", "LDV1",
            // Animation / skeleton chunks
            "AFM2", "AFSA", "AFSB",
            "SKL1", "SKA1", "SKB1", "SKS1", "SKPD",
        };
        return chunks;
    }
 
    inline bool isChunked(const unsigned char* data, size_t dataSize)
    {
        if (!data || dataSize < sizeof(ChunkHeader))
            return false;
 
        ChunkHeader header{};
        std::memcpy(&header, data, sizeof(ChunkHeader));
 
        const std::string magic(header.magic, 4);
        const auto& known = knownFirstChunks();
        if (std::find(known.begin(), known.end(), magic) == known.end())
            return false;
 
        // The first chunk's data must fit within the file.
        return (sizeof(ChunkHeader) + header.size) <= dataSize;
    }
 
    inline std::vector<ChunkInfo> parse(const unsigned char* data, size_t dataSize)
    {
        std::vector<ChunkInfo> result;
 
        if (!data || dataSize < sizeof(ChunkHeader))
            return result;
 
        uint32_t offset = 0;
        while (offset + sizeof(ChunkHeader) <= dataSize)
        {
            ChunkHeader header{};
            std::memcpy(&header, data + offset, sizeof(ChunkHeader));
            offset += sizeof(ChunkHeader);
 
            // If the chunk data would exceed the buffer, stop.
            if (offset + header.size > dataSize)
                break;
 
            ChunkInfo info;
            info.magic = std::string(header.magic, 4);
            info.start = offset;
            info.size  = header.size;
            result.push_back(std::move(info));
 
            offset += header.size;
        }
 
        return result;
    }
}