mirror of
https://github.com/mozilla/gecko-dev.git
synced 2025-11-12 14:20:14 +02:00
3ae43eb506
YUVColorSpace is inseparable from the bit depth as the matrix coefficients to be calculated need the bit depth information. So let's put the two types together. gfx namespace also makes more sense as that's where we find IntRect, IntSize and other. The extent of the changes highlight how much similar data structures are duplicated across the code, to the point it's scary. Differential Revision: https://phabricator.services.mozilla.com/D25347 --HG-- extra : moz-landing-system : lando
553 lines
18 KiB
C++
553 lines
18 KiB
C++
/* -*- 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 "BufferTexture.h"
|
|
#include "libyuv.h"
|
|
#include "mozilla/Move.h"
|
|
#include "mozilla/fallible.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
#include "mozilla/gfx/Logging.h"
|
|
#include "mozilla/layers/CompositableForwarder.h"
|
|
#include "mozilla/layers/ISurfaceAllocator.h"
|
|
#include "mozilla/layers/ImageDataSerializer.h"
|
|
|
|
#ifdef MOZ_WIDGET_GTK
|
|
# include "gfxPlatformGtk.h"
|
|
#endif
|
|
|
|
namespace mozilla {
|
|
namespace layers {
|
|
|
|
class MemoryTextureData : public BufferTextureData {
|
|
public:
|
|
static MemoryTextureData* Create(gfx::IntSize aSize,
|
|
gfx::SurfaceFormat aFormat,
|
|
gfx::BackendType aMoz2DBackend,
|
|
LayersBackend aLayersBackend,
|
|
TextureFlags aFlags,
|
|
TextureAllocationFlags aAllocFlags,
|
|
LayersIPCChannel* aAllocator);
|
|
|
|
virtual TextureData* CreateSimilar(
|
|
LayersIPCChannel* aAllocator, LayersBackend aLayersBackend,
|
|
TextureFlags aFlags = TextureFlags::DEFAULT,
|
|
TextureAllocationFlags aAllocFlags = ALLOC_DEFAULT) const override;
|
|
|
|
virtual bool Serialize(SurfaceDescriptor& aOutDescriptor) override;
|
|
|
|
virtual void Deallocate(LayersIPCChannel*) override;
|
|
|
|
MemoryTextureData(const BufferDescriptor& aDesc,
|
|
gfx::BackendType aMoz2DBackend, uint8_t* aBuffer,
|
|
size_t aBufferSize)
|
|
: BufferTextureData(aDesc, aMoz2DBackend),
|
|
mBuffer(aBuffer),
|
|
mBufferSize(aBufferSize) {
|
|
MOZ_ASSERT(aBuffer);
|
|
MOZ_ASSERT(aBufferSize);
|
|
}
|
|
|
|
virtual uint8_t* GetBuffer() override { return mBuffer; }
|
|
|
|
virtual size_t GetBufferSize() override { return mBufferSize; }
|
|
|
|
protected:
|
|
uint8_t* mBuffer;
|
|
size_t mBufferSize;
|
|
};
|
|
|
|
class ShmemTextureData : public BufferTextureData {
|
|
public:
|
|
static ShmemTextureData* Create(gfx::IntSize aSize,
|
|
gfx::SurfaceFormat aFormat,
|
|
gfx::BackendType aMoz2DBackend,
|
|
LayersBackend aLayersBackend,
|
|
TextureFlags aFlags,
|
|
TextureAllocationFlags aAllocFlags,
|
|
LayersIPCChannel* aAllocator);
|
|
|
|
virtual TextureData* CreateSimilar(
|
|
LayersIPCChannel* aAllocator, LayersBackend aLayersBackend,
|
|
TextureFlags aFlags = TextureFlags::DEFAULT,
|
|
TextureAllocationFlags aAllocFlags = ALLOC_DEFAULT) const override;
|
|
|
|
virtual bool Serialize(SurfaceDescriptor& aOutDescriptor) override;
|
|
|
|
virtual void Deallocate(LayersIPCChannel* aAllocator) override;
|
|
|
|
ShmemTextureData(const BufferDescriptor& aDesc,
|
|
gfx::BackendType aMoz2DBackend, mozilla::ipc::Shmem aShmem)
|
|
: BufferTextureData(aDesc, aMoz2DBackend), mShmem(aShmem) {
|
|
MOZ_ASSERT(mShmem.Size<uint8_t>());
|
|
}
|
|
|
|
virtual uint8_t* GetBuffer() override { return mShmem.get<uint8_t>(); }
|
|
|
|
virtual size_t GetBufferSize() override { return mShmem.Size<uint8_t>(); }
|
|
|
|
protected:
|
|
mozilla::ipc::Shmem mShmem;
|
|
};
|
|
|
|
static bool UsingX11Compositor() {
|
|
#ifdef MOZ_WIDGET_GTK
|
|
return gfx::gfxVars::UseXRender();
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
bool ComputeHasIntermediateBuffer(gfx::SurfaceFormat aFormat,
|
|
LayersBackend aLayersBackend,
|
|
bool aSupportsTextureDirectMapping) {
|
|
if (aSupportsTextureDirectMapping) {
|
|
return false;
|
|
}
|
|
|
|
return aLayersBackend != LayersBackend::LAYERS_BASIC ||
|
|
UsingX11Compositor() || aFormat == gfx::SurfaceFormat::UNKNOWN;
|
|
}
|
|
|
|
BufferTextureData* BufferTextureData::Create(gfx::IntSize aSize,
|
|
gfx::SurfaceFormat aFormat,
|
|
gfx::BackendType aMoz2DBackend,
|
|
LayersBackend aLayersBackend,
|
|
TextureFlags aFlags,
|
|
TextureAllocationFlags aAllocFlags,
|
|
LayersIPCChannel* aAllocator) {
|
|
if (!aAllocator || aAllocator->IsSameProcess()) {
|
|
return MemoryTextureData::Create(aSize, aFormat, aMoz2DBackend,
|
|
aLayersBackend, aFlags, aAllocFlags,
|
|
aAllocator);
|
|
} else {
|
|
return ShmemTextureData::Create(aSize, aFormat, aMoz2DBackend,
|
|
aLayersBackend, aFlags, aAllocFlags,
|
|
aAllocator);
|
|
}
|
|
}
|
|
|
|
BufferTextureData* BufferTextureData::CreateInternal(
|
|
LayersIPCChannel* aAllocator, const BufferDescriptor& aDesc,
|
|
gfx::BackendType aMoz2DBackend, int32_t aBufferSize,
|
|
TextureFlags aTextureFlags) {
|
|
if (!aAllocator || aAllocator->IsSameProcess()) {
|
|
uint8_t* buffer = new (fallible) uint8_t[aBufferSize];
|
|
if (!buffer) {
|
|
return nullptr;
|
|
}
|
|
|
|
GfxMemoryImageReporter::DidAlloc(buffer);
|
|
|
|
return new MemoryTextureData(aDesc, aMoz2DBackend, buffer, aBufferSize);
|
|
} else {
|
|
ipc::Shmem shm;
|
|
if (!aAllocator->AllocUnsafeShmem(aBufferSize, OptimalShmemType(), &shm)) {
|
|
return nullptr;
|
|
}
|
|
|
|
return new ShmemTextureData(aDesc, aMoz2DBackend, shm);
|
|
}
|
|
}
|
|
|
|
BufferTextureData* BufferTextureData::CreateForYCbCr(
|
|
KnowsCompositor* aAllocator, gfx::IntSize aYSize, uint32_t aYStride,
|
|
gfx::IntSize aCbCrSize, uint32_t aCbCrStride, StereoMode aStereoMode,
|
|
gfx::ColorDepth aColorDepth, gfx::YUVColorSpace aYUVColorSpace,
|
|
TextureFlags aTextureFlags) {
|
|
uint32_t bufSize = ImageDataSerializer::ComputeYCbCrBufferSize(
|
|
aYSize, aYStride, aCbCrSize, aCbCrStride);
|
|
if (bufSize == 0) {
|
|
return nullptr;
|
|
}
|
|
|
|
uint32_t yOffset;
|
|
uint32_t cbOffset;
|
|
uint32_t crOffset;
|
|
ImageDataSerializer::ComputeYCbCrOffsets(aYStride, aYSize.height, aCbCrStride,
|
|
aCbCrSize.height, yOffset, cbOffset,
|
|
crOffset);
|
|
|
|
bool supportsTextureDirectMapping =
|
|
aAllocator->SupportsTextureDirectMapping() &&
|
|
aAllocator->GetMaxTextureSize() >
|
|
std::max(aYSize.width,
|
|
std::max(aYSize.height,
|
|
std::max(aCbCrSize.width, aCbCrSize.height)));
|
|
|
|
bool hasIntermediateBuffer =
|
|
aAllocator
|
|
? ComputeHasIntermediateBuffer(gfx::SurfaceFormat::YUV,
|
|
aAllocator->GetCompositorBackendType(),
|
|
supportsTextureDirectMapping)
|
|
: true;
|
|
|
|
YCbCrDescriptor descriptor = YCbCrDescriptor(
|
|
aYSize, aYStride, aCbCrSize, aCbCrStride, yOffset, cbOffset, crOffset,
|
|
aStereoMode, aColorDepth, aYUVColorSpace, hasIntermediateBuffer);
|
|
|
|
return CreateInternal(
|
|
aAllocator ? aAllocator->GetTextureForwarder() : nullptr, descriptor,
|
|
gfx::BackendType::NONE, bufSize, aTextureFlags);
|
|
}
|
|
|
|
void BufferTextureData::FillInfo(TextureData::Info& aInfo) const {
|
|
aInfo.size = GetSize();
|
|
aInfo.format = GetFormat();
|
|
aInfo.hasSynchronization = false;
|
|
aInfo.canExposeMappedData = true;
|
|
|
|
if (mDescriptor.type() == BufferDescriptor::TYCbCrDescriptor) {
|
|
aInfo.hasIntermediateBuffer =
|
|
mDescriptor.get_YCbCrDescriptor().hasIntermediateBuffer();
|
|
} else {
|
|
aInfo.hasIntermediateBuffer =
|
|
mDescriptor.get_RGBDescriptor().hasIntermediateBuffer();
|
|
}
|
|
|
|
switch (aInfo.format) {
|
|
case gfx::SurfaceFormat::YUV:
|
|
case gfx::SurfaceFormat::UNKNOWN:
|
|
aInfo.supportsMoz2D = false;
|
|
break;
|
|
default:
|
|
aInfo.supportsMoz2D = true;
|
|
}
|
|
}
|
|
|
|
gfx::IntSize BufferTextureData::GetSize() const {
|
|
return ImageDataSerializer::SizeFromBufferDescriptor(mDescriptor);
|
|
}
|
|
|
|
Maybe<gfx::IntSize> BufferTextureData::GetCbCrSize() const {
|
|
return ImageDataSerializer::CbCrSizeFromBufferDescriptor(mDescriptor);
|
|
}
|
|
|
|
Maybe<gfx::YUVColorSpace> BufferTextureData::GetYUVColorSpace() const {
|
|
return ImageDataSerializer::YUVColorSpaceFromBufferDescriptor(mDescriptor);
|
|
}
|
|
|
|
Maybe<gfx::ColorDepth> BufferTextureData::GetColorDepth() const {
|
|
return ImageDataSerializer::ColorDepthFromBufferDescriptor(mDescriptor);
|
|
}
|
|
|
|
Maybe<StereoMode> BufferTextureData::GetStereoMode() const {
|
|
return ImageDataSerializer::StereoModeFromBufferDescriptor(mDescriptor);
|
|
}
|
|
|
|
gfx::SurfaceFormat BufferTextureData::GetFormat() const {
|
|
return ImageDataSerializer::FormatFromBufferDescriptor(mDescriptor);
|
|
}
|
|
|
|
already_AddRefed<gfx::DrawTarget> BufferTextureData::BorrowDrawTarget() {
|
|
if (mDescriptor.type() != BufferDescriptor::TRGBDescriptor) {
|
|
return nullptr;
|
|
}
|
|
|
|
const RGBDescriptor& rgb = mDescriptor.get_RGBDescriptor();
|
|
|
|
uint32_t stride = ImageDataSerializer::GetRGBStride(rgb);
|
|
RefPtr<gfx::DrawTarget> dt;
|
|
if (gfx::Factory::DoesBackendSupportDataDrawtarget(mMoz2DBackend)) {
|
|
dt = gfx::Factory::CreateDrawTargetForData(
|
|
mMoz2DBackend, GetBuffer(), rgb.size(), stride, rgb.format(), true);
|
|
}
|
|
if (!dt) {
|
|
// Fall back to supported platform backend. Note that mMoz2DBackend
|
|
// does not match the draw target type.
|
|
dt = gfxPlatform::CreateDrawTargetForData(GetBuffer(), rgb.size(), stride,
|
|
rgb.format(), true);
|
|
}
|
|
|
|
if (!dt) {
|
|
gfxCriticalNote << "BorrowDrawTarget failure, original backend "
|
|
<< (int)mMoz2DBackend;
|
|
}
|
|
|
|
return dt.forget();
|
|
}
|
|
|
|
bool BufferTextureData::BorrowMappedData(MappedTextureData& aData) {
|
|
if (GetFormat() == gfx::SurfaceFormat::YUV) {
|
|
return false;
|
|
}
|
|
|
|
gfx::IntSize size = GetSize();
|
|
|
|
aData.data = GetBuffer();
|
|
aData.size = size;
|
|
aData.format = GetFormat();
|
|
aData.stride =
|
|
ImageDataSerializer::ComputeRGBStride(aData.format, size.width);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BufferTextureData::BorrowMappedYCbCrData(MappedYCbCrTextureData& aMap) {
|
|
if (mDescriptor.type() != BufferDescriptor::TYCbCrDescriptor) {
|
|
return false;
|
|
}
|
|
|
|
const YCbCrDescriptor& desc = mDescriptor.get_YCbCrDescriptor();
|
|
|
|
uint8_t* data = GetBuffer();
|
|
auto ySize = desc.ySize();
|
|
auto cbCrSize = desc.cbCrSize();
|
|
|
|
aMap.stereoMode = desc.stereoMode();
|
|
aMap.metadata = nullptr;
|
|
uint32_t bytesPerPixel =
|
|
BytesPerPixel(SurfaceFormatForColorDepth(desc.colorDepth()));
|
|
|
|
aMap.y.data = data + desc.yOffset();
|
|
aMap.y.size = ySize;
|
|
aMap.y.stride = desc.yStride();
|
|
aMap.y.skip = 0;
|
|
aMap.y.bytesPerPixel = bytesPerPixel;
|
|
|
|
aMap.cb.data = data + desc.cbOffset();
|
|
aMap.cb.size = cbCrSize;
|
|
aMap.cb.stride = desc.cbCrStride();
|
|
aMap.cb.skip = 0;
|
|
aMap.cb.bytesPerPixel = bytesPerPixel;
|
|
|
|
aMap.cr.data = data + desc.crOffset();
|
|
aMap.cr.size = cbCrSize;
|
|
aMap.cr.stride = desc.cbCrStride();
|
|
aMap.cr.skip = 0;
|
|
aMap.cr.bytesPerPixel = bytesPerPixel;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BufferTextureData::UpdateFromSurface(gfx::SourceSurface* aSurface) {
|
|
if (mDescriptor.type() != BufferDescriptor::TRGBDescriptor) {
|
|
return false;
|
|
}
|
|
const RGBDescriptor& rgb = mDescriptor.get_RGBDescriptor();
|
|
|
|
uint32_t stride = ImageDataSerializer::GetRGBStride(rgb);
|
|
RefPtr<gfx::DataSourceSurface> surface =
|
|
gfx::Factory::CreateWrappingDataSourceSurface(GetBuffer(), stride,
|
|
rgb.size(), rgb.format());
|
|
|
|
if (!surface) {
|
|
gfxCriticalError() << "Failed to get serializer as surface!";
|
|
return false;
|
|
}
|
|
|
|
RefPtr<gfx::DataSourceSurface> srcSurf = aSurface->GetDataSurface();
|
|
|
|
if (!srcSurf) {
|
|
gfxCriticalError() << "Failed to GetDataSurface in UpdateFromSurface (BT).";
|
|
return false;
|
|
}
|
|
|
|
if (surface->GetSize() != srcSurf->GetSize() ||
|
|
surface->GetFormat() != srcSurf->GetFormat()) {
|
|
gfxCriticalError() << "Attempt to update texture client from a surface "
|
|
"with a different size or format (BT)! This: "
|
|
<< surface->GetSize() << " " << surface->GetFormat()
|
|
<< " Other: " << aSurface->GetSize() << " "
|
|
<< aSurface->GetFormat();
|
|
return false;
|
|
}
|
|
|
|
gfx::DataSourceSurface::MappedSurface sourceMap;
|
|
gfx::DataSourceSurface::MappedSurface destMap;
|
|
if (!srcSurf->Map(gfx::DataSourceSurface::READ, &sourceMap)) {
|
|
gfxCriticalError()
|
|
<< "Failed to map source surface for UpdateFromSurface (BT).";
|
|
return false;
|
|
}
|
|
|
|
if (!surface->Map(gfx::DataSourceSurface::WRITE, &destMap)) {
|
|
srcSurf->Unmap();
|
|
gfxCriticalError()
|
|
<< "Failed to map destination surface for UpdateFromSurface.";
|
|
return false;
|
|
}
|
|
|
|
for (int y = 0; y < srcSurf->GetSize().height; y++) {
|
|
memcpy(destMap.mData + destMap.mStride * y,
|
|
sourceMap.mData + sourceMap.mStride * y,
|
|
srcSurf->GetSize().width * BytesPerPixel(srcSurf->GetFormat()));
|
|
}
|
|
|
|
srcSurf->Unmap();
|
|
surface->Unmap();
|
|
|
|
return true;
|
|
}
|
|
|
|
void BufferTextureData::SetDescriptor(BufferDescriptor&& aDescriptor) {
|
|
MOZ_ASSERT(mDescriptor.type() == BufferDescriptor::TYCbCrDescriptor);
|
|
MOZ_ASSERT(mDescriptor.get_YCbCrDescriptor().ySize() == gfx::IntSize());
|
|
mDescriptor = std::move(aDescriptor);
|
|
}
|
|
|
|
bool MemoryTextureData::Serialize(SurfaceDescriptor& aOutDescriptor) {
|
|
MOZ_ASSERT(GetFormat() != gfx::SurfaceFormat::UNKNOWN);
|
|
if (GetFormat() == gfx::SurfaceFormat::UNKNOWN) {
|
|
return false;
|
|
}
|
|
|
|
uintptr_t ptr = reinterpret_cast<uintptr_t>(mBuffer);
|
|
aOutDescriptor = SurfaceDescriptorBuffer(mDescriptor, MemoryOrShmem(ptr));
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool InitBuffer(uint8_t* buf, size_t bufSize, gfx::SurfaceFormat aFormat,
|
|
TextureAllocationFlags aAllocFlags, bool aAlreadyZero) {
|
|
if (!buf) {
|
|
gfxDebug() << "BufferTextureData: Failed to allocate " << bufSize
|
|
<< " bytes";
|
|
return false;
|
|
}
|
|
|
|
if ((aAllocFlags & ALLOC_CLEAR_BUFFER) ||
|
|
(aAllocFlags & ALLOC_CLEAR_BUFFER_BLACK)) {
|
|
if (aFormat == gfx::SurfaceFormat::B8G8R8X8) {
|
|
// Even though BGRX was requested, XRGB_UINT32 is what is meant,
|
|
// so use 0xFF000000 to put alpha in the right place.
|
|
libyuv::ARGBRect(buf, bufSize, 0, 0, bufSize / sizeof(uint32_t), 1,
|
|
0xFF000000);
|
|
} else if (!aAlreadyZero) {
|
|
memset(buf, 0, bufSize);
|
|
}
|
|
}
|
|
|
|
if (aAllocFlags & ALLOC_CLEAR_BUFFER_WHITE) {
|
|
memset(buf, 0xFF, bufSize);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
MemoryTextureData* MemoryTextureData::Create(gfx::IntSize aSize,
|
|
gfx::SurfaceFormat aFormat,
|
|
gfx::BackendType aMoz2DBackend,
|
|
LayersBackend aLayersBackend,
|
|
TextureFlags aFlags,
|
|
TextureAllocationFlags aAllocFlags,
|
|
LayersIPCChannel* aAllocator) {
|
|
// Should have used CreateForYCbCr.
|
|
MOZ_ASSERT(aFormat != gfx::SurfaceFormat::YUV);
|
|
|
|
if (aSize.width <= 0 || aSize.height <= 0) {
|
|
gfxDebug() << "Asking for buffer of invalid size " << aSize.width << "x"
|
|
<< aSize.height;
|
|
return nullptr;
|
|
}
|
|
|
|
uint32_t bufSize = ImageDataSerializer::ComputeRGBBufferSize(aSize, aFormat);
|
|
if (!bufSize) {
|
|
return nullptr;
|
|
}
|
|
|
|
uint8_t* buf = new (fallible) uint8_t[bufSize];
|
|
if (!InitBuffer(buf, bufSize, aFormat, aAllocFlags, false)) {
|
|
return nullptr;
|
|
}
|
|
|
|
bool hasIntermediateBuffer = ComputeHasIntermediateBuffer(
|
|
aFormat, aLayersBackend, aAllocFlags & ALLOC_ALLOW_DIRECT_MAPPING);
|
|
|
|
GfxMemoryImageReporter::DidAlloc(buf);
|
|
|
|
BufferDescriptor descriptor =
|
|
RGBDescriptor(aSize, aFormat, hasIntermediateBuffer);
|
|
|
|
return new MemoryTextureData(descriptor, aMoz2DBackend, buf, bufSize);
|
|
}
|
|
|
|
void MemoryTextureData::Deallocate(LayersIPCChannel*) {
|
|
MOZ_ASSERT(mBuffer);
|
|
GfxMemoryImageReporter::WillFree(mBuffer);
|
|
delete[] mBuffer;
|
|
mBuffer = nullptr;
|
|
}
|
|
|
|
TextureData* MemoryTextureData::CreateSimilar(
|
|
LayersIPCChannel* aAllocator, LayersBackend aLayersBackend,
|
|
TextureFlags aFlags, TextureAllocationFlags aAllocFlags) const {
|
|
return MemoryTextureData::Create(GetSize(), GetFormat(), mMoz2DBackend,
|
|
aLayersBackend, aFlags, aAllocFlags,
|
|
aAllocator);
|
|
}
|
|
|
|
bool ShmemTextureData::Serialize(SurfaceDescriptor& aOutDescriptor) {
|
|
MOZ_ASSERT(GetFormat() != gfx::SurfaceFormat::UNKNOWN);
|
|
if (GetFormat() == gfx::SurfaceFormat::UNKNOWN) {
|
|
return false;
|
|
}
|
|
|
|
aOutDescriptor =
|
|
SurfaceDescriptorBuffer(mDescriptor, MemoryOrShmem(std::move(mShmem)));
|
|
|
|
return true;
|
|
}
|
|
|
|
ShmemTextureData* ShmemTextureData::Create(gfx::IntSize aSize,
|
|
gfx::SurfaceFormat aFormat,
|
|
gfx::BackendType aMoz2DBackend,
|
|
LayersBackend aLayersBackend,
|
|
TextureFlags aFlags,
|
|
TextureAllocationFlags aAllocFlags,
|
|
LayersIPCChannel* aAllocator) {
|
|
MOZ_ASSERT(aAllocator);
|
|
// Should have used CreateForYCbCr.
|
|
MOZ_ASSERT(aFormat != gfx::SurfaceFormat::YUV);
|
|
|
|
if (!aAllocator) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (aSize.width <= 0 || aSize.height <= 0) {
|
|
gfxDebug() << "Asking for buffer of invalid size " << aSize.width << "x"
|
|
<< aSize.height;
|
|
return nullptr;
|
|
}
|
|
|
|
uint32_t bufSize = ImageDataSerializer::ComputeRGBBufferSize(aSize, aFormat);
|
|
if (!bufSize) {
|
|
return nullptr;
|
|
}
|
|
|
|
mozilla::ipc::Shmem shm;
|
|
if (!aAllocator->AllocUnsafeShmem(bufSize, OptimalShmemType(), &shm)) {
|
|
return nullptr;
|
|
}
|
|
|
|
uint8_t* buf = shm.get<uint8_t>();
|
|
if (!InitBuffer(buf, bufSize, aFormat, aAllocFlags, true)) {
|
|
return nullptr;
|
|
}
|
|
|
|
bool hasIntermediateBuffer = ComputeHasIntermediateBuffer(
|
|
aFormat, aLayersBackend, aAllocFlags & ALLOC_ALLOW_DIRECT_MAPPING);
|
|
|
|
BufferDescriptor descriptor =
|
|
RGBDescriptor(aSize, aFormat, hasIntermediateBuffer);
|
|
|
|
return new ShmemTextureData(descriptor, aMoz2DBackend, shm);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
TextureData* ShmemTextureData::CreateSimilar(
|
|
LayersIPCChannel* aAllocator, LayersBackend aLayersBackend,
|
|
TextureFlags aFlags, TextureAllocationFlags aAllocFlags) const {
|
|
return ShmemTextureData::Create(GetSize(), GetFormat(), mMoz2DBackend,
|
|
aLayersBackend, aFlags, aAllocFlags,
|
|
aAllocator);
|
|
}
|
|
|
|
void ShmemTextureData::Deallocate(LayersIPCChannel* aAllocator) {
|
|
aAllocator->DeallocShmem(mShmem);
|
|
}
|
|
|
|
} // namespace layers
|
|
} // namespace mozilla
|