mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
2cfb959a9f
This makes the ownership clear and removes some code. --HG-- extra : rebase_source : fca529c3e5dd224be090876a6f4528ed8686e4e5
710 lines
21 KiB
C++
710 lines
21 KiB
C++
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
* 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_TEXTUREHOST_H
|
|
#define MOZILLA_GFX_TEXTUREHOST_H
|
|
|
|
#include <stddef.h> // for size_t
|
|
#include <stdint.h> // for uint64_t, uint32_t, uint8_t
|
|
#include "gfxTypes.h"
|
|
#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc
|
|
#include "mozilla/Attributes.h" // for MOZ_OVERRIDE
|
|
#include "mozilla/RefPtr.h" // for RefPtr, TemporaryRef, etc
|
|
#include "mozilla/gfx/2D.h" // for DataSourceSurface
|
|
#include "mozilla/gfx/Point.h" // for IntSize, IntPoint
|
|
#include "mozilla/gfx/Types.h" // for SurfaceFormat, etc
|
|
#include "mozilla/layers/CompositorTypes.h" // for TextureFlags, etc
|
|
#include "mozilla/layers/FenceUtils.h" // for FenceHandle
|
|
#include "mozilla/layers/LayersTypes.h" // for LayerRenderState, etc
|
|
#include "mozilla/mozalloc.h" // for operator delete
|
|
#include "mozilla/UniquePtr.h" // for UniquePtr
|
|
#include "nsCOMPtr.h" // for already_AddRefed
|
|
#include "nsDebug.h" // for NS_RUNTIMEABORT
|
|
#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc
|
|
#include "nsRegion.h" // for nsIntRegion
|
|
#include "nsTraceRefcnt.h" // for MOZ_COUNT_CTOR, etc
|
|
#include "nscore.h" // for nsACString
|
|
#include "mozilla/layers/AtomicRefCountedWithFinalize.h"
|
|
|
|
class gfxReusableSurfaceWrapper;
|
|
struct nsIntPoint;
|
|
struct nsIntSize;
|
|
struct nsIntRect;
|
|
|
|
namespace mozilla {
|
|
namespace gl {
|
|
class SurfaceStream;
|
|
}
|
|
namespace ipc {
|
|
class Shmem;
|
|
}
|
|
|
|
namespace layers {
|
|
|
|
class Compositor;
|
|
class CompositableHost;
|
|
class CompositableBackendSpecificData;
|
|
class CompositableParentManager;
|
|
class SurfaceDescriptor;
|
|
class SurfaceStreamDescriptor;
|
|
class ISurfaceAllocator;
|
|
class TextureHostOGL;
|
|
class TextureSourceOGL;
|
|
class TextureSourceD3D9;
|
|
class TextureSourceD3D11;
|
|
class TextureSourceBasic;
|
|
class DataTextureSource;
|
|
class PTextureParent;
|
|
class TextureParent;
|
|
|
|
/**
|
|
* A view on a TextureHost where the texture is internally represented as tiles
|
|
* (contrast with a tiled buffer, where each texture is a tile). For iteration by
|
|
* the texture's buffer host.
|
|
* This is only useful when the underlying surface is too big to fit in one
|
|
* device texture, which forces us to split it in smaller parts.
|
|
* Tiled Compositable is a different thing.
|
|
*/
|
|
class BigImageIterator
|
|
{
|
|
public:
|
|
virtual void BeginBigImageIteration() = 0;
|
|
virtual void EndBigImageIteration() {};
|
|
virtual nsIntRect GetTileRect() = 0;
|
|
virtual size_t GetTileCount() = 0;
|
|
virtual bool NextTile() = 0;
|
|
};
|
|
|
|
/**
|
|
* TextureSource is the interface for texture objects that can be composited
|
|
* by a given compositor backend. Since the drawing APIs are different
|
|
* between backends, the TextureSource interface is split into different
|
|
* interfaces (TextureSourceOGL, etc.), and TextureSource mostly provide
|
|
* access to these interfaces.
|
|
*
|
|
* This class is used on the compositor side.
|
|
*/
|
|
class TextureSource
|
|
{
|
|
protected:
|
|
virtual ~TextureSource();
|
|
|
|
public:
|
|
NS_INLINE_DECL_REFCOUNTING(TextureSource)
|
|
|
|
TextureSource();
|
|
|
|
/**
|
|
* Return the size of the texture in texels.
|
|
* If this is a tile iterator, GetSize must return the size of the current tile.
|
|
*/
|
|
virtual gfx::IntSize GetSize() const = 0;
|
|
|
|
/**
|
|
* Return the pixel format of this texture
|
|
*/
|
|
virtual gfx::SurfaceFormat GetFormat() const { return gfx::SurfaceFormat::UNKNOWN; }
|
|
|
|
/**
|
|
* Cast to a TextureSource for for each backend..
|
|
*/
|
|
virtual TextureSourceOGL* AsSourceOGL() { return nullptr; }
|
|
virtual TextureSourceD3D9* AsSourceD3D9() { return nullptr; }
|
|
virtual TextureSourceD3D11* AsSourceD3D11() { return nullptr; }
|
|
virtual TextureSourceBasic* AsSourceBasic() { return nullptr; }
|
|
|
|
/**
|
|
* Cast to a DataTextureSurce.
|
|
*/
|
|
virtual DataTextureSource* AsDataTextureSource() { return nullptr; }
|
|
|
|
/**
|
|
* In some rare cases we currently need to consider a group of textures as one
|
|
* TextureSource, that can be split in sub-TextureSources.
|
|
*/
|
|
virtual TextureSource* GetSubSource(int index) { return nullptr; }
|
|
|
|
/**
|
|
* Overload this if the TextureSource supports big textures that don't fit in
|
|
* one device texture and must be tiled internally.
|
|
*/
|
|
virtual BigImageIterator* AsBigImageIterator() { return nullptr; }
|
|
|
|
virtual void SetCompositableBackendSpecificData(CompositableBackendSpecificData* aBackendData);
|
|
|
|
protected:
|
|
RefPtr<CompositableBackendSpecificData> mCompositableBackendData;
|
|
};
|
|
|
|
/**
|
|
* XXX - merge this class with TextureSource when deprecated texture classes
|
|
* are completely removed.
|
|
*/
|
|
class NewTextureSource : public TextureSource
|
|
{
|
|
public:
|
|
NewTextureSource()
|
|
{
|
|
MOZ_COUNT_CTOR(NewTextureSource);
|
|
}
|
|
protected:
|
|
virtual ~NewTextureSource()
|
|
{
|
|
MOZ_COUNT_DTOR(NewTextureSource);
|
|
}
|
|
|
|
public:
|
|
/**
|
|
* Should be overridden in order to deallocate the data that is associated
|
|
* with the rendering backend, such as GL textures.
|
|
*/
|
|
virtual void DeallocateDeviceData() = 0;
|
|
|
|
virtual void SetCompositor(Compositor* aCompositor) {}
|
|
|
|
void SetNextSibling(NewTextureSource* aTexture)
|
|
{
|
|
mNextSibling = aTexture;
|
|
}
|
|
|
|
NewTextureSource* GetNextSibling() const
|
|
{
|
|
return mNextSibling;
|
|
}
|
|
|
|
// temporary adapter to use the same SubSource API as the old TextureSource
|
|
virtual TextureSource* GetSubSource(int index) MOZ_OVERRIDE
|
|
{
|
|
switch (index) {
|
|
case 0: return this;
|
|
case 1: return GetNextSibling();
|
|
case 2: return GetNextSibling() ? GetNextSibling()->GetNextSibling() : nullptr;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
protected:
|
|
RefPtr<NewTextureSource> mNextSibling;
|
|
};
|
|
|
|
/**
|
|
* Interface for TextureSources that can be updated from a DataSourceSurface.
|
|
*
|
|
* All backend should implement at least one DataTextureSource.
|
|
*/
|
|
class DataTextureSource : public NewTextureSource
|
|
{
|
|
public:
|
|
DataTextureSource()
|
|
: mUpdateSerial(0)
|
|
{}
|
|
|
|
virtual DataTextureSource* AsDataTextureSource() MOZ_OVERRIDE { return this; }
|
|
|
|
/**
|
|
* Upload a (portion of) surface to the TextureSource.
|
|
*
|
|
* The DataTextureSource doesn't own aSurface, although it owns and manage
|
|
* the device texture it uploads to internally.
|
|
*/
|
|
virtual bool Update(gfx::DataSourceSurface* aSurface,
|
|
nsIntRegion* aDestRegion = nullptr,
|
|
gfx::IntPoint* aSrcOffset = nullptr) = 0;
|
|
|
|
/**
|
|
* A facility to avoid reuploading when it is not necessary.
|
|
* The caller of Update can use GetUpdateSerial to see if the number has changed
|
|
* since last update, and call SetUpdateSerial after each successful update.
|
|
* The caller is responsible for managing the update serial except when the
|
|
* texture data is deallocated in which case the TextureSource should always
|
|
* reset the update serial to zero.
|
|
*/
|
|
uint32_t GetUpdateSerial() const { return mUpdateSerial; }
|
|
void SetUpdateSerial(uint32_t aValue) { mUpdateSerial = aValue; }
|
|
|
|
// By default at least set the update serial to zero.
|
|
// overloaded versions should do that too.
|
|
virtual void DeallocateDeviceData() MOZ_OVERRIDE
|
|
{
|
|
SetUpdateSerial(0);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
/**
|
|
* Provide read access to the data as a DataSourceSurface.
|
|
*
|
|
* This is expected to be very slow and should be used for mostly debugging.
|
|
* XXX - implement everywhere and make it pure virtual.
|
|
*/
|
|
virtual TemporaryRef<gfx::DataSourceSurface> ReadBack() { return nullptr; };
|
|
#endif
|
|
|
|
private:
|
|
uint32_t mUpdateSerial;
|
|
};
|
|
|
|
/**
|
|
* TextureHost is a thin abstraction over texture data that need to be shared
|
|
* between the content process and the compositor process. It is the
|
|
* compositor-side half of a TextureClient/TextureHost pair. A corresponding
|
|
* TextureClient lives on the content-side.
|
|
*
|
|
* TextureHost only knows how to deserialize or synchronize generic image data
|
|
* (SurfaceDescriptor) and provide access to one or more TextureSource objects
|
|
* (these provide the necessary APIs for compositor backends to composite the
|
|
* image).
|
|
*
|
|
* A TextureHost implementation corresponds to one SurfaceDescriptor type, as
|
|
* opposed to TextureSource that corresponds to device textures.
|
|
* This means that for YCbCr planes, even though they are represented as
|
|
* 3 textures internally (3 TextureSources), we use 1 TextureHost and not 3,
|
|
* because the 3 planes are stored in the same buffer of shared memory, before
|
|
* they are uploaded separately.
|
|
*
|
|
* There is always one and only one TextureHost per TextureClient, and the
|
|
* TextureClient/Host pair only owns one buffer of image data through its
|
|
* lifetime. This means that the lifetime of the underlying shared data
|
|
* matches the lifetime of the TextureClient/Host pair. It also means
|
|
* TextureClient/Host do not implement double buffering, which is the
|
|
* reponsibility of the compositable (which would use two Texture pairs).
|
|
*
|
|
* The Lock/Unlock mecanism here mirrors Lock/Unlock in TextureClient.
|
|
*
|
|
*/
|
|
class TextureHost
|
|
: public AtomicRefCountedWithFinalize<TextureHost>
|
|
{
|
|
/**
|
|
* Called once, just before the destructor.
|
|
*
|
|
* Here goes the shut-down code that uses virtual methods.
|
|
* Must only be called by Release().
|
|
*/
|
|
void Finalize();
|
|
|
|
friend class AtomicRefCountedWithFinalize<TextureHost>;
|
|
public:
|
|
TextureHost(TextureFlags aFlags);
|
|
|
|
protected:
|
|
virtual ~TextureHost();
|
|
|
|
public:
|
|
/**
|
|
* Factory method.
|
|
*/
|
|
static TemporaryRef<TextureHost> Create(const SurfaceDescriptor& aDesc,
|
|
ISurfaceAllocator* aDeallocator,
|
|
TextureFlags aFlags);
|
|
|
|
/**
|
|
* Tell to TextureChild that TextureHost is recycled.
|
|
* This function should be called from TextureHost's RecycleCallback.
|
|
* If SetRecycleCallback is set to TextureHost.
|
|
* TextureHost can be recycled by calling RecycleCallback
|
|
* when reference count becomes one.
|
|
* One reference count is always added by TextureChild.
|
|
*/
|
|
void CompositorRecycle();
|
|
|
|
/**
|
|
* Lock the texture host for compositing.
|
|
*/
|
|
virtual bool Lock() { return true; }
|
|
|
|
/**
|
|
* Unlock the texture host after compositing.
|
|
*/
|
|
virtual void Unlock() {}
|
|
|
|
/**
|
|
* Note that the texture host format can be different from its corresponding
|
|
* texture source's. For example a ShmemTextureHost can have the ycbcr
|
|
* format and produce 3 "alpha" textures sources.
|
|
*/
|
|
virtual gfx::SurfaceFormat GetFormat() const = 0;
|
|
|
|
/**
|
|
* Return a list of TextureSources for use with a Compositor.
|
|
*
|
|
* This can trigger texture uploads, so do not call it inside transactions
|
|
* so as to not upload textures while the main thread is blocked.
|
|
* Must not be called while this TextureHost is not sucessfully Locked.
|
|
*/
|
|
virtual NewTextureSource* GetTextureSources() = 0;
|
|
|
|
/**
|
|
* Is called before compositing if the shared data has changed since last
|
|
* composition.
|
|
* This method should be overload in cases like when we need to do a texture
|
|
* upload for example.
|
|
*
|
|
* @param aRegion The region that has been changed, if nil, it means that the
|
|
* entire surface should be updated.
|
|
*/
|
|
virtual void Updated(const nsIntRegion* aRegion = nullptr) {}
|
|
|
|
/**
|
|
* Sets this TextureHost's compositor.
|
|
* A TextureHost can change compositor on certain occasions, in particular if
|
|
* it belongs to an async Compositable.
|
|
* aCompositor can be null, in which case the TextureHost must cleanup all
|
|
* of it's device textures.
|
|
*/
|
|
virtual void SetCompositor(Compositor* aCompositor) {}
|
|
|
|
/**
|
|
* Should be overridden in order to deallocate the data that is associated
|
|
* with the rendering backend, such as GL textures.
|
|
*/
|
|
virtual void DeallocateDeviceData() {}
|
|
|
|
/**
|
|
* Should be overridden in order to deallocate the data that is shared with
|
|
* the content side, such as shared memory.
|
|
*/
|
|
virtual void DeallocateSharedData() {}
|
|
|
|
/**
|
|
* Should be overridden in order to force the TextureHost to drop all references
|
|
* to it's shared data.
|
|
*
|
|
* This is important to ensure the correctness of the deallocation protocol.
|
|
*/
|
|
virtual void ForgetSharedData() {}
|
|
|
|
virtual gfx::IntSize GetSize() const = 0;
|
|
|
|
/**
|
|
* Debug facility.
|
|
* XXX - cool kids use Moz2D. See bug 882113.
|
|
*/
|
|
virtual TemporaryRef<gfx::DataSourceSurface> GetAsSurface() = 0;
|
|
|
|
/**
|
|
* XXX - Flags should only be set at creation time, this will be removed.
|
|
*/
|
|
void SetFlags(TextureFlags aFlags) { mFlags = aFlags; }
|
|
|
|
/**
|
|
* XXX - Flags should only be set at creation time, this will be removed.
|
|
*/
|
|
void AddFlag(TextureFlags aFlag) { mFlags |= aFlag; }
|
|
|
|
TextureFlags GetFlags() { return mFlags; }
|
|
|
|
/**
|
|
* Allocate and deallocate a TextureParent actor.
|
|
*
|
|
* TextureParent< is an implementation detail of TextureHost that is not
|
|
* exposed to the rest of the code base. CreateIPDLActor and DestroyIPDLActor
|
|
* are for use with the managing IPDL protocols only (so that they can
|
|
* implement AllocPTextureParent and DeallocPTextureParent).
|
|
*/
|
|
static PTextureParent* CreateIPDLActor(CompositableParentManager* aManager,
|
|
const SurfaceDescriptor& aSharedData,
|
|
TextureFlags aFlags);
|
|
static bool DestroyIPDLActor(PTextureParent* actor);
|
|
|
|
/**
|
|
* Destroy the TextureChild/Parent pair.
|
|
*/
|
|
static bool SendDeleteIPDLActor(PTextureParent* actor);
|
|
|
|
/**
|
|
* Get the TextureHost corresponding to the actor passed in parameter.
|
|
*/
|
|
static TextureHost* AsTextureHost(PTextureParent* actor);
|
|
|
|
/**
|
|
* Return a pointer to the IPDLActor.
|
|
*
|
|
* This is to be used with IPDL messages only. Do not store the returned
|
|
* pointer.
|
|
*/
|
|
PTextureParent* GetIPDLActor();
|
|
|
|
static void SendFenceHandleIfPresent(PTextureParent* actor);
|
|
|
|
FenceHandle GetAndResetReleaseFenceHandle();
|
|
|
|
/**
|
|
* Specific to B2G's Composer2D
|
|
* XXX - more doc here
|
|
*/
|
|
virtual LayerRenderState GetRenderState()
|
|
{
|
|
// By default we return an empty render state, this should be overridden
|
|
// by the TextureHost implementations that are used on B2G with Composer2D
|
|
return LayerRenderState();
|
|
}
|
|
|
|
virtual void SetCompositableBackendSpecificData(CompositableBackendSpecificData* aBackendData);
|
|
|
|
// If a texture host holds a reference to shmem, it should override this method
|
|
// to forget about the shmem _without_ releasing it.
|
|
virtual void OnShutdown() {}
|
|
|
|
// Forget buffer actor. Used only for hacky fix for bug 966446.
|
|
virtual void ForgetBufferActor() {}
|
|
|
|
virtual const char *Name() { return "TextureHost"; }
|
|
virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix);
|
|
|
|
/**
|
|
* Indicates whether the TextureHost implementation is backed by an
|
|
* in-memory buffer. The consequence of this is that locking the
|
|
* TextureHost does not contend with locking the texture on the client side.
|
|
*/
|
|
virtual bool HasInternalBuffer() const { return false; }
|
|
|
|
/**
|
|
* Cast to a TextureHost for each backend.
|
|
*/
|
|
virtual TextureHostOGL* AsHostOGL() { return nullptr; }
|
|
|
|
protected:
|
|
PTextureParent* mActor;
|
|
TextureFlags mFlags;
|
|
RefPtr<CompositableBackendSpecificData> mCompositableBackendData;
|
|
|
|
friend class TextureParent;
|
|
};
|
|
|
|
/**
|
|
* TextureHost that wraps a random access buffer such as a Shmem or some raw
|
|
* memory.
|
|
*
|
|
* This TextureHost is backend-independent and the backend-specific bits are
|
|
* in the TextureSource.
|
|
* This class must be inherited to implement GetBuffer and DeallocSharedData
|
|
* (see ShmemTextureHost and MemoryTextureHost)
|
|
*
|
|
* Uploads happen when Lock is called.
|
|
*
|
|
* BufferTextureHost supports YCbCr and flavours of RGBA images (RGBX, A, etc.).
|
|
*/
|
|
class BufferTextureHost : public TextureHost
|
|
{
|
|
public:
|
|
BufferTextureHost(gfx::SurfaceFormat aFormat,
|
|
TextureFlags aFlags);
|
|
|
|
~BufferTextureHost();
|
|
|
|
virtual uint8_t* GetBuffer() = 0;
|
|
|
|
virtual size_t GetBufferSize() = 0;
|
|
|
|
virtual void Updated(const nsIntRegion* aRegion = nullptr) MOZ_OVERRIDE;
|
|
|
|
virtual bool Lock() MOZ_OVERRIDE;
|
|
|
|
virtual void Unlock() MOZ_OVERRIDE;
|
|
|
|
virtual NewTextureSource* GetTextureSources() MOZ_OVERRIDE;
|
|
|
|
virtual void DeallocateDeviceData() MOZ_OVERRIDE;
|
|
|
|
virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
|
|
|
|
/**
|
|
* Return the format that is exposed to the compositor when calling
|
|
* GetTextureSources.
|
|
*
|
|
* If the shared format is YCbCr and the compositor does not support it,
|
|
* GetFormat will be RGB32 (even though mFormat is SurfaceFormat::YUV).
|
|
*/
|
|
virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE;
|
|
|
|
virtual gfx::IntSize GetSize() const MOZ_OVERRIDE { return mSize; }
|
|
|
|
virtual TemporaryRef<gfx::DataSourceSurface> GetAsSurface() MOZ_OVERRIDE;
|
|
|
|
virtual bool HasInternalBuffer() const MOZ_OVERRIDE { return true; }
|
|
|
|
protected:
|
|
bool Upload(nsIntRegion *aRegion = nullptr);
|
|
bool MaybeUpload(nsIntRegion *aRegion = nullptr);
|
|
|
|
Compositor* mCompositor;
|
|
RefPtr<DataTextureSource> mFirstSource;
|
|
nsIntRegion mMaybeUpdatedRegion;
|
|
gfx::IntSize mSize;
|
|
// format of the data that is shared with the content process.
|
|
gfx::SurfaceFormat mFormat;
|
|
uint32_t mUpdateSerial;
|
|
bool mLocked;
|
|
bool mPartialUpdate;
|
|
};
|
|
|
|
/**
|
|
* TextureHost that wraps shared memory.
|
|
* the corresponding texture on the client side is ShmemTextureClient.
|
|
* This TextureHost is backend-independent.
|
|
*/
|
|
class ShmemTextureHost : public BufferTextureHost
|
|
{
|
|
public:
|
|
ShmemTextureHost(const mozilla::ipc::Shmem& aShmem,
|
|
gfx::SurfaceFormat aFormat,
|
|
ISurfaceAllocator* aDeallocator,
|
|
TextureFlags aFlags);
|
|
|
|
protected:
|
|
~ShmemTextureHost();
|
|
|
|
public:
|
|
virtual void DeallocateSharedData() MOZ_OVERRIDE;
|
|
|
|
virtual void ForgetSharedData() MOZ_OVERRIDE;
|
|
|
|
virtual uint8_t* GetBuffer() MOZ_OVERRIDE;
|
|
|
|
virtual size_t GetBufferSize() MOZ_OVERRIDE;
|
|
|
|
virtual const char *Name() MOZ_OVERRIDE { return "ShmemTextureHost"; }
|
|
|
|
virtual void OnShutdown() MOZ_OVERRIDE;
|
|
|
|
protected:
|
|
UniquePtr<mozilla::ipc::Shmem> mShmem;
|
|
RefPtr<ISurfaceAllocator> mDeallocator;
|
|
};
|
|
|
|
/**
|
|
* TextureHost that wraps raw memory.
|
|
* The corresponding texture on the client side is MemoryTextureClient.
|
|
* Can obviously not be used in a cross process setup.
|
|
* This TextureHost is backend-independent.
|
|
*/
|
|
class MemoryTextureHost : public BufferTextureHost
|
|
{
|
|
public:
|
|
MemoryTextureHost(uint8_t* aBuffer,
|
|
gfx::SurfaceFormat aFormat,
|
|
TextureFlags aFlags);
|
|
|
|
protected:
|
|
~MemoryTextureHost();
|
|
|
|
public:
|
|
virtual void DeallocateSharedData() MOZ_OVERRIDE;
|
|
|
|
virtual void ForgetSharedData() MOZ_OVERRIDE;
|
|
|
|
virtual uint8_t* GetBuffer() MOZ_OVERRIDE;
|
|
|
|
virtual size_t GetBufferSize() MOZ_OVERRIDE;
|
|
|
|
virtual const char *Name() MOZ_OVERRIDE { return "MemoryTextureHost"; }
|
|
|
|
protected:
|
|
uint8_t* mBuffer;
|
|
};
|
|
|
|
/**
|
|
* A TextureHost for shared SurfaceStream
|
|
*/
|
|
class StreamTextureHost : public TextureHost
|
|
{
|
|
public:
|
|
StreamTextureHost(TextureFlags aFlags,
|
|
const SurfaceStreamDescriptor& aDesc);
|
|
|
|
virtual ~StreamTextureHost();
|
|
|
|
virtual void DeallocateDeviceData() MOZ_OVERRIDE {};
|
|
|
|
virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;
|
|
|
|
virtual bool Lock() MOZ_OVERRIDE;
|
|
|
|
virtual void Unlock() MOZ_OVERRIDE;
|
|
|
|
virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE;
|
|
|
|
virtual NewTextureSource* GetTextureSources() MOZ_OVERRIDE
|
|
{
|
|
return mTextureSource;
|
|
}
|
|
|
|
virtual TemporaryRef<gfx::DataSourceSurface> GetAsSurface() MOZ_OVERRIDE
|
|
{
|
|
return nullptr; // XXX - implement this (for MOZ_DUMP_PAINTING)
|
|
}
|
|
|
|
virtual gfx::IntSize GetSize() const MOZ_OVERRIDE;
|
|
|
|
#ifdef MOZ_LAYERS_HAVE_LOG
|
|
virtual const char* Name() { return "StreamTextureHost"; }
|
|
#endif
|
|
|
|
protected:
|
|
Compositor* mCompositor;
|
|
gl::SurfaceStream* mStream;
|
|
RefPtr<NewTextureSource> mTextureSource;
|
|
RefPtr<DataTextureSource> mDataTextureSource;
|
|
};
|
|
|
|
class MOZ_STACK_CLASS AutoLockTextureHost
|
|
{
|
|
public:
|
|
AutoLockTextureHost(TextureHost* aTexture)
|
|
: mTexture(aTexture)
|
|
{
|
|
mLocked = mTexture ? mTexture->Lock() : false;
|
|
}
|
|
|
|
~AutoLockTextureHost()
|
|
{
|
|
if (mTexture && mLocked) {
|
|
mTexture->Unlock();
|
|
}
|
|
}
|
|
|
|
bool Failed() { return mTexture && !mLocked; }
|
|
|
|
private:
|
|
RefPtr<TextureHost> mTexture;
|
|
bool mLocked;
|
|
};
|
|
|
|
/**
|
|
* This can be used as an offscreen rendering target by the compositor, and
|
|
* subsequently can be used as a source by the compositor.
|
|
*/
|
|
class CompositingRenderTarget : public TextureSource
|
|
{
|
|
public:
|
|
CompositingRenderTarget(const gfx::IntPoint& aOrigin)
|
|
: mOrigin(aOrigin)
|
|
{}
|
|
virtual ~CompositingRenderTarget() {}
|
|
|
|
#ifdef MOZ_DUMP_PAINTING
|
|
virtual TemporaryRef<gfx::DataSourceSurface> Dump(Compositor* aCompositor) { return nullptr; }
|
|
#endif
|
|
|
|
const gfx::IntPoint& GetOrigin() { return mOrigin; }
|
|
|
|
private:
|
|
gfx::IntPoint mOrigin;
|
|
};
|
|
|
|
/**
|
|
* Creates a TextureHost that can be used with any of the existing backends
|
|
* Not all SurfaceDescriptor types are supported
|
|
*/
|
|
TemporaryRef<TextureHost>
|
|
CreateBackendIndependentTextureHost(const SurfaceDescriptor& aDesc,
|
|
ISurfaceAllocator* aDeallocator,
|
|
TextureFlags aFlags);
|
|
|
|
}
|
|
}
|
|
|
|
#endif
|