MediaSampleSinks.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Containers/Array.h"
#include "Templates/SharedPointer.h"
 
#include "MediaSampleSink.h"
 
 
template<typename SampleType, typename SinkType=TMediaSampleSink<SampleType>>
class TMediaSampleSinks
{
public:
 
    void Add(const TSharedRef<SinkType, ESPMode::ThreadSafe>& SampleSink, UMediaPlayer* Player = nullptr)
    {
        if (Sinks.Find(SampleSink) != INDEX_NONE)
        {
            return;
        }
        Sinks.Add(SampleSink);
        FMediaSampleSinkEventData Data;
        Data.Attached = { Player };
        SampleSink->ReceiveEvent(EMediaSampleSinkEvent::Attached, Data);
    }
 
    bool Enqueue(const TSharedRef<SampleType, ESPMode::ThreadSafe>& Sample)
    {
        bool Overflowed = false;
 
        for (int32 SinkIndex = Sinks.Num() - 1; SinkIndex >= 0; --SinkIndex)
        {
            TSharedPtr<SinkType, ESPMode::ThreadSafe> Sink = Sinks[SinkIndex].Pin();
 
            if (Sink.IsValid())
            {
                if (!Sink->CanAcceptSamples(1))
                {
                    Overflowed = true;
                }
                else
                {
                    Sink->Enqueue(Sample);
                    FMediaSampleSinkEventData Data;
                    Sink->ReceiveEvent(EMediaSampleSinkEvent::SampleDataUpdate, Data);
                }
            }
            else
            {
                Sinks.RemoveAt(SinkIndex);
            }
        }
 
        return !Overflowed;
    }
 
    void Flush(UMediaPlayer* MediaPlayer)
    {
        for (int32 SinkIndex = Sinks.Num() - 1; SinkIndex >= 0; --SinkIndex)
        {
            TSharedPtr<SinkType, ESPMode::ThreadSafe> Sink = Sinks[SinkIndex].Pin();
 
            if (Sink.IsValid())
            {
                Sink->RequestFlush();
 
                FMediaSampleSinkEventData Data;
                Data.FlushWasRequested = { MediaPlayer };
                Sink->ReceiveEvent(EMediaSampleSinkEvent::FlushWasRequested, Data);
            }
            else
            {
                Sinks.RemoveAt(SinkIndex);
            }
        }
    }
 
    int32 Num() const
    {
        return Sinks.Num();
    }
 
    bool IsEmpty() const
    {
        return Sinks.IsEmpty();
    }
 
    void Remove(const TSharedRef<SinkType, ESPMode::ThreadSafe>& SampleSink, UMediaPlayer* Player = nullptr)
    {
        if (Sinks.RemoveSingle(SampleSink))
        {
            FMediaSampleSinkEventData Data;
            Data.Detached = { Player };
            SampleSink->ReceiveEvent(EMediaSampleSinkEvent::Detached, Data);
        }
    }
 
    void Cleanup()
    {
        for (int32 SinkIndex = Sinks.Num() - 1; SinkIndex >= 0; --SinkIndex)
        {
            if (!Sinks[SinkIndex].IsValid())
            {
                Sinks.RemoveAt(SinkIndex);
            }
        }
    }
 
    void ReceiveEvent(EMediaSampleSinkEvent Event, const FMediaSampleSinkEventData& Data)
    {
        for (int32 SinkIndex = Sinks.Num() - 1; SinkIndex >= 0; --SinkIndex)
        {
            TSharedPtr<SinkType, ESPMode::ThreadSafe> Sink = Sinks[SinkIndex].Pin();
 
            if (Sink.IsValid())
            {
                Sink->ReceiveEvent(Event, Data);
            }
            else
            {
                Sinks.RemoveAt(SinkIndex);
            }
        }
    }
 
protected:
 
    TArray<TWeakPtr<SinkType, ESPMode::ThreadSafe>> Sinks;
};
 
typedef TMediaSampleSinks<IMediaTextureSample, FMediaTextureSampleSink> FMediaVideoSampleSinks;
 
class FMediaAudioSampleSinks : public TMediaSampleSinks<IMediaAudioSample, FMediaAudioSampleSink>
{
public:
    TSharedPtr<FMediaAudioSampleSink, ESPMode::ThreadSafe> GetPrimaryAudioSink()
    {
        Cleanup();
        if (Sinks.Num() == 0)
        {
            return TSharedPtr<FMediaAudioSampleSink, ESPMode::ThreadSafe>();
        }
        return Sinks[0].Pin();
    }
};
 
typedef TMediaSampleSinks<IMediaOverlaySample, FMediaOverlaySampleSink> FMediaOverlaySampleSinks;
typedef TMediaSampleSinks<IMediaBinarySample, FMediaBinarySampleSink> FMediaBinarySampleSinks;