diff options
Diffstat (limited to 'gfx/2d/SourceSurfaceD2D1.cpp')
| -rw-r--r-- | gfx/2d/SourceSurfaceD2D1.cpp | 245 |
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 |