Attachment #516105 for bug #580531

Attachment #516105: Patch: add paint time to Images for bug #580531

View | Details | Raw Unified | Return to bug 580531
Collapse All | Expand All





 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#ifndef GFX_IMAGELAYER_H
#define GFX_IMAGELAYER_H

#include "Layers.h"
#include "mozilla/TimeStamp.h"

#include "gfxPattern.h"
#include "nsThreadUtils.h"
#include "nsCoreAnimationSupport.h"

namespace mozilla {
namespace layers {


     * It wraps an IOSurface object and binds it directly to a GL texture.
     */
    MAC_IO_SURFACE
  };

  Format GetFormat() { return mFormat; }
  void* GetImplData() { return mImplData; }

  /**
   * Return PR_TRUE if this image has been painted at least once.
   * Call on main thread only.
   */
  PRBool HasBeenPainted() const {
    NS_PRECONDITION(NS_IsMainThread(), "Must be called on main thread");
    return mPainted;
  }

  /**
   * Marks this image as having been painted.
   * Call on main thread only.
   */
  void MarkPainted() {
    NS_PRECONDITION(NS_IsMainThread(), "Must be called on main thread");
    mPainted = PR_TRUE;
  }

protected:
  Image(void* aImplData, Format aFormat) :
    mImplData(aImplData),
    mFormat(aFormat),
    mPainted(PR_FALSE)
  {}

  void* mImplData;
  Format mFormat;

  // PR_TRUE if the image has been painted at least once.
  // Accessed on main thread only.
  PRBool mPainted;
};

/**
 * 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.
 */
class THEBES_API ImageContainer {
  THEBES_INLINE_DECL_THREADSAFE_REFCOUNTING(ImageContainer)

public:
  ImageContainer() : mPaintCount(0) {}
  virtual ~ImageContainer() {}

  /**
   * 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.
   */


  /**
   * Get the layer manager type this image container was created with,
   * presumably its users might want to do something special if types do not
   * match.
   */
  virtual LayerManager::LayersBackend GetBackendType() = 0;

  /**
   * 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.  Threadsafe.
   */
  virtual TimeStamp GetPaintTime() = 0;

  /**
   * Returns the number of images which have been contained in this container
   * and painted at least once.  Threadsafe.
   */
  virtual PRUint32 GetPaintCount() = 0;

  /**
   * Notifies the container that aImage has been painted.  Note we must pass
   * in a pointer to the image that has been painted, as the current image
   * can change while we're rendering, and in that case we don't want to
   * record the paint time of the just painted image as the paint time of the
   * current image.  Threadsafe.
   */
  virtual void NotifyPaintedImage(Image* aImage) = 0;

protected:
  LayerManager* mManager;

  ImageContainer(LayerManager* aManager) : mManager(aManager), mPaintCount(0) {}

  // 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.
  PRUint32 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;
};

/**
 * A Layer which renders an Image.
 */
