WebBrowserTextureSample.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "CoreGlobals.h"
#include "Containers/Queue.h"
#include "Math/IntPoint.h"
#include "Math/Range.h"
#include "MediaObjectPool.h"
#include "RHI.h"
#include "RHIUtilities.h"
#include "Templates/SharedPointer.h"
 
class FWebBrowserTextureSample
    : public IMediaPoolable
{
public:
 
    FWebBrowserTextureSample()
        : Buffer(nullptr)
        , BufferSize(0)
        , Dim(FIntPoint::ZeroValue)
        , ScaleRotation(FLinearColor(1.0f, 0.0f, 0.0f, 1.0f))
        , Offset(FLinearColor(0.0f, 0.0f, 0.0f, 0.0f))
    { }
 
    virtual ~FWebBrowserTextureSample()
    {
        if (BufferSize > 0)
        {
            FMemory::Free(Buffer);
        }
    }
 
public:
 
    void* GetMutableBuffer()
    {
        return Buffer;
    }
 
    bool Initialize(const FIntPoint& InDim)
    {
        if (InDim.GetMin() <= 0)
        { 
            return false;
        }
 
        Dim = InDim;
 
        return true;
    }
 
    void InitializeBuffer(void* InBuffer, bool Copy)
    {
        if (Copy)
        {
            SIZE_T RequiredBufferSize = Dim.X * Dim.Y * sizeof(int32);
            if (BufferSize < RequiredBufferSize)
            {
                if (BufferSize == 0)
                {
                    Buffer = FMemory::Malloc(RequiredBufferSize);
                }
                else
                {
                    Buffer = FMemory::Realloc(Buffer, RequiredBufferSize);
                }
 
                BufferSize = RequiredBufferSize;
            }
 
            FMemory::Memcpy(Buffer, InBuffer, RequiredBufferSize);
        }
        else
        {
            if (BufferSize > 0)
            {
                FMemory::Free(Buffer);
                BufferSize = 0;
            }
 
            Buffer = InBuffer;
        }
    }
 
    int32 InitializeBufferForCopy()
    {
        SIZE_T RequiredBufferSize = Dim.X * Dim.Y * sizeof(int32);
        if (BufferSize < RequiredBufferSize)
        {
            if (BufferSize == 0)
            {
                Buffer = FMemory::Malloc(RequiredBufferSize);
            }
            else
            {
                Buffer = FMemory::Realloc(Buffer, RequiredBufferSize);
            }
 
            BufferSize = RequiredBufferSize;
        }
        return BufferSize;
    }
 
    FRHITexture* InitializeTexture(FRHICommandListBase& RHICmdList)
    {
        check(IsInRenderingThread());
 
        if (Texture.IsValid() && (Texture->GetSizeXY() == Dim))
        {
            return Texture;
        }
 
        const FRHITextureCreateDesc Desc =
            FRHITextureCreateDesc::Create2D(TEXT("FWebBrowserTextureSample"))
            .SetExtent(Dim)
            .SetFormat(PF_B8G8R8A8)
            .SetFlags(ETextureCreateFlags::SRGB | ETextureCreateFlags::RenderTargetable | ETextureCreateFlags::ShaderResource)
            .SetInitialState(ERHIAccess::SRVMask);
 
        Texture = RHICmdList.CreateTexture(Desc);
 
        return Texture;
    }
 
    void SetScaleRotationOffset(FVector4& InScaleRotation, FVector4& InOffset)
    {
        ScaleRotation = FLinearColor(InScaleRotation.X, InScaleRotation.Y, InScaleRotation.Z, InScaleRotation.W);
        Offset = FLinearColor(InOffset.X, InOffset.Y, InOffset.Z, InOffset.W);
    }
 
public:
 
    //~ IMediaTextureSample interface
 
    virtual const void* GetBuffer() 
    {
        return Buffer;
    }
 
    virtual FIntPoint GetDim() const
    {
        return Dim;
    }
 
    virtual uint32 GetStride() const
    {
        return Dim.X * sizeof(int32);
    }
 
#if WITH_ENGINE
 
    virtual FRHITexture* GetTexture() const
    {
        return Texture.GetReference();
    }
 
#endif //WITH_ENGINE
 
    virtual FLinearColor GetScaleRotation() const
    {
        return ScaleRotation;
    }
 
    virtual FLinearColor GetOffset() const
    {
        return Offset;
    }
 
private:
 
    void* Buffer;
 
    SIZE_T BufferSize;
 
    FIntPoint Dim;
 
    FLinearColor ScaleRotation;
 
    FLinearColor Offset;
 
#if WITH_ENGINE
 
    TRefCountPtr<FRHITexture> Texture;
 
#endif //WITH_ENGINE
};
 
 
class FWebBrowserTextureSampleQueue
{
public:
 
