forked from mirrors/gecko-dev
70040ff272
We report the number of frames dropped by the compositor because they were too late through: ImageComposite -> ImageHost -> CompositableTransactionParent -> ImageBridgeParent -> IPDL -> ImageBridgeChild -> ImageContainerListener -> ImageContainer -> VideoSink Differential Revision: https://phabricator.services.mozilla.com/D2177
144 lines
5.1 KiB
C++
144 lines
5.1 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/. */
|
|
|
|
#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);
|
|
~ImageHost();
|
|
|
|
virtual CompositableType GetType() override { return mTextureInfo.mCompositableType; }
|
|
virtual ImageHost* AsImageHost() override { return this; }
|
|
|
|
virtual 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;
|
|
|
|
virtual void UseTextureHost(const nsTArray<TimedTexture>& aTextures) override;
|
|
|
|
virtual void RemoveTextureHost(TextureHost* aTexture) override;
|
|
|
|
virtual TextureHost* GetAsTextureHost(gfx::IntRect* aPictureRect = nullptr) override;
|
|
|
|
virtual void Attach(Layer* aLayer,
|
|
TextureSourceProvider* aProvider,
|
|
AttachFlags aFlags = NO_FLAGS) override;
|
|
|
|
virtual void SetTextureSourceProvider(TextureSourceProvider* aProvider) override;
|
|
|
|
gfx::IntSize GetImageSize() override;
|
|
|
|
virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override;
|
|
|
|
virtual void Dump(std::stringstream& aStream,
|
|
const char* aPrefix = "",
|
|
bool aDumpHtml = false) override;
|
|
|
|
virtual already_AddRefed<gfx::DataSourceSurface> GetAsSurface() override;
|
|
|
|
virtual bool Lock() override;
|
|
|
|
virtual void Unlock() override;
|
|
|
|
virtual already_AddRefed<TexturedEffect> GenEffect(const gfx::SamplingFilter aSamplingFilter) override;
|
|
|
|
void SetCurrentTextureHost(TextureHost* aTexture);
|
|
|
|
virtual 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 and update the ChooseImage bias.
|
|
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
|
|
virtual TimeStamp GetCompositionTime() 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
|