1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "gpu/tools/compositor_model_bench/shaders.h" 6 7 #include <algorithm> 8 9 #include "gpu/tools/compositor_model_bench/render_model_utils.h" 10 #include "gpu/tools/compositor_model_bench/render_tree.h" 11 12 using std::min; 13 14 static const int kPositionLocation = 0; 15 static const int kTexCoordLocation = 1; 16 17 static unsigned g_quad_vertices_vbo; 18 static unsigned g_quad_elements_vbo; 19 20 // Store a pointer to the transform matrix of the active layer (the complete 21 // transform isn't build until we draw the quad; then we can apply 22 // translation/scaling/projection) 23 static float* g_current_layer_transform; 24 25 // In addition to the transform, store other useful information about tiled 26 // layers that we'll need to render each tile's quad 27 static float g_current_tile_layer_width; 28 static float g_current_tile_layer_height; 29 static float g_current_tile_width; 30 static float g_current_tile_height; 31 32 static const float yuv2RGB[9] = { 33 1.164f, 1.164f, 1.164f, 34 0.f, -.391f, 2.018f, 35 1.596f, -.813f, 0.f 36 }; 37 38 // Store shader programs in a sparse array so that they can be addressed easily. 39 static int g_program_objects[SHADER_ID_MAX*SHADER_ID_MAX]; 40 static int g_active_index = -1; 41 42 /////////////////////////////////////////////////////////////////////////////// 43 // L R B T N F 44 // glOrtho(0, WINDOW_WIDTH, WINDOW_HEIGHT, 0, -1, 1); // column major 45 46 static float g_projection_matrix[] = { 47 2.0 / WINDOW_WIDTH, 0.0, 0.0, 0.0, 48 0.0, 2.0 / -WINDOW_HEIGHT, 0.0, 0.0, 49 0.0, 0.0, -1.0, 0.0, 50 -1.0, 1.0, 0.0, 1.0 51 }; 52 53 #define ADDR(i, j) (i*4 + j) /* column major */ 54 static void Project(const float* v, float* p) { 55 for (int i = 0; i < 4; ++i) { 56 for (int j = 0; j < 4; ++j) { 57 p[ADDR(i, j)] = 0; 58 for (int k = 0; k < 4; ++k) { 59 p[ADDR(i, j)] += g_projection_matrix[ADDR(k, i)] * v[ADDR(j, k)]; 60 } 61 } 62 } 63 } 64 65 static void Scale(const float* in, float* out, float sx, float sy, float sz) { 66 for (int i = 0; i < 4; ++i) 67 out[i] = in[i] * sx; 68 for (int j = 4; j < 8; ++j) 69 out[j] = in[j] * sy; 70 for (int k = 8; k < 12; ++k) 71 out[k] = in[k] * sz; 72 for (int l = 12; l < 16; ++l) 73 out[l] = in[l]; 74 } 75 76 static void TranslateInPlace(float* m, float tx, float ty, float tz) { 77 m[12] += tx; 78 m[13] += ty; 79 m[14] += tz; 80 } 81 82 /////////////////////////////////////////////////////////////////////////////// 83 84 ShaderID ShaderIDFromString(std::string name) { 85 if (name == "VertexShaderPosTexYUVStretch") 86 return VERTEX_SHADER_POS_TEX_YUV_STRETCH; 87 if (name == "VertexShaderPosTex") 88 return VERTEX_SHADER_POS_TEX; 89 if (name == "VertexShaderPosTexTransform") 90 return VERTEX_SHADER_POS_TEX_TRANSFORM; 91 if (name == "FragmentShaderYUVVideo") 92 return FRAGMENT_SHADER_YUV_VIDEO; 93 if (name == "FragmentShaderRGBATexFlipAlpha") 94 return FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA; 95 if (name == "FragmentShaderRGBATexAlpha") 96 return FRAGMENT_SHADER_RGBA_TEX_ALPHA; 97 return SHADER_UNRECOGNIZED; 98 } 99 100 std::string ShaderNameFromID(ShaderID id) { 101 switch (id) { 102 case VERTEX_SHADER_POS_TEX_YUV_STRETCH: 103 return "VertexShaderPosTexYUVStretch"; 104 case VERTEX_SHADER_POS_TEX: 105 return "VertexShaderPosTex"; 106 case VERTEX_SHADER_POS_TEX_TRANSFORM: 107 return "VertexShaderPosTexTransform"; 108 case FRAGMENT_SHADER_YUV_VIDEO: 109 return "FragmentShaderYUVVideo"; 110 case FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA: 111 return "FragmentShaderRGBATexFlipAlpha"; 112 case FRAGMENT_SHADER_RGBA_TEX_ALPHA: 113 return "FragmentShaderRGBATexAlpha"; 114 default: 115 return "(unknown shader)"; 116 } 117 } 118 119 #define SHADER0(Src) #Src 120 #define SHADER(Src) SHADER0(Src) 121 122 const char* GetShaderSource(ShaderID shader) { 123 switch (shader) { 124 case VERTEX_SHADER_POS_TEX_YUV_STRETCH: 125 return SHADER( 126 #ifdef GL_ES 127 precision mediump float; 128 #endif 129 attribute vec4 a_position; 130 attribute vec2 a_texCoord; 131 uniform mat4 matrix; 132 varying vec2 y_texCoord; 133 varying vec2 uv_texCoord; 134 uniform float y_widthScaleFactor; 135 uniform float uv_widthScaleFactor; 136 void main() { 137 gl_Position = matrix * a_position; 138 y_texCoord = vec2(y_widthScaleFactor * a_texCoord.x, 139 a_texCoord.y); 140 uv_texCoord = vec2(uv_widthScaleFactor * a_texCoord.x, 141 a_texCoord.y); 142 }); 143 break; 144 case VERTEX_SHADER_POS_TEX: 145 return SHADER( 146 attribute vec4 a_position; 147 attribute vec2 a_texCoord; 148 uniform mat4 matrix; 149 varying vec2 v_texCoord; 150 void main() { 151 gl_Position = matrix * a_position; 152 v_texCoord = a_texCoord; 153 }); 154 break; 155 case VERTEX_SHADER_POS_TEX_TRANSFORM: 156 return SHADER( 157 attribute vec4 a_position; 158 attribute vec2 a_texCoord; 159 uniform mat4 matrix; 160 uniform vec4 texTransform; 161 varying vec2 v_texCoord; 162 void main() { 163 gl_Position = matrix * a_position; 164 v_texCoord = a_texCoord*texTransform.zw + texTransform.xy; 165 }); 166 break; 167 case FRAGMENT_SHADER_YUV_VIDEO: 168 return SHADER( 169 #ifdef GL_ES 170 precision mediump float; 171 precision mediump int; 172 #endif 173 varying vec2 y_texCoord; 174 varying vec2 uv_texCoord; 175 uniform sampler2D y_texture; 176 uniform sampler2D u_texture; 177 uniform sampler2D v_texture; 178 uniform float alpha; 179 uniform vec3 yuv_adj; 180 uniform mat3 cc_matrix; 181 void main() { 182 float y_raw = texture2D(y_texture, y_texCoord).x; 183 float u_unsigned = texture2D(u_texture, uv_texCoord).x; 184 float v_unsigned = texture2D(v_texture, uv_texCoord).x; 185 vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj; 186 vec3 rgb = cc_matrix * yuv; 187 gl_FragColor = vec4(rgb, 1.0) * alpha; 188 }); 189 break; 190 case FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA: 191 return SHADER( 192 #ifdef GL_ES 193 precision mediump float; 194 #endif 195 varying vec2 v_texCoord; 196 uniform sampler2D s_texture; 197 uniform float alpha; 198 void main() { 199 vec4 texColor = texture2D(s_texture, 200 vec2(v_texCoord.x, 1.0 - v_texCoord.y)); 201 gl_FragColor = vec4(texColor.x, 202 texColor.y, 203 texColor.z, 204 texColor.w) * alpha; 205 }); 206 break; 207 case FRAGMENT_SHADER_RGBA_TEX_ALPHA: 208 return SHADER( 209 #ifdef GL_ES 210 precision mediump float; 211 #endif 212 varying vec2 v_texCoord; 213 uniform sampler2D s_texture; 214 uniform float alpha; 215 void main() { 216 vec4 texColor = texture2D(s_texture, v_texCoord); 217 gl_FragColor = texColor * alpha; 218 }); 219 break; 220 default: 221 printf("Shader source requested for unknown shader\n"); 222 return ""; 223 } 224 } 225 226 int GetProgramIdx(ShaderID v, ShaderID f) { 227 return v * SHADER_ID_MAX + f; 228 } 229 230 static void ReportAnyShaderCompilationErrors(GLuint shader, ShaderID id) { 231 GLint status; 232 glGetShaderiv(shader, GL_COMPILE_STATUS, &status); 233 if (status) 234 return; 235 // Get the length of the log string 236 GLsizei length; 237 glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length); 238 scoped_ptr<GLchar[]> log(new GLchar[length+1]); 239 glGetShaderInfoLog(shader, length, NULL, log.get()); 240 LOG(ERROR) << log.get() << " in shader " << ShaderNameFromID(id); 241 } 242 243 static int ActivateShader(ShaderID v, ShaderID f, float* layer_transform) { 244 int program_index = GetProgramIdx(v, f); 245 if (!g_program_objects[program_index]) { 246 g_program_objects[program_index] = glCreateProgramObjectARB(); 247 GLenum vs = glCreateShaderObjectARB(GL_VERTEX_SHADER); 248 GLenum fs = glCreateShaderObjectARB(GL_FRAGMENT_SHADER); 249 const char* vs_source = GetShaderSource(v); 250 const char* fs_source = GetShaderSource(f); 251 glShaderSourceARB(vs, 1, &vs_source, 0); 252 glShaderSourceARB(fs, 1, &fs_source, 0); 253 glCompileShaderARB(vs); 254 ReportAnyShaderCompilationErrors(vs, v); 255 glCompileShaderARB(fs); 256 ReportAnyShaderCompilationErrors(fs, f); 257 glAttachObjectARB(g_program_objects[program_index], vs); 258 glAttachObjectARB(g_program_objects[program_index], fs); 259 glBindAttribLocationARB(g_program_objects[program_index], 260 kPositionLocation, 261 "a_position"); 262 glBindAttribLocationARB(g_program_objects[program_index], 263 kTexCoordLocation, 264 "a_texCoord"); 265 glLinkProgramARB(g_program_objects[program_index]); 266 } 267 if (g_active_index != program_index) 268 glUseProgramObjectARB(g_program_objects[program_index]); 269 g_active_index = program_index; 270 271 g_current_layer_transform = layer_transform; 272 273 return g_program_objects[program_index]; 274 } 275 276 void ConfigAndActivateShaderForNode(CCNode* n) { 277 ShaderID vs = n->vertex_shader(); 278 ShaderID fs = n->fragment_shader(); 279 float* transform = n->transform(); 280 int program = ActivateShader(vs, fs, transform); 281 if (vs == VERTEX_SHADER_POS_TEX_YUV_STRETCH) { 282 GLint y_scale = glGetUniformLocationARB(program, "y_widthScaleFactor"); 283 GLint uv_scale = glGetUniformLocationARB(program, "uv_widthScaleFactor"); 284 glUniform1fARB(y_scale, 1.0); 285 glUniform1fARB(uv_scale, 1.0); 286 } 287 if (vs == VERTEX_SHADER_POS_TEX_TRANSFORM) { 288 GLint texTrans = glGetUniformLocationARB(program, "texTransform"); 289 glUniform4fARB(texTrans, 0.0, 0.0, 0.0, 0.0); 290 } 291 if (fs == FRAGMENT_SHADER_RGBA_TEX_FLIP_ALPHA) { 292 DCHECK_EQ(n->num_textures(), 1u); 293 DCHECK_NE(n->texture(0)->texID, -1); 294 glActiveTexture(GL_TEXTURE0); 295 glBindTexture(GL_TEXTURE_2D, n->texture(0)->texID); 296 int sTexLoc = glGetUniformLocationARB(program, "s_texture"); 297 glUniform1iARB(sTexLoc, 0); 298 } 299 if (fs == FRAGMENT_SHADER_YUV_VIDEO) { 300 DCHECK_EQ(n->num_textures(), 3u); 301 DCHECK_NE(n->texture(0)->texID, -1); 302 DCHECK_NE(n->texture(1)->texID, -1); 303 DCHECK_NE(n->texture(2)->texID, -1); 304 // Bind Y tex. 305 glActiveTexture(GL_TEXTURE0); 306 glBindTexture(GL_TEXTURE_2D, n->texture(0)->texID); 307 int yTexLoc = glGetUniformLocationARB(program, "y_texture"); 308 glUniform1iARB(yTexLoc, 0); 309 // Bind U tex. 310 glActiveTexture(GL_TEXTURE0 + 1); 311 glBindTexture(GL_TEXTURE_2D, n->texture(1)->texID); 312 int uTexLoc = glGetUniformLocationARB(program, "u_texture"); 313 glUniform1iARB(uTexLoc, 1); 314 // Bind V tex. 315 glActiveTexture(GL_TEXTURE0 + 2); 316 glBindTexture(GL_TEXTURE_2D, n->texture(2)->texID); 317 int vTexLoc = glGetUniformLocationARB(program, "v_texture"); 318 glUniform1iARB(vTexLoc, 2); 319 // Set YUV offset. 320 int yuvAdjLoc = glGetUniformLocationARB(program, "yuv_adj"); 321 glUniform3fARB(yuvAdjLoc, -0.0625f, -0.5f, -0.5f); 322 // Set YUV matrix. 323 int ccMatLoc = glGetUniformLocationARB(program, "cc_matrix"); 324 glUniformMatrix3fvARB(ccMatLoc, 1, false, yuv2RGB); 325 } 326 GLint alpha = glGetUniformLocationARB(program, "alpha"); 327 glUniform1fARB(alpha, 0.9); 328 } 329 330 void ConfigAndActivateShaderForTiling(ContentLayerNode* n) { 331 int program = ActivateShader(VERTEX_SHADER_POS_TEX_TRANSFORM, 332 FRAGMENT_SHADER_RGBA_TEX_ALPHA, 333 n->transform()); 334 GLint texTrans = glGetUniformLocationARB(program, "texTransform"); 335 glUniform4fARB(texTrans, 0.0, 0.0, 1.0, 1.0); 336 GLint alpha = glGetUniformLocationARB(program, "alpha"); 337 glUniform1fARB(alpha, 0.9); 338 339 g_current_tile_layer_width = n->width(); 340 g_current_tile_layer_height = n->height(); 341 g_current_tile_width = n->tile_width(); 342 g_current_tile_height = n->tile_height(); 343 } 344 345 void DeleteShaders() { 346 g_active_index = -1; 347 glUseProgramObjectARB(0); 348 for (int i = 0; i < SHADER_ID_MAX*SHADER_ID_MAX; ++i) { 349 if (g_program_objects[i]) { 350 glDeleteObjectARB(g_program_objects[i]); 351 } 352 g_program_objects[i] = 0; 353 } 354 } 355 356 void InitBuffers() { 357 // Vertex positions and texture coordinates for the 4 corners of a 1x1 quad. 358 float vertices[] = { -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 359 -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 360 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 361 0.5f, 0.5f, 0.0f, 1.0f, 1.0f }; 362 uint16_t indices[] = { 0, 1, 2, 0, 2, 3}; 363 364 glGenBuffers(1, &g_quad_vertices_vbo); 365 glGenBuffers(1, &g_quad_elements_vbo); 366 glBindBuffer(GL_ARRAY_BUFFER, g_quad_vertices_vbo); 367 glBufferData(GL_ARRAY_BUFFER, 368 sizeof(vertices), 369 vertices, 370 GL_STATIC_DRAW); 371 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_quad_elements_vbo); 372 glBufferData(GL_ELEMENT_ARRAY_BUFFER, 373 sizeof(indices), 374 indices, 375 GL_STATIC_DRAW); 376 } 377 378 void BeginFrame() { 379 glBindBuffer(GL_ARRAY_BUFFER, g_quad_vertices_vbo); 380 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_quad_elements_vbo); 381 unsigned offset = 0; 382 glVertexAttribPointer(kPositionLocation, 383 3, 384 GL_FLOAT, 385 false, 386 5 * sizeof(float), 387 reinterpret_cast<void*>(offset)); 388 offset += 3 * sizeof(float); 389 glVertexAttribPointer(kTexCoordLocation, 390 2, 391 GL_FLOAT, 392 false, 393 5 * sizeof(float), 394 reinterpret_cast<void*>(offset)); 395 glEnableVertexAttribArray(kPositionLocation); 396 glEnableVertexAttribArray(kTexCoordLocation); 397 } 398 399 void DrawQuad(float width, float height) { 400 float mv_transform[16]; 401 float proj_transform[16]; 402 Scale(g_current_layer_transform, mv_transform, width, height, 1.0); 403 Project(mv_transform, proj_transform); 404 GLint mat = glGetUniformLocationARB(g_program_objects[g_active_index], 405 "matrix"); 406 glUniformMatrix4fvARB(mat, 1, GL_TRUE, proj_transform); 407 408 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0); 409 } 410 411 void DrawTileQuad(GLuint texID, int x, int y) { 412 float left = g_current_tile_width*x; 413 float top = g_current_tile_height*y; 414 if (left > g_current_tile_layer_width || top > g_current_tile_layer_height) 415 return; 416 417 float right = min(left+g_current_tile_width, g_current_tile_layer_width); 418 float bottom = min(top+g_current_tile_height, g_current_tile_layer_height); 419 float width = right-left; 420 float height = bottom-top; 421 422 int prog = g_program_objects[g_active_index]; 423 424 // Scale the texture if the full tile rectangle doesn't get drawn. 425 float u_scale = width / g_current_tile_width; 426 float v_scale = height / g_current_tile_height; 427 GLint texTrans = glGetUniformLocationARB(prog, "texTransform"); 428 glUniform4fARB(texTrans, 0.0, 0.0, u_scale, v_scale); 429 430 glActiveTexture(GL_TEXTURE0); 431 glBindTexture(GL_TEXTURE_2D, texID); 432 int texLoc = glGetUniformLocationARB(prog, "s_texture"); 433 glUniform1iARB(texLoc, 0); 434 435 float mv_transform[16]; 436 float proj_transform[16]; 437 Scale(g_current_layer_transform, mv_transform, width, height, 1.0); 438 439 // We have to position the tile by its center. 440 float center_x = (left+right)/2 - g_current_tile_layer_width/2; 441 float center_y = (top+bottom)/2 - g_current_tile_layer_height/2; 442 TranslateInPlace(mv_transform, center_x, center_y, 0.0); 443 444 Project(mv_transform, proj_transform); 445 GLint mat = glGetUniformLocationARB(prog, "matrix"); 446 glUniformMatrix4fvARB(mat, 1, GL_TRUE, proj_transform); 447 448 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0); 449 } 450 451
