Initial commit

engines/grim/movie/movie.cpp

@@ -0,0 +1,300 @@
+/* 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 "graphics/surface.h"
+
+#include "common/system.h"
+#include "common/timer.h"
+
+#include "engines/grim/movie/movie.h"
+#include "engines/grim/gfx_base.h"
+#include "engines/grim/grim.h"
+#include "engines/grim/debug.h"
+#include "engines/grim/savegame.h"
+
+namespace Grim {
+
+MoviePlayer *g_movie;
+
+MoviePlayer::MoviePlayer() {
+	_channels = -1;
+	_freq = 22050;
+	_videoFinished = false;
+	_videoLooping = false;
+	_videoPause = true;
+	_updateNeeded = false;
+	_showSubtitles = true;
+	_movieTime = 0;
+	_frame = -1;
+	_x = 0;
+	_y = 0;
+	_videoDecoder = nullptr;
+	_internalSurface = nullptr;
+	_internalPalette = nullptr;
+	_externalSurface = new Graphics::Surface();
+	_externalPalette = nullptr;
+	_timerStarted = false;
+}
+
+MoviePlayer::~MoviePlayer() {
+	// Remove the callback immediately, so we're sure timerCallback() doesn't get called
+	// after the deinit() or the deletes.
+	if (_timerStarted)
+		g_system->getTimerManager()->removeTimerProc(&timerCallback);
+
+	deinit();
+	delete _videoDecoder;
+	delete _externalSurface;
+	delete[] _externalPalette;
+}
+
+void MoviePlayer::pause(bool p) {
+	Common::StackLock lock(_frameMutex);
+	_videoPause = p;
+	_videoDecoder->pauseVideo(p);
+}
+
+void MoviePlayer::stop() {
+	Common::StackLock lock(_frameMutex);
+	deinit();
+	g_grim->setMode(GrimEngine::NormalMode);
+}
+
+void MoviePlayer::timerCallback(void *instance) {
+	MoviePlayer *movie = static_cast<MoviePlayer *>(instance);
+	Common::StackLock lock(movie->_frameMutex);
+	if (movie->prepareFrame())
+		movie->postHandleFrame();
+}
+
+bool MoviePlayer::prepareFrame() {
+	if (!_videoLooping && _videoDecoder->endOfVideo()) {
+		_videoFinished = true;
+	}
+
+	if (_videoPause) {
+		return false;
+	}
+
+	if (_videoFinished) {
+		if (g_grim->getMode() == GrimEngine::SmushMode) {
+			g_grim->setMode(GrimEngine::NormalMode);
+		}
+		_videoPause = true;
+		return false;
+	}
+
+	if (_videoDecoder->getTimeToNextFrame() > 0)
+		return false;
+
+	handleFrame();
+	_internalSurface = _videoDecoder->decodeNextFrame();
+	_internalPalette = _videoDecoder->getPalette();
+	if (_frame != _videoDecoder->getCurFrame()) {
+		_updateNeeded = true;
+	}
+
+	_movieTime = _videoDecoder->getTime();
+	_frame = _videoDecoder->getCurFrame();
+
+	return true;
+}
+
+Graphics::Surface *MoviePlayer::getDstSurface() {
+	Common::StackLock lock(_frameMutex);
+	if (_updateNeeded && _internalSurface) {
+		_externalSurface->copyFrom(*_internalSurface);
+	}
+
+	return _externalSurface;
+}
+
+const byte *MoviePlayer::getDstPalette() {
+	Common::StackLock lock(_frameMutex);
+	if (_updateNeeded && _internalPalette) {
+		if (!_externalPalette)
+			_externalPalette = new byte[0x300];
+		memcpy(_externalPalette, _internalPalette, 0x300);
+	}
+
+	return _externalPalette;
+}
+
+void MoviePlayer::drawMovieSubtitle() {
+	Common::StackLock lock(_frameMutex);
+	g_grim->drawMovieSubtitle();
+}
+
+void MoviePlayer::init() {
+	if (!_timerStarted) {
+		g_system->getTimerManager()->installTimerProc(&timerCallback, 10000, this, "movieLoop");
+		_timerStarted = true;
+	}
+
+	_frame = -1;
+	_movieTime = 0;
+	_updateNeeded = false;
+	_videoFinished = false;
+}
+
+void MoviePlayer::deinit() {
+	Debug::debug(Debug::Movie, "Deinitting video '%s'.\n", _fname.c_str());
+
+	if (_videoDecoder)
+		_videoDecoder->close();
+
+	_internalSurface = nullptr;
+	_internalPalette = nullptr;
+
+	if (_externalSurface)
+		_externalSurface->free();
+	delete[] _externalPalette;
+	_externalPalette = nullptr;
+
+	_videoPause = false;
+	_videoFinished = true;
+}
+
+bool MoviePlayer::play(const Common::String &filename, bool looping, int x, int y, bool start, bool showSubtitles) {
+	Common::StackLock lock(_frameMutex);
+	deinit();
+	_x = x;
+	_y = y;
+	_fname = filename;
+	_videoLooping = looping;
+	_showSubtitles = showSubtitles;
+
+	if (!loadFile(_fname))
+		return false;
+
+	_videoDecoder->setOutputPixelFormat(g_driver->getMovieFormat());
+
+	Debug::debug(Debug::Movie, "Playing video '%s'.\n", filename.c_str());
+
+	init();
+	_internalSurface = nullptr;
+	_internalPalette = nullptr;
+
+	if (start) {
+		_videoDecoder->start();
+
+		// Get the first frame immediately
+		timerCallback(this);
+	}
+
+	return true;
+}
+
+bool MoviePlayer::loadFile(const Common::String &filename) {
+	return _videoDecoder->loadFile(Common::Path(filename));
+}
+
+void MoviePlayer::saveState(SaveGame *state) {
+	Common::StackLock lock(_frameMutex);
+	state->beginSection('SMUS');
+
+	state->writeString(_fname);
+
+	state->writeLESint32(_frame);
+	state->writeFloat(_movieTime);
+	state->writeBool(_videoFinished);
+	state->writeBool(_videoLooping);
+
+	state->writeLESint32(_x);
+	state->writeLESint32(_y);
+
+	save(state);
+
+	state->endSection();
+}
+
+void MoviePlayer::restoreState(SaveGame *state) {
+	Common::StackLock lock(_frameMutex);
+	state->beginSection('SMUS');
+
+	_fname = state->readString();
+
+	int32 frame = state->readLESint32();
+	float movieTime = state->readFloat();
+	bool videoFinished = state->readBool();
+	bool videoLooping = state->readBool();
+
+	int x = state->readLESint32();
+	int y = state->readLESint32();
+
+	if (!videoFinished && !_fname.empty()) {
+		play(_fname.c_str(), videoLooping, x, y, false);
+	}
+	_frame = frame;
+	_movieTime = movieTime;
+
+	restore(state);
+
+	state->endSection();
+}
+
+#if !defined(USE_MPEG2) || !defined(USE_BINK)
+#define NEED_NULLPLAYER
+#endif
+
+// Temporary fix while reworking codecs:
+#ifndef NEED_NULLPLAYER
+#define NEED_NULLPLAYER
+#endif
+
+// Fallback for when USE_MPEG2 / USE_BINK isn't defined
+
+#ifdef NEED_NULLPLAYER
+class NullPlayer : public MoviePlayer {
+public:
+	NullPlayer(const char *codecID) {
+		warning("%s-playback not compiled in, but needed", codecID);
+		_videoFinished = true; // Rigs all movies to be completed.
+	}
+	~NullPlayer() {}
+	bool play(const Common::String &filename, bool looping, int x, int y, bool start = true, bool showSubtitles = false) override { return true; }
+	bool loadFile(const Common::String &filename) override { return true; }
+	void stop() override {}
+	void pause(bool p) override {}
+	void saveState(SaveGame *state) {}
+	void restoreState(SaveGame *state) {}
+private:
+	static void timerCallback(void *ptr) {}
+	void handleFrame() override {}
+	bool prepareFrame() override { return false; }
+	void init() override {}
+	void deinit() override {}
+};
+#endif
+
+#ifndef USE_MPEG2
+MoviePlayer *CreateMpegPlayer() {
+	return new NullPlayer("MPEG2");
+}
+#endif
+
+#ifndef USE_BINK
+MoviePlayer *CreateBinkPlayer(bool demo) {
+	return new NullPlayer("BINK");
+}
+#endif
+
+} // end of namespace Grim