LoaderTR2 tries to load external SFX file

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141126 ]
+    * Reduced code duplication for BinaryFile/BinaryMemory
+    * LoaderTR2 tries to load an external SFX file
+
     [ 20141124 ]
     * LoaderTR2 is starting to populate Room structures
     * Added BinaryMemory reader

include/Exception.h

 
 class Exception : std::runtime_error {
   public:
-    Exception(const char* what);
-    Exception(const std::string& what);
+    Exception(std::string what);
 
     static std::string getLastException();
 

include/loader/LoaderTR2.h

     void loadSoundMap();
     void loadSoundDetails();
     void loadSampleIndices();
+
+    void loadExternalSoundFile(std::string f);
 };
 
 #endif

include/utils/binary.h

 #define _UTILS_BINARY_H_
 
 #include <fstream>
+#include <string>
 
-class BinaryFile {
+class BinaryReader {
   public:
-    BinaryFile(const char* f = nullptr);
-    ~BinaryFile();
+    virtual ~BinaryReader();
 
-    int open(const char* f = nullptr);
+    virtual long long tell() = 0;
+    virtual void seek(long long pos = 0) = 0;
+    virtual bool eof() = 0;
 
-    long long tell();
-    void seek(long long pos = 0);
+    virtual int8_t read8();
+    virtual uint8_t readU8();
 
-    int8_t read8();
-    uint8_t readU8();
+    virtual int16_t read16();
+    virtual uint16_t readU16();
 
-    int16_t read16();
-    uint16_t readU16();
+    virtual int32_t read32();
+    virtual uint32_t readU32();
 
-    int32_t read32();
-    uint32_t readU32();
+    virtual int64_t read64();
+    virtual uint64_t readU64();
 
-    int64_t read64();
-    uint64_t readU64();
-
-    float readFloat();
+    virtual float readFloat();
 
   private:
-    std::ifstream file;
+    virtual void read(char* d, int c) = 0;
 };
 
-class BinaryMemory {
+class BinaryFile : public BinaryReader {
   public:
-    BinaryMemory(char* d = nullptr);
+    BinaryFile(std::string f = "");
+    virtual ~BinaryFile();
 
-    int open(char* d = nullptr);
+    int open(std::string f = "");
 
-    long long tell();
-    void seek(long long pos = 0);
+    virtual long long tell();
+    virtual void seek(long long pos = 0);
+    virtual bool eof();
 
-    int8_t read8();
-    uint8_t readU8();
+  private:
+    virtual void read(char* d, int c);
 
-    int16_t read16();
-    uint16_t readU16();
+    std::ifstream file;
+};
 
-    int32_t read32();
-    uint32_t readU32();
+class BinaryMemory : public BinaryReader {
+  public:
+    BinaryMemory(const char* d = nullptr, long long max = -1);
+    virtual ~BinaryMemory();
 
-    int64_t read64();
-    uint64_t readU64();
+    int open(const char* d = nullptr, long long max = -1);
 
-    float readFloat();
+    virtual long long tell();
+    virtual void seek(long long pos = 0);
+    virtual bool eof();
 
   private:
-    void read(char* d, int c);
+    virtual void read(char* d, int c);
 
-    char* data;
+    const char* data;
     long long offset;
+    long long max;
 };
 
 #endif

src/Exception.cpp

 
 std::string Exception::lastException("No custom exception since start!");
 
-Exception::Exception(const char* what) : runtime_error(what) {
-    lastException = what;
-}
-
-Exception::Exception(const std::string& what) : runtime_error(what) {
+Exception::Exception(std::string what) : runtime_error(what) {
     lastException = what;
 }
 

src/loader/LoaderTR2.cpp

 }
 
 int LoaderTR2::load(std::string f) {
-    if (file.open(f.c_str()) != 0) {
+    if (file.open(f) != 0) {
         return 1; // Could not open file
     }
 
     loadSoundDetails();
     loadSampleIndices();
 
+    loadExternalSoundFile(f);
+
     return 0; // TODO Not finished with implementation!
 }
 
     }
 
     uint32_t numMeshPointers = file.readU32();
-    std::vector<uint32_t> meshPointers;
-    for (unsigned int i = 0; i < numMeshPointers; i++) {
-        meshPointers.push_back(file.readU32());
+
+    if ((numMeshData == 0) || (numMeshPointers == 0)) {
+        //! \fixme debug level regulating output?
+        getLog() << "LoaderTR2: No mesh data found!" << Log::endl;
+        return;
     }
 
-    // TODO interpret the buffered mesh data
+    for (unsigned int i = 0; i < numMeshPointers; i++) {
+        uint32_t meshPointer = file.readU32();
+        char* tmpPtr = reinterpret_cast<char*>(&buffer[meshPointer]);
+        BinaryMemory mem(tmpPtr, numMeshData - meshPointer);
+
+        // TODO interpret the buffered mesh data
+    }
 }
 
 void LoaderTR2::loadMoveables() {
     }
 
     // TODO store zones somewhere
+
+    if ((numBoxes > 0) || (numOverlaps > 0))
+        getLog() << "LoaderTR2: Found NPC NavigationHints, not yet implemented!" << Log::endl;
 }
 
 void LoaderTR2::loadAnimatedTextures() {
 
         // TODO store cinematic frames somewhere
     }
+
+    if (numCinematicFrames > 0)
+        getLog() << "LoaderTR2: Found CinematicFrames, not yet implemented!" << Log::endl;
 }
 
 void LoaderTR2::loadDemoData() {
         file.readU8();
 
     // TODO store demo data somewhere, find out meaning
+    if (numDemoData > 0)
+        getLog() << "LoaderTR2: Found DemoData, not yet implemented!" << Log::endl;
 }
 
 void LoaderTR2::loadSoundMap() {
     // TODO store sample indices somewhere
 }
 
