MediaPlayer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/UnrealString.h"
#include "Delegates/Delegate.h"
#include "IMediaOptions.h"
#include "IMediaMetadataItem.h"
#include "IMediaControls.h"
#include "Math/Quat.h"
#include "Math/Rotator.h"
#include "Templates/SharedPointer.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/ScriptMacros.h"
#include "Misc/Guid.h"
#include "Misc/Variant.h"
#include "Misc/Timecode.h"
#include "Engine/LatentActionManager.h"
#include "MediaPlayerOptions.h"
#include "IMediaTimeSource.h"
#include "IAudioProxyInitializer.h"
 
#include "MediaPlayer.generated.h"
 
class FMediaPlayerFacade;
class IMediaPlayer;
class IMediaModule;
class IMediaMetadataItem;
class UMediaPlaylist;
class UMediaSource;
class UMediaPlayer;
 
enum class EMediaEvent;
 
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnMediaPlayerMediaEvent);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnMediaPlayerMediaOpened, FString, OpenedUrl);
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnMediaPlayerMediaOpenFailed, FString, FailedUrl);
 
 
UENUM(BlueprintType)
enum class EMediaPlayerTrack : uint8
{
    Audio,
 
    Caption,
 
    Metadata,
 
    Script,
 
    Subtitle,
 
    Text,
 
    Video
};
 
 
UENUM(BlueprintType)
enum class EMediaTimeRangeBPType : uint8
{
    Absolute = (uint8)EMediaTimeRangeType::Absolute,
 
    Current = (uint8)EMediaTimeRangeType::Current
 
};
 
 
UCLASS(BlueprintType, hidecategories = (Object), MinimalAPI)
class UMediaTimeStampInfo
    : public UObject
{
    GENERATED_BODY()
 
public:
    UMediaTimeStampInfo() : Time(FTimespan::Zero()), SequenceIndex(0) {}
 
    UPROPERTY(BlueprintReadOnly, Category = "Media|Time")
    FTimespan Time;
 
    UPROPERTY(BlueprintReadOnly, Category = "Media|Time")
    int64 SequenceIndex;
};
 
USTRUCT(BlueprintType)
struct FMediaMetadataItemBPT
{
    GENERATED_BODY()
 
public:
    UPROPERTY(BlueprintReadOnly, Category = "Media|Metadata")
    FString LanguageCode;
 
    UPROPERTY(BlueprintReadOnly, Category = "Media|Metadata")
    FString MimeType;
 
    UPROPERTY(BlueprintReadOnly, Category = "Media|Metadata")
    FString StringData;
 
    UPROPERTY(BlueprintReadOnly, Category = "Media|Metadata")
    TArray<uint8> BinaryData;
};
 
USTRUCT(BlueprintType)
struct FMediaMetadataItemsBPT
{
    GENERATED_BODY()
public:
    UPROPERTY(BlueprintReadOnly, Category = "Media|Metadata")
    TArray<FMediaMetadataItemBPT> Items;
};
 
class FMediaPlayerProxy : public Audio::TProxyData<FMediaPlayerProxy>
{
public:
    IMPL_AUDIOPROXY_CLASS(FMediaPlayerProxy);
 
    MEDIAASSETS_API explicit FMediaPlayerProxy(UMediaPlayer* Player);
 
    MEDIAASSETS_API FMediaPlayerProxy(const FMediaPlayerProxy& Other);
 
    MEDIAASSETS_API ~FMediaPlayerProxy();
 
    TSharedPtr<FMediaPlayerFacade, ESPMode::ThreadSafe> GetPlayerFacade() const
    {
        return(PlayerFacade.Pin());
    }
 
