WebGL GL_RGB emulation to support IOSurfaces on Mac.

third_party/WebKit/Source/platform/graphics/gpu/DrawingBuffer.cpp

 /*
  * Copyright (c) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/graphics/gpu/DrawingBuffer.h"
 
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "gpu/command_buffer/common/capabilities.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/gpu/Extensions3DUtil.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebExternalBitmap.h"
 #include "public/platform/WebExternalTextureLayer.h"
 #include "public/platform/WebGraphicsContext3D.h"
@@ skipping 84 matching lines @@
     PassOwnPtr<Extensions3DUtil> extensionsUtil,
     bool discardFramebufferSupported,
     bool wantAlphaChannel,
     bool premultipliedAlpha,
     PreserveDrawingBuffer preserve)
     : m_preserveDrawingBuffer(preserve)
     , m_scissorEnabled(false)
     , m_texture2DBinding(0)
     , m_drawFramebufferBinding(0)
     , m_readFramebufferBinding(0)
+    , m_renderbufferBinding(0)
     , m_activeTextureUnit(GL_TEXTURE0)
     , m_contextProvider(std::move(contextProvider))
     , m_context(m_contextProvider->context3d())
     , m_gl(m_contextProvider->contextGL())
     , m_extensionsUtil(std::move(extensionsUtil))
     , m_size(-1, -1)
     , m_discardFramebufferSupported(discardFramebufferSupported)
     , m_wantAlphaChannel(wantAlphaChannel)
     , m_premultipliedAlpha(premultipliedAlpha)
     , m_hasImplicitStencilBuffer(false)
     , m_fbo(0)
     , m_depthStencilBuffer(0)
     , m_multisampleFBO(0)
+    , m_multisampleIntermediateFBO(0)
+    , m_multisampleIntermediateRenderbuffer(0)
     , m_multisampleColorBuffer(0)
     , m_contentsChanged(true)
     , m_contentsChangeCommitted(false)
     , m_bufferClearNeeded(false)
     , m_antiAliasingMode(None)
     , m_maxTextureSize(0)
     , m_sampleCount(0)
     , m_packAlignment(4)
     , m_destructionInProgress(false)
     , m_isHidden(false)
@@ skipping 57 matching lines @@
 
 void DrawingBuffer::setFilterQuality(SkFilterQuality filterQuality)
 {
     if (m_filterQuality != filterQuality) {
         m_filterQuality = filterQuality;
         if (m_layer)
             m_layer->setNearestNeighbor(filterQuality == kNone_SkFilterQuality);
     }
 }
 
+bool DrawingBuffer::requiresRGBEmulation()
+{
+    // When an explicit resolve is required, clients draw into a render buffer
+    // which is never backed by an IOSurface.
+    if (m_antiAliasingMode == MSAAExplicitResolve)
+        return false;
+    return !m_drawFramebufferBinding && !m_wantAlphaChannel && m_colorBuffer.imageId && contextProvider()->getCapabilities().chromium_image_rgb_emulation;
+}
+
 void DrawingBuffer::freeRecycledMailboxes()
 {
     if (m_recycledMailboxQueue.isEmpty())
         return;
     while (!m_recycledMailboxQueue.isEmpty())
         deleteMailbox(m_recycledMailboxQueue.takeLast());
 }
 
 bool DrawingBuffer::prepareMailbox(WebExternalTextureMailbox* outMailbox, WebExternalBitmap* bitmap)
 {
@@ skipping 98 matching lines @@
     ASSERT_NOT_REACHED();
 }
 
 DrawingBuffer::TextureParameters DrawingBuffer::chromiumImageTextureParameters()
 {
 #if OS(MACOSX)
     // A CHROMIUM_image backed texture requires a specialized set of parameters
     // on OSX.
     TextureParameters parameters;
     parameters.target = GC3D_TEXTURE_RECTANGLE_ARB;
-    parameters.internalColorFormat = GL_RGBA;
-    parameters.internalRenderbufferFormat = GL_RGBA8_OES;
-    parameters.colorFormat = GL_RGBA;
+
+    if (m_wantAlphaChannel) {
+        parameters.creationInternalColorFormat = GL_RGBA;
+        parameters.internalColorFormat = GL_RGBA;
+        parameters.internalRenderbufferFormat = GL_RGBA8_OES;
+    } else if (contextProvider()->getCapabilities().chromium_image_rgb_emulation) {
+        parameters.creationInternalColorFormat = GL_RGB;
+        parameters.internalColorFormat = GL_RGBA;
+        parameters.internalRenderbufferFormat = GL_RGB8_OES;
+    } else {
+        parameters.creationInternalColorFormat = GL_RGB;
+        parameters.internalColorFormat = GL_RGB;
+        parameters.internalRenderbufferFormat = GL_RGB8_OES;
+    }
+
+    // Unused.

[Ken Russell (switch to Gerrit), 2016/04/29 09:33:09]

Unused when CHROMIUM_image is being used, right? Does it need to be set if
falling back to use a regular texture?

[erikchen, 2016/05/03 22:58:07]

Correct. I updated the comment. Fallback textures use 
DrawingBuffer::defaultTextureParameters.

+    parameters.colorFormat = 0;
     return parameters;
 #else
     return defaultTextureParameters();
 #endif
 }
 
 DrawingBuffer::TextureParameters DrawingBuffer::defaultTextureParameters()
 {
     TextureParameters parameters;
     parameters.target = GL_TEXTURE_2D;
     if (m_wantAlphaChannel) {
         parameters.internalColorFormat = GL_RGBA;
+        parameters.creationInternalColorFormat = GL_RGBA;
         parameters.colorFormat = GL_RGBA;
         parameters.internalRenderbufferFormat = GL_RGBA8_OES;
     } else {
         parameters.internalColorFormat = GL_RGB;
+        parameters.creationInternalColorFormat = GL_RGB;
         parameters.colorFormat = GL_RGB;
         parameters.internalRenderbufferFormat = GL_RGB8_OES;
     }
     return parameters;
 }
 
 void DrawingBuffer::mailboxReleasedWithoutRecycling(const WebExternalTextureMailbox& mailbox)
 {
     ASSERT(m_textureMailboxes.size());
     // Ensure not to call the destructor until deleteMailbox() is completed.
@@ skipping 204 matching lines @@
 
     if (m_multisampleFBO)
         m_gl->DeleteFramebuffers(1, &m_multisampleFBO);
 
     if (m_fbo)
         m_gl->DeleteFramebuffers(1, &m_fbo);
 
     if (m_multisampleColorBuffer)
         m_gl->DeleteRenderbuffers(1, &m_multisampleColorBuffer);
 
+    if (m_multisampleIntermediateFBO)
+        m_gl->DeleteFramebuffers(1, &m_multisampleIntermediateFBO);
+
+    if (m_multisampleIntermediateRenderbuffer)
+        m_gl->DeleteRenderbuffers(1, &m_multisampleIntermediateRenderbuffer);
+
     if (m_depthStencilBuffer)
         m_gl->DeleteRenderbuffers(1, &m_depthStencilBuffer);
 
     if (m_colorBuffer.textureId) {
         deleteChromiumImageForTexture(&m_colorBuffer);
         m_gl->DeleteTextures(1, &m_colorBuffer.textureId);
     }
 
     setSize(IntSize());
 
@@ skipping 143 matching lines @@
         } while (!adjustedSize.isEmpty());
 
         setSize(adjustedSize);
 
         if (adjustedSize.isEmpty())
             return false;
     }
 
     m_gl->Disable(GL_SCISSOR_TEST);
     m_gl->ClearColor(0, 0, 0, 0);
-    m_gl->ColorMask(true, true, true, true);
+    m_gl->ColorMask(true, true, true, !requiresRGBEmulation());
 
     GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
     if (!!m_depthStencilBuffer) {
         m_gl->ClearDepthf(1.0f);
         clearMask |= GL_DEPTH_BUFFER_BIT;
         m_gl->DepthMask(true);
     }
     if (!!m_depthStencilBuffer) {
         m_gl->ClearStencil(0);
         clearMask |= GL_STENCIL_BUFFER_BIT;
         m_gl->StencilMaskSeparate(GL_FRONT, 0xFFFFFFFF);
     }
 
     clearFramebuffers(clearMask);
+    m_gl->ColorMask(true, true, true, true);

[Ken Russell (switch to Gerrit), 2016/04/29 09:33:09]

Were callers relying on this to set the color mask to (true, true, true, true)?
If so then maybe that should be made more explicit in the callers.

[erikchen, 2016/05/03 22:58:07]

No. I removed this call.

     return true;
 }
 
 void DrawingBuffer::commit()
 {
     if (m_multisampleFBO && !m_contentsChangeCommitted) {
         m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER_ANGLE, m_multisampleFBO);
         m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER_ANGLE, m_fbo);
 
         if (m_scissorEnabled)
             m_gl->Disable(GL_SCISSOR_TEST);
 
         int width = m_size.width();
         int height = m_size.height();
         // Use NEAREST, because there is no scale performed during the blit.
-        m_gl->BlitFramebufferCHROMIUM(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
+        GLuint filter = GL_NEAREST;
+
+        // If the destination has a different color format than the source, then
+        // first resolve to an intermediary renderbuffer with the same color
+        // format.
+        // If this extra blit proves to be a performance problem, it can be
+        // bypassed on most GPUs by performing client side GL_RGBA emulation on
+        // the source renderbuffer.
+        // https://bugs.chromium.org/p/chromium/issues/detail?id=595948#c30
+        if (m_colorBuffer.parameters.internalColorFormat == GL_RGBA && m_colorBuffer.parameters.internalRenderbufferFormat == GL_RGB8_OES) {
+            if (!m_multisampleIntermediateFBO) {
+                DCHECK(!m_multisampleIntermediateRenderbuffer);

[Zhenyao Mo, 2016/04/29 22:54:16]

These two names are misleading.  The intermediate render buffer isn't
multi-sampled, so maybe just name it m_intermediateRenderbuffer,
m_intermediateFBO?

[erikchen, 2016/05/03 22:58:08]

Done.

+                m_gl->GenRenderbuffers(1, &m_multisampleIntermediateRenderbuffer);
+                m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_multisampleIntermediateRenderbuffer);

[Ken Russell (switch to Gerrit), 2016/04/29 09:33:09]

Is resizing of m_multisampleIntermediateRenderbuffer handled properly during
resizes of the DrawingBuffer? It looks like this might have been missed in
DrawingBuffer::reset(). If it's missed, let's add a WebGL conformance test to
catch the error.

[erikchen, 2016/05/03 22:58:07]

No, it wasn't. I added a test:
https://codereview.appspot.com/294490043/

+                m_gl->RenderbufferStorage(GL_RENDERBUFFER, GL_RGB8, width, height);
+
+                m_gl->GenFramebuffers(1, &m_multisampleIntermediateFBO);
+                m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER_ANGLE, m_multisampleIntermediateFBO);
+                m_gl->FramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER_ANGLE, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_multisampleIntermediateRenderbuffer);
+                m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_renderbufferBinding);
+            }
+
+            m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER_ANGLE, m_multisampleIntermediateFBO);
+            m_gl->BlitFramebufferCHROMIUM(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, filter);
+
+            m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER_ANGLE, m_multisampleIntermediateFBO);
+            m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER_ANGLE, m_fbo);
+        }
+
+        m_gl->BlitFramebufferCHROMIUM(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, filter);
 
         if (m_scissorEnabled)
             m_gl->Enable(GL_SCISSOR_TEST);
     }
 
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     if (m_antiAliasingMode == ScreenSpaceAntialiasing) {
         m_gl->ApplyScreenSpaceAntialiasingCHROMIUM();
     }
     m_contentsChangeCommitted = true;
@@ skipping 133 matching lines @@
 void DrawingBuffer::deleteChromiumImageForTexture(TextureInfo* info)
 {
     if (info->imageId) {
         m_gl->BindTexture(info->parameters.target, info->textureId);
         m_gl->ReleaseTexImage2DCHROMIUM(info->parameters.target, info->imageId);
         m_gl->DestroyImageCHROMIUM(info->imageId);
         info->imageId = 0;
     }
 }
 
+void DrawingBuffer::clearChromiumImageIfNecessary(const TextureInfo& info)
+{
+    if (m_wantAlphaChannel)

[Zhenyao Mo, 2016/04/29 22:54:15]

You can also return early if we don't need to emulate, then the texture channels
will just be cleared lazily.

[erikchen, 2016/05/03 22:58:07]

Done.

+        return;
+
+    GLuint fbo = 0;
+    m_gl->GenFramebuffers(1, &fbo);
+    m_gl->BindFramebuffer(GL_FRAMEBUFFER, fbo);
+    m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, info.parameters.target, info.textureId, 0);
+    m_gl->ClearColor(0, 0, 0, 1);
+    m_gl->ColorMask(false, false, false, true);

[Ken Russell (switch to Gerrit), 2016/04/29 09:33:09]

Is it deliberate that only the alpha channel is being cleared (to 1.0) here? If
so I'd suggest making this more explicit in either the name of this method or
its documentation in the header. (I'm guessing this is the only place in the
code which is allowed to touch the alpha channel for the emulated RGB back
buffers, and the clearIfComposited code path takes care of clearing the RGB
channels.)

[erikchen, 2016/05/03 22:58:07]

Yes. I updated the name of this method to be clearChromiumImageAlpha, and also
updated the documentation.

+    m_gl->Clear(GL_COLOR_BUFFER_BIT);
+    m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, info.parameters.target, 0, 0);
+    m_gl->DeleteFramebuffers(1, &fbo);
+    restoreFramebufferBindings();

[Zhenyao Mo, 2016/04/29 22:54:16]

Should we also restore clear color and clear mask at the end?

[erikchen, 2016/05/03 22:58:07]

Yes. Done.

+}
+
 DrawingBuffer::TextureInfo DrawingBuffer::createTextureAndAllocateMemory(const IntSize& size)
 {
-    // TODO(erikchen): Add support for a CHROMIUM_image back buffer whose
-    // behavior mimics a texture with internal format GL_RGB.
-    // https://crbug.com/581777.
-    if (!m_wantAlphaChannel)
-        return createDefaultTextureAndAllocateMemory(size);
-
     if (!RuntimeEnabledFeatures::webGLImageChromiumEnabled())
         return createDefaultTextureAndAllocateMemory(size);
 
     // First, try to allocate a CHROMIUM_image. This always has the potential to
     // fail.
     TextureParameters parameters = chromiumImageTextureParameters();
-    GLuint imageId = m_gl->CreateGpuMemoryBufferImageCHROMIUM(size.width(), size.height(), parameters.internalColorFormat, GC3D_SCANOUT_CHROMIUM);
+    GLuint imageId = m_gl->CreateGpuMemoryBufferImageCHROMIUM(size.width(), size.height(), parameters.creationInternalColorFormat, GC3D_SCANOUT_CHROMIUM);
     if (!imageId)
         return createDefaultTextureAndAllocateMemory(size);
 
     GLuint textureId = createColorTexture(parameters);
     m_gl->BindTexImage2DCHROMIUM(parameters.target, imageId);
 
     TextureInfo info;
     info.textureId = textureId;
     info.imageId = imageId;
     info.parameters = parameters;
+    clearChromiumImageIfNecessary(info);
     return info;
 }
 
 DrawingBuffer::TextureInfo DrawingBuffer::createDefaultTextureAndAllocateMemory(const IntSize& size)
 {
     TextureParameters parameters = defaultTextureParameters();
     GLuint textureId = createColorTexture(parameters);
-    texImage2DResourceSafe(parameters.target, 0, parameters.internalColorFormat, size.width(), size.height(), 0, parameters.colorFormat, GL_UNSIGNED_BYTE);
+    texImage2DResourceSafe(parameters.target, 0, parameters.creationInternalColorFormat, size.width(), size.height(), 0, parameters.colorFormat, GL_UNSIGNED_BYTE);
 
     DrawingBuffer::TextureInfo info;
     info.textureId = textureId;
     info.parameters = parameters;
     return info;
 }
 
 void DrawingBuffer::resizeTextureMemory(TextureInfo* info, const IntSize& size)
 {
     ASSERT(info->textureId);
     if (info->imageId) {
         deleteChromiumImageForTexture(info);
-        info->imageId = m_gl->CreateGpuMemoryBufferImageCHROMIUM(size.width(), size.height(), info->parameters.internalColorFormat, GC3D_SCANOUT_CHROMIUM);
+        info->imageId = m_gl->CreateGpuMemoryBufferImageCHROMIUM(size.width(), size.height(), info->parameters.creationInternalColorFormat, GC3D_SCANOUT_CHROMIUM);
         if (info->imageId) {
             m_gl->BindTexture(info->parameters.target, info->textureId);
             m_gl->BindTexImage2DCHROMIUM(info->parameters.target, info->imageId);
+            clearChromiumImageIfNecessary(*info);
             return;
         }
 
         // If the desired texture target is different, there's no way to fall back
         // to a non CHROMIUM_image texture.
         if (chromiumImageTextureParameters().target != defaultTextureParameters().target)
             return;
     }
 
     m_gl->BindTexture(info->parameters.target, info->textureId);
-    texImage2DResourceSafe(info->parameters.target, 0, info->parameters.internalColorFormat, size.width(), size.height(), 0, info->parameters.colorFormat, GL_UNSIGNED_BYTE);
+    texImage2DResourceSafe(info->parameters.target, 0, info->parameters.creationInternalColorFormat, size.width(), size.height(), 0, info->parameters.colorFormat, GL_UNSIGNED_BYTE);
 }
 
 void DrawingBuffer::attachColorBufferToCurrentFBO()
 {
     GLenum target = m_colorBuffer.parameters.target;
 
     m_gl->BindTexture(target, m_colorBuffer.textureId);
 
     if (m_antiAliasingMode == MSAAImplicitResolve)
         m_gl->FramebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, m_colorBuffer.textureId, 0, m_sampleCount);
     else
         m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, m_colorBuffer.textureId, 0);
 
     m_gl->BindTexture(GL_TEXTURE_2D, m_texture2DBinding);
 }
 
 } // namespace blink