@farwave/runtime-macos-arm64-plugins 0.0.0-stage → 0.1.0

package/obs-plugins/obs-filters.plugin/Contents/Resources/LUTs/original.cube

@@ -0,0 +1,33 @@
+LUT_1D_SIZE 32
+0 0 0
+0.0322581 0.0322581 0.0322581
+0.0645161 0.0645161 0.0645161
+0.0967742 0.0967742 0.0967742
+0.129032 0.129032 0.129032
+0.16129 0.16129 0.16129
+0.193548 0.193548 0.193548
+0.225806 0.225806 0.225806
+0.258065 0.258065 0.258065
+0.290323 0.290323 0.290323
+0.322581 0.322581 0.322581
+0.354839 0.354839 0.354839
+0.387097 0.387097 0.387097
+0.419355 0.419355 0.419355
+0.451613 0.451613 0.451613
+0.483871 0.483871 0.483871
+0.516129 0.516129 0.516129
+0.548387 0.548387 0.548387
+0.580645 0.580645 0.580645
+0.612903 0.612903 0.612903
+0.645161 0.645161 0.645161
+0.677419 0.677419 0.677419
+0.709677 0.709677 0.709677
+0.741935 0.741935 0.741935
+0.774194 0.774194 0.774194
+0.806452 0.806452 0.806452
+0.83871 0.83871 0.83871
+0.870968 0.870968 0.870968
+0.903226 0.903226 0.903226
+0.935484 0.935484 0.935484
+0.967742 0.967742 0.967742
+1 1 1

package/obs-plugins/obs-filters.plugin/Contents/Resources/blend_add_filter.effect

@@ -0,0 +1,54 @@
+uniform float4x4 ViewProj;
+uniform texture2d image;
+
+uniform texture2d target;
+uniform float4 color;
+uniform float2 mul_val;
+uniform float2 add_val;
+
+sampler_state textureSampler {
+	Filter    = Linear;
+	AddressU  = Clamp;
+	AddressV  = Clamp;
+};
+
+struct VertDataIn {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+};
+
+struct VertDataOut {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+	float2 uv2 : TEXCOORD1;
+};
+
+VertDataOut VSDefault(VertDataIn v_in)
+{
+	VertDataOut vert_out;
+	vert_out.pos = mul(float4(v_in.pos.xyz, 1.0), ViewProj);
+	vert_out.uv  = v_in.uv;
+	vert_out.uv2 = v_in.uv * mul_val + add_val;
+	return vert_out;
+}
+
+float4 PSAddImageRGBA(VertDataOut v_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, v_in.uv);
+	rgba.rgb *= (rgba.a > 0.) ? (1. / rgba.a) : 0.;
+	rgba *= color;
+
+	float3 targetRGB = target.Sample(textureSampler, v_in.uv2).rgb;
+	rgba.rgb = saturate(rgba.rgb + targetRGB);
+	rgba.rgb *= rgba.a;
+	return rgba;
+}
+
+technique Draw
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = PSAddImageRGBA(v_in);
+	}
+}

package/obs-plugins/obs-filters.plugin/Contents/Resources/blend_mul_filter.effect

@@ -0,0 +1,54 @@
+uniform float4x4 ViewProj;
+uniform texture2d image;
+
+uniform texture2d target;
+uniform float4 color;
+uniform float2 mul_val;
+uniform float2 add_val;
+
+sampler_state textureSampler {
+	Filter    = Linear;
+	AddressU  = Clamp;
+	AddressV  = Clamp;
+};
+
+struct VertDataIn {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+};
+
+struct VertDataOut {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+	float2 uv2 : TEXCOORD1;
+};
+
+VertDataOut VSDefault(VertDataIn v_in)
+{
+	VertDataOut vert_out;
+	vert_out.pos = mul(float4(v_in.pos.xyz, 1.0), ViewProj);
+	vert_out.uv  = v_in.uv;
+	vert_out.uv2 = v_in.uv * mul_val + add_val;
+	return vert_out;
+}
+
+float4 PSMuliplyImageRGBA(VertDataOut v_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, v_in.uv);
+	rgba.rgb *= (rgba.a > 0.) ? (1. / rgba.a) : 0.;
+	rgba *= color;
+
+	float3 targetRGB = target.Sample(textureSampler, v_in.uv2).rgb;
+	rgba.rgb = saturate(rgba.rgb * targetRGB);
+	rgba.rgb *= rgba.a;
+	return rgba;
+}
+
+technique Draw
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = PSMuliplyImageRGBA(v_in);
+	}
+}

package/obs-plugins/obs-filters.plugin/Contents/Resources/blend_sub_filter.effect

