coktel_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/>.
 *
 *
 * This file is dual-licensed.
 * In addition to the GPLv3 license mentioned above, this code is also
 * licensed under LGPL 2.1. See LICENSES/COPYING.LGPL file for the
 * full text of the license.
 *
 */
 
// Currently, only GOB and SCI32 games play IMDs and VMDs, so skip compiling if GOB and SCI32 is disabled.
#if !(defined(ENABLE_GOB) || defined(ENABLE_SCI32) || defined(DYNAMIC_MODULES))
 
// Do not compile the CoktelDecoder code
 
#else
 
#ifndef VIDEO_COKTELDECODER_H
#define VIDEO_COKTELDECODER_H
 
#include "common/list.h"
#include "common/array.h"
#include "common/rational.h"
#include "common/str.h"
 
#include "graphics/palette.h"
#include "graphics/surface.h"
 
#include "video/video_decoder.h"
 
#include "audio/mixer.h"
 
namespace Common {
struct Rect;
class MemoryReadWriteStream;
class SeekableReadStream;
}
namespace Audio {
class QueuingAudioStream;
}
 
namespace Graphics {
struct PixelFormat;
}
 
namespace Image {
class Codec;
}
 
namespace Video {
 
class CoktelDecoder {
public:
    struct State {
        uint32 flags;
        uint16 speechId;
 
        State();
    };
 
    CoktelDecoder(Audio::Mixer *mixer,
            Audio::Mixer::SoundType soundType = Audio::Mixer::kPlainSoundType);
    virtual ~CoktelDecoder();
 
    virtual bool reloadStream(Common::SeekableReadStream *stream) = 0;
 
    virtual bool seek(int32 frame, int whence = SEEK_SET, bool restart = false) = 0;
 
    void setSurfaceMemory(void *mem, uint16 width, uint16 height, uint8 bpp);
    void setSurfaceMemory();
 
    const Graphics::Surface *getSurface() const;
 
    virtual void setXY(uint16 x, uint16 y);
    void setXY();
 
    void setFrameRate(Common::Rational frameRate);
    Common::Rational getFrameRate() const;
 
    uint16 getDefaultX() const;
    uint16 getDefaultY() const;
 
    const Common::List<Common::Rect> &getDirtyRects() const;
 
    bool hasPalette() const;
    virtual bool hasVideo() const;
    virtual bool hasVideoData() const;
 
    bool hasSound()       const;
    bool isSoundEnabled() const;
    bool isSoundPlaying() const;
 
    void enableSound();
    void disableSound();
    void finishSound();
 
    virtual void colorModeChanged();
 
    virtual bool getFrameCoords(int16 frame, int16 &x, int16 &y, int16 &width, int16 &height);
 
    virtual bool hasEmbeddedFiles() const;
 
    virtual bool hasEmbeddedFile(const Common::String &fileName) const;
 
    virtual Common::SeekableReadStream *getEmbeddedFile(const Common::String &fileName) const;
 
    virtual int32 getSubtitleIndex() const;
 
    virtual bool isPaletted() const;
 
    virtual uint32 getVideoBufferSize() const = 0;
 
    int getCurFrame() const;
    int getNbFramesPastEnd() const;
 
    virtual const Graphics::Surface *decodeNextFrame() = 0;
 
    virtual bool loadStream(Common::SeekableReadStream *stream) = 0;
 
    virtual bool isVideoLoaded() const = 0;
 
    bool endOfVideo() const;
 
    void close();
 
    Audio::Mixer::SoundType getSoundType() const;
    Audio::AudioStream *getAudioStream() const;
 
    uint16 getWidth()  const;
    uint16 getHeight() const;
    virtual uint32 getFlags() const = 0;
    virtual uint16 getSoundFlags() const = 0;
    virtual Graphics::PixelFormat getPixelFormat() const = 0;
 
    uint32 getFrameCount() const;
 
    const byte *getPalette();
    bool  hasDirtyPalette() const;
 
    uint32 getTimeToNextFrame() const;
    uint32 getStaticTimeToNextFrame() const;
    int32 getExpectedFrameFromCurrentTime() const;
 
    void pauseVideo(bool pause);
 
protected:
    enum SoundStage {
        kSoundNone     = 0, 
        kSoundLoaded   = 1, 
        kSoundPlaying  = 2, 
        kSoundFinished = 3  
    };
 
