Initial commit

engines/zvision/video/rlf_decoder.cpp

@@ -0,0 +1,314 @@
+/* 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 "common/debug.h"
+#include "common/endian.h"
+#include "common/file.h"
+#include "common/scummsys.h"
+#include "common/str.h"
+#include "common/textconsole.h"
+#include "zvision/detection.h"
+#include "zvision/video/rlf_decoder.h"
+
+namespace ZVision {
+
+RLFDecoder::~RLFDecoder() {
+	close();
+}
+
+bool RLFDecoder::loadStream(Common::SeekableReadStream *stream) {
+	debugC(5, kDebugVideo, "loadStream()");
+	close();
+	bool isValid = false;
+	// Check if the stream is valid
+	if (stream && !stream->err() && stream->readUint32BE() == MKTAG('F', 'E', 'L', 'R')) {
+		addTrack(new RLFVideoTrack(stream));
+		isValid = true;
+	} else {
+		warning("Invalid rlf stream");
+	}
+	debugC(5, kDebugVideo, "~loadStream()");	
+	return isValid;
+}
+
+RLFDecoder::RLFVideoTrack::RLFVideoTrack(Common::SeekableReadStream *stream)
+	: _readStream(stream),
+	  _lastFrameRead(0),
+	  _frameCount(0),
+	  _width(0),
+	  _height(0),
+	  _frameTime(0),
+	  _frames(0),
+	  _displayedFrame(-1),
+	  _frameBufferByteSize(0) {
+
+	if (!readHeader()) {
+		warning("Not a RLF animation file. Wrong magic number");
+		return;
+	}
+
+	_currentFrameBuffer.create(_width, _height, getPixelFormat());
+	_frameBufferByteSize = _width * _height * sizeof(uint16);
+
+	_frames = new Frame[_frameCount];
+
+	// Read in each frame
+	for (uint i = 0; i < _frameCount; ++i) {
+		_frames[i] = readNextFrame();
+	}
+}
+
+RLFDecoder::RLFVideoTrack::~RLFVideoTrack() {
+	for (uint i = 0; i < _frameCount; ++i) {
+		delete[] _frames[i].encodedData;
+	}
+	delete[] _frames;
+	delete _readStream;
+	_currentFrameBuffer.free();
+}
+
+bool RLFDecoder::RLFVideoTrack::readHeader() {
+	// Read the header
+	_readStream->readUint32LE();                // Size1
+	_readStream->readUint32LE();                // Unknown1
+	_readStream->readUint32LE();                // Unknown2
+	_frameCount = _readStream->readUint32LE();  // Frame count
+
+	// Since we don't need any of the data, we can just seek right to the
+	// entries we need rather than read in all the individual entries.
+	_readStream->seek(136, SEEK_CUR);
+
+	//// Read CIN header
+	//_readStream->readUint32BE();          // Magic number FNIC
+	//_readStream->readUint32LE();          // Size2
+	//_readStream->readUint32LE();          // Unknown3
+	//_readStream->readUint32LE();          // Unknown4
+	//_readStream->readUint32LE();          // Unknown5
+	//_readStream->seek(0x18, SEEK_CUR);    // VRLE
+	//_readStream->readUint32LE();          // LRVD
+	//_readStream->readUint32LE();          // Unknown6
+	//_readStream->seek(0x18, SEEK_CUR);    // HRLE
+	//_readStream->readUint32LE();          // ELHD
+	//_readStream->readUint32LE();          // Unknown7
+	//_readStream->seek(0x18, SEEK_CUR);    // HKEY
+	//_readStream->readUint32LE();          // ELRH
+
+	//// Read MIN info header
+	//_readStream->readUint32BE();          // Magic number FNIM
+	//_readStream->readUint32LE();          // Size3
+	//_readStream->readUint32LE();          // OEDV
+	//_readStream->readUint32LE();          // Unknown8
+	//_readStream->readUint32LE();          // Unknown9
+	//_readStream->readUint32LE();          // Unknown10
+	_width = _readStream->readUint32LE();   // Width
+	_height = _readStream->readUint32LE();  // Height
+
+	// Read time header
+	_readStream->readUint32BE();                    // Magic number EMIT
+	_readStream->readUint32LE();                    // Size4
+	_readStream->readUint32LE();                    // Unknown11
+	_frameTime = _readStream->readUint32LE() / 10;  // Frame time in microseconds
+
+	return true;
+}
+
+RLFDecoder::RLFVideoTrack::Frame RLFDecoder::RLFVideoTrack::readNextFrame() {
+	RLFDecoder::RLFVideoTrack::Frame frame;
+
+	_readStream->readUint32BE();                        // Magic number MARF
+	uint32 size = _readStream->readUint32LE();          // Size
+	_readStream->readUint32LE();                        // Unknown1
+	_readStream->readUint32LE();                        // Unknown2
+	uint32 type = _readStream->readUint32BE();          // Either ELHD or ELRH
+	uint32 headerSize = _readStream->readUint32LE();    // Offset from the beginning of this frame to the frame data. Should always be 28
+	_readStream->readUint32LE();                        // Unknown3
+
+	frame.encodedSize = size - headerSize;
+	frame.encodedData = new int8[frame.encodedSize];
+	_readStream->read(frame.encodedData, frame.encodedSize);
+
+	if (type == MKTAG('E', 'L', 'H', 'D')) {
+		frame.type = Masked;
+	} else if (type == MKTAG('E', 'L', 'R', 'H')) {
+		frame.type = Simple;
+		_completeFrames.push_back(_lastFrameRead);
+	} else {
+		warning("Frame %u doesn't have type that can be decoded", _lastFrameRead);
+	}
+
+	_lastFrameRead++;
+	return frame;
+}
+
+bool RLFDecoder::RLFVideoTrack::seek(const Audio::Timestamp &time) {
+	uint frame = getFrameAtTime(time);
+	assert(frame < _frameCount);
+
+	if ((uint)_displayedFrame == frame)
+		return true;
+
+	int closestFrame = _displayedFrame;
+	int distance = (int)frame - closestFrame;
+
+	if (distance < 0) {
+		for (uint i = 0; i < _completeFrames.size(); ++i) {
+			if (_completeFrames[i] > frame)
+				break;
+			closestFrame = _completeFrames[i];
+		}
+	} else {
+		for (uint i = 0; i < _completeFrames.size(); ++i) {
+			int newDistance = (int)frame - (int)(_completeFrames[i]);
+			if (newDistance < 0)
+				break;
+			if (newDistance < distance) {
+				closestFrame = _completeFrames[i];
+				distance = newDistance;
+			}
+		}
+	}
+
+	for (uint i = closestFrame; i < frame; ++i) {
+		applyFrameToCurrent(i);
+	}
+
+	_displayedFrame = frame - 1;
+
+	return true;
+}
+
+const Graphics::Surface *RLFDecoder::RLFVideoTrack::decodeNextFrame() {
+	if (_displayedFrame >= (int)_frameCount)
+		return NULL;
+
+	_displayedFrame++;
+	applyFrameToCurrent(_displayedFrame);
+
+	return &_currentFrameBuffer;
+}
+
+void RLFDecoder::RLFVideoTrack::applyFrameToCurrent(uint frameNumber) {
+	if (_frames[frameNumber].type == Masked) {
+		decodeMaskedRunLengthEncoding(_frames[frameNumber].encodedData, (int8 *)_currentFrameBuffer.getPixels(), _frames[frameNumber].encodedSize, _frameBufferByteSize);
+	} else if (_frames[frameNumber].type == Simple) {
+		decodeSimpleRunLengthEncoding(_frames[frameNumber].encodedData, (int8 *)_currentFrameBuffer.getPixels(), _frames[frameNumber].encodedSize, _frameBufferByteSize);
+	}
+}
+
+void RLFDecoder::RLFVideoTrack::decodeMaskedRunLengthEncoding(int8 *source, int8 *dest, uint32 sourceSize, uint32 destSize) const {
+	uint32 sourceOffset = 0;
+	uint32 destOffset = 0;
+	int16 numberOfCopy = 0;
+
+	while (sourceOffset < sourceSize) {
+		int8 numberOfSamples = source[sourceOffset];
+		sourceOffset++;
+
+		// If numberOfSamples is negative, the next abs(numberOfSamples) samples should
+		// be copied directly from source to dest
+		if (numberOfSamples < 0) {
+			numberOfCopy = -numberOfSamples;
+
+			while (numberOfCopy > 0) {
+				if (sourceOffset + 1 >= sourceSize) {
+					return;
+				} else if (destOffset + 1 >= destSize) {
+					debugC(3, kDebugVideo, "Frame decoding overflow\n\tsourceOffset=%u\tsourceSize=%u\n\tdestOffset=%u\tdestSize=%u", sourceOffset, sourceSize, destOffset, destSize);
+					return;
+				}
+
+				WRITE_UINT16(dest + destOffset, READ_LE_UINT16(source + sourceOffset));
+
+				sourceOffset += 2;
+				destOffset += 2;
+				numberOfCopy--;
+			}
+
+			// If numberOfSamples is >= 0, move destOffset forward ((numberOfSamples * 2) + 2)
+			// This function assumes the dest buffer has been memset with 0's.
+		} else {
+			if (sourceOffset + 1 >= sourceSize) {
+				return;
+			} else if (destOffset + 1 >= destSize) {
+				debugC(3, kDebugVideo, "Frame decoding overflow\n\tsourceOffset=%u\tsourceSize=%u\n\tdestOffset=%u\tdestSize=%u", sourceOffset, sourceSize, destOffset, destSize);
+				return;
+			}
+
+			destOffset += (numberOfSamples * 2) + 2;
+		}
+	}
+}
+
+void RLFDecoder::RLFVideoTrack::decodeSimpleRunLengthEncoding(int8 *source, int8 *dest, uint32 sourceSize, uint32 destSize) const {
+	uint32 sourceOffset = 0;
+	uint32 destOffset = 0;
+	int16 numberOfCopy = 0;
+
+	while (sourceOffset < sourceSize) {
+		int8 numberOfSamples = source[sourceOffset];
+		sourceOffset++;
+
+		// If numberOfSamples is negative, the next abs(numberOfSamples) samples should
+		// be copied directly from source to dest
+		if (numberOfSamples < 0) {
+			numberOfCopy = -numberOfSamples;
+
+			while (numberOfCopy > 0) {
+				if (sourceOffset + 1 >= sourceSize) {
+					return;
+				} else if (destOffset + 1 >= destSize) {
+					debugC(3, kDebugVideo, "Frame decoding overflow\n\tsourceOffset=%u\tsourceSize=%u\n\tdestOffset=%u\tdestSize=%u", sourceOffset, sourceSize, destOffset, destSize);
+					return;
+				}
+
+				WRITE_UINT16(dest + destOffset, READ_LE_UINT16(source + sourceOffset));
+
+				sourceOffset += 2;
+				destOffset += 2;
+				numberOfCopy--;
+			}
+
+			// If numberOfSamples is >= 0, copy one sample from source to the
+			// next (numberOfSamples + 2) dest spots
+		} else {
+			if (sourceOffset + 1 >= sourceSize) {
+				return;
+			}
+
+			uint16 sampleColor = READ_LE_UINT16(source + sourceOffset);
+			sourceOffset += 2;
+
+			numberOfCopy = numberOfSamples + 2;
+			while (numberOfCopy > 0) {
+				if (destOffset + 1 >= destSize) {
+					debugC(3, kDebugVideo, "Frame decoding overflow\n\tsourceOffset=%u\tsourceSize=%u\n\tdestOffset=%u\tdestSize=%u", sourceOffset, sourceSize, destOffset, destSize);
+					return;
+				}
+
+				WRITE_UINT16(dest + destOffset, sampleColor);
+				destOffset += 2;
+				numberOfCopy--;
+			}
+		}
+	}
+}
+
+} // End of namespace ZVision

engines/zvision/video/rlf_decoder.h

@@ -0,0 +1,132 @@
+/* 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 ZVISION_RLF_DECODER_H
+#define ZVISION_RLF_DECODER_H
+
+#include "common/file.h"
+#include "graphics/surface.h"
+#include "video/video_decoder.h"
+
+namespace ZVision {
+
+class RLFDecoder : public Video::VideoDecoder {
+public:
+	RLFDecoder() {}
+	~RLFDecoder() override;
+
+	bool loadStream(Common::SeekableReadStream *stream) override;
+
+private:
+	class RLFVideoTrack : public FixedRateVideoTrack {
+	public:
+		RLFVideoTrack(Common::SeekableReadStream *stream);
+		~RLFVideoTrack() override;
+
+		uint16 getWidth() const override { return _width; }
+		uint16 getHeight() const override { return _height; }
+		Graphics::PixelFormat getPixelFormat() const override { return Graphics::PixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0); /* RGB 555 */ }
+		int getCurFrame() const override { return _displayedFrame; }
+		int getFrameCount() const override { return _frameCount; }
+		const Graphics::Surface *decodeNextFrame() override;
+		bool isSeekable() const override { return true; }
+		bool seek(const Audio::Timestamp &time) override;
+
+	protected:
+		Common::Rational getFrameRate() const override { return Common::Rational(1000, _frameTime); }
+
+	private:
+		enum EncodingType {
+			Masked,
+			Simple
+		};
+
+		struct Frame {
+			EncodingType type;
+			int8 *encodedData;
+			uint32 encodedSize;
+		};
+
+		/**
+		 * Reads in the header of the RLF file
+		 *
+		 * @return    Will return false if the header magic number is wrong
+		 */
+		bool readHeader();
+
+		/**
+		 * Reads the next frame from the RLF file, stores the data in
+		 * a Frame object, then returns the object
+		 *
+		 * @return    A Frame object representing the frame data
+		 */
+		Frame readNextFrame();
+
+		/**
+		 * Applies the frame corresponding to frameNumber on top of _currentFrameBuffer.
+		 * This function requires _stream = false so it can look up the Frame object
+		 * referenced by frameNumber.
+		 *
+		 * @param frameNumber    The frame number to apply to _currentFrameBuffer
+		 */
+		void applyFrameToCurrent(uint frameNumber);
+
+		/**
+		 * Decode frame data that uses masked run length encoding. This is the encoding
+		 * used by P-frames.
+		 *
+		 * @param source        The source pixel data
+		 * @param dest          The destination buffer
+		 * @param sourceSize    The size of the source pixel data
+		 * @param destSize      The size of the destination buffer
+		 */
+		void decodeMaskedRunLengthEncoding(int8 *source, int8 *dest, uint32 sourceSize, uint32 destSize) const;
+		/**
+		 * Decode frame data that uses simple run length encoding. This is the encoding
+		 * used by I-frames.
+		 *
+		 * @param source        The source pixel data
+		 * @param dest          The destination buffer
+		 * @param sourceSize    The size of the source pixel data
+		 * @param destSize      The size of the destination buffer
+		 */
+		void decodeSimpleRunLengthEncoding(int8 *source, int8 *dest, uint32 sourceSize, uint32 destSize) const;
+
+		uint _lastFrameRead;
+
+		uint _frameCount;
+		uint _width;
+		uint _height;
+		uint32 _frameTime; // In milliseconds
+		Frame *_frames;
+		Common::Array<uint> _completeFrames;
+
+		int _displayedFrame;
+		Graphics::Surface _currentFrameBuffer;
+		uint32 _frameBufferByteSize;
+
+		Common::SeekableReadStream *_readStream;
+	};	// RLFVideoTrack
+};
+
+} // End of namespace ZVision
+
+#endif

