зеркало из https://github.com/mozilla/gecko-dev.git
1129 строки
39 KiB
C++
1129 строки
39 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 "BasicCompositor.h"
|
|
#include "BasicLayersImpl.h" // for FillRectWithMask
|
|
#include "GeckoProfiler.h"
|
|
#include "TextureHostBasic.h"
|
|
#include "mozilla/layers/Effects.h"
|
|
#include "nsIWidget.h"
|
|
#include "gfx2DGlue.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
#include "mozilla/gfx/gfxVars.h"
|
|
#include "mozilla/gfx/Helpers.h"
|
|
#include "mozilla/gfx/Swizzle.h"
|
|
#include "mozilla/gfx/Tools.h"
|
|
#include "mozilla/gfx/ssse3-scaler.h"
|
|
#include "mozilla/layers/ImageDataSerializer.h"
|
|
#include "mozilla/SSE.h"
|
|
#include "gfxPlatform.h"
|
|
#include "gfxUtils.h"
|
|
#include "YCbCrUtils.h"
|
|
#include <algorithm>
|
|
#include "ImageContainer.h"
|
|
#include "gfxPrefs.h"
|
|
|
|
namespace mozilla {
|
|
using namespace mozilla::gfx;
|
|
|
|
namespace layers {
|
|
|
|
class DataTextureSourceBasic : public DataTextureSource,
|
|
public TextureSourceBasic {
|
|
public:
|
|
const char* Name() const override { return "DataTextureSourceBasic"; }
|
|
|
|
explicit DataTextureSourceBasic(DataSourceSurface* aSurface)
|
|
: mSurface(aSurface), mWrappingExistingData(!!aSurface) {}
|
|
|
|
DataTextureSource* AsDataTextureSource() override {
|
|
// If the texture wraps someone else's memory we'd rather not use it as
|
|
// a DataTextureSource per say (that is call Update on it).
|
|
return mWrappingExistingData ? nullptr : this;
|
|
}
|
|
|
|
TextureSourceBasic* AsSourceBasic() override { return this; }
|
|
|
|
gfx::SourceSurface* GetSurface(DrawTarget* aTarget) override {
|
|
return mSurface;
|
|
}
|
|
|
|
SurfaceFormat GetFormat() const override {
|
|
return mSurface ? mSurface->GetFormat() : gfx::SurfaceFormat::UNKNOWN;
|
|
}
|
|
|
|
IntSize GetSize() const override {
|
|
return mSurface ? mSurface->GetSize() : gfx::IntSize(0, 0);
|
|
}
|
|
|
|
bool Update(gfx::DataSourceSurface* aSurface,
|
|
nsIntRegion* aDestRegion = nullptr,
|
|
gfx::IntPoint* aSrcOffset = nullptr) override {
|
|
MOZ_ASSERT(!mWrappingExistingData);
|
|
if (mWrappingExistingData) {
|
|
return false;
|
|
}
|
|
mSurface = aSurface;
|
|
return true;
|
|
}
|
|
|
|
void DeallocateDeviceData() override {
|
|
mSurface = nullptr;
|
|
SetUpdateSerial(0);
|
|
}
|
|
|
|
public:
|
|
RefPtr<gfx::DataSourceSurface> mSurface;
|
|
bool mWrappingExistingData;
|
|
};
|
|
|
|
/**
|
|
* WrappingTextureSourceYCbCrBasic wraps YUV format BufferTextureHost to defer
|
|
* yuv->rgb conversion. The conversion happens when GetSurface is called.
|
|
*/
|
|
class WrappingTextureSourceYCbCrBasic : public DataTextureSource,
|
|
public TextureSourceBasic {
|
|
public:
|
|
const char* Name() const override {
|
|
return "WrappingTextureSourceYCbCrBasic";
|
|
}
|
|
|
|
explicit WrappingTextureSourceYCbCrBasic(BufferTextureHost* aTexture)
|
|
: mTexture(aTexture), mSize(aTexture->GetSize()), mNeedsUpdate(true) {
|
|
mFromYCBCR = true;
|
|
}
|
|
|
|
DataTextureSource* AsDataTextureSource() override { return this; }
|
|
|
|
TextureSourceBasic* AsSourceBasic() override { return this; }
|
|
|
|
WrappingTextureSourceYCbCrBasic* AsWrappingTextureSourceYCbCrBasic()
|
|
override {
|
|
return this;
|
|
}
|
|
|
|
gfx::SourceSurface* GetSurface(DrawTarget* aTarget) override {
|
|
if (mSurface && !mNeedsUpdate) {
|
|
return mSurface;
|
|
}
|
|
MOZ_ASSERT(mTexture);
|
|
if (!mTexture) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (!mSurface) {
|
|
mSurface =
|
|
Factory::CreateDataSourceSurface(mSize, gfx::SurfaceFormat::B8G8R8X8);
|
|
}
|
|
if (!mSurface) {
|
|
return nullptr;
|
|
}
|
|
MOZ_ASSERT(mTexture->GetBufferDescriptor().type() ==
|
|
BufferDescriptor::TYCbCrDescriptor);
|
|
MOZ_ASSERT(mTexture->GetSize() == mSize);
|
|
|
|
mSurface = ImageDataSerializer::DataSourceSurfaceFromYCbCrDescriptor(
|
|
mTexture->GetBuffer(),
|
|
mTexture->GetBufferDescriptor().get_YCbCrDescriptor(), mSurface);
|
|
mNeedsUpdate = false;
|
|
return mSurface;
|
|
}
|
|
|
|
SurfaceFormat GetFormat() const override {
|
|
return gfx::SurfaceFormat::B8G8R8X8;
|
|
}
|
|
|
|
IntSize GetSize() const override { return mSize; }
|
|
|
|
virtual bool Update(gfx::DataSourceSurface* aSurface,
|
|
nsIntRegion* aDestRegion = nullptr,
|
|
gfx::IntPoint* aSrcOffset = nullptr) override {
|
|
return false;
|
|
}
|
|
|
|
void DeallocateDeviceData() override {
|
|
mTexture = nullptr;
|
|
mSurface = nullptr;
|
|
SetUpdateSerial(0);
|
|
}
|
|
|
|
void Unbind() override { mNeedsUpdate = true; }
|
|
|
|
void SetBufferTextureHost(BufferTextureHost* aTexture) override {
|
|
mTexture = aTexture;
|
|
mNeedsUpdate = true;
|
|
}
|
|
|
|
void ConvertAndScale(const SurfaceFormat& aDestFormat,
|
|
const IntSize& aDestSize, unsigned char* aDestBuffer,
|
|
int32_t aStride) {
|
|
MOZ_ASSERT(mTexture);
|
|
if (!mTexture) {
|
|
return;
|
|
}
|
|
MOZ_ASSERT(mTexture->GetBufferDescriptor().type() ==
|
|
BufferDescriptor::TYCbCrDescriptor);
|
|
MOZ_ASSERT(mTexture->GetSize() == mSize);
|
|
ImageDataSerializer::ConvertAndScaleFromYCbCrDescriptor(
|
|
mTexture->GetBuffer(),
|
|
mTexture->GetBufferDescriptor().get_YCbCrDescriptor(), aDestFormat,
|
|
aDestSize, aDestBuffer, aStride);
|
|
}
|
|
|
|
public:
|
|
BufferTextureHost* mTexture;
|
|
const gfx::IntSize mSize;
|
|
RefPtr<gfx::DataSourceSurface> mSurface;
|
|
bool mNeedsUpdate;
|
|
};
|
|
|
|
class BasicAsyncReadbackBuffer final : public AsyncReadbackBuffer {
|
|
public:
|
|
explicit BasicAsyncReadbackBuffer(const IntSize& aSize)
|
|
: AsyncReadbackBuffer(aSize) {}
|
|
|
|
bool MapAndCopyInto(DataSourceSurface* aSurface,
|
|
const IntSize& aReadSize) const override;
|
|
|
|
void TakeSurface(SourceSurface* aSurface) { mSurface = aSurface; }
|
|
|
|
private:
|
|
RefPtr<SourceSurface> mSurface;
|
|
};
|
|
|
|
bool BasicAsyncReadbackBuffer::MapAndCopyInto(DataSourceSurface* aSurface,
|
|
const IntSize& aReadSize) const {
|
|
if (!mSurface) {
|
|
return false;
|
|
}
|
|
|
|
MOZ_RELEASE_ASSERT(aReadSize <= aSurface->GetSize());
|
|
RefPtr<DataSourceSurface> source = mSurface->GetDataSurface();
|
|
|
|
DataSourceSurface::ScopedMap sourceMap(source, DataSourceSurface::READ);
|
|
DataSourceSurface::ScopedMap destMap(aSurface, DataSourceSurface::WRITE);
|
|
|
|
return SwizzleData(sourceMap.GetData(), sourceMap.GetStride(),
|
|
mSurface->GetFormat(), destMap.GetData(),
|
|
destMap.GetStride(), aSurface->GetFormat(), aReadSize);
|
|
}
|
|
|
|
BasicCompositor::BasicCompositor(CompositorBridgeParent* aParent,
|
|
widget::CompositorWidget* aWidget)
|
|
: Compositor(aWidget, aParent),
|
|
mIsPendingEndRemoteDrawing(false),
|
|
mFullWindowRenderTarget(nullptr) {
|
|
MOZ_COUNT_CTOR(BasicCompositor);
|
|
|
|
mMaxTextureSize = Factory::GetMaxSurfaceSize(gfxVars::ContentBackend());
|
|
}
|
|
|
|
BasicCompositor::~BasicCompositor() { MOZ_COUNT_DTOR(BasicCompositor); }
|
|
|
|
bool BasicCompositor::Initialize(nsCString* const out_failureReason) {
|
|
return mWidget ? mWidget->InitCompositor(this) : false;
|
|
};
|
|
|
|
int32_t BasicCompositor::GetMaxTextureSize() const { return mMaxTextureSize; }
|
|
|
|
void BasicCompositingRenderTarget::BindRenderTarget() {
|
|
if (mClearOnBind) {
|
|
mDrawTarget->ClearRect(Rect(0, 0, mSize.width, mSize.height));
|
|
mClearOnBind = false;
|
|
}
|
|
}
|
|
|
|
void BasicCompositor::DetachWidget() {
|
|
if (mWidget) {
|
|
if (mIsPendingEndRemoteDrawing) {
|
|
// Force to end previous remote drawing.
|
|
TryToEndRemoteDrawing(/* aForceToEnd */ true);
|
|
MOZ_ASSERT(!mIsPendingEndRemoteDrawing);
|
|
}
|
|
mWidget->CleanupRemoteDrawing();
|
|
}
|
|
Compositor::DetachWidget();
|
|
}
|
|
|
|
TextureFactoryIdentifier BasicCompositor::GetTextureFactoryIdentifier() {
|
|
TextureFactoryIdentifier ident(LayersBackend::LAYERS_BASIC,
|
|
XRE_GetProcessType(), GetMaxTextureSize());
|
|
return ident;
|
|
}
|
|
|
|
already_AddRefed<CompositingRenderTarget> BasicCompositor::CreateRenderTarget(
|
|
const IntRect& aRect, SurfaceInitMode aInit) {
|
|
MOZ_ASSERT(!aRect.IsZeroArea(),
|
|
"Trying to create a render target of invalid size");
|
|
|
|
if (aRect.IsZeroArea()) {
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<DrawTarget> target = mDrawTarget->CreateSimilarDrawTarget(
|
|
aRect.Size(), SurfaceFormat::B8G8R8A8);
|
|
|
|
if (!target) {
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<BasicCompositingRenderTarget> rt =
|
|
new BasicCompositingRenderTarget(target, aRect);
|
|
|
|
return rt.forget();
|
|
}
|
|
|
|
already_AddRefed<CompositingRenderTarget>
|
|
BasicCompositor::CreateRenderTargetFromSource(
|
|
const IntRect& aRect, const CompositingRenderTarget* aSource,
|
|
const IntPoint& aSourcePoint) {
|
|
MOZ_CRASH("GFX: Shouldn't be called!");
|
|
return nullptr;
|
|
}
|
|
|
|
already_AddRefed<CompositingRenderTarget>
|
|
BasicCompositor::CreateRenderTargetForWindow(
|
|
const LayoutDeviceIntRect& aRect, const LayoutDeviceIntRect& aClearRect,
|
|
BufferMode aBufferMode) {
|
|
MOZ_ASSERT(mDrawTarget);
|
|
MOZ_ASSERT(!aRect.IsZeroArea(),
|
|
"Trying to create a render target of invalid size");
|
|
|
|
if (aRect.IsZeroArea()) {
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<BasicCompositingRenderTarget> rt;
|
|
IntRect rect = aRect.ToUnknownRect();
|
|
|
|
if (aBufferMode != BufferMode::BUFFER_NONE) {
|
|
RefPtr<DrawTarget> target =
|
|
mWidget->GetBackBufferDrawTarget(mDrawTarget, aRect, aClearRect);
|
|
if (!target) {
|
|
return nullptr;
|
|
}
|
|
MOZ_ASSERT(target != mDrawTarget);
|
|
rt = new BasicCompositingRenderTarget(target, rect);
|
|
} else {
|
|
IntRect windowRect = rect;
|
|
// Adjust bounds rect to account for new origin at (0, 0).
|
|
if (windowRect.Size() != mDrawTarget->GetSize()) {
|
|
windowRect.ExpandToEnclose(IntPoint(0, 0));
|
|
}
|
|
rt = new BasicCompositingRenderTarget(mDrawTarget, windowRect);
|
|
if (!aClearRect.IsEmpty()) {
|
|
IntRect clearRect = aClearRect.ToUnknownRect();
|
|
mDrawTarget->ClearRect(Rect(clearRect - rt->GetOrigin()));
|
|
|
|
if (mFullWindowRenderTarget) {
|
|
mFullWindowRenderTarget->mDrawTarget->ClearRect(Rect(clearRect));
|
|
}
|
|
}
|
|
}
|
|
|
|
return rt.forget();
|
|
}
|
|
|
|
already_AddRefed<DataTextureSource> BasicCompositor::CreateDataTextureSource(
|
|
TextureFlags aFlags) {
|
|
RefPtr<DataTextureSourceBasic> result = new DataTextureSourceBasic(nullptr);
|
|
if (aFlags & TextureFlags::RGB_FROM_YCBCR) {
|
|
result->mFromYCBCR = true;
|
|
}
|
|
return result.forget();
|
|
}
|
|
|
|
already_AddRefed<DataTextureSource>
|
|
BasicCompositor::CreateDataTextureSourceAround(DataSourceSurface* aSurface) {
|
|
RefPtr<DataTextureSource> result = new DataTextureSourceBasic(aSurface);
|
|
return result.forget();
|
|
}
|
|
|
|
already_AddRefed<DataTextureSource>
|
|
BasicCompositor::CreateDataTextureSourceAroundYCbCr(TextureHost* aTexture) {
|
|
BufferTextureHost* bufferTexture = aTexture->AsBufferTextureHost();
|
|
MOZ_ASSERT(bufferTexture);
|
|
|
|
if (!bufferTexture) {
|
|
return nullptr;
|
|
}
|
|
RefPtr<DataTextureSource> result =
|
|
new WrappingTextureSourceYCbCrBasic(bufferTexture);
|
|
return result.forget();
|
|
}
|
|
|
|
bool BasicCompositor::SupportsEffect(EffectTypes aEffect) {
|
|
return aEffect != EffectTypes::YCBCR &&
|
|
aEffect != EffectTypes::COMPONENT_ALPHA;
|
|
}
|
|
|
|
bool BasicCompositor::SupportsLayerGeometry() const {
|
|
return gfxPrefs::BasicLayerGeometry();
|
|
}
|
|
|
|
static RefPtr<gfx::Path> BuildPathFromPolygon(const RefPtr<DrawTarget>& aDT,
|
|
const gfx::Polygon& aPolygon) {
|
|
MOZ_ASSERT(!aPolygon.IsEmpty());
|
|
|
|
RefPtr<PathBuilder> pathBuilder = aDT->CreatePathBuilder();
|
|
const nsTArray<Point4D>& points = aPolygon.GetPoints();
|
|
|
|
pathBuilder->MoveTo(points[0].As2DPoint());
|
|
|
|
for (size_t i = 1; i < points.Length(); ++i) {
|
|
pathBuilder->LineTo(points[i].As2DPoint());
|
|
}
|
|
|
|
pathBuilder->Close();
|
|
return pathBuilder->Finish();
|
|
}
|
|
|
|
static void DrawSurface(gfx::DrawTarget* aDest, const gfx::Rect& aDestRect,
|
|
const gfx::Rect& /* aClipRect */,
|
|
const gfx::Color& aColor,
|
|
const gfx::DrawOptions& aOptions,
|
|
gfx::SourceSurface* aMask,
|
|
const gfx::Matrix* aMaskTransform) {
|
|
FillRectWithMask(aDest, aDestRect, aColor, aOptions, aMask, aMaskTransform);
|
|
}
|
|
|
|
static void DrawSurface(gfx::DrawTarget* aDest, const gfx::Polygon& aPolygon,
|
|
const gfx::Rect& aClipRect, const gfx::Color& aColor,
|
|
const gfx::DrawOptions& aOptions,
|
|
gfx::SourceSurface* aMask,
|
|
const gfx::Matrix* aMaskTransform) {
|
|
RefPtr<Path> path = BuildPathFromPolygon(aDest, aPolygon);
|
|
FillPathWithMask(aDest, path, aClipRect, aColor, aOptions, aMask,
|
|
aMaskTransform);
|
|
}
|
|
|
|
static void DrawTextureSurface(
|
|
gfx::DrawTarget* aDest, const gfx::Rect& aDestRect,
|
|
const gfx::Rect& /* aClipRect */, gfx::SourceSurface* aSource,
|
|
gfx::SamplingFilter aSamplingFilter, const gfx::DrawOptions& aOptions,
|
|
ExtendMode aExtendMode, gfx::SourceSurface* aMask,
|
|
const gfx::Matrix* aMaskTransform, const Matrix* aSurfaceTransform) {
|
|
FillRectWithMask(aDest, aDestRect, aSource, aSamplingFilter, aOptions,
|
|
aExtendMode, aMask, aMaskTransform, aSurfaceTransform);
|
|
}
|
|
|
|
static void DrawTextureSurface(
|
|
gfx::DrawTarget* aDest, const gfx::Polygon& aPolygon,
|
|
const gfx::Rect& aClipRect, gfx::SourceSurface* aSource,
|
|
gfx::SamplingFilter aSamplingFilter, const gfx::DrawOptions& aOptions,
|
|
ExtendMode aExtendMode, gfx::SourceSurface* aMask,
|
|
const gfx::Matrix* aMaskTransform, const Matrix* aSurfaceTransform) {
|
|
RefPtr<Path> path = BuildPathFromPolygon(aDest, aPolygon);
|
|
FillPathWithMask(aDest, path, aClipRect, aSource, aSamplingFilter, aOptions,
|
|
aExtendMode, aMask, aMaskTransform, aSurfaceTransform);
|
|
}
|
|
|
|
template <typename Geometry>
|
|
static void DrawSurfaceWithTextureCoords(
|
|
gfx::DrawTarget* aDest, const Geometry& aGeometry,
|
|
const gfx::Rect& aDestRect, gfx::SourceSurface* aSource,
|
|
const gfx::Rect& aTextureCoords, gfx::SamplingFilter aSamplingFilter,
|
|
const gfx::DrawOptions& aOptions, gfx::SourceSurface* aMask,
|
|
const gfx::Matrix* aMaskTransform) {
|
|
if (!aSource) {
|
|
gfxWarning() << "DrawSurfaceWithTextureCoords problem "
|
|
<< gfx::hexa(aSource) << " and " << gfx::hexa(aMask);
|
|
return;
|
|
}
|
|
|
|
// Convert aTextureCoords into aSource's coordinate space
|
|
gfxRect sourceRect(aTextureCoords.X() * aSource->GetSize().width,
|
|
aTextureCoords.Y() * aSource->GetSize().height,
|
|
aTextureCoords.Width() * aSource->GetSize().width,
|
|
aTextureCoords.Height() * aSource->GetSize().height);
|
|
|
|
// Floating point error can accumulate above and we know our visible region
|
|
// is integer-aligned, so round it out.
|
|
sourceRect.Round();
|
|
|
|
// Compute a transform that maps sourceRect to aDestRect.
|
|
Matrix matrix = gfxUtils::TransformRectToRect(
|
|
sourceRect, gfx::IntPoint::Truncate(aDestRect.X(), aDestRect.Y()),
|
|
gfx::IntPoint::Truncate(aDestRect.XMost(), aDestRect.Y()),
|
|
gfx::IntPoint::Truncate(aDestRect.XMost(), aDestRect.YMost()));
|
|
|
|
// Only use REPEAT if aTextureCoords is outside (0, 0, 1, 1).
|
|
gfx::Rect unitRect(0, 0, 1, 1);
|
|
ExtendMode mode = unitRect.Contains(aTextureCoords) ? ExtendMode::CLAMP
|
|
: ExtendMode::REPEAT;
|
|
|
|
DrawTextureSurface(aDest, aGeometry, aDestRect, aSource, aSamplingFilter,
|
|
aOptions, mode, aMask, aMaskTransform, &matrix);
|
|
}
|
|
|
|
static void SetupMask(const EffectChain& aEffectChain, DrawTarget* aDest,
|
|
const IntPoint& aOffset,
|
|
RefPtr<SourceSurface>& aMaskSurface,
|
|
Matrix& aMaskTransform) {
|
|
if (aEffectChain.mSecondaryEffects[EffectTypes::MASK]) {
|
|
EffectMask* effectMask = static_cast<EffectMask*>(
|
|
aEffectChain.mSecondaryEffects[EffectTypes::MASK].get());
|
|
aMaskSurface = effectMask->mMaskTexture->AsSourceBasic()->GetSurface(aDest);
|
|
if (!aMaskSurface) {
|
|
gfxWarning() << "Invalid sourceMask effect";
|
|
}
|
|
MOZ_ASSERT(effectMask->mMaskTransform.Is2D(),
|
|
"How did we end up with a 3D transform here?!");
|
|
aMaskTransform = effectMask->mMaskTransform.As2D();
|
|
aMaskTransform.PostTranslate(-aOffset.x, -aOffset.y);
|
|
}
|
|
}
|
|
|
|
static bool AttemptVideoScale(TextureSourceBasic* aSource,
|
|
const SourceSurface* aSourceMask,
|
|
gfx::Float aOpacity, CompositionOp aBlendMode,
|
|
const TexturedEffect* aTexturedEffect,
|
|
const Matrix& aNewTransform,
|
|
const gfx::Rect& aRect,
|
|
const gfx::Rect& aClipRect, DrawTarget* aDest,
|
|
const DrawTarget* aBuffer) {
|
|
#ifdef MOZILLA_SSE_HAVE_CPUID_DETECTION
|
|
if (!mozilla::supports_ssse3()) return false;
|
|
if (aNewTransform
|
|
.IsTranslation()) // unscaled painting should take the regular path
|
|
return false;
|
|
if (aNewTransform.HasNonAxisAlignedTransform() ||
|
|
aNewTransform.HasNegativeScaling())
|
|
return false;
|
|
if (aSourceMask || aOpacity != 1.0f) return false;
|
|
if (aBlendMode != CompositionOp::OP_OVER &&
|
|
aBlendMode != CompositionOp::OP_SOURCE)
|
|
return false;
|
|
|
|
IntRect dstRect;
|
|
// the compiler should know a lot about aNewTransform at this point
|
|
// maybe it can do some sophisticated optimization of the following
|
|
if (!aNewTransform.TransformBounds(aRect).ToIntRect(&dstRect)) return false;
|
|
|
|
IntRect clipRect;
|
|
if (!aClipRect.ToIntRect(&clipRect)) return false;
|
|
|
|
if (!(aTexturedEffect->mTextureCoords == Rect(0.0f, 0.0f, 1.0f, 1.0f)))
|
|
return false;
|
|
if (aDest->GetFormat() == SurfaceFormat::R5G6B5_UINT16) return false;
|
|
|
|
uint8_t* dstData;
|
|
IntSize dstSize;
|
|
int32_t dstStride;
|
|
SurfaceFormat dstFormat;
|
|
if (aDest->LockBits(&dstData, &dstSize, &dstStride, &dstFormat)) {
|
|
// If we're not painting to aBuffer the clip will
|
|
// be applied later
|
|
IntRect fillRect = dstRect;
|
|
if (aDest == aBuffer) {
|
|
// we need to clip fillRect because LockBits ignores the clip on the aDest
|
|
fillRect = fillRect.Intersect(clipRect);
|
|
}
|
|
|
|
fillRect = fillRect.Intersect(IntRect(IntPoint(0, 0), aDest->GetSize()));
|
|
IntPoint offset = fillRect.TopLeft() - dstRect.TopLeft();
|
|
|
|
RefPtr<DataSourceSurface> srcSource =
|
|
aSource->GetSurface(aDest)->GetDataSurface();
|
|
DataSourceSurface::ScopedMap mapSrc(srcSource, DataSourceSurface::READ);
|
|
|
|
bool success = ssse3_scale_data(
|
|
(uint32_t*)mapSrc.GetData(), srcSource->GetSize().width,
|
|
srcSource->GetSize().height, mapSrc.GetStride() / 4,
|
|
((uint32_t*)dstData) + fillRect.X() + (dstStride / 4) * fillRect.Y(),
|
|
dstRect.Width(), dstRect.Height(), dstStride / 4, offset.x, offset.y,
|
|
fillRect.Width(), fillRect.Height());
|
|
|
|
aDest->ReleaseBits(dstData);
|
|
return success;
|
|
} else
|
|
#endif // MOZILLA_SSE_HAVE_CPUID_DETECTION
|
|
return false;
|
|
}
|
|
|
|
static bool AttemptVideoConvertAndScale(
|
|
TextureSource* aSource, const SourceSurface* aSourceMask,
|
|
gfx::Float aOpacity, CompositionOp aBlendMode,
|
|
const TexturedEffect* aTexturedEffect, const Matrix& aNewTransform,
|
|
const gfx::Rect& aRect, const gfx::Rect& aClipRect, DrawTarget* aDest,
|
|
const DrawTarget* aBuffer) {
|
|
#if defined(XP_WIN) && defined(_M_X64)
|
|
// libyuv does not support SIMD scaling on win 64bit. See Bug 1295927.
|
|
return false;
|
|
#endif
|
|
|
|
WrappingTextureSourceYCbCrBasic* wrappingSource =
|
|
aSource->AsWrappingTextureSourceYCbCrBasic();
|
|
if (!wrappingSource) return false;
|
|
#ifdef MOZILLA_SSE_HAVE_CPUID_DETECTION
|
|
if (!mozilla::supports_ssse3()) // libyuv requests SSSE3 for fast YUV
|
|
// conversion.
|
|
return false;
|
|
if (aNewTransform.HasNonAxisAlignedTransform() ||
|
|
aNewTransform.HasNegativeScaling())
|
|
return false;
|
|
if (aSourceMask || aOpacity != 1.0f) return false;
|
|
if (aBlendMode != CompositionOp::OP_OVER &&
|
|
aBlendMode != CompositionOp::OP_SOURCE)
|
|
return false;
|
|
|
|
IntRect dstRect;
|
|
// the compiler should know a lot about aNewTransform at this point
|
|
// maybe it can do some sophisticated optimization of the following
|
|
if (!aNewTransform.TransformBounds(aRect).ToIntRect(&dstRect)) return false;
|
|
|
|
IntRect clipRect;
|
|
if (!aClipRect.ToIntRect(&clipRect)) return false;
|
|
|
|
if (!(aTexturedEffect->mTextureCoords == Rect(0.0f, 0.0f, 1.0f, 1.0f)))
|
|
return false;
|
|
if (aDest->GetFormat() == SurfaceFormat::R5G6B5_UINT16) return false;
|
|
|
|
if (aDest == aBuffer && !clipRect.Contains(dstRect)) return false;
|
|
if (!IntRect(IntPoint(0, 0), aDest->GetSize()).Contains(dstRect))
|
|
return false;
|
|
|
|
uint8_t* dstData;
|
|
IntSize dstSize;
|
|
int32_t dstStride;
|
|
SurfaceFormat dstFormat;
|
|
if (aDest->LockBits(&dstData, &dstSize, &dstStride, &dstFormat)) {
|
|
wrappingSource->ConvertAndScale(
|
|
dstFormat, dstRect.Size(),
|
|
dstData + ptrdiff_t(dstRect.X()) * BytesPerPixel(dstFormat) +
|
|
ptrdiff_t(dstRect.Y()) * dstStride,
|
|
dstStride);
|
|
aDest->ReleaseBits(dstData);
|
|
return true;
|
|
} else
|
|
#endif // MOZILLA_SSE_HAVE_CPUID_DETECTION
|
|
return false;
|
|
}
|
|
|
|
void BasicCompositor::DrawQuad(const gfx::Rect& aRect,
|
|
const gfx::IntRect& aClipRect,
|
|
const EffectChain& aEffectChain,
|
|
gfx::Float aOpacity,
|
|
const gfx::Matrix4x4& aTransform,
|
|
const gfx::Rect& aVisibleRect) {
|
|
DrawGeometry(aRect, aRect, aClipRect, aEffectChain, aOpacity, aTransform,
|
|
aVisibleRect, true);
|
|
}
|
|
|
|
void BasicCompositor::DrawPolygon(const gfx::Polygon& aPolygon,
|
|
const gfx::Rect& aRect,
|
|
const gfx::IntRect& aClipRect,
|
|
const EffectChain& aEffectChain,
|
|
gfx::Float aOpacity,
|
|
const gfx::Matrix4x4& aTransform,
|
|
const gfx::Rect& aVisibleRect) {
|
|
DrawGeometry(aPolygon, aRect, aClipRect, aEffectChain, aOpacity, aTransform,
|
|
aVisibleRect, false);
|
|
}
|
|
|
|
template <typename Geometry>
|
|
void BasicCompositor::DrawGeometry(
|
|
const Geometry& aGeometry, const gfx::Rect& aRect,
|
|
const gfx::IntRect& aClipRect, const EffectChain& aEffectChain,
|
|
gfx::Float aOpacity, const gfx::Matrix4x4& aTransform,
|
|
const gfx::Rect& aVisibleRect, const bool aEnableAA) {
|
|
RefPtr<DrawTarget> buffer = mRenderTarget->mDrawTarget;
|
|
|
|
// For 2D drawing, |dest| and |buffer| are the same surface. For 3D drawing,
|
|
// |dest| is a temporary surface.
|
|
RefPtr<DrawTarget> dest = buffer;
|
|
|
|
AutoRestoreTransform autoRestoreTransform(dest);
|
|
|
|
Matrix newTransform;
|
|
Rect transformBounds;
|
|
Matrix4x4 new3DTransform;
|
|
IntPoint offset = mRenderTarget->GetOrigin();
|
|
|
|
if (aTransform.Is2D()) {
|
|
newTransform = aTransform.As2D();
|
|
} else {
|
|
// Create a temporary surface for the transform.
|
|
dest = Factory::CreateDrawTarget(gfxVars::ContentBackend(),
|
|
RoundedOut(aRect).Size(),
|
|
SurfaceFormat::B8G8R8A8);
|
|
if (!dest) {
|
|
return;
|
|
}
|
|
|
|
dest->SetTransform(Matrix::Translation(-aRect.X(), -aRect.Y()));
|
|
|
|
// Get the bounds post-transform.
|
|
transformBounds = aTransform.TransformAndClipBounds(
|
|
aRect, Rect(offset.x, offset.y, buffer->GetSize().width,
|
|
buffer->GetSize().height));
|
|
transformBounds.RoundOut();
|
|
|
|
if (transformBounds.IsEmpty()) {
|
|
return;
|
|
}
|
|
|
|
newTransform = Matrix();
|
|
|
|
// When we apply the 3D transformation, we do it against a temporary
|
|
// surface, so undo the coordinate offset.
|
|
new3DTransform = aTransform;
|
|
new3DTransform.PreTranslate(aRect.X(), aRect.Y(), 0);
|
|
}
|
|
|
|
// XXX the transform is probably just an integer offset so this whole
|
|
// business here is a bit silly.
|
|
Rect transformedClipRect =
|
|
buffer->GetTransform().TransformBounds(Rect(aClipRect));
|
|
|
|
buffer->PushClipRect(Rect(aClipRect));
|
|
|
|
newTransform.PostTranslate(-offset.x, -offset.y);
|
|
buffer->SetTransform(newTransform);
|
|
|
|
RefPtr<SourceSurface> sourceMask;
|
|
Matrix maskTransform;
|
|
if (aTransform.Is2D()) {
|
|
SetupMask(aEffectChain, dest, offset, sourceMask, maskTransform);
|
|
}
|
|
|
|
CompositionOp blendMode = CompositionOp::OP_OVER;
|
|
if (Effect* effect =
|
|
aEffectChain.mSecondaryEffects[EffectTypes::BLEND_MODE].get()) {
|
|
blendMode = static_cast<EffectBlendMode*>(effect)->mBlendMode;
|
|
}
|
|
|
|
const AntialiasMode aaMode =
|
|
aEnableAA ? AntialiasMode::DEFAULT : AntialiasMode::NONE;
|
|
|
|
DrawOptions drawOptions(aOpacity, blendMode, aaMode);
|
|
|
|
switch (aEffectChain.mPrimaryEffect->mType) {
|
|
case EffectTypes::SOLID_COLOR: {
|
|
EffectSolidColor* effectSolidColor =
|
|
static_cast<EffectSolidColor*>(aEffectChain.mPrimaryEffect.get());
|
|
|
|
bool unboundedOp = !IsOperatorBoundByMask(blendMode);
|
|
if (unboundedOp) {
|
|
dest->PushClipRect(aRect);
|
|
}
|
|
|
|
DrawSurface(dest, aGeometry, aRect, effectSolidColor->mColor, drawOptions,
|
|
sourceMask, &maskTransform);
|
|
|
|
if (unboundedOp) {
|
|
dest->PopClip();
|
|
}
|
|
break;
|
|
}
|
|
case EffectTypes::RGB: {
|
|
TexturedEffect* texturedEffect =
|
|
static_cast<TexturedEffect*>(aEffectChain.mPrimaryEffect.get());
|
|
TextureSourceBasic* source = texturedEffect->mTexture->AsSourceBasic();
|
|
|
|
if (source && texturedEffect->mPremultiplied) {
|
|
// we have a fast path for video here
|
|
if (source->mFromYCBCR &&
|
|
AttemptVideoConvertAndScale(texturedEffect->mTexture, sourceMask,
|
|
aOpacity, blendMode, texturedEffect,
|
|
newTransform, aRect,
|
|
transformedClipRect, dest, buffer)) {
|
|
// we succeeded in convert and scaling
|
|
} else if (source->mFromYCBCR && !source->GetSurface(dest)) {
|
|
gfxWarning() << "Failed to get YCbCr to rgb surface.";
|
|
} else if (source->mFromYCBCR &&
|
|
AttemptVideoScale(source, sourceMask, aOpacity, blendMode,
|
|
texturedEffect, newTransform, aRect,
|
|
transformedClipRect, dest, buffer)) {
|
|
// we succeeded in scaling
|
|
} else {
|
|
DrawSurfaceWithTextureCoords(
|
|
dest, aGeometry, aRect, source->GetSurface(dest),
|
|
texturedEffect->mTextureCoords, texturedEffect->mSamplingFilter,
|
|
drawOptions, sourceMask, &maskTransform);
|
|
}
|
|
} else if (source) {
|
|
SourceSurface* srcSurf = source->GetSurface(dest);
|
|
if (srcSurf) {
|
|
RefPtr<DataSourceSurface> srcData = srcSurf->GetDataSurface();
|
|
|
|
// Yes, we re-create the premultiplied data every time.
|
|
// This might be better with a cache, eventually.
|
|
RefPtr<DataSourceSurface> premultData =
|
|
gfxUtils::CreatePremultipliedDataSurface(srcData);
|
|
|
|
DrawSurfaceWithTextureCoords(dest, aGeometry, aRect, premultData,
|
|
texturedEffect->mTextureCoords,
|
|
texturedEffect->mSamplingFilter,
|
|
drawOptions, sourceMask, &maskTransform);
|
|
}
|
|
} else {
|
|
gfxDevCrash(LogReason::IncompatibleBasicTexturedEffect)
|
|
<< "Bad for basic with " << texturedEffect->mTexture->Name()
|
|
<< " and " << gfx::hexa(sourceMask);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case EffectTypes::YCBCR: {
|
|
MOZ_CRASH("Can't (easily) support component alpha with BasicCompositor!");
|
|
break;
|
|
}
|
|
case EffectTypes::RENDER_TARGET: {
|
|
EffectRenderTarget* effectRenderTarget =
|
|
static_cast<EffectRenderTarget*>(aEffectChain.mPrimaryEffect.get());
|
|
RefPtr<BasicCompositingRenderTarget> surface =
|
|
static_cast<BasicCompositingRenderTarget*>(
|
|
effectRenderTarget->mRenderTarget.get());
|
|
RefPtr<SourceSurface> sourceSurf = surface->mDrawTarget->Snapshot();
|
|
|
|
DrawSurfaceWithTextureCoords(dest, aGeometry, aRect, sourceSurf,
|
|
effectRenderTarget->mTextureCoords,
|
|
effectRenderTarget->mSamplingFilter,
|
|
drawOptions, sourceMask, &maskTransform);
|
|
break;
|
|
}
|
|
case EffectTypes::COMPONENT_ALPHA: {
|
|
MOZ_CRASH("Can't (easily) support component alpha with BasicCompositor!");
|
|
break;
|
|
}
|
|
default: {
|
|
MOZ_CRASH("Invalid effect type!");
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!aTransform.Is2D()) {
|
|
dest->Flush();
|
|
|
|
RefPtr<SourceSurface> destSnapshot = dest->Snapshot();
|
|
|
|
SetupMask(aEffectChain, buffer, offset, sourceMask, maskTransform);
|
|
|
|
if (sourceMask) {
|
|
RefPtr<DrawTarget> transformDT = dest->CreateSimilarDrawTarget(
|
|
IntSize::Truncate(transformBounds.Width(), transformBounds.Height()),
|
|
SurfaceFormat::B8G8R8A8);
|
|
new3DTransform.PostTranslate(-transformBounds.X(), -transformBounds.Y(),
|
|
0);
|
|
if (transformDT &&
|
|
transformDT->Draw3DTransformedSurface(destSnapshot, new3DTransform)) {
|
|
RefPtr<SourceSurface> transformSnapshot = transformDT->Snapshot();
|
|
|
|
// Transform the source by it's normal transform, and then the inverse
|
|
// of the mask transform so that it's in the mask's untransformed
|
|
// coordinate space.
|
|
Matrix sourceTransform = newTransform;
|
|
sourceTransform.PostTranslate(transformBounds.TopLeft());
|
|
|
|
Matrix inverseMask = maskTransform;
|
|
inverseMask.Invert();
|
|
|
|
sourceTransform *= inverseMask;
|
|
|
|
SurfacePattern source(transformSnapshot, ExtendMode::CLAMP,
|
|
sourceTransform);
|
|
|
|
buffer->PushClipRect(transformBounds);
|
|
|
|
// Mask in the untransformed coordinate space, and then transform
|
|
// by the mask transform to put the result back into destination
|
|
// coords.
|
|
buffer->SetTransform(maskTransform);
|
|
buffer->MaskSurface(source, sourceMask, Point(0, 0));
|
|
|
|
buffer->PopClip();
|
|
}
|
|
} else {
|
|
buffer->Draw3DTransformedSurface(destSnapshot, new3DTransform);
|
|
}
|
|
}
|
|
|
|
buffer->PopClip();
|
|
}
|
|
|
|
void BasicCompositor::ClearRect(const gfx::Rect& aRect) {
|
|
mRenderTarget->mDrawTarget->ClearRect(aRect);
|
|
|
|
if (mFullWindowRenderTarget) {
|
|
mFullWindowRenderTarget->mDrawTarget->ClearRect(aRect);
|
|
}
|
|
}
|
|
|
|
bool BasicCompositor::ReadbackRenderTarget(CompositingRenderTarget* aSource,
|
|
AsyncReadbackBuffer* aDest) {
|
|
RefPtr<SourceSurface> snapshot =
|
|
static_cast<BasicCompositingRenderTarget*>(aSource)
|
|
->mDrawTarget->Snapshot();
|
|
static_cast<BasicAsyncReadbackBuffer*>(aDest)->TakeSurface(snapshot);
|
|
return true;
|
|
}
|
|
|
|
already_AddRefed<AsyncReadbackBuffer>
|
|
BasicCompositor::CreateAsyncReadbackBuffer(const gfx::IntSize& aSize) {
|
|
return MakeAndAddRef<BasicAsyncReadbackBuffer>(aSize);
|
|
}
|
|
|
|
bool BasicCompositor::BlitRenderTarget(CompositingRenderTarget* aSource,
|
|
const gfx::IntSize& aSourceSize,
|
|
const gfx::IntSize& aDestSize) {
|
|
RefPtr<SourceSurface> surface =
|
|
static_cast<BasicCompositingRenderTarget*>(aSource)
|
|
->mDrawTarget->Snapshot();
|
|
mRenderTarget->mDrawTarget->DrawSurface(
|
|
surface, Rect(Point(), Size(aDestSize)), Rect(Point(), Size(aSourceSize)),
|
|
DrawSurfaceOptions(), DrawOptions(1.0f, CompositionOp::OP_SOURCE));
|
|
return true;
|
|
}
|
|
|
|
void BasicCompositor::BeginFrame(
|
|
const nsIntRegion& aInvalidRegion, const gfx::IntRect* aClipRectIn,
|
|
const gfx::IntRect& aRenderBounds, const nsIntRegion& aOpaqueRegion,
|
|
gfx::IntRect* aClipRectOut /* = nullptr */,
|
|
gfx::IntRect* aRenderBoundsOut /* = nullptr */) {
|
|
if (mIsPendingEndRemoteDrawing) {
|
|
// Force to end previous remote drawing.
|
|
TryToEndRemoteDrawing(/* aForceToEnd */ true);
|
|
MOZ_ASSERT(!mIsPendingEndRemoteDrawing);
|
|
}
|
|
|
|
LayoutDeviceIntRect intRect(LayoutDeviceIntPoint(), mWidget->GetClientSize());
|
|
IntRect rect = IntRect(0, 0, intRect.Width(), intRect.Height());
|
|
|
|
const bool shouldInvalidateWindow =
|
|
(ShouldRecordFrames() &&
|
|
(!mFullWindowRenderTarget ||
|
|
mFullWindowRenderTarget->mDrawTarget->GetSize() !=
|
|
rect.ToUnknownRect().Size()));
|
|
|
|
if (shouldInvalidateWindow) {
|
|
mInvalidRegion = intRect;
|
|
} else {
|
|
LayoutDeviceIntRegion invalidRegionSafe;
|
|
// Sometimes the invalid region is larger than we want to draw.
|
|
invalidRegionSafe.And(
|
|
LayoutDeviceIntRegion::FromUnknownRegion(aInvalidRegion), intRect);
|
|
|
|
mInvalidRegion = invalidRegionSafe;
|
|
}
|
|
|
|
mInvalidRect = mInvalidRegion.GetBounds();
|
|
|
|
if (aRenderBoundsOut) {
|
|
*aRenderBoundsOut = IntRect();
|
|
}
|
|
|
|
BufferMode bufferMode = BufferMode::BUFFERED;
|
|
if (mTarget) {
|
|
// If we have a copy target, then we don't have a widget-provided
|
|
// mDrawTarget (currently). Use a dummy placeholder so that
|
|
// CreateRenderTarget() works. This is only used to create a new buffered
|
|
// draw target that we composite into, then copy the results the
|
|
// destination.
|
|
mDrawTarget = mTarget;
|
|
bufferMode = BufferMode::BUFFER_NONE;
|
|
} else {
|
|
// StartRemoteDrawingInRegion can mutate mInvalidRegion.
|
|
mDrawTarget =
|
|
mWidget->StartRemoteDrawingInRegion(mInvalidRegion, &bufferMode);
|
|
if (!mDrawTarget) {
|
|
return;
|
|
}
|
|
mInvalidRect = mInvalidRegion.GetBounds();
|
|
if (mInvalidRect.IsEmpty()) {
|
|
mWidget->EndRemoteDrawingInRegion(mDrawTarget, mInvalidRegion);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!mDrawTarget || mInvalidRect.IsEmpty()) {
|
|
return;
|
|
}
|
|
|
|
LayoutDeviceIntRect clearRect;
|
|
if (!aOpaqueRegion.IsEmpty()) {
|
|
LayoutDeviceIntRegion clearRegion = mInvalidRegion;
|
|
clearRegion.SubOut(LayoutDeviceIntRegion::FromUnknownRegion(aOpaqueRegion));
|
|
clearRect = clearRegion.GetBounds();
|
|
} else {
|
|
clearRect = mInvalidRect;
|
|
}
|
|
|
|
// Prevent CreateRenderTargetForWindow from clearing unwanted area.
|
|
gfxUtils::ClipToRegion(mDrawTarget, mInvalidRegion.ToUnknownRegion());
|
|
|
|
// Setup an intermediate render target to buffer all compositing. We will
|
|
// copy this into mDrawTarget (the widget), and/or mTarget in EndFrame()
|
|
RefPtr<CompositingRenderTarget> target =
|
|
CreateRenderTargetForWindow(mInvalidRect, clearRect, bufferMode);
|
|
|
|
if (ShouldRecordFrames()) {
|
|
IntSize windowSize = rect.ToUnknownRect().Size();
|
|
|
|
// On some platforms (notably Linux with X11) we do not always have a
|
|
// full-size draw target. While capturing profiles with screenshots, we need
|
|
// access to a full-size target so we can record the contents.
|
|
if (!mFullWindowRenderTarget ||
|
|
mFullWindowRenderTarget->mDrawTarget->GetSize() != windowSize) {
|
|
// We have either (1) just started recording and not yet allocated a
|
|
// buffer or (2) are already recording and have resized the window. In
|
|
// either case, we need a new render target.
|
|
RefPtr<gfx::DrawTarget> drawTarget = mDrawTarget->CreateSimilarDrawTarget(
|
|
windowSize, mDrawTarget->GetFormat());
|
|
|
|
mFullWindowRenderTarget =
|
|
new BasicCompositingRenderTarget(drawTarget, rect);
|
|
}
|
|
}
|
|
|
|
mDrawTarget->PopClip();
|
|
|
|
if (!target) {
|
|
if (!mTarget) {
|
|
mWidget->EndRemoteDrawingInRegion(mDrawTarget, mInvalidRegion);
|
|
}
|
|
return;
|
|
}
|
|
SetRenderTarget(target);
|
|
|
|
// We only allocate a surface sized to the invalidated region, so we need to
|
|
// translate future coordinates.
|
|
mRenderTarget->mDrawTarget->SetTransform(
|
|
Matrix::Translation(-mRenderTarget->GetOrigin()));
|
|
|
|
gfxUtils::ClipToRegion(mRenderTarget->mDrawTarget,
|
|
mInvalidRegion.ToUnknownRegion());
|
|
|
|
if (aRenderBoundsOut) {
|
|
*aRenderBoundsOut = rect;
|
|
}
|
|
|
|
if (aClipRectIn) {
|
|
mRenderTarget->mDrawTarget->PushClipRect(Rect(*aClipRectIn));
|
|
} else {
|
|
mRenderTarget->mDrawTarget->PushClipRect(Rect(rect));
|
|
if (aClipRectOut) {
|
|
*aClipRectOut = rect;
|
|
}
|
|
}
|
|
}
|
|
|
|
void BasicCompositor::EndFrame() {
|
|
Compositor::EndFrame();
|
|
|
|
// Pop aClipRectIn/bounds rect
|
|
mRenderTarget->mDrawTarget->PopClip();
|
|
|
|
if (gfxPrefs::WidgetUpdateFlashing()) {
|
|
float r = float(rand()) / RAND_MAX;
|
|
float g = float(rand()) / RAND_MAX;
|
|
float b = float(rand()) / RAND_MAX;
|
|
// We're still clipped to mInvalidRegion, so just fill the bounds.
|
|
mRenderTarget->mDrawTarget->FillRect(
|
|
IntRectToRect(mInvalidRegion.GetBounds()).ToUnknownRect(),
|
|
ColorPattern(Color(r, g, b, 0.2f)));
|
|
}
|
|
|
|
// Pop aInvalidregion
|
|
mRenderTarget->mDrawTarget->PopClip();
|
|
|
|
TryToEndRemoteDrawing();
|
|
|
|
// If we are no longer recording a profile, we can drop the render target if
|
|
// it exists.
|
|
if (mFullWindowRenderTarget && !ShouldRecordFrames()) {
|
|
mFullWindowRenderTarget = nullptr;
|
|
}
|
|
}
|
|
|
|
void BasicCompositor::TryToEndRemoteDrawing(bool aForceToEnd) {
|
|
if (mIsDestroyed || !mRenderTarget) {
|
|
return;
|
|
}
|
|
|
|
// It it is not a good timing for EndRemoteDrawing, defter to call it.
|
|
if (!aForceToEnd && !mTarget && NeedsToDeferEndRemoteDrawing()) {
|
|
mIsPendingEndRemoteDrawing = true;
|
|
|
|
const uint32_t retryMs = 2;
|
|
RefPtr<BasicCompositor> self = this;
|
|
RefPtr<Runnable> runnable =
|
|
NS_NewRunnableFunction("layers::BasicCompositor::TryToEndRemoteDrawing",
|
|
[self]() { self->TryToEndRemoteDrawing(); });
|
|
MessageLoop::current()->PostDelayedTask(runnable.forget(), retryMs);
|
|
return;
|
|
}
|
|
|
|
if (mRenderTarget->mDrawTarget != mDrawTarget || mFullWindowRenderTarget) {
|
|
RefPtr<SourceSurface> source;
|
|
|
|
// Note: Most platforms require us to buffer drawing to the widget
|
|
// surface. That's why we don't draw to mDrawTarget directly.
|
|
IntPoint srcOffset = mRenderTarget->GetOrigin();
|
|
IntPoint dstOffset = mTarget ? mTargetBounds.TopLeft() : IntPoint();
|
|
|
|
if (mRenderTarget->mDrawTarget != mDrawTarget) {
|
|
source = mWidget->EndBackBufferDrawing();
|
|
|
|
// The source DrawTarget is clipped to the invalidation region, so we have
|
|
// to copy the individual rectangles in the region or else we'll draw
|
|
// blank pixels.
|
|
for (auto iter = mInvalidRegion.RectIter(); !iter.Done(); iter.Next()) {
|
|
const LayoutDeviceIntRect& r = iter.Get();
|
|
mDrawTarget->CopySurface(source, r.ToUnknownRect() - srcOffset,
|
|
r.TopLeft().ToUnknownPoint() - dstOffset);
|
|
}
|
|
} else {
|
|
source = mRenderTarget->mDrawTarget->Snapshot();
|
|
}
|
|
|
|
if (mFullWindowRenderTarget) {
|
|
for (auto iter = mInvalidRegion.RectIter(); !iter.Done(); iter.Next()) {
|
|
const LayoutDeviceIntRect& r = iter.Get();
|
|
mFullWindowRenderTarget->mDrawTarget->CopySurface(
|
|
source, r.ToUnknownRect() - srcOffset,
|
|
r.TopLeft().ToUnknownPoint() - dstOffset);
|
|
}
|
|
|
|
mFullWindowRenderTarget->mDrawTarget->Flush();
|
|
}
|
|
}
|
|
|
|
if (aForceToEnd || !mTarget) {
|
|
mWidget->EndRemoteDrawingInRegion(mDrawTarget, mInvalidRegion);
|
|
}
|
|
|
|
mDrawTarget = nullptr;
|
|
mRenderTarget = nullptr;
|
|
mIsPendingEndRemoteDrawing = false;
|
|
}
|
|
|
|
bool BasicCompositor::NeedsToDeferEndRemoteDrawing() {
|
|
MOZ_ASSERT(mDrawTarget);
|
|
MOZ_ASSERT(mRenderTarget);
|
|
|
|
if (mTarget || mRenderTarget->mDrawTarget == mDrawTarget) {
|
|
return false;
|
|
}
|
|
|
|
return mWidget->NeedsToDeferEndRemoteDrawing();
|
|
}
|
|
|
|
void BasicCompositor::FinishPendingComposite() {
|
|
TryToEndRemoteDrawing(/* aForceToEnd */ true);
|
|
}
|
|
|
|
bool BasicCompositor::ShouldRecordFrames() const {
|
|
#ifdef MOZ_GECKO_PROFILER
|
|
return profiler_feature_active(ProfilerFeature::Screenshots) || mRecordFrames;
|
|
#else
|
|
return mRecordFrames;
|
|
#endif // MOZ_GECKO_PROFILER
|
|
}
|
|
|
|
} // namespace layers
|
|
} // namespace mozilla
|