2 * Mesa 3-D graphics library
5 * Copyright (C) 2009-2010 Chia-I Wu <olv@0xlab.org>
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 * DEALINGS IN THE SOFTWARE.
26 #include "egldriver.h"
27 #include "eglcurrent.h"
30 #include "pipe/p_screen.h"
31 #include "util/u_memory.h"
32 #include "util/u_inlines.h"
35 #include "egl_g3d_api.h"
36 #include "egl_g3d_image.h"
37 #include "egl_g3d_st.h"
41 * Return the state tracker for the given context.
43 static struct st_api *
44 egl_g3d_choose_st(_EGLDriver *drv, _EGLContext *ctx)
46 struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
50 switch (ctx->ClientAPI) {
51 case EGL_OPENGL_ES_API:
52 switch (ctx->ClientVersion) {
54 idx = ST_API_OPENGL_ES1;
57 idx = ST_API_OPENGL_ES2;
60 _eglLog(_EGL_WARNING, "unknown client version %d",
72 _eglLog(_EGL_WARNING, "unknown client API 0x%04x", ctx->ClientAPI);
76 stapi = (idx >= 0) ? gdrv->stapis[idx] : NULL;
81 egl_g3d_create_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
82 _EGLContext *share, const EGLint *attribs)
84 struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
85 struct egl_g3d_context *gshare = egl_g3d_context(share);
86 struct egl_g3d_config *gconf = egl_g3d_config(conf);
87 struct egl_g3d_context *gctx;
89 gctx = CALLOC_STRUCT(egl_g3d_context);
91 _eglError(EGL_BAD_ALLOC, "eglCreateContext");
95 if (!_eglInitContext(&gctx->base, dpy, conf, attribs)) {
100 gctx->stapi = egl_g3d_choose_st(drv, &gctx->base);
106 gctx->stctxi = gctx->stapi->create_context(gctx->stapi, gdpy->smapi,
107 &gconf->stvis, (gshare) ? gshare->stctxi : NULL);
113 gctx->stctxi->st_manager_private = (void *) &gctx->base;
122 destroy_context(_EGLDisplay *dpy, _EGLContext *ctx)
124 struct egl_g3d_context *gctx = egl_g3d_context(ctx);
126 /* FIXME a context might live longer than its display */
127 if (!dpy->Initialized)
128 _eglLog(_EGL_FATAL, "destroy a context with an unitialized display");
130 gctx->stctxi->destroy(gctx->stctxi);
136 egl_g3d_destroy_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
138 if (!_eglIsContextBound(ctx))
139 destroy_context(dpy, ctx);
143 struct egl_g3d_create_surface_arg {
146 EGLNativeWindowType win;
147 EGLNativePixmapType pix;
152 egl_g3d_create_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf,
153 struct egl_g3d_create_surface_arg *arg,
154 const EGLint *attribs)
156 struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
157 struct egl_g3d_config *gconf = egl_g3d_config(conf);
158 struct egl_g3d_surface *gsurf;
159 struct native_surface *nsurf;
164 err = "eglCreateWindowSurface";
167 err = "eglCreatePixmapSurface";
169 #ifdef EGL_MESA_screen_surface
170 case EGL_SCREEN_BIT_MESA:
171 err = "eglCreateScreenSurface";
175 err = "eglCreateUnknownSurface";
179 gsurf = CALLOC_STRUCT(egl_g3d_surface);
181 _eglError(EGL_BAD_ALLOC, err);
185 if (!_eglInitSurface(&gsurf->base, dpy, arg->type, conf, attribs)) {
190 /* create the native surface */
193 nsurf = gdpy->native->create_window_surface(gdpy->native,
194 arg->u.win, gconf->native);
197 nsurf = gdpy->native->create_pixmap_surface(gdpy->native,
198 arg->u.pix, gconf->native);
200 #ifdef EGL_MESA_screen_surface
201 case EGL_SCREEN_BIT_MESA:
202 /* prefer back buffer (move to _eglInitSurface?) */
203 gsurf->base.RenderBuffer = EGL_BACK_BUFFER;
204 nsurf = gdpy->native->modeset->create_scanout_surface(gdpy->native,
205 gconf->native, gsurf->base.Width, gsurf->base.Height);
217 /* initialize the geometry */
218 if (!nsurf->validate(nsurf, 0x0, &gsurf->sequence_number, NULL,
219 &gsurf->base.Width, &gsurf->base.Height)) {
220 nsurf->destroy(nsurf);
225 gsurf->stvis = gconf->stvis;
226 if (gsurf->base.RenderBuffer == EGL_SINGLE_BUFFER)
227 gsurf->stvis.render_buffer = ST_ATTACHMENT_FRONT_LEFT;
229 gsurf->stfbi = egl_g3d_create_st_framebuffer(&gsurf->base);
231 nsurf->destroy(nsurf);
236 nsurf->user_data = &gsurf->base;
237 gsurf->native = nsurf;
243 egl_g3d_create_window_surface(_EGLDriver *drv, _EGLDisplay *dpy,
244 _EGLConfig *conf, EGLNativeWindowType win,
245 const EGLint *attribs)
247 struct egl_g3d_create_surface_arg arg;
249 memset(&arg, 0, sizeof(arg));
250 arg.type = EGL_WINDOW_BIT;
253 return egl_g3d_create_surface(drv, dpy, conf, &arg, attribs);
257 egl_g3d_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *dpy,
258 _EGLConfig *conf, EGLNativePixmapType pix,
259 const EGLint *attribs)
261 struct egl_g3d_create_surface_arg arg;
263 memset(&arg, 0, sizeof(arg));
264 arg.type = EGL_PIXMAP_BIT;
267 return egl_g3d_create_surface(drv, dpy, conf, &arg, attribs);
271 egl_g3d_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy,
272 _EGLConfig *conf, const EGLint *attribs)
274 struct egl_g3d_config *gconf = egl_g3d_config(conf);
275 struct egl_g3d_surface *gsurf;
277 gsurf = CALLOC_STRUCT(egl_g3d_surface);
279 _eglError(EGL_BAD_ALLOC, "eglCreatePbufferSurface");
283 if (!_eglInitSurface(&gsurf->base, dpy, EGL_PBUFFER_BIT, conf, attribs)) {
288 gsurf->stvis = gconf->stvis;
290 gsurf->stfbi = egl_g3d_create_st_framebuffer(&gsurf->base);
303 destroy_surface(_EGLDisplay *dpy, _EGLSurface *surf)
305 struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
307 /* FIXME a surface might live longer than its display */
308 if (!dpy->Initialized)
309 _eglLog(_EGL_FATAL, "destroy a surface with an unitialized display");
311 pipe_resource_reference(&gsurf->render_texture, NULL);
312 egl_g3d_destroy_st_framebuffer(gsurf->stfbi);
314 gsurf->native->destroy(gsurf->native);
319 egl_g3d_destroy_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
321 if (!_eglIsSurfaceBound(surf))
322 destroy_surface(dpy, surf);
327 egl_g3d_make_current(_EGLDriver *drv, _EGLDisplay *dpy,
328 _EGLSurface *draw, _EGLSurface *read, _EGLContext *ctx)
330 struct egl_g3d_context *gctx = egl_g3d_context(ctx);
331 struct egl_g3d_surface *gdraw = egl_g3d_surface(draw);
332 struct egl_g3d_surface *gread = egl_g3d_surface(read);
333 struct egl_g3d_context *old_gctx;
334 EGLBoolean ok = EGL_TRUE;
336 /* bind the new context and return the "orphaned" one */
337 if (!_eglBindContext(&ctx, &draw, &read))
339 old_gctx = egl_g3d_context(ctx);
342 /* flush old context */
343 old_gctx->stctxi->flush(old_gctx->stctxi,
344 PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
348 ok = gctx->stapi->make_current(gctx->stapi, gctx->stctxi,
349 (gdraw) ? gdraw->stfbi : NULL, (gread) ? gread->stfbi : NULL);
351 gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi, gdraw->stfbi);
352 if (gread != gdraw) {
353 gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi,
357 if (gdraw->base.Type == EGL_WINDOW_BIT) {
358 gctx->base.WindowRenderBuffer =
359 (gdraw->stvis.render_buffer == ST_ATTACHMENT_FRONT_LEFT) ?
360 EGL_SINGLE_BUFFER : EGL_BACK_BUFFER;
365 ok = old_gctx->stapi->make_current(old_gctx->stapi, NULL, NULL, NULL);
366 old_gctx->base.WindowRenderBuffer = EGL_NONE;
369 if (ctx && !_eglIsContextLinked(ctx))
370 destroy_context(dpy, ctx);
371 if (draw && !_eglIsSurfaceLinked(draw))
372 destroy_surface(dpy, draw);
373 if (read && read != draw && !_eglIsSurfaceLinked(read))
374 destroy_surface(dpy, read);
380 egl_g3d_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf)
382 struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
383 _EGLContext *ctx = _eglGetCurrentContext();
384 struct egl_g3d_context *gctx = NULL;
386 /* no-op for pixmap or pbuffer surface */
387 if (gsurf->base.Type == EGL_PIXMAP_BIT ||
388 gsurf->base.Type == EGL_PBUFFER_BIT)
391 /* or when the surface is single-buffered */
392 if (gsurf->stvis.render_buffer == ST_ATTACHMENT_FRONT_LEFT)
395 if (ctx && ctx->DrawSurface == surf)
396 gctx = egl_g3d_context(ctx);
398 /* flush if the surface is current */
400 gctx->stctxi->flush(gctx->stctxi,
401 PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
404 return gsurf->native->swap_buffers(gsurf->native);
408 * Get the pipe surface of the given attachment of the native surface.
410 static struct pipe_resource *
411 get_pipe_resource(struct native_display *ndpy, struct native_surface *nsurf,
412 enum native_attachment natt)
414 struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS];
416 textures[natt] = NULL;
417 nsurf->validate(nsurf, 1 << natt, NULL, textures, NULL, NULL);
419 return textures[natt];
423 egl_g3d_copy_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surf,
424 EGLNativePixmapType target)
426 struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
427 struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
428 _EGLContext *ctx = _eglGetCurrentContext();
429 struct egl_g3d_config *gconf;
430 struct native_surface *nsurf;
431 struct pipe_screen *screen = gdpy->native->screen;
432 struct pipe_resource *ptex;
434 if (!gsurf->render_texture)
437 gconf = egl_g3d_config(egl_g3d_find_pixmap_config(dpy, target));
439 return _eglError(EGL_BAD_NATIVE_PIXMAP, "eglCopyBuffers");
441 nsurf = gdpy->native->create_pixmap_surface(gdpy->native,
442 target, gconf->native);
444 return _eglError(EGL_BAD_NATIVE_PIXMAP, "eglCopyBuffers");
446 /* flush if the surface is current */
447 if (ctx && ctx->DrawSurface == &gsurf->base) {
448 struct egl_g3d_context *gctx = egl_g3d_context(ctx);
449 gctx->stctxi->flush(gctx->stctxi,
450 PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
453 /* create a pipe context to copy surfaces */
456 gdpy->native->screen->context_create(gdpy->native->screen, NULL);
461 ptex = get_pipe_resource(gdpy->native, nsurf, NATIVE_ATTACHMENT_FRONT_LEFT);
463 struct pipe_surface *psrc;
464 struct pipe_subresource subsrc, subdst;
471 gdpy->pipe->resource_copy_region(gdpy->pipe, ptex, subdst, 0, 0, 0,
472 gsurf->render_texture, subsrc, 0, 0, 0, ptex->width0, ptex->height0);
474 nsurf->flush_frontbuffer(nsurf);
477 pipe_resource_reference(&ptex, NULL);
480 nsurf->destroy(nsurf);
486 egl_g3d_wait_client(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx)
488 struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
489 struct egl_g3d_context *gctx = egl_g3d_context(ctx);
490 struct pipe_screen *screen = gdpy->native->screen;
491 struct pipe_fence_handle *fence = NULL;
493 gctx->stctxi->flush(gctx->stctxi,
494 PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, &fence);
495 screen->fence_finish(screen, fence, 0);
496 screen->fence_reference(screen, &fence, NULL);
502 egl_g3d_wait_native(_EGLDriver *drv, _EGLDisplay *dpy, EGLint engine)
504 _EGLContext *ctx = _eglGetCurrentContext();
506 if (engine != EGL_CORE_NATIVE_ENGINE)
507 return _eglError(EGL_BAD_PARAMETER, "eglWaitNative");
509 if (ctx && ctx->DrawSurface) {
510 struct egl_g3d_surface *gsurf = egl_g3d_surface(ctx->DrawSurface);
513 gsurf->native->wait(gsurf->native);
520 egl_g3d_bind_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
521 _EGLSurface *surf, EGLint buffer)
523 struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
524 _EGLContext *es1 = _eglGetAPIContext(EGL_OPENGL_ES_API);
525 struct egl_g3d_context *gctx;
526 enum pipe_format internal_format;
527 enum st_texture_type target;
529 if (!gsurf || gsurf->base.Type != EGL_PBUFFER_BIT)
530 return _eglError(EGL_BAD_SURFACE, "eglBindTexImage");
531 if (buffer != EGL_BACK_BUFFER)
532 return _eglError(EGL_BAD_PARAMETER, "eglBindTexImage");
533 if (gsurf->base.BoundToTexture)
534 return _eglError(EGL_BAD_ACCESS, "eglBindTexImage");
536 switch (gsurf->base.TextureFormat) {
537 case EGL_TEXTURE_RGB:
538 internal_format = PIPE_FORMAT_R8G8B8_UNORM;
540 case EGL_TEXTURE_RGBA:
541 internal_format = PIPE_FORMAT_B8G8R8A8_UNORM;
544 return _eglError(EGL_BAD_MATCH, "eglBindTexImage");
547 switch (gsurf->base.TextureTarget) {
549 target = ST_TEXTURE_2D;
552 return _eglError(EGL_BAD_MATCH, "eglBindTexImage");
557 if (!gsurf->render_texture)
560 /* flush properly if the surface is bound */
561 if (gsurf->base.CurrentContext) {
562 gctx = egl_g3d_context(gsurf->base.CurrentContext);
563 gctx->stctxi->flush(gctx->stctxi,
564 PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, NULL);
567 gctx = egl_g3d_context(es1);
568 if (gctx->stctxi->teximage) {
569 if (!gctx->stctxi->teximage(gctx->stctxi, target,
570 gsurf->base.MipmapLevel, internal_format,
571 gsurf->render_texture, gsurf->base.MipmapTexture))
573 gsurf->base.BoundToTexture = EGL_TRUE;
580 egl_g3d_release_tex_image(_EGLDriver *drv, _EGLDisplay *dpy,
581 _EGLSurface *surf, EGLint buffer)
583 struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
585 if (!gsurf || gsurf->base.Type != EGL_PBUFFER_BIT ||
586 !gsurf->base.BoundToTexture)
587 return _eglError(EGL_BAD_SURFACE, "eglReleaseTexImage");
588 if (buffer != EGL_BACK_BUFFER)
589 return _eglError(EGL_BAD_PARAMETER, "eglReleaseTexImage");
591 if (gsurf->render_texture) {
592 _EGLContext *ctx = _eglGetAPIContext(EGL_OPENGL_ES_API);
593 struct egl_g3d_context *gctx = egl_g3d_context(ctx);
595 /* what if the context the surface binds to is no longer current? */
597 gctx->stctxi->teximage(gctx->stctxi, ST_TEXTURE_2D,
598 gsurf->base.MipmapLevel, PIPE_FORMAT_NONE, NULL, FALSE);
602 gsurf->base.BoundToTexture = EGL_FALSE;
607 #ifdef EGL_MESA_screen_surface
610 egl_g3d_create_screen_surface(_EGLDriver *drv, _EGLDisplay *dpy,
611 _EGLConfig *conf, const EGLint *attribs)
613 struct egl_g3d_create_surface_arg arg;
615 memset(&arg, 0, sizeof(arg));
616 arg.type = EGL_SCREEN_BIT_MESA;
618 return egl_g3d_create_surface(drv, dpy, conf, &arg, attribs);
622 egl_g3d_show_screen_surface(_EGLDriver *drv, _EGLDisplay *dpy,
623 _EGLScreen *scr, _EGLSurface *surf,
626 struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
627 struct egl_g3d_screen *gscr = egl_g3d_screen(scr);
628 struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
629 struct native_surface *nsurf;
630 const struct native_mode *nmode;
637 return _eglError(EGL_BAD_MATCH, "eglShowSurfaceMESA");
638 if (gsurf->base.Type != EGL_SCREEN_BIT_MESA)
639 return _eglError(EGL_BAD_SURFACE, "eglShowScreenSurfaceMESA");
640 if (gsurf->base.Width < mode->Width || gsurf->base.Height < mode->Height)
641 return _eglError(EGL_BAD_MATCH,
642 "eglShowSurfaceMESA(surface smaller than mode size)");
644 /* find the index of the mode */
645 for (idx = 0; idx < gscr->base.NumModes; idx++)
646 if (mode == &gscr->base.Modes[idx])
648 if (idx >= gscr->base.NumModes) {
649 return _eglError(EGL_BAD_MODE_MESA,
650 "eglShowSurfaceMESA(unknown mode)");
653 nsurf = gsurf->native;
654 nmode = gscr->native_modes[idx];
658 return _eglError(EGL_BAD_MATCH, "eglShowSurfaceMESA");
660 /* disable the screen */
665 /* TODO surface panning by CRTC choosing */
666 changed = gdpy->native->modeset->program(gdpy->native, 0, nsurf,
667 gscr->base.OriginX, gscr->base.OriginY, &gscr->native, 1, nmode);
669 gscr->base.CurrentSurface = &gsurf->base;
670 gscr->base.CurrentMode = mode;
676 #endif /* EGL_MESA_screen_surface */
679 * Find a config that supports the pixmap.
682 egl_g3d_find_pixmap_config(_EGLDisplay *dpy, EGLNativePixmapType pix)
684 struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
685 struct egl_g3d_config *gconf;
688 for (i = 0; i < dpy->NumConfigs; i++) {
689 gconf = egl_g3d_config(dpy->Configs[i]);
690 if (gdpy->native->is_pixmap_supported(gdpy->native, pix, gconf->native))
694 return (i < dpy->NumConfigs) ? &gconf->base : NULL;
698 egl_g3d_init_driver_api(_EGLDriver *drv)
700 _eglInitDriverFallbacks(drv);
702 drv->API.CreateContext = egl_g3d_create_context;
703 drv->API.DestroyContext = egl_g3d_destroy_context;
704 drv->API.CreateWindowSurface = egl_g3d_create_window_surface;
705 drv->API.CreatePixmapSurface = egl_g3d_create_pixmap_surface;
706 drv->API.CreatePbufferSurface = egl_g3d_create_pbuffer_surface;
707 drv->API.DestroySurface = egl_g3d_destroy_surface;
708 drv->API.MakeCurrent = egl_g3d_make_current;
709 drv->API.SwapBuffers = egl_g3d_swap_buffers;
710 drv->API.CopyBuffers = egl_g3d_copy_buffers;
711 drv->API.WaitClient = egl_g3d_wait_client;
712 drv->API.WaitNative = egl_g3d_wait_native;
714 drv->API.BindTexImage = egl_g3d_bind_tex_image;
715 drv->API.ReleaseTexImage = egl_g3d_release_tex_image;
717 drv->API.CreateImageKHR = egl_g3d_create_image;
718 drv->API.DestroyImageKHR = egl_g3d_destroy_image;
720 #ifdef EGL_MESA_screen_surface
721 drv->API.CreateScreenSurfaceMESA = egl_g3d_create_screen_surface;
722 drv->API.ShowScreenSurfaceMESA = egl_g3d_show_screen_surface;