Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-23 21:01:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1716559 - Remove TextureImageEGL. r=jnicol,jgilbert

Browse Source 
TextureImageEGL doesn't seem to provide any value beyond
BasicTextureImage. It's last usage was bug 814159.

Removing this has the side effect of using BasicTextureImage
for small images instead of always using TilingTextureImage.

Differential Revision: https://phabricator.services.mozilla.com/D117904
This commit is contained in:
Jeff Muizelaar 2021-06-15 21:10:47 +00:00
parent e61c7435cc
commit a7817816b7
6 changed files with 11 additions and 327 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
gfx/gl/GLContextEGL.h
View File

@ -36,7 +36,6 @@ inline std::shared_ptr<EglDisplay> DefaultEglDisplay(
// -
class GLContextEGL final : public GLContext {
friend class TextureImageEGL;
public:
MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(GLContextEGL, override)

1
gfx/gl/GLContextProviderEGL.cpp
View File

@ -74,7 +74,6 @@
#include "nsIWidget.h"
#include "nsThreadUtils.h"
#include "ScopedGLHelpers.h"
#include "TextureImageEGL.h"
#if defined(MOZ_WIDGET_GTK)
# include "mozilla/widget/GtkCompositorWidget.h"

36
gfx/gl/GLTextureImage.cpp
View File

@ -14,8 +14,6 @@
#include "GLUploadHelpers.h"
#include "GfxTexturesReporter.h"
#include "TextureImageEGL.h"
using namespace mozilla::gfx;
namespace mozilla {
@ -25,36 +23,24 @@ already_AddRefed<TextureImage> CreateTextureImage(
GLContext* gl, const gfx::IntSize& aSize,
TextureImage::ContentType aContentType, GLenum aWrapMode,
TextureImage::Flags aFlags, TextureImage::ImageFormat aImageFormat) {
switch (gl->GetContextType()) {
case GLContextType::EGL:
return CreateTextureImageEGL(gl, aSize, aContentType, aWrapMode, aFlags,
GLint maxTextureSize;
gl->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE, &maxTextureSize);
if (aSize.width > maxTextureSize || aSize.height > maxTextureSize) {
NS_ASSERTION(aWrapMode == LOCAL_GL_CLAMP_TO_EDGE,
"Can't support wrapping with tiles!");
return CreateTiledTextureImage(gl, aSize, aContentType, aFlags,
aImageFormat);
default: {
GLint maxTextureSize;
gl->fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE, &maxTextureSize);
if (aSize.width > maxTextureSize || aSize.height > maxTextureSize) {
NS_ASSERTION(aWrapMode == LOCAL_GL_CLAMP_TO_EDGE,
"Can't support wrapping with tiles!");
return CreateTiledTextureImage(gl, aSize, aContentType, aFlags,
aImageFormat);
} else {
return CreateBasicTextureImage(gl, aSize, aContentType, aWrapMode,
aFlags);
}
}
} else {
return CreateBasicTextureImage(gl, aSize, aContentType, aWrapMode,
aFlags);
}
}
static already_AddRefed<TextureImage> TileGenFunc(
GLContext* gl, const IntSize& aSize, TextureImage::ContentType aContentType,
TextureImage::Flags aFlags, TextureImage::ImageFormat aImageFormat) {
switch (gl->GetContextType()) {
case GLContextType::EGL:
return TileGenFuncEGL(gl, aSize, aContentType, aFlags, aImageFormat);
default:
return CreateBasicTextureImage(gl, aSize, aContentType,
LOCAL_GL_CLAMP_TO_EDGE, aFlags);
}
return CreateBasicTextureImage(gl, aSize, aContentType,
LOCAL_GL_CLAMP_TO_EDGE, aFlags);
}
already_AddRefed<TextureImage> TextureImage::Create(

220
gfx/gl/TextureImageEGL.cpp
View File

@ -1,220 +0,0 @@
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
#include "TextureImageEGL.h"
#include "GLLibraryEGL.h"
#include "GLContext.h"
#include "GLContextEGL.h"
#include "GLUploadHelpers.h"
#include "gfxPlatform.h"
#include "mozilla/gfx/Types.h"
namespace mozilla {
namespace gl {
static GLenum GLFormatForImage(gfx::SurfaceFormat aFormat) {
switch (aFormat) {
case gfx::SurfaceFormat::B8G8R8A8:
case gfx::SurfaceFormat::B8G8R8X8:
return LOCAL_GL_RGBA;
case gfx::SurfaceFormat::R5G6B5_UINT16:
return LOCAL_GL_RGB;
case gfx::SurfaceFormat::A8:
return LOCAL_GL_LUMINANCE;
default:
NS_WARNING("Unknown GL format for Surface format");
}
return 0;
}
static GLenum GLTypeForImage(gfx::SurfaceFormat aFormat) {
switch (aFormat) {
case gfx::SurfaceFormat::B8G8R8A8:
case gfx::SurfaceFormat::B8G8R8X8:
case gfx::SurfaceFormat::A8:
return LOCAL_GL_UNSIGNED_BYTE;
case gfx::SurfaceFormat::R5G6B5_UINT16:
return LOCAL_GL_UNSIGNED_SHORT_5_6_5;
default:
NS_WARNING("Unknown GL format for Surface format");
}
return 0;
}
TextureImageEGL::TextureImageEGL(GLuint aTexture, const gfx::IntSize& aSize,
GLenum aWrapMode, ContentType aContentType,
GLContext* aContext, Flags aFlags,
TextureState aTextureState,
TextureImage::ImageFormat aImageFormat)
: TextureImage(aSize, aWrapMode, aContentType, aFlags),
mGLContext(aContext),
mUpdateFormat(gfx::ImageFormatToSurfaceFormat(aImageFormat)),
mEGLImage(nullptr),
mTexture(aTexture),
mSurface(nullptr),
mConfig(nullptr),
mTextureState(aTextureState),
mBound(false) {
if (mUpdateFormat == gfx::SurfaceFormat::UNKNOWN) {
mUpdateFormat =
gfxPlatform::GetPlatform()->Optimal2DFormatForContent(GetContentType());
}
if (mUpdateFormat == gfx::SurfaceFormat::R5G6B5_UINT16) {
mTextureFormat = gfx::SurfaceFormat::R8G8B8X8;
} else if (mUpdateFormat == gfx::SurfaceFormat::B8G8R8X8) {
mTextureFormat = gfx::SurfaceFormat::B8G8R8X8;
} else {
mTextureFormat = gfx::SurfaceFormat::B8G8R8A8;
}
}
TextureImageEGL::~TextureImageEGL() {
if (mGLContext->IsDestroyed() || !mGLContext->IsOwningThreadCurrent()) {
return;
}
// If we have a context, then we need to delete the texture;
// if we don't have a context (either real or shared),
// then they went away when the contex was deleted, because it
// was the only one that had access to it.
if (mGLContext->MakeCurrent()) {
mGLContext->fDeleteTextures(1, &mTexture);
}
ReleaseTexImage();
DestroyEGLSurface();
}
bool TextureImageEGL::DirectUpdate(
gfx::DataSourceSurface* aSurf, const nsIntRegion& aRegion,
const gfx::IntPoint& aFrom /* = gfx::IntPoint(0,0) */) {
gfx::IntRect bounds = aRegion.GetBounds();
nsIntRegion region;
if (mTextureState != Valid) {
bounds = gfx::IntRect(0, 0, mSize.width, mSize.height);
region = nsIntRegion(bounds);
} else {
region = aRegion;
}
bool needInit = mTextureState == Created;
size_t uploadSize = 0;
mTextureFormat = UploadSurfaceToTexture(mGLContext, aSurf, region, mTexture,
mSize, &uploadSize, needInit, aFrom);
if (mTextureFormat == gfx::SurfaceFormat::UNKNOWN) {
return false;
}
if (uploadSize > 0) {
UpdateUploadSize(uploadSize);
}
mTextureState = Valid;
return true;
}
void TextureImageEGL::BindTexture(GLenum aTextureUnit) {
// Ensure the texture is allocated before it is used.
if (mTextureState == Created) {
Resize(mSize);
}
mGLContext->fActiveTexture(aTextureUnit);
mGLContext->fBindTexture(LOCAL_GL_TEXTURE_2D, mTexture);
mGLContext->fActiveTexture(LOCAL_GL_TEXTURE0);
}
void TextureImageEGL::Resize(const gfx::IntSize& aSize) {
if (mSize == aSize && mTextureState != Created) return;
mGLContext->fBindTexture(LOCAL_GL_TEXTURE_2D, mTexture);
mGLContext->fTexImage2D(LOCAL_GL_TEXTURE_2D, 0,
GLFormatForImage(mUpdateFormat), aSize.width,
aSize.height, 0, GLFormatForImage(mUpdateFormat),
GLTypeForImage(mUpdateFormat), nullptr);
mTextureState = Allocated;
mSize = aSize;
}
bool TextureImageEGL::BindTexImage() {
if (mBound && !ReleaseTexImage()) return false;
const auto& gle = GLContextEGL::Cast(mGLContext);
const auto& egl = gle->mEgl;
EGLBoolean success =
egl->fBindTexImage((EGLSurface)mSurface, LOCAL_EGL_BACK_BUFFER);
if (success == LOCAL_EGL_FALSE) return false;
mBound = true;
return true;
}
bool TextureImageEGL::ReleaseTexImage() {
if (!mBound) return true;
const auto& gle = GLContextEGL::Cast(mGLContext);
const auto& egl = gle->mEgl;
EGLBoolean success =
egl->fReleaseTexImage((EGLSurface)mSurface, LOCAL_EGL_BACK_BUFFER);
if (success == LOCAL_EGL_FALSE) return false;
mBound = false;
return true;
}
void TextureImageEGL::DestroyEGLSurface(void) {
if (!mSurface) return;
const auto& gle = GLContextEGL::Cast(mGLContext);
const auto& egl = gle->mEgl;
egl->fDestroySurface(mSurface);
mSurface = nullptr;
}
already_AddRefed<TextureImage> CreateTextureImageEGL(
GLContext* gl, const gfx::IntSize& aSize,
TextureImage::ContentType aContentType, GLenum aWrapMode,
TextureImage::Flags aFlags, TextureImage::ImageFormat aImageFormat) {
RefPtr<TextureImage> t =
new gl::TiledTextureImage(gl, aSize, aContentType, aFlags, aImageFormat);
return t.forget();
}
already_AddRefed<TextureImage> TileGenFuncEGL(
GLContext* gl, const gfx::IntSize& aSize,
TextureImage::ContentType aContentType, TextureImage::Flags aFlags,
TextureImage::ImageFormat aImageFormat) {
gl->MakeCurrent();
GLuint texture;
gl->fGenTextures(1, &texture);
RefPtr<TextureImageEGL> teximage =
new TextureImageEGL(texture, aSize, LOCAL_GL_CLAMP_TO_EDGE, aContentType,
gl, aFlags, TextureImage::Created, aImageFormat);
teximage->BindTexture(LOCAL_GL_TEXTURE0);
GLint texfilter = aFlags & TextureImage::UseNearestFilter ? LOCAL_GL_NEAREST
: LOCAL_GL_LINEAR;
gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MIN_FILTER,
texfilter);
gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MAG_FILTER,
texfilter);
gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_S,
LOCAL_GL_CLAMP_TO_EDGE);
gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_T,
LOCAL_GL_CLAMP_TO_EDGE);
return teximage.forget();
}
} // namespace gl
} // namespace mozilla

79
gfx/gl/TextureImageEGL.h
View File

@ -1,79 +0,0 @@
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 TEXTUREIMAGEEGL_H_
#define TEXTUREIMAGEEGL_H_
#include "GLTextureImage.h"
#include "mozilla/gfx/Types.h"
namespace mozilla {
namespace gl {
class TextureImageEGL final : public TextureImage {
public:
TextureImageEGL(
GLuint aTexture, const gfx::IntSize& aSize, GLenum aWrapMode,
ContentType aContentType, GLContext* aContext,
Flags aFlags = TextureImage::NoFlags,
TextureState aTextureState = Created,
TextureImage::ImageFormat aImageFormat = gfx::SurfaceFormat::UNKNOWN);
virtual ~TextureImageEGL();
virtual bool DirectUpdate(
gfx::DataSourceSurface* aSurf, const nsIntRegion& aRegion,
const gfx::IntPoint& aFrom = gfx::IntPoint(0, 0)) override;
virtual void BindTexture(GLenum aTextureUnit) override;
virtual GLuint GetTextureID() override {
// Ensure the texture is allocated before it is used.
if (mTextureState == Created) {
Resize(mSize);
}
return mTexture;
};
virtual void Resize(const gfx::IntSize& aSize) override;
bool BindTexImage();
bool ReleaseTexImage();
virtual bool CreateEGLSurface(gfxASurface* aSurface) { return false; }
virtual void DestroyEGLSurface(void);
protected:
typedef gfxImageFormat ImageFormat;
GLContext* mGLContext;
gfx::SurfaceFormat mUpdateFormat;
EGLImage mEGLImage;
GLuint mTexture;
EGLSurface mSurface;
EGLConfig mConfig;
TextureState mTextureState;
bool mBound;
};
already_AddRefed<TextureImage> CreateTextureImageEGL(
GLContext* gl, const gfx::IntSize& aSize,
TextureImage::ContentType aContentType, GLenum aWrapMode,
TextureImage::Flags aFlags, TextureImage::ImageFormat aImageFormat);
already_AddRefed<TextureImage> TileGenFuncEGL(
GLContext* gl, const gfx::IntSize& aSize,
TextureImage::ContentType aContentType, TextureImage::Flags aFlags,
TextureImage::ImageFormat aImageFormat);
} // namespace gl
} // namespace mozilla
#endif // TEXTUREIMAGEEGL_H_

1
gfx/gl/moz.build
View File

@ -138,7 +138,6 @@ UNIFIED_SOURCES += [
"SharedSurface.cpp",
"SharedSurfaceEGL.cpp",
"SharedSurfaceGL.cpp",
"TextureImageEGL.cpp",
]
SOURCES += [
"GLScreenBuffer.cpp",