Ticket #9141: video_decoder_rewrite.diff

engines/mohawk/video/cinepak.h

@@ -65 +65 @@
         ~CinepakDecoder();
 
         Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
+        Graphics::PixelFormat getPixelFormat() const { return _pixelFormat; }
 
 private:
         CinepakFrame _curFrame;

engines/mohawk/video/rpza.h

@@ -37 +37 @@
         ~RPZADecoder() { delete _surface; }
 
         Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
+        Graphics::PixelFormat getPixelFormat() const { return _pixelFormat; }
 
 private:
         Graphics::Surface *_surface;

engines/mohawk/video/smc.h

@@ -43 +43 @@
         ~SMCDecoder() { delete _surface; }
 
         Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
+        Graphics::PixelFormat getPixelFormat() const { return Graphics::PixelFormat::createFormatCLUT8(); }
 
 private:
         Graphics::Surface *_surface;

engines/mohawk/video/qtrle.h

@@ -37 +37 @@
         ~QTRLEDecoder();
 
         Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
+        Graphics::PixelFormat getPixelFormat() const { return _pixelFormat; }
 
 private:
         byte _bitsPerPixel;

engines/mohawk/jpeg.h

@@ -45 +45 @@
         ~JPEGDecoder();
 
         Graphics::Surface *decodeImage(Common::SeekableReadStream *stream);
+        Graphics::PixelFormat getPixelFormat() const { return _pixelFormat; }
 
 private:
         Graphics::PixelFormat _pixelFormat;

engines/tucker/sequences.cpp

