/**
* We need to check for the xfixes version in order to initialize it ?
*/
xcb_xcursor_t *xcb_xcursor_init(xcb_connection_t *xcb)
{
xcb_xcursor_t *data = bzalloc(sizeof(xcb_xcursor_t));
xcb_xfixes_query_version_cookie_t xfix_c;
xfix_c = xcb_xfixes_query_version_unchecked(xcb,
XCB_XFIXES_MAJOR_VERSION, XCB_XFIXES_MINOR_VERSION);
free(xcb_xfixes_query_version_reply(xcb, xfix_c, NULL));
return data;
}
static struct xcb_connection_t *
create_xcb_connection(Display *dpy)
{
int screen_num = DefaultScreen(dpy);
xcb_connection_t *ret;
xcb_xfixes_query_version_cookie_t cookie;
xcb_xfixes_query_version_reply_t *rep;
ret = xcb_connect(DisplayString(dpy), &screen_num);
cookie = xcb_xfixes_query_version_unchecked(ret, XCB_XFIXES_MAJOR_VERSION, XCB_XFIXES_MINOR_VERSION);
rep = xcb_xfixes_query_version_reply(ret, cookie, NULL);
if (rep)
free(rep);
return ret;
}
ExcCode screen_cursor_init() {
xcb_query_extension_cookie_t extension_cookie =
xcb_query_extension(display,
strlen(XFIXES_EXTENSION_NAME), XFIXES_EXTENSION_NAME);
xcb_query_extension_reply_t *extension_reply =
xcb_query_extension_reply(display, extension_cookie, NULL);
if (extension_reply == NULL)
PANIC(ERR_X_EXTENSION, XFIXES_EXTENSION_NAME);
free(extension_reply);
xcb_xfixes_query_version_cookie_t version_cookie =
xcb_xfixes_query_version(display,
XCB_XFIXES_MAJOR_VERSION, XCB_XFIXES_MINOR_VERSION);
xcb_xfixes_query_version_reply_t *version_reply =
xcb_xfixes_query_version_reply(display, version_cookie, NULL);
if (version_reply == NULL)
PANIC(ERR_X_EXTENSION, XFIXES_EXTENSION_NAME);
free(version_reply);
return 0;
}
bool QXcbConnection::hasSupportForDri2() const
{
if (!m_dri2_support_probed) {
xcb_generic_error_t *error = 0;
xcb_prefetch_extension_data (m_connection, &xcb_xfixes_id);
xcb_prefetch_extension_data (m_connection, &xcb_dri2_id);
xcb_xfixes_query_version_cookie_t xfixes_query_cookie = xcb_xfixes_query_version(m_connection,
XCB_XFIXES_MAJOR_VERSION,
XCB_XFIXES_MINOR_VERSION);
xcb_dri2_query_version_cookie_t dri2_query_cookie = xcb_dri2_query_version (m_connection,
XCB_DRI2_MAJOR_VERSION,
XCB_DRI2_MINOR_VERSION);
xcb_xfixes_query_version_reply_t *xfixes_query = xcb_xfixes_query_version_reply (m_connection,
xfixes_query_cookie, &error);
if (!xfixes_query || error || xfixes_query->major_version < 2) {
delete error;
delete xfixes_query;
return false;
}
delete xfixes_query;
xcb_dri2_query_version_reply_t *dri2_query = xcb_dri2_query_version_reply (m_connection,
dri2_query_cookie, &error);
if (!dri2_query || error) {
delete error;
delete dri2_query;
return false;
}
QXcbConnection *that = const_cast<QXcbConnection *>(this);
that->m_dri2_major = dri2_query->major_version;
that->m_dri2_minor = dri2_query->minor_version;
that->m_has_support_for_dri2 = true;
that->m_dri2_support_probed = true;
}
return m_has_support_for_dri2;
}
void
_ecore_xcb_xfixes_finalize(void)
{
#ifdef ECORE_XCB_XFIXES
const xcb_query_extension_reply_t *ext_reply;
#endif
LOGFN(__FILE__, __LINE__, __FUNCTION__);
#ifdef ECORE_XCB_XFIXES
ext_reply = xcb_get_extension_data(_ecore_xcb_conn, &xcb_xfixes_id);
if ((ext_reply) && (ext_reply->present))
{
xcb_xfixes_query_version_cookie_t cookie;
xcb_xfixes_query_version_reply_t *reply;
cookie =
xcb_xfixes_query_version_unchecked(_ecore_xcb_conn,
XCB_XFIXES_MAJOR_VERSION,
XCB_XFIXES_MINOR_VERSION);
reply = xcb_xfixes_query_version_reply(_ecore_xcb_conn, cookie, NULL);
if (reply)
{
/* NB: XFixes Extension >= 3 needed for shape stuff.
* for now, I am removing this check so that it matches the
* xlib code closer. If the extension version ends up being
* that important, then re-enable this */
/* if (reply->major_version >= 3) */
_xfixes_avail = EINA_TRUE;
free(reply);
}
if (_xfixes_avail)
_ecore_xcb_event_xfixes = ext_reply->first_event;
}
#endif
}
static EGLBoolean
dri2_connect(struct dri2_egl_display *dri2_dpy)
{
xcb_xfixes_query_version_reply_t *xfixes_query;
xcb_xfixes_query_version_cookie_t xfixes_query_cookie;
xcb_dri2_query_version_reply_t *dri2_query;
xcb_dri2_query_version_cookie_t dri2_query_cookie;
xcb_dri2_connect_reply_t *connect;
xcb_dri2_connect_cookie_t connect_cookie;
xcb_generic_error_t *error;
xcb_screen_iterator_t s;
char *driver_name, *device_name;
const xcb_query_extension_reply_t *extension;
xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_xfixes_id);
xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_dri2_id);
extension = xcb_get_extension_data(dri2_dpy->conn, &xcb_xfixes_id);
if (!(extension && extension->present))
return EGL_FALSE;
extension = xcb_get_extension_data(dri2_dpy->conn, &xcb_dri2_id);
if (!(extension && extension->present))
return EGL_FALSE;
xfixes_query_cookie = xcb_xfixes_query_version(dri2_dpy->conn,
XCB_XFIXES_MAJOR_VERSION,
XCB_XFIXES_MINOR_VERSION);
dri2_query_cookie = xcb_dri2_query_version (dri2_dpy->conn,
XCB_DRI2_MAJOR_VERSION,
XCB_DRI2_MINOR_VERSION);
s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
connect_cookie = xcb_dri2_connect_unchecked (dri2_dpy->conn,
s.data->root,
XCB_DRI2_DRIVER_TYPE_DRI);
xfixes_query =
xcb_xfixes_query_version_reply (dri2_dpy->conn,
xfixes_query_cookie, &error);
if (xfixes_query == NULL ||
error != NULL || xfixes_query->major_version < 2) {
_eglLog(_EGL_WARNING, "DRI2: failed to query xfixes version");
free(error);
return EGL_FALSE;
}
free(xfixes_query);
dri2_query =
xcb_dri2_query_version_reply (dri2_dpy->conn, dri2_query_cookie, &error);
if (dri2_query == NULL || error != NULL) {
_eglLog(_EGL_WARNING, "DRI2: failed to query version");
free(error);
return EGL_FALSE;
}
dri2_dpy->dri2_major = dri2_query->major_version;
dri2_dpy->dri2_minor = dri2_query->minor_version;
free(dri2_query);
connect = xcb_dri2_connect_reply (dri2_dpy->conn, connect_cookie, NULL);
if (connect == NULL ||
connect->driver_name_length + connect->device_name_length == 0) {
_eglLog(_EGL_WARNING, "DRI2: failed to authenticate");
return EGL_FALSE;
}
driver_name = xcb_dri2_connect_driver_name (connect);
dri2_dpy->driver_name =
dri2_strndup(driver_name,
xcb_dri2_connect_driver_name_length (connect));
device_name = xcb_dri2_connect_device_name (connect);
dri2_dpy->device_name =
dri2_strndup(device_name,
xcb_dri2_connect_device_name_length (connect));
if (dri2_dpy->device_name == NULL || dri2_dpy->driver_name == NULL) {
free(dri2_dpy->device_name);
free(dri2_dpy->driver_name);
free(connect);
return EGL_FALSE;
}
free(connect);
return EGL_TRUE;
}
static EGLBoolean
dri2_x11_connect(struct dri2_egl_display *dri2_dpy)
{
xcb_xfixes_query_version_reply_t *xfixes_query;
xcb_xfixes_query_version_cookie_t xfixes_query_cookie;
xcb_dri2_query_version_reply_t *dri2_query;
xcb_dri2_query_version_cookie_t dri2_query_cookie;
xcb_dri2_connect_reply_t *connect;
xcb_dri2_connect_cookie_t connect_cookie;
xcb_generic_error_t *error;
xcb_screen_iterator_t s;
xcb_screen_t *screen;
char *driver_name, *loader_driver_name, *device_name;
const xcb_query_extension_reply_t *extension;
xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_xfixes_id);
xcb_prefetch_extension_data (dri2_dpy->conn, &xcb_dri2_id);
extension = xcb_get_extension_data(dri2_dpy->conn, &xcb_xfixes_id);
if (!(extension && extension->present))
return EGL_FALSE;
extension = xcb_get_extension_data(dri2_dpy->conn, &xcb_dri2_id);
if (!(extension && extension->present))
return EGL_FALSE;
xfixes_query_cookie = xcb_xfixes_query_version(dri2_dpy->conn,
XCB_XFIXES_MAJOR_VERSION,
XCB_XFIXES_MINOR_VERSION);
dri2_query_cookie = xcb_dri2_query_version (dri2_dpy->conn,
XCB_DRI2_MAJOR_VERSION,
XCB_DRI2_MINOR_VERSION);
s = xcb_setup_roots_iterator(xcb_get_setup(dri2_dpy->conn));
screen = get_xcb_screen(s, dri2_dpy->screen);
if (!screen) {
_eglLog(_EGL_WARNING, "DRI2: failed to get xcb screen");
return EGL_FALSE;
}
connect_cookie = xcb_dri2_connect_unchecked(dri2_dpy->conn, screen->root,
XCB_DRI2_DRIVER_TYPE_DRI);
xfixes_query =
xcb_xfixes_query_version_reply (dri2_dpy->conn,
xfixes_query_cookie, &error);
if (xfixes_query == NULL ||
error != NULL || xfixes_query->major_version < 2) {
_eglLog(_EGL_WARNING, "DRI2: failed to query xfixes version");
free(error);
return EGL_FALSE;
}
free(xfixes_query);
dri2_query =
xcb_dri2_query_version_reply (dri2_dpy->conn, dri2_query_cookie, &error);
if (dri2_query == NULL || error != NULL) {
_eglLog(_EGL_WARNING, "DRI2: failed to query version");
free(error);
return EGL_FALSE;
}
dri2_dpy->dri2_major = dri2_query->major_version;
dri2_dpy->dri2_minor = dri2_query->minor_version;
free(dri2_query);
connect = xcb_dri2_connect_reply (dri2_dpy->conn, connect_cookie, NULL);
if (connect == NULL ||
connect->driver_name_length + connect->device_name_length == 0) {
_eglLog(_EGL_WARNING, "DRI2: failed to authenticate");
return EGL_FALSE;
}
device_name = xcb_dri2_connect_device_name (connect);
dri2_dpy->device_name =
strndup(device_name,
xcb_dri2_connect_device_name_length(connect));
dri2_dpy->fd = loader_open_device(dri2_dpy->device_name);
if (dri2_dpy->fd == -1) {
_eglLog(_EGL_WARNING,
"DRI2: could not open %s (%s)", dri2_dpy->device_name,
strerror(errno));
free(dri2_dpy->device_name);
free(connect);
return EGL_FALSE;
}
if (!dri2_x11_local_authenticate(dri2_dpy)) {
close(dri2_dpy->fd);
free(dri2_dpy->device_name);
free(connect);
return EGL_FALSE;
}
driver_name = xcb_dri2_connect_driver_name (connect);
/* If Mesa knows about the appropriate driver for this fd, then trust it.
* Otherwise, default to the server's value.
*/
loader_driver_name = loader_get_driver_for_fd(dri2_dpy->fd, 0);
if (loader_driver_name) {
dri2_dpy->driver_name = loader_driver_name;
} else {
dri2_dpy->driver_name =
strndup(driver_name,
xcb_dri2_connect_driver_name_length(connect));
}
if (dri2_dpy->device_name == NULL || dri2_dpy->driver_name == NULL) {
close(dri2_dpy->fd);
free(dri2_dpy->device_name);
free(dri2_dpy->driver_name);
free(connect);
return EGL_FALSE;
}
free(connect);
return EGL_TRUE;
}
static gboolean
_eventd_nd_xcb_start(EventdNdBackendContext *self, const gchar *target)
{
gint r;
gchar *h;
gint d;
r = xcb_parse_display(target, &h, &d, NULL);
if ( r == 0 )
return FALSE;
free(h);
const xcb_query_extension_reply_t *extension_query;
gint screen;
self->source = g_water_xcb_source_new(NULL, target, &screen, _eventd_nd_xcb_events_callback, self, NULL);
if ( self->source == NULL )
{
g_warning("Couldn't initialize X connection for '%s'", target);
return FALSE;
}
self->xcb_connection = g_water_xcb_source_get_connection(self->source);
self->screen_number = screen;
self->screen = xcb_aux_get_screen(self->xcb_connection, screen);
self->bubbles = g_hash_table_new(NULL, NULL);
if ( self->follow_focus != EVENTD_ND_XCB_FOLLOW_FOCUS_NONE )
{
guint32 mask[] = { XCB_EVENT_MASK_PROPERTY_CHANGE };
xcb_change_window_attributes(self->xcb_connection, self->screen->root, XCB_CW_EVENT_MASK, mask);
}
xcb_intern_atom_cookie_t *ac;
ac = xcb_ewmh_init_atoms(self->xcb_connection, &self->ewmh);
xcb_ewmh_init_atoms_replies(&self->ewmh, ac, NULL);
extension_query = xcb_get_extension_data(self->xcb_connection, &xcb_randr_id);
if ( ! extension_query->present )
g_warning("No RandR extension");
else
{
self->randr = TRUE;
self->randr_event_base = extension_query->first_event;
xcb_randr_select_input(self->xcb_connection, self->screen->root,
XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE |
XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE |
XCB_RANDR_NOTIFY_MASK_CRTC_CHANGE |
XCB_RANDR_NOTIFY_MASK_OUTPUT_PROPERTY);
}
self->custom_map = _eventd_nd_xcb_get_colormap(self);
if ( self->custom_map )
{
/* We have a 32bit color map, try to support compositing */
xcb_get_selection_owner_cookie_t oc;
xcb_window_t owner;
oc = xcb_ewmh_get_wm_cm_owner(&self->ewmh, self->screen_number);
self->compositing = xcb_ewmh_get_wm_cm_owner_reply(&self->ewmh, oc, &owner, NULL) && ( owner != XCB_WINDOW_NONE );
extension_query = xcb_get_extension_data(self->xcb_connection, &xcb_xfixes_id);
if ( ! extension_query->present )
g_warning("No XFixes extension");
else
{
xcb_xfixes_query_version_cookie_t vc;
xcb_xfixes_query_version_reply_t *r;
vc = xcb_xfixes_query_version(self->xcb_connection, XCB_XFIXES_MAJOR_VERSION, XCB_XFIXES_MINOR_VERSION);
r = xcb_xfixes_query_version_reply(self->xcb_connection, vc, NULL);
if ( r == NULL )
g_warning("Cannot get XFixes version");
else
{
self->xfixes = TRUE;
self->xfixes_event_base = extension_query->first_event;
xcb_xfixes_select_selection_input_checked(self->xcb_connection, self->screen->root,
self->ewmh._NET_WM_CM_Sn[self->screen_number],
XCB_XFIXES_SELECTION_EVENT_MASK_SET_SELECTION_OWNER |
XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_WINDOW_DESTROY |
XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_CLIENT_CLOSE);
}
}
}
extension_query = xcb_get_extension_data(self->xcb_connection, &xcb_shape_id);
if ( ! extension_query->present )
g_warning("No Shape extension");
else
self->shape = TRUE;
xcb_flush(self->xcb_connection);
_eventd_nd_xcb_check_geometry(self);
return TRUE;
}
struct vl_screen *
vl_dri3_screen_create(Display *display, int screen)
{
struct vl_dri3_screen *scrn;
const xcb_query_extension_reply_t *extension;
xcb_dri3_open_cookie_t open_cookie;
xcb_dri3_open_reply_t *open_reply;
xcb_get_geometry_cookie_t geom_cookie;
xcb_get_geometry_reply_t *geom_reply;
xcb_xfixes_query_version_cookie_t xfixes_cookie;
xcb_xfixes_query_version_reply_t *xfixes_reply;
xcb_generic_error_t *error;
int fd;
assert(display);
scrn = CALLOC_STRUCT(vl_dri3_screen);
if (!scrn)
return NULL;
scrn->conn = XGetXCBConnection(display);
if (!scrn->conn)
goto free_screen;
xcb_prefetch_extension_data(scrn->conn , &xcb_dri3_id);
xcb_prefetch_extension_data(scrn->conn, &xcb_present_id);
xcb_prefetch_extension_data (scrn->conn, &xcb_xfixes_id);
extension = xcb_get_extension_data(scrn->conn, &xcb_dri3_id);
if (!(extension && extension->present))
goto free_screen;
extension = xcb_get_extension_data(scrn->conn, &xcb_present_id);
if (!(extension && extension->present))
goto free_screen;
extension = xcb_get_extension_data(scrn->conn, &xcb_xfixes_id);
if (!(extension && extension->present))
goto free_screen;
xfixes_cookie = xcb_xfixes_query_version(scrn->conn, XCB_XFIXES_MAJOR_VERSION,
XCB_XFIXES_MINOR_VERSION);
xfixes_reply = xcb_xfixes_query_version_reply(scrn->conn, xfixes_cookie, &error);
if (!xfixes_reply || error || xfixes_reply->major_version < 2) {
free(error);
free(xfixes_reply);
goto free_screen;
}
free(xfixes_reply);
open_cookie = xcb_dri3_open(scrn->conn, RootWindow(display, screen), None);
open_reply = xcb_dri3_open_reply(scrn->conn, open_cookie, NULL);
if (!open_reply)
goto free_screen;
if (open_reply->nfd != 1) {
free(open_reply);
goto free_screen;
}
fd = xcb_dri3_open_reply_fds(scrn->conn, open_reply)[0];
if (fd < 0) {
free(open_reply);
goto free_screen;
}
fcntl(fd, F_SETFD, FD_CLOEXEC);
free(open_reply);
fd = loader_get_user_preferred_fd(fd, &scrn->is_different_gpu);
geom_cookie = xcb_get_geometry(scrn->conn, RootWindow(display, screen));
geom_reply = xcb_get_geometry_reply(scrn->conn, geom_cookie, NULL);
if (!geom_reply)
goto close_fd;
scrn->base.xcb_screen = dri3_get_screen_for_root(scrn->conn, geom_reply->root);
if (!scrn->base.xcb_screen) {
free(geom_reply);
goto close_fd;
}
/* TODO support depth other than 24 or 30 */
if (geom_reply->depth != 24 && geom_reply->depth != 30) {
free(geom_reply);
goto close_fd;
}
scrn->base.color_depth = geom_reply->depth;
free(geom_reply);
if (pipe_loader_drm_probe_fd(&scrn->base.dev, fd))
scrn->base.pscreen = pipe_loader_create_screen(scrn->base.dev);
if (!scrn->base.pscreen)
goto release_pipe;
scrn->pipe = scrn->base.pscreen->context_create(scrn->base.pscreen,
NULL, 0);
if (!scrn->pipe)
goto no_context;
scrn->base.destroy = vl_dri3_screen_destroy;
scrn->base.texture_from_drawable = vl_dri3_screen_texture_from_drawable;
scrn->base.get_dirty_area = vl_dri3_screen_get_dirty_area;
scrn->base.get_timestamp = vl_dri3_screen_get_timestamp;
scrn->base.set_next_timestamp = vl_dri3_screen_set_next_timestamp;
scrn->base.get_private = vl_dri3_screen_get_private;
scrn->base.pscreen->flush_frontbuffer = vl_dri3_flush_frontbuffer;
scrn->base.set_back_texture_from_output = vl_dri3_screen_set_back_texture_from_output;
scrn->next_back = 1;
return &scrn->base;
no_context:
scrn->base.pscreen->destroy(scrn->base.pscreen);
release_pipe:
if (scrn->base.dev) {
pipe_loader_release(&scrn->base.dev, 1);
fd = -1;
}
close_fd:
if (fd != -1)
close(fd);
free_screen:
FREE(scrn);
return NULL;
}
/** Get the replies of the QueryVersion requests previously sent and
* check if their version actually matched the versions needed
*
* \see display_init_extensions
*/
void
display_init_extensions_finalise(void)
{
assert(_init_extensions_cookies.composite.sequence);
xcb_composite_query_version_reply_t *composite_version_reply =
xcb_composite_query_version_reply(globalconf.connection,
_init_extensions_cookies.composite,
NULL);
/* Need NameWindowPixmap support introduced in version >= 0.2 */
if(!composite_version_reply || composite_version_reply->minor_version < 2)
{
free(composite_version_reply);
fatal("Need Composite extension 0.2 at least");
}
free(composite_version_reply);
assert(_init_extensions_cookies.damage.sequence);
xcb_damage_query_version_reply_t *damage_version_reply =
xcb_damage_query_version_reply(globalconf.connection,
_init_extensions_cookies.damage,
NULL);
if(!damage_version_reply)
fatal("Can't initialise Damage extension");
free(damage_version_reply);
assert(_init_extensions_cookies.xfixes.sequence);
xcb_xfixes_query_version_reply_t *xfixes_version_reply =
xcb_xfixes_query_version_reply(globalconf.connection,
_init_extensions_cookies.xfixes,
NULL);
/* Need Region objects support introduced in version >= 2.0 */
if(!xfixes_version_reply || xfixes_version_reply->major_version < 2)
{
free(xfixes_version_reply);
fatal("Need XFixes extension 2.0 at least");
}
free(xfixes_version_reply);
/* Need refresh rates support introduced in version >= 1.1 */
if(globalconf.extensions.randr)
{
assert(_init_extensions_cookies.randr.sequence);
xcb_randr_query_version_reply_t *randr_version_reply =
xcb_randr_query_version_reply(globalconf.connection,
_init_extensions_cookies.randr,
NULL);
if(!randr_version_reply || randr_version_reply->major_version < 1 ||
randr_version_reply->minor_version < 1)
globalconf.extensions.randr = NULL;
free(randr_version_reply);
}
}
