0, /* __DRI_ATTRIB_FRAMEBUFFER_SRGB_CAPABLE */
};
+static EGLBoolean
+dri2_match_config(const _EGLConfig *conf, const _EGLConfig *criteria)
+{
+ if (_eglCompareConfigs(conf, criteria, NULL, EGL_FALSE) != 0)
+ return EGL_FALSE;
+
+ if (!_eglMatchConfig(conf, criteria))
+ return EGL_FALSE;
+
+ return EGL_TRUE;
+}
+
struct dri2_egl_config *
dri2_add_config(_EGLDisplay *disp, const __DRIconfig *dri_config, int id,
- int depth, EGLint surface_type, const EGLint *attr_list)
+ int depth, EGLint surface_type, const EGLint *attr_list,
+ const unsigned int *rgba_masks)
{
struct dri2_egl_config *conf;
struct dri2_egl_display *dri2_dpy;
_EGLConfig base;
unsigned int attrib, value, double_buffer;
EGLint key, bind_to_texture_rgb, bind_to_texture_rgba;
+ unsigned int dri_masks[4] = { 0, 0, 0, 0 };
_EGLConfig *matching_config;
EGLint num_configs = 0;
EGLint config_id;
double_buffer = value;
break;
+ case __DRI_ATTRIB_RED_MASK:
+ dri_masks[0] = value;
+ break;
+
+ case __DRI_ATTRIB_GREEN_MASK:
+ dri_masks[1] = value;
+ break;
+
+ case __DRI_ATTRIB_BLUE_MASK:
+ dri_masks[2] = value;
+ break;
+
+ case __DRI_ATTRIB_ALPHA_MASK:
+ dri_masks[3] = value;
+ break;
+
default:
key = dri2_to_egl_attribute_map[attrib];
if (key != 0)
if (depth > 0 && depth != base.BufferSize)
return NULL;
+ if (rgba_masks && memcmp(rgba_masks, dri_masks, sizeof(dri_masks)))
+ return NULL;
+
base.NativeRenderable = EGL_TRUE;
base.SurfaceType = surface_type;
base.ConfigID = EGL_DONT_CARE;
base.SurfaceType = EGL_DONT_CARE;
num_configs = _eglFilterArray(disp->Configs, (void **) &matching_config, 1,
- (_EGLArrayForEach) _eglMatchConfig, &base);
+ (_EGLArrayForEach) dri2_match_config, &base);
if (num_configs == 1) {
conf = (struct dri2_egl_config *) matching_config;
else if (!double_buffer && !conf->dri_single_config)
conf->dri_single_config = dri_config;
else
- /* a similar config type is already added
- * => attach it as new config
- */
- num_configs = 0;
+ /* a similar config type is already added (unlikely) => discard */
+ return NULL;
}
-
- if (num_configs == 0) {
+ else if (num_configs == 0) {
conf = malloc(sizeof *conf);
if (conf == NULL)
return NULL;
_eglLinkConfig(&conf->base);
}
+ else {
+ assert(0);
+ return NULL;
+ }
conf->base.SurfaceType |= surface_type & (!double_buffer ? EGL_PIXMAP_BIT:
(EGL_WINDOW_BIT | EGL_PBUFFER_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT));
return conf;
}
-static __DRIimage *
+__DRIimage *
dri2_lookup_egl_image(__DRIscreen *screen, void *image, void *data)
{
_EGLDisplay *disp = data;
return ret;
}
-EGLBoolean
-dri2_load_driver(_EGLDisplay *disp)
+static const __DRIextension **
+dri2_open_driver(_EGLDisplay *disp)
{
struct dri2_egl_display *dri2_dpy = disp->DriverData;
const __DRIextension **extensions;
if (dri2_dpy->driver == NULL) {
_eglLog(_EGL_WARNING,
- "DRI2: failed to open any driver (search paths %s)",
- search_paths);
- return EGL_FALSE;
+ "DRI2: failed to open %s (search paths %s)",
+ dri2_dpy->driver_name, search_paths);
+ return NULL;
}
_eglLog(_EGL_DEBUG, "DRI2: dlopen(%s)", path);
_eglLog(_EGL_WARNING,
"DRI2: driver exports no extensions (%s)", dlerror());
dlclose(dri2_dpy->driver);
- return EGL_FALSE;
}
- if (strcmp(dri2_dpy->driver_name, "swrast") == 0) {
- if (!dri2_bind_extensions(dri2_dpy, swrast_driver_extensions, extensions)) {
- dlclose(dri2_dpy->driver);
- return EGL_FALSE;
- }
- } else {
- if (!dri2_bind_extensions(dri2_dpy, dri2_driver_extensions, extensions)) {
- dlclose(dri2_dpy->driver);
- return EGL_FALSE;
- }
- }
+ return extensions;
+}
+
+EGLBoolean
+dri2_load_driver(_EGLDisplay *disp)
+{
+ struct dri2_egl_display *dri2_dpy = disp->DriverData;
+ const __DRIextension **extensions;
+
+ extensions = dri2_open_driver(disp);
+ if (!extensions)
+ return EGL_FALSE;
+
+ if (!dri2_bind_extensions(dri2_dpy, dri2_driver_extensions, extensions)) {
+ dlclose(dri2_dpy->driver);
+ return EGL_FALSE;
+ }
return EGL_TRUE;
}
EGLBoolean
-dri2_create_screen(_EGLDisplay *disp)
+dri2_load_driver_swrast(_EGLDisplay *disp)
{
+ struct dri2_egl_display *dri2_dpy = disp->DriverData;
const __DRIextension **extensions;
- struct dri2_egl_display *dri2_dpy;
- unsigned int api_mask;
- dri2_dpy = disp->DriverData;
+ dri2_dpy->driver_name = "swrast";
+ extensions = dri2_open_driver(disp);
- if (dri2_dpy->dri2) {
- dri2_dpy->dri_screen =
- dri2_dpy->dri2->createNewScreen(0, dri2_dpy->fd, dri2_dpy->extensions,
- &dri2_dpy->driver_configs, disp);
- } else {
- assert(dri2_dpy->swrast);
- dri2_dpy->dri_screen =
- dri2_dpy->swrast->createNewScreen(0, dri2_dpy->extensions,
- &dri2_dpy->driver_configs, disp);
- }
+ if (!extensions)
+ return EGL_FALSE;
- if (dri2_dpy->dri_screen == NULL) {
- _eglLog(_EGL_WARNING, "DRI2: failed to create dri screen");
+ if (!dri2_bind_extensions(dri2_dpy, swrast_driver_extensions, extensions)) {
+ dlclose(dri2_dpy->driver);
return EGL_FALSE;
}
- extensions = dri2_dpy->core->getExtensions(dri2_dpy->dri_screen);
-
- if (dri2_dpy->dri2) {
- if (!dri2_bind_extensions(dri2_dpy, dri2_core_extensions, extensions))
- goto cleanup_dri_screen;
- } else {
- assert(dri2_dpy->swrast);
- if (!dri2_bind_extensions(dri2_dpy, swrast_core_extensions, extensions))
- goto cleanup_dri_screen;
- }
+ return EGL_TRUE;
+}
+
+void
+dri2_setup_screen(_EGLDisplay *disp)
+{
+ struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
+ unsigned int api_mask;
if (dri2_dpy->dri2) {
if (dri2_dpy->dri2->base.version >= 2)
disp->Extensions.KHR_image_base = EGL_TRUE;
disp->Extensions.KHR_gl_renderbuffer_image = EGL_TRUE;
}
+}
+
+EGLBoolean
+dri2_create_screen(_EGLDisplay *disp)
+{
+ const __DRIextension **extensions;
+ struct dri2_egl_display *dri2_dpy;
+
+ dri2_dpy = disp->DriverData;
+
+ if (dri2_dpy->dri2) {
+ dri2_dpy->dri_screen =
+ dri2_dpy->dri2->createNewScreen(0, dri2_dpy->fd, dri2_dpy->extensions,
+ &dri2_dpy->driver_configs, disp);
+ } else {
+ assert(dri2_dpy->swrast);
+ dri2_dpy->dri_screen =
+ dri2_dpy->swrast->createNewScreen(0, dri2_dpy->extensions,
+ &dri2_dpy->driver_configs, disp);
+ }
+
+ if (dri2_dpy->dri_screen == NULL) {
+ _eglLog(_EGL_WARNING, "DRI2: failed to create dri screen");
+ return EGL_FALSE;
+ }
+
+ dri2_dpy->own_dri_screen = 1;
+
+ extensions = dri2_dpy->core->getExtensions(dri2_dpy->dri_screen);
+
+ if (dri2_dpy->dri2) {
+ if (!dri2_bind_extensions(dri2_dpy, dri2_core_extensions, extensions))
+ goto cleanup_dri_screen;
+ } else {
+ assert(dri2_dpy->swrast);
+ if (!dri2_bind_extensions(dri2_dpy, swrast_core_extensions, extensions))
+ goto cleanup_dri_screen;
+ }
+
+ dri2_setup_screen(disp);
return EGL_TRUE;
return EGL_FALSE;
switch (disp->Platform) {
+#ifdef HAVE_X11_PLATFORM
case _EGL_PLATFORM_X11:
if (disp->Options.TestOnly)
return EGL_TRUE;
return dri2_initialize_x11(drv, disp);
+#endif
#ifdef HAVE_LIBUDEV
+#ifdef HAVE_DRM_PLATFORM
case _EGL_PLATFORM_DRM:
if (disp->Options.TestOnly)
return EGL_TRUE;
return dri2_initialize_drm(drv, disp);
+#endif
#ifdef HAVE_WAYLAND_PLATFORM
case _EGL_PLATFORM_WAYLAND:
if (disp->Options.TestOnly)
_eglReleaseDisplayResources(drv, disp);
_eglCleanupDisplay(disp);
- dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
+ if (dri2_dpy->own_dri_screen)
+ dri2_dpy->core->destroyScreen(dri2_dpy->dri_screen);
if (dri2_dpy->fd)
close(dri2_dpy->fd);
- dlclose(dri2_dpy->driver);
- if (disp->PlatformDisplay == NULL)
- xcb_disconnect(dri2_dpy->conn);
+ if (dri2_dpy->driver)
+ dlclose(dri2_dpy->driver);
+
+ if (disp->PlatformDisplay == NULL) {
+ switch (disp->Platform) {
+#ifdef HAVE_X11_PLATFORM
+ case _EGL_PLATFORM_X11:
+ xcb_disconnect(dri2_dpy->conn);
+ break;
+#endif
+#ifdef HAVE_WAYLAND_PLATFORM
+ case _EGL_PLATFORM_WAYLAND:
+ wl_display_destroy(dri2_dpy->wl_dpy);
+ break;
+#endif
+#ifdef HAVE_DRM_PLATFORM
+ case _EGL_PLATFORM_DRM:
+ if (dri2_dpy->own_gbm_device) {
+ gbm_device_destroy(&dri2_dpy->gbm_dri->base.base);
+ }
+ break;
+#endif
+ default:
+ break;
+ }
+ }
+
free(dri2_dpy);
disp->DriverData = NULL;
return NULL;
}
+/**
+ * Called via eglDestroyContext(), drv->API.DestroyContext().
+ */
+static EGLBoolean
+dri2_destroy_context(_EGLDriver *drv, _EGLDisplay *disp, _EGLContext *ctx)
+{
+ struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
+ struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
+
+ if (_eglPutContext(ctx)) {
+ dri2_dpy->core->destroyContext(dri2_ctx->dri_context);
+ free(dri2_ctx);
+ }
+
+ return EGL_TRUE;
+}
+
/**
* Called via eglMakeCurrent(), drv->API.MakeCurrent().
*/
drv->API.DestroySurface(drv, disp, old_dsurf);
if (old_rsurf)
drv->API.DestroySurface(drv, disp, old_rsurf);
- /* no destroy? */
if (old_ctx)
- _eglPutContext(old_ctx);
+ drv->API.DestroyContext(drv, disp, old_ctx);
return EGL_TRUE;
} else {
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
struct dri2_egl_context *dri2_ctx = dri2_egl_context(ctx);
struct dri2_egl_image *dri2_img;
- GLuint renderbuffer = (GLuint) buffer;
+ GLuint renderbuffer = (GLuint) (uintptr_t) buffer;
if (renderbuffer == 0) {
_eglError(EGL_BAD_PARAMETER, "dri2_create_image_khr");
return EGL_NO_IMAGE_KHR;
}
- if (!_eglInitImage(&dri2_img->base, disp))
+ if (!_eglInitImage(&dri2_img->base, disp)) {
+ free(dri2_img);
return EGL_NO_IMAGE_KHR;
+ }
dri2_img->dri_image =
dri2_dpy->image->createImageFromRenderbuffer(dri2_ctx->dri_context,
(void) ctx;
- name = (EGLint) buffer;
+ name = (EGLint) (uintptr_t) buffer;
err = _eglParseImageAttribList(&attrs, disp, attr_list);
if (err != EGL_SUCCESS)
return &dri2_img->base;
}
-static EGLBoolean
-dri2_export_drm_image_mesa(_EGLDriver *drv, _EGLDisplay *disp, _EGLImage *img,
- EGLint *name, EGLint *handle, EGLint *stride);
-
+#ifdef HAVE_WAYLAND_PLATFORM
static _EGLImage *
dri2_reference_drm_image(_EGLDisplay *disp, _EGLContext *ctx,
- _EGLImage *image, EGLint width, EGLint height)
+ __DRIimage *dri_image, EGLint width, EGLint height)
{
+ struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
EGLint attr_list[] = {
EGL_WIDTH, 0,
EGL_HEIGHT, 0,
};
EGLint name, stride;
- dri2_export_drm_image_mesa(disp->Driver, disp, image,
- &name, NULL, &stride);
+ dri2_dpy->image->queryImage(dri_image, __DRI_IMAGE_ATTRIB_NAME, &name);
+ dri2_dpy->image->queryImage(dri_image, __DRI_IMAGE_ATTRIB_STRIDE, &stride);
attr_list[1] = width;
attr_list[3] = height;
attr_list);
}
-#ifdef HAVE_WAYLAND_PLATFORM
static _EGLImage *
dri2_create_image_wayland_wl_buffer(_EGLDisplay *disp, _EGLContext *ctx,
- EGLClientBuffer buffer,
+ EGLClientBuffer _buffer,
const EGLint *attr_list)
{
- struct wl_drm_buffer *wl_drm_buffer = (struct wl_drm_buffer *) buffer;
+ struct wl_buffer *buffer = (struct wl_buffer *) _buffer;
+ (void) attr_list;
- (void) attr_list;
+ if (!wayland_buffer_is_drm(buffer))
+ return NULL;
- return dri2_reference_drm_image(disp, ctx, wl_drm_buffer->image,
- wl_drm_buffer->buffer.width,
- wl_drm_buffer->buffer.height);
+ return dri2_reference_drm_image(disp, ctx,
+ wayland_drm_buffer_get_buffer(buffer),
+ buffer->width,
+ buffer->height);
}
#endif
valid_mask =
EGL_DRM_BUFFER_USE_SCANOUT_MESA |
- EGL_DRM_BUFFER_USE_SHARE_MESA;
+ EGL_DRM_BUFFER_USE_SHARE_MESA |
+ EGL_DRM_BUFFER_USE_CURSOR_MESA;
if (attrs.DRMBufferUseMESA & ~valid_mask) {
_eglLog(_EGL_WARNING, "bad image use bit 0x%04x",
attrs.DRMBufferUseMESA & ~valid_mask);
dri_use |= __DRI_IMAGE_USE_SHARE;
if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SCANOUT_MESA)
dri_use |= __DRI_IMAGE_USE_SCANOUT;
+ if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_CURSOR_MESA)
+ dri_use |= __DRI_IMAGE_USE_CURSOR;
dri2_img->dri_image =
dri2_dpy->image->createImage(dri2_dpy->dri_screen,
}
#ifdef HAVE_WAYLAND_PLATFORM
+
+static void *
+dri2_wl_reference_buffer(void *user_data, uint32_t name,
+ int32_t width, int32_t height,
+ uint32_t stride, struct wl_visual *visual)
+{
+ _EGLDisplay *disp = user_data;
+ struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
+ __DRIimage *image;
+
+ image = dri2_dpy->image->createImageFromName(dri2_dpy->dri_screen,
+ width, height,
+ __DRI_IMAGE_FORMAT_ARGB8888,
+ name, stride / 4,
+ NULL);
+
+ return image;
+}
+
+static void
+dri2_wl_release_buffer(void *user_data, void *buffer)
+{
+ _EGLDisplay *disp = user_data;
+ __DRIimage *image = buffer;
+ struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
+
+ dri2_dpy->image->destroyImage(image);
+}
+
+static struct wayland_drm_callbacks wl_drm_callbacks = {
+ .authenticate = NULL,
+ .reference_buffer = dri2_wl_reference_buffer,
+ .release_buffer = dri2_wl_release_buffer
+};
+
static EGLBoolean
dri2_bind_wayland_display_wl(_EGLDriver *drv, _EGLDisplay *disp,
struct wl_display *wl_dpy)
if (dri2_dpy->wl_server_drm)
return EGL_FALSE;
+ wl_drm_callbacks.authenticate =
+ (int(*)(void *, uint32_t)) dri2_dpy->authenticate;
+
dri2_dpy->wl_server_drm =
- wayland_drm_init(wl_dpy, disp,
- dri2_dpy->authenticate,
- dri2_dpy->device_name);
+ wayland_drm_init(wl_dpy, dri2_dpy->device_name,
+ &wl_drm_callbacks, disp);
if (!dri2_dpy->wl_server_drm)
return EGL_FALSE;
if (!dri2_dpy->wl_server_drm)
return EGL_FALSE;
- wayland_drm_destroy(dri2_dpy->wl_server_drm);
+ wayland_drm_uninit(dri2_dpy->wl_server_drm);
dri2_dpy->wl_server_drm = NULL;
return EGL_TRUE;
memset(dri2_drv, 0, sizeof *dri2_drv);
- if (!dri2_load(&dri2_drv->base))
+ if (!dri2_load(&dri2_drv->base)) {
+ free(dri2_drv);
return NULL;
+ }
_eglInitDriverFallbacks(&dri2_drv->base);
dri2_drv->base.API.Initialize = dri2_initialize;
dri2_drv->base.API.Terminate = dri2_terminate;
dri2_drv->base.API.CreateContext = dri2_create_context;
+ dri2_drv->base.API.DestroyContext = dri2_destroy_context;
dri2_drv->base.API.MakeCurrent = dri2_make_current;
dri2_drv->base.API.GetProcAddress = dri2_get_proc_address;
dri2_drv->base.API.WaitClient = dri2_wait_client;
projects / mesa.git / blobdiff