MediaShaders.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GlobalShader.h"
#include "ShaderParameterStruct.h"
 
class FPointerTableBase;
class FRDGBuilder;
class FRDGTexture;
 
namespace UE {
    namespace Color {
        enum class EEncoding : uint8;
    }
}
 
#define NUM_MEDIA_SHADERS_CONVERSION_OP 5
 
 
namespace MediaShaders
{
    enum class EToneMapMethod : uint8
    {
        None = 0,
        Hable = 1,
        SimpleReinhard = 2,
 
        MAX
    };
 
    RENDERCORE_API extern const FMatrix YuvToRgbRec601Unscaled;
 
    RENDERCORE_API extern const FMatrix YuvToRgbRec601Scaled;
 
    RENDERCORE_API extern const FMatrix YuvToRgbRec709Unscaled;
 
    RENDERCORE_API extern const FMatrix YuvToRgbRec709Scaled;
 
    RENDERCORE_API extern const FMatrix YuvToRgbRec2020Unscaled;
 
    RENDERCORE_API extern const FMatrix YuvToRgbRec2020Scaled;
 
    RENDERCORE_API extern const FMatrix YuvToSrgbPs4;
 
    RENDERCORE_API extern const FMatrix RgbToYuvRec709Scaled;
 
    RENDERCORE_API extern const FMatrix RgbToYuvRec2020Scaled;
 
    RENDERCORE_API extern const FVector YUVOffset8bits;
 
    RENDERCORE_API extern const FVector YUVOffsetNoScale8bits;
 
    RENDERCORE_API extern const FVector YUVOffset10bits;
 
    RENDERCORE_API extern const FVector YUVOffsetNoScale10bits;
 
    RENDERCORE_API extern const FVector YUVOffset16bits;
 
    RENDERCORE_API extern const FVector YUVOffsetNoScale16bits;
 
    RENDERCORE_API extern const FVector YUVOffsetFloat;
 
    RENDERCORE_API extern const FVector YUVOffsetNoScaleFloat;
 
    RENDERCORE_API FMatrix CombineColorTransformAndOffset(const FMatrix& InMatrix, const FVector& InYUVOffset);
}
 
 
struct FMediaElementVertex
{
    FVector4f Position;
    FVector2f TextureCoordinate;
 
    FMediaElementVertex() { }
 
    FMediaElementVertex(const FVector4f& InPosition, const FVector2f& InTextureCoordinate)
        : Position(InPosition)
        , TextureCoordinate(InTextureCoordinate)
    { }
};
 
inline FBufferRHIRef CreateTempMediaVertexBuffer(FRHICommandListBase& RHICmdList, float ULeft = 0.0f, float URight = 1.0f, float VTop = 0.0f, float VBottom = 1.0f)
{
    const FRHIBufferCreateDesc CreateDesc =
        FRHIBufferCreateDesc::CreateVertex<FMediaElementVertex>(TEXT("TempMediaVertexBuffer"), 4)
        .AddUsage(EBufferUsageFlags::Volatile)
        .DetermineInitialState()
        .SetInitActionInitializer();
 
    TRHIBufferInitializer<FMediaElementVertex> Vertices = RHICmdList.CreateBufferInitializer(CreateDesc);
 
    Vertices[0].Position.Set(-1.0f, 1.0f, 1.0f, 1.0f); // Top Left
    Vertices[1].Position.Set(1.0f, 1.0f, 1.0f, 1.0f); // Top Right
    Vertices[2].Position.Set(-1.0f, -1.0f, 1.0f, 1.0f); // Bottom Left
    Vertices[3].Position.Set(1.0f, -1.0f, 1.0f, 1.0f); // Bottom Right
 
    Vertices[0].TextureCoordinate.Set(ULeft, VTop);
    Vertices[1].TextureCoordinate.Set(URight, VTop);
    Vertices[2].TextureCoordinate.Set(ULeft, VBottom);
    Vertices[3].TextureCoordinate.Set(URight, VBottom);
 
    return Vertices.Finalize();
}
 
UE_DEPRECATED(5.6, "CreateTempMediaVertexBuffer requires a Command List argument")
inline FBufferRHIRef CreateTempMediaVertexBuffer(float ULeft = 0.0f, float URight = 1.0f, float VTop = 0.0f, float VBottom = 1.0f)
{
    return CreateTempMediaVertexBuffer(FRHICommandListImmediate::Get(), ULeft, URight, VTop, VBottom);
}
 
class FMediaVertexDeclaration : public FRenderResource
{
public:
    RENDERCORE_API FMediaVertexDeclaration();
    RENDERCORE_API virtual ~FMediaVertexDeclaration();
 
