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