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

    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  { return kTrackTypeVideo; }
        virtual bool endOfTrack() const;

        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;
        virtual Audio::Timestamp getDuration() const;
        Audio::Timestamp getFrameTime(uint frame) const;

        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 { return kTrackTypeAudio; }

        virtual bool endOfTrack() const;

        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;

        void setMute(bool mute);

    protected:
        void pauseIntern(bool shouldPause);

        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 { return true; }
        bool rewind();

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

        virtual Audio::RewindableAudioStream *getRewindableAudioStream() const = 0;
    };

    class SeekableAudioTrack : public AudioTrack {
    public:
        SeekableAudioTrack(Audio::Mixer::SoundType soundType) : AudioTrack(soundType) {}
        virtual ~SeekableAudioTrack() {}

        bool isSeekable() const { return true; }
        bool seek(const Audio::Timestamp &time);

        Audio::Timestamp getDuration() const;

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

        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 { 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