summaryrefslogtreecommitdiffstats
path: root/gfx/gl/GLContext.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /gfx/gl/GLContext.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'gfx/gl/GLContext.cpp')
-rw-r--r--gfx/gl/GLContext.cpp3150
1 files changed, 3150 insertions, 0 deletions
diff --git a/gfx/gl/GLContext.cpp b/gfx/gl/GLContext.cpp
new file mode 100644
index 000000000..23090ef98
--- /dev/null
+++ b/gfx/gl/GLContext.cpp
@@ -0,0 +1,3150 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim: set ts=8 sts=4 et sw=4 tw=80: */
+/* 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 "GLContext.h"
+
+#include <algorithm>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <vector>
+#ifdef MOZ_WIDGET_ANDROID
+#include <sys/mman.h>
+#endif
+
+#include "GLBlitHelper.h"
+#include "GLReadTexImageHelper.h"
+#include "GLScreenBuffer.h"
+
+#include "gfxCrashReporterUtils.h"
+#include "gfxEnv.h"
+#include "gfxUtils.h"
+#include "GLContextProvider.h"
+#include "GLTextureImage.h"
+#include "nsPrintfCString.h"
+#include "nsThreadUtils.h"
+#include "prenv.h"
+#include "prlink.h"
+#include "ScopedGLHelpers.h"
+#include "SharedSurfaceGL.h"
+#include "GfxTexturesReporter.h"
+#include "TextureGarbageBin.h"
+#include "gfx2DGlue.h"
+#include "gfxPrefs.h"
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/gfx/Logging.h"
+
+#include "OGLShaderProgram.h" // for ShaderProgramType
+
+#include "mozilla/DebugOnly.h"
+
+#ifdef XP_MACOSX
+#include <CoreServices/CoreServices.h>
+#endif
+
+#if defined(MOZ_WIDGET_COCOA)
+#include "nsCocoaFeatures.h"
+#endif
+
+#ifdef MOZ_WIDGET_ANDROID
+#include "AndroidBridge.h"
+#endif
+
+namespace mozilla {
+namespace gl {
+
+using namespace mozilla::gfx;
+using namespace mozilla::layers;
+
+#ifdef MOZ_GL_DEBUG
+unsigned GLContext::sCurrentGLContextTLS = -1;
+#endif
+
+// If adding defines, don't forget to undefine symbols. See #undef block below.
+#define CORE_SYMBOL(x) { (PRFuncPtr*) &mSymbols.f##x, { #x, nullptr } }
+#define CORE_EXT_SYMBOL2(x,y,z) { (PRFuncPtr*) &mSymbols.f##x, { #x, #x #y, #x #z, nullptr } }
+#define EXT_SYMBOL2(x,y,z) { (PRFuncPtr*) &mSymbols.f##x, { #x #y, #x #z, nullptr } }
+#define EXT_SYMBOL3(x,y,z,w) { (PRFuncPtr*) &mSymbols.f##x, { #x #y, #x #z, #x #w, nullptr } }
+#define END_SYMBOLS { nullptr, { nullptr } }
+
+// should match the order of GLExtensions, and be null-terminated.
+static const char* const sExtensionNames[] = {
+ "NO_EXTENSION",
+ "GL_AMD_compressed_ATC_texture",
+ "GL_ANGLE_depth_texture",
+ "GL_ANGLE_framebuffer_blit",
+ "GL_ANGLE_framebuffer_multisample",
+ "GL_ANGLE_instanced_arrays",
+ "GL_ANGLE_texture_compression_dxt3",
+ "GL_ANGLE_texture_compression_dxt5",
+ "GL_ANGLE_timer_query",
+ "GL_APPLE_client_storage",
+ "GL_APPLE_framebuffer_multisample",
+ "GL_APPLE_sync",
+ "GL_APPLE_texture_range",
+ "GL_APPLE_vertex_array_object",
+ "GL_ARB_ES2_compatibility",
+ "GL_ARB_ES3_compatibility",
+ "GL_ARB_color_buffer_float",
+ "GL_ARB_copy_buffer",
+ "GL_ARB_depth_texture",
+ "GL_ARB_draw_buffers",
+ "GL_ARB_draw_instanced",
+ "GL_ARB_framebuffer_object",
+ "GL_ARB_framebuffer_sRGB",
+ "GL_ARB_geometry_shader4",
+ "GL_ARB_half_float_pixel",
+ "GL_ARB_instanced_arrays",
+ "GL_ARB_internalformat_query",
+ "GL_ARB_invalidate_subdata",
+ "GL_ARB_map_buffer_range",
+ "GL_ARB_occlusion_query2",
+ "GL_ARB_pixel_buffer_object",
+ "GL_ARB_robustness",
+ "GL_ARB_sampler_objects",
+ "GL_ARB_seamless_cube_map",
+ "GL_ARB_shader_texture_lod",
+ "GL_ARB_sync",
+ "GL_ARB_texture_compression",
+ "GL_ARB_texture_float",
+ "GL_ARB_texture_non_power_of_two",
+ "GL_ARB_texture_rectangle",
+ "GL_ARB_texture_rg",
+ "GL_ARB_texture_storage",
+ "GL_ARB_texture_swizzle",
+ "GL_ARB_timer_query",
+ "GL_ARB_transform_feedback2",
+ "GL_ARB_uniform_buffer_object",
+ "GL_ARB_vertex_array_object",
+ "GL_EXT_bgra",
+ "GL_EXT_blend_minmax",
+ "GL_EXT_color_buffer_float",
+ "GL_EXT_color_buffer_half_float",
+ "GL_EXT_copy_texture",
+ "GL_EXT_disjoint_timer_query",
+ "GL_EXT_draw_buffers",
+ "GL_EXT_draw_buffers2",
+ "GL_EXT_draw_instanced",
+ "GL_EXT_draw_range_elements",
+ "GL_EXT_frag_depth",
+ "GL_EXT_framebuffer_blit",
+ "GL_EXT_framebuffer_multisample",
+ "GL_EXT_framebuffer_object",
+ "GL_EXT_framebuffer_sRGB",
+ "GL_EXT_gpu_shader4",
+ "GL_EXT_multisampled_render_to_texture",
+ "GL_EXT_occlusion_query_boolean",
+ "GL_EXT_packed_depth_stencil",
+ "GL_EXT_read_format_bgra",
+ "GL_EXT_robustness",
+ "GL_EXT_sRGB",
+ "GL_EXT_sRGB_write_control",
+ "GL_EXT_shader_texture_lod",
+ "GL_EXT_texture3D",
+ "GL_EXT_texture_compression_dxt1",
+ "GL_EXT_texture_compression_s3tc",
+ "GL_EXT_texture_filter_anisotropic",
+ "GL_EXT_texture_format_BGRA8888",
+ "GL_EXT_texture_sRGB",
+ "GL_EXT_texture_storage",
+ "GL_EXT_timer_query",
+ "GL_EXT_transform_feedback",
+ "GL_EXT_unpack_subimage",
+ "GL_IMG_read_format",
+ "GL_IMG_texture_compression_pvrtc",
+ "GL_IMG_texture_npot",
+ "GL_KHR_debug",
+ "GL_NV_draw_instanced",
+ "GL_NV_fence",
+ "GL_NV_framebuffer_blit",
+ "GL_NV_geometry_program4",
+ "GL_NV_half_float",
+ "GL_NV_instanced_arrays",
+ "GL_NV_primitive_restart",
+ "GL_NV_texture_barrier",
+ "GL_NV_transform_feedback",
+ "GL_NV_transform_feedback2",
+ "GL_OES_EGL_image",
+ "GL_OES_EGL_image_external",
+ "GL_OES_EGL_sync",
+ "GL_OES_compressed_ETC1_RGB8_texture",
+ "GL_OES_depth24",
+ "GL_OES_depth32",
+ "GL_OES_depth_texture",
+ "GL_OES_element_index_uint",
+ "GL_OES_framebuffer_object",
+ "GL_OES_packed_depth_stencil",
+ "GL_OES_rgb8_rgba8",
+ "GL_OES_standard_derivatives",
+ "GL_OES_stencil8",
+ "GL_OES_texture_3D",
+ "GL_OES_texture_float",
+ "GL_OES_texture_float_linear",
+ "GL_OES_texture_half_float",
+ "GL_OES_texture_half_float_linear",
+ "GL_OES_texture_npot",
+ "GL_OES_vertex_array_object"
+};
+
+static bool
+ParseGLSLVersion(GLContext* gl, uint32_t* out_version)
+{
+ if (gl->fGetError() != LOCAL_GL_NO_ERROR) {
+ MOZ_ASSERT(false, "An OpenGL error has been triggered before.");
+ return false;
+ }
+
+ /**
+ * OpenGL 2.x, 3.x, 4.x specifications:
+ * The VERSION and SHADING_LANGUAGE_VERSION strings are laid out as follows:
+ *
+ * <version number><space><vendor-specific information>
+ *
+ * The version number is either of the form major_number.minor_number or
+ * major_number.minor_number.release_number, where the numbers all have
+ * one or more digits.
+ *
+ * SHADING_LANGUAGE_VERSION is *almost* identical to VERSION. The
+ * difference is that the minor version always has two digits and the
+ * prefix has an additional 'GLSL ES'
+ *
+ *
+ * OpenGL ES 2.0, 3.0 specifications:
+ * The VERSION string is laid out as follows:
+ *
+ * "OpenGL ES N.M vendor-specific information"
+ *
+ * The version number is either of the form major_number.minor_number or
+ * major_number.minor_number.release_number, where the numbers all have
+ * one or more digits.
+ *
+ *
+ * Note:
+ * We don't care about release_number.
+ */
+ const char* versionString = (const char*) gl->fGetString(LOCAL_GL_SHADING_LANGUAGE_VERSION);
+
+ if (gl->fGetError() != LOCAL_GL_NO_ERROR) {
+ MOZ_ASSERT(false, "glGetString(GL_SHADING_LANGUAGE_VERSION) has generated an error");
+ return false;
+ }
+
+ if (!versionString) {
+ // This happens on the Android emulators. We'll just return 100
+ *out_version = 100;
+ return true;
+ }
+
+ const auto fnSkipPrefix = [&versionString](const char* prefix) {
+ const auto len = strlen(prefix);
+ if (strncmp(versionString, prefix, len) == 0)
+ versionString += len;
+ };
+
+ const char kGLESVersionPrefix[] = "OpenGL ES GLSL ES";
+ fnSkipPrefix(kGLESVersionPrefix);
+
+ if (gl->WorkAroundDriverBugs()) {
+ // Nexus 7 2013 (bug 1234441)
+ const char kBadGLESVersionPrefix[] = "OpenGL ES GLSL";
+ fnSkipPrefix(kBadGLESVersionPrefix);
+ }
+
+ const char* itr = versionString;
+ char* end = nullptr;
+ auto majorVersion = strtol(itr, &end, 10);
+
+ if (!end) {
+ MOZ_ASSERT(false, "Failed to parse the GL major version number.");
+ return false;
+ }
+
+ if (*end != '.') {
+ MOZ_ASSERT(false, "Failed to parse GL's major-minor version number separator.");
+ return false;
+ }
+
+ // we skip the '.' between the major and the minor version
+ itr = end + 1;
+ end = nullptr;
+
+ auto minorVersion = strtol(itr, &end, 10);
+ if (!end) {
+ MOZ_ASSERT(false, "Failed to parse GL's minor version number.");
+ return false;
+ }
+
+ if (majorVersion <= 0 || majorVersion >= 100) {
+ MOZ_ASSERT(false, "Invalid major version.");
+ return false;
+ }
+
+ if (minorVersion < 0 || minorVersion >= 100) {
+ MOZ_ASSERT(false, "Invalid minor version.");
+ return false;
+ }
+
+ *out_version = (uint32_t) majorVersion * 100 + (uint32_t) minorVersion;
+ return true;
+}
+
+static bool
+ParseGLVersion(GLContext* gl, uint32_t* out_version)
+{
+ if (gl->fGetError() != LOCAL_GL_NO_ERROR) {
+ MOZ_ASSERT(false, "An OpenGL error has been triggered before.");
+ return false;
+ }
+
+ /**
+ * B2G emulator bug work around: The emulator implements OpenGL ES 2.0 on
+ * OpenGL 3.2. The bug is that GetIntegerv(LOCAL_GL_{MAJOR,MINOR}_VERSION)
+ * returns OpenGL 3.2 instead of generating an error.
+ */
+ if (!gl->IsGLES()) {
+ /**
+ * OpenGL 3.1 and OpenGL ES 3.0 both introduce GL_{MAJOR,MINOR}_VERSION
+ * with GetIntegerv. So we first try those constants even though we
+ * might not have an OpenGL context supporting them, as this is a
+ * better way than parsing GL_VERSION.
+ */
+ GLint majorVersion = 0;
+ GLint minorVersion = 0;
+
+ const bool ok = (gl->GetPotentialInteger(LOCAL_GL_MAJOR_VERSION,
+ &majorVersion) &&
+ gl->GetPotentialInteger(LOCAL_GL_MINOR_VERSION,
+ &minorVersion));
+
+ // If it's not an OpenGL (ES) 3.0 context, we will have an error
+ if (ok &&
+ majorVersion > 0 &&
+ minorVersion >= 0)
+ {
+ *out_version = majorVersion * 100 + minorVersion * 10;
+ return true;
+ }
+ }
+
+ /**
+ * We were not able to use GL_{MAJOR,MINOR}_VERSION, so we parse
+ * GL_VERSION.
+ *
+ *
+ * OpenGL 2.x, 3.x, 4.x specifications:
+ * The VERSION and SHADING_LANGUAGE_VERSION strings are laid out as follows:
+ *
+ * <version number><space><vendor-specific information>
+ *
+ * The version number is either of the form major_number.minor_number or
+ * major_number.minor_number.release_number, where the numbers all have
+ * one or more digits.
+ *
+ *
+ * OpenGL ES 2.0, 3.0 specifications:
+ * The VERSION string is laid out as follows:
+ *
+ * "OpenGL ES N.M vendor-specific information"
+ *
+ * The version number is either of the form major_number.minor_number or
+ * major_number.minor_number.release_number, where the numbers all have
+ * one or more digits.
+ *
+ *
+ * Note:
+ * We don't care about release_number.
+ */
+ const char* versionString = (const char*)gl->fGetString(LOCAL_GL_VERSION);
+
+ if (gl->fGetError() != LOCAL_GL_NO_ERROR) {
+ MOZ_ASSERT(false, "glGetString(GL_VERSION) has generated an error");
+ return false;
+ } else if (!versionString) {
+ MOZ_ASSERT(false, "glGetString(GL_VERSION) has returned 0");
+ return false;
+ }
+
+ const char kGLESVersionPrefix[] = "OpenGL ES ";
+ if (strncmp(versionString, kGLESVersionPrefix, strlen(kGLESVersionPrefix)) == 0) {
+ versionString += strlen(kGLESVersionPrefix);
+ }
+
+ const char* itr = versionString;
+ char* end = nullptr;
+ auto majorVersion = strtol(itr, &end, 10);
+
+ if (!end) {
+ MOZ_ASSERT(false, "Failed to parse the GL major version number.");
+ return false;
+ } else if (*end != '.') {
+ MOZ_ASSERT(false, "Failed to parse GL's major-minor version number separator.");
+ return false;
+ }
+
+ // we skip the '.' between the major and the minor version
+ itr = end + 1;
+
+ end = nullptr;
+
+ auto minorVersion = strtol(itr, &end, 10);
+ if (!end) {
+ MOZ_ASSERT(false, "Failed to parse GL's minor version number.");
+ return false;
+ }
+
+ if (majorVersion <= 0 || majorVersion >= 100) {
+ MOZ_ASSERT(false, "Invalid major version.");
+ return false;
+ } else if (minorVersion < 0 || minorVersion >= 10) {
+ MOZ_ASSERT(false, "Invalid minor version.");
+ return false;
+ }
+
+ *out_version = (uint32_t)majorVersion * 100 + (uint32_t)minorVersion * 10;
+ return true;
+}
+
+static uint8_t
+ChooseDebugFlags(CreateContextFlags createFlags)
+{
+ uint8_t debugFlags = 0;
+
+#ifdef MOZ_GL_DEBUG
+ if (gfxEnv::GlDebug()) {
+ debugFlags |= GLContext::DebugFlagEnabled;
+ }
+
+ // Enables extra verbose output, informing of the start and finish of every GL call.
+ // Useful e.g. to record information to investigate graphics system crashes/lockups
+ if (gfxEnv::GlDebugVerbose()) {
+ debugFlags |= GLContext::DebugFlagTrace;
+ }
+
+ // Aborts on GL error. Can be useful to debug quicker code that is known not to
+ // generate any GL error in principle.
+ bool abortOnError = false;
+
+ if (createFlags & CreateContextFlags::NO_VALIDATION) {
+ abortOnError = true;
+
+ const auto fnStringsMatch = [](const char* a, const char* b) {
+ return strcmp(a, b) == 0;
+ };
+
+ const char* envAbortOnError = PR_GetEnv("MOZ_GL_DEBUG_ABORT_ON_ERROR");
+ if (envAbortOnError && fnStringsMatch(envAbortOnError, "0")) {
+ abortOnError = false;
+ }
+ }
+
+ if (abortOnError) {
+ debugFlags |= GLContext::DebugFlagAbortOnError;
+ }
+#endif
+
+ return debugFlags;
+}
+
+GLContext::GLContext(CreateContextFlags flags, const SurfaceCaps& caps,
+ GLContext* sharedContext, bool isOffscreen)
+ : mIsOffscreen(isOffscreen),
+ mContextLost(false),
+ mVersion(0),
+ mProfile(ContextProfile::Unknown),
+ mShadingLanguageVersion(0),
+ mVendor(GLVendor::Other),
+ mRenderer(GLRenderer::Other),
+ mTopError(LOCAL_GL_NO_ERROR),
+ mDebugFlags(ChooseDebugFlags(flags)),
+ mSharedContext(sharedContext),
+ mCaps(caps),
+ mScreen(nullptr),
+ mLockedSurface(nullptr),
+ mMaxTextureSize(0),
+ mMaxCubeMapTextureSize(0),
+ mMaxTextureImageSize(0),
+ mMaxRenderbufferSize(0),
+ mMaxSamples(0),
+ mNeedsTextureSizeChecks(false),
+ mNeedsFlushBeforeDeleteFB(false),
+ mTextureAllocCrashesOnMapFailure(false),
+ mNeedsCheckAfterAttachTextureToFb(false),
+ mWorkAroundDriverBugs(true),
+ mHeavyGLCallsSinceLastFlush(false)
+{
+ mMaxViewportDims[0] = 0;
+ mMaxViewportDims[1] = 0;
+ mOwningThreadId = PlatformThread::CurrentId();
+}
+
+GLContext::~GLContext() {
+ NS_ASSERTION(IsDestroyed(), "GLContext implementation must call MarkDestroyed in destructor!");
+#ifdef MOZ_GL_DEBUG
+ if (mSharedContext) {
+ GLContext* tip = mSharedContext;
+ while (tip->mSharedContext)
+ tip = tip->mSharedContext;
+ tip->SharedContextDestroyed(this);
+ tip->ReportOutstandingNames();
+ } else {
+ ReportOutstandingNames();
+ }
+#endif
+}
+
+/*static*/ void
+GLContext::StaticDebugCallback(GLenum source,
+ GLenum type,
+ GLuint id,
+ GLenum severity,
+ GLsizei length,
+ const GLchar* message,
+ const GLvoid* userParam)
+{
+ GLContext* gl = (GLContext*)userParam;
+ gl->DebugCallback(source, type, id, severity, length, message);
+}
+
+static void
+ClearSymbols(const GLLibraryLoader::SymLoadStruct* symbols)
+{
+ while (symbols->symPointer) {
+ *symbols->symPointer = nullptr;
+ symbols++;
+ }
+}
+
+bool
+GLContext::InitWithPrefix(const char* prefix, bool trygl)
+{
+ MOZ_RELEASE_ASSERT(!mSymbols.fBindFramebuffer,
+ "GFX: InitWithPrefix should only be called once.");
+
+ ScopedGfxFeatureReporter reporter("GL Context");
+
+ if (!InitWithPrefixImpl(prefix, trygl)) {
+ // If initialization fails, zero the symbols to avoid hard-to-understand bugs.
+ mSymbols.Zero();
+ NS_WARNING("GLContext::InitWithPrefix failed!");
+ return false;
+ }
+
+ reporter.SetSuccessful();
+ return true;
+}
+
+static bool
+LoadGLSymbols(GLContext* gl, const char* prefix, bool trygl,
+ const GLLibraryLoader::SymLoadStruct* list, const char* desc)
+{
+ if (gl->LoadSymbols(list, trygl, prefix))
+ return true;
+
+ ClearSymbols(list);
+
+ if (desc) {
+ const nsPrintfCString err("Failed to load symbols for %s.", desc);
+ NS_ERROR(err.BeginReading());
+ }
+ return false;
+}
+
+bool
+GLContext::LoadExtSymbols(const char* prefix, bool trygl, const SymLoadStruct* list,
+ GLExtensions ext)
+{
+ const char* extName = sExtensionNames[size_t(ext)];
+ if (!LoadGLSymbols(this, prefix, trygl, list, extName)) {
+ MarkExtensionUnsupported(ext);
+ return false;
+ }
+ return true;
+};
+
+bool
+GLContext::LoadFeatureSymbols(const char* prefix, bool trygl, const SymLoadStruct* list,
+ GLFeature feature)
+{
+ const char* featureName = GetFeatureName(feature);
+ if (!LoadGLSymbols(this, prefix, trygl, list, featureName)) {
+ MarkUnsupported(feature);
+ return false;
+ }
+ return true;
+};
+
+bool
+GLContext::InitWithPrefixImpl(const char* prefix, bool trygl)
+{
+ mWorkAroundDriverBugs = gfxPrefs::WorkAroundDriverBugs();
+
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fActiveTexture, { "ActiveTexture", "ActiveTextureARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fAttachShader, { "AttachShader", "AttachShaderARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBindAttribLocation, { "BindAttribLocation", "BindAttribLocationARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBindBuffer, { "BindBuffer", "BindBufferARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBindTexture, { "BindTexture", "BindTextureARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBlendColor, { "BlendColor", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBlendEquation, { "BlendEquation", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBlendEquationSeparate, { "BlendEquationSeparate", "BlendEquationSeparateEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBlendFunc, { "BlendFunc", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBlendFuncSeparate, { "BlendFuncSeparate", "BlendFuncSeparateEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBufferData, { "BufferData", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBufferSubData, { "BufferSubData", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fClear, { "Clear", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fClearColor, { "ClearColor", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fClearStencil, { "ClearStencil", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fColorMask, { "ColorMask", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fCompressedTexImage2D, {"CompressedTexImage2D", nullptr} },
+ { (PRFuncPtr*) &mSymbols.fCompressedTexSubImage2D, {"CompressedTexSubImage2D", nullptr} },
+ { (PRFuncPtr*) &mSymbols.fCullFace, { "CullFace", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDetachShader, { "DetachShader", "DetachShaderARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDepthFunc, { "DepthFunc", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDepthMask, { "DepthMask", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDisable, { "Disable", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDisableVertexAttribArray, { "DisableVertexAttribArray", "DisableVertexAttribArrayARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDrawArrays, { "DrawArrays", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDrawElements, { "DrawElements", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fEnable, { "Enable", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fEnableVertexAttribArray, { "EnableVertexAttribArray", "EnableVertexAttribArrayARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fFinish, { "Finish", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fFlush, { "Flush", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fFrontFace, { "FrontFace", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetActiveAttrib, { "GetActiveAttrib", "GetActiveAttribARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetActiveUniform, { "GetActiveUniform", "GetActiveUniformARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetAttachedShaders, { "GetAttachedShaders", "GetAttachedShadersARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetAttribLocation, { "GetAttribLocation", "GetAttribLocationARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetIntegerv, { "GetIntegerv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetFloatv, { "GetFloatv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetBooleanv, { "GetBooleanv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetBufferParameteriv, { "GetBufferParameteriv", "GetBufferParameterivARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetError, { "GetError", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetProgramiv, { "GetProgramiv", "GetProgramivARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetProgramInfoLog, { "GetProgramInfoLog", "GetProgramInfoLogARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTexParameteri, { "TexParameteri", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTexParameteriv, { "TexParameteriv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTexParameterf, { "TexParameterf", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetString, { "GetString", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetTexParameterfv, { "GetTexParameterfv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetTexParameteriv, { "GetTexParameteriv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetUniformfv, { "GetUniformfv", "GetUniformfvARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetUniformiv, { "GetUniformiv", "GetUniformivARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetUniformLocation, { "GetUniformLocation", "GetUniformLocationARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetVertexAttribfv, { "GetVertexAttribfv", "GetVertexAttribfvARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetVertexAttribiv, { "GetVertexAttribiv", "GetVertexAttribivARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetVertexAttribPointerv, { "GetVertexAttribPointerv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fHint, { "Hint", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsBuffer, { "IsBuffer", "IsBufferARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsEnabled, { "IsEnabled", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsProgram, { "IsProgram", "IsProgramARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsShader, { "IsShader", "IsShaderARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsTexture, { "IsTexture", "IsTextureARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fLineWidth, { "LineWidth", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fLinkProgram, { "LinkProgram", "LinkProgramARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fPixelStorei, { "PixelStorei", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fPolygonOffset, { "PolygonOffset", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fReadPixels, { "ReadPixels", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fSampleCoverage, { "SampleCoverage", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fScissor, { "Scissor", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fStencilFunc, { "StencilFunc", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fStencilFuncSeparate, { "StencilFuncSeparate", "StencilFuncSeparateEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fStencilMask, { "StencilMask", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fStencilMaskSeparate, { "StencilMaskSeparate", "StencilMaskSeparateEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fStencilOp, { "StencilOp", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fStencilOpSeparate, { "StencilOpSeparate", "StencilOpSeparateEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTexImage2D, { "TexImage2D", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTexSubImage2D, { "TexSubImage2D", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform1f, { "Uniform1f", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform1fv, { "Uniform1fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform1i, { "Uniform1i", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform1iv, { "Uniform1iv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform2f, { "Uniform2f", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform2fv, { "Uniform2fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform2i, { "Uniform2i", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform2iv, { "Uniform2iv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform3f, { "Uniform3f", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform3fv, { "Uniform3fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform3i, { "Uniform3i", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform3iv, { "Uniform3iv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform4f, { "Uniform4f", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform4fv, { "Uniform4fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform4i, { "Uniform4i", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform4iv, { "Uniform4iv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniformMatrix2fv, { "UniformMatrix2fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniformMatrix3fv, { "UniformMatrix3fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniformMatrix4fv, { "UniformMatrix4fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUseProgram, { "UseProgram", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fValidateProgram, { "ValidateProgram", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttribPointer, { "VertexAttribPointer", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttrib1f, { "VertexAttrib1f", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttrib2f, { "VertexAttrib2f", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttrib3f, { "VertexAttrib3f", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttrib4f, { "VertexAttrib4f", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttrib1fv, { "VertexAttrib1fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttrib2fv, { "VertexAttrib2fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttrib3fv, { "VertexAttrib3fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttrib4fv, { "VertexAttrib4fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fViewport, { "Viewport", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fCompileShader, { "CompileShader", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fCopyTexImage2D, { "CopyTexImage2D", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fCopyTexSubImage2D, { "CopyTexSubImage2D", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetShaderiv, { "GetShaderiv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetShaderInfoLog, { "GetShaderInfoLog", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetShaderSource, { "GetShaderSource", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fShaderSource, { "ShaderSource", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttribPointer, { "VertexAttribPointer", nullptr } },
+
+ { (PRFuncPtr*) &mSymbols.fGenBuffers, { "GenBuffers", "GenBuffersARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGenTextures, { "GenTextures", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fCreateProgram, { "CreateProgram", "CreateProgramARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fCreateShader, { "CreateShader", "CreateShaderARB", nullptr } },
+
+ { (PRFuncPtr*) &mSymbols.fDeleteBuffers, { "DeleteBuffers", "DeleteBuffersARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteTextures, { "DeleteTextures", "DeleteTexturesARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteProgram, { "DeleteProgram", "DeleteProgramARB", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteShader, { "DeleteShader", "DeleteShaderARB", nullptr } },
+
+ END_SYMBOLS
+ };
+
+ if (!LoadGLSymbols(this, prefix, trygl, coreSymbols, "GL"))
+ return false;
+
+ ////////////////
+
+ MakeCurrent();
+ MOZ_ASSERT(mProfile != ContextProfile::Unknown);
+
+ uint32_t version = 0;
+ ParseGLVersion(this, &version);
+
+ mShadingLanguageVersion = 100;
+ ParseGLSLVersion(this, &mShadingLanguageVersion);
+
+ if (ShouldSpew()) {
+ printf_stderr("OpenGL version detected: %u\n", version);
+ printf_stderr("OpenGL shading language version detected: %u\n", mShadingLanguageVersion);
+ printf_stderr("OpenGL vendor: %s\n", fGetString(LOCAL_GL_VENDOR));
+ printf_stderr("OpenGL renderer: %s\n", fGetString(LOCAL_GL_RENDERER));
+ }
+
+ if (version >= mVersion) {
+ mVersion = version;
+ }
+ // Don't fail if version < mVersion, see bug 999445,
+ // Mac OSX 10.6/10.7 machines with Intel GPUs claim only OpenGL 1.4 but
+ // have all the GL2+ extensions that we need.
+
+ ////////////////
+
+ // Load OpenGL ES 2.0 symbols, or desktop if we aren't using ES 2.
+ if (IsGLES()) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetShaderPrecisionFormat, { "GetShaderPrecisionFormat", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fClearDepthf, { "ClearDepthf", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDepthRangef, { "DepthRangef", nullptr } },
+ END_SYMBOLS
+ };
+
+ if (!LoadGLSymbols(this, prefix, trygl, symbols, "OpenGL ES"))
+ return false;
+ } else {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fClearDepth, { "ClearDepth", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDepthRange, { "DepthRange", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fReadBuffer, { "ReadBuffer", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fMapBuffer, { "MapBuffer", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUnmapBuffer, { "UnmapBuffer", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fPointParameterf, { "PointParameterf", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDrawBuffer, { "DrawBuffer", nullptr } },
+ // The following functions are only used by Skia/GL in desktop mode.
+ // Other parts of Gecko should avoid using these
+ { (PRFuncPtr*) &mSymbols.fDrawBuffers, { "DrawBuffers", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fClientActiveTexture, { "ClientActiveTexture", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDisableClientState, { "DisableClientState", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fEnableClientState, { "EnableClientState", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fLoadIdentity, { "LoadIdentity", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fLoadMatrixf, { "LoadMatrixf", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fMatrixMode, { "MatrixMode", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTexGeni, { "TexGeni", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTexGenf, { "TexGenf", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTexGenfv, { "TexGenfv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexPointer, { "VertexPointer", nullptr } },
+ END_SYMBOLS
+ };
+
+ if (!LoadGLSymbols(this, prefix, trygl, symbols, "Desktop OpenGL"))
+ return false;
+ }
+
+ ////////////////
+
+ const char* glVendorString = (const char*)fGetString(LOCAL_GL_VENDOR);
+ const char* glRendererString = (const char*)fGetString(LOCAL_GL_RENDERER);
+ if (!glVendorString || !glRendererString)
+ return false;
+
+ // The order of these strings must match up with the order of the enum
+ // defined in GLContext.h for vendor IDs.
+ const char* vendorMatchStrings[size_t(GLVendor::Other) + 1] = {
+ "Intel",
+ "NVIDIA",
+ "ATI",
+ "Qualcomm",
+ "Imagination",
+ "nouveau",
+ "Vivante",
+ "VMware, Inc.",
+ "ARM",
+ "Unknown"
+ };
+
+ mVendor = GLVendor::Other;
+ for (size_t i = 0; i < size_t(GLVendor::Other); ++i) {
+ if (DoesStringMatch(glVendorString, vendorMatchStrings[i])) {
+ mVendor = GLVendor(i);
+ break;
+ }
+ }
+
+ // The order of these strings must match up with the order of the enum
+ // defined in GLContext.h for renderer IDs.
+ const char* rendererMatchStrings[size_t(GLRenderer::Other) + 1] = {
+ "Adreno 200",
+ "Adreno 205",
+ "Adreno (TM) 200",
+ "Adreno (TM) 205",
+ "Adreno (TM) 305",
+ "Adreno (TM) 320",
+ "Adreno (TM) 330",
+ "Adreno (TM) 420",
+ "Mali-400 MP",
+ "Mali-450 MP",
+ "PowerVR SGX 530",
+ "PowerVR SGX 540",
+ "PowerVR SGX 544MP",
+ "NVIDIA Tegra",
+ "Android Emulator",
+ "Gallium 0.4 on llvmpipe",
+ "Intel HD Graphics 3000 OpenGL Engine",
+ "Microsoft Basic Render Driver",
+ "Unknown"
+ };
+
+ mRenderer = GLRenderer::Other;
+ for (size_t i = 0; i < size_t(GLRenderer::Other); ++i) {
+ if (DoesStringMatch(glRendererString, rendererMatchStrings[i])) {
+ mRenderer = GLRenderer(i);
+ break;
+ }
+ }
+
+ if (ShouldSpew()) {
+ printf_stderr("GL_VENDOR: %s\n", glVendorString);
+ printf_stderr("mVendor: %s\n", vendorMatchStrings[size_t(mVendor)]);
+ printf_stderr("GL_RENDERER: %s\n", glRendererString);
+ printf_stderr("mRenderer: %s\n", rendererMatchStrings[size_t(mRenderer)]);
+ }
+
+ ////////////////
+
+ // We need this for retrieving the list of extensions on Core profiles.
+ if (IsFeatureProvidedByCoreSymbols(GLFeature::get_string_indexed)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetStringi, { "GetStringi", nullptr } },
+ END_SYMBOLS
+ };
+
+ if (!LoadGLSymbols(this, prefix, trygl, symbols, "get_string_indexed")) {
+ MOZ_RELEASE_ASSERT(false, "GFX: get_string_indexed is required!");
+ return false;
+ }
+ }
+
+ InitExtensions();
+ InitFeatures();
+
+ // Disable extensions with partial or incorrect support.
+ if (WorkAroundDriverBugs()) {
+ if (Renderer() == GLRenderer::AdrenoTM320) {
+ MarkUnsupported(GLFeature::standard_derivatives);
+ }
+
+ if (Vendor() == GLVendor::Vivante) {
+ // bug 958256
+ MarkUnsupported(GLFeature::standard_derivatives);
+ }
+
+ if (Renderer() == GLRenderer::MicrosoftBasicRenderDriver) {
+ // Bug 978966: on Microsoft's "Basic Render Driver" (software renderer)
+ // multisampling hardcodes blending with the default blendfunc, which breaks WebGL.
+ MarkUnsupported(GLFeature::framebuffer_multisample);
+ }
+
+#ifdef XP_MACOSX
+ // The Mac Nvidia driver, for versions up to and including 10.8,
+ // don't seem to properly support this. See 814839
+ // this has been fixed in Mac OS X 10.9. See 907946
+ // and it also works in 10.8.3 and higher. See 1094338.
+ if (Vendor() == gl::GLVendor::NVIDIA &&
+ !nsCocoaFeatures::IsAtLeastVersion(10,8,3))
+ {
+ MarkUnsupported(GLFeature::depth_texture);
+ }
+#endif
+ }
+
+ if (IsExtensionSupported(GLContext::ARB_pixel_buffer_object)) {
+ MOZ_ASSERT((mSymbols.fMapBuffer && mSymbols.fUnmapBuffer),
+ "ARB_pixel_buffer_object supported without glMapBuffer/UnmapBuffer"
+ " being available!");
+ }
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ const auto fnLoadForFeature = [this, prefix, trygl](const SymLoadStruct* list,
+ GLFeature feature)
+ {
+ return this->LoadFeatureSymbols(prefix, trygl, list, feature);
+ };
+
+ // Check for ARB_framebuffer_objects
+ if (IsSupported(GLFeature::framebuffer_object)) {
+ // https://www.opengl.org/registry/specs/ARB/framebuffer_object.txt
+ const SymLoadStruct symbols[] = {
+ CORE_SYMBOL(IsRenderbuffer),
+ CORE_SYMBOL(BindRenderbuffer),
+ CORE_SYMBOL(DeleteRenderbuffers),
+ CORE_SYMBOL(GenRenderbuffers),
+ CORE_SYMBOL(RenderbufferStorage),
+ CORE_SYMBOL(RenderbufferStorageMultisample),
+ CORE_SYMBOL(GetRenderbufferParameteriv),
+ CORE_SYMBOL(IsFramebuffer),
+ CORE_SYMBOL(BindFramebuffer),
+ CORE_SYMBOL(DeleteFramebuffers),
+ CORE_SYMBOL(GenFramebuffers),
+ CORE_SYMBOL(CheckFramebufferStatus),
+ CORE_SYMBOL(FramebufferTexture2D),
+ CORE_SYMBOL(FramebufferTextureLayer),
+ CORE_SYMBOL(FramebufferRenderbuffer),
+ CORE_SYMBOL(GetFramebufferAttachmentParameteriv),
+ CORE_SYMBOL(BlitFramebuffer),
+ CORE_SYMBOL(GenerateMipmap),
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::framebuffer_object);
+ }
+
+ if (!IsSupported(GLFeature::framebuffer_object)) {
+ // Check for aux symbols based on extensions
+ if (IsSupported(GLFeature::framebuffer_object_EXT_OES)) {
+ const SymLoadStruct symbols[] = {
+ CORE_EXT_SYMBOL2(IsRenderbuffer, EXT, OES),
+ CORE_EXT_SYMBOL2(BindRenderbuffer, EXT, OES),
+ CORE_EXT_SYMBOL2(DeleteRenderbuffers, EXT, OES),
+ CORE_EXT_SYMBOL2(GenRenderbuffers, EXT, OES),
+ CORE_EXT_SYMBOL2(RenderbufferStorage, EXT, OES),
+ CORE_EXT_SYMBOL2(GetRenderbufferParameteriv, EXT, OES),
+ CORE_EXT_SYMBOL2(IsFramebuffer, EXT, OES),
+ CORE_EXT_SYMBOL2(BindFramebuffer, EXT, OES),
+ CORE_EXT_SYMBOL2(DeleteFramebuffers, EXT, OES),
+ CORE_EXT_SYMBOL2(GenFramebuffers, EXT, OES),
+ CORE_EXT_SYMBOL2(CheckFramebufferStatus, EXT, OES),
+ CORE_EXT_SYMBOL2(FramebufferTexture2D, EXT, OES),
+ CORE_EXT_SYMBOL2(FramebufferRenderbuffer, EXT, OES),
+ CORE_EXT_SYMBOL2(GetFramebufferAttachmentParameteriv, EXT, OES),
+ CORE_EXT_SYMBOL2(GenerateMipmap, EXT, OES),
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::framebuffer_object_EXT_OES);
+ }
+
+ if (IsSupported(GLFeature::framebuffer_blit)) {
+ const SymLoadStruct symbols[] = {
+ EXT_SYMBOL3(BlitFramebuffer, ANGLE, EXT, NV),
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::framebuffer_blit);
+ }
+
+ if (IsSupported(GLFeature::framebuffer_multisample)) {
+ const SymLoadStruct symbols[] = {
+ EXT_SYMBOL3(RenderbufferStorageMultisample, ANGLE, APPLE, EXT),
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::framebuffer_multisample);
+ }
+
+ if (IsExtensionSupported(GLContext::ARB_geometry_shader4) ||
+ IsExtensionSupported(GLContext::NV_geometry_program4))
+ {
+ const SymLoadStruct symbols[] = {
+ EXT_SYMBOL2(FramebufferTextureLayer, ARB, EXT),
+ END_SYMBOLS
+ };
+ if (!LoadGLSymbols(this, prefix, trygl, symbols,
+ "ARB_geometry_shader4/NV_geometry_program4"))
+ {
+ MarkExtensionUnsupported(GLContext::ARB_geometry_shader4);
+ MarkExtensionUnsupported(GLContext::NV_geometry_program4);
+ }
+ }
+ }
+
+ if (!IsSupported(GLFeature::framebuffer_object) &&
+ !IsSupported(GLFeature::framebuffer_object_EXT_OES))
+ {
+ NS_ERROR("GLContext requires support for framebuffer objects.");
+ return false;
+ }
+ MOZ_RELEASE_ASSERT(mSymbols.fBindFramebuffer, "GFX: mSymbols.fBindFramebuffer zero or not set.");
+
+ ////////////////
+
+ LoadMoreSymbols(prefix, trygl);
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ raw_fGetIntegerv(LOCAL_GL_VIEWPORT, mViewportRect);
+ raw_fGetIntegerv(LOCAL_GL_SCISSOR_BOX, mScissorRect);
+ raw_fGetIntegerv(LOCAL_GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
+ raw_fGetIntegerv(LOCAL_GL_MAX_CUBE_MAP_TEXTURE_SIZE, &mMaxCubeMapTextureSize);
+ raw_fGetIntegerv(LOCAL_GL_MAX_RENDERBUFFER_SIZE, &mMaxRenderbufferSize);
+ raw_fGetIntegerv(LOCAL_GL_MAX_VIEWPORT_DIMS, mMaxViewportDims);
+
+#ifdef XP_MACOSX
+ if (mWorkAroundDriverBugs) {
+ if (mVendor == GLVendor::Intel) {
+ // see bug 737182 for 2D textures, bug 684882 for cube map textures.
+ mMaxTextureSize = std::min(mMaxTextureSize, 4096);
+ mMaxCubeMapTextureSize = std::min(mMaxCubeMapTextureSize, 512);
+ // for good measure, we align renderbuffers on what we do for 2D textures
+ mMaxRenderbufferSize = std::min(mMaxRenderbufferSize, 4096);
+ mNeedsTextureSizeChecks = true;
+ } else if (mVendor == GLVendor::NVIDIA) {
+ // See bug 879656. 8192 fails, 8191 works.
+ mMaxTextureSize = std::min(mMaxTextureSize, 8191);
+ mMaxRenderbufferSize = std::min(mMaxRenderbufferSize, 8191);
+
+ // Part of the bug 879656, but it also doesn't hurt the 877949
+ mNeedsTextureSizeChecks = true;
+ }
+ }
+#endif
+#ifdef MOZ_X11
+ if (mWorkAroundDriverBugs) {
+ if (mVendor == GLVendor::Nouveau) {
+ // see bug 814716. Clamp MaxCubeMapTextureSize at 2K for Nouveau.
+ mMaxCubeMapTextureSize = std::min(mMaxCubeMapTextureSize, 2048);
+ mNeedsTextureSizeChecks = true;
+ } else if (mVendor == GLVendor::Intel) {
+ // Bug 1199923. Driver seems to report a larger max size than
+ // actually supported.
+ mMaxTextureSize /= 2;
+ mMaxRenderbufferSize /= 2;
+ mNeedsTextureSizeChecks = true;
+ }
+ }
+#endif
+ if (mWorkAroundDriverBugs &&
+ Renderer() == GLRenderer::AdrenoTM420) {
+ // see bug 1194923. Calling glFlush before glDeleteFramebuffers
+ // prevents occasional driver crash.
+ mNeedsFlushBeforeDeleteFB = true;
+ }
+#ifdef MOZ_WIDGET_ANDROID
+ if (mWorkAroundDriverBugs &&
+ (Renderer() == GLRenderer::AdrenoTM305 ||
+ Renderer() == GLRenderer::AdrenoTM320 ||
+ Renderer() == GLRenderer::AdrenoTM330) &&
+ AndroidBridge::Bridge()->GetAPIVersion() < 21) {
+ // Bug 1164027. Driver crashes when functions such as
+ // glTexImage2D fail due to virtual memory exhaustion.
+ mTextureAllocCrashesOnMapFailure = true;
+ }
+#endif
+#if MOZ_WIDGET_ANDROID
+ if (mWorkAroundDriverBugs &&
+ Renderer() == GLRenderer::SGX540 &&
+ AndroidBridge::Bridge()->GetAPIVersion() <= 15) {
+ // Bug 1288446. Driver sometimes crashes when uploading data to a
+ // texture if the render target has changed since the texture was
+ // rendered from. Calling glCheckFramebufferStatus after
+ // glFramebufferTexture2D prevents the crash.
+ mNeedsCheckAfterAttachTextureToFb = true;
+ }
+#endif
+
+ mMaxTextureImageSize = mMaxTextureSize;
+
+ if (IsSupported(GLFeature::framebuffer_multisample)) {
+ fGetIntegerv(LOCAL_GL_MAX_SAMPLES, (GLint*)&mMaxSamples);
+ }
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ // We're ready for final setup.
+ fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, 0);
+
+ // TODO: Remove SurfaceCaps::any.
+ if (mCaps.any) {
+ mCaps.any = false;
+ mCaps.color = true;
+ mCaps.alpha = false;
+ }
+
+ mTexGarbageBin = new TextureGarbageBin(this);
+
+ MOZ_ASSERT(IsCurrent());
+
+ if (ShouldSpew() && IsExtensionSupported(KHR_debug)) {
+ fEnable(LOCAL_GL_DEBUG_OUTPUT);
+ fDisable(LOCAL_GL_DEBUG_OUTPUT_SYNCHRONOUS);
+ fDebugMessageCallback(&StaticDebugCallback, (void*)this);
+ fDebugMessageControl(LOCAL_GL_DONT_CARE,
+ LOCAL_GL_DONT_CARE,
+ LOCAL_GL_DONT_CARE,
+ 0, nullptr,
+ true);
+ }
+
+ mVersionString = nsPrintfCString("%u.%u.%u", mVersion / 100, (mVersion / 10) % 10,
+ mVersion % 10);
+ return true;
+}
+
+void
+GLContext::LoadMoreSymbols(const char* prefix, bool trygl)
+{
+ const auto fnLoadForExt = [this, prefix, trygl](const SymLoadStruct* list,
+ GLExtensions ext)
+ {
+ return this->LoadExtSymbols(prefix, trygl, list, ext);
+ };
+
+ const auto fnLoadForFeature = [this, prefix, trygl](const SymLoadStruct* list,
+ GLFeature feature)
+ {
+ return this->LoadFeatureSymbols(prefix, trygl, list, feature);
+ };
+
+ const auto fnLoadFeatureByCore = [this, fnLoadForFeature](const SymLoadStruct* coreList,
+ const SymLoadStruct* extList,
+ GLFeature feature)
+ {
+ const bool useCore = this->IsFeatureProvidedByCoreSymbols(feature);
+ const auto list = useCore ? coreList : extList;
+ return fnLoadForFeature(list, feature);
+ };
+
+ if (IsSupported(GLFeature::robustness)) {
+ bool hasRobustness = false;
+
+ if (!hasRobustness && IsExtensionSupported(ARB_robustness)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetGraphicsResetStatus, { "GetGraphicsResetStatusARB", nullptr } },
+ END_SYMBOLS
+ };
+ if (fnLoadForExt(symbols, ARB_robustness)) {
+ hasRobustness = true;
+ }
+ }
+
+ if (!hasRobustness && IsExtensionSupported(EXT_robustness)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetGraphicsResetStatus, { "GetGraphicsResetStatusEXT", nullptr } },
+ END_SYMBOLS
+ };
+ if (fnLoadForExt(symbols, EXT_robustness)) {
+ hasRobustness = true;
+ }
+ }
+
+ if (!hasRobustness) {
+ MarkUnsupported(GLFeature::robustness);
+ }
+ }
+
+ if (IsSupported(GLFeature::sync)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fFenceSync, { "FenceSync", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsSync, { "IsSync", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteSync, { "DeleteSync", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fClientWaitSync, { "ClientWaitSync", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fWaitSync, { "WaitSync", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetInteger64v, { "GetInteger64v", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetSynciv, { "GetSynciv", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::sync);
+ }
+
+ if (IsExtensionSupported(OES_EGL_image)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fEGLImageTargetTexture2D, { "EGLImageTargetTexture2DOES", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fEGLImageTargetRenderbufferStorage, { "EGLImageTargetRenderbufferStorageOES", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForExt(symbols, OES_EGL_image);
+ }
+
+ if (IsExtensionSupported(APPLE_texture_range)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fTextureRangeAPPLE, { "TextureRangeAPPLE", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForExt(symbols, APPLE_texture_range);
+ }
+
+ if (IsSupported(GLFeature::vertex_array_object)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fIsVertexArray, { "IsVertexArray", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGenVertexArrays, { "GenVertexArrays", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBindVertexArray, { "BindVertexArray", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteVertexArrays, { "DeleteVertexArrays", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fIsVertexArray, { "IsVertexArrayARB", "IsVertexArrayOES", "IsVertexArrayAPPLE", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGenVertexArrays, { "GenVertexArraysARB", "GenVertexArraysOES", "GenVertexArraysAPPLE", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBindVertexArray, { "BindVertexArrayARB", "BindVertexArrayOES", "BindVertexArrayAPPLE", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteVertexArrays, { "DeleteVertexArraysARB", "DeleteVertexArraysOES", "DeleteVertexArraysAPPLE", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::vertex_array_object);
+ }
+
+ if (IsSupported(GLFeature::draw_instanced)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fDrawArraysInstanced, { "DrawArraysInstanced", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDrawElementsInstanced, { "DrawElementsInstanced", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fDrawArraysInstanced, { "DrawArraysInstancedARB", "DrawArraysInstancedEXT", "DrawArraysInstancedNV", "DrawArraysInstancedANGLE", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDrawElementsInstanced, { "DrawElementsInstancedARB", "DrawElementsInstancedEXT", "DrawElementsInstancedNV", "DrawElementsInstancedANGLE", nullptr }
+ },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::draw_instanced);
+ }
+
+ if (IsSupported(GLFeature::instanced_arrays)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fVertexAttribDivisor, { "VertexAttribDivisor", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fVertexAttribDivisor, { "VertexAttribDivisorARB", "VertexAttribDivisorNV", "VertexAttribDivisorANGLE", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::instanced_arrays);
+ }
+
+ if (IsSupported(GLFeature::texture_storage)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fTexStorage2D, { "TexStorage2D", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTexStorage3D, { "TexStorage3D", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fTexStorage2D, { "TexStorage2DEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTexStorage3D, { "TexStorage3DEXT", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::texture_storage);
+ }
+
+ if (IsSupported(GLFeature::sampler_objects)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGenSamplers, { "GenSamplers", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteSamplers, { "DeleteSamplers", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsSampler, { "IsSampler", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBindSampler, { "BindSampler", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fSamplerParameteri, { "SamplerParameteri", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fSamplerParameteriv, { "SamplerParameteriv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fSamplerParameterf, { "SamplerParameterf", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fSamplerParameterfv, { "SamplerParameterfv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetSamplerParameteriv, { "GetSamplerParameteriv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetSamplerParameterfv, { "GetSamplerParameterfv", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::sampler_objects);
+ }
+
+ // ARB_transform_feedback2/NV_transform_feedback2 is a
+ // superset of EXT_transform_feedback/NV_transform_feedback
+ // and adds glPauseTransformFeedback &
+ // glResumeTransformFeedback, which are required for WebGL2.
+ if (IsSupported(GLFeature::transform_feedback2)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fBindBufferBase, { "BindBufferBase", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBindBufferRange, { "BindBufferRange", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGenTransformFeedbacks, { "GenTransformFeedbacks", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBindTransformFeedback, { "BindTransformFeedback", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteTransformFeedbacks, { "DeleteTransformFeedbacks", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsTransformFeedback, { "IsTransformFeedback", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBeginTransformFeedback, { "BeginTransformFeedback", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fEndTransformFeedback, { "EndTransformFeedback", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTransformFeedbackVaryings, { "TransformFeedbackVaryings", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetTransformFeedbackVarying, { "GetTransformFeedbackVarying", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fPauseTransformFeedback, { "PauseTransformFeedback", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fResumeTransformFeedback, { "ResumeTransformFeedback", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fBindBufferBase, { "BindBufferBaseEXT", "BindBufferBaseNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBindBufferRange, { "BindBufferRangeEXT", "BindBufferRangeNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGenTransformFeedbacks, { "GenTransformFeedbacksNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBindTransformFeedback, { "BindTransformFeedbackNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteTransformFeedbacks, { "DeleteTransformFeedbacksNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsTransformFeedback, { "IsTransformFeedbackNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fBeginTransformFeedback, { "BeginTransformFeedbackEXT", "BeginTransformFeedbackNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fEndTransformFeedback, { "EndTransformFeedbackEXT", "EndTransformFeedbackNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTransformFeedbackVaryings, { "TransformFeedbackVaryingsEXT", "TransformFeedbackVaryingsNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetTransformFeedbackVarying, { "GetTransformFeedbackVaryingEXT", "GetTransformFeedbackVaryingNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fPauseTransformFeedback, { "PauseTransformFeedbackNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fResumeTransformFeedback, { "ResumeTransformFeedbackNV", nullptr } },
+ END_SYMBOLS
+ };
+ if (!fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::texture_storage)) {
+ // Also mark bind_buffer_offset as unsupported.
+ MarkUnsupported(GLFeature::bind_buffer_offset);
+ }
+ }
+
+ if (IsSupported(GLFeature::bind_buffer_offset)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fBindBufferOffset, { "BindBufferOffset", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fBindBufferOffset,
+ { "BindBufferOffsetEXT", "BindBufferOffsetNV", nullptr }
+ },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::bind_buffer_offset);
+ }
+
+ if (IsSupported(GLFeature::query_counter)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fQueryCounter, { "QueryCounter", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fQueryCounter, { "QueryCounterEXT", "QueryCounterANGLE", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::query_counter);
+ }
+
+ if (IsSupported(GLFeature::query_objects)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fBeginQuery, { "BeginQuery", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGenQueries, { "GenQueries", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteQueries, { "DeleteQueries", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fEndQuery, { "EndQuery", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetQueryiv, { "GetQueryiv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetQueryObjectuiv, { "GetQueryObjectuiv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsQuery, { "IsQuery", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fBeginQuery, { "BeginQueryEXT", "BeginQueryANGLE", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGenQueries, { "GenQueriesEXT", "GenQueriesANGLE", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteQueries, { "DeleteQueriesEXT", "DeleteQueriesANGLE", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fEndQuery, { "EndQueryEXT", "EndQueryANGLE", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetQueryiv, { "GetQueryivEXT", "GetQueryivANGLE", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetQueryObjectuiv, { "GetQueryObjectuivEXT", "GetQueryObjectuivANGLE", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsQuery, { "IsQueryEXT", "IsQueryANGLE", nullptr } },
+ END_SYMBOLS
+ };
+ if (!fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::query_objects)) {
+ MarkUnsupported(GLFeature::get_query_object_i64v);
+ MarkUnsupported(GLFeature::get_query_object_iv);
+ MarkUnsupported(GLFeature::occlusion_query);
+ MarkUnsupported(GLFeature::occlusion_query_boolean);
+ MarkUnsupported(GLFeature::occlusion_query2);
+ }
+ }
+
+ if (IsSupported(GLFeature::get_query_object_i64v)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetQueryObjecti64v, { "GetQueryObjecti64v", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetQueryObjectui64v, { "GetQueryObjectui64v", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetQueryObjecti64v, { "GetQueryObjecti64vEXT", "GetQueryObjecti64vANGLE", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetQueryObjectui64v, { "GetQueryObjectui64vEXT", "GetQueryObjectui64vANGLE", nullptr } },
+ END_SYMBOLS
+ };
+ if (!fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::get_query_object_i64v)) {
+ MarkUnsupported(GLFeature::query_counter);
+ }
+ }
+
+ if (IsSupported(GLFeature::get_query_object_iv)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetQueryObjectiv, { "GetQueryObjectiv", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetQueryObjectiv, { "GetQueryObjectivEXT", "GetQueryObjectivANGLE", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::get_query_object_iv);
+ }
+
+ if (IsSupported(GLFeature::clear_buffers)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fClearBufferfi, { "ClearBufferfi", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fClearBufferfv, { "ClearBufferfv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fClearBufferiv, { "ClearBufferiv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fClearBufferuiv, { "ClearBufferuiv", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::clear_buffers);
+ }
+
+ if (IsSupported(GLFeature::copy_buffer)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fCopyBufferSubData, { "CopyBufferSubData", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::copy_buffer);
+ }
+
+ if (IsSupported(GLFeature::draw_buffers)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fDrawBuffers, { "DrawBuffers", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fDrawBuffers, { "DrawBuffersARB", "DrawBuffersEXT", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::draw_buffers);
+ }
+
+ if (IsSupported(GLFeature::draw_range_elements)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fDrawRangeElements, { "DrawRangeElements", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fDrawRangeElements, { "DrawRangeElementsEXT", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::draw_range_elements);
+ }
+
+ if (IsSupported(GLFeature::get_integer_indexed)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetIntegeri_v, { "GetIntegeri_v", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] ={
+ { (PRFuncPtr*) &mSymbols.fGetIntegeri_v, { "GetIntegerIndexedvEXT", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::get_integer_indexed);
+ }
+
+ if (IsSupported(GLFeature::get_integer64_indexed)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetInteger64i_v, { "GetInteger64i_v", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::get_integer64_indexed);
+ }
+
+ if (IsSupported(GLFeature::gpu_shader4)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetVertexAttribIiv, { "GetVertexAttribIiv", "GetVertexAttribIivEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetVertexAttribIuiv, { "GetVertexAttribIuiv", "GetVertexAttribIuivEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttribI4i, { "VertexAttribI4i", "VertexAttribI4iEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttribI4iv, { "VertexAttribI4iv","VertexAttribI4ivEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttribI4ui, { "VertexAttribI4ui", "VertexAttribI4uiEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttribI4uiv, { "VertexAttribI4uiv", "VertexAttribI4uivEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fVertexAttribIPointer, { "VertexAttribIPointer", "VertexAttribIPointerEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform1ui, { "Uniform1ui", "Uniform1uiEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform2ui, { "Uniform2ui", "Uniform2uiEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform3ui, { "Uniform3ui", "Uniform3uiEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform4ui, { "Uniform4ui", "Uniform4uiEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform1uiv, { "Uniform1uiv", "Uniform1uivEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform2uiv, { "Uniform2uiv", "Uniform2uivEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform3uiv, { "Uniform3uiv", "Uniform3uivEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniform4uiv, { "Uniform4uiv", "Uniform4uivEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetFragDataLocation, { "GetFragDataLocation", "GetFragDataLocationEXT", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetUniformuiv, { "GetUniformuiv", "GetUniformuivEXT", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::gpu_shader4);
+ }
+
+ if (IsSupported(GLFeature::map_buffer_range)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fMapBufferRange, { "MapBufferRange", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fFlushMappedBufferRange, { "FlushMappedBufferRange", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUnmapBuffer, { "UnmapBuffer", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::map_buffer_range);
+ }
+
+ if (IsSupported(GLFeature::texture_3D)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fTexImage3D, { "TexImage3D", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTexSubImage3D, { "TexSubImage3D", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fTexSubImage3D, { "TexSubImage3DEXT", "TexSubImage3DOES", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::texture_3D);
+ }
+
+ if (IsSupported(GLFeature::texture_3D_compressed)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fCompressedTexImage3D, { "CompressedTexImage3D", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fCompressedTexSubImage3D, { "CompressedTexSubImage3D", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fCompressedTexImage3D, { "CompressedTexImage3DARB", "CompressedTexImage3DOES", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fCompressedTexSubImage3D, { "CompressedTexSubImage3DARB", "CompressedTexSubImage3DOES", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::texture_3D_compressed);
+ }
+
+ if (IsSupported(GLFeature::texture_3D_copy)) {
+ const SymLoadStruct coreSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fCopyTexSubImage3D, { "CopyTexSubImage3D", nullptr } },
+ END_SYMBOLS
+ };
+ const SymLoadStruct extSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fCopyTexSubImage3D, { "CopyTexSubImage3DEXT", "CopyTexSubImage3DOES", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadFeatureByCore(coreSymbols, extSymbols, GLFeature::texture_3D_copy);
+ }
+
+ if (IsSupported(GLFeature::uniform_buffer_object)) {
+ // Note: Don't query for glGetActiveUniformName because it is not
+ // supported by GL ES 3.
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetUniformIndices, { "GetUniformIndices", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetActiveUniformsiv, { "GetActiveUniformsiv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetUniformBlockIndex, { "GetUniformBlockIndex", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetActiveUniformBlockiv, { "GetActiveUniformBlockiv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetActiveUniformBlockName, { "GetActiveUniformBlockName", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniformBlockBinding, { "UniformBlockBinding", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::uniform_buffer_object);
+ }
+
+ if (IsSupported(GLFeature::uniform_matrix_nonsquare)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fUniformMatrix2x3fv, { "UniformMatrix2x3fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniformMatrix2x4fv, { "UniformMatrix2x4fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniformMatrix3x2fv, { "UniformMatrix3x2fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniformMatrix3x4fv, { "UniformMatrix3x4fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniformMatrix4x2fv, { "UniformMatrix4x2fv", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fUniformMatrix4x3fv, { "UniformMatrix4x3fv", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::uniform_matrix_nonsquare);
+ }
+
+ if (IsSupported(GLFeature::internalformat_query)) {
+ const SymLoadStruct symbols[] = {
+ CORE_SYMBOL(GetInternalformativ),
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::internalformat_query);
+ }
+
+ if (IsSupported(GLFeature::invalidate_framebuffer)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fInvalidateFramebuffer, { "InvalidateFramebuffer", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fInvalidateSubFramebuffer, { "InvalidateSubFramebuffer", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::invalidate_framebuffer);
+ }
+
+ if (IsSupported(GLFeature::prim_restart)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fPrimitiveRestartIndex, { "PrimitiveRestartIndex", "PrimitiveRestartIndexNV", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::prim_restart);
+ }
+
+ if (IsExtensionSupported(KHR_debug)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fDebugMessageControl, { "DebugMessageControl", "DebugMessageControlKHR", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDebugMessageInsert, { "DebugMessageInsert", "DebugMessageInsertKHR", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDebugMessageCallback, { "DebugMessageCallback", "DebugMessageCallbackKHR", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetDebugMessageLog, { "GetDebugMessageLog", "GetDebugMessageLogKHR", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetPointerv, { "GetPointerv", "GetPointervKHR", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fPushDebugGroup, { "PushDebugGroup", "PushDebugGroupKHR", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fPopDebugGroup, { "PopDebugGroup", "PopDebugGroupKHR", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fObjectLabel, { "ObjectLabel", "ObjectLabelKHR", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetObjectLabel, { "GetObjectLabel", "GetObjectLabelKHR", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fObjectPtrLabel, { "ObjectPtrLabel", "ObjectPtrLabelKHR", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetObjectPtrLabel, { "GetObjectPtrLabel", "GetObjectPtrLabelKHR", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForExt(symbols, KHR_debug);
+ }
+
+ if (IsExtensionSupported(NV_fence)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGenFences, { "GenFencesNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fDeleteFences, { "DeleteFencesNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fSetFence, { "SetFenceNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fTestFence, { "TestFenceNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fFinishFence, { "FinishFenceNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fIsFence, { "IsFenceNV", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetFenceiv, { "GetFenceivNV", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForExt(symbols, NV_fence);
+ }
+
+ if (IsExtensionSupported(NV_texture_barrier)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fTextureBarrier, { "TextureBarrierNV", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForExt(symbols, NV_texture_barrier);
+ }
+
+ if (IsSupported(GLFeature::read_buffer)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fReadBuffer, { "ReadBuffer", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForFeature(symbols, GLFeature::read_buffer);
+ }
+
+ if (IsExtensionSupported(APPLE_framebuffer_multisample)) {
+ const SymLoadStruct symbols[] = {
+ { (PRFuncPtr*) &mSymbols.fResolveMultisampleFramebufferAPPLE, { "ResolveMultisampleFramebufferAPPLE", nullptr } },
+ END_SYMBOLS
+ };
+ fnLoadForExt(symbols, APPLE_framebuffer_multisample);
+ }
+
+ // Load developer symbols, don't fail if we can't find them.
+ const SymLoadStruct devSymbols[] = {
+ { (PRFuncPtr*) &mSymbols.fGetTexImage, { "GetTexImage", nullptr } },
+ { (PRFuncPtr*) &mSymbols.fGetTexLevelParameteriv, { "GetTexLevelParameteriv", nullptr } },
+ END_SYMBOLS
+ };
+ const bool warnOnFailures = ShouldSpew();
+ LoadSymbols(devSymbols, trygl, prefix, warnOnFailures);
+}
+
+#undef CORE_SYMBOL
+#undef CORE_EXT_SYMBOL2
+#undef EXT_SYMBOL2
+#undef EXT_SYMBOL3
+#undef END_SYMBOLS
+
+void
+GLContext::DebugCallback(GLenum source,
+ GLenum type,
+ GLuint id,
+ GLenum severity,
+ GLsizei length,
+ const GLchar* message)
+{
+ nsAutoCString sourceStr;
+ switch (source) {
+ case LOCAL_GL_DEBUG_SOURCE_API:
+ sourceStr = NS_LITERAL_CSTRING("SOURCE_API");
+ break;
+ case LOCAL_GL_DEBUG_SOURCE_WINDOW_SYSTEM:
+ sourceStr = NS_LITERAL_CSTRING("SOURCE_WINDOW_SYSTEM");
+ break;
+ case LOCAL_GL_DEBUG_SOURCE_SHADER_COMPILER:
+ sourceStr = NS_LITERAL_CSTRING("SOURCE_SHADER_COMPILER");
+ break;
+ case LOCAL_GL_DEBUG_SOURCE_THIRD_PARTY:
+ sourceStr = NS_LITERAL_CSTRING("SOURCE_THIRD_PARTY");
+ break;
+ case LOCAL_GL_DEBUG_SOURCE_APPLICATION:
+ sourceStr = NS_LITERAL_CSTRING("SOURCE_APPLICATION");
+ break;
+ case LOCAL_GL_DEBUG_SOURCE_OTHER:
+ sourceStr = NS_LITERAL_CSTRING("SOURCE_OTHER");
+ break;
+ default:
+ sourceStr = nsPrintfCString("<source 0x%04x>", source);
+ break;
+ }
+
+ nsAutoCString typeStr;
+ switch (type) {
+ case LOCAL_GL_DEBUG_TYPE_ERROR:
+ typeStr = NS_LITERAL_CSTRING("TYPE_ERROR");
+ break;
+ case LOCAL_GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
+ typeStr = NS_LITERAL_CSTRING("TYPE_DEPRECATED_BEHAVIOR");
+ break;
+ case LOCAL_GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
+ typeStr = NS_LITERAL_CSTRING("TYPE_UNDEFINED_BEHAVIOR");
+ break;
+ case LOCAL_GL_DEBUG_TYPE_PORTABILITY:
+ typeStr = NS_LITERAL_CSTRING("TYPE_PORTABILITY");
+ break;
+ case LOCAL_GL_DEBUG_TYPE_PERFORMANCE:
+ typeStr = NS_LITERAL_CSTRING("TYPE_PERFORMANCE");
+ break;
+ case LOCAL_GL_DEBUG_TYPE_OTHER:
+ typeStr = NS_LITERAL_CSTRING("TYPE_OTHER");
+ break;
+ case LOCAL_GL_DEBUG_TYPE_MARKER:
+ typeStr = NS_LITERAL_CSTRING("TYPE_MARKER");
+ break;
+ default:
+ typeStr = nsPrintfCString("<type 0x%04x>", type);
+ break;
+ }
+
+ nsAutoCString sevStr;
+ switch (severity) {
+ case LOCAL_GL_DEBUG_SEVERITY_HIGH:
+ sevStr = NS_LITERAL_CSTRING("SEVERITY_HIGH");
+ break;
+ case LOCAL_GL_DEBUG_SEVERITY_MEDIUM:
+ sevStr = NS_LITERAL_CSTRING("SEVERITY_MEDIUM");
+ break;
+ case LOCAL_GL_DEBUG_SEVERITY_LOW:
+ sevStr = NS_LITERAL_CSTRING("SEVERITY_LOW");
+ break;
+ case LOCAL_GL_DEBUG_SEVERITY_NOTIFICATION:
+ sevStr = NS_LITERAL_CSTRING("SEVERITY_NOTIFICATION");
+ break;
+ default:
+ sevStr = nsPrintfCString("<severity 0x%04x>", severity);
+ break;
+ }
+
+ printf_stderr("[KHR_debug: 0x%" PRIxPTR "] ID %u: %s, %s, %s:\n %s\n",
+ (uintptr_t)this,
+ id,
+ sourceStr.BeginReading(),
+ typeStr.BeginReading(),
+ sevStr.BeginReading(),
+ message);
+}
+
+void
+GLContext::InitExtensions()
+{
+ MOZ_ASSERT(IsCurrent());
+
+ std::vector<nsCString> driverExtensionList;
+
+ if (IsFeatureProvidedByCoreSymbols(GLFeature::get_string_indexed)) {
+ GLuint count = 0;
+ GetUIntegerv(LOCAL_GL_NUM_EXTENSIONS, &count);
+ for (GLuint i = 0; i < count; i++) {
+ // This is UTF-8.
+ const char* rawExt = (const char*)fGetStringi(LOCAL_GL_EXTENSIONS, i);
+
+ // We CANNOT use nsDependentCString here, because the spec doesn't guarantee
+ // that the pointers returned are different, only that their contents are.
+ // On Flame, each of these index string queries returns the same address.
+ driverExtensionList.push_back(nsCString(rawExt));
+ }
+ } else {
+ MOZ_ALWAYS_TRUE(!fGetError());
+ const char* rawExts = (const char*)fGetString(LOCAL_GL_EXTENSIONS);
+ MOZ_ALWAYS_TRUE(!fGetError());
+
+ if (rawExts) {
+ nsDependentCString exts(rawExts);
+ SplitByChar(exts, ' ', &driverExtensionList);
+ }
+ }
+
+ const bool shouldDumpExts = ShouldDumpExts();
+ if (shouldDumpExts) {
+ printf_stderr("%i GL driver extensions: (*: recognized)\n",
+ (uint32_t)driverExtensionList.size());
+ }
+
+ MarkBitfieldByStrings(driverExtensionList, shouldDumpExts, sExtensionNames,
+ &mAvailableExtensions);
+
+ if (WorkAroundDriverBugs()) {
+ if (Vendor() == GLVendor::Qualcomm) {
+ // Some Adreno drivers do not report GL_OES_EGL_sync, but they really do support it.
+ MarkExtensionSupported(OES_EGL_sync);
+ }
+
+ if (Vendor() == GLVendor::ATI) {
+ // ATI drivers say this extension exists, but we can't
+ // actually find the EGLImageTargetRenderbufferStorageOES
+ // extension function pointer in the drivers.
+ MarkExtensionUnsupported(OES_EGL_image);
+ }
+
+ if (Vendor() == GLVendor::Imagination &&
+ Renderer() == GLRenderer::SGX540)
+ {
+ // Bug 980048
+ MarkExtensionUnsupported(OES_EGL_sync);
+ }
+
+#ifdef MOZ_WIDGET_ANDROID
+ if (Vendor() == GLVendor::Imagination &&
+ Renderer() == GLRenderer::SGX544MP &&
+ AndroidBridge::Bridge()->GetAPIVersion() < 21)
+ {
+ // Bug 1026404
+ MarkExtensionUnsupported(OES_EGL_image);
+ MarkExtensionUnsupported(OES_EGL_image_external);
+ }
+#endif
+
+ if (Vendor() == GLVendor::ARM &&
+ (Renderer() == GLRenderer::Mali400MP ||
+ Renderer() == GLRenderer::Mali450MP))
+ {
+ // Bug 1264505
+ MarkExtensionUnsupported(OES_EGL_image_external);
+ }
+
+ if (Renderer() == GLRenderer::AndroidEmulator) {
+ // the Android emulator, which we use to run B2G reftests on,
+ // doesn't expose the OES_rgb8_rgba8 extension, but it seems to
+ // support it (tautologically, as it only runs on desktop GL).
+ MarkExtensionSupported(OES_rgb8_rgba8);
+ // there seems to be a similar issue for EXT_texture_format_BGRA8888
+ // on the Android 4.3 emulator
+ MarkExtensionSupported(EXT_texture_format_BGRA8888);
+ }
+
+ if (Vendor() == GLVendor::VMware &&
+ Renderer() == GLRenderer::GalliumLlvmpipe)
+ {
+ // The llvmpipe driver that is used on linux try servers appears to have
+ // buggy support for s3tc/dxt1 compressed textures.
+ // See Bug 975824.
+ MarkExtensionUnsupported(EXT_texture_compression_s3tc);
+ MarkExtensionUnsupported(EXT_texture_compression_dxt1);
+ MarkExtensionUnsupported(ANGLE_texture_compression_dxt3);
+ MarkExtensionUnsupported(ANGLE_texture_compression_dxt5);
+ }
+
+#ifdef XP_MACOSX
+ // Bug 1009642: On OSX Mavericks (10.9), the driver for Intel HD
+ // 3000 appears to be buggy WRT updating sub-images of S3TC
+ // textures with glCompressedTexSubImage2D. Works on Intel HD 4000
+ // and Intel HD 5000/Iris that I tested.
+ // Bug 1124996: Appears to be the same on OSX Yosemite (10.10)
+ if (nsCocoaFeatures::OSXVersionMajor() == 10 &&
+ nsCocoaFeatures::OSXVersionMinor() >= 9 &&
+ Renderer() == GLRenderer::IntelHD3000)
+ {
+ MarkExtensionUnsupported(EXT_texture_compression_s3tc);
+ }
+#endif
+ }
+
+ if (shouldDumpExts) {
+ printf_stderr("\nActivated extensions:\n");
+
+ for (size_t i = 0; i < mAvailableExtensions.size(); i++) {
+ if (!mAvailableExtensions[i])
+ continue;
+
+ const char* ext = sExtensionNames[i];
+ printf_stderr("[%i] %s\n", (uint32_t)i, ext);
+ }
+ }
+}
+
+void
+GLContext::PlatformStartup()
+{
+ RegisterStrongMemoryReporter(new GfxTexturesReporter());
+}
+
+// Common code for checking for both GL extensions and GLX extensions.
+bool
+GLContext::ListHasExtension(const GLubyte* extensions, const char* extension)
+{
+ // fix bug 612572 - we were crashing as we were calling this function with extensions==null
+ if (extensions == nullptr || extension == nullptr)
+ return false;
+
+ const GLubyte* start;
+ GLubyte* where;
+ GLubyte* terminator;
+
+ /* Extension names should not have spaces. */
+ where = (GLubyte*) strchr(extension, ' ');
+ if (where || *extension == '\0')
+ return false;
+
+ /*
+ * It takes a bit of care to be fool-proof about parsing the
+ * OpenGL extensions string. Don't be fooled by sub-strings,
+ * etc.
+ */
+ start = extensions;
+ for (;;) {
+ where = (GLubyte*) strstr((const char*) start, extension);
+ if (!where) {
+ break;
+ }
+ terminator = where + strlen(extension);
+ if (where == start || *(where - 1) == ' ') {
+ if (*terminator == ' ' || *terminator == '\0') {
+ return true;
+ }
+ }
+ start = terminator;
+ }
+ return false;
+}
+
+GLFormats
+GLContext::ChooseGLFormats(const SurfaceCaps& caps) const
+{
+ GLFormats formats;
+
+ // If we're on ES2 hardware and we have an explicit request for 16 bits of color or less
+ // OR we don't support full 8-bit color, return a 4444 or 565 format.
+ bool bpp16 = caps.bpp16;
+ if (IsGLES()) {
+ if (!IsExtensionSupported(OES_rgb8_rgba8))
+ bpp16 = true;
+ } else {
+ // RGB565 is uncommon on desktop, requiring ARB_ES2_compatibility.
+ // Since it's also vanishingly useless there, let's not support it.
+ bpp16 = false;
+ }
+
+ if (bpp16) {
+ MOZ_ASSERT(IsGLES());
+ if (caps.alpha) {
+ formats.color_texInternalFormat = LOCAL_GL_RGBA;
+ formats.color_texFormat = LOCAL_GL_RGBA;
+ formats.color_texType = LOCAL_GL_UNSIGNED_SHORT_4_4_4_4;
+ formats.color_rbFormat = LOCAL_GL_RGBA4;
+ } else {
+ formats.color_texInternalFormat = LOCAL_GL_RGB;
+ formats.color_texFormat = LOCAL_GL_RGB;
+ formats.color_texType = LOCAL_GL_UNSIGNED_SHORT_5_6_5;
+ formats.color_rbFormat = LOCAL_GL_RGB565;
+ }
+ } else {
+ formats.color_texType = LOCAL_GL_UNSIGNED_BYTE;
+
+ if (caps.alpha) {
+ formats.color_texInternalFormat = IsGLES() ? LOCAL_GL_RGBA : LOCAL_GL_RGBA8;
+ formats.color_texFormat = LOCAL_GL_RGBA;
+ formats.color_rbFormat = LOCAL_GL_RGBA8;
+ } else {
+ formats.color_texInternalFormat = IsGLES() ? LOCAL_GL_RGB : LOCAL_GL_RGB8;
+ formats.color_texFormat = LOCAL_GL_RGB;
+ formats.color_rbFormat = LOCAL_GL_RGB8;
+ }
+ }
+
+ uint32_t msaaLevel = gfxPrefs::MSAALevel();
+ GLsizei samples = msaaLevel * msaaLevel;
+ samples = std::min(samples, mMaxSamples);
+
+ // Bug 778765.
+ if (WorkAroundDriverBugs() && samples == 1) {
+ samples = 0;
+ }
+ formats.samples = samples;
+
+
+ // Be clear that these are 0 if unavailable.
+ formats.depthStencil = 0;
+ if (IsSupported(GLFeature::packed_depth_stencil)) {
+ formats.depthStencil = LOCAL_GL_DEPTH24_STENCIL8;
+ }
+
+ formats.depth = 0;
+ if (IsGLES()) {
+ if (IsExtensionSupported(OES_depth24)) {
+ formats.depth = LOCAL_GL_DEPTH_COMPONENT24;
+ } else {
+ formats.depth = LOCAL_GL_DEPTH_COMPONENT16;
+ }
+ } else {
+ formats.depth = LOCAL_GL_DEPTH_COMPONENT24;
+ }
+
+ formats.stencil = LOCAL_GL_STENCIL_INDEX8;
+
+ return formats;
+}
+
+bool
+GLContext::IsFramebufferComplete(GLuint fb, GLenum* pStatus)
+{
+ MOZ_ASSERT(fb);
+
+ ScopedBindFramebuffer autoFB(this, fb);
+ MOZ_ASSERT(fIsFramebuffer(fb));
+
+ GLenum status = fCheckFramebufferStatus(LOCAL_GL_FRAMEBUFFER);
+ if (pStatus)
+ *pStatus = status;
+
+ return status == LOCAL_GL_FRAMEBUFFER_COMPLETE;
+}
+
+void
+GLContext::AttachBuffersToFB(GLuint colorTex, GLuint colorRB,
+ GLuint depthRB, GLuint stencilRB,
+ GLuint fb, GLenum target)
+{
+ MOZ_ASSERT(fb);
+ MOZ_ASSERT( !(colorTex && colorRB) );
+
+ ScopedBindFramebuffer autoFB(this, fb);
+ MOZ_ASSERT(fIsFramebuffer(fb)); // It only counts after being bound.
+
+ if (colorTex) {
+ MOZ_ASSERT(fIsTexture(colorTex));
+ MOZ_ASSERT(target == LOCAL_GL_TEXTURE_2D ||
+ target == LOCAL_GL_TEXTURE_RECTANGLE_ARB);
+ fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER,
+ LOCAL_GL_COLOR_ATTACHMENT0,
+ target,
+ colorTex,
+ 0);
+ } else if (colorRB) {
+ // On the Android 4.3 emulator, IsRenderbuffer may return false incorrectly.
+ MOZ_ASSERT_IF(Renderer() != GLRenderer::AndroidEmulator, fIsRenderbuffer(colorRB));
+ fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER,
+ LOCAL_GL_COLOR_ATTACHMENT0,
+ LOCAL_GL_RENDERBUFFER,
+ colorRB);
+ }
+
+ if (depthRB) {
+ MOZ_ASSERT_IF(Renderer() != GLRenderer::AndroidEmulator, fIsRenderbuffer(depthRB));
+ fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER,
+ LOCAL_GL_DEPTH_ATTACHMENT,
+ LOCAL_GL_RENDERBUFFER,
+ depthRB);
+ }
+
+ if (stencilRB) {
+ MOZ_ASSERT_IF(Renderer() != GLRenderer::AndroidEmulator, fIsRenderbuffer(stencilRB));
+ fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER,
+ LOCAL_GL_STENCIL_ATTACHMENT,
+ LOCAL_GL_RENDERBUFFER,
+ stencilRB);
+ }
+}
+
+bool
+GLContext::AssembleOffscreenFBs(const GLuint colorMSRB,
+ const GLuint depthRB,
+ const GLuint stencilRB,
+ const GLuint texture,
+ GLuint* drawFB_out,
+ GLuint* readFB_out)
+{
+ if (!colorMSRB && !texture) {
+ MOZ_ASSERT(!depthRB && !stencilRB);
+
+ if (drawFB_out)
+ *drawFB_out = 0;
+ if (readFB_out)
+ *readFB_out = 0;
+
+ return true;
+ }
+
+ ScopedBindFramebuffer autoFB(this);
+
+ GLuint drawFB = 0;
+ GLuint readFB = 0;
+
+ if (texture) {
+ readFB = 0;
+ fGenFramebuffers(1, &readFB);
+ BindFB(readFB);
+ fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER,
+ LOCAL_GL_COLOR_ATTACHMENT0,
+ LOCAL_GL_TEXTURE_2D,
+ texture,
+ 0);
+ }
+
+ if (colorMSRB) {
+ drawFB = 0;
+ fGenFramebuffers(1, &drawFB);
+ BindFB(drawFB);
+ fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER,
+ LOCAL_GL_COLOR_ATTACHMENT0,
+ LOCAL_GL_RENDERBUFFER,
+ colorMSRB);
+ } else {
+ drawFB = readFB;
+ }
+ MOZ_ASSERT(GetFB() == drawFB);
+
+ if (depthRB) {
+ fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER,
+ LOCAL_GL_DEPTH_ATTACHMENT,
+ LOCAL_GL_RENDERBUFFER,
+ depthRB);
+ }
+
+ if (stencilRB) {
+ fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER,
+ LOCAL_GL_STENCIL_ATTACHMENT,
+ LOCAL_GL_RENDERBUFFER,
+ stencilRB);
+ }
+
+ // We should be all resized. Check for framebuffer completeness.
+ GLenum status;
+ bool isComplete = true;
+
+ if (!IsFramebufferComplete(drawFB, &status)) {
+ NS_WARNING("DrawFBO: Incomplete");
+ #ifdef MOZ_GL_DEBUG
+ if (ShouldSpew()) {
+ printf_stderr("Framebuffer status: %X\n", status);
+ }
+ #endif
+ isComplete = false;
+ }
+
+ if (!IsFramebufferComplete(readFB, &status)) {
+ NS_WARNING("ReadFBO: Incomplete");
+ #ifdef MOZ_GL_DEBUG
+ if (ShouldSpew()) {
+ printf_stderr("Framebuffer status: %X\n", status);
+ }
+ #endif
+ isComplete = false;
+ }
+
+ if (drawFB_out) {
+ *drawFB_out = drawFB;
+ } else if (drawFB) {
+ NS_RUNTIMEABORT("drawFB created when not requested!");
+ }
+
+ if (readFB_out) {
+ *readFB_out = readFB;
+ } else if (readFB) {
+ NS_RUNTIMEABORT("readFB created when not requested!");
+ }
+
+ return isComplete;
+}
+
+
+void
+GLContext::ClearSafely()
+{
+ // bug 659349 --- we must be very careful here: clearing a GL framebuffer is nontrivial, relies on a lot of state,
+ // and in the case of the backbuffer of a WebGL context, state is exposed to scripts.
+ //
+ // The code here is taken from WebGLContext::ForceClearFramebufferWithDefaultValues, but I didn't find a good way of
+ // sharing code with it. WebGL's code is somewhat performance-critical as it is typically called on every frame, so
+ // WebGL keeps track of GL state to avoid having to query it everytime, and also tries to only do work for actually
+ // present buffers (e.g. stencil buffer). Doing that here seems like premature optimization,
+ // as ClearSafely() is called only when e.g. a canvas is resized, not on every animation frame.
+
+ realGLboolean scissorTestEnabled;
+ realGLboolean ditherEnabled;
+ realGLboolean colorWriteMask[4];
+ realGLboolean depthWriteMask;
+ GLint stencilWriteMaskFront, stencilWriteMaskBack;
+ GLfloat colorClearValue[4];
+ GLfloat depthClearValue;
+ GLint stencilClearValue;
+
+ // save current GL state
+ fGetBooleanv(LOCAL_GL_SCISSOR_TEST, &scissorTestEnabled);
+ fGetBooleanv(LOCAL_GL_DITHER, &ditherEnabled);
+ fGetBooleanv(LOCAL_GL_COLOR_WRITEMASK, colorWriteMask);
+ fGetBooleanv(LOCAL_GL_DEPTH_WRITEMASK, &depthWriteMask);
+ fGetIntegerv(LOCAL_GL_STENCIL_WRITEMASK, &stencilWriteMaskFront);
+ fGetIntegerv(LOCAL_GL_STENCIL_BACK_WRITEMASK, &stencilWriteMaskBack);
+ fGetFloatv(LOCAL_GL_COLOR_CLEAR_VALUE, colorClearValue);
+ fGetFloatv(LOCAL_GL_DEPTH_CLEAR_VALUE, &depthClearValue);
+ fGetIntegerv(LOCAL_GL_STENCIL_CLEAR_VALUE, &stencilClearValue);
+
+ // prepare GL state for clearing
+ fDisable(LOCAL_GL_SCISSOR_TEST);
+ fDisable(LOCAL_GL_DITHER);
+
+ fColorMask(1, 1, 1, 1);
+ fClearColor(0.f, 0.f, 0.f, 0.f);
+
+ fDepthMask(1);
+ fClearDepth(1.0f);
+
+ fStencilMask(0xffffffff);
+ fClearStencil(0);
+
+ // do clear
+ fClear(LOCAL_GL_COLOR_BUFFER_BIT |
+ LOCAL_GL_DEPTH_BUFFER_BIT |
+ LOCAL_GL_STENCIL_BUFFER_BIT);
+
+ // restore GL state after clearing
+ fColorMask(colorWriteMask[0],
+ colorWriteMask[1],
+ colorWriteMask[2],
+ colorWriteMask[3]);
+ fClearColor(colorClearValue[0],
+ colorClearValue[1],
+ colorClearValue[2],
+ colorClearValue[3]);
+
+ fDepthMask(depthWriteMask);
+ fClearDepth(depthClearValue);
+
+ fStencilMaskSeparate(LOCAL_GL_FRONT, stencilWriteMaskFront);
+ fStencilMaskSeparate(LOCAL_GL_BACK, stencilWriteMaskBack);
+ fClearStencil(stencilClearValue);
+
+ if (ditherEnabled)
+ fEnable(LOCAL_GL_DITHER);
+ else
+ fDisable(LOCAL_GL_DITHER);
+
+ if (scissorTestEnabled)
+ fEnable(LOCAL_GL_SCISSOR_TEST);
+ else
+ fDisable(LOCAL_GL_SCISSOR_TEST);
+
+}
+
+void
+GLContext::MarkDestroyed()
+{
+ if (IsDestroyed())
+ return;
+
+ // Null these before they're naturally nulled after dtor, as we want GLContext to
+ // still be alive in *their* dtors.
+ mScreen = nullptr;
+ mBlitHelper = nullptr;
+ mReadTexImageHelper = nullptr;
+
+ if (MakeCurrent()) {
+ mTexGarbageBin->GLContextTeardown();
+ } else {
+ NS_WARNING("MakeCurrent() failed during MarkDestroyed! Skipping GL object teardown.");
+ }
+
+ mSymbols.Zero();
+}
+
+#ifdef MOZ_GL_DEBUG
+/* static */ void
+GLContext::AssertNotPassingStackBufferToTheGL(const void* ptr)
+{
+ int somethingOnTheStack;
+ const void* someStackPtr = &somethingOnTheStack;
+ const int page_bits = 12;
+ intptr_t page = reinterpret_cast<uintptr_t>(ptr) >> page_bits;
+ intptr_t someStackPage = reinterpret_cast<uintptr_t>(someStackPtr) >> page_bits;
+ uintptr_t pageDistance = std::abs(page - someStackPage);
+
+ // Explanation for the "distance <= 1" check here as opposed to just
+ // an equality check.
+ //
+ // Here we assume that pages immediately adjacent to the someStackAddress page,
+ // are also stack pages. That allows to catch the case where the calling frame put
+ // a buffer on the stack, and we just crossed the page boundary. That is likely
+ // to happen, precisely, when using stack arrays. I hit that specifically
+ // with CompositorOGL::Initialize.
+ //
+ // In theory we could be unlucky and wrongly assert here. If that happens,
+ // it will only affect debug builds, and looking at stacks we'll be able to
+ // see that this assert is wrong and revert to the conservative and safe
+ // approach of only asserting when address and someStackAddress are
+ // on the same page.
+ bool isStackAddress = pageDistance <= 1;
+ MOZ_ASSERT(!isStackAddress,
+ "Please don't pass stack arrays to the GL. "
+ "Consider using HeapCopyOfStackArray. "
+ "See bug 1005658.");
+}
+
+void
+GLContext::CreatedProgram(GLContext* aOrigin, GLuint aName)
+{
+ mTrackedPrograms.AppendElement(NamedResource(aOrigin, aName));
+}
+
+void
+GLContext::CreatedShader(GLContext* aOrigin, GLuint aName)
+{
+ mTrackedShaders.AppendElement(NamedResource(aOrigin, aName));
+}
+
+void
+GLContext::CreatedBuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames)
+{
+ for (GLsizei i = 0; i < aCount; ++i) {
+ mTrackedBuffers.AppendElement(NamedResource(aOrigin, aNames[i]));
+ }
+}
+
+void
+GLContext::CreatedQueries(GLContext* aOrigin, GLsizei aCount, GLuint* aNames)
+{
+ for (GLsizei i = 0; i < aCount; ++i) {
+ mTrackedQueries.AppendElement(NamedResource(aOrigin, aNames[i]));
+ }
+}
+
+void
+GLContext::CreatedTextures(GLContext* aOrigin, GLsizei aCount, GLuint* aNames)
+{
+ for (GLsizei i = 0; i < aCount; ++i) {
+ mTrackedTextures.AppendElement(NamedResource(aOrigin, aNames[i]));
+ }
+}
+
+void
+GLContext::CreatedFramebuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames)
+{
+ for (GLsizei i = 0; i < aCount; ++i) {
+ mTrackedFramebuffers.AppendElement(NamedResource(aOrigin, aNames[i]));
+ }
+}
+
+void
+GLContext::CreatedRenderbuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames)
+{
+ for (GLsizei i = 0; i < aCount; ++i) {
+ mTrackedRenderbuffers.AppendElement(NamedResource(aOrigin, aNames[i]));
+ }
+}
+
+static void
+RemoveNamesFromArray(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames, nsTArray<GLContext::NamedResource>& aArray)
+{
+ for (GLsizei j = 0; j < aCount; ++j) {
+ GLuint name = aNames[j];
+ // name 0 can be ignored
+ if (name == 0)
+ continue;
+
+ for (uint32_t i = 0; i < aArray.Length(); ++i) {
+ if (aArray[i].name == name) {
+ aArray.RemoveElementAt(i);
+ break;
+ }
+ }
+ }
+}
+
+void
+GLContext::DeletedProgram(GLContext* aOrigin, GLuint aName)
+{
+ RemoveNamesFromArray(aOrigin, 1, &aName, mTrackedPrograms);
+}
+
+void
+GLContext::DeletedShader(GLContext* aOrigin, GLuint aName)
+{
+ RemoveNamesFromArray(aOrigin, 1, &aName, mTrackedShaders);
+}
+
+void
+GLContext::DeletedBuffers(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames)
+{
+ RemoveNamesFromArray(aOrigin, aCount, aNames, mTrackedBuffers);
+}
+
+void
+GLContext::DeletedQueries(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames)
+{
+ RemoveNamesFromArray(aOrigin, aCount, aNames, mTrackedQueries);
+}
+
+void
+GLContext::DeletedTextures(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames)
+{
+ RemoveNamesFromArray(aOrigin, aCount, aNames, mTrackedTextures);
+}
+
+void
+GLContext::DeletedFramebuffers(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames)
+{
+ RemoveNamesFromArray(aOrigin, aCount, aNames, mTrackedFramebuffers);
+}
+
+void
+GLContext::DeletedRenderbuffers(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames)
+{
+ RemoveNamesFromArray(aOrigin, aCount, aNames, mTrackedRenderbuffers);
+}
+
+static void
+MarkContextDestroyedInArray(GLContext* aContext, nsTArray<GLContext::NamedResource>& aArray)
+{
+ for (uint32_t i = 0; i < aArray.Length(); ++i) {
+ if (aArray[i].origin == aContext)
+ aArray[i].originDeleted = true;
+ }
+}
+
+void
+GLContext::SharedContextDestroyed(GLContext* aChild)
+{
+ MarkContextDestroyedInArray(aChild, mTrackedPrograms);
+ MarkContextDestroyedInArray(aChild, mTrackedShaders);
+ MarkContextDestroyedInArray(aChild, mTrackedTextures);
+ MarkContextDestroyedInArray(aChild, mTrackedFramebuffers);
+ MarkContextDestroyedInArray(aChild, mTrackedRenderbuffers);
+ MarkContextDestroyedInArray(aChild, mTrackedBuffers);
+ MarkContextDestroyedInArray(aChild, mTrackedQueries);
+}
+
+static void
+ReportArrayContents(const char* title, const nsTArray<GLContext::NamedResource>& aArray)
+{
+ if (aArray.Length() == 0)
+ return;
+
+ printf_stderr("%s:\n", title);
+
+ nsTArray<GLContext::NamedResource> copy(aArray);
+ copy.Sort();
+
+ GLContext* lastContext = nullptr;
+ for (uint32_t i = 0; i < copy.Length(); ++i) {
+ if (lastContext != copy[i].origin) {
+ if (lastContext)
+ printf_stderr("\n");
+ printf_stderr(" [%p - %s] ", copy[i].origin, copy[i].originDeleted ? "deleted" : "live");
+ lastContext = copy[i].origin;
+ }
+ printf_stderr("%d ", copy[i].name);
+ }
+ printf_stderr("\n");
+}
+
+void
+GLContext::ReportOutstandingNames()
+{
+ if (!ShouldSpew())
+ return;
+
+ printf_stderr("== GLContext %p Outstanding ==\n", this);
+
+ ReportArrayContents("Outstanding Textures", mTrackedTextures);
+ ReportArrayContents("Outstanding Buffers", mTrackedBuffers);
+ ReportArrayContents("Outstanding Queries", mTrackedQueries);
+ ReportArrayContents("Outstanding Programs", mTrackedPrograms);
+ ReportArrayContents("Outstanding Shaders", mTrackedShaders);
+ ReportArrayContents("Outstanding Framebuffers", mTrackedFramebuffers);
+ ReportArrayContents("Outstanding Renderbuffers", mTrackedRenderbuffers);
+}
+
+#endif /* DEBUG */
+
+void
+GLContext::GuaranteeResolve()
+{
+ if (mScreen) {
+ mScreen->AssureBlitted();
+ }
+ fFinish();
+}
+
+const gfx::IntSize&
+GLContext::OffscreenSize() const
+{
+ MOZ_ASSERT(IsOffscreen());
+ return mScreen->Size();
+}
+
+bool
+GLContext::CreateScreenBufferImpl(const IntSize& size, const SurfaceCaps& caps)
+{
+ UniquePtr<GLScreenBuffer> newScreen = GLScreenBuffer::Create(this, size, caps);
+ if (!newScreen)
+ return false;
+
+ if (!newScreen->Resize(size)) {
+ return false;
+ }
+
+ // This will rebind to 0 (Screen) if needed when
+ // it falls out of scope.
+ ScopedBindFramebuffer autoFB(this);
+
+ mScreen = Move(newScreen);
+
+ return true;
+}
+
+bool
+GLContext::ResizeScreenBuffer(const IntSize& size)
+{
+ if (!IsOffscreenSizeAllowed(size))
+ return false;
+
+ return mScreen->Resize(size);
+}
+
+void
+GLContext::ForceDirtyScreen()
+{
+ ScopedBindFramebuffer autoFB(0);
+
+ BeforeGLDrawCall();
+ // no-op; just pretend we did something
+ AfterGLDrawCall();
+}
+
+void
+GLContext::CleanDirtyScreen()
+{
+ ScopedBindFramebuffer autoFB(0);
+
+ BeforeGLReadCall();
+ // no-op; we just want to make sure the Read FBO is updated if it needs to be
+ AfterGLReadCall();
+}
+
+void
+GLContext::EmptyTexGarbageBin()
+{
+ TexGarbageBin()->EmptyGarbage();
+}
+
+bool
+GLContext::IsOffscreenSizeAllowed(const IntSize& aSize) const
+{
+ int32_t biggerDimension = std::max(aSize.width, aSize.height);
+ int32_t maxAllowed = std::min(mMaxRenderbufferSize, mMaxTextureSize);
+ return biggerDimension <= maxAllowed;
+}
+
+bool
+GLContext::IsOwningThreadCurrent()
+{
+ return PlatformThread::CurrentId() == mOwningThreadId;
+}
+
+GLBlitHelper*
+GLContext::BlitHelper()
+{
+ if (!mBlitHelper) {
+ mBlitHelper.reset(new GLBlitHelper(this));
+ }
+
+ return mBlitHelper.get();
+}
+
+GLReadTexImageHelper*
+GLContext::ReadTexImageHelper()
+{
+ if (!mReadTexImageHelper) {
+ mReadTexImageHelper = MakeUnique<GLReadTexImageHelper>(this);
+ }
+
+ return mReadTexImageHelper.get();
+}
+
+void
+GLContext::FlushIfHeavyGLCallsSinceLastFlush()
+{
+ if (!mHeavyGLCallsSinceLastFlush) {
+ return;
+ }
+ MakeCurrent();
+ fFlush();
+}
+
+/*static*/ bool
+GLContext::ShouldDumpExts()
+{
+ return gfxEnv::GlDumpExtensions();
+}
+
+bool
+DoesStringMatch(const char* aString, const char* aWantedString)
+{
+ if (!aString || !aWantedString)
+ return false;
+
+ const char* occurrence = strstr(aString, aWantedString);
+
+ // aWanted not found
+ if (!occurrence)
+ return false;
+
+ // aWantedString preceded by alpha character
+ if (occurrence != aString && isalpha(*(occurrence-1)))
+ return false;
+
+ // aWantedVendor followed by alpha character
+ const char* afterOccurrence = occurrence + strlen(aWantedString);
+ if (isalpha(*afterOccurrence))
+ return false;
+
+ return true;
+}
+
+/*static*/ bool
+GLContext::ShouldSpew()
+{
+ return gfxEnv::GlSpew();
+}
+
+void
+SplitByChar(const nsACString& str, const char delim, std::vector<nsCString>* const out)
+{
+ uint32_t start = 0;
+ while (true) {
+ int32_t end = str.FindChar(' ', start);
+ if (end == -1)
+ break;
+
+ uint32_t len = (uint32_t)end - start;
+ nsDependentCSubstring substr(str, start, len);
+ out->push_back(nsCString(substr));
+
+ start = end + 1;
+ continue;
+ }
+
+ nsDependentCSubstring substr(str, start);
+ out->push_back(nsCString(substr));
+}
+
+void
+GLContext::Readback(SharedSurface* src, gfx::DataSourceSurface* dest)
+{
+ MOZ_ASSERT(src && dest);
+ MOZ_ASSERT(dest->GetSize() == src->mSize);
+ MOZ_ASSERT(dest->GetFormat() == (src->mHasAlpha ? SurfaceFormat::B8G8R8A8
+ : SurfaceFormat::B8G8R8X8));
+
+ MakeCurrent();
+
+ SharedSurface* prev = GetLockedSurface();
+
+ const bool needsSwap = src != prev;
+ if (needsSwap) {
+ if (prev)
+ prev->UnlockProd();
+ src->LockProd();
+ }
+
+ GLuint tempFB = 0;
+ GLuint tempTex = 0;
+
+ {
+ ScopedBindFramebuffer autoFB(this);
+
+ // We're consuming from the producer side, so which do we use?
+ // Really, we just want a read-only lock, so ConsumerAcquire is the best match.
+ src->ProducerReadAcquire();
+
+ if (src->mAttachType == AttachmentType::Screen) {
+ fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, 0);
+ } else {
+ fGenFramebuffers(1, &tempFB);
+ fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, tempFB);
+
+ switch (src->mAttachType) {
+ case AttachmentType::GLTexture:
+ fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_COLOR_ATTACHMENT0,
+ src->ProdTextureTarget(), src->ProdTexture(), 0);
+ break;
+ case AttachmentType::GLRenderbuffer:
+ fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_COLOR_ATTACHMENT0,
+ LOCAL_GL_RENDERBUFFER, src->ProdRenderbuffer());
+ break;
+ default:
+ MOZ_CRASH("GFX: bad `src->mAttachType`.");
+ }
+
+ DebugOnly<GLenum> status = fCheckFramebufferStatus(LOCAL_GL_FRAMEBUFFER);
+ MOZ_ASSERT(status == LOCAL_GL_FRAMEBUFFER_COMPLETE);
+ }
+
+ if (src->NeedsIndirectReads()) {
+ fGenTextures(1, &tempTex);
+ {
+ ScopedBindTexture autoTex(this, tempTex);
+
+ GLenum format = src->mHasAlpha ? LOCAL_GL_RGBA
+ : LOCAL_GL_RGB;
+ auto width = src->mSize.width;
+ auto height = src->mSize.height;
+ fCopyTexImage2D(LOCAL_GL_TEXTURE_2D, 0, format, 0, 0, width,
+ height, 0);
+ }
+
+ fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER,
+ LOCAL_GL_COLOR_ATTACHMENT0,
+ LOCAL_GL_TEXTURE_2D, tempTex, 0);
+ }
+
+ ReadPixelsIntoDataSurface(this, dest);
+
+ src->ProducerReadRelease();
+ }
+
+ if (tempFB)
+ fDeleteFramebuffers(1, &tempFB);
+
+ if (tempTex) {
+ fDeleteTextures(1, &tempTex);
+ }
+
+ if (needsSwap) {
+ src->UnlockProd();
+ if (prev)
+ prev->LockProd();
+ }
+}
+
+// Do whatever tear-down is necessary after drawing to our offscreen FBO,
+// if it's bound.
+void
+GLContext::AfterGLDrawCall()
+{
+ if (mScreen) {
+ mScreen->AfterDrawCall();
+ }
+ mHeavyGLCallsSinceLastFlush = true;
+}
+
+// Do whatever setup is necessary to read from our offscreen FBO, if it's
+// bound.
+void
+GLContext::BeforeGLReadCall()
+{
+ if (mScreen)
+ mScreen->BeforeReadCall();
+}
+
+void
+GLContext::fBindFramebuffer(GLenum target, GLuint framebuffer)
+{
+ if (!mScreen) {
+ raw_fBindFramebuffer(target, framebuffer);
+ return;
+ }
+
+ switch (target) {
+ case LOCAL_GL_DRAW_FRAMEBUFFER_EXT:
+ mScreen->BindDrawFB(framebuffer);
+ return;
+
+ case LOCAL_GL_READ_FRAMEBUFFER_EXT:
+ mScreen->BindReadFB(framebuffer);
+ return;
+
+ case LOCAL_GL_FRAMEBUFFER:
+ mScreen->BindFB(framebuffer);
+ return;
+
+ default:
+ // Nothing we care about, likely an error.
+ break;
+ }
+
+ raw_fBindFramebuffer(target, framebuffer);
+}
+
+void
+GLContext::fCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x,
+ GLint y, GLsizei width, GLsizei height, GLint border)
+{
+ if (!IsTextureSizeSafeToPassToDriver(target, width, height)) {
+ // pass wrong values to cause the GL to generate GL_INVALID_VALUE.
+ // See bug 737182 and the comment in IsTextureSizeSafeToPassToDriver.
+ level = -1;
+ width = -1;
+ height = -1;
+ border = -1;
+ }
+
+ BeforeGLReadCall();
+ bool didCopyTexImage2D = false;
+ if (mScreen) {
+ didCopyTexImage2D = mScreen->CopyTexImage2D(target, level, internalformat, x,
+ y, width, height, border);
+ }
+
+ if (!didCopyTexImage2D) {
+ raw_fCopyTexImage2D(target, level, internalformat, x, y, width, height,
+ border);
+ }
+ AfterGLReadCall();
+}
+
+void
+GLContext::fGetIntegerv(GLenum pname, GLint* params)
+{
+ switch (pname) {
+ // LOCAL_GL_FRAMEBUFFER_BINDING is equal to
+ // LOCAL_GL_DRAW_FRAMEBUFFER_BINDING_EXT,
+ // so we don't need two cases.
+ case LOCAL_GL_DRAW_FRAMEBUFFER_BINDING_EXT:
+ if (mScreen) {
+ *params = mScreen->GetDrawFB();
+ } else {
+ raw_fGetIntegerv(pname, params);
+ }
+ break;
+
+ case LOCAL_GL_READ_FRAMEBUFFER_BINDING_EXT:
+ if (mScreen) {
+ *params = mScreen->GetReadFB();
+ } else {
+ raw_fGetIntegerv(pname, params);
+ }
+ break;
+
+ case LOCAL_GL_MAX_TEXTURE_SIZE:
+ MOZ_ASSERT(mMaxTextureSize>0);
+ *params = mMaxTextureSize;
+ break;
+
+ case LOCAL_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
+ MOZ_ASSERT(mMaxCubeMapTextureSize>0);
+ *params = mMaxCubeMapTextureSize;
+ break;
+
+ case LOCAL_GL_MAX_RENDERBUFFER_SIZE:
+ MOZ_ASSERT(mMaxRenderbufferSize>0);
+ *params = mMaxRenderbufferSize;
+ break;
+
+ case LOCAL_GL_VIEWPORT:
+ for (size_t i = 0; i < 4; i++) {
+ params[i] = mViewportRect[i];
+ }
+ break;
+
+ case LOCAL_GL_SCISSOR_BOX:
+ for (size_t i = 0; i < 4; i++) {
+ params[i] = mScissorRect[i];
+ }
+ break;
+
+ default:
+ raw_fGetIntegerv(pname, params);
+ break;
+ }
+}
+
+void
+GLContext::fReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
+ GLenum type, GLvoid* pixels)
+{
+ BeforeGLReadCall();
+
+ bool didReadPixels = false;
+ if (mScreen) {
+ didReadPixels = mScreen->ReadPixels(x, y, width, height, format, type, pixels);
+ }
+
+ if (!didReadPixels) {
+ raw_fReadPixels(x, y, width, height, format, type, pixels);
+ }
+
+ AfterGLReadCall();
+
+ // Check if GL is giving back 1.0 alpha for
+ // RGBA reads to RGBA images from no-alpha buffers.
+#ifdef XP_MACOSX
+ if (WorkAroundDriverBugs() &&
+ Vendor() == gl::GLVendor::NVIDIA &&
+ format == LOCAL_GL_RGBA &&
+ type == LOCAL_GL_UNSIGNED_BYTE &&
+ !IsCoreProfile() &&
+ width && height)
+ {
+ GLint alphaBits = 0;
+ fGetIntegerv(LOCAL_GL_ALPHA_BITS, &alphaBits);
+ if (!alphaBits) {
+ const uint32_t alphaMask = 0xff000000;
+
+ uint32_t* itr = (uint32_t*)pixels;
+ uint32_t testPixel = *itr;
+ if ((testPixel & alphaMask) != alphaMask) {
+ // We need to set the alpha channel to 1.0 manually.
+ uint32_t* itrEnd = itr + width*height; // Stride is guaranteed to be width*4.
+
+ for (; itr != itrEnd; itr++) {
+ *itr |= alphaMask;
+ }
+ }
+ }
+ }
+#endif
+}
+
+void
+GLContext::fDeleteFramebuffers(GLsizei n, const GLuint* names)
+{
+ if (mScreen) {
+ // Notify mScreen which framebuffers we're deleting.
+ // Otherwise, we will get framebuffer binding mispredictions.
+ for (int i = 0; i < n; i++) {
+ mScreen->DeletingFB(names[i]);
+ }
+ }
+
+ // Avoid crash by flushing before glDeleteFramebuffers. See bug 1194923.
+ if (mNeedsFlushBeforeDeleteFB) {
+ fFlush();
+ }
+
+ if (n == 1 && *names == 0) {
+ // Deleting framebuffer 0 causes hangs on the DROID. See bug 623228.
+ } else {
+ raw_fDeleteFramebuffers(n, names);
+ }
+ TRACKING_CONTEXT(DeletedFramebuffers(this, n, names));
+}
+
+#ifdef MOZ_WIDGET_ANDROID
+/**
+ * Conservatively estimate whether there is enough available
+ * contiguous virtual address space to map a newly allocated texture.
+ */
+static bool
+WillTextureMapSucceed(GLsizei width, GLsizei height, GLenum format, GLenum type)
+{
+ bool willSucceed = false;
+ // Some drivers leave large gaps between textures, so require
+ // there to be double the actual size of the texture available.
+ size_t size = width * height * GetBytesPerTexel(format, type) * 2;
+
+ void *p = mmap(nullptr, size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ if (p != MAP_FAILED) {
+ willSucceed = true;
+ munmap(p, size);
+ }
+
+ return willSucceed;
+}
+#endif // MOZ_WIDGET_ANDROID
+
+void
+GLContext::fTexImage2D(GLenum target, GLint level, GLint internalformat,
+ GLsizei width, GLsizei height, GLint border,
+ GLenum format, GLenum type, const GLvoid* pixels) {
+ if (!IsTextureSizeSafeToPassToDriver(target, width, height)) {
+ // pass wrong values to cause the GL to generate GL_INVALID_VALUE.
+ // See bug 737182 and the comment in IsTextureSizeSafeToPassToDriver.
+ level = -1;
+ width = -1;
+ height = -1;
+ border = -1;
+ }
+#if MOZ_WIDGET_ANDROID
+ if (mTextureAllocCrashesOnMapFailure) {
+ // We have no way of knowing whether this texture already has
+ // storage allocated for it, and therefore whether this check
+ // is necessary. We must therefore assume it does not and
+ // always perform the check.
+ if (!WillTextureMapSucceed(width, height, internalformat, type)) {
+ return;
+ }
+ }
+#endif
+ raw_fTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+}
+
+GLuint
+GLContext::GetDrawFB()
+{
+ if (mScreen)
+ return mScreen->GetDrawFB();
+
+ GLuint ret = 0;
+ GetUIntegerv(LOCAL_GL_DRAW_FRAMEBUFFER_BINDING_EXT, &ret);
+ return ret;
+}
+
+GLuint
+GLContext::GetReadFB()
+{
+ if (mScreen)
+ return mScreen->GetReadFB();
+
+ GLenum bindEnum = IsSupported(GLFeature::split_framebuffer)
+ ? LOCAL_GL_READ_FRAMEBUFFER_BINDING_EXT
+ : LOCAL_GL_FRAMEBUFFER_BINDING;
+
+ GLuint ret = 0;
+ GetUIntegerv(bindEnum, &ret);
+ return ret;
+}
+
+GLuint
+GLContext::GetFB()
+{
+ if (mScreen) {
+ // This has a very important extra assert that checks that we're
+ // not accidentally ignoring a situation where the draw and read
+ // FBs differ.
+ return mScreen->GetFB();
+ }
+
+ GLuint ret = 0;
+ GetUIntegerv(LOCAL_GL_FRAMEBUFFER_BINDING, &ret);
+ return ret;
+}
+
+bool
+GLContext::InitOffscreen(const gfx::IntSize& size, const SurfaceCaps& caps)
+{
+ if (!CreateScreenBuffer(size, caps))
+ return false;
+
+ MakeCurrent();
+ fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, 0);
+ fScissor(0, 0, size.width, size.height);
+ fViewport(0, 0, size.width, size.height);
+
+ mCaps = mScreen->mCaps;
+ MOZ_ASSERT(!mCaps.any);
+
+ return true;
+}
+
+bool
+GLContext::IsDrawingToDefaultFramebuffer()
+{
+ return Screen()->IsDrawFramebufferDefault();
+}
+
+GLuint
+CreateTexture(GLContext* aGL, GLenum aInternalFormat, GLenum aFormat,
+ GLenum aType, const gfx::IntSize& aSize, bool linear)
+{
+ GLuint tex = 0;
+ aGL->fGenTextures(1, &tex);
+ ScopedBindTexture autoTex(aGL, tex);
+
+ aGL->fTexParameteri(LOCAL_GL_TEXTURE_2D,
+ LOCAL_GL_TEXTURE_MIN_FILTER, linear ? LOCAL_GL_LINEAR
+ : LOCAL_GL_NEAREST);
+ aGL->fTexParameteri(LOCAL_GL_TEXTURE_2D,
+ LOCAL_GL_TEXTURE_MAG_FILTER, linear ? LOCAL_GL_LINEAR
+ : LOCAL_GL_NEAREST);
+ aGL->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_S,
+ LOCAL_GL_CLAMP_TO_EDGE);
+ aGL->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_WRAP_T,
+ LOCAL_GL_CLAMP_TO_EDGE);
+
+ aGL->fTexImage2D(LOCAL_GL_TEXTURE_2D,
+ 0,
+ aInternalFormat,
+ aSize.width, aSize.height,
+ 0,
+ aFormat,
+ aType,
+ nullptr);
+
+ return tex;
+}
+
+GLuint
+CreateTextureForOffscreen(GLContext* aGL, const GLFormats& aFormats,
+ const gfx::IntSize& aSize)
+{
+ MOZ_ASSERT(aFormats.color_texInternalFormat);
+ MOZ_ASSERT(aFormats.color_texFormat);
+ MOZ_ASSERT(aFormats.color_texType);
+
+ GLenum internalFormat = aFormats.color_texInternalFormat;
+ GLenum unpackFormat = aFormats.color_texFormat;
+ GLenum unpackType = aFormats.color_texType;
+ if (aGL->IsANGLE()) {
+ MOZ_ASSERT(internalFormat == LOCAL_GL_RGBA);
+ MOZ_ASSERT(unpackFormat == LOCAL_GL_RGBA);
+ MOZ_ASSERT(unpackType == LOCAL_GL_UNSIGNED_BYTE);
+ internalFormat = LOCAL_GL_BGRA_EXT;
+ unpackFormat = LOCAL_GL_BGRA_EXT;
+ }
+
+ return CreateTexture(aGL, internalFormat, unpackFormat, unpackType, aSize);
+}
+
+uint32_t
+GetBytesPerTexel(GLenum format, GLenum type)
+{
+ // If there is no defined format or type, we're not taking up any memory
+ if (!format || !type) {
+ return 0;
+ }
+
+ if (format == LOCAL_GL_DEPTH_COMPONENT) {
+ if (type == LOCAL_GL_UNSIGNED_SHORT)
+ return 2;
+ else if (type == LOCAL_GL_UNSIGNED_INT)
+ return 4;
+ } else if (format == LOCAL_GL_DEPTH_STENCIL) {
+ if (type == LOCAL_GL_UNSIGNED_INT_24_8_EXT)
+ return 4;
+ }
+
+ if (type == LOCAL_GL_UNSIGNED_BYTE || type == LOCAL_GL_FLOAT || type == LOCAL_GL_UNSIGNED_INT_8_8_8_8_REV) {
+ uint32_t multiplier = type == LOCAL_GL_UNSIGNED_BYTE ? 1 : 4;
+ switch (format) {
+ case LOCAL_GL_ALPHA:
+ case LOCAL_GL_LUMINANCE:
+ return 1 * multiplier;
+ case LOCAL_GL_LUMINANCE_ALPHA:
+ return 2 * multiplier;
+ case LOCAL_GL_RGB:
+ return 3 * multiplier;
+ case LOCAL_GL_RGBA:
+ case LOCAL_GL_BGRA_EXT:
+ return 4 * multiplier;
+ default:
+ break;
+ }
+ } else if (type == LOCAL_GL_UNSIGNED_SHORT_4_4_4_4 ||
+ type == LOCAL_GL_UNSIGNED_SHORT_5_5_5_1 ||
+ type == LOCAL_GL_UNSIGNED_SHORT_5_6_5)
+ {
+ return 2;
+ }
+
+ gfxCriticalError() << "Unknown texture type " << type << " or format " << format;
+ return 0;
+}
+
+} /* namespace gl */
+} /* namespace mozilla */
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-01 13:46:56 +0000