Revision control
++ // SPDX-License-Identifier: BSD-3-Clause
++ // Copyright (c) 2025, Syoyo Fujita and many contributors.
++ // All rights reserved.
++ //
++ // StreamReader: Simple header-only stream reader with endian support
++ //
++ // Part of TinyEXR V2 API (EXPERIMENTAL)
++
++ #ifndef TINYEXR_STREAMREADER_HH_
++ #define TINYEXR_STREAMREADER_HH_
++
++ #include <cstdint>
++ #include <cstring>
++
++ namespace tinyexr {
++
++ enum class Endian {
++ Little,
++ Big,
++ Native
++ };
++
++ class StreamReader {
++ public:
++ // Constructor: takes memory address, length, and endianness
++ StreamReader(const uint8_t* data, size_t length, Endian endian = Endian::Little)
++ : data_(data), length_(length), pos_(0), endian_(endian) {
++ // Detect native endian
++ uint16_t test = 0x0001;
++ native_is_little_ = (*reinterpret_cast<uint8_t*>(&test) == 0x01);
++
++ // Determine if we need to swap bytes
++ if (endian_ == Endian::Native) {
++ needs_swap_ = false;
++ } else {
++ bool data_is_little = (endian_ == Endian::Little);
++ needs_swap_ = (data_is_little != native_is_little_);
++ }
++ }
++
++ // Read n bytes into destination buffer
++ // Returns false on out-of-bounds or error
++ bool read(size_t n, uint8_t* dst) {
++ if (!dst || n == 0) {
++ return false;
++ }
++ if (pos_ + n > length_) {
++ return false; // Out of bounds
++ }
++ std::memcpy(dst, data_ + pos_, n);
++ pos_ += n;
++ return true;
++ }
++
++ // Read 1 byte (uint8_t)
++ bool read1(uint8_t* dst) {
++ return read(1, dst);
++ }
++
++ // Read 2 bytes (uint16_t) with endian swap if needed
++ bool read2(uint16_t* dst) {
++ if (!dst) {
++ return false;
++ }
++ uint8_t buf[2];
++ if (!read(2, buf)) {
++ return false;
++ }
++
++ if (needs_swap_) {
++ *dst = static_cast<uint16_t>(buf[1]) << 8 |
++ static_cast<uint16_t>(buf[0]);
++ } else {
++ std::memcpy(dst, buf, 2);
++ }
++ return true;
++ }
++
++ // Read 4 bytes (uint32_t) with endian swap if needed
++ bool read4(uint32_t* dst) {
++ if (!dst) {
++ return false;
++ }
++ uint8_t buf[4];
++ if (!read(4, buf)) {
++ return false;
++ }
++
++ if (needs_swap_) {
++ *dst = static_cast<uint32_t>(buf[3]) << 24 |
++ static_cast<uint32_t>(buf[2]) << 16 |
++ static_cast<uint32_t>(buf[1]) << 8 |
++ static_cast<uint32_t>(buf[0]);
++ } else {
++ std::memcpy(dst, buf, 4);
++ }
++ return true;
++ }
++
++ // Read 8 bytes (uint64_t) with endian swap if needed
++ bool read8(uint64_t* dst) {
++ if (!dst) {
++ return false;
++ }
++ uint8_t buf[8];
++ if (!read(8, buf)) {
++ return false;
++ }
++
++ if (needs_swap_) {
++ *dst = static_cast<uint64_t>(buf[7]) << 56 |
++ static_cast<uint64_t>(buf[6]) << 48 |
++ static_cast<uint64_t>(buf[5]) << 40 |
++ static_cast<uint64_t>(buf[4]) << 32 |
++ static_cast<uint64_t>(buf[3]) << 24 |
++ static_cast<uint64_t>(buf[2]) << 16 |
++ static_cast<uint64_t>(buf[1]) << 8 |
++ static_cast<uint64_t>(buf[0]);
++ } else {
++ std::memcpy(dst, buf, 8);
++ }
++ return true;
++ }
++
++ // Seek to absolute position
++ // Returns false if position is out of bounds
++ bool seek(size_t pos) {
++ if (pos > length_) {
++ return false;
++ }
++ pos_ = pos;
++ return true;
++ }
++
++ // Rewind to beginning
++ void rewind() {
++ pos_ = 0;
++ }
++
++ // Get current position
++ size_t tell() const {
++ return pos_;
++ }
++
++ // Get remaining bytes
++ size_t remaining() const {
++ return length_ - pos_;
++ }
++
++ // Check if at end
++ bool eof() const {
++ return pos_ >= length_;
++ }
++
++ // Get total length
++ size_t length() const {
++ return length_;
++ }
++
++ private:
++ const uint8_t* data_;
++ size_t length_;
++ size_t pos_;
++ Endian endian_;
++ bool native_is_little_;
++ bool needs_swap_;
++ };
++
++ } // namespace tinyexr
++
++ #endif // TINYEXR_STREAMREADER_HH_