зеркало из https://github.com/mozilla/gecko-dev.git
Bug 1727684 - Remove ContentHost/ImageHost. r=jrmuizel
Differential Revision: https://phabricator.services.mozilla.com/D123881
This commit is contained in:
Matt Woodrow
Родитель
8577eff6ca
Коммит
7960f3b11b
|
|
@ -156,10 +156,7 @@ enum class EffectTypes : uint8_t {
|
|||
*/
|
||||
enum class CompositableType : uint8_t {
|
||||
UNKNOWN,
|
||||
CONTENT_TILED, // tiled painted layer
|
||||
IMAGE, // image with single buffering
|
||||
CONTENT_SINGLE, // painted layer interface, single buffering
|
||||
CONTENT_DOUBLE, // painted layer interface, double buffering
|
||||
COUNT
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,6 @@
|
|||
#include "nsRect.h" // for IntRect
|
||||
#include "nsTArray.h" // for AutoTArray, nsTArray_Impl
|
||||
#include "mozilla/Poison.h"
|
||||
#include "mozilla/layers/ImageHost.h"
|
||||
#include "TreeTraversal.h" // for ForEachNode
|
||||
|
||||
// LayerTreeInvalidation debugging
|
||||
|
|
@ -613,32 +612,16 @@ struct ColorLayerProperties : public LayerPropertiesBase {
|
|||
IntRect mBounds;
|
||||
};
|
||||
|
||||
static ImageHost* GetImageHost(Layer* aLayer) { return nullptr; }
|
||||
|
||||
struct ImageLayerProperties : public LayerPropertiesBase {
|
||||
explicit ImageLayerProperties(ImageLayer* aImage, bool aIsMask)
|
||||
: LayerPropertiesBase(aImage),
|
||||
mContainer(aImage->GetContainer()),
|
||||
mImageHost(GetImageHost(aImage)),
|
||||
mSamplingFilter(aImage->GetSamplingFilter()),
|
||||
mScaleToSize(aImage->GetScaleToSize()),
|
||||
mScaleMode(aImage->GetScaleMode()),
|
||||
mLastProducerID(-1),
|
||||
mLastFrameID(-1),
|
||||
mIsMask(aIsMask) {
|
||||
if (mImageHost) {
|
||||
if (aIsMask) {
|
||||
// Mask layers never set the 'last' producer/frame
|
||||
// id, since they never get composited as their own
|
||||
// layer.
|
||||
mLastProducerID = mImageHost->GetProducerID();
|
||||
mLastFrameID = mImageHost->GetFrameID();
|
||||
} else {
|
||||
mLastProducerID = mImageHost->GetLastProducerID();
|
||||
mLastFrameID = mImageHost->GetLastFrameID();
|
||||
}
|
||||
}
|
||||
}
|
||||
mIsMask(aIsMask) {}
|
||||
|
||||
bool ComputeChangeInternal(const char* aPrefix, nsIntRegion& aOutRegion,
|
||||
NotifySubDocInvalidationFunc aCallback) override {
|
||||
|
|
@ -653,13 +636,10 @@ struct ImageLayerProperties : public LayerPropertiesBase {
|
|||
}
|
||||
|
||||
ImageContainer* container = imageLayer->GetContainer();
|
||||
ImageHost* host = GetImageHost(imageLayer);
|
||||
if (mContainer != container ||
|
||||
mSamplingFilter != imageLayer->GetSamplingFilter() ||
|
||||
mScaleToSize != imageLayer->GetScaleToSize() ||
|
||||
mScaleMode != imageLayer->GetScaleMode() || host != mImageHost ||
|
||||
(host && host->GetProducerID() != mLastProducerID) ||
|
||||
(host && host->GetFrameID() != mLastFrameID)) {
|
||||
mScaleMode != imageLayer->GetScaleMode()) {
|
||||
if (mIsMask) {
|
||||
// Mask layers have an empty visible region, so we have to
|
||||
// use the image size instead.
|
||||
|
|
@ -667,9 +647,6 @@ struct ImageLayerProperties : public LayerPropertiesBase {
|
|||
if (container) {
|
||||
size = container->GetCurrentSize();
|
||||
}
|
||||
if (host) {
|
||||
size = host->GetImageSize();
|
||||
}
|
||||
IntRect rect(0, 0, size.width, size.height);
|
||||
LTI_DUMP(rect, "mask");
|
||||
aOutRegion = TransformRect(rect, GetTransformForInvalidation(mLayer));
|
||||
|
|
@ -684,7 +661,6 @@ struct ImageLayerProperties : public LayerPropertiesBase {
|
|||
}
|
||||
|
||||
RefPtr<ImageContainer> mContainer;
|
||||
RefPtr<ImageHost> mImageHost;
|
||||
SamplingFilter mSamplingFilter;
|
||||
gfx::IntSize mScaleToSize;
|
||||
ScaleMode mScaleMode;
|
||||
|
|
@ -693,30 +669,6 @@ struct ImageLayerProperties : public LayerPropertiesBase {
|
|||
bool mIsMask;
|
||||
};
|
||||
|
||||
struct CanvasLayerProperties : public LayerPropertiesBase {
|
||||
explicit CanvasLayerProperties(CanvasLayer* aCanvas)
|
||||
: LayerPropertiesBase(aCanvas), mImageHost(GetImageHost(aCanvas)) {
|
||||
mFrameID = mImageHost ? mImageHost->GetFrameID() : -1;
|
||||
}
|
||||
|
||||
bool ComputeChangeInternal(const char* aPrefix, nsIntRegion& aOutRegion,
|
||||
NotifySubDocInvalidationFunc aCallback) override {
|
||||
CanvasLayer* canvasLayer = static_cast<CanvasLayer*>(mLayer.get());
|
||||
|
||||
ImageHost* host = GetImageHost(canvasLayer);
|
||||
if (host && host->GetFrameID() != mFrameID) {
|
||||
LTI_DUMP(NewTransformedBoundsForLeaf(), "frameId");
|
||||
aOutRegion = NewTransformedBoundsForLeaf();
|
||||
return true;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
RefPtr<ImageHost> mImageHost;
|
||||
int32_t mFrameID;
|
||||
};
|
||||
|
||||
UniquePtr<LayerPropertiesBase> CloneLayerTreePropertiesInternal(
|
||||
Layer* aRoot, bool aIsMask /* = false */) {
|
||||
if (!aRoot) {
|
||||
|
|
@ -737,8 +689,6 @@ UniquePtr<LayerPropertiesBase> CloneLayerTreePropertiesInternal(
|
|||
return MakeUnique<ImageLayerProperties>(static_cast<ImageLayer*>(aRoot),
|
||||
aIsMask);
|
||||
case Layer::TYPE_CANVAS:
|
||||
return MakeUnique<CanvasLayerProperties>(
|
||||
static_cast<CanvasLayer*>(aRoot));
|
||||
case Layer::TYPE_DISPLAYITEM:
|
||||
case Layer::TYPE_READBACK:
|
||||
case Layer::TYPE_SHADOW:
|
||||
|
|
|
|||
|
|
@ -7,10 +7,8 @@
|
|||
#include "CompositableHost.h"
|
||||
#include <map> // for _Rb_tree_iterator, map, etc
|
||||
#include <utility> // for pair
|
||||
#include "ContentHost.h" // for ContentHostDoubleBuffered, etc
|
||||
#include "Effects.h" // for EffectMask, Effect, etc
|
||||
#include "gfxUtils.h"
|
||||
#include "ImageHost.h" // for ImageHostBuffered, etc
|
||||
#include "Layers.h"
|
||||
#include "mozilla/gfx/gfxVars.h"
|
||||
#include "mozilla/layers/LayersSurfaces.h" // for SurfaceDescriptor
|
||||
|
|
@ -106,26 +104,11 @@ void CompositableHost::RemoveMaskEffect() {
|
|||
|
||||
/* static */
|
||||
already_AddRefed<CompositableHost> CompositableHost::Create(
|
||||
const TextureInfo& aTextureInfo, bool aUseWebRender) {
|
||||
const TextureInfo& aTextureInfo) {
|
||||
RefPtr<CompositableHost> result;
|
||||
switch (aTextureInfo.mCompositableType) {
|
||||
case CompositableType::IMAGE:
|
||||
if (aUseWebRender) {
|
||||
result = new WebRenderImageHost(aTextureInfo);
|
||||
} else {
|
||||
result = new ImageHost(aTextureInfo);
|
||||
}
|
||||
break;
|
||||
case CompositableType::CONTENT_SINGLE:
|
||||
if (aUseWebRender) {
|
||||
result = new WebRenderImageHost(aTextureInfo);
|
||||
} else {
|
||||
result = new ContentHostSingleBuffered(aTextureInfo);
|
||||
}
|
||||
break;
|
||||
case CompositableType::CONTENT_DOUBLE:
|
||||
MOZ_ASSERT(!aUseWebRender);
|
||||
result = new ContentHostDoubleBuffered(aTextureInfo);
|
||||
break;
|
||||
default:
|
||||
NS_ERROR("Unknown CompositableType");
|
||||
|
|
|
|||
|
|
@ -88,7 +88,7 @@ class CompositableHost {
|
|||
explicit CompositableHost(const TextureInfo& aTextureInfo);
|
||||
|
||||
static already_AddRefed<CompositableHost> Create(
|
||||
const TextureInfo& aTextureInfo, bool aUseWebRender);
|
||||
const TextureInfo& aTextureInfo);
|
||||
|
||||
virtual CompositableType GetType() = 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,460 +0,0 @@
|
|||
/* -*- 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/ContentHost.h"
|
||||
#include "gfx2DGlue.h" // for ContentForFormat
|
||||
#include "mozilla/gfx/Point.h" // for IntSize
|
||||
#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc
|
||||
#include "mozilla/gfx/BaseRect.h" // for BaseRect
|
||||
#include "mozilla/layers/Compositor.h" // for Compositor
|
||||
#include "mozilla/layers/Effects.h" // for TexturedEffect, Effect, etc
|
||||
#include "mozilla/layers/LayersMessages.h" // for ThebesBufferData
|
||||
#include "nsAString.h"
|
||||
#include "nsPrintfCString.h" // for nsPrintfCString
|
||||
#include "nsString.h" // for nsAutoCString
|
||||
#include "mozilla/layers/TextureHostOGL.h" // for TextureHostOGL
|
||||
|
||||
namespace mozilla {
|
||||
using namespace gfx;
|
||||
|
||||
namespace layers {
|
||||
|
||||
ContentHostBase::ContentHostBase(const TextureInfo& aTextureInfo)
|
||||
: ContentHost(aTextureInfo), mInitialised(false) {}
|
||||
|
||||
ContentHostBase::~ContentHostBase() = default;
|
||||
|
||||
void ContentHostTexture::Composite(
|
||||
Compositor* aCompositor, LayerComposite* aLayer, EffectChain& aEffectChain,
|
||||
float aOpacity, const gfx::Matrix4x4& aTransform,
|
||||
const SamplingFilter aSamplingFilter, const IntRect& aClipRect,
|
||||
const nsIntRegion* aVisibleRegion, const Maybe<gfx::Polygon>& aGeometry) {
|
||||
NS_ASSERTION(aVisibleRegion, "Requires a visible region");
|
||||
|
||||
AutoLockCompositableHost lock(this);
|
||||
if (lock.Failed()) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!mTextureHost->BindTextureSource(mTextureSource)) {
|
||||
return;
|
||||
}
|
||||
MOZ_ASSERT(mTextureSource.get());
|
||||
|
||||
if (!mTextureHostOnWhite) {
|
||||
mTextureSourceOnWhite = nullptr;
|
||||
}
|
||||
if (mTextureHostOnWhite &&
|
||||
!mTextureHostOnWhite->BindTextureSource(mTextureSourceOnWhite)) {
|
||||
return;
|
||||
}
|
||||
|
||||
RefPtr<TexturedEffect> effect = CreateTexturedEffect(
|
||||
mTextureSource.get(), mTextureSourceOnWhite.get(), aSamplingFilter, true);
|
||||
if (!effect) {
|
||||
return;
|
||||
}
|
||||
|
||||
aEffectChain.mPrimaryEffect = effect;
|
||||
|
||||
nsIntRegion tmpRegion;
|
||||
const nsIntRegion* renderRegion;
|
||||
#ifndef MOZ_IGNORE_PAINT_WILL_RESAMPLE
|
||||
if (PaintWillResample()) {
|
||||
// If we're resampling, then the texture image will contain exactly the
|
||||
// entire visible region's bounds, and we should draw it all in one quad
|
||||
// to avoid unexpected aliasing.
|
||||
tmpRegion = aVisibleRegion->GetBounds();
|
||||
renderRegion = &tmpRegion;
|
||||
} else {
|
||||
renderRegion = aVisibleRegion;
|
||||
}
|
||||
#else
|
||||
renderRegion = aVisibleRegion;
|
||||
#endif
|
||||
|
||||
nsIntRegion region(*renderRegion);
|
||||
nsIntPoint origin = GetOriginOffset();
|
||||
// translate into TexImage space, buffer origin might not be at texture (0,0)
|
||||
region.MoveBy(-origin);
|
||||
|
||||
// Figure out the intersecting draw region
|
||||
gfx::IntSize texSize = mTextureSource->GetSize();
|
||||
IntRect textureRect = IntRect(0, 0, texSize.width, texSize.height);
|
||||
textureRect.MoveBy(region.GetBounds().TopLeft());
|
||||
nsIntRegion subregion;
|
||||
subregion.And(region, textureRect);
|
||||
if (subregion.IsEmpty()) {
|
||||
// Region is empty, nothing to draw
|
||||
return;
|
||||
}
|
||||
|
||||
nsIntRegion screenRects;
|
||||
nsIntRegion regionRects;
|
||||
|
||||
// Collect texture/screen coordinates for drawing
|
||||
for (auto iter = subregion.RectIter(); !iter.Done(); iter.Next()) {
|
||||
IntRect regionRect = iter.Get();
|
||||
IntRect screenRect = iter.Get();
|
||||
screenRect.MoveBy(origin);
|
||||
|
||||
screenRects.Or(screenRects, screenRect);
|
||||
regionRects.Or(regionRects, regionRect);
|
||||
}
|
||||
|
||||
BigImageIterator* bigImgIter = mTextureSource->AsBigImageIterator();
|
||||
BigImageIterator* iterOnWhite = nullptr;
|
||||
if (bigImgIter) {
|
||||
bigImgIter->BeginBigImageIteration();
|
||||
}
|
||||
|
||||
if (mTextureSourceOnWhite) {
|
||||
iterOnWhite = mTextureSourceOnWhite->AsBigImageIterator();
|
||||
MOZ_ASSERT(!bigImgIter ||
|
||||
bigImgIter->GetTileCount() == iterOnWhite->GetTileCount(),
|
||||
"Tile count mismatch on component alpha texture");
|
||||
if (iterOnWhite) {
|
||||
iterOnWhite->BeginBigImageIteration();
|
||||
}
|
||||
}
|
||||
|
||||
bool usingTiles = (bigImgIter && bigImgIter->GetTileCount() > 1);
|
||||
do {
|
||||
if (iterOnWhite && bigImgIter) {
|
||||
MOZ_ASSERT(iterOnWhite->GetTileRect() == bigImgIter->GetTileRect(),
|
||||
"component alpha textures should be the same size.");
|
||||
}
|
||||
|
||||
IntRect texRect = bigImgIter ? bigImgIter->GetTileRect()
|
||||
: IntRect(0, 0, texSize.width, texSize.height);
|
||||
|
||||
// Draw texture. If we're using tiles, we do repeating manually, as texture
|
||||
// repeat would cause each individual tile to repeat instead of the
|
||||
// compound texture as a whole. This involves drawing at most 4 sections,
|
||||
// 2 for each axis that has texture repeat.
|
||||
for (int y = 0; y < (usingTiles ? 2 : 1); y++) {
|
||||
for (int x = 0; x < (usingTiles ? 2 : 1); x++) {
|
||||
IntRect currentTileRect(texRect);
|
||||
currentTileRect.MoveBy(x * texSize.width, y * texSize.height);
|
||||
|
||||
for (auto screenIter = screenRects.RectIter(),
|
||||
regionIter = regionRects.RectIter();
|
||||
!screenIter.Done() && !regionIter.Done();
|
||||
screenIter.Next(), regionIter.Next()) {
|
||||
const IntRect& screenRect = screenIter.Get();
|
||||
const IntRect& regionRect = regionIter.Get();
|
||||
IntRect tileScreenRect(screenRect);
|
||||
IntRect tileRegionRect(regionRect);
|
||||
|
||||
// When we're using tiles, find the intersection between the tile
|
||||
// rect and this region rect. Tiling is then handled by the
|
||||
// outer for-loops and modifying the tile rect.
|
||||
if (usingTiles) {
|
||||
tileScreenRect.MoveBy(-origin);
|
||||
tileScreenRect = tileScreenRect.Intersect(currentTileRect);
|
||||
tileScreenRect.MoveBy(origin);
|
||||
|
||||
if (tileScreenRect.IsEmpty()) continue;
|
||||
|
||||
tileRegionRect = regionRect.Intersect(currentTileRect);
|
||||
tileRegionRect.MoveBy(-currentTileRect.TopLeft());
|
||||
}
|
||||
gfx::Rect rect(tileScreenRect.X(), tileScreenRect.Y(),
|
||||
tileScreenRect.Width(), tileScreenRect.Height());
|
||||
|
||||
effect->mTextureCoords =
|
||||
Rect(Float(tileRegionRect.X()) / texRect.Width(),
|
||||
Float(tileRegionRect.Y()) / texRect.Height(),
|
||||
Float(tileRegionRect.Width()) / texRect.Width(),
|
||||
Float(tileRegionRect.Height()) / texRect.Height());
|
||||
|
||||
aCompositor->DrawGeometry(rect, aClipRect, aEffectChain, aOpacity,
|
||||
aTransform, aGeometry);
|
||||
|
||||
if (usingTiles) {
|
||||
DiagnosticFlags diagnostics =
|
||||
DiagnosticFlags::CONTENT | DiagnosticFlags::BIGIMAGE;
|
||||
if (iterOnWhite) {
|
||||
diagnostics |= DiagnosticFlags::COMPONENT_ALPHA;
|
||||
}
|
||||
aCompositor->DrawDiagnostics(diagnostics, rect, aClipRect,
|
||||
aTransform, mFlashCounter);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (iterOnWhite) {
|
||||
iterOnWhite->NextTile();
|
||||
}
|
||||
} while (usingTiles && bigImgIter->NextTile());
|
||||
|
||||
if (bigImgIter) {
|
||||
bigImgIter->EndBigImageIteration();
|
||||
}
|
||||
if (iterOnWhite) {
|
||||
iterOnWhite->EndBigImageIteration();
|
||||
}
|
||||
|
||||
DiagnosticFlags diagnostics = DiagnosticFlags::CONTENT;
|
||||
if (iterOnWhite) {
|
||||
diagnostics |= DiagnosticFlags::COMPONENT_ALPHA;
|
||||
}
|
||||
aCompositor->DrawDiagnostics(diagnostics, nsIntRegion(mBufferRect), aClipRect,
|
||||
aTransform, mFlashCounter);
|
||||
}
|
||||
|
||||
RefPtr<TextureSource> ContentHostTexture::AcquireTextureSource() {
|
||||
if (!mTextureHost || !mTextureHost->AcquireTextureSource(mTextureSource)) {
|
||||
return nullptr;
|
||||
}
|
||||
return mTextureSource.get();
|
||||
}
|
||||
|
||||
RefPtr<TextureSource> ContentHostTexture::AcquireTextureSourceOnWhite() {
|
||||
if (!mTextureHostOnWhite ||
|
||||
!mTextureHostOnWhite->AcquireTextureSource(mTextureSourceOnWhite)) {
|
||||
return nullptr;
|
||||
}
|
||||
return mTextureSourceOnWhite.get();
|
||||
}
|
||||
|
||||
void ContentHostTexture::UseTextureHost(
|
||||
const nsTArray<TimedTexture>& aTextures) {
|
||||
ContentHostBase::UseTextureHost(aTextures);
|
||||
MOZ_ASSERT(aTextures.Length() == 1);
|
||||
const TimedTexture& t = aTextures[0];
|
||||
MOZ_ASSERT(t.mPictureRect.IsEqualInterior(
|
||||
nsIntRect(nsIntPoint(0, 0), nsIntSize(t.mTexture->GetSize()))),
|
||||
"Only default picture rect supported");
|
||||
|
||||
if (t.mTexture != mTextureHost) {
|
||||
mReceivedNewHost = true;
|
||||
}
|
||||
|
||||
mTextureHost = t.mTexture;
|
||||
mTextureHostOnWhite = nullptr;
|
||||
mTextureSourceOnWhite = nullptr;
|
||||
if (mTextureHost) {
|
||||
mTextureHost->PrepareTextureSource(mTextureSource);
|
||||
}
|
||||
}
|
||||
|
||||
void ContentHostTexture::UseComponentAlphaTextures(
|
||||
TextureHost* aTextureOnBlack, TextureHost* aTextureOnWhite) {
|
||||
ContentHostBase::UseComponentAlphaTextures(aTextureOnBlack, aTextureOnWhite);
|
||||
mTextureHost = aTextureOnBlack;
|
||||
mTextureHostOnWhite = aTextureOnWhite;
|
||||
if (mTextureHost) {
|
||||
mTextureHost->PrepareTextureSource(mTextureSource);
|
||||
}
|
||||
if (mTextureHostOnWhite) {
|
||||
mTextureHostOnWhite->PrepareTextureSource(mTextureSourceOnWhite);
|
||||
}
|
||||
}
|
||||
|
||||
void ContentHostTexture::SetTextureSourceProvider(
|
||||
TextureSourceProvider* aProvider) {
|
||||
ContentHostBase::SetTextureSourceProvider(aProvider);
|
||||
if (mTextureHost) {
|
||||
mTextureHost->SetTextureSourceProvider(aProvider);
|
||||
}
|
||||
if (mTextureHostOnWhite) {
|
||||
mTextureHostOnWhite->SetTextureSourceProvider(aProvider);
|
||||
}
|
||||
}
|
||||
|
||||
void ContentHostTexture::Dump(std::stringstream& aStream, const char* aPrefix,
|
||||
bool aDumpHtml) {
|
||||
#ifdef MOZ_DUMP_PAINTING
|
||||
if (aDumpHtml) {
|
||||
aStream << "<ul>";
|
||||
}
|
||||
if (mTextureHost) {
|
||||
aStream << aPrefix;
|
||||
if (aDumpHtml) {
|
||||
aStream << "<li> <a href=";
|
||||
} else {
|
||||
aStream << "Front buffer: ";
|
||||
}
|
||||
DumpTextureHost(aStream, mTextureHost);
|
||||
if (aDumpHtml) {
|
||||
aStream << "> Front buffer </a></li> ";
|
||||
} else {
|
||||
aStream << "\n";
|
||||
}
|
||||
}
|
||||
if (mTextureHostOnWhite) {
|
||||
aStream << aPrefix;
|
||||
if (aDumpHtml) {
|
||||
aStream << "<li> <a href=";
|
||||
} else {
|
||||
aStream << "Front buffer on white: ";
|
||||
}
|
||||
DumpTextureHost(aStream, mTextureHostOnWhite);
|
||||
if (aDumpHtml) {
|
||||
aStream << "> Front buffer on white </a> </li> ";
|
||||
} else {
|
||||
aStream << "\n";
|
||||
}
|
||||
}
|
||||
if (aDumpHtml) {
|
||||
aStream << "</ul>";
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline void AddWrappedRegion(const nsIntRegion& aInput,
|
||||
nsIntRegion& aOutput, const IntSize& aSize,
|
||||
const nsIntPoint& aShift) {
|
||||
nsIntRegion tempRegion;
|
||||
tempRegion.And(IntRect(aShift, aSize), aInput);
|
||||
tempRegion.MoveBy(-aShift);
|
||||
aOutput.Or(aOutput, tempRegion);
|
||||
}
|
||||
|
||||
bool ContentHostSingleBuffered::UpdateThebes(
|
||||
const ThebesBufferData& aData, const nsIntRegion& aUpdated,
|
||||
const nsIntRegion& aOldValidRegionBack) {
|
||||
if (!mTextureHost) {
|
||||
mInitialised = false;
|
||||
return true; // FIXME should we return false? Returning true for now
|
||||
} // to preserve existing behavior of NOT causing IPC errors.
|
||||
|
||||
// updated is in screen coordinates. Convert it to buffer coordinates.
|
||||
nsIntRegion destRegion(aUpdated);
|
||||
|
||||
if (mReceivedNewHost) {
|
||||
destRegion.Or(destRegion, aOldValidRegionBack);
|
||||
mReceivedNewHost = false;
|
||||
}
|
||||
destRegion.MoveBy(-aData.rect().TopLeft());
|
||||
|
||||
if (!aData.rect().Contains(aUpdated.GetBounds()) ||
|
||||
aData.rotation().x > aData.rect().Width() ||
|
||||
aData.rotation().y > aData.rect().Height()) {
|
||||
NS_ERROR("Invalid update data");
|
||||
return false;
|
||||
}
|
||||
|
||||
// destRegion is now in logical coordinates relative to the buffer, but we
|
||||
// need to account for rotation. We do that by moving the region to the
|
||||
// rotation offset and then wrapping any pixels that extend off the
|
||||
// bottom/right edges.
|
||||
|
||||
// Shift to the rotation point
|
||||
destRegion.MoveBy(aData.rotation());
|
||||
|
||||
IntSize bufferSize = aData.rect().Size();
|
||||
|
||||
// Select only the pixels that are still within the buffer.
|
||||
nsIntRegion finalRegion;
|
||||
finalRegion.And(IntRect(IntPoint(), bufferSize), destRegion);
|
||||
|
||||
// For each of the overlap areas (right, bottom-right, bottom), select those
|
||||
// pixels and wrap them around to the opposite edge of the buffer rect.
|
||||
AddWrappedRegion(destRegion, finalRegion, bufferSize,
|
||||
nsIntPoint(aData.rect().Width(), 0));
|
||||
AddWrappedRegion(destRegion, finalRegion, bufferSize,
|
||||
nsIntPoint(aData.rect().Width(), aData.rect().Height()));
|
||||
AddWrappedRegion(destRegion, finalRegion, bufferSize,
|
||||
nsIntPoint(0, aData.rect().Height()));
|
||||
|
||||
MOZ_ASSERT(IntRect(0, 0, aData.rect().Width(), aData.rect().Height())
|
||||
.Contains(finalRegion.GetBounds()));
|
||||
|
||||
mTextureHost->Updated(&finalRegion);
|
||||
if (mTextureHostOnWhite) {
|
||||
mTextureHostOnWhite->Updated(&finalRegion);
|
||||
}
|
||||
mInitialised = true;
|
||||
|
||||
mBufferRect = aData.rect();
|
||||
mBufferRotation = aData.rotation();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ContentHostDoubleBuffered::UpdateThebes(
|
||||
const ThebesBufferData& aData, const nsIntRegion& aUpdated,
|
||||
const nsIntRegion& aOldValidRegionBack) {
|
||||
if (!mTextureHost) {
|
||||
mInitialised = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
// We don't need to calculate an update region because we assume that if we
|
||||
// are using double buffering then we have render-to-texture and thus no
|
||||
// upload to do.
|
||||
mTextureHost->Updated();
|
||||
if (mTextureHostOnWhite) {
|
||||
mTextureHostOnWhite->Updated();
|
||||
}
|
||||
mInitialised = true;
|
||||
|
||||
mBufferRect = aData.rect();
|
||||
mBufferRotation = aData.rotation();
|
||||
|
||||
// Save the current valid region of our front buffer, because if
|
||||
// we're double buffering, it's going to be the valid region for the
|
||||
// next back buffer sent back to the renderer.
|
||||
//
|
||||
// NB: we rely here on the fact that mValidRegion is initialized to
|
||||
// empty, and that the first time Swap() is called we don't have a
|
||||
// valid front buffer that we're going to return to content.
|
||||
mValidRegionForNextBackBuffer = aOldValidRegionBack;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void ContentHostTexture::PrintInfo(std::stringstream& aStream,
|
||||
const char* aPrefix) {
|
||||
aStream << aPrefix;
|
||||
aStream << nsPrintfCString("ContentHost (0x%p)", this).get()
|
||||
<< " [buffer-rect=" << mBufferRect << "]"
|
||||
<< " [buffer-rotation=" << mBufferRotation << "]";
|
||||
if (PaintWillResample()) {
|
||||
aStream << " [paint-will-resample]";
|
||||
}
|
||||
|
||||
if (mTextureHost) {
|
||||
nsAutoCString pfx(aPrefix);
|
||||
pfx += " ";
|
||||
|
||||
aStream << "\n";
|
||||
mTextureHost->PrintInfo(aStream, pfx.get());
|
||||
}
|
||||
}
|
||||
|
||||
already_AddRefed<TexturedEffect> ContentHostTexture::GenEffect(
|
||||
const gfx::SamplingFilter aSamplingFilter) {
|
||||
if (!mTextureHost) {
|
||||
return nullptr;
|
||||
}
|
||||
if (!mTextureHost->BindTextureSource(mTextureSource)) {
|
||||
return nullptr;
|
||||
}
|
||||
if (!mTextureHostOnWhite) {
|
||||
mTextureSourceOnWhite = nullptr;
|
||||
}
|
||||
if (mTextureHostOnWhite &&
|
||||
!mTextureHostOnWhite->BindTextureSource(mTextureSourceOnWhite)) {
|
||||
return nullptr;
|
||||
}
|
||||
return CreateTexturedEffect(mTextureSource.get(), mTextureSourceOnWhite.get(),
|
||||
aSamplingFilter, true);
|
||||
}
|
||||
|
||||
already_AddRefed<gfx::DataSourceSurface> ContentHostTexture::GetAsSurface() {
|
||||
if (!mTextureHost) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return mTextureHost->GetAsSurface();
|
||||
}
|
||||
|
||||
} // namespace layers
|
||||
} // namespace mozilla
|
||||
|
|
@ -1,233 +0,0 @@
|
|||
/* -*- 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/. */
|
||||
|
||||
#ifndef GFX_CONTENTHOST_H
|
||||
#define GFX_CONTENTHOST_H
|
||||
|
||||
#include <stdint.h> // for uint32_t
|
||||
#include <stdio.h> // for FILE
|
||||
#include "mozilla-config.h" // for MOZ_DUMP_PAINTING
|
||||
#include "CompositableHost.h" // for CompositableHost, etc
|
||||
#include "mozilla/Attributes.h" // for override
|
||||
#include "mozilla/RefPtr.h" // for RefPtr
|
||||
#include "mozilla/gfx/BasePoint.h" // for BasePoint
|
||||
#include "mozilla/gfx/MatrixFwd.h" // for Matrix4x4
|
||||
#include "mozilla/gfx/Point.h" // for Point
|
||||
#include "mozilla/gfx/Polygon.h" // for Polygon
|
||||
#include "mozilla/gfx/Rect.h" // for Rect
|
||||
#include "mozilla/gfx/Types.h" // for SamplingFilter
|
||||
#include "mozilla/layers/CompositorTypes.h" // for TextureInfo, etc
|
||||
#include "mozilla/layers/ContentClient.h" // for ContentClient
|
||||
#include "mozilla/layers/ISurfaceAllocator.h" // for ISurfaceAllocator
|
||||
#include "mozilla/layers/LayersSurfaces.h" // for SurfaceDescriptor
|
||||
#include "mozilla/layers/LayersTypes.h" // for etc
|
||||
#include "mozilla/layers/TextureHost.h" // for TextureHost
|
||||
#include "mozilla/mozalloc.h" // for operator delete
|
||||
#include "mozilla/UniquePtr.h" // for UniquePtr
|
||||
#include "nsCOMPtr.h" // for already_AddRefed
|
||||
#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc
|
||||
#include "nsPoint.h" // for nsIntPoint
|
||||
#include "nsRect.h" // for mozilla::gfx::IntRect
|
||||
#include "nsRegion.h" // for nsIntRegion
|
||||
#include "nsTArray.h" // for nsTArray
|
||||
#include "nscore.h" // for nsACString
|
||||
|
||||
namespace mozilla {
|
||||
namespace layers {
|
||||
class Compositor;
|
||||
class ThebesBufferData;
|
||||
struct EffectChain;
|
||||
|
||||
struct TexturedEffect;
|
||||
|
||||
/**
|
||||
* ContentHosts are used for compositing Painted layers, always matched by a
|
||||
* ContentClient of the same type.
|
||||
*
|
||||
* ContentHosts support only UpdateThebes(), not Update().
|
||||
*/
|
||||
class ContentHost : public CompositableHost {
|
||||
public:
|
||||
virtual bool UpdateThebes(
|
||||
const ThebesBufferData& aData, const nsIntRegion& aUpdated,
|
||||
const nsIntRegion& aOldValidRegionBack) override = 0;
|
||||
|
||||
virtual void SetPaintWillResample(bool aResample) {
|
||||
mPaintWillResample = aResample;
|
||||
}
|
||||
bool PaintWillResample() { return mPaintWillResample; }
|
||||
|
||||
// We use this to allow TiledContentHost to invalidate regions where
|
||||
// tiles are fading in.
|
||||
virtual void AddAnimationInvalidation(nsIntRegion& aRegion) {}
|
||||
|
||||
virtual gfx::IntRect GetBufferRect() {
|
||||
MOZ_ASSERT_UNREACHABLE("Must be implemented in derived class");
|
||||
return gfx::IntRect();
|
||||
}
|
||||
|
||||
ContentHost* AsContentHost() override { return this; }
|
||||
|
||||
protected:
|
||||
explicit ContentHost(const TextureInfo& aTextureInfo)
|
||||
: CompositableHost(aTextureInfo), mPaintWillResample(false) {}
|
||||
|
||||
bool mPaintWillResample;
|
||||
};
|
||||
|
||||
/**
|
||||
* Base class for non-tiled ContentHosts.
|
||||
*
|
||||
* Ownership of the SurfaceDescriptor and the resources it represents is passed
|
||||
* from the ContentClient to the ContentHost when the TextureClient/Hosts are
|
||||
* created, that is recevied here by SetTextureHosts which assigns one or two
|
||||
* texture hosts (for single and double buffering) to the ContentHost.
|
||||
*
|
||||
* It is the responsibility of the ContentHost to destroy its resources when
|
||||
* they are recreated or the ContentHost dies.
|
||||
*/
|
||||
class ContentHostBase : public ContentHost {
|
||||
public:
|
||||
typedef ContentClient::ContentType ContentType;
|
||||
typedef ContentClient::PaintState PaintState;
|
||||
|
||||
explicit ContentHostBase(const TextureInfo& aTextureInfo);
|
||||
virtual ~ContentHostBase();
|
||||
|
||||
gfx::IntRect GetBufferRect() override { return mBufferRect; }
|
||||
|
||||
virtual nsIntPoint GetOriginOffset() {
|
||||
return mBufferRect.TopLeft() - mBufferRotation;
|
||||
}
|
||||
|
||||
protected:
|
||||
gfx::IntRect mBufferRect;
|
||||
nsIntPoint mBufferRotation;
|
||||
bool mInitialised;
|
||||
};
|
||||
|
||||
/**
|
||||
* Shared ContentHostBase implementation for content hosts that
|
||||
* use up to two TextureHosts.
|
||||
*/
|
||||
class ContentHostTexture : public ContentHostBase {
|
||||
public:
|
||||
explicit ContentHostTexture(const TextureInfo& aTextureInfo)
|
||||
: ContentHostBase(aTextureInfo),
|
||||
mLocked(false),
|
||||
mReceivedNewHost(false) {}
|
||||
|
||||
void Composite(Compositor* aCompositor, LayerComposite* aLayer,
|
||||
EffectChain& aEffectChain, float aOpacity,
|
||||
const gfx::Matrix4x4& aTransform,
|
||||
const gfx::SamplingFilter aSamplingFilter,
|
||||
const gfx::IntRect& aClipRect,
|
||||
const nsIntRegion* aVisibleRegion = nullptr,
|
||||
const Maybe<gfx::Polygon>& aGeometry = Nothing()) override;
|
||||
|
||||
void SetTextureSourceProvider(TextureSourceProvider* aProvider) override;
|
||||
|
||||
already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override;
|
||||
|
||||
void Dump(std::stringstream& aStream, const char* aPrefix = "",
|
||||
bool aDumpHtml = false) override;
|
||||
|
||||
void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
|
||||
|
||||
void UseTextureHost(const nsTArray<TimedTexture>& aTextures) override;
|
||||
void UseComponentAlphaTextures(TextureHost* aTextureOnBlack,
|
||||
TextureHost* aTextureOnWhite) override;
|
||||
|
||||
bool Lock() override {
|
||||
MOZ_ASSERT(!mLocked);
|
||||
if (!mTextureHost) {
|
||||
return false;
|
||||
}
|
||||
if (!mTextureHost->Lock()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (mTextureHostOnWhite && !mTextureHostOnWhite->Lock()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
mLocked = true;
|
||||
return true;
|
||||
}
|
||||
void Unlock() override {
|
||||
MOZ_ASSERT(mLocked);
|
||||
mTextureHost->Unlock();
|
||||
if (mTextureHostOnWhite) {
|
||||
mTextureHostOnWhite->Unlock();
|
||||
}
|
||||
mLocked = false;
|
||||
}
|
||||
|
||||
bool HasComponentAlpha() const { return !!mTextureHostOnWhite; }
|
||||
|
||||
RefPtr<TextureSource> AcquireTextureSource();
|
||||
RefPtr<TextureSource> AcquireTextureSourceOnWhite();
|
||||
|
||||
ContentHostTexture* AsContentHostTexture() override { return this; }
|
||||
|
||||
already_AddRefed<TexturedEffect> GenEffect(
|
||||
const gfx::SamplingFilter aSamplingFilter) override;
|
||||
|
||||
protected:
|
||||
CompositableTextureHostRef mTextureHost;
|
||||
CompositableTextureHostRef mTextureHostOnWhite;
|
||||
CompositableTextureSourceRef mTextureSource;
|
||||
CompositableTextureSourceRef mTextureSourceOnWhite;
|
||||
bool mLocked;
|
||||
bool mReceivedNewHost;
|
||||
};
|
||||
|
||||
/**
|
||||
* Double buffering is implemented by swapping the front and back TextureHosts.
|
||||
* We assume that whenever we use double buffering, then we have
|
||||
* render-to-texture and thus no texture upload to do.
|
||||
*/
|
||||
class ContentHostDoubleBuffered : public ContentHostTexture {
|
||||
public:
|
||||
explicit ContentHostDoubleBuffered(const TextureInfo& aTextureInfo)
|
||||
: ContentHostTexture(aTextureInfo) {}
|
||||
|
||||
virtual ~ContentHostDoubleBuffered() = default;
|
||||
|
||||
CompositableType GetType() override {
|
||||
return CompositableType::CONTENT_DOUBLE;
|
||||
}
|
||||
|
||||
virtual bool UpdateThebes(const ThebesBufferData& aData,
|
||||
const nsIntRegion& aUpdated,
|
||||
const nsIntRegion& aOldValidRegionBack) override;
|
||||
|
||||
protected:
|
||||
nsIntRegion mValidRegionForNextBackBuffer;
|
||||
};
|
||||
|
||||
/**
|
||||
* Single buffered, therefore we must synchronously upload the image from the
|
||||
* TextureHost in the layers transaction (i.e., in UpdateThebes).
|
||||
*/
|
||||
class ContentHostSingleBuffered : public ContentHostTexture {
|
||||
public:
|
||||
explicit ContentHostSingleBuffered(const TextureInfo& aTextureInfo)
|
||||
: ContentHostTexture(aTextureInfo) {}
|
||||
virtual ~ContentHostSingleBuffered() = default;
|
||||
|
||||
CompositableType GetType() override {
|
||||
return CompositableType::CONTENT_SINGLE;
|
||||
}
|
||||
|
||||
bool UpdateThebes(const ThebesBufferData& aData, const nsIntRegion& aUpdated,
|
||||
const nsIntRegion& aOldValidRegionBack) override;
|
||||
};
|
||||
|
||||
} // namespace layers
|
||||
} // namespace mozilla
|
||||
|
||||
#endif
|
||||
|
|
@ -1,402 +0,0 @@
|
|||
/* -*- 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 "ImageHost.h"
|
||||
|
||||
#include <utility>
|
||||
|
||||
#include "composite/CompositableHost.h" // for CompositableHost, etc
|
||||
#include "ipc/IPCMessageUtils.h" // for null_t
|
||||
#include "mozilla/layers/Compositor.h" // for Compositor
|
||||
#include "mozilla/layers/Effects.h" // for TexturedEffect, Effect, etc
|
||||
#include "nsAString.h"
|
||||
#include "nsDebug.h" // for NS_WARNING, NS_ASSERTION
|
||||
#include "nsPrintfCString.h" // for nsPrintfCString
|
||||
#include "nsString.h" // for nsAutoCString
|
||||
|
||||
namespace mozilla {
|
||||
|
||||
using namespace gfx;
|
||||
|
||||
namespace layers {
|
||||
|
||||
class ISurfaceAllocator;
|
||||
|
||||
ImageHost::ImageHost(const TextureInfo& aTextureInfo)
|
||||
: CompositableHost(aTextureInfo), ImageComposite(), mLocked(false) {}
|
||||
|
||||
ImageHost::~ImageHost() = default;
|
||||
|
||||
void ImageHost::UseTextureHost(const nsTArray<TimedTexture>& aTextures) {
|
||||
MOZ_ASSERT(!mLocked);
|
||||
|
||||
CompositableHost::UseTextureHost(aTextures);
|
||||
MOZ_ASSERT(aTextures.Length() >= 1);
|
||||
|
||||
nsTArray<TimedImage> newImages;
|
||||
|
||||
for (uint32_t i = 0; i < aTextures.Length(); ++i) {
|
||||
const TimedTexture& t = aTextures[i];
|
||||
MOZ_ASSERT(t.mTexture);
|
||||
if (i + 1 < aTextures.Length() && t.mProducerID == mLastProducerID &&
|
||||
t.mFrameID < mLastFrameID) {
|
||||
// Ignore frames before a frame that we already composited. We don't
|
||||
// ever want to display these frames. This could be important if
|
||||
// the frame producer adjusts timestamps (e.g. to track the audio clock)
|
||||
// and the new frame times are earlier.
|
||||
continue;
|
||||
}
|
||||
TimedImage& img = *newImages.AppendElement();
|
||||
img.mTextureHost = t.mTexture;
|
||||
img.mTimeStamp = t.mTimeStamp;
|
||||
img.mPictureRect = t.mPictureRect;
|
||||
img.mFrameID = t.mFrameID;
|
||||
img.mProducerID = t.mProducerID;
|
||||
img.mTextureHost->SetCropRect(img.mPictureRect);
|
||||
img.mTextureHost->Updated();
|
||||
}
|
||||
|
||||
SetImages(std::move(newImages));
|
||||
|
||||
// If we only have one image we can upload it right away, otherwise we'll
|
||||
// upload on-demand during composition after we have picked the proper
|
||||
// timestamp.
|
||||
if (ImagesCount() == 1) {
|
||||
SetCurrentTextureHost(GetImage(0)->mTextureHost);
|
||||
}
|
||||
}
|
||||
|
||||
void ImageHost::SetCurrentTextureHost(TextureHost* aTexture) {
|
||||
if (aTexture == mCurrentTextureHost.get()) {
|
||||
return;
|
||||
}
|
||||
|
||||
bool swapTextureSources = !!mCurrentTextureHost && !!mCurrentTextureSource &&
|
||||
mCurrentTextureHost->IsValid() &&
|
||||
mCurrentTextureHost->HasIntermediateBuffer();
|
||||
|
||||
if (swapTextureSources) {
|
||||
auto dataSource = mCurrentTextureSource->AsDataTextureSource();
|
||||
if (dataSource) {
|
||||
// The current textureHost has an internal buffer in the form of the
|
||||
// DataTextureSource. Removing the ownership of the texture source
|
||||
// will enable the next texture host we bind to the texture source to
|
||||
// acquire it instead of creating a new one. This is desirable in
|
||||
// ImageHost because the current texture won't be used again with the
|
||||
// same content. It wouldn't be desirable with ContentHost for instance,
|
||||
// because the latter reuses the texture's valid regions.
|
||||
dataSource->SetOwner(nullptr);
|
||||
}
|
||||
|
||||
RefPtr<TextureSource> tmp = mExtraTextureSource;
|
||||
mExtraTextureSource = mCurrentTextureSource.get();
|
||||
mCurrentTextureSource = tmp;
|
||||
} else {
|
||||
mExtraTextureSource = nullptr;
|
||||
}
|
||||
|
||||
mCurrentTextureHost = aTexture;
|
||||
mCurrentTextureHost->PrepareTextureSource(mCurrentTextureSource);
|
||||
}
|
||||
|
||||
void ImageHost::CleanupResources() {
|
||||
mExtraTextureSource = nullptr;
|
||||
mCurrentTextureSource = nullptr;
|
||||
mCurrentTextureHost = nullptr;
|
||||
}
|
||||
|
||||
void ImageHost::RemoveTextureHost(TextureHost* aTexture) {
|
||||
MOZ_ASSERT(!mLocked);
|
||||
|
||||
CompositableHost::RemoveTextureHost(aTexture);
|
||||
RemoveImagesWithTextureHost(aTexture);
|
||||
}
|
||||
|
||||
TimeStamp ImageHost::GetCompositionTime() const {
|
||||
TimeStamp time;
|
||||
return time;
|
||||
}
|
||||
|
||||
CompositionOpportunityId ImageHost::GetCompositionOpportunityId() const {
|
||||
CompositionOpportunityId id;
|
||||
return id;
|
||||
}
|
||||
|
||||
void ImageHost::AppendImageCompositeNotification(
|
||||
const ImageCompositeNotificationInfo& aInfo) const {}
|
||||
|
||||
TextureHost* ImageHost::GetAsTextureHost(IntRect* aPictureRect) {
|
||||
const TimedImage* img = ChooseImage();
|
||||
if (!img) {
|
||||
return nullptr;
|
||||
}
|
||||
SetCurrentTextureHost(img->mTextureHost);
|
||||
if (aPictureRect) {
|
||||
*aPictureRect = img->mPictureRect;
|
||||
}
|
||||
return img->mTextureHost;
|
||||
}
|
||||
|
||||
void ImageHost::Attach(Layer* aLayer, TextureSourceProvider* aProvider,
|
||||
AttachFlags aFlags) {
|
||||
CompositableHost::Attach(aLayer, aProvider, aFlags);
|
||||
for (const auto& img : Images()) {
|
||||
img.mTextureHost->SetTextureSourceProvider(aProvider);
|
||||
img.mTextureHost->Updated();
|
||||
}
|
||||
}
|
||||
|
||||
void ImageHost::Composite(Compositor* aCompositor, LayerComposite* aLayer,
|
||||
EffectChain& aEffectChain, float aOpacity,
|
||||
const gfx::Matrix4x4& aTransform,
|
||||
const gfx::SamplingFilter aSamplingFilter,
|
||||
const gfx::IntRect& aClipRect,
|
||||
const nsIntRegion* aVisibleRegion,
|
||||
const Maybe<gfx::Polygon>& aGeometry) {
|
||||
RenderInfo info;
|
||||
if (!PrepareToRender(aCompositor, &info)) {
|
||||
return;
|
||||
}
|
||||
|
||||
const TimedImage* img = info.img;
|
||||
|
||||
{
|
||||
AutoLockCompositableHost autoLock(this);
|
||||
if (autoLock.Failed()) {
|
||||
NS_WARNING("failed to lock front buffer");
|
||||
return;
|
||||
}
|
||||
|
||||
if (!mCurrentTextureHost->BindTextureSource(mCurrentTextureSource)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!mCurrentTextureSource) {
|
||||
// BindTextureSource above should have returned false!
|
||||
MOZ_ASSERT(false);
|
||||
return;
|
||||
}
|
||||
|
||||
bool isAlphaPremultiplied =
|
||||
!(mCurrentTextureHost->GetFlags() & TextureFlags::NON_PREMULTIPLIED);
|
||||
RefPtr<TexturedEffect> effect =
|
||||
CreateTexturedEffect(mCurrentTextureHost, mCurrentTextureSource.get(),
|
||||
aSamplingFilter, isAlphaPremultiplied);
|
||||
if (!effect) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!aCompositor->SupportsEffect(effect->mType)) {
|
||||
return;
|
||||
}
|
||||
|
||||
DiagnosticFlags diagnosticFlags = DiagnosticFlags::IMAGE;
|
||||
if (effect->mType == EffectTypes::NV12) {
|
||||
diagnosticFlags |= DiagnosticFlags::NV12;
|
||||
} else if (effect->mType == EffectTypes::YCBCR) {
|
||||
diagnosticFlags |= DiagnosticFlags::YCBCR;
|
||||
}
|
||||
|
||||
aEffectChain.mPrimaryEffect = effect;
|
||||
gfx::Rect pictureRect(0, 0, img->mPictureRect.Width(),
|
||||
img->mPictureRect.Height());
|
||||
BigImageIterator* it = mCurrentTextureSource->AsBigImageIterator();
|
||||
if (it) {
|
||||
// This iteration does not work if we have multiple texture sources here
|
||||
// (e.g. 3 YCbCr textures). There's nothing preventing the different
|
||||
// planes from having different resolutions or tile sizes. For example, a
|
||||
// YCbCr frame could have Cb and Cr planes that are half the resolution of
|
||||
// the Y plane, in such a way that the Y plane overflows the maximum
|
||||
// texture size and the Cb and Cr planes do not. Then the Y plane would be
|
||||
// split into multiple tiles and the Cb and Cr planes would just be one
|
||||
// tile each.
|
||||
// To handle the general case correctly, we'd have to create a grid of
|
||||
// intersected tiles over all planes, and then draw each grid tile using
|
||||
// the corresponding source tiles from all planes, with appropriate
|
||||
// per-plane per-tile texture coords.
|
||||
// DrawQuad currently assumes that all planes use the same texture coords.
|
||||
MOZ_ASSERT(
|
||||
it->GetTileCount() == 1 || !mCurrentTextureSource->GetNextSibling(),
|
||||
"Can't handle multi-plane BigImages");
|
||||
|
||||
it->BeginBigImageIteration();
|
||||
do {
|
||||
IntRect tileRect = it->GetTileRect();
|
||||
gfx::Rect rect(tileRect.X(), tileRect.Y(), tileRect.Width(),
|
||||
tileRect.Height());
|
||||
rect = rect.Intersect(pictureRect);
|
||||
effect->mTextureCoords =
|
||||
Rect(Float(rect.X() - tileRect.X()) / tileRect.Width(),
|
||||
Float(rect.Y() - tileRect.Y()) / tileRect.Height(),
|
||||
Float(rect.Width()) / tileRect.Width(),
|
||||
Float(rect.Height()) / tileRect.Height());
|
||||
if (img->mTextureHost->GetFlags() & TextureFlags::ORIGIN_BOTTOM_LEFT) {
|
||||
effect->mTextureCoords.SetRectY(effect->mTextureCoords.YMost(),
|
||||
-effect->mTextureCoords.Height());
|
||||
}
|
||||
aCompositor->DrawGeometry(rect, aClipRect, aEffectChain, aOpacity,
|
||||
aTransform, aGeometry);
|
||||
aCompositor->DrawDiagnostics(
|
||||
diagnosticFlags | DiagnosticFlags::BIGIMAGE, rect, aClipRect,
|
||||
aTransform, mFlashCounter);
|
||||
} while (it->NextTile());
|
||||
it->EndBigImageIteration();
|
||||
// layer border
|
||||
aCompositor->DrawDiagnostics(diagnosticFlags, pictureRect, aClipRect,
|
||||
aTransform, mFlashCounter);
|
||||
} else {
|
||||
IntSize textureSize = mCurrentTextureSource->GetSize();
|
||||
effect->mTextureCoords =
|
||||
Rect(Float(img->mPictureRect.X()) / textureSize.width,
|
||||
Float(img->mPictureRect.Y()) / textureSize.height,
|
||||
Float(img->mPictureRect.Width()) / textureSize.width,
|
||||
Float(img->mPictureRect.Height()) / textureSize.height);
|
||||
|
||||
if (img->mTextureHost->GetFlags() & TextureFlags::ORIGIN_BOTTOM_LEFT) {
|
||||
effect->mTextureCoords.SetRectY(effect->mTextureCoords.YMost(),
|
||||
-effect->mTextureCoords.Height());
|
||||
}
|
||||
|
||||
aCompositor->DrawGeometry(pictureRect, aClipRect, aEffectChain, aOpacity,
|
||||
aTransform, aGeometry);
|
||||
aCompositor->DrawDiagnostics(diagnosticFlags, pictureRect, aClipRect,
|
||||
aTransform, mFlashCounter);
|
||||
}
|
||||
}
|
||||
|
||||
FinishRendering(info);
|
||||
}
|
||||
|
||||
bool ImageHost::PrepareToRender(TextureSourceProvider* aProvider,
|
||||
RenderInfo* aOutInfo) {
|
||||
return false;
|
||||
}
|
||||
|
||||
RefPtr<TextureSource> ImageHost::AcquireTextureSource(const RenderInfo& aInfo) {
|
||||
MOZ_ASSERT(aInfo.host == mCurrentTextureHost);
|
||||
if (!aInfo.host->AcquireTextureSource(mCurrentTextureSource)) {
|
||||
return nullptr;
|
||||
}
|
||||
return mCurrentTextureSource.get();
|
||||
}
|
||||
|
||||
void ImageHost::FinishRendering(const RenderInfo& aInfo) {
|
||||
OnFinishRendering(aInfo.imageIndex, aInfo.img, mAsyncRef.mProcessId,
|
||||
mAsyncRef.mHandle);
|
||||
}
|
||||
|
||||
void ImageHost::SetTextureSourceProvider(TextureSourceProvider* aProvider) {
|
||||
if (mTextureSourceProvider != aProvider) {
|
||||
for (const auto& img : Images()) {
|
||||
img.mTextureHost->SetTextureSourceProvider(aProvider);
|
||||
}
|
||||
}
|
||||
CompositableHost::SetTextureSourceProvider(aProvider);
|
||||
}
|
||||
|
||||
void ImageHost::PrintInfo(std::stringstream& aStream, const char* aPrefix) {
|
||||
aStream << aPrefix;
|
||||
aStream << nsPrintfCString("ImageHost (0x%p)", this).get();
|
||||
|
||||
nsAutoCString pfx(aPrefix);
|
||||
pfx += " ";
|
||||
for (const auto& img : Images()) {
|
||||
aStream << "\n";
|
||||
img.mTextureHost->PrintInfo(aStream, pfx.get());
|
||||
aStream << " [picture-rect=" << img.mPictureRect << "]";
|
||||
}
|
||||
}
|
||||
|
||||
void ImageHost::Dump(std::stringstream& aStream, const char* aPrefix,
|
||||
bool aDumpHtml) {
|
||||
for (const auto& img : Images()) {
|
||||
aStream << aPrefix;
|
||||
aStream << (aDumpHtml ? "<ul><li>TextureHost: " : "TextureHost: ");
|
||||
DumpTextureHost(aStream, img.mTextureHost);
|
||||
aStream << (aDumpHtml ? " </li></ul> " : " ");
|
||||
}
|
||||
}
|
||||
|
||||
already_AddRefed<gfx::DataSourceSurface> ImageHost::GetAsSurface() {
|
||||
const TimedImage* img = ChooseImage();
|
||||
if (img) {
|
||||
return img->mTextureHost->GetAsSurface();
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool ImageHost::Lock() {
|
||||
MOZ_ASSERT(!mLocked);
|
||||
const TimedImage* img = ChooseImage();
|
||||
if (!img) {
|
||||
return false;
|
||||
}
|
||||
|
||||
SetCurrentTextureHost(img->mTextureHost);
|
||||
|
||||
if (!mCurrentTextureHost->Lock()) {
|
||||
return false;
|
||||
}
|
||||
mLocked = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
void ImageHost::Unlock() {
|
||||
MOZ_ASSERT(mLocked);
|
||||
|
||||
if (mCurrentTextureHost) {
|
||||
mCurrentTextureHost->Unlock();
|
||||
}
|
||||
mLocked = false;
|
||||
}
|
||||
|
||||
IntSize ImageHost::GetImageSize() {
|
||||
const TimedImage* img = ChooseImage();
|
||||
if (img) {
|
||||
return IntSize(img->mPictureRect.Width(), img->mPictureRect.Height());
|
||||
}
|
||||
return IntSize();
|
||||
}
|
||||
|
||||
bool ImageHost::IsOpaque() {
|
||||
const TimedImage* img = ChooseImage();
|
||||
if (!img) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (img->mPictureRect.Width() == 0 || img->mPictureRect.Height() == 0 ||
|
||||
!img->mTextureHost) {
|
||||
return false;
|
||||
}
|
||||
|
||||
gfx::SurfaceFormat format = img->mTextureHost->GetFormat();
|
||||
if (gfx::IsOpaque(format)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
already_AddRefed<TexturedEffect> ImageHost::GenEffect(
|
||||
const gfx::SamplingFilter aSamplingFilter) {
|
||||
const TimedImage* img = ChooseImage();
|
||||
if (!img) {
|
||||
return nullptr;
|
||||
}
|
||||
SetCurrentTextureHost(img->mTextureHost);
|
||||
if (!mCurrentTextureHost->BindTextureSource(mCurrentTextureSource)) {
|
||||
return nullptr;
|
||||
}
|
||||
bool isAlphaPremultiplied = true;
|
||||
if (mCurrentTextureHost->GetFlags() & TextureFlags::NON_PREMULTIPLIED) {
|
||||
isAlphaPremultiplied = false;
|
||||
}
|
||||
|
||||
return CreateTexturedEffect(mCurrentTextureHost, mCurrentTextureSource,
|
||||
aSamplingFilter, isAlphaPremultiplied);
|
||||
}
|
||||
|
||||
} // namespace layers
|
||||
} // namespace mozilla
|
||||
|
|
@ -1,138 +0,0 @@
|
|||
/* -*- 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/. */
|
||||
|
||||
#ifndef MOZILLA_GFX_IMAGEHOST_H
|
||||
#define MOZILLA_GFX_IMAGEHOST_H
|
||||
|
||||
#include <stdio.h> // for FILE
|
||||
#include "CompositableHost.h" // for CompositableHost
|
||||
#include "mozilla/Attributes.h" // for override
|
||||
#include "mozilla/RefPtr.h" // for RefPtr
|
||||
#include "mozilla/gfx/MatrixFwd.h" // for Matrix4x4
|
||||
#include "mozilla/gfx/Point.h" // for Point
|
||||
#include "mozilla/gfx/Polygon.h" // for Polygon
|
||||
#include "mozilla/gfx/Rect.h" // for Rect
|
||||
#include "mozilla/gfx/Types.h" // for SamplingFilter
|
||||
#include "mozilla/layers/CompositorTypes.h" // for TextureInfo, etc
|
||||
#include "mozilla/layers/ImageComposite.h" // for ImageComposite
|
||||
#include "mozilla/layers/LayersSurfaces.h" // for SurfaceDescriptor
|
||||
#include "mozilla/layers/LayersTypes.h" // for LayerRenderState, etc
|
||||
#include "mozilla/layers/TextureHost.h" // for TextureHost, etc
|
||||
#include "mozilla/mozalloc.h" // for operator delete
|
||||
#include "nsCOMPtr.h" // for already_AddRefed
|
||||
#include "nsRect.h" // for mozilla::gfx::IntRect
|
||||
#include "nsRegionFwd.h" // for nsIntRegion
|
||||
#include "nscore.h" // for nsACString
|
||||
|
||||
namespace mozilla {
|
||||
namespace layers {
|
||||
|
||||
class Compositor;
|
||||
struct EffectChain;
|
||||
class HostLayerManager;
|
||||
|
||||
/**
|
||||
* ImageHost. Works with ImageClientSingle and ImageClientBuffered
|
||||
*/
|
||||
class ImageHost : public CompositableHost, public ImageComposite {
|
||||
public:
|
||||
explicit ImageHost(const TextureInfo& aTextureInfo);
|
||||
virtual ~ImageHost();
|
||||
|
||||
CompositableType GetType() override { return mTextureInfo.mCompositableType; }
|
||||
ImageHost* AsImageHost() override { return this; }
|
||||
|
||||
void Composite(Compositor* aCompositor, LayerComposite* aLayer,
|
||||
EffectChain& aEffectChain, float aOpacity,
|
||||
const gfx::Matrix4x4& aTransform,
|
||||
const gfx::SamplingFilter aSamplingFilter,
|
||||
const gfx::IntRect& aClipRect,
|
||||
const nsIntRegion* aVisibleRegion = nullptr,
|
||||
const Maybe<gfx::Polygon>& aGeometry = Nothing()) override;
|
||||
|
||||
void UseTextureHost(const nsTArray<TimedTexture>& aTextures) override;
|
||||
|
||||
void RemoveTextureHost(TextureHost* aTexture) override;
|
||||
|
||||
TextureHost* GetAsTextureHost(gfx::IntRect* aPictureRect = nullptr) override;
|
||||
|
||||
void Attach(Layer* aLayer, TextureSourceProvider* aProvider,
|
||||
AttachFlags aFlags = NO_FLAGS) override;
|
||||
|
||||
void SetTextureSourceProvider(TextureSourceProvider* aProvider) override;
|
||||
|
||||
gfx::IntSize GetImageSize() override;
|
||||
|
||||
void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
|
||||
|
||||
void Dump(std::stringstream& aStream, const char* aPrefix = "",
|
||||
bool aDumpHtml = false) override;
|
||||
|
||||
already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override;
|
||||
|
||||
bool Lock() override;
|
||||
|
||||
void Unlock() override;
|
||||
|
||||
already_AddRefed<TexturedEffect> GenEffect(
|
||||
const gfx::SamplingFilter aSamplingFilter) override;
|
||||
|
||||
void SetCurrentTextureHost(TextureHost* aTexture);
|
||||
|
||||
void CleanupResources() override;
|
||||
|
||||
bool IsOpaque();
|
||||
|
||||
uint32_t GetDroppedFrames() override { return GetDroppedFramesAndReset(); }
|
||||
|
||||
struct RenderInfo {
|
||||
int imageIndex;
|
||||
const TimedImage* img;
|
||||
RefPtr<TextureHost> host;
|
||||
|
||||
RenderInfo() : imageIndex(-1), img(nullptr) {}
|
||||
};
|
||||
|
||||
// Acquire rendering information for the current frame.
|
||||
bool PrepareToRender(TextureSourceProvider* aProvider, RenderInfo* aOutInfo);
|
||||
|
||||
// Acquire the TextureSource for the currently prepared frame.
|
||||
RefPtr<TextureSource> AcquireTextureSource(const RenderInfo& aInfo);
|
||||
|
||||
// Send ImageComposite notifications.
|
||||
void FinishRendering(const RenderInfo& aInfo);
|
||||
|
||||
// This should only be called inside a lock, or during rendering. It is
|
||||
// infallible to enforce this.
|
||||
TextureHost* CurrentTextureHost() const {
|
||||
MOZ_ASSERT(mCurrentTextureHost);
|
||||
return mCurrentTextureHost;
|
||||
}
|
||||
|
||||
protected:
|
||||
// ImageComposite
|
||||
TimeStamp GetCompositionTime() const override;
|
||||
CompositionOpportunityId GetCompositionOpportunityId() const override;
|
||||
void AppendImageCompositeNotification(
|
||||
const ImageCompositeNotificationInfo& aInfo) const override;
|
||||
|
||||
// Use a simple RefPtr because the same texture is already held by a
|
||||
// a CompositableTextureHostRef in the array of TimedImage.
|
||||
// See the comment in CompositableTextureRef for more details.
|
||||
RefPtr<TextureHost> mCurrentTextureHost;
|
||||
CompositableTextureSourceRef mCurrentTextureSource;
|
||||
// When doing texture uploads it's best to alternate between two (or three)
|
||||
// texture sources so that the texture we upload to isn't being used by
|
||||
// the GPU to composite the previous frame.
|
||||
RefPtr<TextureSource> mExtraTextureSource;
|
||||
|
||||
bool mLocked;
|
||||
};
|
||||
|
||||
} // namespace layers
|
||||
} // namespace mozilla
|
||||
|
||||
#endif
|
||||
|
|
@ -15,8 +15,6 @@
|
|||
#include "mozilla/gfx/DeviceManagerDx.h"
|
||||
#include "mozilla/gfx/GPUParent.h"
|
||||
#include "mozilla/gfx/Swizzle.h"
|
||||
#include "mozilla/layers/ImageHost.h"
|
||||
#include "mozilla/layers/ContentHost.h"
|
||||
#include "mozilla/layers/Diagnostics.h"
|
||||
#include "mozilla/layers/DiagnosticsD3D11.h"
|
||||
#include "mozilla/layers/Effects.h"
|
||||
|
|
|
|||
|
|
@ -12,7 +12,6 @@
|
|||
#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc
|
||||
#include "mozilla/RefPtr.h" // for RefPtr
|
||||
#include "mozilla/layers/CompositorTypes.h"
|
||||
#include "mozilla/layers/ContentHost.h" // for ContentHostBase
|
||||
#include "mozilla/layers/ImageBridgeParent.h" // for ImageBridgeParent
|
||||
#include "mozilla/layers/LayersSurfaces.h" // for SurfaceDescriptor
|
||||
#include "mozilla/layers/LayersTypes.h" // for MOZ_LAYERS_LOG
|
||||
|
|
@ -81,12 +80,6 @@ bool CompositableParentManager::ReceiveCompositableUpdate(
|
|||
}
|
||||
|
||||
switch (aDetail.type()) {
|
||||
case CompositableOperationDetail::TOpPaintTextureRegion: {
|
||||
return false;
|
||||
}
|
||||
case CompositableOperationDetail::TOpUseTiledLayerBuffer: {
|
||||
return false;
|
||||
}
|
||||
case CompositableOperationDetail::TOpRemoveTexture: {
|
||||
const OpRemoveTexture& op = aDetail.get_OpRemoveTexture();
|
||||
|
||||
|
|
@ -132,42 +125,6 @@ bool CompositableParentManager::ReceiveCompositableUpdate(
|
|||
}
|
||||
break;
|
||||
}
|
||||
case CompositableOperationDetail::TOpUseComponentAlphaTextures: {
|
||||
const OpUseComponentAlphaTextures& op =
|
||||
aDetail.get_OpUseComponentAlphaTextures();
|
||||
RefPtr<TextureHost> texOnBlack =
|
||||
TextureHost::AsTextureHost(op.textureOnBlackParent());
|
||||
RefPtr<TextureHost> texOnWhite =
|
||||
TextureHost::AsTextureHost(op.textureOnWhiteParent());
|
||||
if (op.readLockedBlack()) {
|
||||
texOnBlack->SetReadLocked();
|
||||
}
|
||||
if (op.readLockedWhite()) {
|
||||
texOnWhite->SetReadLocked();
|
||||
}
|
||||
|
||||
MOZ_ASSERT(texOnBlack && texOnWhite);
|
||||
aCompositable->UseComponentAlphaTextures(texOnBlack, texOnWhite);
|
||||
|
||||
if (texOnBlack) {
|
||||
texOnBlack->SetLastFwdTransactionId(mFwdTransactionId);
|
||||
// Make sure that each texture was handled by the compositable
|
||||
// because the recycling logic depends on it.
|
||||
MOZ_ASSERT(texOnBlack->NumCompositableRefs() > 0);
|
||||
}
|
||||
|
||||
if (texOnWhite) {
|
||||
texOnWhite->SetLastFwdTransactionId(mFwdTransactionId);
|
||||
// Make sure that each texture was handled by the compositable
|
||||
// because the recycling logic depends on it.
|
||||
MOZ_ASSERT(texOnWhite->NumCompositableRefs() > 0);
|
||||
}
|
||||
|
||||
if (UsesImageBridge()) {
|
||||
ScheduleComposition(aCompositable);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case CompositableOperationDetail::TOpDeliverAcquireFence: {
|
||||
const OpDeliverAcquireFence& op = aDetail.get_OpDeliverAcquireFence();
|
||||
RefPtr<TextureHost> tex = TextureHost::AsTextureHost(op.textureParent());
|
||||
|
|
@ -204,8 +161,7 @@ void CompositableParentManager::DestroyActor(const OpDestroy& aOp) {
|
|||
}
|
||||
|
||||
RefPtr<CompositableHost> CompositableParentManager::AddCompositable(
|
||||
const CompositableHandle& aHandle, const TextureInfo& aInfo,
|
||||
bool aUseWebRender) {
|
||||
const CompositableHandle& aHandle, const TextureInfo& aInfo) {
|
||||
if (mCompositables.find(aHandle.Value()) != mCompositables.end()) {
|
||||
NS_ERROR("Client should not allocate duplicate handles");
|
||||
return nullptr;
|
||||
|
|
@ -215,8 +171,7 @@ RefPtr<CompositableHost> CompositableParentManager::AddCompositable(
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
RefPtr<CompositableHost> host =
|
||||
CompositableHost::Create(aInfo, aUseWebRender);
|
||||
RefPtr<CompositableHost> host = CompositableHost::Create(aInfo);
|
||||
if (!host) {
|
||||
return nullptr;
|
||||
}
|
||||
|
|
@ -226,33 +181,13 @@ RefPtr<CompositableHost> CompositableParentManager::AddCompositable(
|
|||
}
|
||||
|
||||
RefPtr<CompositableHost> CompositableParentManager::FindCompositable(
|
||||
const CompositableHandle& aHandle, bool aAllowDisablingWebRender) {
|
||||
const CompositableHandle& aHandle) {
|
||||
auto iter = mCompositables.find(aHandle.Value());
|
||||
if (iter == mCompositables.end()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
RefPtr<CompositableHost> host = iter->second;
|
||||
if (!aAllowDisablingWebRender) {
|
||||
return host;
|
||||
}
|
||||
|
||||
if (!host->AsWebRenderImageHost() || !host->GetAsyncRef()) {
|
||||
return host;
|
||||
}
|
||||
|
||||
// Try to replace WebRenderImageHost of ImageBridge to ImageHost.
|
||||
RefPtr<CompositableHost> newHost = CompositableHost::Create(
|
||||
host->GetTextureInfo(), /* aUseWebRender */ false);
|
||||
if (!newHost || !newHost->AsImageHost()) {
|
||||
MOZ_ASSERT_UNREACHABLE("unexpected to be called");
|
||||
return host;
|
||||
}
|
||||
|
||||
newHost->SetAsyncRef(host->GetAsyncRef());
|
||||
mCompositables[aHandle.Value()] = newHost;
|
||||
|
||||
return newHost;
|
||||
return iter->second;
|
||||
}
|
||||
|
||||
void CompositableParentManager::ReleaseCompositable(
|
||||
|
|
|
|||
|
|
@ -36,10 +36,8 @@ class CompositableParentManager : public HostIPCAllocator {
|
|||
uint64_t GetFwdTransactionId() { return mFwdTransactionId; }
|
||||
|
||||
RefPtr<CompositableHost> AddCompositable(const CompositableHandle& aHandle,
|
||||
const TextureInfo& aInfo,
|
||||
bool aUseWebRender);
|
||||
RefPtr<CompositableHost> FindCompositable(
|
||||
const CompositableHandle& aHandle, bool aAllowDisablingWebRender = false);
|
||||
const TextureInfo& aInfo);
|
||||
RefPtr<CompositableHost> FindCompositable(const CompositableHandle& aHandle);
|
||||
|
||||
protected:
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -291,8 +291,7 @@ void ImageBridgeChild::Connect(CompositableClient* aCompositable,
|
|||
|
||||
CompositableHandle handle(id);
|
||||
aCompositable->InitIPDL(handle);
|
||||
SendNewCompositable(handle, aCompositable->GetTextureInfo(),
|
||||
GetCompositorBackendType());
|
||||
SendNewCompositable(handle, aCompositable->GetTextureInfo());
|
||||
}
|
||||
|
||||
void ImageBridgeChild::ForgetImageContainer(const CompositableHandle& aHandle) {
|
||||
|
|
|
|||
|
|
@ -272,10 +272,8 @@ mozilla::ipc::IPCResult ImageBridgeParent::RecvWillClose() {
|
|||
}
|
||||
|
||||
mozilla::ipc::IPCResult ImageBridgeParent::RecvNewCompositable(
|
||||
const CompositableHandle& aHandle, const TextureInfo& aInfo,
|
||||
const LayersBackend& aLayersBackend) {
|
||||
bool useWebRender = aLayersBackend == LayersBackend::LAYERS_WR;
|
||||
RefPtr<CompositableHost> host = AddCompositable(aHandle, aInfo, useWebRender);
|
||||
const CompositableHandle& aHandle, const TextureInfo& aInfo) {
|
||||
RefPtr<CompositableHost> host = AddCompositable(aHandle, aInfo);
|
||||
if (!host) {
|
||||
return IPC_FAIL_NO_REASON(this);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -86,9 +86,8 @@ class ImageBridgeParent final : public PImageBridgeParent,
|
|||
const wr::MaybeExternalImageId& aExternalImageId);
|
||||
bool DeallocPTextureParent(PTextureParent* actor);
|
||||
|
||||
mozilla::ipc::IPCResult RecvNewCompositable(
|
||||
const CompositableHandle& aHandle, const TextureInfo& aInfo,
|
||||
const LayersBackend& aLayersBackend);
|
||||
mozilla::ipc::IPCResult RecvNewCompositable(const CompositableHandle& aHandle,
|
||||
const TextureInfo& aInfo);
|
||||
mozilla::ipc::IPCResult RecvReleaseCompositable(
|
||||
const CompositableHandle& aHandle);
|
||||
|
||||
|
|
|
|||
|
|
@ -346,47 +346,6 @@ union ReadLockDescriptor {
|
|||
null_t;
|
||||
};
|
||||
|
||||
struct TexturedTileDescriptor {
|
||||
PTexture texture;
|
||||
PTexture? textureOnWhite;
|
||||
IntRect updateRect;
|
||||
bool readLocked;
|
||||
bool readLockedOnWhite;
|
||||
bool wasPlaceholder;
|
||||
};
|
||||
|
||||
struct PlaceholderTileDescriptor {
|
||||
};
|
||||
|
||||
union TileDescriptor {
|
||||
TexturedTileDescriptor;
|
||||
PlaceholderTileDescriptor;
|
||||
};
|
||||
|
||||
struct SurfaceDescriptorTiles {
|
||||
nsIntRegion validRegion;
|
||||
TileDescriptor[] tiles;
|
||||
IntPoint tileOrigin;
|
||||
IntSize tileSize;
|
||||
int firstTileX;
|
||||
int firstTileY;
|
||||
int retainedWidth;
|
||||
int retainedHeight;
|
||||
float resolution;
|
||||
float frameXResolution;
|
||||
float frameYResolution;
|
||||
bool isProgressive;
|
||||
};
|
||||
|
||||
struct OpUseTiledLayerBuffer {
|
||||
SurfaceDescriptorTiles tileLayerDescriptor;
|
||||
};
|
||||
|
||||
struct OpPaintTextureRegion {
|
||||
ThebesBufferData bufferData;
|
||||
nsIntRegion updatedRegion;
|
||||
};
|
||||
|
||||
/**
|
||||
* Tells the CompositableHost to remove the corresponding TextureHost
|
||||
*/
|
||||
|
|
@ -417,13 +376,6 @@ struct OpUseTexture {
|
|||
TimedTexture[] textures;
|
||||
};
|
||||
|
||||
struct OpUseComponentAlphaTextures {
|
||||
PTexture textureOnBlack;
|
||||
PTexture textureOnWhite;
|
||||
bool readLockedBlack;
|
||||
bool readLockedWhite;
|
||||
};
|
||||
|
||||
struct OpNotifyNotUsed {
|
||||
uint64_t TextureId;
|
||||
uint64_t fwdTransactionId;
|
||||
|
|
@ -442,14 +394,9 @@ struct OpDeliverReleaseFence {
|
|||
};
|
||||
|
||||
union CompositableOperationDetail {
|
||||
OpPaintTextureRegion;
|
||||
|
||||
OpUseTiledLayerBuffer;
|
||||
|
||||
OpRemoveTexture;
|
||||
|
||||
OpUseTexture;
|
||||
OpUseComponentAlphaTextures;
|
||||
|
||||
OpDeliverAcquireFence;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ parent:
|
|||
async PTexture(SurfaceDescriptor aSharedData, ReadLockDescriptor aReadLock, LayersBackend aBackend, TextureFlags aTextureFlags, uint64_t aSerial, MaybeExternalImageId aExternalImageId);
|
||||
async PMediaSystemResourceManager();
|
||||
|
||||
sync NewCompositable(CompositableHandle aHandle, TextureInfo aInfo, LayersBackend aBackend);
|
||||
sync NewCompositable(CompositableHandle aHandle, TextureInfo aInfo);
|
||||
async ReleaseCompositable(CompositableHandle aHandle);
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -12,7 +12,6 @@ with Files("apz/**"):
|
|||
|
||||
EXPORTS += [
|
||||
"composite/CompositableHost.h",
|
||||
"composite/ImageHost.h",
|
||||
"CompositorTypes.h",
|
||||
"D3D9SurfaceImage.h",
|
||||
"FrameMetrics.h",
|
||||
|
|
@ -134,13 +133,11 @@ EXPORTS.mozilla.layers += [
|
|||
"client/TextureClientRecycleAllocator.h",
|
||||
"client/TextureClientSharedSurface.h",
|
||||
"client/TextureRecorded.h",
|
||||
"composite/ContentHost.h",
|
||||
"composite/Diagnostics.h",
|
||||
"composite/FPSCounter.h",
|
||||
"composite/FrameUniformityData.h",
|
||||
"composite/GPUVideoTextureHost.h",
|
||||
"composite/ImageComposite.h",
|
||||
"composite/ImageHost.h",
|
||||
"composite/TextRenderer.h",
|
||||
"composite/TextureHost.h",
|
||||
"CompositionRecorder.h",
|
||||
|
|
@ -381,13 +378,11 @@ UNIFIED_SOURCES += [
|
|||
"client/TextureClientSharedSurface.cpp",
|
||||
"client/TextureRecorded.cpp",
|
||||
"composite/CompositableHost.cpp",
|
||||
"composite/ContentHost.cpp",
|
||||
"composite/Diagnostics.cpp",
|
||||
"composite/FPSCounter.cpp",
|
||||
"composite/FrameUniformityData.cpp",
|
||||
"composite/GPUVideoTextureHost.cpp",
|
||||
"composite/ImageComposite.cpp",
|
||||
"composite/ImageHost.cpp",
|
||||
"composite/TextRenderer.cpp",
|
||||
"composite/TextureHost.cpp",
|
||||
"CompositionRecorder.cpp",
|
||||
|
|
|
|||
|
|
@ -2611,7 +2611,7 @@ mozilla::ipc::IPCResult WebRenderBridgeParent::RecvNewCompositable(
|
|||
if (mDestroyed) {
|
||||
return IPC_OK();
|
||||
}
|
||||
if (!AddCompositable(aHandle, aInfo, /* aUseWebRender */ true)) {
|
||||
if (!AddCompositable(aHandle, aInfo)) {
|
||||
return IPC_FAIL_NO_REASON(this);
|
||||
}
|
||||
return IPC_OK();
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче