gpu: Add YCbCr 420v extension.

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/foundation_util.h"
+#include "base/strings/stringize_macros.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/scoped_binders.h"
 
 // Note that this must be included after gl_bindings.h to avoid conflicts.
 #include <OpenGL/CGLIOSurface.h>
 #include <Quartz/Quartz.h>
 
 namespace gfx {
 namespace {
 
 using WidgetToLayerMap = std::map<AcceleratedWidget, CALayer*>;
 base::LazyInstance<WidgetToLayerMap> g_widget_to_layer_map;
 
 bool ValidInternalFormat(unsigned internalformat) {
   switch (internalformat) {
     case GL_R8:
     case GL_BGRA_EXT:
     case GL_RGB:
+    case GL_RGB_YCBCR_420V_CHROMIUM:
     case GL_RGB_YCBCR_422_CHROMIUM:
       return true;
     default:
       return false;
   }
 }
 
 bool ValidFormat(BufferFormat format) {
   switch (format) {
     case BufferFormat::R_8:
@@ skipping 14 matching lines @@
       return false;
   }
 
   NOTREACHED();
   return false;
 }
 
 GLenum TextureFormat(BufferFormat format) {
   switch (format) {
     case BufferFormat::R_8:
-    case BufferFormat::YUV_420_BIPLANAR:
       return GL_RED;
     case BufferFormat::BGRA_8888:
       return GL_RGBA;
     case BufferFormat::UYVY_422:
-      return GL_RGB;
     case BufferFormat::ATC:
     case BufferFormat::ATCIA:
     case BufferFormat::DXT1:
     case BufferFormat::DXT5:
     case BufferFormat::ETC1:
     case BufferFormat::RGBA_4444:
     case BufferFormat::RGBA_8888:
     case BufferFormat::RGBX_8888:
     case BufferFormat::BGRX_8888:
     case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
       NOTREACHED();
       return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
 GLenum DataFormat(BufferFormat format) {
   switch (format) {
     case BufferFormat::R_8:
-    case BufferFormat::YUV_420_BIPLANAR:
       return GL_RED;
     case BufferFormat::BGRA_8888:
       return GL_BGRA;
     case BufferFormat::UYVY_422:
       return GL_YCBCR_422_APPLE;
-      break;
     case BufferFormat::ATC:
     case BufferFormat::ATCIA:
     case BufferFormat::DXT1:
     case BufferFormat::DXT5:
     case BufferFormat::ETC1:
     case BufferFormat::RGBA_4444:
     case BufferFormat::RGBA_8888:
     case BufferFormat::RGBX_8888:
     case BufferFormat::BGRX_8888:
     case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
       NOTREACHED();
       return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
 GLenum DataType(BufferFormat format) {
   switch (format) {
     case BufferFormat::R_8:
-    case BufferFormat::YUV_420_BIPLANAR:
       return GL_UNSIGNED_BYTE;
     case BufferFormat::BGRA_8888:
       return GL_UNSIGNED_INT_8_8_8_8_REV;
     case BufferFormat::UYVY_422:
       return GL_UNSIGNED_SHORT_8_8_APPLE;
       break;
     case BufferFormat::ATC:
     case BufferFormat::ATCIA:
     case BufferFormat::DXT1:
     case BufferFormat::DXT5:
     case BufferFormat::ETC1:
     case BufferFormat::RGBA_4444:
     case BufferFormat::RGBA_8888:
     case BufferFormat::RGBX_8888:
     case BufferFormat::BGRX_8888:
     case BufferFormat::YUV_420:
+    case BufferFormat::YUV_420_BIPLANAR:
       NOTREACHED();
       return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
 }  // namespace
 
+class GLImageIOSurface::I420vToRGBA {
+ public:
+  bool Initialize();
+  bool DrawToTexture(const Size& size,
+                     GLuint yuv_planes[2],
+                     GLuint output_texture,
+                     unsigned target);
+  void Destroy();
+
+ private:
+  static const char kVertexShader[];
+  static const char kFragmentShader[];
+  GLuint framebuffer_object_ = 0;
+  GLuint vertex_shader_ = 0;
+  GLuint fragment_shader_ = 0;
+  GLuint program_object_ = 0;
+  GLint y_sampler_location_ = -1;
+  GLint uv_sampler_location_ = -1;
+  GLint size_location_ = -1;
+  GLuint vertex_buffer_ = 0;
+};
+
+// clang-format off
+const char GLImageIOSurface::I420vToRGBA::kVertexShader[] =
+STRINGIZE(
+  attribute vec2 a_position;
+  uniform vec2 a_size;
+  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,1)) * 0.5 * a_size;
+  }
+);
+
+const char GLImageIOSurface::I420vToRGBA::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);
+  }
+);
+// clang-format on
+
+bool GLImageIOSurface::I420vToRGBA::Initialize() {
+  glGenFramebuffersEXT(1, &framebuffer_object_);
+  DCHECK(framebuffer_object_);
+
+  glGenBuffersARB(1, &vertex_buffer_);
+  GLint previous_buffer = 0;
+  glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &previous_buffer);
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
+
+  // clang-format off
+  GLfloat data[] = {
+    -1.f, -1.f,
+    1.f, -1.f,
+    -1.f, 1.f,
+    1.f, 1.f};
+  // clang-format on
+  glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 2, 0);
+  glBindBuffer(GL_ARRAY_BUFFER, previous_buffer);
+
+  vertex_shader_ = GLHelper::LoadShader(GL_VERTEX_SHADER, kVertexShader);
+  fragment_shader_ = GLHelper::LoadShader(GL_FRAGMENT_SHADER, kFragmentShader);
+  program_object_ = GLHelper::SetupProgram(vertex_shader_, fragment_shader_);
+  GLint previous_program = 0;
+  glGetIntegerv(GL_CURRENT_PROGRAM, &previous_program);
+  glUseProgram(program_object_);
+
+  size_location_ = glGetUniformLocation(program_object_, "a_size");
+  DCHECK_NE(-1, size_location_);
+  y_sampler_location_ = glGetUniformLocation(program_object_, "a_y_texture");
+  DCHECK_NE(-1, y_sampler_location_);
+  uv_sampler_location_ = glGetUniformLocation(program_object_, "a_uv_texture");
+  DCHECK_NE(-1, uv_sampler_location_);
+
+  glUniform1i(y_sampler_location_, 0);
+  glUniform1i(uv_sampler_location_, 1);
+  glUseProgram(previous_program);
+  return true;
+}
+
+bool GLImageIOSurface::I420vToRGBA::DrawToTexture(const Size& size,
+                                                  GLuint yuv_planes[2],
+                                                  GLuint output_texture,
+                                                  unsigned target) {
+  ScopedFrameBufferBinder fb(framebuffer_object_);
+  glViewport(0, 0, size.width(), size.height());
+  glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target,
+                            output_texture, 0);
+  DCHECK_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
+            glCheckFramebufferStatusEXT(GL_FRAMEBUFFER));
+
+  GLint previous_active_texture = 0;
+  glGetIntegerv(GL_ACTIVE_TEXTURE, &previous_active_texture);
+  glActiveTexture(GL_TEXTURE0);
+  GLint previous_texture_0 = 0;
+  glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &previous_texture_0);
+  glBindTexture(GL_TEXTURE_RECTANGLE_ARB, yuv_planes[0]);
+
+  glActiveTexture(GL_TEXTURE1);
+  glBindTexture(GL_TEXTURE_RECTANGLE_ARB, yuv_planes[1]);
+  GLint previous_texture_1 = 0;
+  glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &previous_texture_1);
+
+  GLint previous_program = 0;
+  glGetIntegerv(GL_CURRENT_PROGRAM, &previous_program);
+  glUseProgram(program_object_);
+  glUniform2f(size_location_, size.width(), size.height());
+
+  GLint vertex_array_enabled = 0;
+  glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &vertex_array_enabled);
+  glEnableVertexAttribArray(0);
+  GLint previous_buffer = 0;
+  glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &previous_buffer);
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
+  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+  // Detach the service texture from the fbo.
+  glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, 0, 0);
+  // Restore texture bindings and active texture.
+  glBindTexture(GL_TEXTURE_RECTANGLE_ARB, previous_texture_1);
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_RECTANGLE_ARB, previous_texture_0);
+  glActiveTexture(previous_active_texture);
+  // Restore program.
+  glUseProgram(previous_program);
+  // Restore bound vbuff.
+  glBindBuffer(GL_ARRAY_BUFFER_BINDING, previous_buffer);
+  if (!vertex_array_enabled)
+    glDisableVertexAttribArray(0);
+
+  return true;
+}
+
+void GLImageIOSurface::I420vToRGBA::Destroy() {
+  glDeleteProgram(program_object_);
+  glDeleteShader(vertex_shader_);
+  glDeleteShader(fragment_shader_);
+  glDeleteBuffersARB(1, &vertex_buffer_);
+  glDeleteFramebuffersEXT(1, &framebuffer_object_);
+}
+
 GLImageIOSurface::GLImageIOSurface(const Size& size, unsigned internalformat)
     : size_(size),
       internalformat_(internalformat),
       format_(BufferFormat::RGBA_8888) {}
 
 GLImageIOSurface::~GLImageIOSurface() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!io_surface_);
 }
 
