X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fegl%2Fdrivers%2Fdri2%2Fplatform_x11.c;h=c463386481653ceeef307fa0fad01aae76437079;hb=d202fd6596c08fb8cbd745192f547d98f3e5ec84;hp=ec38e8123d8996a669904c1b03a8ce5cdb31f2d3;hpb=92b23683ebc839b13a565252cf13f5c2a715dcaa;p=mesa.git diff --git a/src/egl/drivers/dri2/platform_x11.c b/src/egl/drivers/dri2/platform_x11.c index ec38e8123d8..c4633864816 100644 --- a/src/egl/drivers/dri2/platform_x11.c +++ b/src/egl/drivers/dri2/platform_x11.c @@ -40,10 +40,11 @@ #endif #include #include +#include "util/debug.h" #include "util/macros.h" +#include "util/bitscan.h" #include "egl_dri2.h" -#include "egl_dri2_fallbacks.h" #include "loader.h" #ifdef HAVE_DRI3 @@ -51,8 +52,10 @@ #endif static EGLBoolean -dri2_x11_swap_interval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, - EGLint interval); +dri2_x11_swap_interval(_EGLDisplay *disp, _EGLSurface *surf, EGLint interval); + +uint32_t +dri2_format_for_depth(struct dri2_egl_display *dri2_dpy, uint32_t depth); static void swrastCreateDrawable(struct dri2_egl_display * dri2_dpy, @@ -74,6 +77,7 @@ swrastCreateDrawable(struct dri2_egl_display * dri2_dpy, xcb_create_gc(dri2_dpy->conn, dri2_surf->swapgc, dri2_surf->drawable, mask, valgc); switch (dri2_surf->depth) { case 32: + case 30: case 24: dri2_surf->bytes_per_pixel = 4; break; @@ -207,14 +211,43 @@ get_xcb_screen(xcb_screen_iterator_t iter, int screen) return NULL; } +static xcb_visualtype_t * +get_xcb_visualtype_for_depth(struct dri2_egl_display *dri2_dpy, int depth) +{ + xcb_visualtype_iterator_t visual_iter; + xcb_screen_t *screen = dri2_dpy->screen; + xcb_depth_iterator_t depth_iter = xcb_screen_allowed_depths_iterator(screen); + + for (; depth_iter.rem; xcb_depth_next(&depth_iter)) { + if (depth_iter.data->depth != depth) + continue; + + visual_iter = xcb_depth_visuals_iterator(depth_iter.data); + if (visual_iter.rem) + return visual_iter.data; + } + + return NULL; +} + +/* Get red channel mask for given depth. */ +unsigned int +dri2_x11_get_red_mask_for_depth(struct dri2_egl_display *dri2_dpy, int depth) +{ + xcb_visualtype_t *visual = get_xcb_visualtype_for_depth(dri2_dpy, depth); + + if (visual) + return visual->red_mask; + + return 0; +} /** - * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface(). + * Called via eglCreateWindowSurface(), drv->CreateWindowSurface(). */ static _EGLSurface * -dri2_x11_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type, - _EGLConfig *conf, void *native_surface, - const EGLint *attrib_list) +dri2_x11_create_surface(_EGLDisplay *disp, EGLint type, _EGLConfig *conf, + void *native_surface, const EGLint *attrib_list) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_config *dri2_conf = dri2_egl_config(conf); @@ -222,21 +255,16 @@ dri2_x11_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type, xcb_get_geometry_cookie_t cookie; xcb_get_geometry_reply_t *reply; xcb_generic_error_t *error; - xcb_drawable_t drawable; const __DRIconfig *config; - STATIC_ASSERT(sizeof(uintptr_t) == sizeof(native_surface)); - drawable = (uintptr_t) native_surface; - - (void) drv; - - dri2_surf = malloc(sizeof *dri2_surf); + dri2_surf = calloc(1, sizeof *dri2_surf); if (!dri2_surf) { _eglError(EGL_BAD_ALLOC, "dri2_create_surface"); return NULL; } - if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list)) + if (!dri2_init_surface(&dri2_surf->base, disp, type, conf, attrib_list, + false, native_surface)) goto cleanup_surf; dri2_surf->region = XCB_NONE; @@ -246,32 +274,20 @@ dri2_x11_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type, dri2_surf->drawable, dri2_dpy->screen->root, dri2_surf->base.Width, dri2_surf->base.Height); } else { - if (!drawable) { - assert(type == EGL_PIXMAP_BIT) - _eglError(EGL_BAD_NATIVE_PIXMAP, "dri2_create_surface"); - goto cleanup_surf; - } - dri2_surf->drawable = drawable; + STATIC_ASSERT(sizeof(uintptr_t) == sizeof(native_surface)); + dri2_surf->drawable = (uintptr_t) native_surface; } config = dri2_get_dri_config(dri2_conf, type, dri2_surf->base.GLColorspace); - if (dri2_dpy->dri2) { - dri2_surf->dri_drawable = - dri2_dpy->dri2->createNewDrawable(dri2_dpy->dri_screen, config, - dri2_surf); - } else { - assert(dri2_dpy->swrast); - dri2_surf->dri_drawable = - dri2_dpy->swrast->createNewDrawable(dri2_dpy->dri_screen, config, - dri2_surf); + if (!config) { + _eglError(EGL_BAD_MATCH, "Unsupported surfacetype/colorspace configuration"); + goto cleanup_pixmap; } - if (dri2_surf->dri_drawable == NULL) { - _eglError(EGL_BAD_ALLOC, "dri2->createNewDrawable"); + if (!dri2_create_drawable(dri2_dpy, config, dri2_surf, dri2_surf)) goto cleanup_pixmap; - } if (type != EGL_PBUFFER_BIT) { cookie = xcb_get_geometry (dri2_dpy->conn, dri2_surf->drawable); @@ -318,7 +334,7 @@ dri2_x11_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type, } } else { if (type == EGL_PBUFFER_BIT) { - dri2_surf->depth = _eglGetConfigKey(conf, EGL_BUFFER_SIZE); + dri2_surf->depth = conf->BufferSize; } swrastCreateDrawable(dri2_dpy, dri2_surf); } @@ -340,17 +356,16 @@ dri2_x11_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type, } /** - * Called via eglCreateWindowSurface(), drv->API.CreateWindowSurface(). + * Called via eglCreateWindowSurface(), drv->CreateWindowSurface(). */ static _EGLSurface * -dri2_x11_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp, - _EGLConfig *conf, void *native_window, - const EGLint *attrib_list) +dri2_x11_create_window_surface(_EGLDisplay *disp, _EGLConfig *conf, + void *native_window, const EGLint *attrib_list) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); _EGLSurface *surf; - surf = dri2_x11_create_surface(drv, disp, EGL_WINDOW_BIT, conf, + surf = dri2_x11_create_surface(disp, EGL_WINDOW_BIT, conf, native_window, attrib_list); if (surf != NULL) { /* When we first create the DRI2 drawable, its swap interval on the @@ -359,37 +374,34 @@ dri2_x11_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp, surf->SwapInterval = 1; /* Override that with a driconf-set value. */ - dri2_x11_swap_interval(drv, disp, surf, dri2_dpy->default_swap_interval); + dri2_x11_swap_interval(disp, surf, dri2_dpy->default_swap_interval); } return surf; } static _EGLSurface * -dri2_x11_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp, - _EGLConfig *conf, void *native_pixmap, - const EGLint *attrib_list) +dri2_x11_create_pixmap_surface(_EGLDisplay *disp, _EGLConfig *conf, + void *native_pixmap, const EGLint *attrib_list) { - return dri2_x11_create_surface(drv, disp, EGL_PIXMAP_BIT, conf, + return dri2_x11_create_surface(disp, EGL_PIXMAP_BIT, conf, native_pixmap, attrib_list); } static _EGLSurface * -dri2_x11_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp, - _EGLConfig *conf, const EGLint *attrib_list) +dri2_x11_create_pbuffer_surface(_EGLDisplay *disp, _EGLConfig *conf, + const EGLint *attrib_list) { - return dri2_x11_create_surface(drv, disp, EGL_PBUFFER_BIT, conf, - XCB_WINDOW_NONE, attrib_list); + return dri2_x11_create_surface(disp, EGL_PBUFFER_BIT, conf, + NULL, attrib_list); } static EGLBoolean -dri2_x11_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf) +dri2_x11_destroy_surface(_EGLDisplay *disp, _EGLSurface *surf) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf); - (void) drv; - dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable); if (dri2_dpy->dri2) { @@ -402,6 +414,7 @@ dri2_x11_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf) if (surf->Type == EGL_PBUFFER_BIT) xcb_free_pixmap (dri2_dpy->conn, dri2_surf->drawable); + dri2_fini_surface(surf); free(surf); return EGL_TRUE; @@ -416,11 +429,10 @@ dri2_x11_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf) * have. */ static EGLBoolean -dri2_query_surface(_EGLDriver *drv, _EGLDisplay *dpy, - _EGLSurface *surf, EGLint attribute, - EGLint *value) +dri2_query_surface(_EGLDisplay *disp, _EGLSurface *surf, + EGLint attribute, EGLint *value) { - struct dri2_egl_display *dri2_dpy = dri2_egl_display(dpy); + struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf); int x, y, w, h; @@ -437,7 +449,7 @@ dri2_query_surface(_EGLDriver *drv, _EGLDisplay *dpy, default: break; } - return _eglQuerySurface(drv, dpy, surf, attribute, value); + return _eglQuerySurface(disp, surf, attribute, value); } /** @@ -710,7 +722,6 @@ dri2_x11_connect(struct dri2_egl_display *dri2_dpy) if (dri2_dpy->driver_name == NULL) { close(dri2_dpy->fd); - free(dri2_dpy->driver_name); free(connect); return EGL_FALSE; } @@ -774,33 +785,44 @@ dri2_x11_add_configs_for_visuals(struct dri2_egl_display *dri2_dpy, EGL_NONE }; - unsigned int rgba_masks[4] = { - visuals[i].red_mask, - visuals[i].green_mask, - visuals[i].blue_mask, + int rgba_shifts[4] = { + ffs(visuals[i].red_mask) - 1, + ffs(visuals[i].green_mask) - 1, + ffs(visuals[i].blue_mask) - 1, + -1, + }; + + unsigned int rgba_sizes[4] = { + util_bitcount(visuals[i].red_mask), + util_bitcount(visuals[i].green_mask), + util_bitcount(visuals[i].blue_mask), 0, }; dri2_conf = dri2_add_config(disp, config, config_count + 1, surface_type, config_attrs, - rgba_masks); + rgba_shifts, rgba_sizes); if (dri2_conf) if (dri2_conf->base.ConfigID == config_count + 1) config_count++; /* Allow a 24-bit RGB visual to match a 32-bit RGBA EGLConfig. + * Ditto for 30-bit RGB visuals to match a 32-bit RGBA EGLConfig. * Otherwise it will only match a 32-bit RGBA visual. On a * composited window manager on X11, this will make all of the * EGLConfigs with destination alpha get blended by the * compositor. This is probably not what the application * wants... especially on drivers that only have 32-bit RGBA * EGLConfigs! */ - if (d.data->depth == 24) { - rgba_masks[3] = - ~(rgba_masks[0] | rgba_masks[1] | rgba_masks[2]); + if (d.data->depth == 24 || d.data->depth == 30) { + unsigned int rgba_mask = ~(visuals[i].red_mask | + visuals[i].green_mask | + visuals[i].blue_mask); + rgba_shifts[3] = ffs(rgba_mask) - 1; + rgba_sizes[3] = util_bitcount(rgba_mask); dri2_conf = dri2_add_config(disp, config, config_count + 1, surface_type, config_attrs, - rgba_masks); + rgba_shifts, rgba_sizes); if (dri2_conf) if (dri2_conf->base.ConfigID == config_count + 1) config_count++; @@ -820,7 +842,7 @@ dri2_x11_add_configs_for_visuals(struct dri2_egl_display *dri2_dpy, } static EGLBoolean -dri2_copy_region(_EGLDriver *drv, _EGLDisplay *disp, +dri2_copy_region(_EGLDisplay *disp, _EGLSurface *draw, xcb_xfixes_region_t region) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); @@ -850,7 +872,7 @@ dri2_copy_region(_EGLDriver *drv, _EGLDisplay *disp, } static int64_t -dri2_x11_swap_buffers_msc(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw, +dri2_x11_swap_buffers_msc(_EGLDisplay *disp, _EGLSurface *draw, int64_t msc, int64_t divisor, int64_t remainder) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); @@ -865,23 +887,22 @@ dri2_x11_swap_buffers_msc(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw, xcb_dri2_swap_buffers_reply_t *reply; int64_t swap_count = -1; - /* No-op for a pixmap or pbuffer surface */ - if (draw->Type == EGL_PIXMAP_BIT || draw->Type == EGL_PBUFFER_BIT) - return 0; - - if (draw->SwapBehavior == EGL_BUFFER_PRESERVED || !dri2_dpy->swap_available) - return dri2_copy_region(drv, disp, draw, dri2_surf->region) ? 0 : -1; - - dri2_flush_drawable_for_swapbuffers(disp, draw); + if (draw->SwapBehavior == EGL_BUFFER_PRESERVED || !dri2_dpy->swap_available) { + swap_count = dri2_copy_region(disp, draw, dri2_surf->region) ? 0 : -1; + } else { + dri2_flush_drawable_for_swapbuffers(disp, draw); - cookie = xcb_dri2_swap_buffers_unchecked(dri2_dpy->conn, dri2_surf->drawable, - msc_hi, msc_lo, divisor_hi, divisor_lo, remainder_hi, remainder_lo); + cookie = xcb_dri2_swap_buffers_unchecked(dri2_dpy->conn, + dri2_surf->drawable, msc_hi, + msc_lo, divisor_hi, divisor_lo, + remainder_hi, remainder_lo); - reply = xcb_dri2_swap_buffers_reply(dri2_dpy->conn, cookie, NULL); + reply = xcb_dri2_swap_buffers_reply(dri2_dpy->conn, cookie, NULL); - if (reply) { - swap_count = (((int64_t)reply->swap_hi) << 32) | reply->swap_lo; - free(reply); + if (reply) { + swap_count = combine_u32_into_u64(reply->swap_hi, reply->swap_lo); + free(reply); + } } /* Since we aren't watching for the server's invalidate events like we're @@ -901,7 +922,7 @@ dri2_x11_swap_buffers_msc(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw, } static EGLBoolean -dri2_x11_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw) +dri2_x11_swap_buffers(_EGLDisplay *disp, _EGLSurface *draw) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw); @@ -911,7 +932,7 @@ dri2_x11_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw) return EGL_TRUE; } - if (dri2_x11_swap_buffers_msc(drv, disp, draw, 0, 0, 0) == -1) { + if (dri2_x11_swap_buffers_msc(disp, draw, 0, 0, 0) == -1) { /* Swap failed with a window drawable. */ return _eglError(EGL_BAD_NATIVE_WINDOW, __func__); } @@ -919,8 +940,7 @@ dri2_x11_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw) } static EGLBoolean -dri2_x11_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, - _EGLSurface *draw, +dri2_x11_swap_buffers_region(_EGLDisplay *disp, _EGLSurface *draw, EGLint numRects, const EGLint *rects) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); @@ -930,7 +950,7 @@ dri2_x11_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, xcb_rectangle_t rectangles[16]; if (numRects > (int)ARRAY_SIZE(rectangles)) - return dri2_copy_region(drv, disp, draw, dri2_surf->region); + return dri2_copy_region(disp, draw, dri2_surf->region); for (int i = 0; i < numRects; i++) { rectangles[i].x = rects[i * 4]; @@ -941,14 +961,14 @@ dri2_x11_swap_buffers_region(_EGLDriver *drv, _EGLDisplay *disp, region = xcb_generate_id(dri2_dpy->conn); xcb_xfixes_create_region(dri2_dpy->conn, region, numRects, rectangles); - ret = dri2_copy_region(drv, disp, draw, region); + ret = dri2_copy_region(disp, draw, region); xcb_xfixes_destroy_region(dri2_dpy->conn, region); return ret; } static EGLBoolean -dri2_x11_post_sub_buffer(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw, +dri2_x11_post_sub_buffer(const _EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw, EGLint x, EGLint y, EGLint width, EGLint height) { const EGLint rect[4] = { x, y, width, height }; @@ -956,12 +976,11 @@ dri2_x11_post_sub_buffer(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw, if (x < 0 || y < 0 || width < 0 || height < 0) _eglError(EGL_BAD_PARAMETER, "eglPostSubBufferNV"); - return dri2_x11_swap_buffers_region(drv, disp, draw, 1, rect); + return dri2_x11_swap_buffers_region(disp, draw, 1, rect); } static EGLBoolean -dri2_x11_swap_interval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, - EGLint interval) +dri2_x11_swap_interval(_EGLDisplay *disp, _EGLSurface *surf, EGLint interval) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf); @@ -973,8 +992,7 @@ dri2_x11_swap_interval(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, } static EGLBoolean -dri2_x11_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, - void *native_pixmap_target) +dri2_x11_copy_buffers(_EGLDisplay *disp, _EGLSurface *surf, void *native_pixmap_target) { struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp); struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf); @@ -984,8 +1002,6 @@ dri2_x11_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, STATIC_ASSERT(sizeof(uintptr_t) == sizeof(native_pixmap_target)); target = (uintptr_t) native_pixmap_target; - (void) drv; - dri2_dpy->flush->flush(dri2_surf->dri_drawable); gc = xcb_generate_id(dri2_dpy->conn); @@ -1003,6 +1019,27 @@ dri2_x11_copy_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf, return EGL_TRUE; } +uint32_t +dri2_format_for_depth(struct dri2_egl_display *dri2_dpy, uint32_t depth) +{ + switch (depth) { + case 16: + return __DRI_IMAGE_FORMAT_RGB565; + case 24: + return __DRI_IMAGE_FORMAT_XRGB8888; + case 30: + /* Different preferred formats for different hw */ + if (dri2_x11_get_red_mask_for_depth(dri2_dpy, 30) == 0x3ff) + return __DRI_IMAGE_FORMAT_XBGR2101010; + else + return __DRI_IMAGE_FORMAT_XRGB2101010; + case 32: + return __DRI_IMAGE_FORMAT_ARGB8888; + default: + return __DRI_IMAGE_FORMAT_NONE; + } +} + static _EGLImage * dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx, EGLClientBuffer buffer, const EGLint *attr_list) @@ -1047,17 +1084,8 @@ dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx, return NULL; } - switch (geometry_reply->depth) { - case 16: - format = __DRI_IMAGE_FORMAT_RGB565; - break; - case 24: - format = __DRI_IMAGE_FORMAT_XRGB8888; - break; - case 32: - format = __DRI_IMAGE_FORMAT_ARGB8888; - break; - default: + format = dri2_format_for_depth(dri2_dpy, geometry_reply->depth); + if (format == __DRI_IMAGE_FORMAT_NONE) { _eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr: unsupported pixmap depth"); free(buffers_reply); @@ -1092,7 +1120,7 @@ dri2_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx, } static _EGLImage * -dri2_x11_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp, +dri2_x11_create_image_khr(const _EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attr_list) { @@ -1137,16 +1165,9 @@ static const struct dri2_egl_display_vtbl dri2_x11_swrast_display_vtbl = { .create_pbuffer_surface = dri2_x11_create_pbuffer_surface, .destroy_surface = dri2_x11_destroy_surface, .create_image = dri2_create_image_khr, - .swap_interval = dri2_fallback_swap_interval, .swap_buffers = dri2_x11_swap_buffers, - .set_damage_region = dri2_fallback_set_damage_region, - .swap_buffers_region = dri2_fallback_swap_buffers_region, - .post_sub_buffer = dri2_fallback_post_sub_buffer, - .copy_buffers = dri2_x11_copy_buffers, - .query_buffer_age = dri2_fallback_query_buffer_age, + /* XXX: should really implement this since X11 has pixmaps */ .query_surface = dri2_query_surface, - .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image, - .get_sync_values = dri2_fallback_get_sync_values, .get_dri_drawable = dri2_surface_get_dri_drawable, }; @@ -1159,14 +1180,10 @@ static const struct dri2_egl_display_vtbl dri2_x11_display_vtbl = { .create_image = dri2_x11_create_image_khr, .swap_interval = dri2_x11_swap_interval, .swap_buffers = dri2_x11_swap_buffers, - .swap_buffers_with_damage = dri2_fallback_swap_buffers_with_damage, .swap_buffers_region = dri2_x11_swap_buffers_region, - .set_damage_region = dri2_fallback_set_damage_region, .post_sub_buffer = dri2_x11_post_sub_buffer, .copy_buffers = dri2_x11_copy_buffers, - .query_buffer_age = dri2_fallback_query_buffer_age, .query_surface = dri2_query_surface, - .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image, .get_sync_values = dri2_x11_get_sync_values, .get_dri_drawable = dri2_surface_get_dri_drawable, }; @@ -1185,21 +1202,34 @@ static const __DRIextension *swrast_loader_extensions[] = { NULL, }; +static int +dri2_find_screen_for_display(const _EGLDisplay *disp, int fallback_screen) +{ + const EGLAttrib *attr; + + for (attr = disp->Options.Attribs; attr; attr += 2) { + if (attr[0] == EGL_PLATFORM_X11_SCREEN_EXT) + return attr[1]; + } + + return fallback_screen; +} + static EGLBoolean -dri2_get_xcb_connection(_EGLDriver *drv, _EGLDisplay *disp, +dri2_get_xcb_connection(_EGLDisplay *disp, struct dri2_egl_display *dri2_dpy) { xcb_screen_iterator_t s; - int screen = (uintptr_t)disp->Options.Platform; + int screen; const char *msg; disp->DriverData = (void *) dri2_dpy; if (disp->PlatformDisplay == NULL) { dri2_dpy->conn = xcb_connect(NULL, &screen); dri2_dpy->own_device = true; + screen = dri2_find_screen_for_display(disp, screen); } else { Display *dpy = disp->PlatformDisplay; - dri2_dpy->conn = XGetXCBConnection(dpy); screen = DefaultScreen(dpy); } @@ -1225,8 +1255,9 @@ disconnect: } static EGLBoolean -dri2_initialize_x11_swrast(_EGLDriver *drv, _EGLDisplay *disp) +dri2_initialize_x11_swrast(_EGLDisplay *disp) { + _EGLDevice *dev; struct dri2_egl_display *dri2_dpy; dri2_dpy = calloc(1, sizeof *dri2_dpy); @@ -1234,9 +1265,17 @@ dri2_initialize_x11_swrast(_EGLDriver *drv, _EGLDisplay *disp) return _eglError(EGL_BAD_ALLOC, "eglInitialize"); dri2_dpy->fd = -1; - if (!dri2_get_xcb_connection(drv, disp, dri2_dpy)) + if (!dri2_get_xcb_connection(disp, dri2_dpy)) goto cleanup; + dev = _eglAddDevice(dri2_dpy->fd, true); + if (!dev) { + _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice"); + goto cleanup; + } + + disp->Device = dev; + /* * Every hardware driver_name is set using strdup. Doing the same in * here will allow is to simply free the memory at dri2_terminate(). @@ -1281,6 +1320,7 @@ dri2_x11_setup_swap_interval(_EGLDisplay *disp) */ dri2_dpy->min_swap_interval = 0; dri2_dpy->max_swap_interval = 0; + dri2_dpy->default_swap_interval = 0; if (!dri2_dpy->swap_available) return; @@ -1297,12 +1337,14 @@ static const __DRIextension *dri3_image_loader_extensions[] = { &dri3_image_loader_extension.base, &image_lookup_extension.base, &use_invalidate.base, + &background_callable_extension.base, NULL, }; static EGLBoolean -dri2_initialize_x11_dri3(_EGLDriver *drv, _EGLDisplay *disp) +dri2_initialize_x11_dri3(_EGLDisplay *disp) { + _EGLDevice *dev; struct dri2_egl_display *dri2_dpy; dri2_dpy = calloc(1, sizeof *dri2_dpy); @@ -1310,12 +1352,20 @@ dri2_initialize_x11_dri3(_EGLDriver *drv, _EGLDisplay *disp) return _eglError(EGL_BAD_ALLOC, "eglInitialize"); dri2_dpy->fd = -1; - if (!dri2_get_xcb_connection(drv, disp, dri2_dpy)) + if (!dri2_get_xcb_connection(disp, dri2_dpy)) goto cleanup; if (!dri3_x11_connect(dri2_dpy)) goto cleanup; + dev = _eglAddDevice(dri2_dpy->fd, false); + if (!dev) { + _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice"); + goto cleanup; + } + + disp->Device = dev; + if (!dri2_load_driver_dri3(disp)) goto cleanup; @@ -1340,7 +1390,7 @@ dri2_initialize_x11_dri3(_EGLDriver *drv, _EGLDisplay *disp) disp->Extensions.CHROMIUM_sync_control = EGL_TRUE; disp->Extensions.EXT_buffer_age = EGL_TRUE; - dri2_set_WL_bind_wayland_display(drv, disp); + dri2_set_WL_bind_wayland_display(disp); if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp, false)) goto cleanup; @@ -1393,13 +1443,15 @@ static const __DRIextension *dri2_loader_extensions_old[] = { static const __DRIextension *dri2_loader_extensions[] = { &dri2_loader_extension.base, &image_lookup_extension.base, + &use_invalidate.base, &background_callable_extension.base, NULL, }; static EGLBoolean -dri2_initialize_x11_dri2(_EGLDriver *drv, _EGLDisplay *disp) +dri2_initialize_x11_dri2(_EGLDisplay *disp) { + _EGLDevice *dev; struct dri2_egl_display *dri2_dpy; dri2_dpy = calloc(1, sizeof *dri2_dpy); @@ -1407,12 +1459,20 @@ dri2_initialize_x11_dri2(_EGLDriver *drv, _EGLDisplay *disp) return _eglError(EGL_BAD_ALLOC, "eglInitialize"); dri2_dpy->fd = -1; - if (!dri2_get_xcb_connection(drv, disp, dri2_dpy)) + if (!dri2_get_xcb_connection(disp, dri2_dpy)) goto cleanup; if (!dri2_x11_connect(dri2_dpy)) goto cleanup; + dev = _eglAddDevice(dri2_dpy->fd, false); + if (!dev) { + _eglError(EGL_NOT_INITIALIZED, "DRI2: failed to find EGLDevice"); + goto cleanup; + } + + disp->Device = dev; + if (!dri2_load_driver(disp)) goto cleanup; @@ -1440,7 +1500,7 @@ dri2_initialize_x11_dri2(_EGLDriver *drv, _EGLDisplay *disp) disp->Extensions.NV_post_sub_buffer = EGL_TRUE; disp->Extensions.CHROMIUM_sync_control = EGL_TRUE; - dri2_set_WL_bind_wayland_display(drv, disp); + dri2_set_WL_bind_wayland_display(disp); if (!dri2_x11_add_configs_for_visuals(dri2_dpy, disp, true)) goto cleanup; @@ -1460,23 +1520,29 @@ dri2_initialize_x11_dri2(_EGLDriver *drv, _EGLDisplay *disp) } EGLBoolean -dri2_initialize_x11(_EGLDriver *drv, _EGLDisplay *disp) +dri2_initialize_x11(_EGLDisplay *disp) { EGLBoolean initialized = EGL_FALSE; - if (!getenv("LIBGL_ALWAYS_SOFTWARE")) { + if (!disp->Options.ForceSoftware) { #ifdef HAVE_DRI3 - if (!getenv("LIBGL_DRI3_DISABLE")) - initialized = dri2_initialize_x11_dri3(drv, disp); + if (!env_var_as_boolean("LIBGL_DRI3_DISABLE", false)) + initialized = dri2_initialize_x11_dri3(disp); #endif if (!initialized) - initialized = dri2_initialize_x11_dri2(drv, disp); + initialized = dri2_initialize_x11_dri2(disp); } if (!initialized) - initialized = dri2_initialize_x11_swrast(drv, disp); + initialized = dri2_initialize_x11_swrast(disp); return initialized; } +void +dri2_teardown_x11(struct dri2_egl_display *dri2_dpy) +{ + if (dri2_dpy->own_device) + xcb_disconnect(dri2_dpy->conn); +}