stream: Implement RamStream

CMakeLists.txt

@@ -216,9 +216,12 @@ add_library(sead OBJECT
   modules/src/resource/seadSZSDecompressor.cpp
 
   include/stream/seadBufferStream.h
+  include/stream/seadRamStream.h
   include/stream/seadStream.h
   include/stream/seadStreamFormat.h
   include/stream/seadStreamSrc.h
+  modules/src/stream/seadRamStream.cpp
+  modules/src/stream/seadStream.cpp
 
   include/thread/seadAtomic.h
   include/thread/seadCriticalSection.h

include/stream/seadRamStream.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "stream/seadStream.h"
+#include "stream/seadStreamSrc.h"
+
+namespace sead
+{
+class RamStreamSrc : public StreamSrc
+{
+public:
+    RamStreamSrc(void* buffer, u32 bufferSize);
+    ~RamStreamSrc() override;
+
+    u32 read(void* data, u32 size) override;
+    u32 write(const void* data, u32 size) override;
+    u32 skip(s32 offset) override;
+    void rewind() override;
+    bool isEOF() override;
+
+private:
+    u8* mBuffer = nullptr;
+    u32 mBufferSize = 0;
+    u32 mCurrentPos = 0;
+};
+
+class RamReadStream : public ReadStream
+{
+public:
+    RamReadStream(const void* buffer, u32 buffer_size, Stream::Modes mode);
+    RamReadStream(const void* buffer, u32 buffer_size, StreamFormat* format);
+    ~RamReadStream() override;
+
+private:
+    RamStreamSrc mSrc;
+};
+
+class RamWriteStream : public WriteStream
+{
+public:
+    RamWriteStream(void* buffer, u32 buffer_size, Stream::Modes mode);
+    RamWriteStream(void* buffer, u32 buffer_size, StreamFormat* format);
+    ~RamWriteStream() override;
+
+private:
+    RamStreamSrc mSrc;
+};
+
+}  // namespace sead

include/stream/seadStream.h

@@ -23,8 +23,8 @@ class Stream
     Stream(StreamSrc* src, StreamFormat* format);
     virtual ~Stream() = default;
 
-    void skip(u32);
-    void skip(u32, u32);
+    void skip(u32 bytes);
+    void skip(u32 blockSize, u32 count);
     void rewind();
     bool isEOF();
 
@@ -33,66 +33,74 @@ class Stream
     void setUserFormat(StreamFormat* format);
 
 protected:
-    StreamFormat* mFormat;
-    StreamSrc* mSrc;
-    Endian::Types mEndian;
+    static StreamFormat* BASIC_STREAM_FORMAT[2];
+
+    void setSrc(StreamSrc* src) { mSrc = src; }
+
+    StreamFormat* mFormat = nullptr;
+    StreamSrc* mSrc = nullptr;
+    Endian::Types mEndian = Endian::getHostEndian();
 };
 
 class ReadStream : public Stream
 {
 public:
     u8 readU8();
-    void readU8(u8&);
+    void readU8(u8& value);
     u16 readU16();
-    void readU16(u16&);
+    void readU16(u16& value);
     u32 readU32();
-    void readU32(u32&);
+    void readU32(u32& value);
     u64 readU64();
-    void readU64(u64&);
+    void readU64(u64& value);
     s8 readS8();
-    void readS8(s8&);
+    void readS8(s8& value);
     s16 readS16();
-    void readS16(s16&);
+    void readS16(s16& value);
     s32 readS32();
-    void readS32(s32&);
+    void readS32(s32& value);
     s64 readS64();
-    void readS64(s64&);
+    void readS64(s64& value);
     f32 readF32();
-    void readF32(f32&);
-    void readBit(void*, u32);
-    void readString(BufferedSafeString*, u32);
-    u32 readMemBlock(void*, u32);
+    void readF32(f32& value);
+    void readBit(void* data, u32 bits);
+    void readString(BufferedSafeString* str, u32 size);
+    u32 readMemBlock(void* buffer, u32 size);
 
 private:
-    f32 readF32BitImpl_(u32, u32);
-    f64 readF64BitImpl_(u32, u32);
+    f32 readF32BitImpl_(u32 integerBits, u32 fractionalBits);
+    f64 readF64BitImpl_(u32 integerBits, u32 fractionalBits);
 };
 
 class WriteStream : public ReadStream
 {
 public:
-    ~WriteStream() override = default;
+    ~WriteStream() override
+    {
+        if (mSrc)
+            flush();
+    }
 
-    void writeU8(u8);
-    void writeU16(u16);
-    void writeU32(u32);
-    void writeU64(u64);
-    void writeS8(s8);
-    void writeS16(s16);
-    void writeS32(s32);
-    void writeS64(s64);
-    void writeF32(f32);
-    void writeBit(const void*, u32);
-    void writeString(const SafeString&, u32);
-    void writeMemBlock(const void*, u32);
-    void writeComment(const SafeString&);
-    void writeLineComment(const SafeString&);
-    void writeDecorationText(const SafeString&);
+    void writeU8(u8 value);
+    void writeU16(u16 value);
+    void writeU32(u32 value);
+    void writeU64(u64 value);
+    void writeS8(s8 value);
+    void writeS16(s16 value);
+    void writeS32(s32 value);
+    void writeS64(s64 value);
+    void writeF32(f32 value);
+    void writeBit(const void* data, u32 bits);
+    void writeString(const SafeString& str, u32 size);
+    void writeMemBlock(const void* buffer, u32 size);
+    void writeComment(const SafeString& comment);
+    void writeLineComment(const SafeString& comment);
+    void writeDecorationText(const SafeString& text);
     void writeNullChar();
     void flush();
 
 private:
-    void writeF32BitImpl_(f32, u32, u32);
-    void writeF64BitImpl_(f64, u32, u32);
+    void writeF32BitImpl_(f32 value, u32 integerBits, u32 fractionalBits);
+    void writeF64BitImpl_(f64 value, u32 integerBits, u32 fractionalBits);
 };
 }  // namespace sead