    enum Features {
        kFeaturesNone        = 0x0000,
        kFeaturesPalette     = 0x0008, 
        kFeaturesDataSize    = 0x0020, 
        kFeaturesSound       = 0x0040, 
        kFeaturesFrameCoords = 0x0080, 
        kFeaturesStdCoords   = 0x0100, 
        kFeaturesFramePos    = 0x0200, 
        kFeaturesVideo       = 0x0400  
    };
 
    Audio::Mixer *_mixer;
    Audio::Mixer::SoundType _soundType;
 
    uint16 _width;
    uint16 _height;
 
    uint16 _x;
    uint16 _y;
 
    uint16 _defaultX;
    uint16 _defaultY;
 
    uint32 _features;
 
     int32 _curFrame;
     int32 _nbFramesPastEnd;
    uint32 _frameCount;
 
    uint32 _startTime;
 
    Graphics::Palette _palette;
    bool _paletteDirty;
 
    bool    _ownSurface;
    Graphics::Surface _surface;
 
    Common::List<Common::Rect> _dirtyRects;
 
    Common::Rational _frameRate;
 
    // Current sound state
    bool       _hasSound;
    bool       _soundEnabled;
    SoundStage _soundStage;
 
    Audio::QueuingAudioStream *_audioStream;
    Audio::SoundHandle _audioHandle;
 
    bool evaluateSeekFrame(int32 &frame, int whence) const;
 
    // Surface management
    bool hasSurface();
    void createSurface();
    void freeSurface();
 
    // Decompression
    uint32 deLZ77(byte *dest, const byte *src, uint32 srcSize, uint32 destSize);
    void deRLE(byte *&destPtr, const byte *&srcPtr, int16 destLen, int16 srcLen);
 
    // Block rendering
    void renderBlockWhole       (Graphics::Surface &dstSurf, const byte *src, Common::Rect &rect);
    void renderBlockWhole4X     (Graphics::Surface &dstSurf, const byte *src, Common::Rect &rect);
    void renderBlockWhole2Y     (Graphics::Surface &dstSurf, const byte *src, Common::Rect &rect);
    void renderBlockSparse      (Graphics::Surface &dstSurf, const byte *src, Common::Rect &rect);
    void renderBlockSparse2Y    (Graphics::Surface &dstSurf, const byte *src, Common::Rect &rect);
    void renderBlockRLE         (Graphics::Surface &dstSurf, const byte *src, Common::Rect &rect);
 
    // Sound helper functions
    inline void unsignedToSigned(byte *buffer, int length);
 
private:
    uint32 _pauseStartTime;
    bool   _isPaused;
};
 
class PreIMDDecoder : public CoktelDecoder {
public:
    PreIMDDecoder(uint16 width, uint16 height, Audio::Mixer *mixer,
            Audio::Mixer::SoundType soundType = Audio::Mixer::kPlainSoundType);
    ~PreIMDDecoder();
 
    bool reloadStream(Common::SeekableReadStream *stream) override;
 
    bool seek(int32 frame, int whence = SEEK_SET, bool restart = false) override;
 
    bool loadStream(Common::SeekableReadStream *stream) override;
    void close();
 
    bool isVideoLoaded() const override;
 
    const Graphics::Surface *decodeNextFrame() override;
 
    uint32 getFlags() const override;
    uint16 getSoundFlags() const override;
    uint32 getVideoBufferSize() const override;
 
    Graphics::PixelFormat getPixelFormat() const override;
 
private:
    Common::SeekableReadStream *_stream;
 
    // Buffer for processed frame data
    byte  *_videoBuffer;
    uint32 _videoBufferSize;
 
    // Frame decoding
    void processFrame();
    void renderFrame();
};
 
class IMDDecoder : public CoktelDecoder {
public:
    IMDDecoder(Audio::Mixer *mixer, Audio::Mixer::SoundType soundType = Audio::Mixer::kPlainSoundType);
    ~IMDDecoder();
 
    bool reloadStream(Common::SeekableReadStream *stream) override;
 
    bool seek(int32 frame, int whence = SEEK_SET, bool restart = false) override;
 
    void setXY(uint16 x, uint16 y) override;
 
    bool loadStream(Common::SeekableReadStream *stream) override;
    void close();
 
    bool isVideoLoaded() const override;
 
    const Graphics::Surface *decodeNextFrame() override;
 
    uint32 getFlags() const override;
    uint16 getSoundFlags() const override;
    uint32 getVideoBufferSize() const override;
 
