b4a3772f19
BufferContentType and BufferSizeOkFor make more sense as general functions for any RotatedBuffer, and this helps out in a later patch. MozReview-Commit-ID: EAVodvl4WTu
923 lines
32 KiB
C++
923 lines
32 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 "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)
|
|
{
|
|
PaintState result;
|
|
|
|
BufferDecision dest = CalculateBufferForPaint(aLayer, aFlags);
|
|
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;
|
|
|
|
OpenMode lockMode = aFlags & PAINT_ASYNC ? OpenMode::OPEN_READ_ASYNC_WRITE
|
|
: OpenMode::OPEN_READ_WRITE;
|
|
|
|
if (mBuffer) {
|
|
if (mBuffer->Lock(lockMode)) {
|
|
// Do not modify result.mRegionToDraw or result.mContentType after this call.
|
|
// Do not modify the back buffer's bufferRect, bufferRotation, or didSelfCopy.
|
|
FinalizeFrame(result.mRegionToDraw);
|
|
} else {
|
|
// Abandon everything and redraw it all. Ideally we'd reallocate and copy
|
|
// the old to the new and then call FinalizeFrame on the new buffer so that
|
|
// we only need to draw the latest bits, but we need a big refactor to support
|
|
// that ordering.
|
|
result.mRegionToDraw = dest.mNeededRegion;
|
|
dest.mCanReuseBuffer = false;
|
|
Clear();
|
|
}
|
|
}
|
|
|
|
// 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;
|
|
IntRect drawBounds = result.mRegionToDraw.GetBounds();
|
|
|
|
if (dest.mCanReuseBuffer) {
|
|
MOZ_ASSERT(mBuffer);
|
|
|
|
if (!mBuffer->AdjustTo(dest.mBufferRect,
|
|
drawBounds,
|
|
canHaveRotation,
|
|
canDrawRotated)) {
|
|
dest.mBufferRect = ComputeBufferRect(dest.mNeededRegion.GetBounds());
|
|
dest.mCanReuseBuffer = false;
|
|
}
|
|
}
|
|
|
|
NS_ASSERTION(!(aFlags & PAINT_WILL_RESAMPLE) || dest.mBufferRect == dest.mNeededRegion.GetBounds(),
|
|
"If we're resampling, we need to validate the entire buffer");
|
|
|
|
// The buffer's not big enough, changed content, or we failed to unrotate it,
|
|
// so 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();
|
|
}
|
|
Clear();
|
|
return result;
|
|
}
|
|
|
|
if (!newBuffer->Lock(lockMode)) {
|
|
gfxCriticalNote << "Failed to lock new back buffer.";
|
|
Clear();
|
|
return result;
|
|
}
|
|
|
|
// If we have an existing back buffer, copy it into the new back buffer
|
|
if (mBuffer) {
|
|
newBuffer->UpdateDestinationFrom(*mBuffer, newBuffer->BufferRect());
|
|
|
|
// We are done with the old back buffer now and it is about to be
|
|
// destroyed, so unlock it
|
|
mBuffer->Unlock();
|
|
}
|
|
|
|
// Ensure our reference to the front buffer is released
|
|
// as well as the old back buffer
|
|
Clear();
|
|
|
|
mBuffer = newBuffer;
|
|
}
|
|
|
|
NS_ASSERTION(canHaveRotation || mBuffer->BufferRotation() == IntPoint(0,0),
|
|
"Rotation disabled, but we have nonzero rotation?");
|
|
|
|
nsIntRegion invalidate;
|
|
invalidate.Sub(aLayer->GetValidRegion(), dest.mBufferRect);
|
|
result.mRegionToInvalidate.Or(result.mRegionToInvalidate, invalidate);
|
|
|
|
result.mClip = DrawRegionClip::DRAW;
|
|
result.mMode = dest.mBufferMode;
|
|
|
|
return result;
|
|
}
|
|
|
|
DrawTarget*
|
|
ContentClient::BorrowDrawTargetForPainting(ContentClient::PaintState& aPaintState,
|
|
RotatedBuffer::DrawIterator* aIter /* = nullptr */)
|
|
{
|
|
RefPtr<CapturedPaintState> capturedState =
|
|
ContentClient::BorrowDrawTargetForRecording(aPaintState, aIter, true);
|
|
|
|
if (!capturedState) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (!ContentClient::PrepareDrawTargetForPainting(capturedState)) {
|
|
return nullptr;
|
|
}
|
|
|
|
return capturedState->mTargetDual;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
RefPtr<CapturedPaintState>
|
|
ContentClient::BorrowDrawTargetForRecording(ContentClient::PaintState& aPaintState,
|
|
RotatedBuffer::DrawIterator* aIter,
|
|
bool aSetTransform)
|
|
{
|
|
if (aPaintState.mMode == SurfaceMode::SURFACE_NONE || !mBuffer) {
|
|
return nullptr;
|
|
}
|
|
|
|
Matrix transform;
|
|
DrawTarget* result = mBuffer->BorrowDrawTargetForQuadrantUpdate(
|
|
aPaintState.mRegionToDraw.GetBounds(),
|
|
RotatedBuffer::BUFFER_BOTH, aIter,
|
|
aSetTransform,
|
|
&transform);
|
|
if (!result) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsIntRegion regionToDraw =
|
|
ExpandDrawRegion(aPaintState, aIter, result->GetBackendType());
|
|
|
|
RefPtr<CapturedPaintState> state =
|
|
new CapturedPaintState(regionToDraw,
|
|
result,
|
|
mBuffer->GetDTBuffer(),
|
|
mBuffer->GetDTBufferOnWhite(),
|
|
transform,
|
|
aPaintState.mMode,
|
|
aPaintState.mContentType);
|
|
return state;
|
|
}
|
|
|
|
void
|
|
ContentClient::ReturnDrawTarget(gfx::DrawTarget*& aReturned)
|
|
{
|
|
mBuffer->ReturnDrawTarget(aReturned);
|
|
}
|
|
|
|
/*static */ bool
|
|
ContentClient::PrepareDrawTargetForPainting(CapturedPaintState* aState)
|
|
{
|
|
MOZ_ASSERT(aState);
|
|
RefPtr<DrawTarget> target = aState->mTarget;
|
|
RefPtr<DrawTarget> whiteTarget = aState->mTargetOnWhite;
|
|
|
|
if (aState->mSurfaceMode == SurfaceMode::SURFACE_COMPONENT_ALPHA) {
|
|
if (!target || !target->IsValid() ||
|
|
!whiteTarget || !whiteTarget->IsValid()) {
|
|
// This can happen in release builds if allocating one of the two buffers
|
|
// failed. This in turn can happen if unreasonably large textures are
|
|
// requested.
|
|
return false;
|
|
}
|
|
for (auto iter = aState->mRegionToDraw.RectIter(); !iter.Done(); iter.Next()) {
|
|
const IntRect& rect = iter.Get();
|
|
target->FillRect(Rect(rect.x, rect.y, rect.Width(), rect.Height()),
|
|
ColorPattern(Color(0.0, 0.0, 0.0, 1.0)));
|
|
whiteTarget->FillRect(Rect(rect.x, rect.y, rect.Width(), rect.Height()),
|
|
ColorPattern(Color(1.0, 1.0, 1.0, 1.0)));
|
|
}
|
|
} else if (aState->mContentType == gfxContentType::COLOR_ALPHA &&
|
|
target->IsValid()) {
|
|
// HaveBuffer() => we have an existing buffer that we must clear
|
|
for (auto iter = aState->mRegionToDraw.RectIter(); !iter.Done(); iter.Next()) {
|
|
const IntRect& rect = iter.Get();
|
|
target->ClearRect(Rect(rect.x, rect.y, rect.Width(), rect.Height()));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
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 {
|
|
// We won't be reusing the buffer. Compute a new rect.
|
|
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.
|
|
if (canKeepBufferContents &&
|
|
mBuffer &&
|
|
(contentType != mBuffer->GetContentType() ||
|
|
(mode == SurfaceMode::SURFACE_COMPONENT_ALPHA) != mBuffer->HaveBufferOnWhite()))
|
|
{
|
|
// 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 = Move(neededRegion);
|
|
dest.mValidRegion = 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));
|
|
}
|
|
|
|
return new DrawTargetRotatedBuffer(drawTarget, nullptr, aRect, IntPoint(0,0));
|
|
}
|
|
|
|
RefPtr<CapturedPaintState>
|
|
ContentClientBasic::BorrowDrawTargetForRecording(ContentClient::PaintState& aPaintState,
|
|
RotatedBuffer::DrawIterator* aIter,
|
|
bool aSetTransform)
|
|
{
|
|
// BasicLayers does not yet support OMTP.
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<CapturedPaintState>
|
|
ContentClientRemoteBuffer::BorrowDrawTargetForRecording(ContentClient::PaintState& aPaintState,
|
|
RotatedBuffer::DrawIterator* aIter,
|
|
bool aSetTransform)
|
|
{
|
|
RefPtr<CapturedPaintState> cps = ContentClient::BorrowDrawTargetForRecording(aPaintState, aIter, aSetTransform);
|
|
if (!cps) {
|
|
return nullptr;
|
|
}
|
|
|
|
RemoteRotatedBuffer* remoteBuffer = GetRemoteBuffer();
|
|
cps->mTextureClient = remoteBuffer->GetClient();
|
|
cps->mTextureClientOnWhite = remoteBuffer->GetClientOnWhite();
|
|
return cps.forget();
|
|
}
|
|
|
|
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)
|
|
{
|
|
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, RotatedBuffer::BUFFER_BLACK);
|
|
|
|
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(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(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
|
|
= (aFlags & TextureFlags::COMPONENT_ALPHA) ?
|
|
TextureAllocationFlags::ALLOC_CLEAR_BUFFER_BLACK :
|
|
TextureAllocationFlags::ALLOC_CLEAR_BUFFER;
|
|
|
|
RefPtr<TextureClient> textureClient = CreateTextureClientForDrawing(
|
|
aFormat, aRect.Size(), BackendSelector::Content,
|
|
aFlags | ExtraTextureFlags(),
|
|
textureAllocFlags
|
|
);
|
|
|
|
if (!textureClient || !AddTextureClient(textureClient)) {
|
|
return nullptr;
|
|
}
|
|
textureClient->EnableBlockingReadLock();
|
|
|
|
RefPtr<TextureClient> textureClientOnWhite;
|
|
if (aFlags & TextureFlags::COMPONENT_ALPHA) {
|
|
textureClientOnWhite = textureClient->CreateSimilar(
|
|
mForwarder->GetCompositorBackendType(),
|
|
aFlags | ExtraTextureFlags(),
|
|
TextureAllocationFlags::ALLOC_CLEAR_BUFFER_WHITE
|
|
);
|
|
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(const nsIntRegion& aRegionToDraw)
|
|
{
|
|
if (!mFrontAndBackBufferDiffer) {
|
|
MOZ_ASSERT(!mFrontBuffer->DidSelfCopy(), "If we have to copy the world, then our buffers are different, right?");
|
|
return;
|
|
}
|
|
MOZ_ASSERT(mFrontBuffer);
|
|
if (!mFrontBuffer) {
|
|
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, aRegionToDraw);
|
|
if (updateRegion.IsEmpty()) {
|
|
return;
|
|
}
|
|
|
|
if (!mBuffer) {
|
|
return;
|
|
}
|
|
|
|
if (mFrontBuffer->Lock(OpenMode::OPEN_READ_ONLY)) {
|
|
mBuffer->UpdateDestinationFrom(*mFrontBuffer, updateRegion.GetBounds());
|
|
mFrontBuffer->Unlock();
|
|
}
|
|
}
|
|
|
|
void
|
|
ContentClientDoubleBuffered::EnsureBackBufferIfFrontBuffer()
|
|
{
|
|
if (!mBuffer && mFrontBuffer) {
|
|
mBuffer = CreateBufferInternal(mFrontBuffer->BufferRect(),
|
|
mFrontBuffer->GetFormat(),
|
|
mTextureFlags);
|
|
MOZ_ASSERT(mBuffer);
|
|
}
|
|
}
|
|
|
|
} // namespace layers
|
|
} // namespace mozilla
|