Lotta changes

This commit adds the `XAsset` constructor to the `XAudioXmaDataInfo` class.

ai-commit.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+set -e
+
+# 1. Stage everything
+git add -A
+
+# 2. Get list of staged files
+FILES=$(git diff --cached --name-only)
+
+if [ -z "$FILES" ]; then
+  echo "No changes to commit."
+  exit 0
+fi
+
+# 3. Loop file by file
+for FILE in $FILES; do
+  # Get diff for this file
+  DIFF=$(git diff --cached -- "$FILE")
+
+  if [ -z "$DIFF" ]; then
+    continue
+  fi
+
+  # Ask Ollama for a commit message describing this file change
+  MSG=$(echo "$DIFF" | ollama run gemma3 \
+    "You are a commit bot. Write a SHORT, clear, concise Git commit message for changes in file: $FILE.
+Only output the commit message, nothing else.
+Diff:
+$DIFF")
+
+  # Commit just this file with its message
+  git commit -m "$MSG" -- "$FILE"
+
+  echo "✅ Committed $FILE with message:"
+  echo "$MSG"
+done

app/app.pro

@@ -13,9 +13,9 @@ FORMS += $$files($$PWD/*.ui)
 RESOURCES += ../data/data.qrc
 
 LIBS += \
-    #-L$$PWD/../third_party/devil_sdk/lib/ -lDevIL -lILU -lILUT \
-    #-L$$PWD/../third_party/zlib/lib/ -lzlib \
-    #-L$$PWD/../third_party/xbox_sdk/lib -lxcompress64 \
+    -L$$PWD/../third_party/devil_sdk/lib/ -lDevIL -lILU -lILUT \
+    -L$$PWD/../third_party/zlib/lib/ -lzlib \
+    -L$$PWD/../third_party/xbox_sdk/lib -lxcompress64 \
     -L$$OUT_PWD/../libs/ -lcore \
     -L$$OUT_PWD/../libs/ -lxassets\
     -L$$OUT_PWD/../libs/ -lcompression \
@@ -27,9 +27,9 @@ LIBS += \
     -L$$OUT_PWD/../libs/ -lzonefile
 
 INCLUDEPATH += \
-    #$$PWD/../third_party/devil_sdk/include/ \
-    #$$PWD/../third_party/zlib/include \
-    #$$PWD/../third_party/xbox_sdk/include \
+    $$PWD/../third_party/devil_sdk/include/ \
+    $$PWD/../third_party/zlib/include \
+    $$PWD/../third_party/xbox_sdk/include \
     $$PWD/../libs/core \
     $$PWD/../libs/compression \
     $$PWD/../libs/encryption \
@@ -41,9 +41,9 @@ INCLUDEPATH += \
     $$PWD/../libs/zonefile
 
 DEPENDPATH += \
-    #$$PWD/../third_party/devil_sdk/include/ \
-    #$$PWD/../third_party/zlib/include \
-    #$$PWD/../third_party/xbox_sdk/include \
+    $$PWD/../third_party/devil_sdk/include/ \
+    $$PWD/../third_party/zlib/include \
+    $$PWD/../third_party/xbox_sdk/include \
     $$PWD/../libs/core \
     $$PWD/../libs/compression \
     $$PWD/../libs/encryption \

app/mainwindow.cpp

@@ -789,7 +789,7 @@ int MainWindow::LoadFile_IPAK(const QString aFilePath) {
 
     QVector<IPAKIndexEntry> entries = QVector<IPAKIndexEntry>();
     QVector<IPAKSection> sections = QVector<IPAKSection>(header.sectionCount);
-    for (uint i = 0; i < header.sectionCount; i++) {
+    for (quint32 i = 0; i < header.sectionCount; i++) {
         IPAKSection currentSection;
         stream >> currentSection;
         sections << currentSection;
@@ -811,7 +811,7 @@ int MainWindow::LoadFile_IPAK(const QString aFilePath) {
                      << "      - Count: " << chunkHeader.count << "\n"
                      << "      - Offset: " << chunkHeader.offset;
 
-            for (uint j = 0; j < 31; j++) {
+            for (quint32 j = 0; j < 31; j++) {
                 IPAKDataChunkCommand command;
                 stream >> command;
                 if (!command.size) { continue; }
@@ -821,7 +821,7 @@ int MainWindow::LoadFile_IPAK(const QString aFilePath) {
                          << "          - Compressed: " << command.compressed;
 
             }
-            for (uint j = 0; j < chunkHeader.count; j++) {
+            for (quint32 j = 0; j < chunkHeader.count; j++) {
                 auto command = chunkHeader.commands[j];
 
                 qDebug() << "Reading from " << stream.device()->pos();
@@ -846,7 +846,7 @@ int MainWindow::LoadFile_IPAK(const QString aFilePath) {
             stream.skipRawData(sizeof(quint32) * (31 - chunkHeader.count));
             qDebug() << stream.device()->pos();
         } else if (sectionType == "Index") {
-            for (uint j = 0; j < currentSection.itemCount; j++) {
+            for (quint32 j = 0; j < currentSection.itemCount; j++) {
                 IPAKIndexEntry entry;
                 stream >> entry;
 

app/materialviewer.cpp

@@ -3,19 +3,27 @@
 
 MaterialViewer::MaterialViewer(QWidget *parent)
     : QWidget(parent)
-    , ui(new Ui::MaterialViewer) {
+    , ui(new Ui::MaterialViewer)
+{
     ui->setupUi(this);
 }
 
-MaterialViewer::~MaterialViewer() {
+MaterialViewer::~MaterialViewer()
+{
     delete ui;
 }
 
-QString ToHexStr(quint32 in) {
+QString ToHexStr(quint32 in)
+{
     return QString("%1").arg(in, 8, 16, QChar('0')).toUpper();
 }
 
-void MaterialViewer::SetMaterial(const XMaterial* aMaterial) {
+void MaterialViewer::SetMaterial(const XMaterial* aMaterial)
+{
+    Q_UNUSED(aMaterial);
+
+    // TODO: Fill in MaterialViewer::SetMaterial
+
     // ui->lineEdit_NamePtr->setText(ToHexStr(aMaterial->namePtr));
     // ui->lineEdit_Name->setText(aMaterial->name);
     // ui->lineEdit_RefPtr->setText(ToHexStr(aMaterial->refNamePtr));

app/rumblegraphviewer.cpp

@@ -22,7 +22,7 @@ RumbleGraphViewer::~RumbleGraphViewer() {
 void RumbleGraphViewer::SetRumbleGraphFile(const XRawFile* aRawFile) {
     mRumbleGraphFile = aRawFile;
 
-    QDataStream rawFileStream;//(mRumbleGraphFile->contents.toLatin1());
+    XDataStream rawFileStream;//(mRumbleGraphFile->contents.toLatin1());
 
     QByteArray magic(15, Qt::Uninitialized);
     rawFileStream.readRawData(magic.data(), 15);

app/xtreewidget.cpp

@@ -490,12 +490,12 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
         });
         QAction *exportZoneFileAction = new QAction("Export Zone File");
         exportSubmenu->addAction(exportZoneFileAction);
-        connect(exportZoneFileAction, &QAction::triggered, this, [fastFile](bool checked) {
+        connect(exportZoneFileAction, &QAction::triggered, this, [](bool checked) {
             Q_UNUSED(checked);
 
-            const QString zoneFilePath = QFileDialog::getSaveFileName(
-                nullptr, "Export Zone File...", QDir::currentPath(),
-                "Zone File (*.zone);;All Files(*.*)");
+            // const QString zoneFilePath = QFileDialog::getSaveFileName(
+            //     nullptr, "Export Zone File...", QDir::currentPath(),
+            //     "Zone File (*.zone);;All Files(*.*)");
             //fastFile->GetZoneFile()->SaveZoneFile(zoneFilePath);
         });
     } else if (activeText.contains(".zone")) {
@@ -508,7 +508,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
         QMenu *exportSubmenu = new QMenu("Export...", this);
         contextMenu->addMenu(exportSubmenu);
 
-        const ZoneFile* zoneFile = mZoneFiles[fileStem];
+        //const ZoneFile* zoneFile = mZoneFiles[fileStem];
 
         QAction *exportZoneFileAction = new QAction("Export Zone File");
         exportSubmenu->addAction(exportZoneFileAction);
@@ -530,7 +530,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
             }
         }
         if (parentItem && parentItem != invisibleRootItem() && parentItem->text(0).contains(".zone")) {
-            const QString fileStem = parentItem->text(0).section('.', 0, 0);
+            //const QString fileStem = parentItem->text(0).section('.', 0, 0);
             // QVector<LoadedSound> LoadedSounds = mZoneFiles[fileStem]->GetAssetMap().sounds;
             // for (LoadedSound LoadedSound : LoadedSounds) {
             //     for (Sound sound : LoadedSound.sounds) {
@@ -577,14 +577,14 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
         }
         if (parentItem && parentItem != invisibleRootItem() && parentItem->text(0).contains(".zone")) {
             const QString fileStem = parentItem->text(0).section('.', 0, 0);
-            auto zoneFile = mZoneFiles[fileStem];
+            //auto zoneFile = mZoneFiles[fileStem];
 
             QMenu *exportSubmenu = new QMenu("Export...", this);
             contextMenu->addMenu(exportSubmenu);
 
             QAction *exportAllWAVAction = new QAction("Export ALL as WAV Files");
             exportSubmenu->addAction(exportAllWAVAction);
-            connect(exportAllWAVAction, &QAction::triggered, this, [zoneFile](bool checked) {
+            connect(exportAllWAVAction, &QAction::triggered, this, [](bool checked) {
                 Q_UNUSED(checked);
 
                 // for (LoadedSound LoadedSound : zoneFile->GetAssetMap().sounds) {

libs/compression/compression.cpp

@@ -1,73 +1,68 @@
 #include "compression.h"
-//#include "minilzo.h"
-
-//#define XBOXAPI __declspec(dllimport)
-//#include "xcompress.h"
+#include "minilzo.h"
+#include "xcompress.h"
 
 #include <QLibrary>
 #include <QDebug>
 #include <QFile>
-#include <QDataStream>
 
 QByteArray Compression::CompressXMem(const QByteArray &data)
 {
-    // XMEMCODEC_PARAMETERS_LZX lzxParams = {};
-    // lzxParams.Flags = 0;
-    // lzxParams.WindowSize = 0x20000;
-    // lzxParams.CompressionPartitionSize = 0x80000;
+    XMEMCODEC_PARAMETERS_LZX lzxParams = {};
+    lzxParams.Flags = 0;
+    lzxParams.WindowSize = 0x20000;
+    lzxParams.CompressionPartitionSize = 0x80000;
 
-    // XMEMCOMPRESSION_CONTEXT ctx = nullptr;
-    // if (FAILED(XMemCreateCompressionContext(XMEMCODEC_LZX, &lzxParams, 0, &ctx)) || !ctx)
-    //     return QByteArray();
-
-    // SIZE_T estimatedSize = data.size() + XCOMPRESS_LZX_BLOCK_GROWTH_SIZE_MAX;
-    // QByteArray output(static_cast<int>(estimatedSize), 0);
-    // SIZE_T actualSize = estimatedSize;
-
-    // HRESULT hr = XMemCompress(ctx, output.data(), &actualSize, data.constData(), data.size());
-    // XMemDestroyCompressionContext(ctx);
-
-    // if (FAILED(hr))
-    //     return QByteArray();
-
-    // output.resize(static_cast<int>(actualSize));
-    // return output;
+    XMEMCOMPRESSION_CONTEXT ctx = nullptr;
+    if (FAILED(XMemCreateCompressionContext(XMEMCODEC_LZX, &lzxParams, 0, &ctx)) || !ctx)
         return QByteArray();
+
+    SIZE_T estimatedSize = data.size() + XCOMPRESS_LZX_BLOCK_GROWTH_SIZE_MAX;
+    QByteArray output(static_cast<int>(estimatedSize), 0);
+    SIZE_T actualSize = estimatedSize;
+
+    HRESULT hr = XMemCompress(ctx, output.data(), &actualSize, data.constData(), data.size());
+    XMemDestroyCompressionContext(ctx);
+
+    if (FAILED(hr))
+        return QByteArray();
+
+    output.resize(static_cast<int>(actualSize));
+    return output;
 }
 
 QByteArray Compression::DecompressXMem(const QByteArray &data, int flags, int windowSize, int partSize)
 {
-    // if (data.isEmpty())
-    //     return {};
+    if (data.isEmpty())
+        return {};
 
-    // XMEMCODEC_PARAMETERS_LZX lzxParams = {};
-    // lzxParams.Flags = flags;
-    // lzxParams.WindowSize = windowSize;
-    // lzxParams.CompressionPartitionSize = partSize;
+    XMEMCODEC_PARAMETERS_LZX lzxParams = {};
+    lzxParams.Flags = flags;
+    lzxParams.WindowSize = windowSize;
+    lzxParams.CompressionPartitionSize = partSize;
 
-    // XMEMDECOMPRESSION_CONTEXT ctx = nullptr;
-    // if (FAILED(XMemCreateDecompressionContext(XMEMCODEC_LZX, &lzxParams, 0, &ctx)) || !ctx)
-    //     return {};
+    XMEMDECOMPRESSION_CONTEXT ctx = nullptr;
+    if (FAILED(XMemCreateDecompressionContext(XMEMCODEC_LZX, &lzxParams, 0, &ctx)) || !ctx)
+        return {};
 
-    // // Allocate large enough buffer for decompression (16 MB is a safe upper bound)
-    // const SIZE_T kMaxOutSize = 16 * 1024 * 1024;
-    // QByteArray output(static_cast<int>(kMaxOutSize), Qt::Uninitialized);
-    // SIZE_T actualSize = kMaxOutSize;
+    // Allocate large enough buffer for decompression (16 MB is a safe upper bound)
+    const SIZE_T kMaxOutSize = 16 * 1024 * 1024;
+    QByteArray output(static_cast<int>(kMaxOutSize), Qt::Uninitialized);
+    SIZE_T actualSize = kMaxOutSize;
 
-    // HRESULT hr = XMemDecompress(ctx,
-    //                             output.data(), &actualSize,
-    //                             data.constData(), data.size() + 16);
+    HRESULT hr = XMemDecompress(ctx,
+                                output.data(), &actualSize,
+                                data.constData(), data.size() + 16);
 
-    // XMemDestroyDecompressionContext(ctx);
+    XMemDestroyDecompressionContext(ctx);
 
-    // if (FAILED(hr)) {
-    //     qWarning() << "XMemDecompress failed with HRESULT:" << hr;
-    //     return {};
-    // }
+    if (FAILED(hr)) {
+        qWarning() << "XMemDecompress failed with HRESULT:" << hr;
+        return {};
+    }
 
-    // output.resize(static_cast<int>(actualSize));
-    // return output;
-    return QByteArray();
+    output.resize(static_cast<int>(actualSize));
+    return output;
 }
 
 quint32 Compression::CalculateAdler32Checksum(const QByteArray &data) {
@@ -298,22 +293,22 @@ QByteArray Compression::CompressDeflateWithSettings(const QByteArray &aData, int
 
 QByteArray Compression::DecompressLZO(const QByteArray &aCompressedData, quint32 aDestSize) {
     QByteArray dst;
-    // static bool ok = (lzo_init() == LZO_E_OK);
-    // if (!ok)
-    //     throw std::runtime_error("lzo_init failed");
+    static bool ok = (lzo_init() == LZO_E_OK);
+    if (!ok)
+        throw std::runtime_error("lzo_init failed");
 
-    // dst = QByteArray(aDestSize, Qt::Uninitialized);
-    // lzo_uint out = aDestSize;
+    dst = QByteArray(aDestSize, Qt::Uninitialized);
+    lzo_uint out = aDestSize;
 
-    // int rc = lzo1x_decompress_safe(
-    //     reinterpret_cast<const lzo_bytep>(aCompressedData.constData()),
-    //     static_cast<lzo_uint>(aCompressedData.size()),
-    //     reinterpret_cast<lzo_bytep>(dst.data()),
-    //     &out,
-    //     nullptr);
+    int rc = lzo1x_decompress_safe(
+        reinterpret_cast<const lzo_bytep>(aCompressedData.constData()),
+        static_cast<lzo_uint>(aCompressedData.size()),
+        reinterpret_cast<lzo_bytep>(dst.data()),
+        &out,
+        nullptr);
 
-    // if (rc != LZO_E_OK || out != aDestSize)
-    //     throw std::runtime_error("LZO decompression error");
+    if (rc != LZO_E_OK || out != aDestSize)
+        throw std::runtime_error("LZO decompression error");
 
     return dst;
 }

libs/compression/compression.pro

@@ -3,7 +3,8 @@ TEMPLATE = lib
 CONFIG += staticlib c++17
 DEFINES += MINILZO_USE_STATIC
 
-SOURCES += $$files($$PWD/*.cpp, true)
+SOURCES += $$files($$PWD/*.cpp, true) \
+           $$files($$PWD/*.c, true)
 HEADERS += $$files($$PWD/*.h, true)
 
 LIBS += \

libs/compression/lzoconf.h

@@ -57,7 +57,7 @@
 
 /* get OS and architecture defines */
 #ifndef __LZODEFS_H_INCLUDED
-#include <lzo/lzodefs.h>
+#include <lzodefs.h>
 #endif
 
 

libs/compression/minilzo.h

@@ -25,13 +25,6 @@
    http://www.oberhumer.com/opensource/lzo/
  */
 
-/*
- * NOTE:
- *   the full LZO package can be found at
- *   http://www.oberhumer.com/opensource/lzo/
- */
-
-
 #ifndef __MINILZO_H_INCLUDED
 #define __MINILZO_H_INCLUDED 1
 

libs/core/core.pro

@@ -2,8 +2,10 @@ QT += core widgets
 TEMPLATE = lib
 CONFIG += staticlib c++17
 
-SOURCES += $$files($$PWD/*.cpp, true)
-HEADERS += $$files($$PWD/*.h, true)
+SOURCES += $$files($$PWD/*.cpp, true) \
+    xdatastream.cpp
+HEADERS += $$files($$PWD/*.h, true) \
+    xdatastream.h
 
 LIBS += -L$$OUT_PWD/../libs/xassets -lxassets
 

libs/core/utils.h

@@ -223,7 +223,7 @@ public:
 
         return color;
     }
-    static bool ReadUntilString(QDataStream* stream, const QString& targetString) {
+    static bool ReadUntilString(XDataStream* stream, const QString& targetString) {
         if (!stream || targetString.isEmpty()) {
             return false; // Invalid input
         }
@@ -257,7 +257,7 @@ public:
         return false;
     }
 
-    static bool ReadUntilHex(QDataStream* stream, const QString& hexString) {
+    static bool ReadUntilHex(XDataStream* stream, const QString& hexString) {
         if (!stream || hexString.isEmpty() || hexString.size() % 2 != 0) {
             return false; // Invalid input
         }

libs/core/xdatastream.cpp

@@ -0,0 +1,225 @@
+#include "xdatastream.h"
+
+#include <QIODevice>
+#include <QDebug>
+
+XDataStream::XDataStream(QIODevice *aDevice)
+    : QDataStream(aDevice)
+    , mDebug(false)
+{
+
+}
+
+XDataStream::XDataStream()
+    : QDataStream()
+    , mDebug(false)
+{
+
+}
+
+XDataStream::XDataStream(const QByteArray &aData)
+    : QDataStream(aData)
+    , mDebug(false)
+{
+
+}
+
+XDataStream::XDataStream(QByteArray *aData, OpenMode aFlags)
+    : QDataStream(aData, aFlags)
+    , mDebug(false)
+{
+
+}
+
+XDataStream::~XDataStream()
+{
+
+}
+
+void XDataStream::SetDebug(bool aDebug)
+{
+    mDebug = aDebug;
+}
+
+qint8 XDataStream::ParseInt8(const QString& aDebugString)
+{
+    qint64 start = this->device()->pos();
+
+    qint8 val;
+    *this >> val;
+
+    if (mDebug)
+    {
+        qDebug() << QString("[%1-%2] Parsed %3: %4")
+        .arg(start, 10, 10, QChar('0'))
+            .arg(this->device()->pos(), 10, 10, QChar('0'))
+            .arg(aDebugString)
+            .arg(val);
+    }
+    return val;
+}
+
+quint8 XDataStream::ParseUInt8(const QString& aDebugString)
+{
+    qint64 start = this->device()->pos();
+
+    quint8 val;
+    *this >> val;
+
+    if (mDebug)
+    {
+        qDebug() << QString("[%1-%2] Parsed %3: %4")
+        .arg(start, 10, 10, QChar('0'))
+            .arg(this->device()->pos(), 10, 10, QChar('0'))
+            .arg(aDebugString)
+            .arg(val);
+    }
+    return val;
+}
+
+qint16 XDataStream::ParseInt16(const QString& aDebugString)
+{
+    qint64 start = this->device()->pos();
+
+    qint16 val;
+    *this >> val;
+
+    if (mDebug)
+    {
+        qDebug() << QString("[%1-%2] Parsed %3: %4")
+        .arg(start, 10, 10, QChar('0'))
+            .arg(this->device()->pos(), 10, 10, QChar('0'))
+            .arg(aDebugString)
+            .arg(val);
+    }
+    return val;
+}
+
+quint16 XDataStream::ParseUInt16(const QString& aDebugString)
+{
+    qint64 start = this->device()->pos();
+
+    quint16 val;
+    *this >> val;
+
+    if (mDebug)
+    {
+        qDebug() << QString("[%1-%2] Parsed %3: %4")
+        .arg(start, 10, 10, QChar('0'))
+            .arg(this->device()->pos(), 10, 10, QChar('0'))
+            .arg(aDebugString)
+            .arg(val);
+    }
+    return val;
+}
+
+qint32 XDataStream::ParseInt32(const QString& aDebugString)
+{
+    qint64 start = this->device()->pos();
+
+    qint32 val;
+    *this >> val;
+
+    if (mDebug)
+    {
+        qDebug() << QString("[%1-%2] Parsed %3: %4")
+        .arg(start, 10, 10, QChar('0'))
+            .arg(this->device()->pos(), 10, 10, QChar('0'))
+            .arg(aDebugString)
+            .arg(val);
+    }
+    return val;
+}
+
+quint32 XDataStream::ParseUInt32(const QString& aDebugString)
+{
+    qint64 start = this->device()->pos();
+
+    quint32 val;
+    *this >> val;
+
+    if (mDebug)
+    {
+        qDebug() << QString("[%1-%2] Parsed %3: %4")
+        .arg(start, 10, 10, QChar('0'))
+            .arg(this->device()->pos(), 10, 10, QChar('0'))
+            .arg(aDebugString)
+            .arg(val);
+    }
+    return val;
+}
+
+qint64 XDataStream::ParseInt64(const QString& aDebugString)
+{
+    qint64 start = this->device()->pos();
+
+    qint64 val;
+    *this >> val;
+
+    if (mDebug)
+    {
+        qDebug() << QString("[%1-%2] Parsed %3: %4")
+        .arg(start, 10, 10, QChar('0'))
+            .arg(this->device()->pos(), 10, 10, QChar('0'))
+            .arg(aDebugString)
+            .arg(val);
+    }
+    return val;
+}
+
+quint64 XDataStream::ParseUInt64(const QString& aDebugString)
+{
+    qint64 start = this->device()->pos();
+
+    quint64 val;
+    *this >> val;
+
+    if (mDebug)
+    {
+        qDebug() << QString("[%1-%2] Parsed %3: %4")
+        .arg(start, 10, 10, QChar('0'))
+            .arg(this->device()->pos(), 10, 10, QChar('0'))
+            .arg(aDebugString)
+            .arg(val);
+    }
+    return val;
+}
+
+float XDataStream::ParseSingle(const QString& aDebugString)
+{
+    qint64 start = this->device()->pos();
+
+
+    float val;
+    quint32 rawVal;
+    *this >> rawVal;
+    memcpy(&val, &rawVal, sizeof(val));
+
+    if (mDebug)
+    {
+        qDebug() << QString("[%1-%2] Parsed %3: %4")
+        .arg(start, 10, 10, QChar('0'))
+            .arg(this->device()->pos(), 10, 10, QChar('0'))
+            .arg(aDebugString)
+            .arg(val);
+    }
+    return val;
+}
+
+double XDataStream::ParseDouble(const QString& aDebugString)
+{
+    qint64 start = this->device()->pos();
+
+    float val;
+    *this >> val;
+
+    if (mDebug)
+    {
+        qDebug() << QString("[%1-%2] Parsed %3: %4")
+        .arg(start, 10, 10, QChar('0'))
+            .arg(this->device()->pos(), 10, 10, QChar('0'))
+            .arg(aDebugString)
+            .arg(val);
+    }
+    return val;
+}

libs/core/xdatastream.h

@@ -0,0 +1,33 @@
+#ifndef XDATASTREAM_H
+#define XDATASTREAM_H
+
+#include <QDataStream>
+#include <QString>
+
+class XDataStream : public QDataStream
+{
+public:
+    explicit XDataStream(QIODevice* aDevice);
+    XDataStream();
+    XDataStream(const QByteArray& aData);
+    XDataStream(QByteArray* aData, OpenMode aFlags);
+    ~XDataStream();
+
+    void SetDebug(bool aDebug = true);
+
+    qint8 ParseInt8(const QString& aDebugString = "");
+    quint8 ParseUInt8(const QString& aDebugString = "");
+    qint16 ParseInt16(const QString& aDebugString = "");
+    quint16 ParseUInt16(const QString& aDebugString = "");
+    qint32 ParseInt32(const QString& aDebugString = "");
+    quint32 ParseUInt32(const QString& aDebugString = "");
+    qint64 ParseInt64(const QString& aDebugString = "");
+    quint64 ParseUInt64(const QString& aDebugString = "");
+    float ParseSingle(const QString& aDebugString = "");
+    double ParseDouble(const QString& aDebugString = "");
+
+private:
+    bool mDebug;
+};
+
+#endif // XDATASTREAM_H

libs/encryption/ecrypt-portable.h

@@ -1,15 +1,5 @@
 /* ecrypt-portable.h */
 
-/*
- * WARNING: the conversions defined below are implemented as macros,
- * and should be used carefully. They should NOT be used with
- * parameters which perform some action. E.g., the following two lines
- * are not equivalent:
- *
- *  1) ++x; y = ROTL32(x, n);
- *  2) y = ROTL32(++x, n);
- */
-
 /*
  * *** Please do not edit this file. ***
  *

libs/encryption/salsa20.cpp

@@ -59,7 +59,7 @@ void ECRYPT_encrypt_bytes(ECRYPT_ctx *x,const u8 *m,u8 *c,u32 bytes)
     u32 j0, j1, j2, j3, j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15;
     u8 *ctarget;
     u8 tmp[64];
-    int i;
+    u32 i;
 
     if (!bytes) return;
 
@@ -82,7 +82,10 @@ void ECRYPT_encrypt_bytes(ECRYPT_ctx *x,const u8 *m,u8 *c,u32 bytes)
 
     for (;;) {
         if (bytes < 64) {
-            for (i = 0;i < bytes;++i) tmp[i] = m[i];
+            for (i = 0; i < bytes; ++i)
+            {
+                tmp[i] = m[i];
+            }
             m = tmp;
             ctarget = c;
             c = tmp;

libs/encryption/sha1.cpp

@@ -94,7 +94,6 @@ void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64]);
 
 /* blk0() and blk() perform the initial expand. */
 /* I got the idea of expanding during the round function from SSLeay */
-/* FIXME: can we do this in an endian-proof way? */
 #ifdef WORDS_BIGENDIAN
 #define blk0(i) block->l[i]
 #else

libs/fastfile/360/fastfile_cod10_360.cpp

@@ -69,12 +69,12 @@ bool FastFile_COD10_360::Load(const QString aFilePath) {
 bool FastFile_COD10_360::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
 
     // Select key based on game.
     QByteArray key = QByteArray::fromHex("0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");

libs/fastfile/360/fastfile_cod11_360.cpp

@@ -72,8 +72,8 @@ bool FastFile_COD11_360::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
     // Prepare data stream for parsing
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Verify magic header
     QByteArray fileMagic(8, Qt::Uninitialized);

libs/fastfile/360/fastfile_cod12_360.cpp

@@ -72,8 +72,8 @@ bool FastFile_COD12_360::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
     // Prepare data stream for parsing
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Verify magic header
     QByteArray fileMagic(8, Qt::Uninitialized);

libs/fastfile/360/fastfile_cod2_360.cpp

@@ -68,9 +68,9 @@ bool FastFile_COD2_360::Load(const QString aFilePath) {
 }
 
 bool FastFile_COD2_360::Load(const QByteArray aData) {
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     Utils::ReadUntilHex(&fastFileStream, "78");
     QByteArray compressedData = aData.mid(fastFileStream.device()->pos());

libs/fastfile/360/fastfile_cod4_360.cpp

@@ -80,9 +80,9 @@ bool FastFile_COD4_360::Load(const QByteArray aData) {
         // For COD5, simply decompress from offset 12.
         decompressedData = Compression::DecompressZLIB(aData.mid(12));
     } else if (header == "IWff0100") {
-        // Create a QDataStream on the input data.
-        QDataStream fastFileStream(aData.mid(12));
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        // Create a XDataStream on the input data.
+        XDataStream fastFileStream(aData.mid(12));
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
         QByteArray magic(8, Qt::Uninitialized);
         fastFileStream.readRawData(magic.data(), 8);

libs/fastfile/360/fastfile_cod7_360.cpp

@@ -71,12 +71,12 @@ bool FastFile_COD7_360::Load(const QString aFilePath) {
 bool FastFile_COD7_360::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
     fastFileStream.skipRawData(12);
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
 
     // Select key based on game.
     QByteArray key = QByteArray::fromHex("1ac1d12d527c59b40eca619120ff8217ccff09cd16896f81b829c7f52793405d");

libs/fastfile/360/fastfile_cod8_360.cpp

@@ -69,12 +69,12 @@ bool FastFile_COD8_360::Load(const QString aFilePath) {
 bool FastFile_COD8_360::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
 
     // Select key based on game.
     QByteArray key = QByteArray::fromHex("0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");

libs/fastfile/360/fastfile_cod9_360.cpp

@@ -69,12 +69,12 @@ bool FastFile_COD9_360::Load(const QString aFilePath) {
 bool FastFile_COD9_360::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
 
     // Select key based on game.
     QByteArray key = QByteArray::fromHex("0E50F49F412317096038665622DD091332A209BA0A05A00E1377CEDB0A3CB1D3");

libs/fastfile/PC/fastfile_cod10_pc.cpp

@@ -69,9 +69,9 @@ bool FastFile_COD10_PC::Load(const QString aFilePath) {
 bool FastFile_COD10_PC::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -84,9 +84,9 @@ bool FastFile_COD10_PC::Load(const QByteArray aData) {
     SetGame("COD9");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
     if (GetPlatform() == "PC") {
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
     }
 
     // Select key based on game.

libs/fastfile/PC/fastfile_cod11_pc.cpp

@@ -69,9 +69,9 @@ bool FastFile_COD11_PC::Load(const QString aFilePath) {
 bool FastFile_COD11_PC::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -84,9 +84,9 @@ bool FastFile_COD11_PC::Load(const QByteArray aData) {
     SetGame("COD9");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
     if (GetPlatform() == "PC") {
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
     }
 
     // Select key based on game.

libs/fastfile/PC/fastfile_cod12_pc.cpp

@@ -72,9 +72,9 @@ bool FastFile_COD12_PC::Load(const QString aFilePath) {
 bool FastFile_COD12_PC::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Skip header magic
     fastFileStream.skipRawData(8);

libs/fastfile/PC/fastfile_cod4_pc.cpp

@@ -75,9 +75,9 @@ bool FastFile_COD4_PC::Load(const QByteArray aData) {
     StatusBarManager::instance().updateStatus("Loading COD5 Fast File w/data", 1000);
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // For COD5, simply decompress from offset 12.
     decompressedData = Compression::DecompressZLIB(aData.mid(12));

libs/fastfile/PC/fastfile_cod5_pc.cpp

@@ -75,9 +75,9 @@ bool FastFile_COD5_PC::Load(const QByteArray aData) {
     StatusBarManager::instance().updateStatus("Loading COD5 Fast File w/data", 1000);
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // For COD5, simply decompress from offset 12.
     decompressedData = Compression::DecompressZLIB(aData.mid(12));

libs/fastfile/PC/fastfile_cod7_pc.cpp

@@ -72,9 +72,9 @@ bool FastFile_COD7_PC::Load(const QString aFilePath) {
 bool FastFile_COD7_PC::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));

libs/fastfile/PC/fastfile_cod8_pc.cpp

@@ -72,9 +72,9 @@ bool FastFile_COD8_PC::Load(const QString aFilePath) {
 bool FastFile_COD8_PC::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -87,7 +87,7 @@ bool FastFile_COD8_PC::Load(const QByteArray aData) {
     SetGame("COD7");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Select key based on game.
     QByteArray key;

libs/fastfile/PC/fastfile_cod9_pc.cpp

@@ -69,9 +69,9 @@ bool FastFile_COD9_PC::Load(const QString aFilePath) {
 bool FastFile_COD9_PC::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -84,9 +84,9 @@ bool FastFile_COD9_PC::Load(const QByteArray aData) {
     SetGame("COD9");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
     if (GetPlatform() == "PC") {
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
     }
 
     // Select key based on game.

libs/fastfile/PS3/fastfile_cod10_ps3.cpp

@@ -69,9 +69,9 @@ bool FastFile_COD10_PS3::Load(const QString aFilePath) {
 bool FastFile_COD10_PS3::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -84,9 +84,9 @@ bool FastFile_COD10_PS3::Load(const QByteArray aData) {
     SetGame("COD9");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
     if (GetPlatform() == "PC") {
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
     }
 
     // Select key based on game.

libs/fastfile/PS3/fastfile_cod11_ps3.cpp

@@ -69,9 +69,9 @@ bool FastFile_COD11_PS3::Load(const QString aFilePath) {
 bool FastFile_COD11_PS3::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -84,9 +84,9 @@ bool FastFile_COD11_PS3::Load(const QByteArray aData) {
     SetGame("COD9");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
     if (GetPlatform() == "PC") {
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
     }
 
     // Select key based on game.

libs/fastfile/PS3/fastfile_cod12_ps3.cpp

@@ -69,9 +69,9 @@ bool FastFile_COD12_PS3::Load(const QString aFilePath) {
 bool FastFile_COD12_PS3::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -84,9 +84,9 @@ bool FastFile_COD12_PS3::Load(const QByteArray aData) {
     SetGame("COD9");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
     if (GetPlatform() == "PC") {
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
     }
 
     // Select key based on game.

libs/fastfile/PS3/fastfile_cod4_ps3.cpp

@@ -75,9 +75,9 @@ bool FastFile_COD4_PS3::Load(const QByteArray aData) {
     StatusBarManager::instance().updateStatus("Loading COD5 Fast File w/data", 1000);
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -91,8 +91,8 @@ bool FastFile_COD4_PS3::Load(const QByteArray aData) {
     while (pos <= aData.size()) {
         // Read 2-byte BIG-ENDIAN chunk size
         quint32 chunkSize;
-        QDataStream chunkStream(aData.mid(pos, 2));
-        chunkStream.setByteOrder(QDataStream::BigEndian);
+        XDataStream chunkStream(aData.mid(pos, 2));
+        chunkStream.setByteOrder(XDataStream::BigEndian);
         chunkStream >> chunkSize;
 
         pos += 2;

libs/fastfile/PS3/fastfile_cod5_ps3.cpp

@@ -75,9 +75,9 @@ bool FastFile_COD5_PS3::Load(const QByteArray aData) {
     StatusBarManager::instance().updateStatus("Loading COD5 Fast File w/data", 1000);
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -91,8 +91,8 @@ bool FastFile_COD5_PS3::Load(const QByteArray aData) {
     while (pos <= aData.size()) {
         // Read 2-byte BIG-ENDIAN chunk size
         quint32 chunkSize;
-        QDataStream chunkStream(aData.mid(pos, 2));
-        chunkStream.setByteOrder(QDataStream::BigEndian);
+        XDataStream chunkStream(aData.mid(pos, 2));
+        chunkStream.setByteOrder(XDataStream::BigEndian);
         chunkStream >> chunkSize;
 
         pos += 2;

libs/fastfile/PS3/fastfile_cod6_ps3.cpp

@@ -75,9 +75,9 @@ bool FastFile_COD6_PS3::Load(const QByteArray aData) {
     StatusBarManager::instance().updateStatus("Loading COD5 Fast File w/data", 1000);
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));

libs/fastfile/PS3/fastfile_cod7_ps3.cpp

@@ -72,9 +72,9 @@ bool FastFile_COD7_PS3::Load(const QString aFilePath) {
 bool FastFile_COD7_PS3::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -91,9 +91,9 @@ bool FastFile_COD7_PS3::Load(const QByteArray aData) {
     zoneFile->SetStem(GetBaseStem() + ".zone");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
     if (GetPlatform() == "PC") {
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
         // Select key based on game.
         QByteArray key;

libs/fastfile/PS3/fastfile_cod8_ps3.cpp

@@ -72,9 +72,9 @@ bool FastFile_COD8_PS3::Load(const QString aFilePath) {
 bool FastFile_COD8_PS3::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -90,9 +90,9 @@ bool FastFile_COD8_PS3::Load(const QByteArray aData) {
     zoneFile->SetStem(GetBaseStem() + ".zone");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
     if (GetPlatform() == "PC") {
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
         // Select key based on game.
         QByteArray key;

libs/fastfile/PS3/fastfile_cod9_ps3.cpp

@@ -69,9 +69,9 @@ bool FastFile_COD9_PS3::Load(const QString aFilePath) {
 bool FastFile_COD9_PS3::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -84,9 +84,9 @@ bool FastFile_COD9_PS3::Load(const QByteArray aData) {
     SetGame("COD9");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
     if (GetPlatform() == "PC") {
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
     }
 
     // Select key based on game.

libs/fastfile/Wii/fastfile_cod7_wii.cpp

@@ -69,9 +69,9 @@ bool FastFile_COD7_Wii::Load(const QString aFilePath) {
 bool FastFile_COD7_Wii::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -84,7 +84,7 @@ bool FastFile_COD7_Wii::Load(const QByteArray aData) {
     SetGame("COD7");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
 
     // For COD7, simply decompress from offset 12.
     decompressedData = Compression::DecompressZLIB(aData.mid(12));

libs/fastfile/Wii/fastfile_cod8_wii.cpp

@@ -69,9 +69,9 @@ bool FastFile_COD8_Wii::Load(const QString aFilePath) {
 bool FastFile_COD8_Wii::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -81,7 +81,7 @@ bool FastFile_COD8_Wii::Load(const QByteArray aData) {
     SetVersion(pParseFFVersion(&fastFileStream));
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
 
     // For COD7, simply decompress from offset 12.
     decompressedData = Compression::DecompressZLIB(aData.mid(25));

libs/fastfile/WiiU/fastfile_cod10_wiiu.cpp

@@ -67,9 +67,9 @@ bool FastFile_COD10_WiiU::Load(const QString aFilePath) {
 bool FastFile_COD10_WiiU::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -82,9 +82,9 @@ bool FastFile_COD10_WiiU::Load(const QByteArray aData) {
     SetGame("COD9");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
     if (GetPlatform() == "PC") {
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
     }
 
     // Select key based on game.

libs/fastfile/WiiU/fastfile_cod9_wiiu.cpp

@@ -67,9 +67,9 @@ bool FastFile_COD9_WiiU::Load(const QString aFilePath) {
 bool FastFile_COD9_WiiU::Load(const QByteArray aData) {
     QByteArray decompressedData;
 
-    // Create a QDataStream on the input data.
-    QDataStream fastFileStream(aData);
-    fastFileStream.setByteOrder(QDataStream::LittleEndian);
+    // Create a XDataStream on the input data.
+    XDataStream fastFileStream(aData);
+    fastFileStream.setByteOrder(XDataStream::LittleEndian);
 
     // Parse header values.
     SetCompany(pParseFFCompany(&fastFileStream));
@@ -82,9 +82,9 @@ bool FastFile_COD9_WiiU::Load(const QByteArray aData) {
     SetGame("COD9");
 
     // For COD7/COD9, use BigEndian.
-    fastFileStream.setByteOrder(QDataStream::BigEndian);
+    fastFileStream.setByteOrder(XDataStream::BigEndian);
     if (GetPlatform() == "PC") {
-        fastFileStream.setByteOrder(QDataStream::LittleEndian);
+        fastFileStream.setByteOrder(XDataStream::LittleEndian);
     }
 
     // Select key based on game.

libs/fastfile/fastfile.cpp

@@ -115,7 +115,7 @@ void FastFile::SetPlatform(const QString aPlatform) {
     mPlatform = aPlatform;
 }
 
-FF_COMPANY FastFile::pParseFFCompany(QDataStream *afastFileStream, quint32 &aCompanyInt) {
+FF_COMPANY FastFile::pParseFFCompany(XDataStream *afastFileStream, quint32 &aCompanyInt) {
     LogManager::instance().addEntry("Parsing company into reference...");
     // Check for null datastream ptr
     if (!afastFileStream) { return COMPANY_NONE; }
@@ -137,7 +137,7 @@ FF_COMPANY FastFile::pParseFFCompany(QDataStream *afastFileStream, quint32 &aCom
     return COMPANY_NONE;
 }
 
-FF_COMPANY FastFile::pParseFFCompany(QDataStream *afastFileStream) {
+FF_COMPANY FastFile::pParseFFCompany(XDataStream *afastFileStream) {
     LogManager::instance().addEntry("Parsing company...");
     // Check for null datastream ptr
     if (!afastFileStream) { return COMPANY_NONE; }
@@ -157,7 +157,7 @@ FF_COMPANY FastFile::pParseFFCompany(QDataStream *afastFileStream) {
     return COMPANY_NONE;
 }
 
-FF_FILETYPE FastFile::pParseFFFileType(QDataStream *afastFileStream) {
+FF_FILETYPE FastFile::pParseFFFileType(XDataStream *afastFileStream) {
     // Parse filetype
     QByteArray fileTypeData(2, Qt::Uninitialized);
     afastFileStream->readRawData(fileTypeData.data(), 2);
@@ -168,7 +168,7 @@ FF_FILETYPE FastFile::pParseFFFileType(QDataStream *afastFileStream) {
     return FILETYPE_NONE;
 }
 
-FF_SIGNAGE FastFile::pParseFFSignage(QDataStream *afastFileStream) {
+FF_SIGNAGE FastFile::pParseFFSignage(XDataStream *afastFileStream) {
     // Parse filetype
     QByteArray signedData(1, Qt::Uninitialized);
     afastFileStream->readRawData(signedData.data(), 1);
@@ -181,7 +181,7 @@ FF_SIGNAGE FastFile::pParseFFSignage(QDataStream *afastFileStream) {
     return SIGNAGE_NONE;
 }
 
-QString FastFile::pParseFFMagic(QDataStream *afastFileStream) {
+QString FastFile::pParseFFMagic(XDataStream *afastFileStream) {
     // Parse magic
     QByteArray magicData(3, Qt::Uninitialized);
     afastFileStream->readRawData(magicData.data(), 3);
@@ -192,7 +192,7 @@ QString FastFile::pParseFFMagic(QDataStream *afastFileStream) {
     return "";
 }
 
-quint32 FastFile::pParseFFVersion(QDataStream *afastFileStream) {
+quint32 FastFile::pParseFFVersion(XDataStream *afastFileStream) {
     // Parse version
     quint32 version;
     *afastFileStream >> version;

libs/fastfile/fastfile.h

@@ -46,12 +46,12 @@ public:
     virtual void SetGame(const QString aGame);
     virtual void SetPlatform(const QString aPlatform);
 
-    static FF_COMPANY pParseFFCompany(QDataStream *afastFileStream, quint32 &aCompanyInt);
-    static FF_COMPANY pParseFFCompany(QDataStream *afastFileStream);
-    static FF_FILETYPE pParseFFFileType(QDataStream *afastFileStream);
-    static FF_SIGNAGE pParseFFSignage(QDataStream *afastFileStream);
-    static QString pParseFFMagic(QDataStream *afastFileStream);
-    static quint32 pParseFFVersion(QDataStream *afastFileStream);
+    static FF_COMPANY pParseFFCompany(XDataStream *afastFileStream, quint32 &aCompanyInt);
+    static FF_COMPANY pParseFFCompany(XDataStream *afastFileStream);
+    static FF_FILETYPE pParseFFFileType(XDataStream *afastFileStream);
+    static FF_SIGNAGE pParseFFSignage(XDataStream *afastFileStream);
+    static QString pParseFFMagic(XDataStream *afastFileStream);
+    static quint32 pParseFFVersion(XDataStream *afastFileStream);
     static QString pCalculateFFPlatform(quint32 aVersion);
     static QString pCalculateFFGame(quint32 aVersion);
 

libs/xassets/xanimdeltapart.cpp

@@ -5,14 +5,10 @@ XAnimDeltaPart::XAnimDeltaPart()
     , mTrans()
     , mQuat()
 {
+    SetName("Animation Delta Part");
 }
 
-XAnimDeltaPart::~XAnimDeltaPart()
-{
-
-}
-
-void XAnimDeltaPart::ParseData(QDataStream *aStream) {
+void XAnimDeltaPart::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
         mTrans.ParsePtr(aStream);
         mQuat.ParsePtr(aStream);

libs/xassets/xanimdeltapart.h

@@ -9,9 +9,9 @@ class XAnimDeltaPart : public XAsset
 {
 public:
     explicit XAnimDeltaPart();
-    ~XAnimDeltaPart();
+    ~XAnimDeltaPart() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
     const XAnimPartTrans& GetTrans() const;

libs/xassets/xanimdeltapartquat.cpp

@@ -1,12 +1,14 @@
 #include "xanimdeltapartquat.h"
 
 XAnimDeltaPartQuat::XAnimDeltaPartQuat()
-    : XAsset() {
+    : XAsset()
+{
+    SetName("Animation Delta Part Quat");
 }
 
-void XAnimDeltaPartQuat::ParseData(QDataStream *aStream) {
+void XAnimDeltaPartQuat::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
-        *aStream >> mSize;
+        mSize = aStream->ParseUInt32(QString("%1 size").arg(GetName()));
 
         // Parse data
         mData.ParseData(aStream);

libs/xassets/xanimdeltapartquat.h

@@ -1,9 +1,3 @@
-
-
-
-
-
-
 #ifndef XANIMDELTAPARTQUAT_H
 #define XANIMDELTAPARTQUAT_H
 
@@ -14,8 +8,9 @@ class XAnimDeltaPartQuat : public XAsset
 {
 public:
     explicit XAnimDeltaPartQuat();
+    ~XAnimDeltaPartQuat() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
     quint32 GetSize() const;
     void SetSize(quint32 size);
@@ -29,8 +24,3 @@ private:
 };
 
 #endif // XANIMDELTAPARTQUAT_H
-
-
-
-
-

libs/xassets/xanimdeltapartquatdata.cpp

@@ -1,10 +1,12 @@
 #include "xanimdeltapartquatdata.h"
 
 XAnimDeltaPartQuatData::XAnimDeltaPartQuatData()
-    : XAsset() {
+    : XAsset()
+{
+    SetName("Animation Delta Part Quat Data");
 }
 
-void XAnimDeltaPartQuatData::ParseData(QDataStream *aStream) {
+void XAnimDeltaPartQuatData::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
         // Parse frames
         mFrames.ParseData(aStream);

libs/xassets/xanimdeltapartquatdata.h

@@ -1,9 +1,3 @@
-
-
-
-
-
-
 #ifndef XANIMDELTAPARTQUATDATA_H
 #define XANIMDELTAPARTQUATDATA_H
 
@@ -14,8 +8,9 @@ class XAnimDeltaPartQuatData : public XAsset
 {
 public:
     explicit XAnimDeltaPartQuatData();
+    ~XAnimDeltaPartQuatData() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
 
     const XAnimDeltaPartQuatDataFrames& GetFrames() const;
     void SetFrames(const XAnimDeltaPartQuatDataFrames& frames);
@@ -29,8 +24,3 @@ private:
 };
 
 #endif // XANIMDELTAPARTQUATDATA_H
-
-
-
-
-

libs/xassets/xanimdeltapartquatdataframes.cpp

@@ -1,7 +1,9 @@
 #include "xanimdeltapartquatdataframes.h"
 
 XAnimDeltaPartQuatDataFrames::XAnimDeltaPartQuatDataFrames()
-    : XAsset() {
+    : XAsset()
+{
+    SetName("Animation Delta Part Quat Data Frame");
 }
 
 quint32 XAnimDeltaPartQuatDataFrames::GetFramesPtr() const {
@@ -34,12 +36,12 @@ void XAnimDeltaPartQuatDataFrames::SetIndices(const XAnimDynamicIndices& indices
     mIndices = indices;
 }
 
-void XAnimDeltaPartQuatDataFrames::ParseData(QDataStream *aStream) {
+void XAnimDeltaPartQuatDataFrames::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
-        *aStream
-            >> mFramesPtr
-            >> mFrames[0]
-            >> mFrames[1];
+        mFramesPtr = aStream->ParseInt32(QString("%1 frames ptr").arg(GetName()));
+
+        mFrames[0] = aStream->ParseInt16(QString("%1 frame %2").arg(GetName()).arg(0));
+        mFrames[1] = aStream->ParseInt16(QString("%1 frame %2").arg(GetName()).arg(1));
 
         // Parse indices
         mIndices.ParseData(aStream);

libs/xassets/xanimdeltapartquatdataframes.h

@@ -8,6 +8,7 @@ class XAnimDeltaPartQuatDataFrames : public XAsset
 {
 public:
     explicit XAnimDeltaPartQuatDataFrames();
+    ~XAnimDeltaPartQuatDataFrames() = default;
 
     quint32 GetFramesPtr() const;
     void SetFramesPtr(quint32 ptr);
@@ -19,11 +20,11 @@ public:
     const XAnimDynamicIndices& GetIndices() const;
     void SetIndices(const XAnimDynamicIndices& indices);
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:
-    quint32 mFramesPtr = 0;
+    qint32 mFramesPtr = 0;
     qint16 mFrames[2] = {0};
     XAnimDynamicIndices mIndices;
 };

libs/xassets/xanimdynamicframes.cpp

@@ -4,24 +4,17 @@ XAnimDynamicFrames::XAnimDynamicFrames()
     : XAsset()
     , mFrames(3)
 {
+    SetName("Animation Dynamic Frames");
 }
 
-XAnimDynamicFrames::~XAnimDynamicFrames()
-{
-
-}
-
-void XAnimDynamicFrames::ParseData(QDataStream *aStream) {
+void XAnimDynamicFrames::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
-        qint32 framePtr;
-        *aStream >> framePtr;
-
+        qint32 framePtr = aStream->ParseInt32(QString("%1 frames ptr").arg(GetName()));
         if (framePtr == -1)
         {
-            *aStream
-                >> mFrames[0]
-                >> mFrames[1]
-                >> mFrames[2];
+            mFrames[0] = aStream->ParseUInt8(QString("%1 frame %2").arg(GetName()).arg(0));
+            mFrames[1] = aStream->ParseUInt8(QString("%1 frame %2").arg(GetName()).arg(1));
+            mFrames[2] = aStream->ParseUInt8(QString("%1 frame %2").arg(GetName()).arg(2));
         }
     }
 }

libs/xassets/xanimdynamicframes.h

@@ -1,4 +1,3 @@
-
 #ifndef XANIMDYNAMICFRAMES_H
 #define XANIMDYNAMICFRAMES_H
 
@@ -10,9 +9,9 @@ class XAnimDynamicFrames : public XAsset
 {
 public:
     explicit XAnimDynamicFrames();
-    ~XAnimDynamicFrames();
+    ~XAnimDynamicFrames() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
     QVector<quint8> GetFrames() const;

libs/xassets/xanimdynamicindices.cpp

@@ -4,16 +4,12 @@ XAnimDynamicIndices::XAnimDynamicIndices()
     : XAsset()
     , mIndices(1)
 {
+    SetName("Animation Dynamic Indices");
 }
 
-XAnimDynamicIndices::~XAnimDynamicIndices()
-{
-
-}
-
-void XAnimDynamicIndices::ParseData(QDataStream *aStream) {
+void XAnimDynamicIndices::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
-        *aStream >> mIndices[0];
+        mIndices[0] = aStream->ParseUInt8(QString("%1 index").arg(GetName()));
     }
 }
 

libs/xassets/xanimdynamicindices.h

@@ -9,9 +9,9 @@ class XAnimDynamicIndices : public XAsset
 {
 public:
     explicit XAnimDynamicIndices();
-    ~XAnimDynamicIndices();
+    ~XAnimDynamicIndices() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
     QVector<quint8> GetIndices() const;

libs/xassets/xanimindices.cpp

@@ -4,21 +4,15 @@ XAnimIndices::XAnimIndices()
     : XAsset()
     , mIndex(0)
 {
-
+    SetName("Animation Indices");
 }
 
-XAnimIndices::~XAnimIndices()
-{
-
-}
-
-void XAnimIndices::ParseData(QDataStream *aStream) {
+void XAnimIndices::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
-        qint32 indexPtr;
-        *aStream >> indexPtr;
+        qint32 indexPtr = aStream->ParseInt32(QString("%1 index ptr").arg(GetName()));
         if (indexPtr == -1)
         {
-            *aStream >> mIndex;
+            mIndex = aStream->ParseUInt32(QString("%1 index").arg(GetName()));
         }
     }
 }

libs/xassets/xanimindices.h

@@ -7,9 +7,9 @@ class XAnimIndices : public XAsset
 {
 public:
     explicit XAnimIndices();
-    ~XAnimIndices();
+    ~XAnimIndices() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
     quint32 GetIndex() const;

libs/xassets/xanimnotifyinfo.cpp

@@ -5,19 +5,14 @@ XAnimNotifyInfo::XAnimNotifyInfo()
     , mName(0)
     , mTime(0.0f)
 {
-
+    SetName("Animation Notify Info");
 }
 
-XAnimNotifyInfo::~XAnimNotifyInfo()
-{
-
-}
-
-void XAnimNotifyInfo::ParseData(QDataStream *aStream) {
+void XAnimNotifyInfo::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
-        *aStream
-            >> mName
-            >> mTime;
+
+        mName = aStream->ParseUInt32(QString("%1 name").arg(GetName()));
+        mTime = aStream->ParseSingle(QString("%1 time").arg(GetName()));
     }
 }
 
@@ -26,19 +21,3 @@ void XAnimNotifyInfo::Clear()
     mName = 0;
     mTime = 0.0f;
 }
-
-quint32 XAnimNotifyInfo::GetName() const {
-    return mName;
-}
-
-void XAnimNotifyInfo::SetName(quint32 name) {
-    mName = name;
-}
-
-float XAnimNotifyInfo::GetTime() const {
-    return mTime;
-}
-
-void XAnimNotifyInfo::SetTime(float time) {
-    mTime = time;
-}

libs/xassets/xanimnotifyinfo.h

@@ -7,17 +7,11 @@ class XAnimNotifyInfo : public XAsset
 {
 public:
     explicit XAnimNotifyInfo();
-    ~XAnimNotifyInfo();
+    ~XAnimNotifyInfo() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
-    quint32 GetName() const;
-    void SetName(quint32 name);
-
-    float GetTime() const;
-    void SetTime(float time);
-
 private:
     quint32 mName;
     float mTime;

libs/xassets/xanimparts.cpp

@@ -31,68 +31,49 @@ XAnimParts::XAnimParts()
     , mDeltaPart()
 {
     SetType(ASSET_TYPE_XANIMPARTS);
-    SetName("XAnimParts");
+    SetName("Animation Parts");
 }
 
-XAnimParts::~XAnimParts()
-{
-
-}
-
-void XAnimParts::ParseData(QDataStream *aStream) {
+void XAnimParts::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
 
         mName.ParsePtr(aStream, false);
 
         // Parse all fields
-        *aStream
-            >> mDataByteCount
-            >> mDataShortCount
-            >> mDataIntCount
-            >> mRandomDataByteCount
-            >> mRandomDataIntCount
-            >> mNumFrames;
+        mDataByteCount = aStream->ParseUInt32(QString("%1 data byte count").arg(GetName()));
+        mDataShortCount = aStream->ParseUInt32(QString("%1 data short count").arg(GetName()));
+        mDataIntCount = aStream->ParseUInt32(QString("%1 data int count").arg(GetName()));
+        mRandomDataByteCount = aStream->ParseUInt32(QString("%1 random date byte count").arg(GetName()));
+        mRandomDataIntCount = aStream->ParseUInt32(QString("%1 random data int count").arg(GetName()));
+        mNumFrames = aStream->ParseUInt32(QString("%1 # frames").arg(GetName()));
 
-        quint8 loopDelta;
-        *aStream >> loopDelta;
+        quint8 loopDelta = aStream->ParseUInt8(QString("%1 loop delta").arg(GetName()));
         mIsLoop = (loopDelta & 0x1) != 0;
         mIsDelta = (loopDelta & 0x2) != 0;
 
         for (int i = 0; i < 12; i++)
         {
-            *aStream >> mBoneCount[i];
+            mBoneCount[i] = aStream->ParseUInt8(QString("%1 bone count %2").arg(GetName()).arg(i));
         }
 
-        *aStream
-            >> mNotifyCount
-            >> mAssetType;
-
-        quint32 pad;
-        *aStream >> pad;
-        mPad = (pad != 0);
+        mNotifyCount = aStream->ParseUInt8(QString("%1 notify count").arg(GetName()));
+        mAssetType = aStream->ParseUInt8(QString("%1 asset type").arg(GetName()));
+        mPad = aStream->ParseUInt32(QString("%1 pad").arg(GetName())) != 0;
 
         qint32 namesPtr, dataBytePtr, dataShortPtr, dataIntPtr,
             randomDataShortPtr, randomDataBytePtr, randomDataIntPtr;
 
-        *aStream
-            >> mRandomDataShortCount
-            >> mIndexCount
-            >> mFramerate
-            >> mFrequency
-            >> namesPtr
-            >> mNames
-            >> dataBytePtr
-            >> mDataByte
-            >> dataShortPtr
-            >> mDataShort
-            >> dataIntPtr
-            >> mDataInt
-            >> randomDataShortPtr
-            >> mRandomDataShort
-            >> randomDataBytePtr
-            >> mRandomDataByte
-            >> randomDataIntPtr
-            >> mRandomDataInt;
+        mRandomDataShortCount = aStream->ParseUInt32(QString("%1 random data short count").arg(GetName()));
+        mIndexCount = aStream->ParseUInt32(QString("%1 index count").arg(GetName()));
+        mFramerate = aStream->ParseSingle(QString("%1 frame rate").arg(GetName()));
+        mFrequency = aStream->ParseSingle(QString("%1 frequency").arg(GetName()));
+        namesPtr = aStream->ParseInt32(QString("%1 names ptr").arg(GetName()));
+        dataBytePtr = aStream->ParseInt32(QString("%1 data byte ptr").arg(GetName()));
+        dataShortPtr = aStream->ParseInt32(QString("%1 data short ptr").arg(GetName()));
+        dataIntPtr = aStream->ParseInt32(QString("%1 data int ptr").arg(GetName()));
+        randomDataShortPtr = aStream->ParseInt32(QString("%1 random data short ptr").arg(GetName()));
+        randomDataBytePtr = aStream->ParseInt32(QString("%1 random data byte ptr").arg(GetName()));
+        randomDataIntPtr = aStream->ParseInt32(QString("%1 random data int ptr").arg(GetName()));
 
         // Parse indices
         mIndices.ParseData(aStream);
@@ -102,33 +83,33 @@ void XAnimParts::ParseData(QDataStream *aStream) {
         mName.ParseData(aStream);
         if (namesPtr)
         {
-
+            mNames = aStream->ParseInt32(QString("%1 names").arg(GetName()));
         }
         mNotify.ParseData(aStream);
         mDeltaPart.ParseData(aStream);
         if (dataBytePtr)
         {
-            *aStream >> mDataByte;
+            mDataByte = aStream->ParseUInt8(QString("%1 data byte").arg(GetName()));
         }
         if (dataShortPtr)
         {
-            *aStream >> mDataShort;
+            mDataShort = aStream->ParseInt16(QString("%1 data short").arg(GetName()));
         }
         if (dataIntPtr)
         {
-            *aStream >> mDataInt;
+            mDataInt = aStream->ParseInt32(QString("%1 data int").arg(GetName()));
         }
         if (randomDataShortPtr)
         {
-            *aStream >> mDataInt;
+            mRandomDataShort = aStream->ParseInt16(QString("%1 random data short").arg(GetName()));
         }
         if (randomDataBytePtr)
         {
-            *aStream >> mRandomDataByte;
+            mRandomDataByte = aStream->ParseUInt8(QString("%1 random data byte").arg(GetName()));
         }
         if (randomDataIntPtr)
         {
-            *aStream >> mRandomDataInt;
+            mRandomDataInt = aStream->ParseInt32(QString("%1 random data int").arg(GetName()));
         }
         mIndices.ParseData(aStream);
     }

libs/xassets/xanimparts.h

@@ -13,9 +13,9 @@ class XAnimParts : public XAsset
 {
 public:
     explicit XAnimParts();
-    ~XAnimParts();
+    ~XAnimParts() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:
@@ -43,13 +43,13 @@ private:
     float mFramerate = 0.0f;
     float mFrequency = 0.0f;
 
-    quint32 mNames = 0;
+    quint16 mNames = 0;
     quint8 mDataByte = 0;
     qint16 mDataShort = 0;
-    int mDataInt = 0;
+    qint32 mDataInt = 0;
     qint16 mRandomDataShort = 0;
     quint8 mRandomDataByte = 0;
-    int mRandomDataInt = 0;
+    qint32 mRandomDataInt = 0;
     XAnimIndices mIndices;
     XAnimNotifyInfo mNotify;
     XAnimDeltaPart mDeltaPart;

libs/xassets/xanimparttrans.cpp

@@ -6,6 +6,7 @@ XAnimPartTrans::XAnimPartTrans()
     , mIsSmallTrans(false)
     , mData()
 {
+    SetName("Animation Part Trans");
 }
 
 XAnimPartTrans::XAnimPartTrans(const XAnimPartTrans &aSrc)
@@ -17,18 +18,10 @@ XAnimPartTrans::XAnimPartTrans(const XAnimPartTrans &aSrc)
 
 }
 
-XAnimPartTrans::~XAnimPartTrans()
-{
-
-}
-
-void XAnimPartTrans::ParseData(QDataStream *aStream) {
+void XAnimPartTrans::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
-        quint8 smallTransByte;
-        *aStream
-            >> mSize
-            >> smallTransByte;
-        mIsSmallTrans = (smallTransByte != 0);
+        mSize = aStream->ParseUInt32(QString("%1 size").arg(GetName()));
+        mIsSmallTrans = aStream->ParseUInt8(QString("%1 is small trans").arg(GetName())) != 0;
 
         // Parse data
         mData.ParseData(aStream);

libs/xassets/xanimparttrans.h

@@ -9,9 +9,9 @@ class XAnimPartTrans : public XAsset
 public:
     explicit XAnimPartTrans();
     XAnimPartTrans(const XAnimPartTrans& aSrc);
-    ~XAnimPartTrans();
+    ~XAnimPartTrans() = default;
 
-    void ParseData(QDataStream* aStream) override;
+    void ParseData(XDataStream* aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xanimparttransdata.cpp

@@ -5,6 +5,7 @@ XAnimPartTransData::XAnimPartTransData()
     , mFrames()
     , mFrame()
 {
+    SetName("Animation Part Trans Data");
 }
 
 XAnimPartTransData::XAnimPartTransData(const XAnimPartTransData &aSrc)
@@ -15,12 +16,7 @@ XAnimPartTransData::XAnimPartTransData(const XAnimPartTransData &aSrc)
 
 }
 
-XAnimPartTransData::~XAnimPartTransData()
-{
-
-}
-
-void XAnimPartTransData::ParseData(QDataStream *aStream) {
+void XAnimPartTransData::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
         // We need to determine which part of the union to parse
         // For simplicity, we'll assume it's always frames for now

libs/xassets/xanimparttransdata.h

@@ -9,9 +9,9 @@ class XAnimPartTransData : public XAsset
 public:
     explicit XAnimPartTransData();
     XAnimPartTransData(const XAnimPartTransData &aSrc);
-    ~XAnimPartTransData();
+    ~XAnimPartTransData() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xanimparttransframes.cpp

@@ -7,22 +7,17 @@ XAnimPartTransFrames::XAnimPartTransFrames()
     , mFrames()
     , mIndices()
 {
+    SetName("Animation Parts Trans Frames");
 }
 
-XAnimPartTransFrames::~XAnimPartTransFrames()
-{
-
-}
-
-void XAnimPartTransFrames::ParseData(QDataStream *aStream) {
+void XAnimPartTransFrames::ParseData(XDataStream *aStream) {
     if (GetPtr() == -1) {
-        *aStream
-            >> mMins[0]
-            >> mMins[1]
-            >> mMins[2]
-            >> mMaxs[0]
-            >> mMaxs[1]
-            >> mMaxs[2];
+        mMins[0] = aStream->ParseSingle(QString("%1 min %2").arg(GetName()).arg(0));
+        mMins[1] = aStream->ParseSingle(QString("%1 min %2").arg(GetName()).arg(1));
+        mMins[2] = aStream->ParseSingle(QString("%1 min %2").arg(GetName()).arg(2));
+        mMaxs[0] = aStream->ParseSingle(QString("%1 max %2").arg(GetName()).arg(0));
+        mMaxs[1] = aStream->ParseSingle(QString("%1 max %2").arg(GetName()).arg(1));
+        mMaxs[2] = aStream->ParseSingle(QString("%1 max %2").arg(GetName()).arg(2));
 
         // Parse frames
         mFrames.ParseData(aStream);

libs/xassets/xanimparttransframes.h

@@ -11,9 +11,9 @@ class XAnimPartTransFrames : public XAsset
 {
 public:
     explicit XAnimPartTransFrames();
-    ~XAnimPartTransFrames();
+    ~XAnimPartTransFrames() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
 private:

libs/xassets/xasset.cpp

@@ -19,8 +19,6 @@
 #include "xstringtable.h"
 #include "xweapondef.h"
 
-XAsset::
-
 XAsset::XAsset()
     : mPtr(0)
     , mType(ASSET_TYPE_NONE)
@@ -29,11 +27,6 @@ XAsset::XAsset()
 
 }
 
-XAsset::~XAsset()
-{
-
-}
-
 void XAsset::SetPtr(qint32 aPtr) {
     mPtr = aPtr;
 }
@@ -83,20 +76,9 @@ void XAsset::Clear()
     mType = ASSET_TYPE_NONE;
 }
 
-void XAsset::ParsePtr(QDataStream *aStream, bool aDataFlag) {
-    *aStream >> mPtr;
-    if (mDebug)
-    {
-        // Always treat as unsigned when displaying in hex
-        quint64 raw = static_cast<quint64>(static_cast<quint32>(mPtr));
-
-        QString hexPtr = QString("0x%1")
-                             .arg(raw, 8, 16, QLatin1Char('0'))
-                             .toUpper();
-
-        qDebug() << QString("[%1] Parsed %2 ptr %3 (%4)").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(GetName()).arg(mPtr).arg(hexPtr);
-    }
+void XAsset::ParsePtr(XDataStream *aStream, bool aDataFlag) {
 
+    mPtr = aStream->ParseInt32(QString("%1 ptr").arg(GetName()));
     if (aDataFlag && mPtr == -1)
     {
         ParseData(aStream);
@@ -105,10 +87,6 @@ void XAsset::ParsePtr(QDataStream *aStream, bool aDataFlag) {
 
 XAsset* XAsset::Create(XAssetType aAssetType)
 {
-    if (mDebug)
-    {
-        qDebug() << QString("Creating XAsset with type %1").arg(XAssetTypeToString(aAssetType));
-    }
     switch (aAssetType)
     {
     case ASSET_TYPE_XANIMPARTS:

libs/xassets/xasset.h

@@ -3,7 +3,7 @@
 
 #include "xassettype.h"
 
-#include <QDataStream>
+#include "xdatastream.h"
 #include <QString>
 #include <QDebug>
 #include <QIODevice>
@@ -12,7 +12,7 @@ class XAsset
 {
 public:
     XAsset();
-    virtual ~XAsset();
+    virtual ~XAsset() = default;
 
     void SetPtr(qint32 aPtr);
     qint32 GetPtr() const;
@@ -27,8 +27,8 @@ public:
     bool IsDebug() const;
 
     virtual void Clear();
-    virtual void ParsePtr(QDataStream *aStream, bool aDataFlag = true);
-    virtual void ParseData(QDataStream *aStream) = 0;
+    virtual void ParsePtr(XDataStream *aStream, bool aDataFlag = true);
+    virtual void ParseData(XDataStream *aStream) = 0;
 
     static XAsset* Create(XAssetType aAssetType);
     static QString XAssetTypeToString(XAssetType type);

libs/xassets/xassetheader.cpp

@@ -3,41 +3,39 @@
 
 XAssetHeader::XAssetHeader()
     : XAsset()
+    , mRawType(0)
     , mAssetType()
     , mAssetPtr(0)
     , mZoneFile(nullptr)
 {
-
+    SetName("Asset Header");
 }
 
 XAssetHeader::XAssetHeader(ZoneFile *aZoneFile)
     : XAsset()
+    , mRawType(0)
     , mAssetType()
     , mAssetPtr(0)
     , mZoneFile(aZoneFile)
 {
-
+    SetName("Asset Header");
 }
 
-XAssetHeader::~XAssetHeader()
+void XAssetHeader::ParseData(XDataStream *aStream)
 {
+    mRawType = aStream->ParseUInt32(QString("%1 raw type").arg(GetName()));
+    mAssetPtr = aStream->ParseInt32(QString("%1 asset ptr").arg(GetName()));
 
-}
+    mAssetType = mZoneFile->GetType(mRawType);
 
-void XAssetHeader::ParseData(QDataStream *aStream)
-{
-    quint32 rawAssetType;
-    *aStream
-        >> rawAssetType
-        >> mAssetPtr;
-
-    mAssetType = mZoneFile->GetType(rawAssetType);
+    qDebug() << "Found asset:" << XAssetTypeToString(mAssetType) << QString::number(mRawType, 16);
 }
 
 void XAssetHeader::Clear()
 {
     mAssetType = ASSET_TYPE_NONE;
     mAssetPtr = 0;
+    mRawType = 0;
 }
 
 XAssetType XAssetHeader::GetAssetType() const
@@ -45,6 +43,11 @@ XAssetType XAssetHeader::GetAssetType() const
     return mAssetType;
 }
 
+quint32 XAssetHeader::GetRawAssetType() const
+{
+    return mRawType;
+}
+
 qint32 XAssetHeader::GetAssetPtr() const
 {
     return mAssetPtr;

libs/xassets/xassetheader.h

@@ -10,15 +10,17 @@ class XAssetHeader: public XAsset
 public:
     explicit XAssetHeader();
     XAssetHeader(ZoneFile* aZoneFile);
-    ~XAssetHeader();
+    ~XAssetHeader() = default;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
     XAssetType GetAssetType() const;
+    quint32 GetRawAssetType() const;
     qint32 GetAssetPtr() const;
 
 private:
+    quint32 mRawType;
     XAssetType mAssetType;
     qint32 mAssetPtr;
     ZoneFile *mZoneFile;

libs/xassets/xassetlist.cpp

@@ -10,6 +10,8 @@ XAssetList::XAssetList()
     , mAssetHeaders()
     , mZoneFile(nullptr)
 {
+    SetType(ASSET_TYPE_ASSETLIST);
+    SetName("Asset List");
 }
 
 XAssetList::XAssetList(ZoneFile* aZoneFile)
@@ -29,30 +31,23 @@ XAssetList::~XAssetList()
     
 }
 
-void XAssetList::ParseData(QDataStream *aStream) {
+void XAssetList::ParseData(XDataStream *aStream) {
     // Parse string list
     if (IsDebug())
     {
         qDebug() << QString("[%1] Parsing data for %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(GetName());
     }
-    mStringList.ParsePtr(aStream);
+    mStringList.ParsePtr(aStream, false);
 
     // Parse asset count and assets
-    qint32 assetsPtr;
-    *aStream
-        >> mAssetCount
-        >> assetsPtr;
-    if (IsDebug())
-    {
-        qDebug() << QString("[%1] mAssetCount = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(mAssetCount);
-        qDebug() << QString("[%1] assetsPtr = %2").arg(aStream->device()->pos(), 10, 10, QChar('0')).arg(assetsPtr);
-    }
+    mAssetCount = aStream->ParseUInt32(QString("%1 asset count").arg(GetName()));
+    qint32 assetsPtr = aStream->ParseInt32(QString("%1 assets ptr").arg(GetName()));
 
     mStringList.ParseData(aStream);
 
     if (assetsPtr)
     {
-        for (int i = 0; i < mAssetCount; i++)
+        for (quint32 i = 0; i < mAssetCount; i++)
         {
             XAssetHeader assetHeader(mZoneFile);
             assetHeader.ParseData(aStream);
@@ -62,13 +57,21 @@ void XAssetList::ParseData(QDataStream *aStream) {
 
         for (int i = 0; i < mAssetHeaders.size(); i++)
         {
+            if (aStream->device()->pos() > 98000)
+            {
+                qDebug() << "test";
+            }
             XAssetHeader assetHeader = mAssetHeaders[i];
             XAsset* asset = XAsset::Create(assetHeader.GetAssetType());
+            if (asset)
+            {
+                asset->SetPtr(assetHeader.GetAssetPtr());
                 asset->ParseData(aStream);
 
                 mAssets.append(asset);
             }
         }
+    }
 }
 
 void XAssetList::Clear()

libs/xassets/xassetlist.h

@@ -14,9 +14,9 @@ class XAssetList : public XAsset
 public:
     explicit XAssetList();
     XAssetList(ZoneFile* aZoneFile);
-    ~XAssetList();
+    ~XAssetList() override;
 
-    void ParseData(QDataStream *aStream) override;
+    void ParseData(XDataStream *aStream) override;
     void Clear() override;
 
     XScriptStringList GetStringList() const;

libs/xassets/xaudiochannelmap.cpp

@@ -5,7 +5,7 @@ XAudioChannelMap::XAudioChannelMap()
     , mEntryCount(0)
     , mEntries(QVector<XAudioChannelMapEntry*>())
 {
-
+    SetName("Audio Channel Map");
 }
 
 XAudioChannelMap::~XAudioChannelMap()
@@ -32,15 +32,13 @@ void XAudioChannelMap::SetMapEntry(int aIndex, XAudioChannelMapEntry *aEntry)
     mEntries[aIndex] = aEntry;
 }
 
-void XAudioChannelMap::ParseData(QDataStream *aStream)
+void XAudioChannelMap::ParseData(XDataStream *aStream)
 {
-    *aStream >> mEntryCount;
+    mEntryCount = aStream->ParseUInt8(QString("%1 entry count").arg(GetName()));
 
     aStream->skipRawData(3);
 
-    quint32 entriesPtr;
-    *aStream >> entriesPtr;
-
+    quint32 entriesPtr = aStream->ParseInt32(QString("%1 entries ptr").arg(GetName()));
     if (entriesPtr)
     {
         mEntries.resize(mEntryCount);

libs/xassets/xaudiochannelmap.h

@@ -17,7 +17,7 @@ public:
     XAudioChannelMapEntry* GetMapEntry(int aIndex) const;
     void SetMapEntry(int aIndex, XAudioChannelMapEntry* aEntry);
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xaudiochannelmapentry.cpp

@@ -6,7 +6,7 @@ XAudioChannelMapEntry::XAudioChannelMapEntry()
     , mOutputChannel(0)
     , mVolume(0.0)
 {
-    
+    SetName("Audio Channel Map Entry");
 }
 
 XAudioChannelMapEntry::~XAudioChannelMapEntry()
@@ -44,16 +44,15 @@ void XAudioChannelMapEntry::SetVolume(float aVolume)
     mVolume = aVolume;
 }
 
-void XAudioChannelMapEntry::ParseData(QDataStream *aStream)
+void XAudioChannelMapEntry::ParseData(XDataStream *aStream)
 {
-    *aStream
-        >> mInputChannel
-        >> mOutputChannel;
+    mInputChannel = aStream->ParseUInt8(QString("%1 input channel").arg(GetName()));
+    mOutputChannel = aStream->ParseUInt8(QString("%1 output channel").arg(GetName()));
 
     // Skip padding bytes in struct
     aStream->skipRawData(2);
 
-    *aStream >> mVolume;
+    mVolume = aStream->ParseSingle(QString("%1 volume").arg(GetName()));
 }
 
 void XAudioChannelMapEntry::Clear()

libs/xassets/xaudiochannelmapentry.h

@@ -18,7 +18,7 @@ public:
     float GetVolume() const;
     void SetVolume(float aVolume);
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xaudioformatinfo.cpp

@@ -1,8 +1,10 @@
 #include "xaudioformatinfo.h"
 
 XAudioFormatInfo::XAudioFormatInfo()
+    : XAsset()
+    , mStream()
 {
-
+    SetName("Audio Format Info");
 }
 
 XAudioFormatInfo::~XAudioFormatInfo()
@@ -10,12 +12,14 @@ XAudioFormatInfo::~XAudioFormatInfo()
 
 }
 
-void XAudioFormatInfo::ParseData(QDataStream *aStream)
+void XAudioFormatInfo::ParseData(XDataStream *aStream)
 {
+    Q_UNUSED(aStream);
 
+    // TODO: Implement ParseData(...) for XAudioFormatInfo
 }
 
 void XAudioFormatInfo::Clear()
 {
-
+    mStream.clear();
 }

libs/xassets/xaudioformatinfo.h

@@ -2,22 +2,21 @@
 #define XAUDIOFORMATINFO_H
 
 #include "xasset.h"
+#include "xaudioxmaformat.h"
 
 #include <QVector>
 
-class XAudioXmaFormat;
-
 class XAudioFormatInfo : public XAsset
 {
 public:
-    XAudioFormatInfo();
+    explicit XAudioFormatInfo();
     ~XAudioFormatInfo();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:
-    QVector<XAudioXmaFormat*> mStream;
+    QVector<XAudioXmaFormat> mStream;
 };
 
 #endif // XAUDIOFORMATINFO_H

libs/xassets/xaudiopacketaligned.cpp

@@ -8,7 +8,7 @@ XAudioPacketAligned::XAudioPacketAligned()
     , aXmaLoop()
     , mContext()
 {
-    
+    SetName("Audio Packet Aligned");
 }
 
 XAudioPacketAligned::~XAudioPacketAligned()
@@ -16,14 +16,11 @@ XAudioPacketAligned::~XAudioPacketAligned()
     
 }
 
-void XAudioPacketAligned::ParseData(QDataStream *aStream)
+void XAudioPacketAligned::ParseData(XDataStream *aStream)
 {
-    qint32 bufferPtr, contextPtr;
-
-    *aStream
-        >> bufferPtr
-        >> mBufferSize
-        >> mLoopCount;
+    qint32 bufferPtr = aStream->ParseInt32(QString("%1 buffer ptr").arg(GetName()));
+    mBufferSize = aStream->ParseUInt32(QString("%1 buffer size").arg(GetName()));
+    mLoopCount = aStream->ParseUInt32(QString("%1 loop count").arg(GetName()));
 
     for (int i = 0; i < 6; i++)
     {
@@ -31,15 +28,16 @@ void XAudioPacketAligned::ParseData(QDataStream *aStream)
         loop.ParseData(aStream);
     }
 
-    *aStream >> contextPtr;
+    qint32 contextPtr = aStream->ParseInt32(QString("%1 context ptr").arg(GetName()));
 
     if (bufferPtr)
     {
         aStream->readRawData(mBuffer.data(), mBufferSize);
     }
+
     if (contextPtr)
     {
-        *aStream >> mContext;
+        mContext = aStream->ParseInt8(QString("%1 context").arg(GetName()));
     }
 }
 

libs/xassets/xaudiopacketaligned.h

@@ -12,7 +12,7 @@ public:
     XAudioPacketAligned();
     ~XAudioPacketAligned();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xaudioreverbsettings.cpp

@@ -5,7 +5,7 @@ XAudioReverbSettings::XAudioReverbSettings()
     , mPresetOverridden(0)
     , mReverbSettings(new XReverbSettings())
 {
-
+    SetName("Audio Reverb Settings");
 }
 
 void XAudioReverbSettings::Clear()
@@ -24,12 +24,11 @@ XReverbSettings* XAudioReverbSettings::GetReverbSettings() const
     return mReverbSettings;
 }
 
-void XAudioReverbSettings::ParseData(QDataStream *aStream)
+void XAudioReverbSettings::ParseData(XDataStream *aStream)
 {
     if (GetPtr())
     {
-        *aStream
-            >> mPresetOverridden;
+        mPresetOverridden = aStream->ParseInt32(QString("%1 preset overidden").arg(GetName()));
 
         if (mReverbSettings != nullptr)
         {

libs/xassets/xaudioreverbsettings.h

@@ -16,10 +16,10 @@ public:
     void SetReverbSettings(XReverbSettings* aReverbSettings);
 
     virtual void Clear() override;
-    virtual void ParseData(QDataStream *aStream) override;
+    virtual void ParseData(XDataStream *aStream) override;
 
 private:
-    int mPresetOverridden;
+    qint32 mPresetOverridden;
     XReverbSettings* mReverbSettings;
 };
 

libs/xassets/xaudioseektable.cpp

@@ -5,7 +5,7 @@ XAudioSeekTable::XAudioSeekTable()
     , mSize(0)
     , mData()
 {
-
+    SetName("Audio Seek Table");
 }
 
 XAudioSeekTable::~XAudioSeekTable()
@@ -13,13 +13,11 @@ XAudioSeekTable::~XAudioSeekTable()
 
 }
 
-void XAudioSeekTable::ParseData(QDataStream *aStream)
+void XAudioSeekTable::ParseData(XDataStream *aStream)
 {
-    qint32 dataPtr;
-    *aStream
-        >> mSize
-        >> dataPtr;
+    mSize = aStream->ParseUInt32(QString("%1 size").arg(GetName()));
 
+    qint32 dataPtr = aStream->ParseInt32(QString("%1 data ptr").arg(GetName()));
     if (dataPtr)
     {
         aStream->readRawData(mData.data(), 4 * mSize);

libs/xassets/xaudioseektable.h

@@ -11,7 +11,7 @@ public:
     XAudioSeekTable();
     ~XAudioSeekTable();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xaudiosound.cpp

@@ -7,7 +7,7 @@ XAudioSound::XAudioSound()
     , mXmaDataInfo()
     , mSeekTable()
 {
-
+    SetName("Audio Sound");
 }
 
 XAudioSound::~XAudioSound()
@@ -15,7 +15,7 @@ XAudioSound::~XAudioSound()
 
 }
 
-void XAudioSound::ParseData(QDataStream *aStream)
+void XAudioSound::ParseData(XDataStream *aStream)
 {
     mPacket.ParseData(aStream);
     mFormat.ParseData(aStream);

libs/xassets/xaudiosound.h

@@ -13,7 +13,7 @@ public:
     XAudioSound();
     ~XAudioSound();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xaudiosourceformat.cpp

@@ -1,8 +1,12 @@
 #include "xaudiosourceformat.h"
 
 XAudioSourceFormat::XAudioSourceFormat()
+    : XAsset()
+    , mSampleType(0)
+    , mStreamInfo()
+    , mAudioFormatInfo()
 {
-
+    SetName("Audio Source Format");
 }
 
 XAudioSourceFormat::~XAudioSourceFormat()
@@ -10,12 +14,23 @@ XAudioSourceFormat::~XAudioSourceFormat()
 
 }
 
-void XAudioSourceFormat::ParseData(QDataStream *aStream)
+void XAudioSourceFormat::ParseData(XDataStream *aStream)
 {
+    mSampleType = aStream->ParseUInt8(QString("%1 sample type").arg(GetName()));
 
+    aStream->skipRawData(3);
+
+    mStreamInfo.ParsePtr(aStream, false);
+    mAudioFormatInfo.ParsePtr(aStream, false);
+
+    mStreamInfo.ParseData(aStream);
+    mAudioFormatInfo.ParseData(aStream);
 }
 
 void XAudioSourceFormat::Clear()
 {
 
+    mSampleType = 0;
+    mStreamInfo.Clear();
+    mAudioFormatInfo.Clear();
 }

libs/xassets/xaudiosourceformat.h

@@ -3,22 +3,21 @@
 
 #include "xasset.h"
 #include "xaudioformatinfo.h"
-
-class XAudioStreamInfo;
+#include "xaudiostreaminfo.h"
 
 class XAudioSourceFormat : public XAsset
 {
 public:
-    XAudioSourceFormat();
+    explicit XAudioSourceFormat();
     ~XAudioSourceFormat();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:
     quint8 mSampleType;
-    XAudioStreamInfo* mStreamInfo;
-    XAudioFormatInfo* mAudioFormatInfo;
+    XAudioStreamInfo mStreamInfo;
+    XAudioFormatInfo mAudioFormatInfo;
 };
 
 #endif // XAUDIOSOURCEFORMAT_H

libs/xassets/xaudiostreaminfo.cpp

@@ -1,18 +1,18 @@
 #include "xaudiostreaminfo.h"
 
 XAudioStreamInfo::XAudioStreamInfo()
+    : XAsset()
+    , mNumStreams(0)
+    , mChannelCount(0)
 {
-
+    SetName("Audio Stream Info");
 }
 
-XAudioStreamInfo::~XAudioStreamInfo()
-{
-
-}
-
-void XAudioStreamInfo::ParseData(QDataStream *aStream)
+void XAudioStreamInfo::ParseData(XDataStream *aStream)
 {
+    Q_UNUSED(aStream);
 
+    // TODO: Fill in XAudioStreamInfo::ParseData
 }
 
 void XAudioStreamInfo::Clear()

libs/xassets/xaudiostreaminfo.h

@@ -3,15 +3,13 @@
 
 #include "xasset.h"
 
-class XSoundFileRef;
-
 class XAudioStreamInfo : public XAsset
 {
 public:
-    XAudioStreamInfo();
-    ~XAudioStreamInfo();
+    explicit XAudioStreamInfo();
+    ~XAudioStreamInfo() = default;
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:

libs/xassets/xaudioxmadatainfo.cpp

@@ -1,8 +1,10 @@
 #include "xaudioxmadatainfo.h"
 
 XAudioXmaDataInfo::XAudioXmaDataInfo()
+    : XAsset()
+    , mTotalMsec(0)
 {
-
+    SetName("Audio XMA Data Info");
 }
 
 XAudioXmaDataInfo::~XAudioXmaDataInfo()
@@ -10,12 +12,12 @@ XAudioXmaDataInfo::~XAudioXmaDataInfo()
 
 }
 
-void XAudioXmaDataInfo::ParseData(QDataStream *aStream)
+void XAudioXmaDataInfo::ParseData(XDataStream *aStream)
 {
-
+    mTotalMsec = aStream->ParseInt32(QString("%1 total msec").arg(GetName()));
 }
 
 void XAudioXmaDataInfo::Clear()
 {
-
+    mTotalMsec = 0;
 }

libs/xassets/xaudioxmadatainfo.h

@@ -11,11 +11,11 @@ public:
     XAudioXmaDataInfo();
     ~XAudioXmaDataInfo();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private:
-    int mTotalMsec;
+    qint32 mTotalMsec;
 };
 
 #endif // XAUDIOXMADATAINFO_H

libs/xassets/xaudioxmaformat.cpp

@@ -1,8 +1,12 @@
 #include "xaudioxmaformat.h"
 
 XAudioXmaFormat::XAudioXmaFormat()
+    : XAsset()
+    , mSampleRate(0)
+    , mChannelCount(0)
+    , mDecodeBufferSize(0)
 {
-
+    SetName("Audio XMA Format");
 }
 
 XAudioXmaFormat::~XAudioXmaFormat()
@@ -10,12 +14,16 @@ XAudioXmaFormat::~XAudioXmaFormat()
 
 }
 
-void XAudioXmaFormat::ParseData(QDataStream *aStream)
+void XAudioXmaFormat::ParseData(XDataStream *aStream)
 {
-
+    mSampleRate = aStream->ParseUInt32(QString("%1 sample rate").arg(GetName()));
+    mChannelCount = aStream->ParseUInt8(QString("%1 channel count").arg(GetName()));
+    mDecodeBufferSize = aStream->ParseUInt8(QString("%1 decode buffer size").arg(GetName()));
 }
 
 void XAudioXmaFormat::Clear()
 {
-
+    mSampleRate = 0;
+    mChannelCount = 0;
+    mDecodeBufferSize = 0;
 }

libs/xassets/xaudioxmaformat.h

@@ -9,7 +9,7 @@ public:
     XAudioXmaFormat();
     ~XAudioXmaFormat();
 
-    virtual void ParseData(QDataStream* aStream) override;
+    virtual void ParseData(XDataStream* aStream) override;
     virtual void Clear() override;
 
 private: