YiAbstractVideoPlayer.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2017. All rights reserved.
#ifndef _YI_ABSTRACT_VIDEO_PLAYER_H_
#define _YI_ABSTRACT_VIDEO_PLAYER_H_

#include "binding/YiScriptableObject.h"
#include "network/YiUrl.h"
#include "signal/YiSignal.h"
#include "utility/YiRtti.h"
#include "utility/YiTime.h"
#include "utility/YiTimer.h"

#include <glm/fwd.hpp>

#include <limits>

class CYIAssetTexture;
class CYIAssetVideo;
class CYIClosedCaptionsDispatcher;
class CYIMaterial;
class CYIVideoPlayerStateManager;
class CYIVideoSurface;

class CYIAbstractVideoPlayer : public CYISignalHandler, public CYIScriptableObject
{
friend class CYIVideoPlayerStateManager;
public:
    enum MEDIA_STATE
    {
        MEDIA_UNLOADED, 
        MEDIA_PREPARING, 
        MEDIA_READY 
    };
    
    enum PLAYBACK_STATE
    {
        PLAYBACK_PLAYING, 
        PLAYBACK_PAUSED, 
        PLAYBACK_BUFFERING 
    };
    
    struct PlayerState
    {
        MEDIA_STATE mediaState;
        PLAYBACK_STATE playbackState;
    };

    enum STREAMING_FORMAT
    {
        HLS = 0,
        SMOOTH,
        DASH,
        MP4
    };
    
    enum DRM_SCHEME
    {
        DRM_NONE = 0,
        DRM_FAIRPLAY,
        DRM_PLAYREADY,
        DRM_WIDEVINE_MODULAR
    };

    class DRMConfiguration
    {
    public:
        virtual ~DRMConfiguration() = default;

        virtual DRM_SCHEME GetScheme() const = 0;
    };

    enum ERROR_CODE
    {
        PLAYBACK_ERROR, 
        UNSUPPORTED_FORMAT, 
        STATE_TRANSITION_ERROR, 
        DRM_ERROR, 
        UNKNOWN 
    };

    struct Error
    {
        Error() :
        eErrorCode(UNKNOWN)
        {}
        
        ERROR_CODE eErrorCode;
        CYIString message;
    };

    struct TrackInfo
    {
        uint32_t uID; 
        CYIString name;                     
        CYIString language;                 
        TrackInfo(uint32_t uID) :
            uID(uID) {}
        TrackInfo(uint32_t uID, const CYIString &name) :
            uID(uID),
            name(name) {}
        TrackInfo(uint32_t uID, const CYIString &name, const CYIString &language) :
            uID(uID),
            name(name),
            language(language) {}
    };
    
    struct AudioTrackInfo : public TrackInfo
    {
        static uint32_t DEFAULT_TRACK_ID; 
        AudioTrackInfo() : TrackInfo(DEFAULT_TRACK_ID), bIsValid(false) {}
        AudioTrackInfo(uint32_t uID, const CYIString &name, const CYIString &language) :
            TrackInfo(uID, name, language),
            bIsValid(true) {}
        AudioTrackInfo(const TrackInfo &trackInfo) : TrackInfo(trackInfo), bIsValid(true) {}
        bool bIsValid;                      
    };

    struct ClosedCaptionsTrackInfo : public TrackInfo
    {
        static uint32_t OFF_TRACK_ID; 
        ClosedCaptionsTrackInfo() : TrackInfo(OFF_TRACK_ID) {}
        ClosedCaptionsTrackInfo(uint32_t uID, const CYIString &name, const CYIString &language) :
            TrackInfo(uID, name, language) {}
        ClosedCaptionsTrackInfo(const TrackInfo &trackInfo) : TrackInfo(trackInfo) {}
    };

    using VideoMetadata = std::map<CYIString, CYIString>;

    virtual ~CYIAbstractVideoPlayer();

    CYIString GetName() const;

    CYIString GetVersion() const;

    struct Statistics
    {
        Statistics();

        Statistics(const Statistics &other);
        Statistics &operator=(const Statistics &other);
        bool operator==(const Statistics &other) const;
        bool operator!=(const Statistics &other) const;

        bool bIsLive;

        float fBitrateKbps;

        float fDefaultBitrateKbps;

        float fBufferLengthMs;

        float fMinimumBufferLengthMs;

        float fFramesPerSecond;
    };

    Statistics GetStatistics() const;

    void Init();
    
    void Prepare(const CYIUrl &videoURI, STREAMING_FORMAT eFormatHint, CYIAbstractVideoPlayer::PLAYBACK_STATE eInitialState = CYIAbstractVideoPlayer::PLAYBACK_PAUSED, std::unique_ptr<DRMConfiguration> pDRMConfiguration = nullptr);

    void Prepare(const std::shared_ptr<CYIAssetVideo> &videoAsset, STREAMING_FORMAT eFormatHint, CYIAbstractVideoPlayer::PLAYBACK_STATE eInitialState = CYIAbstractVideoPlayer::PLAYBACK_PAUSED, std::unique_ptr<DRMConfiguration> pDRMConfiguration = nullptr);

