The Tor Browser: gfx/layers/d3d9/TextureD3D9.h@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-

     2  * This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 #ifndef MOZILLA_GFX_TEXTURED3D9_H

     7 #define MOZILLA_GFX_TEXTURED3D9_H

     9 #include "mozilla/layers/Compositor.h"

    10 #include "mozilla/layers/TextureClient.h"

    11 #include "mozilla/layers/TextureHost.h"

    12 #include "mozilla/GfxMessageUtils.h"

    13 #include "gfxWindowsPlatform.h"

    14 #include "d3d9.h"

    15 #include <vector>

    16 #include "DeviceManagerD3D9.h"

    18 namespace mozilla {

    19 namespace gfxs {

    20 class DrawTarget;

    21 }

    22 }

    24 namespace mozilla {

    25 namespace layers {

    27 class CompositorD3D9;

    29 class TextureSourceD3D9

    30 {

    31   friend class DeviceManagerD3D9;

    33 public:

    34   TextureSourceD3D9()

    35     : mPreviousHost(nullptr)

    36     , mNextHost(nullptr)

    37     , mCreatingDeviceManager(nullptr)

    38   {}

    39   virtual ~TextureSourceD3D9();

    41   virtual IDirect3DTexture9* GetD3D9Texture() { return mTexture; }

    43   StereoMode GetStereoMode() const { return mStereoMode; };

    45   // Release all texture memory resources held by the texture host.

    46   virtual void ReleaseTextureResources()

    47   {

    48     mTexture = nullptr;

    49   }

    51 protected:

    52   virtual gfx::IntSize GetSize() const { return mSize; }

    53   void SetSize(const gfx::IntSize& aSize) { mSize = aSize; }

    55   // Helper methods for creating and copying textures.

    56   TemporaryRef<IDirect3DTexture9> InitTextures(

    57     DeviceManagerD3D9* aDeviceManager,

    58     const gfx::IntSize &aSize,

    59     _D3DFORMAT aFormat,

    60     RefPtr<IDirect3DSurface9>& aSurface,

    61     D3DLOCKED_RECT& aLockedRect);

    63   TemporaryRef<IDirect3DTexture9> DataToTexture(

    64     DeviceManagerD3D9* aDeviceManager,

    65     unsigned char *aData,

    66     int aStride,

    67     const gfx::IntSize &aSize,

    68     _D3DFORMAT aFormat,

    69     uint32_t aBPP);

    71   // aTexture should be in SYSTEMMEM, returns a texture in the default

    72   // pool (that is, in video memory).

    73   TemporaryRef<IDirect3DTexture9> TextureToTexture(

    74     DeviceManagerD3D9* aDeviceManager,

    75     IDirect3DTexture9* aTexture,

    76     const gfx::IntSize& aSize,

    77     _D3DFORMAT aFormat);

    79   TemporaryRef<IDirect3DTexture9> SurfaceToTexture(

    80     DeviceManagerD3D9* aDeviceManager,

    81     gfxWindowsSurface* aSurface,

    82     const gfx::IntSize& aSize,

    83     _D3DFORMAT aFormat);

    85   gfx::IntSize mSize;

    87   // Linked list of all objects holding d3d9 textures.

    88   TextureSourceD3D9* mPreviousHost;

    89   TextureSourceD3D9* mNextHost;

    90   // The device manager that created our textures.

    91   DeviceManagerD3D9* mCreatingDeviceManager;

    93   StereoMode mStereoMode;

    94   RefPtr<IDirect3DTexture9> mTexture;

    95 };

    97 /**

    98  * A TextureSource that implements the DataTextureSource interface.

    99  * it can be used without a TextureHost and is able to upload texture data

   100  * from a gfx::DataSourceSurface.

   101  */

   102 class DataTextureSourceD3D9 : public DataTextureSource

   103                             , public TextureSourceD3D9

   104                             , public TileIterator

   105 {

   106 public:

   107   DataTextureSourceD3D9(gfx::SurfaceFormat aFormat,

   108                         CompositorD3D9* aCompositor,

   109                         TextureFlags aFlags = TEXTURE_FLAGS_DEFAULT,

   110                         StereoMode aStereoMode = StereoMode::MONO);

   112   DataTextureSourceD3D9(gfx::SurfaceFormat aFormat,

   113                         gfx::IntSize aSize,

   114                         CompositorD3D9* aCompositor,

   115                         IDirect3DTexture9* aTexture,

   116                         TextureFlags aFlags = TEXTURE_FLAGS_DEFAULT);

   118   virtual ~DataTextureSourceD3D9();

   120   // DataTextureSource

   122   virtual bool Update(gfx::DataSourceSurface* aSurface,

   123                       nsIntRegion* aDestRegion = nullptr,

   124                       gfx::IntPoint* aSrcOffset = nullptr) MOZ_OVERRIDE;

   126   // TextureSource

   128   virtual TextureSourceD3D9* AsSourceD3D9() MOZ_OVERRIDE { return this; }

   130   virtual IDirect3DTexture9* GetD3D9Texture() MOZ_OVERRIDE;

   132   virtual DataTextureSource* AsDataTextureSource() MOZ_OVERRIDE { return this; }

   134   virtual void DeallocateDeviceData() MOZ_OVERRIDE { mTexture = nullptr; }

   136   virtual gfx::IntSize GetSize() const MOZ_OVERRIDE { return mSize; }

   138   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE { return mFormat; }

   140   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;

   142   // TileIterator

   144   virtual TileIterator* AsTileIterator() MOZ_OVERRIDE { return mIsTiled ? this : nullptr; }

   146   virtual size_t GetTileCount() MOZ_OVERRIDE { return mTileTextures.size(); }

   148   virtual bool NextTile() MOZ_OVERRIDE { return (++mCurrentTile < mTileTextures.size()); }

   150   virtual nsIntRect GetTileRect() MOZ_OVERRIDE;

   152   virtual void EndTileIteration() MOZ_OVERRIDE { mIterating = false; }

   154   virtual void BeginTileIteration() MOZ_OVERRIDE

   155   {

   156     mIterating = true;

   157     mCurrentTile = 0;

   158   }

   160   /**

   161    * Copy the content of aTexture using the GPU.

   162    */

   163   bool UpdateFromTexture(IDirect3DTexture9* aTexture, const nsIntRegion* aRegion);

   165   // To use with DIBTextureHostD3D9

   167   bool Update(gfxWindowsSurface* aSurface);

   169 protected:

   170   gfx::IntRect GetTileRect(uint32_t aTileIndex) const;

   172   void Reset();

   174   std::vector< RefPtr<IDirect3DTexture9> > mTileTextures;

   175   RefPtr<CompositorD3D9> mCompositor;

   176   gfx::SurfaceFormat mFormat;

   177   uint32_t mCurrentTile;

   178   TextureFlags mFlags;

   179   bool mIsTiled;

   180   bool mIterating;

   181 };

   183 /**

   184  * Can only be drawn into through Cairo and need a D3D9 context on the client side.

   185  * The corresponding TextureHost is TextureHostD3D9.

   186  */

   187 class CairoTextureClientD3D9 : public TextureClient

   188 {

   189 public:

   190   CairoTextureClientD3D9(gfx::SurfaceFormat aFormat, TextureFlags aFlags);

   192   virtual ~CairoTextureClientD3D9();

   194   // TextureClient

   196   virtual bool IsAllocated() const MOZ_OVERRIDE { return !!mTexture; }

   198   virtual bool Lock(OpenMode aOpenMode) MOZ_OVERRIDE;

   200   virtual void Unlock() MOZ_OVERRIDE;

   202   virtual bool IsLocked() const MOZ_OVERRIDE { return mIsLocked; }

   204   virtual bool ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) MOZ_OVERRIDE;

   206   virtual gfx::IntSize GetSize() const { return mSize; }

   208   virtual gfx::SurfaceFormat GetFormat() const { return mFormat; }

   210   virtual TextureClientData* DropTextureData() MOZ_OVERRIDE;

   212   virtual bool CanExposeDrawTarget() const MOZ_OVERRIDE { return true; }

   214   virtual TemporaryRef<gfx::DrawTarget> GetAsDrawTarget() MOZ_OVERRIDE;

   216   virtual bool AllocateForSurface(gfx::IntSize aSize,

   217                                   TextureAllocationFlags aFlags = ALLOC_DEFAULT) MOZ_OVERRIDE;

   219   virtual bool HasInternalBuffer() const MOZ_OVERRIDE { return true; }

   221 private:

   222   RefPtr<IDirect3DTexture9> mTexture;

   223   nsRefPtr<IDirect3DSurface9> mD3D9Surface;

   224   RefPtr<gfx::DrawTarget> mDrawTarget;

   225   nsRefPtr<gfxASurface> mSurface;

   226   gfx::IntSize mSize;

   227   gfx::SurfaceFormat mFormat;

   228   bool mIsLocked;

   229   bool mNeedsClear;

   230   bool mLockRect;

   231 };

   233 /**

   234  * Can only be drawn into through Cairo.

   235  * Prefer CairoTextureClientD3D9 when possible.

   236  * The coresponding TextureHost is DIBTextureHostD3D9.

   237  */

   238 class DIBTextureClientD3D9 : public TextureClient

   239 {

   240 public:

   241   DIBTextureClientD3D9(gfx::SurfaceFormat aFormat, TextureFlags aFlags);

   243   virtual ~DIBTextureClientD3D9();

   245   // TextureClient

   247   virtual bool IsAllocated() const MOZ_OVERRIDE { return !!mSurface; }

   249   virtual bool Lock(OpenMode aOpenMode) MOZ_OVERRIDE;

   251   virtual void Unlock() MOZ_OVERRIDE;

   253   virtual bool IsLocked() const MOZ_OVERRIDE { return mIsLocked; }

   255   virtual bool ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) MOZ_OVERRIDE;

   257   virtual gfx::IntSize GetSize() const { return mSize; }

   259   virtual gfx::SurfaceFormat GetFormat() const { return mFormat; }

   261   virtual TextureClientData* DropTextureData() MOZ_OVERRIDE;

   263   virtual bool CanExposeDrawTarget() const MOZ_OVERRIDE { return true; }

   265   virtual TemporaryRef<gfx::DrawTarget> GetAsDrawTarget() MOZ_OVERRIDE;

   267   virtual bool AllocateForSurface(gfx::IntSize aSize,

   268                                   TextureAllocationFlags aFlags = ALLOC_DEFAULT) MOZ_OVERRIDE;

   270   virtual bool HasInternalBuffer() const MOZ_OVERRIDE { return true; }

   272 protected:

   273   nsRefPtr<gfxWindowsSurface> mSurface;

   274   RefPtr<gfx::DrawTarget> mDrawTarget;

   275   gfx::IntSize mSize;

   276   gfx::SurfaceFormat mFormat;

   277   bool mIsLocked;

   278 };

   280 /**

   281  * Wraps a D3D9 texture, shared with the compositor though DXGI.

   282  * At the moment it is only used with D3D11 compositing, and the corresponding

   283  * TextureHost is DXGITextureHostD3D11.

   284  */

   285 class SharedTextureClientD3D9 : public TextureClient

   286 {

   287 public:

   288   SharedTextureClientD3D9(gfx::SurfaceFormat aFormat, TextureFlags aFlags);

   290   virtual ~SharedTextureClientD3D9();

   292   // TextureClient

   294   virtual bool IsAllocated() const MOZ_OVERRIDE { return !!mTexture; }

   296   virtual bool Lock(OpenMode aOpenMode) MOZ_OVERRIDE;

   298   virtual void Unlock() MOZ_OVERRIDE;

   300   virtual bool IsLocked() const MOZ_OVERRIDE { return mIsLocked; }

   302   virtual bool ToSurfaceDescriptor(SurfaceDescriptor& aOutDescriptor) MOZ_OVERRIDE;

   304   void InitWith(IDirect3DTexture9* aTexture, HANDLE aSharedHandle, D3DSURFACE_DESC aDesc)

   305   {

   306     MOZ_ASSERT(!mTexture);

   307     mTexture = aTexture;

   308     mHandle = aSharedHandle;

   309     mDesc = aDesc;

   310   }

   312   virtual gfx::IntSize GetSize() const

   313   {

   314     return gfx::IntSize(mDesc.Width, mDesc.Height);

   315   }

   317   virtual TextureClientData* DropTextureData() MOZ_OVERRIDE;

   319   virtual bool HasInternalBuffer() const MOZ_OVERRIDE { return true; }

   321 private:

   322   RefPtr<IDirect3DTexture9> mTexture;

   323   gfx::SurfaceFormat mFormat;

   324   HANDLE mHandle;

   325   D3DSURFACE_DESC mDesc;

   326   bool mIsLocked;

   327 };

   329 class TextureHostD3D9 : public TextureHost

   330 {

   331 public:

   332   TextureHostD3D9(TextureFlags aFlags,

   333                   const SurfaceDescriptorD3D9& aDescriptor);

   335   virtual NewTextureSource* GetTextureSources() MOZ_OVERRIDE;

   337   virtual void DeallocateDeviceData() MOZ_OVERRIDE;

   339   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;

   341   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE { return mFormat; }

   343   virtual bool Lock() MOZ_OVERRIDE;

   345   virtual void Unlock() MOZ_OVERRIDE;

   347   virtual void Updated(const nsIntRegion* aRegion) MOZ_OVERRIDE;

   349   virtual gfx::IntSize GetSize() const MOZ_OVERRIDE { return mSize; }

   351   virtual TemporaryRef<gfx::DataSourceSurface> GetAsSurface() MOZ_OVERRIDE

   352   {

   353     return nullptr;

   354   }

   356   virtual bool HasInternalBuffer() const MOZ_OVERRIDE { return true; }

   358 protected:

   359   TextureHostD3D9(TextureFlags aFlags);

   360   IDirect3DDevice9* GetDevice();

   362   RefPtr<DataTextureSourceD3D9> mTextureSource;

   363   RefPtr<IDirect3DTexture9> mTexture;

   364   RefPtr<CompositorD3D9> mCompositor;

   365   gfx::IntSize mSize;

   366   gfx::SurfaceFormat mFormat;

   367   bool mIsLocked;

   368 };

   370 class DIBTextureHostD3D9 : public TextureHost

   371 {

   372 public:

   373   DIBTextureHostD3D9(TextureFlags aFlags,

   374                      const SurfaceDescriptorDIB& aDescriptor);

   376   virtual NewTextureSource* GetTextureSources() MOZ_OVERRIDE;

   378   virtual void DeallocateDeviceData() MOZ_OVERRIDE;

   380   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;

   382   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE { return mFormat; }

   384   virtual gfx::IntSize GetSize() const MOZ_OVERRIDE { return mSize; }

   386   virtual bool Lock() MOZ_OVERRIDE;

   388   virtual void Unlock() MOZ_OVERRIDE;

   390   virtual void Updated(const nsIntRegion* aRegion = nullptr);

   392   virtual TemporaryRef<gfx::DataSourceSurface> GetAsSurface() MOZ_OVERRIDE

   393   {

   394     return nullptr; // TODO: cf bug 872568

   395   }

   397 protected:

   398   nsRefPtr<gfxWindowsSurface> mSurface;

   399   RefPtr<DataTextureSourceD3D9> mTextureSource;

   400   RefPtr<CompositorD3D9> mCompositor;

   401   gfx::SurfaceFormat mFormat;

   402   gfx::IntSize mSize;

   403   bool mIsLocked;

   404 };

   406 class DXGITextureHostD3D9 : public TextureHost

   407 {

   408 public:

   409   DXGITextureHostD3D9(TextureFlags aFlags,

   410     const SurfaceDescriptorD3D10& aDescriptor);

   412   virtual NewTextureSource* GetTextureSources() MOZ_OVERRIDE;

   414   virtual void DeallocateDeviceData() MOZ_OVERRIDE;

   416   virtual void SetCompositor(Compositor* aCompositor) MOZ_OVERRIDE;

   418   virtual gfx::SurfaceFormat GetFormat() const MOZ_OVERRIDE { return mFormat; }

   420   virtual gfx::IntSize GetSize() const MOZ_OVERRIDE { return mSize; }

   422   virtual bool Lock() MOZ_OVERRIDE;

   424   virtual void Unlock() MOZ_OVERRIDE;

   426   virtual TemporaryRef<gfx::DataSourceSurface> GetAsSurface() MOZ_OVERRIDE

   427   {

   428     return nullptr; // TODO: cf bug 872568

   429   }

   431 protected:

   432   RefPtr<DataTextureSourceD3D9> mTextureSource;

   433   RefPtr<CompositorD3D9> mCompositor;

   434   WindowsHandle mHandle;

   435   gfx::SurfaceFormat mFormat;

   436   gfx::IntSize mSize;

   437   bool mIsLocked;

   438 };

   440 class CompositingRenderTargetD3D9 : public CompositingRenderTarget,

   441                                     public TextureSourceD3D9

   442 {

   443 public:

   444   CompositingRenderTargetD3D9(IDirect3DTexture9* aTexture,

   445                               SurfaceInitMode aInit,

   446                               const gfx::IntRect& aRect);

   447   // use for rendering to the main window, cannot be rendered as a texture

   448   CompositingRenderTargetD3D9(IDirect3DSurface9* aSurface,

   449                               SurfaceInitMode aInit,

   450                               const gfx::IntRect& aRect);

   451   virtual ~CompositingRenderTargetD3D9();

   453   virtual TextureSourceD3D9* AsSourceD3D9() MOZ_OVERRIDE

   454   {

   455     MOZ_ASSERT(mTexture,

   456                "No texture, can't be indirectly rendered. Is this the screen backbuffer?");

   457     return this;

   458   }

   460   virtual gfx::IntSize GetSize() const MOZ_OVERRIDE;

   462   void BindRenderTarget(IDirect3DDevice9* aDevice);

   464   IDirect3DSurface9* GetD3D9Surface() const { return mSurface; }

   466 private:

   467   friend class CompositorD3D9;

   469   nsRefPtr<IDirect3DSurface9> mSurface;

   470   SurfaceInitMode mInitMode;

   471   bool mInitialized;

   472 };

   474 }

   475 }

   477 #endif /* MOZILLA_GFX_TEXTURED3D9_H */

The Tor Browser / file revision

gfx/layers/d3d9/TextureD3D9.h@6474c204b198

gfx/layers/d3d9/TextureD3D9.h