+void LoaderTR2::loadExternalSoundFile(std::string f) {
+    size_t dir = f.find_last_of("/\\");
+    if (dir != std::string::npos) {
+        f.replace(dir + 1, std::string::npos, "MAIN.SFX");
+    } else {
+        f = "MAIN.SFX";
+    }
+
+    BinaryFile sfx;
+    if (sfx.open(f) != 0) {
+        getLog() << "LoaderTR2: Can't open \"" << f << "\"!" << Log::endl;
+        return;
+    }
+
+    int riffCount = 0;
+    bool done = false;
+    while (!done) {
+        char test[5];
+        test[4] = '\0';
+        for (int i = 0; i < 4; i++)
+            test[i] = sfx.read8();
+
+        if (std::string("RIFF") != std::string(test)) {
+            getLog() << "LoaderTR2: External SFX invalid! (" << riffCount
+                << ", \"" << test << "\" != \"RIFF\")" << Log::endl;
+            return;
+        }
+
+        uint32_t riffSize = sfx.readU32();
+
+        for (int i = 0; i < 4; i++)
+            test[i] = sfx.read8();
+
+        if (std::string("WAVE") != std::string(test)) {
+            getLog() << "LoaderTR2: External SFX invalid! (" << riffCount
+                << ", \"" << test << "\" != \"WAVE\")" << Log::endl;
+            return;
+        }
+
+        // TODO load riff somehow somewhere
+
+        // riffSize is (fileLength - 8)
+        sfx.seek(sfx.tell() + riffSize - 4);
+        riffCount++;
+
+        if (sfx.eof()) {
+            done = true;
+            getLog() << "LoaderTR2: Found " << riffCount << " SoundSamples" << Log::endl;
+        }
+    }
+}
+

src/utils/binary.cpp

  * \author xythobuz
  */
 
+#include <sstream>
+
 #include "global.h"
+#include "Exception.h"
 #include "utils/binary.h"
 