    RENDERCORE_API virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    RENDERCORE_API virtual void ReleaseRHI() override;
 
    FVertexDeclarationRHIRef VertexDeclarationRHI;
};
 
RENDERCORE_API extern TGlobalResource<FMediaVertexDeclaration> GMediaVertexDeclaration;
 
 
class FMediaShadersVS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FMediaShadersVS, Global, RENDERCORE_API);
 
public:
    FMediaShadersVS() { }
 
    FMediaShadersVS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
};
 
 
class FAYUVConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FAYUVConvertPS, Global, RENDERCORE_API);
 
public:
    FAYUVConvertPS() { }
 
    FAYUVConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> AYUVTexture, const FMatrix& ColorTransform, const FVector& YUVOffset, bool SrgbToLinear);
};
 
 
class FBMPConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FBMPConvertPS, Global, RENDERCORE_API);
 
public:
    FBMPConvertPS() { }
 
    FBMPConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> BMPTexture, const FIntPoint& OutputDimensions, bool SrgbToLinear);
};
 
 
class FNV12ConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FNV12ConvertPS, Global, RENDERCORE_API);
 
public:
    FNV12ConvertPS() { }
 
    FNV12ConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FIntPoint & TexDim, FShaderResourceViewRHIRef SRV_Y, FShaderResourceViewRHIRef SRV_UV, const FIntPoint& OutputDimensions, const FMatrix44f& ColorTransform, UE::Color::EEncoding Encoding, const FMatrix44f& CSTransform, bool bSwapChroma, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None);
};
 
 
class FNV12ConvertAsBytesPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FNV12ConvertPS, Global, RENDERCORE_API);
 
public:
 
    FNV12ConvertAsBytesPS() { }
 
    FNV12ConvertAsBytesPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> NV12Texture, const FIntPoint& OutputDimensions, const FMatrix44f& ColorTransform, UE::Color::EEncoding Encoding, const FMatrix44f& CSTransform, bool bSwapChroma, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None);
};
 
 
class FNV21ConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FNV21ConvertPS, Global, RENDERCORE_API);
 
public:
    FNV21ConvertPS() { }
 
    FNV21ConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> NV21Texture, const FIntPoint& OutputDimensions, const FMatrix& ColorTransform, const FVector& YUVOffset, bool SrgbToLinear);
};
 
class FP010ConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FP010ConvertPS, Global, RENDERCORE_API);
 
public:
 
    FP010ConvertPS() { }
 
    FP010ConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FIntPoint& TexDim, FShaderResourceViewRHIRef SRV_Y, FShaderResourceViewRHIRef SRV_UV, const FIntPoint& OutputDimensions, const FMatrix44f& ColorTransform, const FMatrix44f& CSTransform, UE::Color::EEncoding Encoding, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None);
};
 
class FP010ConvertAsUINT16sPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FP010ConvertAsUINT16sPS, Global, RENDERCORE_API);
 
public:
 
    FP010ConvertAsUINT16sPS() { }
 
    FP010ConvertAsUINT16sPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FIntPoint& TexDim, TRefCountPtr<FRHITexture> NV12Texture, const FIntPoint& OutputDimensions, const FMatrix44f& ColorTransform, const FMatrix44f& CSTransform, UE::Color::EEncoding Encoding, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None);
};
 
class FP010_2101010ConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FP010_2101010ConvertPS, Global, RENDERCORE_API);
 
public:
 
    FP010_2101010ConvertPS() { }
 
    FP010_2101010ConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, const FIntPoint& TexDim, FShaderResourceViewRHIRef SRV_Y, FShaderResourceViewRHIRef SRV_U, FShaderResourceViewRHIRef SRV_V, const FIntPoint& OutputDimensions, const FMatrix44f& ColorTransform, const FMatrix44f& CSTransform, UE::Color::EEncoding Encoding, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None);
};
 
class FRGBConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FRGBConvertPS, Global, RENDERCORE_API);
 
public:
    FRGBConvertPS() { }
 
    FRGBConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> RGBTexture, const FIntPoint& OutputDimensions, UE::Color::EEncoding Encoding, const FMatrix44f& CSTransform, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None);
};
 
class FYCoCgConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FYCoCgConvertPS, Global, RENDERCORE_API);
 
public:
    FYCoCgConvertPS() { }
 
    FYCoCgConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> YCoCgTexture, const FIntPoint& OutputDimensions, UE::Color::EEncoding Encoding, const FMatrix44f& CSTransform, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None);
};
 
 
class FYCbCrConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FYCbCrConvertPS, Global, RENDERCORE_API);
 
public:
    FYCbCrConvertPS() { }
 
    FYCbCrConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> LumaTexture, TRefCountPtr<FRHITexture> CbCrTexture, const FMatrix& ColorTransform, const FVector& YUVOffset, bool SrgbToLinear);
};
 
