MediaPlayerFacade.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Queue.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/CriticalSection.h"
#include "IMediaClockSink.h"
#include "IMediaEventSink.h"
#include "IMediaPlayerLifecycleManager.h"
#include "IMediaTickable.h"
#include "IMediaTimeSource.h"
#include "IMediaTracks.h"
#include "Internationalization/Text.h"
#include "Math/MathFwd.h"
#include "Math/Quat.h"
#include "Math/Range.h"
#include "Math/RangeSet.h"
#include "Math/Rotator.h"
#include "MediaPlayerOptions.h"
#include "MediaSampleSink.h"
#include "MediaSampleSinks.h"
#include "Misc/Guid.h"
#include "Misc/Optional.h"
#include "Misc/Timespan.h"
#include "Misc/Timecode.h"
#include "Misc/Variant.h"
#include "Templates/Atomic.h"
#include "Templates/SharedPointer.h"
#include "UObject/NameTypes.h"
 
class FMediaSampleCache;
class IMediaModule;
class IMediaOptions;
class IMediaPlayer;
class IMediaPlayerFactory;
class IMediaSamples;
class IMediaMetadataItem;
 
enum class EMediaEvent;
enum class EMediaCacheState;
enum class EMediaThreads;
enum class EMediaTrackType;
enum class EMediaTimeRangeType;
 