    Graphics::PixelFormat getPixelFormat() const override;
 
private:
    enum Command {
        kCommandNextSound   = 0xFF00,
        kCommandStartSound  = 0xFF01,
 
        kCommandBreak       = 0xFFF0,
        kCommandBreakSkip0  = 0xFFF1,
        kCommandBreakSkip16 = 0xFFF2,
        kCommandBreakSkip32 = 0xFFF3,
        kCommandBreakMask   = 0xFFF8,
 
        kCommandPalette     = 0xFFF4,
        kCommandVideoData   = 0xFFFC,
 
        kCommandJump        = 0xFFFD
    };
 
    struct Coord {
        int16 left;
        int16 top;
        int16 right;
        int16 bottom;
    };
 
    Common::SeekableReadStream *_stream;
 
    byte _version;
 
    // Standard coordinates gives by the header
    int16 _stdX;
    int16 _stdY;
    int16 _stdWidth;
    int16 _stdHeight;
 
    uint32 _flags;
 
    uint32  _firstFramePos; 
    uint32 *_framePos;      
    Coord  *_frameCoords;   
 
    uint32 _videoBufferSize;   
    byte  *_videoBuffer[2];    
    uint32 _videoBufferLen[2]; 
 
    // Sound properties
    uint16 _soundFlags;
     int16 _soundFreq;
     int16 _soundSliceSize;
     int16 _soundSlicesCount;
 
    // Loading helper functions
    bool loadCoordinates();
    bool loadFrameTableOffsets(uint32 &framePosPos, uint32 &frameCoordsPos);
    bool assessVideoProperties();
    bool assessAudioProperties();
    bool loadFrameTables(uint32 framePosPos, uint32 frameCoordsPos);
 
    // Frame decoding
    void processFrame();
    Common::Rect calcFrameCoords(uint32 frame);
 
    // Video
    bool renderFrame(Common::Rect &rect);
 
    // Sound
    void nextSoundSlice(bool hasNextCmd);
    bool initialSoundSlice(bool hasNextCmd);
    void emptySoundSlice(bool hasNextCmd);
};
 
class VMDDecoder : public CoktelDecoder {
friend class AdvancedVMDDecoder;
 
public:
    VMDDecoder(Audio::Mixer *mixer, Audio::Mixer::SoundType soundType = Audio::Mixer::kPlainSoundType);
    ~VMDDecoder();
 
    bool reloadStream(Common::SeekableReadStream *stream) override;
 
    bool seek(int32 frame, int whence = SEEK_SET, bool restart = false) override;
 
    void setXY(uint16 x, uint16 y) override;
 
    void colorModeChanged() override;
 
    bool getFrameCoords(int16 frame, int16 &x, int16 &y, int16 &width, int16 &height) override;
 
    bool hasEmbeddedFiles() const override;
    bool hasEmbeddedFile(const Common::String &fileName) const override;
    Common::SeekableReadStream *getEmbeddedFile(const Common::String &fileName) const override;
 
    int32 getSubtitleIndex() const override;
 
    bool hasVideo() const override;
    bool hasVideoData() const override;
    bool isPaletted() const override;
 
    bool loadStream(Common::SeekableReadStream *stream) override;
    void close();
 
    bool isVideoLoaded() const override;
 
    const Graphics::Surface *decodeNextFrame() override;
 
    uint32 getFlags() const override;
    uint16 getSoundFlags() const override;
    uint32 getVideoBufferSize() const override;
 
    Graphics::PixelFormat getPixelFormat() const override;
 
protected:
    void setAutoStartSound(bool autoStartSound);
 
private:
    enum PartType {
        kPartTypeSeparator = 0,
        kPartTypeAudio     = 1,
        kPartTypeVideo     = 2,
        kPartTypeFile      = 3,
        kPartType4         = 4,
        kPartTypeSubtitle  = 5
    };
 
    enum AudioFormat {
        kAudioFormat8bitRaw    = 0,
        kAudioFormat16bitDPCM  = 1,
        kAudioFormat16bitADPCM = 2
    };
 
    struct File {
        Common::String name;
 
        uint32 offset;
        uint32 size;
        uint32 realSize;
 
        File();
    };
 
    struct Part {
        PartType type;
        byte     field_1;
        byte     field_E;
        uint32   size;
        int16    left;
        int16    top;
        int16    right;
        int16    bottom;
        uint16   id;
        byte     flags;
 
