Adding upstream version 115.7.0esr.upstream/115.7.0esr

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

1 files changed, 245 insertions, 0 deletions

diff --git a/gfx/2d/SourceSurfaceD2D1.cpp b/gfx/2d/SourceSurfaceD2D1.cpp
new file mode 100644
index 0000000000..9aef7ab54e
--- /dev/null
+++ b/gfx/2d/SourceSurfaceD2D1.cpp
@@ -0,0 +1,245 @@
+/* -*- 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 "SourceSurfaceD2D1.h"
+#include "DrawTargetD2D1.h"
+
+namespace mozilla {
+namespace gfx {
+
+SourceSurfaceD2D1::SourceSurfaceD2D1(ID2D1Image* aImage,
+                                     ID2D1DeviceContext* aDC,
+                                     SurfaceFormat aFormat,
+                                     const IntSize& aSize, DrawTargetD2D1* aDT)
+    : mImage(aImage),
+      mDC(aDC),
+      mDevice(Factory::GetD2D1Device()),
+      mFormat(aFormat),
+      mSize(aSize),
+      mDrawTarget(aDT),
+      mOwnsCopy(false) {
+  aImage->QueryInterface((ID2D1Bitmap1**)getter_AddRefs(mRealizedBitmap));
+  if (aDT) {
+    mSnapshotLock = aDT->mSnapshotLock;
+  }
+}
+
+SourceSurfaceD2D1::~SourceSurfaceD2D1() {
+  if (mOwnsCopy) {
+    DrawTargetD2D1::mVRAMUsageSS -=
+        mSize.width * mSize.height * BytesPerPixel(mFormat);
+  }
+}
+
+bool SourceSurfaceD2D1::IsValid() const {
+  return mDevice == Factory::GetD2D1Device();
+}
+
+already_AddRefed<DataSourceSurface> SourceSurfaceD2D1::GetDataSurface() {
+  Maybe<MutexAutoLock> lock;
+  if (mSnapshotLock) {
+    lock.emplace(*mSnapshotLock);
+  }
+
+  if (!EnsureRealizedBitmap()) {
+    gfxCriticalError() << "Failed to realize a bitmap, device "
+                       << hexa(mDevice);
+    return nullptr;
+  }
+
+  HRESULT hr;
+
+  RefPtr<ID2D1Bitmap1> softwareBitmap;
+  D2D1_BITMAP_PROPERTIES1 props;
+  props.dpiX = 96;
+  props.dpiY = 96;
+  props.pixelFormat = D2DPixelFormat(mFormat);
+  props.colorContext = nullptr;
+  props.bitmapOptions =
+      D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_CPU_READ;
+  hr = mDC->CreateBitmap(D2DIntSize(mSize), nullptr, 0, props,
+                         (ID2D1Bitmap1**)getter_AddRefs(softwareBitmap));
+
+  if (FAILED(hr)) {
+    gfxCriticalError() << "Failed to create software bitmap: " << mSize
+                       << " Code: " << hexa(hr);
+    return nullptr;
+  }
+
+  D2D1_POINT_2U point = D2D1::Point2U(0, 0);
+  D2D1_RECT_U rect = D2D1::RectU(0, 0, mSize.width, mSize.height);
+
+  hr = softwareBitmap->CopyFromBitmap(&point, mRealizedBitmap, &rect);
+
+  if (FAILED(hr)) {
+    gfxWarning() << "Failed to readback into software bitmap. Code: "
+                 << hexa(hr);
+    return nullptr;
+  }
+
+  return MakeAndAddRef<DataSourceSurfaceD2D1>(softwareBitmap, mFormat);
+}
+
+bool SourceSurfaceD2D1::EnsureRealizedBitmap() {
+  if (mRealizedBitmap) {
+    return true;
+  }
+
+  // Why aren't we using mDevice here or anywhere else?
+  RefPtr<ID2D1Device> device = Factory::GetD2D1Device();
+  if (!device) {
+    return false;
+  }
+
+  RefPtr<ID2D1DeviceContext> dc;
+  device->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_NONE,
+                              getter_AddRefs(dc));
+
+  D2D1_BITMAP_PROPERTIES1 props;
+  props.dpiX = 96;
+  props.dpiY = 96;
+  props.pixelFormat = D2DPixelFormat(mFormat);
+  props.colorContext = nullptr;
+  props.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET;
+  dc->CreateBitmap(D2DIntSize(mSize), nullptr, 0, props,
+                   (ID2D1Bitmap1**)getter_AddRefs(mRealizedBitmap));
+
+  dc->SetTarget(mRealizedBitmap);
+
+  dc->BeginDraw();
+  dc->DrawImage(mImage);
+  dc->EndDraw();
+
+  return true;
+}
+
+void SourceSurfaceD2D1::DrawTargetWillChange() {
+  MOZ_ASSERT(mSnapshotLock);
+  mSnapshotLock->AssertCurrentThreadOwns();
+
+  // At this point in time this should always be true here.
+  MOZ_ASSERT(mRealizedBitmap);
+
+  RefPtr<ID2D1Bitmap1> oldBitmap = mRealizedBitmap;
+
+  D2D1_BITMAP_PROPERTIES1 props;
+  props.dpiX = 96;
+  props.dpiY = 96;
+  props.pixelFormat = D2DPixelFormat(mFormat);
+  props.colorContext = nullptr;
+  props.bitmapOptions = D2D1_BITMAP_OPTIONS_TARGET;
+  HRESULT hr =
+      mDC->CreateBitmap(D2DIntSize(mSize), nullptr, 0, props,
+                        (ID2D1Bitmap1**)getter_AddRefs(mRealizedBitmap));
+
+  if (FAILED(hr)) {
+    gfxCriticalError()
+        << "Failed to create bitmap to make DrawTarget copy. Size: " << mSize
+        << " Code: " << hexa(hr);
+    MarkIndependent();
+    return;
+  }
+
+  D2D1_POINT_2U point = D2D1::Point2U(0, 0);
+  D2D1_RECT_U rect = D2D1::RectU(0, 0, mSize.width, mSize.height);
+  mRealizedBitmap->CopyFromBitmap(&point, oldBitmap, &rect);
+  mImage = mRealizedBitmap;
+
+  DrawTargetD2D1::mVRAMUsageSS +=
+      mSize.width * mSize.height * BytesPerPixel(mFormat);
+  mOwnsCopy = true;
+
+  // Ensure the object stays alive for the duration of MarkIndependent.
+  RefPtr<SourceSurfaceD2D1> deathGrip = this;
+  // We now no longer depend on the source surface content remaining the same.
+  MarkIndependent();
+}
+
+void SourceSurfaceD2D1::MarkIndependent() {
+  if (mDrawTarget) {
+    MOZ_ASSERT(mDrawTarget->mSnapshot == this);
+    mDrawTarget->mSnapshot = nullptr;
+    mDrawTarget = nullptr;
+  }
+}
+
+DataSourceSurfaceD2D1::DataSourceSurfaceD2D1(ID2D1Bitmap1* aMappableBitmap,
+                                             SurfaceFormat aFormat)
+    : mBitmap(aMappableBitmap),
+      mFormat(aFormat),
+      mIsMapped(false),
+      mImplicitMapped(false) {}
+
+DataSourceSurfaceD2D1::~DataSourceSurfaceD2D1() {
+  if (mImplicitMapped) {
+    mBitmap->Unmap();
+  }
+}
+
+IntSize DataSourceSurfaceD2D1::GetSize() const {
+  D2D1_SIZE_F size = mBitmap->GetSize();
+
+  return IntSize(int32_t(size.width), int32_t(size.height));
+}
+
+uint8_t* DataSourceSurfaceD2D1::GetData() {
+  EnsureMapped();
+
+  return mMap.bits;
+}
+
+bool DataSourceSurfaceD2D1::Map(MapType aMapType,
+                                MappedSurface* aMappedSurface) {
+  // DataSourceSurfaces used with the new Map API should not be used with
+  // GetData!!
+  MOZ_ASSERT(!mImplicitMapped);
+  MOZ_ASSERT(!mIsMapped);
+
+  if (aMapType != MapType::READ) {
+    gfxWarning() << "Attempt to map D2D1 DrawTarget for writing.";
+    return false;
+  }
+
+  D2D1_MAPPED_RECT map;
+  if (FAILED(mBitmap->Map(D2D1_MAP_OPTIONS_READ, &map))) {
+    gfxCriticalError() << "Failed to map bitmap (M).";
+    return false;
+  }
+  aMappedSurface->mData = map.bits;
+  aMappedSurface->mStride = map.pitch;
+
+  mIsMapped = !!aMappedSurface->mData;
+  return mIsMapped;
+}
+
+void DataSourceSurfaceD2D1::Unmap() {
+  MOZ_ASSERT(mIsMapped);
+
+  mIsMapped = false;
+  mBitmap->Unmap();
+}
+
+int32_t DataSourceSurfaceD2D1::Stride() {
+  EnsureMapped();
+
+  return mMap.pitch;
+}
+
+void DataSourceSurfaceD2D1::EnsureMapped() {
+  // Do not use GetData() after having used Map!
+  MOZ_ASSERT(!mIsMapped);
+  if (mImplicitMapped) {
+    return;
+  }
+  if (FAILED(mBitmap->Map(D2D1_MAP_OPTIONS_READ, &mMap))) {
+    gfxCriticalError() << "Failed to map bitmap (EM).";
+    return;
+  }
+  mImplicitMapped = true;
+}
+
+}  // namespace gfx
+}  // namespace mozilla