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/>.
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
//#define DEBUGGING
|
|
|
|
|
|
|
|
uniform float u_plane_offset;
|
|
|
|
uniform float v_plane_offset;
|
|
|
|
|
|
|
|
uniform float width;
|
|
|
|
uniform float height;
|
|
|
|
uniform float width_i;
|
|
|
|
uniform float height_i;
|
|
|
|
uniform float width_d2;
|
|
|
|
uniform float height_d2;
|
|
|
|
uniform float width_d2_i;
|
|
|
|
uniform float height_d2_i;
|
2014-05-30 02:13:32 -07:00
|
|
|
uniform float input_width;
|
2014-02-16 18:28:21 -08:00
|
|
|
uniform float input_height;
|
2014-05-30 02:13:32 -07:00
|
|
|
uniform float input_width_i;
|
|
|
|
uniform float input_height_i;
|
|
|
|
uniform float input_width_i_d2;
|
|
|
|
uniform float input_height_i_d2;
|
2014-02-16 18:28:21 -08:00
|
|
|
|
2017-05-06 01:22:51 -07:00
|
|
|
uniform int int_width;
|
|
|
|
uniform int int_input_width;
|
|
|
|
uniform int int_u_plane_offset;
|
|
|
|
uniform int int_v_plane_offset;
|
|
|
|
|
2019-04-02 09:03:57 -07:00
|
|
|
uniform float4x4 color_matrix;
|
|
|
|
uniform float3 color_range_min = {0.0, 0.0, 0.0};
|
|
|
|
uniform float3 color_range_max = {1.0, 1.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
|
|
|
uniform float4 color_vec_y;
|
|
|
|
uniform float4 color_vec_u;
|
|
|
|
uniform float4 color_vec_v;
|
|
|
|
|
2014-02-16 18:28:21 -08:00
|
|
|
uniform texture2d image;
|
|
|
|
|
|
|
|
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
|
|
|
};
|
|
|
|
|
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 {
|
|
|
|
float2 uv : TEXCOORD0;
|
|
|
|
};
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
VertTexPos VSPosTex(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-06-02 06:49:38 -07:00
|
|
|
vert_out.uv = float2(u, 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;
|
|
|
|
}
|
|
|
|
|
2014-02-17 08:28:27 -08:00
|
|
|
/* used to prevent internal GPU precision issues width fmod in particular */
|
2014-12-09 13:33:16 -08:00
|
|
|
#define PRECISION_OFFSET 0.2
|
2014-02-17 08:28:27 -08: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
|
|
|
float4 PSNV12(FragTex frag_in) : TARGET
|
2014-04-04 11:49:23 -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
|
|
|
float v_mul = floor(frag_in.uv.y * input_height);
|
2014-04-04 11:49:23 -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
|
|
|
float byte_offset = floor((v_mul + frag_in.uv.x) * width) * 4.0;
|
2014-04-04 11:49:23 -07:00
|
|
|
byte_offset += PRECISION_OFFSET;
|
|
|
|
|
|
|
|
if (byte_offset < u_plane_offset) {
|
|
|
|
#ifdef DEBUGGING
|
|
|
|
return float4(1.0, 1.0, 1.0, 1.0);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
float lum_u = floor(fmod(byte_offset, width)) * width_i;
|
|
|
|
float lum_v = floor(byte_offset * width_i) * height_i;
|
|
|
|
|
|
|
|
/* move to texel centers to sample the 4 pixels properly */
|
|
|
|
lum_u += width_i * 0.5;
|
|
|
|
lum_v += height_i * 0.5;
|
|
|
|
|
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
|
|
|
float2 sample_pos0 = float2(lum_u, lum_v);
|
|
|
|
float2 sample_pos1 = float2(lum_u += width_i, lum_v);
|
|
|
|
float2 sample_pos2 = float2(lum_u += width_i, lum_v);
|
|
|
|
float2 sample_pos3 = float2(lum_u + width_i, lum_v);
|
|
|
|
|
|
|
|
float3 rgb0 = image.Sample(def_sampler, sample_pos0).rgb;
|
|
|
|
float3 rgb1 = image.Sample(def_sampler, sample_pos1).rgb;
|
|
|
|
float3 rgb2 = image.Sample(def_sampler, sample_pos2).rgb;
|
|
|
|
float3 rgb3 = image.Sample(def_sampler, sample_pos3).rgb;
|
|
|
|
|
|
|
|
float4 out_val = float4(
|
|
|
|
dot(color_vec_y.xyz, rgb0) + color_vec_y.w,
|
|
|
|
dot(color_vec_y.xyz, rgb1) + color_vec_y.w,
|
|
|
|
dot(color_vec_y.xyz, rgb2) + color_vec_y.w,
|
|
|
|
dot(color_vec_y.xyz, rgb3) + color_vec_y.w
|
2014-04-04 11:49:23 -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
|
|
|
return out_val;
|
2014-04-04 11:49:23 -07:00
|
|
|
} else {
|
|
|
|
#ifdef DEBUGGING
|
|
|
|
return float4(0.5, 0.2, 0.5, 0.2);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
float new_offset = byte_offset - u_plane_offset;
|
|
|
|
|
|
|
|
float ch_u = floor(fmod(new_offset, width)) * width_i;
|
|
|
|
float ch_v = floor(new_offset * width_i) * height_d2_i;
|
|
|
|
float width_i2 = width_i*2.0;
|
|
|
|
|
|
|
|
/* move to the borders of each set of 4 pixels to force it
|
|
|
|
* to do bilinear averaging */
|
|
|
|
ch_u += width_i;
|
|
|
|
ch_v += height_i;
|
|
|
|
|
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
|
|
|
float2 sample_pos0 = float2(ch_u, ch_v);
|
|
|
|
float2 sample_pos1 = float2(ch_u + width_i2, ch_v);
|
|
|
|
|
|
|
|
float3 rgb0 = image.Sample(def_sampler, sample_pos0).rgb;
|
|
|
|
float3 rgb1 = image.Sample(def_sampler, sample_pos1).rgb;
|
|
|
|
|
2014-04-04 11:49:23 -07:00
|
|
|
return float4(
|
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
|
|
|
dot(color_vec_u.xyz, rgb0) + color_vec_u.w,
|
|
|
|
dot(color_vec_v.xyz, rgb0) + color_vec_v.w,
|
|
|
|
dot(color_vec_u.xyz, rgb1) + color_vec_u.w,
|
|
|
|
dot(color_vec_v.xyz, rgb1) + color_vec_v.w
|
|
|
|
);
|
2014-04-04 11:49:23 -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
|
|
|
float PSNV12_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;
|
|
|
|
float y = dot(color_vec_y.xyz, rgb) + color_vec_y.w;
|
|
|
|
return y;
|
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
|
|
|
float2 PSNV12_UV(FragTex 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.Sample(def_sampler, frag_in.uv).rgb;
|
|
|
|
float u = dot(color_vec_u.xyz, rgb) + color_vec_u.w;
|
|
|
|
float v = dot(color_vec_v.xyz, rgb) + color_vec_v.w;
|
|
|
|
return float2(u, v);
|
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
|
|
|
float4 PSPlanar420(FragTex frag_in) : TARGET
|
2014-02-16 18:28:21 -08: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
|
|
|
float v_mul = floor(frag_in.uv.y * input_height);
|
2014-02-16 18:28:21 -08: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
|
|
|
float byte_offset = floor((v_mul + frag_in.uv.x) * width) * 4.0;
|
2014-02-17 08:28:27 -08:00
|
|
|
byte_offset += PRECISION_OFFSET;
|
2014-02-16 18:28:21 -08: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
|
|
|
float2 sample_pos0, sample_pos1, sample_pos2, sample_pos3;
|
2014-02-16 18:28:21 -08:00
|
|
|
|
|
|
|
if (byte_offset < u_plane_offset) {
|
|
|
|
#ifdef DEBUGGING
|
2014-02-17 08:28:27 -08:00
|
|
|
return float4(1.0, 1.0, 1.0, 1.0);
|
2014-02-16 18:28:21 -08:00
|
|
|
#endif
|
|
|
|
|
2014-02-17 08:28:27 -08:00
|
|
|
float lum_u = floor(fmod(byte_offset, width)) * width_i;
|
|
|
|
float lum_v = floor(byte_offset * width_i) * height_i;
|
2014-02-16 18:28:21 -08:00
|
|
|
|
|
|
|
/* move to texel centers to sample the 4 pixels properly */
|
|
|
|
lum_u += width_i * 0.5;
|
|
|
|
lum_v += height_i * 0.5;
|
|
|
|
|
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
|
|
|
sample_pos0 = float2(lum_u, lum_v);
|
|
|
|
sample_pos1 = float2(lum_u += width_i, lum_v);
|
|
|
|
sample_pos2 = float2(lum_u += width_i, lum_v);
|
|
|
|
sample_pos3 = float2(lum_u + width_i, lum_v);
|
2014-02-16 18:28:21 -08:00
|
|
|
|
|
|
|
} else {
|
|
|
|
#ifdef DEBUGGING
|
|
|
|
return ((byte_offset < v_plane_offset) ?
|
2014-02-17 08:28:27 -08:00
|
|
|
float4(0.5, 0.5, 0.5, 0.5) :
|
|
|
|
float4(0.2, 0.2, 0.2, 0.2));
|
2014-02-16 18:28:21 -08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
float new_offset = byte_offset -
|
|
|
|
((byte_offset < v_plane_offset) ?
|
|
|
|
u_plane_offset : v_plane_offset);
|
|
|
|
|
2014-02-17 08:28:27 -08:00
|
|
|
float ch_u = floor(fmod(new_offset, width_d2)) * width_d2_i;
|
|
|
|
float ch_v = floor(new_offset * width_d2_i) * height_d2_i;
|
2014-02-16 18:28:21 -08:00
|
|
|
float width_i2 = width_i*2.0;
|
|
|
|
|
|
|
|
/* move to the borders of each set of 4 pixels to force it
|
|
|
|
* to do bilinear averaging */
|
|
|
|
ch_u += width_i;
|
|
|
|
ch_v += height_i;
|
|
|
|
|
2017-09-13 07:31:23 -07:00
|
|
|
/* set up coordinates for next chroma line, in case
|
|
|
|
* (width / 2) % 4 == 2, i.e. the current set of 4 pixels is split
|
|
|
|
* between the current and the next chroma line; do note that the next
|
|
|
|
* chroma line is two source lines below the current source line */
|
|
|
|
float ch_u_n = 0. + width_i;
|
|
|
|
float ch_v_n = ch_v + height_i * 3;
|
|
|
|
|
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
|
|
|
sample_pos0 = float2(ch_u, ch_v);
|
|
|
|
sample_pos1 = float2(ch_u += width_i2, ch_v);
|
2017-09-13 07:31:23 -07:00
|
|
|
|
|
|
|
ch_u += width_i2;
|
|
|
|
// check if ch_u overflowed the current source and chroma line
|
|
|
|
if (ch_u > 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
|
|
|
sample_pos2 = float2(ch_u_n, ch_v_n);
|
|
|
|
sample_pos2 = float2(ch_u_n + width_i2, ch_v_n);
|
2017-09-13 07:31:23 -07:00
|
|
|
} else {
|
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
|
|
|
sample_pos2 = float2(ch_u, ch_v);
|
|
|
|
sample_pos3 = float2(ch_u + width_i2, ch_v);
|
2017-09-13 07:31:23 -07:00
|
|
|
}
|
2014-02-16 18:28:21 -08: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 rgb0 = image.Sample(def_sampler, sample_pos0).rgb;
|
|
|
|
float3 rgb1 = image.Sample(def_sampler, sample_pos1).rgb;
|
|
|
|
float3 rgb2 = image.Sample(def_sampler, sample_pos2).rgb;
|
|
|
|
float3 rgb3 = image.Sample(def_sampler, sample_pos3).rgb;
|
2014-02-16 18:28:21 -08: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
|
|
|
float4 color_vec;
|
2014-02-16 18:28:21 -08:00
|
|
|
if (byte_offset < u_plane_offset)
|
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
|
|
|
color_vec = color_vec_y;
|
2014-02-16 18:28:21 -08:00
|
|
|
else if (byte_offset < v_plane_offset)
|
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
|
|
|
color_vec = color_vec_u;
|
2014-02-16 18:28:21 -08:00
|
|
|
else
|
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
|
|
|
color_vec = color_vec_v;
|
|
|
|
|
|
|
|
return float4(
|
|
|
|
dot(color_vec.xyz, rgb0) + color_vec.w,
|
|
|
|
dot(color_vec.xyz, rgb1) + color_vec.w,
|
|
|
|
dot(color_vec.xyz, rgb2) + color_vec.w,
|
|
|
|
dot(color_vec.xyz, rgb3) + color_vec.w
|
|
|
|
);
|
2014-02-16 18:28:21 -08: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
|
|
|
float4 PSPlanar444(FragTex frag_in) : TARGET
|
2015-04-16 22:43:46 -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
|
|
|
float v_mul = floor(frag_in.uv.y * input_height);
|
2015-04-16 22:43:46 -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
|
|
|
float byte_offset = floor((v_mul + frag_in.uv.x) * width) * 4.0;
|
2015-04-16 22:43:46 -07:00
|
|
|
byte_offset += PRECISION_OFFSET;
|
|
|
|
|
|
|
|
float new_byte_offset = byte_offset;
|
|
|
|
|
|
|
|
if (byte_offset >= v_plane_offset)
|
|
|
|
new_byte_offset -= v_plane_offset;
|
|
|
|
else if (byte_offset >= u_plane_offset)
|
|
|
|
new_byte_offset -= u_plane_offset;
|
|
|
|
|
|
|
|
float u_val = floor(fmod(new_byte_offset, width)) * width_i;
|
|
|
|
float v_val = floor(new_byte_offset * width_i) * height_i;
|
|
|
|
|
|
|
|
/* move to texel centers to sample the 4 pixels properly */
|
|
|
|
u_val += width_i * 0.5;
|
|
|
|
v_val += height_i * 0.5;
|
|
|
|
|
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
|
|
|
float2 sample_pos0 = float2(u_val, v_val);
|
|
|
|
float2 sample_pos1 = float2(u_val += width_i, v_val);
|
|
|
|
float2 sample_pos2 = float2(u_val += width_i, v_val);
|
|
|
|
float2 sample_pos3 = float2(u_val + width_i, v_val);
|
2015-04-16 22:43:46 -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 rgb0 = image.Sample(def_sampler, sample_pos0).rgb;
|
|
|
|
float3 rgb1 = image.Sample(def_sampler, sample_pos1).rgb;
|
|
|
|
float3 rgb2 = image.Sample(def_sampler, sample_pos2).rgb;
|
|
|
|
float3 rgb3 = image.Sample(def_sampler, sample_pos3).rgb;
|
2015-04-16 22:43:46 -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
|
|
|
float4 color_vec;
|
2015-04-16 22:43:46 -07:00
|
|
|
if (byte_offset < u_plane_offset)
|
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
|
|
|
color_vec = color_vec_y;
|
2015-04-16 22:43:46 -07:00
|
|
|
else if (byte_offset < v_plane_offset)
|
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
|
|
|
color_vec = color_vec_u;
|
2015-04-16 22:43:46 -07:00
|
|
|
else
|
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
|
|
|
color_vec = color_vec_v;
|
|
|
|
|
|
|
|
return float4(
|
|
|
|
dot(color_vec.xyz, rgb0) + color_vec.w,
|
|
|
|
dot(color_vec.xyz, rgb1) + color_vec.w,
|
|
|
|
dot(color_vec.xyz, rgb2) + color_vec.w,
|
|
|
|
dot(color_vec.xyz, rgb3) + color_vec.w
|
|
|
|
);
|
2015-04-16 22:43:46 -07:00
|
|
|
}
|
|
|
|
|
2017-05-06 01:22:51 -07:00
|
|
|
float GetIntOffsetColor(int offset)
|
|
|
|
{
|
2017-05-06 10:36:37 -07:00
|
|
|
return image.Load(int3(offset % int_input_width,
|
|
|
|
offset / int_input_width,
|
|
|
|
0)).r;
|
2017-05-06 01:22:51 -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
|
|
|
float4 PSPacked422_Reverse(FragTex frag_in, int u_pos, int v_pos,
|
2014-04-23 20:56:44 -07:00
|
|
|
int y0_pos, int y1_pos) : TARGET
|
|
|
|
{
|
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
|
|
|
float y = frag_in.uv.y;
|
|
|
|
float odd = floor(fmod(width * frag_in.uv.x + PRECISION_OFFSET, 2.0));
|
|
|
|
float x = floor(width_d2 * frag_in.uv.x + PRECISION_OFFSET) *
|
2014-04-23 20:56:44 -07:00
|
|
|
width_d2_i;
|
2014-06-02 07:39:08 -07:00
|
|
|
|
|
|
|
x += input_width_i_d2;
|
|
|
|
|
2014-04-23 20:56:44 -07:00
|
|
|
float4 texel = image.Sample(def_sampler, float2(x, y));
|
2019-04-02 09:03:57 -07:00
|
|
|
float3 yuv = float3(odd > 0.5 ? texel[y1_pos] : texel[y0_pos],
|
|
|
|
texel[u_pos], texel[v_pos]);
|
|
|
|
yuv = clamp(yuv, color_range_min, color_range_max);
|
|
|
|
return saturate(mul(float4(yuv, 1.0), color_matrix));
|
2014-04-23 20:56:44 -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
|
|
|
float4 PSPlanar420_Reverse(FragTex frag_in) : TARGET
|
2014-05-30 02:13:32 -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
|
|
|
int x = int(frag_in.uv.x * width + PRECISION_OFFSET);
|
|
|
|
int y = int(frag_in.uv.y * height + PRECISION_OFFSET);
|
2014-04-23 20:56:44 -07:00
|
|
|
|
2017-05-06 01:22:51 -07:00
|
|
|
int lum_offset = y * int_width + x;
|
|
|
|
int chroma_offset = (y / 2) * (int_width / 2) + x / 2;
|
|
|
|
int chroma1 = int_u_plane_offset + chroma_offset;
|
|
|
|
int chroma2 = int_v_plane_offset + chroma_offset;
|
2014-05-30 02:13:32 -07:00
|
|
|
|
2019-04-02 09:03:57 -07:00
|
|
|
float3 yuv = float3(
|
2017-05-06 01:22:51 -07:00
|
|
|
GetIntOffsetColor(lum_offset),
|
|
|
|
GetIntOffsetColor(chroma1),
|
2019-04-02 09:03:57 -07:00
|
|
|
GetIntOffsetColor(chroma2)
|
2014-05-30 02:13:32 -07:00
|
|
|
);
|
2019-04-02 09:03:57 -07:00
|
|
|
yuv = clamp(yuv, color_range_min, color_range_max);
|
|
|
|
return saturate(mul(float4(yuv, 1.0), color_matrix));
|
|
|
|
}
|
|
|
|
|
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 PSPlanar444_Reverse(FragTex frag_in) : TARGET
|
2019-04-02 09:03:57 -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
|
|
|
int x = int(frag_in.uv.x * width + PRECISION_OFFSET);
|
|
|
|
int y = int(frag_in.uv.y * height + PRECISION_OFFSET);
|
2019-04-02 09:03:57 -07:00
|
|
|
|
|
|
|
int lum_offset = y * int_width + x;
|
|
|
|
int chroma_offset = y * int_width + x;
|
|
|
|
int chroma1 = int_u_plane_offset + chroma_offset;
|
|
|
|
int chroma2 = int_v_plane_offset + chroma_offset;
|
|
|
|
|
|
|
|
float3 yuv = float3(
|
|
|
|
GetIntOffsetColor(lum_offset),
|
|
|
|
GetIntOffsetColor(chroma1),
|
|
|
|
GetIntOffsetColor(chroma2)
|
|
|
|
);
|
|
|
|
yuv = clamp(yuv, color_range_min, color_range_max);
|
|
|
|
return saturate(mul(float4(yuv, 1.0), color_matrix));
|
2014-05-30 02:13:32 -07:00
|
|
|
}
|
2014-04-23 20:56:44 -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
|
|
|
float4 PSNV12_Reverse(FragTex frag_in) : TARGET
|
2014-12-18 11:37:46 -08: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
|
|
|
int x = int(frag_in.uv.x * width + PRECISION_OFFSET);
|
|
|
|
int y = int(frag_in.uv.y * height + PRECISION_OFFSET);
|
2014-12-18 11:37:46 -08:00
|
|
|
|
2017-05-06 01:22:51 -07:00
|
|
|
int lum_offset = y * int_width + x;
|
|
|
|
int chroma_offset = (y / 2) * (int_width / 2) + x / 2;
|
|
|
|
int chroma = int_u_plane_offset + chroma_offset * 2;
|
2014-12-18 11:37:46 -08:00
|
|
|
|
2019-04-02 09:03:57 -07:00
|
|
|
float3 yuv = float3(
|
2017-05-06 01:22:51 -07:00
|
|
|
GetIntOffsetColor(lum_offset),
|
|
|
|
GetIntOffsetColor(chroma),
|
2019-04-02 09:03:57 -07:00
|
|
|
GetIntOffsetColor(chroma + 1)
|
2014-12-18 11:37:46 -08:00
|
|
|
);
|
2019-04-02 09:03:57 -07:00
|
|
|
yuv = clamp(yuv, color_range_min, color_range_max);
|
|
|
|
return saturate(mul(float4(yuv, 1.0), color_matrix));
|
2014-12-18 11:37:46 -08: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
|
|
|
float4 PSY800_Limited(FragTex frag_in) : TARGET
|
2019-04-22 23:38:26 -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
|
|
|
int x = int(frag_in.uv.x * width + PRECISION_OFFSET);
|
|
|
|
int y = int(frag_in.uv.y * height + PRECISION_OFFSET);
|
2019-04-22 23:38:26 -07:00
|
|
|
|
|
|
|
float limited = image.Load(int3(x, y, 0)).x;
|
|
|
|
float full = saturate((limited - (16.0 / 255.0)) * (255.0 / 219.0));
|
|
|
|
return float4(full, full, full, 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
|
|
|
float4 PSY800_Full(FragTex frag_in) : TARGET
|
2019-04-22 23:38:26 -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
|
|
|
int x = int(frag_in.uv.x * width + PRECISION_OFFSET);
|
|
|
|
int y = int(frag_in.uv.y * height + PRECISION_OFFSET);
|
2019-04-22 23:38:26 -07:00
|
|
|
|
|
|
|
float3 full = image.Load(int3(x, y, 0)).xxx;
|
|
|
|
return float4(full, 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
|
|
|
float4 PSRGB_Limited(FragTex frag_in) : TARGET
|
2019-04-22 23:38:26 -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
|
|
|
int x = int(frag_in.uv.x * width + PRECISION_OFFSET);
|
|
|
|
int y = int(frag_in.uv.y * height + PRECISION_OFFSET);
|
2019-04-22 23:38:26 -07:00
|
|
|
|
|
|
|
float4 rgba = image.Load(int3(x, y, 0));
|
|
|
|
rgba.rgb = saturate((rgba.rgb - (16.0 / 255.0)) * (255.0 / 219.0));
|
|
|
|
return rgba;
|
|
|
|
}
|
|
|
|
|
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 PSBGR3_Limited(FragTex frag_in) : TARGET
|
2019-05-30 06:05:53 -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
|
|
|
int x = int(frag_in.uv.x * width * 3.0 + PRECISION_OFFSET);
|
|
|
|
int y = int(frag_in.uv.y * height + PRECISION_OFFSET);
|
2019-05-30 06:05:53 -07:00
|
|
|
|
|
|
|
float b = image.Load(int3(x - 1, y, 0)).x;
|
|
|
|
float g = image.Load(int3(x, y, 0)).x;
|
|
|
|
float r = image.Load(int3(x + 1, y, 0)).x;
|
|
|
|
float3 rgb = float3(r, g, b);
|
|
|
|
rgb = saturate((rgb - (16.0 / 255.0)) * (255.0 / 219.0));
|
|
|
|
return float4(rgb, 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
|
|
|
float4 PSBGR3_Full(FragTex frag_in) : TARGET
|
2019-05-30 06:05:53 -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
|
|
|
int x = int(frag_in.uv.x * width * 3.0 + PRECISION_OFFSET);
|
|
|
|
int y = int(frag_in.uv.y * height + PRECISION_OFFSET);
|
2019-05-30 06:05:53 -07:00
|
|
|
|
|
|
|
float b = image.Load(int3(x - 1, y, 0)).x;
|
|
|
|
float g = image.Load(int3(x, y, 0)).x;
|
|
|
|
float r = image.Load(int3(x + 1, y, 0)).x;
|
|
|
|
float3 rgb = float3(r, g, b);
|
|
|
|
return float4(rgb, 1.0);
|
|
|
|
}
|
|
|
|
|
2014-02-16 18:28:21 -08:00
|
|
|
technique Planar420
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSPlanar420(frag_in);
|
2014-02-16 18:28:21 -08:00
|
|
|
}
|
|
|
|
}
|
2014-04-04 11:49:23 -07:00
|
|
|
|
2015-04-16 22:43:46 -07:00
|
|
|
technique Planar444
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSPlanar444(frag_in);
|
2015-04-16 22:43:46 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-04 11:49:23 -07:00
|
|
|
technique NV12
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSNV12(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);
|
|
|
|
pixel_shader = PSNV12_Y(frag_in);
|
2018-10-05 20:18:15 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique NV12_UV
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSNV12_UV(frag_in);
|
2018-10-05 20:18:15 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-02 07:38:20 -07:00
|
|
|
technique UYVY_Reverse
|
2014-04-23 20:56:44 -07:00
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSPacked422_Reverse(frag_in, 2, 0, 1, 3);
|
2014-04-23 20:56:44 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique YUY2_Reverse
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSPacked422_Reverse(frag_in, 1, 3, 2, 0);
|
2014-04-23 20:56:44 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique YVYU_Reverse
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSPacked422_Reverse(frag_in, 3, 1, 2, 0);
|
2014-04-23 20:56:44 -07:00
|
|
|
}
|
|
|
|
}
|
2014-05-30 02:13:32 -07:00
|
|
|
|
|
|
|
technique I420_Reverse
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSPlanar420_Reverse(frag_in);
|
2014-05-30 02:13:32 -07:00
|
|
|
}
|
|
|
|
}
|
2014-12-18 11:37:46 -08:00
|
|
|
|
2019-04-02 09:03:57 -07:00
|
|
|
technique I444_Reverse
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSPlanar444_Reverse(frag_in);
|
2019-04-02 09:03:57 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-18 11:37:46 -08:00
|
|
|
technique NV12_Reverse
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSNV12_Reverse(frag_in);
|
2014-12-18 11:37:46 -08:00
|
|
|
}
|
|
|
|
}
|
2019-04-22 23:38:26 -07:00
|
|
|
|
|
|
|
technique Y800_Limited
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSY800_Limited(frag_in);
|
2019-04-22 23:38:26 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique Y800_Full
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSY800_Full(frag_in);
|
2019-04-22 23:38:26 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique RGB_Limited
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
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
|
|
|
|
{
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSBGR3_Limited(frag_in);
|
2019-05-30 06:05:53 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
technique BGR3_Full
|
|
|
|
{
|
|
|
|
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 = VSPosTex(id);
|
|
|
|
pixel_shader = PSBGR3_Full(frag_in);
|
2019-05-30 06:05:53 -07:00
|
|
|
}
|
|
|
|
}
|