зеркало из https://github.com/mozilla/gecko-dev.git
238 строки
7.8 KiB
C++
238 строки
7.8 KiB
C++
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
* 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 "SharedPlanarYCbCrImage.h"
|
|
#include <stddef.h> // for size_t
|
|
#include <stdio.h> // for printf
|
|
#include "gfx2DGlue.h" // for Moz2D transition helpers
|
|
#include "ISurfaceAllocator.h" // for ISurfaceAllocator, etc
|
|
#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc
|
|
#include "mozilla/gfx/Types.h" // for SurfaceFormat::SurfaceFormat::YUV
|
|
#include "mozilla/ipc/SharedMemory.h" // for SharedMemory, etc
|
|
#include "mozilla/layers/ImageClient.h" // for ImageClient
|
|
#include "mozilla/layers/LayersSurfaces.h" // for SurfaceDescriptor, etc
|
|
#include "mozilla/layers/TextureClient.h"
|
|
#include "mozilla/layers/TextureClientRecycleAllocator.h"
|
|
#include "mozilla/layers/BufferTexture.h"
|
|
#include "mozilla/layers/ImageDataSerializer.h"
|
|
#include "mozilla/layers/ImageBridgeChild.h" // for ImageBridgeChild
|
|
#include "mozilla/mozalloc.h" // for operator delete
|
|
#include "nsISupportsImpl.h" // for Image::AddRef
|
|
#include "mozilla/ipc/Shmem.h"
|
|
|
|
namespace mozilla {
|
|
namespace layers {
|
|
|
|
using namespace mozilla::ipc;
|
|
|
|
SharedPlanarYCbCrImage::SharedPlanarYCbCrImage(ImageClient* aCompositable)
|
|
: mCompositable(aCompositable)
|
|
{
|
|
MOZ_COUNT_CTOR(SharedPlanarYCbCrImage);
|
|
}
|
|
|
|
SharedPlanarYCbCrImage::~SharedPlanarYCbCrImage() {
|
|
MOZ_COUNT_DTOR(SharedPlanarYCbCrImage);
|
|
}
|
|
|
|
size_t
|
|
SharedPlanarYCbCrImage::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
|
|
{
|
|
// NB: Explicitly skipping mTextureClient, the memory is already reported
|
|
// at time of allocation in GfxMemoryImageReporter.
|
|
// Not owned:
|
|
// - mCompositable
|
|
return 0;
|
|
}
|
|
|
|
TextureClient*
|
|
SharedPlanarYCbCrImage::GetTextureClient(KnowsCompositor* aForwarder)
|
|
{
|
|
return mTextureClient.get();
|
|
}
|
|
|
|
uint8_t*
|
|
SharedPlanarYCbCrImage::GetBuffer()
|
|
{
|
|
// This should never be used
|
|
MOZ_ASSERT(false);
|
|
return nullptr;
|
|
}
|
|
|
|
already_AddRefed<gfx::SourceSurface>
|
|
SharedPlanarYCbCrImage::GetAsSourceSurface()
|
|
{
|
|
if (!IsValid()) {
|
|
NS_WARNING("Can't get as surface");
|
|
return nullptr;
|
|
}
|
|
return PlanarYCbCrImage::GetAsSourceSurface();
|
|
}
|
|
|
|
bool
|
|
SharedPlanarYCbCrImage::CopyData(const PlanarYCbCrData& aData)
|
|
{
|
|
// If mTextureClient has not already been allocated (through Allocate(aData))
|
|
// allocate it. This code path is slower than the one used when Allocate has
|
|
// been called since it will trigger a full copy.
|
|
PlanarYCbCrData data = aData;
|
|
if (!mTextureClient && !Allocate(data)) {
|
|
return false;
|
|
}
|
|
|
|
TextureClientAutoLock autoLock(mTextureClient, OpenMode::OPEN_WRITE_ONLY);
|
|
if (!autoLock.Succeeded()) {
|
|
MOZ_ASSERT(false, "Failed to lock the texture.");
|
|
return false;
|
|
}
|
|
|
|
if (!UpdateYCbCrTextureClient(mTextureClient, aData)) {
|
|
MOZ_ASSERT(false, "Failed to copy YCbCr data into the TextureClient");
|
|
return false;
|
|
}
|
|
mTextureClient->MarkImmutable();
|
|
return true;
|
|
}
|
|
|
|
// needs to be overriden because the parent class sets mBuffer which we
|
|
// do not want to happen.
|
|
uint8_t*
|
|
SharedPlanarYCbCrImage::AllocateAndGetNewBuffer(uint32_t aSize)
|
|
{
|
|
MOZ_ASSERT(!mTextureClient, "This image already has allocated data");
|
|
size_t size = ImageDataSerializer::ComputeYCbCrBufferSize(aSize);
|
|
if (!size) {
|
|
return nullptr;
|
|
}
|
|
|
|
// XXX Add YUVColorSpace handling. Use YUVColorSpace::BT601 for now.
|
|
mTextureClient = TextureClient::CreateForYCbCrWithBufferSize(mCompositable->GetForwarder(),
|
|
size,
|
|
YUVColorSpace::BT601,
|
|
mCompositable->GetTextureFlags());
|
|
|
|
// get new buffer _without_ setting mBuffer.
|
|
if (!mTextureClient) {
|
|
return nullptr;
|
|
}
|
|
|
|
// update buffer size
|
|
mBufferSize = size;
|
|
|
|
MappedYCbCrTextureData mapped;
|
|
if (mTextureClient->BorrowMappedYCbCrData(mapped)) {
|
|
// The caller expects a pointer to the beginning of the writable part of the
|
|
// buffer which is where the y channel starts by default.
|
|
return mapped.y.data;
|
|
} else {
|
|
MOZ_CRASH("GFX: Cannot borrow mapped YCbCr data");
|
|
}
|
|
}
|
|
|
|
bool
|
|
SharedPlanarYCbCrImage::AdoptData(const Data &aData)
|
|
{
|
|
// AdoptData is used to update YUV plane offsets without (re)allocating
|
|
// memory previously allocated with AllocateAndGetNewBuffer().
|
|
|
|
MOZ_ASSERT(mTextureClient, "This Image should have already allocated data");
|
|
if (!mTextureClient) {
|
|
return false;
|
|
}
|
|
mData = aData;
|
|
mSize = aData.mPicSize;
|
|
mOrigin = gfx::IntPoint(aData.mPicX, aData.mPicY);
|
|
|
|
uint8_t *base = GetBuffer();
|
|
uint32_t yOffset = aData.mYChannel - base;
|
|
uint32_t cbOffset = aData.mCbChannel - base;
|
|
uint32_t crOffset = aData.mCrChannel - base;
|
|
|
|
auto fwd = mCompositable->GetForwarder();
|
|
bool hasIntermediateBuffer = ComputeHasIntermediateBuffer(gfx::SurfaceFormat::YUV,
|
|
fwd->GetCompositorBackendType());
|
|
|
|
static_cast<BufferTextureData*>(mTextureClient->GetInternalData())->SetDesciptor(
|
|
YCbCrDescriptor(aData.mYSize, aData.mCbCrSize, yOffset, cbOffset, crOffset,
|
|
aData.mStereoMode, aData.mYUVColorSpace, hasIntermediateBuffer)
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SharedPlanarYCbCrImage::IsValid() {
|
|
return mTextureClient && mTextureClient->IsValid();
|
|
}
|
|
|
|
bool
|
|
SharedPlanarYCbCrImage::Allocate(PlanarYCbCrData& aData)
|
|
{
|
|
MOZ_ASSERT(!mTextureClient,
|
|
"This image already has allocated data");
|
|
static const uint32_t MAX_POOLED_VIDEO_COUNT = 5;
|
|
|
|
if (!mCompositable->HasTextureClientRecycler()) {
|
|
// Initialize TextureClientRecycler
|
|
mCompositable->GetTextureClientRecycler()->SetMaxPoolSize(MAX_POOLED_VIDEO_COUNT);
|
|
}
|
|
|
|
{
|
|
YCbCrTextureClientAllocationHelper helper(aData, mCompositable->GetTextureFlags());
|
|
mTextureClient = mCompositable->GetTextureClientRecycler()->CreateOrRecycle(helper);
|
|
}
|
|
|
|
if (!mTextureClient) {
|
|
NS_WARNING("SharedPlanarYCbCrImage::Allocate failed.");
|
|
return false;
|
|
}
|
|
|
|
MappedYCbCrTextureData mapped;
|
|
// The locking here is sort of a lie. The SharedPlanarYCbCrImage just pulls
|
|
// pointers out of the TextureClient and keeps them around, which works only
|
|
// because the underlyin BufferTextureData is always mapped in memory even outside
|
|
// of the lock/unlock interval. That's sad and new code should follow this example.
|
|
if (!mTextureClient->Lock(OpenMode::OPEN_READ) || !mTextureClient->BorrowMappedYCbCrData(mapped)) {
|
|
MOZ_CRASH("GFX: Cannot lock or borrow mapped YCbCr");
|
|
}
|
|
|
|
aData.mYChannel = mapped.y.data;
|
|
aData.mCbChannel = mapped.cb.data;
|
|
aData.mCrChannel = mapped.cr.data;
|
|
|
|
// copy some of aData's values in mData (most of them)
|
|
mData.mYChannel = aData.mYChannel;
|
|
mData.mCbChannel = aData.mCbChannel;
|
|
mData.mCrChannel = aData.mCrChannel;
|
|
mData.mYSize = aData.mYSize;
|
|
mData.mCbCrSize = aData.mCbCrSize;
|
|
mData.mPicX = aData.mPicX;
|
|
mData.mPicY = aData.mPicY;
|
|
mData.mPicSize = aData.mPicSize;
|
|
mData.mStereoMode = aData.mStereoMode;
|
|
mData.mYUVColorSpace = aData.mYUVColorSpace;
|
|
// those members are not always equal to aData's, due to potentially different
|
|
// packing.
|
|
mData.mYSkip = 0;
|
|
mData.mCbSkip = 0;
|
|
mData.mCrSkip = 0;
|
|
mData.mYStride = mData.mYSize.width;
|
|
mData.mCbCrStride = mData.mCbCrSize.width;
|
|
|
|
// do not set mBuffer like in PlanarYCbCrImage because the later
|
|
// will try to manage this memory without knowing it belongs to a
|
|
// shmem.
|
|
mBufferSize = ImageDataSerializer::ComputeYCbCrBufferSize(mData.mYSize, mData.mCbCrSize);
|
|
mSize = mData.mPicSize;
|
|
mOrigin = gfx::IntPoint(aData.mPicX, aData.mPicY);
|
|
|
|
mTextureClient->Unlock();
|
|
|
|
return mBufferSize > 0;
|
|
}
|
|
|
|
} // namespace layers
|
|
} // namespace mozilla
|