gpu: Add YCbCr 420v extension.

ui/gl/scoped_binders.cc

 // Copyright (c) 2012 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/scoped_binders.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_state_restorer.h"
 
 namespace gfx {
@@ skipping 11 matching lines @@
 ScopedFrameBufferBinder::~ScopedFrameBufferBinder() {
   if (state_restorer_) {
     DCHECK(!!GLContext::GetCurrent());
     DCHECK_EQ(state_restorer_, GLContext::GetCurrent()->GetGLStateRestorer());
     state_restorer_->RestoreFramebufferBindings();
   } else {
     glBindFramebufferEXT(GL_FRAMEBUFFER, old_fbo_);
   }
 }
 
+ScopedActiveTexture::ScopedActiveTexture(unsigned int texture)
+    : old_texture_(-1) {
+  glGetIntegerv(GL_ACTIVE_TEXTURE, &old_texture_);
+  glActiveTexture(texture);
+}
+
+ScopedActiveTexture::~ScopedActiveTexture() {
+  glActiveTexture(old_texture_);
+}
+
 ScopedTextureBinder::ScopedTextureBinder(unsigned int target, unsigned int id)
     : state_restorer_(!GLContext::GetCurrent()
                           ? NULL
                           : GLContext::GetCurrent()->GetGLStateRestorer()),
       target_(target),
       old_id_(-1) {
   if (!state_restorer_) {
     GLenum target_getter = 0;
     switch (target) {
       case GL_TEXTURE_2D:
         target_getter = GL_TEXTURE_BINDING_2D;
         break;
       case GL_TEXTURE_CUBE_MAP:
         target_getter = GL_TEXTURE_BINDING_CUBE_MAP;
         break;
       case GL_TEXTURE_EXTERNAL_OES:
         target_getter = GL_TEXTURE_BINDING_EXTERNAL_OES;
         break;
+      case GL_TEXTURE_RECTANGLE_ARB:
+        target_getter = GL_TEXTURE_BINDING_RECTANGLE_ARB;
+        break;
       default:
-        NOTIMPLEMENTED() << "Target not part of OpenGL ES 2.0 spec.";
+        NOTIMPLEMENTED() << " Target not supported.";
     }
     glGetIntegerv(target_getter, &old_id_);
   }
   glBindTexture(target_, id);
 }
 
 ScopedTextureBinder::~ScopedTextureBinder() {
   if (state_restorer_) {
     DCHECK(!!GLContext::GetCurrent());
     DCHECK_EQ(state_restorer_, GLContext::GetCurrent()->GetGLStateRestorer());
     state_restorer_->RestoreActiveTextureUnitBinding(target_);
   } else {
     glBindTexture(target_, old_id_);
   }
 }
 
+ScopedUseProgram::ScopedUseProgram(unsigned int program) : old_program_(-1) {
+  glGetIntegerv(GL_CURRENT_PROGRAM, &old_program_);
+  glUseProgram(program);
+}
+
+ScopedUseProgram::~ScopedUseProgram() {
+  glUseProgram(old_program_);
+}
+
+ScopedVertexAttribArray::ScopedVertexAttribArray(unsigned int index,
+                                                 int size,
+                                                 unsigned int type,
+                                                 char normalized,
+                                                 int stride,
+                                                 const void* pointer)
+    : enabled_(GL_FALSE),
+      index_(index),
+      size_(-1),
+      type_(-1),
+      normalized_(GL_FALSE),
+      stride_(0),
+      pointer_(0) {
+  glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &enabled_);
+  glEnableVertexAttribArray(index);
+
+  glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_SIZE, &size_);
+  glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_TYPE, &type_);
+  glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &normalized_);
+  glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &stride_);
+  glGetVertexAttribPointerv(index, GL_VERTEX_ATTRIB_ARRAY_POINTER, &pointer_);
+
+  glVertexAttribPointer(index, size, type, normalized, stride, pointer);
+}
+
+ScopedVertexAttribArray::~ScopedVertexAttribArray() {
+  glVertexAttribPointer(index_, size_, type_, normalized_, stride_, pointer_);

[piman, 2015/11/04 22:49:45]

So this one is a little tricky, because there's an implicit state that this call
latches on, which is the current array buffer.

So you need to:
1- in the constructor, query GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING as the saved
array buffer
2- in the destructor, before this call, save the current array buffer, and bind
the saved array buffer as the current array buffer
3- do this call
4- restore the current array buffer

[Daniele Castagna, 2015/12/03 23:12:08]

Done.

+  if (enabled_ == GL_FALSE) {
+    glDisableVertexAttribArray(index_);
+  }
+}
+
+ScopedBufferBinder::ScopedBufferBinder(unsigned int target, unsigned int id)
+    : target_(target), old_id_(-1) {
+  GLenum target_getter = 0;
+  switch (target) {
+    case GL_ARRAY_BUFFER:
+      target_getter = GL_ARRAY_BUFFER_BINDING;
+      break;
+    default:
+      NOTIMPLEMENTED() << " Target not supported.";
+  }
+  glGetIntegerv(target_getter, &old_id_);
+  glBindBuffer(target_, id);
+}
+
+ScopedBufferBinder::~ScopedBufferBinder() {
+  glBindBuffer(target_, old_id_);
+}
+
+ScopedViewport::ScopedViewport(int x, int y, int width, int height) {
+  glGetIntegerv(GL_VIEWPORT, data_);
+  glViewport(x, y, width, height);
+}
+
+ScopedViewport::~ScopedViewport() {
+  glViewport(data_[0], data_[1], data_[2], data_[3]);
+}
+
+ScopedColorMask::ScopedColorMask(char red, char green, char blue, char alpha) {
+  glGetBooleanv(GL_COLOR_WRITEMASK, colors_);
+  glColorMask(red, green, blue, alpha);
+}
+
+ScopedColorMask::~ScopedColorMask() {
+  glColorMask(colors_[0], colors_[1], colors_[2], colors_[3]);
+}
+
+// static
+GLenum ScopedCapabilitiesRestorer::kCapabilities[] = {
+    GL_BLEND,        GL_CULL_FACE,           GL_DEPTH_TEST,
+    GL_DITHER,       GL_POLYGON_OFFSET_FILL, GL_SAMPLE_ALPHA_TO_COVERAGE,

[piman, 2015/11/04 22:49:45]

- polygon offset shouldn't matter since you disable depth
- GL_SAMPLE_ALPHA_TO_COVERAGE doesn't matter since you're not rendering to a
multisample target

[Daniele Castagna, 2015/12/03 23:12:08]

Ack.
This ScopedCapabilitiesRestorer could be used in other places though where those
capabilities could matter.

[piman, 2015/12/04 00:02:16]

Sure, but why these ones and not others too? E.g. GL_SAMPLE_COVERAGE is in core
ES 2.0, and if 3.0 is supported and/or extensions, we add other ones.

Maybe I'd argue for a separate ScopedCapabilityRestorer for each individual
capability.

[Daniele Castagna, 2015/12/04 00:40:18]

Not sure why I left GL_SAMPLE_COVERAGE out. My intention was to add all the
capabilities in core ES 2.0. :/
Removed ScopedCapabilities and added a ScopedCapability that takes the
capability enum as parameter:

gfx::ScopedCapability disable_blending(GL_BLEND, GL_FALSE);

+    GL_SCISSOR_TEST, GL_STENCIL_TEST};
+
+ScopedCapabilitiesRestorer::ScopedCapabilitiesRestorer() {
+  static_assert(arraysize(kCapabilities) <= arraysize(enabled_),
+                "enabled_ array size should be at least kCapabilities size. ");
+  for (size_t i = 0; i < arraysize(kCapabilities); ++i) {
+    enabled_[i] = glIsEnabled(kCapabilities[i]);
+  }
+}
+
+ScopedCapabilitiesRestorer::~ScopedCapabilitiesRestorer() {
+  for (size_t i = 0; i < arraysize(kCapabilities); ++i) {
+    if (enabled_[i] == GL_TRUE) {
+      glEnable(kCapabilities[i]);
+    } else {
+      glDisable(kCapabilities[i]);
+    }
+  }
+}
+
 }  // namespace gfx