Attachment 40977 Details for Bug 32285 – test case for get GL and GLES2 renderer in one process

test case for get GL and GLES2 renderer in one process

renderer_info.c (text/x-csrc), 7.97 KB, created by Jammy Zhou on 2010-12-09 21:19:05 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Jammy Zhou

Created: 2010-12-09 21:19:05 UTC

Size: 7.97 KB

patch

obsolete

>#include <stdlib.h>
>#include <stdio.h>
>#include <dlfcn.h>
>
>#include <X11/Xlib.h>
>#include <X11/Xutil.h>
>
>#include <GL/gl.h>
>#include <GL/glx.h>
>#include <EGL/egl.h>
>
>typedef EGLDisplay (*PFNEGLGETDISPLAYPROC)(EGLNativeDisplayType display_id);
>typedef EGLBoolean (*PFNEGLINITIALIZEPROC)(EGLDisplay dpy, EGLint *major, EGLint *minor);
>typedef EGLBoolean (*PFNEGLTERMINATEPROC)(EGLDisplay dpy);
>typedef EGLBoolean (*PFNEGLGETCONFIGSPROC)(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
>typedef EGLSurface (*PFNEGLCREATEWINDOWSURFACEPROC)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list);
>typedef EGLBoolean (*PFNEGLDESTROYSURFACEPROC)(EGLDisplay dpy, EGLSurface surface);
>typedef EGLContext (*PFNEGLCREATECONTEXTPROC)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
>typedef EGLBoolean (*PFNEGLDESTROYCONTEXTPROC)(EGLDisplay dpy, EGLContext ctx);
>typedef EGLBoolean (*PFNEGLMAKECURRENTPROC)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
>
>PFNEGLGETDISPLAYPROC pfnEGLGetDisplay = NULL;
>PFNEGLINITIALIZEPROC pfnEGLInitialize = NULL;
>PFNEGLTERMINATEPROC pfnEGLTerminate = NULL;
>PFNEGLGETCONFIGSPROC pfnEGLGetConfigs = NULL;
>PFNEGLCREATEWINDOWSURFACEPROC pfnEGLCreateWindowSurface = NULL;
>PFNEGLDESTROYSURFACEPROC pfnEGLDestroySurface = NULL;
>PFNEGLCREATECONTEXTPROC pfnEGLCreateContext = NULL;
>PFNEGLDESTROYCONTEXTPROC pfnEGLDestroyContext = NULL;
>PFNEGLMAKECURRENTPROC pfnEGLMakeCurrent = NULL;
>
>typedef XVisualInfo* (*PFNGLXCHOOSEVISUALPROC)( Display *dpy, int screen, int *attribList );
>typedef GLXContext (*PFNGLXCREATECONTEXTPROC)( Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct );
>typedef void (*PFNGLXDESTROYCONTEXTPROC)( Display *dpy, GLXContext ctx );
>typedef Bool (*PFNGLXMAKECURRENTPROC)( Display *dpy, GLXDrawable drawable, GLXContext ctx);
>
>PFNGLXCHOOSEVISUALPROC pfnGLXChooseVisual = NULL;
>PFNGLXCREATECONTEXTPROC pfnGLXCreateContext = NULL;
>PFNGLXMAKECURRENTPROC pfnGLXMakeCurrent = NULL;
>PFNGLXDESTROYCONTEXTPROC pfnGLXDestroyContext = NULL;
>
>typedef const GLubyte* (*PFNGLGETSTRINGPROC) (GLenum name);
>PFNGLGETSTRINGPROC pfnGLGetString = NULL;
>
>static const char *GetRenderer(unsigned int gles2)
>{
>        Display *dpy = XOpenDisplay(NULL);
>        int scrnum;
>        Window root;
>        const char *renderer = NULL;
>
>        if (NULL == dpy) {
>                printf("failed to open display\n");
>                return NULL;
>        }
>
>        scrnum = DefaultScreen(dpy);
>        root = RootWindow(dpy, scrnum);
>
>        if (gles2) {
>                EGLDisplay egl_dpy;
>                EGLConfig config;
>                EGLint num_configs = 1;
>                EGLContext egl_ctx;
>                EGLSurface egl_surf;
>
>                static const EGLint ctx_attribs[] = {
>                        EGL_CONTEXT_CLIENT_VERSION, 2,
>                        EGL_NONE
>                };
>
>                egl_dpy = (*pfnEGLGetDisplay)(dpy);
>                if ((NULL == egl_dpy) || !(*pfnEGLInitialize)(egl_dpy, NULL, NULL)) {
>                        printf("egl initialization failed\n");
>                        return NULL;
>                }
>
>                if (!(*pfnEGLGetConfigs)(egl_dpy, &config, num_configs, &num_configs) || num_configs < 1) {
>                        printf("failed to get egl config\n");
>                        return NULL;
>                }
>               egl_ctx = (*pfnEGLCreateContext)(egl_dpy, config, EGL_NO_CONTEXT, ctx_attribs);
>                if (!egl_ctx) {
>                        printf("eglCreateContext failed\n");
>                        return NULL;
>                }
>
>                egl_surf = (*pfnEGLCreateWindowSurface)(egl_dpy, config, root, NULL);
>                if (!egl_surf) {
>                        printf("eglCreateWindowSurface failed\n");
>                        return;
>                }
>
>                if (!(*pfnEGLMakeCurrent)(egl_dpy, egl_surf, egl_surf, egl_ctx))
>                        return;
>
>                renderer = (*pfnGLGetString)(GL_RENDERER);
>
>                (*pfnEGLMakeCurrent)(egl_dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
>                (*pfnEGLDestroyContext)(egl_dpy, egl_ctx);
>                (*pfnEGLDestroySurface)(egl_dpy, egl_surf);
>                (*pfnEGLTerminate)(egl_dpy);
>        }
>        else {
>                GLXContext glx_ctx;
>                int attribs[] = {
>                        GLX_RGBA,
>                        None };
>                XVisualInfo *visinfo = NULL;
>
>                visinfo = (*pfnGLXChooseVisual)(dpy, scrnum, attribs);
>
>                if (!visinfo) {
>                        printf("failed to get visual\n");
>                        return NULL;
>                }
>
>                glx_ctx = (*pfnGLXCreateContext)(dpy, visinfo, NULL, True);
>                if (!glx_ctx) {
>                        printf("failed to create GLX context\n");
>                        return NULL;
>                }
>
>                (*pfnGLXMakeCurrent)(dpy, root, glx_ctx);
>
>                renderer = (*pfnGLGetString)(GL_RENDERER);
>
>                (*pfnGLXMakeCurrent)(dpy, None, NULL);
>
>                (*pfnGLXDestroyContext)(dpy, glx_ctx);
>
>                XFree(visinfo);
>        }
>
>        //XCloseDisplay(dpy);
>
>        return renderer;
>}
>
>int main(void)
>{
>        void *egl_handle = NULL;
>        void *gl_handle = NULL;
>        void *gles2_handle = NULL;
>        const char *gl_renderer = NULL;
>        const char *gles2_renderer = NULL;
>
>        gles2_handle = dlopen("/usr/lib/libGLESv2.so", RTLD_LOCAL|RTLD_LAZY);
>        egl_handle = dlopen("/usr/lib/libEGL.so", RTLD_LOCAL|RTLD_LAZY);
>
>        if (egl_handle && gles2_handle) {
>                /* Resolve EGL APIs for create rendering context to get GL_RENDERER */
>                pfnEGLGetDisplay = dlsym(egl_handle, "eglGetDisplay");
>                pfnEGLInitialize = dlsym(egl_handle, "eglInitialize");
>                pfnEGLGetConfigs = dlsym(egl_handle, "eglGetConfigs");
>                pfnEGLCreateContext = dlsym(egl_handle, "eglCreateContext");
>                pfnEGLCreateWindowSurface = dlsym(egl_handle, "eglCreateWindowSurface");
>                pfnEGLMakeCurrent = dlsym(egl_handle, "eglMakeCurrent");
>                pfnEGLDestroyContext = dlsym(egl_handle, "eglDestroyContext");
>                pfnEGLDestroySurface = dlsym(egl_handle, "eglDestroySurface");
>                pfnEGLTerminate = dlsym(egl_handle, "eglTerminate");
>
>                /* Resolve glGetString */
>                pfnGLGetString = dlsym(gles2_handle, "glGetString");
>
>                gles2_renderer = GetRenderer(1);
>
>                pfnGLGetString = NULL;
>        }
>
>        if (egl_handle) {
>                dlclose(egl_handle);
>                egl_handle = NULL;
>        }
>
>        if (gles2_handle) {
>                dlclose(gles2_handle);
>                gles2_handle = NULL;
>        }
>
>        printf("OpenGL ES2.0 Renderer: %s\n", gles2_renderer ? gles2_renderer : "Not Available");
>
>        /* Try to get the opengl renderer info if available */
>        gl_handle = dlopen("/usr/lib/libGL.so", RTLD_LOCAL|RTLD_LAZY);
>
>        if (gl_handle) {
>                /* Resolve GLX APIs needed for create rendering context */
>                pfnGLXChooseVisual = dlsym(gl_handle, "glXChooseVisual");
>                pfnGLXCreateContext = dlsym(gl_handle, "glXCreateContext");
>                pfnGLXMakeCurrent = dlsym(gl_handle, "glXMakeCurrent");
>                pfnGLXDestroyContext = dlsym(gl_handle, "glXDestroyContext");
>
>                /* Resolve glGetString */
>                pfnGLGetString = dlsym(gl_handle, "glGetString");
>
>                gl_renderer = GetRenderer(0);
>
>                pfnGLGetString = NULL;
>               
>                /* Close the library*/
>                dlclose(gl_handle);
>        }
>
>        printf("OpenGL Renderer: %s\n", gl_renderer ? gl_renderer : "Not Available");
>
>	return 0;
>}

Actions: View

Attachments on bug 32285: 40977 | 40980 | 42698

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.