gfx/layers/opengl/TextureHostOGL.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef MOZILLA_GFX_TEXTUREOGL_H
   8 #define MOZILLA_GFX_TEXTUREOGL_H
   9
  10 #include <stddef.h>  // for size_t
  11 #include <stdint.h>  // for uint64_t
  12 #include "CompositableHost.h"
  13 #include "GLContextTypes.h"  // for GLContext
  14 #include "GLDefs.h"          // for GLenum, LOCAL_GL_CLAMP_TO_EDGE, etc
  15 #include "GLTextureImage.h"  // for TextureImage
  16 #include "gfxTypes.h"
  17 #include "mozilla/GfxMessageUtils.h"         // for gfxContentType
  18 #include "mozilla/Assertions.h"              // for MOZ_ASSERT, etc
  19 #include "mozilla/Attributes.h"              // for override
  20 #include "mozilla/RefPtr.h"                  // for RefPtr
  21 #include "mozilla/gfx/Matrix.h"              // for Matrix4x4
  22 #include "mozilla/gfx/Point.h"               // for IntSize, IntPoint
  23 #include "mozilla/gfx/Types.h"               // for SurfaceFormat, etc
  24 #include "mozilla/layers/CompositorOGL.h"    // for CompositorOGL
  25 #include "mozilla/layers/CompositorTypes.h"  // for TextureFlags
  26 #include "mozilla/layers/LayersSurfaces.h"   // for SurfaceDescriptor
  27 #include "mozilla/layers/TextureHost.h"      // for TextureHost, etc
  28 #include "mozilla/mozalloc.h"                // for operator delete, etc
  29 #include "mozilla/webrender/RenderThread.h"
  30 #include "nsCOMPtr.h"         // for already_AddRefed
  31 #include "nsDebug.h"          // for NS_WARNING
  32 #include "nsISupportsImpl.h"  // for TextureImage::Release, etc
  33 #include "nsRegionFwd.h"      // for nsIntRegion
  34
  35 #ifdef MOZ_WIDGET_ANDROID
  36 #  include "AndroidSurfaceTexture.h"
  37 #  include "mozilla/java/GeckoSurfaceTextureWrappers.h"
  38 #endif
  39
  40 namespace mozilla {
  41 namespace gfx {
  42 class DataSourceSurface;
  43 }  // namespace gfx
  44
  45 namespace layers {
  46
  47 class Compositor;
  48 class CompositorOGL;
  49 class AndroidHardwareBuffer;
  50 class SurfaceDescriptorAndroidHardwareBuffer;
  51 class TextureImageTextureSourceOGL;
  52 class GLTextureSource;
  53
  54 void ApplySamplingFilterToBoundTexture(gl::GLContext* aGL,
  55                                        gfx::SamplingFilter aSamplingFilter,
  56                                        GLuint aTarget = LOCAL_GL_TEXTURE_2D);
  57
  58 already_AddRefed<TextureHost> CreateTextureHostOGL(
  59     const SurfaceDescriptor& aDesc, ISurfaceAllocator* aDeallocator,
  60     LayersBackend aBackend, TextureFlags aFlags);
  61
  62 /*
  63  * TextureHost implementations for the OpenGL backend.
  64  *
  65  * Note that it is important to be careful about the ownership model with
  66  * the OpenGL backend, due to some widget limitation on Linux: before
  67  * the nsBaseWidget associated with our OpenGL context has been completely
  68  * deleted, every resource belonging to the OpenGL context MUST have been
  69  * released. At the moment the teardown sequence happens in the middle of
  70  * the nsBaseWidget's destructor, meaning that at a given moment we must be
  71  * able to easily find and release all the GL resources.
  72  * The point is: be careful about the ownership model and limit the number
  73  * of objects sharing references to GL resources to make the tear down
  74  * sequence as simple as possible.
  75  */
  76
  77 /**
  78  * TextureSourceOGL provides the necessary API for CompositorOGL to composite
  79  * a TextureSource.
  80  */
  81 class TextureSourceOGL {
  82  public:
  83   TextureSourceOGL()
  84       : mCachedSamplingFilter(gfx::SamplingFilter::GOOD),
  85         mHasCachedSamplingFilter(false) {}
  86
  87   virtual bool IsValid() const = 0;
  88
  89   virtual void BindTexture(GLenum aTextureUnit,
  90                            gfx::SamplingFilter aSamplingFilter) = 0;
  91
  92   // To be overridden in textures that need this. This method will be called
  93   // when the compositor has used the texture to draw. This allows us to set
  94   // a fence with glFenceSync which we can wait on later to ensure the GPU
  95   // is done with the draw calls using that texture. We would like to be able
  96   // to simply use glFinishObjectAPPLE, but this returns earlier than
  97   // expected with nvidia drivers.
  98   virtual void MaybeFenceTexture() {}
  99
 100   virtual gfx::IntSize GetSize() const = 0;
 101
 102   virtual GLenum GetTextureTarget() const { return LOCAL_GL_TEXTURE_2D; }
 103
 104   virtual gfx::SurfaceFormat GetFormat() const = 0;
 105
 106   virtual GLenum GetWrapMode() const = 0;
 107
 108   virtual gfx::Matrix4x4 GetTextureTransform() { return gfx::Matrix4x4(); }
 109
 110   virtual TextureImageTextureSourceOGL* AsTextureImageTextureSource() {
 111     return nullptr;
 112   }
 113
 114   virtual GLTextureSource* AsGLTextureSource() { return nullptr; }
 115
 116   void SetSamplingFilter(gl::GLContext* aGL,
 117                          gfx::SamplingFilter aSamplingFilter) {
 118     if (mHasCachedSamplingFilter && mCachedSamplingFilter == aSamplingFilter) {
 119       return;
 120     }
 121     mHasCachedSamplingFilter = true;
 122     mCachedSamplingFilter = aSamplingFilter;
 123     ApplySamplingFilterToBoundTexture(aGL, aSamplingFilter, GetTextureTarget());
 124   }
 125
 126   void ClearCachedFilter() { mHasCachedSamplingFilter = false; }
 127
 128  private:
 129   gfx::SamplingFilter mCachedSamplingFilter;
 130   bool mHasCachedSamplingFilter;
 131 };
 132
 133 /**
 134  * A TextureSource backed by a TextureImage.
 135  *
 136  * Depending on the underlying TextureImage, may support texture tiling, so
 137  * make sure to check AsBigImageIterator() and use the texture accordingly.
 138  *
 139  * This TextureSource can be used without a TextureHost and manage it's own
 140  * GL texture(s).
 141  */
 142 class TextureImageTextureSourceOGL final : public DataTextureSource,
 143                                            public TextureSourceOGL,
 144                                            public BigImageIterator {
 145  public:
 146   explicit TextureImageTextureSourceOGL(
 147       CompositorOGL* aCompositor, TextureFlags aFlags = TextureFlags::DEFAULT);
 148
 149   const char* Name() const override { return "TextureImageTextureSourceOGL"; }
 150   // DataTextureSource
 151
 152   bool Update(gfx::DataSourceSurface* aSurface,
 153               nsIntRegion* aDestRegion = nullptr,
 154               gfx::IntPoint* aSrcOffset = nullptr,
 155               gfx::IntPoint* aDstOffset = nullptr) override;
 156
 157   void EnsureBuffer(const gfx::IntSize& aSize, gfxContentType aContentType);
 158
 159   TextureImageTextureSourceOGL* AsTextureImageTextureSource() override {
 160     return this;
 161   }
 162
 163   // TextureSource
 164
 165   void DeallocateDeviceData() override;
 166
 167   TextureSourceOGL* AsSourceOGL() override { return this; }
 168
 169   void BindTexture(GLenum aTextureUnit,
 170                    gfx::SamplingFilter aSamplingFilter) override;
 171
 172   gfx::IntSize GetSize() const override;
 173
 174   gfx::SurfaceFormat GetFormat() const override;
 175
 176   bool IsValid() const override { return !!mTexImage; }
 177
 178   GLenum GetWrapMode() const override { return mTexImage->GetWrapMode(); }
 179
 180   // BigImageIterator
 181
 182   BigImageIterator* AsBigImageIterator() override { return this; }
 183
 184   void BeginBigImageIteration() override {
 185     mTexImage->BeginBigImageIteration();
 186     mIterating = true;
 187   }
 188
 189   void EndBigImageIteration() override { mIterating = false; }
 190
 191   gfx::IntRect GetTileRect() override;
 192
 193   size_t GetTileCount() override { return mTexImage->GetTileCount(); }
 194
 195   bool NextTile() override { return mTexImage->NextTile(); }
 196
 197   gl::GLContext* gl() const { return mGL; }
 198
 199  protected:
 200   ~TextureImageTextureSourceOGL();
 201
 202   RefPtr<gl::TextureImage> mTexImage;
 203   RefPtr<gl::GLContext> mGL;
 204   RefPtr<CompositorOGL> mCompositor;
 205   TextureFlags mFlags;
 206   bool mIterating;
 207 };
 208
 209 /**
 210  * A texture source for GL textures.
 211  *
 212  * It does not own any GL texture, and attaches its shared handle to one of
 213  * the compositor's temporary textures when binding.
 214  *
 215  * The shared texture handle is owned by the TextureHost.
 216  */
 217 class GLTextureSource : public DataTextureSource, public TextureSourceOGL {
 218  public:
 219   GLTextureSource(TextureSourceProvider* aProvider, GLuint aTextureHandle,
 220                   GLenum aTarget, gfx::IntSize aSize,
 221                   gfx::SurfaceFormat aFormat);
 222
 223   GLTextureSource(gl::GLContext* aGL, GLuint aTextureHandle, GLenum aTarget,
 224                   gfx::IntSize aSize, gfx::SurfaceFormat aFormat);
 225
 226   virtual ~GLTextureSource();
 227
 228   const char* Name() const override { return "GLTextureSource"; }
 229
 230   GLTextureSource* AsGLTextureSource() override { return this; }
 231
 232   TextureSourceOGL* AsSourceOGL() override { return this; }
 233
 234   void BindTexture(GLenum activetex,
 235                    gfx::SamplingFilter aSamplingFilter) override;
 236
 237   bool IsValid() const override;
 238
 239   gfx::IntSize GetSize() const override { return mSize; }
 240
 241   gfx::SurfaceFormat GetFormat() const override { return mFormat; }
 242
 243   GLenum GetTextureTarget() const override { return mTextureTarget; }
 244
 245   GLenum GetWrapMode() const override { return LOCAL_GL_CLAMP_TO_EDGE; }
 246
 247   void DeallocateDeviceData() override;
 248
 249   void SetSize(gfx::IntSize aSize) { mSize = aSize; }
 250
 251   void SetFormat(gfx::SurfaceFormat aFormat) { mFormat = aFormat; }
 252
 253   GLuint GetTextureHandle() const { return mTextureHandle; }
 254
 255   gl::GLContext* gl() const { return mGL; }
 256
 257   bool Update(gfx::DataSourceSurface* aSurface,
 258               nsIntRegion* aDestRegion = nullptr,
 259               gfx::IntPoint* aSrcOffset = nullptr,
 260               gfx::IntPoint* aDstOffset = nullptr) override {
 261     return false;
 262   }
 263
 264  protected:
 265   void DeleteTextureHandle();
 266
 267   RefPtr<gl::GLContext> mGL;
 268   RefPtr<CompositorOGL> mCompositor;
 269   GLuint mTextureHandle;
 270   GLenum mTextureTarget;
 271   gfx::IntSize mSize;
 272   gfx::SurfaceFormat mFormat;
 273 };
 274
 275 // This texture source try to wrap "aSurface" in ctor for compositor direct
 276 // access. Since we can't know the timing for gpu buffer access, the surface
 277 // should be alive until the ~ClientStorageTextureSource(). And if we try to
 278 // update the surface we mapped before, we need to call Sync() to make sure
 279 // the surface is not used by compositor.
 280 class DirectMapTextureSource : public GLTextureSource {
 281  public:
 282   DirectMapTextureSource(gl::GLContext* aContext,
 283                          gfx::DataSourceSurface* aSurface);
 284   DirectMapTextureSource(TextureSourceProvider* aProvider,
 285                          gfx::DataSourceSurface* aSurface);
 286   ~DirectMapTextureSource();
 287
 288   bool Update(gfx::DataSourceSurface* aSurface,
 289               nsIntRegion* aDestRegion = nullptr,
 290               gfx::IntPoint* aSrcOffset = nullptr,
 291               gfx::IntPoint* aDstOffset = nullptr) override;
 292
 293   // If aBlocking is false, check if this texture is no longer being used
 294   // by the GPU - if aBlocking is true, this will block until the GPU is
 295   // done with it.
 296   bool Sync(bool aBlocking) override;
 297
 298   void MaybeFenceTexture() override;
 299
 300  private:
 301   bool UpdateInternal(gfx::DataSourceSurface* aSurface,
 302                       nsIntRegion* aDestRegion, gfx::IntPoint* aSrcOffset,
 303                       bool aInit);
 304
 305   GLsync mSync;
 306 };
 307
 308 class GLTextureHost : public TextureHost {
 309  public:
 310   GLTextureHost(TextureFlags aFlags, GLuint aTextureHandle, GLenum aTarget,
 311                 GLsync aSync, gfx::IntSize aSize, bool aHasAlpha);
 312
 313   virtual ~GLTextureHost();
 314
 315   // We don't own anything.
 316   void DeallocateDeviceData() override {}
 317
 318   gfx::SurfaceFormat GetFormat() const override;
 319
 320   already_AddRefed<gfx::DataSourceSurface> GetAsSurface(
 321       gfx::DataSourceSurface* aSurface) override {
 322     return nullptr;  // XXX - implement this (for MOZ_DUMP_PAINTING)
 323   }
 324
 325   gl::GLContext* gl() const;
 326
 327   gfx::IntSize GetSize() const override { return mSize; }
 328
 329   const char* Name() override { return "GLTextureHost"; }
 330
 331  protected:
 332   const GLuint mTexture;
 333   const GLenum mTarget;
 334   GLsync mSync;
 335   const gfx::IntSize mSize;
 336   const bool mHasAlpha;
 337   RefPtr<GLTextureSource> mTextureSource;
 338 };
 339
 340 ////////////////////////////////////////////////////////////////////////
 341 // SurfaceTexture
 342
 343 #ifdef MOZ_WIDGET_ANDROID
 344
 345 class SurfaceTextureSource : public TextureSource, public TextureSourceOGL {
 346  public:
 347   SurfaceTextureSource(TextureSourceProvider* aProvider,
 348                        java::GeckoSurfaceTexture::Ref& aSurfTex,
 349                        gfx::SurfaceFormat aFormat, GLenum aTarget,
 350                        GLenum aWrapMode, gfx::IntSize aSize,
 351                        Maybe<gfx::Matrix4x4> aTransformOverride);
 352
 353   const char* Name() const override { return "SurfaceTextureSource"; }
 354
 355   TextureSourceOGL* AsSourceOGL() override { return this; }
 356
 357   void BindTexture(GLenum activetex,
 358                    gfx::SamplingFilter aSamplingFilter) override;
 359
 360   bool IsValid() const override;
 361
 362   gfx::IntSize GetSize() const override { return mSize; }
 363
 364   gfx::SurfaceFormat GetFormat() const override { return mFormat; }
 365
 366   gfx::Matrix4x4 GetTextureTransform() override;
 367
 368   GLenum GetTextureTarget() const override { return mTextureTarget; }
 369
 370   GLenum GetWrapMode() const override { return mWrapMode; }
 371
 372   void DeallocateDeviceData() override;
 373
 374   gl::GLContext* gl() const { return mGL; }
 375
 376  protected:
 377   RefPtr<gl::GLContext> mGL;
 378   mozilla::java::GeckoSurfaceTexture::GlobalRef mSurfTex;
 379   const gfx::SurfaceFormat mFormat;
 380   const GLenum mTextureTarget;
 381   const GLenum mWrapMode;
 382   const gfx::IntSize mSize;
 383   const Maybe<gfx::Matrix4x4> mTransformOverride;
 384 };
 385
 386 class SurfaceTextureHost : public TextureHost {
 387  public:
 388   SurfaceTextureHost(TextureFlags aFlags,
 389                      mozilla::java::GeckoSurfaceTexture::Ref& aSurfTex,
 390                      gfx::IntSize aSize, gfx::SurfaceFormat aFormat,
 391                      bool aContinuousUpdate, bool aForceBT709ColorSpace,
 392                      Maybe<gfx::Matrix4x4> aTransformOverride);
 393
 394   virtual ~SurfaceTextureHost();
 395
 396   void DeallocateDeviceData() override;
 397
 398   gfx::SurfaceFormat GetFormat() const override;
 399
 400   already_AddRefed<gfx::DataSourceSurface> GetAsSurface(
 401       gfx::DataSourceSurface* aSurface) override {
 402     return nullptr;  // XXX - implement this (for MOZ_DUMP_PAINTING)
 403   }
 404
 405   gl::GLContext* gl() const;
 406
 407   gfx::IntSize GetSize() const override { return mSize; }
 408
 409   const char* Name() override { return "SurfaceTextureHost"; }
 410
 411   SurfaceTextureHost* AsSurfaceTextureHost() override { return this; }
 412
 413   bool IsWrappingSurfaceTextureHost() override { return true; }
 414
 415   void CreateRenderTexture(
 416       const wr::ExternalImageId& aExternalImageId) override;
 417
 418   uint32_t NumSubTextures() override;
 419
 420   void PushResourceUpdates(wr::TransactionBuilder& aResources,
 421                            ResourceUpdateOp aOp,
 422                            const Range<wr::ImageKey>& aImageKeys,
 423                            const wr::ExternalImageId& aExtID) override;
 424
 425   void PushDisplayItems(wr::DisplayListBuilder& aBuilder,
 426                         const wr::LayoutRect& aBounds,
 427                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
 428                         const Range<wr::ImageKey>& aImageKeys,
 429                         PushDisplayItemFlagSet aFlags) override;
 430
 431   bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
 432
 433   // gecko does not need deferred deletion with WebRender
 434   // GPU/hardware task end could be checked by android fence.
 435   // SurfaceTexture uses android fence internally,
 436   bool NeedsDeferredDeletion() const override { return false; }
 437
 438  protected:
 439   mozilla::java::GeckoSurfaceTexture::GlobalRef mSurfTex;
 440   const gfx::IntSize mSize;
 441   const gfx::SurfaceFormat mFormat;
 442   bool mContinuousUpdate;
 443   const bool mForceBT709ColorSpace;
 444   const Maybe<gfx::Matrix4x4> mTransformOverride;
 445   RefPtr<CompositorOGL> mCompositor;
 446   RefPtr<SurfaceTextureSource> mTextureSource;
 447 };
 448
 449 class AndroidHardwareBufferTextureSource : public TextureSource,
 450                                            public TextureSourceOGL {
 451  public:
 452   AndroidHardwareBufferTextureSource(
 453       TextureSourceProvider* aProvider,
 454       AndroidHardwareBuffer* aAndroidHardwareBuffer, gfx::SurfaceFormat aFormat,
 455       GLenum aTarget, GLenum aWrapMode, gfx::IntSize aSize);
 456
 457   const char* Name() const override { return "SurfaceTextureSource"; }
 458
 459   TextureSourceOGL* AsSourceOGL() override { return this; }
 460
 461   void BindTexture(GLenum activetex,
 462                    gfx::SamplingFilter aSamplingFilter) override;
 463
 464   bool IsValid() const override;
 465
 466   gfx::IntSize GetSize() const override { return mSize; }
 467
 468   gfx::SurfaceFormat GetFormat() const override { return mFormat; }
 469
 470   GLenum GetTextureTarget() const override { return mTextureTarget; }
 471
 472   GLenum GetWrapMode() const override { return mWrapMode; }
 473
 474   void DeallocateDeviceData() override;
 475
 476   gl::GLContext* gl() const { return mGL; }
 477
 478  protected:
 479   virtual ~AndroidHardwareBufferTextureSource();
 480
 481   bool EnsureEGLImage();
 482   void DestroyEGLImage();
 483   void DeleteTextureHandle();
 484
 485   RefPtr<gl::GLContext> mGL;
 486   RefPtr<AndroidHardwareBuffer> mAndroidHardwareBuffer;
 487   const gfx::SurfaceFormat mFormat;
 488   const GLenum mTextureTarget;
 489   const GLenum mWrapMode;
 490   const gfx::IntSize mSize;
 491
 492   EGLImage mEGLImage;
 493   GLuint mTextureHandle;
 494 };
 495
 496 class AndroidHardwareBufferTextureHost : public TextureHost {
 497  public:
 498   static already_AddRefed<AndroidHardwareBufferTextureHost> Create(
 499       TextureFlags aFlags, const SurfaceDescriptorAndroidHardwareBuffer& aDesc);
 500
 501   AndroidHardwareBufferTextureHost(
 502       TextureFlags aFlags, AndroidHardwareBuffer* aAndroidHardwareBuffer);
 503
 504   virtual ~AndroidHardwareBufferTextureHost();
 505
 506   void DeallocateDeviceData() override;
 507
 508   gfx::SurfaceFormat GetFormat() const override;
 509
 510   gfx::IntSize GetSize() const override;
 511
 512   void NotifyNotUsed() override;
 513
 514   already_AddRefed<gfx::DataSourceSurface> GetAsSurface(
 515       gfx::DataSourceSurface* aSurface) override {
 516     return nullptr;  // XXX - implement this (for MOZ_DUMP_PAINTING)
 517   }
 518
 519   gl::GLContext* gl() const;
 520
 521   const char* Name() override { return "AndroidHardwareBufferTextureHost"; }
 522
 523   AndroidHardwareBufferTextureHost* AsAndroidHardwareBufferTextureHost()
 524       override {
 525     return this;
 526   }
 527
 528   void CreateRenderTexture(
 529       const wr::ExternalImageId& aExternalImageId) override;
 530
 531   uint32_t NumSubTextures() override;
 532
 533   void PushResourceUpdates(wr::TransactionBuilder& aResources,
 534                            ResourceUpdateOp aOp,
 535                            const Range<wr::ImageKey>& aImageKeys,
 536                            const wr::ExternalImageId& aExtID) override;
 537
 538   void PushDisplayItems(wr::DisplayListBuilder& aBuilder,
 539                         const wr::LayoutRect& aBounds,
 540                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
 541                         const Range<wr::ImageKey>& aImageKeys,
 542                         PushDisplayItemFlagSet aFlags) override;
 543
 544   void SetAcquireFence(mozilla::ipc::FileDescriptor&& aFenceFd) override;
 545
 546   void SetReleaseFence(mozilla::ipc::FileDescriptor&& aFenceFd) override;
 547
 548   mozilla::ipc::FileDescriptor GetAndResetReleaseFence() override;
 549
 550   AndroidHardwareBuffer* GetAndroidHardwareBuffer() const override {
 551     return mAndroidHardwareBuffer;
 552   }
 553
 554   bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
 555
 556   // gecko does not need deferred deletion with WebRender
 557   // GPU/hardware task end could be checked by android fence.
 558   bool NeedsDeferredDeletion() const override { return false; }
 559
 560  protected:
 561   RefPtr<AndroidHardwareBuffer> mAndroidHardwareBuffer;
 562 };
 563
 564 #endif  // MOZ_WIDGET_ANDROID
 565
 566 ////////////////////////////////////////////////////////////////////////
 567 // EGLImage
 568
 569 class EGLImageTextureSource : public TextureSource, public TextureSourceOGL {
 570  public:
 571   EGLImageTextureSource(TextureSourceProvider* aProvider, EGLImage aImage,
 572                         gfx::SurfaceFormat aFormat, GLenum aTarget,
 573                         GLenum aWrapMode, gfx::IntSize aSize);
 574
 575   const char* Name() const override { return "EGLImageTextureSource"; }
 576
 577   TextureSourceOGL* AsSourceOGL() override { return this; }
 578
 579   void BindTexture(GLenum activetex,
 580                    gfx::SamplingFilter aSamplingFilter) override;
 581
 582   bool IsValid() const override;
 583
 584   gfx::IntSize GetSize() const override { return mSize; }
 585
 586   gfx::SurfaceFormat GetFormat() const override { return mFormat; }
 587
 588   gfx::Matrix4x4 GetTextureTransform() override;
 589
 590   GLenum GetTextureTarget() const override { return mTextureTarget; }
 591
 592   GLenum GetWrapMode() const override { return mWrapMode; }
 593
 594   // We don't own anything.
 595   void DeallocateDeviceData() override {}
 596
 597   gl::GLContext* gl() const { return mGL; }
 598
 599  protected:
 600   RefPtr<gl::GLContext> mGL;
 601   RefPtr<CompositorOGL> mCompositor;
 602   const EGLImage mImage;
 603   const gfx::SurfaceFormat mFormat;
 604   const GLenum mTextureTarget;
 605   const GLenum mWrapMode;
 606   const gfx::IntSize mSize;
 607 };
 608
 609 class EGLImageTextureHost final : public TextureHost {
 610  public:
 611   EGLImageTextureHost(TextureFlags aFlags, EGLImage aImage, EGLSync aSync,
 612                       gfx::IntSize aSize, bool hasAlpha);
 613
 614   virtual ~EGLImageTextureHost();
 615
 616   // We don't own anything.
 617   void DeallocateDeviceData() override {}
 618
 619   gfx::SurfaceFormat GetFormat() const override;
 620
 621   already_AddRefed<gfx::DataSourceSurface> GetAsSurface(
 622       gfx::DataSourceSurface* aSurface) override {
 623     return nullptr;  // XXX - implement this (for MOZ_DUMP_PAINTING)
 624   }
 625
 626   gl::GLContext* gl() const;
 627
 628   gfx::IntSize GetSize() const override { return mSize; }
 629
 630   const char* Name() override { return "EGLImageTextureHost"; }
 631
 632   void CreateRenderTexture(
 633       const wr::ExternalImageId& aExternalImageId) override;
 634
 635   void PushResourceUpdates(wr::TransactionBuilder& aResources,
 636                            ResourceUpdateOp aOp,
 637                            const Range<wr::ImageKey>& aImageKeys,
 638                            const wr::ExternalImageId& aExtID) override;
 639
 640   void PushDisplayItems(wr::DisplayListBuilder& aBuilder,
 641                         const wr::LayoutRect& aBounds,
 642                         const wr::LayoutRect& aClip, wr::ImageRendering aFilter,
 643                         const Range<wr::ImageKey>& aImageKeys,
 644                         PushDisplayItemFlagSet aFlags) override;
 645
 646   bool SupportsExternalCompositing(WebRenderBackend aBackend) override;
 647
 648  protected:
 649   const EGLImage mImage;
 650   const EGLSync mSync;
 651   const gfx::IntSize mSize;
 652   const bool mHasAlpha;
 653   RefPtr<EGLImageTextureSource> mTextureSource;
 654 };
 655
 656 }  // namespace layers
 657 }  // namespace mozilla
 658
 659 #endif /* MOZILLA_GFX_TEXTUREOGL_H */