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/palette.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;
    Graphics::Palette _palette;
 
    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 override;
 
        uint16 getWidth() const override;
        uint16 getHeight() const override;
 
        Graphics::PixelFormat getPixelFormat() const override;
 
        int getCurFrame() const override;
        // int getFrameCount() const;
 
        const Graphics::Surface *decodeNextFrame() override;
        const byte *getPalette() const override;
        bool hasDirtyPalette() const override;
 
    protected:
        Common::Rational getFrameRate() const override;
    };
 
    class MveAudioTrack : public AudioTrack {
        MveDecoder *_decoder;
    public:
        MveAudioTrack(MveDecoder *decoder);
 
        Audio::AudioStream *getAudioStream() const override;
    };
 
    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();
 
    void close() override;
    bool loadStream(Common::SeekableReadStream *stream) override;
    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() override;
};
 
} // End of namespace Video
 
#endif