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(gfx::DeviceResetDetectPlace::WR_BEGIN_FRAME,
 170                              /* aForce */ true);
 171     mCompositor->GetWidget()->PostRender(&widgetContext);
 172     return RenderedFrameId();
 173   }
 174
 175   auto size = mCompositor->GetBufferSize();
 176   auto bufferAge = mCompositor->GetBufferAge();
 177
 178   wr_renderer_update(mRenderer);
 179
 180   bool fullRender = mCompositor->RequestFullRender();
 181   // When we're rendering to an external target, we want to render everything.
 182   if (mCompositor->UsePartialPresent() &&
 183       (aReadbackBuffer.isSome() || layers::ProfilerScreenshots::IsEnabled())) {
 184     fullRender = true;
 185   }
 186   if (fullRender) {
 187     wr_renderer_force_redraw(mRenderer);
 188   }
 189
 190   nsTArray<DeviceIntRect> dirtyRects;
 191   bool rendered = wr_renderer_render(mRenderer, size.width, size.height,
 192                                      bufferAge, aOutStats, &dirtyRects);
 193   FlushPipelineInfo();
 194   if (!rendered) {
 195     mCompositor->CancelFrame();
 196     RenderThread::Get()->HandleWebRenderError(WebRenderError::RENDER);
 197     mCompositor->GetWidget()->PostRender(&widgetContext);
 198     return RenderedFrameId();
 199   }
 200
 201   if (aReadbackBuffer.isSome()) {
 202     MOZ_ASSERT(aReadbackSize.isSome());
 203     MOZ_ASSERT(aReadbackFormat.isSome());
 204     if (!mCompositor->MaybeReadback(aReadbackSize.ref(), aReadbackFormat.ref(),
 205                                     aReadbackBuffer.ref(), aNeedsYFlip)) {
 206       wr_renderer_readback(mRenderer, aReadbackSize.ref().width,
 207                            aReadbackSize.ref().height, aReadbackFormat.ref(),
 208                            &aReadbackBuffer.ref()[0],
 209                            aReadbackBuffer.ref().length());
 210       if (aNeedsYFlip) {
 211         *aNeedsYFlip = !mCompositor->SurfaceOriginIsTopLeft();
 212       }
 213     }
 214   }
 215
 216   if (size.Width() != 0 && size.Height() != 0) {
 217     if (!mCompositor->MaybeGrabScreenshot(size.ToUnknownSize())) {
 218       mScreenshotGrabber.MaybeGrabScreenshot(this, size.ToUnknownSize());
 219     }
 220   }
 221
 222   // Frame recording must happen before EndFrame, as we must ensure we read the
 223   // contents of the back buffer before any calls to SwapBuffers which might
 224   // invalidate it.
 225   MaybeRecordFrame(mLastPipelineInfo);
 226
 227   RenderedFrameId frameId = mCompositor->EndFrame(dirtyRects);
 228
 229   mCompositor->GetWidget()->PostRender(&widgetContext);
 230
 231 #if defined(ENABLE_FRAME_LATENCY_LOG)
 232   if (mFrameStartTime) {
 233     uint32_t latencyMs =
 234         round((TimeStamp::Now() - mFrameStartTime).ToMilliseconds());
 235     printf_stderr("generate frame latencyMs latencyMs %d\n", latencyMs);
 236   }
 237   // Clear frame start time
 238   mFrameStartTime = TimeStamp();
 239 #endif
 240
 241   if (!mCompositor->MaybeProcessScreenshotQueue()) {
 242     mScreenshotGrabber.MaybeProcessQueue(this);
 243   }
 244
 245   // TODO: Flush pending actions such as texture deletions/unlocks and
 246   //       textureHosts recycling.
 247
 248   return frameId;
 249 }
 250
 251 bool RendererOGL::EnsureAsyncScreenshot() {
 252   if (mCompositor->SupportAsyncScreenshot()) {
 253     return true;
 254   }
 255   if (!mDisableNativeCompositor) {
 256     layers::CompositorThread()->Dispatch(
 257         NewRunnableFunction("DoWebRenderDisableNativeCompositorRunnable",
 258                             &DoWebRenderDisableNativeCompositor, mBridge));
 259
 260     mDisableNativeCompositor = true;
 261     gfxCriticalNote << "Disable native compositor for async screenshot";
 262   }
 263   return false;
 264 }
 265
 266 void RendererOGL::CheckGraphicsResetStatus(gfx::DeviceResetDetectPlace aPlace,
 267                                            bool aForce) {
 268   if (mCompositor) {
 269     auto reason = mCompositor->IsContextLost(aForce);
 270     if (reason != gfx::DeviceResetReason::OK) {
 271       RenderThread::Get()->HandleDeviceReset(aPlace, reason);
 272     }
 273   }
 274 }
 275
 276 void RendererOGL::WaitForGPU() {
 277   if (!mCompositor->WaitForGPU()) {
 278     CheckGraphicsResetStatus(gfx::DeviceResetDetectPlace::WR_WAIT_FOR_GPU,
 279                              /* aForce */ true);
 280   }
 281 }
 282
 283 ipc::FileDescriptor RendererOGL::GetAndResetReleaseFence() {
 284   return mCompositor->GetAndResetReleaseFence();
 285 }
 286
 287 RenderedFrameId RendererOGL::GetLastCompletedFrameId() {
 288   return mCompositor->GetLastCompletedFrameId();
 289 }
 290
 291 RenderedFrameId RendererOGL::UpdateFrameId() {
 292   return mCompositor->UpdateFrameId();
 293 }
 294
 295 void RendererOGL::Pause() { mCompositor->Pause(); }
 296
 297 bool RendererOGL::Resume() { return mCompositor->Resume(); }
 298
 299 bool RendererOGL::IsPaused() { return mCompositor->IsPaused(); }
 300
 301 layers::SyncObjectHost* RendererOGL::GetSyncObject() const {
 302   return mCompositor->GetSyncObject();
 303 }
 304
 305 gl::GLContext* RendererOGL::gl() const { return mCompositor->gl(); }
 306
 307 void* RendererOGL::swgl() const { return mCompositor->swgl(); }
 308
 309 void RendererOGL::SetFrameStartTime(const TimeStamp& aTime) {
 310   if (mFrameStartTime) {
 311     // frame start time is already set. This could happen when multiple
 312     // generate frame requests are merged by webrender.
 313     return;
 314   }
 315   mFrameStartTime = aTime;
 316 }
 317
 318 void RendererOGL::BeginRecording(const TimeStamp& aRecordingStart,
 319                                  wr::PipelineId aRootPipelineId) {
 320   MOZ_ASSERT(!mCompositionRecorder);
 321
 322   mRootPipelineId = aRootPipelineId;
 323   mCompositionRecorder =
 324       MakeUnique<layers::CompositionRecorder>(aRecordingStart);
 325   mCompositor->MaybeRequestAllowFrameRecording(true);
 326 }
 327
 328 void RendererOGL::MaybeRecordFrame(const WebRenderPipelineInfo* aPipelineInfo) {
 329   if (!mCompositionRecorder || !EnsureAsyncScreenshot()) {
 330     return;
 331   }
 332
 333   if (!mRenderer || !aPipelineInfo || !DidPaintContent(aPipelineInfo)) {
 334     return;
 335   }
 336
 337   if (mCompositor->MaybeRecordFrame(*mCompositionRecorder)) {
 338     return;
 339   }
 340
 341   wr::RecordedFrameHandle handle{0};
 342   gfx::IntSize size(0, 0);
 343
 344   if (wr_renderer_record_frame(mRenderer, wr::ImageFormat::BGRA8, &handle,
 345                                &size.width, &size.height)) {
 346     RefPtr<layers::RecordedFrame> frame =
 347         new RendererRecordedFrame(TimeStamp::Now(), mRenderer, handle, size);
 348
 349     mCompositionRecorder->RecordFrame(frame);
 350   }
 351 }
 352
 353 bool RendererOGL::DidPaintContent(const WebRenderPipelineInfo* aFrameEpochs) {
 354   const wr::WrPipelineInfo& info = aFrameEpochs->Raw();
 355   bool didPaintContent = false;
 356
 357   // Check if a non-root pipeline has updated to a new epoch.
 358   // We treat all non-root pipelines as "content" pipelines, even if they're
 359   // not fed by content paints, such as videos (see bug 1665512).
 360   for (const auto& epoch : info.epochs) {
 361     const wr::PipelineId pipelineId = epoch.pipeline_id;
 362
 363     if (pipelineId == mRootPipelineId) {
 364       continue;
 365     }
 366
 367     const auto it = mContentPipelineEpochs.find(AsUint64(pipelineId));
 368     if (it == mContentPipelineEpochs.end() || it->second != epoch.epoch) {
 369       // This pipeline has updated since last render or has newly rendered.
 370       didPaintContent = true;
 371       mContentPipelineEpochs[AsUint64(pipelineId)] = epoch.epoch;
 372     }
 373   }
 374
 375   for (const auto& removedPipeline : info.removed_pipelines) {
 376     const wr::PipelineId pipelineId = removedPipeline.pipeline_id;
 377     if (pipelineId == mRootPipelineId) {
 378       continue;
 379     }
 380     mContentPipelineEpochs.erase(AsUint64(pipelineId));
 381   }
 382
 383   return didPaintContent;
 384 }
 385
 386 Maybe<layers::FrameRecording> RendererOGL::EndRecording() {
 387   if (!mCompositionRecorder) {
 388     MOZ_DIAGNOSTIC_ASSERT(
 389         false, "Attempted to get frames from a window that was not recording.");
 390     return Nothing();
 391   }
 392
 393   auto maybeRecording = mCompositionRecorder->GetRecording();
 394
 395   wr_renderer_release_composition_recorder_structures(mRenderer);
 396
 397   mCompositor->MaybeRequestAllowFrameRecording(false);
 398   mCompositionRecorder = nullptr;
 399
 400   return maybeRecording;
 401 }
 402
 403 void RendererOGL::FlushPipelineInfo() {
 404   RefPtr<WebRenderPipelineInfo> info = new WebRenderPipelineInfo;
 405   wr_renderer_flush_pipeline_info(mRenderer, &info->Raw());
 406   mLastPipelineInfo = info;
 407 }
 408
 409 RenderTextureHost* RendererOGL::GetRenderTexture(
 410     wr::ExternalImageId aExternalImageId) {
 411   return mThread->GetRenderTexture(aExternalImageId);
 412 }
 413
 414 void RendererOGL::AccumulateMemoryReport(MemoryReport* aReport) {
 415   wr_renderer_accumulate_memory_report(GetRenderer(), aReport, swgl());
 416
 417   LayoutDeviceIntSize size = mCompositor->GetBufferSize();
 418
 419   // Assume BGRA8 for the format since it's not exposed anywhere,
 420   // and all compositor backends should be using that.
 421   uintptr_t swapChainSize = size.width * size.height *
 422                             BytesPerPixel(gfx::SurfaceFormat::B8G8R8A8) *
 423                             (mCompositor->UseTripleBuffering() ? 3 : 2);
 424   aReport->swap_chain += swapChainSize;
 425 }
 426
 427 void RendererOGL::SetProfilerUI(const nsACString& aUI) {
 428   wr_renderer_set_profiler_ui(GetRenderer(), (const uint8_t*)aUI.BeginReading(),
 429                               aUI.Length());
 430 }
 431
 432 }  // namespace wr
 433 }  // namespace mozilla