| /* |
| * 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 |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * 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" |
| #include "wtf/CheckedNumeric.h" |
| #include "wtf/PtrUtil.h" |
| #include "wtf/typed_arrays/ArrayBufferContents.h" |
| #include <algorithm> |
| #include <memory> |
| |
| namespace blink { |
| |
| namespace { |
| |
| const float s_resourceAdjustedRatio = 0.5; |
| |
| class ScopedTextureUnit0BindingRestorer { |
| STACK_ALLOCATED(); |
| WTF_MAKE_NONCOPYABLE(ScopedTextureUnit0BindingRestorer); |
| public: |
| ScopedTextureUnit0BindingRestorer(gpu::gles2::GLES2Interface* gl, GLenum activeTextureUnit, GLuint textureUnitZeroId) |
| : m_gl(gl) |
| , m_oldActiveTextureUnit(activeTextureUnit) |
| , m_oldTextureUnitZeroId(textureUnitZeroId) |
| { |
| m_gl->ActiveTexture(GL_TEXTURE0); |
| } |
| ~ScopedTextureUnit0BindingRestorer() |
| { |
| m_gl->BindTexture(GL_TEXTURE_2D, m_oldTextureUnitZeroId); |
| m_gl->ActiveTexture(m_oldActiveTextureUnit); |
| } |
| |
| private: |
| gpu::gles2::GLES2Interface* m_gl; |
| GLenum m_oldActiveTextureUnit; |
| GLuint m_oldTextureUnitZeroId; |
| }; |
| |
| static bool shouldFailDrawingBufferCreationForTesting = false; |
| |
| } // namespace |
| |
| PassRefPtr<DrawingBuffer> DrawingBuffer::create(std::unique_ptr<WebGraphicsContext3DProvider> contextProvider, |
| const IntSize& size, bool premultipliedAlpha, bool wantAlphaChannel, |
| bool wantDepthBuffer, bool wantStencilBuffer, bool wantAntialiasing, |
| PreserveDrawingBuffer preserve, WebGLVersion webGLVersion) |
| { |
| ASSERT(contextProvider); |
| |
| if (shouldFailDrawingBufferCreationForTesting) { |
| shouldFailDrawingBufferCreationForTesting = false; |
| return nullptr; |
| } |
| |
| std::unique_ptr<Extensions3DUtil> extensionsUtil = Extensions3DUtil::create(contextProvider->contextGL()); |
| if (!extensionsUtil->isValid()) { |
| // This might be the first time we notice that the GL context is lost. |
| return nullptr; |
| } |
| ASSERT(extensionsUtil->supportsExtension("GL_OES_packed_depth_stencil")); |
| extensionsUtil->ensureExtensionEnabled("GL_OES_packed_depth_stencil"); |
| bool multisampleSupported = wantAntialiasing |
| && (extensionsUtil->supportsExtension("GL_CHROMIUM_framebuffer_multisample") |
| || extensionsUtil->supportsExtension("GL_EXT_multisampled_render_to_texture")) |
| && extensionsUtil->supportsExtension("GL_OES_rgb8_rgba8"); |
| if (multisampleSupported) { |
| extensionsUtil->ensureExtensionEnabled("GL_OES_rgb8_rgba8"); |
| if (extensionsUtil->supportsExtension("GL_CHROMIUM_framebuffer_multisample")) |
| extensionsUtil->ensureExtensionEnabled("GL_CHROMIUM_framebuffer_multisample"); |
| else |
| extensionsUtil->ensureExtensionEnabled("GL_EXT_multisampled_render_to_texture"); |
| } |
| bool discardFramebufferSupported = extensionsUtil->supportsExtension("GL_EXT_discard_framebuffer"); |
| if (discardFramebufferSupported) |
| extensionsUtil->ensureExtensionEnabled("GL_EXT_discard_framebuffer"); |
| |
| RefPtr<DrawingBuffer> drawingBuffer = adoptRef(new DrawingBuffer(std::move(contextProvider), std::move(extensionsUtil), |
| discardFramebufferSupported, wantAlphaChannel, premultipliedAlpha, |
| preserve, webGLVersion, wantDepthBuffer, wantStencilBuffer)); |
| if (!drawingBuffer->initialize(size, multisampleSupported)) { |
| drawingBuffer->beginDestruction(); |
| return PassRefPtr<DrawingBuffer>(); |
| } |
| return drawingBuffer.release(); |
| } |
| |
| void DrawingBuffer::forceNextDrawingBufferCreationToFail() |
| { |
| shouldFailDrawingBufferCreationForTesting = true; |
| } |
| |
| DrawingBuffer::DrawingBuffer( |
| std::unique_ptr<WebGraphicsContext3DProvider> contextProvider, |
| std::unique_ptr<Extensions3DUtil> extensionsUtil, |
| bool discardFramebufferSupported, |
| bool wantAlphaChannel, |
| bool premultipliedAlpha, |
| PreserveDrawingBuffer preserve, |
| WebGLVersion webGLVersion, |
| bool wantDepth, |
| bool wantStencil) |
| : m_preserveDrawingBuffer(preserve) |
| , m_webGLVersion(webGLVersion) |
| , m_contextProvider(std::move(contextProvider)) |
| , m_gl(m_contextProvider->contextGL()) |
| , m_extensionsUtil(std::move(extensionsUtil)) |
| , m_discardFramebufferSupported(discardFramebufferSupported) |
| , m_wantAlphaChannel(wantAlphaChannel) |
| , m_premultipliedAlpha(premultipliedAlpha) |
| , m_wantDepth(wantDepth) |
| , m_wantStencil(wantStencil) |
| { |
| 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.reset(); |
| m_contextProvider.reset(); |
| } |
| |
| void DrawingBuffer::markContentsChanged() |
| { |
| m_contentsChanged = true; |
| m_contentsChangeCommitted = false; |
| } |
| |
| bool DrawingBuffer::bufferClearNeeded() const |
| { |
| return m_bufferClearNeeded; |
| } |
| |
| void DrawingBuffer::setBufferClearNeeded(bool flag) |
| { |
| if (m_preserveDrawingBuffer == Discard) { |
| m_bufferClearNeeded = flag; |
| } else { |
| ASSERT(!m_bufferClearNeeded); |
| } |
| } |
| |
| gpu::gles2::GLES2Interface* DrawingBuffer::contextGL() |
| { |
| return m_gl; |
| } |
| |
| WebGraphicsContext3DProvider* DrawingBuffer::contextProvider() |
| { |
| return m_contextProvider.get(); |
| } |
| |
| void DrawingBuffer::setIsHidden(bool hidden) |
| { |
| if (m_isHidden == hidden) |
| return; |
| m_isHidden = hidden; |
| if (m_isHidden) |
| freeRecycledMailboxes(); |
| } |
| |
| void DrawingBuffer::setFilterQuality(SkFilterQuality filterQuality) |
| { |
| if (m_filterQuality != filterQuality) { |
| m_filterQuality = filterQuality; |
| if (m_layer) |
| m_layer->setNearestNeighbor(filterQuality == kNone_SkFilterQuality); |
| } |
| } |
| |
| bool DrawingBuffer::requiresAlphaChannelToBePreserved() |
| { |
| return !m_drawFramebufferBinding && defaultBufferRequiresAlphaChannelToBePreserved(); |
| } |
| |
| bool DrawingBuffer::defaultBufferRequiresAlphaChannelToBePreserved() |
| { |
| if (wantExplicitResolve()) { |
| return !m_wantAlphaChannel && getMultisampledRenderbufferFormat() == GL_RGBA8_OES; |
| } |
| |
| bool rgbEmulation = contextProvider()->getCapabilities().emulate_rgb_buffer_with_rgba |
| || (RuntimeEnabledFeatures::webGLImageChromiumEnabled() && contextProvider()->getCapabilities().chromium_image_rgb_emulation); |
| return !m_wantAlphaChannel && rgbEmulation; |
| } |
| |
| void DrawingBuffer::freeRecycledMailboxes() |
| { |
| if (m_recycledMailboxQueue.isEmpty()) |
| return; |
| while (!m_recycledMailboxQueue.isEmpty()) |
| deleteMailbox(m_recycledMailboxQueue.takeLast()); |
| } |
| |
| bool DrawingBuffer::prepareMailbox(WebExternalTextureMailbox* outMailbox, WebExternalBitmap* bitmap) |
| { |
| if (m_destructionInProgress) { |
| // It can be hit in the following sequence. |
| // 1. WebGL draws something. |
| // 2. The compositor begins the frame. |
| // 3. Javascript makes a context lost using WEBGL_lose_context extension. |
| // 4. Here. |
| return false; |
| } |
| ASSERT(!m_isHidden); |
| if (!m_contentsChanged) |
| return false; |
| |
| if (m_newMailboxCallback) |
| (*m_newMailboxCallback)(); |
| |
| // Resolve the multisampled buffer into m_colorBuffer texture. |
| if (m_antiAliasingMode != None) |
| commit(); |
| |
| if (bitmap) { |
| bitmap->setSize(size()); |
| |
| unsigned char* pixels = bitmap->pixels(); |
| if (!pixels) |
| return false; |
| |
| bool needPremultiply = m_wantAlphaChannel && !m_premultipliedAlpha; |
| WebGLImageConversion::AlphaOp op = needPremultiply ? WebGLImageConversion::AlphaDoPremultiply : WebGLImageConversion::AlphaDoNothing; |
| readBackFramebuffer(pixels, size().width(), size().height(), ReadbackSkia, op); |
| } |
| |
| // We must restore the texture binding since creating new textures, |
| // consuming and producing mailboxes changes it. |
| ScopedTextureUnit0BindingRestorer restorer(m_gl, m_activeTextureUnit, m_texture2DBinding); |
| |
| // First try to recycle an old buffer. |
| RefPtr<MailboxInfo> frontColorBufferMailbox = recycledMailbox(); |
| |
| // No buffer available to recycle, create a new one. |
| if (!frontColorBufferMailbox) |
| frontColorBufferMailbox = createNewMailbox(createTextureAndAllocateMemory(m_size)); |
| |
| if (m_preserveDrawingBuffer == Discard) { |
| std::swap(frontColorBufferMailbox->textureInfo, m_colorBuffer); |
| attachColorBufferToReadFramebuffer(); |
| |
| if (m_discardFramebufferSupported) { |
| // Explicitly discard framebuffer to save GPU memory bandwidth for tile-based GPU arch. |
| const GLenum attachments[3] = { GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT }; |
| m_gl->DiscardFramebufferEXT(GL_FRAMEBUFFER, 3, attachments); |
| } |
| } else { |
| m_gl->CopySubTextureCHROMIUM(m_colorBuffer.textureId, frontColorBufferMailbox->textureInfo.textureId, |
| 0, 0, 0, 0, m_size.width(), m_size.height(), GL_FALSE, GL_FALSE, GL_FALSE); |
| } |
| |
| restoreFramebufferBindings(); |
| m_contentsChanged = false; |
| |
| m_gl->ProduceTextureDirectCHROMIUM(frontColorBufferMailbox->textureInfo.textureId, frontColorBufferMailbox->textureInfo.parameters.target, frontColorBufferMailbox->mailbox.name); |
| const GLuint64 fenceSync = m_gl->InsertFenceSyncCHROMIUM(); |
| if (RuntimeEnabledFeatures::webGLImageChromiumEnabled()) |
| m_gl->DescheduleUntilFinishedCHROMIUM(); |
| m_gl->Flush(); |
| m_gl->GenSyncTokenCHROMIUM(fenceSync, frontColorBufferMailbox->mailbox.syncToken); |
| frontColorBufferMailbox->mailbox.validSyncToken = true; |
| frontColorBufferMailbox->mailbox.allowOverlay = frontColorBufferMailbox->textureInfo.imageId != 0; |
| frontColorBufferMailbox->mailbox.textureTarget = frontColorBufferMailbox->textureInfo.parameters.target; |
| frontColorBufferMailbox->mailbox.textureSize = WebSize(m_size.width(), m_size.height()); |
| frontColorBufferMailbox->mailbox.gpuMemoryBufferId = frontColorBufferMailbox->textureInfo.gpuMemoryBufferId; |
| setBufferClearNeeded(true); |
| |
| // set m_parentDrawingBuffer to make sure 'this' stays alive as long as it has live mailboxes |
| ASSERT(!frontColorBufferMailbox->m_parentDrawingBuffer); |
| frontColorBufferMailbox->m_parentDrawingBuffer = this; |
| *outMailbox = frontColorBufferMailbox->mailbox; |
| m_frontColorBuffer = { frontColorBufferMailbox->textureInfo, frontColorBufferMailbox->mailbox }; |
| return true; |
| } |
| |
| void DrawingBuffer::mailboxReleased(const WebExternalTextureMailbox& mailbox, bool lostResource) |
| { |
| if (m_destructionInProgress || m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR || lostResource || m_isHidden) { |
| mailboxReleasedWithoutRecycling(mailbox); |
| return; |
| } |
| |
| for (size_t i = 0; i < m_textureMailboxes.size(); i++) { |
| RefPtr<MailboxInfo> mailboxInfo = m_textureMailboxes[i]; |
| if (nameEquals(mailboxInfo->mailbox, mailbox)) { |
| memcpy(mailboxInfo->mailbox.syncToken, mailbox.syncToken, |
| sizeof(mailboxInfo->mailbox.syncToken)); |
| mailboxInfo->mailbox.validSyncToken = mailbox.validSyncToken; |
| ASSERT(mailboxInfo->m_parentDrawingBuffer.get() == this); |
| mailboxInfo->m_parentDrawingBuffer.clear(); |
| m_recycledMailboxQueue.prepend(mailboxInfo->mailbox); |
| return; |
| } |
| } |
| 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; |
| |
| if (m_wantAlphaChannel) { |
| parameters.creationInternalColorFormat = GL_RGBA; |
| parameters.internalColorFormat = GL_RGBA; |
| } else if (contextProvider()->getCapabilities().chromium_image_rgb_emulation) { |
| parameters.creationInternalColorFormat = GL_RGB; |
| parameters.internalColorFormat = GL_RGBA; |
| } else { |
| GLenum format = defaultBufferRequiresAlphaChannelToBePreserved() ? GL_RGBA : GL_RGB; |
| parameters.creationInternalColorFormat = format; |
| parameters.internalColorFormat = format; |
| } |
| |
| // 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; |
| } else if (contextProvider()->getCapabilities().emulate_rgb_buffer_with_rgba) { |
| parameters.internalColorFormat = GL_RGBA; |
| parameters.creationInternalColorFormat = GL_RGBA; |
| parameters.colorFormat = GL_RGBA; |
| } else { |
| GLenum format = defaultBufferRequiresAlphaChannelToBePreserved() ? GL_RGBA : GL_RGB; |
| parameters.creationInternalColorFormat = format; |
| parameters.internalColorFormat = format; |
| parameters.colorFormat = format; |
| } |
| return parameters; |
| } |
| |
| void DrawingBuffer::mailboxReleasedWithoutRecycling(const WebExternalTextureMailbox& mailbox) |
| { |
| ASSERT(m_textureMailboxes.size()); |
| // Ensure not to call the destructor until deleteMailbox() is completed. |
| RefPtr<DrawingBuffer> self = this; |
| deleteMailbox(mailbox); |
| } |
| |
| PassRefPtr<DrawingBuffer::MailboxInfo> DrawingBuffer::recycledMailbox() |
| { |
| if (m_recycledMailboxQueue.isEmpty()) |
| return PassRefPtr<MailboxInfo>(); |
| |
| // Creation of image backed mailboxes is very expensive, so be less |
| // aggressive about pruning them. |
| size_t cacheLimit = 1; |
| if (RuntimeEnabledFeatures::webGLImageChromiumEnabled()) |
| cacheLimit = 4; |
| |
| WebExternalTextureMailbox mailbox; |
| while (m_recycledMailboxQueue.size() > cacheLimit) { |
| mailbox = m_recycledMailboxQueue.takeLast(); |
| deleteMailbox(mailbox); |
| } |
| mailbox = m_recycledMailboxQueue.takeLast(); |
| |
| RefPtr<MailboxInfo> mailboxInfo; |
| for (size_t i = 0; i < m_textureMailboxes.size(); i++) { |
| if (nameEquals(m_textureMailboxes[i]->mailbox, mailbox)) { |
| mailboxInfo = m_textureMailboxes[i]; |
| break; |
| } |
| } |
| ASSERT(mailboxInfo); |
| |
| if (mailboxInfo->mailbox.validSyncToken) { |
| m_gl->WaitSyncTokenCHROMIUM(mailboxInfo->mailbox.syncToken); |
| mailboxInfo->mailbox.validSyncToken = false; |
| } |
| |
| if (mailboxInfo->size != m_size) { |
| resizeTextureMemory(&mailboxInfo->textureInfo, m_size); |
| mailboxInfo->size = m_size; |
| } |
| |
| return mailboxInfo.release(); |
| } |
| |
| PassRefPtr<DrawingBuffer::MailboxInfo> DrawingBuffer::createNewMailbox(const TextureInfo& info) |
| { |
| RefPtr<MailboxInfo> returnMailbox = adoptRef(new MailboxInfo()); |
| m_gl->GenMailboxCHROMIUM(returnMailbox->mailbox.name); |
| returnMailbox->textureInfo = info; |
| returnMailbox->size = m_size; |
| m_textureMailboxes.append(returnMailbox); |
| return returnMailbox.release(); |
| } |
| |
| void DrawingBuffer::deleteMailbox(const WebExternalTextureMailbox& mailbox) |
| { |
| for (size_t i = 0; i < m_textureMailboxes.size(); i++) { |
| if (nameEquals(m_textureMailboxes[i]->mailbox, mailbox)) { |
| if (mailbox.validSyncToken) |
| m_gl->WaitSyncTokenCHROMIUM(mailbox.syncToken); |
| |
| deleteChromiumImageForTexture(&m_textureMailboxes[i]->textureInfo); |
| |
| m_gl->DeleteTextures(1, &m_textureMailboxes[i]->textureInfo.textureId); |
| m_textureMailboxes.remove(i); |
| return; |
| } |
| } |
| ASSERT_NOT_REACHED(); |
| } |
| |
| bool DrawingBuffer::initialize(const IntSize& size, bool useMultisampling) |
| { |
| if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) { |
| // Need to try to restore the context again later. |
| return false; |
| } |
| |
| m_gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &m_maxTextureSize); |
| |
| int maxSampleCount = 0; |
| m_antiAliasingMode = None; |
| if (useMultisampling) { |
| m_gl->GetIntegerv(GL_MAX_SAMPLES_ANGLE, &maxSampleCount); |
| m_antiAliasingMode = MSAAExplicitResolve; |
| if (m_extensionsUtil->supportsExtension("GL_EXT_multisampled_render_to_texture")) { |
| m_antiAliasingMode = MSAAImplicitResolve; |
| } else if (m_extensionsUtil->supportsExtension("GL_CHROMIUM_screen_space_antialiasing")) { |
| m_antiAliasingMode = ScreenSpaceAntialiasing; |
| } |
| } |
| m_storageTextureSupported = m_webGLVersion > WebGL1 || m_extensionsUtil->supportsExtension("GL_EXT_texture_storage"); |
| m_sampleCount = std::min(4, maxSampleCount); |
| |
| m_gl->GenFramebuffers(1, &m_fbo); |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo); |
| if (wantExplicitResolve()) { |
| m_gl->GenFramebuffers(1, &m_multisampleFBO); |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO); |
| m_gl->GenRenderbuffers(1, &m_multisampleRenderbuffer); |
| } |
| if (!reset(size)) |
| return false; |
| |
| if (m_depthStencilBuffer) { |
| DCHECK(wantDepthOrStencil()); |
| m_hasImplicitStencilBuffer = !m_wantStencil; |
| } |
| |
| if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) { |
| // It's possible that the drawing buffer allocation provokes a context loss, so check again just in case. http://crbug.com/512302 |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool DrawingBuffer::copyToPlatformTexture(gpu::gles2::GLES2Interface* gl, GLuint texture, GLenum internalFormat, |
| GLenum destType, GLint level, bool premultiplyAlpha, bool flipY, SourceDrawingBuffer sourceBuffer) |
| { |
| if (m_contentsChanged) { |
| if (m_antiAliasingMode != None) { |
| commit(); |
| restoreFramebufferBindings(); |
| } |
| m_gl->Flush(); |
| } |
| |
| // Assume that the destination target is GL_TEXTURE_2D. |
| if (!Extensions3DUtil::canUseCopyTextureCHROMIUM(GL_TEXTURE_2D, internalFormat, destType, level)) |
| return false; |
| |
| // Contexts may be in a different share group. We must transfer the texture through a mailbox first |
| WebExternalTextureMailbox mailbox; |
| GLint textureId = 0; |
| GLenum target = 0; |
| if (sourceBuffer == FrontBuffer && m_frontColorBuffer.texInfo.textureId) { |
| textureId = m_frontColorBuffer.texInfo.textureId; |
| mailbox = m_frontColorBuffer.mailbox; |
| target = m_frontColorBuffer.texInfo.parameters.target; |
| } else { |
| textureId = m_colorBuffer.textureId; |
| target = m_colorBuffer.parameters.target; |
| m_gl->GenMailboxCHROMIUM(mailbox.name); |
| m_gl->ProduceTextureDirectCHROMIUM(textureId, target, mailbox.name); |
| const GLuint64 fenceSync = m_gl->InsertFenceSyncCHROMIUM(); |
| m_gl->Flush(); |
| m_gl->GenSyncTokenCHROMIUM(fenceSync, mailbox.syncToken); |
| mailbox.validSyncToken = true; |
| } |
| |
| if (mailbox.validSyncToken) |
| gl->WaitSyncTokenCHROMIUM(mailbox.syncToken); |
| GLuint sourceTexture = gl->CreateAndConsumeTextureCHROMIUM(target, mailbox.name); |
| |
| GLboolean unpackPremultiplyAlphaNeeded = GL_FALSE; |
| GLboolean unpackUnpremultiplyAlphaNeeded = GL_FALSE; |
| if (m_wantAlphaChannel && m_premultipliedAlpha && !premultiplyAlpha) |
| unpackUnpremultiplyAlphaNeeded = GL_TRUE; |
| else if (m_wantAlphaChannel && !m_premultipliedAlpha && premultiplyAlpha) |
| unpackPremultiplyAlphaNeeded = GL_TRUE; |
| |
| gl->CopyTextureCHROMIUM(sourceTexture, texture, internalFormat, destType, flipY, unpackPremultiplyAlphaNeeded, unpackUnpremultiplyAlphaNeeded); |
| |
| gl->DeleteTextures(1, &sourceTexture); |
| |
| const GLuint64 fenceSync = gl->InsertFenceSyncCHROMIUM(); |
| |
| gl->Flush(); |
| GLbyte syncToken[24]; |
| gl->GenSyncTokenCHROMIUM(fenceSync, syncToken); |
| m_gl->WaitSyncTokenCHROMIUM(syncToken); |
| |
| return true; |
| } |
| |
| GLuint DrawingBuffer::framebuffer() const |
| { |
| return m_fbo; |
| } |
| |
| WebLayer* DrawingBuffer::platformLayer() |
| { |
| if (!m_layer) { |
| m_layer = wrapUnique(Platform::current()->compositorSupport()->createExternalTextureLayer(this)); |
| |
| m_layer->setOpaque(!m_wantAlphaChannel); |
| m_layer->setBlendBackgroundColor(m_wantAlphaChannel); |
| m_layer->setPremultipliedAlpha(m_premultipliedAlpha); |
| m_layer->setNearestNeighbor(m_filterQuality == kNone_SkFilterQuality); |
| GraphicsLayer::registerContentsLayer(m_layer->layer()); |
| } |
| |
| return m_layer->layer(); |
| } |
| |
| void DrawingBuffer::clearPlatformLayer() |
| { |
| if (m_layer) |
| m_layer->clearTexture(); |
| |
| m_gl->Flush(); |
| } |
| |
| void DrawingBuffer::beginDestruction() |
| { |
| ASSERT(!m_destructionInProgress); |
| m_destructionInProgress = true; |
| |
| clearPlatformLayer(); |
| |
| while (!m_recycledMailboxQueue.isEmpty()) |
| deleteMailbox(m_recycledMailboxQueue.takeLast()); |
| |
| if (m_multisampleFBO) |
| m_gl->DeleteFramebuffers(1, &m_multisampleFBO); |
| |
| if (m_fbo) |
| m_gl->DeleteFramebuffers(1, &m_fbo); |
| |
| if (m_multisampleRenderbuffer) |
| m_gl->DeleteRenderbuffers(1, &m_multisampleRenderbuffer); |
| |
| 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()); |
| |
| m_colorBuffer = TextureInfo(); |
| m_frontColorBuffer = FrontBufferInfo(); |
| m_multisampleRenderbuffer = 0; |
| m_depthStencilBuffer = 0; |
| m_multisampleFBO = 0; |
| m_fbo = 0; |
| |
| if (m_layer) |
| GraphicsLayer::unregisterContentsLayer(m_layer->layer()); |
| } |
| |
| GLuint DrawingBuffer::createColorTexture(const TextureParameters& parameters) |
| { |
| GLuint offscreenColorTexture; |
| m_gl->GenTextures(1, &offscreenColorTexture); |
| m_gl->BindTexture(parameters.target, offscreenColorTexture); |
| m_gl->TexParameteri(parameters.target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| m_gl->TexParameteri(parameters.target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| m_gl->TexParameteri(parameters.target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| m_gl->TexParameteri(parameters.target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| return offscreenColorTexture; |
| } |
| |
| bool DrawingBuffer::resizeMultisampleFramebuffer(const IntSize& size) |
| { |
| DCHECK(wantExplicitResolve()); |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO); |
| m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_multisampleRenderbuffer); |
| m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, getMultisampledRenderbufferFormat(), 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_multisampleRenderbuffer); |
| |
| return true; |
| } |
| |
| void DrawingBuffer::resizeDepthStencil(const IntSize& size) |
| { |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO ? m_multisampleFBO : m_fbo); |
| if (!m_depthStencilBuffer) |
| m_gl->GenRenderbuffers(1, &m_depthStencilBuffer); |
| m_gl->BindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer); |
| if (m_antiAliasingMode == MSAAImplicitResolve) |
| m_gl->RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height()); |
| else if (m_antiAliasingMode == MSAAExplicitResolve) |
| m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount, GL_DEPTH24_STENCIL8_OES, size.width(), size.height()); |
| else |
| m_gl->RenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES, size.width(), size.height()); |
| // For ES 2.0 contexts DEPTH_STENCIL is not available natively, so we emulate it |
| // at the command buffer level for WebGL contexts. |
| m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer); |
| m_gl->BindRenderbuffer(GL_RENDERBUFFER, 0); |
| } |
| |
| bool DrawingBuffer::resizeDefaultFramebuffer(const IntSize& size) |
| { |
| // Resize or create m_colorBuffer. |
| if (m_colorBuffer.textureId) { |
| resizeTextureMemory(&m_colorBuffer, size); |
| } else { |
| m_colorBuffer = createTextureAndAllocateMemory(size); |
| } |
| |
| attachColorBufferToReadFramebuffer(); |
| |
| if (wantExplicitResolve()) { |
| if (!resizeMultisampleFramebuffer(size)) |
| return false; |
| } |
| |
| if (wantDepthOrStencil()) |
| resizeDepthStencil(size); |
| |
| if (wantExplicitResolve()) { |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO); |
| if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) |
| return false; |
| } |
| |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo); |
| return m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE; |
| } |
| |
| void DrawingBuffer::clearFramebuffers(GLbitfield clearMask) |
| { |
| // We will clear the multisample FBO, but we also need to clear the non-multisampled buffer. |
| if (m_multisampleFBO) { |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo); |
| m_gl->Clear(GL_COLOR_BUFFER_BIT); |
| } |
| |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO ? m_multisampleFBO : m_fbo); |
| m_gl->Clear(clearMask); |
| } |
| |
| void DrawingBuffer::setSize(const IntSize& size) |
| { |
| if (m_size == size) |
| return; |
| |
| m_size = size; |
| } |
| |
| IntSize DrawingBuffer::adjustSize(const IntSize& desiredSize, const IntSize& curSize, int maxTextureSize) |
| { |
| IntSize adjustedSize = desiredSize; |
| |
| // Clamp if the desired size is greater than the maximum texture size for the device. |
| if (adjustedSize.height() > maxTextureSize) |
| adjustedSize.setHeight(maxTextureSize); |
| |
| if (adjustedSize.width() > maxTextureSize) |
| adjustedSize.setWidth(maxTextureSize); |
| |
| return adjustedSize; |
| } |
| |
| bool DrawingBuffer::reset(const IntSize& newSize) |
| { |
| CHECK(!newSize.isEmpty()); |
| IntSize adjustedSize = adjustSize(newSize, m_size, m_maxTextureSize); |
| if (adjustedSize.isEmpty()) |
| return false; |
| |
| if (adjustedSize != m_size) { |
| do { |
| if (!resizeDefaultFramebuffer(adjustedSize)) { |
| adjustedSize.scale(s_resourceAdjustedRatio); |
| continue; |
| } |
| break; |
| } while (!adjustedSize.isEmpty()); |
| |
| setSize(adjustedSize); |
| |
| if (adjustedSize.isEmpty()) |
| return false; |
| } |
| |
| m_gl->Disable(GL_SCISSOR_TEST); |
| m_gl->ClearColor(0, 0, 0, defaultBufferRequiresAlphaChannelToBePreserved() ? 1 : 0); |
| m_gl->ColorMask(true, true, true, true); |
| |
| 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 (wantExplicitResolve() && !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. |
| GLuint filter = GL_NEAREST; |
| |
| m_gl->BlitFramebufferCHROMIUM(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, filter); |
| |
| // On old AMD GPUs on OS X, glColorMask doesn't work correctly for |
| // multisampled renderbuffers and the alpha channel can be overwritten. |
| // Clear the alpha channel of |m_fbo|. |
| if (defaultBufferRequiresAlphaChannelToBePreserved() |
| && contextProvider()->getCapabilities().disable_multisampling_color_mask_usage) { |
| m_gl->ClearColor(0, 0, 0, 1); |
| m_gl->ColorMask(false, false, false, true); |
| m_gl->Clear(GL_COLOR_BUFFER_BIT); |
| |
| 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]); |
| } |
| |
| 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; |
| } |
| |
| void DrawingBuffer::restoreFramebufferBindings() |
| { |
| if (m_drawFramebufferBinding && m_readFramebufferBinding) { |
| if (m_drawFramebufferBinding == m_readFramebufferBinding) { |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_readFramebufferBinding); |
| } else { |
| m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER, m_readFramebufferBinding); |
| m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER, m_drawFramebufferBinding); |
| } |
| return; |
| } |
| if (!m_drawFramebufferBinding && !m_readFramebufferBinding) { |
| bind(GL_FRAMEBUFFER); |
| return; |
| } |
| if (!m_drawFramebufferBinding) { |
| bind(GL_DRAW_FRAMEBUFFER); |
| m_gl->BindFramebuffer(GL_READ_FRAMEBUFFER, m_readFramebufferBinding); |
| } else { |
| bind(GL_READ_FRAMEBUFFER); |
| m_gl->BindFramebuffer(GL_DRAW_FRAMEBUFFER, m_drawFramebufferBinding); |
| } |
| } |
| |
| bool DrawingBuffer::multisample() const |
| { |
| return m_antiAliasingMode != None; |
| } |
| |
| void DrawingBuffer::bind(GLenum target) |
| { |
| m_gl->BindFramebuffer(target, wantExplicitResolve() ? m_multisampleFBO : m_fbo); |
| } |
| |
| void DrawingBuffer::setPackAlignment(GLint param) |
| { |
| m_packAlignment = param; |
| } |
| |
| bool DrawingBuffer::paintRenderingResultsToImageData(int& width, int& height, SourceDrawingBuffer sourceBuffer, WTF::ArrayBufferContents& contents) |
| { |
| ASSERT(!m_premultipliedAlpha); |
| width = size().width(); |
| height = size().height(); |
| |
| CheckedNumeric<int> dataSize = 4; |
| dataSize *= width; |
| dataSize *= height; |
| if (!dataSize.IsValid()) |
| return false; |
| |
| WTF::ArrayBufferContents pixels(width * height, 4, WTF::ArrayBufferContents::NotShared, WTF::ArrayBufferContents::DontInitialize); |
| |
| GLuint fbo = 0; |
| if (sourceBuffer == FrontBuffer && m_frontColorBuffer.texInfo.textureId) { |
| m_gl->GenFramebuffers(1, &fbo); |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, fbo); |
| m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_frontColorBuffer.texInfo.parameters.target, m_frontColorBuffer.texInfo.textureId, 0); |
| } else { |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, framebuffer()); |
| } |
| |
| readBackFramebuffer(static_cast<unsigned char*>(pixels.data()), width, height, ReadbackRGBA, WebGLImageConversion::AlphaDoNothing); |
| flipVertically(static_cast<uint8_t*>(pixels.data()), width, height); |
| |
| if (fbo) { |
| m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_frontColorBuffer.texInfo.parameters.target, 0, 0); |
| m_gl->DeleteFramebuffers(1, &fbo); |
| } |
| |
| restoreFramebufferBindings(); |
| |
| pixels.transfer(contents); |
| return true; |
| } |
| |
| void DrawingBuffer::readBackFramebuffer(unsigned char* pixels, int width, int height, ReadbackOrder readbackOrder, WebGLImageConversion::AlphaOp op) |
| { |
| if (m_packAlignment > 4) |
| m_gl->PixelStorei(GL_PACK_ALIGNMENT, 1); |
| m_gl->ReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); |
| if (m_packAlignment > 4) |
| m_gl->PixelStorei(GL_PACK_ALIGNMENT, m_packAlignment); |
| |
| size_t bufferSize = 4 * width * height; |
| |
| if (readbackOrder == ReadbackSkia) { |
| #if (SK_R32_SHIFT == 16) && !SK_B32_SHIFT |
| // Swizzle red and blue channels to match SkBitmap's byte ordering. |
| // TODO(kbr): expose GL_BGRA as extension. |
| for (size_t i = 0; i < bufferSize; i += 4) { |
| std::swap(pixels[i], pixels[i + 2]); |
| } |
| #endif |
| } |
| |
| if (op == WebGLImageConversion::AlphaDoPremultiply) { |
| for (size_t i = 0; i < bufferSize; i += 4) { |
| pixels[i + 0] = std::min(255, pixels[i + 0] * pixels[i + 3] / 255); |
| pixels[i + 1] = std::min(255, pixels[i + 1] * pixels[i + 3] / 255); |
| pixels[i + 2] = std::min(255, pixels[i + 2] * pixels[i + 3] / 255); |
| } |
| } else if (op != WebGLImageConversion::AlphaDoNothing) { |
| ASSERT_NOT_REACHED(); |
| } |
| } |
| |
| void DrawingBuffer::flipVertically(uint8_t* framebuffer, int width, int height) |
| { |
| m_scanline.resize(width * 4); |
| uint8_t* scanline = &m_scanline[0]; |
| unsigned rowBytes = width * 4; |
| unsigned count = height / 2; |
| for (unsigned i = 0; i < count; i++) { |
| uint8_t* rowA = framebuffer + i * rowBytes; |
| uint8_t* rowB = framebuffer + (height - i - 1) * rowBytes; |
| memcpy(scanline, rowB, rowBytes); |
| memcpy(rowB, rowA, rowBytes); |
| memcpy(rowA, scanline, rowBytes); |
| } |
| } |
| |
| void DrawingBuffer::allocateConditionallyImmutableTexture(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type) |
| { |
| if (m_storageTextureSupported) { |
| GLenum internalStorageFormat = GL_NONE; |
| if (internalformat == GL_RGB) { |
| internalStorageFormat = GL_RGB8; |
| } else if (internalformat == GL_RGBA) { |
| internalStorageFormat = GL_RGBA8; |
| } else { |
| NOTREACHED(); |
| } |
| m_gl->TexStorage2DEXT(GL_TEXTURE_2D, 1, internalStorageFormat, width, height); |
| return; |
| } |
| m_gl->TexImage2D(target, 0, internalformat, width, height, border, format, type, 0); |
| } |
| |
| 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; |
| info->gpuMemoryBufferId = -1; |
| } |
| } |
| |
| 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) |
| { |
| if (!RuntimeEnabledFeatures::webGLImageChromiumEnabled()) |
| return createDefaultTextureAndAllocateMemory(size); |
| |
| TextureParameters parameters = chromiumImageTextureParameters(); |
| GLuint imageId = m_gl->CreateGpuMemoryBufferImageCHROMIUM(size.width(), size.height(), parameters.creationInternalColorFormat, GC3D_SCANOUT_CHROMIUM); |
| GLint gpuMemoryBufferId = -1; |
| GLuint textureId = createColorTexture(parameters); |
| |
| if (imageId) { |
| m_gl->BindTexImage2DCHROMIUM(parameters.target, imageId); |
| m_gl->GetImageivCHROMIUM(imageId, GC3D_GPU_MEMORY_BUFFER_ID, &gpuMemoryBufferId); |
| DCHECK_NE(-1, gpuMemoryBufferId); |
| } |
| |
| TextureInfo info; |
| info.textureId = textureId; |
| info.imageId = imageId; |
| info.gpuMemoryBufferId = gpuMemoryBufferId; |
| info.parameters = parameters; |
| clearChromiumImageAlpha(info); |
| return info; |
| } |
| |
| DrawingBuffer::TextureInfo DrawingBuffer::createDefaultTextureAndAllocateMemory(const IntSize& size) |
| { |
| DrawingBuffer::TextureInfo info; |
| TextureParameters parameters = defaultTextureParameters(); |
| info.parameters = parameters; |
| info.textureId = createColorTexture(parameters); |
| allocateConditionallyImmutableTexture(parameters.target, parameters.creationInternalColorFormat, |
| size.width(), size.height(), 0, parameters.colorFormat, GL_UNSIGNED_BYTE); |
| info.immutable = m_storageTextureSupported; |
| return info; |
| } |
| |
| void DrawingBuffer::resizeTextureMemory(TextureInfo* info, const IntSize& size) |
| { |
| ASSERT(info->textureId); |
| if (!RuntimeEnabledFeatures::webGLImageChromiumEnabled()) { |
| if (info->immutable) { |
| DCHECK(m_storageTextureSupported); |
| m_gl->DeleteTextures(1, &info->textureId); |
| info->textureId = createColorTexture(info->parameters); |
| } |
| m_gl->BindTexture(info->parameters.target, info->textureId); |
| allocateConditionallyImmutableTexture(info->parameters.target, info->parameters.creationInternalColorFormat, |
| size.width(), size.height(), 0, info->parameters.colorFormat, GL_UNSIGNED_BYTE); |
| info->immutable = m_storageTextureSupported; |
| return; |
| } |
| |
| DCHECK(!info->immutable); |
| deleteChromiumImageForTexture(info); |
| 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); |
| |
| GLint gpuMemoryBufferId = -1; |
| m_gl->GetImageivCHROMIUM(info->imageId, GC3D_GPU_MEMORY_BUFFER_ID, &gpuMemoryBufferId); |
| DCHECK_NE(-1, gpuMemoryBufferId); |
| info->gpuMemoryBufferId = gpuMemoryBufferId; |
| |
| clearChromiumImageAlpha(*info); |
| } else { |
| info->gpuMemoryBufferId = -1; |
| |
| // At this point, the texture still exists, but has no allocated |
| // storage. This is intentional, and mimics the behavior of a texImage2D |
| // failure. |
| } |
| } |
| |
| void DrawingBuffer::attachColorBufferToReadFramebuffer() |
| { |
| m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo); |
| |
| GLenum target = m_colorBuffer.parameters.target; |
| GLenum id = m_colorBuffer.textureId; |
| |
| m_gl->BindTexture(target, id); |
| |
| if (m_antiAliasingMode == MSAAImplicitResolve) |
| m_gl->FramebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, id, 0, m_sampleCount); |
| else |
| m_gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, id, 0); |
| |
| restoreTextureBindings(); |
| restoreFramebufferBindings(); |
| } |
| |
| bool DrawingBuffer::wantExplicitResolve() |
| { |
| return m_antiAliasingMode == MSAAExplicitResolve; |
| } |
| |
| bool DrawingBuffer::wantDepthOrStencil() |
| { |
| return m_wantDepth || m_wantStencil; |
| } |
| |
| GLenum DrawingBuffer::getMultisampledRenderbufferFormat() |
| { |
| DCHECK(wantExplicitResolve()); |
| if (m_wantAlphaChannel) |
| return GL_RGBA8_OES; |
| if (RuntimeEnabledFeatures::webGLImageChromiumEnabled() && contextProvider()->getCapabilities().chromium_image_rgb_emulation) |
| return GL_RGBA8_OES; |
| if (contextProvider()->getCapabilities().disable_webgl_rgb_multisampling_usage) |
| return GL_RGBA8_OES; |
| return GL_RGB8_OES; |
| } |
| |
| void DrawingBuffer::restoreTextureBindings() |
| { |
| // This class potentially modifies the bindings for GL_TEXTURE_2D and |
| // GL_TEXTURE_RECTANGLE. Only GL_TEXTURE_2D needs to be restored since |
| // the public interface for WebGL does not support GL_TEXTURE_RECTANGLE. |
| m_gl->BindTexture(GL_TEXTURE_2D, m_texture2DBinding); |
| } |
| |
| } // namespace blink |
