Add m-esr52 at 52.6.0

1 files changed, 903 insertions, 0 deletions

diff --git a/gfx/layers/ImageContainer.h b/gfx/layers/ImageContainer.h
new file mode 100644
index 000000000..a2f404e17
--- /dev/null
+++ b/gfx/layers/ImageContainer.h
@@ -0,0 +1,903 @@
+/* -*- 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/GonkNativeHandle.h"
+#include "mozilla/layers/LayersTypes.h"  // for LayersBackend, etc
+#include "mozilla/layers/CompositorTypes.h"
+#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 mozilla::gfx::IntRect
+#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"
+#include "mozilla/UniquePtr.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 mozilla::Runnable {
+  public:
+    explicit SurfaceReleaser(RawRef aRef) : mRef(aRef) {}
+    NS_IMETHOD Run() override {
+      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();
+  }
+};
+
+class nsOwningThreadSourceSurfaceRef;
+
+template <>
+class nsAutoRefTraits<nsOwningThreadSourceSurfaceRef> {
+public:
+  typedef mozilla::gfx::SourceSurface* RawRef;
+
+  /**
+   * The XPCOM event that will do the actual release on the creation thread.
+   */
+  class SurfaceReleaser : public mozilla::Runnable {
+  public:
+    explicit SurfaceReleaser(RawRef aRef) : mRef(aRef) {}
+    NS_IMETHOD Run() override {
+      mRef->Release();
+      return NS_OK;
+    }
+    RawRef mRef;
+  };
+
+  static RawRef Void() { return nullptr; }
+  void Release(RawRef aRawRef)
+  {
+    MOZ_ASSERT(mOwningThread);
+    bool current;
+    mOwningThread->IsOnCurrentThread(&current);
+    if (current) {
+      aRawRef->Release();
+      return;
+    }
+    nsCOMPtr<nsIRunnable> runnable = new SurfaceReleaser(aRawRef);
+    mOwningThread->Dispatch(runnable, nsIThread::DISPATCH_NORMAL);
+  }
+  void AddRef(RawRef aRawRef)
+  {
+    MOZ_ASSERT(!mOwningThread);
+    NS_GetCurrentThread(getter_AddRefs(mOwningThread));
+    aRawRef->AddRef();
+  }
+
+private:
+  nsCOMPtr<nsIThread> mOwningThread;
+};
+
+#endif
+
+#ifdef XP_WIN
+struct ID3D10Texture2D;
+struct ID3D10Device;
+struct ID3D10ShaderResourceView;
+#endif
+
+typedef void* HANDLE;
+
+namespace mozilla {
+
+
+namespace layers {
+
+class ImageClient;
+class ImageCompositeNotification;
+class ImageContainerChild;
+class PImageContainerChild;
+class SharedPlanarYCbCrImage;
+class PlanarYCbCrImage;
+class TextureClient;
+class KnowsCompositor;
+class NVImage;
+
+struct ImageBackendData
+{
+  virtual ~ImageBackendData() {}
+
+protected:
+  ImageBackendData() {}
+};
+
+/* Forward declarations for Image derivatives. */
+class GLImage;
+class EGLImageImage;
+class SharedRGBImage;
+#ifdef MOZ_WIDGET_ANDROID
+class SurfaceTextureImage;
+#elif defined(XP_MACOSX)
+class MacIOSurfaceImage;
+#endif
+
+/**
+ * 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:
+  ImageFormat GetFormat() { return mFormat; }
+  void* GetImplData() { return mImplData; }
+
+  virtual gfx::IntSize GetSize() = 0;
+  virtual gfx::IntPoint GetOrigin()
+  {
+    return gfx::IntPoint(0, 0);
+  }
+  virtual gfx::IntRect GetPictureRect()
+  {
+    return gfx::IntRect(GetOrigin().x, GetOrigin().y, 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; }
+
+  virtual already_AddRefed<gfx::SourceSurface> GetAsSourceSurface() = 0;
+
+  virtual bool IsValid() { return true; }
+
+  virtual uint8_t* GetBuffer() { return nullptr; }
+
+  /**
+   * For use with the TextureForwarder only (so that the later can
+   * synchronize the TextureClient with the TextureHost).
+   */
+  virtual TextureClient* GetTextureClient(KnowsCompositor* aForwarder) { return nullptr; }
+
+  /* Access to derived classes. */
+  virtual EGLImageImage* AsEGLImageImage() { return nullptr; }
+  virtual GLImage* AsGLImage() { return nullptr; }
+#ifdef MOZ_WIDGET_ANDROID
+  virtual SurfaceTextureImage* AsSurfaceTextureImage() { return nullptr; }
+#endif
+#ifdef XP_MACOSX
+  virtual MacIOSurfaceImage* AsMacIOSurfaceImage() { return nullptr; }
+#endif
+  virtual PlanarYCbCrImage* AsPlanarYCbCrImage() { return nullptr; }
+
+  virtual NVImage* AsNVImage() { return nullptr; }
+
+protected:
+  Image(void* aImplData, ImageFormat aFormat) :
+    mImplData(aImplData),
+    mSerial(++sSerialCounter),
+    mFormat(aFormat)
+  {}
+
+  // 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;
+};
+
+/**
+ * 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 final {
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(BufferRecycleBin)
+
+  //typedef mozilla::gl::GLContext GLContext;
+
+public:
+  BufferRecycleBin();
+
+  void RecycleBuffer(mozilla::UniquePtr<uint8_t[]> aBuffer, uint32_t aSize);
+  // Returns a recycled buffer of the right size, or allocates a new buffer.
+  mozilla::UniquePtr<uint8_t[]> GetBuffer(uint32_t aSize);
+  virtual void ClearRecycledBuffers();
+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<mozilla::UniquePtr<uint8_t[]>> mRecycledBuffers;
+  // This is only valid if mRecycledBuffers is non-empty
+  uint32_t mRecycledBufferSize;
+};
+
+/**
+ * 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 RefPtr<PlanarYCbCrImage> CreatePlanarYCbCrImage(
+    const gfx::IntSize& aScaleHint,
+    BufferRecycleBin *aRecycleBin);
+};
+ 
+/**
+ * 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 these modes:
+ * 1) Normal. Triggered by constructing the ImageContainer with
+ * DISABLE_ASYNC or when compositing is happening on the main thread.
+ * SetCurrentImages 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.
+ * SetCurrentImages sends a message through the ImageBridge to the compositor
+ * thread to update the image, without going through the main thread or
+ * a layer transaction.
+ * 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 final : public SupportsWeakPtr<ImageContainer>
+{
+  friend class ImageContainerChild;
+
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ImageContainer)
+
+public:
+  MOZ_DECLARE_WEAKREFERENCE_TYPENAME(ImageContainer)
+
+  enum Mode { SYNCHRONOUS = 0x0, ASYNCHRONOUS = 0x01 };
+
+  static const uint64_t sInvalidAsyncContainerId = 0;
+
+  explicit ImageContainer(ImageContainer::Mode flag = SYNCHRONOUS);
+
+  /**
+   * Create ImageContainer just to hold another ASYNCHRONOUS ImageContainer's
+   * async container ID.
+   * @param aAsyncContainerID async container ID for which we are a proxy
+   */
+  explicit ImageContainer(uint64_t aAsyncContainerID);
+
+  typedef uint32_t FrameID;
+  typedef uint32_t ProducerID;
+
+  RefPtr<PlanarYCbCrImage> CreatePlanarYCbCrImage();
+
+  // Factory methods for shared image types.
+  RefPtr<SharedRGBImage> CreateSharedRGBImage();
+
+  struct NonOwningImage {
+    explicit NonOwningImage(Image* aImage = nullptr,
+                            TimeStamp aTimeStamp = TimeStamp(),
+                            FrameID aFrameID = 0,
+                            ProducerID aProducerID = 0)
+      : mImage(aImage), mTimeStamp(aTimeStamp), mFrameID(aFrameID),
+        mProducerID(aProducerID) {}
+    Image* mImage;
+    TimeStamp mTimeStamp;
+    FrameID mFrameID;
+    ProducerID mProducerID;
+  };
+  /**
+   * Set aImages as the list of timestamped to display. The Images must have
+   * been created by this ImageContainer.
+   * Can be called on any thread. This method takes mReentrantMonitor
+   * when accessing thread-shared state.
+   * aImages must be non-empty. The first timestamp in the list may be
+   * null but the others must not be, and the timestamps must increase.
+   * Every element of aImages must have non-null mImage.
+   * mFrameID can be zero, in which case you won't get meaningful
+   * painted/dropped frame counts. Otherwise you should use a unique and
+   * increasing ID for each decoded and submitted frame (but it's OK to
+   * pass the same frame to SetCurrentImages).
+   * mProducerID is a unique ID for the stream of images. A change in the
+   * mProducerID means changing to a new mFrameID namespace. All frames in
+   * aImages must have the same mProducerID.
+   * 
+   * 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.
+   *
+   * The implementation calls CurrentImageChanged() while holding
+   * mReentrantMonitor.
+   *
+   * If this ImageContainer has an ImageClient for async video:
+   * Schedule a task to send the image to the compositor using the
+   * PImageBridge protcol without using the main thread.
+   */
+  void SetCurrentImages(const nsTArray<NonOwningImage>& aImages);
+
+  /**
+   * Clear all images. Let ImageClient release all TextureClients.
+   */
+  void ClearAllImages();
+
+  /**
+   * Clear any resources that are not immediately necessary. This may be called
+   * in low-memory conditions.
+   */
+  void ClearCachedResources();
+
+  /**
+   * Clear the current images.
+   * This function is expect to be called only from a CompositableClient
+   * that belongs to ImageBridgeChild. Created to prevent dead lock.
+   * See Bug 901224.
+   */
+  void ClearImagesFromImageBridge();
+
+  /**
+   * 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.
+   *
+   * You won't get meaningful painted/dropped counts when using this method.
+   */
+  void SetCurrentImageInTransaction(Image* aImage);
+  void SetCurrentImagesInTransaction(const nsTArray<NonOwningImage>& aImages);
+
+  /**
+   * 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();
+
+  /**
+   * 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();
+
+  struct OwningImage {
+    OwningImage() : mFrameID(0), mProducerID(0), mComposited(false) {}
+    RefPtr<Image> mImage;
+    TimeStamp mTimeStamp;
+    FrameID mFrameID;
+    ProducerID mProducerID;
+    bool mComposited;
+  };
+  /**
+   * Copy the current Image list to aImages.
+   * This has to add references since otherwise there are race conditions
+   * where the current image is destroyed before the caller can add
+   * a reference.
+   * Can be called on any thread.
+   * May return an empty list to indicate there is no current image.
+   * If aGenerationCounter is non-null, sets *aGenerationCounter to a value
+   * that's unique for this ImageContainer state.
+   */
+  void GetCurrentImages(nsTArray<OwningImage>* aImages,
+                        uint32_t* aGenerationCounter = 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();
+  }
+
+  ImageFactory* GetImageFactory() const
+  {
+    return mImageFactory;
+  }
+
+  /**
+   * Returns the delay between the last composited image's presentation
+   * timestamp and when it was first composited. It's possible for the delay
+   * to be negative if the first image in the list passed to SetCurrentImages
+   * has a presentation timestamp greater than "now".
+   * Returns 0 if the composited image had a null timestamp, or if no
+   * image has been composited yet.
+   */
+  TimeDuration GetPaintDelay()
+  {
+    ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+    return mPaintDelay;
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * An entry in the current image list "expires" when the entry has an
+   * non-null timestamp, and in a SetCurrentImages call the new image list is
+   * non-empty, the timestamp of the first new image is non-null and greater
+   * than the timestamp associated with the image, and the first new image's
+   * frameID is not the same as the entry's.
+   * Every expired image that is never composited is counted as dropped.
+   */
+  uint32_t GetDroppedImageCount()
+  {
+    ReentrantMonitorAutoEnter mon(mReentrantMonitor);
+    return mDroppedImageCount;
+  }
+
+  PImageContainerChild* GetPImageContainerChild();
+
+  /**
+   * Main thread only.
+   */
+  static ProducerID AllocateProducerID();
+
+private:
+  typedef mozilla::ReentrantMonitor ReentrantMonitor;
+
+  // Private destructor, to discourage deletion outside of Release():
+  ~ImageContainer();
+
+  void SetCurrentImageInternal(const nsTArray<NonOwningImage>& aImages);
+
+  // 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();
+
+  void EnsureImageClient(bool aCreate);
+
+  void NotifyCompositeInternal(const ImageCompositeNotification& aNotification);
+
+  // ReentrantMonitor to protect thread safe access to the "current
+  // image", and any other state which is shared between threads.
+  ReentrantMonitor mReentrantMonitor;
+
+  nsTArray<OwningImage> mCurrentImages;
+
+  // Updates every time mActiveImage changes
+  uint32_t mGenerationCounter;
+
+  // 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;
+
+  // See GetPaintDelay. Accessed only with mReentrantMonitor held.
+  TimeDuration mPaintDelay;
+
+  // See GetDroppedImageCount. Accessed only with mReentrantMonitor held.
+  uint32_t mDroppedImageCount;
+
+  // 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.
+  RefPtr<ImageFactory> mImageFactory;
+
+  gfx::IntSize mScaleHint;
+
+  RefPtr<BufferRecycleBin> mRecycleBin;
+
+  // 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.
+  RefPtr<ImageClient> mImageClient;
+
+  uint64_t mAsyncContainerID;
+
+  nsTArray<FrameID> mFrameIDsNotYetComposited;
+  // ProducerID for last current image(s), including the frames in
+  // mFrameIDsNotYetComposited
+  ProducerID mCurrentProducerID;
+
+  // Object must be released on the ImageBridge thread. Field is immutable
+  // after creation of the ImageContainer.
+  RefPtr<ImageContainerChild> mIPDLChild;
+
+  static mozilla::Atomic<uint32_t> sGenerationCounter;
+};
+
+class AutoLockImage
+{
+public:
+  explicit AutoLockImage(ImageContainer *aContainer)
+  {
+    aContainer->GetCurrentImages(&mImages);
+  }
+
+  bool HasImage() const { return !mImages.IsEmpty(); }
+  Image* GetImage() const
+  {
+    return mImages.IsEmpty() ? nullptr : mImages[0].mImage.get();
+  }
+
+private:
+  AutoTArray<ImageContainer::OwningImage,4> mImages;
+};
+
+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;
+  YUVColorSpace mYUVColorSpace;
+
+  gfx::IntRect GetPictureRect() const {
+    return gfx::IntRect(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)
+    , mYUVColorSpace(YUVColorSpace::BT601)
+  {}
+};
+
+/****** 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 bool CopyData(const Data& aData) = 0;
+
+  /**
+   * This doesn't make a copy of the data buffers. Can be used when mBuffer is
+   * pre allocated with AllocateAndGetNewBuffer(size) and then AdoptData 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 bool AdoptData(const Data &aData);
+
+  /**
+   * This allocates and returns a new buffer
+   */
+  virtual uint8_t* AllocateAndGetNewBuffer(uint32_t aSize) = 0;
+
+  /**
+   * 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; }
+
+  virtual gfx::IntPoint GetOrigin() { return mOrigin; }
+
+  explicit PlanarYCbCrImage();
+
+  virtual SharedPlanarYCbCrImage *AsSharedPlanarYCbCrImage() { return nullptr; }
+
+  virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+    return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+  }
+
+  virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const = 0;
+
+  PlanarYCbCrImage* AsPlanarYCbCrImage() { return this; }
+
+protected:
+  already_AddRefed<gfx::SourceSurface> GetAsSourceSurface();
+
+  void SetOffscreenFormat(gfxImageFormat aFormat) { mOffscreenFormat = aFormat; }
+  gfxImageFormat GetOffscreenFormat();
+
+  Data mData;
+  gfx::IntPoint mOrigin;
+  gfx::IntSize mSize;
+  gfxImageFormat mOffscreenFormat;
+  nsCountedRef<nsMainThreadSourceSurfaceRef> mSourceSurface;
+  uint32_t mBufferSize;
+};
+
+class RecyclingPlanarYCbCrImage: public PlanarYCbCrImage {
+public:
+  explicit RecyclingPlanarYCbCrImage(BufferRecycleBin *aRecycleBin) : mRecycleBin(aRecycleBin) {}
+  virtual ~RecyclingPlanarYCbCrImage() override;
+  virtual bool CopyData(const Data& aData) override;
+  virtual uint8_t* AllocateAndGetNewBuffer(uint32_t aSize) override;
+  virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const override;
+protected:
+
+  /**
+   * Return a buffer to store image data in.
+   */
+  mozilla::UniquePtr<uint8_t[]> AllocateBuffer(uint32_t aSize);
+
+  RefPtr<BufferRecycleBin> mRecycleBin;
+  mozilla::UniquePtr<uint8_t[]> mBuffer;
+};
+
+/**
+ * NVImage is used to store YUV420SP_NV12 and YUV420SP_NV21 data natively, which
+ * are not supported by PlanarYCbCrImage. (PlanarYCbCrImage only stores YUV444P,
+ * YUV422P and YUV420P, it converts YUV420SP_NV12 and YUV420SP_NV21 data into
+ * YUV420P in its PlanarYCbCrImage::SetData() method.)
+ *
+ * PlanarYCbCrData is able to express all the YUV family and so we keep use it
+ * in NVImage.
+ */
+class NVImage: public Image {
+  typedef PlanarYCbCrData Data;
+
+public:
+  explicit NVImage();
+  virtual ~NVImage() override;
+
+  // Methods inherited from layers::Image.
+  virtual gfx::IntSize GetSize() override;
+  virtual gfx::IntRect GetPictureRect() override;
+  virtual already_AddRefed<gfx::SourceSurface> GetAsSourceSurface() override;
+  virtual bool IsValid() override;
+  virtual NVImage* AsNVImage() override;
+
+  // Methods mimic layers::PlanarYCbCrImage.
+  virtual bool SetData(const Data& aData);
+  virtual const Data* GetData() const;
+  virtual uint32_t GetBufferSize() const;
+
+protected:
+
+  /**
+   * Return a buffer to store image data in.
+   */
+  mozilla::UniquePtr<uint8_t> AllocateBuffer(uint32_t aSize);
+
+  mozilla::UniquePtr<uint8_t> mBuffer;
+  uint32_t mBufferSize;
+  gfx::IntSize mSize;
+  Data mData;
+  nsCountedRef<nsMainThreadSourceSurfaceRef> mSourceSurface;
+};
+
+/**
+ * Currently, the data in a SourceSurfaceImage 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 SourceSurfaceImage final : public Image {
+public:
+  virtual already_AddRefed<gfx::SourceSurface> GetAsSourceSurface() override
+  {
+    RefPtr<gfx::SourceSurface> surface(mSourceSurface);
+    return surface.forget();
+  }
+
+  void SetTextureFlags(TextureFlags aTextureFlags) { mTextureFlags = aTextureFlags; }
+  virtual TextureClient* GetTextureClient(KnowsCompositor* aForwarder) override;
+
+  virtual gfx::IntSize GetSize() override { return mSize; }
+
+  SourceSurfaceImage(const gfx::IntSize& aSize, gfx::SourceSurface* aSourceSurface);
+  explicit SourceSurfaceImage(gfx::SourceSurface* aSourceSurface);
+  ~SourceSurfaceImage();
+
+private:
+  gfx::IntSize mSize;
+  nsCountedRef<nsOwningThreadSourceSurfaceRef> mSourceSurface;
+  nsDataHashtable<nsUint32HashKey, RefPtr<TextureClient> >  mTextureClients;
+  TextureFlags mTextureFlags;
+};
+
+} // namespace layers
+} // namespace mozilla
+
+#endif