// 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