gfx/layers/ShareableCanvasRenderer.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 "ShareableCanvasRenderer.h"
   8
   9 #include "mozilla/dom/WebGLTypes.h"
  10 #include "mozilla/gfx/2D.h"
  11 #include "mozilla/layers/TextureClientSharedSurface.h"
  12 #include "mozilla/layers/CompositableForwarder.h"
  13 #include "mozilla/layers/TextureForwarder.h"
  14
  15 #include "ClientWebGLContext.h"
  16 #include "gfxUtils.h"
  17 #include "GLScreenBuffer.h"
  18 #include "nsICanvasRenderingContextInternal.h"
  19 #include "SharedSurfaceGL.h"
  20
  21 using namespace mozilla::gfx;
  22
  23 namespace mozilla {
  24 namespace layers {
  25
  26 ShareableCanvasRenderer::ShareableCanvasRenderer() {
  27   MOZ_COUNT_CTOR(ShareableCanvasRenderer);
  28 }
  29
  30 ShareableCanvasRenderer::~ShareableCanvasRenderer() {
  31   MOZ_COUNT_DTOR(ShareableCanvasRenderer);
  32
  33   mFrontBufferFromDesc = nullptr;
  34   DisconnectClient();
  35 }
  36
  37 void ShareableCanvasRenderer::Initialize(const CanvasRendererData& aData) {
  38   CanvasRenderer::Initialize(aData);
  39   mCanvasClient = nullptr;
  40 }
  41
  42 void ShareableCanvasRenderer::ClearCachedResources() {
  43   CanvasRenderer::ClearCachedResources();
  44
  45   if (mCanvasClient) {
  46     mCanvasClient->Clear();
  47   }
  48 }
  49
  50 void ShareableCanvasRenderer::DisconnectClient() {
  51   if (mCanvasClient) {
  52     mCanvasClient->OnDetach();
  53     mCanvasClient = nullptr;
  54   }
  55 }
  56
  57 RefPtr<layers::TextureClient> ShareableCanvasRenderer::GetFrontBufferFromDesc(
  58     const layers::SurfaceDescriptor& desc, TextureFlags flags) {
  59   if (mFrontBufferFromDesc && mFrontBufferDesc == desc)
  60     return mFrontBufferFromDesc;
  61   mFrontBufferFromDesc = nullptr;
  62
  63   // Test the validity of aAllocator
  64   const auto& compositableForwarder = GetForwarder();
  65   if (!compositableForwarder) {
  66     return nullptr;
  67   }
  68   const auto& textureForwarder = compositableForwarder->GetTextureForwarder();
  69
  70   auto format = gfx::SurfaceFormat::R8G8B8X8;
  71   if (!mData.mIsOpaque) {
  72     format = gfx::SurfaceFormat::R8G8B8A8;
  73
  74     if (!mData.mIsAlphaPremult) {
  75       flags |= TextureFlags::NON_PREMULTIPLIED;
  76     }
  77   }
  78
  79   mFrontBufferFromDesc = SharedSurfaceTextureData::CreateTextureClient(
  80       desc, format, mData.mSize, flags, textureForwarder);
  81   mFrontBufferDesc = desc;
  82   return mFrontBufferFromDesc;
  83 }
  84
  85 void ShareableCanvasRenderer::UpdateCompositableClient() {
  86   if (!CreateCompositable()) {
  87     return;
  88   }
  89
  90   if (!IsDirty()) {
  91     const auto context = mData.GetContext();
  92     if (!context) {
  93       return;
  94     }
  95     const auto& forwarder = GetForwarder();
  96     RefPtr<FwdTransactionTracker> tracker =
  97         context->UseCompositableForwarder(forwarder);
  98     if (forwarder && tracker) {
  99       forwarder->TrackFwdTransaction(tracker);
 100     }
 101     return;
 102   }
 103   ResetDirty();
 104
 105   const auto context = mData.GetContext();
 106   if (!context) return;
 107   const auto& provider = context->GetBufferProvider();
 108   const auto& forwarder = GetForwarder();
 109
 110   // -
 111
 112   auto flags = TextureFlags::IMMUTABLE;
 113   if (!YIsDown()) {
 114     flags |= TextureFlags::ORIGIN_BOTTOM_LEFT;
 115   }
 116   if (IsOpaque()) {
 117     flags |= TextureFlags::IS_OPAQUE;
 118   }
 119
 120   // -
 121
 122   const auto fnGetExistingTc =
 123       [&](const Maybe<SurfaceDescriptor>& aDesc,
 124           bool& aOutLostFrontTexture) -> RefPtr<TextureClient> {
 125     if (aDesc) {
 126       return GetFrontBufferFromDesc(*aDesc, flags);
 127     }
 128     if (provider) {
 129       if (!provider->SetKnowsCompositor(forwarder, aOutLostFrontTexture)) {
 130         gfxCriticalNote << "BufferProvider::SetForwarder failed";
 131         return nullptr;
 132       }
 133       if (aOutLostFrontTexture) {
 134         return nullptr;
 135       }
 136
 137       return provider->GetTextureClient();
 138     }
 139     return nullptr;
 140   };
 141
 142   // -
 143
 144   const auto fnMakeTcFromSnapshot = [&]() -> RefPtr<TextureClient> {
 145     const auto& size = mData.mSize;
 146
 147     auto contentType = gfxContentType::COLOR;
 148     if (!mData.mIsOpaque) {
 149       contentType = gfxContentType::COLOR_ALPHA;
 150     }
 151     const auto surfaceFormat =
 152         gfxPlatform::GetPlatform()->Optimal2DFormatForContent(contentType);
 153
 154     const auto tc =
 155         mCanvasClient->CreateTextureClientForCanvas(surfaceFormat, size, flags);
 156     if (!tc) {
 157       return nullptr;
 158     }
 159
 160     {
 161       TextureClientAutoLock tcLock(tc, OpenMode::OPEN_WRITE_ONLY);
 162       if (!tcLock.Succeeded()) {
 163         return nullptr;
 164       }
 165
 166       const RefPtr<DrawTarget> dt = tc->BorrowDrawTarget();
 167
 168       const bool requireAlphaPremult = false;
 169       auto borrowed = BorrowSnapshot(requireAlphaPremult);
 170       if (!borrowed) {
 171         return nullptr;
 172       }
 173       dt->CopySurface(borrowed->mSurf, borrowed->mSurf->GetRect(), {0, 0});
 174     }
 175
 176     return tc;
 177   };
 178
 179   // -
 180
 181   {
 182     FirePreTransactionCallback();
 183
 184     const auto desc = context->GetFrontBuffer(nullptr);
 185     if (desc &&
 186         desc->type() == SurfaceDescriptor::TSurfaceDescriptorRemoteTexture) {
 187       const auto& forwarder = GetForwarder();
 188       const auto& textureDesc = desc->get_SurfaceDescriptorRemoteTexture();
 189       if (!mData.mIsAlphaPremult) {
 190         flags |= TextureFlags::NON_PREMULTIPLIED;
 191       }
 192       EnsurePipeline();
 193       RefPtr<FwdTransactionTracker> tracker =
 194           context->UseCompositableForwarder(forwarder);
 195       if (tracker) {
 196         flags |= TextureFlags::WAIT_FOR_REMOTE_TEXTURE_OWNER;
 197       }
 198       forwarder->UseRemoteTexture(mCanvasClient, textureDesc.textureId(),
 199                                   textureDesc.ownerId(), mData.mSize, flags,
 200                                   tracker);
 201       FireDidTransactionCallback();
 202       return;
 203     }
 204
 205     EnsurePipeline();
 206
 207     // Let's see if we can get a no-copy TextureClient from the canvas.
 208     bool lostFrontTexture = false;
 209     auto tc = fnGetExistingTc(desc, lostFrontTexture);
 210     if (lostFrontTexture) {
 211       // Device reset could cause this.
 212       return;
 213     }
 214     if (!tc) {
 215       // Otherwise, snapshot the surface and copy into a TexClient.
 216       tc = fnMakeTcFromSnapshot();
 217     }
 218     if (tc != mFrontBufferFromDesc) {
 219       mFrontBufferFromDesc = nullptr;
 220     }
 221
 222     if (!tc) {
 223       NS_WARNING("Couldn't make TextureClient for CanvasRenderer.");
 224       return;
 225     }
 226
 227     mCanvasClient->UseTexture(tc);
 228
 229     FireDidTransactionCallback();
 230   }
 231 }
 232
 233 }  // namespace layers
 234 }  // namespace mozilla