    friend inline uint32 GetTypeHash(const FMediaPlayerProxy& InProxy)
    {
        return InProxy.TypeHash;
    }
 
private:
    TWeakPtr<FMediaPlayerFacade, ESPMode::ThreadSafe> PlayerFacade;
    uint32 TypeHash = INDEX_NONE;
};
using FMediaPlayerProxyPtr = TSharedPtr<FMediaPlayerProxy, ESPMode::ThreadSafe>;
 
 
UCLASS(BlueprintType, hidecategories=(Object), MinimalAPI)
class UMediaPlayer
    : public UObject
    , public IAudioProxyDataFactory
{
    GENERATED_UCLASS_BODY()
 
public:
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool CanPause() const;
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API bool CanPlaySource(UMediaSource* MediaSource);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool CanPlayUrl(const FString& Url);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API void Close();
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API int32 GetAudioTrackChannels(int32 TrackIndex, int32 FormatIndex) const;
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API int32 GetAudioTrackSampleRate(int32 TrackIndex, int32 FormatIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API FString GetAudioTrackType(int32 TrackIndex, int32 FormatIndex) const;
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API FName GetDesiredPlayerName() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API FTimespan GetDuration() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API float GetHorizontalFieldOfView() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API virtual FText GetMediaName() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API int32 GetNumTracks(EMediaPlayerTrack TrackType) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API int32 GetNumTrackFormats(EMediaPlayerTrack TrackType, int32 TrackIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API FName GetPlayerName() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    UMediaPlaylist* GetPlaylist() const
    {
        EnsurePlaylist();
        return Playlist;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    int32 GetPlaylistIndex() const
    {
        return PlaylistIndex;
    }
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API float GetRate() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API int32 GetSelectedTrack(EMediaPlayerTrack TrackType) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API void GetSupportedRates(TArray<FFloatRange>& OutRates, bool Unthinned) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API FTimespan GetTime() const;
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API FTimespan GetDisplayTime() const;
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API UMediaTimeStampInfo* GetTimeStamp() const;
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API UMediaTimeStampInfo* GetDisplayTimeStamp() const;
 
    MEDIAASSETS_API TOptional<FTimecode> GetVideoTimecode() const;
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API FText GetTrackDisplayName(EMediaPlayerTrack TrackType, int32 TrackIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API int32 GetTrackFormat(EMediaPlayerTrack TrackType, int32 TrackIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API FString GetTrackLanguage(EMediaPlayerTrack TrackType, int32 TrackIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API const FString& GetUrl() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API float GetVerticalFieldOfView() const;
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API float GetVideoTrackAspectRatio(int32 TrackIndex, int32 FormatIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API FIntPoint GetVideoTrackDimensions(int32 TrackIndex, int32 FormatIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API float GetVideoTrackFrameRate(int32 TrackIndex, int32 FormatIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API FFloatRange GetVideoTrackFrameRates(int32 TrackIndex, int32 FormatIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API FString GetVideoTrackType(int32 TrackIndex, int32 FormatIndex) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API FRotator GetViewRotation() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API FTimespan GetTimeDelay() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool HasError() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool IsBuffering() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool IsConnecting() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool IsLooping() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool IsPaused() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool IsPlaying() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool IsPreparing() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool IsClosed() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool IsReady() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool Next();
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool OpenFile(const FString& FilePath);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    bool OpenPlaylist(UMediaPlaylist* InPlaylist)
    {
        return OpenPlaylistIndex(InPlaylist, 0);
    }
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool OpenPlaylistIndex(UMediaPlaylist* InPlaylist, int32 Index);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool OpenSource(UMediaSource* MediaSource);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool OpenSourceWithOptions(UMediaSource* MediaSource, const FMediaPlayerOptions& Options);
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer", meta = (Latent, LatentInfo = "LatentInfo", WorldContext = "WorldContextObject"))
    MEDIAASSETS_API void OpenSourceLatent(const UObject* WorldContextObject, struct FLatentActionInfo LatentInfo, UMediaSource* MediaSource, const FMediaPlayerOptions& Options, bool& bSuccess);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool OpenUrl(const FString& Url);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool Pause();
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool Play();
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API void PlayAndSeek();
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool Previous();
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool Reopen();
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool Rewind();
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool Seek(const FTimespan& Time);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool Scrub(const FTimespan& Time);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool SelectTrack(EMediaPlayerTrack TrackType, int32 TrackIndex);
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API void SetBlockOnTime(const FTimespan& Time);
 
    MEDIAASSETS_API void SetBlockOnTimeRange(const TRange<FTimespan>& TimeRange);
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API void SetDesiredPlayerName(FName PlayerName);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool SetLooping(bool Looping);
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API void SetMediaOptions(const UMediaSource* Options);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool SetRate(float Rate);
 
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API bool SetNativeVolume(float Volume);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool SetTrackFormat(EMediaPlayerTrack TrackType, int32 TrackIndex, int32 FormatIndex);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool SetVideoTrackFrameRate(int32 TrackIndex, int32 FormatIndex, float FrameRate);
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API bool SetViewField(float Horizontal, float Vertical, bool Absolute);
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API bool SetViewRotation(const FRotator& Rotation, bool Absolute);
 
    UFUNCTION(BlueprintCallable, Category = "Media|MediaPlayer")
    MEDIAASSETS_API void SetTimeDelay(FTimespan TimeDelay);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool SupportsRate(float Rate, bool Unthinned) const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool SupportsScrubbing() const;
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool SupportsSeeking() const;
 
public:
 
    UPROPERTY(BlueprintAssignable, Category="Media|MediaPlayer", meta = (HideInDetailPanel))
    FOnMediaPlayerMediaEvent OnEndReached;
 
    UPROPERTY(BlueprintAssignable, Category="Media|MediaPlayer", meta = (HideInDetailPanel))
    FOnMediaPlayerMediaEvent OnMediaClosed;
 
    UPROPERTY(BlueprintAssignable, Category="Media|MediaPlayer", meta = (HideInDetailPanel))
    FOnMediaPlayerMediaOpened OnMediaOpened;
 
    UPROPERTY(BlueprintAssignable, Category="Media|MediaPlayer", meta = (HideInDetailPanel))
    FOnMediaPlayerMediaOpenFailed OnMediaOpenFailed;
 
    UPROPERTY(BlueprintAssignable, Category="Media|MediaPlayer", meta = (HideInDetailPanel))
    FOnMediaPlayerMediaEvent OnPlaybackResumed;
 
    UPROPERTY(BlueprintAssignable, Category="Media|MediaPlayer", meta = (HideInDetailPanel))
    FOnMediaPlayerMediaEvent OnPlaybackSuspended;
 
    UPROPERTY(BlueprintAssignable, Category="Media|MediaPlayer", meta = (HideInDetailPanel))
    FOnMediaPlayerMediaEvent OnSeekCompleted;
 
    UPROPERTY(BlueprintAssignable, Category="Media|MediaPlayer", meta = (HideInDetailPanel))
    FOnMediaPlayerMediaEvent OnTracksChanged;
 
    UPROPERTY(BlueprintAssignable, Category="Media|MediaPlayer", meta = (HideInDetailPanel))
    FOnMediaPlayerMediaEvent OnMetadataChanged;
 
    UPROPERTY(BlueprintAssignable, Category="Media|MediaPlayer", meta = (HideInDetailPanel))
    FOnMediaPlayerMediaEvent OnBufferingStart;
 
    UPROPERTY(BlueprintAssignable, Category="Media|MediaPlayer", meta = (HideInDetailPanel))
    FOnMediaPlayerMediaEvent OnBufferingCompleted;
public:
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool SupportsPlaybackTimeRange() const;
 
    MEDIAASSETS_API TRange<FTimespan> GetPlaybackTimeRange(EMediaTimeRangeType InRangeToGet);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API FFloatInterval GetPlaybackTimeRange(EMediaTimeRangeBPType InRangeToGet);
 
    MEDIAASSETS_API bool SetPlaybackTimeRange(const TRange<FTimespan>& InTimeRange);
 
    UFUNCTION(BlueprintCallable, Category="Media|MediaPlayer")
    MEDIAASSETS_API bool SetPlaybackTimeRange(FFloatInterval InTimeRange);
 
    MEDIAASSETS_API void CleanUpBeforeDestroy();
 
    const FGuid& GetGuid()
    {
        return PlayerGuid;
    }
 
    MEDIAASSETS_API FVariant GetMediaInfo(FName InfoName) const;
 
    template<typename T>
    bool GetMediaInfo(T& Result, FName InfoName) const
    {
        FVariant Variant = GetMediaInfo(InfoName);
        if (Variant.GetType() == TVariantTraits<T>::GetType())
        {
            Result = Variant.GetValue<T>();
            return true;
        }
 
        return false;
    }
 
    MEDIAASSETS_API TSharedPtr<TMap<FString, TArray<TUniquePtr<IMediaMetadataItem>>>, ESPMode::ThreadSafe> GetMediaMetadata() const;
 
    UFUNCTION(BlueprintCallable, Category = "Media|Metadata")
    MEDIAASSETS_API TMap<FString, FMediaMetadataItemsBPT> GetMediaMetadataItems() const;
 
    MEDIAASSETS_API TSharedRef<FMediaPlayerFacade, ESPMode::ThreadSafe> GetPlayerFacade() const;
 
    MEDIAASSETS_API void RegisterWithMediaModule();
 
    MEDIAASSETS_API void UnregisterWithMediaModule();
 
    UMediaPlaylist& GetPlaylistRef() const
    {
        EnsurePlaylist();
        return *Playlist;
    }
 
    DECLARE_EVENT_OneParam(UMediaPlayer, FOnMediaEvent, EMediaEvent /*Event*/)
    FOnMediaEvent& OnMediaEvent()
    {
        return MediaEvent;
    }
 
#if WITH_EDITOR
    MEDIAASSETS_API void PausePIE();
 
    MEDIAASSETS_API void ResumePIE();
#endif
 
public:
 
    //~ UObject interface
 
    MEDIAASSETS_API virtual void BeginDestroy() override;
 
    MEDIAASSETS_API virtual FString GetDesc() override;
    MEDIAASSETS_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    MEDIAASSETS_API virtual void PostInitProperties() override;
    MEDIAASSETS_API virtual void PostLoad() override;
 
#if WITH_EDITOR
    MEDIAASSETS_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
 
public:
    static MEDIAASSETS_API FLazyName MediaInfoNameSourceNumMips;
    static MEDIAASSETS_API FLazyName MediaInfoNameSourceNumTiles;
    static MEDIAASSETS_API FLazyName MediaInfoNameStartTimecodeValue;
    static MEDIAASSETS_API FLazyName MediaInfoNameStartTimecodeFrameRate;
    static MEDIAASSETS_API FLazyName MediaInfoNameKeyframeInterval;
 
    UPROPERTY(BlueprintReadWrite, Category=Caching)
    FTimespan CacheAhead;
 
    UPROPERTY(BlueprintReadWrite, Category=Caching)
    FTimespan CacheBehind;
 
    UPROPERTY(BlueprintReadWrite, Category=Caching)
    FTimespan CacheBehindGame;
 
public:
 
    UPROPERTY(BlueprintReadWrite, Category=Output, AdvancedDisplay)
    bool NativeAudioOut;
 
public:
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category=Playback)
    bool PlayOnOpen;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category=Playback)
    uint32 Shuffle : 1;
 
public:
    //
    // IAudioProxyDataFactory interface (for Meta Sound support)
    //
 
    MEDIAASSETS_API virtual TSharedPtr<Audio::IProxyData> CreateProxyData(const Audio::FProxyDataInitParams& InitParams) override;
 
protected:
 
    UPROPERTY(BlueprintReadOnly, EditAnywhere, Category=Playback)
    uint32 Loop:1;
 
    UPROPERTY(BlueprintReadOnly, transient, Category=Playback, BlueprintGetter = GetPlayList)
    mutable TObjectPtr<UMediaPlaylist> Playlist;
 
    UPROPERTY(BlueprintReadOnly, Category=Playback)
    int32 PlaylistIndex;
 
    UPROPERTY(BlueprintReadOnly, Category=Playback)
    FTimespan TimeDelay;
 
protected:
 
    UPROPERTY(EditAnywhere, Category=ViewSettings)
    float HorizontalFieldOfView;
 
    UPROPERTY(EditAnywhere, Category=ViewSettings)
    float VerticalFieldOfView;
 
    UPROPERTY(EditAnywhere, Category=ViewSettings)
    FRotator ViewRotation;
 
private:
    virtual bool CanBeInCluster() const override { return false; }
 
    MEDIAASSETS_API void HandlePlayerMediaEvent(EMediaEvent Event);
 
    MEDIAASSETS_API void SetPlaylistInternal(UMediaPlaylist* InPlaylist) const;
 
    MEDIAASSETS_API bool OpenSourceInternal(UMediaSource* MediaSource, const FMediaPlayerOptions* Options);
 
    MEDIAASSETS_API void EnsurePlaylist() const;
 
private:
 
    FOnMediaEvent MediaEvent;
 
    TSharedPtr<FMediaPlayerFacade, ESPMode::ThreadSafe> PlayerFacade;
 
    UPROPERTY()
    FGuid PlayerGuid;
 
    bool PlayOnNext;
 
    bool RegisteredWithMediaModule;
 
    FMediaPlayerProxyPtr Proxy;
 
#if WITH_EDITORONLY_DATA
public:
    UPROPERTY(BlueprintReadWrite, EditAnywhere, AdvancedDisplay, Category=Editor)
    bool AffectedByPIEHandling;
 
private:
    bool WasPlayingInPIE;
#endif
};