Ticket #8937: groovie.patch

configure

@@ -89 +89 @@
 add_engine cruise "Cinematique evo 2" no
 add_engine drascula "Drascula: The Vampire Strikes Back" yes
 add_engine gob "Gobli*ns" yes
+add_engine groovie "Groovie" no 
 add_engine igor "Igor: Objective Uikokahonia" no
 add_engine kyra "Legend of Kyrandia" yes
 add_engine lure "Lure of the Temptress" yes

engines/engines.mk

@@ -42 +42 @@
 MODULES += engines/gob
 endif
 
+ifdef ENABLE_GROOVIE
+DEFINES += -DENABLE_GROOVIE=$(ENABLE_GROOVIE)
+MODULES += engines/groovie
+endif
+
 ifdef ENABLE_IGOR
 DEFINES += -DENABLE_IGOR=$(ENABLE_IGOR)
 MODULES += engines/igor

engines/groovie/lzss.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$
+ *
+ */
+
+#include "common/stream.h"
+
+class LzssReadStream : public Common::ReadStream {
+private:
+        uint8 *_outLzssBufData;
+        uint32 _size;
+        uint32 _pos;
+
+        uint32 decodeLZSS(Common::ReadStream *in, uint8 lengthmask, uint8 lengthbits);
+
+public:
+        LzssReadStream(Common::ReadStream *indata, uint8 lengthmask, uint8 lengthbits);
+        ~LzssReadStream();
+
+        bool eos() const;
+        uint32 read(void *buf, uint32 size);
+};

engines/groovie/graphics.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 "groovie/groovie.h"
+#include "groovie/graphics.h"
+
+namespace Groovie {
+
+GraphicsMan::GraphicsMan(GroovieEngine *vm) :
+        _vm(vm), _changed(false), _fading(0) {
+        // Create the game surfaces
+        _foreground.create(640, 320, 1);
+        _background.create(640, 320, 1);
+}
+
+GraphicsMan::~GraphicsMan() {
+        // Free the game surfaces
+        _foreground.free();
+        _background.free();
+}
+
+void GraphicsMan::update() {
+        if (_fading) {
+                // Set the start time
+                uint32 time = _vm->_system->getMillis() - _fadeStartTime;
+
+                // Scale the time
+                int step = time / 4;
+                if (step > 256) {
+                        step = 256;
+                }
+
+                if (_fading == 1) {
+                        // Apply the fade in
+                        applyFading(step);
+                } else if (_fading == 2) {
+                        // Apply the fade out
+                        applyFading(256 - step);
+
+                        // Clear the buffer when ending the fade out
+                        if (step == 256)
+                                _foreground.fillRect(Common::Rect::Rect(640, 320), 0);
+                }
+
+                // Check for the end
+                if (step == 256) {
+                        _fading = 0;
+                }
+        }
+
+        // Update the screen if needed and reset the status
+        if (_changed) {
+                _vm->_system->updateScreen();
+                _changed = false;
+        }
+}
+
+void GraphicsMan::change() {
+        _changed = true;
+}
+
+void GraphicsMan::mergeFgAndBg() {
+        uint32 i;
+        byte *countf, *countb;
+        countf = (byte *)_foreground.getBasePtr(0, 0);
+        countb = (byte *)_background.getBasePtr(0, 0);
+        for (i = 640 * 320; i; i--) {
+                if (255 == *(countf)) {
+                        *(countf) = *(countb);
+                }
+                countf++;
+                countb++;
+        }
+}
+
+
+void GraphicsMan::updateScreen(Graphics::Surface *source) {
+        _vm->_system->copyRectToScreen((byte *)source->getBasePtr(0, 0), 640, 0, 80, 640, 320);
+        change();
+}
+
+bool GraphicsMan::isFading() {
+        return _fading;
+}
+
+void GraphicsMan::fadeIn(byte *pal) {
+        // Set the start time
+        _fadeStartTime = _vm->_system->getMillis();
+
+        // Copy the target palette
+        for (int i = 0; i < 256; i++) {
+                _paletteFull[(i * 4) + 0] = pal[(i * 3) + 0];
+                _paletteFull[(i * 4) + 1] = pal[(i * 3) + 1];
+                _paletteFull[(i * 4) + 2] = pal[(i * 3) + 2];
+        }
+
+        // Apply a black palette right now
+        applyFading(0);
+
+        // Set the current fading
+        _fading = 1;
+}
+
+void GraphicsMan::fadeOut() {
+        // Set the start time
+        _fadeStartTime = _vm->_system->getMillis();
+
+        // Get the current palette
+        _vm->_system->grabPalette(_paletteFull, 0, 256);
+
+        // Set the current fading
+        _fading = 2;
+}
+
+void GraphicsMan::applyFading(int step) {
+        // Calculate the fade factor for the given step
+        int factorR = 256 - (256 - step) * 1;
+        if (factorR <= 0) factorR = 0;
+        int factorGB = 256 - (256 - step) * 2;
+        if (factorGB <= 0) factorGB = 0;
+
+        // Calculate the new palette
+        byte newpal[256 * 4];
+        for (int i = 0; i < 256; i++) {
+                newpal[(i * 4) + 0] = (_paletteFull[(i * 4) + 0] * factorR) / 256;
+                newpal[(i * 4) + 1] = (_paletteFull[(i * 4) + 1] * factorGB) / 256;
+                newpal[(i * 4) + 2] = (_paletteFull[(i * 4) + 2] * factorGB) / 256;
+        }
+
+        // Set the screen palette
+        _vm->_system->setPalette(newpal, 0, 256);
+
+        // Request a screen update
+        change();
+}
+
+} // End of Groovie namespace

