scummvm/engines/bladerunner/vqa_player.h

/* 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/>.
 *
 */

#ifndef BLADERUNNER_VQA_PLAYER_H
#define BLADERUNNER_VQA_PLAYER_H

#include "bladerunner/vqa_decoder.h"

#include "audio/audiostream.h"
#include "audio/mixer.h"

#include "graphics/surface.h"

namespace BladeRunner {

enum LoopSetModes {
	kLoopSetModeJustStart = 0, // sets _frameBeginNext, _repeatsCount, _frameEnd
	kLoopSetModeEnqueue   = 1, // sets _frameBeginNext, _repeatsCountQueued, _frameEndQueued
	kLoopSetModeImmediate = 2  // like ModeJustStart, but also sets _frameNext to _frameBeginNext and updates _frameNextTime to current
};

class BladeRunnerEngine;
class View;
class Lights;
class ZBuffer;

class VQAPlayer {
	friend class Debugger;
	friend class OuttakePlayer;

	BladeRunnerEngine           *_vm;
	Common::String               _name;
	Common::SeekableReadStream  *_s;
	VQADecoder                   _decoder;
	Audio::QueuingAudioStream   *_audioStream;
	Graphics::Surface           *_surface;

	static const uint32  kVqaFrameTimeDiff             = 4000; // 60 * 1000 / 15
	static const int     kMaxAudioPreloadedFrames      = 15;
	// Use speech sound type as in original engine
	static const Audio::Mixer::SoundType kVQASoundType = Audio::Mixer::kSpeechSoundType;

	int _frame;
	int _frameNext;
	int _frameBeginNext; // The frame to begin from, after current playing loop ends.
	                     // Does not necessarily reflect current playing loop's start frame
	int _frameEnd;       // The frame to end at for current playing loop
	int _loopIdTarget;   // Does not necessarily reflect current playing loop's id (for a queue of loops this will have the id of the last one in the queue)
	                     // Used: - as param for _callbackLoopEnded() (which typically is loopEnded()), but never actually used in there)
	                     //       - for the MA05 inshot glitch workaround
	                     // It is set at every setLoop call except for the _loopInitial case (when no video stream is loaded)
	int _repeatsCount;   // -1 loop forever
	                     //  0 final repetition (or don't repeat after playing)
	                     //    When that repetition is completeed VQAPlayer::update() returns -3 value
	                     //    See Scene::advanceFrame() and OuttakePlayer::play() for checks for -3 result
	                     // Value is decreased per completed loop of current playing videoloop until it reaches 0

	int _repeatsCountQueued;
	int _frameEndQueued;

	int _lastAudioFrameSuccessfullyQueued;

	int _loopIdInitial;
	int _repeatsCountInitial;

	uint32 _frameNextTime;
	bool   _hasAudio;
	bool   _audioStarted;
	Audio::SoundHandle _soundHandle;

	bool   _specialPS15GlitchFix;
	bool   _specialUG18DoNotRepeatLastLoop;

	void (*_callbackLoopEnded)(void *, int frame, int loopId);
	void  *_callbackData;

public:

	VQAPlayer(BladeRunnerEngine *vm, Graphics::Surface *surface, const Common::String &name)
		: _vm(vm),
		  _name(name),
		  _s(nullptr),
		  _surface(surface),
		  _decoder(),
		  _audioStream(nullptr),
		  _frame(-1),
		  _frameNext(-1),
		  _frameBeginNext(-1),
		  _frameEnd(-1),
		  _loopIdTarget(-1),
		  _repeatsCount(-1),
		  _repeatsCountQueued(-1),
		  _frameEndQueued(-1),
		  _lastAudioFrameSuccessfullyQueued(-1),
		  _loopIdInitial(-1),
		  _repeatsCountInitial(-1),
		  _frameNextTime(0),
		  _hasAudio(false),
		  _audioStarted(false),
		  _specialPS15GlitchFix(false),
		  _specialUG18DoNotRepeatLastLoop(false),
		  _callbackLoopEnded(nullptr),
		  _callbackData(nullptr) { }

	~VQAPlayer() {
		close();
	}

	bool open();
	void close();

	bool loadVQPTable(const Common::String& vqpResName);

	int  update(bool forceDraw = false, bool advanceFrame = true, bool useTime = true, Graphics::Surface *customSurface = nullptr);
	void updateZBuffer(ZBuffer *zbuffer);
	void updateView(View *view);
	void updateScreenEffects(ScreenEffects *screenEffects);
	void updateLights(Lights *lights);

	bool setBeginAndEndFrame(int begin, int end, int repeatsCount, int loopSetMode, void(*callback)(void *, int, int), void *callbackData);
	bool setLoop(int loopId, int repeatsCount, int loopSetMode, void(*callback)(void*, int, int), void *callbackData);

	bool seekToFrame(int frame);

	bool getCurrentBeginAndEndFrame(int frame, int *begin, int *end);
	int getLoopBeginFrame(int loopId);
	int getLoopEndFrame(int loopId);

	int getLoopIdTarget() const { return _loopIdTarget; };

	int getFrameCount() const;

	int getQueuedAudioFrames() const;

private:
	void queueAudioFrame(Audio::AudioStream *audioStream);
};

} // End of namespace BladeRunner

#endif