OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright (C) 2012 Google Inc. All rights reserved. |
| 3 * |
| 4 * Redistribution and use in source and binary forms, with or without |
| 5 * modification, are permitted provided that the following conditions |
| 6 * are met: |
| 7 * |
| 8 * 1. Redistributions of source code must retain the above copyright |
| 9 * notice, this list of conditions and the following disclaimer. |
| 10 * 2. Redistributions in binary form must reproduce the above copyright |
| 11 * notice, this list of conditions and the following disclaimer in the |
| 12 * documentation and/or other materials provided with the distribution. |
| 13 * |
| 14 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY |
| 15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| 16 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| 17 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY |
| 18 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| 19 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| 20 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| 21 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 24 */ |
| 25 |
| 26 #include "config.h" |
| 27 #include "cc/CCDelegatingRenderer.h" |
| 28 |
| 29 #include <set> |
| 30 #include <string> |
| 31 #include <vector> |
| 32 |
| 33 #include "cc/CCCheckerboardDrawQuad.h" |
| 34 #include "cc/CCDebugBorderDrawQuad.h" |
| 35 #include "cc/CCRenderPass.h" |
| 36 #include "cc/CCRenderPassDrawQuad.h" |
| 37 #include "cc/CCResourceProvider.h" |
| 38 #include "cc/CCSolidColorDrawQuad.h" |
| 39 #include "cc/CCTextureDrawQuad.h" |
| 40 #include "cc/CCTileDrawQuad.h" |
| 41 #include "cc/CCYUVVideoDrawQuad.h" |
| 42 #include "cc/compositor_frame.h" |
| 43 #include "CCSettings.h" |
| 44 #include "PlatformColor.h" |
| 45 #include "TraceEvent.h" |
| 46 #include <public/WebFloatRect.h> |
| 47 #include <public/WebRect.h> |
| 48 #include <public/WebSize.h> |
| 49 #include <wtf/text/StringHash.h> |
| 50 #include "base/string_split.h" |
| 51 #include "base/string_util.h" |
| 52 |
| 53 using namespace WebKit; |
| 54 |
| 55 namespace cc { |
| 56 |
| 57 namespace { |
| 58 |
| 59 void CollectResourcesInDrawQuad(const CCDrawQuad* quad, CCResourceProvider::Reso
urceIdArray* resources) { |
| 60 switch (quad->material()) { |
| 61 case CCDrawQuad::Invalid: |
| 62 NOTREACHED(); |
| 63 break; |
| 64 case CCDrawQuad::Checkerboard: |
| 65 case CCDrawQuad::DebugBorder: |
| 66 case CCDrawQuad::SolidColor: |
| 67 break; |
| 68 case CCDrawQuad::IOSurfaceContent: |
| 69 // TODO(piman): convert to CCTextureDrawQuad? |
| 70 NOTIMPLEMENTED(); |
| 71 break; |
| 72 case CCDrawQuad::RenderPass: |
| 73 resources->append(CCRenderPassDrawQuad::materialCast(quad)->maskResourceId
()); |
| 74 break; |
| 75 case CCDrawQuad::TextureContent: |
| 76 resources->append(CCTextureDrawQuad::materialCast(quad)->resourceId()); |
| 77 break; |
| 78 case CCDrawQuad::TiledContent: |
| 79 resources->append(CCTileDrawQuad::materialCast(quad)->resourceId()); |
| 80 break; |
| 81 case CCDrawQuad::YUVVideoContent: { |
| 82 const CCYUVVideoDrawQuad* yuvQuad = CCYUVVideoDrawQuad::materialCast(quad)
; |
| 83 resources->append(yuvQuad->yPlane().resourceId); |
| 84 resources->append(yuvQuad->uPlane().resourceId); |
| 85 resources->append(yuvQuad->vPlane().resourceId); |
| 86 } |
| 87 case CCDrawQuad::StreamVideoContent: |
| 88 // TODO(piman): convert to CCTextureDrawQuad? |
| 89 NOTIMPLEMENTED(); |
| 90 break; |
| 91 } |
| 92 } |
| 93 |
| 94 void CollectResourcesInRenderPass(CCRenderPass* pass, CCResourceProvider::Resour
ceIdArray* resources) { |
| 95 const CCQuadList& quadList = pass->quadList(); |
| 96 for (CCQuadList::const_iterator it = quadList.begin(); it != quadList.end(); +
+it) |
| 97 CollectResourcesInDrawQuad(*it, resources); |
| 98 } |
| 99 |
| 100 } // anonymous namespace |
| 101 |
| 102 |
| 103 PassOwnPtr<CCDelegatingRenderer> CCDelegatingRenderer::create(CCRendererClient*
client, CCResourceProvider* resourceProvider) |
| 104 { |
| 105 OwnPtr<CCDelegatingRenderer> renderer(adoptPtr(new CCDelegatingRenderer(clie
nt, resourceProvider))); |
| 106 if (!renderer->initialize()) |
| 107 return nullptr; |
| 108 return renderer.release(); |
| 109 } |
| 110 |
| 111 CCDelegatingRenderer::CCDelegatingRenderer(CCRendererClient* client, CCResourceP
rovider* resourceProvider) |
| 112 : CCRenderer(client) |
| 113 , m_resourceProvider(resourceProvider) |
| 114 , m_visible(true) |
| 115 { |
| 116 ASSERT(m_resourceProvider); |
| 117 } |
| 118 |
| 119 bool CCDelegatingRenderer::initialize() |
| 120 { |
| 121 m_capabilities.usingPartialSwap = CCSettings::partialSwapEnabled(); |
| 122 // FIXME: Throttling - we may want to only allow 1 outstanding frame (the |
| 123 // parent compositor can pipeline for us). |
| 124 m_capabilities.usingSwapCompleteCallback = true; |
| 125 m_capabilities.maxTextureSize = m_resourceProvider->maxTextureSize(); |
| 126 |
| 127 WebGraphicsContext3D* context = m_resourceProvider->graphicsContext3D(); |
| 128 bool supportsBGRA = false; |
| 129 if (context) { |
| 130 if (!context->makeContextCurrent()) |
| 131 return false; |
| 132 |
| 133 context->setContextLostCallback(this); |
| 134 context->pushGroupMarkerEXT("CompositorContext"); |
| 135 |
| 136 std::string extensionsString = UTF16ToASCII(context->getString(GraphicsCon
text3D::EXTENSIONS)); |
| 137 std::vector<std::string> extensionsList; |
| 138 base::SplitString(extensionsString, ' ', &extensionsList); |
| 139 std::set<std::string> extensions(extensionsList.begin(), extensionsList.en
d()); |
| 140 |
| 141 if (settings().acceleratePainting && extensions.count("GL_EXT_texture_form
at_BGRA8888") |
| 142 && extensions.count("GL_EXT_read_format_bgra")) |
| 143 m_capabilities.usingAcceleratedPainting = true; |
| 144 else |
| 145 m_capabilities.usingAcceleratedPainting = false; |
| 146 |
| 147 // FIXME: loop visibility to GPU process? |
| 148 m_capabilities.usingSetVisibility = extensions.count("GL_CHROMIUM_set_visi
bility"); |
| 149 |
| 150 if (extensions.count("GL_CHROMIUM_iosurface")) |
| 151 ASSERT(extensions.count("GL_ARB_texture_rectangle")); |
| 152 |
| 153 m_capabilities.usingGpuMemoryManager = extensions.count("GL_CHROMIUM_gpu_m
emory_manager"); |
| 154 // FIXME: doesn't belong here. |
| 155 /* |
| 156 if (m_capabilities.usingGpuMemoryManager) |
| 157 context->setMemoryAllocationChangedCallbackCHROMIUM(this); |
| 158 */ |
| 159 |
| 160 m_capabilities.usingEglImage = extensions.count("GL_OES_EGL_image_external
"); |
| 161 supportsBGRA = extensions.count("GL_EXT_texture_format_BGRA8888"); |
| 162 } |
| 163 |
| 164 m_capabilities.bestTextureFormat = PlatformColor::bestTextureFormat(context,
supportsBGRA); |
| 165 m_capabilities.allowPartialTextureUpdates = false; |
| 166 |
| 167 return true; |
| 168 } |
| 169 |
| 170 CCDelegatingRenderer::~CCDelegatingRenderer() |
| 171 { |
| 172 ASSERT(CCProxy::isImplThread()); |
| 173 WebGraphicsContext3D* context = m_resourceProvider->graphicsContext3D(); |
| 174 if (context) |
| 175 context->setContextLostCallback(0); |
| 176 } |
| 177 |
| 178 const RendererCapabilities& CCDelegatingRenderer::capabilities() const |
| 179 { |
| 180 return m_capabilities; |
| 181 } |
| 182 |
| 183 void CCDelegatingRenderer::drawFrame(const CCRenderPassList& renderPassesInDrawO
rder, const CCRenderPassIdHashMap&) |
| 184 { |
| 185 TRACE_EVENT0("cc", "CCDelegatingRenderer::drawFrame"); |
| 186 WebCompositorOutputSurface* outputSurface = m_resourceProvider->context(); |
| 187 ASSERT(outputSurface); |
| 188 CompositorFrame frame; |
| 189 frame.size.SetSize(viewportWidth(), viewportHeight()); |
| 190 frame.render_passes.reserve(renderPassesInDrawOrder.size()); |
| 191 CCResourceProvider::ResourceIdArray resources; |
| 192 for (CCRenderPassList::const_iterator it = renderPassesInDrawOrder.begin();
it != renderPassesInDrawOrder.end(); ++it) { |
| 193 frame.render_passes.push_back(*it); |
| 194 CollectResourcesInRenderPass(*it, &resources); |
| 195 } |
| 196 m_resourceProvider->prepareSendToParent(resources, &frame.resources); |
| 197 |
| 198 outputSurface->sendFrameToParentCompositor(frame); |
| 199 } |
| 200 |
| 201 bool CCDelegatingRenderer::swapBuffers() |
| 202 { |
| 203 return true; |
| 204 } |
| 205 |
| 206 void CCDelegatingRenderer::getFramebufferPixels(void *pixels, const IntRect&) |
| 207 { |
| 208 // FIXME |
| 209 } |
| 210 |
| 211 bool CCDelegatingRenderer::isContextLost() |
| 212 { |
| 213 WebGraphicsContext3D* context = m_resourceProvider->graphicsContext3D(); |
| 214 if (!context) |
| 215 return false; |
| 216 return (context->getGraphicsResetStatusARB() != GraphicsContext3D::NO_ERROR)
; |
| 217 } |
| 218 |
| 219 void CCDelegatingRenderer::onSendFrameToParentCompositorAck(const CompositorFram
eAck& ack) |
| 220 { |
| 221 m_resourceProvider->receiveFromParent(ack.resources); |
| 222 m_client->onSwapBuffersComplete(); |
| 223 } |
| 224 |
| 225 void CCDelegatingRenderer::setVisible(bool visible) |
| 226 { |
| 227 if (m_visible == visible) |
| 228 return; |
| 229 m_visible = visible; |
| 230 } |
| 231 |
| 232 void CCDelegatingRenderer::onContextLost() |
| 233 { |
| 234 m_client->didLoseContext(); |
| 235 } |
| 236 |
| 237 } |
OLD | NEW |