egl_xlib.c File Reference

Include dependency graph for egl_xlib.c:

Go to the source code of this file.

Data Structures
struct	xlib_egl_driver
	EGL / softpipe / xlib winsys module. More...
struct	xlib_egl_context
	subclass of _EGLContext More...
struct	xlib_egl_surface
	subclass of _EGLSurface More...
Functions
static struct xlib_egl_driver *	xlib_egl_driver (_EGLDriver *drv)
	cast wrapper
static struct xlib_egl_surface *	lookup_surface (EGLSurface surf)
static struct xlib_egl_context *	lookup_context (EGLContext surf)
static unsigned int	bitcount (unsigned int n)
static void	create_configs (_EGLDriver *drv, EGLDisplay dpy)
	Create the EGLConfigs.
static EGLBoolean	xlib_eglInitialize (_EGLDriver *drv, EGLDisplay dpy, EGLint *minor, EGLint *major)
	Called via eglInitialize(), drv->API.Initialize().
static EGLBoolean	xlib_eglTerminate (_EGLDriver *drv, EGLDisplay dpy)
	Called via eglTerminate(), drv->API.Terminate().
static _EGLProc	xlib_eglGetProcAddress (const char *procname)
static void	get_drawable_visual_info (Display *dpy, Drawable d, XVisualInfo *visInfo)
static Status	get_drawable_size (Display *dpy, Drawable d, uint *width, uint *height)
	Get size of given window.
static void	check_and_update_buffer_size (struct xlib_egl_surface *surface)
static void	display_surface (struct pipe_winsys *pws, struct pipe_surface *psurf, struct xlib_egl_surface *xsurf)
static void	flush_frontbuffer (struct pipe_winsys *pws, struct pipe_surface *psurf, void *context_private)
	Display gallium surface in X window.
static EGLContext	xlib_eglCreateContext (_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, EGLContext share_list, const EGLint *attrib_list)
	Called via eglCreateContext(), drv->API.CreateContext().
