protected sealed override void RenderOutput(ITargetTexture output)
{
Render(output);
DisposeHelper.DisposeElements(m_Buffers);
m_Buffers.Clear();
}
protected sealed override void RenderOutput(ITargetTexture output)
{
if (GlobalWorkSizes == null)
{
throw new ArgumentNullException("OpenCL global workgroup sizes not set.");
}
Renderer.RunClKernel(Shader, GlobalWorkSizes, LocalWorkSizes);
}
protected override void Render(ITexture2D texture, ITargetTexture target)
{
// Render all frames but only present half of them
// In real life scenario, you'd probably want to use Renderer.RenderQueue[i].Frame
// to do something useful with the current frame.
// (Note: Renderer.RenderQueue.First().Frame is the frame before the current, while
// Renderer.RenderQueue.Last().Frame is earliest frame in the queue.
// Renderer.RenderQueue will have no elements to start off with!)
Renderer.Render(target, texture, false);
// Note: To get actual odd/even frame number, you should calculate from
// Renderer.FrameRateHz and Renderer.FrameTimeStampMicrosec instead of relying on m_Counter
// Note: Setting PresentFrame to false will cause MPDN to disable FluidMotion
Renderer.PresentFrame = ((m_Counter % 2) == 0) || Renderer.RenderQueue.Count <= 1;
m_Counter++;
}
protected void LoadTextureConstants(IList <IBaseTexture> inputs, ITargetTexture output)
{
var index = 0;
foreach (var input in inputs)
{
var linearSampling = PerTextureLinearSampling
.Cast <bool?>()
.ElementAtOrDefault(index)
?? LinearSampling;
SetTextureConstant(index, input, linearSampling);
LoadSizeConstant(index.ToString(), input.GetSize());
index++;
}
/* Add Output Size */
LoadSizeConstant("Output", output.GetSize());
}
protected override void LoadArguments(IList <IBaseTexture> inputs, ITargetTexture output)
{
var inputTexture = (ITexture2D)inputs[0];
GlobalWorkSizes = GlobalWorkSizesHelper.Get(inputTexture.Width, inputTexture.Height, LocalWorkSizes);
// Use the 'temp' texture from first pass as input
Shader.SetTempTextureArg(0, inputTexture); // srcImg
Shader.SetOutputTextureArg(1, output); // dstImg
if (m_ReloadWeights)
{
Shader.SetBufferArg(2, m_Buffer); // weights
Shader.SetArg(3, m_NeuronCount); // nnst
}
Shader.SetArg(4, m_Horizontal ? inputTexture.Height : inputTexture.Width); // SrcWidth
Shader.SetArg(5, m_Horizontal ? inputTexture.Width : inputTexture.Height); // SrcHeight
Shader.SetArg(6, m_Horizontal ? 1 : 0); // SwapXy
}
public override void LoadArguments(IList <IBaseTexture> inputs, ITargetTexture output)
{
IList <ITexture2D> inputs2D;
try
{
inputs2D = inputs.Cast <ITexture2D>().ToList();
}
catch (InvalidCastException e)
{
throw new ArgumentException("OpenCL only supports 2D textures.", e);
}
var index = 0;
foreach (var input in inputs2D)
{
Shader.SetInputTextureArg(index++, input);
}
Shader.SetOutputTextureArg(index++, output);
LoadAdditionalInputs(index);
}
public override IFilter CreateFilter(IFilter sourceFilter)
{
Cleanup();
if (sourceFilter.OutputSize == Renderer.TargetSize)
{
return(sourceFilter);
}
try
{
m_DxvaHd = Renderer.CreateDxvaHd((Size)sourceFilter.OutputSize, TextureFormat.Unorm8,
Renderer.TargetSize, TextureFormat.Unorm8, Quality);
}
catch (DxvaHdException)
{
// DXVA HD not available; fallback
Renderer.FallbackOccurred = true;
return(sourceFilter);
}
var input = YuvMode ? sourceFilter.ConvertToYuv() : sourceFilter;
if (sourceFilter.OutputFormat != TextureFormat.Unorm8)
{
// Convert input to Unorm8 (and unforunately murdering quality at the same time)
var copy = CompileShader("Copy.hlsl").Configure(linearSampling: false);
m_TextureUnorm8 = Renderer.CreateRenderTarget((Size)input.OutputSize, TextureFormat.Unorm8);
input = new CopyShaderFilter(m_TextureUnorm8, copy, input);
}
var result = new DxvaHdResizeFilter(m_DxvaHd, input);
result.SetSize(Renderer.TargetSize);
return(YuvMode ? result.ConvertToRgb() : result);
}
public override void LoadArguments(IList <IBaseTexture> inputs, ITargetTexture output)
{
LoadTextureConstants(inputs, output);
LoadShaderConstants();
LoadCustomConstants();
}
public void Render(IEnumerable <IBaseTexture> inputs, ITargetTexture output)
{
LoadArguments(inputs.ToList(), output);
RenderOutput(output);
}
protected override void LoadArguments(IList <IBaseTexture> inputs, ITargetTexture output)
{
base.LoadArguments(inputs, output);
// Load Legacy Constants
Shader.SetConstant(0, new Vector4(output.Width, output.Height, m_Counter++ & 0x7fffff, Renderer.FrameTimeStampMicrosec / 1000000.0f), false);
Shader.SetConstant(1, new Vector4(1.0f / output.Width, 1.0f / output.Height, 0, 0), false);
}
public static void PutTexture(ITargetTexture texture)
{
s_SavedTextures.Add(texture);
}
private static void Scale(ITargetTexture output, ITexture2D input)
{
Renderer.Scale(output, input, Renderer.LumaUpscaler, Renderer.LumaDownscaler);
}
public static void PutTexture(ITargetTexture texture)
{
s_SavedTextures.Add(texture);
}
protected override void Render(ITexture2D input, ITargetTexture output)
{
Renderer.ConvertToYuv(output, input, Colorimetric, OutputLimitedRange);
}
protected override void Render(ITexture2D input, ITargetTexture target)
{
Renderer.Scale(target, input, m_Channels, m_Offset, m_Upscaler, m_Downscaler, m_Convolver);
}
protected virtual void SetOutputTexture(ITargetTexture targetTexture)
{
Target = targetTexture;
}
protected override void SetOutputTexture(ITargetTexture targetTexture)
{
Target = targetTexture;
}
protected sealed override void Render(ITargetTexture output)
{
Renderer.Render(output, Shader);
}
public abstract void LoadArguments(IList <IBaseTexture> inputs, ITargetTexture output);
protected sealed override void Render(ITargetTexture output)
{
Renderer.Compute(output, Shader, ThreadGroupX, ThreadGroupY, ThreadGroupZ);
}
public CopyShaderFilter(ITargetTexture outputTarget, ShaderFilterSettings <IShader> settings,
params IFilter <IBaseTexture>[] inputFilters)
: base(settings, inputFilters)
{
m_OutputTarget = outputTarget;
}
protected abstract void RenderOutput(ITargetTexture output);
private static void Scale(ITargetTexture output, ITexture2D input)
{
Renderer.Scale(output, input, Renderer.LumaUpscaler, Renderer.LumaDownscaler);
}
protected abstract void Render(TTexture input, ITargetTexture output);