    FWebBrowserTextureSampleQueue()
        : NumSamples(0)
        , PendingFlushes(0)
    { }
 
    virtual ~FWebBrowserTextureSampleQueue() { }
 
public:
 
    int32 Num() const
    {
        return NumSamples;
    }
 
public:
 
    //~ TMediaSampleSource interface (to be called only from consumer thread)
 
    virtual bool Dequeue(TSharedPtr<FWebBrowserTextureSample, ESPMode::ThreadSafe>& OutSample)
    {
        DoPendingFlushes();
 
        TSharedPtr<FWebBrowserTextureSample, ESPMode::ThreadSafe> Sample;
 
        if (!Samples.Peek(Sample))
        {
            return false; // empty queue
        }
 
        if (!Sample.IsValid())
        {
            return false; // pending flush
        }
 
        Samples.Pop();
 
        FPlatformAtomics::InterlockedDecrement(&NumSamples);
        check(NumSamples >= 0);
 
        OutSample = Sample;
 
        return true;
    }
 
    virtual bool Peek(TSharedPtr<FWebBrowserTextureSample, ESPMode::ThreadSafe>& OutSample)
    {
        DoPendingFlushes();
 
        TSharedPtr<FWebBrowserTextureSample, ESPMode::ThreadSafe> Sample;
 
        if (!Samples.Peek(Sample))
        {
            return false; // empty queue
        }
 
        if (!Sample.IsValid())
        {
            return false; // pending flush
        }
 
        OutSample = Sample;
 
        return true;
    }
 
    virtual bool Pop()
    {
        TSharedPtr<FWebBrowserTextureSample, ESPMode::ThreadSafe> Sample;
 
        if (!Samples.Peek(Sample))
        {
            return false; // empty queue
        }
 
        if (!Sample.IsValid())
        {
            return false; // pending flush
        }
 
        Samples.Pop();
 
        FPlatformAtomics::InterlockedDecrement(&NumSamples);
        check(NumSamples >= 0);
 
        return true;
    }
 
public:
 
    //~ TMediaSampleSink interface (to be called only from producer thread)
 
    virtual bool Enqueue(const TSharedPtr<FWebBrowserTextureSample, ESPMode::ThreadSafe>& Sample)
    {
        if (Sample.IsValid())
        {
            FPlatformAtomics::InterlockedIncrement(&NumSamples);
        }
 
        if (!Samples.Enqueue(Sample))
        {
            if (Sample.IsValid())
            {
                FPlatformAtomics::InterlockedDecrement(&NumSamples);
            }
 
            return false;
        }
 
        return true;
    }
 
    virtual void RequestFlush()
    {
        Samples.Enqueue(nullptr); // insert flush marker
        FPlatformAtomics::InterlockedIncrement(&PendingFlushes);
    }
 
protected:
 
    void DoPendingFlushes()
    {
        TSharedPtr<FWebBrowserTextureSample, ESPMode::ThreadSafe> Sample;
 
        while ((PendingFlushes > 0) && Samples.Dequeue(Sample))
        {
            if (Sample.IsValid())
            {
                FPlatformAtomics::InterlockedDecrement(&NumSamples);
                check(NumSamples >= 0);
            }
            else
            {
                FPlatformAtomics::InterlockedDecrement(&PendingFlushes);
            }
        }
    }
 
private:
 
    int32 NumSamples;
 
    int32 PendingFlushes;
 
    TQueue<TSharedPtr<FWebBrowserTextureSample, ESPMode::ThreadSafe>, EQueueMode::Mpsc> Samples;
};
 
 
class FWebBrowserTextureSamplePool : public TMediaObjectPool<FWebBrowserTextureSample> { };