@@ -0,0 +1,54 @@
+uniform float4x4 ViewProj;
+uniform texture2d image;
+
+uniform texture2d target;
+uniform float4 color;
+uniform float2 mul_val;
+uniform float2 add_val;
+
+sampler_state textureSampler {
+	Filter    = Linear;
+	AddressU  = Clamp;
+	AddressV  = Clamp;
+};
+
+struct VertDataIn {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+};
+
+struct VertDataOut {
+	float4 pos : POSITION;
+	float2 uv  : TEXCOORD0;
+	float2 uv2 : TEXCOORD1;
+};
+
+VertDataOut VSDefault(VertDataIn v_in)
+{
+	VertDataOut vert_out;
+	vert_out.pos = mul(float4(v_in.pos.xyz, 1.0), ViewProj);
+	vert_out.uv  = v_in.uv;
+	vert_out.uv2 = v_in.uv * mul_val + add_val;
+	return vert_out;
+}
+
+float4 PSSubtractImageRGBA(VertDataOut v_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, v_in.uv);
+	rgba.rgb *= (rgba.a > 0.) ? (1. / rgba.a) : 0.;
+	rgba *= color;
+
+	float3 targetRGB = target.Sample(textureSampler, v_in.uv2).rgb;
+	rgba.rgb = saturate(rgba.rgb - targetRGB);
+	rgba.rgb *= rgba.a;
+	return rgba;
+}
+
+technique Draw
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = PSSubtractImageRGBA(v_in);
+	}
+}

package/obs-plugins/obs-filters.plugin/Contents/Resources/chroma_key_filter.effect

@@ -0,0 +1,99 @@
+uniform float4x4 ViewProj;
+uniform texture2d image;
+
+uniform float4x4 yuv_mat = { 0.182586,  0.614231,  0.062007, 0.062745,
+                            -0.100644, -0.338572,  0.439216, 0.501961,
+                             0.439216, -0.398942, -0.040274, 0.501961,
+                             0.000000,  0.000000,  0.000000, 1.000000};
+
+uniform float4 color;
+uniform float contrast;
+uniform float brightness;
+uniform float gamma;
+
+uniform float2 chroma_key;
+uniform float2 pixel_size;
+uniform float similarity;
+uniform float smoothness;
+uniform float spill;
+
+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 GetChromaDist(float3 rgb)
+{
+	float4 yuvx = mul(float4(rgb.rgb, 1.0), yuv_mat);
+	return distance(chroma_key, yuvx.yz);
+}
+
+float4 SampleTexture(float2 uv)
+{
+	return image.Sample(textureSampler, uv);
+}
+
+float GetBoxFilteredChromaDist(float3 rgb, float2 texCoord)
+{
+	float2 h_pixel_size = pixel_size / 2.0;
+	float2 point_0 = float2(pixel_size.x, h_pixel_size.y);
+	float2 point_1 = float2(h_pixel_size.x, -pixel_size.y);
+	float distVal = GetChromaDist(SampleTexture(texCoord-point_0).rgb);
+	distVal += GetChromaDist(SampleTexture(texCoord+point_0).rgb);
+	distVal += GetChromaDist(SampleTexture(texCoord-point_1).rgb);
+	distVal += GetChromaDist(SampleTexture(texCoord+point_1).rgb);
+	distVal *= 2.0;
+	distVal += GetChromaDist(rgb);
+	return distVal / 9.0;
+}
+
+float4 ProcessChromaKey(float4 rgba, VertData v_in)
+{
+	float chromaDist = GetBoxFilteredChromaDist(rgba.rgb, v_in.uv);
+	float baseMask = chromaDist - similarity;
+	float fullMask = pow(saturate(baseMask / smoothness), 1.5);
+	float spillVal = pow(saturate(baseMask / spill), 1.5);
+
+	rgba.rgba *= color;
+	rgba.a *= fullMask;
+
+	float desat = (rgba.r * 0.2126 + rgba.g * 0.7152 + rgba.b * 0.0722);
+	rgba.rgb = saturate(float3(desat, desat, desat)) * (1.0 - spillVal) + rgba.rgb * spillVal;
+
+	return CalcColor(rgba);
+}
+
+float4 PSChromaKeyRGBA(VertData v_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, v_in.uv);
+	rgba.rgb *= (rgba.a > 0.) ? (1. / rgba.a) : 0.;
+	return ProcessChromaKey(rgba, v_in);
+}
+
+technique Draw
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = PSChromaKeyRGBA(v_in);
+	}
+}

package/obs-plugins/obs-filters.plugin/Contents/Resources/chroma_key_filter_v2.effect