    void Play();

    void Pause();
    
    void Stop();

    void Seek(uint64_t uSeekPositionMs);

    bool SupportsFormat(STREAMING_FORMAT eStreamingFormat, DRM_SCHEME eDRMScheme = DRM_NONE);

    uint64_t GetDurationMs() const;

    uint64_t GetCurrentTimeMs() const;

    CYIAbstractVideoPlayer::PlayerState GetPlayerState() const;

    bool AreClosedCaptionsTracksAvailable() const;

    bool SelectClosedCaptionsTrack(uint32_t uID);

    std::vector<ClosedCaptionsTrackInfo> GetClosedCaptionsTracks() const;

    ClosedCaptionsTrackInfo GetActiveClosedCaptionsTrack() const;

    /*
        \details Returns the closed captions dispatcher for the player.

        This will return null if the player implementation does not provide control over closed captions rendering.
    */
    CYIClosedCaptionsDispatcher *GetClosedCaptionsDispatcher() const;

    CYIVideoSurface *GetSurface() const;
    
    bool AreAudioTracksAvailable() const;
    
    bool SelectAudioTrack(uint32_t uID);

    std::vector<AudioTrackInfo> GetAudioTracks() const;

    AudioTrackInfo GetActiveAudioTrack() const;

    bool IsMuted() const;

    void Mute(bool bMute);

    void SetMaxBitrate(uint64_t uMaxBitrate);

    void SetUserAgent(const CYIString &userAgent);

    /*
     \details Sets the video player metadata.
     */
    void SetVideoMetadata(const CYIAbstractVideoPlayer::VideoMetadata &metadata);

    const DRMConfiguration *GetDRMConfiguration() const;

    DRMConfiguration *GetDRMConfiguration();

    CYISignal<> BufferingStarted;
    
    CYISignal<> BufferingEnded;

    CYISignal<Error> ErrorOccurred;
    
    CYISignal<> Preparing;

    CYISignal<> Ready;

    CYISignal<> Playing;

    CYISignal<> Paused;
    
    CYISignal<> PlaybackComplete;

    CYISignal<> Finalized;

    CYISignal<uint64_t> CurrentTimeUpdated;

    CYISignal<uint64_t> DurationChanged;

    CYISignal<const CYIAbstractVideoPlayer::PlayerState &> PlayerStateChanged;

    CYISignal<std::vector<AudioTrackInfo> > AvailableAudioTracksChanged;
    
    CYISignal<std::vector<ClosedCaptionsTrackInfo> > AvailableClosedCaptionsTracksChanged;

protected:
    CYIAbstractVideoPlayer();

    const std::shared_ptr<CYIMaterial> &GetVideoMaterial() const;

    void SetVideoSurfaceSize(const glm::ivec2 &size);
    
    void ChangeInitialPlaybackState(CYIAbstractVideoPlayer::PLAYBACK_STATE eInitialState);
    
    CYIAbstractVideoPlayer::PLAYBACK_STATE GetRequestedInitialPlaybackState() const;

    void CheckAndNotifyMediaTracksChanged();

    void UpdateCurrentTime();
    
    CYISignal<Error> NotifyErrorOccurred;
    
    CYISignal<> NotifyPlaybackComplete;
    
    CYISignal<uint64_t> NotifyDurationChanged;

    std::unique_ptr<CYIVideoPlayerStateManager> m_pStateManager;

    std::unique_ptr<CYIClosedCaptionsDispatcher> m_pClosedCaptionsDispatcher;

    std::shared_ptr<DRMConfiguration> m_pDRMConfiguration;

    uint64_t m_uMaxBitrate;

private:
    class TimeUpdater : public CYITime::UpdateListener
    {
    public:
        TimeUpdater();
        void SetPlayer(CYIAbstractVideoPlayer *pPlayer);
        virtual bool OnFrameTimeUpdated(std::chrono::microseconds nFrameTime) override;

    private:
        CYIAbstractVideoPlayer *m_pPlayer;
    };
    friend class TimeUpdater;

    virtual CYIString GetName_() const;

    virtual CYIString GetVersion_() const;

    virtual Statistics GetStatistics_() const;

    /*  
        \details Subclasses must implement this function to create the correct CYIVideoSurface instance for the CYIAbstractVideoPlayer implementation.
     
        \note The surface will be stored in m_pVideoSurface and will be cleaned up automatically.
     */
    virtual std::unique_ptr<CYIVideoSurface> CreateSurface_() = 0;

    virtual bool SupportsFormat_(STREAMING_FORMAT eStreamingFormat, DRM_SCHEME eDRMScheme = DRM_NONE) const = 0;

    virtual void Prepare_(const CYIUrl &videoURI, STREAMING_FORMAT eFormat) = 0;

    virtual void Play_() = 0;

    virtual void Pause_() = 0;
    
    virtual void Stop_() = 0;

    virtual uint64_t GetDurationMs_() const = 0;

    virtual uint64_t GetCurrentTimeMs_() const = 0;

    virtual void Seek_(uint64_t uSeekPositionMS) = 0;

