Mac 420 video: Add core profile shaders

ui/gl/gl_image_io_surface.mm

 // Copyright 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 "ui/gl/gl_image_io_surface.h"
 
 #include <map>
 
 #include "base/callback_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/foundation_util.h"
 #include "base/strings/stringize_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_helper.h"
+#include "ui/gl/gl_implementation.h"
 #include "ui/gl/scoped_api.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/gl/scoped_cgl.h"
 
 // Note that this must be included after gl_bindings.h to avoid conflicts.
 #include <OpenGL/CGLIOSurface.h>
 #include <Quartz/Quartz.h>
 #include <stddef.h>
 
 using gfx::BufferFormat;
 
 namespace gl {
 namespace {
 
-const char kGLSLVersion[] = "#version 110";
+const char kVertexHeaderCompatiblityProfile[] = "#version 110";
 
-const char kTextureRectangleRequired[] =
-    "#extension GL_ARB_texture_rectangle : require";
+const char kVertexHeaderCoreProfile[] =
+    "#version 150\n"
+    "#define attribute in\n"
+    "#define varying out\n";

[Ken Russell (switch to Gerrit), 2016/04/14 00:01:15]

I suggest naming these ATTRIBUTE and VARYING and replacing them in the shaders
so it's clear that they're macros.

[ccameron, 2016/04/14 00:25:13]

Good point -- done.

+
+const char kFragmentHeaderCompatiblityProfile[] =
+    "#version 110\n"
+    "#extension GL_ARB_texture_rectangle : require\n"
+    "#define FRAGCOLOR gl_FragColor\n"
+    "#define TEX texture2DRect\n";
+
+const char kFragmentHeaderCoreProfile[] =
+    "#version 150\n"
+    "#define varying in\n"
+    "#define TEX texture\n"
+    "#define FRAGCOLOR frag_color\n"
+    "out vec4 FRAGCOLOR;\n";
 
 // clang-format off
 const char kVertexShader[] =
 STRINGIZE(
   attribute vec2 a_position;
   uniform vec2 a_texScale;
   varying vec2 v_texCoord;
   void main() {
     gl_Position = vec4(a_position.x, a_position.y, 0.0, 1.0);
     v_texCoord = (a_position + vec2(1.0, 1.0)) * 0.5 * a_texScale;
   }
 );
 
 const char kFragmentShader[] =
 STRINGIZE(
   uniform sampler2DRect a_y_texture;
   uniform sampler2DRect a_uv_texture;
   varying vec2 v_texCoord;
   void main() {
     vec3 yuv_adj = vec3(-0.0625, -0.5, -0.5);
     mat3 yuv_matrix = mat3(vec3(1.164, 1.164, 1.164),
                            vec3(0.0, -.391, 2.018),
                            vec3(1.596, -.813, 0.0));
     vec3 yuv = vec3(
-        texture2DRect(a_y_texture, v_texCoord).r,
-        texture2DRect(a_uv_texture, v_texCoord * 0.5).rg);
-    gl_FragColor = vec4(yuv_matrix * (yuv + yuv_adj), 1.0);
+        TEX(a_y_texture, v_texCoord).r,
+        TEX(a_uv_texture, v_texCoord * 0.5).rg);
+    FRAGCOLOR = vec4(yuv_matrix * (yuv + yuv_adj), 1.0);
   }
 );
 // clang-format on
 
 bool ValidInternalFormat(unsigned internalformat) {
   switch (internalformat) {
     case GL_RED:
     case GL_BGRA_EXT:
     case GL_RGB:
     case GL_RGB_YCBCR_420V_CHROMIUM:
@@ skipping 152 matching lines @@
   DCHECK(current_context);
   DCHECK(g_rgb_converters_thread_checker.Get().CalledOnValidThread());
   auto found = g_rgb_converters.Get().find(current_context);
   if (found != g_rgb_converters.Get().end())
     return make_scoped_refptr(found->second);
   return make_scoped_refptr(new RGBConverter(current_context));
 }
 
 GLImageIOSurface::RGBConverter::RGBConverter(CGLContextObj cgl_context)
     : cgl_context_(cgl_context, base::scoped_policy::RETAIN) {
+  bool use_core_profile =
+      gfx::GetGLImplementation() == gfx::kGLImplementationDesktopGLCoreProfile;
   gfx::ScopedSetGLToRealGLApi scoped_set_gl_api;
   glGenFramebuffersEXT(1, &framebuffer_);
   vertex_buffer_ = gfx::GLHelper::SetupQuadVertexBuffer();
   vertex_shader_ = gfx::GLHelper::LoadShader(
       GL_VERTEX_SHADER,
-      base::StringPrintf("%s\n%s", kGLSLVersion, kVertexShader).c_str());
+      base::StringPrintf("%s\n%s",
+                         use_core_profile ? kVertexHeaderCoreProfile
+                                          : kVertexHeaderCompatiblityProfile,
+                         kVertexShader).c_str());
   fragment_shader_ = gfx::GLHelper::LoadShader(
       GL_FRAGMENT_SHADER,
-      base::StringPrintf("%s\n%s\n%s", kGLSLVersion, kTextureRectangleRequired,
-                         kFragmentShader)
-          .c_str());
+      base::StringPrintf("%s\n%s",
+                         use_core_profile ? kFragmentHeaderCoreProfile
+                                          : kFragmentHeaderCompatiblityProfile,
+                         kFragmentShader).c_str());
   program_ = gfx::GLHelper::SetupProgram(vertex_shader_, fragment_shader_);
 
   gfx::ScopedUseProgram use_program(program_);
   size_location_ = glGetUniformLocation(program_, "a_texScale");
   DCHECK_NE(-1, size_location_);
   int y_sampler_location = glGetUniformLocation(program_, "a_y_texture");
   DCHECK_NE(-1, y_sampler_location);
   int uv_sampler_location = glGetUniformLocation(program_, "a_uv_texture");
   DCHECK_NE(-1, uv_sampler_location);
 
@@ skipping 248 matching lines @@
   return cv_pixel_buffer_;
 }
 
 // static
 unsigned GLImageIOSurface::GetInternalFormatForTesting(
     gfx::BufferFormat format) {
   DCHECK(ValidFormat(format));
   return TextureFormat(format);
 }
 }  // namespace gl