| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // @gyp_namespace(ui_surface) |
| // Compiles into C++ as 'accelerated_surface_transformer_win_hlsl_compiled.h' |
| |
| struct Vertex { |
| float4 position : POSITION; |
| float2 texCoord : TEXCOORD0; |
| }; |
| |
| texture t; |
| sampler s; |
| |
| extern uniform float2 kRenderTargetSize : c0; |
| extern uniform float2 kTextureScale : c1; |
| |
| // @gyp_compile(vs_2_0, vsOneTexture) |
| // |
| // Passes a position and texture coordinate to the pixel shader. |
| Vertex vsOneTexture(Vertex input) { |
| // Texture scale is typically just 1 (to do nothing) or -1 (to flip). |
| input.texCoord = ((2 * (input.texCoord - 0.5) * kTextureScale) + 1) / 2; |
| input.position.x += -1 / kRenderTargetSize.x; |
| input.position.y += 1 / kRenderTargetSize.y; |
| return input; |
| }; |
| |
| // @gyp_compile(ps_2_0, psOneTexture) |
| // |
| // Samples a texture at the given texture coordinate and returns the result. |
| float4 psOneTexture(float2 texCoord : TEXCOORD0) : COLOR0 { |
| return tex2D(s, texCoord); |
| }; |
| |
| // Return |value| rounded up to the nearest multiple of |multiple|. |
| float alignTo(float value, float multiple) { |
| // |multiple| is usually a compile-time constant; this check allows |
| // the compiler to avoid the fmod when possible. |
| if (multiple == 1) |
| return value; |
| |
| // Biasing the value provides numeric stability. We expect |value| to |
| // be an integer; this prevents 4.001 from being rounded up to 8. |
| float biased_value = value - 0.5; |
| return biased_value + multiple - fmod(biased_value, multiple); |
| } |
| |
| float4 packForByteOrder(float4 value) { |
| return value.bgra; |
| } |
| |
| // Adjust the input vertex to address the correct range of texels. This depends |
| // on the value of the shader constant |kRenderTargetSize|, as well as an |
| // alignment factor |align| that effectively specifies the footprint of the |
| // texel samples done by this shader pass, and is used to correct when that |
| // footprint size doesn't align perfectly with the actual input size. |
| Vertex adjustForAlignmentAndPacking(Vertex vtx, float2 align) { |
| float src_width = kRenderTargetSize.x; |
| float src_height = kRenderTargetSize.y; |
| |
| // Because our caller expects to be sampling |align.x| many pixels from src at |
| // a time, if src's width isn't evenly divisible by |align.x|, it is necessary |
| // to pretend that the source is slightly bigger than it is. |
| float bloated_src_width = alignTo(src_width, align.x); |
| float bloated_src_height = alignTo(src_height, align.y); |
| |
| // When bloated_src_width != src_width, we'll adjust the texture coordinates |
| // to sample past the edge of the vtx; clamping will produce extra copies of |
| // the last row. |
| float texture_x_scale = bloated_src_width / src_width; |
| float texture_y_scale = bloated_src_height / src_height; |
| |
| // Adjust positions so that we're addressing full fragments in the output, per |
| // the top-left filling convention. The shifts would be equivalent to |
| // 1/dst_width and 1/dst_height, if we were to calculate those explicitly. |
| vtx.position.x -= align.x / bloated_src_width; |
| vtx.position.y += align.y / bloated_src_height; |
| |
| // Apply the texture scale |
| vtx.texCoord.x *= texture_x_scale; |
| vtx.texCoord.y *= texture_y_scale; |
| |
| return vtx; |
| } |
| |
| /////////////////////////////////////////////////////////////////////// |
| // RGB24 to YV12 in two passes; writing two 8888 targets each pass. |
| // |
| // YV12 is full-resolution luma and half-resolution blue/red chroma. |
| // |
| // (original) |
| // XRGB XRGB XRGB XRGB XRGB XRGB XRGB XRGB |
| // XRGB XRGB XRGB XRGB XRGB XRGB XRGB XRGB |
| // XRGB XRGB XRGB XRGB XRGB XRGB XRGB XRGB |
| // XRGB XRGB XRGB XRGB XRGB XRGB XRGB XRGB |
| // XRGB XRGB XRGB XRGB XRGB XRGB XRGB XRGB |
| // XRGB XRGB XRGB XRGB XRGB XRGB XRGB XRGB |
| // | |
| // | (y plane) (temporary) |
| // | YYYY YYYY UVUV UVUV |
| // +--> { YYYY YYYY + UVUV UVUV } |
| // YYYY YYYY UVUV UVUV |
| // First YYYY YYYY UVUV UVUV |
| // pass YYYY YYYY UVUV UVUV |
| // YYYY YYYY UVUV UVUV |
| // | |
| // | (u plane) (v plane) |
| // Second | UUUU VVVV |
| // pass +--> { UUUU + VVVV } |
| // UUUU VVVV |
| // |
| /////////////////////////////////////////////////////////////////////// |
| |
| // Phase one of RGB24->YV12 conversion: vsFetch4Pixels/psConvertRGBtoY8UV44 |
| // |
| // @gyp_compile(vs_2_0, vsFetch4Pixels) |
| // @gyp_compile(ps_2_0, psConvertRGBtoY8UV44) |
| // |
| // Writes four source pixels at a time to a full-size Y plane and a half-width |
| // interleaved UV plane. After execution, the Y plane is complete but the UV |
| // planes still need to be de-interleaved and vertically scaled. |
| // |
| void vsFetch4Pixels(in Vertex vertex, |
| out float4 position : POSITION, |
| out float2 texCoord0 : TEXCOORD0, |
| out float2 texCoord1 : TEXCOORD1, |
| out float2 texCoord2 : TEXCOORD2, |
| out float2 texCoord3 : TEXCOORD3) { |
| Vertex adjusted = adjustForAlignmentAndPacking(vertex, float2(4, 1)); |
| |
| // Set up four taps, aligned to texel centers if the src's true size is |
| // |kRenderTargetSize|, and doing bilinear interpolation otherwise. |
| float2 one_texel_x = float2(1 / kRenderTargetSize.x, 0); |
| position = adjusted.position; |
| texCoord0 = adjusted.texCoord - 1.5f * one_texel_x; |
| texCoord1 = adjusted.texCoord - 0.5f * one_texel_x; |
| texCoord2 = adjusted.texCoord + 0.5f * one_texel_x; |
| texCoord3 = adjusted.texCoord + 1.5f * one_texel_x; |
| }; |
| |
| struct YV16QuadPixel |
| { |
| float4 YYYY : COLOR0; |
| float4 UUVV : COLOR1; |
| }; |
| |
| // Color conversion constants. |
| static const float3x1 rgb_to_y = float3x1( +0.257f, +0.504f, +0.098f ); |
| static const float3x1 rgb_to_u = float3x1( -0.148f, -0.291f, +0.439f ); |
| static const float3x1 rgb_to_v = float3x1( +0.439f, -0.368f, -0.071f ); |
| static const float y_bias = 0.0625f; |
| static const float uv_bias = 0.5f; |
| |
| YV16QuadPixel psConvertRGBtoY8UV44(float2 texCoord0 : TEXCOORD0, |
| float2 texCoord1 : TEXCOORD1, |
| float2 texCoord2 : TEXCOORD2, |
| float2 texCoord3 : TEXCOORD3) { |
| // Load the four texture samples into a matrix. |
| float4x3 rgb_quad_pixel = float4x3(tex2D(s, texCoord0).rgb, |
| tex2D(s, texCoord1).rgb, |
| tex2D(s, texCoord2).rgb, |
| tex2D(s, texCoord3).rgb); |
| |
| // RGB -> Y conversion (x4). |
| float4 yyyy = mul(rgb_quad_pixel, rgb_to_y) + y_bias; |
| |
| // Average adjacent texture samples while converting RGB->UV. This is the same |
| // as color converting then averaging, but slightly less math. These values |
| // will be in the range [-0.439f, +0.439f] and still need to have the bias |
| // term applied. |
| float2x3 rgb_double_pixel = float2x3(rgb_quad_pixel[0] + rgb_quad_pixel[1], |
| rgb_quad_pixel[2] + rgb_quad_pixel[3]); |
| float2 uu = mul(rgb_double_pixel, rgb_to_u / 2); |
| float2 vv = mul(rgb_double_pixel, rgb_to_v / 2); |
| |
| // Package the result to account for BGRA byte ordering. |
| YV16QuadPixel result; |
| result.YYYY = packForByteOrder(yyyy); |
| result.UUVV.xyzw = float4(uu, vv) + uv_bias; // Apply uv bias. |
| return result; |
| }; |
| |
| // Phase two of RGB24->YV12 conversion: vsFetch2Pixels/psConvertUV44toU2V2 |
| // |
| // @gyp_compile(vs_2_0, vsFetch2Pixels) |
| // @gyp_compile(ps_2_0, psConvertUV44toU2V2) |
| // |
| // Deals with UV only. Input is interleaved UV pixels, already scaled |
| // horizontally, packed two per RGBA texel. Output is two color planes U and V, |
| // packed four to a RGBA pixel. |
| // |
| // Vertical scaling happens via a half-texel offset and bilinear interpolation |
| // during texture sampling. |
| void vsFetch2Pixels(in Vertex vertex, |
| out float4 position : POSITION, |
| out float2 texCoord0 : TEXCOORD0, |
| out float2 texCoord1 : TEXCOORD1) { |
| // We fetch two texels in the horizontal direction, and scale by 2 in the |
| // vertical direction. |
| Vertex adjusted = adjustForAlignmentAndPacking(vertex, float2(2, 2)); |
| |
| // Setup the two texture coordinates. No need to adjust texCoord.y; it's |
| // already at the mid-way point between the two rows. Horizontally, we'll |
| // fetch two texels so that we have enough data to fill our output. |
| float2 one_texel_x = float2(1 / kRenderTargetSize.x, 0); |
| position = adjusted.position; |
| texCoord0 = adjusted.texCoord - 0.5f * one_texel_x; |
| texCoord1 = adjusted.texCoord + 0.5f * one_texel_x; |
| }; |
| |
| struct UV8QuadPixel { |
| float4 UUUU : COLOR0; |
| float4 VVVV : COLOR1; |
| }; |
| |
| UV8QuadPixel psConvertUV44toU2V2(float2 texCoord0 : TEXCOORD0, |
| float2 texCoord1 : TEXCOORD1) { |
| // We're just sampling two pixels and unswizzling them. There's no need to do |
| // vertical scaling with math, since bilinear interpolation in the sampler |
| // takes care of that. |
| float4 lo_uuvv = tex2D(s, texCoord0); |
| float4 hi_uuvv = tex2D(s, texCoord1); |
| UV8QuadPixel result; |
| result.UUUU = packForByteOrder(float4(lo_uuvv.xy, hi_uuvv.xy)); |
| result.VVVV = packForByteOrder(float4(lo_uuvv.zw, hi_uuvv.zw)); |
| return result; |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////// |
| // RGB24 to YV12 in three passes, without MRT: one pass per output color plane. |
| // vsFetch4Pixels is the common vertex shader for all three passes. |
| // |
| // Note that this technique will not do full bilinear filtering on its RGB |
| // input (you'd get correctly filtered Y, but aliasing in U and V). |
| // |
| // Pass 1: vsFetch4Pixels + psConvertRGBToY |
| // Pass 2: vsFetch4Pixels_Scale2 + psConvertRGBToU |
| // Pass 3: vsFetch4Pixels_Scale2 + psConvertRGBToV |
| // |
| // @gyp_compile(vs_2_0, vsFetch4Pixels_Scale2) |
| // @gyp_compile(ps_2_0, psConvertRGBtoY) |
| // @gyp_compile(ps_2_0, psConvertRGBtoU) |
| // @gyp_compile(ps_2_0, psConvertRGBtoV) |
| // |
| /////////////////////////////////////////////////////////////////////// |
| void vsFetch4Pixels_Scale2(in Vertex vertex, |
| out float4 position : POSITION, |
| out float2 texCoord0 : TEXCOORD0, |
| out float2 texCoord1 : TEXCOORD1, |
| out float2 texCoord2 : TEXCOORD2, |
| out float2 texCoord3 : TEXCOORD3) { |
| Vertex adjusted = adjustForAlignmentAndPacking(vertex, float2(8, 2)); |
| |
| // Set up four taps, each of which samples a 2x2 texel quad at the midpoint. |
| float2 one_texel_x = float2(1 / kRenderTargetSize.x, 0); |
| position = adjusted.position; |
| texCoord0 = adjusted.texCoord - 3 * one_texel_x; |
| texCoord1 = adjusted.texCoord - 1 * one_texel_x; |
| texCoord2 = adjusted.texCoord + 1 * one_texel_x; |
| texCoord3 = adjusted.texCoord + 3 * one_texel_x; |
| }; |
| |
| // RGB -> Y, four samples at a time. |
| float4 psConvertRGBtoY(float2 texCoord0 : TEXCOORD0, |
| float2 texCoord1 : TEXCOORD1, |
| float2 texCoord2 : TEXCOORD2, |
| float2 texCoord3 : TEXCOORD3) : COLOR0 { |
| float4x3 rgb_quad_pixel = float4x3(tex2D(s, texCoord0).rgb, |
| tex2D(s, texCoord1).rgb, |
| tex2D(s, texCoord2).rgb, |
| tex2D(s, texCoord3).rgb); |
| return packForByteOrder(mul(rgb_quad_pixel, rgb_to_y) + y_bias); |
| } |
| |
| // RGB -> U, four samples at a time. |
| float4 psConvertRGBtoU(float2 texCoord0 : TEXCOORD0, |
| float2 texCoord1 : TEXCOORD1, |
| float2 texCoord2 : TEXCOORD2, |
| float2 texCoord3 : TEXCOORD3) : COLOR0 { |
| float4x3 rgb_quad_pixel = float4x3(tex2D(s, texCoord0).rgb, |
| tex2D(s, texCoord1).rgb, |
| tex2D(s, texCoord2).rgb, |
| tex2D(s, texCoord3).rgb); |
| return packForByteOrder(mul(rgb_quad_pixel, rgb_to_u) + uv_bias); |
| } |
| |
| // RGB -> V, four samples at a time. |
| float4 psConvertRGBtoV(float2 texCoord0 : TEXCOORD0, |
| float2 texCoord1 : TEXCOORD1, |
| float2 texCoord2 : TEXCOORD2, |
| float2 texCoord3 : TEXCOORD3) : COLOR0 { |
| float4x3 rgb_quad_pixel = float4x3(tex2D(s, texCoord0).rgb, |
| tex2D(s, texCoord1).rgb, |
| tex2D(s, texCoord2).rgb, |
| tex2D(s, texCoord3).rgb); |
| return packForByteOrder(mul(rgb_quad_pixel, rgb_to_v) + uv_bias); |
| } |