decoder.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos 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.
 *
 * xoreos 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 xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef VIDEO_DECODER_H
#define VIDEO_DECODER_H

#include <vector>

#include <boost/shared_ptr.hpp>

#include "src/common/types.h"
#include "src/common/rational.h"
#include "src/common/scopedptr.h"
#include "src/common/timestamp.h"

#include "src/graphics/types.h"
#include "src/graphics/glcontainer.h"
#include "src/graphics/renderable.h"

#include "src/sound/types.h"

namespace Graphics {
    class Surface;
}

namespace Sound {
    class AudioStream;
    class QueuingAudioStream;
}

namespace Video {

class VideoDecoder : public Graphics::GLContainer, public Graphics::Renderable {
public:
    enum Scale {
        kScaleNone,  
        kScaleUp,    
        kScaleDown,  
        kScaleUpDown 
    };

    VideoDecoder();
    ~VideoDecoder();

    void setScale(Scale scale);

    bool isPlaying() const;

    virtual uint32 getWidth() const;

    virtual uint32 getHeight() const;

    void start();

    void abort();

    bool needsUpdate() const;

    bool endOfVideo() const;

    bool endOfVideoTracks() const;

    uint32 getTime() const;

    uint32 getTimeToNextFrame() const;

    // Renderable
    void calculateDistance();
    void render(Graphics::RenderPass pass);

    virtual Common::Timestamp getDuration() const;

    void pauseVideo(bool pause);

    bool isPaused() const { return _pauseLevel != 0; }

protected:
    class Track {
    public:
        Track();
        virtual ~Track() {}

        enum TrackType {
            kTrackTypeNone,

            kTrackTypeAudio,

            kTrackTypeVideo
        };

        virtual TrackType getTrackType() const = 0;

        virtual bool endOfTrack() const = 0;

        void pause(bool shouldPause);

        bool isPaused() const { return _paused; }

        virtual Common::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 uint32 getWidth() const = 0;

        virtual uint32 getHeight() const = 0;

        virtual int getCurFrame() const = 0;

        virtual int getFrameCount() const { return 0; }

        virtual Common::Timestamp getNextFrameStartTime() const = 0;

        virtual Common::Timestamp getFrameTime(uint frame) const;
    };

    class FixedRateVideoTrack : public VideoTrack {
    public:
        FixedRateVideoTrack() {}
        virtual ~FixedRateVideoTrack() {}

        Common::Timestamp getNextFrameStartTime() const;
        virtual Common::Timestamp getDuration() const;
        Common::Timestamp getFrameTime(uint frame) const;

        uint getFrameAtTime(const Common::Timestamp &time) const;

    protected:
        virtual Common::Rational getFrameRate() const = 0;
    };

    class AudioTrack : public Track {
    public:
        AudioTrack();
        virtual ~AudioTrack() {}

        TrackType getTrackType() const { return kTrackTypeAudio; }

        bool endOfTrack() const;

        void start();

        void stop();

        float getGain() const { return _gain; }

        void setGain(float gain);

        uint32 getRunningTime() const;

        void setMute(bool mute);

        virtual bool canBufferData() const = 0;

    protected:
        void pauseIntern(bool shouldPause);

        virtual Sound::AudioStream *getAudioStream() const = 0;

    private:
        Sound::ChannelHandle _handle;
        float _gain;
        bool _muted;
    };

    typedef boost::shared_ptr<Track> TrackPtr;

    typedef boost::shared_ptr<const Track> ConstTrackPtr;

    typedef boost::shared_ptr<AudioTrack> AudioTrackPtr;

    typedef boost::shared_ptr<VideoTrack> VideoTrackPtr;

    typedef std::vector<TrackPtr> TrackList;

    typedef std::vector<ConstTrackPtr> ConstTrackList;

    bool _needCopy; 

    Common::ScopedPtr<Graphics::Surface> _surface; 

    void initVideo();

    void deinit();

    // GLContainer
    void doRebuild();
    void doDestroy();

    virtual void decodeNextTrackFrame(VideoTrack &track) = 0;

    virtual void checkAudioBuffer(AudioTrack &track, const Common::Timestamp &endTime);

    void addTrack(Track *track, bool isExternal = false);

    TrackPtr getTrack(uint track);

    ConstTrackPtr getTrack(uint track) const;

    VideoTrackPtr findNextVideoTrack();

    TrackList getInternalTracks() { return _internalTracks; }

    ConstTrackList getInternalTracks() const;

private:
    TrackList _tracks; 
    TrackList _internalTracks; 
    TrackList _externalTracks; 

    VideoTrackPtr _nextVideoTrack; 

    void stopAudio(); 
    void startAudio(); 
    bool hasAudio() const;

    Graphics::TextureID _texture;

    float _textureWidth;
    float _textureHeight;

    Scale _scale;


    uint32 _startTime;

    uint32 _pauseLevel;

    uint32 _pauseStartTime;

    void update();

    void copyData();

    void getQuadDimensions(float &width, float &height) const;
};

} // End of namespace Video

#endif // VIDEO_DECODER_H