gfx/gl/SharedSurfaceGL.h

   1 /* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40; -*- */
   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/. */
   5
   6 #ifndef SHARED_SURFACE_GL_H_
   7 #define SHARED_SURFACE_GL_H_
   8
   9 #include "ScopedGLHelpers.h"
  10 #include "SharedSurface.h"
  11 #include "SurfaceTypes.h"
  12 #include "GLContextTypes.h"
  13 #include "nsAutoPtr.h"
  14 #include "gfxTypes.h"
  15 #include "mozilla/Mutex.h"
  16
  17 #include <queue>
  18
  19 // Forwards:
  20 namespace mozilla {
  21     namespace gl {
  22         class GLContext;
  23     }
  24     namespace gfx {
  25         class DataSourceSurface;
  26     }
  27 }
  28
  29 namespace mozilla {
  30 namespace gl {
  31
  32 // For readback and bootstrapping:
  33 class SharedSurface_Basic
  34     : public SharedSurface
  35 {
  36 public:
  37     static UniquePtr<SharedSurface_Basic> Create(GLContext* gl,
  38                                                  const GLFormats& formats,
  39                                                  const gfx::IntSize& size,
  40                                                  bool hasAlpha);
  41
  42     static SharedSurface_Basic* Cast(SharedSurface* surf) {
  43         MOZ_ASSERT(surf->mType == SharedSurfaceType::Basic);
  44
  45         return (SharedSurface_Basic*)surf;
  46     }
  47
  48 protected:
  49     const GLuint mTex;
  50     GLuint mFB;
  51
  52     RefPtr<gfx::DataSourceSurface> mData;
  53
  54     SharedSurface_Basic(GLContext* gl,
  55                         const gfx::IntSize& size,
  56                         bool hasAlpha,
  57                         gfx::SurfaceFormat format,
  58                         GLuint tex);
  59
  60 public:
  61     virtual ~SharedSurface_Basic();
  62
  63     virtual void LockProdImpl() MOZ_OVERRIDE {}
  64     virtual void UnlockProdImpl() MOZ_OVERRIDE {}
  65
  66
  67     virtual void Fence() MOZ_OVERRIDE;
  68
  69     virtual bool WaitSync() MOZ_OVERRIDE {
  70         // Since we already store the data in Fence, we're always done already.
  71         return true;
  72     }
  73     virtual bool PollSync() MOZ_OVERRIDE { return true; }
  74
  75     virtual GLuint ProdTexture() MOZ_OVERRIDE {
  76         return mTex;
  77     }
  78
  79     // Implementation-specific functions below:
  80     gfx::DataSourceSurface* GetData() {
  81         return mData;
  82     }
  83 };
  84
  85 class SurfaceFactory_Basic
  86     : public SurfaceFactory
  87 {
  88 public:
  89     SurfaceFactory_Basic(GLContext* gl, const SurfaceCaps& caps)
  90         : SurfaceFactory(gl, SharedSurfaceType::Basic, caps)
  91     {}
  92
  93     virtual UniquePtr<SharedSurface> CreateShared(const gfx::IntSize& size) MOZ_OVERRIDE {
  94         bool hasAlpha = mReadCaps.alpha;
  95         return SharedSurface_Basic::Create(mGL, mFormats, size, hasAlpha);
  96     }
  97 };
  98
  99
 100 // Using shared GL textures:
 101 class SharedSurface_GLTexture
 102     : public SharedSurface
 103 {
 104 public:
 105     static UniquePtr<SharedSurface_GLTexture> Create(GLContext* prodGL,
 106                                                      GLContext* consGL,
 107                                                      const GLFormats& formats,
 108                                                      const gfx::IntSize& size,
 109                                                      bool hasAlpha,
 110                                                      GLuint texture = 0);
 111
 112     static SharedSurface_GLTexture* Cast(SharedSurface* surf) {
 113         MOZ_ASSERT(surf->mType == SharedSurfaceType::GLTextureShare);
 114
 115         return (SharedSurface_GLTexture*)surf;
 116     }
 117
 118 protected:
 119     GLContext* mConsGL;
 120     const GLuint mTex;
 121     const bool mOwnsTex;
 122     GLsync mSync;
 123     mutable Mutex mMutex;
 124
 125     SharedSurface_GLTexture(GLContext* prodGL,
 126                             GLContext* consGL,
 127                             const gfx::IntSize& size,
 128                             bool hasAlpha,
 129                             GLuint tex,
 130                             bool ownsTex)
 131         : SharedSurface(SharedSurfaceType::GLTextureShare,
 132                         AttachmentType::GLTexture,
 133                         prodGL,
 134                         size,
 135                         hasAlpha)
 136         , mConsGL(consGL)
 137         , mTex(tex)
 138         , mOwnsTex(ownsTex)
 139         , mSync(0)
 140         , mMutex("SharedSurface_GLTexture mutex")
 141     {
 142     }
 143
 144 public:
 145     virtual ~SharedSurface_GLTexture();
 146
 147     virtual void LockProdImpl() MOZ_OVERRIDE {}
 148     virtual void UnlockProdImpl() MOZ_OVERRIDE {}
 149
 150     virtual void Fence() MOZ_OVERRIDE;
 151     virtual bool WaitSync() MOZ_OVERRIDE;
 152     virtual bool PollSync() MOZ_OVERRIDE;
 153
 154     virtual GLuint ProdTexture() MOZ_OVERRIDE {
 155         return mTex;
 156     }
 157
 158     // Custom:
 159
 160     GLuint ConsTexture(GLContext* consGL);
 161
 162     GLenum ConsTextureTarget() const {
 163         return ProdTextureTarget();
 164     }
 165 };
 166
 167 class SurfaceFactory_GLTexture
 168     : public SurfaceFactory
 169 {
 170 protected:
 171     GLContext* const mConsGL;
 172
 173 public:
 174     // If we don't know `consGL` at construction time, use `nullptr`, and call
 175     // `SetConsumerGL()` on each `SharedSurface_GLTexture` before calling its
 176     // `WaitSync()`.
 177     SurfaceFactory_GLTexture(GLContext* prodGL,
 178                              GLContext* consGL,
 179                              const SurfaceCaps& caps)
 180         : SurfaceFactory(prodGL, SharedSurfaceType::GLTextureShare, caps)
 181         , mConsGL(consGL)
 182     {
 183         MOZ_ASSERT(consGL != prodGL);
 184     }
 185
 186     virtual UniquePtr<SharedSurface> CreateShared(const gfx::IntSize& size) MOZ_OVERRIDE {
 187         bool hasAlpha = mReadCaps.alpha;
 188         return SharedSurface_GLTexture::Create(mGL, mConsGL, mFormats, size, hasAlpha);
 189     }
 190 };
 191
 192 } /* namespace gfx */
 193 } /* namespace mozilla */
 194
 195 #endif /* SHARED_SURFACE_GL_H_ */