@@ -760 +760 @@
 }
 
 bool AnimationSequencePlayer::decodeNextAnimationFrame(int index) {
-        bool framesLeft = _flicPlayer[index].decodeNextFrame();
+        ::Graphics::Surface *surface = _flicPlayer[index].decodeNextFrame();
+
         if (_seqNum == 19) {
-                _flicPlayer[index].copyFrameToBuffer(_offscreenBuffer, 0, 0, kScreenWidth);
+                for (uint16 y = 0; (y < surface->h) && (y < kScreenHeight); y++)
+                        memcpy(_offscreenBuffer + y * kScreenWidth, (byte *)surface->pixels + y * surface->pitch, surface->w);
         } else {
                 _flicPlayer[index].copyDirtyRectsToBuffer(_offscreenBuffer, kScreenWidth);
                 ++_frameCounter;
         }
-        if (index == 0) {
-                if (_flicPlayer[index].paletteChanged()) {
-                        getRGBPalette(index);
-                }
-        }
-        return framesLeft;
+
+        if (index == 0 && _flicPlayer[index].hasDirtyPalette())
+                getRGBPalette(index);
+
+        return !_flicPlayer[index].endOfVideo();
 }
 
 void AnimationSequencePlayer::loadIntroSeq17_18() {
@@ -797 +798 @@
         // The intro credits animation. This uses 2 animations: the foreground one, which
         // is the actual intro credits, and the background one, which is an animation of
         // cogs, and is being replayed when an intro credit appears
-        if (_flicPlayer[0].getCurFrame() >= 116) {
-                if (!_flicPlayer[1].decodeNextFrame()) {
+        ::Graphics::Surface *surface = 0;
+
+        if (_flicPlayer[0].getCurFrame() >= 117) {
+                surface = _flicPlayer[1].decodeNextFrame();
+                if (_flicPlayer[1].endOfVideo())
                         _flicPlayer[1].reset();
-                }
         }
+
         bool framesLeft = decodeNextAnimationFrame(0);
-        for (int i = 0; i < kScreenWidth * kScreenHeight; ++i) {
-                if (_offscreenBuffer[i] == 0) {
-                        _offscreenBuffer[i] = _flicPlayer[1].getPixel(i);
-                }
-        }
-        if (!framesLeft) {
+
+        if (surface)
+                for (int i = 0; i < kScreenWidth * kScreenHeight; ++i)
+                        if (_offscreenBuffer[i] == 0)
+                                _offscreenBuffer[i] = *((byte *)surface->pixels + i);
+
+        if (!framesLeft)
                 _changeToNextSequence = true;
-        }
 }
 
 void AnimationSequencePlayer::displayLoadingScreen() {
@@ -864 +868 @@
 void AnimationSequencePlayer::playIntroSeq3_4() {
         if (!_updateScreenPicture) {
                 bool framesLeft = decodeNextAnimationFrame(0);
-                if (_flicPlayer[0].getCurFrame() == 706) {
+                if (_flicPlayer[0].getCurFrame() == 707) {
                         initPicPart4();
                 }
                 if (!framesLeft) {
@@ -903 +907 @@
 }
 
 void AnimationSequencePlayer::drawPic1Part10() {
+        ::Graphics::Surface *surface = _flicPlayer[0].decodeNextFrame();
+        _flicPlayer[0].copyDirtyRectsToBuffer(_offscreenBuffer, kScreenWidth);
+        ++_frameCounter;
+
+        if (_flicPlayer[0].hasDirtyPalette())
+                getRGBPalette(0);
+
         int offset = 0;
         for (int y = 0; y < kScreenHeight; ++y) {
                 for (int x = 0; x < kScreenWidth; ++x) {
-                        byte color = _flicPlayer[0].getPixel(offset);
-                        if (color == 0) {
+                        byte color = *((byte *)surface->pixels + offset);
+
+                        if (color == 0)
                                 color = _picBufPtr[800 + y * 640 + _updateScreenWidth + x];
-                        }
+
                         _offscreenBuffer[offset++] = color;
                 }
         }
@@ -924 +936 @@
 }
 
 void AnimationSequencePlayer::playIntroSeq9_10() {
-        bool framesLeft = decodeNextAnimationFrame(0);
-        if (_flicPlayer[0].getCurFrame() >= 264 && _flicPlayer[0].getCurFrame() <= 295) {
+        if (_flicPlayer[0].getCurFrame() >= 265 && _flicPlayer[0].getCurFrame() <= 296) {
                 drawPic1Part10();
                 _updateScreenWidth += 6;
-        } else if (_flicPlayer[0].getCurFrame() == 984) {
+        } else if (_flicPlayer[0].getCurFrame() == 985) {
+                decodeNextAnimationFrame(0);
                 drawPic2Part10();
-        } else if (_flicPlayer[0].getCurFrame() >= 988 && _flicPlayer[0].getCurFrame() <= 996) {
+        } else if (_flicPlayer[0].getCurFrame() >= 989 && _flicPlayer[0].getCurFrame() <= 997) {
                 drawPic1Part10();
                 _updateScreenWidth -= 25;
                 if (_updateScreenWidth < 0) {
                         _updateScreenWidth = 0;
                 }
         }
-        if (!framesLeft) {
+
+        if (_flicPlayer[0].endOfVideo())
                 _changeToNextSequence = true;
-        }
 }
 
 void AnimationSequencePlayer::loadIntroSeq21_22() {

engines/saga/scene.h

@@ -424 +424 @@
         int DinoStartProc();
         int FTA2StartProc();
         int FTA2EndProc(FTA2Endings whichEnding);
+        void playMovie(const char *filename);
 
         void IHNMLoadCutaways();
         bool checkKey();

engines/saga/introproc_saga2.cpp

@@ -40 +40 @@
 int Scene::DinoStartProc() {
         _vm->_gfx->showCursor(false);
 
-        Graphics::SmackerDecoder *smkDecoder = new Graphics::SmackerDecoder(_vm->_mixer);
-        Graphics::VideoPlayer *player = new Graphics::VideoPlayer(smkDecoder);
-        if (smkDecoder->loadFile("testvid.smk"))
-                player->playVideo();        // Play introduction
-        smkDecoder->closeFile();
-        delete player;
-        delete smkDecoder;
+        playMovie("testvid.smk");
 
         // HACK: Forcibly quit here
         _vm->quitGame();
@@ -57 +51 @@
 int Scene::FTA2StartProc() {
         _vm->_gfx->showCursor(false);
 
-        Graphics::SmackerDecoder *smkDecoder = new Graphics::SmackerDecoder(_vm->_mixer);
-        Graphics::VideoPlayer *player = new Graphics::VideoPlayer(smkDecoder);
-        if (smkDecoder->loadFile("trimark.smk"))
-                player->playVideo();      // Show Ignite logo
-        smkDecoder->closeFile();
-        if (smkDecoder->loadFile("intro.smk"))
-                player->playVideo();        // Play introduction
-        smkDecoder->closeFile();
-        delete player;
-        delete smkDecoder;
+        playMovie("trimark.smk");
+        playMovie("intro.smk");
 
         // HACK: Forcibly quit here
         _vm->quitGame();
@@ -100 +86 @@
         _vm->_gfx->showCursor(false);
 
         // Play ending
-        Graphics::SmackerDecoder *smkDecoder = new Graphics::SmackerDecoder(_vm->_mixer);
-        Graphics::VideoPlayer *player = new Graphics::VideoPlayer(smkDecoder);
-        if (smkDecoder->loadFile(videoName)) {
-                player->playVideo();
-                smkDecoder->closeFile();
-        }
-        delete player;
-        delete smkDecoder;
+        playMovie(videoName);
 
         return SUCCESS;
 }
 
+void Scene::playMovie(const char *filename) {
+        Graphics::SmackerDecoder *smkDecoder = new Graphics::SmackerDecoder(_vm->_mixer);
+
+        if (!smkDecoder->loadFile(filename))
+                return;
+
+        uint16 x = (g_system->getWidth() - smkDecoder->getWidth()) / 2;
+        uint16 y = (g_system->getHeight() - smkDecoder->getHeight()) / 2;
+
+        while (!_vm->shouldQuit() && !smkDecoder->endOfVideo()) {
+                if (smkDecoder->needsUpdate()) {
+                        Graphics::Surface *frame = smkDecoder->decodeNextFrame();
+                        if (frame) {
+                                _vm->_system->copyRectToScreen((byte *)frame->pixels, frame->pitch, x, y, frame->w, frame->h);
+
+                                if (smkDecoder->hasDirtyPalette())
+                                        smkDecoder->setSystemPalette();
+
+                                _vm->_system->updateScreen();
+                        }
+                }
+        
+                Common::Event event;
+                while (_vm->_system->getEventManager()->pollEvent(event))
+                        ;
+
+                _vm->_system->delayMillis(10);
+        }
+}
+
 } // End of namespace Saga
 
 #endif

engines/sci/console.cpp

@@ -223 +223 @@
         if (!_videoFile.empty()) {
                 _engine->_gfxCursor->kernelHide();
 
+                Graphics::VideoDecoder *videoDecoder = 0;
+
                 if (_videoFile.hasSuffix(".seq")) {
-                        SeqDecoder *seqDecoder = new SeqDecoder();
-                        Graphics::VideoPlayer *player = new Graphics::VideoPlayer(seqDecoder);
-                        if (seqDecoder->loadFile(_videoFile.c_str(), _videoFrameDelay))
-                                player->playVideo();
-                        else
-                                DebugPrintf("Failed to open movie file %s\n", _videoFile.c_str());
-                        seqDecoder->closeFile();
-                        delete player;
-                        delete seqDecoder;
-                } else if (_videoFile.hasSuffix(".avi")) {
-                        Graphics::AviDecoder *aviDecoder = new Graphics::AviDecoder(g_system->getMixer());
-                        Graphics::VideoPlayer *player = new Graphics::VideoPlayer(aviDecoder);
-                        if (aviDecoder->loadFile(_videoFile.c_str()))
-                                player->playVideo();
-                        else
-                                DebugPrintf("Failed to open movie file %s\n", _videoFile.c_str());
-                        aviDecoder->closeFile();
-                        delete player;
-                        delete aviDecoder;
+                        videoDecoder = new SeqDecoder();
+                        ((SeqDecoder *)videoDecoder)->setFrameDelay(_videoFrameDelay);
+#ifdef ENABLE_SCI32
                 } else if (_videoFile.hasSuffix(".vmd")) {
-#ifdef ENABLE_SCI32
-                        VMDDecoder *vmdDecoder = new VMDDecoder(g_system->getMixer());
-                        Graphics::VideoPlayer *player = new Graphics::VideoPlayer(vmdDecoder);
-                        if (vmdDecoder->loadFile(_videoFile.c_str()))
-                                player->playVideo();
-                        else
-                                DebugPrintf("Failed to open movie file %s\n", _videoFile.c_str());
-                        vmdDecoder->closeFile();
-                        delete player;
-                        delete vmdDecoder;
+                        videoDecoder = new VMDDecoder(g_system->getMixer());
 #endif
+                } else if (_videoFile.hasSuffix(".avi")) {
+                        videoDecoder = new Graphics::AviDecoder(g_system->getMixer());
                 }
 
+                if (videoDecoder && videoDecoder->loadFile(_videoFile)) {
+                        uint16 x = (g_system->getWidth() - videoDecoder->getWidth()) / 2;
+                        uint16 y = (g_system->getHeight() - videoDecoder->getHeight()) / 2;
+
+                        while (!g_engine->shouldQuit() && !videoDecoder->endOfVideo()) {                        
+                                if (videoDecoder->needsUpdate()) {
+                                        Graphics::Surface *frame = videoDecoder->decodeNextFrame();
+                                        if (frame) {
+                                                g_system->copyRectToScreen((byte *)frame->pixels, frame->pitch, x, y, frame->w, frame->h);
+
+                                                if (videoDecoder->hasDirtyPalette())
+                                                        videoDecoder->setSystemPalette();
+
+                                                g_system->updateScreen();
+                                        }
+                                }
+
+                                Common::Event event;
+                                while (g_system->getEventManager()->pollEvent(event))
+                                        ;
+
+                                g_system->delayMillis(10);
+                        }
+                
+                        delete videoDecoder;
+                } else
+                        warning("Could not play video %s\n", _videoFile.c_str());
+
                 _engine->_gfxCursor->kernelShow();
-
                 _videoFile.clear();
                 _videoFrameDelay = 0;
         }

engines/sci/engine/kgraphics.cpp

@@ -1076 +1076 @@
 }
 
 reg_t kShowMovie(EngineState *s, int argc, reg_t *argv) {
-        bool playedVideo = false;
-
         // Hide the cursor if it's showing and then show it again if it was
         // previously visible.
         bool reshowCursor;
@@ -1085 +1083 @@
         reshowCursor = g_sci->_gfxCursor->isVisible();
         if (reshowCursor)
                 g_sci->_gfxCursor->kernelHide();
+                
+        Graphics::VideoDecoder *videoDecoder = 0;
 
         if (argv[0].segment != 0) {
                 // DOS SEQ
                 // SEQ's are called with no subops, just the string and delay
                 Common::String filename = s->_segMan->getString(argv[0]);
-                int delay = argv[1].toUint16(); // Time between frames in ticks
 
                 SeqDecoder *seqDecoder = new SeqDecoder();
-                Graphics::VideoPlayer *player = new Graphics::VideoPlayer(seqDecoder);
-                if (seqDecoder->loadFile(filename.c_str(), delay)) {
-                        player->playVideo();
-                        playedVideo = true;
-                } else {
+                seqDecoder->setFrameDelay(argv[1].toUint16());
+                videoDecoder = seqDecoder;
+                
+                if (!videoDecoder->loadFile(filename)) {
                         warning("Failed to open movie file %s", filename.c_str());
+                        delete videoDecoder;
+                        videoDecoder = 0;
                 }
-                seqDecoder->closeFile();
-                delete player;
-                delete seqDecoder;
         } else {
                 // Windows AVI (Macintosh QuickTime? Need to check KQ6 Macintosh)
                 // TODO: This appears to be some sort of subop. case 0 contains the string
@@ -1121 +1118 @@
                 switch (argv[0].toUint16()) {
                 case 0: {
                         Common::String filename = s->_segMan->getString(argv[1]);
-                        Graphics::AviDecoder *aviDecoder = new Graphics::AviDecoder(g_system->getMixer());
-                        Graphics::VideoPlayer *player = new Graphics::VideoPlayer(aviDecoder);
-                        if (aviDecoder->loadFile(filename.c_str())) {
-                                player->playVideo();
-                                playedVideo = true;
-                        } else {
+                        videoDecoder = new Graphics::AviDecoder(g_system->getMixer());
+
+                        if (!videoDecoder->loadFile(filename.c_str())) {
                                 warning("Failed to open movie file %s", filename.c_str());
+                                delete videoDecoder;
+                                videoDecoder = 0;
                         }
-                        aviDecoder->closeFile();
-                        delete player;
-                        delete aviDecoder;
                         break;
                 }
                 default:
@@ -1139 +1132 @@
                 }
         }
 
-        if (playedVideo)
+        if (videoDecoder) {
+                uint16 x = (g_system->getWidth() - videoDecoder->getWidth()) / 2;
+                uint16 y = (g_system->getHeight() - videoDecoder->getHeight()) / 2;
+
+                while (!g_engine->shouldQuit() && !videoDecoder->endOfVideo()) {                        
+                        if (videoDecoder->needsUpdate()) {
+                                Graphics::Surface *frame = videoDecoder->decodeNextFrame();
+                                if (frame) {
+                                        g_system->copyRectToScreen((byte *)frame->pixels, frame->pitch, x, y, frame->w, frame->h);
+
+                                        if (videoDecoder->hasDirtyPalette())
+                                                videoDecoder->setSystemPalette();
+
+                                        g_system->updateScreen();
+                                }
+                        }
+
+                        Common::Event event;
+                        while (g_system->getEventManager()->pollEvent(event))
+                                ;
+
+                        g_system->delayMillis(10);
+                }
+                
+                delete videoDecoder;
                 g_sci->_gfxScreen->kernelSyncWithFramebuffer();
+        }
 
         if (reshowCursor)
                 g_sci->_gfxCursor->kernelShow();

engines/sci/video/vmd_decoder.h

@@ -29 +29 @@
 #define GRAPHICS_VIDEO_VMD_DECODER_H
 
 #include "graphics/video/coktelvideo/coktelvideo.h"
-#include "graphics/video/video_player.h"
+#include "graphics/video/video_decoder.h"
 #include "sound/mixer.h"
 
 namespace Sci {
@@ -49 +49 @@
  * - Shivers 2: Harvest of Souls
  * - Torin's Passage
  */
-class VMDDecoder : public Graphics::VideoDecoder {
+class VMDDecoder : public Graphics::FixedRateVideoDecoder {
 public:
         VMDDecoder(Audio::Mixer *mixer);
         virtual ~VMDDecoder();
 
         uint32 getFrameWaitTime();
 
-        /**
-         * Load a VMD encoded video file
-         * @param filename      the filename to load
-         */
-        bool loadFile(const char *filename);
+        bool load(Common::SeekableReadStream &stream);
+        void close();
 
-        /**
-         * Close a VMD encoded video file
-         */
-        void closeFile();
+        bool isVideoLoaded() const { return _fileStream != 0; }
+        uint16 getWidth() const { return _surface->w; }
+        uint16 getHeight() const { return _surface->h; }
+        uint32 getFrameCount() const { return _vmdDecoder->getFramesCount(); }
+        Graphics::Surface *decodeNextFrame();
+        Graphics::PixelFormat getPixelFormat() const { return Graphics::PixelFormat::createFormatCLUT8(); }
+        byte *getPalette() { _dirtyPalette = false; return _palette; }
+        bool hasDirtyPalette() const { return _dirtyPalette; }
 
-        bool decodeNextFrame();
+protected:
+        double getFrameRate() const { return _vmdDecoder->getFrameRate(); }
 
 private:
         Graphics::Vmd *_vmdDecoder;
         Audio::Mixer *_mixer;
+        Graphics::Surface *_surface;
+        Common::SeekableReadStream *_fileStream;
         byte _palette[256 * 3];
+        bool _dirtyPalette;
 
-        void getPalette();
+        void loadPaletteFromVMD();
 };
 
 } // End of namespace Graphics

engines/sci/video/seq_decoder.h

@@ -26 +26 @@
 #ifndef SEQ_DECODER_H
 #define SEQ_DECODER_H
 
-#include "graphics/video/video_player.h"
+#include "graphics/video/video_decoder.h"
 
 namespace Sci {
 
 /**
  * Implementation of the Sierra SEQ decoder, used in KQ6 DOS floppy/CD and GK1 DOS
  */
-class SeqDecoder : public Graphics::VideoDecoder {
+class SeqDecoder : public Graphics::FixedRateVideoDecoder {
 public:
-        SeqDecoder() {}
+        SeqDecoder();
         virtual ~SeqDecoder();
 
-        /**
-         * Load a SEQ encoded video file
-         * @param filename      the filename to load
-         */
-        bool loadFile(const char *fileName) { return loadFile(fileName, 10); }
+        bool load(Common::SeekableReadStream &stream);
+        void close();
+        
+        void setFrameDelay(int frameDelay) { _frameDelay = frameDelay; }
 
-        /**
-         * Load a SEQ encoded video file
-         * @param filename      the filename to load
-         * @param frameDelay the delay between frames, in ticks
-         */
-        bool loadFile(const char *fileName, int frameDelay);
+        bool isVideoLoaded() const { return _fileStream != 0; }
+        uint16 getWidth() const { return 320; }
+        uint16 getHeight() const { return 200; }
+        uint32 getFrameCount() const { return _frameCount; }
+        Graphics::Surface *decodeNextFrame();
+        Graphics::PixelFormat getPixelFormat() const { return Graphics::PixelFormat::createFormatCLUT8(); }
+        byte *getPalette() { _dirtyPalette = false; return _palette; }
+        bool hasDirtyPalette() const { return _dirtyPalette; }
 
-        /**
-         * Close a SEQ encoded video file
-         */
-        void closeFile();
+protected:
+        double getFrameRate() const { assert(_frameDelay); return 60.0 / _frameDelay; }
 
-        bool decodeNextFrame();
-
 private:
         bool decodeFrame(byte *rleData, int rleSize, byte *litData, int litSize, byte *dest, int left, int width, int height, int colorKey);
+        uint16 _width, _height;
+        uint16 _frameDelay;
+        Common::SeekableReadStream *_fileStream;
+        byte _palette[256 * 3];
+        bool _dirtyPalette;
+        uint32 _frameCount;
+        Graphics::Surface *_surface;
 };
 
 } // End of namespace Sci

engines/sci/video/vmd_decoder.cpp

@@ -27 +27 @@
 
 #include "sci/video/vmd_decoder.h"
 
-#include "common/archive.h"
 #include "common/endian.h"
 #include "common/util.h"
 #include "common/stream.h"
@@ -42 +41 @@
 
 VMDDecoder::VMDDecoder(Audio::Mixer *mixer) : _mixer(mixer) {
         _vmdDecoder = new Graphics::Vmd(new Graphics::PaletteLUT(5, Graphics::PaletteLUT::kPaletteYUV));
+        _surface = 0;
+        _dirtyPalette = false;
+        _fileStream = 0;
 }
 
 VMDDecoder::~VMDDecoder() {
-        closeFile();
+        close();
 }
 
-uint32 VMDDecoder::getFrameWaitTime() {
-        return _vmdDecoder->getFrameWaitTime();
-}
+bool VMDDecoder::load(Common::SeekableReadStream &stream) {
+        close();
 
-bool VMDDecoder::loadFile(const char *fileName) {
-        closeFile();
-
-        _fileStream = SearchMan.createReadStreamForMember(fileName);
-        if (!_fileStream)
+        if (!_vmdDecoder->load(stream))
                 return false;
 
-        if (!_vmdDecoder->load(*_fileStream))
-                return false;
+        _fileStream = &stream;
 
-        if (_vmdDecoder->getFeatures() & Graphics::CoktelVideo::kFeaturesPalette) {
-                getPalette();
-                setPalette(_palette);
-        }
+        if (_vmdDecoder->getFeatures() & Graphics::CoktelVideo::kFeaturesPalette)
+                loadPaletteFromVMD();
 
         if (_vmdDecoder->getFeatures() & Graphics::CoktelVideo::kFeaturesSound)
                 _vmdDecoder->enableSound(*_mixer);
 
-        _videoInfo.width = _vmdDecoder->getWidth();
-        _videoInfo.height = _vmdDecoder->getHeight();
-        _videoInfo.frameCount = _vmdDecoder->getFramesCount();
-        _videoInfo.frameRate = _vmdDecoder->getFrameRate();
-        _videoInfo.frameDelay = _videoInfo.frameRate * 100;
-        _videoInfo.currentFrame = 0;
-        _videoInfo.firstframeOffset = 0;        // not really necessary for VMDs
-
         if (_vmdDecoder->hasExtraData())
                 warning("This VMD video has extra embedded data, which is currently not handled");
 
-        _videoFrameBuffer = new byte[_videoInfo.width * _videoInfo.height];
-        memset(_videoFrameBuffer, 0, _videoInfo.width * _videoInfo.height);
-
-        _vmdDecoder->setVideoMemory(_videoFrameBuffer, _videoInfo.width, _videoInfo.height);
-
+        _surface = new Graphics::Surface();
+        _surface->create(_vmdDecoder->getWidth(), _vmdDecoder->getHeight(), 1);
+        _vmdDecoder->setVideoMemory((byte *)_surface->pixels, _surface->w, _surface->h);
         return true;
 }
 
-void VMDDecoder::closeFile() {
+void VMDDecoder::close() {
         if (!_fileStream)
                 return;
 
@@ -98 +82 @@
         delete _fileStream;
         _fileStream = 0;
 
-        delete[] _videoFrameBuffer;
-        _videoFrameBuffer = 0;
+        _surface->free();
+        delete _surface;
+        _surface = 0;
+
+        reset();
 }
 
-bool VMDDecoder::decodeNextFrame() {
-        if (_videoInfo.currentFrame == 0)
-                _videoInfo.startTime = g_system->getMillis();
-
+Graphics::Surface *VMDDecoder::decodeNextFrame() {
         Graphics::CoktelVideo::State state = _vmdDecoder->nextFrame();
 
-        if (state.flags & Graphics::CoktelVideo::kStatePalette) {
-                getPalette();
-                setPalette(_palette);
-        }
+        if (state.flags & Graphics::CoktelVideo::kStatePalette)
+                loadPaletteFromVMD();
 
-        return ++_videoInfo.currentFrame < _videoInfo.frameCount;
+        if (_curFrame == -1)
+                _startTime = g_system->getMillis();
+
+        _curFrame++;
+        return _surface;
 }
 
-void VMDDecoder::getPalette() {
+void VMDDecoder::loadPaletteFromVMD() {
         const byte *pal = _vmdDecoder->getPalette();
 
         for (int i = 0; i < 256; i++) {
@@ -124 +110 @@
                 _palette[i * 3 + 1] = pal[i * 3 + 1] << 2;
                 _palette[i * 3 + 2] = pal[i * 3 + 2] << 2;
         }
+
+        _dirtyPalette = true;
 }
 
 } // End of namespace Graphics

engines/sci/video/seq_decoder.cpp

@@ -35 +35 @@
 
 namespace Sci {
 
-// SEQ videos always run at 320x200
-#define SCREEN_WIDTH 320
-#define SCREEN_HEIGHT 200
-
 enum seqPalTypes {
         kSeqPalVariable = 0,
         kSeqPalConstant = 1
@@ -49 +45 @@
         kSeqFrameDiff = 1
 };
 
+SeqDecoder::SeqDecoder() {
+        _fileStream = 0;
+        _surface = 0;
+        _dirtyPalette = false;
+}
+
 SeqDecoder::~SeqDecoder() {
-        closeFile();
+        close();
 }
 
-bool SeqDecoder::loadFile(const char *fileName, int frameDelay) {
-        closeFile();
+bool SeqDecoder::load(Common::SeekableReadStream &stream) {
+        close();
 
-        _fileStream = SearchMan.createReadStreamForMember(fileName);
-        if (!_fileStream)
-                return false;
+        _fileStream = &stream;
+        _surface = new Graphics::Surface();
+        _surface->create(getWidth(), getHeight(), 1);
 
-        // Seek to the first frame
-        _videoInfo.currentFrame = 0;
+        _frameCount = _fileStream->readUint16LE();
 
-        _videoInfo.width = SCREEN_WIDTH;
-        _videoInfo.height = SCREEN_HEIGHT;
-        _videoInfo.frameCount = _fileStream->readUint16LE();
-        // Our frameDelay is calculated in 1/100 ms, so we convert it here
-        _videoInfo.frameDelay = 100 * frameDelay * 1000 / 60;
-        _videoFrameBuffer = new byte[_videoInfo.width * _videoInfo.height];
-
         // Set palette
         int paletteSize = _fileStream->readUint32LE();
 
@@ -81 +75 @@
         uint16 palColorStart = READ_LE_UINT16(paletteData + 25);
         uint16 palColorCount = READ_LE_UINT16(paletteData + 29);
 
-        byte palette[256 * 4];
         int palOffset = 37;
 
         for (uint16 colorNo = palColorStart; colorNo < palColorStart + palColorCount; colorNo++) {
                 if (palFormat == kSeqPalVariable)
                         palOffset++;
-                palette[colorNo * 4 + 0] = paletteData[palOffset++];
-                palette[colorNo * 4 + 1] = paletteData[palOffset++];
-                palette[colorNo * 4 + 2] = paletteData[palOffset++];
-                palette[colorNo * 4 + 3] = 0;
+                _palette[colorNo * 3 + 0] = paletteData[palOffset++];
+                _palette[colorNo * 3 + 1] = paletteData[palOffset++];
+                _palette[colorNo * 3 + 2] = paletteData[palOffset++];
         }
 
-        g_system->setPalette(palette, 0, 256);
-
+        _dirtyPalette = true;
         delete[] paletteData;
-
-        _videoInfo.firstframeOffset = _fileStream->pos();
-
         return true;
 }
 
-void SeqDecoder::closeFile() {
+void SeqDecoder::close() {
         if (!_fileStream)
                 return;
 
+        _frameDelay = 0;
+
         delete _fileStream;
         _fileStream = 0;
 
-        delete[] _videoFrameBuffer;
-        _videoFrameBuffer = 0;
+        _surface->free();
+        delete _surface;
+        _surface = 0;
+
+        reset();
 }
 
-bool SeqDecoder::decodeNextFrame() {
+Graphics::Surface *SeqDecoder::decodeNextFrame() {
         int16 frameWidth = _fileStream->readUint16LE();
         int16 frameHeight = _fileStream->readUint16LE();
         int16 frameLeft = _fileStream->readUint16LE();
@@ -129 +122 @@
 
         _fileStream->seek(offset);
 
-        if (_videoInfo.currentFrame == 0)
-                _videoInfo.startTime = g_system->getMillis();
-
         if (frameType == kSeqFrameFull) {
-                byte *dst = _videoFrameBuffer + frameTop * SCREEN_WIDTH + frameLeft;
+                byte *dst = (byte *)_surface->pixels + frameTop * getWidth() + frameLeft;
 
                 byte *linebuf = new byte[frameWidth];
 
                 do {
                         _fileStream->read(linebuf, frameWidth);
                         memcpy(dst, linebuf, frameWidth);
-                        dst += SCREEN_WIDTH;
+                        dst += getWidth();
                 } while (--frameHeight);
 
                 delete[] linebuf;
         } else {
                 byte *buf = new byte[frameSize];
                 _fileStream->read(buf, frameSize);
-                decodeFrame(buf, rleSize, buf + rleSize, frameSize - rleSize, _videoFrameBuffer + SCREEN_WIDTH * frameTop, frameLeft, frameWidth, frameHeight, colorKey);
+                decodeFrame(buf, rleSize, buf + rleSize, frameSize - rleSize, (byte *)_surface->pixels + getWidth() * frameTop, frameLeft, frameWidth, frameHeight, colorKey);
                 delete[] buf;
         }
 
-        return ++_videoInfo.currentFrame < _videoInfo.frameCount;
+        if (_curFrame == -1)
+                _startTime = g_system->getMillis();
+
+        _curFrame++;
+        return _surface;
 }
 
 #define WRITE_TO_BUFFER(n) \
-        if (writeRow * SCREEN_WIDTH + writeCol + (n) > SCREEN_WIDTH * height) { \
+        if (writeRow * getWidth() + writeCol + (n) > getWidth() * height) { \
                 warning("SEQ player: writing out of bounds, aborting"); \
                 return false; \
         } \
         if (litPos + (n) > litSize) { \
                 warning("SEQ player: reading out of bounds, aborting"); \
         } \
-        memcpy(dest + writeRow * SCREEN_WIDTH + writeCol, litData + litPos, n);
+        memcpy(dest + writeRow * getWidth() + writeCol, litData + litPos, n);
 
 bool SeqDecoder::decodeFrame(byte *rleData, int rleSize, byte *litData, int litSize, byte *dest, int left, int width, int height, int colorKey) {
         int writeRow = 0;

engines/sword1/animation.h

@@ -28 +28 @@
 
 #include "graphics/video/dxa_decoder.h"
 #include "graphics/video/smk_decoder.h"
-#include "graphics/video/video_player.h"
+#include "graphics/video/video_decoder.h"
 
 #include "sword1/screen.h"
 #include "sword1/sound.h"
@@ -61 +61 @@
         DXADecoderWithSound(Audio::Mixer *mixer, Audio::SoundHandle *bgSoundHandle);
         ~DXADecoderWithSound() {}
 
-        int32 getAudioLag();
+        uint32 getElapsedTime() const;
+
 private:
         Audio::Mixer *_mixer;
         Audio::SoundHandle *_bgSoundHandle;
 };
 
-class MoviePlayer : public Graphics::VideoPlayer {
+class MoviePlayer {
 public:
         MoviePlayer(SwordEngine *vm, Text *textMan, Audio::Mixer *snd, OSystem *system, Audio::SoundHandle *bgSoundHandle, Graphics::VideoDecoder *decoder, DecoderType decoderType);
         virtual ~MoviePlayer();
         bool load(uint32 id);
         void play();
+
 protected:
         SwordEngine *_vm;
         Text *_textMan;
@@ -82 +84 @@
         int _textX, _textY, _textWidth, _textHeight;
         DecoderType _decoderType;
 
+        Graphics::VideoDecoder *_decoder;
         Audio::SoundHandle *_bgSoundHandle;
         Audio::AudioStream *_bgSoundStream;
 
+        bool playVideo();
         void performPostProcessing(byte *screen);
+
+        byte findBlackPalIndex();
+        byte findWhitePalIndex();
 };
 
 MoviePlayer *makeMoviePlayer(uint32 id, SwordEngine *vm, Text *textMan, Audio::Mixer *snd, OSystem *system);

engines/sword1/animation.cpp

@@ -68 +68 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 MoviePlayer::MoviePlayer(SwordEngine *vm, Text *textMan, Audio::Mixer *snd, OSystem *system, Audio::SoundHandle *bgSoundHandle, Graphics::VideoDecoder *decoder, DecoderType decoderType)
-        : _vm(vm), _textMan(textMan), _snd(snd), _bgSoundHandle(bgSoundHandle), _system(system), VideoPlayer(decoder) {
+        : _vm(vm), _textMan(textMan), _snd(snd), _bgSoundHandle(bgSoundHandle), _system(system) {
         _bgSoundStream = NULL;
         _decoderType = decoderType;
+        _decoder = decoder;
 }
 
 MoviePlayer::~MoviePlayer() {
@@ -86 +87 @@
         Common::File f;
         char filename[20];
 
-        if (_decoderType == kVideoDecoderDXA) {
+        if (_decoderType == kVideoDecoderDXA)
                 _bgSoundStream = Audio::SeekableAudioStream::openStreamFile(sequenceList[id]);
-        } else {
+        else
                 _bgSoundStream = NULL;
-        }
 
         if (SwordEngine::_systemVars.showText) {
                 sprintf(filename, "%s.txt", sequenceList[id]);
@@ -146 +146 @@
 }
 
 void MoviePlayer::play() {
-        if (_bgSoundStream) {
+        if (_bgSoundStream)
                 _snd->playInputStream(Audio::Mixer::kSFXSoundType, _bgSoundHandle, _bgSoundStream);
-        }
+
         bool terminated = false;
 
         _textX = 0;
@@ -205 +205 @@
                         for (x = 0; x < _textWidth; x++) {
                                 switch (src[x]) {
                                 case BORDER_COL:
-                                        dst[x] = _decoder->getBlack();
+                                        dst[x] = findBlackPalIndex();
                                         break;
                                 case LETTER_COL:
-                                        dst[x] = _decoder->getWhite();
+                                        dst[x] = findWhitePalIndex();
                                         break;
                                 }
                         }
@@ -228 +228 @@
 
                 for (y = 0; y < _textHeight; y++) {
                         if (_textY + y < frameY || _textY + y >= frameY + frameHeight) {
-                                memset(dst + _textX, _decoder->getBlack(), _textWidth);
+                                memset(dst + _textX, findBlackPalIndex(), _textWidth);
                         } else {
                                 if (frameX > _textX)
-                                        memset(dst + _textX, _decoder->getBlack(), frameX - _textX);
+                                        memset(dst + _textX, findBlackPalIndex(), frameX - _textX);
                                 if (frameX + frameWidth < _textX + _textWidth)
-                                        memset(dst + frameX + frameWidth, _decoder->getBlack(), _textX + _textWidth - (frameX + frameWidth));
+                                        memset(dst + frameX + frameWidth, findBlackPalIndex(), _textX + _textWidth - (frameX + frameWidth));
                         }
 
                         dst += _system->getWidth();
@@ -244 +244 @@
         }
 }
 
-DXADecoderWithSound::DXADecoderWithSound(Audio::Mixer *mixer, Audio::SoundHandle *bgSoundHandle)
-        : _mixer(mixer), _bgSoundHandle(bgSoundHandle)  {
+bool MoviePlayer::playVideo() {
+        uint16 x = (g_system->getWidth() - _decoder->getWidth()) / 2;
+        uint16 y = (g_system->getHeight() - _decoder->getHeight()) / 2;
+
+        while (!_vm->shouldQuit() && !_decoder->endOfVideo()) {
+                if (_decoder->needsUpdate()) {
+                        Graphics::Surface *frame = _decoder->decodeNextFrame();
+                        if (frame)
+                                _vm->_system->copyRectToScreen((byte *)frame->pixels, frame->pitch, x, y, frame->w, frame->h);
+
+                        if (_decoder->hasDirtyPalette())
+                                _decoder->setSystemPalette();
+
+                        Graphics::Surface *screen = _vm->_system->lockScreen();
+                        performPostProcessing((byte *)screen->pixels);
+                        _vm->_system->unlockScreen();
+                        _vm->_system->updateScreen();
+                }
+
+                Common::Event event;
+                while (_vm->_system->getEventManager()->pollEvent(event))
+                        if ((event.type == Common::EVENT_KEYDOWN && event.kbd.keycode == Common::KEYCODE_ESCAPE) || event.type == Common::EVENT_LBUTTONUP)
+                                return false;
+        }
+
+        return true;
 }
 
-int32 DXADecoderWithSound::getAudioLag() {
-        if (!_fileStream)
-                return 0;
+byte MoviePlayer::findBlackPalIndex() {
+        return 0;
+}
 
-        if (!_mixer->isSoundHandleActive(*_bgSoundHandle))
-                return 0;
+byte MoviePlayer::findWhitePalIndex() {
+        return 0xff;
+}
 
-        int32 frameDelay = getFrameDelay();
-        int32 videoTime = _videoInfo.currentFrame * frameDelay;
-        int32 audioTime;
+DXADecoderWithSound::DXADecoderWithSound(Audio::Mixer *mixer, Audio::SoundHandle *bgSoundHandle)
+        : _mixer(mixer), _bgSoundHandle(bgSoundHandle)  {
+}
 
-        const Audio::Timestamp ts = _mixer->getElapsedTime(*_bgSoundHandle);
-        audioTime = ts.convertToFramerate(100000).totalNumberOfFrames();
+uint32 DXADecoderWithSound::getElapsedTime() const {
+        if (_mixer->isSoundHandleActive(*_bgSoundHandle))
+                return _mixer->getSoundElapsedTime(*_bgSoundHandle);
 
-        return videoTime - audioTime;
+        return VideoDecoder::getElapsedTime();
 }
 
 ///////////////////////////////////////////////////////////////////////////////

engines/sword2/animation.h

@@ -30 +30 @@
 
 #include "graphics/video/dxa_decoder.h"
 #include "graphics/video/smk_decoder.h"
-#include "graphics/video/video_player.h"
+#include "graphics/video/video_decoder.h"
 #include "sound/mixer.h"
 
 #include "sword2/screen.h"
@@ -63 +63 @@
         DXADecoderWithSound(Audio::Mixer *mixer, Audio::SoundHandle *bgSoundHandle);
         ~DXADecoderWithSound() {}
 
-        int32 getAudioLag();
+        uint32 getElapsedTime() const;
 private:
         Audio::Mixer *_mixer;
         Audio::SoundHandle *_bgSoundHandle;
 };
 
-class MoviePlayer : public Graphics::VideoPlayer {
+class MoviePlayer {
 public:
         MoviePlayer(Sword2Engine *vm, Audio::Mixer *snd, OSystem *system, Audio::SoundHandle *bgSoundHandle, Graphics::VideoDecoder *decoder, DecoderType decoderType);
         virtual ~MoviePlayer();
@@ -89 +89 @@
         int _textX, _textY;
         DecoderType _decoderType;
 
+        Graphics::VideoDecoder *_decoder;
         Audio::SoundHandle *_bgSoundHandle;
         Audio::AudioStream *_bgSoundStream;
 
@@ -96 +97 @@
         int _leadOutFrame;
 
         void performPostProcessing(byte *screen);
+        bool playVideo();
 
         void openTextObject(uint32 index);
         void closeTextObject(uint32 index, byte *screen);
         void drawTextObject(uint32 index, byte *screen);
+
+        byte findBlackPalIndex();
+        byte findWhitePalIndex();
 };
 
 MoviePlayer *makeMoviePlayer(const char *name, Sword2Engine *vm, Audio::Mixer *snd, OSystem *system);

engines/sword2/animation.cpp

@@ -47 +47 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 MoviePlayer::MoviePlayer(Sword2Engine *vm, Audio::Mixer *snd, OSystem *system, Audio::SoundHandle *bgSoundHandle, Graphics::VideoDecoder *decoder, DecoderType decoderType)
-        : _vm(vm), _snd(snd), _bgSoundHandle(bgSoundHandle), _system(system), VideoPlayer(decoder) {
+        : _vm(vm), _snd(snd), _bgSoundHandle(bgSoundHandle), _system(system) {
         _bgSoundStream = NULL;
         _decoderType = decoderType;
+        _decoder = decoder;
 }
 
 MoviePlayer:: ~MoviePlayer() {
@@ -62 +63 @@
  * @param id the id of the file
  */
 bool MoviePlayer::load(const char *name) {
-        if (_decoderType == kVideoDecoderDXA) {
+        if (_decoderType == kVideoDecoderDXA)
                 _bgSoundStream = Audio::SeekableAudioStream::openStreamFile(name);
-        } else {
+        else
                 _bgSoundStream = NULL;
-        }
 
         _textSurface = NULL;
 
@@ -97 +97 @@
         _currentMovieText = 0;
         _leadOut = leadOut;
 
-        if (leadIn) {
+        if (leadIn)
                 _vm->_sound->playMovieSound(leadIn, kLeadInSound);
-        }
 
-        if (_bgSoundStream) {
+        if (_bgSoundStream)
                 _snd->playInputStream(Audio::Mixer::kSFXSoundType, _bgSoundHandle, _bgSoundStream);
-        }
 
         bool terminated = false;
 
@@ -186 +184 @@
 
                                 for (int y = 0; y < text->_textSprite.h; y++) {
                                         if (_textY + y < frameY || _textY + y >= frameY + frameHeight) {
-                                                memset(dst + _textX, _decoder->getBlack(), text->_textSprite.w);
+                                                memset(dst + _textX, findBlackPalIndex(), text->_textSprite.w);
                                         } else {
                                                 if (frameX > _textX)
-                                                        memset(dst + _textX, _decoder->getBlack(), frameX - _textX);
+                                                        memset(dst + _textX, findBlackPalIndex(), frameX - _textX);
                                                 if (frameX + frameWidth < _textX + text->_textSprite.w)
-                                                        memset(dst + frameX + frameWidth, _decoder->getBlack(), _textX + text->_textSprite.w - (frameX + frameWidth));
+                                                        memset(dst + frameX + frameWidth, findBlackPalIndex(), _textX + text->_textSprite.w - (frameX + frameWidth));
                                         }
 
                                         dst += _system->getWidth();
@@ -207 +205 @@
 void MoviePlayer::drawTextObject(uint32 index, byte *screen) {
         MovieText *text = &_movieTexts[index];
 
-        byte white = _decoder->getWhite();
-        byte black = _decoder->getBlack();
+        byte white = findWhitePalIndex();
+        byte black = findBlackPalIndex();
 
         if (text->_textMem && _textSurface) {
                 byte *src = text->_textSprite.data;
@@ -272 +270 @@
         }
 }
 
-DXADecoderWithSound::DXADecoderWithSound(Audio::Mixer *mixer, Audio::SoundHandle *bgSoundHandle)
-        : _mixer(mixer), _bgSoundHandle(bgSoundHandle)  {
+bool MoviePlayer::playVideo() {
+        uint16 x = (g_system->getWidth() - _decoder->getWidth()) / 2;
+        uint16 y = (g_system->getHeight() - _decoder->getHeight()) / 2;
+
+        while (!_vm->shouldQuit() && !_decoder->endOfVideo()) {
+                if (_decoder->needsUpdate()) {
+                        Graphics::Surface *frame = _decoder->decodeNextFrame();
+                        if (frame)
+                                _vm->_system->copyRectToScreen((byte *)frame->pixels, frame->pitch, x, y, frame->w, frame->h);
+
+                        if (_decoder->hasDirtyPalette())
+                                _decoder->setSystemPalette();
+
+                        Graphics::Surface *screen = _vm->_system->lockScreen();
+                        performPostProcessing((byte *)screen->pixels);
+                        _vm->_system->unlockScreen();
+                        _vm->_system->updateScreen();
+                }
+
+                Common::Event event;
+                while (_vm->_system->getEventManager()->pollEvent(event))
+                        if ((event.type == Common::EVENT_KEYDOWN && event.kbd.keycode == Common::KEYCODE_ESCAPE) || event.type == Common::EVENT_LBUTTONUP)
+                                return false;
+        }
+
+        return true;
 }
 
-int32 DXADecoderWithSound::getAudioLag() {
-        if (!_fileStream)
-                return 0;
+byte MoviePlayer::findBlackPalIndex() {
+        return 0;
+}
 
-        if (!_mixer->isSoundHandleActive(*_bgSoundHandle))
-                return 0;
+byte MoviePlayer::findWhitePalIndex() {
+        return 0xff;
+}
 
-        int32 frameDelay = getFrameDelay();
-        int32 videoTime = _videoInfo.currentFrame * frameDelay;
-        int32 audioTime;
+DXADecoderWithSound::DXADecoderWithSound(Audio::Mixer *mixer, Audio::SoundHandle *bgSoundHandle)
+        : _mixer(mixer), _bgSoundHandle(bgSoundHandle)  {
+}
 
-        const Audio::Timestamp ts = _mixer->getElapsedTime(*_bgSoundHandle);
-        audioTime = ts.convertToFramerate(100000).totalNumberOfFrames();
+uint32 DXADecoderWithSound::getElapsedTime() const {
+        if (_mixer->isSoundHandleActive(*_bgSoundHandle))
+                return _mixer->getSoundElapsedTime(*_bgSoundHandle);
 
-        return videoTime - audioTime;
+        return VideoDecoder::getElapsedTime();
 }
 
 ///////////////////////////////////////////////////////////////////////////////

engines/scumm/he/animation_he.h

@@ -56 +56 @@
 
         void copyFrameToBuffer(byte *dst, int dstType, uint x, uint y, uint pitch);
         void handleNextFrame();
-
-protected:
-        virtual void setPalette(byte *pal);
 };
 
 } // End of namespace Scumm

engines/scumm/he/script_v90he.cpp

@@ -1437 +1437 @@
                         }
                 } else if (_videoParams.status == 165) {
                         // Stop video
-                        _moviePlay->closeFile();
+                        _moviePlay->close();
                 }
                 break;
         default:
@@ -1464 +1464 @@
                 break;
         case 52:        // Get current frame
                 pop();
-                push(_moviePlay->getCurFrame());
+                push(_moviePlay->endOfVideo() ? -1 : (_moviePlay->getCurFrame() + 1));
                 break;
         case 63:        // Get image number
                 pop();

engines/scumm/he/script_v100he.cpp

@@ -2254 +2254 @@
                         }
                 } else if (_videoParams.status == 19) {
                         // Stop video
-                        _moviePlay->closeFile();
+                        _moviePlay->close();
                 }
                 break;
         default:
@@ -2937 +2937 @@
                 break;
         case 73:
                 pop();
-                push(_moviePlay->getCurFrame());
+                push(_moviePlay->endOfVideo() ? -1 : (_moviePlay->getCurFrame() + 1));
                 break;
         case 84:
                 pop();

engines/scumm/he/animation_he.cpp

@@ -46 +46 @@
 }
 
 int MoviePlayer::load(const char *filename, int flags, int image) {
-        if (isVideoLoaded()) {
-                closeFile();
-        }
+        if (isVideoLoaded())
+                close();
 
-        if (!loadFile(filename)) {
+        if (!loadFile(Common::String(filename))) {
                 warning("Failed to load video file %s", filename);
                 return -1;
         }
+
         debug(1, "Playing video %s", filename);
 
-        if (flags & 2) {
+        if (flags & 2)
                 _vm->_wiz->createWizEmptyImage(image, 0, 0, getWidth(), getHeight());
-        }
 
         _flags = flags;
         _wizResNum = image;
-
         return 0;
 }
 
@@ -70 +68 @@
         uint h = getHeight();
         uint w = getWidth();
 
-        byte *src = _videoFrameBuffer;
+        Graphics::Surface *surface = decodeNextFrame();
+        byte *src = (byte *)surface->pixels;
 
+        if (hasDirtyPalette())
+                _vm->setPaletteFromPtr(getPalette(), 256);
+
         if (_vm->_game.features & GF_16BIT_COLOR) {
                 dst += y * pitch + x * 2;
                 do {
@@ -102 +104 @@
 }
 
 void MoviePlayer::handleNextFrame() {
-        if (!isVideoLoaded()) {
+        if (!isVideoLoaded())
                 return;
-        }
 
         VirtScreen *pvs = &_vm->_virtscr[kMainVirtScreen];
 
-        decodeNextFrame();
-
         if (_flags & 2) {
                 uint8 *dstPtr = _vm->getResourceAddress(rtImage, _wizResNum);
                 assert(dstPtr);
@@ -128 +127 @@
                 _vm->markRectAsDirty(kMainVirtScreen, imageRect);
         }
 
-        if (getCurFrame() == getFrameCount()) {
-                closeFile();
-        }
+        if (endOfVideo())
+                close();
 }
 
-void MoviePlayer::setPalette(byte *pal) {
-        _vm->setPaletteFromPtr(pal, 256);
-}
-
 } // End of namespace Scumm
 
 #endif // ENABLE_HE

engines/agos/animation.h

@@ -72 +72 @@
         virtual void handleNextFrame();
         virtual bool processFrame() = 0;
         virtual void startSound() {};
+
+protected:
+        uint32 _firstFrameOffset;
 };
 
 class MoviePlayerDXA : public MoviePlayer, ::Graphics::DXADecoder {
@@ -84 +87 @@
         void playVideo();
         void nextFrame();
         virtual void stopVideo();
-protected:
-        void setPalette(byte *pal);
 
 private:
         void handleNextFrame();
         bool processFrame();
         void startSound();
+        void copyFrameToBuffer(byte *dst, uint x, uint y, uint pitch);
 };
 
 class MoviePlayerSMK : public MoviePlayer, ::Graphics::SmackerDecoder {
@@ -101 +103 @@
         void playVideo();
         void nextFrame();
         virtual void stopVideo();
-protected:
-        void setPalette(byte *pal);
+
 private:
         void handleNextFrame();
         bool processFrame();
         void startSound();
+        void copyFrameToBuffer(byte *dst, uint x, uint y, uint pitch);
 };
 
 MoviePlayer *makeMoviePlayer(AGOSEngine_Feeble *vm, const char *name);

engines/agos/animation.cpp

@@ -241 +241 @@
 }
 
 bool MoviePlayerDXA::load() {
-        char videoName[20];
-        uint i;
-
         if ((_vm->getPlatform() == Common::kPlatformAmiga || _vm->getPlatform() == Common::kPlatformMacintosh) &&
                 _vm->_language != Common::EN_ANY) {
                 _sequenceNum = 0;
-                for (i = 0; i < 90; i++) {
+                for (uint i = 0; i < 90; i++) {
                         if (!scumm_stricmp(baseName, _sequenceList[i]))
                                 _sequenceNum = i;
                 }
         }
 
-        sprintf(videoName, "%s.dxa", baseName);
+        Common::String videoName = Common::String::printf("%s.dxa", baseName);
         if (!loadFile(videoName))
-                error("Failed to load video file %s", videoName);
+                error("Failed to load video file %s", videoName.c_str());
 
-        debug(0, "Playing video %s", videoName);
+        debug(0, "Playing video %s", videoName.c_str());
 
         CursorMan.showMouse(false);
 
+        _firstFrameOffset = _fileStream->pos();
+
         return true;
 }
 
+void MoviePlayerDXA::copyFrameToBuffer(byte *dst, uint x, uint y, uint pitch) {
+        uint h = getHeight();
+        uint w = getWidth();
+
+        Graphics::Surface *surface = decodeNextFrame();
+        byte *src = (byte *)surface->pixels;
+        dst += y * pitch + x;
+
+        do {
+                memcpy(dst, src, w);
+                dst += pitch;
+                src += w;
+        } while (--h);
+
+        if (hasDirtyPalette())
+                setSystemPalette();
+}
+
 void MoviePlayerDXA::playVideo() {
         // Most of the videos included in the Amiga version, reduced the
         // resoluton to 384 x 280, so require the screen to be cleared,
@@ -272 +289 @@
                 _vm->clearSurfaces();
         }
 
-        while (getCurFrame() < getFrameCount() && !_skipMovie && !_vm->shouldQuit())
+        while (!endOfVideo() && !_skipMovie && !_vm->shouldQuit())
                 handleNextFrame();
 }
 
 void MoviePlayerDXA::stopVideo() {
-        closeFile();
+        close();
         _mixer->stopHandle(_bgSound);
 }
 
@@ -318 +335 @@
 }
 
 void MoviePlayerDXA::nextFrame() {
-        if (_bgSoundStream && _vm->_mixer->isSoundHandleActive(_bgSound) && (_vm->_mixer->getSoundElapsedTime(_bgSound) * getFrameRate()) / 1000 < (uint32)getCurFrame()) {
+        if (_bgSoundStream && _vm->_mixer->isSoundHandleActive(_bgSound) && needsUpdate()) {
                 copyFrameToBuffer(_vm->getBackBuf(), 465, 222, _vm->_screenWidth);
                 return;
         }
 
-        if (_vm->_interactiveVideo == TYPE_LOOPING && getCurFrame() == getFrameCount()) {
-                _fileStream->seek(_videoInfo.firstframeOffset);
-                _videoInfo.currentFrame = 0;
+        if (_vm->_interactiveVideo == TYPE_LOOPING && endOfVideo()) {
+                _fileStream->seek(_firstFrameOffset);
+                _curFrame = -1;
                 startSound();
         }
 
-        if (getCurFrame() < getFrameCount()) {
-                decodeNextFrame();
-                if (_vm->_interactiveVideo == TYPE_OMNITV) {
+        if (!endOfVideo()) {
+                if (_vm->_interactiveVideo == TYPE_OMNITV)
                         copyFrameToBuffer(_vm->getBackBuf(), 465, 222, _vm->_screenWidth);
-                } else if (_vm->_interactiveVideo == TYPE_LOOPING) {
+                else if (_vm->_interactiveVideo == TYPE_LOOPING)
                         copyFrameToBuffer(_vm->getBackBuf(), (_vm->_screenWidth - getWidth()) / 2, (_vm->_screenHeight - getHeight()) / 2, _vm->_screenWidth);
-                }
         } else if (_vm->_interactiveVideo == TYPE_OMNITV) {
-                closeFile();
+                close();
                 _vm->_interactiveVideo = 0;
                 _vm->_variableArray[254] = 6747;
         }
 }
 
 void MoviePlayerDXA::handleNextFrame() {
-        decodeNextFrame();
         if (processFrame())
                 _vm->_system->updateScreen();
 
         MoviePlayer::handleNextFrame();
 }
 
-void MoviePlayerDXA::setPalette(byte *pal) {
-        byte palette[1024];
-        byte *p = palette;
-
-        for (int i = 0; i < 256; i++) {
-                *p++ = *pal++;
-                *p++ = *pal++;
-                *p++ = *pal++;
-                *p++ = 0;
-        }
-
-        _vm->_system->setPalette(palette, 0, 256);
-}
-
 bool MoviePlayerDXA::processFrame() {
         Graphics::Surface *screen = _vm->_system->lockScreen();
         copyFrameToBuffer((byte *)screen->pixels, (_vm->_screenWidth - getWidth()) / 2, (_vm->_screenHeight - getHeight()) / 2, _vm->_screenWidth);
@@ -381 +381 @@
                         // sync case for the subsequent frames.
                         _ticks = _vm->_system->getMillis();
                 } else {
-                        _ticks += getFrameWaitTime();
+                        _ticks += getTimeToNextFrame();
                         while (_vm->_system->getMillis() < _ticks)
                                 _vm->_system->delayMillis(10);
                 }
@@ -407 +407 @@
 }
 
 bool MoviePlayerSMK::load() {
-        char videoName[20];
+        Common::String videoName = Common::String::printf("%s.smk", baseName);
 
-        sprintf(videoName, "%s.smk", baseName);
         if (!loadFile(videoName))
-                error("Failed to load video file %s", videoName);
+                error("Failed to load video file %s", videoName.c_str());
 
-        debug(0, "Playing video %s", videoName);
+        debug(0, "Playing video %s", videoName.c_str());
 
         CursorMan.showMouse(false);
 
+        _firstFrameOffset = _fileStream->pos();
+
         return true;
 }
 
+void MoviePlayerSMK::copyFrameToBuffer(byte *dst, uint x, uint y, uint pitch) {
+        uint h = getHeight();
+        uint w = getWidth();
+
+        Graphics::Surface *surface = decodeNextFrame();
+        byte *src = (byte *)surface->pixels;
+        dst += y * pitch + x;
+
+        do {
+                memcpy(dst, src, w);
+                dst += pitch;
+                src += w;
+        } while (--h);
+
+        if (hasDirtyPalette())
+                setSystemPalette();
+}
+
 void MoviePlayerSMK::playVideo() {
-        while (getCurFrame() < getFrameCount() && !_skipMovie && !_vm->shouldQuit())
+        while (!endOfVideo() && !_skipMovie && !_vm->shouldQuit())
                 handleNextFrame();
 }
 
 void MoviePlayerSMK::stopVideo() {
-        closeFile();
+        close();
 }
 
 void MoviePlayerSMK::startSound() {
 }
 
 void MoviePlayerSMK::handleNextFrame() {
-        decodeNextFrame();
         processFrame();
 
         MoviePlayer::handleNextFrame();
 }
 
 void MoviePlayerSMK::nextFrame() {
-        if (_vm->_interactiveVideo == TYPE_LOOPING && getCurFrame() == getFrameCount()) {
-                _fileStream->seek(_videoInfo.firstframeOffset);
-                _videoInfo.currentFrame = 0;
+        if (_vm->_interactiveVideo == TYPE_LOOPING && endOfVideo()) {
+                _fileStream->seek(_firstFrameOffset);
+                _curFrame = -1;
         }
 
-        if (getCurFrame() < getFrameCount()) {
-                decodeNextFrame();
+        if (!endOfVideo()) {
                 if (_vm->_interactiveVideo == TYPE_OMNITV) {
                         copyFrameToBuffer(_vm->getBackBuf(), 465, 222, _vm->_screenWidth);
                 } else if (_vm->_interactiveVideo == TYPE_LOOPING) {
                         copyFrameToBuffer(_vm->getBackBuf(), (_vm->_screenWidth - getWidth()) / 2, (_vm->_screenHeight - getHeight()) / 2, _vm->_screenWidth);
                 }
         } else if (_vm->_interactiveVideo == TYPE_OMNITV) {
-                closeFile();
+                close();
                 _vm->_interactiveVideo = 0;
                 _vm->_variableArray[254] = 6747;
         }
 }
 
-void MoviePlayerSMK::setPalette(byte *pal) {
-        byte palette[1024];
-        byte *p = palette;
-
-        for (int i = 0; i < 256; i++) {
-                *p++ = *pal++;
-                *p++ = *pal++;
-                *p++ = *pal++;
-                *p++ = 0;
-        }
-
-        _vm->_system->setPalette(palette, 0, 256);
-}
-
 bool MoviePlayerSMK::processFrame() {
         Graphics::Surface *screen = _vm->_system->lockScreen();
         copyFrameToBuffer((byte *)screen->pixels, (_vm->_screenWidth - getWidth()) / 2, (_vm->_screenHeight - getHeight()) / 2, _vm->_screenWidth);
         _vm->_system->unlockScreen();
 
-        uint32 waitTime = getFrameWaitTime();
+        uint32 waitTime = getTimeToNextFrame();
 
-        if (!waitTime) {
-                warning("dropped frame %i", getCurFrame());
-                return false;
-        }
-
         _vm->_system->updateScreen();
 
         // Wait before showing the next frame

graphics/module.mk

@@ -26 +26 @@
         video/flic_decoder.o \
         video/mpeg_player.o \
         video/smk_decoder.o \
-        video/video_player.o \
+        video/video_decoder.o \
         video/codecs/msrle.o \
         video/codecs/msvideo1.o \
         video/coktelvideo/indeo3.o \

graphics/video/video_decoder.h

@@ -30 +30 @@
 #include "common/list.h"
 #include "common/stream.h"
 
+#include "graphics/surface.h"
+#include "graphics/pixelformat.h"
+
 namespace Common {
         class SeekableReadStream;
 }
@@ -42 +45 @@
 class VideoDecoder {
 public:
         VideoDecoder();
-        virtual ~VideoDecoder();
+        virtual ~VideoDecoder() {}
 
         /**
          * Returns the width of the video
          * @return the width of the video
          */
-        virtual int getWidth();
+        virtual uint16 getWidth() const = 0;
 
         /**
          * Returns the height of the video
          * @return the height of the video
          */
-        virtual int getHeight();
+        virtual uint16 getHeight() const = 0;
 
         /**
          * Returns the current frame number of the video
-         * @return the current frame number of the video
+         * @return the last frame decoded by the video
          */
-        virtual int32 getCurFrame();
+        virtual int32 getCurFrame() const { return _curFrame; }
 
         /**
          * Returns the amount of frames in the video
          * @return the amount of frames in the video
          */
-        virtual int32 getFrameCount();
+        virtual uint32 getFrameCount() const = 0;
 
         /**
-         * Returns the frame rate of the video
-         * @return the frame rate of the video
+         * Returns the time (in ms) that the video has been running
          */
-        virtual int32 getFrameRate();
+        virtual uint32 getElapsedTime() const;
 
         /**
-         * Returns the time to wait for each frame in 1/100 ms (to avoid rounding errors)
-         * @return the time to wait for each frame in 1/100 ms (to avoid rounding errors)
+         * Returns whether a frame should be decoded or not
+         * @return whether a frame should be decoded or not
          */
-        virtual int32 getFrameDelay();
+        virtual bool needsUpdate() const;
 
         /**
-         * Returns the current A/V lag in 1/100 ms (to avoid rounding errors)
-         * If > 0, audio lags behind
-         * If < 0, video lags behind
-         * @return the current A/V lag in 1/100 ms (to avoid rounding errors)
+         * Load a video file
+         * @param filename      the filename to load
          */
-        virtual int32 getAudioLag();
+        virtual bool loadFile(const Common::String &filename);
 
         /**
-         * Returns the time to wait until the next frame in ms, minding any lag
-         * @return the time to wait until the next frame in ms
-         */
-        virtual uint32 getFrameWaitTime();
-
-        /**
          * Load a video file
-         * @param filename      the filename to load
+         * @param stream  the stream to load
          */
-        virtual bool loadFile(const char *filename) = 0;
+        virtual bool load(Common::SeekableReadStream &stream) = 0;
 
         /**
          * Close a video file
          */
-        virtual void closeFile() = 0;
+        virtual void close() = 0;
 
         /**
          * Returns if a video file is loaded or not
          */
-        bool isVideoLoaded() { return (_fileStream != NULL); }
+        virtual bool isVideoLoaded() const = 0;
 
         /**
-         * Set RGB palette, based on current frame
-         * @param pal           the RGB palette data
+         * Decode the next frame and return the frame's surface
+         * @note the return surface should *not* be freed
+         * @note this may return 0, in which case the last frame should be kept on screen
          */
-        virtual void setPalette(byte *pal);
+        virtual Surface *decodeNextFrame() = 0;
 
         /**
-         * Gets the value of the pixel at the specified x and y coordinates
-         * Note: This method assumes that the video's pitch equals its width, and that
-         * the video has an 8bpp palette
-         * @param x     the x coordinate of the pixel
-         * @param y     the y coordinate of the pixel
+         * Get the pixel format of the video
          */
-        byte getPixel(int x, int y) {
-                return *(_videoFrameBuffer + y * _videoInfo.width + x * 1);
-        }
+        virtual PixelFormat getPixelFormat() const = 0;
 
         /**
-         * Gets the value of the pixel at the specified offset
-         * @param offset        the offset of the pixel in the video buffer
+         * Get the palette for the video in RGB format (if 8bpp or less)
          */
-        byte getPixel(int offset) { return getPixel(offset, 0); }
+        virtual byte *getPalette() { return 0; }
 
         /**
-         * Return the black palette color for the current frame
+         * Returns if the palette is dirty or not
          */
-        byte getBlack() { return _curFrameBlack; }
+        virtual bool hasDirtyPalette() const { return false; }
 
         /**
-         * Return the white palette color for the current frame
+         * Add the time the video has been paused to maintain sync
          */
-        byte getWhite() { return _curFrameWhite; }
+        virtual void addPauseTime(uint32 ms) { _startTime += ms; }
 
         /**
-         * Copy current frame into the specified position of the destination
-         * buffer.
-         * @param dst           the buffer
-         * @param x             the x position of the buffer
-         * @param y             the y position of the buffer
-         * @param pitch         the pitch of buffer
+         * Returns if the video is finished or not
          */
-        void copyFrameToBuffer(byte *dst, uint x, uint y, uint pitch);
+        virtual bool endOfVideo() const;
 
         /**
-         * Decode the next frame to _videoFrameBuffer
+         * Set the current palette to the system palette
          */
-        virtual bool decodeNextFrame() = 0;
+        void setSystemPalette();
 
+        /**
+         * Return the time until the next frame (in ms)
+         */
+        virtual uint32 getTimeToNextFrame() const = 0;
+
 protected:
-        struct {
-                uint32 width;
-                uint32 height;
-                uint32 frameCount;
-                int32 frameRate;
-                int32 frameDelay;               // 1/100 ms (to avoid rounding errors)
-                uint32 firstframeOffset;
-                uint32 currentFrame;
-                uint32 startTime;
-        } _videoInfo;
+        /**
+         * Resets _curFrame and _startTime. Should be called from every close() function.
+         */
+        void reset();
 
-        byte _curFrameBlack, _curFrameWhite;
-
-        Common::SeekableReadStream *_fileStream;
-        byte *_videoFrameBuffer;
+        int32 _curFrame;
+        uint32 _startTime;
 };
 
-class VideoPlayer {
+/**
+ * A VideoDecoder wrapper that implements getTimeToNextFrame() based on getFrameRate().
+ */
+class FixedRateVideoDecoder : public VideoDecoder {
 public:
-        VideoPlayer(VideoDecoder* decoder) : _skipVideo(false), _decoder(decoder)
-                { }
-        virtual ~VideoPlayer() { }
-        /**
-         * A default implementation of a video player
-         * Plays a non-interactive full screen video till it's stopped by a
-         * specific event
-         * @param filename              the name of the file to play
-         * @param stopEvents    a list of events that can stop the video
-         *
-         * Returns true if the video was played to the end, false if skipped
-         */
-        bool playVideo(Common::List<Common::Event> &stopEvents);
+        FixedRateVideoDecoder() {}
+        virtual ~FixedRateVideoDecoder() {}
 
-        /**
-         * Provides the same functionality as the video player, and it adds the
-         * event of skipping the video with the escape key by default
-         */
-        bool playVideo();
+        uint32 getTimeToNextFrame() const;
 
 protected:
         /**
-         * Perform postprocessing once the frame data is copied to the screen,
-         * right before the frame is drawn. Called by playVideo()
+         * Return the frame rate in frames per second
+         * This returns a double because videos can have rates that are not integers and
+         * there are some videos with frame rates < 1.
          */
-        virtual void performPostProcessing(byte *screen);
+        virtual double getFrameRate() const = 0;
 
-        bool _skipVideo;
-        VideoDecoder* _decoder;
-
-        void processVideoEvents(Common::List<Common::Event> &stopEvents);
+private:
+        uint32 getFrameBeginTime(uint32 frame) const;
 };
 
 } // End of namespace Graphics

graphics/video/dxa_decoder.cpp

@@ -39 +39 @@
 
 DXADecoder::DXADecoder() {
         _fileStream = 0;
+        _surface = 0;
+        _dirtyPalette = false;
 
         _frameBuffer1 = 0;
         _frameBuffer2 = 0;
         _scaledBuffer = 0;
-        _videoFrameBuffer = 0;
 
         _inBuffer = 0;
         _inBufferSize = 0;
@@ -51 +52 @@
         _decompBuffer = 0;
         _decompBufferSize = 0;
 
-        _videoInfo.width = 0;
-        _videoInfo.height = 0;
+        _width = 0;
+        _height = 0;
 
         _frameSize = 0;
-        _videoInfo.frameCount = 0;
-        _videoInfo.currentFrame = 0;
-        _videoInfo.frameRate = 0;
-        _videoInfo.frameDelay = 0;
+        _frameCount = 0;
+        _frameRate = 0;
 
         _scaleMode = S_NONE;
 }
 
 DXADecoder::~DXADecoder() {
-        closeFile();
+        close();
 }
 
-bool DXADecoder::loadFile(const char *fileName) {
-        uint32 tag;
-        int32 frameRate;
+bool DXADecoder::load(Common::SeekableReadStream &stream) {
+        close();
 
-        closeFile();
+        _fileStream = &stream;
 
-        _fileStream = SearchMan.createReadStreamForMember(fileName);
-        if (!_fileStream)
-                return false;
-
-        tag = _fileStream->readUint32BE();
+        uint32 tag = _fileStream->readUint32BE();
         assert(tag == MKID_BE('DEXA'));
 
         uint8 flags = _fileStream->readByte();
-        _videoInfo.frameCount = _fileStream->readUint16BE();
-        frameRate = _fileStream->readSint32BE();
+        _frameCount = _fileStream->readUint16BE();
+        int32 frameRate = _fileStream->readSint32BE();
 
-        if (frameRate > 0) {
-                _videoInfo.frameRate = 1000 / frameRate;
-                _videoInfo.frameDelay = frameRate * 100;
-        } else if (frameRate < 0) {
-                _videoInfo.frameRate = 100000 / (-frameRate);
-                _videoInfo.frameDelay = -frameRate;
-        } else {
-                _videoInfo.frameRate = 10;
-                _videoInfo.frameDelay = 10000;
-        }
+        if (frameRate > 0)
+                _frameRate = 1000 / frameRate;
+        else if (frameRate < 0)
+                _frameRate = 100000 / (-frameRate);
+        else
+                _frameRate = 10;
 
-        _videoInfo.width = _fileStream->readUint16BE();
-        _videoInfo.height = _fileStream->readUint16BE();
+        _width = _fileStream->readUint16BE();
+        _height = _fileStream->readUint16BE();
 
         if (flags & 0x80) {
                 _scaleMode = S_INTERLACED;
-                _curHeight = _videoInfo.height / 2;
+                _curHeight = _height / 2;
         } else if (flags & 0x40) {
                 _scaleMode = S_DOUBLE;
-                _curHeight = _videoInfo.height / 2;
+                _curHeight = _height / 2;
         } else {
                 _scaleMode = S_NONE;
-                _curHeight = _videoInfo.height;
+                _curHeight = _height;
         }
 
-        debug(2, "flags 0x0%x framesCount %d width %d height %d rate %d ticks %d", flags, getFrameCount(), getWidth(), getHeight(), getFrameRate(), getFrameDelay());
+        _surface = new Graphics::Surface();
+        _surface->bytesPerPixel = 1;
 
-        _frameSize = _videoInfo.width * _videoInfo.height;
+        debug(2, "flags 0x0%x framesCount %d width %d height %d rate %d", flags, getFrameCount(), getWidth(), getHeight(), (uint32)getFrameRate());
+
+        _frameSize = _width * _height;
         _decompBufferSize = _frameSize;
         _frameBuffer1 = (uint8 *)malloc(_frameSize);
         memset(_frameBuffer1, 0, _frameSize);
@@ -135 +128 @@
 
                 do {
                         tag = _fileStream->readUint32BE();
-                        if (tag != 0) {
+
+                        if (tag != 0)
                                 size = _fileStream->readUint32BE();
-                        }
+
                         switch (tag) {
                                 case 0: // No more tags
                                         break;
@@ -159 +153 @@
         // Read the sound header
         _soundTag = _fileStream->readUint32BE();
 
-        _videoInfo.currentFrame = 0;
-
-        _videoInfo.firstframeOffset = _fileStream->pos();
-
         return true;
 }
 
-void DXADecoder::closeFile() {
+void DXADecoder::close() {
         if (!_fileStream)
                 return;
 
         delete _fileStream;
         _fileStream = 0;
 
+        delete _surface;
+        _surface = 0;
+
         free(_frameBuffer1);
         free(_frameBuffer2);
         free(_scaledBuffer);
@@ -181 +174 @@
 
         _inBuffer = 0;
         _decompBuffer = 0;
+
+        reset();
 }
 
 void DXADecoder::decodeZlib(byte *data, int size, int totalSize) {
@@ -208 +203 @@
 
         memcpy(_frameBuffer2, _frameBuffer1, _frameSize);
 
-        for (uint32 by = 0; by < _videoInfo.height; by += BLOCKH) {
-                for (uint32 bx = 0; bx < _videoInfo.width; bx += BLOCKW) {
+        for (uint32 by = 0; by < _height; by += BLOCKH) {
+                for (uint32 bx = 0; bx < _width; bx += BLOCKW) {
                         byte type = *dat++;
-                        byte *b2 = _frameBuffer1 + bx + by * _videoInfo.width;
+                        byte *b2 = _frameBuffer1 + bx + by * _width;
 
                         switch (type) {
                         case 0:
@@ -243 +238 @@
                                                 }
                                                 diffMap <<= 1;
                                         }
-                                        b2 += _videoInfo.width;
+                                        b2 += _width;
                                 }
                                 break;
                         }
@@ -254 +249 @@
                                         for (int xc = 0; xc < BLOCKW; xc++) {
                                                 b2[xc] = color;
                                         }
-                                        b2 += _videoInfo.width;
+                                        b2 += _width;
                                 }
                                 break;
                         }
@@ -263 +258 @@
                                         for (int xc = 0; xc < BLOCKW; xc++) {
                                                 b2[xc] = *dat++;
                                         }
-                                        b2 += _videoInfo.width;
+                                        b2 += _width;
                                 }
                                 break;
                         }
@@ -275 +270 @@
                                 int my = mbyte & 0x07;
                                 if (mbyte & 0x08)
                                         my = -my;
-                                byte *b1 = _frameBuffer2 + (bx+mx) + (by+my) * _videoInfo.width;
+                                byte *b1 = _frameBuffer2 + (bx+mx) + (by+my) * _width;
                                 for (int yc = 0; yc < BLOCKH; yc++) {
                                         memcpy(b2, b1, BLOCKW);
-                                        b1 += _videoInfo.width;
-                                        b2 += _videoInfo.width;
+                                        b1 += _width;
+                                        b2 += _width;
                                 }
                                 break;
                         }
@@ -309 +304 @@
 
         memcpy(_frameBuffer2, _frameBuffer1, _frameSize);
 
-        int codeSize = _videoInfo.width * _curHeight / 16;
+        int codeSize = _width * _curHeight / 16;
         int dataSize, motSize, maskSize;
 
         dataSize = READ_BE_UINT32(&_decompBuffer[0]);
@@ -322 +317 @@
         maskBuf = &motBuf[motSize];
 
         for (uint32 by = 0; by < _curHeight; by += BLOCKH) {
-                for (uint32 bx = 0; bx < _videoInfo.width; bx += BLOCKW) {
+                for (uint32 bx = 0; bx < _width; bx += BLOCKW) {
                         uint8 type = *codeBuf++;
-                        uint8 *b2 = (uint8*)_frameBuffer1 + bx + by * _videoInfo.width;
+                        uint8 *b2 = (uint8*)_frameBuffer1 + bx + by * _width;
 
                         switch (type) {
                         case 0:
@@ -341 +336 @@
                                                 }
                                                 diffMap <<= 1;
                                         }
-                                        b2 += _videoInfo.width;
+                                        b2 += _width;
                                 }
                                 break;
                         }
@@ -352 +347 @@
                                         for (int xc = 0; xc < BLOCKW; xc++) {
                                                 b2[xc] = color;
                                         }
-                                        b2 += _videoInfo.width;
+                                        b2 += _width;
                                 }
                                 break;
                         }
@@ -361 +356 @@
                                         for (int xc = 0; xc < BLOCKW; xc++) {
                                                 b2[xc] = *dataBuf++;
                                         }
-                                        b2 += _videoInfo.width;
+                                        b2 += _width;
                                 }
                                 break;
                         }
@@ -375 +370 @@
                                 if (mbyte & 0x08)
                                         my = -my;
 
-                                uint8 *b1 = (uint8*)_frameBuffer2 + (bx+mx) + (by+my) * _videoInfo.width;
+                                uint8 *b1 = (uint8*)_frameBuffer2 + (bx+mx) + (by+my) * _width;
                                 for (int yc = 0; yc < BLOCKH; yc++) {
                                         memcpy(b2, b1, BLOCKW);
-                                        b1 += _videoInfo.width;
-                                        b2 += _videoInfo.width;
+                                        b1 += _width;
+                                        b2 += _width;
                                 }
                                 break;
                         }
@@ -391 +386 @@
 
                                 for (int subBlock = 0; subBlock < 4; subBlock++) {
                                         int sx = bx + subX[subBlock], sy = by + subY[subBlock];
-                                        b2 = (uint8*)_frameBuffer1 + sx + sy * _videoInfo.width;
+                                        b2 = (uint8*)_frameBuffer1 + sx + sy * _width;
                                         switch (subMask & 0xC0) {
                                         // 00: skip
                                         case 0x00:
@@ -403 +398 @@
                                                         for (int xc = 0; xc < BLOCKW / 2; xc++) {
                                                                 b2[xc] = subColor;
                                                         }
-                                                        b2 += _videoInfo.width;
+                                                        b2 += _width;
                                                 }
                                                 break;
                                         }
@@ -419 +414 @@
                                                 if (mbyte & 0x08)
                                                         my = -my;
 
-                                                uint8 *b1 = (uint8*)_frameBuffer2 + (sx+mx) + (sy+my) * _videoInfo.width;
+                                                uint8 *b1 = (uint8*)_frameBuffer2 + (sx+mx) + (sy+my) * _width;
                                                 for (int yc = 0; yc < BLOCKH / 2; yc++) {
                                                         memcpy(b2, b1, BLOCKW / 2);
-                                                        b1 += _videoInfo.width;
-                                                        b2 += _videoInfo.width;
+                                                        b1 += _width;
+                                                        b2 += _width;
                                                 }
                                                 break;
                                         }
@@ -433 +428 @@
                                                         for (int xc = 0; xc < BLOCKW / 2; xc++) {
                                                                 b2[xc] = *dataBuf++;
                                                         }
-                                                        b2 += _videoInfo.width;
+                                                        b2 += _width;
                                                 }
                                                 break;
                                         }
@@ -458 +453 @@
                                                         b2[xc] = pixels[code & 1];
                                                         code >>= 1;
                                                 }
-                                                b2 += _videoInfo.width;
+                                                b2 += _width;
                                         }
                                 } else {
                                         uint32 code = READ_BE_UINT32(maskBuf);
@@ -468 +463 @@
                                                         b2[xc] = pixels[code & 3];
                                                         code >>= 2;
                                                 }
-                                                b2 += _videoInfo.width;
+                                                b2 += _width;
                                         }
                                 }
                                 break;
@@ -481 +476 @@
 #endif
 }
 
-bool DXADecoder::decodeNextFrame() {
-        uint32 tag;
-
-        if (_videoInfo.currentFrame == 0)
-                _videoInfo.startTime = g_system->getMillis();
-
-        tag = _fileStream->readUint32BE();
+Surface *DXADecoder::decodeNextFrame() {
+        uint32 tag = _fileStream->readUint32BE();
         if (tag == MKID_BE('CMAP')) {
-                byte rgb[768];
-
-                _fileStream->read(rgb, ARRAYSIZE(rgb));
-                setPalette(rgb);
+                _fileStream->read(_palette, 256 * 3);
+                _dirtyPalette = true;
         }
 
         tag = _fileStream->readUint32BE();
@@ -529 +517 @@
 
                 if (type == 3) {
                         for (uint32 j = 0; j < _curHeight; ++j) {
-                                for (uint32 i = 0; i < _videoInfo.width; ++i) {
-                                        const int offs = j * _videoInfo.width + i;
+                                for (uint32 i = 0; i < _width; ++i) {
+                                        const int offs = j * _width + i;
                                         _frameBuffer1[offs] ^= _frameBuffer2[offs];
                                 }
                         }
@@ -540 +528 @@
         switch (_scaleMode) {
         case S_INTERLACED:
                 for (int cy = 0; cy < _curHeight; cy++) {
-                        memcpy(&_scaledBuffer[2 * cy * _videoInfo.width], &_frameBuffer1[cy * _videoInfo.width], _videoInfo.width);
-                        memset(&_scaledBuffer[((2 * cy) + 1) * _videoInfo.width], 0, _videoInfo.width);
+                        memcpy(&_scaledBuffer[2 * cy * _width], &_frameBuffer1[cy * _width], _width);
+                        memset(&_scaledBuffer[((2 * cy) + 1) * _width], 0, _width);
                 }
-                _videoFrameBuffer = _scaledBuffer;
+                _surface->pixels = _scaledBuffer;
                 break;
         case S_DOUBLE:
                 for (int cy = 0; cy < _curHeight; cy++) {
-                        memcpy(&_scaledBuffer[2 * cy * _videoInfo.width], &_frameBuffer1[cy * _videoInfo.width], _videoInfo.width);
-                        memcpy(&_scaledBuffer[((2 * cy) + 1) * _videoInfo.width], &_frameBuffer1[cy * _videoInfo.width], _videoInfo.width);
+                        memcpy(&_scaledBuffer[2 * cy * _width], &_frameBuffer1[cy * _width], _width);
+                        memcpy(&_scaledBuffer[((2 * cy) + 1) * _width], &_frameBuffer1[cy * _width], _width);
                 }
-                _videoFrameBuffer = _scaledBuffer;
+                _surface->pixels = _scaledBuffer;
                 break;
         case S_NONE:
-                _videoFrameBuffer = _frameBuffer1;
+                _surface->pixels = _frameBuffer1;
                 break;
         }
 
-        return ++_videoInfo.currentFrame < _videoInfo.frameCount;
+        // Copy in the relevant info to the Surface
+        _surface->w = getWidth();
+        _surface->h = getHeight();
+        _surface->pitch = getWidth();
+
+        _curFrame++;
+
+        if (_curFrame == 0)
+                _startTime = g_system->getMillis();
+
+        return _surface;
 }
 
 } // End of namespace Graphics

graphics/video/flic_decoder.cpp

@@ -34 +34 @@
 FlicDecoder::FlicDecoder() {
         _paletteChanged = false;
         _fileStream = 0;
-        _videoFrameBuffer = 0;
-        memset(&_videoInfo, 0, sizeof(_videoInfo));
+        _surface = 0;
 }
 
 FlicDecoder::~FlicDecoder() {
-        closeFile();
+        close();
 }
 
-bool FlicDecoder::loadFile(const char *fileName) {
-        closeFile();
+bool FlicDecoder::load(Common::SeekableReadStream &stream) {
+        close();
 
-        _fileStream = SearchMan.createReadStreamForMember(fileName);
-        if (!_fileStream)
-                return false;
+        _fileStream = &stream;
 
         /* uint32 frameSize = */ _fileStream->readUint32LE();
         uint16 frameType = _fileStream->readUint16LE();
@@ -60 +57 @@
                 return false;
         }
 
-        _videoInfo.frameCount = _fileStream->readUint16LE();
-        _videoInfo.width = _fileStream->readUint16LE();
-        _videoInfo.height = _fileStream->readUint16LE();
+        
+        _frameCount = _fileStream->readUint16LE();
+        uint16 width = _fileStream->readUint16LE();
+        uint16 height = _fileStream->readUint16LE();
         uint16 colorDepth = _fileStream->readUint16LE();
         if (colorDepth != 8) {
                 warning("FlicDecoder::FlicDecoder(): attempted to load an FLC with a palette of color depth %d. Only 8-bit color palettes are supported", frameType);
@@ -70 +68 @@
                 _fileStream = 0;
                 return false;
         }
+
         _fileStream->readUint16LE();    // flags
         // Note: The normal delay is a 32-bit integer (dword), whereas the overriden delay is a 16-bit integer (word)
         // frameDelay is the FLIC "speed", in milliseconds. Our frameDelay is calculated in 1/100 ms, so we convert it here
-        _videoInfo.frameDelay = 100 * _fileStream->readUint32LE();
-        _videoInfo.frameRate = 100 * 1000 / _videoInfo.frameDelay;
+        uint32 frameDelay = 100 * _fileStream->readUint32LE();
+        _frameRate = 100 * 1000 / frameDelay;
 
         _fileStream->seek(80);
         _offsetFrame1 = _fileStream->readUint32LE();
         _offsetFrame2 = _fileStream->readUint32LE();
 
-        _videoFrameBuffer = new byte[_videoInfo.width * _videoInfo.height];
+        _surface = new Graphics::Surface();
+        _surface->create(width, height, 1);
         _palette = (byte *)malloc(3 * 256);
         memset(_palette, 0, 3 * 256);
         _paletteChanged = false;
 
         // Seek to the first frame
-        _videoInfo.currentFrame = 0;
         _fileStream->seek(_offsetFrame1);
         return true;
 }
 
-void FlicDecoder::closeFile() {
+void FlicDecoder::close() {
         if (!_fileStream)
                 return;
 
         delete _fileStream;
         _fileStream = 0;
 
-        delete[] _videoFrameBuffer;
-        _videoFrameBuffer = 0;
+        _surface->free();
+        delete _surface;
+        _surface = 0;
 
         free(_palette);
+        _dirtyRects.clear();
 
-        _dirtyRects.clear();
+        reset();
 }
 
 void FlicDecoder::decodeByteRun(uint8 *data) {
-        byte *ptr = (uint8 *)_videoFrameBuffer;
-        while ((uint32)(ptr - _videoFrameBuffer) < (_videoInfo.width * _videoInfo.height)) {
+        byte *ptr = (byte *)_surface->pixels;
+        while ((int32)(ptr - (byte *)_surface->pixels) < (getWidth() * getHeight())) {
                 int chunks = *data++;
                 while (chunks--) {
                         int count = (int8)*data++;
@@ -125 +126 @@
 
         // Redraw
         _dirtyRects.clear();
-        _dirtyRects.push_back(Common::Rect(0, 0, _videoInfo.width, _videoInfo.height));
+        _dirtyRects.push_back(Common::Rect(0, 0, getWidth(), getHeight()));
 }
 
 #define OP_PACKETCOUNT   0
@@ -152 +153 @@
                         case OP_UNDEFINED:
                                 break;
                         case OP_LASTPIXEL:
-                                _videoFrameBuffer[currentLine * _videoInfo.width + _videoInfo.width - 1] = (opcode & 0xFF);
-                                _dirtyRects.push_back(Common::Rect(_videoInfo.width - 1, currentLine, _videoInfo.width, currentLine + 1));
+                                *((byte *)_surface->pixels + currentLine * getWidth() + getWidth() - 1) = (opcode & 0xFF);
+                                _dirtyRects.push_back(Common::Rect(getWidth() - 1, currentLine, getWidth(), currentLine + 1));
                                 break;
                         case OP_LINESKIPCOUNT:
                                 currentLine += -(int16)opcode;
@@ -168 +169 @@
                         column += *data++;
                         int rleCount = (int8)*data++;
                         if (rleCount > 0) {
-                                memcpy(_videoFrameBuffer + (currentLine * _videoInfo.width) + column, data, rleCount * 2);
+                                memcpy((byte *)_surface->pixels + (currentLine * getWidth()) + column, data, rleCount * 2);
                                 data += rleCount * 2;
                                 _dirtyRects.push_back(Common::Rect(column, currentLine, column + rleCount * 2, currentLine + 1));
                         } else if (rleCount < 0) {
                                 rleCount = -rleCount;
                                 uint16 dataWord = READ_UINT16(data); data += 2;
                                 for (int i = 0; i < rleCount; ++i) {
-                                        WRITE_UINT16(_videoFrameBuffer + currentLine * _videoInfo.width + column + i * 2, dataWord);
+                                        WRITE_UINT16((byte *)_surface->pixels + currentLine * getWidth() + column + i * 2, dataWord);
                                 }
                                 _dirtyRects.push_back(Common::Rect(column, currentLine, column + rleCount * 2, currentLine + 1));
                         } else { // End of cutscene ?
@@ -194 +195 @@
 #define PSTAMP     18
 #define FRAME_TYPE 0xF1FA
 
-bool FlicDecoder::decodeNextFrame() {
-        if (_videoInfo.currentFrame == 0)
-                _videoInfo.startTime = g_system->getMillis();
-
+Surface *FlicDecoder::decodeNextFrame() {
         // Read chunk
         uint32 frameSize = _fileStream->readUint32LE();
         uint16 frameType = _fileStream->readUint16LE();
         uint16 chunkCount = 0;
 
         switch (frameType) {
-        case FRAME_TYPE: {
-                chunkCount = _fileStream->readUint16LE();
-                // Note: The overriden delay is a 16-bit integer (word), whereas the normal delay is a 32-bit integer (dword)
-                // frameDelay is the FLIC "speed", in milliseconds. Our frameDelay is calculated in 1/100 ms, so we convert it here
-                uint16 newFrameDelay = _fileStream->readUint16LE();     // "speed", in milliseconds
-                if (newFrameDelay > 0) {
-                        _videoInfo.frameDelay = 100 * newFrameDelay;
-                        _videoInfo.frameRate = 100 * 1000 / _videoInfo.frameDelay;
-                }
-                _fileStream->readUint16LE();    // reserved, always 0
-                uint16 newWidth = _fileStream->readUint16LE();
-                uint16 newHeight = _fileStream->readUint16LE();
-                if (newWidth > 0)
-                        _videoInfo.width = newWidth;
-                if (newHeight > 0)
-                        _videoInfo.height = newHeight;
+        case FRAME_TYPE:
+                {
+                        // FIXME: FLIC should be switched over to a variable frame rate VideoDecoder to handle
+                        // this properly.
 
-                _videoInfo.currentFrame++;
+                        chunkCount = _fileStream->readUint16LE();
+                        // Note: The overriden delay is a 16-bit integer (word), whereas the normal delay is a 32-bit integer (dword)
+                        // frameDelay is the FLIC "speed", in milliseconds. Our frameDelay is calculated in 1/100 ms, so we convert it here
+                        uint16 newFrameDelay = _fileStream->readUint16LE();     // "speed", in milliseconds
+                        if (newFrameDelay > 0)
+                                _frameRate = 1000 / newFrameDelay;
+
+                        _fileStream->readUint16LE();    // reserved, always 0
+                        uint16 newWidth = _fileStream->readUint16LE();
+                        uint16 newHeight = _fileStream->readUint16LE();
+
+                        if ((newWidth != 0) && (newHeight != 0)) {
+                                if (newWidth == 0)
+                                        newWidth = _surface->w;
+                                if (newHeight == 0)
+                                        newHeight = _surface->h;
+
+                                _surface->free();
+                                delete _surface;
+                                _surface = new Graphics::Surface();
+                                _surface->create(newWidth, newHeight, 1);
+                        }
                 }
                 break;
         default:
@@ -239 +246 @@
                         switch (frameType) {
                         case FLI_SETPAL:
                                 unpackPalette(data);
-                                setPalette(_palette);
                                 _paletteChanged = true;
                                 break;
                         case FLI_SS2:
@@ -259 +265 @@
                         delete[] data;
                 }
         }
+        
+        _curFrame++;
 
+        if (_curFrame == 0)
+                _startTime = g_system->getMillis();
+
         // If we just processed the ring frame, set the next frame
-        if (_videoInfo.currentFrame == _videoInfo.frameCount + 1) {
-                _videoInfo.currentFrame = 1;
+        if (_curFrame == (int32)_frameCount) {
+                _curFrame = 0;
                 _fileStream->seek(_offsetFrame2);
         }
 
-        return _videoInfo.currentFrame < _videoInfo.frameCount;
+        return _surface;
 }
 
 void FlicDecoder::reset() {
-        _videoInfo.currentFrame = 0;
-        _fileStream->seek(_offsetFrame1);
+        VideoDecoder::reset();
+        if (_fileStream)
+                _fileStream->seek(_offsetFrame1);
 }
 
 void FlicDecoder::unpackPalette(uint8 *data) {
@@ -303 +315 @@
         for (Common::List<Common::Rect>::const_iterator it = _dirtyRects.begin(); it != _dirtyRects.end(); ++it) {
                 for (int y = (*it).top; y < (*it).bottom; ++y) {
                         const int x = (*it).left;
-                        memcpy(dst + y * pitch + x, _videoFrameBuffer + y * _videoInfo.width + x, (*it).right - x);
+                        memcpy(dst + y * pitch + x, (byte *)_surface->pixels + y * getWidth() + x, (*it).right - x);
                 }
         }
         _dirtyRects.clear();

graphics/video/avi_decoder.cpp

@@ -23 +23 @@
  *
  */
 
-#include "common/archive.h"
 #include "common/endian.h"
 #include "common/file.h"
 #include "common/stream.h"
@@ -47 +46 @@
         _videoCodec = NULL;
         _decodedHeader = false;
         _audStream = NULL;
-        _fileStream = NULL;
+        _stream = NULL;
         _audHandle = new Audio::SoundHandle();
+        _dirtyPalette = false;
+        _stream = NULL;
         memset(_palette, 0, sizeof(_palette));
         memset(&_wvInfo, 0, sizeof(PCMWAVEFORMAT));
         memset(&_bmInfo, 0, sizeof(BITMAPINFOHEADER));
@@ -58 +59 @@
 }
 
 AviDecoder::~AviDecoder() {
-        closeFile();
+        close();
         delete _audHandle;
 }
 
 void AviDecoder::runHandle(uint32 tag) {
-        assert (_fileStream);
-        if (_fileStream->eos())
+        assert (_stream);
+        if (_stream->eos())
                 return;
 
         debug (3, "Decoding tag %s", tag2str(tag));
 
         switch (tag) {
                 case ID_RIFF:
-                        /*_filesize = */_fileStream->readUint32LE();
-                        if (_fileStream->readUint32BE() != ID_AVI)
+                        /*_filesize = */_stream->readUint32LE();
+                        if (_stream->readUint32BE() != ID_AVI)
                                 error("RIFF file is not an AVI video");
                         break;
                 case ID_LIST:
                         handleList();
                         break;
                 case ID_AVIH:
-                        _header.size = _fileStream->readUint32LE();
-                        _header.microSecondsPerFrame = _fileStream->readUint32LE();
-                        _header.maxBytesPerSecond = _fileStream->readUint32LE();
-                        _header.padding = _fileStream->readUint32LE();
-                        _header.flags = _fileStream->readUint32LE();
-                        _header.totalFrames = _fileStream->readUint32LE();
-                        _header.initialFrames = _fileStream->readUint32LE();
-                        _header.streams = _fileStream->readUint32LE();
-                        _header.bufferSize = _fileStream->readUint32LE();
-                        _header.width = _fileStream->readUint32LE();
-                        _header.height = _fileStream->readUint32LE();
+                        _header.size = _stream->readUint32LE();
+                        _header.microSecondsPerFrame = _stream->readUint32LE();
+                        _header.maxBytesPerSecond = _stream->readUint32LE();
+                        _header.padding = _stream->readUint32LE();
+                        _header.flags = _stream->readUint32LE();
+                        _header.totalFrames = _stream->readUint32LE();
+                        _header.initialFrames = _stream->readUint32LE();
+                        _header.streams = _stream->readUint32LE();
+                        _header.bufferSize = _stream->readUint32LE();
+                        _header.width = _stream->readUint32LE();
+                        _header.height = _stream->readUint32LE();
                         //Ignore 16 bytes of reserved data
-                        _fileStream->skip(16);
+                        _stream->skip(16);
                         break;
                 case ID_STRH:
                         handleStreamHeader();
@@ -100 +101 @@
                 case ID_VEDT: // Unknown, safe to ignore
                 case ID_JUNK: // Alignment bytes, should be ignored
                         {
-                        uint32 junkSize = _fileStream->readUint32LE();
-                        _fileStream->skip(junkSize + (junkSize & 1)); // Alignment
+                        uint32 junkSize = _stream->readUint32LE();
+                        _stream->skip(junkSize + (junkSize & 1)); // Alignment
                         } break;
                 case ID_IDX1:
-                        _ixInfo.size = _fileStream->readUint32LE();
+                        _ixInfo.size = _stream->readUint32LE();
                         _ixInfo.indices = new AVIOLDINDEX::Index[_ixInfo.size / 16];
                         debug (0, "%d Indices", (_ixInfo.size / 16));
                         for (uint32 i = 0; i < (_ixInfo.size / 16); i++) {
-                                _ixInfo.indices[i].id = _fileStream->readUint32BE();
-                                _ixInfo.indices[i].flags = _fileStream->readUint32LE();
-                                _ixInfo.indices[i].offset = _fileStream->readUint32LE();
-                                _ixInfo.indices[i].size = _fileStream->readUint32LE();
+                                _ixInfo.indices[i].id = _stream->readUint32BE();
+                                _ixInfo.indices[i].flags = _stream->readUint32LE();
+                                _ixInfo.indices[i].offset = _stream->readUint32LE();
+                                _ixInfo.indices[i].size = _stream->readUint32LE();
                                 debug (0, "Index %d == Tag \'%s\', Offset = %d, Size = %d", i, tag2str(_ixInfo.indices[i].id), _ixInfo.indices[i].offset, _ixInfo.indices[i].size);
                         }
                         break;
@@ -121 +122 @@
 }
 
 void AviDecoder::handleList() {
-        uint32 listSize = _fileStream->readUint32LE() - 4; // Subtract away listType's 4 bytes
-        uint32 listType = _fileStream->readUint32BE();
-        uint32 curPos = _fileStream->pos();
+        uint32 listSize = _stream->readUint32LE() - 4; // Subtract away listType's 4 bytes
+        uint32 listType = _stream->readUint32BE();
+        uint32 curPos = _stream->pos();
 
         debug (0, "Found LIST of type %s", tag2str(listType));
 
-        while ((_fileStream->pos() - curPos) < listSize)
-                runHandle(_fileStream->readUint32BE());
+        while ((_stream->pos() - curPos) < listSize)
+                runHandle(_stream->readUint32BE());
 
         // We now have all the header data
         if (listType == ID_HDRL)
@@ -137 +138 @@
 
 void AviDecoder::handleStreamHeader() {
         AVIStreamHeader sHeader;
-        sHeader.size = _fileStream->readUint32LE();
-        sHeader.streamType = _fileStream->readUint32BE();
+        sHeader.size = _stream->readUint32LE();
+        sHeader.streamType = _stream->readUint32BE();
         if (sHeader.streamType == ID_MIDS || sHeader.streamType == ID_TXTS)
                 error ("Unhandled MIDI/Text stream");
-        sHeader.streamHandler = _fileStream->readUint32BE();
-        sHeader.flags = _fileStream->readUint32LE();
-        sHeader.priority = _fileStream->readUint16LE();
-        sHeader.language = _fileStream->readUint16LE();
-        sHeader.initialFrames = _fileStream->readUint32LE();
-        sHeader.scale = _fileStream->readUint32LE();
-        sHeader.rate = _fileStream->readUint32LE();
-        sHeader.start = _fileStream->readUint32LE();
-        sHeader.length = _fileStream->readUint32LE();
-        sHeader.bufferSize = _fileStream->readUint32LE();
-        sHeader.quality = _fileStream->readUint32LE();
-        sHeader.sampleSize = _fileStream->readUint32LE();
-        sHeader.frame.left = _fileStream->readSint16LE();
-        sHeader.frame.top = _fileStream->readSint16LE();
-        sHeader.frame.right = _fileStream->readSint16LE();
-        sHeader.frame.bottom = _fileStream->readSint16LE();
+        sHeader.streamHandler = _stream->readUint32BE();
+        sHeader.flags = _stream->readUint32LE();
+        sHeader.priority = _stream->readUint16LE();
+        sHeader.language = _stream->readUint16LE();
+        sHeader.initialFrames = _stream->readUint32LE();
+        sHeader.scale = _stream->readUint32LE();
+        sHeader.rate = _stream->readUint32LE();
+        sHeader.start = _stream->readUint32LE();
+        sHeader.length = _stream->readUint32LE();
+        sHeader.bufferSize = _stream->readUint32LE();
+        sHeader.quality = _stream->readUint32LE();
+        sHeader.sampleSize = _stream->readUint32LE();
+        sHeader.frame.left = _stream->readSint16LE();
+        sHeader.frame.top = _stream->readSint16LE();
+        sHeader.frame.right = _stream->readSint16LE();
+        sHeader.frame.bottom = _stream->readSint16LE();
 
-        if (_fileStream->readUint32BE() != ID_STRF)
+        if (_stream->readUint32BE() != ID_STRF)
                 error("Could not find STRF tag");
-        /* uint32 strfSize = */ _fileStream->readUint32LE();
+        /* uint32 strfSize = */ _stream->readUint32LE();
 
         if (sHeader.streamType == ID_VIDS) {
                 _vidsHeader = sHeader;
 
-                _bmInfo.size = _fileStream->readUint32LE();
-                _bmInfo.width = _fileStream->readUint32LE();
+                _bmInfo.size = _stream->readUint32LE();
+                _bmInfo.width = _stream->readUint32LE();
                 assert (_header.width == _bmInfo.width);
-                _bmInfo.height = _fileStream->readUint32LE();
+                _bmInfo.height = _stream->readUint32LE();
                 assert (_header.height == _bmInfo.height);
-                _bmInfo.planes = _fileStream->readUint16LE();
-                _bmInfo.bitCount = _fileStream->readUint16LE();
-                _bmInfo.compression = _fileStream->readUint32BE();
-                _bmInfo.sizeImage = _fileStream->readUint32LE();
-                _bmInfo.xPelsPerMeter = _fileStream->readUint32LE();
-                _bmInfo.yPelsPerMeter = _fileStream->readUint32LE();
-                _bmInfo.clrUsed = _fileStream->readUint32LE();
-                _bmInfo.clrImportant = _fileStream->readUint32LE();
+                _bmInfo.planes = _stream->readUint16LE();
+                _bmInfo.bitCount = _stream->readUint16LE();
+                _bmInfo.compression = _stream->readUint32BE();
+                _bmInfo.sizeImage = _stream->readUint32LE();
+                _bmInfo.xPelsPerMeter = _stream->readUint32LE();
+                _bmInfo.yPelsPerMeter = _stream->readUint32LE();
+                _bmInfo.clrUsed = _stream->readUint32LE();
+                _bmInfo.clrImportant = _stream->readUint32LE();
 
                 if (_bmInfo.bitCount == 8) {
                         if (_bmInfo.clrUsed == 0)
                                 _bmInfo.clrUsed = 256;
 
                         for (uint32 i = 0; i < _bmInfo.clrUsed; i++) {
-                                _palette[i * 3 + 2] = _fileStream->readByte();
-                                _palette[i * 3 + 1] = _fileStream->readByte();
-                                _palette[i * 3] = _fileStream->readByte();
-                                /*_palette[i * 4 + 3] = */_fileStream->readByte();
+                                _palette[i * 3 + 2] = _stream->readByte();
+                                _palette[i * 3 + 1] = _stream->readByte();
+                                _palette[i * 3] = _stream->readByte();
+                                /*_palette[i * 4 + 3] = */_stream->readByte();
                         }
 
-                        setPalette(_palette);
+                        _dirtyPalette = true;
                 }
         } else if (sHeader.streamType == ID_AUDS) {
                 _audsHeader = sHeader;
 
-                _wvInfo.tag = _fileStream->readUint16LE();
-                _wvInfo.channels = _fileStream->readUint16LE();
-                _wvInfo.samplesPerSec = _fileStream->readUint32LE();
-                _wvInfo.avgBytesPerSec = _fileStream->readUint32LE();
-                _wvInfo.blockAlign = _fileStream->readUint16LE();
-                _wvInfo.size = _fileStream->readUint16LE();
+                _wvInfo.tag = _stream->readUint16LE();
+                _wvInfo.channels = _stream->readUint16LE();
+                _wvInfo.samplesPerSec = _stream->readUint32LE();
+                _wvInfo.avgBytesPerSec = _stream->readUint32LE();
+                _wvInfo.blockAlign = _stream->readUint16LE();
+                _wvInfo.size = _stream->readUint16LE();
         }
 }
 
-bool AviDecoder::loadFile(const char *fileName) {
-        closeFile();
+bool AviDecoder::load(Common::SeekableReadStream &stream) {
+        close();
 
-        _fileStream = SearchMan.createReadStreamForMember(fileName);
-        if (!_fileStream)
-                return false;
-
+        _stream = &stream;
         _decodedHeader = false;
-        // Seek to the first frame
-        _videoInfo.currentFrame = 0;
 
-
         // Read chunks until we have decoded the header
         while (!_decodedHeader)
-                runHandle(_fileStream->readUint32BE());
+                runHandle(_stream->readUint32BE());
 
-        _videoFrameBuffer = new byte[_header.width * _header.height];
-        memset(_videoFrameBuffer, 0, _header.width * _header.height);
+        uint32 nextTag = _stream->readUint32BE();
 
-        uint32 nextTag = _fileStream->readUint32BE();
-
         // Throw out any JUNK section
         if (nextTag == ID_JUNK) {
                 runHandle(ID_JUNK);
-                nextTag = _fileStream->readUint32BE();
+                nextTag = _stream->readUint32BE();
         }
 
         // Ignore the 'movi' LIST
         if (nextTag == ID_LIST) {
-                _fileStream->readUint32BE(); // Skip size
-                if (_fileStream->readUint32BE() != ID_MOVI)
+                _stream->readUint32BE(); // Skip size
+                if (_stream->readUint32BE() != ID_MOVI)
                         error ("Expected 'movi' LIST");
         } else
                 error ("Expected 'movi' LIST");
@@ -248 +240 @@
                 _mixer->playInputStream(_soundType, _audHandle, _audStream);
 
         debug (0, "Frames = %d, Dimensions = %d x %d", _header.totalFrames, _header.width, _header.height);
-        debug (0, "Frame Rate = %d", getFrameRate());
+        debug (0, "Frame Rate = %d", _vidsHeader.rate / _vidsHeader.scale);
         if ((_audsHeader.scale != 0) && (_header.flags & AVIF_ISINTERLEAVED))
                 debug (0, "Sound Rate = %d", AUDIO_RATE);
         debug (0, "Video Codec = \'%s\'", tag2str(_vidsHeader.streamHandler));
 
-        _videoInfo.firstframeOffset = _fileStream->pos();
-        _videoInfo.width = _header.width;
-        _videoInfo.height = _header.height;
-        _videoInfo.frameCount = _header.totalFrames;
-        // Our frameDelay is calculated in 1/100 ms, so we convert it here
-        _videoInfo.frameDelay = _header.microSecondsPerFrame / 10;
-
         if (!_videoCodec)
                 return false;
 
         return true;
 }
 
-void AviDecoder::closeFile() {
-        if (!_fileStream)
+void AviDecoder::close() {
+        if (!_stream)
                 return;
 
-        delete _fileStream;
-        _fileStream = 0;
+        delete _stream;
+        _stream = 0;
 
-        delete[] _videoFrameBuffer;
-        _videoFrameBuffer = 0;
-
         // Deinitialize sound
         _mixer->stopHandle(*_audHandle);
         _audStream = 0;
@@ -294 +276 @@
         memset(&_vidsHeader, 0, sizeof(AVIStreamHeader));
         memset(&_audsHeader, 0, sizeof(AVIStreamHeader));
         memset(&_ixInfo, 0, sizeof(AVIOLDINDEX));
+
+        reset();
 }
 
-Surface *AviDecoder::getNextFrame() {
-        uint32 nextTag = _fileStream->readUint32BE();
+uint32 AviDecoder::getElapsedTime() const {
+        if (_audStream)
+                return _mixer->getSoundElapsedTime(*_audHandle);
 
-        if (_fileStream->eos())
+        return VideoDecoder::getElapsedTime();
+}
+
+Surface *AviDecoder::decodeNextFrame() {
+        uint32 nextTag = _stream->readUint32BE();
+
+        if (_stream->eos())
                 return NULL;
 
+        if (_curFrame == -1)
+                _startTime = g_system->getMillis();
+
         if (nextTag == ID_LIST) {
                 // A list of audio/video chunks
-                uint32 listSize = _fileStream->readUint32LE() - 4;
-                int32 startPos = _fileStream->pos();
+                uint32 listSize = _stream->readUint32LE() - 4;
+                int32 startPos = _stream->pos();
 
-                if (_fileStream->readUint32BE() != ID_REC)
+                if (_stream->readUint32BE() != ID_REC)
                         error ("Expected 'rec ' LIST");
 
                 // Decode chunks in the list and see if we get a frame
                 Surface *frame = NULL;
-                while (_fileStream->pos() < startPos + (int32)listSize) {
-                        Surface *temp = getNextFrame();
+                while (_stream->pos() < startPos + (int32)listSize) {
+                        Surface *temp = decodeNextFrame();
                         if (temp)
                                 frame = temp;
                 }
@@ -321 +315 @@
                 return frame;
         } else if (getStreamType(nextTag) == 'wb') {
                 // Audio Chunk
-                uint32 chunkSize = _fileStream->readUint32LE();
+                uint32 chunkSize = _stream->readUint32LE();
                 byte *data = (byte *)malloc(chunkSize);
-                _fileStream->read(data, chunkSize);
+                _stream->read(data, chunkSize);
 
                 byte flags = 0;
                 if (_audsHeader.sampleSize == 2)
@@ -332 +326 @@
                         flags |= Audio::FLAG_UNSIGNED;
 
                 _audStream->queueBuffer(data, chunkSize, DisposeAfterUse::YES, flags);
-                _fileStream->skip(chunkSize & 1); // Alignment
+                _stream->skip(chunkSize & 1); // Alignment
         } else if (getStreamType(nextTag) == 'dc' || getStreamType(nextTag) == 'id' ||
                    getStreamType(nextTag) == 'AM' || getStreamType(nextTag) == '32') {
                 // Compressed Frame
-                _videoInfo.currentFrame++;
-                uint32 chunkSize = _fileStream->readUint32LE();
+                _curFrame++;
+                uint32 chunkSize = _stream->readUint32LE();
 
                 if (chunkSize == 0) // Keep last frame on screen
                         return NULL;
 
-                Common::SeekableReadStream *frameData = _fileStream->readStream(chunkSize);
+                Common::SeekableReadStream *frameData = _stream->readStream(chunkSize);
                 Graphics::Surface *surface = _videoCodec->decodeImage(frameData);
                 delete frameData;
-                _fileStream->skip(chunkSize & 1); // Alignment
+                _stream->skip(chunkSize & 1); // Alignment
                 return surface;
         } else if (getStreamType(nextTag) == 'pc') {
                 // Palette Change
-                _fileStream->readUint32LE(); // Chunk size, not needed here
-                byte firstEntry = _fileStream->readByte();
-                uint16 numEntries = _fileStream->readByte();
-                _fileStream->readUint16LE(); // Reserved
+                _stream->readUint32LE(); // Chunk size, not needed here
+                byte firstEntry = _stream->readByte();
+                uint16 numEntries = _stream->readByte();
+                _stream->readUint16LE(); // Reserved
 
                 // 0 entries means all colors are going to be changed
                 if (numEntries == 0)
                         numEntries = 256;
 
                 for (uint16 i = firstEntry; i < numEntries + firstEntry; i++) {
-                        _palette[i * 3] = _fileStream->readByte();
-                        _palette[i * 3 + 1] = _fileStream->readByte();
-                        _palette[i * 3 + 2] = _fileStream->readByte();
-                        _fileStream->readByte(); // Flags that don't serve us any purpose
+                        _palette[i * 3] = _stream->readByte();
+                        _palette[i * 3 + 1] = _stream->readByte();
+                        _palette[i * 3 + 2] = _stream->readByte();
+                        _stream->readByte(); // Flags that don't serve us any purpose
                 }
 
-                setPalette(_palette);
+                _dirtyPalette = true;
 
                 // No alignment necessary. It's always even.
         } else if (nextTag == ID_JUNK) {
@@ -373 +367 @@
         } else if (nextTag == ID_IDX1) {
                 runHandle(ID_IDX1);
         } else
-                error ("Tag = \'%s\', %d", tag2str(nextTag), _fileStream->pos());
+                error("Tag = \'%s\', %d", tag2str(nextTag), _stream->pos());
 
         return NULL;
 }
 
-bool AviDecoder::decodeNextFrame() {
-        if (_videoInfo.currentFrame == 0)
-                _videoInfo.startTime = g_system->getMillis();
-
-        Surface *surface = NULL;
-
-        uint32 curFrame = _videoInfo.currentFrame;
-
-        while (!surface && _videoInfo.currentFrame < _videoInfo.frameCount && !_fileStream->eos())
-                surface = getNextFrame();
-
-        if (curFrame == _videoInfo.currentFrame) {
-                warning("No video frame found");
-                _videoInfo.currentFrame++;
-        }
-
-        if (surface)
-                memcpy(_videoFrameBuffer, surface->pixels, _header.width * _header.height);
-
-        return _videoInfo.currentFrame < _videoInfo.frameCount;
-}
-
-int32 AviDecoder::getAudioLag() {
-        if (!_fileStream)
-                return 0;
-
-        int32 frameDelay = getFrameDelay();
-        int32 videoTime = _videoInfo.currentFrame * frameDelay;
-        int32 audioTime;
-
-        if (!_audStream) {
-                /* No audio.
-                   Calculate the lag by how much time has gone by since the first frame
-                   and how much time *should* have passed.
-                */
-
-                audioTime = (g_system->getMillis() - _videoInfo.startTime) * 100;
-        } else {
-                const Audio::Timestamp ts = _mixer->getElapsedTime(*_audHandle);
-                audioTime = ts.convertToFramerate(100000).totalNumberOfFrames();
-        }
-
-        return videoTime - audioTime;
-}
-
 Codec *AviDecoder::createCodec() {
         switch (_vidsHeader.streamHandler) {
                 case ID_CRAM:
@@ -438 +387 @@
         return NULL;
 }
 
-Audio::QueuingAudioStream *AviDecoder::createAudioStream() {
+PixelFormat AviDecoder::getPixelFormat() const {
+        assert(_videoCodec);
+        return _videoCodec->getPixelFormat();
+}
 
-        if (_wvInfo.tag == AVI_WAVE_FORMAT_PCM) {
+Audio::QueuingAudioStream *AviDecoder::createAudioStream() {
+        if (_wvInfo.tag == AVI_WAVE_FORMAT_PCM)
                 return Audio::makeQueuingAudioStream(AUDIO_RATE, false);
-        }
 
         if (_wvInfo.tag != 0) // No sound
                 warning ("Unsupported AVI audio format %d", _wvInfo.tag);

graphics/video/dxa_decoder.h

@@ -26 +26 @@
 #ifndef GRAPHICS_VIDEO_DXA_PLAYER_H
 #define GRAPHICS_VIDEO_DXA_PLAYER_H
 
-#include "graphics/video/video_player.h"
+#include "graphics/video/video_decoder.h"
 
 namespace Graphics {
 
@@ -38 +38 @@
  *  - sword1
  *  - sword2
  */
-class DXADecoder : public VideoDecoder {
+class DXADecoder : public FixedRateVideoDecoder {
 public:
         DXADecoder();
         virtual ~DXADecoder();
 
-        /**
-         * Load a DXA encoded video file
-         * @param filename      the filename to load
-         */
-        bool loadFile(const char *fileName);
+        bool load(Common::SeekableReadStream &stream);
+        void close();
+        
+        bool isVideoLoaded() const { return _fileStream != 0; }
+        uint16 getWidth() const { return _width; }
+        uint16 getHeight() const { return _height; }
+        uint32 getFrameCount() const { return _frameCount; }
+        Surface *decodeNextFrame();
+        PixelFormat getPixelFormat() const { return PixelFormat::createFormatCLUT8(); }
+        byte *getPalette() { _dirtyPalette = false; return _palette; }
+        bool hasDirtyPalette() const { return _dirtyPalette; }
 
         /**
-         * Close a DXA encoded video file
-         */
-        void closeFile();
-
-        bool decodeNextFrame();
-
-        /**
          * Get the sound chunk tag of the loaded DXA file
          */
         uint32 getSoundTag() { return _soundTag; }
 
+protected:
+        double getFrameRate() const { return _frameRate; }
+
+        Common::SeekableReadStream *_fileStream;
+
 private:
         void decodeZlib(byte *data, int size, int totalSize);
         void decode12(int size);
@@ -72 +76 @@
                 S_DOUBLE
         };
 
+        Graphics::Surface *_surface;
+        byte _palette[256 * 3];
+        bool _dirtyPalette;
+
         byte *_frameBuffer1;
         byte *_frameBuffer2;
         byte *_scaledBuffer;
@@ -83 +91 @@
         uint32 _frameSize;
         ScaleMode _scaleMode;
         uint32 _soundTag;
+        uint16 _width, _height;
+        uint32 _frameRate;
+        uint32 _frameCount;
 };
 
 } // End of namespace Graphics

graphics/video/flic_decoder.h

@@ -23 +23 @@
  *
  */
 
-#ifndef GRAPHICS_VIDEO_FlicDecoder_H
-#define GRAPHICS_VIDEO_FlicDecoder_H
+#ifndef GRAPHICS_VIDEO_FLIC_DECODER_H
+#define GRAPHICS_VIDEO_FLIC_DECODER_H
 
-#include "graphics/video/video_player.h"
+#include "graphics/video/video_decoder.h"
 #include "common/list.h"
 #include "common/rect.h"
 
@@ -42 +42 @@
  * Video decoder used in engines:
  *  - tucker
  */
-class FlicDecoder : public VideoDecoder {
+class FlicDecoder : public FixedRateVideoDecoder {
 public:
         FlicDecoder();
         virtual ~FlicDecoder();
 
-        /**
-         * Load a FLIC encoded video file
-         * @param filename      the filename to load
-         */
-        bool loadFile(const char *fileName);
+        bool load(Common::SeekableReadStream &stream);
+        void close();
 
-        /**
-         * Close a FLIC encoded video file
-         */
-        void closeFile();
+        bool isVideoLoaded() const { return _fileStream != 0; }
+        uint16 getWidth() const { return _surface->w; }
+        uint16 getHeight() const { return _surface->h; }
+        uint32 getFrameCount() const { return _frameCount; }
+        Surface *decodeNextFrame();
+        PixelFormat getPixelFormat() const { return PixelFormat::createFormatCLUT8(); }
 
-        /**
-         * Decode the next frame
-         */
-        bool decodeNextFrame();
-
         const Common::List<Common::Rect> *getDirtyRects() const { return &_dirtyRects; }
         void clearDirtyRects() { _dirtyRects.clear(); }
         void copyDirtyRectsToBuffer(uint8 *dst, uint pitch);
 
-        const byte *getPalette() { _paletteChanged = false; return _palette; }
-        bool paletteChanged() { return _paletteChanged; }
+        byte *getPalette() { _paletteChanged = false; return _palette; }
+        bool hasDirtyPalette() { return _paletteChanged; }
         void reset();
 
+protected:
+        double getFrameRate() const { return _frameRate; }
+
 private:
         uint16 _offsetFrame1;
         uint16 _offsetFrame2;
@@ -81 +78 @@
         void decodeDeltaFLC(uint8 *data);
         void unpackPalette(uint8 *mem);
 
+        Common::SeekableReadStream *_fileStream;
+        Surface *_surface;
+        uint32 _frameCount;
+        uint32 _frameRate;
+
         Common::List<Common::Rect> _dirtyRects;
-
 };
 
 } // End of namespace Graphics

graphics/video/avi_decoder.h

@@ -26 +26 @@
 #ifndef GRAPHICS_AVI_PLAYER_H
 #define GRAPHICS_AVI_PLAYER_H
 
-#include "graphics/video/video_player.h"
+#include "graphics/video/video_decoder.h"
 #include "graphics/video/codecs/codec.h"
 #include "sound/audiostream.h"
 #include "sound/mixer.h"
@@ -172 +172 @@
         Common::Rect frame;
 };
 
-class AviDecoder : public VideoDecoder {
+class AviDecoder : public FixedRateVideoDecoder {
 public:
         AviDecoder(Audio::Mixer *mixer,
                         Audio::Mixer::SoundType soundType = Audio::Mixer::kPlainSoundType);
         virtual ~AviDecoder();
 
-        /**
-         * Load an AVI video file
-         * @param filename      the filename to load
-         */
-        bool loadFile(const char *fileName);
+        bool load(Common::SeekableReadStream &stream);
+        void close();
 
-        /**
-         * Close an AVI video file
-         */
-        void closeFile();
+        bool isVideoLoaded() const { return _stream != 0; }
+        uint16 getWidth() const { return _header.width; }
+        uint16 getHeight() const { return _header.height; }
+        uint32 getFrameCount() const { return _header.totalFrames; }
+        uint32 getElapsedTime() const;
+        Surface *decodeNextFrame();
+        PixelFormat getPixelFormat() const;
+        byte *getPalette() { _dirtyPalette = false; return _palette; }
+        bool hasDirtyPalette() const { return _dirtyPalette; }
 
-        bool decodeNextFrame();
-        int32 getAudioLag();
-        int32 getFrameRate() { return _vidsHeader.rate / _vidsHeader.scale; }
+protected:
+        double getFrameRate() const { return (double)_vidsHeader.rate / _vidsHeader.scale; }
 
 private:
         Audio::Mixer *_mixer;
@@ -202 +203 @@
         AVIStreamHeader _vidsHeader;
         AVIStreamHeader _audsHeader;
         byte _palette[3 * 256];
+        bool _dirtyPalette;
 
+        Common::SeekableReadStream *_stream;
         bool _decodedHeader;
 
         Codec *_videoCodec;
@@ -223 +226 @@
         static byte char2num(char c);
         static byte getStreamNum(uint32 tag);
         static uint16 getStreamType(uint32 tag);
-
-        Surface *getNextFrame();
 };
 
 } // End of namespace Graphics

graphics/video/codecs/codec.h

@@ -28 +28 @@
 
 #include "common/stream.h"
 #include "graphics/surface.h"
+#include "graphics/pixelformat.h"
 
 namespace Graphics {
 
@@ -35 +36 @@
 public:
         Codec() {}
         virtual ~Codec() {}
+
         virtual Surface *decodeImage(Common::SeekableReadStream *stream) = 0;
+        virtual PixelFormat getPixelFormat() const = 0;
 };
 
 } // End of namespace Graphics

graphics/video/codecs/msrle.h

@@ -36 +36 @@
         ~MSRLEDecoder();
 
         Surface *decodeImage(Common::SeekableReadStream *stream);
+        PixelFormat getPixelFormat() const { return PixelFormat::createFormatCLUT8(); }
 
 private:
         byte _bitsPerPixel;

graphics/video/codecs/msvideo1.cpp

@@ -125 +125 @@
     }
 }
 
-Graphics::Surface *MSVideo1Decoder::decodeImage(Common::SeekableReadStream *stream) {
+Surface *MSVideo1Decoder::decodeImage(Common::SeekableReadStream *stream) {
         if (_bitsPerPixel == 8)
                 decode8(stream);
         else {

graphics/video/codecs/msvideo1.h

@@ -36 +36 @@
         ~MSVideo1Decoder();
 
         Surface *decodeImage(Common::SeekableReadStream *stream);
+        PixelFormat getPixelFormat() const { return PixelFormat::createFormatCLUT8(); }
 
 private:
         byte _bitsPerPixel;

graphics/video/smk_decoder.cpp

@@ -351 +351 @@
 
 SmackerDecoder::SmackerDecoder(Audio::Mixer *mixer, Audio::Mixer::SoundType soundType)
         : _audioStarted(false), _audioStream(0), _mixer(mixer), _soundType(soundType) {
+        _surface = 0;
+        _fileStream = 0;
+        _dirtyPalette = false;
 }
 
 SmackerDecoder::~SmackerDecoder() {
-        closeFile();
+        close();
 }
 
-int SmackerDecoder::getHeight() {
-        if (!_fileStream)
-                return 0;
-        return (_header.flags ? 2 : 1) * _videoInfo.height;
-}
+uint32 SmackerDecoder::getElapsedTime() const {
+        if (_audioStream)
+                return _mixer->getSoundElapsedTime(_audioHandle);
 
-int32 SmackerDecoder::getAudioLag() {
-        if (!_fileStream)
-                return 0;
-
-        int32 frameDelay = getFrameDelay();
-        int32 videoTime = _videoInfo.currentFrame * frameDelay;
-        int32 audioTime;
-
-        if (!_audioStream) {
-                /* No audio.
-                   Calculate the lag by how much time has gone by since the first frame
-                   and how much time *should* have passed.
-                */
-
-                audioTime = (g_system->getMillis() - _videoInfo.startTime) * 100;
-        } else {
-                const Audio::Timestamp ts = _mixer->getElapsedTime(_audioHandle);
-                audioTime = ts.convertToFramerate(100000).totalNumberOfFrames();
-        }
-
-        return videoTime - audioTime;
+        return VideoDecoder::getElapsedTime();
 }
 
-bool SmackerDecoder::loadFile(const char *fileName) {
-        int32 frameRate;
+bool SmackerDecoder::load(Common::SeekableReadStream &stream) {
+        close();
 
-        closeFile();
+        _fileStream = &stream;
 
-        _fileStream = SearchMan.createReadStreamForMember(fileName);
-        if (!_fileStream)
-                return false;
-
         // Seek to the first frame
-        _videoInfo.currentFrame = 0;
         _header.signature = _fileStream->readUint32BE();
 
         // No BINK support available
@@ -408 +384 @@
 
         assert(_header.signature == MKID_BE('SMK2') || _header.signature == MKID_BE('SMK4'));
 
-        _videoInfo.width = _fileStream->readUint32LE();
-        _videoInfo.height = _fileStream->readUint32LE();
-        _videoInfo.frameCount = _fileStream->readUint32LE();
-        frameRate = _fileStream->readSint32LE();
+        uint32 width = _fileStream->readUint32LE();
+        uint32 height = _fileStream->readUint32LE();
+        _frameCount = _fileStream->readUint32LE();
+        int32 frameRate = _fileStream->readSint32LE();
 
-        if (frameRate > 0) {
-                _videoInfo.frameRate = 1000 / frameRate;
-                _videoInfo.frameDelay = frameRate * 100;
-        } else if (frameRate < 0) {
-                _videoInfo.frameRate = 100000 / (-frameRate);
-                _videoInfo.frameDelay = -frameRate;
-        } else {
-                _videoInfo.frameRate = 10;
-                _videoInfo.frameDelay = 10000;
-        }
+        if (frameRate > 0)
+                _frameRate = 1000 / frameRate;
+        else if (frameRate < 0)
+                _frameRate = 100000 / (-frameRate);
+        else
+                _frameRate = 10;
 
         // Flags are determined by which bit is set, which can be one of the following:
         // 0 - set to 1 if file contains a ring frame.
@@ -447 +419 @@
         _header.fullSize = _fileStream->readUint32LE();
         _header.typeSize = _fileStream->readUint32LE();
 
-        uint32 audioInfo;
         for (i = 0; i < 7; ++i) {
                 // AudioRate - Frequency and format information for each sound track, up to 7 audio tracks.
                 // The 32 constituent bits have the following meaning:
@@ -458 +429 @@
                 // * bits 27-26 - if both set to zero - use v2 sound decompression
                 // * bits 25-24 - unused
                 // * bits 23-0 - audio sample rate
-                audioInfo = _fileStream->readUint32LE();
+                uint32 audioInfo = _fileStream->readUint32LE();
                 _header.audioInfo[i].isCompressed = audioInfo & 0x80000000;
                 _header.audioInfo[i].hasAudio = audioInfo & 0x40000000;
                 _header.audioInfo[i].is16Bits = audioInfo & 0x20000000;
@@ -467 +438 @@
                                                                                                 !(audioInfo & 0x4000000);
                 _header.audioInfo[i].sampleRate = audioInfo & 0xFFFFFF;
 
-                if (_header.audioInfo[i].hasAudio && i == 0) {
+                if (_header.audioInfo[i].hasAudio && i == 0)
                         _audioStream = Audio::makeQueuingAudioStream(_header.audioInfo[0].sampleRate, _header.audioInfo[0].isStereo);
-                }
         }
 
         _header.dummy = _fileStream->readUint32LE();
 
-        _frameSizes = (uint32 *)malloc(_videoInfo.frameCount * sizeof(uint32));
-        for (i = 0; i < _videoInfo.frameCount; ++i)
+        _frameSizes = new uint32[_frameCount];
+        for (i = 0; i < _frameCount; ++i)
                 _frameSizes[i] = _fileStream->readUint32LE();
 
-        _frameTypes = (byte *)malloc(_videoInfo.frameCount);
-        for (i = 0; i < _videoInfo.frameCount; ++i)
+        _frameTypes = new byte[_frameCount];
+        for (i = 0; i < _frameCount; ++i)
                 _frameTypes[i] = _fileStream->readByte();
 
         byte *huffmanTrees = new byte[_header.treesSize];
@@ -494 +464 @@
 
         delete[] huffmanTrees;
 
-        _videoFrameBuffer = (byte *)malloc(2 * _videoInfo.width * _videoInfo.height);
-        memset(_videoFrameBuffer, 0, 2 * _videoInfo.width * _videoInfo.height);
+        _surface = new Graphics::Surface();
+        _surface->create(width, height * (_header.flags ? 2 : 1), 1);
         _palette = (byte *)malloc(3 * 256);
         memset(_palette, 0, 3 * 256);
-
-        _videoInfo.firstframeOffset = _fileStream->pos();
-
         return true;
 }
 
-void SmackerDecoder::closeFile() {
+void SmackerDecoder::close() {
         if (!_fileStream)
                 return;
 
@@ -517 +484 @@
         delete _fileStream;
         _fileStream = 0;
 
+        _surface->free();
+        delete _surface;
+        _surface = 0;
+
         delete _MMapTree;
         delete _MClrTree;
         delete _FullTree;
         delete _TypeTree;
 
-        free(_frameSizes);
-        free(_frameTypes);
-        free(_videoFrameBuffer);
+        delete[] _frameSizes;
+        delete[] _frameTypes;
         free(_palette);
+
+        reset();
 }
 
-bool SmackerDecoder::decodeNextFrame() {
+Surface *SmackerDecoder::decodeNextFrame() {
         uint i;
         uint32 chunkSize = 0;
         uint32 dataSizeUnpacked = 0;
 
         uint32 startPos = _fileStream->pos();
 
-        if (_videoInfo.currentFrame == 0)
-                _videoInfo.startTime = g_system->getMillis();
+        _curFrame++;
 
         // Check if we got a frame with palette data, and
         // call back the virtual setPalette function to set
         // the current palette
-        if (_frameTypes[_videoInfo.currentFrame] & 1) {
+        if (_frameTypes[_curFrame] & 1) {
                 unpackPalette();
-                setPalette(_palette);
+                _dirtyPalette = true;
         }
 
         // Load audio tracks
         for (i = 0; i < 7; ++i) {
-                if (!(_frameTypes[_videoInfo.currentFrame] & (2 << i)))
+                if (!(_frameTypes[_curFrame] & (2 << i)))
                         continue;
 
                 chunkSize = _fileStream->readUint32LE();
@@ -596 +567 @@
                 }
         }
 
-        uint32 frameSize = _frameSizes[_videoInfo.currentFrame] & ~3;
+        uint32 frameSize = _frameSizes[_curFrame] & ~3;
 
         if (_fileStream->pos() - startPos > frameSize)
-                exit(1);
+                error("Smacker actual frame size exceeds recorded frame size");
 
         uint32 frameDataSize = frameSize - (_fileStream->pos() - startPos);
 
@@ -613 +584 @@
         _FullTree->reset();
         _TypeTree->reset();
 
-        uint bw = _videoInfo.width / 4;
-        uint bh = _videoInfo.height / 4;
-        uint stride = _videoInfo.width;
+        uint bw = getWidth() / 4;
+        uint bh = getHeight() / (_header.flags ? 2 : 1) / 4;
+        uint stride = getWidth();
         uint block = 0, blocks = bw*bh;
 
         uint doubleY = _header.flags ? 2 : 1;
@@ -634 +605 @@
                         while (run-- && block < blocks) {
                                 clr = _MClrTree->getCode(bs);
                                 map = _MMapTree->getCode(bs);
-                                out = _videoFrameBuffer + (block / bw) * (stride * 4 * doubleY) + (block % bw) * 4;
+                                out = (byte *)_surface->pixels + (block / bw) * (stride * 4 * doubleY) + (block % bw) * 4;
                                 hi = clr >> 8;
                                 lo = clr & 0xff;
                                 for (i = 0; i < 4; i++) {
@@ -667 +638 @@
                         }
 
                         while (run-- && block < blocks) {
-                                out = _videoFrameBuffer + (block / bw) * (stride * 4 * doubleY) + (block % bw) * 4;
+                                out = (byte *)_surface->pixels + (block / bw) * (stride * 4 * doubleY) + (block % bw) * 4;
                                 switch (mode) {
                                         case 0:
                                                 for (i = 0; i < 4; ++i) {
@@ -733 +704 @@
                         uint32 col;
                         mode = type >> 8;
                         while (run-- && block < blocks) {
-                                out = _videoFrameBuffer + (block / bw) * (stride * 4 * doubleY) + (block % bw) * 4;
+                                out = (byte *)_surface->pixels + (block / bw) * (stride * 4 * doubleY) + (block % bw) * 4;
                                 col = mode * 0x01010101;
                                 for (i = 0; i < 4 * doubleY; ++i) {
                                         out[0] = out[1] = out[2] = out[3] = col;
@@ -749 +720 @@
 
         free(_frameData);
 
-        return ++_videoInfo.currentFrame < _videoInfo.frameCount;
+        if (_curFrame == 0)
+                _startTime = g_system->getMillis();
+
+        return _surface;
 }
 
 void SmackerDecoder::queueCompressedBuffer(byte *buffer, uint32 bufferSize,
@@ -804 +778 @@
                 // If the sample is stereo, the data is stored for the left and right channel, respectively
                 // (the exact opposite to the base values)
                 if (!is16Bits) {
-
                         for (int k = 0; k < (isStereo ? 2 : 1); k++) {
                                 bases[k] += (int8) ((int16) audioTrees[k]->getCode(audioBS));
                                 *curPointer++ = CLIP<int>(bases[k], 0, 255) ^ 0x80;
                                 curPos++;
                         }
-
                 } else {
-
                         for (int k = 0; k < (isStereo ? 2 : 1); k++) {
                                 bases[k] += (int16) (audioTrees[k * 2]->getCode(audioBS) |
                                                     (audioTrees[k * 2 + 1]->getCode(audioBS) << 8));
@@ -885 +856 @@
         }
 
         _fileStream->seek(startPos + len);
-
         free(chunk);
 }
 

graphics/video/video_player.cpp

@@ -1 @@
-/* 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.
- *
- * $URL$
- * $Id$
- *
- */
-
-#include "common/archive.h"
-#include "common/debug.h"
-#include "common/events.h"
-#include "common/system.h"
-#include "common/util.h"
-#include "common/array.h"
-#include "common/endian.h"
-
-#include "graphics/video/video_player.h"
-#include "graphics/surface.h"
-
-namespace Graphics {
-
-VideoDecoder::VideoDecoder() : _fileStream(0) {
-        _curFrameBlack = 0;
-        _curFrameWhite = 255;
-}
-
-VideoDecoder::~VideoDecoder() {
-}
-
-int VideoDecoder::getWidth() {
-        if (!_fileStream)
-                return 0;
-        return _videoInfo.width;
-}
-
-int VideoDecoder::getHeight() {
-        if (!_fileStream)
-                return 0;
-        return _videoInfo.height;
-}
-
-int32 VideoDecoder::getCurFrame() {
-        if (!_fileStream)
-                return -1;
-        return _videoInfo.currentFrame;
-}
-
-int32 VideoDecoder::getFrameCount() {
-        if (!_fileStream)
-                return 0;
-        return _videoInfo.frameCount;
-}
-
-int32 VideoDecoder::getFrameRate() {
-        if (!_fileStream)
-                return 0;
-        return _videoInfo.frameRate;
-}
-
-int32 VideoDecoder::getFrameDelay() {
-        if (!_fileStream)
-                return 0;
-        return _videoInfo.frameDelay;
-}
-
-int32 VideoDecoder::getAudioLag() {
-        if (!_fileStream)
-                return 0;
-
-        /* No audio.
-           Calculate the lag by how much time has gone by since the first frame
-           and how much time *should* have passed.
-        */
-        int32 audioTime = (g_system->getMillis() - _videoInfo.startTime) * 100;
-        int32 videoTime = _videoInfo.currentFrame * getFrameDelay();
-
-        return videoTime - audioTime;
-}
-
-uint32 VideoDecoder::getFrameWaitTime() {
-        int32 waitTime = (getFrameDelay() + getAudioLag()) / 100;
-
-        if (waitTime < 0)
-                return 0;
-
-        return waitTime;
-}
-
-void VideoDecoder::copyFrameToBuffer(byte *dst, uint x, uint y, uint pitch) {
-        uint h = getHeight();
-        uint w = getWidth();
-
-        byte *src = _videoFrameBuffer;
-        dst += y * pitch + x;
-
-        do {
-                memcpy(dst, src, w);
-                dst += pitch;
-                src += w;
-        } while (--h);
-}
-
-void VideoDecoder::setPalette(byte *pal) {
-        byte videoPalette[256 * 4];
-
-        uint32 maxWeight = 0;
-        uint32 minWeight = 0xFFFFFFFF;
-        uint32 weight = 0;
-        byte r, g, b;
-
-        for (int i = 0; i < 256; i++) {
-                videoPalette[i * 4 + 0] = *pal++;
-                videoPalette[i * 4 + 1] = *pal++;
-                videoPalette[i * 4 + 2] = *pal++;
-                videoPalette[i * 4 + 3] = 0;
-
-                // Try and find the white and black colors for the current palette
-                r = videoPalette[i * 4 + 0];
-                g = videoPalette[i * 4 + 1];
-                b = videoPalette[i * 4 + 2];
-
-                weight = 3 * r * r + 6 * g * g + 2 * b * b;
-
-                if (weight >= maxWeight) {
-                        _curFrameWhite = i;
-                        maxWeight = weight;
-                }
-
-                if (weight <= minWeight) {
-                        _curFrameBlack = i;
-                        minWeight = i;
-                }
-        }
-
-        g_system->setPalette(videoPalette, 0, 256);
-}
-
-
-/*
- *  VideoPlayer
- */
-
-void VideoPlayer::processVideoEvents(Common::List<Common::Event> &stopEvents) {
-        Common::Event curEvent;
-        Common::EventManager *eventMan = g_system->getEventManager();
-
-        // Process events, and skip video if esc is pressed
-        while (eventMan->pollEvent(curEvent)) {
-                if (curEvent.type == Common::EVENT_RTL || curEvent.type == Common::EVENT_QUIT) {
-                        _skipVideo = true;
-                }
-
-                for (Common::List<Common::Event>::const_iterator iter = stopEvents.begin(); iter != stopEvents.end(); ++iter) {
-                        if (curEvent.type == iter->type) {
-                                if (iter->type == Common::EVENT_KEYDOWN || iter->type == Common::EVENT_KEYUP) {
-                                        if (curEvent.kbd.keycode == iter->kbd.keycode) {
-                                                _skipVideo = true;
-                                                break;
-                                        }
-                                } else {
-                                        _skipVideo = true;
-                                        break;
-                                }
-                        }
-                }
-        }
-}
-
-bool VideoPlayer::playVideo(Common::List<Common::Event> &stopEvents) {
-        _skipVideo = false;
-        debug(0, "Playing video");
-
-        g_system->fillScreen(0);
-
-        int frameX = (g_system->getWidth() - _decoder->getWidth()) / 2;
-        int frameY = (g_system->getHeight() - _decoder->getHeight()) / 2;
-
-        while (_decoder->getCurFrame() < _decoder->getFrameCount() && !_skipVideo) {
-                processVideoEvents(stopEvents);
-
-                uint32 startTime = 0;
-                _decoder->decodeNextFrame();
-
-                Graphics::Surface *screen = g_system->lockScreen();
-                _decoder->copyFrameToBuffer((byte *)screen->pixels, frameX, frameY, g_system->getWidth());
-                performPostProcessing((byte *)screen->pixels);
-                g_system->unlockScreen();
-
-                uint32 waitTime = _decoder->getFrameWaitTime();
-
-                if (!waitTime) {
-                        warning("dropped frame %i", _decoder->getCurFrame());
-                        continue;
-                }
-
-                // Update the screen
-                g_system->updateScreen();
-
-                startTime = g_system->getMillis();
-
-                // Wait before showing the next frame
-                while (g_system->getMillis() < startTime + waitTime && !_skipVideo) {
-                        processVideoEvents(stopEvents);
-                        g_system->delayMillis(10);
-                }
-        }
-
-        return !_skipVideo;
-}
-
-bool VideoPlayer::playVideo() {
-        Common::Event stopEvent;
-        Common::List<Common::Event> stopEvents;
-        stopEvents.clear();
-        stopEvent.type = Common::EVENT_KEYDOWN;
-        stopEvent.kbd = Common::KEYCODE_ESCAPE;
-        stopEvents.push_back(stopEvent);
-
-        return playVideo(stopEvents);
-}
-
-void VideoPlayer::performPostProcessing(byte *screen) {
-}
-
-} // End of namespace Graphics

graphics/video/smk_decoder.h

@@ -26 +26 @@
 #ifndef GRAPHICS_VIDEO_SMK_PLAYER_H
 #define GRAPHICS_VIDEO_SMK_PLAYER_H
 
-#include "graphics/video/video_player.h"
+#include "graphics/video/video_decoder.h"
 #include "sound/mixer.h"
 
 namespace Audio {
@@ -51 +51 @@
  *  - sword1
  *  - sword2
  */
-class SmackerDecoder : public VideoDecoder {
+class SmackerDecoder : public FixedRateVideoDecoder {
 public:
         SmackerDecoder(Audio::Mixer *mixer,
                         Audio::Mixer::SoundType soundType = Audio::Mixer::kSFXSoundType);
         virtual ~SmackerDecoder();
 
-        int getHeight();
-        int32 getAudioLag();
+        bool load(Common::SeekableReadStream &stream);
+        void close();
 
-        /**
-         * Load an SMK encoded video file
-         * @param filename      the filename to load
-         */
-        bool loadFile(const char *filename);
+        bool isVideoLoaded() const { return _fileStream != 0; }
+        uint16 getWidth() const { return _surface->w; }
+        uint16 getHeight() const { return _surface->h; }
+        uint32 getFrameCount() const { return _frameCount; }
+        uint32 getElapsedTime() const;
+        Surface *decodeNextFrame();
+        PixelFormat getPixelFormat() const { return PixelFormat::createFormatCLUT8(); }
+        byte *getPalette() { _dirtyPalette = false; return _palette; }
+        bool hasDirtyPalette() const { return _dirtyPalette; }
 
-        /**
-         * Close an SMK encoded video file
-         */
-        void closeFile();
+protected:
+        double getFrameRate() const { return _frameRate; }
+        Common::SeekableReadStream *_fileStream;
 
-        bool decodeNextFrame();
-
 private:
         void unpackPalette();
         // Possible runs of blocks
@@ -111 +112 @@
         byte *_frameData;
         // The RGB palette
         byte *_palette;
+        bool _dirtyPalette;
 
+        uint32 _frameRate;
+        uint32 _frameCount;
+        Surface *_surface;
+
         Audio::Mixer::SoundType _soundType;
         Audio::Mixer *_mixer;
         bool _audioStarted;

graphics/video/video_player.h

@@ -1 @@
-/* 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.
- *
- * $URL$
- * $Id$
- *
- */
-
-#ifndef GRAPHICS_VIDEO_PLAYER_H
-#define GRAPHICS_VIDEO_PLAYER_H
-
-#include "common/events.h"
-#include "common/list.h"
-#include "common/stream.h"
-
-namespace Common {
-        class SeekableReadStream;
-}
-
-namespace Graphics {
-
-/**
- * Implementation of a generic video decoder
- */
-class VideoDecoder {
-public:
-        VideoDecoder();
-        virtual ~VideoDecoder();
-
-        /**
-         * Returns the width of the video
-         * @return the width of the video
-         */
-        virtual int getWidth();
-
-        /**
-         * Returns the height of the video
-         * @return the height of the video
-         */
-        virtual int getHeight();
-
-        /**
-         * Returns the current frame number of the video
-         * @return the current frame number of the video
-         */
-        virtual int32 getCurFrame();
-
-        /**
-         * Returns the amount of frames in the video
-         * @return the amount of frames in the video
-         */
-        virtual int32 getFrameCount();
-
-        /**
-         * Returns the frame rate of the video
-         * @return the frame rate of the video
-         */
-        virtual int32 getFrameRate();
-
-        /**
-         * Returns the time to wait for each frame in 1/100 ms (to avoid rounding errors)
-         * @return the time to wait for each frame in 1/100 ms (to avoid rounding errors)
-         */
-        virtual int32 getFrameDelay();
-
-        /**
-         * Returns the current A/V lag in 1/100 ms (to avoid rounding errors)
-         * If > 0, audio lags behind
-         * If < 0, video lags behind
-         * @return the current A/V lag in 1/100 ms (to avoid rounding errors)
-         */
-        virtual int32 getAudioLag();
-
-        /**
-         * Returns the time to wait until the next frame in ms, minding any lag
-         * @return the time to wait until the next frame in ms
-         */
-        virtual uint32 getFrameWaitTime();
-
-        /**
-         * Load a video file
-         * @param filename      the filename to load
-         */
-        virtual bool loadFile(const char *filename) = 0;
-
-        /**
-         * Close a video file
-         */
-        virtual void closeFile() = 0;
-
-        /**
-         * Returns if a video file is loaded or not
-         */
-        bool isVideoLoaded() { return (_fileStream != NULL); }
-
-        /**
-         * Set RGB palette, based on current frame
-         * @param pal           the RGB palette data
-         */
-        virtual void setPalette(byte *pal);
-
-        /**
-         * Gets the value of the pixel at the specified x and y coordinates
-         * Note: This method assumes that the video's pitch equals its width, and that
-         * the video has an 8bpp palette
-         * @param x     the x coordinate of the pixel
-         * @param y     the y coordinate of the pixel
-         */
-        byte getPixel(int x, int y) {
-                return *(_videoFrameBuffer + y * _videoInfo.width + x * 1);
-        }
-
-        /**
-         * Gets the value of the pixel at the specified offset
-         * @param offset        the offset of the pixel in the video buffer
-         */
-        byte getPixel(int offset) { return getPixel(offset, 0); }
-
-        /**
-         * Return the black palette color for the current frame
-         */
-        byte getBlack() { return _curFrameBlack; }
-
-        /**
-         * Return the white palette color for the current frame
-         */
-        byte getWhite() { return _curFrameWhite; }
-
-        /**
-         * Copy current frame into the specified position of the destination
-         * buffer.
-         * @param dst           the buffer
-         * @param x             the x position of the buffer
-         * @param y             the y position of the buffer
-         * @param pitch         the pitch of buffer
-         */
-        void copyFrameToBuffer(byte *dst, uint x, uint y, uint pitch);
-
-        /**
-         * Decode the next frame to _videoFrameBuffer
-         */
-        virtual bool decodeNextFrame() = 0;
-
-protected:
-        struct {
-                uint32 width;
-                uint32 height;
-                uint32 frameCount;
-                int32 frameRate;
-                int32 frameDelay;               // 1/100 ms (to avoid rounding errors)
-                uint32 firstframeOffset;
-                uint32 currentFrame;
-                uint32 startTime;
-        } _videoInfo;
-
-        byte _curFrameBlack, _curFrameWhite;
-
-        Common::SeekableReadStream *_fileStream;
-        byte *_videoFrameBuffer;
-};
-
-class VideoPlayer {
-public:
-        VideoPlayer(VideoDecoder* decoder) : _skipVideo(false), _decoder(decoder)
-                { }
-        virtual ~VideoPlayer() { }
-        /**
-         * A default implementation of a video player
-         * Plays a non-interactive full screen video till it's stopped by a
-         * specific event
-         * @param filename              the name of the file to play
-         * @param stopEvents    a list of events that can stop the video
-         *
-         * Returns true if the video was played to the end, false if skipped
-         */
-        bool playVideo(Common::List<Common::Event> &stopEvents);
-
-        /**
-         * Provides the same functionality as the video player, and it adds the
-         * event of skipping the video with the escape key by default
-         */
-        bool playVideo();
-
-protected:
-        /**
-         * Perform postprocessing once the frame data is copied to the screen,
-         * right before the frame is drawn. Called by playVideo()
-         */
-        virtual void performPostProcessing(byte *screen);
-
-        bool _skipVideo;
-        VideoDecoder* _decoder;
-
-        void processVideoEvents(Common::List<Common::Event> &stopEvents);
-};
-
-} // End of namespace Graphics
-
-#endif

graphics/video/video_decoder.cpp

@@ -23 +23 @@
  *
  */
 
-#include "common/archive.h"
-#include "common/debug.h"
-#include "common/events.h"
+#include "graphics/video/video_decoder.h"
+
+#include "common/file.h"
 #include "common/system.h"
-#include "common/util.h"
-#include "common/array.h"
-#include "common/endian.h"
 
-#include "graphics/video/video_player.h"
-#include "graphics/surface.h"
-
 namespace Graphics {
 
-VideoDecoder::VideoDecoder() : _fileStream(0) {
-        _curFrameBlack = 0;
-        _curFrameWhite = 255;
+VideoDecoder::VideoDecoder() {
+        reset();
 }
 
-VideoDecoder::~VideoDecoder() {
-}
+bool VideoDecoder::loadFile(const Common::String &filename) {
+        Common::File *file = new Common::File();
 
-int VideoDecoder::getWidth() {
-        if (!_fileStream)
-                return 0;
-        return _videoInfo.width;
-}
+        if (!file->open(filename)) {
+                delete file;
+                return false;
+        }
 
-int VideoDecoder::getHeight() {
-        if (!_fileStream)
-                return 0;
-        return _videoInfo.height;
+        return load(*file);
 }
 
-int32 VideoDecoder::getCurFrame() {
-        if (!_fileStream)
-                return -1;
-        return _videoInfo.currentFrame;
+uint32 VideoDecoder::getElapsedTime() const {
+        return g_system->getMillis() - _startTime;
 }
 
-int32 VideoDecoder::getFrameCount() {
-        if (!_fileStream)
-                return 0;
-        return _videoInfo.frameCount;
-}
+void VideoDecoder::setSystemPalette() {
+        byte *vidPalette = getPalette();
+        byte *sysPalette = new byte[256 * 4];
 
-int32 VideoDecoder::getFrameRate() {
-        if (!_fileStream)
-                return 0;
-        return _videoInfo.frameRate;
-}
+        for (uint16 i = 0; i < 256; i++) {
+                sysPalette[i * 4] = vidPalette[i * 3];
+                sysPalette[i * 4 + 1] = vidPalette[i * 3 + 1];
+                sysPalette[i * 4 + 2] = vidPalette[i * 3 + 2];
+                sysPalette[i * 4 + 3] = 0;
+        }
 
-int32 VideoDecoder::getFrameDelay() {
-        if (!_fileStream)
-                return 0;
-        return _videoInfo.frameDelay;
+        g_system->setPalette(sysPalette, 0, 256);
+        delete[] sysPalette;
 }
 
-int32 VideoDecoder::getAudioLag() {
-        if (!_fileStream)
-                return 0;
-
-        /* No audio.
-           Calculate the lag by how much time has gone by since the first frame
-           and how much time *should* have passed.
-        */
-        int32 audioTime = (g_system->getMillis() - _videoInfo.startTime) * 100;
-        int32 videoTime = _videoInfo.currentFrame * getFrameDelay();
-
-        return videoTime - audioTime;
+bool VideoDecoder::needsUpdate() const {        
+        return !endOfVideo() && getTimeToNextFrame() == 0;
 }
 
-uint32 VideoDecoder::getFrameWaitTime() {
-        int32 waitTime = (getFrameDelay() + getAudioLag()) / 100;
-
-        if (waitTime < 0)
-                return 0;
-
-        return waitTime;
+void VideoDecoder::reset() {
+        _curFrame = -1;
+        _startTime = 0;
 }
 
-void VideoDecoder::copyFrameToBuffer(byte *dst, uint x, uint y, uint pitch) {
-        uint h = getHeight();
-        uint w = getWidth();
-
-        byte *src = _videoFrameBuffer;
-        dst += y * pitch + x;
-
-        do {
-                memcpy(dst, src, w);
-                dst += pitch;
-                src += w;
-        } while (--h);
+bool VideoDecoder::endOfVideo() const {
+        return !isVideoLoaded() || getCurFrame() >= (int32)getFrameCount() - 1;
 }
 
-void VideoDecoder::setPalette(byte *pal) {
-        byte videoPalette[256 * 4];
+uint32 FixedRateVideoDecoder::getTimeToNextFrame() const {
+        if (endOfVideo() || _curFrame < 0)
+                return 0;
 
-        uint32 maxWeight = 0;
-        uint32 minWeight = 0xFFFFFFFF;
-        uint32 weight = 0;
-        byte r, g, b;
+        uint32 elapsedTime = getElapsedTime();
+        uint32 nextFrameStartTime = getFrameBeginTime(_curFrame + 1);
 
-        for (int i = 0; i < 256; i++) {
-                videoPalette[i * 4 + 0] = *pal++;
-                videoPalette[i * 4 + 1] = *pal++;
-                videoPalette[i * 4 + 2] = *pal++;
-                videoPalette[i * 4 + 3] = 0;
+        // If the time that the next frame should be shown has past
+        // the frame should be shown ASAP.
+        if (nextFrameStartTime <= elapsedTime)
+                return 0;
 
-                // Try and find the white and black colors for the current palette
-                r = videoPalette[i * 4 + 0];
-                g = videoPalette[i * 4 + 1];
-                b = videoPalette[i * 4 + 2];
-
-                weight = 3 * r * r + 6 * g * g + 2 * b * b;
-
-                if (weight >= maxWeight) {
-                        _curFrameWhite = i;
-                        maxWeight = weight;
-                }
-
-                if (weight <= minWeight) {
-                        _curFrameBlack = i;
-                        minWeight = i;
-                }
-        }
-
-        g_system->setPalette(videoPalette, 0, 256);
+        return nextFrameStartTime - elapsedTime;
 }
 
-
-/*
- *  VideoPlayer
- */
-
-void VideoPlayer::processVideoEvents(Common::List<Common::Event> &stopEvents) {
-        Common::Event curEvent;
-        Common::EventManager *eventMan = g_system->getEventManager();
-
-        // Process events, and skip video if esc is pressed
-        while (eventMan->pollEvent(curEvent)) {
-                if (curEvent.type == Common::EVENT_RTL || curEvent.type == Common::EVENT_QUIT) {
-                        _skipVideo = true;
-                }
-
-                for (Common::List<Common::Event>::const_iterator iter = stopEvents.begin(); iter != stopEvents.end(); ++iter) {
-                        if (curEvent.type == iter->type) {
-                                if (iter->type == Common::EVENT_KEYDOWN || iter->type == Common::EVENT_KEYUP) {
-                                        if (curEvent.kbd.keycode == iter->kbd.keycode) {
-                                                _skipVideo = true;
-                                                break;
-                                        }
-                                } else {
-                                        _skipVideo = true;
-                                        break;
-                                }
-                        }
-                }
-        }
+uint32 FixedRateVideoDecoder::getFrameBeginTime(uint32 frame) const {
+        return (uint32)(frame * 1000 / getFrameRate());
 }
 
-bool VideoPlayer::playVideo(Common::List<Common::Event> &stopEvents) {
-        _skipVideo = false;
-        debug(0, "Playing video");
-
-        g_system->fillScreen(0);
-
-        int frameX = (g_system->getWidth() - _decoder->getWidth()) / 2;
-        int frameY = (g_system->getHeight() - _decoder->getHeight()) / 2;
-
-        while (_decoder->getCurFrame() < _decoder->getFrameCount() && !_skipVideo) {
-                processVideoEvents(stopEvents);
-
-                uint32 startTime = 0;
-                _decoder->decodeNextFrame();
-
-                Graphics::Surface *screen = g_system->lockScreen();
-                _decoder->copyFrameToBuffer((byte *)screen->pixels, frameX, frameY, g_system->getWidth());
-                performPostProcessing((byte *)screen->pixels);
-                g_system->unlockScreen();
-
-                uint32 waitTime = _decoder->getFrameWaitTime();
-
-                if (!waitTime) {
-                        warning("dropped frame %i", _decoder->getCurFrame());
-                        continue;
-                }
-
-                // Update the screen
-                g_system->updateScreen();
-
-                startTime = g_system->getMillis();
-
-                // Wait before showing the next frame
-                while (g_system->getMillis() < startTime + waitTime && !_skipVideo) {
-                        processVideoEvents(stopEvents);
-                        g_system->delayMillis(10);
-                }
-        }
-
-        return !_skipVideo;
-}
-
-bool VideoPlayer::playVideo() {
-        Common::Event stopEvent;
-        Common::List<Common::Event> stopEvents;
-        stopEvents.clear();
-        stopEvent.type = Common::EVENT_KEYDOWN;
-        stopEvent.kbd = Common::KEYCODE_ESCAPE;
-        stopEvents.push_back(stopEvent);
-
-        return playVideo(stopEvents);
-}
-
-void VideoPlayer::performPostProcessing(byte *screen) {
-}
-
 } // End of namespace Graphics