video_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_DECODER_H
#define VIDEO_DECODER_H
 
#include "audio/mixer.h"
#include "audio/timestamp.h"    // TODO: Move this to common/ ?
#include "common/array.h"
#include "common/path.h"
#include "common/rational.h"
#include "common/str.h"
#include "graphics/pixelformat.h"
#include "image/codec-options.h"
 
namespace Audio {
class AudioStream;
class RewindableAudioStream;
class SeekableAudioStream;
}
 
namespace Common {
class SeekableReadStream;
}
 
namespace Graphics {
struct Surface;
}
 
namespace Video {
 
class VideoDecoder {
public:
    VideoDecoder();
    virtual ~VideoDecoder() {}
 
    // Opening/Closing a Video
 
    virtual bool loadFile(const Common::Path &filename);
 
    virtual bool loadStream(Common::SeekableReadStream *stream) = 0;
 
    virtual void close();
 
    bool isVideoLoaded() const;
 
 
    // Playback Control
 
    void start();
 
    void stop();
 
    void setRate(const Common::Rational &rate);
 
    Common::Rational getRate() const { return _playbackRate; }
 
    bool isPlaying() const;
 
    virtual bool isRewindable() const;
 
    virtual bool rewind();
 
    virtual bool isSeekable() const;
 
    bool seek(const Audio::Timestamp &time);
 
    virtual bool seekToFrame(uint frame);
 
    void pauseVideo(bool pause);
 
    bool isPaused() const { return _pauseLevel != 0; }
 
    void setEndTime(const Audio::Timestamp &endTime);
 
    void setEndFrame(uint frame);
 
    Audio::Timestamp getEndTime() const { return _endTime; }
 
    void resetStartTime();
 
 
    // Playback Status
 
    bool endOfVideo() const;
 
    int getCurFrame() const;
 
    int getCurFrameDelay() const;
 
    uint32 getFrameCount() const;
 
    uint32 getTime() const;
 
 
    // Video Info
 
    virtual uint16 getWidth() const;
 
    virtual uint16 getHeight() const;
 
    Graphics::PixelFormat getPixelFormat() const;
 
    virtual Audio::Timestamp getDuration() const;
 
 
    // Frame Decoding
 
    const byte *getPalette();
 
    bool hasDirtyPalette() const { return _dirtyPalette; }
 
    void delayMillis(uint msecs);
 
    uint32 getTimeToNextFrame() const;
 
    bool needsUpdate() const;
 
    virtual const Graphics::Surface *decodeNextFrame();
 
    bool setReverse(bool reverse);
 
    bool setDitheringPalette(const byte *palette);
 
    bool setOutputPixelFormat(const Graphics::PixelFormat &format);
 
    bool setOutputPixelFormats(const Common::List<Graphics::PixelFormat> &formatList);
 
    virtual void setVideoCodecAccuracy(Image::CodecAccuracy accuracy);
 
    // Audio Control
 
    byte getVolume() const { return _audioVolume; }
 
    void setVolume(byte volume);
 
    int8 getBalance() const { return _audioBalance; }
 
    void setBalance(int8 balance);
 
    Audio::Mixer::SoundType getSoundType() const;
 
    void setSoundType(Audio::Mixer::SoundType soundType);
 
    bool addStreamTrack(Audio::SeekableAudioStream *stream);
 
    bool addStreamFileTrack(const Common::Path &baseName);
 
    bool setAudioTrack(int index);
 
    bool getAudioTrackMute(int index);
 
    bool setAudioTrackMute(int index, bool muted);
 
    uint getAudioTrackCount() const;
 
protected:
    class Track {
    public:
        Track();
        virtual ~Track() {}
 
        enum TrackType {
            kTrackTypeNone,
            kTrackTypeVideo,
            kTrackTypeAudio
        };
 
        virtual TrackType getTrackType() const = 0;
 
        virtual bool endOfTrack() const = 0;
 
        virtual bool isRewindable() const;
 
        virtual bool rewind();
 
        virtual bool isSeekable() const { return false; }
 
        virtual bool seek(const Audio::Timestamp &time) { return false; }
 
        void pause(bool shouldPause);
 
        bool isPaused() const { return _paused; }
 
        virtual Audio::Timestamp getDuration() const;
 
    protected:
        virtual void pauseIntern(bool shouldPause) {}
 
    private:
        bool _paused;
    };
 
    class VideoTrack : public Track {
    public:
        VideoTrack() {}
        virtual ~VideoTrack() {}
 
        TrackType getTrackType() const override { return kTrackTypeVideo; }
        bool endOfTrack() const override;
 
        virtual uint16 getWidth() const = 0;
 
        virtual uint16 getHeight() const = 0;
 
        virtual Graphics::PixelFormat getPixelFormat() const = 0;
 
        virtual bool setOutputPixelFormat(const Graphics::PixelFormat &format) { return format == getPixelFormat(); }
 
        virtual void setCodecAccuracy(Image::CodecAccuracy accuracy) {}
 
        virtual int getCurFrame() const = 0;
 
        virtual int getCurFrameDelay() const {
            return 0;
        };
 
        virtual int getFrameCount() const { return 0; }
 
        virtual uint32 getNextFrameStartTime() const = 0;
 
        virtual const Graphics::Surface *decodeNextFrame() = 0;
 
        virtual const byte *getPalette() const { return 0; }
 
        virtual bool hasDirtyPalette() const { return false; }
 
        virtual Audio::Timestamp getFrameTime(uint frame) const;
 
        virtual bool setReverse(bool reverse) { return !reverse; }
 
        virtual bool isReversed() const { return false; }
 
        virtual bool canDither() const { return false; }
 
