noobs 0.0.115 → 0.0.131

package/dist/data/obs-plugins/obs-filters/color_grade_filter.effect

@@ -0,0 +1,177 @@
+uniform float4x4 ViewProj;
+uniform texture2d image;
+
+uniform texture2d clut_1d;
+uniform texture3d clut_3d;
+uniform float clut_amount;
+uniform float3 clut_scale;
+uniform float3 clut_offset;
+uniform float3 domain_min;
+uniform float3 domain_max;
+
+sampler_state textureSampler {
+	Filter    = Linear;
+	AddressU  = Clamp;
+	AddressV  = Clamp;
+	AddressW  = Clamp;
+};
+
+struct VertDataIn {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+};
+
+struct VertDataOut {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+};
+
+VertDataOut VSDefault(VertDataIn v_in)
+{
+	VertDataOut vert_out;
+	vert_out.uv = v_in.uv;
+	vert_out.pos = mul(float4(v_in.pos.xyz, 1.0), ViewProj);
+	return vert_out;
+}
+
+float srgb_linear_to_nonlinear_channel(float u)
+{
+	return (u <= 0.0031308) ? (12.92 * u) : ((1.055 * pow(u, 1.0 / 2.4)) - 0.055);
+}
+
+float3 srgb_linear_to_nonlinear(float3 v)
+{
+	return float3(srgb_linear_to_nonlinear_channel(v.r), srgb_linear_to_nonlinear_channel(v.g), srgb_linear_to_nonlinear_channel(v.b));
+}
+
+float4 LUT1D(VertDataOut v_in) : TARGET
+{
+	float4 textureColor = image.Sample(textureSampler, v_in.uv);
+	textureColor.rgb *= (textureColor.a > 0.) ? (1. / textureColor.a) : 0.;
+	float3 nonlinear = srgb_linear_to_nonlinear(textureColor.rgb);
+
+	if (nonlinear.r >= domain_min.r && nonlinear.r <= domain_max.r) {
+		float u = nonlinear.r * clut_scale.r + clut_offset.r;
+		float channel = clut_1d.Sample(textureSampler, float2(u, 0.5)).r;
+		textureColor.r = lerp(textureColor.r, channel, clut_amount);
+	}
+
+	if (nonlinear.g >= domain_min.g && nonlinear.g <= domain_max.g) {
+		float u = nonlinear.g * clut_scale.g + clut_offset.g;
+		float channel = clut_1d.Sample(textureSampler, float2(u, 0.5)).g;
+		textureColor.g = lerp(textureColor.g, channel, clut_amount);
+	}
+
+	if (nonlinear.b >= domain_min.b && nonlinear.b <= domain_max.b) {
+		float u = nonlinear.b * clut_scale.b + clut_offset.b;
+		float channel = clut_1d.Sample(textureSampler, float2(u, 0.5)).b;
+		textureColor.b = lerp(textureColor.b, channel, clut_amount);
+	}
+
+	return textureColor;
+}
+
+float4 LUT3D(VertDataOut v_in) : TARGET
+{
+	float4 textureColor = image.Sample(textureSampler, v_in.uv);
+	float3 nonlinear = srgb_linear_to_nonlinear(textureColor.rgb);
+
+	float3 clut_uvw = nonlinear * clut_scale + clut_offset;
+	textureColor.rgb = clut_3d.Sample(textureSampler, clut_uvw).rgb;
+
+	return textureColor;
+}
+
+float4 LUTAlpha3D(VertDataOut v_in) : TARGET
+{
+	float4 textureColor = image.Sample(textureSampler, v_in.uv);
+	textureColor.rgb *= (textureColor.a > 0.) ? (1. / textureColor.a) : 0.;
+	float3 nonlinear = srgb_linear_to_nonlinear(textureColor.rgb);
+
+	float3 clut_uvw = nonlinear * clut_scale + clut_offset;
+	textureColor.rgb = clut_3d.Sample(textureSampler, clut_uvw).rgb;
+
+	textureColor.rgb *= textureColor.a;
+	return textureColor;
+}
+
+float4 LUTAmount3D(VertDataOut v_in) : TARGET
+{
+	float4 textureColor = image.Sample(textureSampler, v_in.uv);
+	textureColor.rgb *= (textureColor.a > 0.) ? (1. / textureColor.a) : 0.;
+	float3 nonlinear = srgb_linear_to_nonlinear(textureColor.rgb);
+
+	float3 clut_uvw = nonlinear * clut_scale + clut_offset;
+	float3 luttedColor = clut_3d.Sample(textureSampler, clut_uvw).rgb;
+	textureColor.rgb = lerp(textureColor.rgb, luttedColor, clut_amount);
+
+	textureColor.rgb *= textureColor.a;
+	return textureColor;
+}
+
+float4 LUTDomain3D(VertDataOut v_in) : TARGET
+{
+	float4 textureColor = image.Sample(textureSampler, v_in.uv);
+	textureColor.rgb *= (textureColor.a > 0.) ? (1. / textureColor.a) : 0.;
+	float3 nonlinear = srgb_linear_to_nonlinear(textureColor.rgb);
+
+	float r = nonlinear.r;
+	float g = nonlinear.g;
+	float b = nonlinear.b;
+	if (r >= domain_min.r && r <= domain_max.r &&
+		g >= domain_min.g && g <= domain_max.g &&
+		b >= domain_min.b && b <= domain_max.b)
+	{
+		float3 clut_uvw = nonlinear * clut_scale + clut_offset;
+		float3 luttedColor = clut_3d.Sample(textureSampler, clut_uvw).rgb;
+		textureColor.rgb = lerp(textureColor.rgb, luttedColor, clut_amount);
+	}
+
+	textureColor.rgb *= textureColor.a;
+	return textureColor;
+}
+
+technique Draw1D
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = LUT1D(v_in);
+	}
+}
+
+technique Draw3D
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = LUT3D(v_in);
+	}
+}
+
+technique DrawAlpha3D
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = LUTAlpha3D(v_in);
+	}
+}
+
+technique DrawAmount3D
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = LUTAmount3D(v_in);
+	}
+}
+
+technique DrawDomain3D
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = LUTDomain3D(v_in);
+	}
+}