@@ skipping 14 matching lines @@
   }
 
   format_ = format;
   io_surface_.reset(io_surface, base::scoped_policy::RETAIN);
   io_surface_id_ = io_surface_id;
   return true;
 }
 
 void GLImageIOSurface::Destroy(bool have_context) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  if (have_context && i420v_to_RGBA_) {
+    i420v_to_RGBA_->Destroy();

[reveman, 2015/10/27 19:31:54]

without looking at what this does, it's confusing that we would only destroy an
object if "have_context" is true. I think this would be better if there was no
i420v_to_RGBA_ instance. See my comment below for more on this.

[Daniele Castagna, 2015/10/29 20:09:04]

Removed the class as suggested in the comment below.

+  }
   io_surface_.reset();
 }
 
 Size GLImageIOSurface::GetSize() {
   return size_;
 }
 
 unsigned GLImageIOSurface::GetInternalFormat() { return internalformat_; }
 
 bool GLImageIOSurface::BindTexImage(unsigned target) {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (format_ == BufferFormat::YUV_420_BIPLANAR)
+    return false;
+
   if (target != GL_TEXTURE_RECTANGLE_ARB) {
     // This might be supported in the future. For now, perform strict
     // validation so we know what's going on.
     LOG(ERROR) << "IOSurface requires TEXTURE_RECTANGLE_ARB target";
     return false;
   }
 
   CGLContextObj cgl_context =
       static_cast<CGLContextObj>(GLContext::GetCurrent()->GetHandle());
 
   DCHECK(io_surface_);
   CGLError cgl_error =
       CGLTexImageIOSurface2D(cgl_context, target, TextureFormat(format_),
                              size_.width(), size_.height(), DataFormat(format_),
                              DataType(format_), io_surface_.get(), 0);
   if (cgl_error != kCGLNoError) {
     LOG(ERROR) << "Error in CGLTexImageIOSurface2D";
     return false;
   }
 
   return true;
 }
 
 bool GLImageIOSurface::CopyTexImage(unsigned target) {
-  return false;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(io_surface_);
+  if (format_ != BufferFormat::YUV_420_BIPLANAR)
+    return false;
+
+  if (!i420v_to_RGBA_) {

[reveman, 2015/10/27 19:31:54]

I would prefer to see all this state just part of the GLImageIOSurface instead
and all the code right here in this function with helper functions in anonymous
namespace. This way we don't have to deal with a "initialize GL structures..."
failing and there's no need for scoped bind textures here and then again in
DrawToTexture..

[Daniele Castagna, 2015/10/29 20:09:04]

Done.

+    i420v_to_RGBA_.reset(new I420vToRGBA());
+    if (!i420v_to_RGBA_->Initialize()) {
+      LOG(ERROR)
+          << "Can't initialize GL structures for 420v to RGBA conversion";
+      return false;
+    }
+  }
+
+  DCHECK(target == GL_TEXTURE_2D);

[reveman, 2015/10/27 19:31:54]

What prevents a client from using a different target and that because of this
causing the GPU process to crash?

[Daniele Castagna, 2015/10/29 20:09:04]

Changed that to LOG(ERROR) ... + return false.

+  CGLContextObj cgl_context =
+      static_cast<CGLContextObj>(GLContext::GetCurrent()->GetHandle());
+
+  GLuint yuv_textures[2];
+  glGenTextures(2, yuv_textures);
+  DCHECK(yuv_textures[0] && yuv_textures[1]);
+
+  GLint service_texture = 0;
+  glGetIntegerv(GL_TEXTURE_BINDING_2D, &service_texture);
+  DCHECK(service_texture);
+
+  CGLError cgl_error = kCGLNoError;
+  {
+    ScopedTextureBinder b(GL_TEXTURE_RECTANGLE_ARB, yuv_textures[0]);
+    cgl_error = CGLTexImageIOSurface2D(
+        cgl_context, GL_TEXTURE_RECTANGLE_ARB, GL_RED, size_.width(),
+        size_.height(), GL_RED, GL_UNSIGNED_BYTE, io_surface_.get(), 0);
+  }
+  if (cgl_error != kCGLNoError) {
+    LOG(ERROR) << "Error in CGLTexImageIOSurface2D for the Y plane. "
+               << cgl_error;
+    glDeleteTextures(2, yuv_textures);
+    return false;
+  }
+
+  {
+    ScopedTextureBinder b(GL_TEXTURE_RECTANGLE_ARB, yuv_textures[1]);
+    cgl_error = CGLTexImageIOSurface2D(
+        cgl_context, GL_TEXTURE_RECTANGLE_ARB, GL_RG, size_.width() / 2,
+        size_.height() / 2, GL_RG, GL_UNSIGNED_BYTE, io_surface_.get(), 1);
+  }
+  if (cgl_error != kCGLNoError) {
+    LOG(ERROR) << "Error in CGLTexImageIOSurface2D for the UV plane. "
+               << cgl_error;
+    glDeleteTextures(2, yuv_textures);
+    return false;
+  }
+
+  if (!i420v_to_RGBA_->DrawToTexture(size_, yuv_textures, service_texture,
+                                     target)) {
+    LOG(ERROR) << "Can't draw 420v IOSurface to RGBA texture.";
+    glDeleteTextures(2, yuv_textures);
+    return false;
+  }
+
+  return true;
 }
 
 bool GLImageIOSurface::CopyTexSubImage(unsigned target,
                                        const Point& offset,
                                        const Rect& rect) {
   return false;
 }
 
 bool GLImageIOSurface::ScheduleOverlayPlane(AcceleratedWidget widget,
                                             int z_order,
@@ skipping 30 matching lines @@
 // static
 void GLImageIOSurface::SetLayerForWidget(AcceleratedWidget widget,
                                          CALayer* layer) {
   if (layer)
     g_widget_to_layer_map.Pointer()->insert(std::make_pair(widget, layer));
   else
     g_widget_to_layer_map.Pointer()->erase(widget);
 }
 
 }  // namespace gfx