gstreamer/subprojects/gst-plugins-bad/gst-libs/gst/d3dshader/converter-hlsl/CSMain_converter.hlsl
Seungha Yang 13c90b606a d3dshader: Add HLSL shader library
Adding a new library for HLSL compile and compiled bytecode caching.
This library will be used by d3d11 and d3d12 library/plugin, in order to
reuse single HLSL code and compiled HLSL bytecode.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/6434>
2024-03-24 22:05:49 +09:00

1169 lines
33 KiB
HLSL

/* GStreamer
* Copyright (C) 2023 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef BUILDING_HLSL
#ifdef BUILDING_CSMain_YUY2_to_AYUV
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float4 val = inTex.Load (tid);
float Y0 = val.r;
float U = val.g;
float Y1 = val.b;
float V = val.a;
outTex[uint2(tid.x * 2, tid.y)] = float4 (1.0, Y0, U, V);
outTex[uint2(tid.x * 2 + 1, tid.y)] = float4 (1.0, Y1, U, V);
}
#endif
#ifdef BUILDING_CSMain_UYVY_to_AYUV
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float4 val = inTex.Load (tid);
float Y0 = val.g;
float U = val.r;
float Y1 = val.a;
float V = val.b;
outTex[uint2(tid.x * 2, tid.y)] = float4 (1.0, Y0, U, V);
outTex[uint2(tid.x * 2 + 1, tid.y)] = float4 (1.0, Y1, U, V);
}
#endif
#ifdef BUILDING_CSMain_VYUY_to_AYUV
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float4 val = inTex.Load (tid);
float Y0 = val.g;
float U = val.b;
float Y1 = val.a;
float V = val.r;
outTex[uint2(tid.x * 2, tid.y)] = float4 (1.0, Y0, U, V);
outTex[uint2(tid.x * 2 + 1, tid.y)] = float4 (1.0, Y1, U, V);
}
#endif
#ifdef BUILDING_CSMain_YVYU_to_AYUV
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float4 val = inTex.Load (tid);
float Y0 = val.r;
float U = val.a;
float Y1 = val.b;
float V = val.g;
outTex[uint2(tid.x * 2, tid.y)] = float4 (1.0, Y0, U, V);
outTex[uint2(tid.x * 2 + 1, tid.y)] = float4 (1.0, Y1, U, V);
}
#endif
#ifdef BUILDING_CSMain_v210_to_AYUV
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
uint xpos = tid.x * 4;
float3 val = inTex.Load (uint3 (xpos, tid.y, 0)).xyz;
float U0 = val.r;
float Y0 = val.g;
float V0 = val.b;
val = inTex.Load (uint3 (xpos + 1, tid.y, 0)).xyz;
float Y1 = val.r;
float U2 = val.g;
float Y2 = val.b;
val = inTex.Load (uint3 (xpos + 2, tid.y, 0)).xyz;
float V2 = val.r;
float Y3 = val.g;
float U4 = val.b;
val = inTex.Load (uint3 (xpos + 3, tid.y, 0)).xyz;
float Y4 = val.r;
float V4 = val.g;
float Y5 = val.b;
xpos = tid.x * 6;
outTex[uint2(xpos, tid.y)] = float4 (1.0, Y0, U0, V0);
outTex[uint2(xpos + 1, tid.y)] = float4 (1.0, Y1, U0, V0);
outTex[uint2(xpos + 2, tid.y)] = float4 (1.0, Y2, U2, V2);
outTex[uint2(xpos + 3, tid.y)] = float4 (1.0, Y3, U2, V2);
outTex[uint2(xpos + 4, tid.y)] = float4 (1.0, Y4, U4, V4);
outTex[uint2(xpos + 5, tid.y)] = float4 (1.0, Y5, U4, V4);
}
#endif
#ifdef BUILDING_CSMain_v308_to_AYUV
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float4 val = inTex.Load (uint3 (tid.x * 3, tid.y, 0));
float Y0 = val.x;
float U0 = val.y;
float V0 = val.z;
float Y1 = val.w;
val = inTex.Load (uint3 (tid.x * 3 + 1, tid.y, 0));
float U1 = val.x;
float V1 = val.y;
float Y2 = val.z;
float U2 = val.w;
val = inTex.Load (uint3 (tid.x * 3 + 2, tid.y, 0));
float V2 = val.x;
float Y3 = val.y;
float U3 = val.z;
float V3 = val.w;
outTex[uint2(tid.x * 4, tid.y)] = float4 (1.0, Y0, U0, V0);
outTex[uint2(tid.x * 4 + 1, tid.y)] = float4 (1.0, Y1, U1, V1);
outTex[uint2(tid.x * 4 + 2, tid.y)] = float4 (1.0, Y2, U2, V2);
outTex[uint2(tid.x * 4 + 3, tid.y)] = float4 (1.0, Y3, U3, V3);
}
#endif
#ifdef BUILDING_CSMain_IYU2_to_AYUV
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float4 val = inTex.Load (uint3 (tid.x * 3, tid.y, 0));
float U0 = val.x;
float Y0 = val.y;
float V0 = val.z;
float U1 = val.w;
val = inTex.Load (uint3 (tid.x * 3 + 1, tid.y, 0));
float Y1 = val.x;
float V1 = val.y;
float U2 = val.z;
float Y2 = val.w;
val = inTex.Load (uint3 (tid.x * 3 + 2, tid.y, 0));
float V2 = val.x;
float U3 = val.y;
float Y3 = val.z;
float V3 = val.w;
outTex[uint2(tid.x * 4, tid.y)] = float4 (1.0, Y0, U0, V0);
outTex[uint2(tid.x * 4 + 1, tid.y)] = float4 (1.0, Y1, U1, V1);
outTex[uint2(tid.x * 4 + 2, tid.y)] = float4 (1.0, Y2, U2, V2);
outTex[uint2(tid.x * 4 + 3, tid.y)] = float4 (1.0, Y3, U3, V3);
}
#endif
#ifdef BUILDING_CSMain_AYUV_to_YUY2
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float3 val = inTex.Load (uint3(tid.x * 2, tid.y, 0)).yzw;
float Y0 = val.x;
float U = val.y;
float V = val.z;
float Y1 = inTex.Load (uint3(tid.x * 2 + 1, tid.y, 0)).y;
outTex[tid.xy] = float4 (Y0, U, Y1, V);
}
#endif
#ifdef BUILDING_CSMain_AYUV_to_UYVY
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float3 val = inTex.Load (uint3(tid.x * 2, tid.y, 0)).yzw;
float Y0 = val.x;
float U = val.y;
float V = val.z;
float Y1 = inTex.Load (uint3(tid.x * 2 + 1, tid.y, 0)).y;
outTex[tid.xy] = float4 (U, Y0, V, Y1);
}
#endif
#ifdef BUILDING_CSMain_AYUV_to_VYUY
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float3 val = inTex.Load (uint3(tid.x * 2, tid.y, 0)).yzw;
float Y0 = val.x;
float U = val.y;
float V = val.z;
float Y1 = inTex.Load (uint3(tid.x * 2 + 1, tid.y, 0)).y;
outTex[tid.xy] = float4 (V, Y0, U, Y1);
}
#endif
#ifdef BUILDING_CSMain_AYUV_to_YVYU
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float3 val = inTex.Load (uint3(tid.x * 2, tid.y, 0)).yzw;
float Y0 = val.x;
float U = val.y;
float V = val.z;
float Y1 = inTex.Load (uint3(tid.x * 2 + 1, tid.y, 0)).y;
outTex[tid.xy] = float4 (Y0, V, Y1, U);
}
#endif
#ifdef BUILDING_CSMain_AYUV_to_v210
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
uint xpos = tid.x * 6;
float3 val = inTex.Load (uint3 (xpos, tid.y, 0)).yzw;
float Y0 = val.x;
float U0 = val.y;
float V0 = val.z;
float Y1 = inTex.Load (uint3 (xpos + 1, tid.y, 0)).y;
val = inTex.Load (uint3 (xpos + 2, tid.y, 0)).yzw;
float Y2 = val.x;
float U2 = val.y;
float V2 = val.z;
float Y3 = inTex.Load (uint3 (xpos + 3, tid.y, 0)).y;
val = inTex.Load (uint3 (xpos + 4, tid.y, 0)).yzw;
float Y4 = val.x;
float U4 = val.y;
float V4 = val.z;
float Y5 = inTex.Load (uint3 (xpos + 5, tid.y, 0)).y;
xpos = tid.x * 4;
outTex[uint2(xpos, tid.y)] = float4 (U0, Y0, V0, 0);
outTex[uint2(xpos + 1, tid.y)] = float4 (Y1, U2, Y2, 0);
outTex[uint2(xpos + 2, tid.y)] = float4 (V2, Y3, U4, 0);
outTex[uint2(xpos + 3, tid.y)] = float4 (Y4, V4, Y5, 0);
}
#endif
#ifdef BUILDING_CSMain_AYUV_to_v308
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float3 val0 = inTex.Load (uint3 (tid.x * 4, tid.y, 0)).yzw;
float3 val1 = inTex.Load (uint3 (tid.x * 4 + 1, tid.y, 0)).yzw;
float3 val2 = inTex.Load (uint3 (tid.x * 4 + 2, tid.y, 0)).yzw;
float3 val3 = inTex.Load (uint3 (tid.x * 4 + 3, tid.y, 0)).yzw;
outTex[uint2(tid.x * 3, tid.y)] = float4 (val0.x, val0.y, val0.z, val1.x);
outTex[uint2(tid.x * 3 + 1, tid.y)] = float4 (val1.y, val1.z, val2.x, val2.y);
outTex[uint2(tid.x * 3 + 2, tid.y)] = float4 (val2.z, val3.x, val3.y, val3.z);
}
#endif
#ifdef BUILDING_CSMain_AYUV_to_IYU2
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float3 val0 = inTex.Load (uint3 (tid.x * 4, tid.y, 0)).zyw;
float3 val1 = inTex.Load (uint3 (tid.x * 4 + 1, tid.y, 0)).zyw;
float3 val2 = inTex.Load (uint3 (tid.x * 4 + 2, tid.y, 0)).zyw;
float3 val3 = inTex.Load (uint3 (tid.x * 4 + 3, tid.y, 0)).zyw;
outTex[uint2(tid.x * 3, tid.y)] = float4 (val0.x, val0.y, val0.z, val1.x);
outTex[uint2(tid.x * 3 + 1, tid.y)] = float4 (val1.y, val1.z, val2.x, val2.y);
outTex[uint2(tid.x * 3 + 2, tid.y)] = float4 (val2.z, val3.x, val3.y, val3.z);
}
#endif
#ifdef BUILDING_CSMain_AYUV_to_Y410
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float4 val = inTex.Load (tid);
float Y = val.y;
float U = val.z;
float V = val.w;
float A = val.x;
outTex[tid.xy] = float4 (U, Y, V, A);
}
#endif
#ifdef BUILDING_CSMain_RGB_to_RGBA
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float4 val = inTex.Load (uint3 (tid.x * 3, tid.y, 0));
float R0 = val.r;
float G0 = val.g;
float B0 = val.b;
float R1 = val.a;
val = inTex.Load (uint3 (tid.x * 3 + 1, tid.y, 0));
float G1 = val.r;
float B1 = val.g;
float R2 = val.b;
float G2 = val.a;
val = inTex.Load (uint3 (tid.x * 3 + 2, tid.y, 0));
float B2 = val.r;
float R3 = val.g;
float G3 = val.b;
float B3 = val.a;
outTex[uint2(tid.x * 4, tid.y)] = float4 (R0, G0, B0, 1.0);
outTex[uint2(tid.x * 4 + 1, tid.y)] = float4 (R1, G1, B1, 1.0);
outTex[uint2(tid.x * 4 + 2, tid.y)] = float4 (R2, G2, B2, 1.0);
outTex[uint2(tid.x * 4 + 3, tid.y)] = float4 (R3, G3, B3, 1.0);
}
#endif
#ifdef BUILDING_CSMain_BGR_to_RGBA
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float4 val = inTex.Load (uint3 (tid.x * 3, tid.y, 0));
float B0 = val.r;
float G0 = val.g;
float R0 = val.b;
float B1 = val.a;
val = inTex.Load (uint3 (tid.x * 3 + 1, tid.y, 0));
float G1 = val.r;
float R1 = val.g;
float B2 = val.b;
float G2 = val.a;
val = inTex.Load (uint3 (tid.x * 3 + 2, tid.y, 0));
float R2 = val.r;
float B3 = val.g;
float G3 = val.b;
float R3 = val.a;
outTex[uint2(tid.x * 4, tid.y)] = float4 (R0, G0, B0, 1.0);
outTex[uint2(tid.x * 4 + 1, tid.y)] = float4 (R1, G1, B1, 1.0);
outTex[uint2(tid.x * 4 + 2, tid.y)] = float4 (R2, G2, B2, 1.0);
outTex[uint2(tid.x * 4 + 3, tid.y)] = float4 (R3, G3, B3, 1.0);
}
#endif
#ifdef BUILDING_CSMain_RGB16_to_RGBA
Texture2D<uint> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
uint val = inTex.Load (tid);
float R = float ((val & 0xf800) >> 11) / 31;
float G = float ((val & 0x7e0) >> 5) / 63;
float B = float ((val & 0x1f)) / 31;
outTex[tid.xy] = float4 (R, G, B, 1.0);
}
#endif
#ifdef BUILDING_CSMain_BGR16_to_RGBA
Texture2D<uint> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
uint val = inTex.Load (tid);
float B = float ((val & 0xf800) >> 11) / 31;
float G = float ((val & 0x7e0) >> 5) / 63;
float R = float ((val & 0x1f)) / 31;
outTex[tid.xy] = float4 (R, G, B, 1.0);
}
#endif
#ifdef BUILDING_CSMain_RGB15_to_RGBA
Texture2D<uint> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
uint val = inTex.Load (tid);
uint R = (val & 0x7c00) >> 10;
uint G = (val & 0x3e0) >> 5;
uint B = (val & 0x1f);
outTex[tid.xy] = float4 (float3 (R, G, B) / 31, 1.0);
}
#endif
#ifdef BUILDING_CSMain_BGR15_to_RGBA
Texture2D<uint> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
uint val = inTex.Load (tid);
uint B = (val & 0x7c00) >> 10;
uint G = (val & 0x3e0) >> 5;
uint R = (val & 0x1f);
outTex[tid.xy] = float4 (float3 (R, G, B) / 31, 1.0);
}
#endif
#ifdef BUILDING_CSMain_r210_to_RGBA
Texture2D<uint> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
uint val = inTex.Load (tid);
uint val_be = ((val & 0xff) << 24) | ((val & 0xff00) << 8) |
((val & 0xff0000) >> 8) | ((val & 0xff000000) >> 24);
uint R = (val_be >> 20) & 0x3ff;
uint G = (val_be >> 10) & 0x3ff;
uint B = val_be & 0x3ff;
outTex[tid.xy] = float4 (float3 (R, G, B) / 1023, 1.0);
}
#endif
#ifdef BUILDING_CSMain_RGBA_to_RGB
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float3 val0 = inTex.Load (uint3 (tid.x * 4, tid.y, 0)).rgb;
float3 val1 = inTex.Load (uint3 (tid.x * 4 + 1, tid.y, 0)).rgb;
float3 val2 = inTex.Load (uint3 (tid.x * 4 + 2, tid.y, 0)).rgb;
float3 val3 = inTex.Load (uint3 (tid.x * 4 + 3, tid.y, 0)).rgb;
outTex[uint2(tid.x * 3, tid.y)] = float4 (val0.r, val0.g, val0.b, val1.r);
outTex[uint2(tid.x * 3 + 1, tid.y)] = float4 (val1.g, val1.b, val2.r, val2.g);
outTex[uint2(tid.x * 3 + 2, tid.y)] = float4 (val2.b, val3.r, val3.g, val3.b);
}
#endif
#ifdef BUILDING_CSMain_RGBA_to_BGR
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float3 val0 = inTex.Load (uint3 (tid.x * 4, tid.y, 0)).rgb;
float3 val1 = inTex.Load (uint3 (tid.x * 4 + 1, tid.y, 0)).rgb;
float3 val2 = inTex.Load (uint3 (tid.x * 4 + 2, tid.y, 0)).rgb;
float3 val3 = inTex.Load (uint3 (tid.x * 4 + 3, tid.y, 0)).rgb;
outTex[uint2(tid.x * 3, tid.y)] = float4 (val0.b, val0.g, val0.r, val1.b);
outTex[uint2(tid.x * 3 + 1, tid.y)] = float4 (val1.g, val1.r, val2.b, val2.g);
outTex[uint2(tid.x * 3 + 2, tid.y)] = float4 (val2.r, val3.b, val3.g, val3.r);
}
#endif
#ifdef BUILDING_CSMain_RGBA_to_RGB16
Texture2D<float4> inTex : register(t0);
RWTexture2D<uint> outTex : register(u0);
void Execute (uint3 tid)
{
float3 val = inTex.Load (tid).rgb;
uint R = val.r * 31;
uint G = val.g * 63;
uint B = val.b * 31;
outTex[tid.xy] = (R << 11) | (G << 5) | B;
}
#endif
#ifdef BUILDING_CSMain_RGBA_to_BGR16
Texture2D<float4> inTex : register(t0);
RWTexture2D<uint> outTex : register(u0);
void Execute (uint3 tid)
{
float3 val = inTex.Load (tid).rgb;
uint R = val.r * 31;
uint G = val.g * 63;
uint B = val.b * 31;
outTex[tid.xy] = (B << 11) | (G << 5) | R;
}
#endif
#ifdef BUILDING_CSMain_RGBA_to_RGB15
Texture2D<float4> inTex : register(t0);
RWTexture2D<uint> outTex : register(u0);
void Execute (uint3 tid)
{
uint3 val = inTex.Load (tid).rgb * 31;
outTex[tid.xy] = (val.r << 10) | (val.g << 5) | val.b;
}
#endif
#ifdef BUILDING_CSMain_RGBA_to_BGR15
Texture2D<float4> inTex : register(t0);
RWTexture2D<uint> outTex : register(u0);
void Execute (uint3 tid)
{
uint3 val = inTex.Load (tid).rgb * 31;
outTex[tid.xy] = (val.b << 10) | (val.g << 5) | val.r;
}
#endif
#ifdef BUILDING_CSMain_RGBA_to_r210
Texture2D<float4> inTex : register(t0);
RWTexture2D<uint> outTex : register(u0);
void Execute (uint3 tid)
{
uint3 val = inTex.Load (tid).rgb * 1023;
uint packed = (val.r << 20) | (val.g << 10) | val.b;
uint packed_be = ((packed & 0xff) << 24) | ((packed & 0xff00) << 8) |
((packed & 0xff0000) >> 8) | ((packed & 0xff000000) >> 24);
outTex[tid.xy] = packed_be;
}
#endif
#ifdef BUILDING_CSMain_RGBA_to_BGRA
Texture2D<float4> inTex : register(t0);
RWTexture2D<unorm float4> outTex : register(u0);
void Execute (uint3 tid)
{
float4 val = inTex.Load (tid);
outTex[tid.xy] = val.bgra;
}
#endif
[numthreads(8, 8, 1)]
void ENTRY_POINT (uint3 tid : SV_DispatchThreadID)
{
Execute (tid);
}
#else
static const char str_CSMain_converter[] =
"#ifdef BUILDING_CSMain_YUY2_to_AYUV\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float4 val = inTex.Load (tid);\n"
" float Y0 = val.r;\n"
" float U = val.g;\n"
" float Y1 = val.b;\n"
" float V = val.a;\n"
"\n"
" outTex[uint2(tid.x * 2, tid.y)] = float4 (1.0, Y0, U, V);\n"
" outTex[uint2(tid.x * 2 + 1, tid.y)] = float4 (1.0, Y1, U, V);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_UYVY_to_AYUV\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float4 val = inTex.Load (tid);\n"
" float Y0 = val.g;\n"
" float U = val.r;\n"
" float Y1 = val.a;\n"
" float V = val.b;\n"
"\n"
" outTex[uint2(tid.x * 2, tid.y)] = float4 (1.0, Y0, U, V);\n"
" outTex[uint2(tid.x * 2 + 1, tid.y)] = float4 (1.0, Y1, U, V);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_VYUY_to_AYUV\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float4 val = inTex.Load (tid);\n"
" float Y0 = val.g;\n"
" float U = val.b;\n"
" float Y1 = val.a;\n"
" float V = val.r;\n"
"\n"
" outTex[uint2(tid.x * 2, tid.y)] = float4 (1.0, Y0, U, V);\n"
" outTex[uint2(tid.x * 2 + 1, tid.y)] = float4 (1.0, Y1, U, V);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_YVYU_to_AYUV\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float4 val = inTex.Load (tid);\n"
" float Y0 = val.r;\n"
" float U = val.a;\n"
" float Y1 = val.b;\n"
" float V = val.g;\n"
"\n"
" outTex[uint2(tid.x * 2, tid.y)] = float4 (1.0, Y0, U, V);\n"
" outTex[uint2(tid.x * 2 + 1, tid.y)] = float4 (1.0, Y1, U, V);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_v210_to_AYUV\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" uint xpos = tid.x * 4;\n"
" float3 val = inTex.Load (uint3 (xpos, tid.y, 0)).xyz;\n"
" float U0 = val.r;\n"
" float Y0 = val.g;\n"
" float V0 = val.b;\n"
"\n"
" val = inTex.Load (uint3 (xpos + 1, tid.y, 0)).xyz;\n"
" float Y1 = val.r;\n"
" float U2 = val.g;\n"
" float Y2 = val.b;\n"
"\n"
" val = inTex.Load (uint3 (xpos + 2, tid.y, 0)).xyz;\n"
" float V2 = val.r;\n"
" float Y3 = val.g;\n"
" float U4 = val.b;\n"
"\n"
" val = inTex.Load (uint3 (xpos + 3, tid.y, 0)).xyz;\n"
" float Y4 = val.r;\n"
" float V4 = val.g;\n"
" float Y5 = val.b;\n"
"\n"
" xpos = tid.x * 6;\n"
" outTex[uint2(xpos, tid.y)] = float4 (1.0, Y0, U0, V0);\n"
" outTex[uint2(xpos + 1, tid.y)] = float4 (1.0, Y1, U0, V0);\n"
" outTex[uint2(xpos + 2, tid.y)] = float4 (1.0, Y2, U2, V2);\n"
" outTex[uint2(xpos + 3, tid.y)] = float4 (1.0, Y3, U2, V2);\n"
" outTex[uint2(xpos + 4, tid.y)] = float4 (1.0, Y4, U4, V4);\n"
" outTex[uint2(xpos + 5, tid.y)] = float4 (1.0, Y5, U4, V4);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_v308_to_AYUV\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float4 val = inTex.Load (uint3 (tid.x * 3, tid.y, 0));\n"
" float Y0 = val.x;\n"
" float U0 = val.y;\n"
" float V0 = val.z;\n"
" float Y1 = val.w;\n"
"\n"
" val = inTex.Load (uint3 (tid.x * 3 + 1, tid.y, 0));\n"
" float U1 = val.x;\n"
" float V1 = val.y;\n"
" float Y2 = val.z;\n"
" float U2 = val.w;\n"
"\n"
" val = inTex.Load (uint3 (tid.x * 3 + 2, tid.y, 0));\n"
" float V2 = val.x;\n"
" float Y3 = val.y;\n"
" float U3 = val.z;\n"
" float V3 = val.w;\n"
"\n"
" outTex[uint2(tid.x * 4, tid.y)] = float4 (1.0, Y0, U0, V0);\n"
" outTex[uint2(tid.x * 4 + 1, tid.y)] = float4 (1.0, Y1, U1, V1);\n"
" outTex[uint2(tid.x * 4 + 2, tid.y)] = float4 (1.0, Y2, U2, V2);\n"
" outTex[uint2(tid.x * 4 + 3, tid.y)] = float4 (1.0, Y3, U3, V3);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_IYU2_to_AYUV\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float4 val = inTex.Load (uint3 (tid.x * 3, tid.y, 0));\n"
" float U0 = val.x;\n"
" float Y0 = val.y;\n"
" float V0 = val.z;\n"
" float U1 = val.w;\n"
"\n"
" val = inTex.Load (uint3 (tid.x * 3 + 1, tid.y, 0));\n"
" float Y1 = val.x;\n"
" float V1 = val.y;\n"
" float U2 = val.z;\n"
" float Y2 = val.w;\n"
"\n"
" val = inTex.Load (uint3 (tid.x * 3 + 2, tid.y, 0));\n"
" float V2 = val.x;\n"
" float U3 = val.y;\n"
" float Y3 = val.z;\n"
" float V3 = val.w;\n"
"\n"
" outTex[uint2(tid.x * 4, tid.y)] = float4 (1.0, Y0, U0, V0);\n"
" outTex[uint2(tid.x * 4 + 1, tid.y)] = float4 (1.0, Y1, U1, V1);\n"
" outTex[uint2(tid.x * 4 + 2, tid.y)] = float4 (1.0, Y2, U2, V2);\n"
" outTex[uint2(tid.x * 4 + 3, tid.y)] = float4 (1.0, Y3, U3, V3);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_AYUV_to_YUY2\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float3 val = inTex.Load (uint3(tid.x * 2, tid.y, 0)).yzw;\n"
" float Y0 = val.x;\n"
" float U = val.y;\n"
" float V = val.z;\n"
" float Y1 = inTex.Load (uint3(tid.x * 2 + 1, tid.y, 0)).y;\n"
"\n"
" outTex[tid.xy] = float4 (Y0, U, Y1, V);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_AYUV_to_UYVY\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float3 val = inTex.Load (uint3(tid.x * 2, tid.y, 0)).yzw;\n"
" float Y0 = val.x;\n"
" float U = val.y;\n"
" float V = val.z;\n"
" float Y1 = inTex.Load (uint3(tid.x * 2 + 1, tid.y, 0)).y;\n"
"\n"
" outTex[tid.xy] = float4 (U, Y0, V, Y1);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_AYUV_to_VYUY\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float3 val = inTex.Load (uint3(tid.x * 2, tid.y, 0)).yzw;\n"
" float Y0 = val.x;\n"
" float U = val.y;\n"
" float V = val.z;\n"
" float Y1 = inTex.Load (uint3(tid.x * 2 + 1, tid.y, 0)).y;\n"
"\n"
" outTex[tid.xy] = float4 (V, Y0, U, Y1);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_AYUV_to_YVYU\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float3 val = inTex.Load (uint3(tid.x * 2, tid.y, 0)).yzw;\n"
" float Y0 = val.x;\n"
" float U = val.y;\n"
" float V = val.z;\n"
" float Y1 = inTex.Load (uint3(tid.x * 2 + 1, tid.y, 0)).y;\n"
"\n"
" outTex[tid.xy] = float4 (Y0, V, Y1, U);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_AYUV_to_v210\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" uint xpos = tid.x * 6;\n"
" float3 val = inTex.Load (uint3 (xpos, tid.y, 0)).yzw;\n"
" float Y0 = val.x;\n"
" float U0 = val.y;\n"
" float V0 = val.z;\n"
" float Y1 = inTex.Load (uint3 (xpos + 1, tid.y, 0)).y;\n"
"\n"
" val = inTex.Load (uint3 (xpos + 2, tid.y, 0)).yzw;\n"
" float Y2 = val.x;\n"
" float U2 = val.y;\n"
" float V2 = val.z;\n"
" float Y3 = inTex.Load (uint3 (xpos + 3, tid.y, 0)).y;\n"
"\n"
" val = inTex.Load (uint3 (xpos + 4, tid.y, 0)).yzw;\n"
" float Y4 = val.x;\n"
" float U4 = val.y;\n"
" float V4 = val.z;\n"
" float Y5 = inTex.Load (uint3 (xpos + 5, tid.y, 0)).y;\n"
"\n"
" xpos = tid.x * 4;\n"
" outTex[uint2(xpos, tid.y)] = float4 (U0, Y0, V0, 0);\n"
" outTex[uint2(xpos + 1, tid.y)] = float4 (Y1, U2, Y2, 0);\n"
" outTex[uint2(xpos + 2, tid.y)] = float4 (V2, Y3, U4, 0);\n"
" outTex[uint2(xpos + 3, tid.y)] = float4 (Y4, V4, Y5, 0);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_AYUV_to_v308\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float3 val0 = inTex.Load (uint3 (tid.x * 4, tid.y, 0)).yzw;\n"
" float3 val1 = inTex.Load (uint3 (tid.x * 4 + 1, tid.y, 0)).yzw;\n"
" float3 val2 = inTex.Load (uint3 (tid.x * 4 + 2, tid.y, 0)).yzw;\n"
" float3 val3 = inTex.Load (uint3 (tid.x * 4 + 3, tid.y, 0)).yzw;\n"
"\n"
" outTex[uint2(tid.x * 3, tid.y)] = float4 (val0.x, val0.y, val0.z, val1.x);\n"
" outTex[uint2(tid.x * 3 + 1, tid.y)] = float4 (val1.y, val1.z, val2.x, val2.y);\n"
" outTex[uint2(tid.x * 3 + 2, tid.y)] = float4 (val2.z, val3.x, val3.y, val3.z);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_AYUV_to_IYU2\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float3 val0 = inTex.Load (uint3 (tid.x * 4, tid.y, 0)).zyw;\n"
" float3 val1 = inTex.Load (uint3 (tid.x * 4 + 1, tid.y, 0)).zyw;\n"
" float3 val2 = inTex.Load (uint3 (tid.x * 4 + 2, tid.y, 0)).zyw;\n"
" float3 val3 = inTex.Load (uint3 (tid.x * 4 + 3, tid.y, 0)).zyw;\n"
"\n"
" outTex[uint2(tid.x * 3, tid.y)] = float4 (val0.x, val0.y, val0.z, val1.x);\n"
" outTex[uint2(tid.x * 3 + 1, tid.y)] = float4 (val1.y, val1.z, val2.x, val2.y);\n"
" outTex[uint2(tid.x * 3 + 2, tid.y)] = float4 (val2.z, val3.x, val3.y, val3.z);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_AYUV_to_Y410\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float4 val = inTex.Load (tid);\n"
" float Y = val.y;\n"
" float U = val.z;\n"
" float V = val.w;\n"
" float A = val.x;\n"
"\n"
" outTex[tid.xy] = float4 (U, Y, V, A);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_RGB_to_RGBA\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float4 val = inTex.Load (uint3 (tid.x * 3, tid.y, 0));\n"
" float R0 = val.r;\n"
" float G0 = val.g;\n"
" float B0 = val.b;\n"
" float R1 = val.a;\n"
"\n"
" val = inTex.Load (uint3 (tid.x * 3 + 1, tid.y, 0));\n"
" float G1 = val.r;\n"
" float B1 = val.g;\n"
" float R2 = val.b;\n"
" float G2 = val.a;\n"
"\n"
" val = inTex.Load (uint3 (tid.x * 3 + 2, tid.y, 0));\n"
" float B2 = val.r;\n"
" float R3 = val.g;\n"
" float G3 = val.b;\n"
" float B3 = val.a;\n"
"\n"
" outTex[uint2(tid.x * 4, tid.y)] = float4 (R0, G0, B0, 1.0);\n"
" outTex[uint2(tid.x * 4 + 1, tid.y)] = float4 (R1, G1, B1, 1.0);\n"
" outTex[uint2(tid.x * 4 + 2, tid.y)] = float4 (R2, G2, B2, 1.0);\n"
" outTex[uint2(tid.x * 4 + 3, tid.y)] = float4 (R3, G3, B3, 1.0);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_BGR_to_RGBA\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float4 val = inTex.Load (uint3 (tid.x * 3, tid.y, 0));\n"
" float B0 = val.r;\n"
" float G0 = val.g;\n"
" float R0 = val.b;\n"
" float B1 = val.a;\n"
"\n"
" val = inTex.Load (uint3 (tid.x * 3 + 1, tid.y, 0));\n"
" float G1 = val.r;\n"
" float R1 = val.g;\n"
" float B2 = val.b;\n"
" float G2 = val.a;\n"
"\n"
" val = inTex.Load (uint3 (tid.x * 3 + 2, tid.y, 0));\n"
" float R2 = val.r;\n"
" float B3 = val.g;\n"
" float G3 = val.b;\n"
" float R3 = val.a;\n"
"\n"
" outTex[uint2(tid.x * 4, tid.y)] = float4 (R0, G0, B0, 1.0);\n"
" outTex[uint2(tid.x * 4 + 1, tid.y)] = float4 (R1, G1, B1, 1.0);\n"
" outTex[uint2(tid.x * 4 + 2, tid.y)] = float4 (R2, G2, B2, 1.0);\n"
" outTex[uint2(tid.x * 4 + 3, tid.y)] = float4 (R3, G3, B3, 1.0);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_RGB16_to_RGBA\n"
"Texture2D<uint> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" uint val = inTex.Load (tid);\n"
" float R = float ((val & 0xf800) >> 11) / 31;\n"
" float G = float ((val & 0x7e0) >> 5) / 63;\n"
" float B = float ((val & 0x1f)) / 31;\n"
"\n"
" outTex[tid.xy] = float4 (R, G, B, 1.0);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_BGR16_to_RGBA\n"
"Texture2D<uint> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" uint val = inTex.Load (tid);\n"
" float B = float ((val & 0xf800) >> 11) / 31;\n"
" float G = float ((val & 0x7e0) >> 5) / 63;\n"
" float R = float ((val & 0x1f)) / 31;\n"
"\n"
" outTex[tid.xy] = float4 (R, G, B, 1.0);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_RGB15_to_RGBA\n"
"Texture2D<uint> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" uint val = inTex.Load (tid);\n"
" uint R = (val & 0x7c00) >> 10;\n"
" uint G = (val & 0x3e0) >> 5;\n"
" uint B = (val & 0x1f);\n"
"\n"
" outTex[tid.xy] = float4 (float3 (R, G, B) / 31, 1.0);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_BGR15_to_RGBA\n"
"Texture2D<uint> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" uint val = inTex.Load (tid);\n"
" uint B = (val & 0x7c00) >> 10;\n"
" uint G = (val & 0x3e0) >> 5;\n"
" uint R = (val & 0x1f);\n"
"\n"
" outTex[tid.xy] = float4 (float3 (R, G, B) / 31, 1.0);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_r210_to_RGBA\n"
"Texture2D<uint> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" uint val = inTex.Load (tid);\n"
" uint val_be = ((val & 0xff) << 24) | ((val & 0xff00) << 8) |\n"
" ((val & 0xff0000) >> 8) | ((val & 0xff000000) >> 24);\n"
" uint R = (val_be >> 20) & 0x3ff;\n"
" uint G = (val_be >> 10) & 0x3ff;\n"
" uint B = val_be & 0x3ff;\n"
"\n"
" outTex[tid.xy] = float4 (float3 (R, G, B) / 1023, 1.0);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_RGBA_to_RGB\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float3 val0 = inTex.Load (uint3 (tid.x * 4, tid.y, 0)).rgb;\n"
" float3 val1 = inTex.Load (uint3 (tid.x * 4 + 1, tid.y, 0)).rgb;\n"
" float3 val2 = inTex.Load (uint3 (tid.x * 4 + 2, tid.y, 0)).rgb;\n"
" float3 val3 = inTex.Load (uint3 (tid.x * 4 + 3, tid.y, 0)).rgb;\n"
"\n"
" outTex[uint2(tid.x * 3, tid.y)] = float4 (val0.r, val0.g, val0.b, val1.r);\n"
" outTex[uint2(tid.x * 3 + 1, tid.y)] = float4 (val1.g, val1.b, val2.r, val2.g);\n"
" outTex[uint2(tid.x * 3 + 2, tid.y)] = float4 (val2.b, val3.r, val3.g, val3.b);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_RGBA_to_BGR\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float3 val0 = inTex.Load (uint3 (tid.x * 4, tid.y, 0)).rgb;\n"
" float3 val1 = inTex.Load (uint3 (tid.x * 4 + 1, tid.y, 0)).rgb;\n"
" float3 val2 = inTex.Load (uint3 (tid.x * 4 + 2, tid.y, 0)).rgb;\n"
" float3 val3 = inTex.Load (uint3 (tid.x * 4 + 3, tid.y, 0)).rgb;\n"
"\n"
" outTex[uint2(tid.x * 3, tid.y)] = float4 (val0.b, val0.g, val0.r, val1.b);\n"
" outTex[uint2(tid.x * 3 + 1, tid.y)] = float4 (val1.g, val1.r, val2.b, val2.g);\n"
" outTex[uint2(tid.x * 3 + 2, tid.y)] = float4 (val2.r, val3.b, val3.g, val3.r);\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_RGBA_to_RGB16\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<uint> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float3 val = inTex.Load (tid).rgb;\n"
" uint R = val.r * 31;\n"
" uint G = val.g * 63;\n"
" uint B = val.b * 31;\n"
"\n"
" outTex[tid.xy] = (R << 11) | (G << 5) | B;\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_RGBA_to_BGR16\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<uint> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float3 val = inTex.Load (tid).rgb;\n"
" uint R = val.r * 31;\n"
" uint G = val.g * 63;\n"
" uint B = val.b * 31;\n"
"\n"
" outTex[tid.xy] = (B << 11) | (G << 5) | R;\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_RGBA_to_RGB15\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<uint> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" uint3 val = inTex.Load (tid).rgb * 31;\n"
"\n"
" outTex[tid.xy] = (val.r << 10) | (val.g << 5) | val.b;\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_RGBA_to_BGR15\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<uint> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" uint3 val = inTex.Load (tid).rgb * 31;\n"
"\n"
" outTex[tid.xy] = (val.b << 10) | (val.g << 5) | val.r;\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_RGBA_to_r210\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<uint> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" uint3 val = inTex.Load (tid).rgb * 1023;\n"
" uint packed = (val.r << 20) | (val.g << 10) | val.b;\n"
" uint packed_be = ((packed & 0xff) << 24) | ((packed & 0xff00) << 8) |\n"
" ((packed & 0xff0000) >> 8) | ((packed & 0xff000000) >> 24);\n"
"\n"
" outTex[tid.xy] = packed_be;\n"
"}\n"
"#endif\n"
"\n"
"#ifdef BUILDING_CSMain_RGBA_to_BGRA\n"
"Texture2D<float4> inTex : register(t0);\n"
"RWTexture2D<unorm float4> outTex : register(u0);\n"
"\n"
"void Execute (uint3 tid)\n"
"{\n"
" float4 val = inTex.Load (tid);\n"
"\n"
" outTex[tid.xy] = val.bgra;\n"
"}\n"
"#endif\n"
"\n"
"[numthreads(8, 8, 1)]\n"
"void ENTRY_POINT (uint3 tid : SV_DispatchThreadID)\n"
"{\n"
" Execute (tid);\n"
"}\n";
#endif