@@ -0,0 +1,111 @@
+uniform float4x4 ViewProj;
+uniform texture2d image;
+
+uniform float4 cb_v4 = { -0.100644, -0.338572,  0.439216, 0.501961 };
+uniform float4 cr_v4 = {  0.439216, -0.398942, -0.040274, 0.501961 };
+
+uniform float opacity;
+uniform float contrast;
+uniform float brightness;
+uniform float gamma;
+
+uniform float2 chroma_key;
+uniform float2 pixel_size;
+uniform float similarity;
+uniform float smoothness;
+uniform float spill;
+
+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 GetChromaDist(float3 rgb)
+{
+	float cb = dot(rgb.rgb, cb_v4.xyz) + cb_v4.w;
+	float cr = dot(rgb.rgb, cr_v4.xyz) + cr_v4.w;
+	return distance(chroma_key, float2(cb, cr));
+}
+
+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));
+}
+
+float3 SampleTexture(float2 uv)
+{
+	float3 rgb = image.Sample(textureSampler, uv).rgb;
+	return GetNonlinearColor(rgb);
+}
+
+float GetBoxFilteredChromaDist(float3 rgb, float2 texCoord)
+{
+	float2 h_pixel_size = pixel_size / 2.0;
+	float2 point_0 = float2(pixel_size.x, h_pixel_size.y);
+	float2 point_1 = float2(h_pixel_size.x, -pixel_size.y);
+	float distVal = GetChromaDist(SampleTexture(texCoord-point_0));
+	distVal += GetChromaDist(SampleTexture(texCoord+point_0));
+	distVal += GetChromaDist(SampleTexture(texCoord-point_1));
+	distVal += GetChromaDist(SampleTexture(texCoord+point_1));
+	distVal *= 2.0;
+	distVal += GetChromaDist(GetNonlinearColor(rgb));
+	return distVal / 9.0;
+}
+
+float4 ProcessChromaKey(float4 rgba, VertData v_in)
+{
+	float chromaDist = GetBoxFilteredChromaDist(rgba.rgb, v_in.uv);
+	float baseMask = chromaDist - similarity;
+	float fullMask = pow(saturate(baseMask / smoothness), 1.5);
+	float spillVal = pow(saturate(baseMask / spill), 1.5);
+
+	rgba.a *= opacity;
+	rgba.a *= fullMask;
+
+	float desat = dot(rgba.rgb, float3(0.2126, 0.7152, 0.0722));
+	rgba.rgb = lerp(float3(desat, desat, desat), rgba.rgb, spillVal);
+
+	return CalcColor(rgba);
+}
+
+float4 PSChromaKeyRGBA(VertData v_in) : TARGET
+{
+	float4 rgba = image.Sample(textureSampler, v_in.uv);
+	rgba.rgb *= (rgba.a > 0.) ? (1. / rgba.a) : 0.;
+	rgba = ProcessChromaKey(rgba, v_in);
+	rgba.rgb *= rgba.a;
+	return rgba;
+}
+
+technique Draw
+{
+	pass
+	{
+		vertex_shader = VSDefault(v_in);
+		pixel_shader  = PSChromaKeyRGBA(v_in);
+	}
+}

package/obs-plugins/obs-filters.plugin/Contents/Resources/color.effect

