| // Copyright (c) 2013 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. |
| |
| #include "content/browser/renderer_host/compositing_iosurface_shader_programs_mac.h" |
| |
| #include <string> |
| #include <OpenGL/gl.h> |
| |
| #include "base/basictypes.h" |
| #include "base/debug/trace_event.h" |
| #include "base/logging.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "base/values.h" |
| #include "content/browser/gpu/gpu_data_manager_impl.h" |
| #include "gpu/config/gpu_driver_bug_workaround_type.h" |
| |
| namespace content { |
| |
| namespace { |
| |
| // Convenience macro allowing GLSL programs to be specified inline, and to be |
| // automatically converted into string form by the C preprocessor. |
| #define GLSL_PROGRAM_AS_STRING(shader_code) #shader_code |
| |
| // As required by the spec, add the version directive to the beginning of each |
| // program to activate the expected syntax and built-in features. GLSL version |
| // 1.2 is the latest version supported by MacOS 10.6. |
| const char kVersionDirective[] = "#version 120\n"; |
| |
| // Allow switchable output swizzling from RGBToYV12 fragment shaders (needed for |
| // workaround; see comments in CompositingIOSurfaceShaderPrograms ctor). |
| const char kOutputSwizzleMacroNormal[] = "#define OUTPUT_PIXEL_ORDERING bgra\n"; |
| const char kOutputSwizzleMacroSwapRB[] = "#define OUTPUT_PIXEL_ORDERING rgba\n"; |
| |
| // Only the bare-bones calculations here for speed. |
| const char kvsBlit[] = GLSL_PROGRAM_AS_STRING( |
| varying vec2 texture_coord; |
| void main() { |
| gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; |
| texture_coord = gl_MultiTexCoord0.xy; |
| } |
| ); |
| |
| // Just samples the texture. |
| const char kfsBlit[] = GLSL_PROGRAM_AS_STRING( |
| uniform sampler2DRect texture_; |
| varying vec2 texture_coord; |
| void main() { |
| gl_FragColor = vec4(texture2DRect(texture_, texture_coord).rgb, 1.0); |
| } |
| ); |
| |
| |
| // Only calculates position. |
| const char kvsSolidWhite[] = GLSL_PROGRAM_AS_STRING( |
| void main() { |
| gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; |
| } |
| ); |
| |
| // Always white. |
| const char kfsSolidWhite[] = GLSL_PROGRAM_AS_STRING( |
| void main() { |
| gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0); |
| } |
| ); |
| |
| |
| /////////////////////////////////////////////////////////////////////// |
| // 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 UUVV UUVV |
| // +--> { YYYY YYYY + UUVV UUVV } |
| // YYYY YYYY UUVV UUVV |
| // First YYYY YYYY UUVV UUVV |
| // pass YYYY YYYY UUVV UUVV |
| // YYYY YYYY UUVV UUVV |
| // | |
| // | (u plane) (v plane) |
| // Second | UUUU VVVV |
| // pass +--> { UUUU + VVVV } |
| // UUUU VVVV |
| // |
| /////////////////////////////////////////////////////////////////////// |
| |
| // Phase one of RGB24->YV12 conversion: vsFetch4Pixels/fsConvertRGBtoY8UV44 |
| // |
| // 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. |
| const char kRGBtoYV12_vsFetch4Pixels[] = GLSL_PROGRAM_AS_STRING( |
| uniform float texel_scale_x_; |
| varying vec2 texture_coord0; |
| varying vec2 texture_coord1; |
| varying vec2 texture_coord2; |
| varying vec2 texture_coord3; |
| void main() { |
| gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; |
| |
| vec2 texcoord_base = gl_MultiTexCoord0.xy; |
| vec2 one_texel_x = vec2(texel_scale_x_, 0.0); |
| texture_coord0 = texcoord_base - 1.5 * one_texel_x; |
| texture_coord1 = texcoord_base - 0.5 * one_texel_x; |
| texture_coord2 = texcoord_base + 0.5 * one_texel_x; |
| texture_coord3 = texcoord_base + 1.5 * one_texel_x; |
| } |
| ); |
| |
| const char kRGBtoYV12_fsConvertRGBtoY8UV44[] = GLSL_PROGRAM_AS_STRING( |
| const vec3 rgb_to_y = vec3(0.257, 0.504, 0.098); |
| const vec3 rgb_to_u = vec3(-0.148, -0.291, 0.439); |
| const vec3 rgb_to_v = vec3(0.439, -0.368, -0.071); |
| const float y_bias = 0.0625; |
| const float uv_bias = 0.5; |
| uniform sampler2DRect texture_; |
| varying vec2 texture_coord0; |
| varying vec2 texture_coord1; |
| varying vec2 texture_coord2; |
| varying vec2 texture_coord3; |
| void main() { |
| // Load the four texture samples. |
| vec3 pixel0 = texture2DRect(texture_, texture_coord0).rgb; |
| vec3 pixel1 = texture2DRect(texture_, texture_coord1).rgb; |
| vec3 pixel2 = texture2DRect(texture_, texture_coord2).rgb; |
| vec3 pixel3 = texture2DRect(texture_, texture_coord3).rgb; |
| |
| // RGB -> Y conversion (x4). |
| vec4 yyyy = vec4(dot(pixel0, rgb_to_y), |
| dot(pixel1, rgb_to_y), |
| dot(pixel2, rgb_to_y), |
| dot(pixel3, 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. |
| vec3 blended_pixel0 = pixel0 + pixel1; |
| vec3 blended_pixel1 = pixel2 + pixel3; |
| vec2 uu = vec2(dot(blended_pixel0, rgb_to_u), |
| dot(blended_pixel1, rgb_to_u)) / 2.0; |
| vec2 vv = vec2(dot(blended_pixel0, rgb_to_v), |
| dot(blended_pixel1, rgb_to_v)) / 2.0; |
| |
| gl_FragData[0] = yyyy.OUTPUT_PIXEL_ORDERING; |
| gl_FragData[1] = vec4(uu, vv) + uv_bias; |
| } |
| ); |
| |
| // Phase two of RGB24->YV12 conversion: vsFetch2Pixels/fsConvertUV44toU2V2 |
| // |
| // Deals with UV only. Input is two UUVV quads. The pixels have already been |
| // scaled horizontally prior to this point, and vertical scaling will now happen |
| // via bilinear interpolation during texture sampling. Output is two color |
| // planes U and V, packed four pixels to a "RGBA" quad. |
| const char kRGBtoYV12_vsFetch2Pixels[] = GLSL_PROGRAM_AS_STRING( |
| varying vec2 texture_coord0; |
| varying vec2 texture_coord1; |
| void main() { |
| gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; |
| |
| vec2 texcoord_base = gl_MultiTexCoord0.xy; |
| texture_coord0 = texcoord_base - vec2(0.5, 0.0); |
| texture_coord1 = texcoord_base + vec2(0.5, 0.0); |
| } |
| ); |
| |
| const char kRGBtoYV12_fsConvertUV44toU2V2[] = GLSL_PROGRAM_AS_STRING( |
| uniform sampler2DRect texture_; |
| varying vec2 texture_coord0; |
| varying vec2 texture_coord1; |
| void main() { |
| // 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. |
| vec4 lo_uuvv = texture2DRect(texture_, texture_coord0); |
| vec4 hi_uuvv = texture2DRect(texture_, texture_coord1); |
| gl_FragData[0] = vec4(lo_uuvv.rg, hi_uuvv.rg).OUTPUT_PIXEL_ORDERING; |
| gl_FragData[1] = vec4(lo_uuvv.ba, hi_uuvv.ba).OUTPUT_PIXEL_ORDERING; |
| } |
| ); |
| |
| |
| enum ShaderProgram { |
| SHADER_PROGRAM_BLIT = 0, |
| SHADER_PROGRAM_SOLID_WHITE, |
| SHADER_PROGRAM_RGB_TO_YV12__1_OF_2, |
| SHADER_PROGRAM_RGB_TO_YV12__2_OF_2, |
| NUM_SHADER_PROGRAMS |
| }; |
| |
| // The code snippets that together make up an entire vertex shader program. |
| const char* kVertexShaderSourceCodeMap[] = { |
| // SHADER_PROGRAM_BLIT |
| kvsBlit, |
| // SHADER_PROGRAM_SOLID_WHITE |
| kvsSolidWhite, |
| |
| // SHADER_PROGRAM_RGB_TO_YV12__1_OF_2 |
| kRGBtoYV12_vsFetch4Pixels, |
| // SHADER_PROGRAM_RGB_TO_YV12__2_OF_2 |
| kRGBtoYV12_vsFetch2Pixels, |
| }; |
| |
| // The code snippets that together make up an entire fragment shader program. |
| const char* kFragmentShaderSourceCodeMap[] = { |
| // SHADER_PROGRAM_BLIT |
| kfsBlit, |
| // SHADER_PROGRAM_SOLID_WHITE |
| kfsSolidWhite, |
| |
| // SHADER_PROGRAM_RGB_TO_YV12__1_OF_2 |
| kRGBtoYV12_fsConvertRGBtoY8UV44, |
| // SHADER_PROGRAM_RGB_TO_YV12__2_OF_2 |
| kRGBtoYV12_fsConvertUV44toU2V2, |
| }; |
| |
| GLuint CompileShaderGLSL(ShaderProgram shader_program, GLenum shader_type, |
| bool output_swap_rb) { |
| TRACE_EVENT2("gpu", "CompileShaderGLSL", |
| "program", shader_program, |
| "type", shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment"); |
| |
| DCHECK_GE(shader_program, 0); |
| DCHECK_LT(shader_program, NUM_SHADER_PROGRAMS); |
| |
| const GLuint shader = glCreateShader(shader_type); |
| DCHECK_NE(shader, 0u); |
| |
| // Select and compile the shader program source code. |
| if (shader_type == GL_VERTEX_SHADER) { |
| const GLchar* source_snippets[] = { |
| kVersionDirective, |
| kVertexShaderSourceCodeMap[shader_program], |
| }; |
| glShaderSource(shader, arraysize(source_snippets), source_snippets, NULL); |
| } else { |
| DCHECK(shader_type == GL_FRAGMENT_SHADER); |
| const GLchar* source_snippets[] = { |
| kVersionDirective, |
| output_swap_rb ? kOutputSwizzleMacroSwapRB : kOutputSwizzleMacroNormal, |
| kFragmentShaderSourceCodeMap[shader_program], |
| }; |
| glShaderSource(shader, arraysize(source_snippets), source_snippets, NULL); |
| } |
| glCompileShader(shader); |
| |
| // Check for successful compilation. On error in debug builds, pull the info |
| // log and emit the compiler messages. |
| GLint error; |
| glGetShaderiv(shader, GL_COMPILE_STATUS, &error); |
| if (error != GL_TRUE) { |
| #ifndef NDEBUG |
| static const int kMaxInfoLogLength = 8192; |
| scoped_ptr<char[]> buffer(new char[kMaxInfoLogLength]); |
| GLsizei length_returned = 0; |
| glGetShaderInfoLog(shader, kMaxInfoLogLength - 1, &length_returned, |
| buffer.get()); |
| buffer[kMaxInfoLogLength - 1] = '\0'; |
| DLOG(ERROR) << "Failed to compile " |
| << (shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment") |
| << " shader for program " << shader_program << ":\n" |
| << buffer.get() |
| << (length_returned >= kMaxInfoLogLength ? |
| "\n*** TRUNCATED! ***" : ""); |
| #endif |
| glDeleteShader(shader); |
| return 0; |
| } |
| |
| // Success! |
| return shader; |
| } |
| |
| GLuint CompileAndLinkProgram(ShaderProgram which, bool output_swap_rb) { |
| TRACE_EVENT1("gpu", "CompileAndLinkProgram", "program", which); |
| |
| // Compile and link a new shader program. |
| const GLuint vertex_shader = |
| CompileShaderGLSL(which, GL_VERTEX_SHADER, false); |
| const GLuint fragment_shader = |
| CompileShaderGLSL(which, GL_FRAGMENT_SHADER, output_swap_rb); |
| const GLuint program = glCreateProgram(); |
| DCHECK_NE(program, 0u); |
| glAttachShader(program, vertex_shader); |
| glAttachShader(program, fragment_shader); |
| glLinkProgram(program); |
| |
| // Flag shaders for deletion so that they will be deleted automatically when |
| // the program is later deleted. |
| glDeleteShader(vertex_shader); |
| glDeleteShader(fragment_shader); |
| |
| // Check that the program successfully linked. |
| GLint error = GL_FALSE; |
| glGetProgramiv(program, GL_LINK_STATUS, &error); |
| if (error != GL_TRUE) { |
| glDeleteProgram(program); |
| return 0; |
| } |
| return program; |
| } |
| |
| } // namespace |
| |
| |
| CompositingIOSurfaceShaderPrograms::CompositingIOSurfaceShaderPrograms() |
| : rgb_to_yv12_output_format_(GL_BGRA) { |
| COMPILE_ASSERT(kNumShaderPrograms == NUM_SHADER_PROGRAMS, |
| header_constant_disagrees_with_enum); |
| COMPILE_ASSERT(arraysize(kVertexShaderSourceCodeMap) == NUM_SHADER_PROGRAMS, |
| vertex_shader_source_code_map_incorrect_size); |
| COMPILE_ASSERT(arraysize(kFragmentShaderSourceCodeMap) == NUM_SHADER_PROGRAMS, |
| fragment_shader_source_code_map_incorrect_size); |
| |
| memset(shader_programs_, 0, sizeof(shader_programs_)); |
| for (size_t i = 0; i < arraysize(texture_var_locations_); ++i) |
| texture_var_locations_[i] = -1; |
| for (size_t i = 0; i < arraysize(texel_scale_x_var_locations_); ++i) |
| texel_scale_x_var_locations_[i] = -1; |
| |
| // Look for the swizzle_rgba_for_async_readpixels driver bug workaround and |
| // modify rgb_to_yv12_output_format_ if necessary. |
| // See: http://crbug.com/265115 |
| GpuDataManagerImpl* const manager = GpuDataManagerImpl::GetInstance(); |
| if (manager) { |
| base::ListValue workarounds; |
| manager->GetDriverBugWorkarounds(&workarounds); |
| base::ListValue::const_iterator it = workarounds.Find( |
| base::StringValue(gpu::GpuDriverBugWorkaroundTypeToString( |
| gpu::SWIZZLE_RGBA_FOR_ASYNC_READPIXELS))); |
| if (it != workarounds.end()) |
| rgb_to_yv12_output_format_ = GL_RGBA; |
| } |
| DVLOG(1) << "Using RGBToYV12 fragment shader output format: " |
| << (rgb_to_yv12_output_format_ == GL_BGRA ? "BGRA" : "RGBA"); |
| } |
| |
| CompositingIOSurfaceShaderPrograms::~CompositingIOSurfaceShaderPrograms() { |
| #ifndef NDEBUG |
| for (size_t i = 0; i < arraysize(shader_programs_); ++i) |
| DCHECK_EQ(shader_programs_[i], 0u) << "Failed to call Reset()."; |
| #endif |
| } |
| |
| void CompositingIOSurfaceShaderPrograms::Reset() { |
| for (size_t i = 0; i < arraysize(shader_programs_); ++i) { |
| if (shader_programs_[i] != 0u) { |
| glDeleteProgram(shader_programs_[i]); |
| shader_programs_[i] = 0u; |
| } |
| } |
| for (size_t i = 0; i < arraysize(texture_var_locations_); ++i) |
| texture_var_locations_[i] = -1; |
| for (size_t i = 0; i < arraysize(texel_scale_x_var_locations_); ++i) |
| texel_scale_x_var_locations_[i] = -1; |
| } |
| |
| bool CompositingIOSurfaceShaderPrograms::UseBlitProgram() { |
| const GLuint program = GetShaderProgram(SHADER_PROGRAM_BLIT); |
| if (program == 0u) |
| return false; |
| glUseProgram(program); |
| BindUniformTextureVariable(SHADER_PROGRAM_BLIT, 0); |
| return true; |
| } |
| |
| bool CompositingIOSurfaceShaderPrograms::UseSolidWhiteProgram() { |
| const GLuint program = GetShaderProgram(SHADER_PROGRAM_SOLID_WHITE); |
| if (program == 0u) |
| return false; |
| glUseProgram(program); |
| return true; |
| } |
| |
| bool CompositingIOSurfaceShaderPrograms::UseRGBToYV12Program( |
| int pass_number, float texel_scale_x) { |
| const int which = SHADER_PROGRAM_RGB_TO_YV12__1_OF_2 + pass_number - 1; |
| DCHECK_GE(which, SHADER_PROGRAM_RGB_TO_YV12__1_OF_2); |
| DCHECK_LE(which, SHADER_PROGRAM_RGB_TO_YV12__2_OF_2); |
| |
| const GLuint program = GetShaderProgram(which); |
| if (program == 0u) |
| return false; |
| glUseProgram(program); |
| BindUniformTextureVariable(which, 0); |
| if (which == SHADER_PROGRAM_RGB_TO_YV12__1_OF_2) { |
| BindUniformTexelScaleXVariable(which, texel_scale_x); |
| } else { |
| // The second pass doesn't have a texel_scale_x uniform variable since it's |
| // never supposed to be doing any scaling (i.e., outside of the usual |
| // 2x2-->1x1 that's already built into the process). |
| DCHECK_EQ(texel_scale_x, 1.0f); |
| } |
| return true; |
| } |
| |
| void CompositingIOSurfaceShaderPrograms::SetOutputFormatForTesting( |
| GLenum format) { |
| rgb_to_yv12_output_format_ = format; |
| Reset(); |
| } |
| |
| GLuint CompositingIOSurfaceShaderPrograms::GetShaderProgram(int which) { |
| if (shader_programs_[which] == 0u) { |
| shader_programs_[which] = |
| CompileAndLinkProgram(static_cast<ShaderProgram>(which), |
| rgb_to_yv12_output_format_ == GL_RGBA); |
| DCHECK_NE(shader_programs_[which], 0u) |
| << "Failed to create ShaderProgram " << which; |
| } |
| return shader_programs_[which]; |
| } |
| |
| void CompositingIOSurfaceShaderPrograms::BindUniformTextureVariable( |
| int which, int texture_unit_offset) { |
| if (texture_var_locations_[which] == -1) { |
| texture_var_locations_[which] = |
| glGetUniformLocation(GetShaderProgram(which), "texture_"); |
| DCHECK_NE(texture_var_locations_[which], -1) |
| << "Failed to find location of uniform variable: texture_"; |
| } |
| glUniform1i(texture_var_locations_[which], texture_unit_offset); |
| } |
| |
| void CompositingIOSurfaceShaderPrograms::BindUniformTexelScaleXVariable( |
| int which, float texel_scale_x) { |
| if (texel_scale_x_var_locations_[which] == -1) { |
| texel_scale_x_var_locations_[which] = |
| glGetUniformLocation(GetShaderProgram(which), "texel_scale_x_"); |
| DCHECK_NE(texel_scale_x_var_locations_[which], -1) |
| << "Failed to find location of uniform variable: texel_scale_x_"; |
| } |
| glUniform1f(texel_scale_x_var_locations_[which], texel_scale_x); |
| } |
| |
| } // namespace content |