Added BinaryMemory reader

ChangeLog.md

@@ -4,6 +4,7 @@
 
     [ 20141124 ]
     * LoaderTR2 is starting to populate Room structures
+    * Added BinaryMemory reader
 
     [ 20141123 ]
     * Added texture viewer debug UI

include/utils/binary.h

@@ -12,13 +12,13 @@
 
 class BinaryFile {
   public:
-
+    BinaryFile(const char* f = nullptr);
     ~BinaryFile();
 
-    int open(const char* f);
+    int open(const char* f = nullptr);
 
     long long tell();
-    void seek(long long pos);
+    void seek(long long pos = 0);
 
     int8_t read8();
     uint8_t readU8();
@@ -38,5 +38,35 @@ class BinaryFile {
     std::ifstream file;
 };
 
+class BinaryMemory {
+  public:
+    BinaryMemory(char* d = nullptr);
+
+    int open(char* d = nullptr);
+
+    long long tell();
+    void seek(long long pos = 0);
+
+    int8_t read8();
+    uint8_t readU8();
+
+    int16_t read16();
+    uint16_t readU16();
+
+    int32_t read32();
+    uint32_t readU32();
+
+    int64_t read64();
+    uint64_t readU64();
+
+    float readFloat();
+
+  private:
+    void read(char* d, int c);
+
+    char* data;
+    long long offset;
+};
+
 #endif
 

src/utils/binary.cpp

@@ -8,6 +8,12 @@
 #include "global.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();
@@ -17,6 +23,8 @@ 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);
     }
@@ -139,3 +147,119 @@ int64_t BinaryFile::read64() {
     return ret;
 }
 
+// ----------------------------------------------------------------------------
+
+BinaryMemory::BinaryMemory(char* d) : data(nullptr), offset(0) {
+    int r = open(d);
+    if (r != 0)
+        throw r;
+}
+
+int BinaryMemory::open(char* d) {
+    if (data != nullptr)
+        return 1;
+
+    if (d != nullptr) {
+        data = d;
+        offset = 0;
+    }
+
+    return 0;
+}
+
+long long BinaryMemory::tell() {
+    assert(offset >= 0);
+    return offset;
+}
+
+void BinaryMemory::seek(long long pos) {
+    assert(pos >= 0);
+    offset = pos;
+}
+
+void BinaryMemory::read(char* d, int c) {
+    for (int i = 0; i < c; i++) {
+        d[i] = data[offset + i];
+    }
+    offset += c;
+}
+
+uint8_t BinaryMemory::readU8() {
+    assert(offset >= 0);
+    uint8_t ret;
+    char* c = reinterpret_cast<char*>(&ret);
+    read(c, 1);
+    return ret;
+}
+
+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));
+}
+
+uint64_t BinaryMemory::readU64() {
+    assert(offset >= 0);
+    uint32_t a = readU32();
+    uint32_t b = readU32();
+    return ((uint64_t)a | (uint64_t)(b << 32));
+}
+
+float BinaryMemory::readFloat() {
+    assert(offset >= 0);
+    uint32_t val = readU32();
+    char* a = reinterpret_cast<char*>(&val);
+
+    float ret;
+    char* b = reinterpret_cast<char*>(&ret);
+
+    for (int i = 0; i < 4; i++)
+        b[i] = a[i];
+
+    return ret;
+}
+
+int8_t BinaryMemory::read8() {
+    assert(offset >= 0);
+    int8_t ret;
+    char* p = reinterpret_cast<char*>(&ret);
+    read(p, sizeof(ret));
+    return ret;
+}
+
+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;
+}
+
+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;
+}
+
+int64_t BinaryMemory::read64() {
+    assert(offset >= 0);
+    assert(offset >= 0);
+    int64_t ret;
+    char* p = reinterpret_cast<char*>(&ret);
+    read(p, sizeof(ret));
+    swapByteOrder(p, 8);
+    return ret;
+}
+