include/stream/seadStreamFormat.h

@@ -41,4 +41,73 @@ class StreamFormat
     virtual void flush(StreamSrc*) = 0;
     virtual void rewind(StreamSrc*) = 0;
 };
+
+class BinaryStreamFormat : public StreamFormat
+{
+public:
+    u8 readU8(StreamSrc*, Endian::Types) override;
+    u16 readU16(StreamSrc*, Endian::Types) override;
+    u32 readU32(StreamSrc*, Endian::Types) override;
+    u64 readU64(StreamSrc*, Endian::Types) override;
+    s8 readS8(StreamSrc*, Endian::Types) override;
+    s16 readS16(StreamSrc*, Endian::Types) override;
+    s32 readS32(StreamSrc*, Endian::Types) override;
+    s64 readS64(StreamSrc*, Endian::Types) override;
+    f32 readF32(StreamSrc*, Endian::Types) override;
+    void readBit(StreamSrc*, void*, u32) override;
+    void readString(StreamSrc*, BufferedSafeString*, u32) override;
+    u32 readMemBlock(StreamSrc*, void*, u32) override;
+    void writeU8(StreamSrc*, Endian::Types, u8) override;
+    void writeU16(StreamSrc*, Endian::Types, u16) override;
+    void writeU32(StreamSrc*, Endian::Types, u32) override;
+    void writeU64(StreamSrc*, Endian::Types, u64) override;
+    void writeS8(StreamSrc*, Endian::Types, s8) override;
+    void writeS16(StreamSrc*, Endian::Types, s16) override;
+    void writeS32(StreamSrc*, Endian::Types, s32) override;
+    void writeS64(StreamSrc*, Endian::Types, s64) override;
+    void writeF32(StreamSrc*, Endian::Types, f32) override;
+    void writeBit(StreamSrc*, const void*, u32) override;
+    void writeString(StreamSrc*, const SafeString&, u32) override;
+    void writeMemBlock(StreamSrc*, const void*, u32) override;
+    void writeDecorationText(StreamSrc*, const SafeString&) override;
+    void writeNullChar(StreamSrc*) override;
+    void skip(StreamSrc*, u32) override;
+    void flush(StreamSrc*) override;
+    void rewind(StreamSrc*) override;
+};
+
+class TextStreamFormat : public StreamFormat
+{
+public:
+    u8 readU8(StreamSrc*, Endian::Types) override;
+    u16 readU16(StreamSrc*, Endian::Types) override;
+    u32 readU32(StreamSrc*, Endian::Types) override;
+    u64 readU64(StreamSrc*, Endian::Types) override;
+    s8 readS8(StreamSrc*, Endian::Types) override;
+    s16 readS16(StreamSrc*, Endian::Types) override;
+    s32 readS32(StreamSrc*, Endian::Types) override;
+    s64 readS64(StreamSrc*, Endian::Types) override;
+    f32 readF32(StreamSrc*, Endian::Types) override;
+    void readBit(StreamSrc*, void*, u32) override;
+    void readString(StreamSrc*, BufferedSafeString*, u32) override;
+    u32 readMemBlock(StreamSrc*, void*, u32) override;
+    void writeU8(StreamSrc*, Endian::Types, u8) override;
+    void writeU16(StreamSrc*, Endian::Types, u16) override;
+    void writeU32(StreamSrc*, Endian::Types, u32) override;
+    void writeU64(StreamSrc*, Endian::Types, u64) override;
+    void writeS8(StreamSrc*, Endian::Types, s8) override;
+    void writeS16(StreamSrc*, Endian::Types, s16) override;
+    void writeS32(StreamSrc*, Endian::Types, s32) override;
+    void writeS64(StreamSrc*, Endian::Types, s64) override;
+    void writeF32(StreamSrc*, Endian::Types, f32) override;
+    void writeBit(StreamSrc*, const void*, u32) override;
+    void writeString(StreamSrc*, const SafeString&, u32) override;
+    void writeMemBlock(StreamSrc*, const void*, u32) override;
+    void writeDecorationText(StreamSrc*, const SafeString&) override;
+    void writeNullChar(StreamSrc*) override;
+    void skip(StreamSrc*, u32) override;
+    void flush(StreamSrc*) override;
+    void rewind(StreamSrc*) override;
+};
+
 }  // namespace sead

