gfx/webrender_bindings/RenderCompositorLayersSWGL.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  *
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file,
   7  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   8
   9 #include "RenderCompositorLayersSWGL.h"
  10
  11 #include "GLContext.h"
  12 #include "GLContextEGL.h"
  13 #include "mozilla/layers/BuildConstants.h"
  14 #include "mozilla/layers/Effects.h"
  15 #include "mozilla/layers/TextureHostOGL.h"
  16 #include "mozilla/widget/CompositorWidget.h"
  17 #include "RenderCompositorRecordedFrame.h"
  18
  19 #if defined(XP_WIN)
  20 #  include "mozilla/webrender/RenderCompositorD3D11SWGL.h"
  21 #else
  22 #  include "mozilla/webrender/RenderCompositorOGLSWGL.h"
  23 #endif
  24
  25 namespace mozilla {
  26 using namespace layers;
  27 using namespace gfx;
  28
  29 namespace wr {
  30
  31 UniquePtr<RenderCompositor> RenderCompositorLayersSWGL::Create(
  32     const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError) {
  33 #ifdef XP_WIN
  34   return RenderCompositorD3D11SWGL::Create(aWidget, aError);
  35 #else
  36   return RenderCompositorOGLSWGL::Create(aWidget, aError);
  37 #endif
  38 }
  39
  40 RenderCompositorLayersSWGL::RenderCompositorLayersSWGL(
  41     Compositor* aCompositor, const RefPtr<widget::CompositorWidget>& aWidget,
  42     void* aContext)
  43     : RenderCompositor(aWidget),
  44       mCompositor(aCompositor),
  45       mContext(aContext),
  46       mCurrentTileId(wr::NativeTileId()) {
  47   MOZ_ASSERT(mCompositor);
  48   MOZ_ASSERT(mContext);
  49 }
  50
  51 RenderCompositorLayersSWGL::~RenderCompositorLayersSWGL() {
  52   wr_swgl_destroy_context(mContext);
  53 }
  54
  55 bool RenderCompositorLayersSWGL::MakeCurrent() {
  56   wr_swgl_make_current(mContext);
  57   return true;
  58 }
  59
  60 bool RenderCompositorLayersSWGL::BeginFrame() {
  61   MOZ_ASSERT(!mInFrame);
  62   MakeCurrent();
  63   mInFrame = true;
  64   return true;
  65 }
  66
  67 void RenderCompositorLayersSWGL::CancelFrame() {
  68   MOZ_ASSERT(mInFrame);
  69   mInFrame = false;
  70   if (mCompositingStarted) {
  71     mCompositor->CancelFrame();
  72     mCompositingStarted = false;
  73   }
  74 }
  75
  76 void RenderCompositorLayersSWGL::StartCompositing(
  77     wr::ColorF aClearColor, const wr::DeviceIntRect* aDirtyRects,
  78     size_t aNumDirtyRects, const wr::DeviceIntRect* aOpaqueRects,
  79     size_t aNumOpaqueRects) {
  80   MOZ_RELEASE_ASSERT(!mCompositingStarted);
  81
  82   if (!mInFrame || aNumDirtyRects == 0) {
  83     return;
  84   }
  85
  86   gfx::IntRect bounds(gfx::IntPoint(0, 0), GetBufferSize().ToUnknownSize());
  87   nsIntRegion dirty;
  88
  89   MOZ_RELEASE_ASSERT(aNumDirtyRects > 0);
  90   for (size_t i = 0; i < aNumDirtyRects; i++) {
  91     const auto& rect = aDirtyRects[i];
  92     dirty.OrWith(
  93         gfx::IntRect(rect.min.x, rect.min.y, rect.width(), rect.height()));
  94   }
  95   dirty.AndWith(bounds);
  96
  97   nsIntRegion opaque(bounds);
  98   opaque.SubOut(mWidget->GetTransparentRegion().ToUnknownRegion());
  99   for (size_t i = 0; i < aNumOpaqueRects; i++) {
 100     const auto& rect = aOpaqueRects[i];
 101     opaque.OrWith(
 102         gfx::IntRect(rect.min.x, rect.min.y, rect.width(), rect.height()));
 103   }
 104
 105   mCompositor->SetClearColor(gfx::DeviceColor(aClearColor.r, aClearColor.g,
 106                                               aClearColor.b, aClearColor.a));
 107
 108   if (!mCompositor->BeginFrameForWindow(dirty, Nothing(), bounds, opaque)) {
 109     return;
 110   }
 111   mCompositingStarted = true;
 112 }
 113
 114 void RenderCompositorLayersSWGL::CompositorEndFrame() {
 115   nsTArray<FrameSurface> frameSurfaces = std::move(mFrameSurfaces);
 116
 117   if (!mCompositingStarted) {
 118     return;
 119   }
 120
 121   for (auto& frameSurface : frameSurfaces) {
 122     auto surfaceCursor = mSurfaces.find(frameSurface.mId);
 123     MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
 124     Surface* surface = surfaceCursor->second.get();
 125
 126     for (auto it = surface->mTiles.begin(); it != surface->mTiles.end(); ++it) {
 127       if (!it->second->IsValid()) {
 128         continue;
 129       }
 130
 131       gfx::Point tileOffset(it->first.mX * surface->mTileSize.width,
 132                             it->first.mY * surface->mTileSize.height);
 133       gfx::Rect drawRect = it->second->mValidRect + tileOffset;
 134
 135       RefPtr<TexturedEffect> texturedEffect =
 136           new EffectRGB(it->second->GetTextureSource(),
 137                         /* aPremultiplied */ true, frameSurface.mFilter);
 138       if (surface->mIsOpaque) {
 139         texturedEffect->mPremultipliedCopy = true;
 140       }
 141
 142       texturedEffect->mTextureCoords =
 143           gfx::Rect(it->second->mValidRect.x / surface->mTileSize.width,
 144                     it->second->mValidRect.y / surface->mTileSize.height,
 145                     it->second->mValidRect.width / surface->mTileSize.width,
 146                     it->second->mValidRect.height / surface->mTileSize.height);
 147
 148       EffectChain effect;
 149       effect.mPrimaryEffect = texturedEffect;
 150       mCompositor->DrawQuad(drawRect, frameSurface.mClipRect, effect, 1.0,
 151                             frameSurface.mTransform, drawRect);
 152     }
 153
 154     if (surface->mExternalImage) {
 155       HandleExternalImage(surface->mExternalImage, frameSurface);
 156     }
 157   }
 158 }
 159
 160 RenderedFrameId RenderCompositorLayersSWGL::EndFrame(
 161     const nsTArray<DeviceIntRect>& aDirtyRects) {
 162   MOZ_ASSERT(mInFrame);
 163   mInFrame = false;
 164   if (mCompositingStarted) {
 165     mCompositor->EndFrame();
 166     mCompositingStarted = false;
 167   }
 168   return GetNextRenderFrameId();
 169 }
 170
 171 LayoutDeviceIntSize RenderCompositorLayersSWGL::GetBufferSize() {
 172   return mWidget->GetClientSize();
 173 }
 174
 175 void RenderCompositorLayersSWGL::Bind(wr::NativeTileId aId,
 176                                       wr::DeviceIntPoint* aOffset,
 177                                       uint32_t* aFboId,
 178                                       wr::DeviceIntRect aDirtyRect,
 179                                       wr::DeviceIntRect aValidRect) {
 180   MOZ_RELEASE_ASSERT(false);
 181 }
 182
 183 void RenderCompositorLayersSWGL::Unbind() { MOZ_RELEASE_ASSERT(false); }
 184
 185 bool RenderCompositorLayersSWGL::MapTile(wr::NativeTileId aId,
 186                                          wr::DeviceIntRect aDirtyRect,
 187                                          wr::DeviceIntRect aValidRect,
 188                                          void** aData, int32_t* aStride) {
 189   auto surfaceCursor = mSurfaces.find(aId.surface_id);
 190   MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
 191   Surface* surface = surfaceCursor->second.get();
 192
 193   auto layerCursor = surface->mTiles.find(TileKey(aId.x, aId.y));
 194   MOZ_RELEASE_ASSERT(layerCursor != surface->mTiles.end());
 195
 196   mCurrentTile = layerCursor->second.get();
 197   mCurrentTileId = aId;
 198   mCurrentTileDirty = gfx::IntRect(aDirtyRect.min.x, aDirtyRect.min.y,
 199                                    aDirtyRect.width(), aDirtyRect.height());
 200
 201   if (!mCurrentTile->Map(aDirtyRect, aValidRect, aData, aStride)) {
 202     gfxCriticalNote << "MapTile failed aValidRect: "
 203                     << gfx::Rect(aValidRect.min.x, aValidRect.min.y,
 204                                  aValidRect.width(), aValidRect.height());
 205     return false;
 206   }
 207
 208   // Store the new valid rect, so that we can composite only those pixels
 209   mCurrentTile->mValidRect = gfx::Rect(aValidRect.min.x, aValidRect.min.y,
 210                                        aValidRect.width(), aValidRect.height());
 211   return true;
 212 }
 213
 214 void RenderCompositorLayersSWGL::UnmapTile() {
 215   mCurrentTile->Unmap(mCurrentTileDirty);
 216   mCurrentTile = nullptr;
 217 }
 218
 219 void RenderCompositorLayersSWGL::CreateSurface(
 220     wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset,
 221     wr::DeviceIntSize aTileSize, bool aIsOpaque) {
 222   MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end());
 223   auto surface = DoCreateSurface(aTileSize, aIsOpaque);
 224   mSurfaces.insert({aId, std::move(surface)});
 225 }
 226
 227 UniquePtr<RenderCompositorLayersSWGL::Surface>
 228 RenderCompositorLayersSWGL::DoCreateSurface(wr::DeviceIntSize aTileSize,
 229                                             bool aIsOpaque) {
 230   return MakeUnique<Surface>(aTileSize, aIsOpaque);
 231 }
 232
 233 void RenderCompositorLayersSWGL::CreateExternalSurface(wr::NativeSurfaceId aId,
 234                                                        bool aIsOpaque) {
 235   MOZ_RELEASE_ASSERT(mSurfaces.find(aId) == mSurfaces.end());
 236   auto surface = MakeUnique<Surface>(wr::DeviceIntSize{}, aIsOpaque);
 237   surface->mIsExternal = true;
 238   mSurfaces.insert({aId, std::move(surface)});
 239 }
 240
 241 void RenderCompositorLayersSWGL::DestroySurface(NativeSurfaceId aId) {
 242   auto surfaceCursor = mSurfaces.find(aId);
 243   MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
 244   mSurfaces.erase(surfaceCursor);
 245 }
 246
 247 void RenderCompositorLayersSWGL::CreateTile(wr::NativeSurfaceId aId, int32_t aX,
 248                                             int32_t aY) {
 249   auto surfaceCursor = mSurfaces.find(aId);
 250   MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
 251   Surface* surface = surfaceCursor->second.get();
 252   MOZ_RELEASE_ASSERT(!surface->mIsExternal);
 253
 254   auto tile = DoCreateTile(surface);
 255   surface->mTiles.insert({TileKey(aX, aY), std::move(tile)});
 256 }
 257
 258 void RenderCompositorLayersSWGL::DestroyTile(wr::NativeSurfaceId aId,
 259                                              int32_t aX, int32_t aY) {
 260   auto surfaceCursor = mSurfaces.find(aId);
 261   MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
 262   Surface* surface = surfaceCursor->second.get();
 263   MOZ_RELEASE_ASSERT(!surface->mIsExternal);
 264
 265   auto layerCursor = surface->mTiles.find(TileKey(aX, aY));
 266   MOZ_RELEASE_ASSERT(layerCursor != surface->mTiles.end());
 267   surface->mTiles.erase(layerCursor);
 268 }
 269
 270 void RenderCompositorLayersSWGL::AttachExternalImage(
 271     wr::NativeSurfaceId aId, wr::ExternalImageId aExternalImage) {
 272   RenderTextureHost* image =
 273       RenderThread::Get()->GetRenderTexture(aExternalImage);
 274   MOZ_ASSERT(image);
 275   if (!image) {
 276     gfxCriticalNoteOnce
 277         << "Failed to get RenderTextureHost for D3D11SWGL extId:"
 278         << AsUint64(aExternalImage);
 279     return;
 280   }
 281 #if defined(XP_WIN)
 282   MOZ_RELEASE_ASSERT(image->AsRenderDXGITextureHost() ||
 283                      image->AsRenderDXGIYCbCrTextureHost());
 284 #elif defined(ANDROID)
 285   MOZ_RELEASE_ASSERT(image->AsRenderAndroidHardwareBufferTextureHost() ||
 286                      image->AsRenderAndroidSurfaceTextureHost() ||
 287                      image->AsRenderEGLImageTextureHost());
 288 #endif
 289
 290   auto surfaceCursor = mSurfaces.find(aId);
 291   MOZ_RELEASE_ASSERT(surfaceCursor != mSurfaces.end());
 292
 293   Surface* surface = surfaceCursor->second.get();
 294   surface->mExternalImage = image;
 295   MOZ_RELEASE_ASSERT(surface->mTiles.empty());
 296   MOZ_RELEASE_ASSERT(surface->mIsExternal);
 297 }
 298
 299 // static
 300 gfx::SamplingFilter RenderCompositorLayersSWGL::ToSamplingFilter(
 301     wr::ImageRendering aImageRendering) {
 302   if (aImageRendering == wr::ImageRendering::Auto) {
 303     return gfx::SamplingFilter::LINEAR;
 304   }
 305   return gfx::SamplingFilter::POINT;
 306 }
 307
 308 void RenderCompositorLayersSWGL::AddSurface(
 309     wr::NativeSurfaceId aId, const wr::CompositorSurfaceTransform& aTransform,
 310     wr::DeviceIntRect aClipRect, wr::ImageRendering aImageRendering) {
 311   float sx = aTransform.scale.x;
 312   float sy = aTransform.scale.y;
 313   float tx = aTransform.offset.x;
 314   float ty = aTransform.offset.y;
 315   gfx::Matrix4x4 transform(sx, 0.0, 0.0, 0.0, 0.0, sy, 0.0, 0.0, 0.0, 0.0, 1.0,
 316                            0.0, tx, ty, 0.0, 1.0);
 317   gfx::IntRect clipRect(aClipRect.min.x, aClipRect.min.y, aClipRect.width(),
 318                         aClipRect.height());
 319
 320   mFrameSurfaces.AppendElement(FrameSurface{aId, transform, clipRect,
 321                                             ToSamplingFilter(aImageRendering)});
 322 }
 323
 324 void RenderCompositorLayersSWGL::MaybeRequestAllowFrameRecording(
 325     bool aWillRecord) {
 326   mCompositor->RequestAllowFrameRecording(aWillRecord);
 327 }
 328
 329 class WindowLMC : public profiler_screenshots::Window {
 330  public:
 331   explicit WindowLMC(Compositor* aCompositor) : mCompositor(aCompositor) {}
 332
 333   already_AddRefed<profiler_screenshots::RenderSource> GetWindowContents(
 334       const gfx::IntSize& aWindowSize) override;
 335   already_AddRefed<profiler_screenshots::DownscaleTarget> CreateDownscaleTarget(
 336       const gfx::IntSize& aSize) override;
 337   already_AddRefed<profiler_screenshots::AsyncReadbackBuffer>
 338   CreateAsyncReadbackBuffer(const gfx::IntSize& aSize) override;
 339
 340  protected:
 341   Compositor* mCompositor;
 342 };
 343
 344 class RenderSourceLMC : public profiler_screenshots::RenderSource {
 345  public:
 346   explicit RenderSourceLMC(CompositingRenderTarget* aRT)
 347       : RenderSource(aRT->GetSize()), mRT(aRT) {}
 348
 349   const auto& RenderTarget() { return mRT; }
 350
 351  protected:
 352   virtual ~RenderSourceLMC() {}
 353
 354   RefPtr<CompositingRenderTarget> mRT;
 355 };
 356
 357 class DownscaleTargetLMC : public profiler_screenshots::DownscaleTarget {
 358  public:
 359   explicit DownscaleTargetLMC(CompositingRenderTarget* aRT,
 360                               Compositor* aCompositor)
 361       : profiler_screenshots::DownscaleTarget(aRT->GetSize()),
 362         mRenderSource(new RenderSourceLMC(aRT)),
 363         mCompositor(aCompositor) {}
 364
 365   already_AddRefed<profiler_screenshots::RenderSource> AsRenderSource()
 366       override {
 367     return do_AddRef(mRenderSource);
 368   }
 369
 370   bool DownscaleFrom(profiler_screenshots::RenderSource* aSource,
 371                      const IntRect& aSourceRect,
 372                      const IntRect& aDestRect) override {
 373     MOZ_RELEASE_ASSERT(aSourceRect.TopLeft() == IntPoint());
 374     MOZ_RELEASE_ASSERT(aDestRect.TopLeft() == IntPoint());
 375     RefPtr<CompositingRenderTarget> previousTarget =
 376         mCompositor->GetCurrentRenderTarget();
 377
 378     mCompositor->SetRenderTarget(mRenderSource->RenderTarget());
 379     bool result = mCompositor->BlitRenderTarget(
 380         static_cast<RenderSourceLMC*>(aSource)->RenderTarget(),
 381         aSourceRect.Size(), aDestRect.Size());
 382
 383     // Restore the old render target.
 384     mCompositor->SetRenderTarget(previousTarget);
 385
 386     return result;
 387   }
 388
 389  protected:
 390   virtual ~DownscaleTargetLMC() {}
 391
 392   RefPtr<RenderSourceLMC> mRenderSource;
 393   Compositor* mCompositor;
 394 };
 395
 396 class AsyncReadbackBufferLMC
 397     : public profiler_screenshots::AsyncReadbackBuffer {
 398  public:
 399   AsyncReadbackBufferLMC(mozilla::layers::AsyncReadbackBuffer* aARB,
 400                          Compositor* aCompositor)
 401       : profiler_screenshots::AsyncReadbackBuffer(aARB->GetSize()),
 402         mARB(aARB),
 403         mCompositor(aCompositor) {}
 404   void CopyFrom(profiler_screenshots::RenderSource* aSource) override {
 405     mCompositor->ReadbackRenderTarget(
 406         static_cast<RenderSourceLMC*>(aSource)->RenderTarget(), mARB);
 407   }
 408   bool MapAndCopyInto(DataSourceSurface* aSurface,
 409                       const IntSize& aReadSize) override {
 410     return mARB->MapAndCopyInto(aSurface, aReadSize);
 411   }
 412
 413  protected:
 414   virtual ~AsyncReadbackBufferLMC() {}
 415
 416   RefPtr<mozilla::layers::AsyncReadbackBuffer> mARB;
 417   Compositor* mCompositor;
 418 };
 419
 420 already_AddRefed<profiler_screenshots::RenderSource>
 421 WindowLMC::GetWindowContents(const gfx::IntSize& aWindowSize) {
 422   RefPtr<CompositingRenderTarget> rt = mCompositor->GetWindowRenderTarget();
 423   if (!rt) {
 424     return nullptr;
 425   }
 426   return MakeAndAddRef<RenderSourceLMC>(rt);
 427 }
 428
 429 already_AddRefed<profiler_screenshots::DownscaleTarget>
 430 WindowLMC::CreateDownscaleTarget(const gfx::IntSize& aSize) {
 431   RefPtr<CompositingRenderTarget> rt =
 432       mCompositor->CreateRenderTarget(IntRect({}, aSize), INIT_MODE_NONE);
 433   return MakeAndAddRef<DownscaleTargetLMC>(rt, mCompositor);
 434 }
 435
 436 already_AddRefed<profiler_screenshots::AsyncReadbackBuffer>
 437 WindowLMC::CreateAsyncReadbackBuffer(const gfx::IntSize& aSize) {
 438   RefPtr<AsyncReadbackBuffer> carb =
 439       mCompositor->CreateAsyncReadbackBuffer(aSize);
 440   if (!carb) {
 441     return nullptr;
 442   }
 443   return MakeAndAddRef<AsyncReadbackBufferLMC>(carb, mCompositor);
 444 }
 445
 446 bool RenderCompositorLayersSWGL::MaybeRecordFrame(
 447     layers::CompositionRecorder& aRecorder) {
 448   WindowLMC window(mCompositor);
 449   gfx::IntSize size = GetBufferSize().ToUnknownSize();
 450   RefPtr<layers::profiler_screenshots::RenderSource> snapshot =
 451       window.GetWindowContents(size);
 452   if (!snapshot) {
 453     return true;
 454   }
 455
 456   RefPtr<layers::profiler_screenshots::AsyncReadbackBuffer> buffer =
 457       window.CreateAsyncReadbackBuffer(size);
 458   buffer->CopyFrom(snapshot);
 459
 460   RefPtr<layers::RecordedFrame> frame =
 461       new RenderCompositorRecordedFrame(TimeStamp::Now(), std::move(buffer));
 462   aRecorder.RecordFrame(frame);
 463   return false;
 464 }
 465
 466 bool RenderCompositorLayersSWGL::MaybeGrabScreenshot(
 467     const gfx::IntSize& aWindowSize) {
 468   if (!mCompositingStarted) {
 469     return true;
 470   }
 471   WindowLMC window(mCompositor);
 472   mProfilerScreenshotGrabber.MaybeGrabScreenshot(window, aWindowSize);
 473   return true;
 474 }
 475
 476 bool RenderCompositorLayersSWGL::MaybeProcessScreenshotQueue() {
 477   mProfilerScreenshotGrabber.MaybeProcessQueue();
 478   return true;
 479 }
 480
 481 }  // namespace wr
 482 }  // namespace mozilla