Attachment 53741 Details for Bug 41999 – Standalone test case

Standalone test case

test-mapbuffer-gles2.c (text/x-csrc), 10.39 KB, created by Neil Roberts on 2011-11-21 07:40:50 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Neil Roberts

Created: 2011-11-21 07:40:50 UTC

Size: 10.39 KB

patch

obsolete

>/* Compile with -lEGL -lX11 -ldl (don't add -lGLESv2) */
>
>/* If you additionally add -lGL then test fail */
>
>#include <GLES2/gl2.h>
>#include <GLES2/gl2ext.h>
>#include <EGL/egl.h>
>#include <EGL/eglext.h>
>#include <stdio.h>
>#include <string.h>
>#include <errno.h>
>#include <stdlib.h>
>#include <dlfcn.h>
>
>static const EGLint attribs[] = {
>  EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
>  EGL_RED_SIZE, 1,
>  EGL_GREEN_SIZE, 1,
>  EGL_BLUE_SIZE, 1,
>  EGL_DEPTH_SIZE, 1,
>  EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
>  EGL_NONE
>};
>
>static const EGLint context_attribs[] ={
>  EGL_CONTEXT_CLIENT_VERSION, 2,
>  EGL_NONE
>};
>
>typedef struct
>{
>  void (* glAttachShader) (GLuint program,
>                           GLuint shader);
>  void (* glBindAttribLocation) (GLuint program,
>                                 GLuint index,
>                                 const GLchar* name);
>  void (* glBindBuffer) (GLenum target,
>                         GLuint buffer);
>  void (* glBufferData) (GLenum target,
>                         GLsizeiptr size,
>                         const GLvoid* data,
>                         GLenum usage);
>  void (* glClear) (GLbitfield mask);
>  void (* glClearColor) (GLclampf red,
>                         GLclampf green,
>                         GLclampf blue,
>                         GLclampf alpha);
>  void (* glCompileShader) (GLuint shader);
>  GLuint (* glCreateProgram) (void);
>  GLuint (* glCreateShader) (GLenum type);
>  void (* glDeleteBuffers) (GLsizei n,
>                            const GLuint* buffers);
>  void (* glDeleteProgram) (GLuint program);
>  void (* glDeleteShader) (GLuint shader);
>  void (* glDisableVertexAttribArray) (GLuint index);
>  void (* glDrawArrays) (GLenum mode,
>                         GLint first,
>                         GLsizei count);
>  void (* glEnableVertexAttribArray) (GLuint index);
>  void (* glGenBuffers) (GLsizei n,
>                         GLuint* buffers);
>  const GLubyte * (* glGetString) (GLenum name);
>  void (* glLinkProgram) (GLuint program);
>  void (* glShaderSource) (GLuint shader,
>                           GLsizei count,
>                           const GLchar** string,
>                           const GLint* length);
>  void (* glUseProgram) (GLuint program);
>  void (* glVertexAttribPointer) (GLuint indx,
>                                  GLint size,
>                                  GLenum type,
>                                  GLboolean normalized,
>                                  GLsizei stride,
>                                  const GLvoid* ptr);
>} Funcs;
>
>struct egl_state
>{
>  Display *dpy;
>  Window win;
>  EGLDisplay egl_dpy;
>  EGLConfig cfg;
>  EGLContext ctx;
>  EGLSurface surf;
>  EGLint major, minor;
>  int depth;
>  int width;
>  int height;
>
>  void * (* map_buffer) (GLenum target, GLenum access);
>  GLboolean (* unmap_buffer) (GLenum target);
>
>  void *gles2_lib;
>
>  Funcs funcs;
>};
>
>static const char * const
>func_names[] =
>  {
>    "glAttachShader",
>    "glBindAttribLocation",
>    "glBindBuffer",
>    "glBufferData",
>    "glClear",
>    "glClearColor",
>    "glCompileShader",
>    "glCreateProgram",
>    "glCreateShader",
>    "glDeleteBuffers",
>    "glDeleteProgram",
>    "glDeleteShader",
>    "glDisableVertexAttribArray",
>    "glDrawArrays",
>    "glEnableVertexAttribArray",
>    "glGenBuffers",
>    "glGetString",
>    "glLinkProgram",
>    "glShaderSource",
>    "glUseProgram",
>    "glVertexAttribPointer"
>};
>
>typedef struct
>{
>  float x, y;
>} Vertex;
>
>static const Vertex
>vertices[] =
>  {
>    { -1, -1 }, { 1, -1 }, { 0, 1 }
>  };
>
>static void
>create_window (struct egl_state *state)
>{
>  XSetWindowAttributes window_attr;
>  XVisualInfo template, *vinfo;
>  EGLint id;
>  unsigned long mask;
>  int screen = DefaultScreen (state->dpy);
>  Window root_win = RootWindow (state->dpy, screen);
>  int count;
>
>  if (!eglGetConfigAttrib (state->egl_dpy,
>                           state->cfg, EGL_NATIVE_VISUAL_ID, &id))
>    {
>      fprintf (stderr, "eglGetConfigAttrib() failed\n");
>      exit (1);
>    }
>
>  template.visualid = id;
>  vinfo = XGetVisualInfo (state->dpy, VisualIDMask, &template, &count);
>  if (count != 1)
>    {
>      fprintf (stderr, "XGetVisualInfo() failed\n");
>      exit (1);
>    }
>
>  state->depth = vinfo->depth;
>  window_attr.background_pixel = 0;
>  window_attr.border_pixel = 0;
>  window_attr.colormap = XCreateColormap (state->dpy, root_win,
>                                          vinfo->visual, AllocNone);
>  window_attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
>  mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
>  state->win = XCreateWindow (state->dpy, root_win, 0, 0,
>                              state->width, state->height,
>                              0, vinfo->depth, InputOutput,
>                              vinfo->visual, mask, &window_attr);
>
>  XMapWindow (state->dpy, state->win);
>
>  XFree (vinfo);
>}
>
>static void
>setup_shaders (struct egl_state *state)
>{
>  static const char vertex_source[] =
>    "attribute vec2 pos;\n"
>    "\n"
>    "void\n"
>    "main ()\n"
>    "{\n"
>    "  gl_Position = vec4 (pos, 0.0, 1.0);\n"
>    "}\n";
>  static const char fragment_source[] =
>    "void\n"
>    "main ()\n"
>    "{\n"
>    "  gl_FragColor = vec4 (1.0, 0.0, 0.0, 1.0);\n"
>    "}\n";
>  const char *source_strings;
>  GLuint shader, program;
>
>  program = state->funcs.glCreateProgram ();
>
>  shader = state->funcs.glCreateShader (GL_VERTEX_SHADER);
>  source_strings = vertex_source;
>  state->funcs.glShaderSource (shader, 1, &source_strings, NULL);
>  state->funcs.glCompileShader (shader);
>  state->funcs.glAttachShader (program, shader);
>  state->funcs.glDeleteShader (shader);
>
>  shader = state->funcs.glCreateShader (GL_FRAGMENT_SHADER);
>  source_strings = fragment_source;
>  state->funcs.glShaderSource (shader, 1, &source_strings, NULL);
>  state->funcs.glCompileShader (shader);
>  state->funcs.glAttachShader (program, shader);
>  state->funcs.glDeleteShader (shader);
>
>  state->funcs.glBindAttribLocation (program, 0, "pos");
>
>  state->funcs.glLinkProgram (program);
>
>  state->funcs.glUseProgram (program);
>  state->funcs.glDeleteProgram (program);
>}
>
>static void
>draw (struct egl_state *state)
>{
>  GLuint buf;
>  void *data;
>
>  state->funcs.glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
>  state->funcs.glClear (GL_COLOR_BUFFER_BIT);
>
>  state->funcs.glGenBuffers (1, &buf);
>
>  state->funcs.glBindBuffer (GL_ARRAY_BUFFER, buf);
>  state->funcs.glBufferData (GL_ARRAY_BUFFER,
>                             sizeof (vertices),
>                             NULL,
>                             GL_STATIC_DRAW);
>
>  data = state->map_buffer (GL_ARRAY_BUFFER, GL_WRITE_ONLY_OES);
>
>  if (data == NULL)
>    {
>      fprintf (stderr, "glMapBufferOES returned NULL\n");
>      state->funcs.glBufferData (GL_ARRAY_BUFFER,
>                    sizeof (vertices),
>                    vertices,
>                    GL_STATIC_DRAW);
>    }
>  else
>    {
>      memcpy (data, vertices, sizeof (vertices));
>      state->unmap_buffer (GL_ARRAY_BUFFER);
>    }
>
>  state->funcs.glVertexAttribPointer (0, 2,
>                                      GL_FLOAT,
>                                      GL_FALSE,
>                                      sizeof (Vertex),
>                                      NULL);
>  state->funcs.glEnableVertexAttribArray (0);
>  state->funcs.glDrawArrays (GL_TRIANGLES, 0, 3);
>  state->funcs.glDisableVertexAttribArray (0);
>
>  state->funcs.glBindBuffer (GL_ARRAY_BUFFER, 0);
>
>  state->funcs.glDeleteBuffers (1, &buf);
>}
>
>static int
>check_mapbuffer_extension (struct egl_state *state)
>{
>  const GLubyte *extensions;
>
>  extensions = state->funcs.glGetString (GL_EXTENSIONS);
>
>  if (!strstr ((const char *) extensions, "GL_OES_mapbuffer"))
>    {
>      fprintf (stderr, "GL_OES_mapbuffer extension is not advertised\n");
>      return 0;
>    }
>
>  state->map_buffer = (void *) eglGetProcAddress ("glMapBufferOES");
>  state->unmap_buffer = (void *) eglGetProcAddress ("glUnmapBufferOES");
>
>  if (state->map_buffer == NULL || state->unmap_buffer == NULL)
>    {
>      fprintf (stderr, "The map and unmap functions are not present\n");
>      return 0;
>    }
>
>  return 1;
>}
>
>static int
>load_gles2_lib (struct egl_state *state)
>{
>  int i;
>
>  if ((state->gles2_lib =
>       dlopen ("libGLESv2.so", RTLD_LAZY | RTLD_GLOBAL)) == NULL)
>    {
>      fprintf (stderr, "failed to dlopen libGLESv2.so");
>      return 0;
>    }
>
>  for (i = 0; i < sizeof (func_names) / sizeof (func_names[0]); i++)
>    {
>      void **p = ((void **) &state->funcs) + i;
>
>      *p = dlsym (state->gles2_lib, func_names[i]);
>
>      if (*p == NULL)
>        {
>          fprintf (stderr, "couldn't resolve %s\n", func_names[i]);
>          return 0;
>        }
>    }
>
>  return 1;
>}
>
>int
>main (int argc, char **argv)
>{
>  struct egl_state state;
>  int count;
>
>  if (!load_gles2_lib (&state))
>    return EXIT_FAILURE;
>
>  state.dpy = XOpenDisplay (NULL);
>  if (state.dpy == NULL)
>    {
>      fprintf (stderr, "couldn't open display\n");
>      return EXIT_FAILURE;
>    }
>
>  state.egl_dpy = eglGetDisplay (state.dpy);
>  if (state.egl_dpy == EGL_NO_DISPLAY)
>    {
>      fprintf (stderr, "eglGetDisplay() failed\n");
>      return EXIT_FAILURE;
>    }
>
>  if (!eglInitialize (state.egl_dpy, &state.major, &state.minor))
>    {
>      fprintf (stderr, "eglInitialize() failed\n");
>      return EXIT_FAILURE;
>    }
>
>  if (!eglChooseConfig (state.egl_dpy, attribs, &state.cfg, 1, &count) ||
>      count == 0)
>    {
>      fprintf (stderr, "eglChooseConfig() failed\n");
>      return EXIT_FAILURE;
>    }
>
>  state.ctx = eglCreateContext (state.egl_dpy, state.cfg,
>                                EGL_NO_CONTEXT, context_attribs);
>  if (state.ctx == EGL_NO_CONTEXT)
>    {
>      fprintf (stderr, "eglCreateContext() failed\n");
>      return EXIT_FAILURE;
>    }
>
>  state.width = 300;
>  state.height = 300;
>  create_window (&state);
>
>  state.surf = eglCreateWindowSurface (state.egl_dpy,
>                                       state.cfg, state.win, NULL);
>  if (state.surf == EGL_NO_SURFACE)
>    {
>      fprintf (stderr, "eglCreateWindowSurface() failed\n");
>      return EXIT_FAILURE;
>    }
>
>  if (!eglMakeCurrent (state.egl_dpy, state.surf, state.surf, state.ctx))
>    {
>      fprintf (stderr, "eglMakeCurrent() failed\n");
>      return EXIT_FAILURE;
>    }
>
>  if (!check_mapbuffer_extension (&state))
>    return EXIT_FAILURE;
>
>  setup_shaders (&state);
>
>  while (1)
>    {
>      XEvent event;
>
>      XNextEvent (state.dpy, &event);
>
>      switch (event.type)
>        {
>        case Expose:
>          draw (&state);
>          eglSwapBuffers (state.egl_dpy, state.surf);
>          break;
>        }
>    }
>
>  eglTerminate (state.egl_dpy);
>
>  dlclose (state.gles2_lib);
>
>  return EXIT_SUCCESS;
>}

Actions: View

Attachments on bug 41999: 53741

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.