class FYCbCrConvertPS_4x4Matrix : public FYCbCrConvertPS
{
    DECLARE_EXPORTED_SHADER_TYPE(FYCbCrConvertPS_4x4Matrix, Global, RENDERCORE_API);
    
public:
    FYCbCrConvertPS_4x4Matrix() { }
    
    FYCbCrConvertPS_4x4Matrix(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
    : FYCbCrConvertPS(Initializer)
    { }
};
 
 
class FUYVYConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FUYVYConvertPS, Global, RENDERCORE_API);
 
public:
    FUYVYConvertPS() { }
 
    FUYVYConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> UYVYTexture, const FMatrix& ColorTransform, const FVector& YUVOffset, bool SrgbToLinear);
};
 
 
class FYUVConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FYUVConvertPS, Global, RENDERCORE_API);
 
public:
    FYUVConvertPS() { }
 
    FYUVConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> YTexture, TRefCountPtr<FRHITexture> UTexture, TRefCountPtr<FRHITexture> VTexture, const FIntPoint& OutputDimensions, const FMatrix& ColorTransform, const FVector& YUVOffset, bool SrgbToLinear);
};
 
 
class FYUVv216ConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FYUVv216ConvertPS, Global, RENDERCORE_API);
 
public:
    FYUVv216ConvertPS() { }
 
    FYUVv216ConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> YUVTexture, const FIntPoint& OutputDimensions, const FMatrix44f& ColorTransform, UE::Color::EEncoding Encoding, const FMatrix44f& CSTransform, bool bIsCbY0CrY1, bool bIsARGBFmt, bool bSwapChroma, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None, bool bUseBilinearSamplingForChroma = false);
};
 
 
class FYUVv210ConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FYUVv210ConvertPS, Global, RENDERCORE_API);
 
public:
    FYUVv210ConvertPS() { }
 
    FYUVv210ConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> YUVTexture, const FIntPoint& OutputDimensions, const FMatrix44f& ColorTransform, UE::Color::EEncoding Encoding, const FMatrix44f& CSTransform, bool bIsCbY0CrY1, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None);
};
 
 
class FYUVY416ConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FYUVY416ConvertPS, Global, RENDERCORE_API);
 
public:
    FYUVY416ConvertPS() { }
 
    FYUVY416ConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, FShaderResourceViewRHIRef SRV_Y, const FMatrix44f& ColorTransform, UE::Color::EEncoding Encoding, const FMatrix44f& CSTransform, bool bIsARGBFmt, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None);
};
 
class FYUY2ConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FYUY2ConvertPS, Global, RENDERCORE_API);
 
public:
    FYUY2ConvertPS() { }
 
    FYUY2ConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> YUY2Texture, const FIntPoint& OutputDimensions, const FMatrix& ColorTransform, const FVector& YUVOffset, bool SrgbToLinear, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None);
};
 
class FARGB16BigConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FARGB16BigConvertPS, Global, RENDERCORE_API);
 
public:
    FARGB16BigConvertPS() { }
 
    FARGB16BigConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, FShaderResourceViewRHIRef SRV, const FIntPoint& OutputDimensions, UE::Color::EEncoding Encoding, const FMatrix44f& CSTransform, MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None);
};
 
 
class FYVYUConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FYVYUConvertPS, Global, RENDERCORE_API);
 
public:
    FYVYUConvertPS() { }
 
    FYVYUConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> YVYUTexture, const FMatrix& ColorTransform, const FVector& YUVOffset, bool SrgbToLinear);
};
 
 
class FRGB8toY8ConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FRGB8toY8ConvertPS, Global, RENDERCORE_API);
 
public:
    FRGB8toY8ConvertPS() { }
 
    FRGB8toY8ConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> RGBATexture, const FVector4f& ColorTransform, bool LinearToSrgb);
};
 
 
class FReadTextureExternalPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FReadTextureExternalPS, Global, RENDERCORE_API);
 
public:
    FReadTextureExternalPS() { }
 
    FReadTextureExternalPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    {
        InTexture.Bind(Initializer.ParameterMap, TEXT("InExternalTexture"), SPF_Mandatory);
    }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, FTextureRHIRef TextureExt, FSamplerStateRHIRef SamplerState, const FLinearColor & ScaleRotation, const FLinearColor & Offset);
 
    LAYOUT_FIELD(FShaderResourceParameter, InTexture);
};
 
 
BEGIN_SHADER_PARAMETER_STRUCT(FRGBToYUVConversion, RENDERCORE_API)
    SHADER_PARAMETER_RDG_TEXTURE(Texture2D, InputTexture) 
    SHADER_PARAMETER_SAMPLER(SamplerState, InputSampler)
    SHADER_PARAMETER(FMatrix44f, ColorTransform)
    SHADER_PARAMETER(uint32, DoLinearToSrgb)
    SHADER_PARAMETER(float, OnePixelDeltaX)