package/dist/data/obs-plugins/obs-filters/color_key_filter.effect

@@ -0,0 +1,65 @@
+uniform float4x4 ViewProj;
+uniform texture2d image;
+
+uniform float4 color;
+uniform float contrast;
+uniform float brightness;
+uniform float gamma;
+
+uniform float4 key_color;
+uniform float similarity;
+uniform float smoothness;
+
+sampler_state textureSampler {
+	Filter    = Linear;
+	AddressU  = Clamp;
+	AddressV  = Clamp;
+};
+
+struct VertData {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+};
+
+VertData VSDefault(VertData v_in)
+{
+	VertData vert_out;
+	vert_out.pos = mul(float4(v_in.pos.xyz, 1.0), ViewProj);
+	vert_out.uv  = v_in.uv;
+	return vert_out;
+}
+
+float4 CalcColor(float4 rgba)
+{
+	return float4(pow(rgba.rgb, float3(gamma, gamma, gamma)) * contrast + brightness, rgba.a);
+}
+
+float GetColorDist(float3 rgb)
+{
+	return distance(key_color.rgb, rgb);
+}
+
+float4 ProcessColorKey(float4 rgba, VertData v_in)
+{
+	float colorDist = GetColorDist(rgba.rgb);
+	rgba.a *= saturate(max(colorDist - similarity, 0.0) / smoothness);
+
+	return CalcColor(rgba);
+}
+
+float4 PSColorKeyRGBA(VertData v_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, v_in.uv);
+	rgba.rgb *= (rgba.a > 0.) ? (1. / rgba.a) : 0.;
+	rgba *= color;
+	return ProcessColorKey(rgba, v_in);
+}
+
+technique Draw
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = PSColorKeyRGBA(v_in);
+	}
+}

package/dist/data/obs-plugins/obs-filters/color_key_filter_v2.effect

