TheoraVideoClip.h

Go to the documentation of this file.

/************************************************************************************
This source file is part of the Theora Video Playback Library
For latest info, see http://libtheoraplayer.googlecode.com
*************************************************************************************
Copyright (c) 2008-2014 Kresimir Spes (kspes@cateia.com)
This program is free software; you can redistribute it and/or modify it under
the terms of the BSD license: http://opensource.org/licenses/BSD-3-Clause
*************************************************************************************/

#ifndef _TheoraVideoClip_h
#define _TheoraVideoClip_h

#include <string>
#include "TheoraExport.h"

// forward class declarations
class TheoraMutex;
class TheoraFrameQueue;
class TheoraTimer;
class TheoraAudioInterface;
class TheoraWorkerThread;
class TheoraDataSource;
class TheoraVideoFrame;

enum TheoraOutputMode
{
        // A = full alpha (255), order of letters represents the byte order for a pixel
        // A means the image is treated as if it contains an alpha channel, while X formats
        // just mean that RGB frame is transformed to a 4 byte format
        TH_UNDEFINED = 0,
        TH_RGB    =  1,
        TH_RGBA   =  2,
        TH_RGBX   =  3,
        TH_ARGB   =  4,
        TH_XRGB   =  5,
        TH_BGR    =  6,
        TH_BGRA   =  7,
        TH_BGRX   =  8,
        TH_ABGR   =  9,
        TH_XBGR   = 10,
        TH_GREY   = 11,
        TH_GREY3  = 12,
        TH_GREY3A = 13,
        TH_GREY3X = 14,
        TH_AGREY3 = 15,
        TH_XGREY3 = 16,
        TH_YUV    = 17,
        TH_YUVA   = 18,
        TH_YUVX   = 19,
        TH_AYUV   = 20,
        TH_XYUV   = 21
};

class TheoraPlayerExport TheoraVideoClip
{
        friend class TheoraWorkerThread;
        friend class TheoraVideoFrame;
        friend class TheoraVideoManager;
protected:
        TheoraFrameQueue* mFrameQueue;
        TheoraAudioInterface* mAudioInterface;
        TheoraDataSource* mStream;

        TheoraTimer *mTimer, *mDefaultTimer;

        TheoraWorkerThread* mAssignedWorkerThread;
        
        bool mUseAlpha;
        
        bool mWaitingForCache;
        
        // benchmark vars
        int mNumDroppedFrames, mNumDisplayedFrames, mNumPrecachedFrames;

        int mThreadAccessCount; 
        
        int mSeekFrame; 
        float mDuration, mFrameDuration;
        float mPriority; 
        std::string mName;
        int mWidth, mHeight, mStride;
        int mNumFrames;
        float mFPS;

        int mSubFrameWidth, mSubFrameHeight, mSubFrameOffsetX, mSubFrameOffsetY;
        float mAudioGain; 

        TheoraOutputMode mOutputMode, mRequestedOutputMode;
        bool mFirstFrameDisplayed;
        bool mAutoRestart;
        bool mEndOfFile, mRestarted;
        int mIteration, mPlaybackIteration; 

        TheoraMutex* mAudioMutex; 
        TheoraMutex* mThreadAccessMutex;
        
        int calculatePriority();
        void readTheoraVorbisHeaders();
        virtual void doSeek() = 0; 
        virtual bool _readData() = 0;
        bool isBusy();

        virtual float decodeAudio() = 0;
        
        int _getNumReadyFrames();
        void resetFrameQueue();
        int discardOutdatedFrames(float absTime);
        float getAbsPlaybackTime();
        virtual void load(TheoraDataSource* source) = 0;

        virtual void _restart() = 0; // resets the decoder and stream but leaves the frame queue intact
public:
        TheoraVideoClip(TheoraDataSource* data_source, TheoraOutputMode output_mode, int nPrecachedFrames, bool usePower2Stride);
        virtual ~TheoraVideoClip();

        std::string getName();
        virtual std::string getDecoderName() = 0;

        int getNumDisplayedFrames() { return mNumDisplayedFrames; }
        int getNumDroppedFrames() { return mNumDroppedFrames; }

        int getWidth();
        int getHeight();
        bool hasAlphaChannel() { return mUseAlpha; }
        
        int getSubFrameWidth();
        int getSubFrameHeight();
        int getSubFrameOffsetX();
        int getSubFrameOffsetY();
        int getStride() { return mStride; }

        TheoraTimer* getTimer();
        void setTimer(TheoraTimer* timer);

        virtual bool decodeNextFrame() = 0;

        void update(float timeDelta);
        float updateToNextFrame();

        
        TheoraFrameQueue* getFrameQueue();
        
        void popFrame();

        TheoraVideoFrame* getNextFrame();
        virtual void decodedAudioCheck() = 0;

        void setAudioInterface(TheoraAudioInterface* iface);
        TheoraAudioInterface* getAudioInterface();

        void setNumPrecachedFrames(int n);
        int getNumPrecachedFrames();
        int getNumReadyFrames();

        void setAudioGain(float gain);
        float getAudioGain();

        void setAutoRestart(bool value);
        bool getAutoRestart() { return mAutoRestart; }



        void setPriority(float priority);
        float getPriority();

        float getPriorityIndex();

        float getTimePosition();
        float getDuration();
        float getFPS();
        int getNumFrames() { return mNumFrames; }

        TheoraOutputMode getOutputMode();
        void setOutputMode(TheoraOutputMode mode);

        bool isDone();
        void play();
        void pause();
        void restart();
        bool isPaused();
        void stop();
        void setPlaybackSpeed(float speed);
        float getPlaybackSpeed();
        void seek(float time);
        void seekToFrame(int frame);
        float waitForCache(float desired_cache_factor = 0.5f, float max_wait_time = 1.0f);
};

#endif