engines/zvision/video/video.cpp

@@ -0,0 +1,196 @@
+/* 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 "backends/keymapper/keymap.h"
+#include "common/scummsys.h"
+#include "common/system.h"
+#include "engines/util.h"
+#include "graphics/surface.h"
+#include "video/video_decoder.h"
+#if defined(USE_MPEG2) && defined(USE_A52)
+#include "video/mpegps_decoder.h"
+#endif
+#include "zvision/zvision.h"
+#include "zvision/core/clock.h"
+#include "zvision/file/file_manager.h"
+#include "zvision/graphics/render_manager.h"
+#include "zvision/scripting/script_manager.h"
+#include "zvision/sound/volume_manager.h"
+#include "zvision/text/subtitle_manager.h"
+#include "zvision/video/rlf_decoder.h"
+#include "zvision/video/zork_avi_decoder.h"
+
+namespace ZVision {
+
+Video::VideoDecoder *ZVision::loadAnimation(const Common::Path &fileName) {
+	debugC(5, kDebugVideo, "loadAnimation()");
+	Common::String tmpFileName = fileName.baseName();
+	tmpFileName.toLowercase();
+	Video::VideoDecoder *animation = NULL;
+
+	debugC(1, kDebugVideo, "Loading animation %s", fileName.toString().c_str());
+
+	if (tmpFileName.hasSuffix(".rlf"))
+		animation = new RLFDecoder();
+	else if (tmpFileName.hasSuffix(".avi"))
+		animation = new ZorkAVIDecoder();
+#if defined(USE_MPEG2) && defined(USE_A52)
+	else if (tmpFileName.hasSuffix(".vob")) {
+ 		double amplification = getVolumeManager()->getVobAmplification(tmpFileName);
+		animation = new Video::MPEGPSDecoder(amplification);
+	}
+#endif
+	else
+		error("Unknown suffix for animation %s", fileName.toString().c_str());
+
+	Common::File *file = getFileManager()->open(fileName);
+	if (!file)
+		error("Error opening %s", fileName.toString().c_str());
+
+	bool loaded = animation->loadStream(file);
+	if (!loaded)
+		error("Error loading animation %s", fileName.toString().c_str());
+
+	debugC(5, kDebugVideo, "~loadAnimation()");
+	return animation;
+}
+
+/**
+ * Play video at specified location.
+ *
+ * Pauses clock & normal game loop for duration of video; will still update & render subtitles & cursor.
+ *
+ * @param vid       Source video
+ * @param dstRect   Rectangle to play video into, defined relative to working window origin; video will scale to rectangle automatically.
+ * @param skippable Allow video to be skipped
+ * @param sub       Subtitle associated with video
+ * @param srcRect   Rectangle within video frame, defined relative to frame origin, to blit to output.  Only used for removing baked-in letterboxing in ZGI DVD HD videos
+ */
+
+void ZVision::playVideo(Video::VideoDecoder &vid, Common::Rect dstRect, bool skippable, uint16 sub, Common::Rect srcRect) {
+	Common::Rect frameArea = Common::Rect(vid.getWidth(), vid.getHeight());
+	Common::Rect workingArea = _renderManager->getWorkingArea();
+	// If dstRect is empty, no specific scaling was requested. However, we may choose to do scaling anyway
+	bool scaled = false;
+	workingArea.moveTo(0, 0); // Set local origin system in this scope to origin of working area
+
+	debugC(1, kDebugVideo, "Playing video, source %d,%d,%d,%d, at destination %d,%d,%d,%d", srcRect.left, srcRect.top, srcRect.right, srcRect.bottom, dstRect.left, dstRect.top, dstRect.right, dstRect.bottom);
+
+	if (dstRect.isEmpty())
+		dstRect = frameArea;
+	dstRect.clip(workingArea);
+
+	debugC(2, kDebugVideo, "Clipped dstRect = %d,%d,%d,%d", dstRect.left, dstRect.top, dstRect.right, dstRect.bottom);
+
+	if (srcRect.isEmpty())
+		srcRect = frameArea;
+	else
+		srcRect.clip(frameArea);
+
+	debugC(2, kDebugVideo, "Clipped srcRect = %d,%d,%d,%d", srcRect.left, srcRect.top, srcRect.right, srcRect.bottom);
+
+	Graphics::ManagedSurface &outSurface = _renderManager->getVidSurface(dstRect);
+	dstRect.moveTo(0, 0);
+	dstRect.clip(Common::Rect(outSurface.w, outSurface.h));
+
+	debugC(2, kDebugVideo, "dstRect clipped with outSurface = %d,%d,%d,%d", dstRect.left, dstRect.top, dstRect.right, dstRect.bottom);
+
+	debugC(1, kDebugVideo, "Final size %d x %d, at working window coordinates %d, %d", srcRect.width(), srcRect.height(), dstRect.left, dstRect.top);
+	if (srcRect.width() != dstRect.width() || srcRect.height() != dstRect.height()) {
+		debugC(1, kDebugVideo, "Video will be scaled from %dx%d to %dx%d", srcRect.width(), srcRect.height(), dstRect.width(), dstRect.height());
+		scaled = true;
+	}
+
+	bool showSubs = (_scriptManager->getStateValue(StateKey_Subtitles) == 1);
+
+	_clock.stop();
+	vid.start();
+	_videoIsPlaying = true;
+
+	_cutscenesKeymap->setEnabled(true);
+	_gameKeymap->setEnabled(false);
+	
+	// Only continue while the video is still playing
+	while (!shouldQuit() && !vid.endOfVideo() && vid.isPlaying()) {
+		// Check for engine quit and video stop key presses
+		while (_eventMan->pollEvent(_event)) {
+			switch (_event.type) {
+			case Common::EVENT_CUSTOM_ENGINE_ACTION_START:
+				switch ((ZVisionAction)_event.customType) {
+				case kZVisionActionQuit:
+					if (ConfMan.hasKey("confirm_exit") && ConfMan.getBool("confirm_exit")) {
+						if (quit(true, true))
+							vid.stop();
+					}
+					else {
+						quit(false);
+						vid.stop();
+					}
+					break;
+				case kZVisionActionSkipCutscene:
+					if (skippable) {
+						vid.stop();
+					}
+					break;
+				default:
+					break;
+				}
+			default:
+				break;
+			}
+		}
+
+		if (vid.needsUpdate()) {
+			const Graphics::Surface *frame = vid.decodeNextFrame();
+			if (showSubs && sub > 0)
+				_subtitleManager->update(vid.getCurFrame(), sub);
+
+			if (frame) {
+				_renderManager->renderSceneToScreen(true, true, true); // Redraw text area to clean background of subtitles for videos that don't fill entire working area, e.g, Nemesis sarcophagi
+				if (scaled) {
+					debugC(8, kDebugVideo, "Scaled blit from area %d x %d to video output surface at output surface position %d, %d", srcRect.width(), srcRect.height(), dstRect.left, dstRect.top);
+					outSurface.blitFrom(*frame, srcRect, dstRect);
+				} else {
+					debugC(8, kDebugVideo, "Simple blit from area %d x %d to video output surface at output surface position %d, %d", srcRect.width(), srcRect.height(), dstRect.left, dstRect.top);
+					outSurface.simpleBlitFrom(*frame, srcRect, dstRect.origin());
+				}
+				_subtitleManager->process(0);
+			}
+		}
+
+		// Always update the screen so the mouse continues to render & video does not skip
+		_renderManager->renderSceneToScreen(true, true, false);
+
+		_system->delayMillis(vid.getTimeToNextFrame() / 2); // Exponentially decaying delay
+	}
+	
+	vid.close();	// Ensure resources are freed.
+	
+	_cutscenesKeymap->setEnabled(false);
+	_gameKeymap->setEnabled(true);
+
+	_videoIsPlaying = false;
+	_clock.start();
+
+	debugC(1, kDebugVideo, "Video playback complete");
+}
+
+} // End of namespace ZVision

