mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-14 21:59:17 +00:00
340 lines
9.1 KiB
C++
340 lines
9.1 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
*/
|
|
|
|
#ifndef COMMON_MEMSTREAM_H
|
|
#define COMMON_MEMSTREAM_H
|
|
|
|
#include "common/stream.h"
|
|
#include "common/types.h"
|
|
#include "common/util.h"
|
|
|
|
namespace Common {
|
|
|
|
/**
|
|
* Simple memory based 'stream', which implements the ReadStream interface for
|
|
* a plain memory block.
|
|
*/
|
|
class MemoryReadStream : virtual public SeekableReadStream {
|
|
private:
|
|
const byte * const _ptrOrig;
|
|
const byte *_ptr;
|
|
const uint32 _size;
|
|
uint32 _pos;
|
|
DisposeAfterUse::Flag _disposeMemory;
|
|
bool _eos;
|
|
|
|
public:
|
|
|
|
/**
|
|
* This constructor takes a pointer to a memory buffer and a length, and
|
|
* wraps it. If disposeMemory is true, the MemoryReadStream takes ownership
|
|
* of the buffer and hence free's it when destructed.
|
|
*/
|
|
MemoryReadStream(const byte *dataPtr, uint32 dataSize, DisposeAfterUse::Flag disposeMemory = DisposeAfterUse::NO) :
|
|
_ptrOrig(dataPtr),
|
|
_ptr(dataPtr),
|
|
_size(dataSize),
|
|
_pos(0),
|
|
_disposeMemory(disposeMemory),
|
|
_eos(false) {}
|
|
|
|
~MemoryReadStream() {
|
|
if (_disposeMemory)
|
|
free(const_cast<byte *>(_ptrOrig));
|
|
}
|
|
|
|
uint32 read(void *dataPtr, uint32 dataSize);
|
|
|
|
bool eos() const { return _eos; }
|
|
void clearErr() { _eos = false; }
|
|
|
|
int32 pos() const { return _pos; }
|
|
int32 size() const { return _size; }
|
|
|
|
bool seek(int32 offs, int whence = SEEK_SET);
|
|
};
|
|
|
|
|
|
/**
|
|
* This is a MemoryReadStream subclass which adds non-endian
|
|
* read methods whose endianness is set on the stream creation.
|
|
*/
|
|
class MemoryReadStreamEndian : public MemoryReadStream, public SeekableReadStreamEndian {
|
|
public:
|
|
MemoryReadStreamEndian(const byte *buf, uint32 len, bool bigEndian, DisposeAfterUse::Flag disposeMemory = DisposeAfterUse::NO)
|
|
: MemoryReadStream(buf, len, disposeMemory), SeekableReadStreamEndian(bigEndian), ReadStreamEndian(bigEndian) {}
|
|
|
|
int32 pos() const { return MemoryReadStream::pos(); }
|
|
int32 size() const { return MemoryReadStream::size(); }
|
|
|
|
bool seek(int32 offs, int whence = SEEK_SET) { return MemoryReadStream::seek(offs, whence); }
|
|
|
|
bool skip(uint32 offset) { return MemoryReadStream::seek(offset, SEEK_CUR); }
|
|
};
|
|
|
|
/**
|
|
* Simple memory based 'stream', which implements the WriteStream interface for
|
|
* a plain memory block.
|
|
*/
|
|
class MemoryWriteStream : public SeekableWriteStream {
|
|
private:
|
|
const uint32 _bufSize;
|
|
protected:
|
|
byte *_ptr;
|
|
uint32 _pos;
|
|
bool _err;
|
|
public:
|
|
MemoryWriteStream(byte *buf, uint32 len) : _ptr(buf), _bufSize(len), _pos(0), _err(false) {}
|
|
|
|
uint32 write(const void *dataPtr, uint32 dataSize) override {
|
|
// Write at most as many bytes as are still available...
|
|
if (dataSize > _bufSize - _pos) {
|
|
dataSize = _bufSize - _pos;
|
|
// We couldn't write all the data => set error indicator
|
|
_err = true;
|
|
}
|
|
memcpy(_ptr, dataPtr, dataSize);
|
|
_ptr += dataSize;
|
|
_pos += dataSize;
|
|
return dataSize;
|
|
}
|
|
|
|
virtual int32 pos() const override { return _pos; }
|
|
virtual int32 size() const override { return _bufSize; }
|
|
|
|
virtual bool err() const override { return _err; }
|
|
virtual void clearErr() override { _err = false; }
|
|
|
|
virtual bool seek(int32 offset, int whence = SEEK_SET) override { return false; }
|
|
};
|
|
|
|
/**
|
|
* MemoryWriteStream subclass with ability to set stream position indicator.
|
|
*/
|
|
class SeekableMemoryWriteStream : public MemoryWriteStream {
|
|
private:
|
|
byte *_ptrOrig;
|
|
public:
|
|
SeekableMemoryWriteStream(byte *buf, uint32 len) : MemoryWriteStream(buf, len), _ptrOrig(buf) {}
|
|
|
|
virtual bool seek(int32 offset, int whence = SEEK_SET) override {
|
|
switch (whence) {
|
|
case SEEK_END:
|
|
// SEEK_END works just like SEEK_SET, only 'reversed',
|
|
// i.e. from the end.
|
|
offset = size() + offset;
|
|
// Fall through
|
|
case SEEK_SET:
|
|
// Fall through
|
|
default:
|
|
_ptr = _ptrOrig + offset;
|
|
_pos = offset;
|
|
break;
|
|
case SEEK_CUR:
|
|
_ptr += offset;
|
|
_pos += offset;
|
|
break;
|
|
}
|
|
// Post-Condition
|
|
if ((int32)_pos > size()) {
|
|
_pos = size();
|
|
_ptr = _ptrOrig + _pos;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
|
|
/**
|
|
* A sort of hybrid between MemoryWriteStream and Array classes. A stream
|
|
* that grows as it's written to.
|
|
*/
|
|
class MemoryWriteStreamDynamic : public SeekableWriteStream {
|
|
protected:
|
|
uint32 _capacity;
|
|
uint32 _size;
|
|
byte *_ptr;
|
|
byte *_data;
|
|
uint32 _pos;
|
|
DisposeAfterUse::Flag _disposeMemory;
|
|
|
|
void ensureCapacity(uint32 new_len) {
|
|
if (new_len <= _capacity)
|
|
return;
|
|
|
|
byte *old_data = _data;
|
|
|
|
_capacity = MAX(new_len + 32, _capacity * 2);
|
|
_data = (byte *)malloc(_capacity);
|
|
_ptr = _data + _pos;
|
|
|
|
if (old_data) {
|
|
// Copy old data
|
|
memcpy(_data, old_data, _size);
|
|
free(old_data);
|
|
}
|
|
|
|
_size = new_len;
|
|
}
|
|
public:
|
|
explicit MemoryWriteStreamDynamic(DisposeAfterUse::Flag disposeMemory) : _capacity(0), _size(0), _ptr(nullptr), _data(nullptr), _pos(0), _disposeMemory(disposeMemory) {}
|
|
|
|
~MemoryWriteStreamDynamic() {
|
|
if (_disposeMemory)
|
|
free(_data);
|
|
}
|
|
|
|
uint32 write(const void *dataPtr, uint32 dataSize) override {
|
|
ensureCapacity(_pos + dataSize);
|
|
memcpy(_ptr, dataPtr, dataSize);
|
|
_ptr += dataSize;
|
|
_pos += dataSize;
|
|
if (_pos > _size)
|
|
_size = _pos;
|
|
return dataSize;
|
|
}
|
|
|
|
virtual int32 pos() const override { return _pos; }
|
|
virtual int32 size() const override { return _size; }
|
|
|
|
byte *getData() { return _data; }
|
|
|
|
virtual bool seek(int32 offs, int whence = SEEK_SET) override {
|
|
// Pre-Condition
|
|
assert(_pos <= _size);
|
|
switch (whence) {
|
|
case SEEK_END:
|
|
// SEEK_END works just like SEEK_SET, only 'reversed', i.e. from the end.
|
|
offs = _size + offs;
|
|
// Fall through
|
|
case SEEK_SET:
|
|
// Fall through
|
|
default:
|
|
_ptr = _data + offs;
|
|
_pos = offs;
|
|
break;
|
|
|
|
case SEEK_CUR:
|
|
_ptr += offs;
|
|
_pos += offs;
|
|
break;
|
|
}
|
|
|
|
assert(_pos <= _size);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* MemoryStream based on RingBuffer. Grows if has insufficient buffer size.
|
|
*/
|
|
class MemoryReadWriteStream : public SeekableReadStream, public SeekableWriteStream {
|
|
private:
|
|
uint32 _capacity;
|
|
uint32 _size;
|
|
byte *_data;
|
|
uint32 _writePos, _readPos, _pos, _length;
|
|
DisposeAfterUse::Flag _disposeMemory;
|
|
bool _eos;
|
|
|
|
void ensureCapacity(uint32 new_len) {
|
|
if (new_len <= _capacity)
|
|
return;
|
|
|
|
byte *old_data = _data;
|
|
uint32 oldCapacity = _capacity;
|
|
|
|
_capacity = MAX(new_len + 32, _capacity * 2);
|
|
_data = (byte *)malloc(_capacity);
|
|
|
|
if (old_data) {
|
|
// Copy old data
|
|
if (_readPos < _writePos) {
|
|
memcpy(_data, old_data + _readPos, _writePos - _readPos);
|
|
_writePos = _length;
|
|
_readPos = 0;
|
|
} else {
|
|
memcpy(_data, old_data + _readPos, oldCapacity - _readPos);
|
|
memcpy(_data + oldCapacity - _readPos, old_data, _writePos);
|
|
_writePos = _length;
|
|
_readPos = 0;
|
|
}
|
|
free(old_data);
|
|
}
|
|
}
|
|
public:
|
|
explicit MemoryReadWriteStream(DisposeAfterUse::Flag disposeMemory) : _capacity(0), _size(0), _data(nullptr), _writePos(0), _readPos(0), _pos(0), _length(0), _disposeMemory(disposeMemory), _eos(false) {}
|
|
|
|
~MemoryReadWriteStream() {
|
|
if (_disposeMemory)
|
|
free(_data);
|
|
}
|
|
|
|
uint32 write(const void *dataPtr, uint32 dataSize) override {
|
|
ensureCapacity(_length + dataSize);
|
|
if (_writePos + dataSize < _capacity) {
|
|
memcpy(_data + _writePos, dataPtr, dataSize);
|
|
} else {
|
|
memcpy(_data + _writePos, dataPtr, _capacity - _writePos);
|
|
const byte *shiftedPtr = (const byte *)dataPtr + _capacity - _writePos;
|
|
memcpy(_data, shiftedPtr, dataSize - (_capacity - _writePos));
|
|
}
|
|
_writePos = (_writePos + dataSize) % _capacity;
|
|
_pos += dataSize;
|
|
_length += dataSize;
|
|
if (_pos > _size)
|
|
_size = _pos;
|
|
return dataSize;
|
|
}
|
|
|
|
virtual uint32 read(void *dataPtr, uint32 dataSize) override {
|
|
if (_length < dataSize) {
|
|
dataSize = _length;
|
|
_eos = true;
|
|
}
|
|
if (dataSize == 0 || _capacity == 0) return 0;
|
|
if (_readPos + dataSize < _capacity) {
|
|
memcpy(dataPtr, _data + _readPos, dataSize);
|
|
} else {
|
|
memcpy(dataPtr, _data + _readPos, _capacity - _readPos);
|
|
byte *shiftedPtr = (byte *)dataPtr + _capacity - _readPos;
|
|
memcpy(shiftedPtr, _data, dataSize - (_capacity - _readPos));
|
|
}
|
|
_readPos = (_readPos + dataSize) % _capacity;
|
|
_length -= dataSize;
|
|
return dataSize;
|
|
}
|
|
|
|
virtual int32 pos() const override { return _pos - _length; }
|
|
virtual int32 size() const override { return _size; }
|
|
virtual bool seek(int32, int) override { return false; }
|
|
virtual bool eos() const override { return _eos; }
|
|
virtual void clearErr() override { _eos = false; }
|
|
|
|
byte *getData() { return _data; }
|
|
};
|
|
|
|
} // End of namespace Common
|
|
|
|
#endif
|