struct FMediaAudioTrackFormat;
struct FMediaPlayerOptions;
struct FMediaVideoTrackFormat;
 
 
class FMediaPlayerFacade
    : public IMediaClockSink
    , public IMediaTickable
    , protected IMediaEventSink
    , public TSharedFromThis<FMediaPlayerFacade, ESPMode::ThreadSafe>
{
public:
 
    FName DesiredPlayerName;
 
    FTimespan TimeDelay;
 
    TOptional<FMediaPlayerOptions> ActivePlayerOptions;
 
public:
 
    MEDIAUTILS_API FMediaPlayerFacade(TWeakObjectPtr<UMediaPlayer> InMediaPlayer);
 
    MEDIAUTILS_API virtual ~FMediaPlayerFacade();
 
public:
 
    MEDIAUTILS_API void AddAudioSampleSink(const TSharedRef<FMediaAudioSampleSink, ESPMode::ThreadSafe>& SampleSink);
 
    MEDIAUTILS_API void AddCaptionSampleSink(const TSharedRef<FMediaOverlaySampleSink, ESPMode::ThreadSafe>& SampleSink);
 
    MEDIAUTILS_API void AddMetadataSampleSink(const TSharedRef<FMediaBinarySampleSink, ESPMode::ThreadSafe>& SampleSink);
 
    MEDIAUTILS_API void AddSubtitleSampleSink(const TSharedRef<FMediaOverlaySampleSink, ESPMode::ThreadSafe>& SampleSink);
 
    MEDIAUTILS_API void AddVideoSampleSink(const TSharedRef<FMediaTextureSampleSink, ESPMode::ThreadSafe>& SampleSink);
 
    MEDIAUTILS_API bool CanPause() const;
 
    MEDIAUTILS_API bool CanPlayUrl(const FString& Url, const IMediaOptions* Options);
 
    MEDIAUTILS_API bool CanResume() const;
 
    MEDIAUTILS_API bool CanScrub() const;
 
    MEDIAUTILS_API bool CanSeek() const;
 
    MEDIAUTILS_API bool SupportsPlaybackTimeRange() const;
 
    MEDIAUTILS_API void Close();
 
    MEDIAUTILS_API uint32 GetAudioTrackChannels(int32 TrackIndex, int32 FormatIndex) const;
 
    MEDIAUTILS_API uint32 GetAudioTrackSampleRate(int32 TrackIndex, int32 FormatIndex) const;
 
    MEDIAUTILS_API FString GetAudioTrackType(int32 TrackIndex, int32 FormatIndex) const;
 
    MEDIAUTILS_API FTimespan GetDuration() const;
 
    MEDIAUTILS_API const FGuid& GetGuid();
 
    MEDIAUTILS_API FString GetInfo() const;
 
    MEDIAUTILS_API FVariant GetMediaInfo(FName InfoName) const;
 
    MEDIAUTILS_API FText GetMediaName() const;
 
    MEDIAUTILS_API TSharedPtr<TMap<FString, TArray<TUniquePtr<IMediaMetadataItem>>>, ESPMode::ThreadSafe> GetMediaMetadata() const;
 
    MEDIAUTILS_API int32 GetNumTracks(EMediaTrackType TrackType) const;
 
    MEDIAUTILS_API int32 GetNumTrackFormats(EMediaTrackType TrackType, int32 TrackIndex) const;
 
    TSharedPtr<IMediaPlayer, ESPMode::ThreadSafe> GetPlayer() const
    {
        return Player;
    }
 
    MEDIAUTILS_API FName GetPlayerName() const;
 
    MEDIAUTILS_API float GetRate() const;
 
    MEDIAUTILS_API int32 GetSelectedTrack(EMediaTrackType TrackType) const;
 
    MEDIAUTILS_API FString GetStats() const;
 
    MEDIAUTILS_API TRangeSet<float> GetSupportedRates(bool Unthinned = true) const;
 
    MEDIAUTILS_API TRange<FTimespan> GetPlaybackTimeRange(EMediaTimeRangeType InRangeToGet) const;
 
    MEDIAUTILS_API FTimespan GetTime() const;
 
    MEDIAUTILS_API FMediaTimeStamp GetTimeStamp() const;
 
    MEDIAUTILS_API FMediaTimeStamp GetDisplayTimeStamp() const;
 
    MEDIAUTILS_API TOptional<FTimecode> GetVideoTimecode() const;
 
    MEDIAUTILS_API TRange<FMediaTimeStamp> GetLastProcessedVideoSampleTimeRange() const;
 
    MEDIAUTILS_API FText GetTrackDisplayName(EMediaTrackType TrackType, int32 TrackIndex) const;
 
    MEDIAUTILS_API int32 GetTrackFormat(EMediaTrackType TrackType, int32 TrackIndex) const;
 
    MEDIAUTILS_API FString GetTrackLanguage(EMediaTrackType TrackType, int32 TrackIndex) const;
 
    const FString& GetUrl() const
    {
        return CurrentUrl;
    }
 
    MEDIAUTILS_API float GetVideoTrackAspectRatio(int32 TrackIndex, int32 FormatIndex) const;
 
    MEDIAUTILS_API FIntPoint GetVideoTrackDimensions(int32 TrackIndex, int32 FormatIndex) const;
 
    MEDIAUTILS_API float GetVideoTrackFrameRate(int32 TrackIndex, int32 FormatIndex) const;
 
    MEDIAUTILS_API TRange<float> GetVideoTrackFrameRates(int32 TrackIndex, int32 FormatIndex) const;
 
    MEDIAUTILS_API FString GetVideoTrackType(int32 TrackIndex, int32 FormatIndex) const;
 
    MEDIAUTILS_API bool GetViewField(float& OutHorizontal, float& OutVertical) const;
 
    MEDIAUTILS_API bool GetViewOrientation(FQuat& OutOrientation) const;
 
    MEDIAUTILS_API bool HasError() const;
 
    MEDIAUTILS_API bool IsBuffering() const;
 
    MEDIAUTILS_API bool IsConnecting() const;
 
    MEDIAUTILS_API bool IsLooping() const;
 
    MEDIAUTILS_API bool IsPaused() const;
 
    MEDIAUTILS_API bool IsPlaying() const;
 
    MEDIAUTILS_API bool IsPreparing() const;
 
    MEDIAUTILS_API bool IsClosed() const;
 
    MEDIAUTILS_API bool IsReady() const;
 
    MEDIAUTILS_API bool Open(const FString& Url, const IMediaOptions* Options, const FMediaPlayerOptions* PlayerOptions = nullptr);
 
    MEDIAUTILS_API void QueryCacheState(EMediaTrackType TrackType, EMediaCacheState State, TRangeSet<FTimespan>& OutTimeRanges) const;
 
    MEDIAUTILS_API bool Seek(const FTimespan& Time);
 
    MEDIAUTILS_API bool IsSeeking() const;
 
    MEDIAUTILS_API FMediaTimeStamp GetSeekTarget() const;
 
    MEDIAUTILS_API void SetNextSeek(const FTimespan& InTime);
 
    MEDIAUTILS_API bool SelectTrack(EMediaTrackType TrackType, int32 TrackIndex);
 
    MEDIAUTILS_API void SetBlockOnTime(const FTimespan& Time);
 
    MEDIAUTILS_API void SetBlockOnTimeRange(const TRange<FTimespan>& TimeRange);
 
    MEDIAUTILS_API void SetCacheWindow(FTimespan Ahead, FTimespan Behind);
 
    MEDIAUTILS_API void SetGuid(FGuid& Guid);
 
    MEDIAUTILS_API bool SetLooping(bool Looping);
 
    MEDIAUTILS_API void SetMediaOptions(const IMediaOptions* Options);
 
    MEDIAUTILS_API bool SetRate(float Rate);
 
    MEDIAUTILS_API bool SetPlaybackTimeRange(const TRange<FTimespan>& InTimeRange);
 
    MEDIAUTILS_API bool SetNativeVolume(float Volume);
 
    MEDIAUTILS_API bool SetTrackFormat(EMediaTrackType TrackType, int32 TrackIndex, int32 FormatIndex);
 
    MEDIAUTILS_API bool SetVideoTrackFrameRate(int32 TrackIndex, int32 FormatIndex, float FrameRate);
 
    MEDIAUTILS_API bool SetViewField(float Horizontal, float Vertical, bool Absolute);
 
    MEDIAUTILS_API bool SetViewOrientation(const FQuat& Orientation, bool Absolute);
 
    MEDIAUTILS_API bool SupportsRate(float Rate, bool Unthinned) const;
 
    MEDIAUTILS_API void SetLastAudioRenderedSampleTime(FTimespan SampleTime);
 
    MEDIAUTILS_API FTimespan GetLastAudioRenderedSampleTime() const;
 
    MEDIAUTILS_API void SetAreEventsSafeForAnyThread(bool bInAreEventsSafeForAnyThread);
 
public:
 
    DECLARE_EVENT_OneParam(FMediaPlayerFacade, FOnMediaEvent, EMediaEvent /*Event*/)
    FOnMediaEvent& OnMediaEvent()
    {
        return MediaEvent;
    }
 
public:
 
    //~ IMediaClockSink interface
 
    MEDIAUTILS_API virtual void TickFetch(FTimespan DeltaTime, FTimespan Timecode) override;
    MEDIAUTILS_API virtual void TickInput(FTimespan DeltaTime, FTimespan Timecode) override;
    MEDIAUTILS_API virtual void TickOutput(FTimespan DeltaTime, FTimespan Timecode) override;
 
public:
 
    //~ IMediaTickable interface
 
    MEDIAUTILS_API virtual void TickTickable() override;
 
protected:
 
    MEDIAUTILS_API bool BlockOnFetch() const;
 
    MEDIAUTILS_API void Flush(bool bExcludePlayer = false, bool bOnSeek = false);
 
    MEDIAUTILS_API FMediaTimeStamp GetTimeStampInternal(bool bForDisplay) const;
 
    MEDIAUTILS_API bool GetAudioTrackFormat(int32 TrackIndex, int32 FormatIndex, FMediaAudioTrackFormat& OutFormat) const;
 
    MEDIAUTILS_API IMediaPlayerFactory *GetPlayerFactoryForUrl(const FString& Url, const IMediaOptions* Options) const;
 
    MEDIAUTILS_API bool GetVideoTrackFormat(int32 TrackIndex, int32 FormatIndex, FMediaVideoTrackFormat& OutFormat) const;
 
    MEDIAUTILS_API void ProcessEvent(EMediaEvent Event, bool bIsBroadcastAllowed);
 
private:
    struct FTrackSelection
    {
        int32 UserSelection[(int32)EMediaTrackType::Num];
        int32 PlayerSelection[(int32)EMediaTrackType::Num];
    } TrackSelection;
 
    MEDIAUTILS_API void ResetTracks();
 
    MEDIAUTILS_API void UpdateTrackSelectionWithPlayer();
 
    MEDIAUTILS_API void SelectDefaultTracks();
 
protected:
    MEDIAUTILS_API bool HaveAudioPlayback() const;
    MEDIAUTILS_API bool HaveVideoPlayback() const;
    MEDIAUTILS_API float GetUnpausedRate() const;
 
 
protected:
 
    //~ IMediaEventSink interface
 
    MEDIAUTILS_API void ReceiveMediaEvent(EMediaEvent Event) override;
 
private:
    friend class FMediaPlayerLifecycleManagerDelegateControl;
 
    // Internal
    MEDIAUTILS_API bool NotifyLifetimeManagerDelegate_PlayerOpen(IMediaPlayerLifecycleManagerDelegate::IControlRef& NewLifecycleManagerDelegateControl, const FString& InUrl, const IMediaOptions* Options, const FMediaPlayerOptions* InPlayerOptions, IMediaPlayerFactory* PlayerFactory, bool bWillCreatePlayer, uint32 WillUseNewResources, uint64 NewPlayerInstanceID);
    MEDIAUTILS_API bool NotifyLifetimeManagerDelegate_PlayerCreated();
    MEDIAUTILS_API bool NotifyLifetimeManagerDelegate_PlayerCreateFailed();
    MEDIAUTILS_API bool NotifyLifetimeManagerDelegate_PlayerClosed();
    MEDIAUTILS_API bool NotifyLifetimeManagerDelegate_PlayerDestroyed();
    MEDIAUTILS_API bool NotifyLifetimeManagerDelegate_PlayerResourcesReleased(uint32 ResourceFlags);
 
    MEDIAUTILS_API void ProcessAudioSamples(IMediaSamples& Samples, const TRange<FMediaTimeStamp>& TimeRange);
    MEDIAUTILS_API bool ProcessVideoSamples(IMediaSamples& Samples, const TRange<FMediaTimeStamp>& TimeRange);
    MEDIAUTILS_API void ProcessCaptionSamples(IMediaSamples& Samples, const TRange<FMediaTimeStamp>& TimeRange);
    MEDIAUTILS_API void ProcessSubtitleSamples(IMediaSamples& Samples, const TRange<FMediaTimeStamp>& TimeRange);
    MEDIAUTILS_API void ProcessMetadataSamples(IMediaSamples& Samples, const TRange<FMediaTimeStamp>& TimeRange);
 
    MEDIAUTILS_API void ProcessAudioSamplesV1(IMediaSamples& Samples, TRange<FTimespan> TimeRange);
    MEDIAUTILS_API void ProcessVideoSamplesV1(IMediaSamples& Samples, TRange<FTimespan> TimeRange);
    MEDIAUTILS_API void ProcessSubtitleSamplesV1(IMediaSamples& Samples, TRange<FTimespan> TimeRange);
    MEDIAUTILS_API void ProcessCaptionSamplesV1(IMediaSamples& Samples, TRange<FTimespan> TimeRange);
    MEDIAUTILS_API void ProcessMetadataSamplesV1(IMediaSamples& Samples, TRange<FTimespan> TimeRange);
 
    MEDIAUTILS_API bool IsVideoSampleStillGood(const TRange<FMediaTimeStamp>& LastSampleTimeRange, const TRange<FMediaTimeStamp>& TimeRange, bool bReverse) const;
    MEDIAUTILS_API void MonitorAudioEnablement();
    MEDIAUTILS_API void UpdateSeekStatus(const FMediaTimeStamp* pCheckTimeStamp = nullptr);
    void ExecuteNextSeek();
    void PrepareSampleQueueForSequenceIndex();
    MEDIAUTILS_API void PreSampleProcessingTimeHandling();
    MEDIAUTILS_API bool GetCurrentPlaybackTimeRange(TRange<FMediaTimeStamp>& TimeRange, float Rate, FTimespan DeltaTime, bool bPurgeSampleRelated) const;
    MEDIAUTILS_API void PostSampleProcessingTimeHandling(FTimespan DeltaTime);
 
    MEDIAUTILS_API void DestroyPlayer();
 
    MEDIAUTILS_API bool ContinueOpen(IMediaPlayerLifecycleManagerDelegate::IControlRef NewLifecycleManagerDelegateControl, const FString& Url, const IMediaOptions* Options, const FMediaPlayerOptions* PlayerOptions, IMediaPlayerFactory* PlayerFactory, TSharedPtr<IMediaPlayer, ESPMode::ThreadSafe> ReusedPlayer, bool bCreateNewPlayer, uint64 NewPlayerInstanceID);
 
    MEDIAUTILS_API void SendSinkEvent(EMediaSampleSinkEvent Event, const FMediaSampleSinkEventData& Data);
 
    TWeakPtr<FMediaAudioSampleSink, ESPMode::ThreadSafe> PrimaryAudioSink;
    FMediaAudioSampleSinks AudioSampleSinks;
 
    FMediaOverlaySampleSinks CaptionSampleSinks;
 
    FMediaBinarySampleSinks MetadataSampleSinks;
 
    FMediaOverlaySampleSinks SubtitleSampleSinks;
 
    FMediaVideoSampleSinks VideoSampleSinks;
 
private:
    MEDIAUTILS_API TRange<FMediaTimeStamp> GetAdjustedBlockOnRange() const;
 
    TRange<FTimespan> GetActivePlaybackRange() const;
    void ReInit();
 
    class FBlockOnRange
    {
    public:
        FBlockOnRange(FMediaPlayerFacade* InFacade) : Facade(InFacade) { Reset(); }
 
        void SetRange(const TRange<FTimespan> & NewRange);
 
        const TRange<FMediaTimeStamp> & GetRange() const;
        bool IsSet() const;
 
        void OnFlush();
        void OnSeek(int32 PrimaryIndex);
 
        void Reset()
        {
            BlockOnRange = TRange<FMediaTimeStamp>::Empty();
            CurrentTimeRange = TRange<FTimespan>::Empty();
            LastProcessedTimeRange = TRange<FTimespan>::Empty();
            RangeIsDirty = false;
            OnBlockSequenceIndex = 0;
            OnBlockLoopIndexOffset = 0;
        }
 
    private:
        FMediaPlayerFacade* Facade;
 
        TRange<FTimespan> CurrentTimeRange;
 
        mutable TRange<FTimespan> LastProcessedTimeRange;
 
        mutable TRange<FMediaTimeStamp> BlockOnRange;
 
        mutable bool RangeIsDirty;
 
        mutable int32 OnBlockSequenceIndex;
 
        mutable int32 OnBlockLoopIndexOffset;
    };
 
    FBlockOnRange BlockOnRange;
 
 
    bool BlockOnRangeDisabled;
 
    FMediaSampleCache* Cache;
 
    FCriticalSection CriticalSection;
 
    FString CurrentUrl;
 
    float LastRate;
 
    float CurrentRate;
 
    bool bHaveActiveAudio;
 
    int32 VideoSampleAvailability;
    int32 AudioSampleAvailability;
 
    FOnMediaEvent MediaEvent;
 
    FTimespan NextVideoSampleTime;
 
    TSharedPtr<IMediaPlayer, ESPMode::ThreadSafe> Player;
 
    uint64 PlayerInstanceID = ~0;
 
    bool PlayerUsesResourceReleaseNotification = false;
 
    FGuid PlayerGuid;
 
    TQueue<EMediaEvent, EQueueMode::Mpsc> QueuedEvents;
 
    TQueue<EMediaEvent, EQueueMode::Spsc> QueuedEventBroadcasts;
 
    mutable FCriticalSection TimeValueLock;
 
    FMediaTimeStampSample LastAudioRenderedSampleTime;
 
    FMediaTimeStampSample LastAudioSampleProcessedTime;
 
    TRange<FMediaTimeStamp> LastVideoSampleProcessedTimeRange;
 
    FMediaTimeStamp CurrentFrameAudioTimeStamp;
 
    FMediaTimeStamp CurrentFrameVideoTimeStamp;
 
    FMediaTimeStamp CurrentFrameVideoDisplayTimeStamp;
 
    FMediaTimeStampSample NextEstVideoTimeAtFrameStart;
 
    TOptional<FTimecode> MostRecentlyDeliveredVideoFrameTimecode;
 
    FMediaTimeStamp SeekTargetTime;
 
    TOptional<FTimespan> NextSeekTime;
 
    TOptional<int32> NextSequenceIndex;
 
    bool bDidRecentPlayerHaveError;
 
    bool bAreEventsSafeForAnyThread;
 
    IMediaModule* MediaModule;
 
    TWeakObjectPtr<UMediaPlayer> MediaPlayer;
 
    IMediaPlayerLifecycleManagerDelegate::IControlRef LifecycleManagerDelegateControl;
};