// Copyright 2010 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 "config.h" #if USE(ACCELERATED_COMPOSITING) #include "CCRendererGL.h" #include "CCDamageTracker.h" #include "CCLayerQuad.h" #include "CCMathUtil.h" #include "CCProxy.h" #include "CCRenderPass.h" #include "CCRenderSurfaceFilters.h" #include "CCScopedTexture.h" #include "CCSettings.h" #include "CCSingleThreadProxy.h" #include "CCVideoLayerImpl.h" #include "Extensions3D.h" #include "FloatQuad.h" #include "GeometryBinding.h" #include "GrTexture.h" #include "NotImplemented.h" #include "PlatformColor.h" #include "SkBitmap.h" #include "SkColor.h" #include "ThrottledTextureUploader.h" #include "TraceEvent.h" #include "UnthrottledTextureUploader.h" #include #include #include #include #include #include using namespace std; using WebKit::WebGraphicsContext3D; using WebKit::WebGraphicsMemoryAllocation; using WebKit::WebSharedGraphicsContext3D; using WebKit::WebTransformationMatrix; namespace WebCore { namespace { bool needsIOSurfaceReadbackWorkaround() { #if OS(DARWIN) return true; #else return false; #endif } } // anonymous namespace PassOwnPtr CCRendererGL::create(CCRendererClient* client, CCResourceProvider* resourceProvider, TextureUploaderOption textureUploaderSetting) { OwnPtr renderer(adoptPtr(new CCRendererGL(client, resourceProvider, textureUploaderSetting))); if (!renderer->initialize()) return nullptr; return renderer.release(); } CCRendererGL::CCRendererGL(CCRendererClient* client, CCResourceProvider* resourceProvider, TextureUploaderOption textureUploaderSetting) : CCDirectRenderer(client, resourceProvider) , m_offscreenFramebufferId(0) , m_sharedGeometryQuad(FloatRect(-0.5f, -0.5f, 1.0f, 1.0f)) , m_context(resourceProvider->graphicsContext3D()) , m_isViewportChanged(false) , m_isFramebufferDiscarded(false) , m_isUsingBindUniform(false) , m_visible(true) , m_textureUploaderSetting(textureUploaderSetting) { ASSERT(m_context); } bool CCRendererGL::initialize() { if (!m_context->makeContextCurrent()) return false; m_context->setContextLostCallback(this); m_context->pushGroupMarkerEXT("CompositorContext"); WebKit::WebString extensionsWebString = m_context->getString(GraphicsContext3D::EXTENSIONS); String extensionsString(extensionsWebString.data(), extensionsWebString.length()); Vector extensionsList; extensionsString.split(' ', extensionsList); HashSet extensions; for (size_t i = 0; i < extensionsList.size(); ++i) extensions.add(extensionsList[i]); if (settings().acceleratePainting && extensions.contains("GL_EXT_texture_format_BGRA8888") && extensions.contains("GL_EXT_read_format_bgra")) m_capabilities.usingAcceleratedPainting = true; else m_capabilities.usingAcceleratedPainting = false; m_capabilities.contextHasCachedFrontBuffer = extensions.contains("GL_CHROMIUM_front_buffer_cached"); m_capabilities.usingPartialSwap = CCSettings::partialSwapEnabled() && extensions.contains("GL_CHROMIUM_post_sub_buffer"); // Use the swapBuffers callback only with the threaded proxy. if (CCProxy::hasImplThread()) m_capabilities.usingSwapCompleteCallback = extensions.contains("GL_CHROMIUM_swapbuffers_complete_callback"); if (m_capabilities.usingSwapCompleteCallback) m_context->setSwapBuffersCompleteCallbackCHROMIUM(this); m_capabilities.usingSetVisibility = extensions.contains("GL_CHROMIUM_set_visibility"); if (extensions.contains("GL_CHROMIUM_iosurface")) ASSERT(extensions.contains("GL_ARB_texture_rectangle")); m_capabilities.usingGpuMemoryManager = extensions.contains("GL_CHROMIUM_gpu_memory_manager"); if (m_capabilities.usingGpuMemoryManager) m_context->setMemoryAllocationChangedCallbackCHROMIUM(this); m_capabilities.usingDiscardFramebuffer = extensions.contains("GL_CHROMIUM_discard_framebuffer"); m_capabilities.usingEglImage = extensions.contains("GL_OES_EGL_image_external"); GLC(m_context, m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_capabilities.maxTextureSize)); m_capabilities.bestTextureFormat = PlatformColor::bestTextureFormat(m_context, extensions.contains("GL_EXT_texture_format_BGRA8888")); m_isUsingBindUniform = extensions.contains("GL_CHROMIUM_bind_uniform_location"); if (!initializeSharedObjects()) return false; // Make sure the viewport and context gets initialized, even if it is to zero. viewportChanged(); return true; } CCRendererGL::~CCRendererGL() { ASSERT(CCProxy::isImplThread()); m_context->setSwapBuffersCompleteCallbackCHROMIUM(0); m_context->setMemoryAllocationChangedCallbackCHROMIUM(0); m_context->setContextLostCallback(0); cleanupSharedObjects(); } WebGraphicsContext3D* CCRendererGL::context() { return m_context; } void CCRendererGL::debugGLCall(WebGraphicsContext3D* context, const char* command, const char* file, int line) { unsigned long error = context->getError(); if (error != GraphicsContext3D::NO_ERROR) LOG_ERROR("GL command failed: File: %s\n\tLine %d\n\tcommand: %s, error %x\n", file, line, command, static_cast(error)); } void CCRendererGL::setVisible(bool visible) { if (m_visible == visible) return; m_visible = visible; // TODO: Replace setVisibilityCHROMIUM with an extension to explicitly manage front/backbuffers // crbug.com/116049 if (m_capabilities.usingSetVisibility) m_context->setVisibilityCHROMIUM(visible); } void CCRendererGL::releaseRenderPassTextures() { m_renderPassTextures.clear(); } void CCRendererGL::viewportChanged() { m_isViewportChanged = true; } void CCRendererGL::clearFramebuffer(DrawingFrame& frame) { // On DEBUG builds, opaque render passes are cleared to blue to easily see regions that were not drawn on the screen. if (frame.currentRenderPass->hasTransparentBackground()) GLC(m_context, m_context->clearColor(0, 0, 0, 0)); else GLC(m_context, m_context->clearColor(0, 0, 1, 1)); #if defined(NDEBUG) if (frame.currentRenderPass->hasTransparentBackground()) #endif m_context->clear(GraphicsContext3D::COLOR_BUFFER_BIT); } void CCRendererGL::beginDrawingFrame(DrawingFrame& frame) { // FIXME: Remove this once framebuffer is automatically recreated on first use ensureFramebuffer(); if (viewportSize().isEmpty()) return; TRACE_EVENT0("cc", "CCRendererGL::drawLayers"); if (m_isViewportChanged) { // Only reshape when we know we are going to draw. Otherwise, the reshape // can leave the window at the wrong size if we never draw and the proper // viewport size is never set. m_isViewportChanged = false; m_context->reshape(viewportWidth(), viewportHeight()); } makeContextCurrent(); // Bind the common vertex attributes used for drawing all the layers. m_sharedGeometry->prepareForDraw(); GLC(m_context, m_context->disable(GraphicsContext3D::DEPTH_TEST)); GLC(m_context, m_context->disable(GraphicsContext3D::CULL_FACE)); GLC(m_context, m_context->colorMask(true, true, true, true)); GLC(m_context, m_context->enable(GraphicsContext3D::BLEND)); GLC(m_context, m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA)); } void CCRendererGL::doNoOp() { GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0)); GLC(m_context, m_context->flush()); } void CCRendererGL::drawQuad(DrawingFrame& frame, const CCDrawQuad* quad) { if (quad->needsBlending()) GLC(m_context, m_context->enable(GraphicsContext3D::BLEND)); else GLC(m_context, m_context->disable(GraphicsContext3D::BLEND)); switch (quad->material()) { case CCDrawQuad::Invalid: ASSERT_NOT_REACHED(); break; case CCDrawQuad::Checkerboard: drawCheckerboardQuad(frame, CCCheckerboardDrawQuad::materialCast(quad)); break; case CCDrawQuad::DebugBorder: drawDebugBorderQuad(frame, CCDebugBorderDrawQuad::materialCast(quad)); break; case CCDrawQuad::IOSurfaceContent: drawIOSurfaceQuad(frame, CCIOSurfaceDrawQuad::materialCast(quad)); break; case CCDrawQuad::RenderPass: drawRenderPassQuad(frame, CCRenderPassDrawQuad::materialCast(quad)); break; case CCDrawQuad::SolidColor: drawSolidColorQuad(frame, CCSolidColorDrawQuad::materialCast(quad)); break; case CCDrawQuad::StreamVideoContent: drawStreamVideoQuad(frame, CCStreamVideoDrawQuad::materialCast(quad)); break; case CCDrawQuad::TextureContent: drawTextureQuad(frame, CCTextureDrawQuad::materialCast(quad)); break; case CCDrawQuad::TiledContent: drawTileQuad(frame, CCTileDrawQuad::materialCast(quad)); break; case CCDrawQuad::YUVVideoContent: drawYUVVideoQuad(frame, CCYUVVideoDrawQuad::materialCast(quad)); break; } } void CCRendererGL::drawCheckerboardQuad(const DrawingFrame& frame, const CCCheckerboardDrawQuad* quad) { const TileCheckerboardProgram* program = tileCheckerboardProgram(); ASSERT(program && program->initialized()); GLC(context(), context()->useProgram(program->program())); IntRect tileRect = quad->quadRect(); float texOffsetX = tileRect.x(); float texOffsetY = tileRect.y(); float texScaleX = tileRect.width(); float texScaleY = tileRect.height(); GLC(context(), context()->uniform4f(program->fragmentShader().texTransformLocation(), texOffsetX, texOffsetY, texScaleX, texScaleY)); const int checkerboardWidth = 16; float frequency = 1.0 / checkerboardWidth; GLC(context(), context()->uniform1f(program->fragmentShader().frequencyLocation(), frequency)); setShaderOpacity(quad->opacity(), program->fragmentShader().alphaLocation()); drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), program->vertexShader().matrixLocation()); } void CCRendererGL::drawDebugBorderQuad(const DrawingFrame& frame, const CCDebugBorderDrawQuad* quad) { static float glMatrix[16]; const SolidColorProgram* program = solidColorProgram(); ASSERT(program && program->initialized()); GLC(context(), context()->useProgram(program->program())); // Use the full quadRect for debug quads to not move the edges based on partial swaps. const IntRect& layerRect = quad->quadRect(); WebTransformationMatrix renderMatrix = quad->quadTransform(); renderMatrix.translate(0.5 * layerRect.width() + layerRect.x(), 0.5 * layerRect.height() + layerRect.y()); renderMatrix.scaleNonUniform(layerRect.width(), layerRect.height()); CCRendererGL::toGLMatrix(&glMatrix[0], frame.projectionMatrix * renderMatrix); GLC(context(), context()->uniformMatrix4fv(program->vertexShader().matrixLocation(), 1, false, &glMatrix[0])); SkColor color = quad->color(); float alpha = SkColorGetA(color) / 255.0; GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), (SkColorGetR(color) / 255.0) * alpha, (SkColorGetG(color) / 255.0) * alpha, (SkColorGetB(color) / 255.0) * alpha, alpha)); GLC(context(), context()->lineWidth(quad->width())); // The indices for the line are stored in the same array as the triangle indices. GLC(context(), context()->drawElements(GraphicsContext3D::LINE_LOOP, 4, GraphicsContext3D::UNSIGNED_SHORT, 6 * sizeof(unsigned short))); } static inline SkBitmap applyFilters(CCRendererGL* renderer, const WebKit::WebFilterOperations& filters, CCScopedTexture* sourceTexture) { if (filters.isEmpty()) return SkBitmap(); WebGraphicsContext3D* filterContext = CCProxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadContext() : WebSharedGraphicsContext3D::mainThreadContext(); GrContext* filterGrContext = CCProxy::hasImplThread() ? WebSharedGraphicsContext3D::compositorThreadGrContext() : WebSharedGraphicsContext3D::mainThreadGrContext(); if (!filterContext || !filterGrContext) return SkBitmap(); renderer->context()->flush(); CCResourceProvider::ScopedWriteLockGL lock(renderer->resourceProvider(), sourceTexture->id()); SkBitmap source = CCRenderSurfaceFilters::apply(filters, lock.textureId(), sourceTexture->size(), filterContext, filterGrContext); return source; } PassOwnPtr CCRendererGL::drawBackgroundFilters(DrawingFrame& frame, const CCRenderPassDrawQuad* quad, const WebKit::WebFilterOperations& filters, const WebTransformationMatrix& contentsDeviceTransform) { // This method draws a background filter, which applies a filter to any pixels behind the quad and seen through its background. // The algorithm works as follows: // 1. Compute a bounding box around the pixels that will be visible through the quad. // 2. Read the pixels in the bounding box into a buffer R. // 3. Apply the background filter to R, so that it is applied in the pixels' coordinate space. // 4. Apply the quad's inverse transform to map the pixels in R into the quad's content space. This implicitly // clips R by the content bounds of the quad since the destination texture has bounds matching the quad's content. // 5. Draw the background texture for the contents using the same transform as used to draw the contents itself. This is done // without blending to replace the current background pixels with the new filtered background. // 6. Draw the contents of the quad over drop of the new background with blending, as per usual. The filtered background // pixels will show through any non-opaque pixels in this draws. // // Pixel copies in this algorithm occur at steps 2, 3, 4, and 5. // FIXME: When this algorithm changes, update CCLayerTreeHost::prioritizeTextures() accordingly. if (filters.isEmpty()) return nullptr; // FIXME: We only allow background filters on an opaque render surface because other surfaces may contain // translucent pixels, and the contents behind those translucent pixels wouldn't have the filter applied. if (frame.currentRenderPass->hasTransparentBackground()) return nullptr; ASSERT(!frame.currentTexture); // FIXME: Do a single readback for both the surface and replica and cache the filtered results (once filter textures are not reused). IntRect deviceRect = enclosingIntRect(CCMathUtil::mapClippedRect(contentsDeviceTransform, sharedGeometryQuad().boundingBox())); int top, right, bottom, left; filters.getOutsets(top, right, bottom, left); deviceRect.move(-left, -top); deviceRect.expand(left + right, top + bottom); deviceRect.intersect(frame.currentRenderPass->outputRect()); OwnPtr deviceBackgroundTexture = CCScopedTexture::create(m_resourceProvider); if (!getFramebufferTexture(deviceBackgroundTexture.get(), deviceRect)) return nullptr; SkBitmap filteredDeviceBackground = applyFilters(this, filters, deviceBackgroundTexture.get()); if (!filteredDeviceBackground.getTexture()) return nullptr; GrTexture* texture = reinterpret_cast(filteredDeviceBackground.getTexture()); int filteredDeviceBackgroundTextureId = texture->getTextureHandle(); OwnPtr backgroundTexture = CCScopedTexture::create(m_resourceProvider); if (!backgroundTexture->allocate(CCRenderer::ImplPool, quad->quadRect().size(), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageFramebuffer)) return nullptr; const CCRenderPass* targetRenderPass = frame.currentRenderPass; bool usingBackgroundTexture = useScopedTexture(frame, backgroundTexture.get(), quad->quadRect()); if (usingBackgroundTexture) { // Copy the readback pixels from device to the background texture for the surface. WebTransformationMatrix deviceToFramebufferTransform; deviceToFramebufferTransform.translate(quad->quadRect().width() / 2.0, quad->quadRect().height() / 2.0); deviceToFramebufferTransform.scale3d(quad->quadRect().width(), quad->quadRect().height(), 1); deviceToFramebufferTransform.multiply(contentsDeviceTransform.inverse()); copyTextureToFramebuffer(frame, filteredDeviceBackgroundTextureId, deviceRect, deviceToFramebufferTransform); } useRenderPass(frame, targetRenderPass); if (!usingBackgroundTexture) return nullptr; return backgroundTexture.release(); } void CCRendererGL::drawRenderPassQuad(DrawingFrame& frame, const CCRenderPassDrawQuad* quad) { CachedTexture* contentsTexture = m_renderPassTextures.get(quad->renderPassId()); if (!contentsTexture || !contentsTexture->id()) return; const CCRenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId()); ASSERT(renderPass); if (!renderPass) return; WebTransformationMatrix renderMatrix = quad->quadTransform(); renderMatrix.translate(0.5 * quad->quadRect().width() + quad->quadRect().x(), 0.5 * quad->quadRect().height() + quad->quadRect().y()); WebTransformationMatrix deviceMatrix = renderMatrix; deviceMatrix.scaleNonUniform(quad->quadRect().width(), quad->quadRect().height()); WebTransformationMatrix contentsDeviceTransform = WebTransformationMatrix(frame.windowMatrix * frame.projectionMatrix * deviceMatrix).to2dTransform(); // Can only draw surface if device matrix is invertible. if (!contentsDeviceTransform.isInvertible()) return; OwnPtr backgroundTexture = drawBackgroundFilters(frame, quad, renderPass->backgroundFilters(), contentsDeviceTransform); // FIXME: Cache this value so that we don't have to do it for both the surface and its replica. // Apply filters to the contents texture. SkBitmap filterBitmap = applyFilters(this, renderPass->filters(), contentsTexture); OwnPtr contentsResourceLock; unsigned contentsTextureId = 0; if (filterBitmap.getTexture()) { GrTexture* texture = reinterpret_cast(filterBitmap.getTexture()); contentsTextureId = texture->getTextureHandle(); } else { contentsResourceLock = adoptPtr(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, contentsTexture->id())); contentsTextureId = contentsResourceLock->textureId(); } // Draw the background texture if there is one. if (backgroundTexture) { ASSERT(backgroundTexture->size() == quad->quadRect().size()); CCResourceProvider::ScopedReadLockGL lock(m_resourceProvider, backgroundTexture->id()); copyTextureToFramebuffer(frame, lock.textureId(), quad->quadRect(), quad->quadTransform()); } bool clipped = false; FloatQuad deviceQuad = CCMathUtil::mapQuad(contentsDeviceTransform, sharedGeometryQuad(), clipped); ASSERT(!clipped); CCLayerQuad deviceLayerBounds = CCLayerQuad(FloatQuad(deviceQuad.boundingBox())); CCLayerQuad deviceLayerEdges = CCLayerQuad(deviceQuad); // Use anti-aliasing programs only when necessary. bool useAA = (!deviceQuad.isRectilinear() || !deviceQuad.boundingBox().isExpressibleAsIntRect()); if (useAA) { deviceLayerBounds.inflateAntiAliasingDistance(); deviceLayerEdges.inflateAntiAliasingDistance(); } OwnPtr maskResourceLock; unsigned maskTextureId = 0; if (quad->maskResourceId()) { maskResourceLock = adoptPtr(new CCResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->maskResourceId())); maskTextureId = maskResourceLock->textureId(); } // FIXME: use the backgroundTexture and blend the background in with this draw instead of having a separate copy of the background texture. GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0)); context()->bindTexture(GraphicsContext3D::TEXTURE_2D, contentsTextureId); int shaderQuadLocation = -1; int shaderEdgeLocation = -1; int shaderMaskSamplerLocation = -1; int shaderMaskTexCoordScaleLocation = -1; int shaderMaskTexCoordOffsetLocation = -1; int shaderMatrixLocation = -1; int shaderAlphaLocation = -1; if (useAA && maskTextureId) { const RenderPassMaskProgramAA* program = renderPassMaskProgramAA(); GLC(context(), context()->useProgram(program->program())); GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0)); shaderQuadLocation = program->vertexShader().pointLocation(); shaderEdgeLocation = program->fragmentShader().edgeLocation(); shaderMaskSamplerLocation = program->fragmentShader().maskSamplerLocation(); shaderMaskTexCoordScaleLocation = program->fragmentShader().maskTexCoordScaleLocation(); shaderMaskTexCoordOffsetLocation = program->fragmentShader().maskTexCoordOffsetLocation(); shaderMatrixLocation = program->vertexShader().matrixLocation(); shaderAlphaLocation = program->fragmentShader().alphaLocation(); } else if (!useAA && maskTextureId) { const RenderPassMaskProgram* program = renderPassMaskProgram(); GLC(context(), context()->useProgram(program->program())); GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0)); shaderMaskSamplerLocation = program->fragmentShader().maskSamplerLocation(); shaderMaskTexCoordScaleLocation = program->fragmentShader().maskTexCoordScaleLocation(); shaderMaskTexCoordOffsetLocation = program->fragmentShader().maskTexCoordOffsetLocation(); shaderMatrixLocation = program->vertexShader().matrixLocation(); shaderAlphaLocation = program->fragmentShader().alphaLocation(); } else if (useAA && !maskTextureId) { const RenderPassProgramAA* program = renderPassProgramAA(); GLC(context(), context()->useProgram(program->program())); GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0)); shaderQuadLocation = program->vertexShader().pointLocation(); shaderEdgeLocation = program->fragmentShader().edgeLocation(); shaderMatrixLocation = program->vertexShader().matrixLocation(); shaderAlphaLocation = program->fragmentShader().alphaLocation(); } else { const RenderPassProgram* program = renderPassProgram(); GLC(context(), context()->useProgram(program->program())); GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0)); shaderMatrixLocation = program->vertexShader().matrixLocation(); shaderAlphaLocation = program->fragmentShader().alphaLocation(); } if (shaderMaskSamplerLocation != -1) { ASSERT(shaderMaskTexCoordScaleLocation != 1); ASSERT(shaderMaskTexCoordOffsetLocation != 1); GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE1)); GLC(context(), context()->uniform1i(shaderMaskSamplerLocation, 1)); GLC(context(), context()->uniform2f(shaderMaskTexCoordScaleLocation, quad->maskTexCoordScaleX(), quad->maskTexCoordScaleY())); GLC(context(), context()->uniform2f(shaderMaskTexCoordOffsetLocation, quad->maskTexCoordOffsetX(), quad->maskTexCoordOffsetY())); context()->bindTexture(GraphicsContext3D::TEXTURE_2D, maskTextureId); GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0)); } if (shaderEdgeLocation != -1) { float edge[24]; deviceLayerEdges.toFloatArray(edge); deviceLayerBounds.toFloatArray(&edge[12]); GLC(context(), context()->uniform3fv(shaderEdgeLocation, 8, edge)); } // Map device space quad to surface space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project. FloatQuad surfaceQuad = CCMathUtil::mapQuad(contentsDeviceTransform.inverse(), deviceLayerEdges.floatQuad(), clipped); ASSERT(!clipped); setShaderOpacity(quad->opacity(), shaderAlphaLocation); setShaderFloatQuad(surfaceQuad, shaderQuadLocation); drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), shaderMatrixLocation); } void CCRendererGL::drawSolidColorQuad(const DrawingFrame& frame, const CCSolidColorDrawQuad* quad) { const SolidColorProgram* program = solidColorProgram(); GLC(context(), context()->useProgram(program->program())); SkColor color = quad->color(); float opacity = quad->opacity(); float alpha = (SkColorGetA(color) / 255.0) * opacity; GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), (SkColorGetR(color) / 255.0) * alpha, (SkColorGetG(color) / 255.0) * alpha, (SkColorGetB(color) / 255.0) * alpha, alpha)); drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), program->vertexShader().matrixLocation()); } struct TileProgramUniforms { unsigned program; unsigned samplerLocation; unsigned vertexTexTransformLocation; unsigned fragmentTexTransformLocation; unsigned edgeLocation; unsigned matrixLocation; unsigned alphaLocation; unsigned pointLocation; }; template static void tileUniformLocation(T program, TileProgramUniforms& uniforms) { uniforms.program = program->program(); uniforms.vertexTexTransformLocation = program->vertexShader().vertexTexTransformLocation(); uniforms.matrixLocation = program->vertexShader().matrixLocation(); uniforms.pointLocation = program->vertexShader().pointLocation(); uniforms.samplerLocation = program->fragmentShader().samplerLocation(); uniforms.alphaLocation = program->fragmentShader().alphaLocation(); uniforms.fragmentTexTransformLocation = program->fragmentShader().fragmentTexTransformLocation(); uniforms.edgeLocation = program->fragmentShader().edgeLocation(); } void CCRendererGL::drawTileQuad(const DrawingFrame& frame, const CCTileDrawQuad* quad) { IntRect tileRect = quad->quadVisibleRect(); FloatRect clampRect(tileRect); // Clamp texture coordinates to avoid sampling outside the layer // by deflating the tile region half a texel or half a texel // minus epsilon for one pixel layers. The resulting clamp region // is mapped to the unit square by the vertex shader and mapped // back to normalized texture coordinates by the fragment shader // after being clamped to 0-1 range. const float epsilon = 1 / 1024.0f; float clampX = min(0.5, clampRect.width() / 2.0 - epsilon); float clampY = min(0.5, clampRect.height() / 2.0 - epsilon); clampRect.inflateX(-clampX); clampRect.inflateY(-clampY); FloatSize clampOffset = clampRect.minXMinYCorner() - FloatRect(tileRect).minXMinYCorner(); FloatPoint textureOffset = quad->textureOffset() + clampOffset + IntPoint(tileRect.location() - quad->quadRect().location()); // Map clamping rectangle to unit square. float vertexTexTranslateX = -clampRect.x() / clampRect.width(); float vertexTexTranslateY = -clampRect.y() / clampRect.height(); float vertexTexScaleX = tileRect.width() / clampRect.width(); float vertexTexScaleY = tileRect.height() / clampRect.height(); // Map to normalized texture coordinates. const IntSize& textureSize = quad->textureSize(); float fragmentTexTranslateX = textureOffset.x() / textureSize.width(); float fragmentTexTranslateY = textureOffset.y() / textureSize.height(); float fragmentTexScaleX = clampRect.width() / textureSize.width(); float fragmentTexScaleY = clampRect.height() / textureSize.height(); FloatQuad localQuad; WebTransformationMatrix deviceTransform = WebTransformationMatrix(frame.windowMatrix * frame.projectionMatrix * quad->quadTransform()).to2dTransform(); if (!deviceTransform.isInvertible()) return; bool clipped = false; FloatQuad deviceLayerQuad = CCMathUtil::mapQuad(deviceTransform, FloatQuad(quad->visibleContentRect()), clipped); ASSERT(!clipped); TileProgramUniforms uniforms; // For now, we simply skip anti-aliasing with the quad is clipped. This only happens // on perspective transformed layers that go partially behind the camera. if (quad->isAntialiased() && !clipped) { if (quad->swizzleContents()) tileUniformLocation(tileProgramSwizzleAA(), uniforms); else tileUniformLocation(tileProgramAA(), uniforms); } else { if (quad->needsBlending()) { if (quad->swizzleContents()) tileUniformLocation(tileProgramSwizzle(), uniforms); else tileUniformLocation(tileProgram(), uniforms); } else { if (quad->swizzleContents()) tileUniformLocation(tileProgramSwizzleOpaque(), uniforms); else tileUniformLocation(tileProgramOpaque(), uniforms); } } GLC(context(), context()->useProgram(uniforms.program)); GLC(context(), context()->uniform1i(uniforms.samplerLocation, 0)); GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0)); CCResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId()); GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, quadResourceLock.textureId())); GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, quad->textureFilter())); GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, quad->textureFilter())); bool useAA = !clipped && quad->isAntialiased(); if (useAA) { CCLayerQuad deviceLayerBounds = CCLayerQuad(FloatQuad(deviceLayerQuad.boundingBox())); deviceLayerBounds.inflateAntiAliasingDistance(); CCLayerQuad deviceLayerEdges = CCLayerQuad(deviceLayerQuad); deviceLayerEdges.inflateAntiAliasingDistance(); float edge[24]; deviceLayerEdges.toFloatArray(edge); deviceLayerBounds.toFloatArray(&edge[12]); GLC(context(), context()->uniform3fv(uniforms.edgeLocation, 8, edge)); GLC(context(), context()->uniform4f(uniforms.vertexTexTransformLocation, vertexTexTranslateX, vertexTexTranslateY, vertexTexScaleX, vertexTexScaleY)); GLC(context(), context()->uniform4f(uniforms.fragmentTexTransformLocation, fragmentTexTranslateX, fragmentTexTranslateY, fragmentTexScaleX, fragmentTexScaleY)); FloatPoint bottomRight(tileRect.maxX(), tileRect.maxY()); FloatPoint bottomLeft(tileRect.x(), tileRect.maxY()); FloatPoint topLeft(tileRect.x(), tileRect.y()); FloatPoint topRight(tileRect.maxX(), tileRect.y()); // Map points to device space. bottomRight = CCMathUtil::mapPoint(deviceTransform, bottomRight, clipped); ASSERT(!clipped); bottomLeft = CCMathUtil::mapPoint(deviceTransform, bottomLeft, clipped); ASSERT(!clipped); topLeft = CCMathUtil::mapPoint(deviceTransform, topLeft, clipped); ASSERT(!clipped); topRight = CCMathUtil::mapPoint(deviceTransform, topRight, clipped); ASSERT(!clipped); CCLayerQuad::Edge bottomEdge(bottomRight, bottomLeft); CCLayerQuad::Edge leftEdge(bottomLeft, topLeft); CCLayerQuad::Edge topEdge(topLeft, topRight); CCLayerQuad::Edge rightEdge(topRight, bottomRight); // Only apply anti-aliasing to edges not clipped by culling or scissoring. if (quad->topEdgeAA() && tileRect.y() == quad->quadRect().y()) topEdge = deviceLayerEdges.top(); if (quad->leftEdgeAA() && tileRect.x() == quad->quadRect().x()) leftEdge = deviceLayerEdges.left(); if (quad->rightEdgeAA() && tileRect.maxX() == quad->quadRect().maxX()) rightEdge = deviceLayerEdges.right(); if (quad->bottomEdgeAA() && tileRect.maxY() == quad->quadRect().maxY()) bottomEdge = deviceLayerEdges.bottom(); float sign = FloatQuad(tileRect).isCounterclockwise() ? -1 : 1; bottomEdge.scale(sign); leftEdge.scale(sign); topEdge.scale(sign); rightEdge.scale(sign); // Create device space quad. CCLayerQuad deviceQuad(leftEdge, topEdge, rightEdge, bottomEdge); // Map device space quad to local space. contentsDeviceTransform has no 3d component since it was generated with to2dTransform() so we don't need to project. WebTransformationMatrix inverseDeviceTransform = deviceTransform.inverse(); localQuad = CCMathUtil::mapQuad(inverseDeviceTransform, deviceQuad.floatQuad(), clipped); // We should not ASSERT(!clipped) here, because anti-aliasing inflation may cause deviceQuad to become // clipped. To our knowledge this scenario does not need to be handled differently than the unclipped case. } else { // Move fragment shader transform to vertex shader. We can do this while // still producing correct results as fragmentTexTransformLocation // should always be non-negative when tiles are transformed in a way // that could result in sampling outside the layer. vertexTexScaleX *= fragmentTexScaleX; vertexTexScaleY *= fragmentTexScaleY; vertexTexTranslateX *= fragmentTexScaleX; vertexTexTranslateY *= fragmentTexScaleY; vertexTexTranslateX += fragmentTexTranslateX; vertexTexTranslateY += fragmentTexTranslateY; GLC(context(), context()->uniform4f(uniforms.vertexTexTransformLocation, vertexTexTranslateX, vertexTexTranslateY, vertexTexScaleX, vertexTexScaleY)); localQuad = FloatRect(tileRect); } // Normalize to tileRect. localQuad.scale(1.0f / tileRect.width(), 1.0f / tileRect.height()); setShaderOpacity(quad->opacity(), uniforms.alphaLocation); setShaderFloatQuad(localQuad, uniforms.pointLocation); // The tile quad shader behaves differently compared to all other shaders. // The transform and vertex data are used to figure out the extents that the // un-antialiased quad should have and which vertex this is and the float // quad passed in via uniform is the actual geometry that gets used to draw // it. This is why this centered rect is used and not the original quadRect. FloatRect centeredRect(FloatPoint(-0.5 * tileRect.width(), -0.5 * tileRect.height()), tileRect.size()); drawQuadGeometry(frame, quad->quadTransform(), centeredRect, uniforms.matrixLocation); } void CCRendererGL::drawYUVVideoQuad(const DrawingFrame& frame, const CCYUVVideoDrawQuad* quad) { const VideoYUVProgram* program = videoYUVProgram(); ASSERT(program && program->initialized()); const CCVideoLayerImpl::FramePlane& yPlane = quad->yPlane(); const CCVideoLayerImpl::FramePlane& uPlane = quad->uPlane(); const CCVideoLayerImpl::FramePlane& vPlane = quad->vPlane(); CCResourceProvider::ScopedReadLockGL yPlaneLock(m_resourceProvider, yPlane.resourceId); CCResourceProvider::ScopedReadLockGL uPlaneLock(m_resourceProvider, uPlane.resourceId); CCResourceProvider::ScopedReadLockGL vPlaneLock(m_resourceProvider, vPlane.resourceId); GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE1)); GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, yPlaneLock.textureId())); GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE2)); GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, uPlaneLock.textureId())); GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE3)); GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, vPlaneLock.textureId())); GLC(context(), context()->useProgram(program->program())); float yWidthScaleFactor = static_cast(yPlane.visibleSize.width()) / yPlane.size.width(); // Arbitrarily take the u sizes because u and v dimensions are identical. float uvWidthScaleFactor = static_cast(uPlane.visibleSize.width()) / uPlane.size.width(); GLC(context(), context()->uniform1f(program->vertexShader().yWidthScaleFactorLocation(), yWidthScaleFactor)); GLC(context(), context()->uniform1f(program->vertexShader().uvWidthScaleFactorLocation(), uvWidthScaleFactor)); GLC(context(), context()->uniform1i(program->fragmentShader().yTextureLocation(), 1)); GLC(context(), context()->uniform1i(program->fragmentShader().uTextureLocation(), 2)); GLC(context(), context()->uniform1i(program->fragmentShader().vTextureLocation(), 3)); // These values are magic numbers that are used in the transformation from YUV to RGB color values. // They are taken from the following webpage: http://www.fourcc.org/fccyvrgb.php float yuv2RGB[9] = { 1.164f, 1.164f, 1.164f, 0.f, -.391f, 2.018f, 1.596f, -.813f, 0.f, }; GLC(context(), context()->uniformMatrix3fv(program->fragmentShader().ccMatrixLocation(), 1, 0, yuv2RGB)); // These values map to 16, 128, and 128 respectively, and are computed // as a fraction over 256 (e.g. 16 / 256 = 0.0625). // They are used in the YUV to RGBA conversion formula: // Y - 16 : Gives 16 values of head and footroom for overshooting // U - 128 : Turns unsigned U into signed U [-128,127] // V - 128 : Turns unsigned V into signed V [-128,127] float yuvAdjust[3] = { -0.0625f, -0.5f, -0.5f, }; GLC(context(), context()->uniform3fv(program->fragmentShader().yuvAdjLocation(), 1, yuvAdjust)); setShaderOpacity(quad->opacity(), program->fragmentShader().alphaLocation()); drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), program->vertexShader().matrixLocation()); // Reset active texture back to texture 0. GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0)); } void CCRendererGL::drawStreamVideoQuad(const DrawingFrame& frame, const CCStreamVideoDrawQuad* quad) { static float glMatrix[16]; ASSERT(m_capabilities.usingEglImage); const VideoStreamTextureProgram* program = videoStreamTextureProgram(); GLC(context(), context()->useProgram(program->program())); toGLMatrix(&glMatrix[0], quad->matrix()); GLC(context(), context()->uniformMatrix4fv(program->vertexShader().texMatrixLocation(), 1, false, glMatrix)); GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0)); GLC(context(), context()->bindTexture(Extensions3DChromium::GL_TEXTURE_EXTERNAL_OES, quad->textureId())); GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0)); setShaderOpacity(quad->opacity(), program->fragmentShader().alphaLocation()); drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), program->vertexShader().matrixLocation()); } struct TextureProgramBinding { template void set(Program* program) { ASSERT(program && program->initialized()); programId = program->program(); samplerLocation = program->fragmentShader().samplerLocation(); matrixLocation = program->vertexShader().matrixLocation(); alphaLocation = program->fragmentShader().alphaLocation(); } int programId; int samplerLocation; int matrixLocation; int alphaLocation; }; struct TexTransformTextureProgramBinding : TextureProgramBinding { template void set(Program* program) { TextureProgramBinding::set(program); texTransformLocation = program->vertexShader().texTransformLocation(); } int texTransformLocation; }; void CCRendererGL::drawTextureQuad(const DrawingFrame& frame, const CCTextureDrawQuad* quad) { ASSERT(CCProxy::isImplThread()); TexTransformTextureProgramBinding binding; if (quad->flipped()) binding.set(textureProgramFlip()); else binding.set(textureProgram()); GLC(context(), context()->useProgram(binding.programId)); GLC(context(), context()->uniform1i(binding.samplerLocation, 0)); const FloatRect& uvRect = quad->uvRect(); GLC(context(), context()->uniform4f(binding.texTransformLocation, uvRect.x(), uvRect.y(), uvRect.width(), uvRect.height())); GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0)); CCResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId()); GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, quadResourceLock.textureId())); // FIXME: setting the texture parameters every time is redundant. Move this code somewhere // where it will only happen once per texture. GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR)); GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR)); GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE)); GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE)); if (!quad->premultipliedAlpha()) { // As it turns out, the premultiplied alpha blending function (ONE, ONE_MINUS_SRC_ALPHA) // will never cause the alpha channel to be set to anything less than 1.0 if it is // initialized to that value! Therefore, premultipliedAlpha being false is the first // situation we can generally see an alpha channel less than 1.0 coming out of the // compositor. This is causing platform differences in some layout tests (see // https://bugs.webkit.org/show_bug.cgi?id=82412), so in this situation, use a separate // blend function for the alpha channel to avoid modifying it. Don't use colorMask for this // as it has performance implications on some platforms. GLC(context(), context()->blendFuncSeparate(GraphicsContext3D::SRC_ALPHA, GraphicsContext3D::ONE_MINUS_SRC_ALPHA, GraphicsContext3D::ZERO, GraphicsContext3D::ONE)); } setShaderOpacity(quad->opacity(), binding.alphaLocation); drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), binding.matrixLocation); if (!quad->premultipliedAlpha()) GLC(m_context, m_context->blendFunc(GraphicsContext3D::ONE, GraphicsContext3D::ONE_MINUS_SRC_ALPHA)); } void CCRendererGL::drawIOSurfaceQuad(const DrawingFrame& frame, const CCIOSurfaceDrawQuad* quad) { ASSERT(CCProxy::isImplThread()); TexTransformTextureProgramBinding binding; binding.set(textureIOSurfaceProgram()); GLC(context(), context()->useProgram(binding.programId)); GLC(context(), context()->uniform1i(binding.samplerLocation, 0)); if (quad->orientation() == CCIOSurfaceDrawQuad::Flipped) GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->ioSurfaceSize().height(), quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height() * -1.0)); else GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height())); GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0)); GLC(context(), context()->bindTexture(Extensions3D::TEXTURE_RECTANGLE_ARB, quad->ioSurfaceTextureId())); setShaderOpacity(quad->opacity(), binding.alphaLocation); drawQuadGeometry(frame, quad->quadTransform(), quad->quadRect(), binding.matrixLocation); GLC(context(), context()->bindTexture(Extensions3D::TEXTURE_RECTANGLE_ARB, 0)); } void CCRendererGL::finishDrawingFrame(DrawingFrame& frame) { m_currentFramebufferLock.clear(); m_swapBufferRect.unite(enclosingIntRect(frame.rootDamageRect)); GLC(m_context, m_context->disable(GraphicsContext3D::SCISSOR_TEST)); GLC(m_context, m_context->disable(GraphicsContext3D::BLEND)); } void CCRendererGL::toGLMatrix(float* flattened, const WebTransformationMatrix& m) { flattened[0] = m.m11(); flattened[1] = m.m12(); flattened[2] = m.m13(); flattened[3] = m.m14(); flattened[4] = m.m21(); flattened[5] = m.m22(); flattened[6] = m.m23(); flattened[7] = m.m24(); flattened[8] = m.m31(); flattened[9] = m.m32(); flattened[10] = m.m33(); flattened[11] = m.m34(); flattened[12] = m.m41(); flattened[13] = m.m42(); flattened[14] = m.m43(); flattened[15] = m.m44(); } void CCRendererGL::setShaderFloatQuad(const FloatQuad& quad, int quadLocation) { if (quadLocation == -1) return; float point[8]; point[0] = quad.p1().x(); point[1] = quad.p1().y(); point[2] = quad.p2().x(); point[3] = quad.p2().y(); point[4] = quad.p3().x(); point[5] = quad.p3().y(); point[6] = quad.p4().x(); point[7] = quad.p4().y(); GLC(m_context, m_context->uniform2fv(quadLocation, 4, point)); } void CCRendererGL::setShaderOpacity(float opacity, int alphaLocation) { if (alphaLocation != -1) GLC(m_context, m_context->uniform1f(alphaLocation, opacity)); } void CCRendererGL::drawQuadGeometry(const DrawingFrame& frame, const WebKit::WebTransformationMatrix& drawTransform, const FloatRect& quadRect, int matrixLocation) { WebTransformationMatrix quadRectMatrix; quadRectTransform(&quadRectMatrix, drawTransform, quadRect); static float glMatrix[16]; toGLMatrix(&glMatrix[0], frame.projectionMatrix * quadRectMatrix); GLC(m_context, m_context->uniformMatrix4fv(matrixLocation, 1, false, &glMatrix[0])); GLC(m_context, m_context->drawElements(GraphicsContext3D::TRIANGLES, 6, GraphicsContext3D::UNSIGNED_SHORT, 0)); } void CCRendererGL::copyTextureToFramebuffer(const DrawingFrame& frame, int textureId, const IntRect& rect, const WebTransformationMatrix& drawMatrix) { const RenderPassProgram* program = renderPassProgram(); GLC(context(), context()->activeTexture(GraphicsContext3D::TEXTURE0)); GLC(context(), context()->bindTexture(GraphicsContext3D::TEXTURE_2D, textureId)); GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR)); GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR)); GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE)); GLC(context(), context()->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE)); GLC(context(), context()->useProgram(program->program())); GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0)); setShaderOpacity(1, program->fragmentShader().alphaLocation()); drawQuadGeometry(frame, drawMatrix, rect, program->vertexShader().matrixLocation()); } void CCRendererGL::finish() { TRACE_EVENT0("cc", "CCRendererGL::finish"); m_context->finish(); } bool CCRendererGL::swapBuffers() { ASSERT(m_visible); ASSERT(!m_isFramebufferDiscarded); TRACE_EVENT0("cc", "CCRendererGL::swapBuffers"); // We're done! Time to swapbuffers! if (m_capabilities.usingPartialSwap) { // If supported, we can save significant bandwidth by only swapping the damaged/scissored region (clamped to the viewport) m_swapBufferRect.intersect(IntRect(IntPoint(), viewportSize())); int flippedYPosOfRectBottom = viewportHeight() - m_swapBufferRect.y() - m_swapBufferRect.height(); m_context->postSubBufferCHROMIUM(m_swapBufferRect.x(), flippedYPosOfRectBottom, m_swapBufferRect.width(), m_swapBufferRect.height()); } else { // Note that currently this has the same effect as swapBuffers; we should // consider exposing a different entry point on WebGraphicsContext3D. m_context->prepareTexture(); } m_swapBufferRect = IntRect(); return true; } void CCRendererGL::onSwapBuffersComplete() { m_client->onSwapBuffersComplete(); } void CCRendererGL::onMemoryAllocationChanged(WebGraphicsMemoryAllocation allocation) { // FIXME: This is called on the main thread in single threaded mode, but we expect it on the impl thread. if (!CCProxy::hasImplThread()) { ASSERT(CCProxy::isMainThread()); DebugScopedSetImplThread impl; onMemoryAllocationChangedOnImplThread(allocation); } else { ASSERT(CCProxy::isImplThread()); onMemoryAllocationChangedOnImplThread(allocation); } } void CCRendererGL::onMemoryAllocationChangedOnImplThread(WebKit::WebGraphicsMemoryAllocation allocation) { if (m_visible && !allocation.gpuResourceSizeInBytes) return; if (!allocation.suggestHaveBackbuffer && !m_visible) discardFramebuffer(); if (!allocation.gpuResourceSizeInBytes) { releaseRenderPassTextures(); m_client->releaseContentsTextures(); GLC(m_context, m_context->flush()); } else m_client->setMemoryAllocationLimitBytes(allocation.gpuResourceSizeInBytes); } void CCRendererGL::discardFramebuffer() { if (m_isFramebufferDiscarded) return; if (!m_capabilities.usingDiscardFramebuffer) return; // FIXME: Update attachments argument to appropriate values once they are no longer ignored. m_context->discardFramebufferEXT(GraphicsContext3D::TEXTURE_2D, 0, 0); m_isFramebufferDiscarded = true; // Damage tracker needs a full reset every time framebuffer is discarded. m_client->setFullRootLayerDamage(); } void CCRendererGL::ensureFramebuffer() { if (!m_isFramebufferDiscarded) return; if (!m_capabilities.usingDiscardFramebuffer) return; m_context->ensureFramebufferCHROMIUM(); m_isFramebufferDiscarded = false; } void CCRendererGL::onContextLost() { m_client->didLoseContext(); } void CCRendererGL::getFramebufferPixels(void *pixels, const IntRect& rect) { ASSERT(rect.maxX() <= viewportWidth() && rect.maxY() <= viewportHeight()); if (!pixels) return; makeContextCurrent(); bool doWorkaround = needsIOSurfaceReadbackWorkaround(); Platform3DObject temporaryTexture = 0; Platform3DObject temporaryFBO = 0; if (doWorkaround) { // On Mac OS X, calling glReadPixels against an FBO whose color attachment is an // IOSurface-backed texture causes corruption of future glReadPixels calls, even those on // different OpenGL contexts. It is believed that this is the root cause of top crasher // http://crbug.com/99393. temporaryTexture = m_context->createTexture(); GLC(m_context, m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, temporaryTexture)); GLC(m_context, m_context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::LINEAR)); GLC(m_context, m_context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_MAG_FILTER, GraphicsContext3D::LINEAR)); GLC(m_context, m_context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_S, GraphicsContext3D::CLAMP_TO_EDGE)); GLC(m_context, m_context->texParameteri(GraphicsContext3D::TEXTURE_2D, GraphicsContext3D::TEXTURE_WRAP_T, GraphicsContext3D::CLAMP_TO_EDGE)); // Copy the contents of the current (IOSurface-backed) framebuffer into a temporary texture. GLC(m_context, m_context->copyTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, GraphicsContext3D::RGBA, 0, 0, rect.maxX(), rect.maxY(), 0)); temporaryFBO = m_context->createFramebuffer(); // Attach this texture to an FBO, and perform the readback from that FBO. GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, temporaryFBO)); GLC(m_context, m_context->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, temporaryTexture, 0)); ASSERT(m_context->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) == GraphicsContext3D::FRAMEBUFFER_COMPLETE); } GLC(m_context, m_context->readPixels(rect.x(), rect.y(), rect.width(), rect.height(), GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, pixels)); if (doWorkaround) { // Clean up. GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0)); GLC(m_context, m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, 0)); GLC(m_context, m_context->deleteFramebuffer(temporaryFBO)); GLC(m_context, m_context->deleteTexture(temporaryTexture)); } if (!m_visible) { TRACE_EVENT0("cc", "CCRendererGL::getFramebufferPixels dropping resources after readback"); discardFramebuffer(); releaseRenderPassTextures(); m_client->releaseContentsTextures(); GLC(m_context, m_context->flush()); } } bool CCRendererGL::getFramebufferTexture(CCScopedTexture* texture, const IntRect& deviceRect) { ASSERT(!texture->id() || (texture->size() == deviceRect.size() && texture->format() == GraphicsContext3D::RGB)); if (!texture->id() && !texture->allocate(CCRenderer::ImplPool, deviceRect.size(), GraphicsContext3D::RGB, CCResourceProvider::TextureUsageAny)) return false; CCResourceProvider::ScopedWriteLockGL lock(m_resourceProvider, texture->id()); GLC(m_context, m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, lock.textureId())); GLC(m_context, m_context->copyTexImage2D(GraphicsContext3D::TEXTURE_2D, 0, texture->format(), deviceRect.x(), deviceRect.y(), deviceRect.width(), deviceRect.height(), 0)); return true; } bool CCRendererGL::useScopedTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& viewportRect) { ASSERT(texture->id()); frame.currentRenderPass = 0; frame.currentTexture = texture; return bindFramebufferToTexture(frame, texture, viewportRect); } void CCRendererGL::bindFramebufferToOutputSurface(DrawingFrame& frame) { m_currentFramebufferLock.clear(); GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0)); } bool CCRendererGL::bindFramebufferToTexture(DrawingFrame& frame, const CCScopedTexture* texture, const IntRect& framebufferRect) { ASSERT(texture->id()); GLC(m_context, m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_offscreenFramebufferId)); m_currentFramebufferLock = adoptPtr(new CCResourceProvider::ScopedWriteLockGL(m_resourceProvider, texture->id())); unsigned textureId = m_currentFramebufferLock->textureId(); GLC(m_context, m_context->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, textureId, 0)); #if !defined ( NDEBUG ) if (m_context->checkFramebufferStatus(GraphicsContext3D::FRAMEBUFFER) != GraphicsContext3D::FRAMEBUFFER_COMPLETE) { ASSERT_NOT_REACHED(); return false; } #endif initializeMatrices(frame, framebufferRect, false); setDrawViewportSize(framebufferRect.size()); return true; } void CCRendererGL::enableScissorTestRect(const IntRect& scissorRect) { GLC(m_context, m_context->enable(GraphicsContext3D::SCISSOR_TEST)); GLC(m_context, m_context->scissor(scissorRect.x(), scissorRect.y(), scissorRect.width(), scissorRect.height())); } void CCRendererGL::disableScissorTest() { GLC(m_context, m_context->disable(GraphicsContext3D::SCISSOR_TEST)); } void CCRendererGL::setDrawViewportSize(const IntSize& viewportSize) { GLC(m_context, m_context->viewport(0, 0, viewportSize.width(), viewportSize.height())); } bool CCRendererGL::makeContextCurrent() { return m_context->makeContextCurrent(); } bool CCRendererGL::initializeSharedObjects() { TRACE_EVENT0("cc", "CCRendererGL::initializeSharedObjects"); makeContextCurrent(); // Create an FBO for doing offscreen rendering. GLC(m_context, m_offscreenFramebufferId = m_context->createFramebuffer()); // We will always need these programs to render, so create the programs eagerly so that the shader compilation can // start while we do other work. Other programs are created lazily on first access. m_sharedGeometry = adoptPtr(new GeometryBinding(m_context, quadVertexRect())); m_renderPassProgram = adoptPtr(new RenderPassProgram(m_context)); m_tileProgram = adoptPtr(new TileProgram(m_context)); m_tileProgramOpaque = adoptPtr(new TileProgramOpaque(m_context)); GLC(m_context, m_context->flush()); m_textureCopier = AcceleratedTextureCopier::create(m_context, m_isUsingBindUniform); if (m_textureUploaderSetting == ThrottledUploader) m_textureUploader = ThrottledTextureUploader::create(m_context); else m_textureUploader = UnthrottledTextureUploader::create(); return true; } const CCRendererGL::TileCheckerboardProgram* CCRendererGL::tileCheckerboardProgram() { if (!m_tileCheckerboardProgram) m_tileCheckerboardProgram = adoptPtr(new TileCheckerboardProgram(m_context)); if (!m_tileCheckerboardProgram->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::checkerboardProgram::initalize"); m_tileCheckerboardProgram->initialize(m_context, m_isUsingBindUniform); } return m_tileCheckerboardProgram.get(); } const CCRendererGL::SolidColorProgram* CCRendererGL::solidColorProgram() { if (!m_solidColorProgram) m_solidColorProgram = adoptPtr(new SolidColorProgram(m_context)); if (!m_solidColorProgram->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::solidColorProgram::initialize"); m_solidColorProgram->initialize(m_context, m_isUsingBindUniform); } return m_solidColorProgram.get(); } const CCRendererGL::RenderPassProgram* CCRendererGL::renderPassProgram() { ASSERT(m_renderPassProgram); if (!m_renderPassProgram->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::renderPassProgram::initialize"); m_renderPassProgram->initialize(m_context, m_isUsingBindUniform); } return m_renderPassProgram.get(); } const CCRendererGL::RenderPassProgramAA* CCRendererGL::renderPassProgramAA() { if (!m_renderPassProgramAA) m_renderPassProgramAA = adoptPtr(new RenderPassProgramAA(m_context)); if (!m_renderPassProgramAA->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::renderPassProgramAA::initialize"); m_renderPassProgramAA->initialize(m_context, m_isUsingBindUniform); } return m_renderPassProgramAA.get(); } const CCRendererGL::RenderPassMaskProgram* CCRendererGL::renderPassMaskProgram() { if (!m_renderPassMaskProgram) m_renderPassMaskProgram = adoptPtr(new RenderPassMaskProgram(m_context)); if (!m_renderPassMaskProgram->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::renderPassMaskProgram::initialize"); m_renderPassMaskProgram->initialize(m_context, m_isUsingBindUniform); } return m_renderPassMaskProgram.get(); } const CCRendererGL::RenderPassMaskProgramAA* CCRendererGL::renderPassMaskProgramAA() { if (!m_renderPassMaskProgramAA) m_renderPassMaskProgramAA = adoptPtr(new RenderPassMaskProgramAA(m_context)); if (!m_renderPassMaskProgramAA->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::renderPassMaskProgramAA::initialize"); m_renderPassMaskProgramAA->initialize(m_context, m_isUsingBindUniform); } return m_renderPassMaskProgramAA.get(); } const CCRendererGL::TileProgram* CCRendererGL::tileProgram() { ASSERT(m_tileProgram); if (!m_tileProgram->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::tileProgram::initialize"); m_tileProgram->initialize(m_context, m_isUsingBindUniform); } return m_tileProgram.get(); } const CCRendererGL::TileProgramOpaque* CCRendererGL::tileProgramOpaque() { ASSERT(m_tileProgramOpaque); if (!m_tileProgramOpaque->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::tileProgramOpaque::initialize"); m_tileProgramOpaque->initialize(m_context, m_isUsingBindUniform); } return m_tileProgramOpaque.get(); } const CCRendererGL::TileProgramAA* CCRendererGL::tileProgramAA() { if (!m_tileProgramAA) m_tileProgramAA = adoptPtr(new TileProgramAA(m_context)); if (!m_tileProgramAA->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::tileProgramAA::initialize"); m_tileProgramAA->initialize(m_context, m_isUsingBindUniform); } return m_tileProgramAA.get(); } const CCRendererGL::TileProgramSwizzle* CCRendererGL::tileProgramSwizzle() { if (!m_tileProgramSwizzle) m_tileProgramSwizzle = adoptPtr(new TileProgramSwizzle(m_context)); if (!m_tileProgramSwizzle->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::tileProgramSwizzle::initialize"); m_tileProgramSwizzle->initialize(m_context, m_isUsingBindUniform); } return m_tileProgramSwizzle.get(); } const CCRendererGL::TileProgramSwizzleOpaque* CCRendererGL::tileProgramSwizzleOpaque() { if (!m_tileProgramSwizzleOpaque) m_tileProgramSwizzleOpaque = adoptPtr(new TileProgramSwizzleOpaque(m_context)); if (!m_tileProgramSwizzleOpaque->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::tileProgramSwizzleOpaque::initialize"); m_tileProgramSwizzleOpaque->initialize(m_context, m_isUsingBindUniform); } return m_tileProgramSwizzleOpaque.get(); } const CCRendererGL::TileProgramSwizzleAA* CCRendererGL::tileProgramSwizzleAA() { if (!m_tileProgramSwizzleAA) m_tileProgramSwizzleAA = adoptPtr(new TileProgramSwizzleAA(m_context)); if (!m_tileProgramSwizzleAA->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::tileProgramSwizzleAA::initialize"); m_tileProgramSwizzleAA->initialize(m_context, m_isUsingBindUniform); } return m_tileProgramSwizzleAA.get(); } const CCRendererGL::TextureProgram* CCRendererGL::textureProgram() { if (!m_textureProgram) m_textureProgram = adoptPtr(new TextureProgram(m_context)); if (!m_textureProgram->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::textureProgram::initialize"); m_textureProgram->initialize(m_context, m_isUsingBindUniform); } return m_textureProgram.get(); } const CCRendererGL::TextureProgramFlip* CCRendererGL::textureProgramFlip() { if (!m_textureProgramFlip) m_textureProgramFlip = adoptPtr(new TextureProgramFlip(m_context)); if (!m_textureProgramFlip->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::textureProgramFlip::initialize"); m_textureProgramFlip->initialize(m_context, m_isUsingBindUniform); } return m_textureProgramFlip.get(); } const CCRendererGL::TextureIOSurfaceProgram* CCRendererGL::textureIOSurfaceProgram() { if (!m_textureIOSurfaceProgram) m_textureIOSurfaceProgram = adoptPtr(new TextureIOSurfaceProgram(m_context)); if (!m_textureIOSurfaceProgram->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::textureIOSurfaceProgram::initialize"); m_textureIOSurfaceProgram->initialize(m_context, m_isUsingBindUniform); } return m_textureIOSurfaceProgram.get(); } const CCRendererGL::VideoYUVProgram* CCRendererGL::videoYUVProgram() { if (!m_videoYUVProgram) m_videoYUVProgram = adoptPtr(new VideoYUVProgram(m_context)); if (!m_videoYUVProgram->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::videoYUVProgram::initialize"); m_videoYUVProgram->initialize(m_context, m_isUsingBindUniform); } return m_videoYUVProgram.get(); } const CCRendererGL::VideoStreamTextureProgram* CCRendererGL::videoStreamTextureProgram() { if (!m_videoStreamTextureProgram) m_videoStreamTextureProgram = adoptPtr(new VideoStreamTextureProgram(m_context)); if (!m_videoStreamTextureProgram->initialized()) { TRACE_EVENT0("cc", "CCRendererGL::streamTextureProgram::initialize"); m_videoStreamTextureProgram->initialize(m_context, m_isUsingBindUniform); } return m_videoStreamTextureProgram.get(); } void CCRendererGL::cleanupSharedObjects() { makeContextCurrent(); m_sharedGeometry.clear(); if (m_tileProgram) m_tileProgram->cleanup(m_context); if (m_tileProgramOpaque) m_tileProgramOpaque->cleanup(m_context); if (m_tileProgramSwizzle) m_tileProgramSwizzle->cleanup(m_context); if (m_tileProgramSwizzleOpaque) m_tileProgramSwizzleOpaque->cleanup(m_context); if (m_tileProgramAA) m_tileProgramAA->cleanup(m_context); if (m_tileProgramSwizzleAA) m_tileProgramSwizzleAA->cleanup(m_context); if (m_tileCheckerboardProgram) m_tileCheckerboardProgram->cleanup(m_context); if (m_renderPassMaskProgram) m_renderPassMaskProgram->cleanup(m_context); if (m_renderPassProgram) m_renderPassProgram->cleanup(m_context); if (m_renderPassMaskProgramAA) m_renderPassMaskProgramAA->cleanup(m_context); if (m_renderPassProgramAA) m_renderPassProgramAA->cleanup(m_context); if (m_textureProgram) m_textureProgram->cleanup(m_context); if (m_textureProgramFlip) m_textureProgramFlip->cleanup(m_context); if (m_textureIOSurfaceProgram) m_textureIOSurfaceProgram->cleanup(m_context); if (m_videoYUVProgram) m_videoYUVProgram->cleanup(m_context); if (m_videoStreamTextureProgram) m_videoStreamTextureProgram->cleanup(m_context); if (m_solidColorProgram) m_solidColorProgram->cleanup(m_context); if (m_offscreenFramebufferId) GLC(m_context, m_context->deleteFramebuffer(m_offscreenFramebufferId)); m_textureCopier.clear(); m_textureUploader.clear(); releaseRenderPassTextures(); } bool CCRendererGL::isContextLost() { return (m_context->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR); } } // namespace WebCore #endif // USE(ACCELERATED_COMPOSITING)