        virtual void setDither(const byte *palette) {}
    };
 
    class FixedRateVideoTrack : public VideoTrack {
    public:
        FixedRateVideoTrack() {}
        virtual ~FixedRateVideoTrack() {}
 
        uint32 getNextFrameStartTime() const override;
        Audio::Timestamp getDuration() const override;
        Audio::Timestamp getFrameTime(uint frame) const override;
 
        uint getFrameAtTime(const Audio::Timestamp &time) const;
 
    protected:
        virtual Common::Rational getFrameRate() const = 0;
    };
 
    class AudioTrack : public Track {
    public:
        AudioTrack(Audio::Mixer::SoundType soundType);
        virtual ~AudioTrack() {}
 
        TrackType getTrackType() const override { return kTrackTypeAudio; }
 
        bool endOfTrack() const override;
 
        void start();
 
        void stop();
 
        void start(const Audio::Timestamp &limit);
 
        byte getVolume() const { return _volume; }
 
        void setVolume(byte volume);
 
        uint32 getRate() const { return _rate; }
 
        void setRate(uint32 rate);
 
        void setRate(Common::Rational rate);
 
        int8 getBalance() const { return _balance; }
 
        void setBalance(int8 balance);
 
        Audio::Mixer::SoundType getSoundType() const { return _soundType; }
 
        void setSoundType(Audio::Mixer::SoundType soundType) { _soundType = soundType; }
 
        uint32 getRunningTime() const;
 
        bool getMute() { return _muted; }
 
        void setMute(bool mute);
 
    protected:
        void pauseIntern(bool shouldPause) override;
 
        virtual Audio::AudioStream *getAudioStream() const = 0;
 
    private:
        Audio::SoundHandle _handle;
        Audio::Mixer::SoundType _soundType;
        byte _volume;
        uint32 _rate;
        int8 _balance;
        bool _muted;
    };
 
    class RewindableAudioTrack : public AudioTrack {
    public:
        RewindableAudioTrack(Audio::Mixer::SoundType soundType) : AudioTrack(soundType) {}
        virtual ~RewindableAudioTrack() {}
 
        bool isRewindable() const override { return true; }
        bool rewind() override;
 
    protected:
        Audio::AudioStream *getAudioStream() const override;
 
        virtual Audio::RewindableAudioStream *getRewindableAudioStream() const = 0;
    };
 
    class SeekableAudioTrack : public AudioTrack {
    public:
        SeekableAudioTrack(Audio::Mixer::SoundType soundType) : AudioTrack(soundType) {}
        virtual ~SeekableAudioTrack() {}
 
        bool isSeekable() const override { return true; }
        bool seek(const Audio::Timestamp &time) override;
 
        Audio::Timestamp getDuration() const override;
 
    protected:
        Audio::AudioStream *getAudioStream() const override;
 
        virtual Audio::SeekableAudioStream *getSeekableAudioStream() const = 0;
    };
 
    class StreamFileAudioTrack : public SeekableAudioTrack {
    public:
        StreamFileAudioTrack(Audio::Mixer::SoundType soundType);
        StreamFileAudioTrack(Audio::SeekableAudioStream *stream, Audio::Mixer::SoundType soundType);
        ~StreamFileAudioTrack();
 
        bool loadFromFile(const Common::Path &baseName);
 
    protected:
        Audio::SeekableAudioStream *_stream;
        Audio::SeekableAudioStream *getSeekableAudioStream() const override { return _stream; }
    };
 
    void resetPauseStartTime();
 
    virtual void readNextPacket() {}
 
    void addTrack(Track *track, bool isExternal = false);
 
    virtual bool useAudioSync() const { return true; }
 
    Track *getTrack(uint track);
 
    const Track *getTrack(uint track) const;
 
    bool endOfVideoTracks() const;
 
    VideoTrack *findNextVideoTrack();
 
    typedef Common::Array<Track *> TrackList;
    typedef TrackList::iterator TrackListIterator;
 
    TrackListIterator getTrackListBegin() { return _internalTracks.begin(); }
 
    TrackListIterator getTrackListEnd() { return _internalTracks.end(); }
 
    void eraseTrack(Track *track);
 
    virtual bool seekIntern(const Audio::Timestamp &time);
 
    virtual bool supportsAudioTrackSwitching() const { return false; }
 
    virtual AudioTrack *getAudioTrack(int index) { return 0; }
 
    uint getNumTracks() { return _tracks.size(); }
 
private:
    // Tracks owned by this VideoDecoder
    TrackList _tracks;
    TrackList _internalTracks;
    TrackList _externalTracks;
 
    // Current playback status
    bool _needsUpdate;
    Audio::Timestamp _endTime;
    bool _endTimeSet;
    Common::Rational _playbackRate;
 
    // Palette settings from individual tracks
    mutable bool _dirtyPalette;
    const byte *_palette;
 
    // Enforcement of not being able to set dither or set the default format
    bool _canSetDither;
    bool _canSetDefaultFormat;
 
protected:
    // Internal helper functions
    void stopAudio();
    void setAudioRate(Common::Rational rate);
    void startAudio();
    void startAudioLimit(const Audio::Timestamp &limit);
    bool hasFramesLeft() const;
    bool hasAudio() const;
 
    Audio::Timestamp _lastTimeChange;
    int32 _startTime;
 
    VideoTrack *_nextVideoTrack;
 
    Image::CodecAccuracy _videoCodecAccuracy;
 
private:
    uint32 _pauseLevel;
    uint32 _pauseStartTime;
    byte _audioVolume;
    int8 _audioBalance;
    Audio::Mixer::SoundType _soundType;
 
    AudioTrack *_mainAudioTrack;
};
 
} // End of namespace Video
 
#endif