gfx/webrender_bindings/RendererOGL.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "RendererOGL.h"
   8
   9 #include "base/task.h"
  10 #include "GLContext.h"
  11 #include "mozilla/gfx/Logging.h"
  12 #include "mozilla/gfx/gfxVars.h"
  13 #include "mozilla/gfx/Types.h"
  14 #include "mozilla/layers/CompositorBridgeParent.h"
  15 #include "mozilla/layers/CompositorThread.h"
  16 #include "mozilla/layers/LayersTypes.h"
  17 #include "mozilla/layers/ProfilerScreenshots.h"
  18 #include "mozilla/webrender/RenderCompositor.h"
  19 #include "mozilla/webrender/RenderTextureHost.h"
  20 #include "mozilla/widget/CompositorWidget.h"
  21
  22 namespace mozilla {
  23 namespace wr {
  24
  25 class RendererRecordedFrame final : public layers::RecordedFrame {
  26  public:
  27   RendererRecordedFrame(const TimeStamp& aTimeStamp, wr::Renderer* aRenderer,
  28                         const wr::RecordedFrameHandle aHandle,
  29                         const gfx::IntSize& aSize)
  30       : RecordedFrame(aTimeStamp),
  31         mRenderer(aRenderer),
  32         mSize(aSize),
  33         mHandle(aHandle) {}
  34
  35   already_AddRefed<gfx::DataSourceSurface> GetSourceSurface() override {
  36     if (!mSurface) {
  37       mSurface = gfx::Factory::CreateDataSourceSurface(
  38           mSize, gfx::SurfaceFormat::B8G8R8A8, /* aZero = */ false);
  39
  40       gfx::DataSourceSurface::ScopedMap map(mSurface,
  41                                             gfx::DataSourceSurface::WRITE);
  42
  43       if (!wr_renderer_map_recorded_frame(mRenderer, mHandle, map.GetData(),
  44                                           map.GetStride() * mSize.height,
  45                                           map.GetStride())) {
  46         return nullptr;
  47       }
  48     }
  49
  50     return do_AddRef(mSurface);
  51   }
  52
  53  private:
  54   wr::Renderer* mRenderer;
  55   RefPtr<gfx::DataSourceSurface> mSurface;
  56   gfx::IntSize mSize;
  57   wr::RecordedFrameHandle mHandle;
  58 };
  59
  60 wr::WrExternalImage wr_renderer_lock_external_image(void* aObj,
  61                                                     wr::ExternalImageId aId,
  62                                                     uint8_t aChannelIndex) {
  63   RendererOGL* renderer = reinterpret_cast<RendererOGL*>(aObj);
  64   RenderTextureHost* texture = renderer->GetRenderTexture(aId);
  65   MOZ_ASSERT(texture);
  66   if (!texture) {
  67     gfxCriticalNoteOnce << "Failed to lock ExternalImage for extId:"
  68                         << AsUint64(aId);
  69     return InvalidToWrExternalImage();
  70   }
  71   if (auto* gl = renderer->gl()) {
  72     return texture->Lock(aChannelIndex, gl);
  73   } else if (auto* swgl = renderer->swgl()) {
  74     return texture->LockSWGL(aChannelIndex, swgl, renderer->GetCompositor());
  75   } else {
  76     gfxCriticalNoteOnce
  77         << "No GL or SWGL context available to lock ExternalImage for extId:"
  78         << AsUint64(aId);
  79     return InvalidToWrExternalImage();
  80   }
  81 }
  82
  83 void wr_renderer_unlock_external_image(void* aObj, wr::ExternalImageId aId,
  84                                        uint8_t aChannelIndex) {
  85   RendererOGL* renderer = reinterpret_cast<RendererOGL*>(aObj);
  86   RenderTextureHost* texture = renderer->GetRenderTexture(aId);
  87   MOZ_ASSERT(texture);
  88   if (!texture) {
  89     return;
  90   }
  91   if (renderer->gl()) {
  92     texture->Unlock();
  93   } else if (renderer->swgl()) {
  94     texture->UnlockSWGL();
  95   }
  96 }
  97
  98 RendererOGL::RendererOGL(RefPtr<RenderThread>&& aThread,
  99                          UniquePtr<RenderCompositor> aCompositor,
 100                          wr::WindowId aWindowId, wr::Renderer* aRenderer,
 101                          layers::CompositorBridgeParent* aBridge)
 102     : mThread(aThread),
 103       mCompositor(std::move(aCompositor)),
 104       mRenderer(aRenderer),
 105       mBridge(aBridge),
 106       mWindowId(aWindowId),
 107       mDisableNativeCompositor(false),
 108       mLastPipelineInfo(new WebRenderPipelineInfo) {
 109   MOZ_ASSERT(mThread);
 110   MOZ_ASSERT(mCompositor);
 111   MOZ_ASSERT(mRenderer);
 112   MOZ_ASSERT(mBridge);
 113   MOZ_COUNT_CTOR(RendererOGL);
 114 }
 115
 116 RendererOGL::~RendererOGL() {
 117   MOZ_COUNT_DTOR(RendererOGL);
 118   if (!mCompositor->MakeCurrent()) {
 119     gfxCriticalNote
 120         << "Failed to make render context current during destroying.";
 121     // Leak resources!
 122   } else {
 123     wr_renderer_delete(mRenderer);
 124   }
 125 }
 126
 127 wr::WrExternalImageHandler RendererOGL::GetExternalImageHandler() {
 128   return wr::WrExternalImageHandler{
 129       this,
 130   };
 131 }
 132
 133 void RendererOGL::SetFramePublishId(FramePublishId aPublishId) {
 134   wr_renderer_set_target_frame_publish_id(mRenderer, aPublishId);
 135 }
 136
 137 void RendererOGL::Update() {
 138   mCompositor->Update();
 139   if (mCompositor->MakeCurrent()) {
 140     wr_renderer_update(mRenderer);
 141     FlushPipelineInfo();
 142   }
 143 }
 144
 145 static void DoWebRenderDisableNativeCompositor(
 146     layers::CompositorBridgeParent* aBridge) {
 147   aBridge->NotifyWebRenderDisableNativeCompositor();
 148 }
 149
 150 RenderedFrameId RendererOGL::UpdateAndRender(
 151     const Maybe<gfx::IntSize>& aReadbackSize,
 152     const Maybe<wr::ImageFormat>& aReadbackFormat,
 153     const Maybe<Range<uint8_t>>& aReadbackBuffer, bool* aNeedsYFlip,
 154     RendererStats* aOutStats) {
 155   mozilla::widget::WidgetRenderingContext widgetContext;
 156
 157 #if defined(XP_MACOSX)
 158   widgetContext.mGL = mCompositor->gl();
 159 #endif
 160
 161   if (!mCompositor->GetWidget()->PreRender(&widgetContext)) {
 162     // XXX This could cause oom in webrender since pending_texture_updates is
 163     // not handled. It needs to be addressed.
 164     return RenderedFrameId();
 165   }
 166   // XXX set clear color if MOZ_WIDGET_ANDROID is defined.
 167
 168   if (mThread->IsHandlingDeviceReset() || !mCompositor->BeginFrame()) {
 169     CheckGraphicsResetStatus("BeginFrame", /* aForce */ true);
 170     mCompositor->GetWidget()->PostRender(&widgetContext);
 171     return RenderedFrameId();
 172   }
 173
 174   auto size = mCompositor->GetBufferSize();
 175   auto bufferAge = mCompositor->GetBufferAge();
 176
 177   wr_renderer_update(mRenderer);
 178
 179   bool fullRender = mCompositor->RequestFullRender();
 180   // When we're rendering to an external target, we want to render everything.
 181   if (mCompositor->UsePartialPresent() &&
 182       (aReadbackBuffer.isSome() || layers::ProfilerScreenshots::IsEnabled())) {
 183     fullRender = true;
 184   }
 185   if (fullRender) {
 186     wr_renderer_force_redraw(mRenderer);
 187   }
 188
 189   nsTArray<DeviceIntRect> dirtyRects;
 190   bool rendered = wr_renderer_render(mRenderer, size.width, size.height,
 191                                      bufferAge, aOutStats, &dirtyRects);
 192   FlushPipelineInfo();
 193   if (!rendered) {
 194     mCompositor->CancelFrame();
 195     RenderThread::Get()->HandleWebRenderError(WebRenderError::RENDER);
 196     mCompositor->GetWidget()->PostRender(&widgetContext);
 197     return RenderedFrameId();
 198   }
 199
 200   if (aReadbackBuffer.isSome()) {
 201     MOZ_ASSERT(aReadbackSize.isSome());
 202     MOZ_ASSERT(aReadbackFormat.isSome());
 203     if (!mCompositor->MaybeReadback(aReadbackSize.ref(), aReadbackFormat.ref(),
 204                                     aReadbackBuffer.ref(), aNeedsYFlip)) {
 205       wr_renderer_readback(mRenderer, aReadbackSize.ref().width,
 206                            aReadbackSize.ref().height, aReadbackFormat.ref(),
 207                            &aReadbackBuffer.ref()[0],
 208                            aReadbackBuffer.ref().length());
 209       if (aNeedsYFlip) {
 210         *aNeedsYFlip = !mCompositor->SurfaceOriginIsTopLeft();
 211       }
 212     }
 213   }
 214
 215   if (size.Width() != 0 && size.Height() != 0) {
 216     if (!mCompositor->MaybeGrabScreenshot(size.ToUnknownSize())) {
 217       mScreenshotGrabber.MaybeGrabScreenshot(this, size.ToUnknownSize());
 218     }
 219   }
 220
 221   // Frame recording must happen before EndFrame, as we must ensure we read the
 222   // contents of the back buffer before any calls to SwapBuffers which might
 223   // invalidate it.
 224   MaybeRecordFrame(mLastPipelineInfo);
 225
 226   RenderedFrameId frameId = mCompositor->EndFrame(dirtyRects);
 227
 228   mCompositor->GetWidget()->PostRender(&widgetContext);
 229
 230 #if defined(ENABLE_FRAME_LATENCY_LOG)
 231   if (mFrameStartTime) {
 232     uint32_t latencyMs =
 233         round((TimeStamp::Now() - mFrameStartTime).ToMilliseconds());
 234     printf_stderr("generate frame latencyMs latencyMs %d\n", latencyMs);
 235   }
 236   // Clear frame start time
 237   mFrameStartTime = TimeStamp();
 238 #endif
 239
 240   if (!mCompositor->MaybeProcessScreenshotQueue()) {
 241     mScreenshotGrabber.MaybeProcessQueue(this);
 242   }
 243
 244   // TODO: Flush pending actions such as texture deletions/unlocks and
 245   //       textureHosts recycling.
 246
 247   return frameId;
 248 }
 249
 250 bool RendererOGL::EnsureAsyncScreenshot() {
 251   if (mCompositor->SupportAsyncScreenshot()) {
 252     return true;
 253   }
 254   if (!mDisableNativeCompositor) {
 255     layers::CompositorThread()->Dispatch(
 256         NewRunnableFunction("DoWebRenderDisableNativeCompositorRunnable",
 257                             &DoWebRenderDisableNativeCompositor, mBridge));
 258
 259     mDisableNativeCompositor = true;
 260     gfxCriticalNote << "Disable native compositor for async screenshot";
 261   }
 262   return false;
 263 }
 264
 265 void RendererOGL::CheckGraphicsResetStatus(const char* aCaller, bool aForce) {
 266   if (mCompositor) {
 267     auto reason = mCompositor->IsContextLost(aForce);
 268     if (reason != LOCAL_GL_NO_ERROR) {
 269       RenderThread::Get()->HandleDeviceReset(aCaller, reason);
 270     }
 271   }
 272 }
 273
 274 void RendererOGL::WaitForGPU() {
 275   if (!mCompositor->WaitForGPU()) {
 276     CheckGraphicsResetStatus("WaitForGPU", /* aForce */ true);
 277   }
 278 }
 279
 280 ipc::FileDescriptor RendererOGL::GetAndResetReleaseFence() {
 281   return mCompositor->GetAndResetReleaseFence();
 282 }
 283
 284 RenderedFrameId RendererOGL::GetLastCompletedFrameId() {
 285   return mCompositor->GetLastCompletedFrameId();
 286 }
 287
 288 RenderedFrameId RendererOGL::UpdateFrameId() {
 289   return mCompositor->UpdateFrameId();
 290 }
 291
 292 void RendererOGL::Pause() { mCompositor->Pause(); }
 293
 294 bool RendererOGL::Resume() { return mCompositor->Resume(); }
 295
 296 bool RendererOGL::IsPaused() { return mCompositor->IsPaused(); }
 297
 298 layers::SyncObjectHost* RendererOGL::GetSyncObject() const {
 299   return mCompositor->GetSyncObject();
 300 }
 301
 302 gl::GLContext* RendererOGL::gl() const { return mCompositor->gl(); }
 303
 304 void* RendererOGL::swgl() const { return mCompositor->swgl(); }
 305
 306 void RendererOGL::SetFrameStartTime(const TimeStamp& aTime) {
 307   if (mFrameStartTime) {
 308     // frame start time is already set. This could happen when multiple
 309     // generate frame requests are merged by webrender.
 310     return;
 311   }
 312   mFrameStartTime = aTime;
 313 }
 314
 315 void RendererOGL::BeginRecording(const TimeStamp& aRecordingStart,
 316                                  wr::PipelineId aRootPipelineId) {
 317   MOZ_ASSERT(!mCompositionRecorder);
 318
 319   mRootPipelineId = aRootPipelineId;
 320   mCompositionRecorder =
 321       MakeUnique<layers::CompositionRecorder>(aRecordingStart);
 322   mCompositor->MaybeRequestAllowFrameRecording(true);
 323 }
 324
 325 void RendererOGL::MaybeRecordFrame(const WebRenderPipelineInfo* aPipelineInfo) {
 326   if (!mCompositionRecorder || !EnsureAsyncScreenshot()) {
 327     return;
 328   }
 329
 330   if (!mRenderer || !aPipelineInfo || !DidPaintContent(aPipelineInfo)) {
 331     return;
 332   }
 333
 334   if (mCompositor->MaybeRecordFrame(*mCompositionRecorder)) {
 335     return;
 336   }
 337
 338   wr::RecordedFrameHandle handle{0};
 339   gfx::IntSize size(0, 0);
 340
 341   if (wr_renderer_record_frame(mRenderer, wr::ImageFormat::BGRA8, &handle,
 342                                &size.width, &size.height)) {
 343     RefPtr<layers::RecordedFrame> frame =
 344         new RendererRecordedFrame(TimeStamp::Now(), mRenderer, handle, size);
 345
 346     mCompositionRecorder->RecordFrame(frame);
 347   }
 348 }
 349
 350 bool RendererOGL::DidPaintContent(const WebRenderPipelineInfo* aFrameEpochs) {
 351   const wr::WrPipelineInfo& info = aFrameEpochs->Raw();
 352   bool didPaintContent = false;
 353
 354   // Check if a non-root pipeline has updated to a new epoch.
 355   // We treat all non-root pipelines as "content" pipelines, even if they're
 356   // not fed by content paints, such as videos (see bug 1665512).
 357   for (const auto& epoch : info.epochs) {
 358     const wr::PipelineId pipelineId = epoch.pipeline_id;
 359
 360     if (pipelineId == mRootPipelineId) {
 361       continue;
 362     }
 363
 364     const auto it = mContentPipelineEpochs.find(AsUint64(pipelineId));
 365     if (it == mContentPipelineEpochs.end() || it->second != epoch.epoch) {
 366       // This pipeline has updated since last render or has newly rendered.
 367       didPaintContent = true;
 368       mContentPipelineEpochs[AsUint64(pipelineId)] = epoch.epoch;
 369     }
 370   }
 371
 372   for (const auto& removedPipeline : info.removed_pipelines) {
 373     const wr::PipelineId pipelineId = removedPipeline.pipeline_id;
 374     if (pipelineId == mRootPipelineId) {
 375       continue;
 376     }
 377     mContentPipelineEpochs.erase(AsUint64(pipelineId));
 378   }
 379
 380   return didPaintContent;
 381 }
 382
 383 Maybe<layers::FrameRecording> RendererOGL::EndRecording() {
 384   if (!mCompositionRecorder) {
 385     MOZ_DIAGNOSTIC_ASSERT(
 386         false, "Attempted to get frames from a window that was not recording.");
 387     return Nothing();
 388   }
 389
 390   auto maybeRecording = mCompositionRecorder->GetRecording();
 391
 392   wr_renderer_release_composition_recorder_structures(mRenderer);
 393
 394   mCompositor->MaybeRequestAllowFrameRecording(false);
 395   mCompositionRecorder = nullptr;
 396
 397   return maybeRecording;
 398 }
 399
 400 void RendererOGL::FlushPipelineInfo() {
 401   RefPtr<WebRenderPipelineInfo> info = new WebRenderPipelineInfo;
 402   wr_renderer_flush_pipeline_info(mRenderer, &info->Raw());
 403   mLastPipelineInfo = info;
 404 }
 405
 406 RenderTextureHost* RendererOGL::GetRenderTexture(
 407     wr::ExternalImageId aExternalImageId) {
 408   return mThread->GetRenderTexture(aExternalImageId);
 409 }
 410
 411 void RendererOGL::AccumulateMemoryReport(MemoryReport* aReport) {
 412   wr_renderer_accumulate_memory_report(GetRenderer(), aReport, swgl());
 413
 414   LayoutDeviceIntSize size = mCompositor->GetBufferSize();
 415
 416   // Assume BGRA8 for the format since it's not exposed anywhere,
 417   // and all compositor backends should be using that.
 418   uintptr_t swapChainSize = size.width * size.height *
 419                             BytesPerPixel(gfx::SurfaceFormat::B8G8R8A8) *
 420                             (mCompositor->UseTripleBuffering() ? 3 : 2);
 421   aReport->swap_chain += swapChainSize;
 422 }
 423
 424 void RendererOGL::SetProfilerUI(const nsACString& aUI) {
 425   wr_renderer_set_profiler_ui(GetRenderer(), (const uint8_t*)aUI.BeginReading(),
 426                               aUI.Length());
 427 }
 428
 429 }  // namespace wr
 430 }  // namespace mozilla