Major changes. Struct realignment, future-proofed, spec changes.

Author: ef1500

.gitignore

@@ -1 +1,15 @@
-.vscode/
+.vscode/
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+CMakeUserPresets.json
+/build
+CMakeLists.txt

src/bbfenc.cpp

@@ -1,3 +1,5 @@
+#define NOMINMAX
+
 #include "libbbf.h"
 #include "xxhash.h"
 #include <iostream>
@@ -133,13 +135,23 @@ class BBFReader
     {
         if (!mmap.map(path))
             return false;
+        
+        // Basic size check
         if (mmap.size < sizeof(BBFHeader) + sizeof(BBFFooter))
             return false;
 
+        // Read the fixed-size part of the header first
         std::memcpy(&header, mmap.data, sizeof(BBFHeader));
+        
         if (std::memcmp(header.magic, "BBF1", 4) != 0)
             return false;
 
+        // FUTURE PROOFING: 
+        // If header.headerLen > sizeof(BBFHeader), we know there is extra data 
+        // in the header we should ignore. We don't need to do anything right now 
+        // because we read assets via absolute offsets, but it's good to know.
+
+        // Read Footer
         std::memcpy(&footer, (uint8_t *)mmap.data + mmap.size - sizeof(BBFFooter), sizeof(BBFFooter));
         if (std::memcmp(footer.magic, "BBF1", 4) != 0)
             return false;
@@ -574,9 +586,13 @@ int main(int argc, char *argv[])
             for (uint32_t i = start; i < end; ++i)
             {
                 const auto &asset = assets[pages[i].assetIndex];
-                std::string outPath = (fs::path(outDir) / ("p" + std::to_string(i + 1) + ((asset.type == 1) ? ".avif" : ".png"))).string();
 
-                // Optimized: Direct write from mapped memory
+                // FIX: Use the library function to get the extension
+                // This automatically handles PNG, JPG, AVIF, JXL, etc.
+                std::string ext = MediaTypeToStr(asset.type);
+
+                std::string outPath = (fs::path(outDir) / ("p" + std::to_string(i + 1) + ext)).string();
+
                 std::ofstream ofs(outPath, std::ios::binary);
                 ofs.write((const char *)reader.mmap.data + asset.offset, asset.length);
             }
@@ -686,7 +702,8 @@ int main(int argc, char *argv[])
         for (uint32_t i = 0; i < manifest.size(); ++i)
         {
             std::string ext = fs::path(manifest[i].path).extension().string();
-            uint8_t type = (ext == ".avif" || ext == ".AVIF") ? 1 : 2;
+            BBFMediaType mediaType = detectTypeFromExtension(ext);
+            uint8_t type = static_cast<uint8_t>(mediaType);
             builder.addPage(manifest[i].path, type);
             fileToPage[manifest[i].filename] = i;
         }

src/libbbf.cpp

@@ -3,6 +3,9 @@
 
 #include <iostream>
 #include <vector>
+#include <algorithm>
+#include <string>
+#include <cctype>
 
 BBFBuilder::BBFBuilder(const std::string& outputFilename) : currentOffset(0)
 {
@@ -22,7 +25,9 @@ BBFBuilder::BBFBuilder(const std::string& outputFilename) : currentOffset(0)
     header.magic[1] = 'B';
     header.magic[2] = 'F';
     header.magic[3] = '1';
-    header.version = 1;
+    header.version = 2;
+    header.flags = 0; // reserved for now as well.
+    header.headerLen = sizeof(BBFHeader);
     header.reserved = 0; // Reserved for future expansions
 
     // Write the header
@@ -92,16 +97,19 @@ bool BBFBuilder::addPage(const std::string& imagePath, uint8_t type, uint32_t fl
         // No dupe found. create a new asset.
         alignPadding(); // start by allocating necessary padding.
 
-        BBFAssetEntry newAsset;
+        BBFAssetEntry newAsset = {0};
         newAsset.offset = currentOffset;
         newAsset.length = size;
+        newAsset.decodedLength = size;
         newAsset.xxh3Hash = hash;
         newAsset.type = type;
+        newAsset.flags = 0; // no flags yet.
 
-        for ( int i = 0; i < 7; i++ )
-        {
-            newAsset.reserved[i] = 0; // Add in the reserved bytes.
-        }
+        // set reserved equal to zero
+        //newAsset.reserved[4] = {0};
+
+        // same for padding
+        //newAsset.padding[7] = {0};
 
         fileStream.write(buffer.data(), size);
         currentOffset += size;
@@ -160,8 +168,6 @@ bool BBFBuilder::addMetadata(const std::string& key, const std::string& value)
 
 bool BBFBuilder::finalize()
 {
-    uint64_t indexStart = currentOffset;
-
     // Initialize XXH3 State
     XXH3_state_t* const state = XXH3_createState();
     if (state == nullptr) return false;
@@ -178,6 +184,7 @@ bool BBFBuilder::finalize()
     //write footer
     BBFFooter footer;
     footer.stringPoolOffset = currentOffset;
+    footer.extraOffset = 0; // set the extraOffset to 0 since we aren't using it.
 
     //fileStream.write(stringPool.data(), stringPool.size());
     //currentOffset += stringPool.size();
@@ -230,4 +237,42 @@ bool BBFBuilder::finalize()
     fileStream.write(reinterpret_cast<char*>(&footer), sizeof(BBFFooter));
     fileStream.close();
     return true;
+}
+
+BBFMediaType detectTypeFromExtension(const std::string &extension) 
+{
+    std::string ext = extension;
+    std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
+
+    if (ext == ".png") return BBFMediaType::PNG;
+    if (ext == ".jpg" || ext == ".jpeg") return BBFMediaType::JPG;
+    if (ext == ".avif") return BBFMediaType::AVIF;
+    if (ext == ".webp") return BBFMediaType::WEBP;
+    if (ext == ".jxl") return BBFMediaType::JXL;
+    if (ext == ".bmp") return BBFMediaType::BMP;
+    if (ext == ".gif") return BBFMediaType::GIF;
+    if (ext == ".tiff") return BBFMediaType::TIFF;
+    
+    return BBFMediaType::UNKNOWN;
+}
+
+std::string MediaTypeToStr(uint8_t type)
+{
+    BBFMediaType mediaType = static_cast<BBFMediaType>(type);
+
+    switch (mediaType)
+    {
+        case BBFMediaType::AVIF: return ".avif";
+        case BBFMediaType::PNG:  return ".png";
+        case BBFMediaType::JPG:  return ".jpg";
+        case BBFMediaType::WEBP: return ".webp";
+        case BBFMediaType::JXL:  return ".jxl";
+        case BBFMediaType::BMP:  return ".bmp";
+        case BBFMediaType::GIF:  return ".gif";
+        case BBFMediaType::TIFF: return ".tiff";
+
+        case BBFMediaType::UNKNOWN: 
+        default: 
+            return ".png"; 
+    }
 }

src/libbbf.h

@@ -7,13 +7,31 @@
 #include <fstream>
 #include <unordered_map>
 
-#pragma pack(push, 1)
+// ENUM for filetypes
+enum class BBFMediaType: uint8_t
+{
+    UNKNOWN = 0x00,
+    AVIF = 0x01,
+    PNG = 0x02,
+    WEBP = 0x03,
+    JXL = 0x04,
+    BMP = 0x05,
+    GIF = 0x07,
+    TIFF = 0x08,
+    JPG = 0x09
+};
 
+BBFMediaType detectTypeFromExtension(const std::string &extension);
+std::string MediaTypeToStr(uint8_t type);
+
+#pragma pack(push, 1)
 
 struct BBFHeader
 {
     uint8_t magic[4]; // 0x42424631 (BBF1)
-    uint8_t version; // 1
+    uint8_t version; // Major version, 1
+    uint32_t flags; // Reserved for now
+    uint16_t headerLen; // Size of header
     uint64_t reserved; // set to 0
 };
 
@@ -22,9 +40,14 @@ struct BBFAssetEntry
 {
     uint64_t offset; // Offset of the page
     uint64_t length; // length of the file
+    uint64_t decodedLength;
     uint64_t xxh3Hash; // Hash of image
+
     uint8_t type; // 0x01 - AVIF, 0x02 PNG, 0x03 JPG ... etc.
-    uint8_t reserved[7]; // padding. Could use this in the future.
+    uint8_t flags; // i.e. encryped or compressed
+
+    uint8_t padding[6]; // 64 BYTE struct
+    uint64_t reserved[3]; // Reserved. Future proofing.
 };
 
 // Create reading order
@@ -49,6 +72,16 @@ struct BBFMetadata
     uint32_t valOffset; // offset into String pool
 };
 
+// BBF Extension table (Generic, not used)
+struct BBFExpansionHeader
+{
+    uint32_t extensionType;
+    uint32_t padding;
+    uint64_t offset;
+    uint64_t flags;
+    uint64_t length;
+};
+
 // Create the footer
 struct BBFFooter
 {
@@ -65,6 +98,8 @@ struct BBFFooter
     uint64_t metaTableOffset;
     uint32_t keyCount;
 
+    uint64_t extraOffset; // Point to an extra table in the future if we need.
+
     uint64_t indexHash; // Integrity check, hash of everything between index start and the current position.
     uint8_t magic[4]; // 0x42424631 (BBF1) (Verification)
 };
@@ -74,7 +109,7 @@ struct BBFFooter
 class BBFBuilder
 {
     public:
-        BBFBuilder(const std::string &outputFilemame);
+        BBFBuilder(const std::string &outputFilename);
         ~BBFBuilder();
 
         bool addPage(const std::string& imagePath, uint8_t type, uint32_t flags = 0);