engines/groovie/roq.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 "groovie/groovie.h"
+#include "groovie/jpeg.h"
+#include "groovie/roq.h"
+
+#include "sound/mixer.h"
+
+namespace Groovie {
+
+ROQPlayer::ROQPlayer(GroovieEngine *vm) :
+        VideoPlayer(vm) {
+}
+
+ROQPlayer::~ROQPlayer() {
+}
+
+uint16 ROQPlayer::loadInternal() {
+        // Begin reading the file
+        debugC(1, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Loading video");
+
+        // Read the file header
+        ROQBlockHeader blockHeader;
+        if (!readBlockHeader(blockHeader)) {
+                return 0;
+        }
+        if (blockHeader.type != 0x1084 || blockHeader.size != 0 || blockHeader.param != 0) {
+                return 0;
+        }
+
+        // Hardcoded FPS
+        return 25;
+}
+
+bool ROQPlayer::playFrameInternal() {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Playing frame");
+
+        // Process the needed blocks until the next video frame
+        bool endframe = false;
+        while (!endframe && !_file->eos()) {
+                endframe = processBlock();
+        }
+
+        // Wait until the current frame can be shown
+        waitFrame();
+
+        // Update the screen
+        _syst->updateScreen();
+
+        // Return whether the video has ended
+        return _file->eos();
+}
+
+bool ROQPlayer::readBlockHeader(ROQBlockHeader &blockHeader) {
+        if (_file->eos()) {
+                return false;
+        } else {
+                blockHeader.type = _file->readUint16LE();
+                blockHeader.size = _file->readUint32LE();
+                blockHeader.param = _file->readUint16LE();
+
+                debugC(10, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Block type = 0x%02X", blockHeader.type);
+                debugC(10, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Block size = 0x%08X", blockHeader.size);
+                debugC(10, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Block param = 0x%04X", blockHeader.param);
+
+                return true;
+        }
+}
+
+bool ROQPlayer::processBlock() {
+        // Read the header of the block
+        ROQBlockHeader blockHeader;
+        if (!readBlockHeader(blockHeader)) {
+                return true;
+        }
+
+        bool ok = true;
+        bool endframe = false;
+        switch (blockHeader.type) {
+        case 0x1001: // Video info
+                ok = processBlockInfo(blockHeader);
+                break;
+        case 0x1002: // Quad codebook definition
+                ok = processBlockQuadCodebook(blockHeader);
+                break;
+        case 0x1011: // Quad vector quantised video frame
+                ok = processBlockQuadVector(blockHeader);
+                endframe = true;
+                break;
+        case 0x1012: // Still image (JPEG)
+                ok = processBlockStill(blockHeader);
+                endframe = true;
+                break;
+        case 0x1013: // Hang
+                //warning("Groovie::ROQ: Hang block (skipped)");
+                break;
+        case 0x1020: // Mono sound samples
+                ok = processBlockSoundMono(blockHeader);
+                break;
+        case 0x1021: // Stereo sound samples
+                ok = processBlockSoundStereo(blockHeader);
+                break;
+        case 0x1030: // Audio container
+                ok = processBlockAudioContainer(blockHeader);
+                break;
+        default:
+                error("Groovie::ROQ: Unknown block type: 0x%04X", blockHeader.type);
+                ok = false;
+        }
+
+        // End the frame when the graphics have been modified or when there's an error
+        return endframe || !ok;
+}
+
+bool ROQPlayer::processBlockInfo(ROQBlockHeader &blockHeader) {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Processing info block");
+
+        // Verify the block header
+        if (blockHeader.type != 0x1001 || blockHeader.size != 8 || blockHeader.param != 0) {
+                return false;
+        }
+
+        uint16 tmp;
+        tmp = _file->readUint16LE();
+        printf("w = %d\n", tmp);
+        if (tmp != 640) {
+                return false;
+        }
+        tmp = _file->readUint16LE();
+        printf("h = %d\n", tmp);
+        if (tmp != 320) {
+                return false;
+        }
+        tmp = _file->readUint16LE();
+        printf("unk1 = %d\n", tmp);
+        if (tmp != 8) {
+                return false;
+        }
+        tmp = _file->readUint16LE();
+        printf("unk2 = %d\n", tmp);
+        if (tmp != 4) {
+                return false;
+        }
+        return true;
+}
+
+bool ROQPlayer::processBlockQuadCodebook(ROQBlockHeader &blockHeader) {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Processing quad codebook block");
+
+        // Get the number of 2x2 pixel blocks
+        _num2blocks = blockHeader.param >> 8;
+        if (_num2blocks == 0) {
+                _num2blocks = 256;
+        }
+
+        // Get the number of 4x4 pixel blocks
+        _num4blocks = blockHeader.param & 0xFF;
+        if (_num4blocks == 0 && (blockHeader.size > (uint32)_num2blocks * 6)) {
+                _num4blocks = 256;
+        }
+
+        _file->skip(_num2blocks * 6);
+        _file->skip(_num4blocks * 4);
+
+        return true;
+}
+
+bool ROQPlayer::processBlockQuadVector(ROQBlockHeader &blockHeader) {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Processing quad vector block");
+        _file->skip(blockHeader.size);
+        return true;
+
+        // Get the mean motion vectors
+        byte Mx = blockHeader.param >> 8;
+        byte My = blockHeader.param & 0xFF;
+
+int32 ends =_file->pos() + blockHeader.size;
+        int numblocks = (640 / 8) * (320 / 8);
+        for (int j = 0; j < numblocks && ends > _file->pos(); j++) {
+                printf("doing block %d/%d\n", j, numblocks);
+                uint16 codingType = _file->readUint16LE();
+                for (int i = 0; i < 8; i++) {
+                        switch (codingType >> 14) {
+                        case 0: // MOT: Skip block
+                                //printf("coding type 0\n");
+                                break;
+                        case 1: { // FCC: Copy an existing block
+                                //printf("coding type 1\n");
+                                byte argument = _file->readByte();
+                                byte Dx = Mx + (argument >> 4);
+                                byte Dy = My + (argument & 0x0F);
+                                // Dx = X + 8 - (argument >> 4) - Mx
+                                // Dy = Y + 8 - (argument & 0x0F) - My
+                                break;
+                        }
+                        case 2: { // SLD: Quad vector quantisation
+                                //printf("coding type 2\n");
+                                byte argument = _file->readByte();
+                                if (argument > _num4blocks) {
+                                        //error("invalid 4x4 block %d of %d", argument, _num4blocks);
+                                }
+                                // Upsample the 4x4 pixel block
+                                break;
+                        }
+                        case 3: // CCC: 
+                                //printf("coding type 3:\n");
+                                processBlockQuadVectorSub(blockHeader);
+                                break;
+                        }
+                        codingType <<= 2;
+                }
+        }
+printf("Should have ended at %d, and has ended at %d\n", ends, _file->pos());
+        return true;
+}
+
+bool ROQPlayer::processBlockQuadVectorSub(ROQBlockHeader &blockHeader) {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Processing quad vector sub block");
+
+        // Get the mean motion vectors
+        byte Mx = blockHeader.param >> 8;
+        byte My = blockHeader.param & 0xFF;
+
+        uint16 codingType = _file->readUint16LE();
+        for (int i = 0; i < 4; i++) {
+                switch (codingType >> 14) {
+                case 0: // MOT: Skip block
+                        //printf("coding type 0\n");
+                        break;
+                case 1: { // FCC: Copy an existing block
+                        //printf("coding type 1\n");
+                        byte argument = _file->readByte();
+                        byte Dx = Mx + (argument >> 4);
+                        byte Dy = My + (argument & 0x0F);
+                        // Dx = X + 8 - (argument >> 4) - Mx
+                        // Dy = Y + 8 - (argument & 0x0F) - My
+                        break;
+                }
+                case 2: { // SLD: Quad vector quantisation
+                        //printf("coding type 2\n");
+                        byte argument = _file->readByte();
+                        if (argument > _num2blocks) {
+                                //error("invalid 2x2 block: %d of %d", argument, _num2blocks);
+                        }
+                        break;
+                }
+                case 3:
+                        //printf("coding type 3\n");
+                        _file->readByte();
+                        _file->readByte();
+                        _file->readByte();
+                        _file->readByte();
+                        break;
+                }
+                codingType <<= 2;
+        }
+        return true;
+}
+
+bool ROQPlayer::processBlockStill(ROQBlockHeader &blockHeader) {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Processing still (JPEG) block");
+        Common::ReadStream *jpegData = new Common::SubReadStream(_file, blockHeader.size);
+        JPEG jpegFrame;
+        jpegFrame.read(jpegData);
+        /*
+        Common::File save;
+        save.open("dump.jpg", Common::File::kFileWriteMode);
+        save.write(data, blockHeader.size);
+        save.close();
+        */
+        error("JPEG!");
+        return true;
+}
+
+bool ROQPlayer::processBlockSoundMono(ROQBlockHeader &blockHeader) {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Processing mono sound block");
+
+        // Verify the block header
+        if (blockHeader.type != 0x1020) {
+                return false;
+        }
+
+        // Initialize the audio stream if needed
+        if (!_audioStream) {
+                byte flags = Audio::Mixer::FLAG_16BITS | Audio::Mixer::FLAG_AUTOFREE;
+#ifdef SCUMM_LITTLE_ENDIAN
+                flags |= Audio::Mixer::FLAG_LITTLE_ENDIAN;
+#endif
+                _audioStream = Audio::makeAppendableAudioStream(22050, flags);
+                Audio::SoundHandle sound_handle;
+                ::g_engine->_mixer->playInputStream(Audio::Mixer::kPlainSoundType, &sound_handle, _audioStream);
+        }
+
+        // Create the audio buffer
+        int16 *buffer = new int16[blockHeader.size];
+
+        // Initialize the prediction with the block parameter
+        int16 prediction = blockHeader.param ^ 0x8000;
+
+        // Process the data
+        for (uint16 i = 0; i < blockHeader.size; i++) {
+                int16 data = _file->readByte();
+                if (data < 0x80) {
+                        prediction += data * data;
+                } else {
+                        data -= 0x80;
+                        prediction -= data * data;
+                }
+                buffer[i] = prediction;
+        }
+
+        // Queue the read buffer
+        _audioStream->queueBuffer((byte *)buffer, blockHeader.size * 2);
+
+        return true;
+}
+
+bool ROQPlayer::processBlockSoundStereo(ROQBlockHeader &blockHeader) {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Processing stereo sound block");
+
+        // Verify the block header
+        if (blockHeader.type != 0x1021) {
+                return false;
+        }
+
+        // Initialize the audio stream if needed
+        if (!_audioStream) {
+                byte flags = Audio::Mixer::FLAG_16BITS | Audio::Mixer::FLAG_AUTOFREE | Audio::Mixer::FLAG_STEREO;
+#ifdef SCUMM_LITTLE_ENDIAN
+                flags |= Audio::Mixer::FLAG_LITTLE_ENDIAN;
+#endif
+                _audioStream = Audio::makeAppendableAudioStream(22050, flags);
+                Audio::SoundHandle sound_handle;
+                ::g_engine->_mixer->playInputStream(Audio::Mixer::kPlainSoundType, &sound_handle, _audioStream);
+        }
+
+        // Create the audio buffer
+        int16 *buffer = new int16[blockHeader.size];
+
+        // Initialize the prediction with the block parameter
+        int16 predictionLeft = (blockHeader.param & 0xFF00) ^ 0x8000;
+        int16 predictionRight = (blockHeader.param << 8) ^ 0x8000;
+        bool left = true;
+
+        // Process the data
+        for (uint16 i = 0; i < blockHeader.size; i++) {
+                int16 data = _file->readByte();
+                if (left) {
+                        if (data < 0x80) {
+                                predictionLeft += data * data;
+                        } else {
+                                data -= 0x80;
+                                predictionLeft -= data * data;
+                        }
+                        buffer[i] = predictionLeft;
+                } else {
+                        if (data < 0x80) {
+                                predictionRight += data * data;
+                        } else {
+                                data -= 0x80;
+                                predictionRight -= data * data;
+                        }
+                        buffer[i] = predictionRight;
+                }
+                left = !left;
+        }
+
+        // Queue the read buffer
+        _audioStream->queueBuffer((byte *)buffer, blockHeader.size * 2);
+
+        return true;
+}
+
+bool ROQPlayer::processBlockAudioContainer(ROQBlockHeader &blockHeader) {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::ROQ: Processing audio container block: 0x%04X", blockHeader.param);
+        return true;
+}
+
+} // End of Groovie namespace

engines/groovie/vdx.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 "groovie/groovie.h"
+#include "groovie/lzss.h"
+#include "groovie/vdx.h"
+
+#include "sound/mixer.h"
+
+#define TILE_SIZE 4             // Size of each tile on the image: only ever seen 4 so far
+#define VDX_IDENT 0x9267        // 37479
+
+namespace Groovie {
+
+VDXPlayer::VDXPlayer(GroovieEngine *vm) :
+        VideoPlayer(vm), _origX(0), _origY(0), _flagOnePrev(false),
+        _fg(&_vm->_graphicsMan->_foreground), _bg(&_vm->_graphicsMan->_background) {
+}
+
+VDXPlayer::~VDXPlayer() {
+        //delete _audioStream;
+}
+
+void VDXPlayer::setOrigin(int16 x, int16 y) {
+        _origX = x;
+        _origY = y;
+}
+
+uint16 VDXPlayer::loadInternal() {
+        uint32 engine_level = kGroovieDebugVideo | kGroovieDebugAll;
+        if ((gDebugLevel == 11) || (Common::getEnabledSpecialDebugLevels() & engine_level)) {
+                int8 i;
+                debugN(1, "Groovie::VDX: New VDX: bitflags are ");
+                for (i = 11; i >= 0; i--) {
+                        debugN(1, "%d", _flags & (1 << i)? 1 : 0);
+                        if (i % 4 == 0) {
+                                debugN(1, " ");
+                        }
+                }
+                debug(1, " ");
+        }
+        // Flags:
+        // - 1 Puzzle piece? Skip palette, don't redraw full screen, draw still to b/ack buffer
+        // - 2 Transparent colour is 0xFF
+        // - 5 Skip still chunks
+        // - 7 
+        // - 8 Just show the first frame
+        // - 9 Start a palette fade in
+        _flagZero =             ((_flags & (1 << 0)) != 0);
+        _flagOne =              ((_flags & (1 << 1)) != 0);
+        _flag2Byte =            (_flags & (1 << 2)) ? 0xFF : 0x00;
+        _flagThree =            ((_flags & (1 << 3)) != 0);
+        _flagFour =             ((_flags & (1 << 4)) != 0);
+        _flagFive =             ((_flags & (1 << 5)) != 0);
+        _flagSix =              ((_flags & (1 << 6)) != 0);
+        _flagSeven =            ((_flags & (1 << 7)) != 0);
+        _flagEight =            ((_flags & (1 << 8)) != 0);
+        _flagNine =             ((_flags & (1 << 9)) != 0);
+
+        if (_flagOnePrev && !_flagOne && !_flagEight) {
+                _flagSeven = true;
+        }
+
+        // Save _flagOne for the next video
+        _flagOnePrev = _flagOne;
+
+        //_flagTransparent =    _flagOne;
+        _flagFirstFrame =       _flagEight;
+        //_flagSkipPalette =    _flagSeven;
+        _flagSkipPalette =      false;
+        //_flagSkipStill =      _flagFive || _flagSeven;
+        //_flagUpdateStill =    _flagNine || _flagSix;
+
+        // Begin reading the file
+        debugC(1, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::VDX: Playing video");
+
+        if (_file->readUint16LE() != VDX_IDENT) {
+                error("Groovie::VDX: This does not appear to be a 7th guest vxd file");
+                return 0;
+        } else {
+                debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::VDX: VDX file identified correctly");
+        }
+
+        uint16 tmp;
+
+        // Skip unknown data: 6 bytes, ref Martine
+        tmp = _file->readUint16LE();
+        debugC(2, kGroovieDebugVideo | kGroovieDebugUnknown | kGroovieDebugAll, "Groovie::VDX: Martine1 = 0x%04X", tmp);
+        tmp = _file->readUint16LE();
+        debugC(2, kGroovieDebugVideo | kGroovieDebugUnknown | kGroovieDebugAll, "Groovie::VDX: Martine2 = 0x%04X", tmp);
+        tmp = _file->readUint16LE();
+        debugC(2, kGroovieDebugVideo | kGroovieDebugUnknown | kGroovieDebugAll, "Groovie::VDX: Martine3 (FPS?) = %d", tmp);
+
+        return tmp;
+}
+
+bool VDXPlayer::playFrameInternal() {
+        byte currRes = 0x80;
+        while (!_file->eos() && currRes == 0x80) {
+                currRes = _file->readByte();
+
+                // Skip unknown data: 1 byte, ref Edward
+                byte tmp = _file->readByte();
+                debugC(5, kGroovieDebugVideo | kGroovieDebugUnknown | kGroovieDebugAll, "Groovie::VDX: Edward = 0x%04X", tmp);
+
+                uint32 compSize = _file->readUint32LE();
+                uint8 lengthmask = _file->readByte();
+                uint8 lengthbits = _file->readByte();
+
+                // Read the chunk data and decompress if needed
+                Common::ReadStream *vdxData = new Common::SubReadStream(_file, compSize);
+                if (lengthmask && lengthbits) {
+                        Common::ReadStream *decompData = new LzssReadStream(vdxData, lengthmask, lengthbits);
+                        delete vdxData;
+                        vdxData = decompData;
+                }
+
+                // Use the current chunk
+                switch (currRes) {
+                        case 0x00:
+                                debugC(6, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::VDX: Replay frame");
+                                break;
+                        case 0x20:
+                                debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::VDX: Still frame");
+                                getStill(vdxData);
+                                break;
+                        case 0x25:
+                                debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::VDX: Animation frame");
+                                getDelta(vdxData);
+                                break;
+                        case 0x80:
+                                debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::VDX: Sound resource");
+                                chunkSound(vdxData);
+                                break;
+                        default:
+                                error("Groovie::VDX: Invalid resource type: %d", currRes);
+                }
+                delete vdxData;
+        }
+
+        // Wait until the current frame can be shown
+        waitFrame();
+
+        // TODO: Move it to a better place
+        // Update the screen
+        if (currRes == 0x25) {
+                //if (_flagSeven) {
+                        //_vm->_graphicsMan->mergeFgAndBg();
+                //}
+                _vm->_graphicsMan->updateScreen(_bg);
+        }
+
+        // Report the end of the video if we reached the end of the file or if we
+        // just wanted to play one frame.
+        return _file->eos() || _flagFirstFrame;
+}
+
+static const uint16 vdxBlockMapLookup[] = {
+0xc800, 0xec80, 0xfec8, 0xffec, 0xfffe, 0x3100, 0x7310, 0xf731, 0xff73, 0xfff7, 0x6c80, 0x36c8, 0x136c, 0x6310, 0xc631, 0x8c63,
+0xf000, 0xff00, 0xfff0, 0x1111, 0x3333, 0x7777, 0x6666, 0xcccc, 0x0ff0, 0x00ff, 0xffcc, 0x0076, 0xff33, 0x0ee6, 0xccff, 0x6770,
+0x33ff, 0x6ee0, 0x4800, 0x2480, 0x1248, 0x0024, 0x0012, 0x2100, 0x4210, 0x8421, 0x0042, 0x0084, 0xf888, 0x0044, 0x0032, 0x111f,
+0x22e0, 0x4c00, 0x888f, 0x4470, 0x2300, 0xf111, 0x0e22, 0x00c4, 0xf33f, 0xfccf, 0xff99, 0x99ff, 0x4444, 0x2222, 0xccee, 0x7733,
+0x00f8, 0x00f1, 0x00bb, 0x0cdd, 0x0f0f, 0x0f88, 0x13f1, 0x19b3, 0x1f80, 0x226f, 0x27ec, 0x3077, 0x3267, 0x37e4, 0x38e3, 0x3f90,
+0x44cf, 0x4cd9, 0x4c99, 0x5555, 0x603f, 0x6077, 0x6237, 0x64c9, 0x64cd, 0x6cd9, 0x70ef, 0x0f00, 0x00f0, 0x0000, 0x4444, 0x2222
+};
+
+void VDXPlayer::getDelta(Common::ReadStream *in) {
+        uint16 j, k, l;
+        uint32 offset;
+        uint8 currOpCode, param1, param2, param3;
+
+        // Get the size of the local palette
+        j = in->readUint16LE();
+
+        // Load the palette if it isn't empty
+        if (j) {
+                uint16 palBitField[16];
+                int flag = 1, palIndex;
+
+                // Load the bit field
+                for (l = 0; l < 16; l++) {
+                        palBitField[l] = in->readUint16LE();
+                }
+
+                // Load the actual palette
+                for (l = 0; l < 16; l++) {
+                        flag = 1 << 15;
+                        for (j = 0; j < 16; j++) {
+                                palIndex = (l * 16) + j;
+
+                                if (flag & palBitField[l]) {
+                                        for (k = 0; k < 3; k++) {
+                                                _palBuf[(palIndex * 3) + k] = in->readByte();
+                                        }
+                                }
+                                flag = flag >> 1;
+                        }
+                }
+
+                // Apply the palette
+                if (!_flagSix && !_flagSeven) {
+                        setPalette(_palBuf);
+                }
+        }
+        currOpCode = in->readByte();
+
+        /* j now becomes the current block line we're dealing with */
+        j = 0;
+        offset = 0;
+        while (!in->eos()) {
+                byte colours[16];
+                if (currOpCode < 0x60) {
+                        param1 = in->readByte();
+                        param2 = in->readByte();
+                        expandColourMap(colours, vdxBlockMapLookup[currOpCode], param1, param2);
+                        decodeBlockDelta(offset, colours, 640);
+                        offset += TILE_SIZE;
+                } else if (currOpCode > 0x7f) {
+                        param1 = in->readByte();
+                        param2 = in->readByte();
+                        param3 = in->readByte();
+                        expandColourMap(colours, (param1 << 8) + currOpCode, param2, param3);
+                        decodeBlockDelta(offset, colours, 640);
+                        offset += TILE_SIZE;
+                } else switch (currOpCode) {
+                        case 0x60: /* Fill tile with the 16 colours given as parameters */
+                                for (l = 0; l < 16; l++) {
+                                        colours[l] = in->readByte();
+                                }
+                                decodeBlockDelta(offset, colours, 640);
+                                offset += TILE_SIZE;
+                                break;
+                        case 0x61: /* Skip to the end of this line, next block is start of next */
+                                /* Note this is used at the end of EVERY line */
+                                j++;
+                                offset = j * TILE_SIZE * 640;
+                                break;
+                        case 0x62:
+                        case 0x63:
+                        case 0x64:
+                        case 0x65:
+                        case 0x66:
+                        case 0x67:
+                        case 0x68:
+                        case 0x69:
+                        case 0x6a:
+                        case 0x6b: /* Skip next param1 blocks (within line) */
+                                offset += (currOpCode - 0x62) * TILE_SIZE;
+                                break;
+                        case 0x6c:
+                        case 0x6d:
+                        case 0x6e:
+                        case 0x6f:
+                        case 0x70:
+                        case 0x71:
+                        case 0x72:
+                        case 0x73:
+                        case 0x74:
+                        case 0x75: /* Next param1 blocks are filled with colour param2 */
+                                param1 = currOpCode - 0x6b;
+                                param2 = in->readByte();
+                                for (l = 0; l < 16; l++) {
+                                        colours[l] = param2;
+                                }
+                                for (k = 0; k < param1; k++) {
+                                        decodeBlockDelta(offset, colours, 640);
+                                        offset += TILE_SIZE;
+                                }
+                                break;
+                        case 0x76:
+                        case 0x77:
+                        case 0x78:
+                        case 0x79:
+                        case 0x7a:
+                        case 0x7b:
+                        case 0x7c:
+                        case 0x7d:
+                        case 0x7e:
+                        case 0x7f: /* Next bytes contain colours to fill the next param1 blocks in the current line*/
+                                param1 = currOpCode - 0x75;
+                                for (k = 0; k < param1; k++) {
+                                        param2 = in->readByte();
+                                        for (l = 0; l < 16; l++) {
+                                                colours[l] = param2;
+                                        }
+                                        decodeBlockDelta(offset, colours, 640);
+                                        offset += TILE_SIZE;
+                                }
+                                break;
+                        default:
+                                error("Groovie::VDX: Broken somehow");
+                }
+                currOpCode = in->readByte();
+        }
+}
+
+void VDXPlayer::getStill(Common::ReadStream *in) {
+        uint16 numXTiles = in->readUint16LE();
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::VDX: numXTiles=%d", numXTiles);
+        uint16 numYTiles = in->readUint16LE();
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::VDX: numYTiles=%d", numYTiles);
+
+        // It's skipped in the original:
+        uint16 colourDepth = in->readUint16LE();
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::VDX: colourDepth=%d", colourDepth);
+
+        uint16 imageWidth = TILE_SIZE * numXTiles;
+
+        uint8 mask = 0;
+        byte *buf;
+        if (_flagOne) {
+                // Paint to the foreground
+                buf = (byte *)_fg->getBasePtr(0, 0);
+                if (_flag2Byte) {
+                        mask = 0xff;
+                } else {
+                        mask = 0;
+                }
+
+                // TODO: Verify this is the right procedure. Couldn't find it on the
+                // disassembly, but it's required to work properly
+                _flagFirstFrame = true;
+        } else {
+                // Paint to the background
+                buf = (byte *)_bg->getBasePtr(0, 0);
+        }
+
+        // Read the palette
+        in->read(_palBuf, 3 * 256);
+
+        if (_flagSeven) {
+                _flagFive = true;
+        }
+
+        // Skip the frame when flag 5 is set, unless flag 1 is set
+        if (!_flagFive || _flagOne) {
+
+                byte colours[16];
+                for (uint16 j = 0; j < numYTiles; j++) {
+                        for (uint16 i = 0; i < numXTiles; i++) { /* Tile number */
+                                uint8 colour1 = in->readByte();
+                                uint8 colour0 = in->readByte();
+                                uint16 colourMap = in->readUint16LE();
+                                expandColourMap(colours, colourMap, colour1, colour0);
+                                decodeBlockStill(buf + j * TILE_SIZE * imageWidth + i * TILE_SIZE, colours, 640, mask);
+                        }
+                }
+
+                // Apply the palette
+                if (_flagNine) {
+                        // Flag 9 starts a fade in
+                        fadeIn(_palBuf);
+                } else {
+                        if (!_flagOne && !_flagSeven) {
+                                // Actually apply the palette
+                                setPalette(_palBuf);
+                        }
+                }
+
+                if (!_flagOne) {
+                        _vm->_graphicsMan->updateScreen(_bg);
+                }
+                /*
+                if (_flagSix) {
+                        if (_flagOne) {
+                                _vm->_graphicsMan->updateScreen(_fg);
+                        } else {
+                                _vm->_graphicsMan->updateScreen(_bg);
+                        }
+                        _flagSix = 0;
+                }
+                */
+        } else {
+                // Skip the remaining data
+                debugC(10, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::VDX: Skipping still frame");
+                while (!in->eos()) {
+                        in->readByte();
+                }
+        }
+}
+
+void VDXPlayer::expandColourMap(byte *out, uint16 colourMap, uint8 colour1, uint8 colour0) {
+        int flag = 1 << 15;
+        for (int i = 0; i < 16; i++) {
+                // Set the corresponding colour
+                out[i] = (colourMap & flag) ? colour1 : colour0;
+
+                // Update the flag to test the next colour
+                flag >>= 1;
+        }
+}
+
+void VDXPlayer::decodeBlockStill(byte *buf, byte *colours, uint16 imageWidth, uint8 mask) {
+        for (int y = 0; y < TILE_SIZE; y++) {
+                for (int x = 0; x < TILE_SIZE; x++) {
+                        if (_flagOne) {
+                                // 0xff pixels don't modify the buffer
+                                if (*colours != 0xff) {
+                                        // Write the colour
+                                        *buf = *colours | mask;
+                                        // Note: if the mask is 0, it paints the image
+                                        // else, it paints the image's mask using 0xff
+                                }
+                        } else {
+                                *buf = *colours;
+                        }
+
+                        // Point to the next colour
+                        colours++;
+
+                        // Point to the next pixel
+                        buf++;
+                }
+
+                // Point to the start of the next line
+                buf += imageWidth - TILE_SIZE;
+        }
+}
+
+void VDXPlayer::decodeBlockDelta(uint32 offset, byte *colours, uint16 imageWidth) {
+        byte *fgBuf = (byte *)_fg->getBasePtr(0, 0) + offset;
+        //byte *bgBuf = (byte *)_bg->getBasePtr(0, 0) + offset;
+
+        byte *dest;
+        // TODO: Verify just the else block is required
+        //if (_flagOne) {
+                // Paint to the foreground
+                //dest = (byte *)_fg->getBasePtr(0, 0) + offset;
+        //} else {
+                dest = (byte *)_bg->getBasePtr(0, 0) + offset;
+        //}
+
+        int32 off = _origX + _origY * imageWidth;
+        for (int y = 0; y < TILE_SIZE; y++) {
+                for (int x = 0; x < TILE_SIZE; x++) {
+                        if (_flagSeven) {
+                                if (fgBuf[off] != 0xff) {
+                                        if (*colours == 0xff) {
+                                                dest[off] = fgBuf[off];
+                                        } else {
+                                                dest[off] = *colours;
+                                        }
+                                }
+                        } else {
+                                // Paint directly
+                                dest[off] = *colours;
+                        }
+                        colours++;
+                        off++;
+                }
+
+                // Prepare the offset of the next line
+                off += imageWidth - TILE_SIZE;
+        }
+}
+
+void VDXPlayer::chunkSound(Common::ReadStream *in) {
+        if (!_audioStream) {
+                _audioStream = Audio::makeAppendableAudioStream(22050, Audio::Mixer::FLAG_UNSIGNED | Audio::Mixer::FLAG_AUTOFREE);
+                Audio::SoundHandle sound_handle;
+                ::g_engine->_mixer->playInputStream(Audio::Mixer::kPlainSoundType, &sound_handle, _audioStream);
+        }
+
+        byte *data = new byte[60000];
+        int chunksize = in->read(data, 60000);
+        _audioStream->queueBuffer(data, chunksize);
+}
+
+void VDXPlayer::fadeIn(uint8 *targetpal) {
+        // Don't do anything if we're asked to skip palette changes
+        if (_flagSkipPalette)
+                return;
+
+        // TODO: Is it required? If so, move to an appropiate place
+        // Copy the foreground to the background
+        memcpy((byte *)_vm->_graphicsMan->_foreground.getBasePtr(0, 0), (byte *)_vm->_graphicsMan->_background.getBasePtr(0, 0), 640 * 320);
+
+        // Start a fadein
+        _vm->_graphicsMan->fadeIn(targetpal);
+
+        // Show the background
+        _vm->_graphicsMan->updateScreen(_bg);
+}
+
+void VDXPlayer::setPalette(uint8 *palette) {
+        if (_flagSkipPalette)
+                return;
+
+        uint8 palBuf[4 * 256];
+        debugC(7, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::VDX: Setting palette");
+        for (int i = 0; i < 256; i++) {
+                palBuf[(i * 4) + 0] = palette[(i * 3) + 0];
+                palBuf[(i * 4) + 1] = palette[(i * 3) + 1];
+                palBuf[(i * 4) + 2] = palette[(i * 3) + 2];
+                palBuf[(i * 4) + 3] = 0;
+        }
+        _syst->setPalette(palBuf, 0, 256);
+}
+
+} // End of Groovie namespace

engines/groovie/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 GROOVIE_PLAYER_H
+#define GROOVIE_PLAYER_H
+
+#include "common/system.h"
+#include "sound/audiostream.h"
+
+namespace Groovie {
+
+class GroovieEngine;
+
+class VideoPlayer {
+public:
+        VideoPlayer(GroovieEngine *vm);
+        virtual ~VideoPlayer() {}
+
+        bool load(Common::SeekableReadStream *file, uint16 flags);
+        bool playFrame();
+        virtual void setOrigin(int16 x, int16 y) {};
+
+protected:
+        // To be implemented by subclasses
+        virtual uint16 loadInternal() = 0;
+        virtual bool playFrameInternal() = 0;
+
+        GroovieEngine *_vm;
+        OSystem *_syst;
+        Common::SeekableReadStream *_file;
+        uint16 _flags;
+        Audio::AppendableAudioStream *_audioStream;
+
+private:
+        // Synchronization stuff
+        bool _begunPlaying;
+        uint16 _millisBetweenFrames;
+        uint32 _lastFrameTime;
+
+protected:
+        void waitFrame();
+};
+
+} // End of Groovie namespace
+
+#endif // GROOVIE_PLAYER_H

engines/groovie/script.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 "groovie/debug.h"
+#include "groovie/music.h"
+#include "groovie/script.h"
+#include "groovie/groovie.h"
+
+#include "common/config-manager.h"
+#include "common/endian.h"
+#include "common/events.h"
+#include "common/savefile.h"
+#include "sound/audiocd.h"
+
+#define NUM_OPCODES 90
+
+namespace Groovie {
+
+void debugScript(int level, bool nl, const char *s, ...) {
+        char buf[STRINGBUFLEN];
+        va_list va;
+
+        uint32 engine_level = kGroovieDebugScript | kGroovieDebugAll;
+        if (gDebugLevel != 11)
+                if (!(Common::getEnabledSpecialDebugLevels() & engine_level))
+                        return;
+
+        va_start(va, s);
+        vsnprintf(buf, STRINGBUFLEN, s, va);
+        va_end(va);
+
+        if (nl)
+                debug(level, buf);
+        else
+                debugN(level, buf);
+}
+
+Script::Script(GroovieEngine *vm) :
+        _code(NULL), _savedCode(NULL), _stacktop(0),
+        _debugger(NULL), _error(false), _vm(vm),
+        _videoFile(NULL), _videoRef(0), _font(NULL) {
+        // Initialize the random source
+        _vm->_system->getEventManager()->registerRandomSource(_random, "GroovieScripts");
+
+        // Prepare the variables
+        _bitflags = 0;
+        for (int i = 0; i < 0x400; i++) {
+                _variables[i] = 0;
+        }
+
+        // Initialize the music type variable
+        int midiDriver = MidiDriver::detectMusicDriver(MDT_MIDI | MDT_ADLIB | MDT_PREFER_MIDI);
+        if (midiDriver == MD_ADLIB) {
+                // MIDI through AdLib
+                _variables[0x100] = 0;
+        } else  if ((midiDriver == MD_MT32) || ConfMan.getBool("native_mt32")) {
+                // MT-32
+                _variables[0x100] = 2;
+        } else {
+                // GM
+                _variables[0x100] = 1;
+        }
+
+        _hotspotTopAction = 0;
+        _hotspotBottomAction = 0;
+        _hotspotRightAction = 0;
+        _hotspotLeftAction = 0;
+        _hotspotCursorOldX = 1000;
+        _hotspotCursorOldY = 1000;
+}
+
+Script::~Script() {
+        delete[] _code;
+        delete[] _savedCode;
+
+        delete _font;
+        delete _videoFile;
+}
+
+void Script::setDebugger(Debugger *debugger) {
+        _debugger = debugger;
+}
+
+bool Script::loadScript(Common::String filename) {
+        // Try to open the script file
+        Common::File scriptfile;
+        if (!scriptfile.open(filename)) {
+                return false;
+        }
+
+        // Save the script filename
+        _scriptFile = filename;
+
+        // Load the code
+        _code = new byte[0x10000];
+        scriptfile.read(_code, 0x10000);
+        scriptfile.close();
+
+        // Initialize the script
+        _currentInstruction = 0;
+
+        return true;
+}
+
+void Script::directGameLoad(int slot) {
+        // Reject invalid slots
+        if (slot < 0 || slot > 9) {
+                return;
+        }
+
+        // TODO: Return to the main script, likely reusing most of o_returnscript()
+
+        // HACK: We set variable 0x19 to the slot to load, and set the current
+        // instruction to the one that actually loads the saved game specified
+        // in that variable. This will change in other versions of the game and
+        // in other games.
+        _variables[0x19] = slot;
+        _currentInstruction = 0x287;
+
+        // TODO: We'll probably need to start by running the beginning of the
+        // script to let it do the soundcard initialization and then do the
+        // actual loading.
+}
+
+void Script::step() {
+        // Reset the error status
+        _error = false;
+
+        // Prepare the base debug string
+        char debugstring[10];
+        sprintf(debugstring, "@0x%04X: ", _currentInstruction);
+        _debugString = _scriptFile + debugstring;
+
+        // Get the current opcode
+        byte opcode = readScript8bits();
+        _firstbit = ((opcode & 0x80) != 0);
+        opcode = opcode & 0x7F;
+
+        // Show the opcode debug string
+        sprintf(debugstring, "op 0x%02X: ", opcode);
+        _debugString += debugstring;
+        debugScript(1, false, _debugString.c_str());
+
+        // Detect invalid opcodes
+        if (opcode >= NUM_OPCODES) {
+                o_invalid();
+                return;
+        }
+
+        // Execute the current opcode
+        OpcodeFunc op = _opcodes[opcode];
+        (this->*op)();
+}
+
+void Script::setMouseClick() {
+        _eventMouseClicked = true;
+}
+
+void Script::setKbdChar(uint8 c) {
+        _eventKbdChar = c;
+}
+
+bool Script::haveError() {
+        return _error;
+}
+
+void Script::error(const char *msg) {
+        // Prepend the debugging info to the error
+        Common::String msg2 = _debugString + msg;
+
+        // Print the error message
+        printf("ERROR: %s\n", msg2.c_str());
+
+        // Show it in the debugger
+        _debugger->attach(msg2.c_str());
+
+        // Set the error state
+        _error = true;
+}
+
+uint8 Script::readScript8bits() {
+        uint8 data = _code[_currentInstruction];
+        _currentInstruction++;
+        return data;
+}
+
+uint8 Script::readScriptVar() {
+        uint8 data = _variables[readScript8or16bits()];
+        return data;
+}
+
+uint16 Script::readScript16bits() {
+        uint16 data = READ_LE_UINT16(_code + _currentInstruction);
+        _currentInstruction += 2;
+        return data;
+}
+
+uint32 Script::readScript32bits() {
+        uint32 data = READ_LE_UINT32(_code + _currentInstruction);
+        _currentInstruction += 4;
+        return data;
+}
+
+uint16 Script::readScript8or16bits() {
+        if (_firstbit) {
+                return readScript8bits();
+        } else {
+                return readScript16bits();
+        }
+}
+
+uint8 Script::readScriptChar(bool allow7C, bool limitVal, bool limitVar) {
+        uint8 result;
+        uint8 data = readScript8bits();
+        if (limitVal) {
+                data &= 0x7F;
+        }
+
+        if (allow7C && (data == 0x7C)) {
+                // Index a bidimensional array
+                uint8 parta, partb;
+                parta = readScriptChar(false, false, false);
+                partb = readScriptChar(false, true, true);
+                result = _variables[0x0A * parta + partb + 0x19];
+        } else if (data == 0x23) {
+                // Index an array
+                data = readScript8bits();
+                if (limitVar) {
+                        data &= 0x7F;
+                }
+                result = _variables[data - 0x61];
+        } else {
+                // Immediate value
+                result = data - 0x30;
+        }
+        return result;
+}
+
+uint16 Script::getVideoRefString() {
+        Common::String str;
+        byte c;
+        while ((c = readScript8bits())) {
+                switch (c) {
+                case 0x23:
+                        c = readScript8bits();
+                        c = _variables[c - 0x61] + 0x30;
+                        if (c >= 0x41 && c <= 0x5A) {
+                                c += 0x20;
+                        }
+                        break;
+                case 0x7C:
+                        uint8 parta, partb;
+                        parta = readScriptChar(false, false, false);
+                        partb = readScriptChar(false, false, false);
+                        c = _variables[0x0A * parta + partb + 0x19] + 0x30;
+                        break;
+                default:
+                        if (c >= 0x41 && c <= 0x5A) {
+                                c += 0x20;
+                        }
+                }
+                // Append the current character at the end of the string
+                str += c;
+        }
+
+        // Add a trailing dot
+        str += 0x2E;
+
+        debugScript(0, false, "%s", str.c_str());
+
+        // Extract the script name.
+        Common::String scriptname(_scriptFile.c_str(), _scriptFile.size() - 4);
+
+        // Get the fileref of the resource
+        return _vm->_resMan->getRef(str, scriptname);
+}
+
+bool Script::hotspot(Common::Rect rect, uint16 address, uint8 cursor) {
+        // Test if the current mouse position is contained in the specified rectangle
+        Common::Point mousepos = _vm->_system->getEventManager()->getMousePos();
+        bool contained = rect.contains(mousepos);
+
+        // Show hotspots when debugging
+        if (Common::getEnabledSpecialDebugLevels() & (kGroovieDebugHotspots | kGroovieDebugAll)) {
+                rect.translate(0, -80);
+                _vm->_graphicsMan->_foreground.frameRect(rect, 250);
+                _vm->_system->copyRectToScreen((byte*)_vm->_graphicsMan->_foreground.getBasePtr(0, 0), 640, 0, 80, 640, 320);
+                _vm->_system->updateScreen();
+        }
+
+        // If there's an already planned action, do nothing
+        if (_inputAction != -1) {
+                return false;
+        }
+
+        if (contained) {
+                // Change the mouse cursor
+                if (_newCursorStyle == 5) {
+                        _newCursorStyle = cursor;
+                }
+
+                // If clicked with the mouse, jump to the specified address
+                if (_mouseClicked) {
+                        _inputAction = address;
+                }
+        }
+
+        return contained;
+}
+
+void Script::loadgame(uint slot) {
+        Common::String filename = ConfMan.getActiveDomainName() + ".00" + ('0' + slot);
+        Common::InSaveFile *file = _vm->_system->getSavefileManager()->openForLoading(filename.c_str());
+
+        // Loading the variables. It is endian safe because they're byte variables
+        file->read(_variables, 0x400);
+
+        delete file;
+}
+
+void Script::savegame(uint slot) {
+        Common::String filename = ConfMan.getActiveDomainName() + ".00" + ('0' + slot);
+        Common::OutSaveFile *file = _vm->_system->getSavefileManager()->openForSaving(filename.c_str());
+
+        // Saving the variables. It is endian safe because they're byte variables
+        file->write(_variables, 0x400);
+
+        delete file;
+}
+
+// OPCODES
+
+void Script::o_invalid() {
+        error("Invalid opcode");
+}
+
+void Script::o_nop() {
+        debugScript(1, true, "NOP");
+}
+
+void Script::o_nop8() {
+        uint8 tmp = readScript8bits();
+        debugScript(1, true, "NOP8: 0x%02X", tmp);
+}
+
+void Script::o_nop16() {
+        uint16 tmp = readScript16bits();
+        debugScript(1, true, "NOP16: 0x%04X", tmp);
+}
+
+void Script::o_nop32() {
+        uint32 tmp = readScript32bits();
+        debugScript(1, true, "NOP32: 0x%08X", tmp);
+}
+
+void Script::o_nop8or16() {
+        uint16 tmp = readScript8or16bits();
+        debugScript(1, true, "NOP8OR16: 0x%04X", tmp);
+}
+
+void Script::o_playsong() {                     // 0x02
+        uint16 fileref = readScript16bits();
+        debugScript(1, true, "PlaySong(0x%04X): Play xmidi file", fileref);
+        if (fileref == 0x4C17) {
+                warning("this song is special somehow");
+                // don't save the reference?
+        }
+        _vm->_musicPlayer->playSong(fileref);
+}
+
+void Script::o_bf9on() {                        // 0x03
+        debugScript(1, true, "BF9ON: bitflag 9 turned on");
+        _bitflags |= 1 << 9;
+}
+
+void Script::o_palfadeout() {
+        debugScript(1, true, "PALFADEOUT");
+        _vm->_graphicsMan->fadeOut();
+}
+
+void Script::o_bf8on() {                        // 0x05
+        debugScript(1, true, "BF8ON: bitflag 8 turned on");
+        _bitflags |= 1 << 8;
+}
+
+void Script::o_bf6on() {                        // 0x06
+        debugScript(1, true, "BF6ON: bitflag 6 turned on");
+        _bitflags |= 1 << 6;
+}
+
+void Script::o_bf7on() {                        // 0x07
+        debugScript(1, true, "BF7ON: bitflag 7 turned on");
+        _bitflags |= 1 << 7;
+}
+
+void Script::o_setbackgroundsong() {                    // 0x08
+        uint16 fileref = readScript16bits();
+        debugScript(1, true, "SetBackgroundSong(0x%04X)", fileref);
+        _vm->_musicPlayer->setBackgroundSong(fileref);
+}
+
+void Script::o_videofromref() {                 // 0x09
+        uint16 fileref = readScript16bits();
+
+        // Show the debug information just when starting the playback
+        if (fileref != _videoRef) {
+                debugScript(1, false, "VIDEOFROMREF(0x%04X) (Not fully imp): Play video file from ref", fileref);
+                debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Playing video 0x%04X via 0x09", fileref);
+        }
+        switch (fileref) {
+        case 0x1C03:    // Trilobyte logo
+        case 0x1C04:    // Virgin logo
+        case 0x1C05:    // Credits
+                if (fileref != _videoRef) {
+                        debugScript(1, true, "Use external file if available");
+                }
+                break;
+                
+        case 0x400D:    // floating objects in music room
+        case 0x5060:    // a sound from gamwav?
+        case 0x5098:    // a sound from gamwav?
+        case 0x2402:    // House becomes book in intro?
+        case 0x1426:    // Turn to face front in hall: played after intro
+        case 0x206D:    // Cards on table puzzle (bedroom)
+        case 0x2001:    // Coins on table puzzle (bedroom)
+                if (fileref != _videoRef) {
+                        debugScript(1, false, " (This video is special somehow!)");
+                        warning("(This video is special somehow!)");
+                        printf("Special vid: 0x%04X\n", fileref);
+                }
+        }
+        if (fileref != _videoRef) {
+                debugScript(1, true, "");
+        }
+        // Play the video
+        if (!playvideofromref(fileref)) {
+                // Move _currentInstruction back
+                _currentInstruction -= 3;
+        }
+}
+
+bool Script::playvideofromref(uint16 fileref) {
+        // It isn't the current video, open it
+        if (fileref != _videoRef) {
+
+                // Debug bitflags
+                debugScript(1, false, "Play video 0x%04X (bitflags:", fileref);
+                for (int i = 10; i >= 0; i--) {
+                        debugScript(1, false, "%d", _bitflags & (1 << i)? 1 : 0);
+                }
+                debugScript(1, true, ")");
+
+                // Close the previous video file
+                if (_videoFile) {
+                        _videoRef = 0;
+                        delete _videoFile;
+                }
+
+                // Try to open the new file
+                _videoFile = _vm->_resMan->open(fileref);
+
+                if (_videoFile) {
+                        _videoRef = fileref;
+                        _vm->_videoPlayer->load(_videoFile, _bitflags);
+                } else {
+                        error("Couldn't open file");
+                        return true;
+                }
+
+                _bitflags = 0;
+        }
+
+        // Video available, play one frame
+        if (_videoFile) {
+                bool endVideo = _vm->_videoPlayer->playFrame();
+
+                if (endVideo) {
+                        // Close the file
+                        delete _videoFile;
+                        _videoFile = NULL;
+                        _videoRef = 0;
+
+                        // Clear the input events while playing the video
+                        _eventMouseClicked = false;
+                        _eventKbdChar = 0;
+
+                        // Newline
+                        debugScript(1, true, "");
+                }
+
+                // Let the caller know if the video has ended
+                return endVideo;
+        }
+
+        // If the file is closed, finish the playback
+        return true;
+}
+
+void Script::o_bf5on() {                        // 0x0A
+        debugScript(1, true, "BF5ON: bitflag 5 turned on");
+        _bitflags |= 1 << 5;
+}
+
+void Script::o_inputloopstart() {
+        debugScript(5, true, "Input loop start");
+
+        // Reset the input action and the mouse cursor
+        _inputAction = -1;
+        _newCursorStyle = 5;
+
+        // Save the input loop address
+        _inputLoopAddress = _currentInstruction - 1;
+
+        // Save the current mouse state for the whole loop
+        _mouseClicked = _eventMouseClicked;
+        _eventMouseClicked = false;
+
+        // Save the current pressed character for the whole loop
+        _kbdChar = _eventKbdChar;
+        _eventKbdChar = 0;
+}
+
+void Script::o_keyboardaction() {
+        uint8 val = readScript8bits();
+        uint16 address = readScript16bits();
+        debugScript(5, true, "Test key == 0x%02X @0x%04X", val, address);
+
+        // If there's an already planned action, do nothing
+        if (_inputAction != -1) {
+                return;
+        }
+
+        // Check the typed key
+        if (_kbdChar == val) {
+                // Exit the input loop
+                _inputLoopAddress = 0;
+
+                // Save the action address
+                _inputAction = address;
+        }
+}
+
+void Script::o_hotspot_rect() {
+        uint16 left = readScript16bits();
+        uint16 top = readScript16bits();
+        uint16 right = readScript16bits();
+        uint16 bottom = readScript16bits();
+        uint16 address = readScript16bits();
+        uint8 cursor = readScript8bits();
+        debugScript(5, true, "HOTSPOT-RECT(%d,%d,%d,%d) @0x%04X cursor=%d", left, top, right, bottom, address, cursor);
+
+        // Mark the specified rectangle
+        Common::Rect rect(left, top, right, bottom);
+        hotspot(rect, address, cursor);
+}
+
+void Script::o_hotspot_left() {
+        uint16 address = readScript16bits();
+        debugScript(5, true, "HOTSPOT-LEFT @0x%04X", address);
+
+        // Mark the leftmost 100 pixels of the game area
+        Common::Rect rect(0, 80, 100, 400);
+        hotspot(rect, address, 1);
+}
+
+void Script::o_hotspot_right() {
+        uint16 address = readScript16bits();
+        debugScript(5, true, "HOTSPOT-RIGHT @0x%04X", address);
+
+        // Mark the rightmost 100 pixels of the game area
+        Common::Rect rect(540, 80, 640, 400);
+        hotspot(rect, address, 2);
+}
+
+void Script::o_hotspot_center() {
+        uint16 address = readScript16bits();
+        debugScript(5, true, "HOTSPOT-CENTER @0x%04X", address);
+
+        // Mark the centremost 240 pixels of the game area
+        Common::Rect rect(200, 80, 440, 400);
+        hotspot(rect, address, 0);
+}
+
+void Script::o_hotspot_current() {
+       uint16 address = readScript16bits();
+       debugScript(5, true, "HOTSPOT-CURRENT @0x%04X", address);
+
+       // The original interpreter doesn't check the position, so accept the
+       // whole screen
+       Common::Rect rect(0, 0, 640, 480);
+       hotspot(rect, address, 0);
+}
+
+void Script::o_inputloopend() {
+        debugScript(5, true, "Input loop end");
+
+        // Handle the predefined hotspots
+        if (_hotspotTopAction) {
+                Common::Rect rect(0, 0, 640, 80);
+                hotspot(rect, _hotspotTopAction, _hotspotTopCursor);
+        }
+        if (_hotspotBottomAction) {
+                Common::Rect rect(0, 400, 640, 480);
+                hotspot(rect, _hotspotBottomAction, _hotspotBottomCursor);
+        }
+        if (_hotspotRightAction) {
+                Common::Rect rect(560, 0, 640, 480);
+                hotspot(rect, _hotspotRightAction, 2);
+        }
+        if (_hotspotLeftAction) {
+                Common::Rect rect(0, 0, 80, 480);
+                hotspot(rect, _hotspotLeftAction, 1);
+        }
+
+        // Actually execute the planned action
+        if (_inputAction != -1) {
+                // Jump to the planned address
+                _currentInstruction = _inputAction;
+
+                // Exit the input loop
+                _inputLoopAddress = 0;
+                _vm->_system->showMouse(false);
+        }
+
+        // Nothing to do
+        if (_inputLoopAddress) {
+                if (_newCursorStyle != _vm->_cursorMan->getStyle()) {
+                        _vm->_cursorMan->setStyle(_newCursorStyle);
+                }
+                _vm->_system->showMouse(true);
+
+                // Go back to the begining of the loop
+                _currentInstruction = _inputLoopAddress;
+
+                // There's nothing to do until we get some input
+                _vm->waitForInput();
+        }
+}
+
+void Script::o_random() {
+        uint16 varnum = readScript8or16bits();
+        uint8 maxnum = readScript8bits();
+        debugScript(1, true, "RANDOM: var[0x%04X] = rand(%d)", varnum, maxnum);
+
+        _variables[varnum] = _random.getRandomNumber(maxnum);
+}
+
+void Script::o_jmp() {
+        uint16 address = readScript16bits();
+        debugScript(1, true, "JMP @0x%04X", address);
+
+        // Set the current address
+        _currentInstruction = address;
+}
+
+void Script::o_loadstring() {
+        uint16 varnum = readScript8or16bits();
+        debugScript(1, false, "LOADSTRING var[0x%04X..] =", varnum);
+        do {
+                _variables[varnum++] = readScriptChar(true, true, true);
+                debugScript(1, false, " 0x%02X", _variables[varnum - 1]);
+        } while (!(_code[_currentInstruction - 1] & 0x80));
+        debugScript(1, true, "");
+}
+
+void Script::o_ret() {
+        uint8 val = readScript8bits();
+        debugScript(1, true, "RET %d", val);
+
+        // Set the return value
+        _variables[0x102] = val;
+
+        // Get the return address
+        if (_stacktop > 0) {
+                _stacktop--;
+                _currentInstruction = _stack[_stacktop];
+        } else {
+                error("Return: Stack is empty");
+        }
+}
+
+void Script::o_call() {
+        uint16 address = readScript16bits();
+        debugScript(1, true, "CALL @0x%04X", address);
+
+        // Save return address in the call stack
+        _stack[_stacktop] = _currentInstruction;
+        _stacktop++;
+
+        // Change the current instruction
+        _currentInstruction = address;
+}
+
+void Script::o_sleep() {
+        uint16 time = readScript16bits();
+        debugScript(1, true, "SLEEP 0x%04X", time);
+
+        _vm->_system->delayMillis(time * 3);
+}
+
+void Script::o_strcmpnejmp() {                  // 0x1A
+        uint16 varnum = readScript8or16bits();
+        debugScript(1, false, "STRCMP-NEJMP: var[0x%04X..],", varnum);
+        uint8 val;
+        uint8 result = 1;
+        do {
+                val = readScriptChar(true, true, true);
+
+                if (_variables[varnum] != val) {
+                        result = 0;
+                }
+                varnum++;
+                debugScript(1, false, " 0x%02X", val);
+
+        } while (!(_code[_currentInstruction - 1] & 0x80));
+
+        uint16 address = readScript16bits();
+        if (!result) {
+                debugScript(1, true, " jumping to @0x%04X", address);
+                _currentInstruction = address;
+        } else {
+                debugScript(1, true, " not jumping");
+        }
+}
+
+void Script::o_xor_obfuscate() {
+        uint16 varnum = readScript8or16bits();
+        debugScript(1, false, "XOR OBFUSCATE: var[0x%04X..] = ", varnum);
+        do {
+                uint8 val = readScript8bits();
+                _firstbit = ((val & 0x80) != 0);
+                val &= 0x4F;
+
+                _variables[varnum] ^= val;
+                debugScript(1, false, "%c", _variables[varnum]);
+
+                varnum++;
+        } while (!_firstbit);
+        debugScript(1, true, "");
+}
+
+void Script::o_vdxtransition() {                // 0x1C
+        uint16 fileref = readScript16bits();
+
+        // Show the debug information just when starting the playback
+        if (fileref != _videoRef) {
+                debugScript(1, true, "VDX transition fileref = 0x%04X", fileref);
+                debugC(1, kGroovieDebugVideo | kGroovieDebugAll, "Playing video 0x%04X with transition", fileref);
+        }
+
+        // Set bit 1
+        _bitflags |= 1 << 1;
+
+        // Clear bit 7
+        _bitflags &= ~(1 << 7);
+
+        // Set bit 2 if _firstbit
+        if (_firstbit) {
+                _bitflags |= 1 << 2;
+        }
+
+        // Play the video
+        if (!playvideofromref(fileref)) {
+                // Move _currentInstruction back
+                _currentInstruction -= 3;
+        }
+}
+
+void Script::o_swap() {
+        uint16 varnum1 = readScript8or16bits();
+        uint16 varnum2 = readScript16bits();
+        debugScript(1, true, "SWAP var[0x%04X] <-> var[0x%04X]", varnum1, varnum2);
+
+        uint8 tmp = _variables[varnum1];
+        _variables[varnum1] = _variables[varnum2];
+        _variables[varnum2] = tmp;
+}
+
+void Script::o_inc() {
+        uint16 varnum = readScript8or16bits();
+        debugScript(1, true, "INC var[0x%04X]", varnum);
+
+        _variables[varnum]++;
+}
+
+void Script::o_dec() {
+        uint16 varnum = readScript8or16bits();
+        debugScript(1, true, "DEC var[0x%04X]", varnum);
+
+        _variables[varnum]--;
+}
+
+void Script::o_strcmpnejmp_var() {                      // 0x21
+        uint16 data = readScriptVar();
+        if (data > 9) {
+                data -= 7;
+        }
+        data = _variables[data + 0x19];
+        bool stringsmatch = 1;
+        do {
+                if (_variables[data++] != readScriptChar(true, true, true)) {
+                        stringsmatch = 0;
+                }       
+        } while (!(_code[_currentInstruction - 1] & 0x80));
+
+        uint16 offset = readScript16bits();
+        if (!stringsmatch) {
+                _currentInstruction = offset;
+        }
+}
+
+void Script::o_copybgtofg() {                   // 0x22
+        debugScript(1, true, "COPY_BG_TO_FG");
+        memcpy(_vm->_graphicsMan->_foreground.getBasePtr(0, 0), _vm->_graphicsMan->_background.getBasePtr(0, 0), 640 * 320);
+}
+
+void Script::o_strcmpeqjmp() {                  // 0x23
+        uint16 varnum = readScript8or16bits();
+        debugScript(1, false, "STRCMP-EQJMP: var[0x%04X..],", varnum);
+        uint8 val;
+        uint8 result = 1;
+        do {
+                val = readScriptChar(true, true, true);
+
+                if (_variables[varnum] != val) {
+                        result = 0;
+                }
+                varnum++;
+                debugScript(1, false, " 0x%02X", val);
+
+        } while (!(_code[_currentInstruction - 1] & 0x80));
+
+        uint16 address = readScript16bits();
+        if (result) {
+                debugScript(1, true, " jumping to @0x%04X", address);
+                _currentInstruction = address;
+        } else {
+                debugScript(1, true, " not jumping");
+        }
+}
+
+void Script::o_mov() {
+        uint16 varnum1 = readScript8or16bits();
+        uint16 varnum2 = readScript16bits();
+        debugScript(1, true, "MOV var[0x%04X] = var[0x%04X]", varnum1, varnum2);
+
+        _variables[varnum1] = _variables[varnum2];
+}
+
+void Script::o_add() {
+        uint16 varnum1 = readScript8or16bits();
+        uint16 varnum2 = readScript16bits();
+        debugScript(1, true, "ADD var[0x%04X] += var[0x%04X]", varnum1, varnum2);
+
+        _variables[varnum1] += _variables[varnum2];
+}
+
+void Script::o_videofromstring1() {
+        uint16 instStart = _currentInstruction;
+        uint16 fileref = getVideoRefString();
+
+        // Show the debug information just when starting the playback
+        if (fileref != _videoRef) {
+                debugScript(0, true, "VIDEOFROMSTRING1 0x%04X", fileref);
+        }
+
+        // Play the video
+        if (!playvideofromref(fileref)) {
+                // Move _currentInstruction back
+                _currentInstruction = instStart - 1;
+        }
+}
+
+void Script::o_videofromstring2() {
+        uint16 instStart = _currentInstruction;
+        uint16 fileref = getVideoRefString();
+
+        // Show the debug information just when starting the playback
+        if (fileref != _videoRef) {
+                debugScript(0, true, "VIDEOFROMSTRING2 0x%04X", fileref);
+        }
+
+        // Set bit 1
+        _bitflags |= 1 << 1;
+
+        // Set bit 2 if _firstbit
+        if (_firstbit) {
+                _bitflags |= 1 << 2;
+        }
+
+        // Play the video
+        if (!playvideofromref(fileref)) {
+                // Move _currentInstruction back
+                _currentInstruction = instStart - 1;
+        }
+}
+
+void Script::o_stopmidi() {
+        debugScript(1, true, "STOPMIDI (TODO)");
+}
+
+void Script::o_endscript() {
+        debugScript(1, true, "END OF SCRIPT");
+        _error = true;
+}
+
+void Script::o_sethotspottop() {
+        uint16 address = readScript16bits();
+        uint8 cursor = readScript8bits();
+        debugScript(5, true, "SETHOTSPOTTOP @0x%04X cursor=%d", address, cursor);
+
+        _hotspotTopAction = address;
+        _hotspotTopCursor = cursor;
+}
+
+void Script::o_sethotspotbottom() {
+        uint16 address = readScript16bits();
+        uint8 cursor = readScript8bits();
+        debugScript(5, true, "SETHOTSPOTBOTTOM @0x%04X cursor=%d", address, cursor);
+
+        _hotspotBottomAction = address;
+        _hotspotBottomCursor = cursor;
+}
+
+void Script::o_loadgame() {
+        uint16 varnum = readScript8or16bits();
+        uint8 slot = _variables[varnum];
+        debugScript(1, true, "LOADGAME var[0x%04X] -> slot=%d (TODO)", varnum, slot);
+
+        loadgame(slot);
+        _vm->_system->clearScreen();
+}
+
+void Script::o_savegame() {
+        uint16 varnum = readScript8or16bits();
+        uint8 slot = _variables[varnum];
+        debugScript(1, true, "SAVEGAME var[0x%04X] -> slot=%d (TODO)", varnum, slot);
+
+        savegame(slot);
+}
+
+void Script::o_hotspotbottom_4() {      //0x30
+        uint16 address = readScript16bits();
+        debugScript(5, true, "HOTSPOT-BOTTOM @0x%04X", address);
+
+        // Mark the 80 pixels under the game area
+        Common::Rect rect(0, 400, 640, 480);
+        hotspot(rect, address, 4);
+}
+
+void Script::o_midivolume() {
+        uint16 arg1 = readScript16bits();
+        uint16 arg2 = readScript16bits();
+        debugScript(1, true, "MIDI volume: %d %d", arg1, arg2);
+        _vm->_musicPlayer->setGameVolume(arg1, arg2);
+}
+
+void Script::o_jne() {
+        int16 varnum1 = readScript8or16bits();
+        uint16 varnum2 = readScript16bits();
+        uint16 address = readScript16bits();
+        debugScript(1, false, "JNE: var[var[0x%04X] - 0x31] != var[0x%04X] @0x%04X", varnum1, varnum2, address);
+
+        if (_variables[_variables[varnum1] - 0x31] != _variables[varnum2]) {
+                _currentInstruction = address;
+                debugScript(1, true, " jumping to @0x%04X", address);
+        } else {
+                debugScript(1, true, " not jumping");
+        }
+}
+
+void Script::o_loadstringvar() {
+        uint16 varnum = readScript8or16bits();
+        varnum = _variables[varnum] - 0x31;
+        debugScript(1, false, "LOADSTRINGVAR var[0x%04X..] =", varnum);
+        do {
+                _variables[varnum++] = readScriptChar(true, true, true);
+                debugScript(1, false, " 0x%02X", _variables[varnum - 1]);
+        } while (!(_code[_currentInstruction - 1] & 0x80));
+        debugScript(1, true, "");
+}
+
+void Script::o_chargreatjmp() {
+        uint16 varnum = readScript8or16bits();
+        debugScript(1, false, "CHARGREAT-JMP: var[0x%04X..],", varnum);
+        uint8 val;
+        uint8 result = 0;
+        do {
+                val = readScriptChar(true, true, true);
+
+                if (val < _variables[varnum]) {
+                        result = 1;
+                }
+                varnum++;
+                debugScript(1, false, " 0x%02X", val);
+        } while (!(_code[_currentInstruction - 1] & 0x80));
+
+        uint16 address = readScript16bits();
+        if (result) {
+                debugScript(1, true, " jumping to @0x%04X", address);
+                _currentInstruction = address;
+        } else {
+                debugScript(1, true, " not jumping");
+        }
+}
+
+void Script::o_bf7off() {
+        debugScript(1, true, "BF7OFF: bitflag 7 turned off");
+        _bitflags &= ~(1 << 7);
+}
+
+void Script::o_charlessjmp() {
+        uint16 varnum = readScript8or16bits();
+        debugScript(1, false, "CHARLESS-JMP: var[0x%04X..],", varnum);
+        uint8 val;
+        uint8 result = 0;
+        do {
+                val = readScriptChar(true, true, true);
+
+                if (val > _variables[varnum]) {
+                        result = 1;
+                }
+                varnum++;
+                debugScript(1, false, " 0x%02X", val);
+        } while (!(_code[_currentInstruction - 1] & 0x80));
+
+        uint16 address = readScript16bits();
+        if (result) {
+                debugScript(1, true, " jumping to @0x%04X", address);
+                _currentInstruction = address;
+        } else {
+                debugScript(1, true, " not jumping");
+        }
+}
+
+void Script::o_copyrecttobg() { // 0x37
+        uint16 left = readScript16bits();
+        uint16 top = readScript16bits();
+        uint16 right = readScript16bits();
+        uint16 bottom = readScript16bits();
+        debugScript(1, true, "COPYRECT((%d,%d)->(%d,%d))", left, top, right, bottom);
+
+        uint16 i, width = right - left, height = bottom - top;
+        uint32 offset = 0;
+        byte *fg, *bg;
+        fg = (byte *)_vm->_graphicsMan->_foreground.getBasePtr(left, top - 80);
+        bg = (byte *)_vm->_graphicsMan->_background.getBasePtr(left, top - 80);
+        for (i = 0; i < height; i++) {
+                memcpy(bg + offset, fg + offset, width);
+                offset += 640;
+        }
+        _vm->_system->copyRectToScreen((byte *)_vm->_graphicsMan->_background.getBasePtr(left, top - 80), 640, left, top, width, height);
+        _vm->_graphicsMan->change();
+}
+
+void Script::o_restorestkpnt() {
+        debugScript(1, true, "Restore stack pointer from saved (TODO)");
+}
+
+void Script::o_obscureswap() {
+        debugScript(1, true, "OBSCSWAP");
+        uint16 var1, var2, tmp;
+
+        // Read the first variable
+        var1 = readScriptChar(false, true, true) * 10;
+        var1 += readScriptChar(false, true, true) + 0x19;
+
+        // Read the second variable
+        var2 = readScriptChar(false, true, true) * 10;
+        var2 += readScriptChar(false, true, true) + 0x19;
+
+        // Swap the values
+        tmp = _variables[var1];
+        _variables[var1] = _variables[var2];
+        _variables[var2] = tmp;
+}
+
+void Script::o_printstring() {
+        char stringstorage[15], newchar;
+        uint8 counter = 0;
+        memset(stringstorage, 0, 15);
+        do {
+                newchar = readScriptChar(true, true, true) + 0x30;
+                if (newchar < 0x30 || newchar > 0x39) {         // If character is invalid, chuck a space in
+                        if (newchar < 0x41 || newchar > 0x7A) {
+                                newchar = 0x20;
+                        }
+                }
+
+                stringstorage[counter] = newchar;
+                counter++;
+        } while (!(_code[_currentInstruction - 1] & 0x80));
+
+        stringstorage[counter] = 0;
+
+        // Load the font if required
+        if (!_font) {
+                _font = new Font(_vm->_system);
+        }
+        _font->printstring(stringstorage);
+}
+
+void Script::o_hotspot_slot() {
+        uint16 slot = readScript8bits();
+        uint16 left = readScript16bits();
+        uint16 top = readScript16bits();
+        uint16 right = readScript16bits();
+        uint16 bottom = readScript16bits();
+        uint16 address = readScript16bits();
+        uint16 cursor = readScript8bits();
+        debugScript(1, true, "HOTSPOT-SLOT %d (%d,%d,%d,%d) @0x%04X cursor=%d (TODO)", slot, left, top, right, bottom, address, cursor);
+
+        Common::Rect rect(left, top, right, bottom);
+        if (hotspot(rect, address, cursor)) {
+                char savename[15];
+
+                Common::String filename = ConfMan.getActiveDomainName() + ".00" + ('0' + slot);
+                Common::StringList files = _vm->_system->getSavefileManager()->listSavefiles(filename.c_str());
+                if (!files.empty()) {
+                        Common::InSaveFile *file = _vm->_system->getSavefileManager()->openForLoading(filename.c_str());
+                        if (file) {
+                                uint8 i;
+                                char temp;
+
+                                for (i = 0; i < 15; i++) {
+                                        file->read(&temp, 1);
+                                        savename[i] = temp + 0x30;
+                                } 
+
+                                delete file;
+                        } else {
+                                strcpy(savename, "ERROR");
+                        }
+                } else {
+                        strcpy(savename, "E M P T Y");
+                }
+
+                // Load the font if required
+                if (!_font) {
+                        _font = new Font(_vm->_system);
+                }
+                _font->printstring(savename);
+        } else {
+                Common::Point mousepos = _vm->_system->getEventManager()->getMousePos();
+                if (_hotspotCursorOldX != mousepos.x || _hotspotCursorOldY != mousepos.y ) {
+                        Common::Rect topbar(640, 80);
+
+                        Graphics::Surface *gamescreen;
+                        gamescreen = _vm->_system->lockScreen();
+
+                        gamescreen->fillRect(topbar, 0);        
+
+                        _vm->_system->unlockScreen();
+                        _hotspotCursorOldX = mousepos.x;
+                        _hotspotCursorOldY = mousepos.y;
+                }
+        }
+}
+
+void Script::o_checkvalidsaves() {
+        debugScript(1, true, "CHECKVALIDSAVES");
+
+        // Reset the array of valid saves
+        for (int i = 0; i < 10; i++) {
+                _variables[i] = 0;
+        }
+
+        // Get the list of savefiles
+        Common::String pattern = ConfMan.getActiveDomainName() + ".00?";
+        Common::StringList savefiles = _vm->_system->getSavefileManager()->listSavefiles(pattern.c_str());
+
+        // Mark the existing savefiles as valid
+        uint count = 0;
+        Common::StringList::iterator it = savefiles.begin();
+        while (it != savefiles.end()) {
+                int8 n = it->lastChar() - '0';
+                if (n >= 0 && n <= 9) {
+                        // TODO: Check the contents of the file?
+                        debugScript(2, true, "  Found valid savegame: %s", it->c_str());
+                        _variables[n] = 1;
+                        count++;
+                }
+                it++;
+        }
+
+        // Save the number of valid saves
+        _variables[0x104] = count;
+        debugScript(1, true, "  Found %d valid savegames", count);
+}
+
+void Script::o_resetvars() {
+        debugScript(1, true, "RESETVARS");
+        for (int i = 0; i < 0x100; i++) {
+                _variables[i] = 0;
+        }
+}
+
+void Script::o_mod() {
+        uint16 varnum = readScript8or16bits();
+        uint8 val = readScript8bits();
+        debugScript(1, true, "MOD var[0x%04X] %%= %d", varnum, val);
+
+        _variables[varnum] %= val;
+}
+
+void Script::o_loadscript() {
+        Common::String filename;
+        char c;
+        while ((c = readScript8bits())) {
+                filename += c;
+        }
+        debugScript(1, true, "LOADSCRIPT %s", filename.c_str());
+
+        // Just 1 level of sub-scripts are allowed
+        if (_savedCode) {
+                error("Tried to load a level 2 sub-script");
+        }
+
+        // Save the current code
+        _savedCode = _code;
+        _savedInstruction = _currentInstruction;
+
+        // Save the filename of the current script
+        _savedScriptFile = _scriptFile;
+
+        // Load the sub-script
+        if (!loadScript(filename)) {
+                error("Couldn't load sub-script");
+        }
+
+        // Save the current stack top
+        _savedStacktop = _stacktop;
+
+        // Save the variables
+        memcpy(_savedVariables, _variables + 0x107, 0x180);
+}
+
+void Script::o_setvideoorigin() {
+        // Set bitflag 7
+        _bitflags |= 1 << 7;
+
+        // Read the two offset arguments
+        int16 origX = readScript16bits();
+        int16 origY = readScript16bits();
+
+        debugScript(1, true, "SetVideoOrigin(0x%04X,0x%04X) (%d, %d)", origX, origY, origX, origY);
+        _vm->_videoPlayer->setOrigin(origX, origY);
+}
+
+void Script::o_sub() {
+        uint16 varnum1 = readScript8or16bits();
+        uint16 varnum2 = readScript16bits();
+        debugScript(1, true, "SUB var[0x%04X] -= var[0x%04X]", varnum1, varnum2);
+
+        _variables[varnum1] -= _variables[varnum2];
+}
+
+void Script::o_othello() {
+        uint16 arg = readScript8bits();
+        debugScript(1, true, "OTHELLO var[0x%02X]", arg);
+
+        // Arguments used by the original implementation: (2, arg, scriptBoard)
+        byte *scriptBoard = &_variables[0x19];
+        byte board[7][7];
+        for (int y = 0; y < 7; y++) {
+                for (int x = 0; x < 7; x++) {
+                        board[x][y] = 0;
+                        if (*scriptBoard == 0x32) board[x][y] = 1;
+                        if (*scriptBoard == 0x42) board[x][y] = 2;
+                        scriptBoard++;
+                        printf("%d", board[x][y]);
+                }
+                printf("\n");
+        }
+
+        // Set the movement origin
+        _variables[0] = 6; // y
+        _variables[1] = 0; // x
+        // Set the movement destination
+        _variables[2] = 6;
+        _variables[3] = 1;
+}
+
+void Script::o_returnscript() {
+        uint8 val = readScript8bits();
+        debugScript(1, true, "RETURNSCRIPT @0x%02X", val);
+
+        // Are we returning from a sub-script?
+        if (!_savedCode) {
+                error("Tried to return from the main script");
+        }
+
+        // Set the return value
+        _variables[0x102] = val;
+
+        // Restore the code
+        delete[] _code;
+        _code = _savedCode;
+        _savedCode = NULL;
+        _currentInstruction = _savedInstruction;
+
+        // Restore the stack
+        _stacktop = _savedStacktop;
+
+        // Restore the variables
+        memcpy(_variables + 0x107, _savedVariables, 0x180);
+
+        // Restore the filename of the script
+        _scriptFile = _savedScriptFile;
+
+        //TODO: reset script flags and previous video's flag1?
+        _vm->_videoPlayer->setOrigin(0, 0);
+}
+
+void Script::o_sethotspotright() {
+        uint16 address = readScript16bits();
+        debugScript(1, true, "SETHOTSPOTRIGHT @0x%04X", address);
+
+        _hotspotRightAction = address;
+}
+
+void Script::o_sethotspotleft() {
+        uint16 address = readScript16bits();
+        debugScript(1, true, "SETHOTSPOTLEFT @0x%04X", address);
+
+        _hotspotLeftAction = address;
+}
+
+void Script::o_getcd() {
+        debugScript(1, true, "GETCD");
+
+        // By default set it to no CD available
+        int8 cd = -1;
+
+        // Try to open one file from each CD
+        Common::File cdfile;
+        if (cdfile.open("b.gjd")) {
+                cdfile.close();
+                cd = 1;
+        }
+        if (cdfile.open("at.gjd")) {
+                cdfile.close();
+                if (cd == 1) {
+                        // Both CDs are available
+                        cd = 0;
+                } else {
+                        cd = 2;
+                }
+        }
+
+        _variables[0x106] = cd;
+}
+
+void Script::o_opcode4D() {
+        // TODO: play alternative vie logo, then playcd
+        uint8 val = readScript8bits();
+        debugScript(1, true, "PLAYCD? %d", val);
+
+        if (val == 2) {
+                AudioCD.play(1, 1, 0, 0);
+        }
+
+}
+
+void Script::o_hotspot_outrect() {
+        uint16 left = readScript16bits();
+        uint16 top = readScript16bits();
+        uint16 right = readScript16bits();
+        uint16 bottom = readScript16bits();
+        uint16 address = readScript16bits();
+        debugScript(1, true, "HOTSPOT-OUTRECT(%d,%d,%d,%d) @0x%04X (TODO)", left, top, right, bottom, address);
+
+        // Test if the current mouse position is outside the specified rectangle
+        Common::Rect rect(left, top, right, bottom);
+        Common::Point mousepos = _vm->_system->getEventManager()->getMousePos();
+        bool contained = rect.contains(mousepos);
+
+        if (!contained) {
+                error("hotspot-outrect unimplemented!");
+                // TODO: what to do with address?
+        }
+}
+
+void Script::o_stub56() {
+        uint32 val1 = readScript32bits();
+        uint8 val2 = readScript8bits();
+        uint8 val3 = readScript8bits();
+        debugScript(1, true, "STUB56: 0x%08X 0x%02X 0x%02X", val1, val2, val3);
+}
+
+void Script::o_stub59() {
+        uint16 val1 = readScript8or16bits();
+        uint8 val2 = readScript8bits();
+        debugScript(1, true, "STUB59: 0x%04X 0x%02X", val1, val2);
+}
+
+Script::OpcodeFunc Script::_opcodes[NUM_OPCODES] = {
+        &Script::o_nop, // 0x00
+        &Script::o_nop, 
+        &Script::o_playsong,
+        &Script::o_bf9on,
+        &Script::o_palfadeout, // 0x04
+        &Script::o_bf8on,
+        &Script::o_bf6on,
+        &Script::o_bf7on,
+        &Script::o_setbackgroundsong, // 0x08
+        &Script::o_videofromref,
+        &Script::o_bf5on,
+        &Script::o_inputloopstart,
+        &Script::o_keyboardaction, // 0x0C
+        &Script::o_hotspot_rect,
+        &Script::o_hotspot_left,
+        &Script::o_hotspot_right,
+        &Script::o_hotspot_center, // 0x10
+        &Script::o_hotspot_center,
+        &Script::o_hotspot_current,
+        &Script::o_inputloopend,
+        &Script::o_random, // 0x14
+        &Script::o_jmp,
+        &Script::o_loadstring,
+        &Script::o_ret,
+        &Script::o_call, // 0x18
+        &Script::o_sleep,
+        &Script::o_strcmpnejmp,
+        &Script::o_xor_obfuscate,
+        &Script::o_vdxtransition, // 0x1C
+        &Script::o_swap,
+        &Script::o_nop8,
+        &Script::o_inc,
+        &Script::o_dec, // 0x20
+        &Script::o_strcmpnejmp_var,
+        &Script::o_copybgtofg,
+        &Script::o_strcmpeqjmp,
+        &Script::o_mov, // 0x24
+        &Script::o_add,
+        &Script::o_videofromstring1, // Reads a string and then does stuff: used by book in library
+        &Script::o_videofromstring2, // play vdx file from string, after setting 1 (and 2 if firstbit)
+        &Script::o_nop16, // 0x28
+        &Script::o_stopmidi,
+        &Script::o_endscript,
+        &Script::o_nop,
+        &Script::o_sethotspottop, // 0x2C
+        &Script::o_sethotspotbottom,
+        &Script::o_loadgame,
+        &Script::o_savegame,
+        &Script::o_hotspotbottom_4, // 0x30
+        &Script::o_midivolume,
+        &Script::o_jne,
+        &Script::o_loadstringvar,
+        &Script::o_chargreatjmp, // 0x34
+        &Script::o_bf7off,
+        &Script::o_charlessjmp,
+        &Script::o_copyrecttobg,
+        &Script::o_restorestkpnt, // 0x38
+        &Script::o_obscureswap,
+        &Script::o_printstring,
+        &Script::o_hotspot_slot,
+        &Script::o_checkvalidsaves, // 0x3C
+        &Script::o_resetvars,
+        &Script::o_mod,
+        &Script::o_loadscript,
+        &Script::o_setvideoorigin, // 0x40
+        &Script::o_sub,
+        &Script::o_othello,
+        &Script::o_returnscript,
+        &Script::o_sethotspotright, // 0x44
+        &Script::o_sethotspotleft,
+        &Script::o_nop,
+        &Script::o_nop,
+        &Script::o_nop8, // 0x48
+        &Script::o_nop,
+        &Script::o_nop16,
+        &Script::o_nop8,
+        &Script::o_getcd, // 0x4C
+        &Script::o_opcode4D,
+        &Script::o_nop16,
+        &Script::o_nop16,
+        &Script::o_nop16, // 0x50
+        &Script::o_nop16,
+        //&Script::o_nop8,
+        &Script::o_invalid,             // Do loads with game area, maybe draw dirty areas?
+        &Script::o_hotspot_outrect,
+        &Script::o_nop, // 0x54
+        &Script::o_nop16,
+        &Script::o_stub56,
+        //&Script::o_nop32,
+        &Script::o_invalid,             // completely unimplemented, plays vdx in some way
+        //&Script::o_nop, // 0x58
+        &Script::o_invalid, // 0x58     // like above, but plays from string not ref
+        &Script::o_stub59
+};
+
+} // End of Groovie namespace

engines/groovie/graphics.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 GROOVIE_GRAPHICS_H
+#define GROOVIE_GRAPHICS_H
+
+namespace Groovie {
+
+class GroovieEngine;
+
+class GraphicsMan {
+public:
+        GraphicsMan(GroovieEngine *vm);
+        ~GraphicsMan();
+
+        // Buffers
+        void update();
+        void change();
+        void mergeFgAndBg();
+        void updateScreen(Graphics::Surface *source);
+        Graphics::Surface _foreground;  // The main surface that most things are drawn to
+        Graphics::Surface _background;  // Used occasionally, mostly (only?) in puzzles
+
+        // Palette fading
+        bool isFading();
+        void fadeIn(byte *pal);
+        void fadeOut();
+
+private:
+        GroovieEngine *_vm;
+
+        bool _changed;
+
+        // Palette fading
+        void applyFading(int step);
+        int _fading;
+        byte _paletteFull[256 * 4];
+        uint32 _fadeStartTime;
+};
+
+} // End of Groovie namespace
+
+#endif // GROOVIE_GRAPHICS_H

engines/groovie/roq.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 GROOVIE_ROQ_H
+#define GROOVIE_ROQ_H
+
+#include "groovie/player.h"
+
+namespace Groovie {
+
+class GroovieEngine;
+
+struct ROQBlockHeader {
+        uint16 type;
+        uint32 size;
+        uint16 param;
+};
+
+class ROQPlayer : public VideoPlayer {
+public:
+        ROQPlayer(GroovieEngine *vm);
+        ~ROQPlayer();
+
+protected:
+        uint16 loadInternal();
+        bool playFrameInternal();
+
+private:
+        bool readBlockHeader(ROQBlockHeader &blockHeader);
+
+        bool processBlock();
+        bool processBlockInfo(ROQBlockHeader &blockHeader);
+        bool processBlockQuadCodebook(ROQBlockHeader &blockHeader);
+        bool processBlockQuadVector(ROQBlockHeader &blockHeader);
+        bool processBlockQuadVectorSub(ROQBlockHeader &blockHeader);
+        bool processBlockStill(ROQBlockHeader &blockHeader);
+        bool processBlockSoundMono(ROQBlockHeader &blockHeader);
+        bool processBlockSoundStereo(ROQBlockHeader &blockHeader);
+        bool processBlockAudioContainer(ROQBlockHeader &blockHeader);
+
+        uint16 _num2blocks;
+        uint16 _num4blocks;
+};
+
+} // End of Groovie namespace
+
+#endif // GROOVIE_ROQ_H

engines/groovie/font.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/file.h"
+#include "graphics/surface.h"
+
+#include "groovie/font.h"
+
+namespace Groovie {
+
+Font::Font(OSystem *syst) :
+        _syst(syst), _sphinxfnt(NULL) {
+
+        Common::File fontfile;
+        if (!fontfile.open("sphinx.fnt")) {
+                error("Groovie::Font: Couldn't open sphinx.fnt");
+        }
+        uint16 fontfilesize = fontfile.size();
+        _sphinxfnt = fontfile.readStream(fontfilesize);
+        fontfile.close();
+}
+
+Font::~Font() {
+        delete _sphinxfnt;
+}
+
+void Font::printstring(char *messagein) {
+        uint16 totalwidth = 0, currxoffset, i;
+
+        char message[15];
+        memset(message, 0, 15);
+
+        // Clear the top bar
+        Common::Rect topbar(640, 80);
+        Graphics::Surface *gamescreen;
+        gamescreen = _syst->lockScreen();
+        gamescreen->fillRect(topbar, 0);        
+        _syst->unlockScreen();
+
+        for (i = 0; i < 14; i++) {
+                char chartocopy = messagein[i];
+                if (chartocopy <= 0x00 || chartocopy == 0x24) {
+                        break;
+                }
+                message[i] = chartocopy;
+        }
+        Common::rtrim(message);
+        for (i = 0; i < strlen(message); i++) {
+                totalwidth += letterwidth(message[i]);
+        }
+        currxoffset = (640 - totalwidth) / 2;
+        char *currpos = message;
+        while (*(currpos) != 0) {
+                currxoffset += printletter(*(currpos++), currxoffset);
+        }
+}
+
+uint16 Font::letteroffset(char letter) {
+        uint16 offset;
+        offset = letter;
+        _sphinxfnt->seek(offset);
+        offset = _sphinxfnt->readByte() * 2 + 128;
+        _sphinxfnt->seek(offset);
+        offset = _sphinxfnt->readUint16LE();
+        return offset;
+}
+
+uint8 Font::letterwidth(char letter) {
+        uint16 offset = letteroffset(letter);
+        _sphinxfnt->seek(offset);
+        return _sphinxfnt->readByte();
+}
+
+uint8 Font::letterheight(char letter) {
+        uint16 offset, width, julia, data, counter = 0;
+        offset = letteroffset(letter);
+        _sphinxfnt->seek(offset);
+        width = _sphinxfnt->readByte();
+        julia = _sphinxfnt->readByte();
+        data = _sphinxfnt->readByte();
+        while (data != 0xFF) {
+                data = _sphinxfnt->readByte();
+                counter++;
+        }
+        if (counter % width != 0) assert("font file corrupt");
+        return counter / width;
+}
+
+
+uint8 Font::printletter(char letter, uint16 xoffset) {
+        uint16 offset, width, height, julia;
+        //printf("%c (%d), ", letter, letter);
+        offset = letteroffset(letter);
+        height = letterheight(letter);
+        _sphinxfnt->seek(offset);
+        width = _sphinxfnt->readByte();
+        julia = _sphinxfnt->readByte();
+
+        byte *data = new byte[width * height];
+        _sphinxfnt->read(data, width * height);
+        _syst->copyRectToScreen(data, width, xoffset, 16, width, height);
+        delete data;
+        
+        return width;
+}
+
+} // End of Groovie namespace

engines/groovie/vdx.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 GROOVIE_VDX_H
+#define GROOVIE_VDX_H
+
+#include "groovie/player.h"
+
+namespace Groovie {
+
+class VDXPlayer : public VideoPlayer {
+public:
+        VDXPlayer(GroovieEngine *vm);
+        ~VDXPlayer();
+        void setOrigin(int16 x, int16 y);
+
+protected:
+        uint16 loadInternal();
+        bool playFrameInternal();
+
+private:
+        Graphics::Surface *_fg, *_bg;
+        uint8 _palBuf[3 * 256];
+
+        // Origin
+        int16 _origX, _origY;
+
+        // Video flags
+        bool _flagZero;
+        bool _flagOne;
+        bool _flagOnePrev;
+        byte _flag2Byte;
+        bool _flagThree;
+        bool _flagFour;
+        bool _flagFive;
+        bool _flagSix;
+        bool _flagSeven;
+        bool _flagEight;
+        bool _flagNine;
+
+        bool _flagSkipStill;
+        bool _flagSkipPalette;
+        bool _flagFirstFrame;
+        bool _flagTransparent;
+        bool _flagUpdateStill;
+
+        void getStill(Common::ReadStream *in);
+        void getDelta(Common::ReadStream *in);
+        void expandColourMap(byte *out, uint16 colourMap, uint8 colour1, uint8 colour0);
+        void decodeBlockStill(byte *buf, byte *colours, uint16 imageWidth, uint8 mask);
+        void decodeBlockDelta(uint32 offset, byte *colours, uint16 imageWidth);
+        void chunkSound(Common::ReadStream *in);
+        void setPalette(uint8 *palette);
+        void fadeIn(uint8 *palette);
+};
+
+} // End of Groovie namespace
+
+#endif // GROOVIE_VDX_H

engines/groovie/script.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 GROOVIE_SCRIPT_H
+#define GROOVIE_SCRIPT_H
+
+#include "common/file.h"
+#include "common/rect.h"
+
+#include "groovie/font.h"
+
+namespace Groovie {
+
+class GroovieEngine;
+
+class Script {
+        friend class Debugger;
+
+public:
+        Script(GroovieEngine *vm);
+        ~Script();
+
+        void setDebugger(Debugger *debugger);
+
+        bool loadScript(Common::String scriptfile);
+        void directGameLoad(int slot);
+        void step();
+
+        void setMouseClick();
+        void setKbdChar(uint8 c);
+
+        bool haveError();
+
+private:
+        GroovieEngine *_vm;
+
+        Common::RandomSource _random;
+
+        bool _firstbit;
+
+        // Script filename (for debugging purposes)
+        Common::String _scriptFile;
+        Common::String _savedScriptFile;
+
+        // Code
+        byte *_code;
+        uint16 _currentInstruction;
+        byte *_savedCode;
+        uint16 _savedInstruction;
+
+        // Variables
+        byte _variables[0x400];
+        byte _savedVariables[0x180];
+
+        // Stack
+        uint16 _stack[0x20];
+        uint8 _stacktop;
+        uint8 _savedStacktop;
+
+        // Input
+        bool _mouseClicked;
+        bool _eventMouseClicked;
+        uint8 _kbdChar;
+        uint8 _eventKbdChar;
+        uint16 _inputLoopAddress;
+        int16 _inputAction;
+        uint8 _newCursorStyle;
+        uint16 _hotspotTopAction;
+        uint16 _hotspotTopCursor;
+        uint16 _hotspotBottomAction;
+        uint16 _hotspotBottomCursor;
+        uint16 _hotspotRightAction;
+        uint16 _hotspotLeftAction;
+        uint16 _hotspotCursorOldX;
+        uint16 _hotspotCursorOldY;
+
+        // Video
+        Font *_font;
+        Common::SeekableReadStream *_videoFile;
+        uint16 _videoRef;
+        uint16 _bitflags;
+
+        // Debugging
+        Debugger *_debugger;
+        Common::String _debugString;
+        void error(const char *msg);
+        bool _error;
+
+        // Helper functions
+        uint8 readScript8bits();
+        uint16 readScript16bits();
+        uint32 readScript32bits();
+        uint16 readScript8or16bits();
+        uint8 readScriptChar(bool allow7C, bool limitVal, bool limitVar);
+        uint8 readScriptVar();
+        uint16 getVideoRefString();
+
+        bool hotspot(Common::Rect rect, uint16 addr, uint8 cursor);
+
+        void loadgame(uint slot);
+        void savegame(uint slot);
+        bool playvideofromref(uint16 fileref);
+
+        // Opcodes
+        typedef void (Script::*OpcodeFunc)();
+        static OpcodeFunc _opcodes[];
+
+        void o_invalid();
+
+        void o_nop();
+        void o_nop8();
+        void o_nop16();
+        void o_nop32();
+        void o_nop8or16();
+
+        void o_playsong();
+        void o_bf9on();
+        void o_palfadeout();
+        void o_bf8on();
+        void o_bf6on();
+        void o_bf7on();
+        void o_setbackgroundsong();
+        void o_videofromref();
+        void o_bf5on();
+        void o_inputloopstart();
+        void o_keyboardaction();
+        void o_hotspot_rect();
+        void o_hotspot_left();
+        void o_hotspot_right();
+        void o_hotspot_center();
+        void o_hotspot_current();
+        void o_inputloopend();
+        void o_random();
+        void o_jmp();
+        void o_loadstring();
+        void o_ret();
+        void o_call();
+        void o_sleep();
+        void o_strcmpnejmp_var();
+        void o_copybgtofg();
+        void o_strcmpnejmp();
+        void o_xor_obfuscate();
+        void o_vdxtransition();
+        void o_swap();
+        void o_inc();
+        void o_dec();
+        void o_strcmpeqjmp();
+        void o_mov();
+        void o_add();
+        void o_videofromstring1();
+        void o_videofromstring2();
+        void o_stopmidi();
+        void o_endscript();
+        void o_sethotspottop();
+        void o_sethotspotbottom();
+        void o_loadgame();
+        void o_savegame();
+        void o_hotspotbottom_4();
+        void o_midivolume();
+        void o_jne();
+        void o_loadstringvar();
+        void o_chargreatjmp();
+        void o_bf7off();
+        void o_charlessjmp();
+        void o_copyrecttobg();
+        void o_restorestkpnt();
+        void o_obscureswap();
+        void o_printstring();
+        void o_hotspot_slot();
+        void o_checkvalidsaves();
+        void o_resetvars();
+        void o_mod();
+        void o_loadscript();
+        void o_setvideoorigin();
+        void o_sub();
+        void o_othello();
+        void o_returnscript();
+        void o_sethotspotright();
+        void o_sethotspotleft();
+        void o_getcd();
+        void o_opcode4D();
+        void o_hotspot_outrect();
+        void o_stub56();
+        void o_stub59();
+};
+
+} // End of Groovie namespace
+
+#endif // GROOVIE_SCRIPT_H

engines/groovie/groovie.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/config-manager.h"
+#include "common/events.h"
+#include "sound/mixer.h"
+
+#include "groovie/groovie.h"
+#include "groovie/music.h"
+#include "groovie/roq.h"
+#include "groovie/vdx.h"
+
+namespace Groovie {
+
+GroovieEngine::GroovieEngine(OSystem *syst, GroovieGameDescription *gd) :
+        Engine(syst), _gameDescription(gd), _debugger(NULL), _script(this),
+        _resMan(NULL), _cursorMan(NULL), _videoPlayer(NULL), _musicPlayer(NULL),
+        _graphicsMan(NULL), _waitingForInput(false) {
+
+        // Adding the default directories
+        Common::File::addDefaultDirectory(_gameDataDir.getChild("groovie"));
+        Common::File::addDefaultDirectory(_gameDataDir.getChild("media"));
+        Common::File::addDefaultDirectory(_gameDataDir.getChild("system"));
+
+        // Initialize the custom debug levels
+        Common::addSpecialDebugLevel(kGroovieDebugAll, "All", "Debug everything");
+        Common::addSpecialDebugLevel(kGroovieDebugVideo, "Video", "Debug video and audio playback");
+        Common::addSpecialDebugLevel(kGroovieDebugResource, "Resource", "Debug resouce management");
+        Common::addSpecialDebugLevel(kGroovieDebugScript, "Script", "Debug the scripts");
+        Common::addSpecialDebugLevel(kGroovieDebugUnknown, "Unknown", "Report values of unknown data in files");
+        Common::addSpecialDebugLevel(kGroovieDebugHotspots, "Hotspots", "Show the hotspots");
+        Common::addSpecialDebugLevel(kGroovieDebugCursor, "Cursor", "Debug cursor decompression / switching");
+}
+
+GroovieEngine::~GroovieEngine() {
+        // Delete the remaining objects
+        delete _debugger;
+        delete _resMan;
+        delete _cursorMan;
+        delete _videoPlayer;
+        delete _musicPlayer;
+        delete _graphicsMan;
+}
+
+Common::Error GroovieEngine::init() {
+        // Initialize the graphics
+        _system->beginGFXTransaction();
+        initCommonGFX(true);
+        _system->initSize(640, 480);
+        _system->endGFXTransaction();
+
+        // Create debugger. It requires GFX to be initialized
+        _debugger = new Debugger(this);
+        _script.setDebugger(_debugger);
+
+        // Create the graphics manager
+        _graphicsMan = new GraphicsMan(this);
+
+        // Create the resource and cursor managers and the video player
+        switch (_gameDescription->version) {
+        case kGroovieT7G:
+                _resMan = new ResMan_t7g();
+                _cursorMan = new CursorMan_t7g(_system);
+                _videoPlayer = new VDXPlayer(this);
+                break;
+        case kGroovieV2:
+                _resMan = new ResMan_v2();
+                _cursorMan = new CursorMan_v2(_system);
+                _videoPlayer = new ROQPlayer(this);
+                break;
+        }
+
+        // Create the music player
+        _musicPlayer = new MusicPlayer(this);
+
+        // Load volume levels
+        syncSoundSettings();
+
+        // Get the name of the main script
+        Common::String filename = _gameDescription->desc.filesDescriptions[0].fileName;
+        if (_gameDescription->version == kGroovieT7G) {
+                // Run The 7th Guest's demo if requested
+                if (ConfMan.hasKey("demo_mode") && ConfMan.getBool("demo_mode")) {
+                        filename = Common::String("demo.grv");
+                }
+        } else if (_gameDescription->version == kGroovieV2) {
+                // Open the disk index
+                Common::File disk;
+                if (!disk.open(filename)) {
+                        error("Couldn't open %s", filename.c_str());
+                        return Common::kNoGameDataFoundError;
+                }
+
+                // Search the entry
+                bool found = false;
+                int index = 0;
+                while (!found && !disk.eos()) {
+                        Common::String line = disk.readLine();
+                        if (line.hasPrefix("title: ")) {
+                                // A new entry
+                                index++;
+                        } else if (line.hasPrefix("boot: ") && index == _gameDescription->indexEntry) {
+                                // It's the boot of the entry were looking for,
+                                // get the script filename
+                                filename = line.c_str() + 6;
+                                found = true;
+                        }
+                }
+
+                // Couldn't find the entry
+                if (!found) {
+                        error("Couldn't find entry %d in %s", _gameDescription->indexEntry, filename.c_str());
+                        return Common::kUnknownError;
+                }
+        }
+        
+        // Check the script file extension
+        if (!filename.hasSuffix(".grv")) {
+                error("%s isn't a valid script filename", filename.c_str());
+                return Common::kUnknownError;
+        }
+
+        // Load the script
+        if (!_script.loadScript(filename)) {
+                error("Couldn't load the script file %s", filename.c_str());
+                return Common::kUnknownError;
+        }
+
+        // Should I load a saved game?
+        if (ConfMan.hasKey("save_slot")) {
+                // Get the requested slot
+                int slot = ConfMan.getInt("save_slot");
+                _script.directGameLoad(slot);
+        }
+
+        return Common::kNoError;
+}
+
+Common::Error GroovieEngine::go() {
+        // Check that the game files and the audio tracks aren't together run from
+        // the same cd
+        
+        checkCD();
+
+        // Initialize the CD
+        int cd_num = ConfMan.getInt("cdrom");
+        if (cd_num >= 0)
+                _system->openCD(cd_num);
+
+        while (!shouldQuit()) {
+                // Show the debugger if required
+                if (_debugger->isAttached()) {
+                        _debugger->onFrame();
+                }
+
+                // If there's still a script error after debugging, end the execution
+                if (_script.haveError()) {
+                        quitGame();
+                        break;
+                }
+
+                // Handle input
+                Common::Event ev;
+                while (_eventMan->pollEvent(ev)) {
+                        switch (ev.type) {
+                        case Common::EVENT_KEYDOWN:
+                                // CTRL-D: Attach the debugger
+                                if ((ev.kbd.flags & Common::KBD_CTRL) && ev.kbd.keycode == Common::KEYCODE_d)
+                                        _debugger->attach();
+
+                                // Send the event to the scripts
+                                _script.setKbdChar(ev.kbd.ascii);
+
+                                // Continue the script execution to handle the key
+                                _waitingForInput = false;
+                                break;
+
+                        case Common::EVENT_MOUSEMOVE:
+                                // Continue the script execution, the mouse
+                                // pointer may fall inside a hotspot now
+                                _waitingForInput = false;
+                                break;
+
+                        case Common::EVENT_LBUTTONDOWN:
+                                // Send the event to the scripts
+                                _script.setMouseClick();
+
+                                // Continue the script execution to handle
+                                // the click
+                                _waitingForInput = false;
+                                break;
+
+                        case Common::EVENT_QUIT:
+                                quitGame();
+                                break;
+
+                        default:
+                                break;
+                        }
+                }
+
+                if (_waitingForInput) {
+                        // Still waiting for input, just update the mouse and wait a bit more
+                        _cursorMan->animate();
+                        _system->updateScreen();
+                        _system->delayMillis(50);
+                } else if (_graphicsMan->isFading()) {
+                        // We're waiting for a fading to end, let the CPU rest
+                        // for a while and continue
+                        _system->delayMillis(30);
+                } else {
+                        // Everything's fine, execute another script step
+                        _script.step();
+                }
+
+                // Update the screen if required
+                _graphicsMan->update();
+        }
+
+        return Common::kNoError;
+}
+
+bool GroovieEngine::hasFeature(EngineFeature f) const {
+        return
+                (f == kSupportsRTL) ||
+                (f == kSupportsLoadingDuringRuntime);
+}
+
+void GroovieEngine::syncSoundSettings() {
+        _musicPlayer->setUserVolume(ConfMan.getInt("music_volume"));
+        _mixer->setVolumeForSoundType(Audio::Mixer::kPlainSoundType, ConfMan.getInt("speech_volume"));
+}
+
+bool GroovieEngine::canLoadGameStateCurrently() {
+        // TODO: verify the engine has been initialized
+        return true;
+}
+
+Common::Error GroovieEngine::loadGameState(int slot) {
+        _script.directGameLoad(slot);
+
+        // TODO: Use specific error codes
+        return Common::kNoError;
+}
+
+void GroovieEngine::waitForInput() {
+        _waitingForInput = true;
+}
+
+} // End of namespace Groovie 

engines/groovie/module.mk

@@ +1 @@
+MODULE := engines/groovie
+
+MODULE_OBJS := \
+        cursor.o \
+        debug.o \
+        detection.o \
+        font.o \
+        graphics.o \
+        groovie.o \
+        jpeg.o \
+        lzss.o \
+        music.o \
+        player.o \
+        resource.o \
+        roq.o \
+        script.o \
+        vdx.o
+
+# This module can be built as a plugin
+ifeq ($(ENABLE_GROOVIE), DYNAMIC_PLUGIN)
+PLUGIN := 1
+endif
+
+# Include common rules 
+include $(srcdir)/rules.mk

engines/groovie/font.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 GROOVIE_FONT_H
+#define GROOVIE_FONT_H
+
+#include "common/stream.h"
+#include "common/system.h"
+
+namespace Groovie {
+
+class Font {
+public:
+        Font(OSystem *syst);
+        ~Font();
+        void printstring(char *messagein);
+
+private:
+        OSystem *_syst;
+        Common::MemoryReadStream *_sphinxfnt;
+
+        uint16 letteroffset(char letter);
+        uint8 letterwidth(char letter);
+        uint8 letterheight(char letter);
+        uint8 printletter(char letter, uint16 xoffset);
+};
+
+} // End of Groovie namespace
+
+#endif // GROOVIE_FONT_H

engines/groovie/cursor.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 "groovie/cursor.h"
+#include "groovie/groovie.h"
+
+namespace Groovie {
+
+// Cursor Manager
+
+CursorMan::CursorMan(OSystem *system) :
+        _syst(system), _lastTime(0), _cursor(NULL) {
+}
+
+CursorMan::~CursorMan() {
+        // Delete the cursors
+        for (uint cursor = 0; cursor < _cursors.size(); cursor++) {
+                delete _cursors[cursor];
+        }
+}
+
+uint8 CursorMan::getStyle() {
+        return _current;
+}
+
+void CursorMan::setStyle(uint8 newStyle) {
+        // Reset the animation
+        _lastFrame = 254;
+        _lastTime = 1;
+
+        // Save the new cursor
+        _current = newStyle;
+        _cursor = _cursors[newStyle];
+
+        // Show the first frame
+        _cursor->enable();
+        animate();
+}
+
+void CursorMan::animate() {
+        if (_lastTime) {
+                int newTime = _syst->getMillis();
+                if (_lastTime - newTime >= 75) {
+                        _lastFrame++;
+                        _lastFrame %= _cursor->getFrames();
+                        _cursor->showFrame(_lastFrame);
+                        _lastTime = _syst->getMillis();
+                }
+        }
+}
+
+
+// t7g Cursor
+
+class Cursor_t7g : public Cursor {
+public:
+        Cursor_t7g(OSystem *system, uint8 *img, uint8 *pal);
+
+        void enable();
+        void showFrame(uint16 frame);
+
+private:
+        OSystem *_syst;
+        byte *_img;
+        byte *_pal;
+};
+
+Cursor_t7g::Cursor_t7g(OSystem *system, uint8 *img, uint8 *pal) :
+        _syst(system), _pal(pal) {
+
+        _width = img[0];
+        _height = img[1];
+        _numFrames = img[2];
+        uint8 elinor1 = img[3];
+        uint8 elinor2 = img[4];
+
+        _img = img + 5;
+
+        debugC(1, kGroovieDebugCursor | kGroovieDebugAll, "Groovie::Cursor: width: %d, height: %d, frames:%d", _width, _height, _numFrames);
+        debugC(1, kGroovieDebugCursor | kGroovieDebugUnknown | kGroovieDebugAll, "Groovie::Cursor: elinor: 0x%02X (%d), 0x%02X (%d)", elinor1, elinor1, elinor2, elinor2);
+}
+
+void Cursor_t7g::enable() {
+        // Apply the palette
+        _syst->setCursorPalette(_pal, 0, 32);
+}
+
+void Cursor_t7g::showFrame(uint16 frame) {
+        // Set the mouse cursor
+        int offset = _width * _height * frame;
+        _syst->setMouseCursor((const byte *)_img + offset, _width, _height, _width >> 1, _height >> 1, 0);
+}
+
+
+// t7g Cursor Manager
+
+#define NUM_IMGS 9
+static const uint16 cursorDataOffsets[NUM_IMGS] = {
+0x0000, 0x182f, 0x3b6d, 0x50cc, 0x6e79, 0x825d, 0x96d7, 0xa455, 0xa776
+};
+
+#define NUM_PALS 7
+//Pals: 0xb794, 0xb7f4, 0xb854, 0xb8b4, 0xb914, 0xb974, 0xb9d4
+
+#define NUM_STYLES 11
+// pyramid is cursor 8, eyes are 9 & 10
+const uint CursorMan_t7g::_cursorImg[NUM_STYLES] = {3, 5, 4, 3, 1, 0, 2, 6, 7, 8, 8};
+const uint CursorMan_t7g::_cursorPal[NUM_STYLES] = {0, 0, 0, 0, 2, 0, 1, 3, 5, 4, 6};
+
+CursorMan_t7g::CursorMan_t7g(OSystem *system) :
+        CursorMan(system) {
+
+        // Open the cursors file
+        Common::File robgjd;
+        if (!robgjd.open("rob.gjd")) {
+                error("Groovie::Cursor: Couldn't open rob.gjd");
+                return;
+        }
+
+        // Load the images
+        for (uint imgnum = 0; imgnum < NUM_IMGS; imgnum++) {
+                robgjd.seek(cursorDataOffsets[imgnum]);
+                _images.push_back(loadImage(robgjd));
+        }
+
+        // Load the palettes
+        robgjd.seek(-0x60 * NUM_PALS, SEEK_END);
+        for (uint palnum = 0; palnum < NUM_PALS; palnum++) {
+                _palettes.push_back(loadPalette(robgjd));
+        }
+
+        // Build the cursors
+        for (uint cursor = 0; cursor < NUM_STYLES; cursor++) {
+                Cursor *s = new Cursor_t7g(_syst, _images[_cursorImg[cursor]], _palettes[_cursorPal[cursor]]);
+                _cursors.push_back(s);
+        }
+
+        robgjd.close();
+}
+
+CursorMan_t7g::~CursorMan_t7g() {
+        // Delete the images
+        for (uint img = 0; img < _images.size(); img++) {
+                delete[] _images[img];
+        }
+
+        // Delete the palettes
+        for (uint pal = 0; pal < _palettes.size(); pal++) {
+                delete[] _palettes[pal];
+        }
+}
+
+byte *CursorMan_t7g::loadImage(Common::File &file) {
+        uint16 decompbytes = 0, offset, i, length;
+        uint8 flagbyte, lengthmask = 0x0F, offsetlen, var_8;
+        byte *cursorStorage = new byte[65536];
+        uint8 *runningcursor = cursorStorage;
+
+        bool finished = false;
+        while (!(finished || file.eos())) {
+                flagbyte = file.readByte();
+                for (i = 1; i <= 8; i++) {
+                        if (!file.eos()) {
+                                if (flagbyte & 1) {
+                                        *(runningcursor++) = file.readByte();
+                                        decompbytes++;
+                                } else {
+                                        var_8 = file.readByte();
+                                        offsetlen = file.readByte();
+                                        if (var_8 == 0 && offsetlen == 0) {
+                                                finished = true;
+                                                break;
+                                        }
+                                        length = (offsetlen & lengthmask) + 3;
+                                        offsetlen >>= 4;
+                                        offset = (offsetlen << 8) + var_8;
+                                        decompbytes += length;
+
+                                        for (; length > 0; length--, runningcursor++) {
+                                                *(runningcursor) = *(runningcursor - offset);
+                                        }
+                                }
+                                flagbyte = flagbyte >> 1;
+                        }
+                }
+        }
+
+        return cursorStorage;
+}
+
+byte *CursorMan_t7g::loadPalette(Common::File &file) {
+        byte *palette = new byte[4 * 32];
+        for (uint8 colournum = 0; colournum < 32; colournum++) {
+                palette[colournum * 4 + 0] = file.readByte();
+                palette[colournum * 4 + 1] = file.readByte();
+                palette[colournum * 4 + 2] = file.readByte();
+                palette[colournum * 4 + 3] = 0;
+        }
+        return palette;
+}
+
+
+// v2 Cursor
+
+class Cursor_v2 : public Cursor {
+public:
+        Cursor_v2(Common::File &file);
+
+        void enable();
+        void showFrame(uint16 frame);
+
+private:
+        //byte *_data;
+};
+
+Cursor_v2::Cursor_v2(Common::File &file) {
+        _numFrames = file.readUint16LE();
+        _width = file.readUint16LE();
+        _height = file.readUint16LE();
+
+        debugC(1, kGroovieDebugCursor | kGroovieDebugAll, "Groovie::Cursor: width: %d, height: %d, frames:%d", _width, _height, _numFrames);
+
+        uint16 tmp16 = file.readUint16LE();
+        printf("hotspot x?: %d\n", tmp16);
+        tmp16 = file.readUint16LE();
+        printf("hotspot y?: %d\n", tmp16);
+        int loop2count = file.readUint16LE();
+        printf("loop2count?: %d\n", loop2count);
+        for (int l = 0; l < loop2count; l++) {
+                tmp16 = file.readUint16LE();
+                printf("loop2a: %d\n", tmp16);
+                tmp16 = file.readUint16LE();
+                printf("loop2b: %d\n", tmp16);
+        }
+
+        file.seek(0x20 * 3, SEEK_CUR);
+
+        for (int f = 0; f < _numFrames; f++) {
+                uint32 tmp32 = file.readUint32LE();
+                printf("loop3: %d\n", tmp32);
+
+                //file.seek(tmp32, SEEK_CUR);
+                byte *data = new byte[tmp32];
+                file.read(data, tmp32);
+                //Common::hexdump(data, tmp32);
+                delete[] data;
+        }
+}
+
+void Cursor_v2::enable() {
+}
+
+void Cursor_v2::showFrame(uint16 frame) {
+}
+
+
+// v2 Cursor Manager
+
+CursorMan_v2::CursorMan_v2(OSystem *system) :
+        CursorMan(system) {
+
+        // Open the icons file
+        Common::File iconsFile;
+        if (!iconsFile.open("icons.ph")) {
+                error("Groovie::Cursor: Couldn't open icons.ph");
+                return;
+        }
+
+        // Verify the signature
+        uint32 tmp32 = iconsFile.readUint32LE();
+        uint16 tmp16 = iconsFile.readUint16LE();
+        if (tmp32 != 0x6e6f6369 || tmp16 != 1) {
+                error("Groovie::Cursor: icons.ph signature failed: %04X %d", tmp32, tmp16);
+                return;
+        }
+
+        // Read the number of icons
+        uint16 nicons = iconsFile.readUint16LE();
+
+        // Read the icons
+        for (int i = 0; i < nicons; i++) {
+                Cursor *s = new Cursor_v2(iconsFile);
+                _cursors.push_back(s);
+        }
+
+        iconsFile.close();
+}
+
+CursorMan_v2::~CursorMan_v2() {
+}
+
+} // End of Groovie namespace

engines/groovie/detection.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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/engines/groovie/detection.cpp $
+ * $Id: detection.cpp 28132 2007-07-17 22:29:09Z aquadran $
+ *
+ */
+
+#include "common/savefile.h"
+
+#include "groovie/groovie.h"
+
+namespace Groovie {
+
+//#define GROOVIE_EXPERIMENTAL
+
+static const PlainGameDescriptor groovieGames[] = {
+        // Games
+        {"t7g", "The 7th Guest"},
+
+#ifdef GROOVIE_EXPERIMENTAL
+        {"11h", "The 11th Hour: The sequel to The 7th Guest"},
+        {"clandestiny", "Clandestiny"},
+        {"unclehenry", "Uncle Henry's Playhouse"},
+        {"tlc", "Tender Loving Care"},
+
+        // Extras
+        {"making11h", "The Making of The 11th Hour"},
+        {"clantrailer", "Clandestiny Trailer"},
+#endif
+
+        // Unknown
+        {"groovie", "Groovie engine game"},
+        {0, 0}
+};
+
+static const GroovieGameDescription gameDescriptions[] = {
+
+        // The 7th Guest DOS English
+        { 
+                {
+                        "t7g", "",
+                        AD_ENTRY1s("script.grv", "d1b8033b40aa67c076039881eccce90d", 16659),
+                        Common::EN_ANY, Common::kPlatformPC, Common::ADGF_NO_FLAGS
+                },
+                kGroovieT7G, 0
+        },
+
+        // The 7th Guest Mac English
+        {
+                {
+                        "t7g", "",
+                        AD_ENTRY1s("script.grv", "6e30b54b1f3bc2262cdcf7961db2ae67", 17191),
+                        Common::EN_ANY, Common::kPlatformMacintosh, Common::ADGF_NO_FLAGS
+                },
+                kGroovieT7G, 0
+        },
+
+#ifdef GROOVIE_EXPERIMENTAL
+        // The 11th Hour DOS English
+        { 
+                {
+                        "11h", "",
+                        AD_ENTRY1s("disk.1", "5c0428cd3659fc7bbcd0aa16485ed5da", 227),
+                        Common::EN_ANY, Common::kPlatformPC, Common::ADGF_NO_FLAGS
+                },
+                kGroovieV2, 1
+        },
+
+        // The Making of The 11th Hour DOS English
+        { 
+                {
+                        "making11h", "",
+                        AD_ENTRY1s("disk.1", "5c0428cd3659fc7bbcd0aa16485ed5da", 227),
+                        Common::EN_ANY, Common::kPlatformPC, Common::ADGF_NO_FLAGS
+                },
+                kGroovieV2, 2
+        },
+
+        // Clandestiny Trailer DOS English
+        { 
+                {
+                        "clantrailer", "",
+                        AD_ENTRY1s("disk.1", "5c0428cd3659fc7bbcd0aa16485ed5da", 227),
+                        Common::EN_ANY, Common::kPlatformPC, Common::ADGF_NO_FLAGS
+                },
+                kGroovieV2, 3
+        },
+
+        // Clandestiny DOS English
+        { 
+                {
+                        "clandestiny", "",
+                        AD_ENTRY1s("disk.1", "f79fc1515174540fef6a34132efc4c53", 76),
+                        Common::EN_ANY, Common::kPlatformPC, Common::ADGF_NO_FLAGS
+                },
+                kGroovieV2, 1
+        },
+
+        // Uncle Henry's Playhouse PC English
+        { 
+                {
+                        "unclehenry", "",
+                        AD_ENTRY1s("disk.1", "0e1b1d3cecc4fc7efa62a968844d1f7a", 72),
+                        Common::EN_ANY, Common::kPlatformPC, Common::ADGF_NO_FLAGS
+                },
+                kGroovieV2, 1
+        },
+
+        // Tender Loving Care PC English
+        { 
+                {
+                        "tlc", "",
+                        AD_ENTRY1s("disk.1", "32a1afa68478f1f9d2b25eeea427f2e3", 84),
+                        Common::EN_ANY, Common::kPlatformPC, Common::ADGF_NO_FLAGS
+                },
+                kGroovieV2, 1
+        },
+#endif
+
+        {AD_TABLE_END_MARKER, kGroovieT7G, 0}
+};
+
+static const Common::ADParams detectionParams = {
+        // Pointer to ADGameDescription or its superset structure
+        (const byte *)gameDescriptions,
+        // Size of that superset structure
+        sizeof(GroovieGameDescription),
+        // Number of bytes to compute MD5 sum for
+        5000,
+        // List of all engine targets
+        groovieGames,
+        // Structure for autoupgrading obsolete targets
+        0,
+        // Name of single gameid (optional)
+        0,
+        // List of files for file-based fallback detection (optional)
+        0,
+        // Flags
+        0
+};
+
+
+class GroovieMetaEngine : public Common::AdvancedMetaEngine {
+public:
+        GroovieMetaEngine() : Common::AdvancedMetaEngine(detectionParams) {}
+
+        const char *getName() const {
+                return "Groovie Engine";
+        }
+
+        const char *getCopyright() const {
+                return "Groovie Engine (C) 1990-1996 Trilobyte";
+        }
+
+        bool createInstance(OSystem *syst, Engine **engine, const Common::ADGameDescription *gd) const;
+
+        bool hasFeature(MetaEngineFeature f) const;
+        SaveStateList listSaves(const char *target) const;
+        void removeSaveState(const char *target, int slot) const;
+};
+
+bool GroovieMetaEngine::createInstance(OSystem *syst, Engine **engine, const Common::ADGameDescription *gd) const {
+        if (gd) {
+                *engine = new GroovieEngine(syst, (GroovieGameDescription *)gd);
+        }
+        return gd != 0;
+}
+
+bool GroovieMetaEngine::hasFeature(MetaEngineFeature f) const {
+        return
+                (f == kSupportsListSaves) ||
+                (f == kSupportsLoadingDuringStartup) ||
+                (f == kSupportsDeleteSave);
+                //(f == kSavesSupportCreationDate)
+}
+
+SaveStateList GroovieMetaEngine::listSaves(const char *target) const {
+        Common::SaveFileManager *sfm = g_system->getSavefileManager();
+        SaveStateList list;
+
+        // Get the list of savefiles
+        Common::String pattern = Common::String(target) + ".00?";
+        Common::StringList savefiles = sfm->listSavefiles(pattern.c_str());
+
+        // Sort the list of filenames
+        sort(savefiles.begin(), savefiles.end());
+
+        // Fill the information for the existing savegames
+        Common::StringList::iterator it = savefiles.begin();
+        while (it != savefiles.end()) {
+                int slot = it->lastChar() - '0';
+                if (slot >= 0 && slot <= 9) {
+                        Common::InSaveFile *file = sfm->openForLoading(it->c_str());
+
+                        // Read the savegame description
+                        Common::String description;
+                        unsigned char c = 1;
+                        for (int i = 0; (c != 0) && (i < 15); i++) {
+                                c = file->readByte();
+                                switch (c) {
+                                case 0:
+                                        break;
+                                case 16: // @
+                                        c = ' ';
+                                        break;
+                                case 244: // $
+                                        c = 0;
+                                        break;
+                                default:
+                                        c += 0x30;
+                                }
+                                if (c != 0) {
+                                        description += c;
+                                }
+                        }
+                        delete file;
+
+                        list.push_back(SaveStateDescriptor(slot, description));
+                }
+                it++;
+        }
+
+        return list;
+}
+
+void GroovieMetaEngine::removeSaveState(const char *target, int slot) const {
+        if (slot < 0 || slot > 9) {
+                // Invalid slot, do nothing
+                return;
+        }
+
+        char extension[6];
+        snprintf(extension, sizeof(extension), ".00%01d", slot);
+
+        Common::String filename = target;
+        filename += extension;
+
+        g_system->getSavefileManager()->removeSavefile(filename.c_str());
+}
+
+} // End of namespace Groovie
+
+#if PLUGIN_ENABLED_DYNAMIC(GROOVIE)
+        REGISTER_PLUGIN_DYNAMIC(GROOVIE, PLUGIN_TYPE_ENGINE, Groovie::GroovieMetaEngine);
+#else
+        REGISTER_PLUGIN_STATIC(GROOVIE, PLUGIN_TYPE_ENGINE, Groovie::GroovieMetaEngine);
+#endif

engines/groovie/groovie.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 GROOVIE_H
+#define GROOVIE_H
+
+#include "common/advancedDetector.h"
+#include "engines/engine.h"
+#include "graphics/surface.h"
+
+#include "groovie/cursor.h"
+#include "groovie/debug.h"
+#include "groovie/graphics.h"
+#include "groovie/player.h"
+#include "groovie/resource.h"
+#include "groovie/script.h"
+
+namespace Groovie {
+
+class MusicPlayer;
+
+enum kDebugLevels {
+        kGroovieDebugAll = 1 << 0,
+        kGroovieDebugVideo = 1 << 1,
+        kGroovieDebugResource = 1 << 2,
+        kGroovieDebugScript = 1 << 3,
+        kGroovieDebugUnknown = 1 << 4,
+        kGroovieDebugHotspots = 1 << 5,
+        kGroovieDebugCursor = 1 << 6
+                // the current limitation is 32 debug levels (1 << 31 is the last one)
+};
+
+enum kEngineVersion {
+        kGroovieT7G,
+        kGroovieV2
+};
+
+struct GroovieGameDescription {
+        Common::ADGameDescription desc;
+
+        kEngineVersion version; // Version of the engine
+        int indexEntry; // The index of the entry in disk.1 for V2 games
+};
+
+class GroovieEngine : public Engine {
+public:
+        GroovieEngine(OSystem *syst, GroovieGameDescription *gd);
+        ~GroovieEngine();
+
+protected:
+        Common::Error init();
+        Common::Error go();
+
+public:
+        bool hasFeature(EngineFeature f) const;
+
+        bool canLoadGameStateCurrently();
+        Common::Error loadGameState(int slot);
+        void syncSoundSettings();
+
+        Debugger *getDebugger() { return _debugger; }
+
+        void waitForInput();
+
+        Script _script;
+        ResMan *_resMan;
+        CursorMan *_cursorMan;
+        VideoPlayer *_videoPlayer;
+        MusicPlayer *_musicPlayer;
+        GraphicsMan *_graphicsMan;
+
+private:
+        GroovieGameDescription *_gameDescription;
+        Debugger *_debugger;
+        bool _waitingForInput;
+};
+
+} // End of namespace Groovie
+
+#endif // GROOVIE_H

engines/groovie/music.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 "groovie/music.h"
+#include "groovie/resource.h"
+
+namespace Groovie {
+
+MusicPlayer::MusicPlayer(GroovieEngine *vm) :
+        _vm(vm), _midiParser(NULL), _data(NULL), _driver(NULL),
+        _backgroundFileRef(0) {
+        // Create the parser
+        _midiParser = MidiParser::createParser_XMIDI();
+
+        // Create the driver
+        int driver = detectMusicDriver(MDT_MIDI | MDT_ADLIB | MDT_PREFER_MIDI);
+        _driver = createMidi(driver);
+        _driver->open();
+
+        // Initialize the channel volumes
+        for (int i = 0; i < 0x10; i++) {
+                _chanVolumes[i] = 0x7F;
+        }
+
+        // Set the parser's driver
+        _midiParser->setMidiDriver(this);
+
+        // Set the timer rate
+        _midiParser->setTimerRate(_driver->getBaseTempo());
+}
+
+MusicPlayer::~MusicPlayer() {
+        // Unload the parser
+        unload();
+        delete _midiParser;
+
+        // Unload the MIDI Driver
+        _driver->close();
+        delete _driver;
+}
+
+void MusicPlayer::playSong(uint16 fileref) {
+        // Play the referenced file once
+        play(fileref, false);
+}
+
+void MusicPlayer::setBackgroundSong(uint16 fileref) {
+        _backgroundFileRef = fileref;
+}
+
+void MusicPlayer::setUserVolume(uint16 volume) {
+        // Save the new user volume
+        _userVolume = volume;
+        if (_userVolume > 0x100) _userVolume = 0x100;
+
+        // Apply it to all the channels
+        for (int i = 0; i < 0x10; i++) {
+                updateChanVolume(i);
+        }
+        //FIXME: AdlibPercussionChannel::controlChange() is empty
+        //(can't set the volume for the percusion channel)
+}
+
+void MusicPlayer::setGameVolume(uint16 volume, uint16 time) {
+        //TODO: Implement volume fading
+        printf("setting game volume: %d, %d\n", volume, time);
+
+        // Save the new game volume
+        _gameVolume = volume;
+        if (_gameVolume > 100) _gameVolume = 100;
+
+        // Apply it to all the channels
+        for (int i = 0; i < 0x10; i++) {
+                updateChanVolume(i);
+        }
+}
+
+void MusicPlayer::updateChanVolume(byte channel) {
+        // Generate a MIDI Control change message for the volume
+        uint32 b = 0x7B0;
+
+        // Specify the channel
+        b |= (channel & 0xF);
+
+        // Scale by the user and game volumes
+        uint32 val = (_chanVolumes[channel] * _userVolume * _gameVolume) / 0x100 / 100;
+        val &= 0x7F;
+
+        // Send it to the driver
+        _driver->send(b | (val << 16));
+}
+
+bool MusicPlayer::play(uint16 fileref, bool loop) {
+        // Unload the previous song
+        unload();
+
+        // Set the looping option
+        _midiParser->property(MidiParser::mpAutoLoop, loop);
+
+        // Load the new file
+        return load(fileref);
+}
+
+bool MusicPlayer::load(uint16 fileref) {
+        // Open the song resource
+        Common::SeekableReadStream *xmidiFile = _vm->_resMan->open(fileref);
+        if (!xmidiFile) {
+                error("Groovie::Music: Couldn't resource 0x%04X", fileref);
+                return false;
+        }
+
+        // Read the whole file to memory
+        int length = xmidiFile->size();
+        _data = new byte[length];
+        xmidiFile->read(_data, length);
+        delete xmidiFile;
+
+        // Start parsing the data
+        if (!_midiParser->loadMusic(_data, length)) {
+                error("Groovie::Music: Invalid XMI file");
+                return false;
+        }
+
+        // Activate the timer source
+        _driver->setTimerCallback(_midiParser, MidiParser::timerCallback);
+
+        return true;
+}
+
+void MusicPlayer::unload() {
+        // Unload the parser
+        _midiParser->unloadMusic();
+
+        // Unload the xmi file
+        delete[] _data;
+        _data = NULL;
+}
+
+int MusicPlayer::open() {
+        return 0;
+}
+
+void MusicPlayer::close() {}
+
+void MusicPlayer::send(uint32 b) {
+        if ((b & 0xFFF0) == 0x07B0) { // Volume change
+                // Save the specific channel volume
+                byte chan = b & 0xF;
+                _chanVolumes[chan] = (b >> 16) & 0x7F;
+
+                // Send the updated value
+                updateChanVolume(chan);
+
+                return;
+        }
+        _driver->send(b);
+}
+
+void MusicPlayer::metaEvent(byte type, byte *data, uint16 length) {
+        switch (type) {
+        case 0x2F:
+                // End of Track, play the background song
+                if (_backgroundFileRef) {
+                        play(_backgroundFileRef, true);
+                }
+                break;
+        default:
+                _driver->metaEvent(type, data, length);
+                break;
+        }
+}
+
+void MusicPlayer::setTimerCallback(void *timer_param, Common::TimerManager::TimerProc timer_proc) {
+        _driver->setTimerCallback(timer_param, timer_proc);
+}
+
+uint32 MusicPlayer::getBaseTempo(void) {
+        return _driver->getBaseTempo();
+}
+
+MidiChannel *MusicPlayer::allocateChannel() {
+        return _driver->allocateChannel();
+}
+
+MidiChannel *MusicPlayer::getPercussionChannel() {
+        return _driver->getPercussionChannel();
+}
+
+} // End of Groovie namespace

engines/groovie/cursor.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 GROOVIE_CURSOR_H
+#define GROOVIE_CURSOR_H
+
+#include "common/system.h"
+#include "common/file.h"
+
+namespace Groovie {
+
+class Cursor {
+public:
+        virtual ~Cursor() {}
+        uint16 getFrames() { return _numFrames; }
+        virtual void enable() = 0;
+        virtual void showFrame(uint16 frame) = 0;
+
+protected:
+        uint16 _width;
+        uint16 _height;
+        uint16 _numFrames;
+};
+
+class CursorMan {
+public:
+        CursorMan(OSystem *system);
+        virtual ~CursorMan();
+
+        virtual void animate();
+        virtual void setStyle(uint8 newStyle);
+        virtual uint8 getStyle();
+
+protected:
+        OSystem *_syst;
+
+        // Animation variables
+        uint8 _lastFrame;
+        uint32 _lastTime;
+
+        // Styles
+        Common::Array<Cursor *> _cursors;
+        uint8 _current;
+        Cursor *_cursor;
+};
+
+class CursorMan_t7g : public CursorMan {
+public:
+        CursorMan_t7g(OSystem *system);
+        ~CursorMan_t7g();
+
+private:
+        // Styles data
+        static const uint _cursorImg[];
+        static const uint _cursorPal[];
+
+        // Cursors data
+        Common::Array<byte *> _images;
+        Common::Array<byte *> _palettes;
+
+        // Loading functions
+        byte *loadImage(Common::File &file);
+        byte *loadPalette(Common::File &file);
+};
+
+class CursorMan_v2 : public CursorMan {
+public:
+        CursorMan_v2(OSystem *system);
+        ~CursorMan_v2();
+};
+
+} // End of Groovie namespace
+
+#endif // GROOVIE_CURSOR_H

engines/groovie/music.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 GROOVIE_MUSIC_H
+#define GROOVIE_MUSIC_H
+
+#include "groovie/groovie.h"
+
+#include "sound/mididrv.h"
+#include "sound/midiparser.h"
+
+namespace Groovie {
+
+class MusicPlayer : public MidiDriver {
+public:
+        MusicPlayer(GroovieEngine *vm);
+        ~MusicPlayer();
+        void playSong(uint16 fileref);
+        void setBackgroundSong(uint16 fileref);
+
+        // Volume
+        void setUserVolume(uint16 volume);
+        void setGameVolume(uint16 volume, uint16 time);
+private:
+        uint16 _userVolume;
+        uint16 _gameVolume;
+        byte _chanVolumes[0x10];
+        void updateChanVolume(byte channel);
+
+public:
+        // MidiDriver interface
+        int open();
+        void close();
+        void send(uint32 b);
+        void metaEvent(byte type, byte *data, uint16 length);
+        void setTimerCallback(void *timer_param, Common::TimerManager::TimerProc timer_proc);
+        uint32 getBaseTempo(void);
+        MidiChannel *allocateChannel();
+        MidiChannel *getPercussionChannel();
+
+private:
+        GroovieEngine *_vm;
+        byte *_data;
+        MidiParser *_midiParser;
+        MidiDriver *_driver;
+
+        uint16 _backgroundFileRef;
+
+        bool play(uint16 fileref, bool loop);
+        bool load(uint16 fileref);
+        void unload();
+};
+
+} // End of Groovie namespace
+
+#endif // GROOVIE_MUSIC_H

engines/groovie/jpeg.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 "groovie/groovie.h"
+#include "groovie/jpeg.h"
+
+#include "common/util.h"
+
+namespace Groovie {
+
+// Order used to traverse the quantization tables
+uint8 JPEG::_zigZagOrder[64] = {
+        0,   1,  8, 16,  9,  2,  3, 10,
+        17, 24, 32, 25, 18, 11,  4,  5,
+        12, 19, 26, 33, 40, 48, 41, 34,
+        27, 20, 13,  6,  7, 14, 21, 28,
+        35, 42, 49, 56, 57, 50, 43, 36,
+        29, 22, 15, 23, 30, 37, 44, 51,
+        58, 59, 52, 45, 38, 31, 39, 46,
+        53, 60, 61, 54, 47, 55, 62, 63
+};
+
+JPEG::JPEG() :
+        _str(NULL), _w(0), _h(0), _numComp(0), _components(NULL), _numScanComp(0),
+        _scanComp(NULL), _currentComp(NULL) {
+
+        // Initialize the quantization tables
+        for (int i = 0; i < JPEG_MAX_QUANT_TABLES; i++) {
+                _quant[i] = NULL;
+        }
+
+        // Initialize the Huffman tables
+        for (int i = 0; i < 2 * JPEG_MAX_HUFF_TABLES; i++) {
+                _huff[i].count = 0;
+                _huff[i].values = NULL;
+                _huff[i].sizes = NULL;
+                _huff[i].codes = NULL;
+        }
+}
+
+JPEG::~JPEG() {
+        reset();
+}
+
+void JPEG::reset() {
+        // Reset member variables
+        _str = NULL;
+        _w = _h = 0;
+
+        // Free the components
+        if (_components) {
+                delete[] _components;
+                _components = NULL;
+        }
+        _numComp = 0;
+
+        // Free the scan components
+        if (_scanComp) {
+                delete[] _scanComp;
+                _scanComp = NULL;
+        }
+        _numScanComp = 0;
+        _currentComp = NULL;
+
+        // Free the quantization tables
+        for (int i = 0; i < JPEG_MAX_QUANT_TABLES; i++) {
+                if (_quant[i]) {
+                        delete[] _quant[i];
+                        _quant[i] = NULL;
+                }
+        }
+
+        // Free the Huffman tables
+        for (int i = 0; i < 2 * JPEG_MAX_HUFF_TABLES; i++) {
+                _huff[i].count = 0;
+                if (_huff[i].values) {
+                        delete[] _huff[i].values;
+                        _huff[i].values = NULL;
+                }
+                if (_huff[i].sizes) {
+                        delete[] _huff[i].sizes;
+                        _huff[i].sizes = NULL;
+                }
+                if (_huff[i].codes) {
+                        delete[] _huff[i].codes;
+                        _huff[i].codes = NULL;
+                }
+        }
+}
+
+bool JPEG::read(Common::ReadStream *str) {
+        // Reset member variables and tables from previous reads
+        reset();
+
+        // Save the input stream
+        _str = str;
+
+        bool ok = true;
+        while (!_str->eos() && ok) {
+                // Read the marker
+                uint16 marker = _str->readByte();
+                if (marker != 0xFF) {
+                        error("Groovie::JPEG: Invalid marker[0]: 0x%02X", marker);
+                        ok = false;
+                        break;
+                }
+                while (marker == 0xFF) {
+                        marker = _str->readByte();
+                }
+
+                // Process the marker data
+                switch (marker) {
+                case 0xC0: // Start Of Frame
+                        ok = readSOF0();
+                        break;
+                case 0xC4: // Define Huffman Tables
+                        ok = readDHT();
+                        break;
+                case 0xD8: // Start Of Image
+                case 0xD9: // End Of Image
+                        break;
+                case 0xDA: // Start Of Scan
+                        ok = readSOS();
+                        break;
+                case 0xDB: // Define Quantization Tables
+                        ok = readDQT();
+                        break;
+                default: { // Unknown marker
+                        uint16 size = _str->readUint16BE();
+                        warning("Groovie::JPEG: Unknown marker %02X, skipping %d bytes", marker, size);
+                        for (int i = 2; i < size; i++) {
+                                _str->readByte();
+                        }
+                }
+                }
+        }
+        return ok;
+}
+
+// Marker 0xC0 (Start Of Frame, Baseline DCT)
+bool JPEG::readSOF0() {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::JPEG: readSOF0");
+        uint16 size = _str->readUint16BE();
+
+        // Read the sample precision
+        uint8 precision = _str->readByte();
+        if (precision != 8) {
+                warning("Groovie::JPEG: Just 8 bit precision supported at the moment");
+                return false;
+        }
+
+        // Image size
+        _h = _str->readUint16BE();
+        _w = _str->readUint16BE();
+
+        // Number of components
+        _numComp = _str->readByte();
+        if (size != 8 + 3 * _numComp) {
+                warning("Groovie::JPEG: Invalid number of components");
+                return false;
+        }
+
+        // Allocate the new components
+        if (_components) {
+                delete[] _components;
+        }
+        _components = new Component[_numComp];
+
+        // Read the components details
+        for (int c = 0; c < _numComp; c++) {
+                _components[c].id = _str->readByte();
+                _components[c].factorH = _str->readByte();
+                _components[c].factorV = _components[c].factorH & 0xF;
+                _components[c].factorH >>= 4;
+                _components[c].quantTableSelector = _str->readByte();
+        }
+
+        return true;
+}
+
+// Marker 0xC4 (Define Huffman Tables)
+bool JPEG::readDHT() {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::JPEG: readDHT");
+        uint16 size = _str->readUint16BE();
+
+        // Read the table type and id
+        uint8 tableId = _str->readByte();
+        uint8 tableType = tableId >> 4; // type 0: DC, 1: AC
+        tableId &= 0xF;
+        uint8 tableNum = (tableId << 1) + tableType;
+
+        // Free the Huffman table
+        if (_huff[tableNum].values) {
+                delete[] _huff[tableNum].values;
+                _huff[tableNum].values = NULL;
+        }
+        if (_huff[tableNum].sizes) {
+                delete[] _huff[tableNum].sizes;
+                _huff[tableNum].sizes = NULL;
+        }
+        if (_huff[tableNum].codes) {
+                delete[] _huff[tableNum].codes;
+                _huff[tableNum].codes = NULL;
+        }
+
+        // Read the number of values for each length
+        uint8 numValues[16];
+        _huff[tableNum].count = 0;
+        for (int len = 0; len < 16; len++) {
+                numValues[len] = _str->readByte();
+                _huff[tableNum].count += numValues[len];
+        }
+
+        // Verify the number of bytes to read
+        if (size != _huff[tableNum].count + 19) {
+                warning("Groovie::JPEG: Invalid number of values in the Huffman table");
+                return false;
+        }
+
+        // Allocate memory for the current table
+        _huff[tableNum].values = new uint8[_huff[tableNum].count];
+        _huff[tableNum].sizes = new uint8[_huff[tableNum].count];
+        _huff[tableNum].codes = new uint16[_huff[tableNum].count];
+
+        // Read the table contents
+        int cur = 0;
+        for (int len = 0; len < 16; len++) {
+                for (int i = 0; i < numValues[len]; i++) {
+                        _huff[tableNum].values[cur] = _str->readByte();
+                        _huff[tableNum].sizes[cur] = len + 1;
+                        cur++;
+                }
+        }
+
+        // Fill the table of Huffman codes
+        cur = 0;
+        uint16 curCode = 0;
+        uint8 curCodeSize = _huff[tableNum].sizes[0];
+        while (cur < _huff[tableNum].count) {
+                // Increase the code size to fit the request
+                while (_huff[tableNum].sizes[cur] != curCodeSize) {
+                        curCode <<= 1;
+                        curCodeSize++;
+                }
+
+                // Assign the current code
+                _huff[tableNum].codes[cur] = curCode;
+                curCode++;
+                cur++;
+        }
+
+        return true;
+}
+
+// Marker 0xDA (Start Of Scan)
+bool JPEG::readSOS() {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::JPEG: readSOS");
+        uint16 size = _str->readUint16BE();
+
+        // Number of scan components
+        _numScanComp = _str->readByte();
+        if (size != 6 + 2 * _numScanComp) {
+                warning("Groovie::JPEG: Invalid number of components");
+                return false;
+        }
+
+        // Allocate the new scan components
+        if (_scanComp) {
+                delete[] _scanComp;
+        }
+        _scanComp = new Component *[_numScanComp];
+
+        // Reset the maximum sampling factors
+        _maxFactorV = 0;
+        _maxFactorH = 0;
+
+        // Component-specification parameters
+        for (int c = 0; c < _numScanComp; c++) {
+                // Read the desired component id
+                uint8 id = _str->readByte();
+
+                // Search the component with the specified id
+                bool found = false;
+                for (int i = 0; !found && i < _numComp; i++) {
+                        if (_components[i].id == id) {
+                                // We found the desired component
+                                found = true;
+
+                                // Assign the found component to the c'th scan component
+                                _scanComp[c] = &_components[i];
+                        }
+                }
+                if (!found) {
+                        warning("Groovie::JPEG: Invalid component");
+                        return false;
+                }
+
+                // Read the entropy table selectors
+                _scanComp[c]->DCentropyTableSelector = _str->readByte();
+                _scanComp[c]->ACentropyTableSelector = _scanComp[c]->DCentropyTableSelector & 0xF;
+                _scanComp[c]->DCentropyTableSelector >>= 4;
+
+                // Calculate the maximum sampling factors
+                if (_scanComp[c]->factorV > _maxFactorV) {
+                        _maxFactorV = _scanComp[c]->factorV;
+                }
+                if (_scanComp[c]->factorH > _maxFactorH) {
+                        _maxFactorH = _scanComp[c]->factorH;
+                }
+
+                // Initialize the DC predictor
+                _scanComp[c]->DCpredictor = 0;
+        }
+
+        // Start of spectral selection
+        if (_str->readByte() != 0) {
+                warning("Groovie::JPEG: Progressive scanning not supported");
+                return false;
+        }
+
+        // End of spectral selection
+        if (_str->readByte() != 63) {
+                warning("Groovie::JPEG: Progressive scanning not supported");
+                return false;
+        }
+
+        // Successive approximation parameters
+        if (_str->readByte() != 0) {
+                warning("Groovie::JPEG: Progressive scanning not supported");
+                return false;
+        }
+
+        // Entropy coded sequence starts, initialize Huffman decoder
+        _bitsNumber = 0;
+
+        // Read all the scan MCUs
+        uint16 xMCU = _w / (_maxFactorH * 8);
+        uint16 yMCU = _h / (_maxFactorV * 8);
+        bool ok = true;
+        for (int y = 0; ok && (y < yMCU); y++) {
+                for (int x = 0; ok && (x < xMCU); x++) {
+                        ok = readMCU(x, y);
+                }
+        }
+
+        return ok;
+}
+
+// Marker 0xDB (Define Quantization Tables)
+bool JPEG::readDQT() {
+        debugC(5, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::JPEG: readDQT");
+        uint16 size = _str->readUint16BE();
+        if (size - 3 != 64) {
+                warning("Groovie::JPEG: (TODO) Trying to define several quantization tables on the same block");
+                return false;
+        }
+
+        // Read the table precision and id
+        uint8 tableId = _str->readByte();
+        if (tableId & 0xF0) {
+                // Precision = 1 -> 16 bits per element
+                warning("Groovie::JPEG: Just 8 bit precision supported at the moment");
+                return false;
+        }
+
+        // Validate the table id
+        tableId &= 0xF;
+        if (tableId > JPEG_MAX_QUANT_TABLES) {
+                warning("Groovie::JPEG: Invalid number of components");
+                return false;
+        }
+
+        // Create the new table if necessary
+        if (!_quant[tableId]) {
+                _quant[tableId] = new uint8[64];
+        }
+
+        // Read the table in Zig-Zag order
+        for (int i = 0; i < 64; i++) {
+                _quant[tableId][_zigZagOrder[i]] = _str->readByte();
+        }
+
+        return true;
+}
+
+bool JPEG::readMCU(uint16 xMCU, uint16 yMCU) {
+        bool ok = true;
+        for (int c = 0; ok && (c < _numComp); c++) {
+                // Set the current component
+                _currentComp = _scanComp[c];
+
+                // Read the data units of the current component
+                for (int y = 0; ok && (y < _scanComp[c]->factorV); y++) {
+                        for (int x = 0; ok && (x < _scanComp[c]->factorH); x++) {
+                                ok = readDataUnit(xMCU * _scanComp[c]->factorH + x, yMCU * _scanComp[c]->factorV + y);
+                        }
+                }
+        }
+        //printf("MCU(%d,%d) ", xMCU, yMCU);
+
+        return ok;
+}
+
+bool JPEG::readDataUnit(uint16 x, uint16 y) {
+        // Prepare an empty data array
+        int8 readData[64];
+        for (int i = 1; i < 64; i++) {
+                readData[i] = 0;
+        }
+
+        // Read the DC component
+        readData[0] = _currentComp->DCpredictor + readDC();
+        _currentComp->DCpredictor = readData[0];
+
+        // Read the AC components
+        readAC(readData);
+
+        // Calculate the DCT coefficients from the input sequence
+        uint16 _DCT[64];
+        for (int i = 0; i < 64; i++) {
+                // Dequantize
+                int16 val = readData[i];
+                int16 quant = _quant[_currentComp->quantTableSelector][i];
+                val *= quant;
+
+                // Store the normalized coefficients in the Zig-Zag order
+                _DCT[_zigZagOrder[i]] = val;
+        }
+
+        // TODO: apply the IDCT PAG31
+
+        // Level shift to make the values unsigned
+        for (int i = 0; i < 64; i++) {
+                _DCT[i] += 128;
+        }
+
+        if (_currentComp->id == 1) {
+                // HACK: show the DC luminance!
+                for (int j = 0; j < 8 * _maxFactorV / _currentComp->factorV; j++) {
+                        for (int i = 0; i < 8 * _maxFactorH / _currentComp->factorH; i++) {
+                                // TODO
+                                // paint (x + i, y + j)
+                        }
+                }
+        }
+
+        return true;
+}
+
+int8 JPEG::readDC() {
+        // DC is type 0
+        uint8 tableNum = _currentComp->DCentropyTableSelector << 1;
+
+        // Get the number of bits to read
+        uint8 numBits = readHuff(tableNum);
+
+        // Read the requested bits
+        return readSignedBits(numBits);
+}
+
+void JPEG::readAC(int8 *out) {
+        // AC is type 1
+        uint8 tableNum = (_currentComp->ACentropyTableSelector << 1) + 1;
+
+        // Start reading AC element 1
+        uint8 cur = 1;
+        while (cur < 64) {
+                uint8 s = readHuff(tableNum);
+                uint8 r = s >> 4;
+                s &= 0xF;
+
+                if (s == 0) {
+                        if (r == 15) {
+                                // Skip 16 values
+                                cur += 16;
+                        } else {
+                                // EOB: end of block
+                                cur = 64;
+                        }
+                } else {
+                        // Skip r values
+                        cur += r;
+
+                        // Read the next value
+                        out[cur] = readSignedBits(s);
+                        cur++;
+                }
+        }
+}
+
+int16 JPEG::readSignedBits(uint8 numBits) {
+        uint16 ret = 0;
+        if (numBits > 8) error("requested %d bits", numBits); //XXX
+
+        //MSB=0 for negatives, 1 for positives
+        for (int i = 0; i < numBits; i++) {
+                ret = (ret << 1) + readBit();
+        }
+
+        // TODO: extend sign bits: PAG109
+
+        return ret;
+}
+
+// TODO: optimize?
+uint8 JPEG::readHuff(uint8 table) {
+        bool foundCode = false;
+        uint8 val = 0;
+
+        uint8 cur = 0;
+        uint8 codeSize = 1;
+        uint16 code = readBit();
+        while (!foundCode) {
+                // Prepare a code of the current size
+                while (codeSize < _huff[table].sizes[cur]) {
+                        code = (code << 1) + readBit();
+                        codeSize++;
+                }
+
+                // Compare the codes of the current size
+                while (!foundCode && (codeSize == _huff[table].sizes[cur])) {
+                        if (code == _huff[table].codes[cur]) {
+                                // Found the code
+                                val = _huff[table].values[cur];
+                                foundCode = true;
+                        } else {
+                                // Continue reading
+                                cur++;
+                        }
+                }
+        }
+
+        return val;
+}
+
+uint8 JPEG::readBit() {
+        // Read a whole byte if necessary
+        if (_bitsNumber == 0) {
+                _bitsData = _str->readByte();
+                _bitsNumber = 8;
+
+                // Detect markers
+                if (_bitsData == 0xFF) {
+                        uint8 byte2 = _str->readByte();
+
+                        // A stuffed 0 validates the previous byte
+                        if (byte2 != 0) {
+                                if (byte2 == 0xDC) {
+                                        // DNL marker: Define Number of Lines
+                                        // TODO: terminate scan
+                                        printf("DNL marker detected: terminate scan\n");
+                                } else {
+                                        printf("Error: marker 0x%02X read in entropy data\n", byte2);
+                                }
+                        }
+                }
+        }
+        _bitsNumber--;
+
+        return (_bitsData & (1 << _bitsNumber)) ? 1 : 0;
+}
+
+} // End of Groovie namespace

engines/groovie/debug.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 "groovie/debug.h"
+#include "groovie/script.h"
+#include "groovie/groovie.h"
+
+namespace Groovie {
+
+Debugger::Debugger(GroovieEngine *vm) :
+        _vm (vm), _script(&_vm->_script), _syst(_vm->_system) {
+
+        // Register the debugger comands
+        DCmd_Register("step", WRAP_METHOD(Debugger, cmd_step));
+        DCmd_Register("go", WRAP_METHOD(Debugger, cmd_go));
+        DCmd_Register("pc", WRAP_METHOD(Debugger, cmd_pc));
+        DCmd_Register("fg", WRAP_METHOD(Debugger, cmd_fg));
+        DCmd_Register("bg", WRAP_METHOD(Debugger, cmd_bg));
+        DCmd_Register("mem", WRAP_METHOD(Debugger, cmd_mem));
+        DCmd_Register("load", WRAP_METHOD(Debugger, cmd_loadgame));
+        DCmd_Register("save", WRAP_METHOD(Debugger, cmd_savegame));
+        DCmd_Register("playref", WRAP_METHOD(Debugger, cmd_playref));
+        DCmd_Register("dumppal", WRAP_METHOD(Debugger, cmd_dumppal));
+}
+
+Debugger::~Debugger() {
+        Common::clearAllSpecialDebugLevels();
+}
+
+int Debugger::getNumber(const char *arg) {
+        return strtol(arg, (char **)NULL, 0);
+}
+
+bool Debugger::cmd_step(int argc, const char **argv) {
+        _script->step();
+        return true;
+}
+
+bool Debugger::cmd_go(int argc, const char **argv) {
+        _script->step();
+        return false;
+}
+
+bool Debugger::cmd_fg(int argc, const char **argv) {
+        _vm->_graphicsMan->updateScreen(&_vm->_graphicsMan->_foreground);
+        return false;
+}
+
+bool Debugger::cmd_bg(int argc, const char **argv) {
+        _vm->_graphicsMan->updateScreen(&_vm->_graphicsMan->_background);
+        return false;
+}
+
+bool Debugger::cmd_pc(int argc, const char **argv) {
+        if (argc == 2) {
+                int val = getNumber(argv[1]);
+                _script->_currentInstruction = val;
+        }
+        DebugPrintf("pc = 0x%04X\n", _script->_currentInstruction);
+        return true;
+}
+
+bool Debugger::cmd_mem(int argc, const char **argv) {
+        if (argc >= 2) {
+                int pos = getNumber(argv[1]);
+                uint8 val;
+                if (argc >= 3) {
+                        // Set
+                        val = getNumber(argv[2]);
+                        _script->_variables[pos] = val;
+                } else {
+                        // Get
+                        val = _script->_variables[pos];
+                }
+                DebugPrintf("mem[0x%04X] = 0x%02X\n", pos, val);
+        } else {
+                DebugPrintf("Syntax: mem <addr> [<val>]\n");
+        }
+        return true;
+}
+
+bool Debugger::cmd_loadgame(int argc, const char **argv) {
+        if (argc == 2) {
+                int slot = getNumber(argv[1]);
+                _script->loadgame(slot);
+        } else {
+                DebugPrintf("Syntax: load <slot>\n");
+        }
+        return true;
+}
+
+bool Debugger::cmd_savegame(int argc, const char **argv) {
+        if (argc == 2) {
+                int slot = getNumber(argv[1]);
+                _script->savegame(slot);
+        } else {
+                DebugPrintf("Syntax: save <slot>\n");
+        }
+        return true;
+}
+
+bool Debugger::cmd_playref(int argc, const char **argv) {
+        if (argc == 2) {
+                int ref = getNumber(argv[1]);
+                _script->playvideofromref(ref);
+        } else {
+                DebugPrintf("Syntax: playref <videorefnum>\n");
+        }
+        return true;
+}
+
+bool Debugger::cmd_dumppal(int argc, const char **argv) {
+        uint16 i;
+        byte palettedump[256 * 4];
+        _syst->grabPalette(palettedump, 0, 256);
+
+        for (i = 0; i < 256; i++) {
+                printf("%3d: %3d,%3d,%3d,%3d\n", i, palettedump[(i * 4)], palettedump[(i * 4) + 1], palettedump[(i * 4) + 2], palettedump[(i * 4) + 3]);
+                DebugPrintf("%3d: %3d,%3d,%3d,%3d\n", i, palettedump[(i * 4)], palettedump[(i * 4) + 1], palettedump[(i * 4) + 2], palettedump[(i * 4) + 3]);
+        }
+        return true;
+}
+
+} // End of Groovie namespace

engines/groovie/resource.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 "groovie/groovie.h"
+#include "groovie/resource.h"
+
+namespace Groovie {
+
+// ResMan
+
+Common::SeekableReadStream *ResMan::open(uint16 fileRef) {
+        // Get the information about the resource
+        ResInfo resInfo;
+        if (!getResInfo(fileRef, resInfo)) {
+                return NULL;
+        }
+
+        // Do we know the name of the required GJD?
+        if (resInfo.gjd >= _gjds.size()) {
+                error("Groovie::Resource: Unknown GJD %d", resInfo.gjd);
+                return NULL;
+        }
+
+        debugC(1, kGroovieDebugResource | kGroovieDebugAll, "Groovie::Resource: Opening resource 0x%04X (%s, %d, %d)", fileRef, _gjds[resInfo.gjd].c_str(), resInfo.offset, resInfo.size);
+
+        // Does it exist?
+        if (!Common::File::exists(_gjds[resInfo.gjd])) {
+                error("Groovie::Resource: %s not found", _gjds[resInfo.gjd].c_str());
+                return NULL;
+        }
+
+        // Open the pack file
+        Common::File *gjdFile = new Common::File();
+        if (!gjdFile->open(_gjds[resInfo.gjd].c_str())) {
+                delete gjdFile;
+                error("Groovie::Resource: Couldn't open %s", _gjds[resInfo.gjd].c_str());
+                return NULL;
+        }
+
+        // Save the used gjd file (except xmi and gamwav)
+        if (resInfo.gjd < 19) {
+                _lastGjd = resInfo.gjd;
+        }
+
+        // Returning the resource substream
+        return new Common::SeekableSubReadStream(gjdFile, resInfo.offset, resInfo.offset + resInfo.size, true);
+}
+
+
+// ResMan_t7g
+
+static const char t7g_gjds[][0x15] = {"at", "b", "ch", "d", "dr", "fh", "ga", "hdisk", "htbd", "intro", "jhek", "k", "la", "li", "mb", "mc", "mu", "n", "p", "xmi", "gamwav"};
+
+ResMan_t7g::ResMan_t7g() {
+        for (int i = 0; i < 0x15; i++) {
+                // Prepare the filename
+                Common::String filename = t7g_gjds[i];
+                filename += ".gjd";
+
+                // Append it to the list of GJD files
+                _gjds.push_back(filename);
+        }
+}
+
+uint16 ResMan_t7g::getRef(Common::String name, Common::String scriptname) {
+        // Get the name of the RL file
+        Common::String rlFileName(t7g_gjds[_lastGjd]);
+        rlFileName += ".rl";
+
+        // Open the RL file
+        Common::File rlFile;
+        if (!rlFile.open(rlFileName)) {
+                error("Groovie::Resource: Couldn't open %s", rlFileName.c_str());
+                return false;
+        }
+
+        uint16 resNum;
+        bool found = false;
+        for (resNum = 0; !found && !rlFile.ioFailed(); resNum++) {
+                // Read the resource name
+                char readname[12];
+                rlFile.read(readname, 12);
+
+                // Test whether it's the resource we're searching
+                Common::String resname(readname, 12);
+                if (resname.hasPrefix(name.c_str())) {
+                        debugC(2, kGroovieDebugResource | kGroovieDebugAll, "Groovie::Resource: Resource %12s matches %s", readname, name.c_str());
+                        found = true;
+                }
+
+                // Skip the rest of resource information
+                rlFile.read(readname, 8);
+        }
+
+        // Close the RL file
+        rlFile.close();
+
+        // Verify we really found the resource
+        if (!found) {
+                error("Groovie::Resource: Couldn't find resource %s in %s", name.c_str(), rlFileName.c_str());
+                return (uint16)-1;
+        }
+
+        return (_lastGjd << 10) | (resNum - 1);
+}
+
+bool ResMan_t7g::getResInfo(uint16 fileRef, ResInfo &resInfo) {
+        // Calculate the GJD and the resource number
+        resInfo.gjd = fileRef >> 10;
+        uint16 resNum = fileRef & 0x3FF;
+
+        // Get the name of the RL file
+        Common::String rlFileName(t7g_gjds[resInfo.gjd]);
+        rlFileName += ".rl";
+
+        // Open the RL file
+        Common::File rlFile;
+        if (!rlFile.open(rlFileName)) {
+                error("Groovie::Resource: Couldn't open %s", rlFileName.c_str());
+                return false;
+        }
+
+        // Seek to the position of the desired resource
+        rlFile.seek(resNum * 20);
+        if (rlFile.eos()) {
+                rlFile.close();
+                error("Groovie::Resource: Invalid resource number: 0x%04X (%s)", resNum, rlFileName.c_str());
+                return false;
+        }
+
+        // Read the resource name (just for debugging purposes)
+        char resname[12];
+        rlFile.read(resname, 12);
+        debugC(2, kGroovieDebugResource | kGroovieDebugAll, "Groovie::Resource: Resource name: %12s", resname);
+
+        // Read the resource information
+        resInfo.offset = rlFile.readUint32LE();
+        resInfo.size = rlFile.readUint32LE();
+
+        // Close the resource RL file
+        rlFile.close();
+
+        return true;
+}
+
+
+// ResMan_v2
+
+ResMan_v2::ResMan_v2() {
+        Common::File indexfile;
+
+        // Open the GJD index file
+        if (!indexfile.open("gjd.gjd")) {
+                error("Groovie::Resource: Couldn't open gjd.gjd");
+                return;
+        }
+
+        Common::String line = indexfile.readLine();
+        while (!indexfile.eos() && !line.empty()) {
+                // Get the name before the space
+                Common::String filename;
+                for (const char *cur = line.c_str(); *cur != ' '; cur++) {
+                        filename += *cur;
+                }
+
+                // Append it to the list of GJD files
+                if (!filename.empty()) {
+                        _gjds.push_back(filename);
+                }
+
+                // Read the next line
+                line = indexfile.readLine();
+        }
+
+        // Close the GJD index file
+        indexfile.close();
+}
+
+uint16 ResMan_v2::getRef(Common::String name, Common::String scriptname) {
+        return 0;
+}
+
+bool ResMan_v2::getResInfo(uint16 fileRef, ResInfo &resInfo) {
+        // Open the RL file
+        Common::File rlFile;
+        if (!rlFile.open("dir.rl")) {
+                error("Groovie::Resource: Couldn't open dir.rl");
+                return false;
+        }
+
+        // Seek to the position of the desired resource
+        rlFile.seek(fileRef * 32);
+        if (rlFile.eos()) {
+                rlFile.close();
+                error("Groovie::Resource: Invalid resource number: 0x%04X", fileRef);
+                return false;
+        }
+
+        // Read the resource information
+        rlFile.readUint32LE(); // Unknown
+        resInfo.offset = rlFile.readUint32LE();
+        resInfo.size = rlFile.readUint32LE();
+        resInfo.gjd = rlFile.readUint16LE();
+
+        // Read the resource name (just for debugging purposes)
+        char resname[12];
+        rlFile.read(resname, 12);
+        debugC(2, kGroovieDebugResource | kGroovieDebugAll, "Groovie::Resource: Resource name: %12s", resname);
+
+        // 6 padding bytes? (it looks like they're always 0)
+
+        // Close the resource RL file
+        rlFile.close();
+
+        return true;
+}
+
+} // End of Groovie namespace

engines/groovie/jpeg.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 GROOVIE_JPEG_H
+#define GROOVIE_JPEG_H
+
+#include "common/stream.h"
+
+namespace Groovie {
+
+#define JPEG_MAX_QUANT_TABLES 4
+#define JPEG_MAX_HUFF_TABLES 2
+
+class JPEG {
+public:
+        JPEG();
+        ~JPEG();
+
+        bool read(Common::ReadStream *str);
+
+private:
+        void reset();
+
+        Common::ReadStream *_str;
+        uint16 _w, _h;
+
+        // Image components
+        uint8 _numComp;
+        struct Component {
+                // Global values
+                uint8 id;
+                uint8 factorH;
+                uint8 factorV;
+                uint8 quantTableSelector;
+
+                // Scan specific values
+                uint8 DCentropyTableSelector;
+                uint8 ACentropyTableSelector;
+                int8 DCpredictor;
+        };
+        Component *_components;
+
+        // Scan components
+        uint8 _numScanComp;
+        Component **_scanComp;
+        Component *_currentComp;
+
+        // Maximum sampling factors, used to calculate the interleaving of the MCU
+        uint8 _maxFactorV;
+        uint8 _maxFactorH;
+
+        // Zig-Zag order
+        static uint8 _zigZagOrder[64];
+
+        // Quantization tables
+        uint8 *_quant[JPEG_MAX_QUANT_TABLES];
+
+        // Huffman tables
+        struct HuffmanTable {
+                uint8 count;
+                uint8 *values;
+                uint8 *sizes;
+                uint16 *codes;
+        };
+        HuffmanTable _huff[2 * JPEG_MAX_HUFF_TABLES];
+
+        // Marker read functions
+        bool readSOF0();
+        bool readDHT();
+        bool readSOS();
+        bool readDQT();
+
+        // Helper functions
+        bool readMCU(uint16 xMCU, uint16 yMCU);
+        bool readDataUnit(uint16 x, uint16 y);
+        int8 readDC();
+        void readAC(int8 *out);
+        int16 readSignedBits(uint8 numBits);
+
+        // Huffman decoding
+        uint8 readHuff(uint8 table);
+        uint8 readBit();
+        uint8 _bitsData;
+        uint8 _bitsNumber;
+};
+
+} // End of Groovie namespace
+
+#endif // GROOVIE_JPEG_H

engines/groovie/debug.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 GROOVIE_DEBUG_H
+#define GROOVIE_DEBUG_H
+
+#include "gui/debugger.h"
+#include "engines/engine.h"
+
+namespace Groovie {
+
+class Script;
+class GroovieEngine;
+
+class Debugger : public GUI::Debugger {
+public:
+        Debugger(GroovieEngine *vm);
+        ~Debugger();
+
+private:
+        GroovieEngine *_vm;
+        Script *_script;
+        OSystem *_syst;
+
+        int getNumber(const char *arg);
+
+        bool cmd_step(int argc, const char **argv);
+        bool cmd_go(int argc, const char **argv);
+        bool cmd_pc(int argc, const char **argv);
+        bool cmd_bg(int argc, const char **argv);
+        bool cmd_fg(int argc, const char **argv);
+        bool cmd_mem(int argc, const char **argv);
+        bool cmd_loadgame(int argc, const char **argv);
+        bool cmd_savegame(int argc, const char **argv);
+        bool cmd_playref(int argc, const char **argv);
+        bool cmd_dumppal(int argc, const char **argv);
+};
+
+} // End of Groovie namespace
+
+#endif // GROOVIE_DEBUG_H

engines/groovie/lzss.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 "groovie/lzss.h"
+
+#define OUT_BUFF_SIZE 131072
+#define COMP_THRESH 3 // Compression not attempted if string to be compressed is less than 3 long
+
+LzssReadStream::LzssReadStream(Common::ReadStream *indata, uint8 lengthmask, uint8 lengthbits) {
+        /*
+        TODO: Nasty hack. Make a buffer bigger than I'll ever need... probably.
+        What should *really* happen is I should define a whole new type of stream
+        that gets lzss decompressed on the fly
+        */
+        _outLzssBufData = (uint8 *)malloc(OUT_BUFF_SIZE);
+        _size = decodeLZSS(indata, lengthmask, lengthbits);
+        _pos = 0;
+}
+
+LzssReadStream::~LzssReadStream() {
+        free(_outLzssBufData);
+}
+
+uint32 LzssReadStream::decodeLZSS(Common::ReadStream *in, uint8 lengthmask, uint8 lengthbits) {
+        uint32 N = 1 << (16 - lengthbits); /* History buffer size */
+        byte *histbuff = new byte[N]; /* History buffer */
+        memset(histbuff, 0, N);
+        uint32 outstreampos = 0;
+        uint32 bufpos = 0;
+
+        while (!in->eos()) {
+                byte flagbyte = in->readByte();
+                for (uint32 i = 1; i <= 8; i++) {
+                        if (!in->eos()) {
+                                if ((flagbyte & 1) == 0) {
+                                        uint32 offsetlen = in->readUint16LE();
+                                        if (offsetlen == 0) {
+                                                break;
+                                        }
+                                        uint32 length = (offsetlen & lengthmask) + COMP_THRESH;
+                                        uint32 offset = (bufpos - (offsetlen >> lengthbits)) & (N - 1);
+                                        for (uint32 j = 0; j < length; j++) {
+                                                byte tempa = histbuff[(offset + j) & (N - 1)];
+                                                _outLzssBufData[outstreampos++] = tempa;
+                                                histbuff[bufpos] = tempa;
+                                                bufpos = (bufpos + 1) & (N - 1);
+                                        }
+                                } else {
+                                        byte tempa = in->readByte();
+                                        if (in->eos()) {
+                                                break;
+                                        }
+                                        _outLzssBufData[outstreampos++] = tempa;
+                                        histbuff[bufpos] = tempa;
+                                        bufpos = (bufpos + 1) & (N - 1);
+                                }
+                                flagbyte = flagbyte >> 1;
+                        }
+                }
+        }
+        delete[] histbuff;
+        return outstreampos;
+}
+
+bool LzssReadStream::eos() const {
+        return _pos >= _size;
+}
+
+uint32 LzssReadStream::read(void *buf, uint32 size) {
+        if (size > _size - _pos)
+                size = _size - _pos;
+
+        memcpy(buf, &_outLzssBufData[_pos], size);
+        _pos += size;
+
+        return size;
+}

engines/groovie/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 "groovie/groovie.h"
+#include "groovie/player.h"
+
+namespace Groovie {
+
+VideoPlayer::VideoPlayer(GroovieEngine *vm) :
+        _vm(vm), _syst(vm->_system), _file(NULL), _audioStream(NULL) {
+}
+
+bool VideoPlayer::load(Common::SeekableReadStream *file, uint16 flags) {
+        _file = file;
+        _flags = flags;
+        _audioStream = NULL;
+
+        uint16 fps = loadInternal();
+
+        if (fps != 0) {
+                _millisBetweenFrames = 1000 / fps;
+                _begunPlaying = false;
+                return true;
+        } else {
+                _file = NULL;
+                return false;
+        }
+}
+
+bool VideoPlayer::playFrame() {
+        bool end = true;
+
+        // Process the next frame while the file is open
+        if (_file) {
+                end = playFrameInternal();
+        }
+
+        // The file has been completely processed
+        if (end) {
+                _file = NULL;
+
+                // Wait for pending audio
+                if (_audioStream) {
+                        if (_audioStream->endOfData()) {
+                                // Mark the audio stream as finished (no more data will be appended)
+                                _audioStream->finish();
+                        } else {
+                                // Don't end if there's still audio playing
+                                end = false;
+                        }
+                }
+        }
+
+        return end;
+}
+
+void VideoPlayer::waitFrame() {
+        uint32 currTime = _syst->getMillis();
+        if (!_begunPlaying) {
+                _begunPlaying = true;
+                _lastFrameTime = currTime;
+        } else {
+                uint32 millisDiff = currTime - _lastFrameTime;
+                if (millisDiff < _millisBetweenFrames) {
+                        debugC(7, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::Player: Delaying %d (currTime=%d, _lastFrameTime=%d, millisDiff=%d, _millisBetweenFrame=%d)",
+                                        _millisBetweenFrames - millisDiff, currTime, _lastFrameTime, millisDiff, _millisBetweenFrames);
+                        _syst->delayMillis(_millisBetweenFrames - millisDiff);
+                        currTime = _syst->getMillis();
+                        debugC(7, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::Player: Finished delay at %d", currTime);
+                }
+                debugC(6, kGroovieDebugVideo | kGroovieDebugAll, "Groovie::Player: Frame displayed at %d (%f FPS)", currTime, 1000.0 / (currTime - _lastFrameTime));
+                _lastFrameTime = currTime;
+        }
+}
+
+} // End of Groovie namespace

engines/groovie/resource.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 GROOVIE_RESOURCE_H
+#define GROOVIE_RESOURCE_H
+
+namespace Groovie {
+
+struct ResInfo {
+        uint16 gjd;
+        uint32 offset;
+        uint32 size;
+};
+
+class ResMan {
+public:
+        virtual ~ResMan() {};
+
+        Common::SeekableReadStream *open(uint16 fileRef);
+        virtual uint16 getRef(Common::String name, Common::String scriptname = "") = 0;
+
+protected:
+        Common::Array<Common::String> _gjds;
+        virtual bool getResInfo(uint16 fileRef, ResInfo &resInfo) = 0;
+
+        uint16 _lastGjd;
+};
+
+class ResMan_t7g : public ResMan {
+public:
+        ResMan_t7g();
+        ~ResMan_t7g() {};
+
+        uint16 getRef(Common::String name, Common::String scriptname);
+        bool getResInfo(uint16 fileRef, ResInfo &resInfo);
+};
+
+class ResMan_v2 : public ResMan {
+public:
+        ResMan_v2();
+        ~ResMan_v2() {};
+
+        uint16 getRef(Common::String name, Common::String scriptname);
+        bool getResInfo(uint16 fileRef, ResInfo &resInfo);
+};
+
+} // End of Groovie namespace
+
+#endif // GROOVIE_RESOURCE_H

base/plugins.cpp

@@ -108 +108 @@
                 #if PLUGIN_ENABLED_STATIC(GOB)
                 LINK_PLUGIN(GOB)
                 #endif
+                #if PLUGIN_ENABLED_STATIC(GROOVIE)
+                LINK_PLUGIN(GROOVIE)
+                #endif
                 #if PLUGIN_ENABLED_STATIC(IGOR)
                 LINK_PLUGIN(IGOR)
                 #endif