class THEBES_API ImageLayer : public Layer {
public:
  /**





  virtual already_AddRefed<Image> GetCurrentImage();
  virtual already_AddRefed<gfxASurface> GetCurrentAsSurface(gfxIntSize* aSize);
  virtual gfxIntSize GetCurrentSize();
  virtual PRBool SetLayerManager(LayerManager *aManager);
  virtual void SetScaleHint(const gfxIntSize& aScaleHint);
  void SetOffscreenFormat(gfxImageFormat aFormat) { mOffscreenFormat = aFormat; }
  virtual LayerManager::LayersBackend GetBackendType() { return LayerManager::LAYERS_BASIC; }

  TimeStamp GetPaintTime();
  PRUint32 GetPaintCount();
  void NotifyPaintedImage(Image* aImage);

protected:
  Monitor mMonitor;
  nsRefPtr<Image> mImage;
  gfxIntSize mScaleHint;
  gfxImageFormat mOffscreenFormat;
};

/**

  } else if (FormatInList(aFormats, aNumFormats, Image::PLANAR_YCBCR)) {
    MonitorAutoEnter mon(mMonitor);
    image = new BasicPlanarYCbCrImage(mScaleHint);
    static_cast<BasicPlanarYCbCrImage*>(image.get())->SetOffscreenFormat(mOffscreenFormat);
  }
  return image.forget();
}

TimeStamp
BasicImageContainer::GetPaintTime()
{
  MonitorAutoEnter mon(mMonitor);
  return mPaintTime;
}

PRUint32
BasicImageContainer::GetPaintCount()
{
  MonitorAutoEnter mon(mMonitor);
  return mPaintCount;
}

void
BasicImageContainer::NotifyPaintedImage(Image* aImage)
{
  MonitorAutoEnter mon(mMonitor);
  mPaintCount++;
  if (aImage == mImage) {
    mPaintTime = TimeStamp::Now();
  }
}

void
BasicImageContainer::SetCurrentImage(Image* aImage)
{
  MonitorAutoEnter mon(mMonitor);
  mPaintTime = TimeStamp();
  mImage = aImage;
}

already_AddRefed<Image>
BasicImageContainer::GetCurrentImage()
{
  MonitorAutoEnter mon(mMonitor);
  nsRefPtr<Image> image = mImage;






already_AddRefed<gfxPattern>
BasicImageLayer::GetAndPaintCurrentImage(gfxContext* aContext,
                                         float aOpacity)
{
  if (!mContainer)
    return nsnull;

  nsRefPtr<Image> image = mContainer->GetCurrentImage();

  nsRefPtr<gfxASurface> surface = mContainer->GetCurrentAsSurface(&mSize);
  if (!surface) {
    return nsnull;
  }

  nsRefPtr<gfxPattern> pat = new gfxPattern(surface);
  if (!pat) {
    return nsnull;


  // The visible region can extend outside the image.  If we're not
  // tiling, we don't want to draw into that area, so just draw within
  // the image bounds.
  const nsIntRect* tileSrcRect = GetTileSourceRect();
  PaintContext(pat,
               tileSrcRect ? GetVisibleRegion() : nsIntRegion(nsIntRect(0, 0, mSize.width, mSize.height)),
               tileSrcRect,
               aOpacity, aContext);

  if (!image->HasBeenPainted()) {
    image->MarkPainted();
    GetContainer()->NotifyPaintedImage(image);
  }

  return pat.forget();
}

/*static*/ void
BasicImageLayer::PaintContext(gfxPattern* aPattern,
                              const nsIntRegion& aVisible,
                              const nsIntRect* aTileSourceRect,
                              float aOpacity,





  }
  return img.forget();
}

void
ImageContainerD3D10::SetCurrentImage(Image *aImage)
{
  MutexAutoLock lock(mActiveImageLock);
  
  mPaintTime = TimeStamp();
  mActiveImage = aImage;
}

TimeStamp ImageContainerD3D10::GetPaintTime() {
  MutexAutoLock lock(mActiveImageLock);

  return mPaintTime;
}

PRUint32 ImageContainerD3D10::GetPaintCount() {
  MutexAutoLock lock(mActiveImageLock);

  return mPaintCount;
}

void ImageContainerD3D10::NotifyPaintedImage(Image* aImage) {
  MutexAutoLock lock(mActiveImageLock);

  mPaintCount++;
  if (aImage == mActiveImage) {
    mPaintTime = TimeStamp::Now();
  }
}

already_AddRefed<Image>
ImageContainerD3D10::GetCurrentImage()
{
  MutexAutoLock lock(mActiveImageLock);

  nsRefPtr<Image> retval = mActiveImage;

        (float)0,
        (float)yuvImage->mSize.width,
        (float)yuvImage->mSize.height)
      );
  }

  technique->GetPassByIndex(0)->Apply(0);
  device()->Draw(4, 0);

  if (!image->HasBeenPainted()) {
    image->MarkPainted();
    GetContainer()->NotifyPaintedImage(image);
  }
}

PlanarYCbCrImageD3D10::PlanarYCbCrImageD3D10(ID3D10Device1 *aDevice)
  : PlanarYCbCrImage(static_cast<ImageD3D10*>(this))
  , mDevice(aDevice)
  , mHasData(PR_FALSE)
{
}






  virtual PRBool SetLayerManager(LayerManager *aManager);

  virtual LayerManager::LayersBackend GetBackendType() { return LayerManager::LAYERS_D3D10; }

  ID3D10Device1 *device() { return mDevice; }
  void SetDevice(ID3D10Device1 *aDevice) { mDevice = aDevice; }

  TimeStamp GetPaintTime();
  PRUint32 GetPaintCount();
  void NotifyPaintedImage(Image* aImage);

private:
  typedef mozilla::Mutex Mutex;

  nsRefPtr<Image> mActiveImage;
  nsRefPtr<ID3D10Device1> mDevice;

  Mutex mActiveImageLock;
};





  if (aFormats[0] == Image::PLANAR_YCBCR) {
    img = new PlanarYCbCrImageD3D9();
  } else if (aFormats[0] == Image::CAIRO_SURFACE) {
    img = new CairoImageD3D9(mDevice);
  }
  return img.forget();
}

TimeStamp
ImageContainerD3D9::GetPaintTime()
{
  MutexAutoLock lock(mActiveImageLock);

  return mPaintTime;
}

PRUint32
ImageContainerD3D9::GetPaintCount()
{
  MutexAutoLock lock(mActiveImageLock);

  return mPaintCount;
}

