2014-02-16 18:28:21 -08:00
|
|
|
/******************************************************************************
|
|
|
|
Copyright (C) 2014 by Hugh Bailey <obs.jim@gmail.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/>.
|
|
|
|
******************************************************************************/
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
#include "color.effect"
|
|
|
|
|
2014-02-16 18:28:21 -08:00
|
|
|
uniform float width;
|
|
|
|
uniform float height;
|
|
|
|
uniform float width_i;
|
2022-04-03 00:00:38 -07:00
|
|
|
uniform float height_i;
|
2014-02-16 18:28:21 -08:00
|
|
|
uniform float width_d2;
|
2019-08-09 20:43:14 -07:00
|
|
|
uniform float height_d2;
|
|
|
|
uniform float width_x2_i;
|
2022-04-03 00:00:38 -07:00
|
|
|
uniform float maximum_over_sdr_white_nits;
|
|
|
|
uniform float sdr_white_nits_over_maximum;
|
2022-04-10 12:31:08 -07:00
|
|
|
uniform float hlg_exponent;
|
|
|
|
uniform float hlg_lw;
|
2014-02-16 18:28:21 -08:00
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
uniform float4 color_vec0;
|
|
|
|
uniform float4 color_vec1;
|
|
|
|
uniform float4 color_vec2;
|
2019-04-02 09:03:57 -07:00
|
|
|
uniform float3 color_range_min = {0.0, 0.0, 0.0};
|
|
|
|
uniform float3 color_range_max = {1.0, 1.0, 1.0};
|
|
|
|
|
2014-02-16 18:28:21 -08:00
|
|
|
uniform texture2d image;
|
2019-08-09 20:43:14 -07:00
|
|
|
uniform texture2d image1;
|
|
|
|
uniform texture2d image2;
|
2019-08-11 11:26:22 -07:00
|
|
|
uniform texture2d image3;
|
2014-02-16 18:28:21 -08:00
|
|
|
|
|
|
|
sampler_state def_sampler {
|
|
|
|
Filter = Linear;
|
|
|
|
AddressU = Clamp;
|
|
|
|
AddressV = Clamp;
|
|
|
|
};
|
|
|
|
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
struct FragPos {
|
2014-02-16 18:28:21 -08:00
|
|
|
float4 pos : POSITION;
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct VertTexPos {
|
2014-02-16 18:28:21 -08:00
|
|
|
float2 uv : TEXCOORD0;
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
float4 pos : POSITION;
|
2014-02-16 18:28:21 -08:00
|
|
|
};
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
struct VertPosWide {
|
|
|
|
float3 pos_wide : TEXCOORD0;
|
|
|
|
float4 pos : POSITION;
|
|
|
|
};
|
|
|
|
|
2019-07-26 23:21:41 -07:00
|
|
|
struct VertTexPosWide {
|
|
|
|
float3 uuv : TEXCOORD0;
|
|
|
|
float4 pos : POSITION;
|
|
|
|
};
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
struct VertTexPosWideWide {
|
|
|
|
float4 uuvv : TEXCOORD0;
|
|
|
|
float4 pos : POSITION;
|
|
|
|
};
|
|
|
|
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
struct FragTex {
|
2019-07-26 23:21:41 -07:00
|
|
|
float2 uv : TEXCOORD0;
|
|
|
|
};
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
struct FragPosWide {
|
|
|
|
float3 pos_wide : TEXCOORD0;
|
|
|
|
};
|
|
|
|
|
2019-07-26 23:21:41 -07:00
|
|
|
struct FragTexWide {
|
|
|
|
float3 uuv : TEXCOORD0;
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
};
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
struct FragTexWideWide {
|
|
|
|
float4 uuvv : TEXCOORD0;
|
|
|
|
};
|
|
|
|
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
FragPos VSPos(uint id : VERTEXID)
|
|
|
|
{
|
|
|
|
float idHigh = float(id >> 1);
|
|
|
|
float idLow = float(id & uint(1));
|
|
|
|
|
|
|
|
float x = idHigh * 4.0 - 1.0;
|
|
|
|
float y = idLow * 4.0 - 1.0;
|
|
|
|
|
|
|
|
FragPos vert_out;
|
|
|
|
vert_out.pos = float4(x, y, 0.0, 1.0);
|
|
|
|
return vert_out;
|
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
VertTexPosWide VSTexPos_Left(uint id : VERTEXID)
|
|
|
|
{
|
|
|
|
float idHigh = float(id >> 1);
|
|
|
|
float idLow = float(id & uint(1));
|
|
|
|
|
|
|
|
float x = idHigh * 4.0 - 1.0;
|
|
|
|
float y = idLow * 4.0 - 1.0;
|
|
|
|
|
|
|
|
float u_right = idHigh * 2.0;
|
|
|
|
float u_left = u_right - width_i;
|
|
|
|
float v = obs_glsl_compile ? (idLow * 2.0) : (1.0 - idLow * 2.0);
|
|
|
|
|
|
|
|
VertTexPosWide vert_out;
|
|
|
|
vert_out.uuv = float3(u_left, u_right, v);
|
|
|
|
vert_out.pos = float4(x, y, 0.0, 1.0);
|
|
|
|
return vert_out;
|
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
VertTexPosWideWide VSTexPos_TopLeft(uint id : VERTEXID)
|
|
|
|
{
|
|
|
|
float idHigh = float(id >> 1);
|
|
|
|
float idLow = float(id & uint(1));
|
|
|
|
|
|
|
|
float x = idHigh * 4.0 - 1.0;
|
|
|
|
float y = idLow * 4.0 - 1.0;
|
|
|
|
|
|
|
|
float u_right = idHigh * 2.0;
|
|
|
|
float u_left = u_right - width_i;
|
|
|
|
float v_bottom;
|
|
|
|
float v_top;
|
|
|
|
if (obs_glsl_compile) {
|
|
|
|
v_bottom = idLow * 2.0;
|
|
|
|
v_top = v_bottom + height_i;
|
|
|
|
} else {
|
|
|
|
v_bottom = 1.0 - idLow * 2.0;
|
|
|
|
v_top = v_bottom - height_i;
|
|
|
|
}
|
|
|
|
|
|
|
|
VertTexPosWideWide vert_out;
|
|
|
|
vert_out.uuvv = float4(u_left, u_right, v_top, v_bottom);
|
|
|
|
vert_out.pos = float4(x, y, 0.0, 1.0);
|
|
|
|
return vert_out;
|
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
VertTexPos VSTexPosHalf_Reverse(uint id : VERTEXID)
|
2014-02-16 18:28:21 -08:00
|
|
|
{
|
2019-06-02 06:49:38 -07:00
|
|
|
float idHigh = float(id >> 1);
|
|
|
|
float idLow = float(id & uint(1));
|
|
|
|
|
|
|
|
float x = idHigh * 4.0 - 1.0;
|
|
|
|
float y = idLow * 4.0 - 1.0;
|
|
|
|
|
|
|
|
float u = idHigh * 2.0;
|
|
|
|
float v = obs_glsl_compile ? (idLow * 2.0) : (1.0 - idLow * 2.0);
|
|
|
|
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
VertTexPos vert_out;
|
2019-08-09 20:43:14 -07:00
|
|
|
vert_out.uv = float2(width_d2 * u, height * v);
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
vert_out.pos = float4(x, y, 0.0, 1.0);
|
2014-02-16 18:28:21 -08:00
|
|
|
return vert_out;
|
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
VertTexPos VSTexPosHalfHalf_Reverse(uint id : VERTEXID)
|
2014-04-04 11:49:23 -07:00
|
|
|
{
|
2019-07-26 23:21:41 -07:00
|
|
|
float idHigh = float(id >> 1);
|
|
|
|
float idLow = float(id & uint(1));
|
2014-04-04 11:49:23 -07:00
|
|
|
|
2019-07-26 23:21:41 -07:00
|
|
|
float x = idHigh * 4.0 - 1.0;
|
|
|
|
float y = idLow * 4.0 - 1.0;
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float u = idHigh * 2.0;
|
2019-07-26 23:21:41 -07:00
|
|
|
float v = obs_glsl_compile ? (idLow * 2.0) : (1.0 - idLow * 2.0);
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
VertTexPos vert_out;
|
|
|
|
vert_out.uv = float2(width_d2 * u, height_d2 * v);
|
2019-07-26 23:21:41 -07:00
|
|
|
vert_out.pos = float4(x, y, 0.0, 1.0);
|
|
|
|
return vert_out;
|
2014-04-04 11:49:23 -07:00
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
VertPosWide VSPosWide_Reverse(uint id : VERTEXID)
|
|
|
|
{
|
|
|
|
float idHigh = float(id >> 1);
|
|
|
|
float idLow = float(id & uint(1));
|
|
|
|
|
|
|
|
float x = idHigh * 4.0 - 1.0;
|
|
|
|
float y = idLow * 4.0 - 1.0;
|
|
|
|
|
|
|
|
float u = idHigh * 2.0;
|
|
|
|
float v = obs_glsl_compile ? (idLow * 2.0) : (1.0 - idLow * 2.0);
|
|
|
|
|
|
|
|
VertPosWide vert_out;
|
|
|
|
vert_out.pos_wide = float3(float2(width, width_d2) * u, height * v);
|
|
|
|
vert_out.pos = float4(x, y, 0.0, 1.0);
|
|
|
|
return vert_out;
|
|
|
|
}
|
2019-07-26 23:21:41 -07:00
|
|
|
|
|
|
|
float PS_Y(FragPos frag_in) : TARGET
|
2018-10-05 20:18:15 -07:00
|
|
|
{
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
float3 rgb = image.Load(int3(frag_in.pos.xy, 0)).rgb;
|
2019-08-09 20:43:14 -07:00
|
|
|
float y = dot(color_vec0.xyz, rgb) + color_vec0.w;
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
return y;
|
2018-10-05 20:18:15 -07:00
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
float PS_PQ_Y_709_2020(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb = image.Load(int3(frag_in.pos.xy, 0)).rgb * sdr_white_nits_over_maximum;
|
|
|
|
rgb = rec709_to_rec2020(rgb);
|
|
|
|
rgb = linear_to_st2084(rgb);
|
|
|
|
float y = dot(color_vec0.xyz, rgb) + color_vec0.w;
|
2022-03-30 22:39:53 -07:00
|
|
|
y = (65472. / 65535.) * y + (32. / 65535.); // set up truncation to 10 bits
|
2022-04-03 00:00:38 -07:00
|
|
|
return y;
|
|
|
|
}
|
|
|
|
|
|
|
|
float PS_HLG_Y_709_2020(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb = image.Load(int3(frag_in.pos.xy, 0)).rgb * sdr_white_nits_over_maximum;
|
|
|
|
rgb = rec709_to_rec2020(rgb);
|
2022-04-10 12:31:08 -07:00
|
|
|
rgb = linear_to_hlg(rgb, hlg_lw);
|
2022-04-03 00:00:38 -07:00
|
|
|
float y = dot(color_vec0.xyz, rgb) + color_vec0.w;
|
2022-03-30 22:39:53 -07:00
|
|
|
y = (65472. / 65535.) * y + (32. / 65535.); // set up truncation to 10 bits
|
|
|
|
return y;
|
|
|
|
}
|
|
|
|
|
|
|
|
float PS_SRGB_Y(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb = image.Load(int3(frag_in.pos.xy, 0)).rgb;
|
|
|
|
rgb = srgb_linear_to_nonlinear(rgb);
|
|
|
|
float y = dot(color_vec0.xyz, rgb) + color_vec0.w;
|
|
|
|
y = (65472. / 65535.) * y + (32. / 65535.); // set up truncation to 10 bits
|
2022-04-03 00:00:38 -07:00
|
|
|
return y;
|
|
|
|
}
|
|
|
|
|
|
|
|
float PS_I010_PQ_Y_709_2020(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb = image.Load(int3(frag_in.pos.xy, 0)).rgb * sdr_white_nits_over_maximum;
|
|
|
|
rgb = rec709_to_rec2020(rgb);
|
|
|
|
rgb = linear_to_st2084(rgb);
|
|
|
|
float y = dot(color_vec0.xyz, rgb) + color_vec0.w;
|
|
|
|
return y * (1023. / 65535.);
|
|
|
|
}
|
|
|
|
|
|
|
|
float PS_I010_HLG_Y_709_2020(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb = image.Load(int3(frag_in.pos.xy, 0)).rgb * sdr_white_nits_over_maximum;
|
|
|
|
rgb = rec709_to_rec2020(rgb);
|
2022-04-10 12:31:08 -07:00
|
|
|
rgb = linear_to_hlg(rgb, hlg_lw);
|
2022-04-03 00:00:38 -07:00
|
|
|
float y = dot(color_vec0.xyz, rgb) + color_vec0.w;
|
|
|
|
return y * (1023. / 65535.);
|
|
|
|
}
|
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
float PS_I010_SRGB_Y(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb = image.Load(int3(frag_in.pos.xy, 0)).rgb;
|
|
|
|
rgb = srgb_linear_to_nonlinear(rgb);
|
|
|
|
float y = dot(color_vec0.xyz, rgb) + color_vec0.w;
|
|
|
|
return y * (1023. / 65535.);
|
|
|
|
}
|
|
|
|
|
2019-07-26 23:21:41 -07:00
|
|
|
float2 PS_UV_Wide(FragTexWide frag_in) : TARGET
|
2018-10-05 20:18:15 -07:00
|
|
|
{
|
2019-07-26 23:21:41 -07:00
|
|
|
float3 rgb_left = image.Sample(def_sampler, frag_in.uuv.xz).rgb;
|
|
|
|
float3 rgb_right = image.Sample(def_sampler, frag_in.uuv.yz).rgb;
|
|
|
|
float3 rgb = (rgb_left + rgb_right) * 0.5;
|
2019-08-09 20:43:14 -07:00
|
|
|
float u = dot(color_vec1.xyz, rgb) + color_vec1.w;
|
|
|
|
float v = dot(color_vec2.xyz, rgb) + color_vec2.w;
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
return float2(u, v);
|
2018-10-05 20:18:15 -07:00
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
float2 PS_PQ_UV_709_2020_WideWide(FragTexWideWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb_topleft = image.Sample(def_sampler, frag_in.uuvv.xz).rgb;
|
|
|
|
float3 rgb_topright = image.Sample(def_sampler, frag_in.uuvv.yz).rgb;
|
|
|
|
float3 rgb_bottomleft = image.Sample(def_sampler, frag_in.uuvv.xw).rgb;
|
|
|
|
float3 rgb_bottomright = image.Sample(def_sampler, frag_in.uuvv.yw).rgb;
|
|
|
|
float3 rgb = (rgb_topleft + rgb_topright + rgb_bottomleft + rgb_bottomright) * (0.25 * sdr_white_nits_over_maximum);
|
|
|
|
rgb = rec709_to_rec2020(rgb);
|
|
|
|
rgb = linear_to_st2084(rgb);
|
|
|
|
float u = dot(color_vec1.xyz, rgb) + color_vec1.w;
|
|
|
|
float v = dot(color_vec2.xyz, rgb) + color_vec2.w;
|
|
|
|
float2 uv = float2(u, v);
|
2022-03-30 22:39:53 -07:00
|
|
|
uv = (65472. / 65535.) * uv + (32. / 65535.); // set up truncation to 10 bits
|
2022-04-03 00:00:38 -07:00
|
|
|
return uv;
|
|
|
|
}
|
|
|
|
|
|
|
|
float2 PS_HLG_UV_709_2020_WideWide(FragTexWideWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb_topleft = image.Sample(def_sampler, frag_in.uuvv.xz).rgb;
|
|
|
|
float3 rgb_topright = image.Sample(def_sampler, frag_in.uuvv.yz).rgb;
|
|
|
|
float3 rgb_bottomleft = image.Sample(def_sampler, frag_in.uuvv.xw).rgb;
|
|
|
|
float3 rgb_bottomright = image.Sample(def_sampler, frag_in.uuvv.yw).rgb;
|
|
|
|
float3 rgb = (rgb_topleft + rgb_topright + rgb_bottomleft + rgb_bottomright) * (0.25 * sdr_white_nits_over_maximum);
|
|
|
|
rgb = rec709_to_rec2020(rgb);
|
2022-04-10 12:31:08 -07:00
|
|
|
rgb = linear_to_hlg(rgb, hlg_lw);
|
2022-04-03 00:00:38 -07:00
|
|
|
float u = dot(color_vec1.xyz, rgb) + color_vec1.w;
|
|
|
|
float v = dot(color_vec2.xyz, rgb) + color_vec2.w;
|
|
|
|
float2 uv = float2(u, v);
|
2022-03-30 22:39:53 -07:00
|
|
|
uv = (65472. / 65535.) * uv + (32. / 65535.); // set up truncation to 10 bits
|
|
|
|
return uv;
|
|
|
|
}
|
|
|
|
|
|
|
|
float2 PS_SRGB_UV_WideWide(FragTexWideWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb_topleft = image.Sample(def_sampler, frag_in.uuvv.xz).rgb;
|
|
|
|
float3 rgb_topright = image.Sample(def_sampler, frag_in.uuvv.yz).rgb;
|
|
|
|
float3 rgb_bottomleft = image.Sample(def_sampler, frag_in.uuvv.xw).rgb;
|
|
|
|
float3 rgb_bottomright = image.Sample(def_sampler, frag_in.uuvv.yw).rgb;
|
|
|
|
float3 rgb = (rgb_topleft + rgb_topright + rgb_bottomleft + rgb_bottomright) * 0.25;
|
|
|
|
rgb = srgb_linear_to_nonlinear(rgb);
|
|
|
|
float u = dot(color_vec1.xyz, rgb) + color_vec1.w;
|
|
|
|
float v = dot(color_vec2.xyz, rgb) + color_vec2.w;
|
|
|
|
float2 uv = float2(u, v);
|
|
|
|
uv = (65472. / 65535.) * uv + (32. / 65535.); // set up truncation to 10 bits
|
2022-04-03 00:00:38 -07:00
|
|
|
return uv;
|
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float PS_U(FragPos frag_in) : TARGET
|
2014-02-16 18:28:21 -08:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 rgb = image.Load(int3(frag_in.pos.xy, 0)).rgb;
|
|
|
|
float u = dot(color_vec1.xyz, rgb) + color_vec1.w;
|
2019-07-26 23:21:41 -07:00
|
|
|
return u;
|
2014-02-16 18:28:21 -08:00
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float PS_V(FragPos frag_in) : TARGET
|
2015-04-16 22:43:46 -07:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 rgb = image.Load(int3(frag_in.pos.xy, 0)).rgb;
|
|
|
|
float v = dot(color_vec2.xyz, rgb) + color_vec2.w;
|
2019-07-26 23:21:41 -07:00
|
|
|
return v;
|
|
|
|
}
|
2015-04-16 22:43:46 -07:00
|
|
|
|
2019-07-26 23:21:41 -07:00
|
|
|
float PS_U_Wide(FragTexWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb_left = image.Sample(def_sampler, frag_in.uuv.xz).rgb;
|
|
|
|
float3 rgb_right = image.Sample(def_sampler, frag_in.uuv.yz).rgb;
|
|
|
|
float3 rgb = (rgb_left + rgb_right) * 0.5;
|
2019-08-09 20:43:14 -07:00
|
|
|
float u = dot(color_vec1.xyz, rgb) + color_vec1.w;
|
2019-07-26 23:21:41 -07:00
|
|
|
return u;
|
|
|
|
}
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
|
2019-07-26 23:21:41 -07:00
|
|
|
float PS_V_Wide(FragTexWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb_left = image.Sample(def_sampler, frag_in.uuv.xz).rgb;
|
|
|
|
float3 rgb_right = image.Sample(def_sampler, frag_in.uuv.yz).rgb;
|
|
|
|
float3 rgb = (rgb_left + rgb_right) * 0.5;
|
2019-08-09 20:43:14 -07:00
|
|
|
float v = dot(color_vec2.xyz, rgb) + color_vec2.w;
|
2019-07-26 23:21:41 -07:00
|
|
|
return v;
|
2015-04-16 22:43:46 -07:00
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
float PS_I010_PQ_U_709_2020_WideWide(FragTexWideWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb_topleft = image.Sample(def_sampler, frag_in.uuvv.xz).rgb;
|
|
|
|
float3 rgb_topright = image.Sample(def_sampler, frag_in.uuvv.yz).rgb;
|
|
|
|
float3 rgb_bottomleft = image.Sample(def_sampler, frag_in.uuvv.xw).rgb;
|
|
|
|
float3 rgb_bottomright = image.Sample(def_sampler, frag_in.uuvv.yw).rgb;
|
|
|
|
float3 rgb = (rgb_topleft + rgb_topright + rgb_bottomleft + rgb_bottomright) * (0.25 * sdr_white_nits_over_maximum);
|
|
|
|
rgb = rec709_to_rec2020(rgb);
|
|
|
|
rgb = linear_to_st2084(rgb);
|
|
|
|
float u = dot(color_vec1.xyz, rgb) + color_vec1.w;
|
|
|
|
return u * (1023. / 65535.);
|
|
|
|
}
|
|
|
|
|
|
|
|
float PS_I010_HLG_U_709_2020_WideWide(FragTexWideWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb_topleft = image.Sample(def_sampler, frag_in.uuvv.xz).rgb;
|
|
|
|
float3 rgb_topright = image.Sample(def_sampler, frag_in.uuvv.yz).rgb;
|
|
|
|
float3 rgb_bottomleft = image.Sample(def_sampler, frag_in.uuvv.xw).rgb;
|
|
|
|
float3 rgb_bottomright = image.Sample(def_sampler, frag_in.uuvv.yw).rgb;
|
|
|
|
float3 rgb = (rgb_topleft + rgb_topright + rgb_bottomleft + rgb_bottomright) * (0.25 * sdr_white_nits_over_maximum);
|
|
|
|
rgb = rec709_to_rec2020(rgb);
|
2022-04-10 12:31:08 -07:00
|
|
|
rgb = linear_to_hlg(rgb, hlg_lw);
|
2022-04-03 00:00:38 -07:00
|
|
|
float u = dot(color_vec1.xyz, rgb) + color_vec1.w;
|
|
|
|
return u * (1023. / 65535.);
|
|
|
|
}
|
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
float PS_I010_SRGB_U_WideWide(FragTexWideWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb_topleft = image.Sample(def_sampler, frag_in.uuvv.xz).rgb;
|
|
|
|
float3 rgb_topright = image.Sample(def_sampler, frag_in.uuvv.yz).rgb;
|
|
|
|
float3 rgb_bottomleft = image.Sample(def_sampler, frag_in.uuvv.xw).rgb;
|
|
|
|
float3 rgb_bottomright = image.Sample(def_sampler, frag_in.uuvv.yw).rgb;
|
|
|
|
float3 rgb = (rgb_topleft + rgb_topright + rgb_bottomleft + rgb_bottomright) * 0.25;
|
|
|
|
rgb = srgb_linear_to_nonlinear(rgb);
|
|
|
|
float u = dot(color_vec1.xyz, rgb) + color_vec1.w;
|
|
|
|
return u * (1023. / 65535.);
|
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
float PS_I010_PQ_V_709_2020_WideWide(FragTexWideWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb_topleft = image.Sample(def_sampler, frag_in.uuvv.xz).rgb;
|
|
|
|
float3 rgb_topright = image.Sample(def_sampler, frag_in.uuvv.yz).rgb;
|
|
|
|
float3 rgb_bottomleft = image.Sample(def_sampler, frag_in.uuvv.xw).rgb;
|
|
|
|
float3 rgb_bottomright = image.Sample(def_sampler, frag_in.uuvv.yw).rgb;
|
|
|
|
float3 rgb = (rgb_topleft + rgb_topright + rgb_bottomleft + rgb_bottomright) * (0.25 * sdr_white_nits_over_maximum);
|
|
|
|
rgb = rec709_to_rec2020(rgb);
|
|
|
|
rgb = linear_to_st2084(rgb);
|
|
|
|
float v = dot(color_vec2.xyz, rgb) + color_vec2.w;
|
|
|
|
return v * (1023. / 65535.);
|
|
|
|
}
|
|
|
|
|
|
|
|
float PS_I010_HLG_V_709_2020_WideWide(FragTexWideWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb_topleft = image.Sample(def_sampler, frag_in.uuvv.xz).rgb;
|
|
|
|
float3 rgb_topright = image.Sample(def_sampler, frag_in.uuvv.yz).rgb;
|
|
|
|
float3 rgb_bottomleft = image.Sample(def_sampler, frag_in.uuvv.xw).rgb;
|
|
|
|
float3 rgb_bottomright = image.Sample(def_sampler, frag_in.uuvv.yw).rgb;
|
|
|
|
float3 rgb = (rgb_topleft + rgb_topright + rgb_bottomleft + rgb_bottomright) * (0.25 * sdr_white_nits_over_maximum);
|
|
|
|
rgb = rec709_to_rec2020(rgb);
|
2022-04-10 12:31:08 -07:00
|
|
|
rgb = linear_to_hlg(rgb, hlg_lw);
|
2022-04-03 00:00:38 -07:00
|
|
|
float v = dot(color_vec2.xyz, rgb) + color_vec2.w;
|
|
|
|
return v * (1023. / 65535.);
|
|
|
|
}
|
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
float PS_I010_SRGB_V_WideWide(FragTexWideWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float3 rgb_topleft = image.Sample(def_sampler, frag_in.uuvv.xz).rgb;
|
|
|
|
float3 rgb_topright = image.Sample(def_sampler, frag_in.uuvv.yz).rgb;
|
|
|
|
float3 rgb_bottomleft = image.Sample(def_sampler, frag_in.uuvv.xw).rgb;
|
|
|
|
float3 rgb_bottomright = image.Sample(def_sampler, frag_in.uuvv.yw).rgb;
|
|
|
|
float3 rgb = (rgb_topleft + rgb_topright + rgb_bottomleft + rgb_bottomright) * 0.25;
|
|
|
|
rgb = srgb_linear_to_nonlinear(rgb);
|
|
|
|
float v = dot(color_vec2.xyz, rgb) + color_vec2.w;
|
|
|
|
return v * (1023. / 65535.);
|
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 YUV_to_RGB(float3 yuv)
|
2017-05-06 01:22:51 -07:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
yuv = clamp(yuv, color_range_min, color_range_max);
|
|
|
|
float r = dot(color_vec0.xyz, yuv) + color_vec0.w;
|
|
|
|
float g = dot(color_vec1.xyz, yuv) + color_vec1.w;
|
|
|
|
float b = dot(color_vec2.xyz, yuv) + color_vec2.w;
|
|
|
|
return float3(r, g, b);
|
2017-05-06 01:22:51 -07:00
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 PSUYVY_Reverse(FragTex frag_in) : TARGET
|
2014-04-23 20:56:44 -07:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
float4 y2uv = image.Load(int3(frag_in.uv.xy, 0));
|
|
|
|
float2 y01 = y2uv.yw;
|
|
|
|
float2 cbcr = y2uv.zx;
|
|
|
|
float leftover = frac(frag_in.uv.x);
|
|
|
|
float y = (leftover < 0.5) ? y01.x : y01.y;
|
|
|
|
float3 yuv = float3(y, cbcr);
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
return rgb;
|
2014-04-23 20:56:44 -07:00
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 PSYUY2_Reverse(FragTex frag_in) : TARGET
|
2014-05-30 02:13:32 -07:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
float4 y2uv = image.Load(int3(frag_in.uv.xy, 0));
|
|
|
|
float2 y01 = y2uv.zx;
|
|
|
|
float2 cbcr = y2uv.yw;
|
|
|
|
float leftover = frac(frag_in.uv.x);
|
|
|
|
float y = (leftover < 0.5) ? y01.x : y01.y;
|
|
|
|
float3 yuv = float3(y, cbcr);
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
return rgb;
|
2019-04-02 09:03:57 -07:00
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 PSYVYU_Reverse(FragTex frag_in) : TARGET
|
2019-06-17 22:25:18 -07:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
float4 y2uv = image.Load(int3(frag_in.uv.xy, 0));
|
|
|
|
float2 y01 = y2uv.zx;
|
|
|
|
float2 cbcr = y2uv.wy;
|
|
|
|
float leftover = frac(frag_in.uv.x);
|
|
|
|
float y = (leftover < 0.5) ? y01.x : y01.y;
|
|
|
|
float3 yuv = float3(y, cbcr);
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
return rgb;
|
2019-06-17 22:25:18 -07:00
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 PSPlanar420_Reverse(VertTexPos frag_in) : TARGET
|
2019-04-02 09:03:57 -07:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
float y = image.Load(int3(frag_in.pos.xy, 0)).x;
|
|
|
|
int3 xy0_chroma = int3(frag_in.uv, 0);
|
|
|
|
float cb = image1.Load(xy0_chroma).x;
|
|
|
|
float cr = image2.Load(xy0_chroma).x;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
return rgb;
|
2014-05-30 02:13:32 -07:00
|
|
|
}
|
2014-04-23 20:56:44 -07:00
|
|
|
|
2019-08-11 11:26:22 -07:00
|
|
|
float4 PSPlanar420A_Reverse(VertTexPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
int3 xy0_luma = int3(frag_in.pos.xy, 0);
|
|
|
|
float y = image.Load(xy0_luma).x;
|
|
|
|
int3 xy0_chroma = int3(frag_in.uv, 0);
|
|
|
|
float cb = image1.Load(xy0_chroma).x;
|
|
|
|
float cr = image2.Load(xy0_chroma).x;
|
|
|
|
float alpha = image3.Load(xy0_luma).x;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
float4 rgba = float4(YUV_to_RGB(yuv), alpha);
|
|
|
|
return rgba;
|
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 PSPlanar422_Reverse(FragPosWide frag_in) : TARGET
|
2014-12-18 11:37:46 -08:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
float y = image.Load(int3(frag_in.pos_wide.xz, 0)).x;
|
|
|
|
int3 xy0_chroma = int3(frag_in.pos_wide.yz, 0);
|
|
|
|
float cb = image1.Load(xy0_chroma).x;
|
|
|
|
float cr = image2.Load(xy0_chroma).x;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
return rgb;
|
2014-12-18 11:37:46 -08:00
|
|
|
}
|
|
|
|
|
2022-04-19 10:37:07 -07:00
|
|
|
float4 PSPlanar422_10LE_Reverse(FragPosWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float y = image.Load(int3(frag_in.pos_wide.xz, 0)).x;
|
|
|
|
int3 xy0_chroma = int3(frag_in.pos_wide.yz, 0);
|
|
|
|
float cb = image1.Load(xy0_chroma).x;
|
|
|
|
float cr = image2.Load(xy0_chroma).x;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
yuv *= 65535. / 1023.;
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
rgb = srgb_nonlinear_to_linear(rgb);
|
|
|
|
return float4(rgb, 1.0);
|
|
|
|
}
|
|
|
|
|
2019-08-11 11:26:22 -07:00
|
|
|
float4 PSPlanar422A_Reverse(FragPosWide frag_in) : TARGET
|
|
|
|
{
|
|
|
|
int3 xy0_luma = int3(frag_in.pos_wide.xz, 0);
|
|
|
|
float y = image.Load(xy0_luma).x;
|
|
|
|
int3 xy0_chroma = int3(frag_in.pos_wide.yz, 0);
|
|
|
|
float cb = image1.Load(xy0_chroma).x;
|
|
|
|
float cr = image2.Load(xy0_chroma).x;
|
|
|
|
float alpha = image3.Load(xy0_luma).x;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
float4 rgba = float4(YUV_to_RGB(yuv), alpha);
|
|
|
|
return rgba;
|
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 PSPlanar444_Reverse(FragPos frag_in) : TARGET
|
2019-04-22 23:38:26 -07:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
int3 xy0 = int3(frag_in.pos.xy, 0);
|
|
|
|
float y = image.Load(xy0).x;
|
|
|
|
float cb = image1.Load(xy0).x;
|
|
|
|
float cr = image2.Load(xy0).x;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
return rgb;
|
2019-04-22 23:38:26 -07:00
|
|
|
}
|
|
|
|
|
2022-04-19 10:37:07 -07:00
|
|
|
float4 PSPlanar444_12LE_Reverse(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
int3 xy0 = int3(frag_in.pos.xy, 0);
|
|
|
|
float y = image.Load(xy0).x;
|
|
|
|
float cb = image1.Load(xy0).x;
|
|
|
|
float cr = image2.Load(xy0).x;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
yuv *= 65535. / 4095.;
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
rgb = srgb_nonlinear_to_linear(rgb);
|
|
|
|
return float4(rgb, 1.0);
|
|
|
|
}
|
|
|
|
|
2019-08-11 11:26:22 -07:00
|
|
|
float4 PSPlanar444A_Reverse(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
int3 xy0 = int3(frag_in.pos.xy, 0);
|
|
|
|
float y = image.Load(xy0).x;
|
|
|
|
float cb = image1.Load(xy0).x;
|
|
|
|
float cr = image2.Load(xy0).x;
|
|
|
|
float alpha = image3.Load(xy0).x;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
float4 rgba = float4(YUV_to_RGB(yuv), alpha);
|
|
|
|
return rgba;
|
|
|
|
}
|
|
|
|
|
2022-04-19 10:37:07 -07:00
|
|
|
float4 PSPlanar444A_12LE_Reverse(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
int3 xy0 = int3(frag_in.pos.xy, 0);
|
|
|
|
float y = image.Load(xy0).x;
|
|
|
|
float cb = image1.Load(xy0).x;
|
|
|
|
float cr = image2.Load(xy0).x;
|
|
|
|
float alpha = image3.Load(xy0).x * 16.;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
yuv *= 65535. / 4095.;
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
rgb = srgb_nonlinear_to_linear(rgb);
|
|
|
|
return float4(rgb, alpha);
|
|
|
|
}
|
|
|
|
|
2019-08-11 11:26:22 -07:00
|
|
|
float4 PSAYUV_Reverse(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float4 yuva = image.Load(int3(frag_in.pos.xy, 0));
|
|
|
|
float4 rgba = float4(YUV_to_RGB(yuva.xyz), yuva.a);
|
|
|
|
return rgba;
|
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 PSNV12_Reverse(VertTexPos frag_in) : TARGET
|
2019-04-22 23:38:26 -07:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
float y = image.Load(int3(frag_in.pos.xy, 0)).x;
|
|
|
|
float2 cbcr = image1.Load(int3(frag_in.uv, 0)).xy;
|
|
|
|
float3 yuv = float3(y, cbcr);
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
return rgb;
|
|
|
|
}
|
2019-04-22 23:38:26 -07:00
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
float4 PSI010_SRGB_Reverse(VertTexPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float ratio = 65535. / 1023.;
|
|
|
|
float y = image.Load(int3(frag_in.pos.xy, 0)).x * ratio;
|
|
|
|
int3 xy0_chroma = int3(frag_in.uv, 0);
|
|
|
|
float cb = image1.Load(xy0_chroma).x * ratio;
|
|
|
|
float cr = image2.Load(xy0_chroma).x * ratio;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
rgb = srgb_nonlinear_to_linear(rgb);
|
|
|
|
return float4(rgb, 1.0);
|
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
float4 PSI010_PQ_2020_709_Reverse(VertTexPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float ratio = 65535. / 1023.;
|
|
|
|
float y = image.Load(int3(frag_in.pos.xy, 0)).x * ratio;
|
|
|
|
int3 xy0_chroma = int3(frag_in.uv, 0);
|
|
|
|
float cb = image1.Load(xy0_chroma).x * ratio;
|
|
|
|
float cr = image2.Load(xy0_chroma).x * ratio;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
float3 pq = YUV_to_RGB(yuv);
|
|
|
|
float3 hdr2020 = st2084_to_linear(pq) * maximum_over_sdr_white_nits;
|
|
|
|
float3 rgb = rec2020_to_rec709(hdr2020);
|
|
|
|
return float4(rgb, 1.0);
|
|
|
|
}
|
|
|
|
|
|
|
|
float4 PSI010_HLG_2020_709_Reverse(VertTexPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float ratio = 65535. / 1023.;
|
|
|
|
float y = image.Load(int3(frag_in.pos.xy, 0)).x * ratio;
|
|
|
|
int3 xy0_chroma = int3(frag_in.uv, 0);
|
|
|
|
float cb = image1.Load(xy0_chroma).x * ratio;
|
|
|
|
float cr = image2.Load(xy0_chroma).x * ratio;
|
|
|
|
float3 yuv = float3(y, cb, cr);
|
|
|
|
float3 hlg = YUV_to_RGB(yuv);
|
2022-04-10 12:31:08 -07:00
|
|
|
float3 hdr2020 = hlg_to_linear(hlg, hlg_exponent) * maximum_over_sdr_white_nits;
|
2022-04-03 00:00:38 -07:00
|
|
|
float3 rgb = rec2020_to_rec709(hdr2020);
|
|
|
|
return float4(rgb, 1.0);
|
|
|
|
}
|
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
float4 PSP010_SRGB_Reverse(VertTexPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float y = image.Load(int3(frag_in.pos.xy, 0)).x;
|
|
|
|
float2 cbcr = image1.Load(int3(frag_in.uv, 0)).xy;
|
|
|
|
float3 yuv = float3(y, cbcr);
|
|
|
|
float3 rgb = YUV_to_RGB(yuv);
|
|
|
|
rgb = srgb_nonlinear_to_linear(rgb);
|
|
|
|
return float4(rgb, 1.0);
|
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
float4 PSP010_PQ_2020_709_Reverse(VertTexPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float y = image.Load(int3(frag_in.pos.xy, 0)).x;
|
|
|
|
float2 cbcr = image1.Load(int3(frag_in.uv, 0)).xy;
|
|
|
|
float3 yuv = float3(y, cbcr);
|
|
|
|
float3 pq = YUV_to_RGB(yuv);
|
|
|
|
float3 hdr2020 = st2084_to_linear(pq) * maximum_over_sdr_white_nits;
|
|
|
|
float3 rgb = rec2020_to_rec709(hdr2020);
|
|
|
|
return float4(rgb, 1.0);
|
|
|
|
}
|
|
|
|
|
|
|
|
float4 PSP010_HLG_2020_709_Reverse(VertTexPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float y = image.Load(int3(frag_in.pos.xy, 0)).x;
|
|
|
|
float2 cbcr = image1.Load(int3(frag_in.uv, 0)).xy;
|
|
|
|
float3 yuv = float3(y, cbcr);
|
|
|
|
float3 hlg = YUV_to_RGB(yuv);
|
2022-04-10 12:31:08 -07:00
|
|
|
float3 hdr2020 = hlg_to_linear(hlg, hlg_exponent) * maximum_over_sdr_white_nits;
|
2022-04-03 00:00:38 -07:00
|
|
|
float3 rgb = rec2020_to_rec709(hdr2020);
|
|
|
|
return float4(rgb, 1.0);
|
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 PSY800_Limited(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float limited = image.Load(int3(frag_in.pos.xy, 0)).x;
|
|
|
|
float full = (255.0 / 219.0) * limited - (16.0 / 219.0);
|
|
|
|
return float3(full, full, full);
|
2019-04-22 23:38:26 -07:00
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 PSY800_Full(FragPos frag_in) : TARGET
|
2019-04-22 23:38:26 -07:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 full = image.Load(int3(frag_in.pos.xy, 0)).xxx;
|
|
|
|
return full;
|
|
|
|
}
|
2019-04-22 23:38:26 -07:00
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float4 PSRGB_Limited(FragPos frag_in) : TARGET
|
|
|
|
{
|
|
|
|
float4 rgba = image.Load(int3(frag_in.pos.xy, 0));
|
|
|
|
rgba.rgb = (255.0 / 219.0) * rgba.rgb - (16.0 / 219.0);
|
2019-04-22 23:38:26 -07:00
|
|
|
return rgba;
|
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 PSBGR3_Limited(FragPos frag_in) : TARGET
|
2019-05-30 06:05:53 -07:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
float x = frag_in.pos.x * 3.0;
|
|
|
|
float y = frag_in.pos.y;
|
|
|
|
float b = image.Load(int3(x - 1.0, y, 0)).x;
|
2019-05-30 06:05:53 -07:00
|
|
|
float g = image.Load(int3(x, y, 0)).x;
|
2019-08-09 20:43:14 -07:00
|
|
|
float r = image.Load(int3(x + 1.0, y, 0)).x;
|
2019-05-30 06:05:53 -07:00
|
|
|
float3 rgb = float3(r, g, b);
|
2019-08-09 20:43:14 -07:00
|
|
|
rgb = (255.0 / 219.0) * rgb - (16.0 / 219.0);
|
|
|
|
return rgb;
|
2019-05-30 06:05:53 -07:00
|
|
|
}
|
|
|
|
|
2019-08-09 20:43:14 -07:00
|
|
|
float3 PSBGR3_Full(FragPos frag_in) : TARGET
|
2019-05-30 06:05:53 -07:00
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
float x = frag_in.pos.x * 3.0;
|
|
|
|
float y = frag_in.pos.y;
|
|
|
|
float b = image.Load(int3(x - 1.0, y, 0)).x;
|
2019-05-30 06:05:53 -07:00
|
|
|
float g = image.Load(int3(x, y, 0)).x;
|
2019-08-09 20:43:14 -07:00
|
|
|
float r = image.Load(int3(x + 1.0, y, 0)).x;
|
2019-05-30 06:05:53 -07:00
|
|
|
float3 rgb = float3(r, g, b);
|
2019-08-09 20:43:14 -07:00
|
|
|
return rgb;
|
2019-05-30 06:05:53 -07:00
|
|
|
}
|
|
|
|
|
2019-07-26 23:21:41 -07:00
|
|
|
technique Planar_Y
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPos(id);
|
|
|
|
pixel_shader = PS_Y(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique Planar_U
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSPos(id);
|
2019-07-26 23:21:41 -07:00
|
|
|
pixel_shader = PS_U(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique Planar_V
|
2014-02-16 18:28:21 -08:00
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSPos(id);
|
2019-07-26 23:21:41 -07:00
|
|
|
pixel_shader = PS_V(frag_in);
|
2014-02-16 18:28:21 -08:00
|
|
|
}
|
|
|
|
}
|
2014-04-04 11:49:23 -07:00
|
|
|
|
2019-07-26 23:21:41 -07:00
|
|
|
technique Planar_U_Left
|
2015-04-16 22:43:46 -07:00
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSTexPos_Left(id);
|
2019-07-26 23:21:41 -07:00
|
|
|
pixel_shader = PS_U_Wide(frag_in);
|
2015-04-16 22:43:46 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-26 23:21:41 -07:00
|
|
|
technique Planar_V_Left
|
2014-04-04 11:49:23 -07:00
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSTexPos_Left(id);
|
2019-07-26 23:21:41 -07:00
|
|
|
pixel_shader = PS_V_Wide(frag_in);
|
2014-04-04 11:49:23 -07:00
|
|
|
}
|
|
|
|
}
|
2014-04-23 20:56:44 -07:00
|
|
|
|
2018-10-05 20:18:15 -07:00
|
|
|
technique NV12_Y
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
vertex_shader = VSPos(id);
|
2019-07-26 23:21:41 -07:00
|
|
|
pixel_shader = PS_Y(frag_in);
|
2018-10-05 20:18:15 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique NV12_UV
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSTexPos_Left(id);
|
2019-07-26 23:21:41 -07:00
|
|
|
pixel_shader = PS_UV_Wide(frag_in);
|
2018-10-05 20:18:15 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
technique I010_PQ_Y
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPos(id);
|
|
|
|
pixel_shader = PS_I010_PQ_Y_709_2020(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique I010_HLG_Y
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPos(id);
|
|
|
|
pixel_shader = PS_I010_HLG_Y_709_2020(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
technique I010_SRGB_Y
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPos(id);
|
|
|
|
pixel_shader = PS_I010_SRGB_Y(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
technique I010_PQ_U
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPos_TopLeft(id);
|
|
|
|
pixel_shader = PS_I010_PQ_U_709_2020_WideWide(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique I010_HLG_U
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPos_TopLeft(id);
|
|
|
|
pixel_shader = PS_I010_HLG_U_709_2020_WideWide(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
technique I010_SRGB_U
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPos_TopLeft(id);
|
|
|
|
pixel_shader = PS_I010_SRGB_U_WideWide(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
technique I010_PQ_V
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPos_TopLeft(id);
|
|
|
|
pixel_shader = PS_I010_PQ_V_709_2020_WideWide(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique I010_HLG_V
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPos_TopLeft(id);
|
|
|
|
pixel_shader = PS_I010_HLG_V_709_2020_WideWide(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
technique I010_SRGB_V
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPos_TopLeft(id);
|
|
|
|
pixel_shader = PS_I010_SRGB_V_WideWide(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
technique P010_PQ_Y
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPos(id);
|
|
|
|
pixel_shader = PS_PQ_Y_709_2020(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique P010_HLG_Y
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPos(id);
|
|
|
|
pixel_shader = PS_HLG_Y_709_2020(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
technique P010_SRGB_Y
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPos(id);
|
|
|
|
pixel_shader = PS_SRGB_Y(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
technique P010_PQ_UV
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPos_TopLeft(id);
|
|
|
|
pixel_shader = PS_PQ_UV_709_2020_WideWide(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique P010_HLG_UV
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPos_TopLeft(id);
|
|
|
|
pixel_shader = PS_HLG_UV_709_2020_WideWide(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
technique P010_SRGB_UV
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPos_TopLeft(id);
|
|
|
|
pixel_shader = PS_SRGB_UV_WideWide(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-02 07:38:20 -07:00
|
|
|
technique UYVY_Reverse
|
2014-04-23 20:56:44 -07:00
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSTexPosHalf_Reverse(id);
|
|
|
|
pixel_shader = PSUYVY_Reverse(frag_in);
|
2014-04-23 20:56:44 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique YUY2_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSTexPosHalf_Reverse(id);
|
|
|
|
pixel_shader = PSYUY2_Reverse(frag_in);
|
2014-04-23 20:56:44 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique YVYU_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSTexPosHalf_Reverse(id);
|
|
|
|
pixel_shader = PSYVYU_Reverse(frag_in);
|
2014-04-23 20:56:44 -07:00
|
|
|
}
|
|
|
|
}
|
2014-05-30 02:13:32 -07:00
|
|
|
|
|
|
|
technique I420_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSTexPosHalfHalf_Reverse(id);
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
pixel_shader = PSPlanar420_Reverse(frag_in);
|
2014-05-30 02:13:32 -07:00
|
|
|
}
|
|
|
|
}
|
2014-12-18 11:37:46 -08:00
|
|
|
|
2019-08-11 11:26:22 -07:00
|
|
|
technique I40A_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPosHalfHalf_Reverse(id);
|
|
|
|
pixel_shader = PSPlanar420A_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-17 22:25:18 -07:00
|
|
|
technique I422_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSPosWide_Reverse(id);
|
2019-06-17 22:25:18 -07:00
|
|
|
pixel_shader = PSPlanar422_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-19 10:37:07 -07:00
|
|
|
technique I210_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPosWide_Reverse(id);
|
|
|
|
pixel_shader = PSPlanar422_10LE_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-11 11:26:22 -07:00
|
|
|
technique I42A_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPosWide_Reverse(id);
|
|
|
|
pixel_shader = PSPlanar422A_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-02 09:03:57 -07:00
|
|
|
technique I444_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSPos(id);
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
pixel_shader = PSPlanar444_Reverse(frag_in);
|
2019-04-02 09:03:57 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-19 10:37:07 -07:00
|
|
|
technique I412_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPos(id);
|
|
|
|
pixel_shader = PSPlanar444_12LE_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-11 11:26:22 -07:00
|
|
|
technique YUVA_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPos(id);
|
|
|
|
pixel_shader = PSPlanar444A_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-19 10:37:07 -07:00
|
|
|
technique YA2L_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPos(id);
|
|
|
|
pixel_shader = PSPlanar444A_12LE_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-11 11:26:22 -07:00
|
|
|
technique AYUV_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSPos(id);
|
|
|
|
pixel_shader = PSAYUV_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-18 11:37:46 -08:00
|
|
|
technique NV12_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSTexPosHalfHalf_Reverse(id);
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
pixel_shader = PSNV12_Reverse(frag_in);
|
2014-12-18 11:37:46 -08:00
|
|
|
}
|
|
|
|
}
|
2019-04-22 23:38:26 -07:00
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
technique I010_SRGB_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPosHalfHalf_Reverse(id);
|
|
|
|
pixel_shader = PSI010_SRGB_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
technique I010_PQ_2020_709_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPosHalfHalf_Reverse(id);
|
|
|
|
pixel_shader = PSI010_PQ_2020_709_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique I010_HLG_2020_709_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPosHalfHalf_Reverse(id);
|
|
|
|
pixel_shader = PSI010_HLG_2020_709_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-30 22:39:53 -07:00
|
|
|
technique P010_SRGB_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPosHalfHalf_Reverse(id);
|
|
|
|
pixel_shader = PSP010_SRGB_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-03 00:00:38 -07:00
|
|
|
technique P010_PQ_2020_709_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPosHalfHalf_Reverse(id);
|
|
|
|
pixel_shader = PSP010_PQ_2020_709_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique P010_HLG_2020_709_Reverse
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
|
|
|
vertex_shader = VSTexPosHalfHalf_Reverse(id);
|
|
|
|
pixel_shader = PSP010_HLG_2020_709_Reverse(frag_in);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-22 23:38:26 -07:00
|
|
|
technique Y800_Limited
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSPos(id);
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
pixel_shader = PSY800_Limited(frag_in);
|
2019-04-22 23:38:26 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique Y800_Full
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSPos(id);
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
pixel_shader = PSY800_Full(frag_in);
|
2019-04-22 23:38:26 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique RGB_Limited
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSPos(id);
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
pixel_shader = PSRGB_Limited(frag_in);
|
2019-04-22 23:38:26 -07:00
|
|
|
}
|
|
|
|
}
|
2019-05-30 06:05:53 -07:00
|
|
|
|
|
|
|
technique BGR3_Limited
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSPos(id);
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
pixel_shader = PSBGR3_Limited(frag_in);
|
2019-05-30 06:05:53 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique BGR3_Full
|
|
|
|
{
|
|
|
|
pass
|
|
|
|
{
|
2019-08-09 20:43:14 -07:00
|
|
|
vertex_shader = VSPos(id);
|
libobs: Rework RGB to YUV conversion
RGB to YUV converison was previously baked into every scale shader, but
this work has been moved to the YUV packing shaders. The scale shaders
now write RGBA instead. In the case where base and output resolutions
are identical, the render texture is forwarded directly to the YUV pack
step, skipping an entire fullscreen pass.
Intel GPA, SetStablePowerState, Intel HD Graphics 530, NV12
1920x1080, Before:
RGBA -> UYVX: ~321 us
UYVX -> Y: ~480 us
UYVX -> UV: ~127 us
1920x1080, After:
[forward render texture]
RGBA -> Y: ~487 us
RGBA -> UV: ~131 us
1920x1080 -> 1280x720, Before:
RGBA -> UYVX: ~268 us
UYVX -> Y: ~209 us
UYVX -> UV: ~57 us
1920x1080 -> 1280x720, After:
RGBA -> RGBA (rescale): ~268 us
RGBA -> Y: ~210 us
RGBA -> UV: ~58 us
2019-07-22 01:12:35 -07:00
|
|
|
pixel_shader = PSBGR3_Full(frag_in);
|
2019-05-30 06:05:53 -07:00
|
|
|
}
|
|
|
|
}
|