@@ -0,0 +1,77 @@
+uniform float4x4 ViewProj;
+uniform texture2d image;
+
+uniform float opacity;
+uniform float contrast;
+uniform float brightness;
+uniform float gamma;
+
+uniform float4 key_color;
+uniform float similarity;
+uniform float smoothness;
+
+sampler_state textureSampler {
+	Filter    = Linear;
+	AddressU  = Clamp;
+	AddressV  = Clamp;
+};
+
+struct VertData {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+};
+
+VertData VSDefault(VertData v_in)
+{
+	VertData vert_out;
+	vert_out.pos = mul(float4(v_in.pos.xyz, 1.0), ViewProj);
+	vert_out.uv  = v_in.uv;
+	return vert_out;
+}
+
+float4 CalcColor(float4 rgba)
+{
+	return float4(pow(rgba.rgb, float3(gamma, gamma, gamma)) * contrast + brightness, rgba.a);
+}
+
+float GetNonlinearChannel(float u)
+{
+	return (u <= 0.0031308) ? (12.92 * u) : ((1.055 * pow(u, 1.0 / 2.4)) - 0.055);
+}
+
+float3 GetNonlinearColor(float3 rgb)
+{
+	return float3(GetNonlinearChannel(rgb.r), GetNonlinearChannel(rgb.g), GetNonlinearChannel(rgb.b));
+}
+
+float GetColorDist(float3 rgb)
+{
+	return distance(key_color.rgb, GetNonlinearColor(rgb));
+}
+
+float4 ProcessColorKey(float4 rgba, VertData v_in)
+{
+	float colorDist = GetColorDist(rgba.rgb);
+	rgba.a *= saturate(max(colorDist - similarity, 0.0) / smoothness);
+
+	return CalcColor(rgba);
+}
+
+float4 PSColorKeyRGBA(VertData v_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, v_in.uv);
+	rgba.rgb *= (rgba.a > 0.) ? (1. / rgba.a) : 0.;
+	rgba.a *= opacity;
+	rgba = ProcessColorKey(rgba, v_in);
+	rgba.rgb *= rgba.a;
+	return rgba;
+}
+
+technique Draw
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = PSColorKeyRGBA(v_in);
+	}
+}

package/dist/data/obs-plugins/obs-filters/crop_filter.effect

@@ -0,0 +1,95 @@
+#include "color.effect"
+
+uniform float4x4 ViewProj;
+uniform texture2d image;
+
+uniform float2 mul_val;
+uniform float2 add_val;
+uniform float multiplier;
+
+sampler_state textureSampler {
+	Filter    = Linear;
+	AddressU  = Border;
+	AddressV  = Border;
+	BorderColor = 00000000;
+};
+
+struct VertData {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+};
+
+VertData VSCrop(VertData v_in)
+{
+	VertData vert_out;
+	vert_out.pos = mul(float4(v_in.pos.xyz, 1.0), ViewProj);
+	vert_out.uv  = v_in.uv * mul_val + add_val;
+	return vert_out;
+}
+
+float4 PSCrop(VertData v_in) : TARGET
+{
+	return image.Sample(textureSampler, v_in.uv);
+}
+
+float4 PSCropMultiply(VertData v_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, v_in.uv);
+	rgba.rgb *= multiplier;
+	return rgba;
+}
+
+float4 PSCropTonemap(VertData v_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, v_in.uv);
+	rgba.rgb = rec709_to_rec2020(rgba.rgb);
+	rgba.rgb = reinhard(rgba.rgb);
+	rgba.rgb = rec2020_to_rec709(rgba.rgb);
+	return rgba;
+}
+
+float4 PSCropMultiplyTonemap(VertData v_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, v_in.uv);
+	rgba.rgb *= multiplier;
+	rgba.rgb = rec709_to_rec2020(rgba.rgb);
+	rgba.rgb = reinhard(rgba.rgb);
+	rgba.rgb = rec2020_to_rec709(rgba.rgb);
+	return rgba;
+}
+
+technique Draw
+{
+	pass
+	{
+		vertex_shader = VSCrop(v_in);
+		pixel_shader  = PSCrop(v_in);
+	}
+}
+
+technique DrawMultiply
+{
+	pass
+	{
+		vertex_shader = VSCrop(v_in);
+		pixel_shader  = PSCropMultiply(v_in);
+	}
+}
+
+technique DrawTonemap
+{
+	pass
+	{
+		vertex_shader = VSCrop(v_in);
+		pixel_shader  = PSCropTonemap(v_in);
+	}
+}
+
+technique DrawMultiplyTonemap
+{
+	pass
+	{
+		vertex_shader = VSCrop(v_in);
+		pixel_shader  = PSCropMultiplyTonemap(v_in);
+	}
+}

