Initial commit

engines/ags/shared/util/buffered_stream.cpp

@@ -0,0 +1,210 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+//include <cstring>
+#include "common/std/algorithm.h"
+#include "ags/shared/util/buffered_stream.h"
+#include "ags/shared/util/stdio_compat.h"
+#include "ags/shared/util/string.h"
+
+namespace AGS3 {
+namespace AGS {
+namespace Shared {
+
+//-----------------------------------------------------------------------------
+// BufferedStream
+//-----------------------------------------------------------------------------
+
+const size_t BufferedStream::BufferSize;
+
+BufferedStream::BufferedStream(const String &file_name, FileOpenMode open_mode, FileWorkMode work_mode, DataEndianess stream_endianess)
+	: FileStream(file_name, open_mode, work_mode, stream_endianess) {
+	if (IsValid()) {
+		soff_t end_pos = FileStream::Seek(0, kSeekEnd);
+		if (end_pos >= 0) {
+			_start = 0;
+			_end = end_pos;
+			if (FileStream::Seek(0, kSeekBegin) < 0)
+				_end = -1;
+		}
+
+		if (_end == -1) {
+			FileStream::Close();
+			error("Error determining stream end.");
+		}
+	}
+}
+
+BufferedStream::~BufferedStream() {
+	BufferedStream::Close();
+}
+
+void BufferedStream::FillBufferFromPosition(soff_t position) {
+	FileStream::Seek(position, kSeekBegin);
+	// remember to restrict to the end position!
+	size_t fill_size = std::min(BufferSize, static_cast<size_t>(_end - position));
+	_buffer.resize(fill_size);
+	auto sz = FileStream::Read(_buffer.data(), fill_size);
+	_buffer.resize(sz);
+	_bufferPosition = position;
+}
+
+void BufferedStream::FlushBuffer(soff_t position) {
+	size_t sz = _buffer.size() > 0 ? FileStream::Write(_buffer.data(), _buffer.size()) : 0u;
+	_buffer.clear(); // will start from the clean buffer next time
+	_bufferPosition += sz;
+	if (position != _bufferPosition) {
+		FileStream::Seek(position, kSeekBegin);
+		_bufferPosition = position;
+	}
+}
+
+bool BufferedStream::EOS() const {
+	return _position == _end;
+}
+
+soff_t BufferedStream::GetLength() const {
+	return _end - _start;
+}
+
+soff_t BufferedStream::GetPosition() const {
+	return _position - _start;
+}
+
+void BufferedStream::Close() {
+	if (GetWorkMode() == kFile_Write)
+		FlushBuffer(_position);
+	FileStream::Close();
+}
+
+bool BufferedStream::Flush() {
+	if (GetWorkMode() == kFile_Write)
+		FlushBuffer(_position);
+	return FileStream::Flush();
+}
+
+size_t BufferedStream::Read(void *buffer, size_t size) {
+	// If the read size is larger than the internal buffer size,
+	// then read directly into the user buffer and bail out.
+	if (size >= BufferSize) {
+		FileStream::Seek(_position, kSeekBegin);
+		// remember to restrict to the end position!
+		size_t fill_size = std::min(size, static_cast<size_t>(_end - _position));
+		size_t sz = FileStream::Read(buffer, fill_size);
+		_position += sz;
+		return sz;
+	}
+
+	auto *to = static_cast<uint8_t*>(buffer);
+
+	while(size > 0) {
+		if (_position < _bufferPosition || _position >= _bufferPosition + _buffer.size()) {
+			FillBufferFromPosition(_position);
+		}
+		if (_buffer.empty()) { break; } // reached EOS
+		assert(_position >= _bufferPosition && _position < _bufferPosition + _buffer.size());
+
+		soff_t bufferOffset = _position - _bufferPosition;
+		assert(bufferOffset >= 0);
+		size_t bytesLeft = _buffer.size() - (size_t)bufferOffset;
+		size_t chunkSize = MIN<size_t>(bytesLeft, size);
+
+		memcpy(to, _buffer.data() + bufferOffset, chunkSize);
+
+		to += chunkSize;
+		_position += chunkSize;
+		size -= chunkSize;
+	}
+	return to - static_cast<uint8_t*>(buffer);
+}
+
+int32_t BufferedStream::ReadByte() {
+	uint8_t ch;
+	auto bytesRead = Read(&ch, 1);
+	if (bytesRead != 1) {
+		return EOF;
+	}
+	return ch;
+}
+
+size_t BufferedStream::Write(const void *buffer, size_t size) {
+	const uint8_t *from = static_cast<const uint8_t*>(buffer);
+	while (size > 0) {
+		if (_position < _bufferPosition || // seek'd before buffer pos
+			_position > _bufferPosition + _buffer.size() || // seek'd beyond buffer pos
+			_position >= _bufferPosition + (soff_t) BufferSize) // seek'd, or exceeded buffer limit
+		{
+			FlushBuffer(_position);
+		}
+		size_t pos_in_buff = static_cast<size_t>(_position - _bufferPosition);
+		size_t chunk_sz = std::min(size, BufferSize - pos_in_buff);
+		if (_buffer.size() < pos_in_buff + chunk_sz)
+			_buffer.resize(pos_in_buff + chunk_sz);
+		memcpy(_buffer.data() + pos_in_buff, from, chunk_sz);
+		_position += chunk_sz;
+		from += chunk_sz;
+		size -= chunk_sz;
+	}
+
+	_end = std::max(_end, _position);
+	return from - static_cast<const uint8_t*>(buffer);
+
+}
+
+int32_t BufferedStream::WriteByte(uint8_t val) {
+	auto sz = Write(&val, 1);
+	if (sz != 1) {
+		return -1;
+	}
+	return val;
+}
+
+soff_t BufferedStream::Seek(soff_t offset, StreamSeek origin) {
+	soff_t want_pos = -1;
+	switch (origin) {
+		case StreamSeek::kSeekCurrent:  want_pos = _position + offset; break;
+		case StreamSeek::kSeekBegin:    want_pos = _start + offset; break;
+		case StreamSeek::kSeekEnd:      want_pos = _end + offset; break;
+		default: return -1;
+	}
+	// clamp to the valid range
+	_position = MIN(MAX(want_pos, _start), _end);
+	return _position - _start; // convert to a stream section pos
+}
+
+//-----------------------------------------------------------------------------
+// BufferedSectionStream
+//-----------------------------------------------------------------------------
+
+BufferedSectionStream::BufferedSectionStream(const String &file_name, soff_t start_pos, soff_t end_pos,
+	FileOpenMode open_mode, FileWorkMode work_mode, DataEndianess stream_endianess)
+	: BufferedStream(file_name, open_mode, work_mode, stream_endianess) {
+	assert(start_pos <= end_pos);
+	start_pos = MIN(start_pos, end_pos);
+	_start = MIN(start_pos, _end);
+	_end = MIN(end_pos, _end);
+	BufferedStream::Seek(0, kSeekBegin);
+}
+
+
+} // namespace Shared
+} // namespace AGS
+} // namespace AGS3