void
ImageContainerD3D9::NotifyPaintedImage(Image* aImage)
{
  MutexAutoLock lock(mActiveImageLock);

  mPaintCount++;
  if (aImage == mActiveImage) {
    mPaintTime = TimeStamp::Now();
  }
}

void
ImageContainerD3D9::SetCurrentImage(Image *aImage)
{
  MutexAutoLock lock(mActiveImageLock);

  mPaintTime = TimeStamp();
  mActiveImage = aImage;
}

already_AddRefed<Image>
ImageContainerD3D9::GetCurrentImage()
{
  MutexAutoLock lock(mActiveImageLock);


    }
    device()->SetTexture(0, cairoImage->GetOrCreateTexture());
    device()->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
    if (mFilter == gfxPattern::FILTER_NEAREST) {
      device()->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
      device()->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
    }
  }

  if (!image->HasBeenPainted()) {
    image->MarkPainted();
    GetContainer()->NotifyPaintedImage(image);
  }
}

PlanarYCbCrImageD3D9::PlanarYCbCrImageD3D9()
  : PlanarYCbCrImage(static_cast<ImageD3D9*>(this))
  , mHasData(PR_FALSE)
{
}







  virtual PRBool SetLayerManager(LayerManager *aManager);

  virtual LayerManager::LayersBackend GetBackendType() { return LayerManager::LAYERS_D3D9; }

  IDirect3DDevice9 *device() { return mDevice; }
  void SetDevice(IDirect3DDevice9 *aDevice) { mDevice = aDevice; }

  TimeStamp GetPaintTime();
  PRUint32 GetPaintCount();
  void NotifyPaintedImage(Image* aImage);

private:
  typedef mozilla::Mutex Mutex;

  nsRefPtr<Image> mActiveImage;

  nsRefPtr<IDirect3DDevice9> mDevice;

  Mutex mActiveImageLock;





  else if (aFormats[0] == Image::MAC_IO_SURFACE) {
    img = new MacIOSurfaceImageOGL(static_cast<LayerManagerOGL*>(mManager));
  }
#endif

  return img.forget();
}

TimeStamp
ImageContainerOGL::GetPaintTime()
{
  MutexAutoLock lock(mActiveImageLock);

  return mPaintTime;
}

PRUint32
ImageContainerOGL::GetPaintCount()
{
  MutexAutoLock lock(mActiveImageLock);

  return mPaintCount;
}

void
ImageContainerOGL::NotifyPaintedImage(Image* aImage)
{
  MutexAutoLock lock(mActiveImageLock);

  mPaintCount++;
  if (aImage == mActiveImage) {
    mPaintTime = TimeStamp::Now();
  }
}

void
ImageContainerOGL::SetCurrentImage(Image *aImage)
{
  nsRefPtr<Image> oldImage;

  {
    MutexAutoLock lock(mActiveImageLock);

    mPaintTime = TimeStamp();
    oldImage = mActiveImage.forget();
    mActiveImage = aImage;
  }

  // Make sure oldImage is released outside the lock, so it can take our
  // lock in RecycleBuffer
}


     program->SetLayerOpacity(GetEffectiveOpacity());
     program->SetRenderOffset(aOffset);
     program->SetTextureUnit(0);
    
     mOGLManager->BindAndDrawQuad(program);
     gl()->fBindTexture(LOCAL_GL_TEXTURE_RECTANGLE_ARB, 0);
#endif
  }
  if (!image->HasBeenPainted()) {
    image->MarkPainted();
    GetContainer()->NotifyPaintedImage(image);
  }
}

static void
InitTexture(GLContext* aGL, GLuint aTexture, GLenum aFormat, const gfxIntSize& aSize)
{
  aGL->fBindTexture(LOCAL_GL_TEXTURE_2D, aTexture);
  aGL->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MIN_FILTER, LOCAL_GL_LINEAR);
  aGL->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MAG_FILTER, LOCAL_GL_LINEAR);





  virtual already_AddRefed<gfxASurface> GetCurrentAsSurface(gfxIntSize* aSize);

  virtual gfxIntSize GetCurrentSize();

  virtual PRBool SetLayerManager(LayerManager *aManager);

  virtual LayerManager::LayersBackend GetBackendType() { return LayerManager::LAYERS_OPENGL; }

  TimeStamp GetPaintTime();
  PRUint32 GetPaintCount();
  void NotifyPaintedImage(Image* aImage);

private:
  typedef mozilla::Mutex Mutex;

  nsRefPtr<RecycleBin> mRecycleBin;

  // This protects mActiveImage
  Mutex mActiveImageLock;


Return to bug 580531