mve_decoder.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef VIDEO_MVEDECODER_H
#define VIDEO_MVEDECODER_H

#include "audio/audiostream.h"
#include "video/video_decoder.h"
#include "graphics/surface.h"
#include "common/list.h"
#include "common/rect.h"
#include "common/memstream.h"

namespace Common {
class SeekableReadStream;
}

namespace Graphics {
struct PixelFormat;
}

class PaletteManager;

namespace Video {

class MveDecoder : public VideoDecoder {
    bool _done;
    Common::SeekableReadStream *_s;

    uint16 _packetLen;
    uint16 _packetKind;

    Graphics::Surface _decodeSurface0;
    Graphics::Surface _decodeSurface1;
    Graphics::Surface _frameSurface;

    uint16 _widthInBlocks;
    uint16 _heightInBlocks;

    uint16 _width;
    uint16 _height;

    Common::Rational _frameRate;

    bool      _trueColor;
    Graphics::PixelFormat _pixelFormat;
    bool      _dirtyPalette;
    uint16    _palStart;
    uint16    _palCount;
    byte      _palette[0x300];

    uint16    _skipMapSize;
    byte     *_skipMap;

    uint16    _decodingMapSize;
    byte     *_decodingMap;

    int       _frameNumber;
    uint16    _frameSize;
    byte     *_frameData;

    int _audioTrack;
    Audio::QueuingAudioStream *_audioStream;

    void readPacketHeader();
    void copyBlock_8bit(Graphics::Surface &dst, Common::MemoryReadStream &s, int block);
    void copyBlock_16bit(Graphics::Surface &dst, Common::MemoryReadStream &s, int block);
    void copyBlock(Graphics::Surface &dst, Graphics::Surface &src, int block, int offset = 0);
    void copyBlock(Graphics::Surface &dst, Graphics::Surface &src, int dx, int dy, int off_x, int off_y);

    void decodeFormat6();
    void decodeFormat10();

    class MveVideoTrack : public FixedRateVideoTrack {
        MveDecoder *_decoder;
    public:
        MveVideoTrack(MveDecoder *decoder);

        bool endOfTrack() const;

        uint16 getWidth() const;
        uint16 getHeight() const;

        Graphics::PixelFormat getPixelFormat() const;

        int getCurFrame() const;
        // int getFrameCount() const;

        const Graphics::Surface *decodeNextFrame();
        const byte *getPalette() const;
        bool hasDirtyPalette() const;

    protected:
        Common::Rational getFrameRate() const;
    };

    class MveAudioTrack : public AudioTrack {
        MveDecoder *_decoder;
    public:
        MveAudioTrack(MveDecoder *decoder);

        Audio::AudioStream *getAudioStream() const;
    };

    class MveSkipStream {
        Common::MemoryReadStream s;
        uint16 queue;
    public:
        MveSkipStream(byte *p, size_t sz)
            : s(p, sz), queue(0x8000)
        {}

        void reset() {
            s.seek(0);
            queue = 0x8000;
        }

        bool skip() {
            if (queue == 0x8000) {
                queue = s.readUint16LE();
                assert(queue != 0);
            }
            bool r = (queue & 0x8000) == 0;
            queue <<= 1;
            return r;
        }
    };

public:
    MveDecoder();
    virtual ~MveDecoder();

    bool loadStream(Common::SeekableReadStream *stream);
    void setAudioTrack(int track);
    void applyPalette(PaletteManager *paletteManager);

    // const Common::List<Common::Rect> *getDirtyRects() const;
    // void clearDirtyRects();
    // void copyDirtyRectsToBuffer(uint8 *dst, uint pitch);

    Common::Rational getFrameRate() { return _frameRate; }
    void readNextPacket();
};

} // End of namespace Video

#endif