public TransformedResizeableFilter(Func <IFilter, IFilter> transformation, IResizeableFilter inputFilter)
: base(new IFilter[0])
{
m_InputFilter = inputFilter;
PassthroughFilter = transformation(m_InputFilter);
CheckSize();
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
var nedi1Shader = CompileShader("NEDI-I.hlsl");
var nedi2Shader = CompileShader("NEDI-II.hlsl");
var nediHInterleaveShader = CompileShader("NEDI-HInterleave.hlsl");
var nediVInterleaveShader = CompileShader("NEDI-VInterleave.hlsl");
Func <Size, Size> transformWidth;
Func <Size, Size> transformHeight;
if (Centered)
{
transformWidth = s => new Size(2 * s.Width - 1, s.Height);
transformHeight = s => new Size(s.Width, 2 * s.Height - 1);
}
else
{
transformWidth = s => new Size(2 * s.Width, s.Height);
transformHeight = s => new Size(s.Width, 2 * s.Height);
}
if (!UseNedi(sourceFilter))
{
return(sourceFilter);
}
var nedi1 = new ShaderFilter(nedi1Shader, LumaConstants, sourceFilter);
var nediH = new ShaderFilter(nediHInterleaveShader, transformWidth, sourceFilter, nedi1);
var nedi2 = new ShaderFilter(nedi2Shader, LumaConstants, nediH);
var nediV = new ShaderFilter(nediVInterleaveShader, transformHeight, nediH, nedi2);
return(nediV);
}
public TransformedResizeableFilter(Func <IFilter, IFilter> transformation, IResizeableFilter inputFilter)
: base(new IBaseFilter[0])
{
m_InputFilter = inputFilter;
CompilationResult = transformation(m_InputFilter);
CheckSize();
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
Create3DTexture();
var shader = CompileShader("Lut3D.hlsl");
return(new ShaderFilter(shader, true, sourceFilter, new Texture3DSourceFilter(m_Texture3D)));
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
CreateTextures();
var shader = CompileShader("CustomTextures.hlsl");
return(new ShaderFilter(shader, sourceFilter, new TextureSourceFilter(m_Texture1),
new TextureSourceFilter(m_Texture2)));
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
if (UseImageProcessor(sourceFilter))
{
return(ShaderFileNames.Aggregate((IFilter)sourceFilter,
(current, filename) => new ShaderFilter(CompileShader(filename), current)));
}
return(sourceFilter);
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
if (SelectedOption != null)
{
return(SelectedOption.CreateFilter(sourceFilter));
}
else
{
return(sourceFilter);
}
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
if (Script != null)
{
return(Script.GetChain().CreateFilter(sourceFilter));
}
else
{
return(sourceFilter);
}
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
// get MPDN to scale image to target size first
sourceFilter += new Resizer {
ResizerOption = ResizerOption.TargetSize100Percent
};
// apply our blue tint
var blueTint = CompileShader("BlueTintSm3.hlsl");
return(new ShaderFilter(blueTint, false, new[] { 0.25f, 0.5f, 0.75f }, sourceFilter));
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
if (!Activate || !File.Exists(FileName))
{
return(sourceFilter);
}
Create3DTexture();
var shader = CompileShader("Lut3D.hlsl");
return(new ShaderFilter(shader, true, sourceFilter, new Texture3DSourceFilter(m_Texture3D)));
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
var inputSize = sourceFilter.OutputSize;
var targetSize = TargetSize();
// Skip if downscaling
if (targetSize.Width <= inputSize.Width && targetSize.Height <= inputSize.Height)
{
return(sourceFilter);
}
else
{
return(CreateFilter(sourceFilter, sourceFilter));
}
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
var chromaShader = CompileShader("Chroma.hlsl");
var yInput = new YSourceFilter();
var uInput = new USourceFilter();
var vInput = new VSourceFilter();
float[] offset = { 0.0f, 0.5f };
var chroma = new ShaderFilter(chromaShader, new[] { B, C, offset[0], offset[1] }, yInput, uInput, vInput);
var rgb = chroma.ConvertToRgb();
return(rgb);
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
if (!Renderer.IsDx11Avail)
{
return(new NullFilter()); // display blank screen on purpose
}
// get MPDN to scale image to target size first
sourceFilter += new Resizer {
ResizerOption = ResizerOption.TargetSize100Percent
};
// apply our blue tint
var blueTint = CompileShader11("BlueTintSm5.hlsl", "ps_5_0");
return(new Shader11Filter(blueTint, false, new[] { 0.25f, 0.5f, 0.75f }, sourceFilter));
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
if (!Renderer.IsDx11Avail)
{
return(new NullFilter()); // display blank screen on purpose
}
// get MPDN to scale image to target size first
sourceFilter += new Resizer {
ResizerOption = ResizerOption.TargetSize100Percent
};
// apply our blue tint
var blueTint = CompileShader11("BlueTintDirectCompute.hlsl", "cs_5_0");
var width = sourceFilter.OutputSize.Width;
var height = sourceFilter.OutputSize.Height;
return(new DirectComputeFilter(blueTint, width / 32 + 1, height / 32 + 1, 1, new[] { 0.25f, 0.5f, 0.75f },
sourceFilter));
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
return(new ResizeFilter(sourceFilter, GetOutputSize(),
Upscaler ?? Renderer.LumaUpscaler, Downscaler ?? Renderer.LumaDownscaler));
}
public abstract IFilter CreateFilter(IResizeableFilter sourceFilter);
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
return(m_Compiler(sourceFilter));
}
public TransformedResizeableFilter(Func <ITextureFilter, ITextureFilter> transformation, IResizeableFilter inputFilter)
: base(inputFilter)
{
m_InputFilter = inputFilter;
m_Transformation = transformation;
}
public static IResizeableFilter Transform(this IResizeableFilter filter, Func <ITextureFilter, ITextureFilter> transformation)
{
return(new TransformedResizeableFilter(transformation, filter));
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
return(ScriptList.Select(pair => pair.GetChain()).Aggregate(sourceFilter, (a, b) => a + b));
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
IFilter yuv;
var chromaSize = Renderer.ChromaSize;
var targetSize = sourceFilter.OutputSize;
var Diff = CompileShader("SuperChromaRes/Diff.hlsl");
var CopyLuma = CompileShader("SuperChromaRes/CopyLuma.hlsl");
var CopyChroma = CompileShader("SuperChromaRes/CopyChroma.hlsl");
var SuperRes = CompileShader("SuperChromaRes/SuperRes.hlsl");
var GammaToLab = CompileShader("GammaToLab.hlsl");
var LabToGamma = CompileShader("LabToGamma.hlsl");
var LinearToGamma = CompileShader("LinearToGamma.hlsl");
var GammaToLinear = CompileShader("GammaToLinear.hlsl");
var LabToLinear = CompileShader("LabToLinear.hlsl");
var LinearToLab = CompileShader("LinearToLab.hlsl");
// Skip if downscaling
if (targetSize.Width <= chromaSize.Width && targetSize.Height <= chromaSize.Height)
{
return(sourceFilter);
}
// Original values
var yInput = new YSourceFilter();
var uInput = new USourceFilter();
var vInput = new VSourceFilter();
float[] YuvConsts = new float[2];
switch (Renderer.Colorimetric)
{
case YuvColorimetric.Auto: return(sourceFilter);
case YuvColorimetric.FullRangePc601: YuvConsts = new[] { 0.114f, 0.299f, 0.0f }; break;
case YuvColorimetric.FullRangePc709: YuvConsts = new[] { 0.0722f, 0.2126f, 0.0f }; break;
case YuvColorimetric.FullRangePc2020: YuvConsts = new[] { 0.0593f, 0.2627f, 0.0f }; break;
case YuvColorimetric.ItuBt601: YuvConsts = new[] { 0.114f, 0.299f, 1.0f }; break;
case YuvColorimetric.ItuBt709: YuvConsts = new[] { 0.0722f, 0.2126f, 1.0f }; break;
case YuvColorimetric.ItuBt2020: YuvConsts = new[] { 0.0593f, 0.2627f, 1.0f }; break;
}
var Consts = new[] { Strength, Sharpness, AntiAliasing, AntiRinging,
Softness, YuvConsts[0], YuvConsts[1] };
yuv = sourceFilter.ConvertToYuv();
for (int i = 1; i <= Passes; i++)
{
IFilter res, diff, linear;
bool useBilinear = (upscaler is Scaler.Bilinear) || (FirstPassOnly && !(i == 1));
// Compare to chroma
linear = new ShaderFilter(GammaToLinear, yuv.ConvertToRgb());
res = new ResizeFilter(linear, chromaSize, upscaler, downscaler);
res = new ShaderFilter(LinearToGamma, res).ConvertToYuv();
diff = new ShaderFilter(Diff, YuvConsts, res, uInput, vInput);
if (!useBilinear)
{
diff = new ResizeFilter(diff, targetSize, upscaler, downscaler); // Scale to output size
}
// Update result
yuv = new ShaderFilter(SuperRes, useBilinear, Consts, yuv, diff, uInput, vInput);
}
return(yuv.ConvertToRgb());
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
var upscaler = new Scaler.Custom(new GaussianBlur(0.75), ScalerTaps.Four, false);
var downscaler = new Scaler.HwBilinear(); // Good enough (?)
int bits = 8;
switch (Renderer.InputFormat)
{
case FrameBufferInputFormat.P010: bits = 10; break;
case FrameBufferInputFormat.Y410: bits = 10; break;
case FrameBufferInputFormat.P016: bits = 16; break;
case FrameBufferInputFormat.Y416: bits = 16; break;
case FrameBufferInputFormat.Rgb24: return(sourceFilter);
case FrameBufferInputFormat.Rgb32: return(sourceFilter);
}
if (bits > maxbitdepth)
{
return(sourceFilter);
}
var inputsize = sourceFilter.OutputSize;
var size = inputsize;
var current = sourceFilter.ConvertToYuv();
var factor = 2.0;
var downscaled = new Stack <IFilter>();
downscaled.Push(current);
// Generate downscaled images
for (int i = 0; i < 8; i++)
{
size = new Size((int)Math.Floor(size.Width / factor), (int)Math.Floor(size.Height / factor));
if (size.Width == 0 || size.Height == 0)
{
break;
}
current = new ResizeFilter(current, size, upscaler, downscaler);
downscaled.Push(current);
}
var deband = downscaled.Pop();
while (downscaled.Count > 0)
{
deband = new ShaderFilter(CompileShader("Deband.hlsl"), true,
new[]
{
(1 << bits) - 1,
advancedMode ? threshold : DEFAULT_THRESHOLD,
advancedMode ? margin : DEFAULT_MARGIN
},
downscaled.Pop(), deband);
}
return(deband.ConvertToRgb());
}
public TransformedResizeableFilter(Func<IFilter, IFilter> transformation, IResizeableFilter inputFilter)
: base(new IBaseFilter[0])
{
m_InputFilter = inputFilter;
CompilationResult = transformation(m_InputFilter);
CheckSize();
}
public override IFilter CreateFilter(IResizeableFilter sourceFilter)
{
// Scale chroma first (this bypasses MPDN's chroma scaler)
sourceFilter += new BicubicChroma {
Preset = Presets.MitchellNetravali
};
if (Renderer.InterlaceFlags.HasFlag(InterlaceFlags.IsInterlaced))
{
// Deinterlace using blend
sourceFilter += new ImageProcessor {
ShaderFileNames = Deinterlace
};
}
// Pre resize shaders, followed by NEDI image doubler
sourceFilter += new ImageProcessor {
ShaderFileNames = PreProcess
};
// Use NEDI once only.
// Note: To use NEDI as many times as required to get the image past target size,
// Change the following *if* to *while*
if (IsUpscalingFrom(sourceFilter)) // See CombinedChain for other comparer methods
{
sourceFilter += new Nedi {
AlwaysDoubleImage = true
};
}
if (IsDownscalingFrom(sourceFilter))
{
// Use linear light for downscaling
sourceFilter += new ImageProcessor {
ShaderFileNames = ToLinear
}
+new Resizer {
ResizerOption = ResizerOption.TargetSize100Percent
}
+new ImageProcessor {
ShaderFileNames = ToGamma
};
}
else
{
// Otherwise, scale with gamma light
sourceFilter += new Resizer {
ResizerOption = ResizerOption.TargetSize100Percent
};
}
if (Renderer.VideoSize.Width < 1920)
{
// Sharpen only if video isn't full HD
sourceFilter += new ImageProcessor {
ShaderFileNames = PostProcess
};
}
return(sourceFilter);
}
public TransformedResizeableFilter(Func<IFilter, IFilter> transformation, IResizeableFilter inputFilter)
{
m_InputFilter = inputFilter;
m_Transformation = transformation;
}
