mirror of
https://github.com/mpv-player/mpv
synced 2025-01-09 00:19:32 +00:00
20e9c66fa9
With earlier commit f8e62d3d82 ("egl_helpers: fix create_context
fallback behavior") we added a fallback for creating OpenGL context
while EGL_KHR_create_context is missing.
While it looked correct at first, it is missing the eglMakeCurrent()
call after creating the EGL context. Thus calling glGetString() fails.
Instead of doing that we can just remove some code - simply pass the
CLIENT_VERSION 2, as attributes which is honoured by EGL regardless of
the client API. This allows us to remove the special case and drop some
code.
v2:
- mpgl_preferred_gl_versions -> mpgl_min_required_gl_versions
Signed-off-by: Emil Velikov <emil.l.velikov@gmail.com>
670 lines
21 KiB
C
670 lines
21 KiB
C
/*
|
|
* common OpenGL routines
|
|
*
|
|
* copyleft (C) 2005-2010 Reimar Döffinger <Reimar.Doeffinger@gmx.de>
|
|
* Special thanks go to the xine team and Matthias Hopf, whose video_out_opengl.c
|
|
* gave me lots of good ideas.
|
|
*
|
|
* This file is part of mpv.
|
|
*
|
|
* mpv is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* mpv is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with mpv. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include <math.h>
|
|
#include <assert.h>
|
|
|
|
#include "common.h"
|
|
#include "common/common.h"
|
|
#include "utils.h"
|
|
|
|
// This guesses if the current GL context is a suspected software renderer.
|
|
static bool is_software_gl(GL *gl)
|
|
{
|
|
const char *renderer = gl->GetString(GL_RENDERER);
|
|
const char *vendor = gl->GetString(GL_VENDOR);
|
|
return !(renderer && vendor) ||
|
|
strcmp(renderer, "Software Rasterizer") == 0 ||
|
|
strstr(renderer, "llvmpipe") ||
|
|
strstr(renderer, "softpipe") ||
|
|
strcmp(vendor, "Microsoft Corporation") == 0 ||
|
|
strcmp(renderer, "Mesa X11") == 0 ||
|
|
strcmp(renderer, "Apple Software Renderer") == 0;
|
|
}
|
|
|
|
static void GLAPIENTRY dummy_glBindFramebuffer(GLenum target, GLuint framebuffer)
|
|
{
|
|
assert(framebuffer == 0);
|
|
}
|
|
|
|
#define FN_OFFS(name) offsetof(GL, name)
|
|
|
|
#define DEF_FN(name) {FN_OFFS(name), "gl" # name}
|
|
#define DEF_FN_NAME(name, str) {FN_OFFS(name), str}
|
|
|
|
struct gl_function {
|
|
ptrdiff_t offset;
|
|
char *name;
|
|
};
|
|
|
|
struct gl_functions {
|
|
const char *extension; // introduced with this extension in any version
|
|
int provides; // bitfield of MPGL_CAP_* constants
|
|
int ver_core; // introduced as required function
|
|
int ver_es_core; // introduced as required GL ES function
|
|
int ver_exclude; // not applicable to versions >= ver_exclude
|
|
int ver_es_exclude; // same for GLES
|
|
const struct gl_function *functions;
|
|
};
|
|
|
|
#define MAX_FN_COUNT 100 // max functions per gl_functions section
|
|
|
|
// Note: to keep the number of sections low, some functions are in multiple
|
|
// sections (if there are tricky combinations of GL/ES versions)
|
|
static const struct gl_functions gl_functions[] = {
|
|
// GL 2.1+ desktop and GLES 2.0+ (anything we support)
|
|
// Probably all of these are in GL 2.0 too, but we require GLSL 120.
|
|
{
|
|
.ver_core = 210,
|
|
.ver_es_core = 200,
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(ActiveTexture),
|
|
DEF_FN(AttachShader),
|
|
DEF_FN(BindAttribLocation),
|
|
DEF_FN(BindBuffer),
|
|
DEF_FN(BindTexture),
|
|
DEF_FN(BlendFuncSeparate),
|
|
DEF_FN(BufferData),
|
|
DEF_FN(BufferSubData),
|
|
DEF_FN(Clear),
|
|
DEF_FN(ClearColor),
|
|
DEF_FN(CompileShader),
|
|
DEF_FN(CreateProgram),
|
|
DEF_FN(CreateShader),
|
|
DEF_FN(DeleteBuffers),
|
|
DEF_FN(DeleteProgram),
|
|
DEF_FN(DeleteShader),
|
|
DEF_FN(DeleteTextures),
|
|
DEF_FN(Disable),
|
|
DEF_FN(DisableVertexAttribArray),
|
|
DEF_FN(DrawArrays),
|
|
DEF_FN(Enable),
|
|
DEF_FN(EnableVertexAttribArray),
|
|
DEF_FN(Finish),
|
|
DEF_FN(Flush),
|
|
DEF_FN(GenBuffers),
|
|
DEF_FN(GenTextures),
|
|
DEF_FN(GetAttribLocation),
|
|
DEF_FN(GetError),
|
|
DEF_FN(GetIntegerv),
|
|
DEF_FN(GetProgramInfoLog),
|
|
DEF_FN(GetProgramiv),
|
|
DEF_FN(GetShaderInfoLog),
|
|
DEF_FN(GetShaderiv),
|
|
DEF_FN(GetString),
|
|
DEF_FN(GetUniformLocation),
|
|
DEF_FN(LinkProgram),
|
|
DEF_FN(PixelStorei),
|
|
DEF_FN(ReadPixels),
|
|
DEF_FN(Scissor),
|
|
DEF_FN(ShaderSource),
|
|
DEF_FN(TexImage2D),
|
|
DEF_FN(TexParameteri),
|
|
DEF_FN(TexSubImage2D),
|
|
DEF_FN(Uniform1f),
|
|
DEF_FN(Uniform2f),
|
|
DEF_FN(Uniform3f),
|
|
DEF_FN(Uniform1i),
|
|
DEF_FN(UniformMatrix2fv),
|
|
DEF_FN(UniformMatrix3fv),
|
|
DEF_FN(UseProgram),
|
|
DEF_FN(VertexAttribPointer),
|
|
DEF_FN(Viewport),
|
|
{0}
|
|
},
|
|
},
|
|
// GL 2.1+ desktop only (and GLSL 120 shaders)
|
|
{
|
|
.ver_core = 210,
|
|
.provides = MPGL_CAP_ROW_LENGTH | MPGL_CAP_1D_TEX,
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(GetTexLevelParameteriv),
|
|
DEF_FN(ReadBuffer),
|
|
DEF_FN(TexImage1D),
|
|
DEF_FN(UnmapBuffer),
|
|
{0}
|
|
},
|
|
},
|
|
// GL 2.1 has this as extension only.
|
|
{
|
|
.ver_exclude = 300,
|
|
.ver_es_exclude = 300,
|
|
.extension = "GL_ARB_map_buffer_range",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(MapBufferRange),
|
|
{0}
|
|
},
|
|
},
|
|
// GL 3.0+ and ES 3.x core only functions.
|
|
{
|
|
.ver_core = 300,
|
|
.ver_es_core = 300,
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(BindBufferBase),
|
|
DEF_FN(BlitFramebuffer),
|
|
DEF_FN(GetStringi),
|
|
DEF_FN(MapBufferRange),
|
|
// for ES 3.0
|
|
DEF_FN(ReadBuffer),
|
|
DEF_FN(UnmapBuffer),
|
|
{0}
|
|
},
|
|
},
|
|
// For ES 3.1 core
|
|
{
|
|
.ver_es_core = 310,
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(GetTexLevelParameteriv),
|
|
{0}
|
|
},
|
|
},
|
|
{
|
|
.ver_core = 210,
|
|
.ver_es_core = 300,
|
|
.provides = MPGL_CAP_3D_TEX,
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(TexImage3D),
|
|
{0}
|
|
},
|
|
},
|
|
// Useful for ES 2.0
|
|
{
|
|
.ver_core = 110,
|
|
.ver_es_core = 300,
|
|
.extension = "GL_EXT_unpack_subimage",
|
|
.provides = MPGL_CAP_ROW_LENGTH,
|
|
},
|
|
// Framebuffers, extension in GL 2.x, core in GL 3.x core.
|
|
{
|
|
.ver_core = 300,
|
|
.ver_es_core = 200,
|
|
.extension = "GL_ARB_framebuffer_object",
|
|
.provides = MPGL_CAP_FB,
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(BindFramebuffer),
|
|
DEF_FN(GenFramebuffers),
|
|
DEF_FN(DeleteFramebuffers),
|
|
DEF_FN(CheckFramebufferStatus),
|
|
DEF_FN(FramebufferTexture2D),
|
|
DEF_FN(GetFramebufferAttachmentParameteriv),
|
|
{0}
|
|
},
|
|
},
|
|
// VAOs, extension in GL 2.x, core in GL 3.x core.
|
|
{
|
|
.ver_core = 300,
|
|
.ver_es_core = 300,
|
|
.extension = "GL_ARB_vertex_array_object",
|
|
.provides = MPGL_CAP_VAO,
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(GenVertexArrays),
|
|
DEF_FN(BindVertexArray),
|
|
DEF_FN(DeleteVertexArrays),
|
|
{0}
|
|
}
|
|
},
|
|
// GL_RED / GL_RG textures, extension in GL 2.x, core in GL 3.x core.
|
|
{
|
|
.ver_core = 300,
|
|
.ver_es_core = 300,
|
|
.extension = "GL_ARB_texture_rg",
|
|
.provides = MPGL_CAP_TEX_RG,
|
|
},
|
|
{
|
|
.ver_core = 300,
|
|
.ver_es_core = 300,
|
|
.extension = "GL_EXT_texture_rg",
|
|
.provides = MPGL_CAP_TEX_RG,
|
|
},
|
|
// GL_R16 etc.
|
|
{
|
|
.extension = "GL_EXT_texture_norm16",
|
|
.provides = MPGL_CAP_EXT16,
|
|
.ver_exclude = 1, // never in desktop GL
|
|
},
|
|
// Float texture support for GL 2.x
|
|
{
|
|
.extension = "GL_ARB_texture_float",
|
|
.provides = MPGL_CAP_ARB_FLOAT,
|
|
.ver_exclude = 300,
|
|
.ver_es_exclude = 1,
|
|
},
|
|
// 16 bit float textures that can be rendered to in GLES
|
|
{
|
|
.extension = "GL_EXT_color_buffer_half_float",
|
|
.provides = MPGL_CAP_EXT_CR_HFLOAT,
|
|
.ver_exclude = 1,
|
|
.ver_es_exclude = 320,
|
|
},
|
|
{
|
|
.ver_core = 320,
|
|
.ver_es_core = 300,
|
|
.extension = "GL_ARB_sync",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(FenceSync),
|
|
DEF_FN(ClientWaitSync),
|
|
DEF_FN(DeleteSync),
|
|
{0}
|
|
},
|
|
},
|
|
{
|
|
.ver_core = 330,
|
|
.extension = "GL_ARB_timer_query",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(GenQueries),
|
|
DEF_FN(DeleteQueries),
|
|
DEF_FN(BeginQuery),
|
|
DEF_FN(EndQuery),
|
|
DEF_FN(QueryCounter),
|
|
DEF_FN(IsQuery),
|
|
DEF_FN(GetQueryObjectiv),
|
|
DEF_FN(GetQueryObjecti64v),
|
|
DEF_FN(GetQueryObjectuiv),
|
|
DEF_FN(GetQueryObjectui64v),
|
|
{0}
|
|
},
|
|
},
|
|
{
|
|
.extension = "GL_EXT_disjoint_timer_query",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN_NAME(GenQueries, "glGenQueriesEXT"),
|
|
DEF_FN_NAME(DeleteQueries, "glDeleteQueriesEXT"),
|
|
DEF_FN_NAME(BeginQuery, "glBeginQueryEXT"),
|
|
DEF_FN_NAME(EndQuery, "glEndQueryEXT"),
|
|
DEF_FN_NAME(QueryCounter, "glQueryCounterEXT"),
|
|
DEF_FN_NAME(IsQuery, "glIsQueryEXT"),
|
|
DEF_FN_NAME(GetQueryObjectiv, "glGetQueryObjectivEXT"),
|
|
DEF_FN_NAME(GetQueryObjecti64v, "glGetQueryObjecti64vEXT"),
|
|
DEF_FN_NAME(GetQueryObjectuiv, "glGetQueryObjectuivEXT"),
|
|
DEF_FN_NAME(GetQueryObjectui64v, "glGetQueryObjectui64vEXT"),
|
|
{0}
|
|
},
|
|
},
|
|
{
|
|
.ver_core = 430,
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(InvalidateTexImage),
|
|
{0}
|
|
},
|
|
},
|
|
{
|
|
.ver_core = 430,
|
|
.ver_es_core = 300,
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(InvalidateFramebuffer),
|
|
{0}
|
|
},
|
|
},
|
|
{
|
|
.ver_core = 410,
|
|
.ver_es_core = 300,
|
|
.extension = "GL_ARB_get_program_binary",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(GetProgramBinary),
|
|
DEF_FN(ProgramBinary),
|
|
{0}
|
|
},
|
|
},
|
|
{
|
|
.ver_core = 440,
|
|
.extension = "GL_ARB_buffer_storage",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(BufferStorage),
|
|
{0}
|
|
},
|
|
},
|
|
{
|
|
.ver_core = 420,
|
|
.extension = "GL_ARB_shader_image_load_store",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(BindImageTexture),
|
|
DEF_FN(MemoryBarrier),
|
|
{0}
|
|
},
|
|
},
|
|
{
|
|
.ver_core = 310,
|
|
.extension = "GL_ARB_uniform_buffer_object",
|
|
.provides = MPGL_CAP_UBO,
|
|
},
|
|
{
|
|
.ver_core = 430,
|
|
.extension = "GL_ARB_shader_storage_buffer_object",
|
|
.provides = MPGL_CAP_SSBO,
|
|
},
|
|
{
|
|
.ver_core = 430,
|
|
.extension = "GL_ARB_compute_shader",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(DispatchCompute),
|
|
{0},
|
|
},
|
|
},
|
|
{
|
|
.ver_core = 430,
|
|
.extension = "GL_ARB_arrays_of_arrays",
|
|
.provides = MPGL_CAP_NESTED_ARRAY,
|
|
},
|
|
// Swap control, always an OS specific extension
|
|
// The OSX code loads this manually.
|
|
{
|
|
.extension = "GLX_SGI_swap_control",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN_NAME(SwapInterval, "glXSwapIntervalSGI"),
|
|
{0},
|
|
},
|
|
},
|
|
// This one overrides GLX_SGI_swap_control on platforms using mesa. The
|
|
// only difference is that it supports glXSwapInterval(0).
|
|
{
|
|
.extension = "GLX_MESA_swap_control",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN_NAME(SwapInterval, "glXSwapIntervalMESA"),
|
|
{0},
|
|
},
|
|
},
|
|
{
|
|
.extension = "WGL_EXT_swap_control",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN_NAME(SwapInterval, "wglSwapIntervalEXT"),
|
|
{0},
|
|
},
|
|
},
|
|
{
|
|
.extension = "GLX_SGI_video_sync",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN_NAME(GetVideoSync, "glXGetVideoSyncSGI"),
|
|
DEF_FN_NAME(WaitVideoSync, "glXWaitVideoSyncSGI"),
|
|
{0},
|
|
},
|
|
},
|
|
// For gl_hwdec_vdpau.c
|
|
// http://www.opengl.org/registry/specs/NV/vdpau_interop.txt
|
|
{
|
|
.extension = "GL_NV_vdpau_interop",
|
|
.provides = MPGL_CAP_VDPAU,
|
|
.functions = (const struct gl_function[]) {
|
|
// (only functions needed by us)
|
|
DEF_FN(VDPAUInitNV),
|
|
DEF_FN(VDPAUFiniNV),
|
|
DEF_FN(VDPAURegisterOutputSurfaceNV),
|
|
DEF_FN(VDPAURegisterVideoSurfaceNV),
|
|
DEF_FN(VDPAUUnregisterSurfaceNV),
|
|
DEF_FN(VDPAUSurfaceAccessNV),
|
|
DEF_FN(VDPAUMapSurfacesNV),
|
|
DEF_FN(VDPAUUnmapSurfacesNV),
|
|
{0}
|
|
},
|
|
},
|
|
#if HAVE_GL_DXINTEROP
|
|
{
|
|
.extension = "WGL_NV_DX_interop",
|
|
.provides = MPGL_CAP_DXINTEROP,
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN_NAME(DXSetResourceShareHandleNV, "wglDXSetResourceShareHandleNV"),
|
|
DEF_FN_NAME(DXOpenDeviceNV, "wglDXOpenDeviceNV"),
|
|
DEF_FN_NAME(DXCloseDeviceNV, "wglDXCloseDeviceNV"),
|
|
DEF_FN_NAME(DXRegisterObjectNV, "wglDXRegisterObjectNV"),
|
|
DEF_FN_NAME(DXUnregisterObjectNV, "wglDXUnregisterObjectNV"),
|
|
DEF_FN_NAME(DXLockObjectsNV, "wglDXLockObjectsNV"),
|
|
DEF_FN_NAME(DXUnlockObjectsNV, "wglDXUnlockObjectsNV"),
|
|
{0}
|
|
},
|
|
},
|
|
#endif
|
|
// Apple Packed YUV Formats
|
|
// For gl_hwdec_vda.c
|
|
// http://www.opengl.org/registry/specs/APPLE/rgb_422.txt
|
|
{
|
|
.extension = "GL_APPLE_rgb_422",
|
|
.provides = MPGL_CAP_APPLE_RGB_422,
|
|
},
|
|
{
|
|
.ver_core = 430,
|
|
.extension = "GL_ARB_debug_output",
|
|
.provides = MPGL_CAP_DEBUG,
|
|
.functions = (const struct gl_function[]) {
|
|
// (only functions needed by us)
|
|
DEF_FN(DebugMessageCallback),
|
|
{0}
|
|
},
|
|
},
|
|
// These don't exist - they are for the sake of mpv internals, and libmpv
|
|
// interaction (see libmpv/opengl_cb.h).
|
|
// This is not used by the render API, only the deprecated opengl-cb API.
|
|
{
|
|
.extension = "GL_MP_MPGetNativeDisplay",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(MPGetNativeDisplay),
|
|
{0}
|
|
},
|
|
},
|
|
// Same, but using the old name.
|
|
{
|
|
.extension = "GL_MP_D3D_interfaces",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN_NAME(MPGetNativeDisplay, "glMPGetD3DInterface"),
|
|
{0}
|
|
},
|
|
},
|
|
{
|
|
.extension = "GL_ANGLE_translated_shader_source",
|
|
.functions = (const struct gl_function[]) {
|
|
DEF_FN(GetTranslatedShaderSourceANGLE),
|
|
{0}
|
|
},
|
|
},
|
|
};
|
|
|
|
#undef FN_OFFS
|
|
#undef DEF_FN_HARD
|
|
#undef DEF_FN
|
|
#undef DEF_FN_NAME
|
|
|
|
// Fill the GL struct with function pointers and extensions from the current
|
|
// GL context. Called by the backend.
|
|
// get_fn: function to resolve function names
|
|
// ext2: an extra extension string
|
|
// log: used to output messages
|
|
void mpgl_load_functions2(GL *gl, void *(*get_fn)(void *ctx, const char *n),
|
|
void *fn_ctx, const char *ext2, struct mp_log *log)
|
|
{
|
|
talloc_free(gl->extensions);
|
|
*gl = (GL) {
|
|
.extensions = talloc_strdup(gl, ext2 ? ext2 : ""),
|
|
};
|
|
|
|
gl->GetString = get_fn(fn_ctx, "glGetString");
|
|
if (!gl->GetString) {
|
|
mp_err(log, "Can't load OpenGL functions.\n");
|
|
goto error;
|
|
}
|
|
|
|
int major = 0, minor = 0;
|
|
const char *version_string = gl->GetString(GL_VERSION);
|
|
if (!version_string) {
|
|
mp_fatal(log, "glGetString(GL_VERSION) returned NULL.\n");
|
|
goto error;
|
|
}
|
|
mp_verbose(log, "GL_VERSION='%s'\n", version_string);
|
|
if (strncmp(version_string, "OpenGL ES ", 10) == 0) {
|
|
version_string += 10;
|
|
gl->es = 100;
|
|
}
|
|
if (sscanf(version_string, "%d.%d", &major, &minor) < 2)
|
|
goto error;
|
|
gl->version = MPGL_VER(major, minor);
|
|
mp_verbose(log, "Detected %s %d.%d.\n", gl->es ? "GLES" : "desktop OpenGL",
|
|
major, minor);
|
|
|
|
if (gl->es) {
|
|
gl->es = gl->version;
|
|
gl->version = 0;
|
|
if (gl->es < 200) {
|
|
mp_fatal(log, "At least GLESv2 required.\n");
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
mp_verbose(log, "GL_VENDOR='%s'\n", gl->GetString(GL_VENDOR));
|
|
mp_verbose(log, "GL_RENDERER='%s'\n", gl->GetString(GL_RENDERER));
|
|
const char *shader = gl->GetString(GL_SHADING_LANGUAGE_VERSION);
|
|
if (shader)
|
|
mp_verbose(log, "GL_SHADING_LANGUAGE_VERSION='%s'\n", shader);
|
|
|
|
if (gl->version >= 300) {
|
|
gl->GetStringi = get_fn(fn_ctx, "glGetStringi");
|
|
gl->GetIntegerv = get_fn(fn_ctx, "glGetIntegerv");
|
|
|
|
if (!(gl->GetStringi && gl->GetIntegerv))
|
|
goto error;
|
|
|
|
GLint exts;
|
|
gl->GetIntegerv(GL_NUM_EXTENSIONS, &exts);
|
|
for (int n = 0; n < exts; n++) {
|
|
const char *ext = gl->GetStringi(GL_EXTENSIONS, n);
|
|
gl->extensions = talloc_asprintf_append(gl->extensions, " %s", ext);
|
|
}
|
|
|
|
} else {
|
|
const char *ext = (char*)gl->GetString(GL_EXTENSIONS);
|
|
gl->extensions = talloc_asprintf_append(gl->extensions, " %s", ext);
|
|
}
|
|
|
|
mp_dbg(log, "Combined OpenGL extensions string:\n%s\n", gl->extensions);
|
|
|
|
for (int n = 0; n < MP_ARRAY_SIZE(gl_functions); n++) {
|
|
const struct gl_functions *section = &gl_functions[n];
|
|
int version = gl->es ? gl->es : gl->version;
|
|
int ver_core = gl->es ? section->ver_es_core : section->ver_core;
|
|
|
|
// NOTE: Function entrypoints can exist, even if they do not work.
|
|
// We must always check extension strings and versions.
|
|
|
|
if (gl->version && section->ver_exclude &&
|
|
gl->version >= section->ver_exclude)
|
|
continue;
|
|
if (gl->es && section->ver_es_exclude &&
|
|
gl->es >= section->ver_es_exclude)
|
|
continue;
|
|
|
|
bool exists = false, must_exist = false;
|
|
if (ver_core)
|
|
must_exist = version >= ver_core;
|
|
|
|
if (section->extension)
|
|
exists = gl_check_extension(gl->extensions, section->extension);
|
|
|
|
exists |= must_exist;
|
|
if (!exists)
|
|
continue;
|
|
|
|
void *loaded[MAX_FN_COUNT] = {0};
|
|
bool all_loaded = true;
|
|
const struct gl_function *fnlist = section->functions;
|
|
|
|
for (int i = 0; fnlist && fnlist[i].name; i++) {
|
|
const struct gl_function *fn = &fnlist[i];
|
|
void *ptr = get_fn(fn_ctx, fn->name);
|
|
if (!ptr) {
|
|
all_loaded = false;
|
|
if (must_exist) {
|
|
mp_err(log, "GL %d.%d function %s not found.\n",
|
|
MPGL_VER_GET_MAJOR(ver_core),
|
|
MPGL_VER_GET_MINOR(ver_core), fn->name);
|
|
goto error;
|
|
} else {
|
|
mp_warn(log, "Function %s from extension %s not found.\n",
|
|
fn->name, section->extension);
|
|
}
|
|
break;
|
|
}
|
|
assert(i < MAX_FN_COUNT);
|
|
loaded[i] = ptr;
|
|
}
|
|
|
|
if (all_loaded) {
|
|
gl->mpgl_caps |= section->provides;
|
|
for (int i = 0; fnlist && fnlist[i].name; i++) {
|
|
const struct gl_function *fn = &fnlist[i];
|
|
void **funcptr = (void**)(((char*)gl) + fn->offset);
|
|
if (loaded[i])
|
|
*funcptr = loaded[i];
|
|
}
|
|
if (!must_exist && section->extension)
|
|
mp_verbose(log, "Loaded extension %s.\n", section->extension);
|
|
}
|
|
}
|
|
|
|
gl->glsl_version = 0;
|
|
if (gl->es) {
|
|
if (gl->es >= 200)
|
|
gl->glsl_version = 100;
|
|
if (gl->es >= 300)
|
|
gl->glsl_version = 300;
|
|
} else {
|
|
gl->glsl_version = 120;
|
|
int glsl_major = 0, glsl_minor = 0;
|
|
if (shader && sscanf(shader, "%d.%d", &glsl_major, &glsl_minor) == 2)
|
|
gl->glsl_version = glsl_major * 100 + glsl_minor;
|
|
// restrict GLSL version to be forwards compatible
|
|
gl->glsl_version = MPMIN(gl->glsl_version, 440);
|
|
}
|
|
|
|
if (is_software_gl(gl)) {
|
|
gl->mpgl_caps |= MPGL_CAP_SW;
|
|
mp_verbose(log, "Detected suspected software renderer.\n");
|
|
}
|
|
|
|
// GL_ARB_compute_shader & GL_ARB_shader_image_load_store
|
|
if (gl->DispatchCompute && gl->BindImageTexture)
|
|
gl->mpgl_caps |= MPGL_CAP_COMPUTE_SHADER;
|
|
|
|
// Provided for simpler handling if no framebuffer support is available.
|
|
if (!gl->BindFramebuffer)
|
|
gl->BindFramebuffer = &dummy_glBindFramebuffer;
|
|
return;
|
|
|
|
error:
|
|
gl->version = 0;
|
|
gl->es = 0;
|
|
gl->mpgl_caps = 0;
|
|
}
|
|
|
|
static void *get_procaddr_wrapper(void *ctx, const char *name)
|
|
{
|
|
void *(*getProcAddress)(const GLubyte *) = ctx;
|
|
return getProcAddress ? getProcAddress((const GLubyte*)name) : NULL;
|
|
}
|
|
|
|
void mpgl_load_functions(GL *gl, void *(*getProcAddress)(const GLubyte *),
|
|
const char *ext2, struct mp_log *log)
|
|
{
|
|
mpgl_load_functions2(gl, get_procaddr_wrapper, getProcAddress, ext2, log);
|
|
}
|