IMediaPlayer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/UnrealString.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Internationalization/Text.h"
#include "Math/Interval.h"
#include "Math/IntPoint.h"
#include "Math/MathFwd.h"
#include "Misc/Paths.h"
#include "Misc/Timespan.h"
#include "Misc/Variant.h"
 
class FArchive;
 
class IMediaCache;
class IMediaControls;
class IMediaOptions;
class IMediaSamples;
class IMediaTracks;
class IMediaView;
class IMediaMetadataItem;
 
struct FGuid;
struct FMediaPlayerOptions;
 
class IMediaPlayer
{
public:
 
    //~ The following methods must be implemented by media players
 
    virtual void Close() = 0;
 
    virtual IMediaCache& GetCache() = 0;
 
    virtual IMediaControls& GetControls() = 0;
 
    virtual FString GetInfo() const = 0;
 
    virtual FGuid GetPlayerPluginGUID() const = 0;
 
    virtual IMediaSamples& GetSamples() = 0;
 
    virtual FString GetStats() const = 0;
 
    virtual IMediaTracks& GetTracks() = 0;
 
    virtual FString GetUrl() const = 0;
 
    virtual IMediaView& GetView() = 0;
 
    virtual bool Open(const FString& Url, const IMediaOptions* Options) = 0;
 
    virtual bool Open(const TSharedRef<FArchive, ESPMode::ThreadSafe>& Archive, const FString& OriginalUrl, const IMediaOptions* Options) = 0;
 
public:
 
    //~ The following methods are optional
 
    virtual bool Open(const FString& Url, const IMediaOptions* Options, const FMediaPlayerOptions* PlayerOptions)
    {
        return Open(Url, Options);
    }
 
    virtual FVariant GetMediaInfo(FName InfoName) const
    {
        return FVariant();
    }
 
    virtual TSharedPtr<TMap<FString, TArray<TUniquePtr<IMediaMetadataItem>>>, ESPMode::ThreadSafe> GetMediaMetadata() const
    {
        return nullptr;
    }
 
    virtual FText GetMediaName() const
    {
        const FString Url = GetUrl();
 
        if (Url.IsEmpty())
        {
            return FText::GetEmpty();
        }
 
        return FText::FromString(FPaths::GetBaseFilename(Url));
    }
 
    virtual void SetGuid(const FGuid& Guid)
    {
        // override in child classes if supported
    }
 
    virtual bool SetNativeVolume(float Volume)
    {
        return false;
    }
 
    virtual void SetLastAudioRenderedSampleTime(FTimespan SampleTime)
    {
        // override in child classes if supported
    }
 
    virtual void TickAudio()
    {
        // override in child class if needed
    }
 
    virtual void TickFetch(FTimespan DeltaTime, FTimespan Timecode)
    {
        // override in child class if needed
    }
 
    virtual void TickInput(FTimespan DeltaTime, FTimespan Timecode)
    {
        // override in child class if needed
    }
 
    virtual bool FlushOnSeekStarted() const
    {
        return false;
    }
 
    virtual bool FlushOnSeekCompleted() const
    {
        return true;
    }
 
    enum class EFeatureFlag
    {
        AllowShutdownOnClose = 0,       
        UsePlaybackTimingV2,            
        UseRealtimeWithVideoOnly,       
        AlwaysPullNewestVideoFrame,     
        PlayerUsesInternalFlushOnSeek,  
        IsTrackSwitchSeamless,          
        PlayerSelectsDefaultTracks,     
    };
    
    virtual bool GetPlayerFeatureFlag(EFeatureFlag /*flag*/) const
    {
        // Override in child class if needed.
        return false;
    }
 
    class IAsyncResourceReleaseNotification
    {
    public:
        virtual ~IAsyncResourceReleaseNotification() {}
        virtual void Signal(uint32 ResourceFlags) = 0;
    };
    typedef TSharedRef<IAsyncResourceReleaseNotification, ESPMode::ThreadSafe> IAsyncResourceReleaseNotificationRef;
 
    virtual bool SetAsyncResourceReleaseNotification(IAsyncResourceReleaseNotificationRef AsyncDestructNotification)
    {
        // Override in child class if needed.
        return false;
    }
 
    /*
    * Return IMediaPlayerLifecycleManagerDelegate::ResourceFlags bitmask to indicate resource types recreated on a open call
    */
    virtual uint32 GetNewResourcesOnOpen() const
    {
        // Override in child class if needed. Default assumes resources carry over (to a large degree) and are created per instance only
        // (as a simplified model for older players)
        return 0;
    }
 
public:
 
    virtual ~IMediaPlayer() { }
};