summaryrefslogtreecommitdiffstats
path: root/gfx/layers/TextureDIB.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /gfx/layers/TextureDIB.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'gfx/layers/TextureDIB.cpp')
-rw-r--r--gfx/layers/TextureDIB.cpp505
1 files changed, 505 insertions, 0 deletions
diff --git a/gfx/layers/TextureDIB.cpp b/gfx/layers/TextureDIB.cpp
new file mode 100644
index 000000000..79a9469bf
--- /dev/null
+++ b/gfx/layers/TextureDIB.cpp
@@ -0,0 +1,505 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * 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 "TextureDIB.h"
+#include "gfx2DGlue.h"
+#include "mozilla/gfx/DataSurfaceHelpers.h" // For BufferSizeFromDimensions
+#include "mozilla/layers/ISurfaceAllocator.h"
+#include "mozilla/ipc/ProtocolUtils.h"
+
+namespace mozilla {
+
+using namespace gfx;
+
+namespace layers {
+
+/**
+ * Can only be drawn into through Cairo.
+ * The coresponding TextureHost depends on the compositor
+ */
+class MemoryDIBTextureData : public DIBTextureData
+{
+public:
+ virtual bool Serialize(SurfaceDescriptor& aOutDescriptor) override;
+
+ virtual TextureData*
+ CreateSimilar(LayersIPCChannel* aAllocator,
+ LayersBackend aLayersBackend,
+ TextureFlags aFlags = TextureFlags::DEFAULT,
+ TextureAllocationFlags aAllocFlags = ALLOC_DEFAULT) const override;
+
+ virtual bool UpdateFromSurface(gfx::SourceSurface* aSurface) override;
+
+ static
+ DIBTextureData* Create(gfx::IntSize aSize, gfx::SurfaceFormat aFormat);
+
+ virtual void Deallocate(LayersIPCChannel* aAllocator) override
+ {
+ mSurface = nullptr;
+ }
+
+ MemoryDIBTextureData(gfx::IntSize aSize, gfx::SurfaceFormat aFormat,
+ gfxWindowsSurface* aSurface)
+ : DIBTextureData(aSize, aFormat, aSurface)
+ {
+ MOZ_COUNT_CTOR(MemoryDIBTextureData);
+ }
+
+ virtual ~MemoryDIBTextureData()
+ {
+ MOZ_COUNT_DTOR(MemoryDIBTextureData);
+ }
+};
+
+/**
+ * Can only be drawn into through Cairo.
+ * The coresponding TextureHost depends on the compositor
+ */
+class ShmemDIBTextureData : public DIBTextureData
+{
+public:
+ virtual bool Serialize(SurfaceDescriptor& aOutDescriptor) override;
+
+ virtual TextureData*
+ CreateSimilar(LayersIPCChannel* aAllocator,
+ LayersBackend aLayersBackend,
+ TextureFlags aFlags = TextureFlags::DEFAULT,
+ TextureAllocationFlags aAllocFlags = ALLOC_DEFAULT) const override;
+
+ virtual bool UpdateFromSurface(gfx::SourceSurface* aSurface) override;
+
+ static
+ DIBTextureData* Create(gfx::IntSize aSize, gfx::SurfaceFormat aFormat,
+ LayersIPCChannel* aAllocator);
+
+ void DeallocateData()
+ {
+ if (mSurface) {
+ ::DeleteObject(mBitmap);
+ ::DeleteDC(mDC);
+ ::CloseHandle(mFileMapping);
+ mBitmap = NULL;
+ mDC = NULL;
+ mFileMapping = NULL;
+ mSurface = nullptr;
+ }
+ }
+
+ virtual void Deallocate(LayersIPCChannel* aAllocator) override
+ {
+ DeallocateData();
+ }
+
+ ShmemDIBTextureData(gfx::IntSize aSize, gfx::SurfaceFormat aFormat,
+ gfxWindowsSurface* aSurface,
+ HANDLE aFileMapping, HANDLE aHostHandle,
+ HDC aDC, HBITMAP aBitmap)
+ : DIBTextureData(aSize, aFormat, aSurface)
+ , mFileMapping(aFileMapping)
+ , mHostHandle(aHostHandle)
+ , mDC(aDC)
+ , mBitmap(aBitmap)
+ {
+ MOZ_COUNT_CTOR(ShmemDIBTextureData);
+ }
+
+ virtual ~ShmemDIBTextureData()
+ {
+ MOZ_COUNT_DTOR(ShmemDIBTextureData);
+
+ // The host side has its own references and handles to this data, we can
+ // safely clear ours.
+ DeallocateData();
+ }
+
+ HANDLE mFileMapping;
+ HANDLE mHostHandle;
+ HDC mDC;
+ HBITMAP mBitmap;
+};
+
+void
+DIBTextureData::FillInfo(TextureData::Info& aInfo) const
+{
+ aInfo.size = mSize;
+ aInfo.format = mFormat;
+ aInfo.hasIntermediateBuffer = true;
+ aInfo.hasSynchronization = false;
+ aInfo.supportsMoz2D = true;
+ aInfo.canExposeMappedData = false;
+}
+
+already_AddRefed<gfx::DrawTarget>
+DIBTextureData::BorrowDrawTarget()
+{
+ return gfxPlatform::GetPlatform()->CreateDrawTargetForSurface(mSurface, mSize);
+}
+
+DIBTextureData*
+DIBTextureData::Create(gfx::IntSize aSize, gfx::SurfaceFormat aFormat,
+ LayersIPCChannel* aAllocator)
+{
+ if (!aAllocator) {
+ return nullptr;
+ }
+ if (aFormat == gfx::SurfaceFormat::UNKNOWN) {
+ return nullptr;
+ }
+ if (aAllocator->IsSameProcess()) {
+ return MemoryDIBTextureData::Create(aSize, aFormat);
+ } else {
+ return ShmemDIBTextureData::Create(aSize, aFormat, aAllocator);
+ }
+}
+
+TextureData*
+MemoryDIBTextureData::CreateSimilar(LayersIPCChannel* aAllocator,
+ LayersBackend aLayersBackend,
+ TextureFlags aFlags,
+ TextureAllocationFlags aAllocFlags) const
+{
+ if (!aAllocator) {
+ return nullptr;
+ }
+ return MemoryDIBTextureData::Create(mSize, mFormat);
+}
+
+bool
+MemoryDIBTextureData::Serialize(SurfaceDescriptor& aOutDescriptor)
+{
+ MOZ_ASSERT(mSurface);
+ // The host will release this ref when it receives the surface descriptor.
+ // We AddRef in case we die before the host receives the pointer.
+ aOutDescriptor = SurfaceDescriptorDIB(reinterpret_cast<uintptr_t>(mSurface.get()));
+ mSurface->AddRef();
+ return true;
+}
+
+DIBTextureData*
+MemoryDIBTextureData::Create(gfx::IntSize aSize, gfx::SurfaceFormat aFormat)
+{
+ RefPtr<gfxWindowsSurface> surface
+ = new gfxWindowsSurface(aSize, SurfaceFormatToImageFormat(aFormat));
+ if (!surface || surface->CairoStatus()) {
+ NS_WARNING("Could not create DIB surface");
+ return nullptr;
+ }
+
+ return new MemoryDIBTextureData(aSize, aFormat, surface);
+}
+
+bool
+MemoryDIBTextureData::UpdateFromSurface(gfx::SourceSurface* aSurface)
+{
+ RefPtr<gfxImageSurface> imgSurf = mSurface->GetAsImageSurface();
+
+ RefPtr<DataSourceSurface> srcSurf = aSurface->GetDataSurface();
+
+ if (!srcSurf) {
+ gfxCriticalError() << "Failed to GetDataSurface in UpdateFromSurface (DIB).";
+ return false;
+ }
+
+ DataSourceSurface::MappedSurface sourceMap;
+ if (!srcSurf->Map(gfx::DataSourceSurface::READ, &sourceMap)) {
+ gfxCriticalError() << "Failed to map source surface for UpdateFromSurface.";
+ return false;
+ }
+
+ for (int y = 0; y < srcSurf->GetSize().height; y++) {
+ memcpy(imgSurf->Data() + imgSurf->Stride() * y,
+ sourceMap.mData + sourceMap.mStride * y,
+ srcSurf->GetSize().width * BytesPerPixel(srcSurf->GetFormat()));
+ }
+
+ srcSurf->Unmap();
+ return true;
+}
+
+TextureData*
+ShmemDIBTextureData::CreateSimilar(LayersIPCChannel* aAllocator,
+ LayersBackend aLayersBackend,
+ TextureFlags aFlags,
+ TextureAllocationFlags aAllocFlags) const
+{
+ if (!aAllocator) {
+ return nullptr;
+ }
+ return ShmemDIBTextureData::Create(mSize, mFormat, aAllocator);
+}
+
+bool
+ShmemDIBTextureData::UpdateFromSurface(gfx::SourceSurface* aSurface)
+{
+
+ RefPtr<DataSourceSurface> srcSurf = aSurface->GetDataSurface();
+
+ if (!srcSurf) {
+ gfxCriticalError() << "Failed to GetDataSurface in UpdateFromSurface (DTD).";
+ return false;
+ }
+
+ DataSourceSurface::MappedSurface sourceMap;
+ if (!srcSurf->Map(gfx::DataSourceSurface::READ, &sourceMap)) {
+ gfxCriticalError() << "Failed to map source surface for UpdateFromSurface.";
+ return false;
+ }
+
+ GdiFlush();
+
+ uint32_t stride = mSize.width * BytesPerPixel(mFormat);
+ uint8_t* data = (uint8_t*)::MapViewOfFile(mFileMapping, FILE_MAP_WRITE, 0, 0, stride * mSize.height);
+
+ if (!data) {
+ gfxCriticalError() << "Failed to map view of file for UpdateFromSurface.";
+ srcSurf->Unmap();
+ return false;
+ }
+
+ for (int y = 0; y < srcSurf->GetSize().height; y++) {
+ memcpy(data + stride * y,
+ sourceMap.mData + sourceMap.mStride * y,
+ srcSurf->GetSize().width * BytesPerPixel(srcSurf->GetFormat()));
+ }
+
+ ::UnmapViewOfFile(data);
+
+ srcSurf->Unmap();
+ return true;
+}
+
+bool
+ShmemDIBTextureData::Serialize(SurfaceDescriptor& aOutDescriptor)
+{
+ if (mFormat == gfx::SurfaceFormat::UNKNOWN) {
+ return false;
+ }
+
+ ::GdiFlush();
+ aOutDescriptor = SurfaceDescriptorFileMapping((WindowsHandle)mHostHandle, mFormat, mSize);
+ return true;
+}
+
+DIBTextureData*
+ShmemDIBTextureData::Create(gfx::IntSize aSize, gfx::SurfaceFormat aFormat,
+ LayersIPCChannel* aAllocator)
+{
+ MOZ_ASSERT(aAllocator->GetParentPid() != base::ProcessId());
+
+ DWORD mapSize = aSize.width * aSize.height * BytesPerPixel(aFormat);
+ HANDLE fileMapping = ::CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, mapSize, NULL);
+
+ if (!fileMapping) {
+ gfxCriticalError() << "Failed to create memory file mapping for " << mapSize << " bytes.";
+ return nullptr;
+ }
+
+ BITMAPV4HEADER header;
+ memset(&header, 0, sizeof(BITMAPV4HEADER));
+ header.bV4Size = sizeof(BITMAPV4HEADER);
+ header.bV4Width = aSize.width;
+ header.bV4Height = -LONG(aSize.height); // top-to-buttom DIB
+ header.bV4Planes = 1;
+ header.bV4BitCount = 32;
+ header.bV4V4Compression = BI_BITFIELDS;
+ header.bV4RedMask = 0x00FF0000;
+ header.bV4GreenMask = 0x0000FF00;
+ header.bV4BlueMask = 0x000000FF;
+
+ HDC nulldc = ::GetDC(NULL);
+
+ HDC dc = ::CreateCompatibleDC(nulldc);
+
+ ::ReleaseDC(nullptr, nulldc);
+
+ if (!dc) {
+ ::CloseHandle(fileMapping);
+ gfxCriticalError() << "Failed to create DC for bitmap.";
+ return nullptr;
+ }
+
+ void* bits;
+ HBITMAP bitmap = ::CreateDIBSection(dc, (BITMAPINFO*)&header,
+ DIB_RGB_COLORS, &bits,
+ fileMapping, 0);
+
+ if (!bitmap) {
+ gfxCriticalError() << "Failed to create DIB section for a bitmap of size "
+ << aSize << " and mapSize " << mapSize;
+ ::CloseHandle(fileMapping);
+ ::DeleteDC(dc);
+ return nullptr;
+ }
+
+ ::SelectObject(dc, bitmap);
+
+ RefPtr<gfxWindowsSurface> surface = new gfxWindowsSurface(dc, 0);
+ if (surface->CairoStatus())
+ {
+ ::DeleteObject(bitmap);
+ ::DeleteDC(dc);
+ ::CloseHandle(fileMapping);
+ gfxCriticalError() << "Could not create surface, status: "
+ << surface->CairoStatus();
+ return nullptr;
+ }
+
+ HANDLE hostHandle = NULL;
+
+ if (!ipc::DuplicateHandle(fileMapping, aAllocator->GetParentPid(),
+ &hostHandle, 0, DUPLICATE_SAME_ACCESS)) {
+ gfxCriticalError() << "Failed to duplicate handle to parent process for surface.";
+ ::DeleteObject(bitmap);
+ ::DeleteDC(dc);
+ ::CloseHandle(fileMapping);
+ return nullptr;
+ }
+
+ return new ShmemDIBTextureData(aSize, aFormat, surface,
+ fileMapping, hostHandle,
+ dc, bitmap);
+}
+
+
+bool
+TextureHostDirectUpload::Lock()
+{
+ MOZ_ASSERT(!mIsLocked);
+ mIsLocked = true;
+ return true;
+}
+
+void
+TextureHostDirectUpload::Unlock()
+{
+ MOZ_ASSERT(mIsLocked);
+ mIsLocked = false;
+}
+
+void
+TextureHostDirectUpload::SetCompositor(Compositor* aCompositor)
+{
+ mCompositor = aCompositor;
+}
+
+void
+TextureHostDirectUpload::DeallocateDeviceData()
+{
+ if (mTextureSource) {
+ mTextureSource->DeallocateDeviceData();
+ }
+}
+
+bool
+TextureHostDirectUpload::BindTextureSource(CompositableTextureSourceRef& aTexture)
+{
+ if (!mTextureSource) {
+ Updated();
+ }
+
+ aTexture = mTextureSource;
+ return !!aTexture;
+}
+
+DIBTextureHost::DIBTextureHost(TextureFlags aFlags,
+ const SurfaceDescriptorDIB& aDescriptor)
+ : TextureHostDirectUpload(aFlags, SurfaceFormat::B8G8R8X8, IntSize())
+{
+ // We added an extra ref for transport, so we shouldn't AddRef now.
+ mSurface =
+ dont_AddRef(reinterpret_cast<gfxWindowsSurface*>(aDescriptor.surface()));
+ MOZ_ASSERT(mSurface);
+
+ mSize = mSurface->GetSize();
+ mFormat = mSurface->GetSurfaceFormat();
+}
+
+void
+DIBTextureHost::UpdatedInternal(const nsIntRegion* aRegion)
+{
+ if (!mCompositor) {
+ // This can happen if we send textures to a compositable that isn't yet
+ // attached to a layer.
+ return;
+ }
+
+ if (!mTextureSource) {
+ mTextureSource = mCompositor->CreateDataTextureSource(mFlags);
+ }
+
+ if (mSurface->CairoStatus()) {
+ gfxWarning() << "Bad Cairo surface internal update " << mSurface->CairoStatus();
+ mTextureSource = nullptr;
+ return;
+ }
+ RefPtr<gfxImageSurface> imgSurf = mSurface->GetAsImageSurface();
+
+ RefPtr<DataSourceSurface> surf = Factory::CreateWrappingDataSourceSurface(imgSurf->Data(), imgSurf->Stride(), mSize, mFormat);
+
+ if (!surf || !mTextureSource->Update(surf, const_cast<nsIntRegion*>(aRegion))) {
+ mTextureSource = nullptr;
+ }
+
+ ReadUnlock();
+}
+
+TextureHostFileMapping::TextureHostFileMapping(TextureFlags aFlags,
+ const SurfaceDescriptorFileMapping& aDescriptor)
+ : TextureHostDirectUpload(aFlags, aDescriptor.format(), aDescriptor.size())
+ , mFileMapping((HANDLE)aDescriptor.handle())
+{
+}
+
+TextureHostFileMapping::~TextureHostFileMapping()
+{
+ ::CloseHandle(mFileMapping);
+}
+
+UserDataKey kFileMappingKey;
+
+static void UnmapFileData(void* aData)
+{
+ MOZ_ASSERT(aData);
+ ::UnmapViewOfFile(aData);
+}
+
+void
+TextureHostFileMapping::UpdatedInternal(const nsIntRegion* aRegion)
+{
+ if (!mCompositor) {
+ // This can happen if we send textures to a compositable that isn't yet
+ // attached to a layer.
+ return;
+ }
+
+ if (!mTextureSource) {
+ mTextureSource = mCompositor->CreateDataTextureSource(mFlags);
+ }
+
+ uint8_t* data = nullptr;
+ int32_t totalBytes = BufferSizeFromDimensions(mSize.width, mSize.height, BytesPerPixel(mFormat));
+ if (totalBytes > 0) {
+ data = (uint8_t*)::MapViewOfFile(mFileMapping, FILE_MAP_READ, 0, 0, totalBytes);
+ }
+
+ if (data) {
+ RefPtr<DataSourceSurface> surf = Factory::CreateWrappingDataSourceSurface(data, mSize.width * BytesPerPixel(mFormat), mSize, mFormat);
+ if (surf) {
+ surf->AddUserData(&kFileMappingKey, data, UnmapFileData);
+ if (!mTextureSource->Update(surf, const_cast<nsIntRegion*>(aRegion))) {
+ mTextureSource = nullptr;
+ }
+ } else {
+ mTextureSource = nullptr;
+ }
+ } else {
+ mTextureSource = nullptr;
+ }
+
+ ReadUnlock();
+}
+
+}
+}