include/stream/seadStreamSrc.h

@@ -13,5 +13,7 @@ class StreamSrc
     virtual void rewind() = 0;
     virtual bool isEOF() = 0;
     virtual bool flush() { return true; }
+
+    virtual ~StreamSrc() = default;
 };
 }  // namespace sead

modules/src/stream/seadRamStream.cpp

@@ -0,0 +1,101 @@
+#include "stream/seadRamStream.h"
+
+namespace sead
+{
+RamStreamSrc::RamStreamSrc(void* buffer, u32 bufferSize)
+    : mBuffer(static_cast<u8*>(buffer)), mBufferSize(bufferSize)
+{
+}
+
+RamStreamSrc::~RamStreamSrc() = default;
+
+u32 RamStreamSrc::read(void* data, u32 size)
+{
+    if (mCurrentPos + size > mBufferSize)
+    {
+        size = mBufferSize - mCurrentPos;
+    }
+
+    memcpy(data, mBuffer + mCurrentPos, size);
+    mCurrentPos += size;
+    return size;
+}
+
+u32 RamStreamSrc::write(const void* data, u32 size)
+{
+    if (mCurrentPos + size > mBufferSize)
+    {
+        size = mBufferSize - mCurrentPos;
+    }
+
+    memcpy(mBuffer + mCurrentPos, data, size);
+    mCurrentPos += size;
+    return size;
+}
+
+u32 RamStreamSrc::skip(s32 offset)
+{
+    if (offset > 0 && mCurrentPos + offset > mBufferSize)
+    {
+        offset = mBufferSize - mCurrentPos;
+    }
+
+    if (offset < 0 && mCurrentPos < static_cast<u32>(-offset))
+    {
+        offset = -mCurrentPos;
+    }
+
+    mCurrentPos += offset;
+    return offset;
+}
+
+void RamStreamSrc::rewind()
+{
+    mCurrentPos = 0;
+}
+
+bool RamStreamSrc::isEOF()
+{
+    return mCurrentPos >= mBufferSize;
+}
+
+RamReadStream::RamReadStream(const void* buffer, u32 buffer_size, Stream::Modes mode)
+    : mSrc(const_cast<void*>(buffer), buffer_size)
+{
+    setSrc(&mSrc);
+    setMode(mode);
+}
+
+RamReadStream::RamReadStream(const void* buffer, u32 buffer_size, StreamFormat* format)
+    : mSrc(const_cast<void*>(buffer), buffer_size)
+{
+    setSrc(&mSrc);
+    setUserFormat(format);
+}
+
+RamReadStream::~RamReadStream()
+{
+    setSrc(nullptr);
+}
+
+RamWriteStream::RamWriteStream(void* buffer, u32 buffer_size, Stream::Modes mode)
+    : mSrc(buffer, buffer_size)
+{
+    setSrc(&mSrc);
+    setMode(mode);
+}
+
+RamWriteStream::RamWriteStream(void* buffer, u32 buffer_size, StreamFormat* format)
+    : mSrc(buffer, buffer_size)
+{
+    setSrc(&mSrc);
+    setUserFormat(format);
+}
+
+RamWriteStream::~RamWriteStream()
+{
+    flush();
+    setSrc(nullptr);
+}
+
+}  // namespace sead