package/dist/data/obs-plugins/obs-filters/hdr_tonemap_filter.effect

@@ -0,0 +1,97 @@
+#include "color.effect"
+
+uniform float4x4 ViewProj;
+uniform texture2d image;
+
+uniform float multiplier;
+uniform float input_maximum_nits;
+uniform float output_maximum_nits;
+
+sampler_state textureSampler {
+	Filter    = Linear;
+	AddressU  = Clamp;
+	AddressV  = Clamp;
+};
+
+struct VertData {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+};
+
+struct VertOut {
+	float2 uv  : TEXCOORD0;
+	float4 pos : POSITION;
+};
+
+struct FragData {
+	float2 uv  : TEXCOORD0;
+};
+
+VertOut VSHdrTonemap(VertData v_in)
+{
+	VertOut vert_out;
+	vert_out.pos = mul(float4(v_in.pos.xyz, 1.0), ViewProj);
+	vert_out.uv  = v_in.uv;
+	return vert_out;
+}
+
+float4 PSReinhard(FragData f_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, f_in.uv);
+	rgba.rgb *= multiplier;
+	rgba.rgb = rec709_to_rec2020(rgba.rgb);
+	rgba.rgb = reinhard(rgba.rgb);
+	rgba.rgb = rec2020_to_rec709(rgba.rgb);
+	return rgba;
+}
+
+float4 PSMaxrgb(FragData f_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, f_in.uv);
+	rgba.rgb *= multiplier;
+	rgba.rgb = rec709_to_rec2020(rgba.rgb);
+	rgba.rgb = maxRGB_eetf_linear_to_linear(rgba.rgb, input_maximum_nits, output_maximum_nits);
+	rgba.rgb = rec2020_to_rec709(rgba.rgb);
+	rgba.rgb *= 1. / multiplier;
+	return rgba;
+}
+
+float4 PSMaxrgbSdr(FragData f_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, f_in.uv);
+	rgba.rgb *= multiplier;
+	rgba.rgb = rec709_to_rec2020(rgba.rgb);
+	rgba.rgb = maxRGB_eetf_linear_to_linear(rgba.rgb, input_maximum_nits, output_maximum_nits);
+	rgba.rgb = rec2020_to_rec709(rgba.rgb);
+	rgba.rgb *= 10000. / output_maximum_nits;
+	rgba.rgb = pow(saturate(rgba.rgb), float3(1. / 2.4, 1. / 2.4, 1. / 2.4));
+	rgba.rgb = srgb_nonlinear_to_linear(rgba.rgb);
+	return rgba;
+}
+
+technique Reinhard
+{
+	pass
+	{
+		vertex_shader = VSHdrTonemap(v_in);
+		pixel_shader  = PSReinhard(f_in);
+	}
+}
+
+technique MaxRGB
+{
+	pass
+	{
+		vertex_shader = VSHdrTonemap(v_in);
+		pixel_shader  = PSMaxrgb(f_in);
+	}
+}
+
+technique MaxRGBSDR
+{
+	pass
+	{
+		vertex_shader = VSHdrTonemap(v_in);
+		pixel_shader  = PSMaxrgbSdr(f_in);
+	}
+}

package/dist/data/obs-plugins/obs-filters/locale/af-ZA.ini