        Part();
    };
 
    struct Frame {
        uint32 offset;
        Part  *parts;
 
        Frame();
        ~Frame();
    };
 
    Common::SeekableReadStream *_stream;
 
    byte   _version;
    uint32 _flags;
 
    uint32 _frameInfoOffset;
    uint16 _partsPerFrame;
    Frame *_frames;
 
    Common::Array<File> _files;
 
    // Sound properties
    uint16 _soundFlags;
    uint16  _soundFreq;
    int16  _soundSliceSize;
    int16  _soundSlicesCount;
    byte   _soundBytesPerSample;
    byte   _soundStereo; // (0: mono, 1: old-style stereo, 2: new-style stereo)
    uint32 _soundHeaderSize;
    uint32 _soundDataSize;
    uint32 _soundLastFilledFrame;
    AudioFormat _audioFormat;
    bool   _autoStartSound;
 
    Common::MemoryReadWriteStream *_oldStereoBuffer;
 
    // Video properties
    bool   _hasVideo;
    bool   _hasVideoData; 
    uint32 _videoCodec;
    byte   _blitMode;
    byte   _bytesPerPixel;
 
    uint32  _firstFramePos; 
 
    uint32 _videoBufferSize;   
    byte  *_videoBuffer[3];    
    uint32 _videoBufferLen[3]; 
 
    Graphics::Surface _8bppSurface[3]; 
 
    bool _externalCodec;
    Image::Codec *_codec;
 
    int32 _subtitle;
 
    bool _isPaletted;
 
    // Loading helper functions
    bool assessVideoProperties();
    bool assessAudioProperties();
    bool openExternalCodec();
    bool readFrameTable(int &numFiles);
    bool readFiles();
 
    // Frame decoding
    void processFrame();
 
    // Video
    bool renderFrame(Common::Rect &rect);
    bool getRenderRects(const Common::Rect &rect,
            Common::Rect &realRect, Common::Rect &fakeRect);
    void blit16(const Graphics::Surface &srcSurf, Common::Rect &rect);
    void blit24(const Graphics::Surface &srcSurf, Common::Rect &rect);
 
    // Sound
    void emptySoundSlice  (uint32 size);
    void filledSoundSlice (uint32 size);
    void filledSoundSlices(uint32 size, uint32 mask);
    void createAudioStream();
 
    uint8 evaluateMask(uint32 mask, bool *fillInfo, uint8 &max);
 
    // Generating audio streams
    Audio::AudioStream *create8bitRaw   (Common::SeekableReadStream *stream);
    Audio::AudioStream *create16bitDPCM (Common::SeekableReadStream *stream);
    Audio::AudioStream *create16bitADPCM(Common::SeekableReadStream *stream);
 
    bool getPartCoords(int16 frame, PartType type, int16 &x, int16 &y, int16 &width, int16 &height);
};
 
class AdvancedVMDDecoder : public VideoDecoder {
public:
    AdvancedVMDDecoder(Audio::Mixer::SoundType soundType = Audio::Mixer::kPlainSoundType);
    ~AdvancedVMDDecoder();
 
    bool loadStream(Common::SeekableReadStream *stream) override;
    void close() override;
 
    void setSurfaceMemory(void *mem, uint16 width, uint16 height, uint8 bpp);
 
private:
    class VMDVideoTrack : public FixedRateVideoTrack {
    public:
        VMDVideoTrack(VMDDecoder *decoder);
 
        uint16 getWidth() const override;
        uint16 getHeight() const override;
        Graphics::PixelFormat getPixelFormat() const override;
        int getCurFrame() const override;
        int getFrameCount() const override;
        const Graphics::Surface *decodeNextFrame() override;
        const byte *getPalette() const override;
        bool hasDirtyPalette() const override;
 
    protected:
        Common::Rational getFrameRate() const override;
 
    private:
        VMDDecoder *_decoder;
    };
 
    class VMDAudioTrack : public AudioTrack {
    public:
        VMDAudioTrack(VMDDecoder *decoder);
 
    protected:
        Audio::AudioStream *getAudioStream() const override;
 
    private:
        VMDDecoder *_decoder;
    };
 
    VMDDecoder    *_decoder;
    VMDVideoTrack *_videoTrack;
    VMDAudioTrack *_audioTrack;
};
 
} // End of namespace Video
 
#endif // VIDEO_COKTELDECODER_H
 
#endif // Engine and dynamic plugins guard