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     return;
  92   }
  93   ResetDirty();
  94
  95   const auto context = mData.GetContext();
  96   if (!context) return;
  97   const auto& provider = context->GetBufferProvider();
  98   const auto& forwarder = GetForwarder();
  99
 100   // -
 101
 102   auto flags = TextureFlags::IMMUTABLE;
 103   if (!YIsDown()) {
 104     flags |= TextureFlags::ORIGIN_BOTTOM_LEFT;
 105   }
 106   if (IsOpaque()) {
 107     flags |= TextureFlags::IS_OPAQUE;
 108   }
 109
 110   // With remote texture push callback, a new pushed remote texture is notifiled
 111   // from RemoteTextureMap to WebRenderImageHost.
 112   if (mData.mRemoteTextureOwnerIdOfPushCallback) {
 113     GetForwarder()->EnableRemoteTexturePushCallback(
 114         mCanvasClient, *mData.mRemoteTextureOwnerIdOfPushCallback, mData.mSize,
 115         flags);
 116     EnsurePipeline();
 117     return;
 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       forwarder->UseRemoteTexture(mCanvasClient, textureDesc.textureId(),
 194                                   textureDesc.ownerId(), mData.mSize, flags);
 195
 196       FireDidTransactionCallback();
 197       return;
 198     }
 199
 200     EnsurePipeline();
 201
 202     // Let's see if we can get a no-copy TextureClient from the canvas.
 203     bool lostFrontTexture = false;
 204     auto tc = fnGetExistingTc(desc, lostFrontTexture);
 205     if (lostFrontTexture) {
 206       // Device reset could cause this.
 207       return;
 208     }
 209     if (!tc) {
 210       // Otherwise, snapshot the surface and copy into a TexClient.
 211       tc = fnMakeTcFromSnapshot();
 212     }
 213     if (tc != mFrontBufferFromDesc) {
 214       mFrontBufferFromDesc = nullptr;
 215     }
 216
 217     if (!tc) {
 218       NS_WARNING("Couldn't make TextureClient for CanvasRenderer.");
 219       return;
 220     }
 221
 222     mCanvasClient->UseTexture(tc);
 223
 224     FireDidTransactionCallback();
 225   }
 226 }
 227
 228 }  // namespace layers
 229 }  // namespace mozilla