gfx/layers/composite/GPUVideoTextureHost.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 "GPUVideoTextureHost.h"
   8
   9 #include "ImageContainer.h"
  10 #include "mozilla/RemoteDecoderManagerParent.h"
  11 #include "mozilla/layers/ImageBridgeParent.h"
  12 #include "mozilla/layers/VideoBridgeParent.h"
  13 #include "mozilla/webrender/RenderTextureHostWrapper.h"
  14 #include "mozilla/webrender/RenderThread.h"
  15
  16 namespace mozilla {
  17 namespace layers {
  18
  19 GPUVideoTextureHost::GPUVideoTextureHost(
  20     const dom::ContentParentId& aContentId, TextureFlags aFlags,
  21     const SurfaceDescriptorGPUVideo& aDescriptor)
  22     : TextureHost(TextureHostType::Unknown, aFlags),
  23       mContentId(aContentId),
  24       mDescriptor(aDescriptor) {
  25   MOZ_COUNT_CTOR(GPUVideoTextureHost);
  26 }
  27
  28 GPUVideoTextureHost::~GPUVideoTextureHost() {
  29   MOZ_COUNT_DTOR(GPUVideoTextureHost);
  30 }
  31
  32 GPUVideoTextureHost* GPUVideoTextureHost::CreateFromDescriptor(
  33     const dom::ContentParentId& aContentId, TextureFlags aFlags,
  34     const SurfaceDescriptorGPUVideo& aDescriptor) {
  35   return new GPUVideoTextureHost(aContentId, aFlags, aDescriptor);
  36 }
  37
  38 TextureHost* GPUVideoTextureHost::EnsureWrappedTextureHost() {
  39   if (mWrappedTextureHost) {
  40     return mWrappedTextureHost;
  41   }
  42
  43   const auto& sd =
  44       static_cast<const SurfaceDescriptorRemoteDecoder&>(mDescriptor);
  45   RefPtr<VideoBridgeParent> parent =
  46       VideoBridgeParent::GetSingleton(sd.source());
  47   if (!parent) {
  48     // The VideoBridge went away. This can happen if the RDD process
  49     // crashes.
  50     return nullptr;
  51   }
  52
  53   mWrappedTextureHost = parent->LookupTextureAsync(mContentId, sd.handle());
  54
  55   if (!mWrappedTextureHost) {
  56     // The TextureHost hasn't been registered yet. This is due to a race
  57     // between the ImageBridge (content) and the VideoBridge (RDD) and the
  58     // ImageBridge won. See bug
  59     // https://bugzilla.mozilla.org/show_bug.cgi?id=1630733#c14 for more
  60     // details.
  61     return nullptr;
  62   }
  63
  64   if (mExternalImageId.isSome()) {
  65     // External image id is allocated by mWrappedTextureHost.
  66     mWrappedTextureHost->EnsureRenderTexture(Nothing());
  67     MOZ_ASSERT(mWrappedTextureHost->mExternalImageId.isSome());
  68     auto wrappedId = mWrappedTextureHost->mExternalImageId.ref();
  69
  70     RefPtr<wr::RenderTextureHost> texture =
  71         new wr::RenderTextureHostWrapper(wrappedId);
  72     wr::RenderThread::Get()->RegisterExternalImage(mExternalImageId.ref(),
  73                                                    texture.forget());
  74   }
  75
  76   return mWrappedTextureHost;
  77 }
  78
  79 bool GPUVideoTextureHost::IsValid() { return !!EnsureWrappedTextureHost(); }
  80
  81 gfx::YUVColorSpace GPUVideoTextureHost::GetYUVColorSpace() const {
  82   MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet");
  83   if (!mWrappedTextureHost) {
  84     return TextureHost::GetYUVColorSpace();
  85   }
  86   return mWrappedTextureHost->GetYUVColorSpace();
  87 }
  88
  89 gfx::ColorDepth GPUVideoTextureHost::GetColorDepth() const {
  90   MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet");
  91   if (!mWrappedTextureHost) {
  92     return TextureHost::GetColorDepth();
  93   }
  94   return mWrappedTextureHost->GetColorDepth();
  95 }
  96
  97 gfx::ColorRange GPUVideoTextureHost::GetColorRange() const {
  98   MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet");
  99   if (!mWrappedTextureHost) {
 100     return TextureHost::GetColorRange();
 101   }
 102   return mWrappedTextureHost->GetColorRange();
 103 }
 104
 105 gfx::IntSize GPUVideoTextureHost::GetSize() const {
 106   MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet");
 107   if (!mWrappedTextureHost) {
 108     return gfx::IntSize();
 109   }
 110   return mWrappedTextureHost->GetSize();
 111 }
 112
 113 gfx::SurfaceFormat GPUVideoTextureHost::GetFormat() const {
 114   MOZ_ASSERT(mWrappedTextureHost, "Image isn't valid yet");
 115   if (!mWrappedTextureHost) {
 116     return gfx::SurfaceFormat::UNKNOWN;
 117   }
 118   return mWrappedTextureHost->GetFormat();
 119 }
 120
 121 void GPUVideoTextureHost::CreateRenderTexture(
 122     const wr::ExternalImageId& aExternalImageId) {
 123   MOZ_ASSERT(mExternalImageId.isSome());
 124
 125   // When mWrappedTextureHost already exist, call CreateRenderTexture() here.
 126   // In other cases, EnsureWrappedTextureHost() handles CreateRenderTexture().
 127
 128   if (mWrappedTextureHost) {
 129     // External image id is allocated by mWrappedTextureHost.
 130     mWrappedTextureHost->EnsureRenderTexture(Nothing());
 131     MOZ_ASSERT(mWrappedTextureHost->mExternalImageId.isSome());
 132     auto wrappedId = mWrappedTextureHost->mExternalImageId.ref();
 133
 134     RefPtr<wr::RenderTextureHost> texture =
 135         new wr::RenderTextureHostWrapper(wrappedId);
 136     wr::RenderThread::Get()->RegisterExternalImage(mExternalImageId.ref(),
 137                                                    texture.forget());
 138     return;
 139   }
 140
 141   EnsureWrappedTextureHost();
 142 }
 143
 144 void GPUVideoTextureHost::MaybeDestroyRenderTexture() {
 145   if (mExternalImageId.isNothing()) {
 146     // RenderTextureHost was not created
 147     return;
 148   }
 149
 150   if (mExternalImageId.isSome() && mWrappedTextureHost) {
 151     // When GPUVideoTextureHost created RenderTextureHost, delete it here.
 152     TextureHost::DestroyRenderTexture(mExternalImageId.ref());
 153   }
 154   mExternalImageId = Nothing();
 155 }
 156
 157 uint32_t GPUVideoTextureHost::NumSubTextures() {
 158   if (!EnsureWrappedTextureHost()) {
 159     return 0;
 160   }
 161   return EnsureWrappedTextureHost()->NumSubTextures();
 162 }
 163
 164 void GPUVideoTextureHost::PushResourceUpdates(
 165     wr::TransactionBuilder& aResources, ResourceUpdateOp aOp,
 166     const Range<wr::ImageKey>& aImageKeys, const wr::ExternalImageId& aExtID) {
 167   MOZ_ASSERT(EnsureWrappedTextureHost(), "Image isn't valid yet");
 168   if (!EnsureWrappedTextureHost()) {
 169     return;
 170   }
 171   EnsureWrappedTextureHost()->PushResourceUpdates(aResources, aOp, aImageKeys,
 172                                                   aExtID);
 173 }
 174
 175 void GPUVideoTextureHost::PushDisplayItems(
 176     wr::DisplayListBuilder& aBuilder, const wr::LayoutRect& aBounds,
 177     const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
 178     const Range<wr::ImageKey>& aImageKeys, PushDisplayItemFlagSet aFlags) {
 179   MOZ_ASSERT(EnsureWrappedTextureHost(), "Image isn't valid yet");
 180   MOZ_ASSERT(aImageKeys.length() > 0);
 181   if (!EnsureWrappedTextureHost()) {
 182     return;
 183   }
 184
 185   EnsureWrappedTextureHost()->PushDisplayItems(aBuilder, aBounds, aClip,
 186                                                aFilter, aImageKeys, aFlags);
 187 }
 188
 189 bool GPUVideoTextureHost::SupportsExternalCompositing(
 190     WebRenderBackend aBackend) {
 191   if (!EnsureWrappedTextureHost()) {
 192     return false;
 193   }
 194   return EnsureWrappedTextureHost()->SupportsExternalCompositing(aBackend);
 195 }
 196
 197 void GPUVideoTextureHost::UnbindTextureSource() {
 198   if (EnsureWrappedTextureHost()) {
 199     EnsureWrappedTextureHost()->UnbindTextureSource();
 200   }
 201   // Handle read unlock
 202   TextureHost::UnbindTextureSource();
 203 }
 204
 205 void GPUVideoTextureHost::NotifyNotUsed() {
 206   if (EnsureWrappedTextureHost()) {
 207     EnsureWrappedTextureHost()->NotifyNotUsed();
 208   }
 209   TextureHost::NotifyNotUsed();
 210 }
 211
 212 BufferTextureHost* GPUVideoTextureHost::AsBufferTextureHost() {
 213   if (EnsureWrappedTextureHost()) {
 214     return EnsureWrappedTextureHost()->AsBufferTextureHost();
 215   }
 216   return nullptr;
 217 }
 218
 219 bool GPUVideoTextureHost::IsWrappingSurfaceTextureHost() {
 220   if (EnsureWrappedTextureHost()) {
 221     return EnsureWrappedTextureHost()->IsWrappingSurfaceTextureHost();
 222   }
 223   return false;
 224 }
 225
 226 TextureHostType GPUVideoTextureHost::GetTextureHostType() {
 227   if (!mWrappedTextureHost) {
 228     return TextureHostType::Unknown;
 229   }
 230   return mWrappedTextureHost->GetTextureHostType();
 231 }
 232
 233 bool GPUVideoTextureHost::NeedsDeferredDeletion() const {
 234   if (!mWrappedTextureHost) {
 235     return TextureHost::NeedsDeferredDeletion();
 236   }
 237   return mWrappedTextureHost->NeedsDeferredDeletion();
 238 }
 239
 240 }  // namespace layers
 241 }  // namespace mozilla