mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/gfx/layers/client/ContentClient.cpp

873 строки
31 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 "mozilla/layers/ContentClient.h"
#include "BasicLayers.h" // for BasicLayerManager
#include "gfxContext.h" // for gfxContext, etc
#include "gfxPlatform.h" // for gfxPlatform
#include "gfxEnv.h" // for gfxEnv
#include "gfxPrefs.h" // for gfxPrefs
#include "gfxPoint.h" // for IntSize, gfxPoint
#include "gfxUtils.h" // for gfxUtils
#include "ipc/ShadowLayers.h" // for ShadowLayerForwarder
#include "mozilla/ArrayUtils.h" // for ArrayLength
#include "mozilla/gfx/2D.h" // for DrawTarget, Factory
#include "mozilla/gfx/BasePoint.h" // for BasePoint
#include "mozilla/gfx/BaseSize.h" // for BaseSize
#include "mozilla/gfx/Rect.h" // for Rect
#include "mozilla/gfx/Types.h"
#include "mozilla/layers/CompositorBridgeChild.h" // for CompositorBridgeChild
#include "mozilla/layers/LayerManagerComposite.h"
#include "mozilla/layers/LayersMessages.h" // for ThebesBufferData
#include "mozilla/layers/LayersTypes.h"
#include "mozilla/layers/PaintThread.h"
#include "nsDebug.h" // for NS_ASSERTION, NS_WARNING, etc
#include "nsISupportsImpl.h" // for gfxContext::Release, etc
#include "nsIWidget.h" // for nsIWidget
#include "nsLayoutUtils.h"
#ifdef XP_WIN
# include "gfxWindowsPlatform.h"
#endif
#ifdef MOZ_WIDGET_GTK
# include "gfxPlatformGtk.h"
#endif
#include "ReadbackLayer.h"
#include <utility>
#include <vector>
using namespace std;
namespace mozilla {
using namespace gfx;
namespace layers {
static TextureFlags TextureFlagsForContentClientFlags(uint32_t aBufferFlags) {
TextureFlags result = TextureFlags::NO_FLAGS;
if (aBufferFlags & ContentClient::BUFFER_COMPONENT_ALPHA) {
result |= TextureFlags::COMPONENT_ALPHA;
}
return result;
}
static IntRect ComputeBufferRect(const IntRect& aRequestedRect) {
IntRect rect(aRequestedRect);
// Set a minimum width to guarantee a minimum size of buffers we
// allocate (and work around problems on some platforms with smaller
// dimensions). 64 used to be the magic number needed to work around
// a rendering glitch on b2g (see bug 788411). Now that we don't support
// this device anymore we should be fine with 8 pixels as the minimum.
rect.SetWidth(std::max(aRequestedRect.Width(), 8));
return rect;
}
/* static */ already_AddRefed<ContentClient> ContentClient::CreateContentClient(
CompositableForwarder* aForwarder) {
LayersBackend backend = aForwarder->GetCompositorBackendType();
if (backend != LayersBackend::LAYERS_OPENGL &&
backend != LayersBackend::LAYERS_D3D11 &&
backend != LayersBackend::LAYERS_WR &&
backend != LayersBackend::LAYERS_BASIC) {
return nullptr;
}
bool useDoubleBuffering = false;
#ifdef XP_WIN
if (backend == LayersBackend::LAYERS_D3D11) {
useDoubleBuffering = gfxWindowsPlatform::GetPlatform()->IsDirect2DBackend();
} else
#endif
#ifdef MOZ_WIDGET_GTK
// We can't use double buffering when using image content with
// Xrender support on Linux, as ContentHostDoubleBuffered is not
// suited for direct uploads to the server.
if (!gfxPlatformGtk::GetPlatform()->UseImageOffscreenSurfaces() ||
!gfxVars::UseXRender())
#endif
{
useDoubleBuffering = backend == LayersBackend::LAYERS_BASIC;
}
if (useDoubleBuffering || gfxEnv::ForceDoubleBuffering()) {
return MakeAndAddRef<ContentClientDoubleBuffered>(aForwarder);
}
return MakeAndAddRef<ContentClientSingleBuffered>(aForwarder);
}
void ContentClient::Clear() { mBuffer = nullptr; }
ContentClient::PaintState ContentClient::BeginPaint(PaintedLayer* aLayer,
uint32_t aFlags) {
BufferDecision dest = CalculateBufferForPaint(aLayer, aFlags);
PaintState result;
result.mAsyncPaint = (aFlags & PAINT_ASYNC);
result.mContentType = dest.mBufferContentType;
if (!dest.mCanKeepBufferContents) {
// We're effectively clearing the valid region, so we need to draw
// the entire needed region now.
MOZ_ASSERT(!dest.mCanReuseBuffer);
MOZ_ASSERT(dest.mValidRegion.IsEmpty());
result.mRegionToInvalidate = aLayer->GetValidRegion();
#if defined(MOZ_DUMP_PAINTING)
if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) {
if (result.mContentType != mBuffer->GetContentType()) {
printf_stderr(
"Invalidating entire rotated buffer (layer %p): content type "
"changed\n",
aLayer);
} else if ((dest.mBufferMode == SurfaceMode::SURFACE_COMPONENT_ALPHA) !=
mBuffer->HaveBufferOnWhite()) {
printf_stderr(
"Invalidating entire rotated buffer (layer %p): component alpha "
"changed\n",
aLayer);
}
}
#endif
Clear();
}
result.mRegionToDraw.Sub(dest.mNeededRegion, dest.mValidRegion);
if (result.mRegionToDraw.IsEmpty()) return result;
// We need to disable rotation if we're going to be resampled when
// drawing, because we might sample across the rotation boundary.
// Also disable buffer rotation when using webrender.
bool canHaveRotation =
gfxPlatform::BufferRotationEnabled() &&
!(aFlags & (PAINT_WILL_RESAMPLE | PAINT_NO_ROTATION)) &&
!(aLayer->Manager()->AsWebRenderLayerManager());
bool canDrawRotated = aFlags & PAINT_CAN_DRAW_ROTATED;
OpenMode readMode =
result.mAsyncPaint ? OpenMode::OPEN_READ_ASYNC : OpenMode::OPEN_READ;
OpenMode writeMode = result.mAsyncPaint ? OpenMode::OPEN_READ_WRITE_ASYNC
: OpenMode::OPEN_READ_WRITE;
IntRect drawBounds = result.mRegionToDraw.GetBounds();
if (result.mAsyncPaint) {
result.mAsyncTask.reset(new PaintTask());
}
// Try to acquire the back buffer, copy over contents if we are using a new
// buffer, and rotate or unrotate the buffer as necessary
if (mBuffer && dest.mCanReuseBuffer) {
if (mBuffer->Lock(writeMode)) {
auto newParameters = mBuffer->AdjustedParameters(dest.mBufferRect);
bool needsUnrotate =
(!canHaveRotation && newParameters.IsRotated()) ||
(!canDrawRotated && newParameters.RectWrapsBuffer(drawBounds));
bool canUnrotate =
!result.mAsyncPaint || mBuffer->BufferRotation() == IntPoint(0, 0);
// Only begin a frame and copy over the previous frame if we don't need
// to unrotate, or we can try to unrotate it. This is to ensure that we
// don't have a paint task that depends on another paint task.
if (!needsUnrotate || canUnrotate) {
// If we're async painting then begin to capture draw commands
if (result.mAsyncPaint) {
mBuffer->BeginCapture();
}
// Do not modify result.mRegionToDraw or result.mContentType after this
// call.
FinalizeFrame(result);
}
// Try to rotate the buffer or unrotate it if we cannot be rotated
if (needsUnrotate) {
if (canUnrotate && mBuffer->UnrotateBufferTo(newParameters)) {
newParameters.SetUnrotated();
mBuffer->SetParameters(newParameters);
} else {
MOZ_ASSERT(GetFrontBuffer());
mBuffer->Unlock();
dest.mBufferRect = ComputeBufferRect(dest.mNeededRegion.GetBounds());
dest.mCanReuseBuffer = false;
}
} else {
mBuffer->SetParameters(newParameters);
}
} else {
result.mRegionToDraw = dest.mNeededRegion;
dest.mCanReuseBuffer = false;
Clear();
}
}
MOZ_ASSERT(dest.mBufferRect.Contains(result.mRegionToDraw.GetBounds()));
NS_ASSERTION(!(aFlags & PAINT_WILL_RESAMPLE) ||
dest.mBufferRect == dest.mNeededRegion.GetBounds(),
"If we're resampling, we need to validate the entire buffer");
// We never had a buffer, the buffer wasn't big enough, the content changed
// types, or we failed to unrotate the buffer when requested. In any case,
// we need to allocate a new one and prepare it for drawing.
if (!dest.mCanReuseBuffer) {
uint32_t bufferFlags = 0;
if (dest.mBufferMode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
bufferFlags |= BUFFER_COMPONENT_ALPHA;
}
RefPtr<RotatedBuffer> newBuffer =
CreateBuffer(result.mContentType, dest.mBufferRect, bufferFlags);
if (!newBuffer) {
if (Factory::ReasonableSurfaceSize(
IntSize(dest.mBufferRect.Width(), dest.mBufferRect.Height()))) {
gfxCriticalNote << "Failed buffer for " << dest.mBufferRect.X() << ", "
<< dest.mBufferRect.Y() << ", "
<< dest.mBufferRect.Width() << ", "
<< dest.mBufferRect.Height();
}
result.mAsyncTask = nullptr;
Clear();
return result;
}
if (!newBuffer->Lock(writeMode)) {
gfxCriticalNote << "Failed to lock new back buffer.";
result.mAsyncTask = nullptr;
Clear();
return result;
}
if (result.mAsyncPaint) {
newBuffer->BeginCapture();
}
// If we have an existing front buffer, copy it into the new back buffer
RefPtr<RotatedBuffer> frontBuffer = GetFrontBuffer();
if (frontBuffer && frontBuffer->Lock(readMode)) {
nsIntRegion updateRegion = newBuffer->BufferRect();
updateRegion.Sub(updateRegion, result.mRegionToDraw);
if (!updateRegion.IsEmpty()) {
newBuffer->UpdateDestinationFrom(*frontBuffer,
updateRegion.GetBounds());
}
frontBuffer->Unlock();
} else {
result.mRegionToDraw = dest.mNeededRegion;
}
Clear();
mBuffer = newBuffer;
}
NS_ASSERTION(canHaveRotation || mBuffer->BufferRotation() == IntPoint(0, 0),
"Rotation disabled, but we have nonzero rotation?");
if (result.mAsyncPaint) {
result.mAsyncTask->mTarget = mBuffer->GetBufferTarget();
result.mAsyncTask->mClients.AppendElement(mBuffer->GetClient());
if (mBuffer->GetClientOnWhite()) {
result.mAsyncTask->mClients.AppendElement(mBuffer->GetClientOnWhite());
}
}
nsIntRegion invalidate;
invalidate.Sub(aLayer->GetValidRegion(), dest.mBufferRect);
result.mRegionToInvalidate.Or(result.mRegionToInvalidate, invalidate);
result.mClip = DrawRegionClip::DRAW;
result.mMode = dest.mBufferMode;
return result;
}
void ContentClient::EndPaint(
PaintState& aPaintState,
nsTArray<ReadbackProcessor::Update>* aReadbackUpdates) {
if (aPaintState.mAsyncTask) {
aPaintState.mAsyncTask->mCapture = mBuffer->EndCapture();
}
}
nsIntRegion ExpandDrawRegion(ContentClient::PaintState& aPaintState,
RotatedBuffer::DrawIterator* aIter,
BackendType aBackendType) {
nsIntRegion* drawPtr = &aPaintState.mRegionToDraw;
if (aIter) {
// The iterators draw region currently only contains the bounds of the
// region, this makes it the precise region.
aIter->mDrawRegion.And(aIter->mDrawRegion, aPaintState.mRegionToDraw);
drawPtr = &aIter->mDrawRegion;
}
if (aBackendType == BackendType::DIRECT2D ||
aBackendType == BackendType::DIRECT2D1_1) {
// Simplify the draw region to avoid hitting expensive drawing paths
// for complex regions.
drawPtr->SimplifyOutwardByArea(100 * 100);
}
return *drawPtr;
}
DrawTarget* ContentClient::BorrowDrawTargetForPainting(
ContentClient::PaintState& aPaintState,
RotatedBuffer::DrawIterator* aIter /* = nullptr */) {
if (aPaintState.mMode == SurfaceMode::SURFACE_NONE || !mBuffer) {
return nullptr;
}
DrawTarget* result = mBuffer->BorrowDrawTargetForQuadrantUpdate(
aPaintState.mRegionToDraw.GetBounds(), aIter);
if (!result || !result->IsValid()) {
if (result) {
mBuffer->ReturnDrawTarget(result);
}
return nullptr;
}
nsIntRegion regionToDraw =
ExpandDrawRegion(aPaintState, aIter, result->GetBackendType());
if (aPaintState.mMode == SurfaceMode::SURFACE_COMPONENT_ALPHA ||
aPaintState.mContentType == gfxContentType::COLOR_ALPHA) {
// HaveBuffer() => we have an existing buffer that we must clear
for (auto iter = regionToDraw.RectIter(); !iter.Done(); iter.Next()) {
const IntRect& rect = iter.Get();
result->ClearRect(Rect(rect.X(), rect.Y(), rect.Width(), rect.Height()));
}
}
return result;
}
void ContentClient::ReturnDrawTarget(gfx::DrawTarget*& aReturned) {
mBuffer->ReturnDrawTarget(aReturned);
}
ContentClient::BufferDecision ContentClient::CalculateBufferForPaint(
PaintedLayer* aLayer, uint32_t aFlags) {
gfxContentType layerContentType = aLayer->CanUseOpaqueSurface()
? gfxContentType::COLOR
: gfxContentType::COLOR_ALPHA;
SurfaceMode mode;
gfxContentType contentType;
IntRect destBufferRect;
nsIntRegion neededRegion;
nsIntRegion validRegion = aLayer->GetValidRegion();
bool canReuseBuffer = !!mBuffer;
bool canKeepBufferContents = true;
while (true) {
mode = aLayer->GetSurfaceMode();
neededRegion = aLayer->GetVisibleRegion().ToUnknownRegion();
canReuseBuffer =
canReuseBuffer &&
ValidBufferSize(mBufferSizePolicy, mBuffer->BufferRect().Size(),
neededRegion.GetBounds().Size());
contentType = layerContentType;
if (canReuseBuffer) {
if (mBuffer->BufferRect().Contains(neededRegion.GetBounds())) {
// We don't need to adjust mBufferRect.
destBufferRect = mBuffer->BufferRect();
} else if (neededRegion.GetBounds().Size() <=
mBuffer->BufferRect().Size()) {
// The buffer's big enough but doesn't contain everything that's
// going to be visible. We'll move it.
destBufferRect = IntRect(neededRegion.GetBounds().TopLeft(),
mBuffer->BufferRect().Size());
} else {
destBufferRect = neededRegion.GetBounds();
}
} else {
destBufferRect = ComputeBufferRect(neededRegion.GetBounds());
}
if (mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
#if defined(MOZ_GFX_OPTIMIZE_MOBILE)
mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
#else
if (!aLayer->GetParent() ||
!aLayer->GetParent()->SupportsComponentAlphaChildren() ||
!aLayer->AsShadowableLayer() ||
!aLayer->AsShadowableLayer()->HasShadow()) {
mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
} else {
contentType = gfxContentType::COLOR;
}
#endif
}
if ((aFlags & PAINT_WILL_RESAMPLE) &&
(!neededRegion.GetBounds().IsEqualInterior(destBufferRect) ||
neededRegion.GetNumRects() > 1)) {
// The area we add to neededRegion might not be painted opaquely.
if (mode == SurfaceMode::SURFACE_OPAQUE) {
contentType = gfxContentType::COLOR_ALPHA;
mode = SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA;
}
// We need to validate the entire buffer, to make sure that only valid
// pixels are sampled.
neededRegion = destBufferRect;
}
// If we have an existing buffer, but the content type has changed or we
// have transitioned into/out of component alpha, then we need to recreate
// it.
bool needsComponentAlpha = (mode == SurfaceMode::SURFACE_COMPONENT_ALPHA);
bool backBufferChangedSurface =
mBuffer && (contentType != mBuffer->GetContentType() ||
needsComponentAlpha != mBuffer->HaveBufferOnWhite());
if (canKeepBufferContents && backBufferChangedSurface) {
// Restart the decision process; we won't re-enter since we guard on
// being able to keep the buffer contents.
canReuseBuffer = false;
canKeepBufferContents = false;
validRegion.SetEmpty();
continue;
}
break;
}
NS_ASSERTION(destBufferRect.Contains(neededRegion.GetBounds()),
"Destination rect doesn't contain what we need to paint");
BufferDecision dest;
dest.mNeededRegion = std::move(neededRegion);
dest.mValidRegion = std::move(validRegion);
dest.mBufferRect = destBufferRect;
dest.mBufferMode = mode;
dest.mBufferContentType = contentType;
dest.mCanReuseBuffer = canReuseBuffer;
dest.mCanKeepBufferContents = canKeepBufferContents;
return dest;
}
bool ContentClient::ValidBufferSize(BufferSizePolicy aPolicy,
const gfx::IntSize& aBufferSize,
const gfx::IntSize& aVisibleBoundsSize) {
return (
aVisibleBoundsSize == aBufferSize ||
(SizedToVisibleBounds != aPolicy && aVisibleBoundsSize < aBufferSize));
}
void ContentClient::PrintInfo(std::stringstream& aStream, const char* aPrefix) {
aStream << aPrefix;
aStream << nsPrintfCString("ContentClient (0x%p)", this).get();
}
// We pass a null pointer for the ContentClient Forwarder argument, which means
// this client will not have a ContentHost on the other side.
ContentClientBasic::ContentClientBasic(gfx::BackendType aBackend)
: ContentClient(nullptr, ContainsVisibleBounds), mBackend(aBackend) {}
void ContentClientBasic::DrawTo(PaintedLayer* aLayer, gfx::DrawTarget* aTarget,
float aOpacity, gfx::CompositionOp aOp,
gfx::SourceSurface* aMask,
const gfx::Matrix* aMaskTransform) {
if (!mBuffer) {
return;
}
mBuffer->DrawTo(aLayer, aTarget, aOpacity, aOp, aMask, aMaskTransform);
}
RefPtr<RotatedBuffer> ContentClientBasic::CreateBuffer(gfxContentType aType,
const IntRect& aRect,
uint32_t aFlags) {
MOZ_ASSERT(!(aFlags & BUFFER_COMPONENT_ALPHA));
if (aFlags & BUFFER_COMPONENT_ALPHA) {
gfxDevCrash(LogReason::AlphaWithBasicClient)
<< "Asking basic content client for component alpha";
}
IntSize size(aRect.Width(), aRect.Height());
RefPtr<gfx::DrawTarget> drawTarget;
#ifdef XP_WIN
if (mBackend == BackendType::CAIRO &&
(aType == gfxContentType::COLOR ||
aType == gfxContentType::COLOR_ALPHA)) {
RefPtr<gfxASurface> surf = new gfxWindowsSurface(
size, aType == gfxContentType::COLOR ? gfxImageFormat::X8R8G8B8_UINT32
: gfxImageFormat::A8R8G8B8_UINT32);
drawTarget =
gfxPlatform::GetPlatform()->CreateDrawTargetForSurface(surf, size);
}
#endif
if (!drawTarget) {
drawTarget = gfxPlatform::GetPlatform()->CreateDrawTargetForBackend(
mBackend, size,
gfxPlatform::GetPlatform()->Optimal2DFormatForContent(aType));
}
if (!drawTarget) {
return nullptr;
}
return new DrawTargetRotatedBuffer(drawTarget, nullptr, aRect,
IntPoint(0, 0));
}
class RemoteBufferReadbackProcessor : public TextureReadbackSink {
public:
RemoteBufferReadbackProcessor(
nsTArray<ReadbackProcessor::Update>* aReadbackUpdates,
const IntRect& aBufferRect, const nsIntPoint& aBufferRotation)
: mReadbackUpdates(*aReadbackUpdates),
mBufferRect(aBufferRect),
mBufferRotation(aBufferRotation) {
for (uint32_t i = 0; i < mReadbackUpdates.Length(); ++i) {
mLayerRefs.push_back(mReadbackUpdates[i].mLayer);
}
}
virtual void ProcessReadback(
gfx::DataSourceSurface* aSourceSurface) override {
SourceRotatedBuffer rotBuffer(aSourceSurface, nullptr, mBufferRect,
mBufferRotation);
for (uint32_t i = 0; i < mReadbackUpdates.Length(); ++i) {
ReadbackProcessor::Update& update = mReadbackUpdates[i];
nsIntPoint offset = update.mLayer->GetBackgroundLayerOffset();
ReadbackSink* sink = update.mLayer->GetSink();
if (!sink) {
continue;
}
if (!aSourceSurface) {
sink->SetUnknown(update.mSequenceCounter);
continue;
}
RefPtr<DrawTarget> dt = sink->BeginUpdate(update.mUpdateRect + offset,
update.mSequenceCounter);
if (!dt) {
continue;
}
dt->SetTransform(Matrix::Translation(offset.x, offset.y));
rotBuffer.DrawBufferWithRotation(dt);
update.mLayer->GetSink()->EndUpdate(update.mUpdateRect + offset);
}
}
private:
nsTArray<ReadbackProcessor::Update> mReadbackUpdates;
// This array is used to keep the layers alive until the callback.
vector<RefPtr<Layer>> mLayerRefs;
IntRect mBufferRect;
nsIntPoint mBufferRotation;
};
void ContentClientRemoteBuffer::EndPaint(
PaintState& aPaintState,
nsTArray<ReadbackProcessor::Update>* aReadbackUpdates) {
MOZ_ASSERT(!mBuffer || !mBuffer->HaveBufferOnWhite() || !aReadbackUpdates ||
aReadbackUpdates->Length() == 0);
RemoteRotatedBuffer* remoteBuffer = GetRemoteBuffer();
if (remoteBuffer && remoteBuffer->IsLocked()) {
if (aReadbackUpdates && aReadbackUpdates->Length() > 0) {
RefPtr<TextureReadbackSink> readbackSink =
new RemoteBufferReadbackProcessor(aReadbackUpdates,
remoteBuffer->BufferRect(),
remoteBuffer->BufferRotation());
remoteBuffer->GetClient()->SetReadbackSink(readbackSink);
}
remoteBuffer->Unlock();
remoteBuffer->SyncWithObject(mForwarder->GetSyncObject());
}
ContentClient::EndPaint(aPaintState, aReadbackUpdates);
}
RefPtr<RotatedBuffer> ContentClientRemoteBuffer::CreateBuffer(
gfxContentType aType, const IntRect& aRect, uint32_t aFlags) {
// If we hit this assertion, then it might be due to an empty transaction
// followed by a real transaction. Our buffers should be created (but not
// painted in the empty transaction) and then painted (but not created) in the
// real transaction. That is kind of fragile, and this assert will catch
// circumstances where we screw that up, e.g., by unnecessarily recreating our
// buffers.
MOZ_ASSERT(!mIsNewBuffer,
"Bad! Did we create a buffer twice without painting?");
gfx::SurfaceFormat format =
gfxPlatform::GetPlatform()->Optimal2DFormatForContent(aType);
TextureFlags textureFlags = TextureFlagsForContentClientFlags(aFlags);
if (aFlags & BUFFER_COMPONENT_ALPHA) {
textureFlags |= TextureFlags::COMPONENT_ALPHA;
}
RefPtr<RotatedBuffer> buffer =
CreateBufferInternal(aRect, format, textureFlags);
if (!buffer) {
return nullptr;
}
mIsNewBuffer = true;
mTextureFlags = textureFlags;
return buffer;
}
RefPtr<RotatedBuffer> ContentClientRemoteBuffer::CreateBufferInternal(
const gfx::IntRect& aRect, gfx::SurfaceFormat aFormat,
TextureFlags aFlags) {
TextureAllocationFlags textureAllocFlags =
TextureAllocationFlags::ALLOC_DEFAULT;
RefPtr<TextureClient> textureClient = CreateTextureClientForDrawing(
aFormat, aRect.Size(), BackendSelector::Content,
aFlags | ExtraTextureFlags() | TextureFlags::BLOCKING_READ_LOCK,
textureAllocFlags);
if (!textureClient || !AddTextureClient(textureClient)) {
return nullptr;
}
RefPtr<TextureClient> textureClientOnWhite;
if (aFlags & TextureFlags::COMPONENT_ALPHA) {
TextureAllocationFlags allocFlags = TextureAllocationFlags::ALLOC_DEFAULT;
if (mForwarder->SupportsTextureDirectMapping()) {
allocFlags =
TextureAllocationFlags(allocFlags | ALLOC_ALLOW_DIRECT_MAPPING);
}
textureClientOnWhite =
textureClient->CreateSimilar(mForwarder->GetCompositorBackendType(),
aFlags | ExtraTextureFlags(), allocFlags);
if (!textureClientOnWhite || !AddTextureClient(textureClientOnWhite)) {
return nullptr;
}
// We don't enable the readlock for the white buffer since we always
// use them together and waiting on the lock for the black
// should be sufficient.
}
return new RemoteRotatedBuffer(textureClient, textureClientOnWhite, aRect,
IntPoint(0, 0));
}
nsIntRegion ContentClientRemoteBuffer::GetUpdatedRegion(
const nsIntRegion& aRegionToDraw, const nsIntRegion& aVisibleRegion) {
nsIntRegion updatedRegion;
if (mIsNewBuffer || mBuffer->DidSelfCopy()) {
// A buffer reallocation clears both buffers. The front buffer has all the
// content by now, but the back buffer is still clear. Here, in effect, we
// are saying to copy all of the pixels of the front buffer to the back.
// Also when we self-copied in the buffer, the buffer space
// changes and some changed buffer content isn't reflected in the
// draw or invalidate region (on purpose!). When this happens, we
// need to read back the entire buffer too.
updatedRegion = aVisibleRegion.GetBounds();
mIsNewBuffer = false;
} else {
updatedRegion = aRegionToDraw;
}
MOZ_ASSERT(mBuffer, "should have a back buffer by now");
NS_ASSERTION(mBuffer->BufferRect().Contains(aRegionToDraw.GetBounds()),
"Update outside of buffer rect!");
return updatedRegion;
}
void ContentClientRemoteBuffer::Updated(const nsIntRegion& aRegionToDraw,
const nsIntRegion& aVisibleRegion) {
nsIntRegion updatedRegion = GetUpdatedRegion(aRegionToDraw, aVisibleRegion);
RemoteRotatedBuffer* remoteBuffer = GetRemoteBuffer();
MOZ_ASSERT(remoteBuffer && remoteBuffer->GetClient());
if (remoteBuffer->HaveBufferOnWhite()) {
mForwarder->UseComponentAlphaTextures(this, remoteBuffer->GetClient(),
remoteBuffer->GetClientOnWhite());
} else {
AutoTArray<CompositableForwarder::TimedTextureClient, 1> textures;
CompositableForwarder::TimedTextureClient* t = textures.AppendElement();
t->mTextureClient = remoteBuffer->GetClient();
IntSize size = remoteBuffer->GetClient()->GetSize();
t->mPictureRect = nsIntRect(0, 0, size.width, size.height);
GetForwarder()->UseTextures(this, textures);
}
// This forces a synchronous transaction, so we can swap buffers now
// and know that we'll have sole ownership of the old front buffer
// by the time we paint next.
mForwarder->UpdateTextureRegion(
this,
ThebesBufferData(remoteBuffer->BufferRect(),
remoteBuffer->BufferRotation()),
updatedRegion);
SwapBuffers(updatedRegion);
}
void ContentClientRemoteBuffer::Dump(std::stringstream& aStream,
const char* aPrefix, bool aDumpHtml,
TextureDumpMode aCompress) {
RemoteRotatedBuffer* remoteBuffer = GetRemoteBuffer();
// TODO We should combine the OnWhite/OnBlack here an just output a single
// image.
if (!aDumpHtml) {
aStream << "\n" << aPrefix << "Surface: ";
}
CompositableClient::DumpTextureClient(
aStream, remoteBuffer ? remoteBuffer->GetClient() : nullptr, aCompress);
}
void ContentClientDoubleBuffered::Dump(std::stringstream& aStream,
const char* aPrefix, bool aDumpHtml,
TextureDumpMode aCompress) {
// TODO We should combine the OnWhite/OnBlack here an just output a single
// image.
if (!aDumpHtml) {
aStream << "\n" << aPrefix << "Surface: ";
}
CompositableClient::DumpTextureClient(
aStream, mFrontBuffer ? mFrontBuffer->GetClient() : nullptr, aCompress);
}
void ContentClientDoubleBuffered::Clear() {
ContentClient::Clear();
mFrontBuffer = nullptr;
}
void ContentClientDoubleBuffered::SwapBuffers(
const nsIntRegion& aFrontUpdatedRegion) {
mFrontUpdatedRegion = aFrontUpdatedRegion;
RefPtr<RemoteRotatedBuffer> frontBuffer = mFrontBuffer;
RefPtr<RemoteRotatedBuffer> backBuffer = GetRemoteBuffer();
std::swap(frontBuffer, backBuffer);
mFrontBuffer = frontBuffer;
mBuffer = backBuffer;
mFrontAndBackBufferDiffer = true;
}
ContentClient::PaintState ContentClientDoubleBuffered::BeginPaint(
PaintedLayer* aLayer, uint32_t aFlags) {
EnsureBackBufferIfFrontBuffer();
mIsNewBuffer = false;
if (!mFrontBuffer || !mBuffer) {
mFrontAndBackBufferDiffer = false;
}
if (mFrontAndBackBufferDiffer) {
if (mFrontBuffer->DidSelfCopy()) {
// We can't easily draw our front buffer into us, since we're going to be
// copying stuff around anyway it's easiest if we just move our situation
// to non-rotated while we're at it. If this situation occurs we'll have
// hit a self-copy path in PaintThebes before as well anyway.
gfx::IntRect backBufferRect = mBuffer->BufferRect();
backBufferRect.MoveTo(mFrontBuffer->BufferRect().TopLeft());
mBuffer->SetBufferRect(backBufferRect);
mBuffer->SetBufferRotation(IntPoint(0, 0));
} else {
mBuffer->SetBufferRect(mFrontBuffer->BufferRect());
mBuffer->SetBufferRotation(mFrontBuffer->BufferRotation());
}
}
return ContentClient::BeginPaint(aLayer, aFlags);
}
// Sync front/back buffers content
// After executing, the new back buffer has the same (interesting) pixels as
// the new front buffer, and mValidRegion et al. are correct wrt the new
// back buffer (i.e. as they were for the old back buffer)
void ContentClientDoubleBuffered::FinalizeFrame(PaintState& aPaintState) {
if (!mFrontAndBackBufferDiffer) {
MOZ_ASSERT(!mFrontBuffer || !mFrontBuffer->DidSelfCopy(),
"If the front buffer did a self copy then our front and back "
"buffer must be different.");
return;
}
MOZ_ASSERT(mFrontBuffer && mBuffer);
if (!mFrontBuffer || !mBuffer) {
return;
}
MOZ_LAYERS_LOG(
("BasicShadowableThebes(%p): reading back <x=%d,y=%d,w=%d,h=%d>", this,
mFrontUpdatedRegion.GetBounds().X(), mFrontUpdatedRegion.GetBounds().Y(),
mFrontUpdatedRegion.GetBounds().Width(),
mFrontUpdatedRegion.GetBounds().Height()));
mFrontAndBackBufferDiffer = false;
nsIntRegion updateRegion = mFrontUpdatedRegion;
if (mFrontBuffer->DidSelfCopy()) {
mFrontBuffer->ClearDidSelfCopy();
updateRegion = mBuffer->BufferRect();
}
// No point in sync'ing what we are going to draw over anyway. And if there is
// nothing to sync at all, there is nothing to do and we can go home early.
updateRegion.Sub(updateRegion, aPaintState.mRegionToDraw);
if (updateRegion.IsEmpty()) {
return;
}
OpenMode openMode = aPaintState.mAsyncPaint ? OpenMode::OPEN_READ_ASYNC
: OpenMode::OPEN_READ_ONLY;
if (mFrontBuffer->Lock(openMode)) {
mBuffer->UpdateDestinationFrom(*mFrontBuffer, updateRegion.GetBounds());
if (aPaintState.mAsyncPaint) {
aPaintState.mAsyncTask->mClients.AppendElement(mFrontBuffer->GetClient());
if (mFrontBuffer->GetClientOnWhite()) {
aPaintState.mAsyncTask->mClients.AppendElement(
mFrontBuffer->GetClientOnWhite());
}
}
mFrontBuffer->Unlock();
}
}
void ContentClientDoubleBuffered::EnsureBackBufferIfFrontBuffer() {
if (!mBuffer && mFrontBuffer) {
mBuffer = CreateBufferInternal(mFrontBuffer->BufferRect(),
mFrontBuffer->GetFormat(), mTextureFlags);
MOZ_ASSERT(mBuffer);
}
}
} // namespace layers
} // namespace mozilla
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку