mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-12 09:01:16 +00:00
271 lines
6.9 KiB
C++
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_ */
|