    virtual bool SelectAudioTrack_(uint32_t uID) = 0;

    virtual std::vector<AudioTrackInfo> GetAudioTracks_() const = 0;

    virtual CYIAbstractVideoPlayer::AudioTrackInfo GetActiveAudioTrack_() const = 0;

    virtual bool IsMuted_() const = 0;

    virtual void Mute_(bool bMute) = 0;

    virtual void DisableClosedCaptions_() = 0;

    virtual bool SelectClosedCaptionsTrack_(uint32_t uID) = 0;

    virtual std::vector<ClosedCaptionsTrackInfo> GetClosedCaptionsTracks_() const = 0;

    virtual CYIAbstractVideoPlayer::ClosedCaptionsTrackInfo GetActiveClosedCaptionsTrack_() const = 0; 

    virtual void GetClosedCaptionsDispatcher_() const;
    
    virtual void SetMaxBitrate_(uint64_t uMaxBitrate);

    virtual void SetUserAgent_(const CYIString &userAgent);

    virtual void SetVideoMetadata_(const CYIAbstractVideoPlayer::VideoMetadata &metadata);

    void CheckAndNotifyAudioTracksChanged();
    void CheckAndNotifyClosedCaptionsTracksChanged();
    void OnNotifyErrorOccurred(Error error);
    void OnNotifyPlaybackComplete();
    void OnNotifyDurationChanged(uint64_t);
    void ClearCachedTrackData();
    void OnStateReady();
    void OnStateUnloaded();
    void ClearClosedCaptions();

    bool m_bAudioTracksAvailable;
    std::vector<AudioTrackInfo> m_audioTracksCache;

    std::unique_ptr<CYIVideoSurface> m_pVideoSurface;
    uint64_t m_uLastNotifiedTime;
    TimeUpdater m_timeUpdater;
    PLAYBACK_STATE m_eInitialPlaybackState;
    PLAYBACK_STATE m_eRequestedInitialPlaybackState;
    CYITimer m_mediaTracksRefreshTimer;

    bool m_bClosedCaptionsTracksAvailable;
    std::vector<ClosedCaptionsTrackInfo> m_closedCaptionsTracksCache;
    static const ClosedCaptionsTrackInfo CLOSED_CAPTIONS_OFF_TRACK;
    
    YI_TYPE_BASES(CYIAbstractVideoPlayer)
    YI_DISALLOW_COPY_AND_ASSIGN(CYIAbstractVideoPlayer)
};

// Audio tracks
bool operator==(const CYIAbstractVideoPlayer::AudioTrackInfo &audioTrackL, const CYIAbstractVideoPlayer::AudioTrackInfo &audioTrackR);
bool operator!=(const CYIAbstractVideoPlayer::AudioTrackInfo &audioTrackL, const CYIAbstractVideoPlayer::AudioTrackInfo &audioTrackR);

// Closed captions tracks
bool operator==(const CYIAbstractVideoPlayer::ClosedCaptionsTrackInfo &closedCaptionsTrackL, const CYIAbstractVideoPlayer::ClosedCaptionsTrackInfo &closedCaptionsTrackR);
bool operator!=(const CYIAbstractVideoPlayer::ClosedCaptionsTrackInfo &closedCaptionsTrackL, const CYIAbstractVideoPlayer::ClosedCaptionsTrackInfo &closedCaptionsTrackR);

//States
bool operator ==(const CYIAbstractVideoPlayer::PlayerState &playerStateL, const CYIAbstractVideoPlayer::PlayerState &playerStateR);
bool operator ==(const CYIAbstractVideoPlayer::PlayerState &playerState, const CYIAbstractVideoPlayer::MEDIA_STATE &mediaState);
bool operator ==(const CYIAbstractVideoPlayer::MEDIA_STATE &mediaState, const CYIAbstractVideoPlayer::PlayerState &playerState);
bool operator ==(const CYIAbstractVideoPlayer::PlayerState &playerState, const CYIAbstractVideoPlayer::PLAYBACK_STATE &playbackState);
bool operator ==(const CYIAbstractVideoPlayer::PLAYBACK_STATE &playbackState, const CYIAbstractVideoPlayer::PlayerState &playerState);

bool operator !=(const CYIAbstractVideoPlayer::PlayerState &playerStateL, const CYIAbstractVideoPlayer::PlayerState &playerStateR);
bool operator !=(const CYIAbstractVideoPlayer::PlayerState &playerState, const CYIAbstractVideoPlayer::MEDIA_STATE &mediaState);
bool operator !=(const CYIAbstractVideoPlayer::MEDIA_STATE &mediaState, const CYIAbstractVideoPlayer::PlayerState &playerState);
bool operator !=(const CYIAbstractVideoPlayer::PlayerState &playerState, const CYIAbstractVideoPlayer::PLAYBACK_STATE &playbackState);
bool operator !=(const CYIAbstractVideoPlayer::PLAYBACK_STATE &playbackState, const CYIAbstractVideoPlayer::PlayerState &playerState);

#endif //ifndef _YI_ABSTRACT_VIDEO_PLAYER_H_