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 setDouble(bool isDouble); // double the size of the video, to accommodate higher resolutions

    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;

    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 _isDouble;

    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 renderBlockWholeDouble (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 renderBlockSparseDouble(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);

    bool seek(int32 frame, int whence = SEEK_SET, bool restart = false);

    bool loadStream(Common::SeekableReadStream *stream);
    void close();

    bool isVideoLoaded() const;

    const Graphics::Surface *decodeNextFrame();

    uint32 getFlags() const;
    uint16 getSoundFlags() const;
    uint32 getVideoBufferSize() const;

    Graphics::PixelFormat getPixelFormat() const;

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);

    bool seek(int32 frame, int whence = SEEK_SET, bool restart = false);

    void setXY(uint16 x, uint16 y);

    bool loadStream(Common::SeekableReadStream *stream);
    void close();

    bool isVideoLoaded() const;

    const Graphics::Surface *decodeNextFrame();

    uint32 getFlags() const;
    uint16 getSoundFlags() const;
    uint32 getVideoBufferSize() const;

    Graphics::PixelFormat getPixelFormat() const;

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);

    bool seek(int32 frame, int whence = SEEK_SET, bool restart = false);

    void setXY(uint16 x, uint16 y);

    void colorModeChanged();

    bool getFrameCoords(int16 frame, int16 &x, int16 &y, int16 &width, int16 &height);

    bool hasEmbeddedFiles() const;
    bool hasEmbeddedFile(const Common::String &fileName) const;
    Common::SeekableReadStream *getEmbeddedFile(const Common::String &fileName) const;

    int32 getSubtitleIndex() const;

    bool hasVideo() const;
    bool isPaletted() const;

    bool loadStream(Common::SeekableReadStream *stream);
    void close();

    bool isVideoLoaded() const;

    const Graphics::Surface *decodeNextFrame();

    uint32 getFlags() const;
    uint16 getSoundFlags() const;
    uint32 getVideoBufferSize() const;

    Graphics::PixelFormat getPixelFormat() const;

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;
    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);
    void close();

    void setSurfaceMemory(void *mem, uint16 width, uint16 height, uint8 bpp);

private:
    class VMDVideoTrack : public FixedRateVideoTrack {
    public:
        VMDVideoTrack(VMDDecoder *decoder);

        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;

    private:
        VMDDecoder *_decoder;
    };

    class VMDAudioTrack : public AudioTrack {
    public:
        VMDAudioTrack(VMDDecoder *decoder);

    protected:
        virtual Audio::AudioStream *getAudioStream() const;

    private:
        VMDDecoder *_decoder;
    };

    VMDDecoder    *_decoder;
    VMDVideoTrack *_videoTrack;
    VMDAudioTrack *_audioTrack;
};

} // End of namespace Video

#endif // VIDEO_COKTELDECODER_H

#endif // Engine and dynamic plugins guard