@@ -0,0 +1,95 @@
+float srgb_linear_to_nonlinear_channel(float u)
+{
+	return (u <= 0.0031308) ? (12.92 * u) : ((1.055 * pow(u, 1. / 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));
+}
+
+float srgb_nonlinear_to_linear_channel(float u)
+{
+	return (u <= 0.04045) ? (u / 12.92) : pow(mad(u, 1. / 1.055, .055 / 1.055), 2.4);
+}
+
+float3 srgb_nonlinear_to_linear(float3 v)
+{
+	return float3(srgb_nonlinear_to_linear_channel(v.r), srgb_nonlinear_to_linear_channel(v.g), srgb_nonlinear_to_linear_channel(v.b));
+}
+
+float3 rec709_to_rec2020(float3 v)
+{
+	float r = dot(v, float3(0.62740389593469903, 0.32928303837788370, 0.043313065687417225));
+	float g = dot(v, float3(0.069097289358232075, 0.91954039507545871, 0.011362315566309178));
+	float b = dot(v, float3(0.016391438875150280, 0.088013307877225749, 0.89559525324762401));
+	return float3(r, g, b);
+}
+
+float3 rec2020_to_rec709(float3 v)
+{
+	float r = dot(v, float3(1.6604910021084345, -0.58764113878854951, -0.072849863319884883));
+	float g = dot(v, float3(-0.12455047452159074, 1.1328998971259603, -0.0083494226043694768));
+	float b = dot(v, float3(-0.018150763354905303, -0.10057889800800739, 1.1187296613629127));
+	return float3(r, g, b);
+}
+
+float3 reinhard(float3 rgb)
+{
+	rgb /= rgb + float3(1., 1., 1.);
+	rgb = saturate(rgb);
+	rgb = pow(rgb, float3(1. / 2.4, 1. / 2.4, 1. / 2.4));
+	rgb = srgb_nonlinear_to_linear(rgb);
+	return rgb;
+}
+
+float linear_to_st2084_channel(float x)
+{
+	float c = pow(abs(x), 0.1593017578);
+	return pow((0.8359375 + 18.8515625 * c) / (1. + 18.6875 * c), 78.84375);
+}
+
+float st2084_to_linear_channel(float u)
+{
+	float c = pow(abs(u), 1. / 78.84375);
+	return pow(abs(max(c - 0.8359375, 0.) / (18.8515625 - 18.6875 * c)), 1. / 0.1593017578);
+}
+
+float eetf_0_Lmax(float maxRGB1_pq, float Lw, float Lmax)
+{
+	float Lw_pq = linear_to_st2084_channel(Lw / 10000.);
+	float E1 = saturate(maxRGB1_pq / Lw_pq); // Ensure normalization in case Lw is a lie
+	float maxLum = linear_to_st2084_channel(Lmax / 10000.) / Lw_pq;
+	float KS = (1.5 * maxLum) - 0.5;
+	float E2 = E1;
+	if (E1 > KS)
+	{
+		float T = (E1 - KS) / (1. - KS);
+		float Tsquared = T * T;
+		float Tcubed = Tsquared * T;
+		float P = (2. * Tcubed - 3. * Tsquared + 1.) * KS + (Tcubed - 2. * Tsquared + T) * (1. - KS) + (-2. * Tcubed + 3. * Tsquared) * maxLum;
+		E2 = P;
+	}
+	float E3 = E2;
+	float E4 = E3 * Lw_pq;
+	return E4;
+}
+
+float3 maxRGB_eetf_internal(float3 rgb_linear, float maxRGB1_linear, float maxRGB1_pq, float Lw, float Lmax)
+{
+	float maxRGB2_pq = eetf_0_Lmax(maxRGB1_pq, Lw, Lmax);
+	float maxRGB2_linear = st2084_to_linear_channel(maxRGB2_pq);
+
+	// avoid divide-by-zero possibility
+	maxRGB1_linear = max(6.10352e-5, maxRGB1_linear);
+
+	rgb_linear *= maxRGB2_linear / maxRGB1_linear;
+	return rgb_linear;
+}
+
+float3 maxRGB_eetf_linear_to_linear(float3 rgb_linear, float Lw, float Lmax)
+{
+	float maxRGB1_linear = max(max(rgb_linear.r, rgb_linear.g), rgb_linear.b);
+	float maxRGB1_pq = linear_to_st2084_channel(maxRGB1_linear);
+	return maxRGB_eetf_internal(rgb_linear, maxRGB1_linear, maxRGB1_pq, Lw, Lmax);
+}

package/obs-plugins/obs-filters.plugin/Contents/Resources/color_correction_filter.effect

@@ -0,0 +1,74 @@
+/*****************************************************************************
+Copyright (C) 2016 by c3r1c3 <c3r1c3@nevermindonline.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*****************************************************************************/
+
+uniform float4x4 ViewProj;
+uniform texture2d image;
+
+uniform float gamma;
+
+/* Pre-Compute variables. */
+uniform float4x4 color_matrix;
+
+
+sampler_state textureSampler {
+	Filter   = Linear;
+	AddressU = Clamp;
+	AddressV = Clamp;
+};
+
+struct VertData {
+	float4 pos : POSITION;
+	float2 uv : TEXCOORD0;
+};
+
+VertData VSDefault(VertData vert_in)
+{
+	VertData vert_out;
+	vert_out.pos = mul(float4(vert_in.pos.xyz, 1.0), ViewProj);
+	vert_out.uv = vert_in.uv;
+	return vert_out;
+}
+
+float4 PSColorFilterRGBA(VertData vert_in) : TARGET
+{
+	/* Grab the current pixel to perform operations on. */
+	float4 currentPixel = image.Sample(textureSampler, vert_in.uv);
+	currentPixel.rgb *= (currentPixel.a > 0.) ? (1. / currentPixel.a) : 0.;
+
+	/* Always address the gamma first. */
+	currentPixel.rgb = pow(currentPixel.rgb, float3(gamma, gamma, gamma));
+
+	/* Much easier to manipulate pixels for these types of operations
+	 * when in a matrix such as the below. See
+	 * http://www.graficaobscura.com/matrix/index.html and
+	 * https://docs.rainmeter.net/tips/colormatrix-guide/for more info.
+	 */
+	currentPixel = mul(color_matrix, currentPixel);
+
+	currentPixel.rgb *= currentPixel.a;
+
+	return currentPixel;
+}
+
+technique Draw
+{
+	pass
+	{
+		vertex_shader = VSDefault(vert_in);
+		pixel_shader = PSColorFilterRGBA(vert_in);
+	}
+}