Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 275 insertions, 0 deletions

diff --git a/gfx/layers/D3D9SurfaceImage.cpp b/gfx/layers/D3D9SurfaceImage.cpp
new file mode 100644
index 0000000000..2c8037a03f
--- /dev/null
+++ b/gfx/layers/D3D9SurfaceImage.cpp
@@ -0,0 +1,275 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "D3D9SurfaceImage.h"
+#include "gfx2DGlue.h"
+#include "gfxWindowsPlatform.h"
+#include "mozilla/layers/CompositableClient.h"
+#include "mozilla/layers/CompositableForwarder.h"
+#include "mozilla/layers/ImageBridgeChild.h"
+#include "mozilla/gfx/Types.h"
+#include "mozilla/ProfilerLabels.h"
+
+namespace mozilla {
+namespace layers {
+
+DXGID3D9TextureData::DXGID3D9TextureData(gfx::SurfaceFormat aFormat,
+                                         IDirect3DTexture9* aTexture,
+                                         HANDLE aHandle,
+                                         IDirect3DDevice9* aDevice)
+    : mDevice(aDevice), mTexture(aTexture), mFormat(aFormat), mHandle(aHandle) {
+  MOZ_COUNT_CTOR(DXGID3D9TextureData);
+}
+
+DXGID3D9TextureData::~DXGID3D9TextureData() {
+  gfxWindowsPlatform::sD3D9SharedTextures -= mDesc.Width * mDesc.Height * 4;
+  MOZ_COUNT_DTOR(DXGID3D9TextureData);
+}
+
+// static
+DXGID3D9TextureData* DXGID3D9TextureData::Create(gfx::IntSize aSize,
+                                                 gfx::SurfaceFormat aFormat,
+                                                 TextureFlags aFlags,
+                                                 IDirect3DDevice9* aDevice) {
+  AUTO_PROFILER_LABEL("DXGID3D9TextureData::Create", GRAPHICS);
+  MOZ_ASSERT(aFormat == gfx::SurfaceFormat::B8G8R8A8);
+  if (aFormat != gfx::SurfaceFormat::B8G8R8A8) {
+    return nullptr;
+  }
+
+  RefPtr<IDirect3DTexture9> texture;
+  HANDLE shareHandle = nullptr;
+  HRESULT hr = aDevice->CreateTexture(
+      aSize.width, aSize.height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8,
+      D3DPOOL_DEFAULT, getter_AddRefs(texture), &shareHandle);
+  if (FAILED(hr) || !shareHandle) {
+    return nullptr;
+  }
+
+  D3DSURFACE_DESC surfaceDesc;
+  hr = texture->GetLevelDesc(0, &surfaceDesc);
+  if (FAILED(hr)) {
+    return nullptr;
+  }
+  DXGID3D9TextureData* data =
+      new DXGID3D9TextureData(aFormat, texture, shareHandle, aDevice);
+  data->mDesc = surfaceDesc;
+
+  gfxWindowsPlatform::sD3D9SharedTextures += aSize.width * aSize.height * 4;
+  return data;
+}
+
+void DXGID3D9TextureData::FillInfo(TextureData::Info& aInfo) const {
+  aInfo.size = GetSize();
+  aInfo.format = mFormat;
+  aInfo.supportsMoz2D = false;
+  aInfo.canExposeMappedData = false;
+  aInfo.hasSynchronization = false;
+}
+
+already_AddRefed<IDirect3DSurface9> DXGID3D9TextureData::GetD3D9Surface()
+    const {
+  RefPtr<IDirect3DSurface9> textureSurface;
+  HRESULT hr = mTexture->GetSurfaceLevel(0, getter_AddRefs(textureSurface));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
+
+  return textureSurface.forget();
+}
+
+bool DXGID3D9TextureData::Serialize(SurfaceDescriptor& aOutDescriptor) {
+  SurfaceDescriptorD3D10 desc((WindowsHandle)(mHandle),
+                              /* gpuProcessTextureId */ Nothing(),
+                              /* arrayIndex */ 0, mFormat, GetSize(),
+                              gfx::ColorSpace2::SRGB, gfx::ColorRange::FULL);
+  // In reality, with D3D9 we will only ever deal with RGBA textures.
+  bool isYUV = mFormat == gfx::SurfaceFormat::NV12 ||
+               mFormat == gfx::SurfaceFormat::P010 ||
+               mFormat == gfx::SurfaceFormat::P016;
+  if (isYUV) {
+    gfxCriticalError() << "Unexpected YUV format for DXGID3D9TextureData: "
+                       << mFormat;
+    desc.colorSpace() = gfx::ColorSpace2::BT601_525;
+    desc.colorRange() = gfx::ColorRange::LIMITED;
+  }
+  aOutDescriptor = desc;
+  return true;
+}
+
+D3D9SurfaceImage::D3D9SurfaceImage()
+    : Image(nullptr, ImageFormat::D3D9_RGB32_TEXTURE),
+      mSize(0, 0),
+      mShareHandle(0),
+      mValid(true) {}
+
+D3D9SurfaceImage::~D3D9SurfaceImage() {}
+
+HRESULT
+D3D9SurfaceImage::AllocateAndCopy(D3D9RecycleAllocator* aAllocator,
+                                  IDirect3DSurface9* aSurface,
+                                  const gfx::IntRect& aRegion) {
+  NS_ENSURE_TRUE(aSurface, E_POINTER);
+  HRESULT hr;
+  RefPtr<IDirect3DSurface9> surface = aSurface;
+
+  RefPtr<IDirect3DDevice9> device;
+  hr = surface->GetDevice(getter_AddRefs(device));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), E_FAIL);
+
+  RefPtr<IDirect3D9> d3d9;
+  hr = device->GetDirect3D(getter_AddRefs(d3d9));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), E_FAIL);
+
+  D3DSURFACE_DESC desc;
+  surface->GetDesc(&desc);
+  // Ensure we can convert the textures format to RGB conversion
+  // in StretchRect. Fail if we can't.
+  hr = d3d9->CheckDeviceFormatConversion(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
+                                         desc.Format, D3DFMT_A8R8G8B8);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  // DXVA surfaces aren't created sharable, so we need to copy the surface
+  // to a sharable texture to that it's accessible to the layer manager's
+  // device.
+  if (aAllocator) {
+    mTextureClient = aAllocator->CreateOrRecycleClient(
+        gfx::SurfaceFormat::B8G8R8A8, aRegion.Size());
+    if (!mTextureClient) {
+      return E_FAIL;
+    }
+
+    DXGID3D9TextureData* texData =
+        static_cast<DXGID3D9TextureData*>(mTextureClient->GetInternalData());
+    mTexture = texData->GetD3D9Texture();
+    mShareHandle = texData->GetShareHandle();
+    mDesc = texData->GetDesc();
+  } else {
+    hr = device->CreateTexture(aRegion.Size().width, aRegion.Size().height, 1,
+                               D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8,
+                               D3DPOOL_DEFAULT, getter_AddRefs(mTexture),
+                               &mShareHandle);
+    if (FAILED(hr) || !mShareHandle) {
+      return E_FAIL;
+    }
+
+    hr = mTexture->GetLevelDesc(0, &mDesc);
+    if (FAILED(hr)) {
+      return E_FAIL;
+    }
+  }
+
+  // Copy the image onto the texture, preforming YUV -> RGB conversion if
+  // necessary.
+  RefPtr<IDirect3DSurface9> textureSurface = GetD3D9Surface();
+  if (!textureSurface) {
+    return E_FAIL;
+  }
+
+  RECT src = {aRegion.X(), aRegion.Y(), aRegion.XMost(), aRegion.YMost()};
+  hr =
+      device->StretchRect(surface, &src, textureSurface, nullptr, D3DTEXF_NONE);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
+
+  mSize = aRegion.Size();
+  return S_OK;
+}
+
+already_AddRefed<IDirect3DSurface9> D3D9SurfaceImage::GetD3D9Surface() const {
+  RefPtr<IDirect3DSurface9> textureSurface;
+  HRESULT hr = mTexture->GetSurfaceLevel(0, getter_AddRefs(textureSurface));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
+  return textureSurface.forget();
+}
+
+HANDLE
+D3D9SurfaceImage::GetShareHandle() const { return mShareHandle; }
+
+gfx::IntSize D3D9SurfaceImage::GetSize() const { return mSize; }
+
+TextureClient* D3D9SurfaceImage::GetTextureClient(
+    KnowsCompositor* aKnowsCompositor) {
+  MOZ_ASSERT(mTextureClient);
+  MOZ_ASSERT(mTextureClient->GetAllocator() ==
+             aKnowsCompositor->GetTextureForwarder());
+  return mTextureClient;
+}
+
+already_AddRefed<gfx::SourceSurface> D3D9SurfaceImage::GetAsSourceSurface() {
+  if (!mTexture) {
+    return nullptr;
+  }
+
+  HRESULT hr;
+  RefPtr<gfx::DataSourceSurface> surface =
+      gfx::Factory::CreateDataSourceSurface(mSize,
+                                            gfx::SurfaceFormat::B8G8R8X8);
+  if (NS_WARN_IF(!surface)) {
+    return nullptr;
+  }
+
+  // Readback the texture from GPU memory into system memory, so that
+  // we can copy it into the Cairo image. This is expensive.
+  RefPtr<IDirect3DSurface9> textureSurface = GetD3D9Surface();
+  if (!textureSurface) {
+    return nullptr;
+  }
+
+  RefPtr<IDirect3DDevice9> device;
+  hr = textureSurface->GetDevice(getter_AddRefs(device));
+  NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
+
+  RefPtr<IDirect3DSurface9> systemMemorySurface;
+  hr = device->CreateOffscreenPlainSurface(
+      mSize.width, mSize.height, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM,
+      getter_AddRefs(systemMemorySurface), 0);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
+
+  hr = device->GetRenderTargetData(textureSurface, systemMemorySurface);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
+
+  D3DLOCKED_RECT rect;
+  hr = systemMemorySurface->LockRect(&rect, nullptr, 0);
+  NS_ENSURE_TRUE(SUCCEEDED(hr), nullptr);
+
+  gfx::DataSourceSurface::MappedSurface mappedSurface;
+  if (!surface->Map(gfx::DataSourceSurface::WRITE, &mappedSurface)) {
+    systemMemorySurface->UnlockRect();
+    return nullptr;
+  }
+
+  const unsigned char* src = (const unsigned char*)(rect.pBits);
+  const unsigned srcPitch = rect.Pitch;
+  for (int y = 0; y < mSize.height; y++) {
+    memcpy(mappedSurface.mData + mappedSurface.mStride * y,
+           (unsigned char*)(src) + srcPitch * y, mSize.width * 4);
+  }
+
+  systemMemorySurface->UnlockRect();
+  surface->Unmap();
+
+  return surface.forget();
+}
+
+already_AddRefed<TextureClient> D3D9RecycleAllocator::Allocate(
+    gfx::SurfaceFormat aFormat, gfx::IntSize aSize, BackendSelector aSelector,
+    TextureFlags aTextureFlags, TextureAllocationFlags aAllocFlags) {
+  TextureData* data =
+      DXGID3D9TextureData::Create(aSize, aFormat, aTextureFlags, mDevice);
+  if (!data) {
+    return nullptr;
+  }
+
+  return MakeAndAddRef<TextureClient>(data, aTextureFlags,
+                                      mKnowsCompositor->GetTextureForwarder());
+}
+
+already_AddRefed<TextureClient> D3D9RecycleAllocator::CreateOrRecycleClient(
+    gfx::SurfaceFormat aFormat, const gfx::IntSize& aSize) {
+  return CreateOrRecycle(aFormat, aSize, BackendSelector::Content,
+                         TextureFlags::DEFAULT);
+}
+
+}  // namespace layers
+}  // namespace mozilla