From 60ea7c38a2e68b8567d47d171ac8e2aa2365fa9d Mon Sep 17 00:00:00 2001 From: Eric Anholt Date: Fri, 6 Dec 2013 12:53:00 -0800 Subject: [PATCH] Move GLX/EGL dispatch code using those API types to separate files. The dlopen bits are left in place, but the functions required the types, and in the case of EGL, the types require that the platform header actually exists. --- src/Makefile.am | 14 +++-- src/dispatch_common.c | 120 +----------------------------------------- src/dispatch_common.h | 2 + src/dispatch_egl.c | 69 ++++++++++++++++++++++++ src/dispatch_glx.c | 105 ++++++++++++++++++++++++++++++++++++ 5 files changed, 187 insertions(+), 123 deletions(-) create mode 100644 src/dispatch_egl.c create mode 100644 src/dispatch_glx.c diff --git a/src/Makefile.am b/src/Makefile.am index 9479415..eb22ecf 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -89,16 +89,22 @@ libepoxy_la_SOURCES = \ dispatch_common.c \ dispatch_common.h \ $(GENERATED_GL) \ - $(BUILD_GENERATED_EGL) \ - $(BUILD_GENERATED_GLX) \ + $(BUILD_EGL_CODE) \ + $(BUILD_GLX_CODE) \ $() if BUILD_EGL -BUILD_GENERATED_EGL = $(GENERATED_EGL) +BUILD_EGL_CODE = \ + $(GENERATED_EGL) \ + dispatch_egl.c \ + $() endif if BUILD_GLX -BUILD_GENERATED_GLX = $(GENERATED_GLX) +BUILD_GLX_CODE = \ + $(GENERATED_GLX) \ + dispatch_glx.c \ + $() endif # These are generated alongside the .c file. diff --git a/src/dispatch_common.c b/src/dispatch_common.c index 0ce0218..fa8507d 100644 --- a/src/dispatch_common.c +++ b/src/dispatch_common.c @@ -235,76 +235,7 @@ epoxy_conservative_gl_version(void) return epoxy_internal_gl_version(100); } -/** - * If we can determine the GLX version from the current context, then - * return that, otherwise return a version that will just send us on - * to dlsym() or get_proc_address(). - */ -int -epoxy_conservative_glx_version(void) -{ - Display *dpy = glXGetCurrentDisplay(); - GLXContext ctx = glXGetCurrentContext(); - int screen; - - if (!dpy || !ctx) - return 14; - - glXQueryContext(dpy, ctx, GLX_SCREEN, &screen); - - return epoxy_glx_version(dpy, screen); -} - -PUBLIC int -epoxy_glx_version(Display *dpy, int screen) -{ - int server_major, server_minor; - int client_major, client_minor; - int server, client; - const char *version_string; - int ret; - - version_string = glXQueryServerString(dpy, screen, GLX_VERSION); - ret = sscanf(version_string, "%d.%d", &server_major, &server_minor); - assert(ret == 2); - server = server_major * 10 + server_minor; - - version_string = glXGetClientString(dpy, GLX_VERSION); - ret = sscanf(version_string, "%d.%d", &client_major, &client_minor); - assert(ret == 2); - client = client_major * 10 + client_minor; - - if (client < server) - return client; - else - return server; -} - -PUBLIC int -epoxy_conservative_egl_version(void) -{ - EGLDisplay *dpy = eglGetCurrentDisplay(); - - if (!dpy) - return 14; - - return epoxy_egl_version(dpy); -} - -PUBLIC int -epoxy_egl_version(EGLDisplay *dpy) -{ - int major, minor; - const char *version_string; - int ret; - - version_string = eglQueryString(dpy, EGL_VERSION); - ret = sscanf(version_string, "%d.%d", &major, &minor); - assert(ret == 2); - return major * 10 + minor; -} - -static bool +bool epoxy_extension_in_string(const char *extension_list, const char *ext) { const char *ptr = extension_list; @@ -366,55 +297,6 @@ epoxy_conservative_has_gl_extension(const char *ext) return epoxy_internal_has_gl_extension(ext, true); } -bool -epoxy_conservative_has_egl_extension(const char *ext) -{ - EGLDisplay *dpy = eglGetCurrentDisplay(); - - if (!dpy) - return true; - - return epoxy_has_egl_extension(dpy, ext); -} - -PUBLIC bool -epoxy_has_egl_extension(EGLDisplay *dpy, const char *ext) -{ - return epoxy_extension_in_string(eglQueryString(dpy, EGL_EXTENSIONS), ext); -} - -/** - * If we can determine the GLX extension support from the current - * context, then return that, otherwise give the answer that will just - * send us on to get_proc_address(). - */ -bool -epoxy_conservative_has_glx_extension(const char *ext) -{ - Display *dpy = glXGetCurrentDisplay(); - GLXContext ctx = glXGetCurrentContext(); - int screen; - - if (!dpy || !ctx) - return true; - - glXQueryContext(dpy, ctx, GLX_SCREEN, &screen); - - return epoxy_has_glx_extension(dpy, screen, ext); -} - -PUBLIC bool -epoxy_has_glx_extension(Display *dpy, int screen, const char *ext) - { - /* No, you can't just use glXGetClientString or - * glXGetServerString() here. Those each tell you about one half - * of what's needed for an extension to be supported, and - * glXQueryExtensionsString() is what gives you the intersection - * of the two. - */ - return epoxy_extension_in_string(glXQueryExtensionsString(dpy, screen), ext); -} - void * epoxy_egl_dlsym(const char *name) { diff --git a/src/dispatch_common.h b/src/dispatch_common.h index c7b6944..127845a 100644 --- a/src/dispatch_common.h +++ b/src/dispatch_common.h @@ -64,5 +64,7 @@ void epoxy_print_failure_reasons(const char *name, const char **provider_names, const int *providers); +bool epoxy_extension_in_string(const char *extension_list, const char *ext); + void epoxy_glBegin_unwrapped(GLenum primtype); void epoxy_glEnd_unwrapped(void); diff --git a/src/dispatch_egl.c b/src/dispatch_egl.c new file mode 100644 index 0000000..09eae00 --- /dev/null +++ b/src/dispatch_egl.c @@ -0,0 +1,69 @@ +/* + * Copyright © 2013 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include +#include +#include + +#include "dispatch_common.h" + +PUBLIC int +epoxy_conservative_egl_version(void) +{ + EGLDisplay *dpy = eglGetCurrentDisplay(); + + if (!dpy) + return 14; + + return epoxy_egl_version(dpy); +} + +PUBLIC int +epoxy_egl_version(EGLDisplay *dpy) +{ + int major, minor; + const char *version_string; + int ret; + + version_string = eglQueryString(dpy, EGL_VERSION); + ret = sscanf(version_string, "%d.%d", &major, &minor); + assert(ret == 2); + return major * 10 + minor; +} + +bool +epoxy_conservative_has_egl_extension(const char *ext) +{ + EGLDisplay *dpy = eglGetCurrentDisplay(); + + if (!dpy) + return true; + + return epoxy_has_egl_extension(dpy, ext); +} + +PUBLIC bool +epoxy_has_egl_extension(EGLDisplay *dpy, const char *ext) +{ + return epoxy_extension_in_string(eglQueryString(dpy, EGL_EXTENSIONS), ext); +} diff --git a/src/dispatch_glx.c b/src/dispatch_glx.c new file mode 100644 index 0000000..78e61c2 --- /dev/null +++ b/src/dispatch_glx.c @@ -0,0 +1,105 @@ +/* + * Copyright © 2013 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include +#include +#include + +#include "dispatch_common.h" + +/** + * If we can determine the GLX version from the current context, then + * return that, otherwise return a version that will just send us on + * to dlsym() or get_proc_address(). + */ +int +epoxy_conservative_glx_version(void) +{ + Display *dpy = glXGetCurrentDisplay(); + GLXContext ctx = glXGetCurrentContext(); + int screen; + + if (!dpy || !ctx) + return 14; + + glXQueryContext(dpy, ctx, GLX_SCREEN, &screen); + + return epoxy_glx_version(dpy, screen); +} + +PUBLIC int +epoxy_glx_version(Display *dpy, int screen) +{ + int server_major, server_minor; + int client_major, client_minor; + int server, client; + const char *version_string; + int ret; + + version_string = glXQueryServerString(dpy, screen, GLX_VERSION); + ret = sscanf(version_string, "%d.%d", &server_major, &server_minor); + assert(ret == 2); + server = server_major * 10 + server_minor; + + version_string = glXGetClientString(dpy, GLX_VERSION); + ret = sscanf(version_string, "%d.%d", &client_major, &client_minor); + assert(ret == 2); + client = client_major * 10 + client_minor; + + if (client < server) + return client; + else + return server; +} + +/** + * If we can determine the GLX extension support from the current + * context, then return that, otherwise give the answer that will just + * send us on to get_proc_address(). + */ +bool +epoxy_conservative_has_glx_extension(const char *ext) +{ + Display *dpy = glXGetCurrentDisplay(); + GLXContext ctx = glXGetCurrentContext(); + int screen; + + if (!dpy || !ctx) + return true; + + glXQueryContext(dpy, ctx, GLX_SCREEN, &screen); + + return epoxy_has_glx_extension(dpy, screen, ext); +} + +PUBLIC bool +epoxy_has_glx_extension(Display *dpy, int screen, const char *ext) + { + /* No, you can't just use glXGetClientString or + * glXGetServerString() here. Those each tell you about one half + * of what's needed for an extension to be supported, and + * glXQueryExtensionsString() is what gives you the intersection + * of the two. + */ + return epoxy_extension_in_string(glXQueryExtensionsString(dpy, screen), ext); +}