END_SHADER_PARAMETER_STRUCT()
 
 
class FRGB8toUYVY8ConvertPS : public FGlobalShader
{
public:
    DECLARE_EXPORTED_GLOBAL_SHADER(FRGB8toUYVY8ConvertPS, RENDERCORE_API);
 
    SHADER_USE_PARAMETER_STRUCT(FRGB8toUYVY8ConvertPS, FGlobalShader);
 
    BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )
        SHADER_PARAMETER_STRUCT_INCLUDE(FRGBToYUVConversion, RGBToYUVConversion)
        RENDER_TARGET_BINDING_SLOTS()
    END_SHADER_PARAMETER_STRUCT()
 
public:
    RENDERCORE_API FRGB8toUYVY8ConvertPS::FParameters* AllocateAndSetParameters(FRDGBuilder& GraphBuilder, FRDGTextureRef RGBATexture, const FMatrix& ColorTransform, const FVector& YUVOffset, bool bDoLinearToSrgb, FRDGTextureRef OutputTexture);
};
 
 
class FRGB10toYUVv210ConvertPS : public FGlobalShader
{
public:
    DECLARE_EXPORTED_GLOBAL_SHADER(FRGB10toYUVv210ConvertPS, RENDERCORE_API);
 
    SHADER_USE_PARAMETER_STRUCT(FRGB10toYUVv210ConvertPS, FGlobalShader);
 
    BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )
        SHADER_PARAMETER_STRUCT_INCLUDE(FRGBToYUVConversion, RGBToYUVConversion)
        SHADER_PARAMETER(float, PaddingScale)
        RENDER_TARGET_BINDING_SLOTS()
    END_SHADER_PARAMETER_STRUCT()
 
public:
    RENDERCORE_API FRGB10toYUVv210ConvertPS::FParameters* AllocateAndSetParameters(FRDGBuilder& GraphBuilder, FRDGTextureRef RGBATexture, const FMatrix& ColorTransform, const FVector& YUVOffset, bool bDoLinearToSrgb, FRDGTextureRef OutputTexture);
};
 
class FModifyAlphaSwizzleRgbaPS : public FGlobalShader
{
public:
    DECLARE_EXPORTED_GLOBAL_SHADER(FModifyAlphaSwizzleRgbaPS, RENDERCORE_API);
 
    SHADER_USE_PARAMETER_STRUCT(FModifyAlphaSwizzleRgbaPS, FGlobalShader);
 
    class FConversionOp : SHADER_PERMUTATION_INT("CONVERSION_OP", NUM_MEDIA_SHADERS_CONVERSION_OP);
    using FPermutationDomain = TShaderPermutationDomain<FConversionOp>;
 
    BEGIN_SHADER_PARAMETER_STRUCT(FParameters, )
        SHADER_PARAMETER_RDG_TEXTURE(Texture2D, InputTexture) 
        SHADER_PARAMETER_SAMPLER(SamplerState, InputSampler)
        RENDER_TARGET_BINDING_SLOTS()
    END_SHADER_PARAMETER_STRUCT()
 
public:
    RENDERCORE_API FModifyAlphaSwizzleRgbaPS::FParameters* AllocateAndSetParameters(FRDGBuilder& GraphBuilder, FRDGTextureRef RGBATexture, FRDGTextureRef OutputTexture);
};
 
class FVYUConvertPS
    : public FGlobalShader
{
    DECLARE_EXPORTED_SHADER_TYPE(FVYUConvertPS, Global, RENDERCORE_API);
 
public:
    FVYUConvertPS() { }
 
    FVYUConvertPS(const ShaderMetaType::CompiledShaderInitializerType& Initializer)
        : FGlobalShader(Initializer)
    { }
 
    RENDERCORE_API void SetParameters(FRHIBatchedShaderParameters& BatchedParameters, TRefCountPtr<FRHITexture> VYUTexture, const FIntPoint& OutputDimensions, const FMatrix44f& ColorTransform, UE::Color::EEncoding Encoding, const FMatrix44f& CSTransform, 
        MediaShaders::EToneMapMethod ToneMapMethod = MediaShaders::EToneMapMethod::None,
        const FLinearColor& UVRotation = FLinearColor(1.0f, 0.0f, 0.0f, 1.0f),
        const FLinearColor& UVRotOffset = FLinearColor(0.0f, 0.0f, 0.0f, 0.0f));
};