@@ -0,0 +1,89 @@
+ColorFilter="Kleurkorreksie"
+CropFilter="Snoei/Aanvul"
+ScrollFilter="Rol"
+SharpnessFilter="Verskerp"
+Sharpness="Skerpte"
+ScaleFilter="Verskaling/Aspekverhouding"
+NoiseSuppress="Ruisonderdrukking"
+InvertPolarity="Keer polariteit om"
+DelayMs="Vertraging"
+Type="Tipe"
+MaskBlendType.MaskColor="Alfamasker (Kleurkanaal)"
+MaskBlendType.MaskAlpha="Alfamasker (Alfakanaal)"
+MaskBlendType.BlendMultiply="Meng (Vermenigvuldig)"
+MaskBlendType.BlendAddition="Meng (Toevoeging)"
+MaskBlendType.BlendSubtraction="Meng (Verskil)"
+Path="Pad"
+Color="Kleur"
+ColorMultiply="Kleur vermenigvuldiging"
+ColorAdd="Kleur toevoeging"
+Opacity="Ondeursigtigheid"
+Contrast="Kontras"
+Brightness="Helderheid"
+BrowsePath.Images="Alle beeldlêers"
+BrowsePath.AllFiles="Alle lêers"
+Similarity="Toleransie (1-1000)"
+Smoothness="Gladheid (1-1000)"
+Crop.Left="Links"
+Crop.Right="Regs"
+Crop.Top="Bo"
+Crop.Bottom="Onder"
+Crop.Width="Breedte"
+Crop.Height="Hoogte"
+Crop.Relative="Relatief"
+HdrTonemap.Description="OBS kan outomaties HDR na SDR omsit. Gebruik net hierdie filter as u ekstra invloed benodig vir ’n bepaalde bron.\nHierdie filter het geen effek op SDR-bronne nie."
+HdrTonemap.SdrWhiteLevel="SDR witvlak"
+ScrollFilter.SpeedX="Horisontale snelheid"
+ScrollFilter.SpeedY="Vertikale snelheid"
+ScrollFilter.LimitWidth="Beperk wydte"
+ScrollFilter.LimitHeight="Beperk hoogte"
+ScrollFilter.Loop="Herhaal"
+CustomColor="Pasgemaakte kleur"
+Red="Rooi"
+Green="Groen"
+Blue="Blou"
+NoiseGate.OpenThreshold="Oop-drempel"
+NoiseGate.CloseThreshold="Sluit-drempel"
+StretchImage="Rek beeld uit (ignoreer beeldaspekverhouding)"
+Resolution="Beeldskerpte"
+Base.Canvas="Basisbeeldskerpte (Doek)"
+None="Geen"
+ScaleFiltering="Skaalfilter"
+ScaleFiltering.Point="Punt"
+ScaleFiltering.Bilinear="Bilineêr"
+NoiseSuppress.SuppressLevel="Onderdrukkingsvlak"
+NoiseSuppress.Intensity="Onderdrukkingsintensiteit"
+NoiseSuppress.Method="Metode"
+NoiseSuppress.Method.RNNoise="RNNoise (goeie kwaliteit, meer SVE-gebruik)"
+NoiseSuppress.Method.Nvafx.Denoiser="NVIDIA-ruisverwydering"
+NoiseSuppress.Method.Nvafx.Dereverb="NVIDIA-kamereggoverwydering"
+NoiseSuppress.Method.Nvafx.DenoiserPlusDereverb="NVIDIA-ruisverwydering + -kamereggoverwydering"
+Saturation="Versadiging"
+HueShift="Tintverskuiwing"
+Amount="Hoeveelheid"
+Compressor="Kompressor"
+Compressor.Ratio="Verhouding"
+Compressor.Threshold="Drempel"
+Limiter="Begrenser"
+Limiter.Threshold="Drempel"
+Expander="Uitbreiding"
+Expander.Ratio="Verhouding"
+Expander.Threshold="Drempel"
+Expander.Detector="Bespeuring"
+Expander.Peak="Piek"
+Expander.Presets="Voorinstellings"
+Expander.Presets.Expander="Uitbreiding"
+Expander.Presets.Gate="Hek"
+Expander.Knee.Width="Kniebreedte"
+NvidiaGreenscreenFilter="NVIDIA-agtergrondverwydering"
+Greenscreen.Mode="Modus"
+Greenscreen.Quality="Kwaliteit (hoër GPU-gebruik, beter kwaliteit)"
+Greenscreen.Performance="Verrigting (laer GPU-gebruik, goeie kwaliteit)"
+Greenscreen.Threshold="Drempel"
+Greenscreen.Deprecation="WAARSKUWING: Gradeer asb. sowel die NVIDIA Video SDK as die NVIDIA Audio SDK op. U huidige weergawe van Video SDK is verouderd."
+Greenscreen.Processing.Hint="Dit verlig die GPU-lading deur slegs vir elke N rame ’n masker te genereer (2 by verstek)."
+Upward.Compressor="Opwaartse kompressor"
+3BandEq="3-bandeffenaar"
+3BandEq.low="Laag"
+3BandEq.mid="Middel"
+3BandEq.high="Hoog"