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/WebGraphicsContext3DProvider.h"
@@ skipping 83 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_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_intermediateFBO(0)
+    , m_intermediateRenderbuffer(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)
     , m_filterQuality(kLow_SkFilterQuality)
 {
+    memset(m_colorMask, 0, 4 * sizeof(GLboolean));
+    memset(m_clearColor, 0, 4 * sizeof(GLfloat));
     // Used by browser tests to detect the use of a DrawingBuffer.
     TRACE_EVENT_INSTANT0("test_gpu", "DrawingBufferCreation", TRACE_EVENT_SCOPE_GLOBAL);
 }
 
 DrawingBuffer::~DrawingBuffer()
 {
     ASSERT(m_destructionInProgress);
     ASSERT(m_textureMailboxes.isEmpty());
     m_layer.clear();
     m_contextProvider.clear();
@@ skipping 40 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 when CHROMIUM_image is being used.
+    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_intermediateFBO)
+        m_gl->DeleteFramebuffers(1, &m_intermediateFBO);
+
+    if (m_intermediateRenderbuffer)
+        m_gl->DeleteRenderbuffers(1, &m_intermediateRenderbuffer);
+
     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 50 matching lines @@
         m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, m_colorBuffer.parameters.internalRenderbufferFormat, size.width(), size.height());
 
         if (m_gl->GetError() == GL_OUT_OF_MEMORY)
             return false;
 
         m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_multisampleColorBuffer);
         if (wantDepthOrStencilBuffer)
             resizeDepthStencil(size);
         if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
             return false;
+
+        if (m_intermediateFBO) {
+            m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_intermediateFBO);
+            m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_intermediateRenderbuffer);
+            m_gl->RenderbufferStorage(GL_RENDERBUFFER, m_colorBuffer.parameters.internalRenderbufferFormat, size.width(), size.height());
+
+            if (m_gl->GetError() == GL_OUT_OF_MEMORY)
+                return false;
+
+            m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_intermediateRenderbuffer);
+            if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+                return false;
+
+            m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
+        }
     }
 
     return true;
 }
 
 void DrawingBuffer::resizeDepthStencil(const IntSize& size)
 {
     if (!m_depthStencilBuffer)
         m_gl->GenRenderbuffers(1, &m_depthStencilBuffer);
     m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
@@ skipping 73 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);
     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_intermediateFBO) {
+                DCHECK(!m_intermediateRenderbuffer);
+                m_gl->GenRenderbuffers(1, &m_intermediateRenderbuffer);
+                m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_intermediateRenderbuffer);
+                m_gl->RenderbufferStorage(GL_RENDERBUFFER, GL_RGB8, width, height);
+
+                m_gl->GenFramebuffers(1, &m_intermediateFBO);
+                m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER_ANGLE, m_intermediateFBO);
+                m_gl->FramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER_ANGLE, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_intermediateRenderbuffer);
+                m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_renderbufferBinding);
+            }
+
+            m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER_ANGLE, m_intermediateFBO);
+            m_gl->BlitFramebufferCHROMIUM(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, filter);
+
+            m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER_ANGLE, m_intermediateFBO);
+            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::clearChromiumImageAlpha(const TextureInfo& info)
+{
+    if (m_wantAlphaChannel)
+        return;
+    if (!contextProvider()->getCapabilities().chromium_image_rgb_emulation)
+        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);
+    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();
+    m_gl->ClearColor(m_clearColor[0], m_clearColor[1], m_clearColor[2], m_clearColor[3]);
+    m_gl->ColorMask(m_colorMask[0], m_colorMask[1], m_colorMask[2], m_colorMask[3]);
+}
+
 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;
+    clearChromiumImageAlpha(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);
+            clearChromiumImageAlpha(*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