gecko-dev/gfx/gl/SharedSurfaceGL.h

271 lines
6.9 KiB
C++

/* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40; -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef SHARED_SURFACE_GL_H_
#define SHARED_SURFACE_GL_H_
#include "SharedSurface.h"
#include "SurfaceFactory.h"
#include "SurfaceTypes.h"
#include "GLContextTypes.h"
#include "nsAutoPtr.h"
#include "gfxASurface.h"
#include "mozilla/Mutex.h"
#include <queue>
// Forwards:
class gfxImageSurface;
namespace mozilla {
namespace gl {
class GLContext;
}
}
namespace mozilla {
namespace gl {
class SurfaceFactory_GL;
class SharedSurface_GL
: public gfx::SharedSurface
{
protected:
typedef class gfx::SharedSurface SharedSurface;
typedef gfx::SharedSurfaceType SharedSurfaceType;
typedef gfx::APITypeT APITypeT;
typedef gfx::AttachmentType AttachmentType;
GLContext* const mGL;
SharedSurface_GL(SharedSurfaceType type,
AttachmentType attachType,
GLContext* gl,
const gfxIntSize& size,
bool hasAlpha)
: SharedSurface(type, APITypeT::OpenGL, attachType, size, hasAlpha)
, mGL(gl)
{}
public:
static void Copy(SharedSurface_GL* src, SharedSurface_GL* dest,
SurfaceFactory_GL* factory);
static SharedSurface_GL* Cast(SharedSurface* surf) {
MOZ_ASSERT(surf->APIType() == APITypeT::OpenGL);
return (SharedSurface_GL*)surf;
}
virtual bool ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type, GLvoid *pixels) {
return false;
}
virtual void LockProd();
virtual void UnlockProd();
GLContext* GL() const {
return mGL;
}
};
class SurfaceFactory_GL
: public gfx::SurfaceFactory
{
protected:
typedef struct gfx::SurfaceCaps SurfaceCaps;
typedef class gfx::SurfaceFactory SurfaceFactory;
typedef class gfx::SharedSurface SharedSurface;
typedef gfx::SharedSurfaceType SharedSurfaceType;
GLContext* const mGL;
const GLFormats mFormats;
SurfaceCaps mDrawCaps;
SurfaceCaps mReadCaps;
// This uses ChooseBufferBits to pick drawBits/readBits.
SurfaceFactory_GL(GLContext* gl,
SharedSurfaceType type,
const SurfaceCaps& caps);
virtual void ChooseBufferBits(const SurfaceCaps& caps,
SurfaceCaps& drawCaps,
SurfaceCaps& readCaps) const;
public:
GLContext* GL() const {
return mGL;
}
const GLFormats& Formats() const {
return mFormats;
}
const SurfaceCaps& DrawCaps() const {
return mDrawCaps;
}
const SurfaceCaps& ReadCaps() const {
return mReadCaps;
}
};
// For readback and bootstrapping:
class SharedSurface_Basic
: public SharedSurface_GL
{
public:
static SharedSurface_Basic* Create(GLContext* gl,
const GLFormats& formats,
const gfxIntSize& size,
bool hasAlpha);
static SharedSurface_Basic* Cast(SharedSurface* surf) {
MOZ_ASSERT(surf->Type() == SharedSurfaceType::Basic);
return (SharedSurface_Basic*)surf;
}
protected:
const GLuint mTex;
nsRefPtr<gfxImageSurface> mData;
SharedSurface_Basic(GLContext* gl,
const gfxIntSize& size,
bool hasAlpha,
gfxASurface::gfxImageFormat format,
GLuint tex);
public:
virtual ~SharedSurface_Basic();
virtual void LockProdImpl() {}
virtual void UnlockProdImpl() {}
virtual void Fence();
virtual bool WaitSync() {
// Since we already store the data in Fence, we're always done already.
return true;
}
virtual GLuint Texture() const {
return mTex;
}
// Implementation-specific functions below:
gfxImageSurface* GetData() {
return mData;
}
};
class SurfaceFactory_Basic
: public SurfaceFactory_GL
{
public:
SurfaceFactory_Basic(GLContext* gl, const SurfaceCaps& caps)
: SurfaceFactory_GL(gl, SharedSurfaceType::Basic, caps)
{}
virtual SharedSurface* CreateShared(const gfxIntSize& size) {
bool hasAlpha = mReadCaps.alpha;
return SharedSurface_Basic::Create(mGL, mFormats, size, hasAlpha);
}
};
// Using shared GL textures:
class SharedSurface_GLTexture
: public SharedSurface_GL
{
public:
static SharedSurface_GLTexture* Create(GLContext* prodGL,
GLContext* consGL,
const GLFormats& formats,
const gfxIntSize& size,
bool hasAlpha);
static SharedSurface_GLTexture* Cast(SharedSurface* surf) {
MOZ_ASSERT(surf->Type() == SharedSurfaceType::GLTextureShare);
return (SharedSurface_GLTexture*)surf;
}
protected:
GLContext* mConsGL;
const GLuint mTex;
GLsync mSync;
mutable Mutex mMutex;
SharedSurface_GLTexture(GLContext* prodGL,
GLContext* consGL,
const gfxIntSize& size,
bool hasAlpha,
GLuint tex)
: SharedSurface_GL(SharedSurfaceType::GLTextureShare,
AttachmentType::GLTexture,
prodGL,
size,
hasAlpha)
, mConsGL(consGL)
, mTex(tex)
, mSync(0)
, mMutex("SharedSurface_GLTexture mutex")
{
}
public:
virtual ~SharedSurface_GLTexture();
virtual void LockProdImpl() {}
virtual void UnlockProdImpl() {}
virtual void Fence();
virtual bool WaitSync();
virtual GLuint Texture() const {
return mTex;
}
// Custom:
void SetConsumerGL(GLContext* consGL);
};
class SurfaceFactory_GLTexture
: public SurfaceFactory_GL
{
protected:
GLContext* const mConsGL;
public:
// If we don't know `consGL` at construction time, use `nullptr`, and call
// `SetConsumerGL()` on each `SharedSurface_GLTexture` before calling its
// `WaitSync()`.
SurfaceFactory_GLTexture(GLContext* prodGL,
GLContext* consGL,
const SurfaceCaps& caps)
: SurfaceFactory_GL(prodGL, SharedSurfaceType::GLTextureShare, caps)
, mConsGL(consGL)
{
MOZ_ASSERT(consGL != prodGL);
}
virtual SharedSurface* CreateShared(const gfxIntSize& size) {
bool hasAlpha = mReadCaps.alpha;
return SharedSurface_GLTexture::Create(mGL, mConsGL, mFormats, size, hasAlpha);
}
};
} /* namespace gfx */
} /* namespace mozilla */
#endif /* SHARED_SURFACE_GL_H_ */