The Tor Browser: comparison gfx/layers/ImageContainer.h

--1:000000000000
+:b4665e5f33db
+/* -*- 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 GFX_IMAGECONTAINER_H
+#define GFX_IMAGECONTAINER_H
+#include <stdint.h>                     // for uint32_t, uint8_t, uint64_t
+#include <sys/types.h>                  // for int32_t
+#include "gfxTypes.h"
+#include "ImageTypes.h"                 // for ImageFormat, etc
+#include "mozilla/Assertions.h"         // for MOZ_ASSERT_HELPER2
+#include "mozilla/Mutex.h"              // for Mutex
+#include "mozilla/ReentrantMonitor.h"   // for ReentrantMonitorAutoEnter, etc
+#include "mozilla/TimeStamp.h"          // for TimeStamp
+#include "mozilla/gfx/Point.h"          // For IntSize
+#include "mozilla/layers/LayersTypes.h"  // for LayersBackend, etc
+#include "mozilla/mozalloc.h"           // for operator delete, etc
+#include "nsAutoPtr.h"                  // for nsRefPtr, nsAutoArrayPtr, etc
+#include "nsAutoRef.h"                  // for nsCountedRef
+#include "nsCOMPtr.h"                   // for already_AddRefed
+#include "nsDebug.h"                    // for NS_ASSERTION
+#include "nsISupportsImpl.h"            // for Image::Release, etc
+#include "nsRect.h"                     // for nsIntRect
+#include "nsSize.h"                     // for nsIntSize
+#include "nsTArray.h"                   // for nsTArray
+#include "mozilla/Atomics.h"
+#include "mozilla/WeakPtr.h"
+#include "nsThreadUtils.h"
+#include "mozilla/gfx/2D.h"
+#include "nsDataHashtable.h"
+#include "mozilla/EnumeratedArray.h"
+#ifndef XPCOM_GLUE_AVOID_NSPR
+/**
+* We need to be able to hold a reference to a Moz2D SourceSurface from Image
+* subclasses. This is potentially a problem since Images can be addrefed
+* or released off the main thread. We can ensure that we never AddRef
+* a SourceSurface off the main thread, but we might want to Release due
+* to an Image being destroyed off the main thread.
+*
+* We use nsCountedRef<nsMainThreadSourceSurfaceRef> to reference the
+* SourceSurface. When AddRefing, we assert that we're on the main thread.
+* When Releasing, if we're not on the main thread, we post an event to
+* the main thread to do the actual release.
+*/
+class nsMainThreadSourceSurfaceRef;
+template <>
+class nsAutoRefTraits<nsMainThreadSourceSurfaceRef> {
+public:
+typedef mozilla::gfx::SourceSurface* RawRef;
+/**
+* The XPCOM event that will do the actual release on the main thread.
+*/
+class SurfaceReleaser : public nsRunnable {
+public:
+SurfaceReleaser(RawRef aRef) : mRef(aRef) {}
+NS_IMETHOD Run() {
+mRef->Release();
+return NS_OK;
+}
+RawRef mRef;
+};
+static RawRef Void() { return nullptr; }
+static void Release(RawRef aRawRef)
+{
+if (NS_IsMainThread()) {
+aRawRef->Release();
+return;
+}
+nsCOMPtr<nsIRunnable> runnable = new SurfaceReleaser(aRawRef);
+NS_DispatchToMainThread(runnable);
+}
+static void AddRef(RawRef aRawRef)
+{
+NS_ASSERTION(NS_IsMainThread(),
+"Can only add a reference on the main thread");
+aRawRef->AddRef();
+}
+};
+#endif
+#ifdef XP_WIN
+struct ID3D10Texture2D;
+struct ID3D10Device;
+struct ID3D10ShaderResourceView;
+#endif
+typedef void* HANDLE;
+namespace mozilla {
+class CrossProcessMutex;
+namespace layers {
+class ImageClient;
+class SharedPlanarYCbCrImage;
+class TextureClient;
+class CompositableClient;
+class CompositableForwarder;
+class SurfaceDescriptor;
+struct ImageBackendData
+{
+virtual ~ImageBackendData() {}
+protected:
+ImageBackendData() {}
+};
+// sadly we'll need this until we get rid of Deprected image classes
+class ISharedImage {
+public:
+virtual uint8_t* GetBuffer() = 0;
+/**
+* For use with the CompositableClient only (so that the later can
+* synchronize the TextureClient with the TextureHost).
+*/
+virtual TextureClient* GetTextureClient(CompositableClient* aClient) = 0;
+};
+/**
+* A class representing a buffer of pixel data. The data can be in one
+* of various formats including YCbCr.
+*
+* Create an image using an ImageContainer. Fill the image with data, and
+* then call ImageContainer::SetImage to display it. An image must not be
+* modified after calling SetImage. Image implementations do not need to
+* perform locking; when filling an Image, the Image client is responsible
+* for ensuring only one thread accesses the Image at a time, and after
+* SetImage the image is immutable.
+*
+* When resampling an Image, only pixels within the buffer should be
+* sampled. For example, cairo images should be sampled in EXTEND_PAD mode.
+*/
+class Image {
+NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Image)
+public:
+virtual ISharedImage* AsSharedImage() { return nullptr; }
+ImageFormat GetFormat() { return mFormat; }
+void* GetImplData() { return mImplData; }
+virtual gfx::IntSize GetSize() = 0;
+virtual nsIntRect GetPictureRect()
+{
+return nsIntRect(0, 0, GetSize().width, GetSize().height);
+}
+ImageBackendData* GetBackendData(LayersBackend aBackend)
+{ return mBackendData[aBackend]; }
+void SetBackendData(LayersBackend aBackend, ImageBackendData* aData)
+{ mBackendData[aBackend] = aData; }
+int32_t GetSerial() { return mSerial; }
+void MarkSent() { mSent = true; }
+bool IsSentToCompositor() { return mSent; }
+virtual TemporaryRef<gfx::SourceSurface> GetAsSourceSurface() = 0;
+protected:
+Image(void* aImplData, ImageFormat aFormat) :
+mImplData(aImplData),
+mSerial(++sSerialCounter),
+mFormat(aFormat),
+mSent(false)
+{}
+// Protected destructor, to discourage deletion outside of Release():
+virtual ~Image() {}
+mozilla::EnumeratedArray<mozilla::layers::LayersBackend,
+mozilla::layers::LayersBackend::LAYERS_LAST,
+nsAutoPtr<ImageBackendData>>
+mBackendData;
+void* mImplData;
+int32_t mSerial;
+ImageFormat mFormat;
+static mozilla::Atomic<int32_t> sSerialCounter;
+bool mSent;
+};
+/**
+* A RecycleBin is owned by an ImageContainer. We store buffers in it that we
+* want to recycle from one image to the next.It's a separate object from
+* ImageContainer because images need to store a strong ref to their RecycleBin
+* and we must avoid creating a reference loop between an ImageContainer and
+* its active image.
+*/
+class BufferRecycleBin MOZ_FINAL {
+NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RecycleBin)
+//typedef mozilla::gl::GLContext GLContext;
+public:
+BufferRecycleBin();
+void RecycleBuffer(uint8_t* aBuffer, uint32_t aSize);
+// Returns a recycled buffer of the right size, or allocates a new buffer.
+uint8_t* GetBuffer(uint32_t aSize);
+private:
+typedef mozilla::Mutex Mutex;
+// Private destructor, to discourage deletion outside of Release():
+~BufferRecycleBin()
+{
+}
+// This protects mRecycledBuffers, mRecycledBufferSize, mRecycledTextures
+// and mRecycledTextureSizes
+Mutex mLock;
+// We should probably do something to prune this list on a timer so we don't
+// eat excess memory while video is paused...
+nsTArray<nsAutoArrayPtr<uint8_t> > mRecycledBuffers;
+// This is only valid if mRecycledBuffers is non-empty
+uint32_t mRecycledBufferSize;
+};
+class CompositionNotifySink
+{
+public:
+virtual void DidComposite() = 0;
+virtual ~CompositionNotifySink() {}
+};
+/**
+* A class that manages Image creation for a LayerManager. The only reason
+* we need a separate class here is that LayerManagers aren't threadsafe
+* (because layers can only be used on the main thread) and we want to
+* be able to create images from any thread, to facilitate video playback
+* without involving the main thread, for example.
+* Different layer managers can implement child classes of this making it
+* possible to create layer manager specific images.
+* This class is not meant to be used directly but rather can be set on an
+* image container. This is usually done by the layer system internally and
+* not explicitly by users. For PlanarYCbCr or Cairo images the default
+* implementation will creates images whose data lives in system memory, for
+* MacIOSurfaces the default implementation will be a simple MacIOSurface
+* wrapper.
+*/
+class ImageFactory
+{
+NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ImageFactory)
+protected:
+friend class ImageContainer;
+ImageFactory() {}
+virtual ~ImageFactory() {}
+virtual already_AddRefed<Image> CreateImage(ImageFormat aFormat,
+const gfx::IntSize &aScaleHint,
+BufferRecycleBin *aRecycleBin);
+};
+/**
+* This struct is used to store RemoteImages, it is meant to be able to live in
+* shared memory. Therefor it should not contain a vtable pointer. Remote
+* users can manipulate the data in this structure to specify what image is to
+* be drawn by the container. When accessing this data users should make sure
+* the mutex synchronizing access to the structure is held!
+*/
+struct RemoteImageData {
+enum Type {
+/**
+* This is a format that uses raw bitmap data.
+*/
+RAW_BITMAP,
+/**
+* This is a format that uses a pointer to a texture do draw directly
+* from a shared texture. Any process may have created this texture handle,
+* the process creating the texture handle is responsible for managing it's
+* lifetime by managing the lifetime of the first D3D texture object this
+* handle was created for. It must also ensure the handle is not set
+* current anywhere when the last reference to this object is released.
+*/
+DXGI_TEXTURE_HANDLE
+};
+/* These formats describe the format in the memory byte-order */
+enum Format {
+/* 8 bits per channel */
+BGRA32,
+/* 8 bits per channel, alpha channel is ignored */
+BGRX32
+};
+// This should be set to true if a change was made so that the ImageContainer
+// knows to throw out any cached RemoteImage objects.
+bool mWasUpdated;
+Type mType;
+Format mFormat;
+gfx::IntSize mSize;
+union {
+struct {
+/* This pointer is set by a remote process, however it will be set to
+* the container process' address the memory of the raw bitmap resides
+* at.
+*/
+unsigned char *mData;
+int mStride;
+} mBitmap;
+#ifdef XP_WIN
+HANDLE mTextureHandle;
+#endif
+};
+};
+/**
+* A class that manages Images for an ImageLayer. The only reason
+* we need a separate class here is that ImageLayers aren't threadsafe
+* (because layers can only be used on the main thread) and we want to
+* be able to set the current Image from any thread, to facilitate
+* video playback without involving the main thread, for example.
+*
+* An ImageContainer can operate in one of three modes:
+* 1) Normal. Triggered by constructing the ImageContainer with
+* DISABLE_ASYNC or when compositing is happening on the main thread.
+* SetCurrentImage changes ImageContainer state but nothing is sent to the
+* compositor until the next layer transaction.
+* 2) Asynchronous. Initiated by constructing the ImageContainer with
+* ENABLE_ASYNC when compositing is happening on the main thread.
+* SetCurrentImage sends a message through the ImageBridge to the compositor
+* thread to update the image, without going through the main thread or
+* a layer transaction.
+* 3) Remote. Initiated by calling SetRemoteImageData on the ImageContainer
+* before any other activity.
+* The ImageContainer uses a shared memory block containing a cross-process mutex
+* to communicate with the compositor thread. SetCurrentImage synchronously
+* updates the shared state to point to the new image and the old image
+* is immediately released (not true in Normal or Asynchronous modes).
+*/
+class ImageContainer MOZ_FINAL : public SupportsWeakPtr<ImageContainer> {
+NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ImageContainer)
+public:
+MOZ_DECLARE_REFCOUNTED_TYPENAME(ImageContainer)
+enum { DISABLE_ASYNC = 0x0, ENABLE_ASYNC = 0x01 };
+ImageContainer(int flag = 0);
+/**
+* Create an Image in one of the given formats.
+* Picks the "best" format from the list and creates an Image of that
+* format.
+* Returns null if this backend does not support any of the formats.
+* Can be called on any thread. This method takes mReentrantMonitor
+* when accessing thread-shared state.
+*/
+already_AddRefed<Image> CreateImage(ImageFormat aFormat);
+/**
+* Set an Image as the current image to display. The Image must have
+* been created by this ImageContainer.
+* Can be called on any thread. This method takes mReentrantMonitor
+* when accessing thread-shared state.
+* aImage can be null. While it's null, nothing will be painted.
+*
+* The Image data must not be modified after this method is called!
+* Note that this must not be called if ENABLE_ASYNC has not been set.
+*
+* Implementations must call CurrentImageChanged() while holding
+* mReentrantMonitor.
+*
+* If this ImageContainer has an ImageClient for async video:
+* Schelude a task to send the image to the compositor using the
+* PImageBridge protcol without using the main thread.
+*/
+void SetCurrentImage(Image* aImage);
+/**
+* Clear all images. Let ImageClient release all TextureClients.
+*/
+void ClearAllImages();
+/**
+* Clear all images except current one.
+* Let ImageClient release all TextureClients except front one.
+*/
+void ClearAllImagesExceptFront();
+/**
+* Clear the current image.
+* This function is expect to be called only from a CompositableClient
+* that belongs to ImageBridgeChild. Created to prevent dead lock.
+* See Bug 901224.
+*/
+void ClearCurrentImage();
+/**
+* Set an Image as the current image to display. The Image must have
+* been created by this ImageContainer.
+* Must be called on the main thread, within a layers transaction.
+*
+* This method takes mReentrantMonitor
+* when accessing thread-shared state.
+* aImage can be null. While it's null, nothing will be painted.
+*
+* The Image data must not be modified after this method is called!
+* Note that this must not be called if ENABLE_ASYNC been set.
+*
+* Implementations must call CurrentImageChanged() while holding
+* mReentrantMonitor.
+*/
+void SetCurrentImageInTransaction(Image* aImage);
+/**
+* Returns true if this ImageContainer uses the ImageBridge IPDL protocol.
+*
+* Can be called from any thread.
+*/
+bool IsAsync() const;
+/**
+* If this ImageContainer uses ImageBridge, returns the ID associated to
+* this container, for use in the ImageBridge protocol.
+* Returns 0 if this ImageContainer does not use ImageBridge. Note that
+* 0 is always an invalid ID for asynchronous image containers.
+*
+* Can be called from any thread.
+*/
+uint64_t GetAsyncContainerID() const;
+/**
+* Returns if the container currently has an image.
+* Can be called on any thread. This method takes mReentrantMonitor
+* when accessing thread-shared state.
+*/
+bool HasCurrentImage();
+/**
+* Lock the current Image.
+* This has to add a reference since otherwise there are race conditions
+* where the current image is destroyed before the caller can add
+* a reference. This lock strictly guarantees the underlying image remains
+* valid, it does not mean the current image cannot change.
+* Can be called on any thread. This method will lock the cross-process
+* mutex to ensure remote processes cannot alter underlying data. This call
+* -must- be balanced by a call to UnlockCurrentImage and users should avoid
+* holding the image locked for a long time.
+*/
+already_AddRefed<Image> LockCurrentImage();
+/**
+* This call unlocks the image. For remote images releasing the cross-process
+* mutex.
+*/
+void UnlockCurrentImage();
+/**
+* Get the current image as a SourceSurface. This is useful for fallback
+* rendering.
+* This can only be called from the main thread, since cairo objects
+* can only be used from the main thread.
+* This is defined here and not on Image because it's possible (likely)
+* that some backends will make an Image "ready to draw" only when it
+* becomes the current image for an image container.
+* Returns null if there is no current image.
+* Returns the size in aSize.
+* The returned surface will never be modified. The caller must not
+* modify it.
+* Can be called on any thread. This method takes mReentrantMonitor
+* when accessing thread-shared state.
+* If the current image is a remote image, that is, if it is an image that
+* may be shared accross processes, calling this function will make
+* a copy of the image data while holding the mRemoteDataMutex. If possible,
+* the lock methods should be used to avoid the copy, however this should be
+* avoided if the surface is required for a long period of time.
+*/
+TemporaryRef<gfx::SourceSurface> GetCurrentAsSourceSurface(gfx::IntSize* aSizeResult);
+/**
+* Same as LockCurrentAsSurface but for Moz2D
+*/
+TemporaryRef<gfx::SourceSurface> LockCurrentAsSourceSurface(gfx::IntSize* aSizeResult,
+Image** aCurrentImage = nullptr);
+/**
+* Returns the size of the image in pixels.
+* Can be called on any thread. This method takes mReentrantMonitor when accessing
+* thread-shared state.
+*/
+gfx::IntSize GetCurrentSize();
+/**
+* Sets a size that the image is expected to be rendered at.
+* This is a hint for image backends to optimize scaling.
+* Default implementation in this class is to ignore the hint.
+* Can be called on any thread. This method takes mReentrantMonitor
+* when accessing thread-shared state.
+*/
+void SetScaleHint(const gfx::IntSize& aScaleHint)
+{ mScaleHint = aScaleHint; }
+void SetImageFactory(ImageFactory *aFactory)
+{
+ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+mImageFactory = aFactory ? aFactory : new ImageFactory();
+}
+/**
+* Returns the time at which the currently contained image was first
+* painted.  This is reset every time a new image is set as the current
+* image.  Note this may return a null timestamp if the current image
+* has not yet been painted.  Can be called from any thread.
+*/
+TimeStamp GetPaintTime() {
+ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+return mPaintTime;
+}
+/**
+* Returns the number of images which have been contained in this container
+* and painted at least once.  Can be called from any thread.
+*/
+uint32_t GetPaintCount() {
+ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+return mPaintCount;
+}
+/**
+* Resets the paint count to zero.
+* Can be called from any thread.
+*/
+void ResetPaintCount() {
+ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+mPaintCount = 0;
+}
+/**
+* Increments mPaintCount if this is the first time aPainted has been
+* painted, and sets mPaintTime if the painted image is the current image.
+* current image.  Can be called from any thread.
+*/
+void NotifyPaintedImage(Image* aPainted) {
+ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+nsRefPtr<Image> current = mActiveImage;
+if (aPainted == current) {
+if (mPaintTime.IsNull()) {
+mPaintTime = TimeStamp::Now();
+mPaintCount++;
+}
+} else if (!mPreviousImagePainted) {
+// While we were painting this image, the current image changed. We
+// still must count it as painted, but can't set mPaintTime, since we're
+// no longer the current image.
+mPaintCount++;
+mPreviousImagePainted = true;
+}
+if (mCompositionNotifySink) {
+mCompositionNotifySink->DidComposite();
+}
+}
+void SetCompositionNotifySink(CompositionNotifySink *aSink) {
+mCompositionNotifySink = aSink;
+}
+/**
+* This function is called to tell the ImageContainer where the
+* (cross-process) segment lives where the shared data about possible
+* remote images are stored. In addition to this a CrossProcessMutex object
+* is passed telling the container how to synchronize access to this data.
+* NOTE: This should be called during setup of the container and not after
+* usage has started.
+*/
+void SetRemoteImageData(RemoteImageData *aRemoteData,
+CrossProcessMutex *aRemoteDataMutex);
+/**
+* This can be used to check if the container has RemoteData set.
+*/
+RemoteImageData *GetRemoteImageData() { return mRemoteData; }
+private:
+typedef mozilla::ReentrantMonitor ReentrantMonitor;
+// Private destructor, to discourage deletion outside of Release():
+~ImageContainer();
+void SetCurrentImageInternal(Image* aImage);
+// This is called to ensure we have an active image, this may not be true
+// when we're storing image information in a RemoteImageData structure.
+// NOTE: If we have remote data mRemoteDataMutex should be locked when
+// calling this function!
+void EnsureActiveImage();
+// ReentrantMonitor to protect thread safe access to the "current
+// image", and any other state which is shared between threads.
+ReentrantMonitor mReentrantMonitor;
+// Performs necessary housekeeping to ensure the painted frame statistics
+// are accurate. Must be called by SetCurrentImage() implementations with
+// mReentrantMonitor held.
+void CurrentImageChanged() {
+mReentrantMonitor.AssertCurrentThreadIn();
+mPreviousImagePainted = !mPaintTime.IsNull();
+mPaintTime = TimeStamp();
+}
+nsRefPtr<Image> mActiveImage;
+// Number of contained images that have been painted at least once.  It's up
+// to the ImageContainer implementation to ensure accesses to this are
+// threadsafe.
+uint32_t mPaintCount;
+// Time stamp at which the current image was first painted.  It's up to the
+// ImageContainer implementation to ensure accesses to this are threadsafe.
+TimeStamp mPaintTime;
+// Denotes whether the previous image was painted.
+bool mPreviousImagePainted;
+// This is the image factory used by this container, layer managers using
+// this container can set an alternative image factory that will be used to
+// create images for this container.
+nsRefPtr<ImageFactory> mImageFactory;
+gfx::IntSize mScaleHint;
+nsRefPtr<BufferRecycleBin> mRecycleBin;
+// This contains the remote image data for this container, if this is nullptr
+// that means the container has no other process that may control its active
+// image.
+RemoteImageData *mRemoteData;
+// This cross-process mutex is used to synchronise access to mRemoteData.
+// When this mutex is held, we will always be inside the mReentrantMonitor
+// however the same is not true vice versa.
+CrossProcessMutex *mRemoteDataMutex;
+CompositionNotifySink *mCompositionNotifySink;
+// This member points to an ImageClient if this ImageContainer was
+// sucessfully created with ENABLE_ASYNC, or points to null otherwise.
+// 'unsuccessful' in this case only means that the ImageClient could not
+// be created, most likely because off-main-thread compositing is not enabled.
+// In this case the ImageContainer is perfectly usable, but it will forward
+// frames to the compositor through transactions in the main thread rather than
+// asynchronusly using the ImageBridge IPDL protocol.
+ImageClient* mImageClient;
+};
+class AutoLockImage
+{
+public:
+AutoLockImage(ImageContainer *aContainer) : mContainer(aContainer) { mImage = mContainer->LockCurrentImage(); }
+AutoLockImage(ImageContainer *aContainer, RefPtr<gfx::SourceSurface> *aSurface) : mContainer(aContainer) {
+*aSurface = mContainer->LockCurrentAsSourceSurface(&mSize, getter_AddRefs(mImage));
+}
+~AutoLockImage() { if (mContainer) { mContainer->UnlockCurrentImage(); } }
+Image* GetImage() { return mImage; }
+const gfx::IntSize &GetSize() { return mSize; }
+void Unlock() {
+if (mContainer) {
+mImage = nullptr;
+mContainer->UnlockCurrentImage();
+mContainer = nullptr;
+}
+}
+/** Things get a little tricky here, because our underlying image can -still-
+* change, and OS X requires a complicated callback mechanism to update this
+* we need to support staying the lock and getting the new image in a proper
+* way. This method makes any images retrieved with GetImage invalid!
+*/
+void Refresh() {
+if (mContainer) {
+mContainer->UnlockCurrentImage();
+mImage = mContainer->LockCurrentImage();
+}
+}
+private:
+ImageContainer *mContainer;
+nsRefPtr<Image> mImage;
+gfx::IntSize mSize;
+};
+struct PlanarYCbCrData {
+// Luminance buffer
+uint8_t* mYChannel;
+int32_t mYStride;
+gfx::IntSize mYSize;
+int32_t mYSkip;
+// Chroma buffers
+uint8_t* mCbChannel;
+uint8_t* mCrChannel;
+int32_t mCbCrStride;
+gfx::IntSize mCbCrSize;
+int32_t mCbSkip;
+int32_t mCrSkip;
+// Picture region
+uint32_t mPicX;
+uint32_t mPicY;
+gfx::IntSize mPicSize;
+StereoMode mStereoMode;
+nsIntRect GetPictureRect() const {
+return nsIntRect(mPicX, mPicY,
+mPicSize.width,
+mPicSize.height);
+}
+PlanarYCbCrData()
+: mYChannel(nullptr), mYStride(0), mYSize(0, 0), mYSkip(0)
+, mCbChannel(nullptr), mCrChannel(nullptr)
+, mCbCrStride(0), mCbCrSize(0, 0) , mCbSkip(0), mCrSkip(0)
+, mPicX(0), mPicY(0), mPicSize(0, 0), mStereoMode(StereoMode::MONO)
+{}
+};
+/****** Image subtypes for the different formats ******/
+/**
+* We assume that the image data is in the REC 470M color space (see
+* Theora specification, section 4.3.1).
+*
+* The YCbCr format can be:
+*
+* 4:4:4 - CbCr width/height are the same as Y.
+* 4:2:2 - CbCr width is half that of Y. Height is the same.
+* 4:2:0 - CbCr width and height is half that of Y.
+*
+* The color format is detected based on the height/width ratios
+* defined above.
+*
+* The Image that is rendered is the picture region defined by
+* mPicX, mPicY and mPicSize. The size of the rendered image is
+* mPicSize, not mYSize or mCbCrSize.
+*
+* mYSkip, mCbSkip, mCrSkip are added to support various output
+* formats from hardware decoder. They are per-pixel skips in the
+* source image.
+*
+* For example when image width is 640, mYStride is 670, mYSkip is 3,
+* the mYChannel buffer looks like:
+*
+* |<----------------------- mYStride ----------------------------->|
+* |<----------------- mYSize.width --------------->|
+*  0   3   6   9   12  15  18  21                659             669
+* |----------------------------------------------------------------|
+* |Y___Y___Y___Y___Y___Y___Y___Y...                      |%%%%%%%%%|
+* |Y___Y___Y___Y___Y___Y___Y___Y...                      |%%%%%%%%%|
+* |Y___Y___Y___Y___Y___Y___Y___Y...                      |%%%%%%%%%|
+* |            |<->|
+*                mYSkip
+*/
+class PlanarYCbCrImage : public Image {
+public:
+typedef PlanarYCbCrData Data;
+enum {
+MAX_DIMENSION = 16384
+};
+virtual ~PlanarYCbCrImage();
+/**
+* This makes a copy of the data buffers, in order to support functioning
+* in all different layer managers.
+*/
+virtual void SetData(const Data& aData);
+/**
+* This doesn't make a copy of the data buffers. Can be used when mBuffer is
+* pre allocated with AllocateAndGetNewBuffer(size) and then SetDataNoCopy is
+* called to only update the picture size, planes etc. fields in mData.
+* The GStreamer media backend uses this to decode into PlanarYCbCrImage(s)
+* directly.
+*/
+virtual void SetDataNoCopy(const Data &aData);
+/**
+* This allocates and returns a new buffer
+*/
+virtual uint8_t* AllocateAndGetNewBuffer(uint32_t aSize);
+/**
+* Ask this Image to not convert YUV to RGB during SetData, and make
+* the original data available through GetData. This is optional,
+* and not all PlanarYCbCrImages will support it.
+*/
+virtual void SetDelayedConversion(bool aDelayed) { }
+/**
+* Grab the original YUV data. This is optional.
+*/
+virtual const Data* GetData() { return &mData; }
+/**
+* Return the number of bytes of heap memory used to store this image.
+*/
+virtual uint32_t GetDataSize() { return mBufferSize; }
+virtual bool IsValid() { return !!mBufferSize; }
+virtual gfx::IntSize GetSize() { return mSize; }
+PlanarYCbCrImage(BufferRecycleBin *aRecycleBin);
+virtual SharedPlanarYCbCrImage *AsSharedPlanarYCbCrImage() { return nullptr; }
+virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const;
+protected:
+/**
+* Make a copy of the YCbCr data into local storage.
+*
+* @param aData           Input image data.
+*/
+void CopyData(const Data& aData);
+/**
+* Return a buffer to store image data in.
+* The default implementation returns memory that can
+* be freed wit delete[]
+*/
+virtual uint8_t* AllocateBuffer(uint32_t aSize);
+TemporaryRef<gfx::SourceSurface> GetAsSourceSurface();
+void SetOffscreenFormat(gfxImageFormat aFormat) { mOffscreenFormat = aFormat; }
+gfxImageFormat GetOffscreenFormat();
+nsAutoArrayPtr<uint8_t> mBuffer;
+uint32_t mBufferSize;
+Data mData;
+gfx::IntSize mSize;
+gfxImageFormat mOffscreenFormat;
+nsCountedRef<nsMainThreadSourceSurfaceRef> mSourceSurface;
+nsRefPtr<BufferRecycleBin> mRecycleBin;
+};
+/**
+* Currently, the data in a CairoImage surface is treated as being in the
+* device output color space. This class is very simple as all backends
+* have to know about how to deal with drawing a cairo image.
+*/
+class CairoImage : public Image,
+public ISharedImage {
+public:
+struct Data {
+gfx::IntSize mSize;
+RefPtr<gfx::SourceSurface> mSourceSurface;
+};
+/**
+* This can only be called on the main thread. It may add a reference
+* to the surface (which will eventually be released on the main thread).
+* The surface must not be modified after this call!!!
+*/
+void SetData(const Data& aData)
+{
+mSize = aData.mSize;
+mSourceSurface = aData.mSourceSurface;
+}
+virtual TemporaryRef<gfx::SourceSurface> GetAsSourceSurface()
+{
+return mSourceSurface.get();
+}
+virtual ISharedImage* AsSharedImage() { return this; }
+virtual uint8_t* GetBuffer() { return nullptr; }
+virtual TextureClient* GetTextureClient(CompositableClient* aClient);
+gfx::IntSize GetSize() { return mSize; }
+CairoImage();
+~CairoImage();
+gfx::IntSize mSize;
+nsCountedRef<nsMainThreadSourceSurfaceRef> mSourceSurface;
+nsDataHashtable<nsUint32HashKey, RefPtr<TextureClient> >  mTextureClients;
+};
+class RemoteBitmapImage : public Image {
+public:
+RemoteBitmapImage() : Image(nullptr, ImageFormat::REMOTE_IMAGE_BITMAP) {}
+TemporaryRef<gfx::SourceSurface> GetAsSourceSurface();
+gfx::IntSize GetSize() { return mSize; }
+unsigned char *mData;
+int mStride;
+gfx::IntSize mSize;
+RemoteImageData::Format mFormat;
+};
+} //namespace
+} //namespace
+#endif

The Tor Browser / file comparison

comparison: gfx/layers/ImageContainer.h

gfx/layers/ImageContainer.h