-BinaryFile::BinaryFile(const char* f) {
-    int r = open(f);
-    if (r != 0)
-        throw r;
-}
-
-BinaryFile::~BinaryFile() {
-    if (file.is_open())
-        file.close();
-}
-
-int BinaryFile::open(const char* f) {
-    if (file.is_open()) {
-        return 1;
-    } else {
-        if (f == nullptr)
-            return 0;
-        file.open(f, std::ios_base::in | std::ios_base::binary);
-        return (file ? 0 : 1);
-    }
-}
-
-long long BinaryFile::tell() {
-    assert(file.is_open());
-    return file.tellg();
-}
-
-void BinaryFile::seek(long long pos) {
-    assert(file.is_open());
-    file.seekg(pos);
+BinaryReader::~BinaryReader() {
 }
 
-uint8_t BinaryFile::readU8() {
-    assert(file.is_open());
-    assert(file.good());
+uint8_t BinaryReader::readU8() {
     uint8_t ret;
     char* c = reinterpret_cast<char*>(&ret);
-    file.read(c, 1);
+    read(c, 1);
     return ret;
 }
 
-uint16_t BinaryFile::readU16() {
-    assert(file.is_open());
-    assert(file.good());
-    uint8_t a = readU8();
-    uint8_t b = readU8();
-    return ((uint16_t)a | (uint16_t)(b << 8));
+uint16_t BinaryReader::readU16() {
+    uint16_t a = readU8();
+    uint16_t b = readU8();
+    return (a | (b << 8));
 }
 
-uint32_t BinaryFile::readU32() {
-    assert(file.is_open());
-    assert(file.good());
-    uint16_t a = readU16();
-    uint16_t b = readU16();
-    return ((uint32_t)a | (uint32_t)(b << 16));
+uint32_t BinaryReader::readU32() {
+    uint32_t a = readU16();
+    uint32_t b = readU16();
+    return (a | (b << 16));
 }
 
-uint64_t BinaryFile::readU64() {
-    assert(file.is_open());
-    assert(file.good());
-    uint32_t a = readU32();
-    uint32_t b = readU32();
-    return ((uint64_t)a | ((uint64_t)b << 32));
+uint64_t BinaryReader::readU64() {
+    uint64_t a = readU32();
+    uint64_t b = readU32();
+    return (a | (b << 32));
 }
 
-float BinaryFile::readFloat() {
-    assert(file.is_open());
-    assert(file.good());
+float BinaryReader::readFloat() {
     uint32_t val = readU32();
     char* a = reinterpret_cast<char*>(&val);
 
      *  without having to detect the endianness at run-time?
      */
     const int bigendiandetection = 1;
-#define ISBIGENDIAN() ((*(char *)&bigendiandetection) == 0)
+#define ISBIGENDIAN() ((*reinterpret_cast<const char *>(&bigendiandetection)) == 0)
 
     void swapByteOrder(char* d, unsigned int n) {
         if (ISBIGENDIAN()) {
     }
 }
 
-int8_t BinaryFile::read8() {
-    assert(file.is_open());
-    assert(file.good());
+int8_t BinaryReader::read8() {
     int8_t ret;
     char* p = reinterpret_cast<char*>(&ret);
-    file.read(p, sizeof(ret));
+    read(p, sizeof(ret));
     return ret;
 }
 
-int16_t BinaryFile::read16() {
-    assert(file.is_open());
-    assert(file.good());
+int16_t BinaryReader::read16() {
     int16_t ret;
     char* p = reinterpret_cast<char*>(&ret);
-    file.read(p, sizeof(ret));
+    read(p, sizeof(ret));
     swapByteOrder(p, 2);
     return ret;
 }
 
-int32_t BinaryFile::read32() {
-    assert(file.is_open());
-    assert(file.good());
+int32_t BinaryReader::read32() {
     int32_t ret;
     char* p = reinterpret_cast<char*>(&ret);
-    file.read(p, sizeof(ret));
+    read(p, sizeof(ret));
     swapByteOrder(p, 4);
     return ret;
 }
 
-int64_t BinaryFile::read64() {
-    assert(file.is_open());
-    assert(file.good());
+int64_t BinaryReader::read64() {
     int64_t ret;
     char* p = reinterpret_cast<char*>(&ret);
-    file.read(p, sizeof(ret));
+    read(p, sizeof(ret));
     swapByteOrder(p, 8);
     return ret;
 }
 
 // ----------------------------------------------------------------------------
 
-BinaryMemory::BinaryMemory(char* d) : data(nullptr), offset(0) {
-    int r = open(d);
+BinaryFile::BinaryFile(std::string f) {
+    int r = open(f);
     if (r != 0)
         throw r;
 }
 
-int BinaryMemory::open(char* d) {
-    if (data != nullptr)
-        return 1;
+BinaryFile::~BinaryFile() {
+    if (file.is_open())
+        file.close();
+}
 
-    if (d != nullptr) {
-        data = d;
-        offset = 0;
+int BinaryFile::open(std::string f) {
+    if (file.is_open()) {
+        return 1;
+    } else {
+        if (f == "")
+            return 0;
+        file.open(f, std::ios_base::in | std::ios_base::binary);
+        return (file ? 0 : 1);
     }
-
-    return 0;
 }
 
-long long BinaryMemory::tell() {
-    assert(offset >= 0);
-    return offset;
+long long BinaryFile::tell() {
+    assert(file.is_open());
+    return file.tellg();
 }
 
-void BinaryMemory::seek(long long pos) {
-    assert(pos >= 0);
-    offset = pos;
+void BinaryFile::seek(long long pos) {
+    assert(file.is_open());
+    file.seekg(pos);
 }
 
-void BinaryMemory::read(char* d, int c) {
-    for (int i = 0; i < c; i++) {
-        d[i] = data[offset + i];
-    }
-    offset += c;
+bool BinaryFile::eof() {
+    file.peek();
+    return file.eof();
 }
 
-uint8_t BinaryMemory::readU8() {
-    assert(offset >= 0);
-    uint8_t ret;
-    char* c = reinterpret_cast<char*>(&ret);
-    read(c, 1);
-    return ret;
+void BinaryFile::read(char* d, int c) {
+    assert(file.is_open());
+    assert(file.good());
+    file.read(d, c);
 }
 
-uint16_t BinaryMemory::readU16() {
-    assert(offset >= 0);
-    uint8_t a = readU8();
-    uint8_t b = readU8();
-    return ((uint16_t)a | (uint16_t)(b << 8));
-}
+// ----------------------------------------------------------------------------
 
-uint32_t BinaryMemory::readU32() {
-    assert(offset >= 0);
-    uint16_t a = readU16();
-    uint16_t b = readU16();
-    return ((uint32_t)a | (uint32_t)(b << 16));
+BinaryMemory::BinaryMemory(const char* d, long long m) : data(nullptr), offset(0), max(-1) {
+    int r = open(d, m);
+    if (r != 0)
+        throw r;
 }
 
-uint64_t BinaryMemory::readU64() {
-    assert(offset >= 0);
-    uint32_t a = readU32();
-    uint32_t b = readU32();
-    return ((uint64_t)a | (uint64_t)(b << 32));
+BinaryMemory::~BinaryMemory() {
 }
 
-float BinaryMemory::readFloat() {
-    assert(offset >= 0);
-    uint32_t val = readU32();
-    char* a = reinterpret_cast<char*>(&val);
-
-    float ret;
-    char* b = reinterpret_cast<char*>(&ret);
+int BinaryMemory::open(const char* d, long long m) {
+    if (data != nullptr)
+        return 1;
 
-    for (int i = 0; i < 4; i++)
-        b[i] = a[i];
+    if (d != nullptr) {
+        data = d;
+        offset = 0;
+        max = m;
+    }
 
-    return ret;
+    return 0;
 }
 
-int8_t BinaryMemory::read8() {
+long long BinaryMemory::tell() {
     assert(offset >= 0);
-    int8_t ret;
-    char* p = reinterpret_cast<char*>(&ret);
-    read(p, sizeof(ret));
-    return ret;
+    return offset;
 }
 
-int16_t BinaryMemory::read16() {
-    assert(offset >= 0);
-    int16_t ret;
-    char* p = reinterpret_cast<char*>(&ret);
-    read(p, sizeof(ret));
-    swapByteOrder(p, 2);
-    return ret;
+void BinaryMemory::seek(long long pos) {
+    assert(pos >= 0);
+    offset = pos;
 }
 
-int32_t BinaryMemory::read32() {
-    assert(offset >= 0);
-    int32_t ret;
-    char* p = reinterpret_cast<char*>(&ret);
-    read(p, sizeof(ret));
-    swapByteOrder(p, 4);
-    return ret;
+bool BinaryMemory::eof() {
+    return (offset > max);
 }
 
-int64_t BinaryMemory::read64() {
-    assert(offset >= 0);
+void BinaryMemory::read(char* d, int c) {
     assert(offset >= 0);
-    int64_t ret;
-    char* p = reinterpret_cast<char*>(&ret);
-    read(p, sizeof(ret));
-    swapByteOrder(p, 8);
-    return ret;
+    assert(c > 0);
+    if ((offset + c) > max) {
+        std::ostringstream ss;
+        ss << "BinaryMemory read out of bounds ("
+            << offset << " + " << c << " > " << max;
+        throw new Exception(ss.str());
+    }
+
+    for (int i = 0; i < c; i++) {
+        d[i] = data[offset + i];
+    }
+    offset += c;
 }