Line data    Source code

       1             : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2             : /* This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       5             : 
       6             : #include "RendererOGL.h"
       7             : #include "GLContext.h"
       8             : #include "GLContextProvider.h"
       9             : #include "mozilla/gfx/Logging.h"
      10             : #include "mozilla/layers/CompositorBridgeParent.h"
      11             : #include "mozilla/layers/CompositorThread.h"
      12             : #include "mozilla/webrender/RenderBufferTextureHost.h"
      13             : #include "mozilla/webrender/RenderTextureHostOGL.h"
      14             : #include "mozilla/widget/CompositorWidget.h"
      15             : 
      16             : namespace mozilla {
      17             : namespace wr {
      18             : 
      19           0 : WrExternalImage LockExternalImage(void* aObj, WrExternalImageId aId, uint8_t aChannelIndex)
      20             : {
      21           0 :   RendererOGL* renderer = reinterpret_cast<RendererOGL*>(aObj);
      22           0 :   RenderTextureHost* texture = renderer->GetRenderTexture(aId);
      23             : 
      24           0 :   if (texture->AsBufferTextureHost()) {
      25           0 :     RenderBufferTextureHost* bufferTexture = texture->AsBufferTextureHost();
      26           0 :     MOZ_ASSERT(bufferTexture);
      27           0 :     bufferTexture->Lock();
      28             :     RenderBufferTextureHost::RenderBufferData data =
      29           0 :         bufferTexture->GetBufferDataForRender(aChannelIndex);
      30             : 
      31           0 :     return RawDataToWrExternalImage(data.mData, data.mBufferSize);
      32             :   } else {
      33             :     // texture handle case
      34           0 :     RenderTextureHostOGL* textureOGL = texture->AsTextureHostOGL();
      35           0 :     MOZ_ASSERT(textureOGL);
      36             : 
      37           0 :     textureOGL->SetGLContext(renderer->mGL);
      38           0 :     textureOGL->Lock();
      39           0 :     gfx::IntSize size = textureOGL->GetSize(aChannelIndex);
      40             : 
      41           0 :     return NativeTextureToWrExternalImage(textureOGL->GetGLHandle(aChannelIndex),
      42             :                                           0, 0,
      43           0 :                                           size.width, size.height);
      44             :   }
      45             : }
      46             : 
      47           0 : void UnlockExternalImage(void* aObj, WrExternalImageId aId, uint8_t aChannelIndex)
      48             : {
      49           0 :   RendererOGL* renderer = reinterpret_cast<RendererOGL*>(aObj);
      50           0 :   RenderTextureHost* texture = renderer->GetRenderTexture(aId);
      51           0 :   MOZ_ASSERT(texture);
      52           0 :   texture->Unlock();
      53           0 : }
      54             : 
      55           0 : RendererOGL::RendererOGL(RefPtr<RenderThread>&& aThread,
      56             :                          RefPtr<gl::GLContext>&& aGL,
      57             :                          RefPtr<widget::CompositorWidget>&& aWidget,
      58             :                          wr::WindowId aWindowId,
      59             :                          WrRenderer* aWrRenderer,
      60           0 :                          layers::CompositorBridgeParentBase* aBridge)
      61             :   : mThread(aThread)
      62             :   , mGL(aGL)
      63             :   , mWidget(aWidget)
      64             :   , mWrRenderer(aWrRenderer)
      65             :   , mBridge(aBridge)
      66           0 :   , mWindowId(aWindowId)
      67             : {
      68           0 :   MOZ_ASSERT(mThread);
      69           0 :   MOZ_ASSERT(mGL);
      70           0 :   MOZ_ASSERT(mWidget);
      71           0 :   MOZ_ASSERT(mWrRenderer);
      72           0 :   MOZ_ASSERT(mBridge);
      73           0 :   MOZ_COUNT_CTOR(RendererOGL);
      74           0 : }
      75             : 
      76           0 : RendererOGL::~RendererOGL()
      77             : {
      78           0 :   MOZ_COUNT_DTOR(RendererOGL);
      79           0 :   if (!mGL->MakeCurrent()) {
      80           0 :     gfxCriticalNote << "Failed to make render context current during destroying.";
      81             :     // Leak resources!
      82           0 :     return;
      83             :   }
      84           0 :   wr_renderer_delete(mWrRenderer);
      85           0 : }
      86             : 
      87             : WrExternalImageHandler
      88           0 : RendererOGL::GetExternalImageHandler()
      89             : {
      90             :   return WrExternalImageHandler {
      91             :     this,
      92             :     LockExternalImage,
      93             :     UnlockExternalImage,
      94           0 :   };
      95             : }
      96             : 
      97             : void
      98           0 : RendererOGL::Update()
      99             : {
     100           0 :   wr_renderer_update(mWrRenderer);
     101           0 : }
     102             : 
     103             : bool
     104           0 : RendererOGL::Render()
     105             : {
     106           0 :   if (!mGL->MakeCurrent()) {
     107           0 :     gfxCriticalNote << "Failed to make render context current, can't draw.";
     108             :     // XXX This could cause oom in webrender since pending_texture_updates is not handled.
     109             :     // It needs to be addressed.
     110           0 :     return false;
     111             :   }
     112             : 
     113             :   mozilla::widget::WidgetRenderingContext widgetContext;
     114             : 
     115             : #if defined(XP_MACOSX)
     116             :   widgetContext.mGL = mGL;
     117             : // TODO: we don't have a notion of compositor here.
     118             : //#elif defined(MOZ_WIDGET_ANDROID)
     119             : //  widgetContext.mCompositor = mCompositor;
     120             : #endif
     121             : 
     122           0 :   if (!mWidget->PreRender(&widgetContext)) {
     123             :     // XXX This could cause oom in webrender since pending_texture_updates is not handled.
     124             :     // It needs to be addressed.
     125           0 :     return false;
     126             :   }
     127             :   // XXX set clear color if MOZ_WIDGET_ANDROID is defined.
     128             : 
     129           0 :   auto size = mWidget->GetClientSize();
     130           0 :   wr_renderer_render(mWrRenderer, size.width, size.height);
     131             : 
     132           0 :   mGL->SwapBuffers();
     133           0 :   mWidget->PostRender(&widgetContext);
     134             : 
     135             :   // TODO: Flush pending actions such as texture deletions/unlocks and
     136             :   //       textureHosts recycling.
     137             : 
     138           0 :   return true;
     139             : }
     140             : 
     141             : void
     142           0 : RendererOGL::Pause()
     143             : {
     144             : #ifdef MOZ_WIDGET_ANDROID
     145             :   if (!mGL || mGL->IsDestroyed()) {
     146             :     return;
     147             :   }
     148             :   // ReleaseSurface internally calls MakeCurrent.
     149             :   mGL->ReleaseSurface();
     150             : #endif
     151           0 : }
     152             : 
     153             : bool
     154           0 : RendererOGL::Resume()
     155             : {
     156             : #ifdef MOZ_WIDGET_ANDROID
     157             :   if (!mGL || mGL->IsDestroyed()) {
     158             :     return false;
     159             :   }
     160             :   // RenewSurface internally calls MakeCurrent.
     161             :   return mGL->RenewSurface(mWidget);
     162             : #else
     163           0 :   return true;
     164             : #endif
     165             : }
     166             : 
     167             : void
     168           0 : RendererOGL::SetProfilerEnabled(bool aEnabled)
     169             : {
     170           0 :   wr_renderer_set_profiler_enabled(mWrRenderer, aEnabled);
     171           0 : }
     172             : 
     173             : WrRenderedEpochs*
     174           0 : RendererOGL::FlushRenderedEpochs()
     175             : {
     176           0 :   return wr_renderer_flush_rendered_epochs(mWrRenderer);
     177             : }
     178             : 
     179             : RenderTextureHost*
     180           0 : RendererOGL::GetRenderTexture(WrExternalImageId aExternalImageId)
     181             : {
     182           0 :   return mThread->GetRenderTexture(aExternalImageId);
     183             : }
     184             : 
     185             : } // namespace wr
     186             : } // namespace mozilla