aboutsummaryrefslogtreecommitdiff
path: root/common
diff options
context:
space:
mode:
Diffstat (limited to 'common')
-rw-r--r--common/EventDispatcher.cpp12
-rw-r--r--common/EventRecorder.cpp428
-rw-r--r--common/EventRecorder.h110
-rw-r--r--common/debug.h4
-rw-r--r--common/events.h12
-rw-r--r--common/memstream.h37
-rw-r--r--common/module.mk6
-rw-r--r--common/random.cpp9
-rw-r--r--common/recorderfile.cpp708
-rw-r--r--common/recorderfile.h180
-rw-r--r--common/system.cpp11
-rw-r--r--common/system.h18
12 files changed, 972 insertions, 563 deletions
diff --git a/common/EventDispatcher.cpp b/common/EventDispatcher.cpp
index 012a2dfce5..dc123e8f8f 100644
--- a/common/EventDispatcher.cpp
+++ b/common/EventDispatcher.cpp
@@ -38,7 +38,9 @@ EventDispatcher::~EventDispatcher() {
delete i->observer;
}
- delete _mapper;
+ if (_autoFreeMapper) {
+ delete _mapper;
+ }
_mapper = 0;
}
@@ -68,11 +70,15 @@ void EventDispatcher::dispatch() {
}
}
-void EventDispatcher::registerMapper(EventMapper *mapper) {
- delete _mapper;
+void EventDispatcher::registerMapper(EventMapper *mapper, bool autoFree) {
+ if (_autoFreeMapper) {
+ delete _mapper;
+ }
_mapper = mapper;
+ _autoFreeMapper = autoFree;
}
+
void EventDispatcher::registerSource(EventSource *source, bool autoFree) {
SourceEntry newEntry;
diff --git a/common/EventRecorder.cpp b/common/EventRecorder.cpp
deleted file mode 100644
index 5e24f128c3..0000000000
--- a/common/EventRecorder.cpp
+++ /dev/null
@@ -1,428 +0,0 @@
-/* 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.
- *
- */
-
-#include "common/EventRecorder.h"
-
-#include "common/bufferedstream.h"
-#include "common/config-manager.h"
-#include "common/random.h"
-#include "common/savefile.h"
-#include "common/textconsole.h"
-
-namespace Common {
-
-DECLARE_SINGLETON(EventRecorder);
-
-#define RECORD_SIGNATURE 0x54455354
-#define RECORD_VERSION 1
-
-uint32 readTime(ReadStream *inFile) {
- uint32 d = inFile->readByte();
- if (d == 0xff) {
- d = inFile->readUint32LE();
- }
-
- return d;
-}
-
-void writeTime(WriteStream *outFile, uint32 d) {
- //Simple RLE compression
- if (d >= 0xff) {
- outFile->writeByte(0xff);
- outFile->writeUint32LE(d);
- } else {
- outFile->writeByte(d);
- }
-}
-
-void readRecord(SeekableReadStream *inFile, uint32 &diff, Event &event, uint32 &millis) {
- millis = readTime(inFile);
-
- diff = inFile->readUint32LE();
-
- event.type = (EventType)inFile->readUint32LE();
-
- switch (event.type) {
- case EVENT_KEYDOWN:
- case EVENT_KEYUP:
- event.kbd.keycode = (KeyCode)inFile->readSint32LE();
- event.kbd.ascii = inFile->readUint16LE();
- event.kbd.flags = inFile->readByte();
- break;
- case EVENT_MOUSEMOVE:
- case EVENT_LBUTTONDOWN:
- case EVENT_LBUTTONUP:
- case EVENT_RBUTTONDOWN:
- case EVENT_RBUTTONUP:
- case EVENT_WHEELUP:
- case EVENT_WHEELDOWN:
- case EVENT_MBUTTONDOWN:
- case EVENT_MBUTTONUP:
- event.mouse.x = inFile->readSint16LE();
- event.mouse.y = inFile->readSint16LE();
- break;
- default:
- break;
- }
-}
-
-void writeRecord(WriteStream *outFile, uint32 diff, const Event &event, uint32 millis) {
- writeTime(outFile, millis);
-
- outFile->writeUint32LE(diff);
-
- outFile->writeUint32LE((uint32)event.type);
-
- switch (event.type) {
- case EVENT_KEYDOWN:
- case EVENT_KEYUP:
- outFile->writeSint32LE(event.kbd.keycode);
- outFile->writeUint16LE(event.kbd.ascii);
- outFile->writeByte(event.kbd.flags);
- break;
- case EVENT_MOUSEMOVE:
- case EVENT_LBUTTONDOWN:
- case EVENT_LBUTTONUP:
- case EVENT_RBUTTONDOWN:
- case EVENT_RBUTTONUP:
- case EVENT_WHEELUP:
- case EVENT_WHEELDOWN:
- case EVENT_MBUTTONDOWN:
- case EVENT_MBUTTONUP:
- outFile->writeSint16LE(event.mouse.x);
- outFile->writeSint16LE(event.mouse.y);
- break;
- default:
- break;
- }
-}
-
-EventRecorder::EventRecorder() {
- _recordFile = NULL;
- _recordTimeFile = NULL;
- _playbackFile = NULL;
- _playbackTimeFile = NULL;
- _timeMutex = g_system->createMutex();
- _recorderMutex = g_system->createMutex();
-
- _eventCount = 0;
- _lastEventCount = 0;
- _lastMillis = 0;
- _lastEventMillis = 0;
-
- _recordMode = kPassthrough;
-}
-
-EventRecorder::~EventRecorder() {
- deinit();
-
- g_system->deleteMutex(_timeMutex);
- g_system->deleteMutex(_recorderMutex);
-}
-
-void EventRecorder::init() {
- String recordModeString = ConfMan.get("record_mode");
- if (recordModeString.compareToIgnoreCase("record") == 0) {
- _recordMode = kRecorderRecord;
-
- debug(3, "EventRecorder: record");
- } else {
- if (recordModeString.compareToIgnoreCase("playback") == 0) {
- _recordMode = kRecorderPlayback;
- debug(3, "EventRecorder: playback");
- } else {
- _recordMode = kPassthrough;
- debug(3, "EventRecorder: passthrough");
- }
- }
-
- _recordFileName = ConfMan.get("record_file_name");
- if (_recordFileName.empty()) {
- _recordFileName = "record.bin";
- }
- _recordTempFileName = ConfMan.get("record_temp_file_name");
- if (_recordTempFileName.empty()) {
- _recordTempFileName = "record.tmp";
- }
- _recordTimeFileName = ConfMan.get("record_time_file_name");
- if (_recordTimeFileName.empty()) {
- _recordTimeFileName = "record.time";
- }
-
- // recorder stuff
- if (_recordMode == kRecorderRecord) {
- _recordCount = 0;
- _recordTimeCount = 0;
- _recordFile = wrapBufferedWriteStream(g_system->getSavefileManager()->openForSaving(_recordTempFileName), 128 * 1024);
- _recordTimeFile = wrapBufferedWriteStream(g_system->getSavefileManager()->openForSaving(_recordTimeFileName), 128 * 1024);
- _recordSubtitles = ConfMan.getBool("subtitles");
- }
-
- uint32 sign;
- uint32 randomSourceCount;
- if (_recordMode == kRecorderPlayback) {
- _playbackCount = 0;
- _playbackTimeCount = 0;
- _playbackFile = wrapBufferedSeekableReadStream(g_system->getSavefileManager()->openForLoading(_recordFileName), 128 * 1024, DisposeAfterUse::YES);
- _playbackTimeFile = wrapBufferedSeekableReadStream(g_system->getSavefileManager()->openForLoading(_recordTimeFileName), 128 * 1024, DisposeAfterUse::YES);
-
- if (!_playbackFile) {
- warning("Cannot open playback file %s. Playback was switched off", _recordFileName.c_str());
- _recordMode = kPassthrough;
- }
-
- if (!_playbackTimeFile) {
- warning("Cannot open playback time file %s. Playback was switched off", _recordTimeFileName.c_str());
- _recordMode = kPassthrough;
- }
- }
-
- if (_recordMode == kRecorderPlayback) {
- sign = _playbackFile->readUint32LE();
- if (sign != RECORD_SIGNATURE) {
- error("Unknown record file signature");
- }
-
- _playbackFile->readUint32LE(); // version
-
- // conf vars
- ConfMan.setBool("subtitles", _playbackFile->readByte() != 0);
-
- _recordCount = _playbackFile->readUint32LE();
- _recordTimeCount = _playbackFile->readUint32LE();
-
- randomSourceCount = _playbackFile->readUint32LE();
- for (uint i = 0; i < randomSourceCount; ++i) {
- RandomSourceRecord rec;
- rec.name = "";
- uint32 sLen = _playbackFile->readUint32LE();
- for (uint j = 0; j < sLen; ++j) {
- char c = _playbackFile->readSByte();
- rec.name += c;
- }
- rec.seed = _playbackFile->readUint32LE();
- _randomSourceRecords.push_back(rec);
- }
-
- _hasPlaybackEvent = false;
- }
-
- g_system->getEventManager()->getEventDispatcher()->registerSource(this, false);
- g_system->getEventManager()->getEventDispatcher()->registerObserver(this, EventManager::kEventRecorderPriority, false, true);
-}
-
-void EventRecorder::deinit() {
- debug(3, "EventRecorder: deinit");
-
- g_system->getEventManager()->getEventDispatcher()->unregisterSource(this);
- g_system->getEventManager()->getEventDispatcher()->unregisterObserver(this);
-
- g_system->lockMutex(_timeMutex);
- g_system->lockMutex(_recorderMutex);
- _recordMode = kPassthrough;
- g_system->unlockMutex(_timeMutex);
- g_system->unlockMutex(_recorderMutex);
-
- delete _playbackFile;
- delete _playbackTimeFile;
-
- if (_recordFile != NULL) {
- _recordFile->finalize();
- delete _recordFile;
- _recordTimeFile->finalize();
- delete _recordTimeFile;
-
- _playbackFile = g_system->getSavefileManager()->openForLoading(_recordTempFileName);
-
- assert(_playbackFile);
-
- _recordFile = g_system->getSavefileManager()->openForSaving(_recordFileName);
- _recordFile->writeUint32LE(RECORD_SIGNATURE);
- _recordFile->writeUint32LE(RECORD_VERSION);
-
- // conf vars
- _recordFile->writeByte(_recordSubtitles ? 1 : 0);
-
- _recordFile->writeUint32LE(_recordCount);
- _recordFile->writeUint32LE(_recordTimeCount);
-
- _recordFile->writeUint32LE(_randomSourceRecords.size());
- for (uint i = 0; i < _randomSourceRecords.size(); ++i) {
- _recordFile->writeUint32LE(_randomSourceRecords[i].name.size());
- _recordFile->writeString(_randomSourceRecords[i].name);
- _recordFile->writeUint32LE(_randomSourceRecords[i].seed);
- }
-
- for (uint i = 0; i < _recordCount; ++i) {
- uint32 tempDiff;
- Event tempEvent;
- uint32 millis;
- readRecord(_playbackFile, tempDiff, tempEvent, millis);
- writeRecord(_recordFile, tempDiff, tempEvent, millis);
- }
-
- _recordFile->finalize();
- delete _recordFile;
- delete _playbackFile;
-
- //TODO: remove recordTempFileName'ed file
- }
-}
-
-void EventRecorder::registerRandomSource(RandomSource &rnd, const String &name) {
- if (_recordMode == kRecorderRecord) {
- RandomSourceRecord rec;
- rec.name = name;
- rec.seed = rnd.getSeed();
- _randomSourceRecords.push_back(rec);
- }
-
- if (_recordMode == kRecorderPlayback) {
- for (uint i = 0; i < _randomSourceRecords.size(); ++i) {
- if (_randomSourceRecords[i].name == name) {
- rnd.setSeed(_randomSourceRecords[i].seed);
- _randomSourceRecords.remove_at(i);
- break;
- }
- }
- }
-}
-
-void EventRecorder::processMillis(uint32 &millis) {
- uint32 d;
- if (_recordMode == kPassthrough) {
- return;
- }
-
- g_system->lockMutex(_timeMutex);
- if (_recordMode == kRecorderRecord) {
- d = millis - _lastMillis;
- writeTime(_recordTimeFile, d);
-
- _recordTimeCount++;
- }
-
- if (_recordMode == kRecorderPlayback) {
- if (_recordTimeCount > _playbackTimeCount) {
- d = readTime(_playbackTimeFile);
-
- while ((_lastMillis + d > millis) && (_lastMillis + d - millis > 50)) {
- _recordMode = kPassthrough;
- g_system->delayMillis(50);
- millis = g_system->getMillis();
- _recordMode = kRecorderPlayback;
- }
-
- millis = _lastMillis + d;
- _playbackTimeCount++;
- }
- }
-
- _lastMillis = millis;
- g_system->unlockMutex(_timeMutex);
-}
-
-bool EventRecorder::processDelayMillis(uint &msecs) {
- if (_recordMode == kRecorderPlayback) {
- _recordMode = kPassthrough;
-
- uint32 millis = g_system->getMillis();
-
- _recordMode = kRecorderPlayback;
-
- if (_lastMillis > millis) {
- // Skip delay if we're getting late
- return true;
- }
- }
-
- return false;
-}
-
-bool EventRecorder::notifyEvent(const Event &ev) {
- if (_recordMode != kRecorderRecord)
- return false;
-
- StackLock lock(_recorderMutex);
- ++_eventCount;
-
- writeRecord(_recordFile, _eventCount - _lastEventCount, ev, _lastMillis - _lastEventMillis);
-
- _recordCount++;
- _lastEventCount = _eventCount;
- _lastEventMillis = _lastMillis;
-
- return false;
-}
-
-bool EventRecorder::notifyPoll() {
- if (_recordMode != kRecorderRecord)
- return false;
-
- ++_eventCount;
-
- return false;
-}
-
-bool EventRecorder::pollEvent(Event &ev) {
- uint32 millis;
-
- if (_recordMode != kRecorderPlayback)
- return false;
-
- StackLock lock(_recorderMutex);
- ++_eventCount;
-
- if (!_hasPlaybackEvent) {
- if (_recordCount > _playbackCount) {
- readRecord(_playbackFile, const_cast<uint32&>(_playbackDiff), _playbackEvent, millis);
- _playbackCount++;
- _hasPlaybackEvent = true;
- }
- }
-
- if (_hasPlaybackEvent) {
- if (_playbackDiff <= (_eventCount - _lastEventCount)) {
- switch (_playbackEvent.type) {
- case EVENT_MOUSEMOVE:
- case EVENT_LBUTTONDOWN:
- case EVENT_LBUTTONUP:
- case EVENT_RBUTTONDOWN:
- case EVENT_RBUTTONUP:
- case EVENT_WHEELUP:
- case EVENT_WHEELDOWN:
- g_system->warpMouse(_playbackEvent.mouse.x, _playbackEvent.mouse.y);
- break;
- default:
- break;
- }
- ev = _playbackEvent;
- _hasPlaybackEvent = false;
- _lastEventCount = _eventCount;
- return true;
- }
- }
-
- return false;
-}
-
-} // End of namespace Common
diff --git a/common/EventRecorder.h b/common/EventRecorder.h
deleted file mode 100644
index 43a08b08cd..0000000000
--- a/common/EventRecorder.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/* 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_EVENTRECORDER_H
-#define COMMON_EVENTRECORDER_H
-
-#include "common/scummsys.h"
-#include "common/events.h"
-#include "common/singleton.h"
-#include "common/mutex.h"
-#include "common/array.h"
-
-#define g_eventRec (Common::EventRecorder::instance())
-
-namespace Common {
-
-class RandomSource;
-class SeekableReadStream;
-class WriteStream;
-
-/**
- * Our generic event recorder.
- *
- * TODO: Add more documentation.
- */
-class EventRecorder : private EventSource, private EventObserver, public Singleton<EventRecorder> {
- friend class Singleton<SingletonBaseType>;
- EventRecorder();
- ~EventRecorder();
-public:
- void init();
- void deinit();
-
- /** Register random source so it can be serialized in game test purposes */
- void registerRandomSource(RandomSource &rnd, const String &name);
-
- /** TODO: Add documentation, this is only used by the backend */
- void processMillis(uint32 &millis);
-
- /** TODO: Add documentation, this is only used by the backend */
- bool processDelayMillis(uint &msecs);
-
-private:
- bool notifyEvent(const Event &ev);
- bool notifyPoll();
- bool pollEvent(Event &ev);
- bool allowMapping() const { return false; }
-
- class RandomSourceRecord {
- public:
- String name;
- uint32 seed;
- };
- Array<RandomSourceRecord> _randomSourceRecords;
-
- bool _recordSubtitles;
- volatile uint32 _recordCount;
- volatile uint32 _lastRecordEvent;
- volatile uint32 _recordTimeCount;
- volatile uint32 _lastEventMillis;
- WriteStream *_recordFile;
- WriteStream *_recordTimeFile;
- MutexRef _timeMutex;
- MutexRef _recorderMutex;
- volatile uint32 _lastMillis;
-
- volatile uint32 _playbackCount;
- volatile uint32 _playbackDiff;
- volatile bool _hasPlaybackEvent;
- volatile uint32 _playbackTimeCount;
- Event _playbackEvent;
- SeekableReadStream *_playbackFile;
- SeekableReadStream *_playbackTimeFile;
-
- volatile uint32 _eventCount;
- volatile uint32 _lastEventCount;
-
- enum RecordMode {
- kPassthrough = 0,
- kRecorderRecord = 1,
- kRecorderPlayback = 2
- };
- volatile RecordMode _recordMode;
- String _recordFileName;
- String _recordTempFileName;
- String _recordTimeFileName;
-};
-
-} // End of namespace Common
-
-#endif
diff --git a/common/debug.h b/common/debug.h
index dc94839082..859f3c41b3 100644
--- a/common/debug.h
+++ b/common/debug.h
@@ -117,5 +117,9 @@ void debugCN(uint32 debugChannels, const char *s, ...) GCC_PRINTF(2, 3);
*/
extern int gDebugLevel;
+//Global constant for EventRecorder debug channel
+enum GlobalDebugLevels {
+ kDebugLevelEventRec = 1 << 30
+};
#endif
diff --git a/common/events.h b/common/events.h
index 7366c51d36..9029a4096a 100644
--- a/common/events.h
+++ b/common/events.h
@@ -288,11 +288,14 @@ public:
* to the EventDispatcher, thus it will be deleted
* with "delete", when EventDispatcher is destroyed.
*
- * Note there is only one mapper per EventDispatcher
- * possible, thus when this method is called twice,
- * the former mapper will be destroied.
+ * @param autoFree Destroy previous mapper [default]
+ * Normally we allow only one event mapper to exists,
+ * However Event Recorder must intervent into normal
+ * event flow without altering its semantics. Thus during
+ * Event Recorder playback and recording we allow
+ * two mappers.
*/
- void registerMapper(EventMapper *mapper);
+ void registerMapper(EventMapper *mapper, bool autoFree = true);
/**
* Queries the setup event mapper.
@@ -326,6 +329,7 @@ public:
*/
void unregisterObserver(EventObserver *obs);
private:
+ bool _autoFreeMapper;
EventMapper *_mapper;
struct Entry {
diff --git a/common/memstream.h b/common/memstream.h
index 260fb64d84..7fa6500753 100644
--- a/common/memstream.h
+++ b/common/memstream.h
@@ -89,8 +89,9 @@ public:
*/
class MemoryWriteStream : public WriteStream {
private:
- byte *_ptr;
const uint32 _bufSize;
+protected:
+ byte *_ptr;
uint32 _pos;
bool _err;
public:
@@ -117,6 +118,40 @@ public:
};
/**
+ * 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) {}
+ uint32 seek(uint32 offset, int whence = SEEK_SET) {
+ 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:
+ _ptr = _ptrOrig + offset;
+ _pos = offset;
+ break;
+ case SEEK_CUR:
+ _ptr += offset;
+ _pos += offset;
+ break;
+ }
+ // Post-Condition
+ if (_pos > size()) {
+ _pos = size();
+ _ptr = _ptrOrig + _pos;
+ }
+ return _pos;
+ }
+};
+
+
+/**
* A sort of hybrid between MemoryWriteStream and Array classes. A stream
* that grows as it's written to.
*/
diff --git a/common/module.mk b/common/module.mk
index d96b11ee40..9f9126c8ef 100644
--- a/common/module.mk
+++ b/common/module.mk
@@ -10,7 +10,6 @@ MODULE_OBJS := \
error.o \
EventDispatcher.o \
EventMapper.o \
- EventRecorder.o \
file.o \
fs.o \
gui_options.o \
@@ -51,5 +50,10 @@ MODULE_OBJS += \
rdft.o \
sinetables.o
+ifdef ENABLE_EVENTRECORDER
+MODULE_OBJS += \
+ recorderfile.o
+endif
+
# Include common rules
include $(srcdir)/rules.mk
diff --git a/common/random.cpp b/common/random.cpp
index fd75534c44..a74ab831ea 100644
--- a/common/random.cpp
+++ b/common/random.cpp
@@ -21,7 +21,7 @@
#include "common/random.h"
#include "common/system.h"
-#include "common/EventRecorder.h"
+#include "gui/EventRecorder.h"
namespace Common {
@@ -30,13 +30,8 @@ RandomSource::RandomSource(const String &name) {
// Use system time as RNG seed. Normally not a good idea, if you are using
// a RNG for security purposes, but good enough for our purposes.
assert(g_system);
- uint32 seed = g_system->getMillis();
+ uint32 seed = g_eventRec.getRandomSeed(name);
setSeed(seed);
-
- // Register this random source with the event recorder. This may end
- // up querying or resetting the current seed, so we must call it
- // *after* the initial seed has been set.
- g_eventRec.registerRandomSource(*this, name);
}
void RandomSource::setSeed(uint32 seed) {
diff --git a/common/recorderfile.cpp b/common/recorderfile.cpp
new file mode 100644
index 0000000000..60c47e11ce
--- /dev/null
+++ b/common/recorderfile.cpp
@@ -0,0 +1,708 @@
+/* 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.
+ *
+ */
+
+#include "common/system.h"
+#include "gui/EventRecorder.h"
+#include "common/md5.h"
+#include "common/recorderfile.h"
+#include "common/savefile.h"
+#include "common/bufferedstream.h"
+#include "graphics/thumbnail.h"
+#include "graphics/surface.h"
+#include "graphics/scaler.h"
+
+#define RECORD_VERSION 1
+
+namespace Common {
+
+PlaybackFile::PlaybackFile() : _tmpRecordFile(_tmpBuffer, kRecordBuffSize), _tmpPlaybackFile(_tmpBuffer, kRecordBuffSize) {
+ _readStream = NULL;
+ _writeStream = NULL;
+ _screenshotsFile = NULL;
+ _mode = kClosed;
+}
+
+PlaybackFile::~PlaybackFile() {
+ close();
+}
+
+bool PlaybackFile::openWrite(const String &fileName) {
+ close();
+ _header.fileName = fileName;
+ _writeStream = wrapBufferedWriteStream(g_system->getSavefileManager()->openForSaving(fileName), 128 * 1024);
+ _headerDumped = false;
+ _recordCount = 0;
+ if (_writeStream == NULL) {
+ return false;
+ }
+ _mode = kWrite;
+ return true;
+}
+
+bool PlaybackFile::openRead(const String &fileName) {
+ close();
+ _header.fileName = fileName;
+ _eventsSize = 0;
+ _tmpPlaybackFile.seek(0);
+ _readStream = wrapBufferedSeekableReadStream(g_system->getSavefileManager()->openForLoading(fileName), 128 * 1024, DisposeAfterUse::YES);
+ if (_readStream == NULL) {
+ debugC(1, kDebugLevelEventRec, "playback:action=\"Load File\" result=fail reason=\"file %s not found\"", fileName.c_str());
+ return false;
+ }
+ if (!parseHeader()) {
+ debugC(1, kDebugLevelEventRec, "playback:action=\"Load File\" result=fail reason=\"header parsing failed\"");
+ return false;
+ }
+ _screenshotsFile = wrapBufferedWriteStream(g_system->getSavefileManager()->openForSaving("screenshots.bin"), 128 * 1024);
+ debugC(1, kDebugLevelEventRec, "playback:action=\"Load File\" result=success");
+ _mode = kRead;
+ return true;
+}
+
+void PlaybackFile::close() {
+ delete _readStream;
+ _readStream = NULL;
+ if (_writeStream != NULL) {
+ dumpRecordsToFile();
+ _writeStream->finalize();
+ delete _writeStream;
+ _writeStream = NULL;
+ updateHeader();
+ }
+ if (_screenshotsFile != NULL) {
+ _screenshotsFile->finalize();
+ delete _screenshotsFile;
+ _screenshotsFile = NULL;
+ }
+ for (HashMap<String, SaveFileBuffer>::iterator i = _header.saveFiles.begin(); i != _header.saveFiles.end(); ++i) {
+ free(i->_value.buffer);
+ }
+ _header.saveFiles.clear();
+ _mode = kClosed;
+}
+
+bool PlaybackFile::parseHeader() {
+ PlaybackFileHeader result;
+ ChunkHeader nextChunk;
+ _playbackParseState = kFileStateCheckFormat;
+ if (!readChunkHeader(nextChunk)) {
+ _playbackParseState = kFileStateError;
+ return false;
+ }
+ while ((_playbackParseState != kFileStateDone) && (_playbackParseState != kFileStateError)) {
+ if (processChunk(nextChunk)) {
+ if (!readChunkHeader(nextChunk)) {
+ warning("Error in header parsing");
+ _playbackParseState = kFileStateError;
+ }
+ }
+ }
+ return _playbackParseState == kFileStateDone;
+}
+
+bool PlaybackFile::checkPlaybackFileVersion() {
+ uint32 version;
+ version = _readStream->readUint32LE();
+ if (version != RECORD_VERSION) {
+ warning("Incorrect playback file version. Expected version %d, but got %d.", RECORD_VERSION, version);
+ return false;
+ }
+ return true;
+}
+
+
+String PlaybackFile::readString(int len) {
+ String result;
+ char buf[50];
+ int readSize = 49;
+ while (len > 0) {
+ if (len <= 49) {
+ readSize = len;
+ }
+ _readStream->read(buf, readSize);
+ buf[readSize] = 0;
+ result += buf;
+ len -= readSize;
+ }
+ return result;
+}
+
+bool PlaybackFile::readChunkHeader(PlaybackFile::ChunkHeader &nextChunk) {
+ nextChunk.id = (FileTag)_readStream->readUint32LE();
+ nextChunk.len = _readStream->readUint32LE();
+ return !_readStream->err() && !_readStream->eos();
+}
+
+bool PlaybackFile::processChunk(ChunkHeader &nextChunk) {
+ switch (_playbackParseState) {
+ case kFileStateCheckFormat:
+ if (nextChunk.id == kFormatIdTag) {
+ _playbackParseState = kFileStateCheckVersion;
+ } else {
+ warning("Unknown playback file signature");
+ _playbackParseState = kFileStateError;
+ }
+ break;
+ case kFileStateCheckVersion:
+ if ((nextChunk.id == kVersionTag) && checkPlaybackFileVersion()) {
+ _playbackParseState = kFileStateSelectSection;
+ } else {
+ _playbackParseState = kFileStateError;
+ }
+ break;
+ case kFileStateSelectSection:
+ switch (nextChunk.id) {
+ case kHeaderSectionTag:
+ _playbackParseState = kFileStateProcessHeader;
+ break;
+ case kHashSectionTag:
+ _playbackParseState = kFileStateProcessHash;
+ break;
+ case kRandomSectionTag:
+ _playbackParseState = kFileStateProcessRandom;
+ break;
+ case kEventTag:
+ case kScreenShotTag:
+ _readStream->seek(-8, SEEK_CUR);
+ _playbackParseState = kFileStateDone;
+ return false;
+ case kSaveTag:
+ _playbackParseState = kFileStateProcessSave;
+ break;
+ case kSettingsSectionTag:
+ _playbackParseState = kFileStateProcessSettings;
+ warning("Loading record header");
+ break;
+ default:
+ _readStream->skip(nextChunk.len);
+ break;
+ }
+ break;
+ case kFileStateProcessSave:
+ if (nextChunk.id == kSaveRecordTag) {
+ readSaveRecord();
+ } else {
+ _playbackParseState = kFileStateSelectSection;
+ return false;
+ }
+ break;
+ case kFileStateProcessHeader:
+ switch (nextChunk.id) {
+ case kAuthorTag:
+ _header.author = readString(nextChunk.len);
+ break;
+ case kCommentsTag:
+ _header.notes = readString(nextChunk.len);
+ break;
+ case kNameTag:
+ _header.name = readString(nextChunk.len);
+ break;
+ default:
+ _playbackParseState = kFileStateSelectSection;
+ return false;
+ }
+ break;
+ case kFileStateProcessHash:
+ if (nextChunk.id == kHashRecordTag) {
+ readHashMap(nextChunk);
+ } else {
+ _playbackParseState = kFileStateSelectSection;
+ return false;
+ }
+ break;
+ case kFileStateProcessRandom:
+ if (nextChunk.id == kRandomRecordTag) {
+ processRndSeedRecord(nextChunk);
+ } else {
+ _playbackParseState = kFileStateSelectSection;
+ return false;
+ }
+ break;
+ case kFileStateProcessSettings:
+ if (nextChunk.id == kSettingsRecordTag) {
+ if (!processSettingsRecord()) {
+ _playbackParseState = kFileStateError;
+ return false;
+ }
+ } else {
+ _playbackParseState = kFileStateSelectSection;
+ return false;
+ }
+ break;
+ default:
+ return false;
+ }
+ return true;
+}
+
+void PlaybackFile::returnToChunkHeader() {
+ _readStream->seek(-8, SEEK_CUR);
+}
+
+void PlaybackFile::readHashMap(ChunkHeader chunk) {
+ String hashName = readString(chunk.len - 32);
+ String hashMd5 = readString(32);
+ _header.hashRecords[hashName] = hashMd5;
+}
+
+void PlaybackFile::processRndSeedRecord(ChunkHeader chunk) {
+ String randomSourceName = readString(chunk.len - 4);
+ uint32 randomSourceSeed = _readStream->readUint32LE();
+ _header.randomSourceRecords[randomSourceName] = randomSourceSeed;
+}
+
+bool PlaybackFile::processSettingsRecord() {
+ ChunkHeader keyChunk;
+ if (!readChunkHeader(keyChunk) || (keyChunk.id != kSettingsRecordKeyTag)) {
+ warning("Invalid format of settings section");
+ return false;
+ }
+ String key = readString(keyChunk.len);
+ ChunkHeader valueChunk;
+ if (!readChunkHeader(valueChunk) || (valueChunk.id != kSettingsRecordValueTag)) {
+ warning("Invalid format of settings section");
+ return false;
+ }
+ String value = readString(valueChunk.len);
+ _header.settingsRecords[key] = value;
+ return true;
+}
+
+
+bool PlaybackFile::readSaveRecord() {
+ ChunkHeader fileNameChunk;
+ if (!readChunkHeader(fileNameChunk) || (fileNameChunk.id != kSaveRecordNameTag)) {
+ warning("Invalid format of save section");
+ return false;
+ }
+ String fileName = readString(fileNameChunk.len);
+ ChunkHeader saveBufferChunk;
+ if (!readChunkHeader(saveBufferChunk) || (saveBufferChunk.id != kSaveRecordBufferTag)) {
+ warning("Invalid format of save section");
+ return false;
+ }
+ SaveFileBuffer buf;
+ buf.size = saveBufferChunk.len;
+ buf.buffer = (byte *)malloc(saveBufferChunk.len);
+ _readStream->read(buf.buffer, buf.size);
+ _header.saveFiles[fileName] = buf;
+ debugC(1, kDebugLevelEventRec, "playback:action=\"Load save file\" filename=%s len=%d", fileName.c_str(), buf.size);
+ return true;
+}
+
+
+
+RecorderEvent PlaybackFile::getNextEvent() {
+ assert(_mode == kRead);
+ if (isEventsBufferEmpty()) {
+ PlaybackFile::ChunkHeader header;
+ header.id = kFormatIdTag;
+ while (header.id != kEventTag) {
+ if (!readChunkHeader(header) || _readStream->eos()) {
+ break;
+ }
+ switch (header.id) {
+ case kEventTag:
+ readEventsToBuffer(header.len);
+ break;
+ case kScreenShotTag:
+ _readStream->seek(-4, SEEK_CUR);
+ header.len = _readStream->readUint32BE();
+ _readStream->skip(header.len-8);
+ break;
+ case kMD5Tag:
+ checkRecordedMD5();
+ break;
+ default:
+ _readStream->skip(header.len);
+ break;
+ }
+ }
+ }
+ RecorderEvent result;
+ readEvent(result);
+ return result;
+}
+
+bool PlaybackFile::isEventsBufferEmpty() {
+ return (uint32)_tmpPlaybackFile.pos() == _eventsSize;
+}
+
+void PlaybackFile::readEvent(RecorderEvent& event) {
+ event.recordedtype = (RecorderEventType)_tmpPlaybackFile.readByte();
+ switch (event.recordedtype) {
+ case kRecorderEventTypeTimer:
+ event.time = _tmpPlaybackFile.readUint32LE();
+ break;
+ case kRecorderEventTypeNormal:
+ event.type = (EventType)_tmpPlaybackFile.readUint32LE();
+ switch (event.type) {
+ case EVENT_KEYDOWN:
+ case EVENT_KEYUP:
+ event.time = _tmpPlaybackFile.readUint32LE();
+ event.kbd.keycode = (KeyCode)_tmpPlaybackFile.readSint32LE();
+ event.kbd.ascii = _tmpPlaybackFile.readUint16LE();
+ event.kbd.flags = _tmpPlaybackFile.readByte();
+ break;
+ case EVENT_MOUSEMOVE:
+ case EVENT_LBUTTONDOWN:
+ case EVENT_LBUTTONUP:
+ case EVENT_RBUTTONDOWN:
+ case EVENT_RBUTTONUP:
+ case EVENT_WHEELUP:
+ case EVENT_WHEELDOWN:
+ case EVENT_MBUTTONDOWN:
+ case EVENT_MBUTTONUP:
+ event.time = _tmpPlaybackFile.readUint32LE();
+ event.mouse.x = _tmpPlaybackFile.readSint16LE();
+ event.mouse.y = _tmpPlaybackFile.readSint16LE();
+ break;
+ default:
+ event.time = _tmpPlaybackFile.readUint32LE();
+ break;
+ }
+ break;
+ }
+ event.synthetic = true;
+}
+
+void PlaybackFile::readEventsToBuffer(uint32 size) {
+ _readStream->read(_tmpBuffer, size);
+ _tmpPlaybackFile.seek(0);
+ _eventsSize = size;
+}
+
+void PlaybackFile::saveScreenShot(Graphics::Surface &screen, byte md5[16]) {
+ dumpRecordsToFile();
+ _writeStream->writeUint32LE(kMD5Tag);
+ _writeStream->writeUint32LE(16);
+ _writeStream->write(md5, 16);
+ Graphics::saveThumbnail(*_writeStream, screen);
+}
+
+void PlaybackFile::dumpRecordsToFile() {
+ if (!_headerDumped) {
+ dumpHeaderToFile();
+ _headerDumped = true;
+ }
+ if (_recordCount == 0) {
+ return;
+ }
+ _writeStream->writeUint32LE(kEventTag);
+ _writeStream->writeUint32LE(_tmpRecordFile.pos());
+ _writeStream->write(_tmpBuffer, _tmpRecordFile.pos());
+ _tmpRecordFile.seek(0);
+ _recordCount = 0;
+}
+
+void PlaybackFile::dumpHeaderToFile() {
+ _writeStream->writeUint32LE(kFormatIdTag);
+ // Specify size for first tag as NULL since we cannot calculate
+ // size of the file at time of the header dumping
+ _writeStream->writeUint32LE(0);
+ _writeStream->writeUint32LE(kVersionTag);
+ _writeStream->writeUint32LE(4);
+ _writeStream->writeUint32LE(RECORD_VERSION);
+ writeHeaderSection();
+ writeGameHash();
+ writeRandomRecords();
+ writeGameSettings();
+ writeSaveFilesSection();
+}
+
+void PlaybackFile::writeHeaderSection() {
+ uint32 headerSize = 0;
+ if (!_header.author.empty()) {
+ headerSize = _header.author.size() + 8;
+ }
+ if (!_header.notes.empty()) {
+ headerSize += _header.notes.size() + 8;
+ }
+ if (!_header.name.empty()) {
+ headerSize += _header.name.size() + 8;
+ }
+ if (headerSize == 0) {
+ return;
+ }
+ _writeStream->writeUint32LE(kHeaderSectionTag);
+ _writeStream->writeUint32LE(headerSize);
+ if (!_header.author.empty()) {
+ _writeStream->writeUint32LE(kAuthorTag);
+ _writeStream->writeUint32LE(_header.author.size());
+ _writeStream->writeString(_header.author);
+ }
+ if (!_header.notes.empty()) {
+ _writeStream->writeUint32LE(kCommentsTag);
+ _writeStream->writeUint32LE(_header.notes.size());
+ _writeStream->writeString(_header.notes);
+ }
+ if (!_header.name.empty()) {
+ _writeStream->writeUint32LE(kNameTag);
+ _writeStream->writeUint32LE(_header.name.size());
+ _writeStream->writeString(_header.name);
+ }
+}
+
+void PlaybackFile::writeGameHash() {
+ uint32 hashSectionSize = 0;
+ for (StringMap::iterator i = _header.hashRecords.begin(); i != _header.hashRecords.end(); ++i) {
+ hashSectionSize = hashSectionSize + i->_key.size() + i->_value.size() + 8;
+ }
+ if (_header.hashRecords.size() == 0) {
+ return;
+ }
+ _writeStream->writeUint32LE(kHashSectionTag);
+ _writeStream->writeUint32LE(hashSectionSize);
+ for (StringMap::iterator i = _header.hashRecords.begin(); i != _header.hashRecords.end(); ++i) {
+ _writeStream->writeUint32LE(kHashRecordTag);
+ _writeStream->writeUint32LE(i->_key.size() + i->_value.size());
+ _writeStream->writeString(i->_key);
+ _writeStream->writeString(i->_value);
+ }
+}
+
+void PlaybackFile::writeRandomRecords() {
+ uint32 randomSectionSize = 0;
+ for (RandomSeedsDictionary::iterator i = _header.randomSourceRecords.begin(); i != _header.randomSourceRecords.end(); ++i) {
+ randomSectionSize = randomSectionSize + i->_key.size() + 12;
+ }
+ if (_header.randomSourceRecords.size() == 0) {
+ return;
+ }
+ _writeStream->writeUint32LE(kRandomSectionTag);
+ _writeStream->writeUint32LE(randomSectionSize);
+ for (RandomSeedsDictionary::iterator i = _header.randomSourceRecords.begin(); i != _header.randomSourceRecords.end(); ++i) {
+ _writeStream->writeUint32LE(kRandomRecordTag);
+ _writeStream->writeUint32LE(i->_key.size() + 4);
+ _writeStream->writeString(i->_key);
+ _writeStream->writeUint32LE(i->_value);
+ }
+}
+
+void PlaybackFile::writeEvent(const RecorderEvent &event) {
+ assert(_mode == kWrite);
+ _recordCount++;
+ _tmpRecordFile.writeByte(event.recordedtype);
+ switch (event.recordedtype) {
+ case kRecorderEventTypeTimer:
+ _tmpRecordFile.writeUint32LE(event.time);
+ break;
+ case kRecorderEventTypeNormal:
+ _tmpRecordFile.writeUint32LE((uint32)event.type);
+ switch(event.type) {
+ case EVENT_KEYDOWN:
+ case EVENT_KEYUP:
+ _tmpRecordFile.writeUint32LE(event.time);
+ _tmpRecordFile.writeSint32LE(event.kbd.keycode);
+ _tmpRecordFile.writeUint16LE(event.kbd.ascii);
+ _tmpRecordFile.writeByte(event.kbd.flags);
+ break;
+ case EVENT_MOUSEMOVE:
+ case EVENT_LBUTTONDOWN:
+ case EVENT_LBUTTONUP:
+ case EVENT_RBUTTONDOWN:
+ case EVENT_RBUTTONUP:
+ case EVENT_WHEELUP:
+ case EVENT_WHEELDOWN:
+ case EVENT_MBUTTONDOWN:
+ case EVENT_MBUTTONUP:
+ _tmpRecordFile.writeUint32LE(event.time);
+ _tmpRecordFile.writeSint16LE(event.mouse.x);
+ _tmpRecordFile.writeSint16LE(event.mouse.y);
+ break;
+ default:
+ _tmpRecordFile.writeUint32LE(event.time);
+ break;
+ }
+ break;
+ }
+ if (_recordCount == kMaxBufferedRecords) {
+ dumpRecordsToFile();
+ }
+}
+
+void PlaybackFile::writeGameSettings() {
+ _writeStream->writeUint32LE(kSettingsSectionTag);
+ uint32 settingsSectionSize = 0;
+ for (StringMap::iterator i = _header.settingsRecords.begin(); i != _header.settingsRecords.end(); ++i) {
+ settingsSectionSize += i->_key.size() + i->_value.size() + 24;
+ }
+ _writeStream->writeUint32LE(settingsSectionSize);
+ for (StringMap::iterator i = _header.settingsRecords.begin(); i != _header.settingsRecords.end(); ++i) {
+ _writeStream->writeUint32LE(kSettingsRecordTag);
+ _writeStream->writeUint32LE(i->_key.size() + i->_value.size() + 16);
+ _writeStream->writeUint32LE(kSettingsRecordKeyTag);
+ _writeStream->writeUint32LE(i->_key.size());
+ _writeStream->writeString(i->_key);
+ _writeStream->writeUint32LE(kSettingsRecordValueTag);
+ _writeStream->writeUint32LE(i->_value.size());
+ _writeStream->writeString(i->_value);
+ }
+}
+
+int PlaybackFile::getScreensCount() {
+ if (_mode != kRead) {
+ return 0;
+ }
+ _readStream->seek(0);
+ int result = 0;
+ while (skipToNextScreenshot()) {
+ uint32 size = _readStream->readUint32BE();
+ _readStream->skip(size-8);
+ ++result;
+ }
+ return result;
+}
+
+bool PlaybackFile::skipToNextScreenshot() {
+ while (true) {
+ FileTag id = (FileTag)_readStream->readUint32LE();
+ if (_readStream->eos()) {
+ break;
+ }
+ if (id == kScreenShotTag) {
+ return true;
+ }
+ else {
+ uint32 size = _readStream->readUint32LE();
+ _readStream->skip(size);
+ }
+ }
+ return false;
+}
+
+Graphics::Surface *PlaybackFile::getScreenShot(int number) {
+ if (_mode != kRead) {
+ return NULL;
+ }
+ _readStream->seek(0);
+ int screenCount = 1;
+ while (skipToNextScreenshot()) {
+ if (screenCount == number) {
+ screenCount++;
+ _readStream->seek(-4, SEEK_CUR);
+ return Graphics::loadThumbnail(*_readStream);
+ } else {
+ uint32 size = _readStream->readUint32BE();
+ _readStream->skip(size-8);
+ screenCount++;
+ }
+ }
+ return NULL;
+}
+
+void PlaybackFile::updateHeader() {
+ if (_mode == kWrite) {
+ _readStream = g_system->getSavefileManager()->openForLoading(_header.fileName);
+ }
+ _readStream->seek(0);
+ skipHeader();
+ String tmpFilename = "_" + _header.fileName;
+ _writeStream = g_system->getSavefileManager()->openForSaving(tmpFilename);
+ dumpHeaderToFile();
+ uint32 readedSize = 0;
+ do {
+ readedSize = _readStream->read(_tmpBuffer, kRecordBuffSize);
+ _writeStream->write(_tmpBuffer, readedSize);
+ } while (readedSize != 0);
+ delete _writeStream;
+ _writeStream = NULL;
+ delete _readStream;
+ _readStream = NULL;
+ g_system->getSavefileManager()->removeSavefile(_header.fileName);
+ g_system->getSavefileManager()->renameSavefile(tmpFilename, _header.fileName);
+ if (_mode == kRead) {
+ openRead(_header.fileName);
+ }
+}
+
+void PlaybackFile::skipHeader() {
+ while (true) {
+ uint32 id = _readStream->readUint32LE();
+ if (_readStream->eos()) {
+ break;
+ }
+ if ((id == kScreenShotTag) || (id == kEventTag) || (id == kMD5Tag)) {
+ _readStream->seek(-4, SEEK_CUR);
+ return;
+ }
+ else {
+ uint32 size = _readStream->readUint32LE();
+ _readStream->skip(size);
+ }
+ }
+}
+
+void PlaybackFile::addSaveFile(const String &fileName, InSaveFile *saveStream) {
+ uint oldPos = saveStream->pos();
+ saveStream->seek(0);
+ _header.saveFiles[fileName].buffer = (byte *)malloc(saveStream->size());
+ _header.saveFiles[fileName].size = saveStream->size();
+ saveStream->read(_header.saveFiles[fileName].buffer, saveStream->size());
+ saveStream->seek(oldPos);
+}
+
+void PlaybackFile::writeSaveFilesSection() {
+ uint size = 0;
+ for (HashMap<String, SaveFileBuffer>::iterator i = _header.saveFiles.begin(); i != _header.saveFiles.end(); ++i) {
+ size += i->_value.size + i->_key.size() + 24;
+ }
+ if (size == 0) {
+ return;
+ }
+ _writeStream->writeSint32LE(kSaveTag);
+ _writeStream->writeSint32LE(size);
+ for (HashMap<String, SaveFileBuffer>::iterator i = _header.saveFiles.begin(); i != _header.saveFiles.end(); ++i) {
+ _writeStream->writeSint32LE(kSaveRecordTag);
+ _writeStream->writeSint32LE(i->_key.size() + i->_value.size + 16);
+ _writeStream->writeSint32LE(kSaveRecordNameTag);
+ _writeStream->writeSint32LE(i->_key.size());
+ _writeStream->writeString(i->_key);
+ _writeStream->writeSint32LE(kSaveRecordBufferTag);
+ _writeStream->writeSint32LE(i->_value.size);
+ _writeStream->write(i->_value.buffer, i->_value.size);
+ }
+}
+
+
+void PlaybackFile::checkRecordedMD5() {
+ uint8 currentMD5[16];
+ uint8 savedMD5[16];
+ Graphics::Surface screen;
+ _readStream->read(savedMD5, 16);
+ if (!g_eventRec.grabScreenAndComputeMD5(screen, currentMD5)) {
+ return;
+ }
+ uint32 seconds = g_system->getMillis(true) / 1000;
+ String screenTime = String::format("%.2d:%.2d:%.2d", seconds / 3600 % 24, seconds / 60 % 60, seconds % 60);
+ if (memcmp(savedMD5, currentMD5, 16) != 0) {
+ debugC(1, kDebugLevelEventRec, "playback:action=\"Check screenshot\" time=%s result = fail", screenTime.c_str());
+ warning("Recorded and current screenshots are different");
+ } else {
+ debugC(1, kDebugLevelEventRec, "playback:action=\"Check screenshot\" time=%s result = success", screenTime.c_str());
+ }
+ Graphics::saveThumbnail(*_screenshotsFile, screen);
+ screen.free();
+}
+
+
+}
diff --git a/common/recorderfile.h b/common/recorderfile.h
new file mode 100644
index 0000000000..1c95e5a915
--- /dev/null
+++ b/common/recorderfile.h
@@ -0,0 +1,180 @@
+/* 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_RECORDERFILE_H
+#define COMMON_RECORDERFILE_H
+
+#include "common/scummsys.h"
+#include "common/events.h"
+#include "common/mutex.h"
+#include "common/memstream.h"
+#include "common/config-manager.h"
+#include "common/savefile.h"
+
+//capacity of records buffer
+#define kMaxBufferedRecords 10000
+#define kRecordBuffSize sizeof(RecorderEvent) * kMaxBufferedRecords
+
+namespace Common {
+
+enum RecorderEventType {
+ kRecorderEventTypeNormal = 0,
+ kRecorderEventTypeTimer = 1
+};
+
+struct RecorderEvent : Event {
+ RecorderEventType recordedtype;
+ uint32 time;
+};
+
+
+
+class PlaybackFile {
+ typedef HashMap<String, uint32, IgnoreCase_Hash, IgnoreCase_EqualTo> RandomSeedsDictionary;
+ enum fileMode {
+ kRead = 0,
+ kWrite = 1,
+ kClosed = 2
+ };
+ enum PlaybackFileState {
+ kFileStateCheckFormat,
+ kFileStateCheckVersion,
+ kFileStateProcessHash,
+ kFileStateProcessHeader,
+ kFileStateProcessRandom,
+ kFileStateSelectSection,
+ kFileStateProcessSettings,
+ kFileStateProcessSave,
+ kFileStateDone,
+ kFileStateError
+ };
+ enum FileTag {
+ kFormatIdTag = MKTAG('P','B','C','K'),
+ kVersionTag = MKTAG('V','E','R','S'),
+ kHeaderSectionTag = MKTAG('H','E','A','D'),
+ kHashSectionTag = MKTAG('H','A','S','H'),
+ kRandomSectionTag = MKTAG('R','A','N','D'),
+ kEventTag = MKTAG('E','V','N','T'),
+ kScreenShotTag = MKTAG('B','M','H','T'),
+ kSettingsSectionTag = MKTAG('S','E','T','T'),
+ kAuthorTag = MKTAG('H','A','U','T'),
+ kCommentsTag = MKTAG('H','C','M','T'),
+ kNameTag = MKTAG('H','N','A','M'),
+ kHashRecordTag = MKTAG('H','R','C','D'),
+ kRandomRecordTag = MKTAG('R','R','C','D'),
+ kSettingsRecordTag = MKTAG('S','R','E','C'),
+ kSettingsRecordKeyTag = MKTAG('S','K','E','Y'),
+ kSettingsRecordValueTag = MKTAG('S','V','A','L'),
+ kSaveTag = MKTAG('S','A','V','E'),
+ kSaveRecordTag = MKTAG('R','S','A','V'),
+ kSaveRecordNameTag = MKTAG('S','N','A','M'),
+ kSaveRecordBufferTag = MKTAG('S','B','U','F'),
+ kMD5Tag = MKTAG('M','D','5',' ')
+ };
+ struct ChunkHeader {
+ FileTag id;
+ uint32 len;
+ };
+public:
+ struct SaveFileBuffer {
+ byte *buffer;
+ uint32 size;
+ };
+ struct PlaybackFileHeader {
+ String fileName;
+ String author;
+ String name;
+ String notes;
+ String description;
+ StringMap hashRecords;
+ StringMap settingsRecords;
+ HashMap<String, SaveFileBuffer> saveFiles;
+ RandomSeedsDictionary randomSourceRecords;
+ };
+ PlaybackFile();
+ ~PlaybackFile();
+
+ bool openWrite(const String &fileName);
+ bool openRead(const String &fileName);
+ void close();
+
+ RecorderEvent getNextEvent();
+ void writeEvent(const RecorderEvent &event);
+
+ void saveScreenShot(Graphics::Surface &screen, byte md5[16]);
+ Graphics::Surface *getScreenShot(int number);
+ int getScreensCount();
+
+ bool isEventsBufferEmpty();
+ PlaybackFileHeader &getHeader() {return _header;}
+ void updateHeader();
+ void addSaveFile(const String &fileName, InSaveFile *saveStream);
+private:
+ WriteStream *_recordFile;
+ WriteStream *_writeStream;
+ WriteStream *_screenshotsFile;
+ MemoryReadStream _tmpPlaybackFile;
+ SeekableReadStream *_readStream;
+ SeekableMemoryWriteStream _tmpRecordFile;
+
+ fileMode _mode;
+ bool _headerDumped;
+ int _recordCount;
+ uint32 _eventsSize;
+ byte _tmpBuffer[kRecordBuffSize];
+ PlaybackFileHeader _header;
+ PlaybackFileState _playbackParseState;
+
+ void skipHeader();
+ bool parseHeader();
+ bool processChunk(ChunkHeader &nextChunk);
+ void returnToChunkHeader();
+
+ bool readSaveRecord();
+ void checkRecordedMD5();
+ bool readChunkHeader(ChunkHeader &nextChunk);
+ void processRndSeedRecord(ChunkHeader chunk);
+ bool processSettingsRecord();
+
+ bool checkPlaybackFileVersion();
+
+ void dumpHeaderToFile();
+ void writeSaveFilesSection();
+ void writeGameSettings();
+ void writeHeaderSection();
+ void writeGameHash();
+ void writeRandomRecords();
+
+ void dumpRecordsToFile();
+
+ String readString(int len);
+ void readHashMap(ChunkHeader chunk);
+
+ bool skipToNextScreenshot();
+ void readEvent(RecorderEvent& event);
+ void readEventsToBuffer(uint32 size);
+ bool grabScreenAndComputeMD5(Graphics::Surface &screen, uint8 md5[16]);
+};
+
+} // End of namespace Common
+
+#endif
diff --git a/common/system.cpp b/common/system.cpp
index 59210544ab..b40072afad 100644
--- a/common/system.cpp
+++ b/common/system.cpp
@@ -30,6 +30,7 @@
#include "common/taskbar.h"
#include "common/updates.h"
#include "common/textconsole.h"
+#include "gui/EventRecorder.h"
#include "backends/audiocd/default/default-audiocd.h"
#include "backends/fs/fs-factory.h"
@@ -84,7 +85,7 @@ void OSystem::initBackend() {
error("Backend failed to instantiate audio CD manager");
if (!_eventManager)
error("Backend failed to instantiate event manager");
- if (!_timerManager)
+ if (!getTimerManager())
error("Backend failed to instantiate timer manager");
// TODO: We currently don't check _savefileManager, because at least
@@ -152,3 +153,11 @@ Common::String OSystem::getDefaultConfigFileName() {
Common::String OSystem::getSystemLanguage() const {
return "en_US";
}
+
+Common::TimerManager *OSystem::getTimerManager() {
+ return _timerManager;
+}
+
+Common::SaveFileManager *OSystem::getSavefileManager() {
+ return g_eventRec.getSaveManager(_savefileManager);
+}
diff --git a/common/system.h b/common/system.h
index 99b947d7f3..81c4bdf34e 100644
--- a/common/system.h
+++ b/common/system.h
@@ -890,8 +890,14 @@ public:
/** @name Events and Time */
//@{
- /** Get the number of milliseconds since the program was started. */
- virtual uint32 getMillis() = 0;
+ /** Get the number of milliseconds since the program was started.
+
+ @param skipRecord Skip recording of this value by event recorder.
+ This could be needed particularly when we are in
+ an on-screen GUI loop where player can pause
+ the recording.
+ */
+ virtual uint32 getMillis(bool skipRecord = false) = 0;
/** Delay/sleep for the specified amount of milliseconds. */
virtual void delayMillis(uint msecs) = 0;
@@ -907,9 +913,7 @@ public:
* Return the timer manager singleton. For more information, refer
* to the TimerManager documentation.
*/
- inline Common::TimerManager *getTimerManager() {
- return _timerManager;
- }
+ virtual Common::TimerManager *getTimerManager();
/**
* Return the event manager singleton. For more information, refer
@@ -1086,9 +1090,7 @@ public:
* and other modifiable persistent game data. For more information,
* refer to the SaveFileManager documentation.
*/
- inline Common::SaveFileManager *getSavefileManager() {
- return _savefileManager;
- }
+ Common::SaveFileManager *getSavefileManager();
#if defined(USE_TASKBAR)
/**
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-09 18:21:58 +0000