static EGLBoolean	xlib_eglDestroyContext (_EGLDriver *drv, EGLDisplay dpy, EGLContext ctx)
static EGLBoolean	xlib_eglMakeCurrent (_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
	Called via eglMakeCurrent(), drv->API.MakeCurrent().
static enum pipe_format	choose_color_format (const __GLcontextModes *visual)
static enum pipe_format	choose_depth_format (const __GLcontextModes *visual)
static enum pipe_format	choose_stencil_format (const __GLcontextModes *visual)
static EGLSurface	xlib_eglCreateWindowSurface (_EGLDriver *drv, EGLDisplay dpy, EGLConfig config, NativeWindowType window, const EGLint *attrib_list)
	Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().
static EGLBoolean	xlib_eglDestroySurface (_EGLDriver *drv, EGLDisplay dpy, EGLSurface surface)
static EGLBoolean	xlib_eglSwapBuffers (_EGLDriver *drv, EGLDisplay dpy, EGLSurface draw)
static EGLint	find_supported_apis (void)
	Determine which API(s) is(are) present by looking for some specific global symbols.
_EGLDriver *	_eglMain (_EGLDisplay *dpy, const char *args)
	This is the main entrypoint into the driver.

---

Function Documentation

_EGLDriver* _eglMain	(	_EGLDisplay *	dpy,
		const char *	args
	)

This is the main entrypoint into the driver.

Called by libEGL to instantiate an _EGLDriver object.

Definition at line 611 of file egl_xlib.c.

References xlib_egl_driver::Base, CALLOC_STRUCT, create_sw_winsys(), find_supported_apis(), flush_frontbuffer(), pipe_winsys::flush_frontbuffer, xlib_egl_driver::screen, softpipe_create_screen(), xlib_egl_driver::winsys, xlib_eglCreateContext(), xlib_eglCreateWindowSurface(), xlib_eglDestroyContext(), xlib_eglDestroySurface(), xlib_eglGetProcAddress(), xlib_eglInitialize(), xlib_eglMakeCurrent(), xlib_eglSwapBuffers(), and xlib_eglTerminate().

{
   struct xlib_egl_driver *xdrv;

   _eglLog(_EGL_INFO, "Entering EGL/Xlib _eglMain(%s)", args);

   xdrv = CALLOC_STRUCT(xlib_egl_driver);
   if (!xdrv)
      return NULL;

   if (!dpy->Xdpy) {
      dpy->Xdpy = XOpenDisplay(NULL);
   }

   _eglInitDriverFallbacks(&xdrv->Base);
   xdrv->Base.API.Initialize = xlib_eglInitialize;
   xdrv->Base.API.Terminate = xlib_eglTerminate;
   xdrv->Base.API.GetProcAddress = xlib_eglGetProcAddress;
   xdrv->Base.API.CreateContext = xlib_eglCreateContext;
   xdrv->Base.API.DestroyContext = xlib_eglDestroyContext;
   xdrv->Base.API.CreateWindowSurface = xlib_eglCreateWindowSurface;
   xdrv->Base.API.DestroySurface = xlib_eglDestroySurface;
   xdrv->Base.API.MakeCurrent = xlib_eglMakeCurrent;
   xdrv->Base.API.SwapBuffers = xlib_eglSwapBuffers;

   xdrv->Base.ClientAPIsMask = find_supported_apis();
   if (xdrv->Base.ClientAPIsMask == 0x0) {
      /* the app isn't directly linked with any EGL-supprted APIs
       * (such as libGLESv2.so) so use an EGL utility to see what
       * APIs might be loaded dynamically on this system.
       */
      xdrv->Base.ClientAPIsMask = _eglFindAPIs();
   }      

   xdrv->Base.Name = "Xlib/softpipe";

   /* create one winsys and use it for all contexts/surfaces */
   xdrv->winsys = create_sw_winsys();
   xdrv->winsys->flush_frontbuffer = flush_frontbuffer;

   xdrv->screen = softpipe_create_screen(xdrv->winsys);

   return &xdrv->Base;
}

static unsigned int bitcount

(

unsigned int

n

)

[static]

Definition at line 120 of file egl_xlib.c.

{
   unsigned int bits;
   for (bits = 0; n > 0; n = n >> 1) {
      bits += (n & 1);
   }
   return bits;
}

static void check_and_update_buffer_size

(

struct xlib_egl_surface *

surface

)

[static]

Definition at line 263 of file egl_xlib.c.

References xlib_egl_surface::Base, xlib_egl_surface::Dpy, xlib_egl_surface::Framebuffer, get_drawable_size(), st_resize_framebuffer(), and xlib_egl_surface::Win.

{
   uint width, height;
   get_drawable_size(surface->Dpy, surface->Win, &width, &height);
   st_resize_framebuffer(surface->Framebuffer, width, height);
   surface->Base.Width = width;
   surface->Base.Height = height;
}

static enum pipe_format choose_color_format

(

const __GLcontextModes *

visual

)

[static]

Definition at line 435 of file egl_xlib.c.

References assert, PIPE_FORMAT_A8R8G8B8_UNORM, and PIPE_FORMAT_NONE.

{
   if (visual->redBits == 8 &&
       visual->greenBits == 8 &&
       visual->blueBits == 8 &&
       visual->alphaBits == 8) {
      /* XXX this really also depends on the ordering of R,G,B,A */
      return PIPE_FORMAT_A8R8G8B8_UNORM;
   }
   else {
      assert(0);
      return PIPE_FORMAT_NONE;
   }
}

static enum pipe_format choose_depth_format

(

const __GLcontextModes *

visual

)

[static]

Definition at line 452 of file egl_xlib.c.

References PIPE_FORMAT_NONE, and PIPE_FORMAT_S8Z24_UNORM.

{
   if (visual->depthBits > 0)
      return PIPE_FORMAT_S8Z24_UNORM;
   else
      return PIPE_FORMAT_NONE;
}

static enum pipe_format choose_stencil_format

(

const __GLcontextModes *

visual

)

[static]

Definition at line 462 of file egl_xlib.c.

References PIPE_FORMAT_NONE, and PIPE_FORMAT_S8Z24_UNORM.

{
   if (visual->stencilBits > 0)
      return PIPE_FORMAT_S8Z24_UNORM;
   else
      return PIPE_FORMAT_NONE;
}

static void create_configs	(	_EGLDriver *	drv,
		EGLDisplay	dpy
	)			[static]

Create the EGLConfigs.

(one per X visual)

Definition at line 134 of file egl_xlib.c.

References bitcount().

{
   static const EGLint all_apis = (EGL_OPENGL_ES_BIT |
                                   EGL_OPENGL_ES2_BIT |
                                   EGL_OPENVG_BIT |
                                   EGL_OPENGL_BIT);
   _EGLDisplay *disp = _eglLookupDisplay(dpy);
   XVisualInfo *visInfo, visTemplate;
   int num_visuals, i;

   /* get list of all X visuals, create an EGL config for each */
   visTemplate.screen = DefaultScreen(disp->Xdpy);
   visInfo = XGetVisualInfo(disp->Xdpy, VisualScreenMask,
                            &visTemplate, &num_visuals);
   if (!visInfo) {
      printf("egl_xlib.c: couldn't get any X visuals\n");
      abort();
   }

   for (i = 0; i < num_visuals; i++) {
      _EGLConfig *config = calloc(1, sizeof(_EGLConfig));
      int id = i + 1;
      int rbits = bitcount(visInfo[i].red_mask);
      int gbits = bitcount(visInfo[i].green_mask);
      int bbits = bitcount(visInfo[i].blue_mask);
      int abits = bbits == 8 ? 8 : 0;
      int zbits = 24;
      int sbits = 8;
      int visid = visInfo[i].visualid;
#if defined(__cplusplus) || defined(c_plusplus)
      int vistype = visInfo[i].c_class;
#else
      int vistype = visInfo[i].class;
#endif

      _eglInitConfig(config, id);
      SET_CONFIG_ATTRIB(config, EGL_BUFFER_SIZE, rbits + gbits + bbits + abits);
      SET_CONFIG_ATTRIB(config, EGL_RED_SIZE, rbits);
      SET_CONFIG_ATTRIB(config, EGL_GREEN_SIZE, gbits);
      SET_CONFIG_ATTRIB(config, EGL_BLUE_SIZE, bbits);
      SET_CONFIG_ATTRIB(config, EGL_ALPHA_SIZE, abits);
      SET_CONFIG_ATTRIB(config, EGL_DEPTH_SIZE, zbits);
      SET_CONFIG_ATTRIB(config, EGL_STENCIL_SIZE, sbits);
      SET_CONFIG_ATTRIB(config, EGL_NATIVE_VISUAL_ID, visid);
      SET_CONFIG_ATTRIB(config, EGL_NATIVE_VISUAL_TYPE, vistype);
      SET_CONFIG_ATTRIB(config, EGL_NATIVE_RENDERABLE, EGL_FALSE);
      SET_CONFIG_ATTRIB(config, EGL_CONFORMANT, all_apis);
      SET_CONFIG_ATTRIB(config, EGL_RENDERABLE_TYPE, all_apis);
      SET_CONFIG_ATTRIB(config, EGL_SURFACE_TYPE, EGL_WINDOW_BIT);

      _eglAddConfig(disp, config);
   }
}

static void display_surface	(	struct pipe_winsys *	pws,
		struct pipe_surface *	psurf,
		struct xlib_egl_surface *	xsurf
	)			[static]

Definition at line 275 of file egl_xlib.c.

References assert, pipe_surface::buffer, pipe_winsys::buffer_map, pipe_winsys::buffer_unmap, xlib_egl_surface::Dpy, xlib_egl_surface::Gc, pipe_surface::height, pipe_surface::stride, xlib_egl_surface::VisInfo, pipe_surface::width, and xlib_egl_surface::Win.

{
   XImage *ximage;
   void *data;

   ximage = XCreateImage(xsurf->Dpy,
                         xsurf->VisInfo.visual,
                         xsurf->VisInfo.depth,
                         ZPixmap, 0,   /* format, offset */
                         NULL,         /* data */
                         0, 0,         /* size */
                         32,           /* bitmap_pad */
                         0);           /* bytes_per_line */


   assert(ximage->format);
   assert(ximage->bitmap_unit);

   data = pws->buffer_map(pws, psurf->buffer, 0);

   /* update XImage's fields */
   ximage->data = data;
   ximage->width = psurf->width;
   ximage->height = psurf->height;
   ximage->bytes_per_line = psurf->stride;
   
   XPutImage(xsurf->Dpy, xsurf->Win, xsurf->Gc,
             ximage, 0, 0, 0, 0, psurf->width, psurf->height);

   XSync(xsurf->Dpy, 0);

   ximage->data = NULL;
   XDestroyImage(ximage);

   pws->buffer_unmap(pws, psurf->buffer);
}

static EGLint find_supported_apis

(

void

)

[static]

Determine which API(s) is(are) present by looking for some specific global symbols.

Definition at line 581 of file egl_xlib.c.

{
   EGLint mask = 0;
   void *handle;

   handle = dlopen(NULL, 0);

   if (dlsym(handle, "st_api_OpenGL_ES1"))
      mask |= EGL_OPENGL_ES_BIT;

   if (dlsym(handle, "st_api_OpenGL_ES2"))
      mask |= EGL_OPENGL_ES2_BIT;

   if (dlsym(handle, "st_api_OpenGL"))
      mask |= EGL_OPENGL_BIT;

   if (dlsym(handle, "st_api_OpenVG"))
      mask |= EGL_OPENVG_BIT;

   dlclose(handle);

   return mask;
}

static void flush_frontbuffer	(	struct pipe_winsys *	pws,
		struct pipe_surface *	psurf,
		void *	context_private
	)			[static]

Display gallium surface in X window.

Definition at line 318 of file egl_xlib.c.

References display_surface().

{
   struct xlib_egl_surface *xsurf = (struct xlib_egl_surface *) context_private;
   display_surface(pws, psurf, xsurf);
}

static Status get_drawable_size	(	Display *	dpy,
		Drawable	d,
		uint *	width,
		uint *	height
	)			[static]

Get size of given window.

Definition at line 249 of file egl_xlib.c.

{
   Window root;
   Status stat;
   int xpos, ypos;
   unsigned int w, h, bw, depth;
   stat = XGetGeometry(dpy, d, &root, &xpos, &ypos, &w, &h, &bw, &depth);
   *width = w;
   *height = h;
   return stat;
}

static void get_drawable_visual_info	(	Display *	dpy,
		Drawable	d,
		XVisualInfo *	visInfo
	)			[static]

Definition at line 226 of file egl_xlib.c.

{
   XWindowAttributes attr;
   XVisualInfo visTemp, *vis;
   int num_visuals;

   XGetWindowAttributes(dpy, d, &attr);

   visTemp.screen = DefaultScreen(dpy);
   visTemp.visualid = attr.visual->visualid;
   vis = XGetVisualInfo(dpy,
                        (VisualScreenMask | VisualIDMask),
                        &visTemp, &num_visuals);
   if (vis)
      *visInfo = *vis;

   XFree(vis);
}

static struct xlib_egl_context* lookup_context

(

EGLContext

surf

)

[static, read]

Definition at line 112 of file egl_xlib.c.

{
   _EGLContext *context = _eglLookupContext(surf);
   return (struct xlib_egl_context *) context;
}

static struct xlib_egl_surface* lookup_surface

(

EGLSurface

surf

)

[static, read]

Definition at line 104 of file egl_xlib.c.

{
   _EGLSurface *surface = _eglLookupSurface(surf);
   return (struct xlib_egl_surface *) surface;
}

static struct xlib_egl_driver* xlib_egl_driver

(

_EGLDriver *

drv

)

[static, read]

cast wrapper

Definition at line 97 of file egl_xlib.c.

{
   return (struct xlib_egl_driver *) drv;
}

static EGLContext xlib_eglCreateContext	(	_EGLDriver *	drv,
		EGLDisplay	dpy,
		EGLConfig	config,
		EGLContext	share_list,
		const EGLint *	attrib_list
	)			[static]

Called via eglCreateContext(), drv->API.CreateContext().

Definition at line 332 of file egl_xlib.c.

References xlib_egl_context::Base, CALLOC_STRUCT, xlib_egl_context::Context, xlib_egl_context::pipe, xlib_egl_driver::screen, softpipe_create(), st_create_context(), xlib_egl_driver::winsys, and xlib_egl_driver().

{
   struct xlib_egl_driver *xdrv = xlib_egl_driver(drv);
   _EGLConfig *conf = _eglLookupConfig(drv, dpy, config);
   struct xlib_egl_context *ctx;
   struct st_context *share_ctx = NULL; /* XXX fix */
   __GLcontextModes visual;

   ctx = CALLOC_STRUCT(xlib_egl_context);
   if (!ctx)
      return EGL_NO_CONTEXT;

   /* let EGL lib init the common stuff */
   if (!_eglInitContext(drv, dpy, &ctx->Base, config, attrib_list)) {
      free(ctx);
      return EGL_NO_CONTEXT;
   }

   /* API-dependent context creation */
   switch (ctx->Base.ClientAPI) {
   case EGL_OPENVG_API:
   case EGL_OPENGL_ES_API:
      _eglLog(_EGL_DEBUG, "Create Context for ES version %d\n",
              ctx->Base.ClientVersion);
      /* fall-through */
   case EGL_OPENGL_API:
      /* create a softpipe context */
      ctx->pipe = softpipe_create(xdrv->screen, xdrv->winsys, NULL);
      /* Now do xlib / state tracker inits here */
      _eglConfigToContextModesRec(conf, &visual);
      ctx->Context = st_create_context(ctx->pipe, &visual, share_ctx);
      break;
   default:
      _eglError(EGL_BAD_MATCH, "eglCreateContext(unsupported API)");
      free(ctx);
      return EGL_NO_CONTEXT;
   }

   _eglSaveContext(&ctx->Base);

   return _eglGetContextHandle(&ctx->Base);
}

static EGLSurface xlib_eglCreateWindowSurface	(	_EGLDriver *	drv,
		EGLDisplay	dpy,
		EGLConfig	config,
		NativeWindowType	window,
		const EGLint *	attrib_list
	)			[static]

Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface().

Definition at line 475 of file egl_xlib.c.

References xlib_egl_surface::Base, CALLOC_STRUCT, choose_color_format(), choose_depth_format(), choose_stencil_format(), xlib_egl_surface::Dpy, xlib_egl_surface::Framebuffer, xlib_egl_surface::Gc, get_drawable_size(), get_drawable_visual_info(), st_create_framebuffer(), st_resize_framebuffer(), xlib_egl_surface::VisInfo, xlib_egl_surface::Win, xlib_egl_driver::winsys, xlib_egl_surface::winsys, and xlib_egl_driver().

{
   struct xlib_egl_driver *xdrv = xlib_egl_driver(drv);
   _EGLDisplay *disp = _eglLookupDisplay(dpy);
   _EGLConfig *conf = _eglLookupConfig(drv, dpy, config);

   struct xlib_egl_surface *surf;
   __GLcontextModes visual;
   uint width, height;

   surf = CALLOC_STRUCT(xlib_egl_surface);
   if (!surf)
      return EGL_NO_SURFACE;

   /* Let EGL lib init the common stuff */
   if (!_eglInitSurface(drv, dpy, &surf->Base, EGL_WINDOW_BIT,
                        config, attrib_list)) {
      free(surf);
      return EGL_NO_SURFACE;
   }

   _eglSaveSurface(&surf->Base);

   /*
    * Now init the Xlib and gallium stuff
    */
   surf->Win = (Window) window;  /* The X window ID */
   surf->Dpy = disp->Xdpy;  /* The X display */
   surf->Gc = XCreateGC(surf->Dpy, surf->Win, 0, NULL);

   surf->winsys = xdrv->winsys;

   _eglConfigToContextModesRec(conf, &visual);
   get_drawable_size(surf->Dpy, surf->Win, &width, &height);
   get_drawable_visual_info(surf->Dpy, surf->Win, &surf->VisInfo);

   surf->Base.Width = width;
   surf->Base.Height = height;

   /* Create GL statetracker framebuffer */
   surf->Framebuffer = st_create_framebuffer(&visual,
                                             choose_color_format(&visual),
                                             choose_depth_format(&visual),
                                             choose_stencil_format(&visual),
                                             width, height,
                                             (void *) surf);

   st_resize_framebuffer(surf->Framebuffer, width, height);

   return _eglGetSurfaceHandle(&surf->Base);
}

static EGLBoolean xlib_eglDestroyContext	(	_EGLDriver *	drv,
		EGLDisplay	dpy,
		EGLContext	ctx
	)			[static]

Definition at line 378 of file egl_xlib.c.

References assert, xlib_egl_context::Base, xlib_egl_context::Context, lookup_context(), and st_destroy_context().

{
   struct xlib_egl_context *context = lookup_context(ctx);
   if (context) {
      if (context->Base.IsBound) {
         context->Base.DeletePending = EGL_TRUE;
      }
      else {
         /* API-dependent clean-up */
         switch (context->Base.ClientAPI) {
         case EGL_OPENGL_ES_API:
            /* fall-through */
         case EGL_OPENGL_API:
            st_destroy_context(context->Context);
            break;
         default:
            assert(0);
         }
         free(context);
      }
      return EGL_TRUE;
   }
   else {
      _eglError(EGL_BAD_CONTEXT, "eglDestroyContext");
      return EGL_TRUE;
   }
}

static EGLBoolean xlib_eglDestroySurface	(	_EGLDriver *	drv,
		EGLDisplay	dpy,
		EGLSurface	surface
	)			[static]

Definition at line 530 of file egl_xlib.c.

References xlib_egl_surface::Base, xlib_egl_surface::Dpy, xlib_egl_surface::Framebuffer, xlib_egl_surface::Gc, lookup_surface(), and st_unreference_framebuffer().

{
   struct xlib_egl_surface *surf = lookup_surface(surface);
   if (surf) {
      _eglHashRemove(_eglGlobal.Surfaces, (EGLuint) surface);
      if (surf->Base.IsBound) {
         surf->Base.DeletePending = EGL_TRUE;
      }
      else {
         XFreeGC(surf->Dpy, surf->Gc);
         st_unreference_framebuffer(&surf->Framebuffer);
         free(surf);
      }
      return EGL_TRUE;
   }
   else {
      _eglError(EGL_BAD_SURFACE, "eglDestroySurface");
      return EGL_FALSE;
   }
}

static _EGLProc xlib_eglGetProcAddress

(

const char *

procname

)

[static]

Definition at line 219 of file egl_xlib.c.

References st_get_proc_address().

{
   return (_EGLProc) st_get_proc_address(procname);
}

static EGLBoolean xlib_eglInitialize	(	_EGLDriver *	drv,
		EGLDisplay	dpy,
		EGLint *	minor,
		EGLint *	major
	)			[static]

Called via eglInitialize(), drv->API.Initialize().

Definition at line 193 of file egl_xlib.c.

References create_configs().

{
   create_configs(drv, dpy);

   drv->Initialized = EGL_TRUE;

   /* we're supporting EGL 1.4 */
   *minor = 1;
   *major = 4;

   return EGL_TRUE;
}

static EGLBoolean xlib_eglMakeCurrent	(	_EGLDriver *	drv,
		EGLDisplay	dpy,
		EGLSurface	draw,
		EGLSurface	read,
		EGLContext	ctx
	)			[static]

Called via eglMakeCurrent(), drv->API.MakeCurrent().

Definition at line 411 of file egl_xlib.c.

References check_and_update_buffer_size(), xlib_egl_context::Context, xlib_egl_surface::Framebuffer, lookup_context(), lookup_surface(), and st_make_current().

{
   struct xlib_egl_context *context = lookup_context(ctx);
   struct xlib_egl_surface *draw_surf = lookup_surface(draw);
   struct xlib_egl_surface *read_surf = lookup_surface(read);

   if (!_eglMakeCurrent(drv, dpy, draw, read, context))
      return EGL_FALSE;

   st_make_current((context ? context->Context : NULL),
                   (draw_surf ? draw_surf->Framebuffer : NULL),
                   (read_surf ? read_surf->Framebuffer : NULL));

   if (draw_surf)
      check_and_update_buffer_size(draw_surf);
   if (read_surf && read_surf != draw_surf)
      check_and_update_buffer_size(draw_surf);

   return EGL_TRUE;
}

static EGLBoolean xlib_eglSwapBuffers	(	_EGLDriver *	drv,
		EGLDisplay	dpy,
		EGLSurface	draw
	)			[static]

Definition at line 553 of file egl_xlib.c.

References check_and_update_buffer_size(), display_surface(), xlib_egl_surface::Framebuffer, lookup_surface(), st_get_framebuffer_surface(), st_notify_swapbuffers(), ST_SURFACE_BACK_LEFT, and xlib_egl_surface::winsys.

{
   /* error checking step: */
   if (!_eglSwapBuffers(drv, dpy, draw))
      return EGL_FALSE;

   {
      struct xlib_egl_surface *xsurf = lookup_surface(draw);
      struct pipe_winsys *pws = xsurf->winsys;
      struct pipe_surface *psurf =
         st_get_framebuffer_surface(xsurf->Framebuffer, ST_SURFACE_BACK_LEFT);

      st_notify_swapbuffers(xsurf->Framebuffer);

      display_surface(pws, psurf, xsurf);

      check_and_update_buffer_size(xsurf);
   }

   return EGL_TRUE;
}

static EGLBoolean xlib_eglTerminate	(	_EGLDriver *	drv,
		EGLDisplay	dpy
	)			[static]

Called via eglTerminate(), drv->API.Terminate().

Definition at line 212 of file egl_xlib.c.

{
   return EGL_TRUE;
}

---