engines/zvision/video/zork_avi_decoder.cpp

@@ -0,0 +1,71 @@
+/* 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 "audio/audiostream.h"
+#include "audio/decoders/raw.h"
+#include "common/scummsys.h"
+#include "common/stream.h"
+#include "zvision/sound/zork_raw.h"
+#include "zvision/video/zork_avi_decoder.h"
+
+namespace ZVision {
+
+Video::AVIDecoder::AVIAudioTrack *ZorkAVIDecoder::createAudioTrack(Video::AVIDecoder::AVIStreamHeader sHeader, Video::AVIDecoder::PCMWaveFormat wvInfo) {
+	if (wvInfo.tag != kWaveFormatZorkPCM)
+		return new AVIAudioTrack(sHeader, wvInfo, getSoundType());
+
+	assert(wvInfo.size == 8);
+	return new ZorkAVIAudioTrack(sHeader, wvInfo, getSoundType());
+}
+
+ZorkAVIDecoder::ZorkAVIAudioTrack::ZorkAVIAudioTrack(const AVIStreamHeader &streamHeader, const PCMWaveFormat &waveFormat, Audio::Mixer::SoundType soundType) :
+		Video::AVIDecoder::AVIAudioTrack(streamHeader, waveFormat, soundType), _queueStream(0), _decoder(waveFormat.channels == 2) {
+}
+
+void ZorkAVIDecoder::ZorkAVIAudioTrack::createAudioStream() {
+	_queueStream = Audio::makeQueuingAudioStream(_wvInfo.samplesPerSec, _wvInfo.channels == 2);
+	_audioStream = _queueStream;
+}
+
+void ZorkAVIDecoder::ZorkAVIAudioTrack::queueSound(Common::SeekableReadStream *stream) {
+	RawChunkStream::RawChunk chunk = _decoder.readNextChunk(stream);
+	delete stream;
+
+	if (chunk.data) {
+		byte flags = Audio::FLAG_16BITS;
+		if (_wvInfo.channels == 2)
+			flags |= Audio::FLAG_STEREO;
+#ifdef SCUMM_LITTLE_ENDIAN
+		// RawChunkStream produces native endianness int16
+		flags |= Audio::FLAG_LITTLE_ENDIAN;
+#endif
+		_queueStream->queueBuffer((byte *)chunk.data, chunk.size, DisposeAfterUse::YES, flags);
+	}
+
+	_curChunk++;
+}
+
+void ZorkAVIDecoder::ZorkAVIAudioTrack::resetStream() {
+	AVIAudioTrack::resetStream();
+	_decoder.init();
+}
+
+} // End of namespace ZVision

engines/zvision/video/zork_avi_decoder.h

@@ -0,0 +1,62 @@
+/* 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 ZORK_AVI_DECODER_H
+#define ZORK_AVI_DECODER_H
+
+#include "video/avi_decoder.h"
+#include "zvision/sound/zork_raw.h"
+
+namespace ZVision {
+
+class ZorkAVIDecoder : public Video::AVIDecoder {
+public:
+	ZorkAVIDecoder() {}
+
+	~ZorkAVIDecoder() override {}
+
+private:
+	class ZorkAVIAudioTrack : public Video::AVIDecoder::AVIAudioTrack {
+	public:
+		ZorkAVIAudioTrack(const AVIStreamHeader &streamHeader, const PCMWaveFormat &waveFormat, Audio::Mixer::SoundType soundType);
+
+		void createAudioStream() override;
+		void queueSound(Common::SeekableReadStream *stream) override;
+		void resetStream() override;
+
+	private:
+		Audio::QueuingAudioStream *_queueStream;
+		RawChunkStream _decoder;
+	};
+
+	Video::AVIDecoder::AVIAudioTrack *createAudioTrack(Video::AVIDecoder::AVIStreamHeader sHeader, Video::AVIDecoder::PCMWaveFormat wvInfo) override;
+
+private:
+	// Audio Codecs
+	enum {
+		kWaveFormatZorkPCM = 17 // special Zork PCM audio format (clashes with MS IMA ADPCM)
+	};
+};
+
+} // End of namespace ZVision
+
+#endif