static xcb_cursor_t create_empty_cursor(xcb_connection_t *conn, xcb_screen_t *screen) {
xcb_cursor_t cursor = xcb_generate_id(conn);
xcb_pixmap_t pixmap = xcb_generate_id(conn);
xcb_create_pixmap_checked(conn, 1, pixmap, screen->root, 1, 1);
xcb_create_cursor(conn, cursor, pixmap, pixmap, 0, 0, 0, 0, 0, 0, 0, 0);
return cursor;
}
/* Test each depth not explicitly advertised to see if pixmap creation
* succeeds: if it does, that depth is usable. */
static int
pixmap_depths_usable (xcb_connection_t *c, uint32_t missing, xcb_pixmap_t pixmap, xcb_drawable_t root)
{
xcb_void_cookie_t create_cookie[32] = { { 0 } };
xcb_void_cookie_t free_cookie[32] = { { 0 } };
int d;
int success = 1;
for (d = 1; d <= 32; d++)
if (missing & DEPTH_MASK(d))
{
create_cookie[d - 1] = xcb_create_pixmap_checked (c, d, pixmap, root, 1, 1);
free_cookie[d - 1] = xcb_free_pixmap_checked (c, pixmap);
if (!create_cookie[d - 1].sequence || !free_cookie[d - 1].sequence)
{
success = 0;
break;
}
}
for (d = 0; d < 32; d++)
if (create_cookie[d].sequence || free_cookie[d].sequence)
{
xcb_generic_error_t *create_error = xcb_request_check (c, create_cookie[d]);
xcb_generic_error_t *free_error = xcb_request_check (c, free_cookie[d]);
success = success && !create_error;
free(create_error);
free(free_error);
}
return success;
}
static cairo_surface_t *
create_source_surface (int size)
{
#if CAIRO_HAS_XCB_SURFACE
xcb_render_pictforminfo_t *render_format;
struct closure *data;
cairo_surface_t *surface;
xcb_screen_t *root;
xcb_void_cookie_t cookie;
void *formats;
data = xmalloc (sizeof (struct closure));
data->connection = xcb_connect (NULL, NULL);
render_format = find_depth (data->connection, 32, &formats);
if (render_format == NULL) {
xcb_disconnect (data->connection);
free (data);
return NULL;
}
root = xcb_setup_roots_iterator (xcb_get_setup (data->connection)).data;
data->pixmap = xcb_generate_id (data->connection);
cookie = xcb_create_pixmap_checked (data->connection, 32,
data->pixmap, root->root, size, size);
/* slow, but sure */
if (xcb_request_check (data->connection, cookie) != NULL) {
free (formats);
xcb_disconnect (data->connection);
free (data);
return NULL;
}
surface = cairo_xcb_surface_create_with_xrender_format (data->connection,
root,
data->pixmap,
render_format,
size, size);
free (formats);
data->device = cairo_device_reference (cairo_surface_get_device (surface));
cairo_surface_set_user_data (surface, &closure_key, data, cleanup);
return surface;
#else
return NULL;
#endif
}
static cairo_surface_t *
_cairo_boilerplate_xcb_create_surface (const char *name,
cairo_content_t content,
double width,
double height,
double max_width,
double max_height,
cairo_boilerplate_mode_t mode,
int id,
void **closure)
{
xcb_screen_t *root;
xcb_target_closure_t *xtc;
xcb_connection_t *c;
xcb_render_pictforminfo_t *render_format;
xcb_pict_standard_t format;
xcb_void_cookie_t cookie;
cairo_surface_t *surface;
cairo_status_t status;
*closure = xtc = xmalloc (sizeof (xcb_target_closure_t));
if (width == 0)
width = 1;
if (height == 0)
height = 1;
xtc->c = c = xcb_connect(NULL,NULL);
if (xcb_connection_has_error(c)) {
fprintf (stderr, "Failed to connect to X server through XCB\n");
return NULL;
}
root = xcb_setup_roots_iterator(xcb_get_setup(c)).data;
xtc->pixmap = xcb_generate_id (c);
switch (content) {
case CAIRO_CONTENT_COLOR:
cookie = xcb_create_pixmap_checked (c, 24,
xtc->pixmap, root->root,
width, height);
format = XCB_PICT_STANDARD_RGB_24;
break;
case CAIRO_CONTENT_COLOR_ALPHA:
cookie = xcb_create_pixmap_checked (c, 32,
xtc->pixmap, root->root,
width, height);
format = XCB_PICT_STANDARD_ARGB_32;
break;
case CAIRO_CONTENT_ALPHA: /* would be XCB_PICT_STANDARD_A_8 */
default:
fprintf (stderr, "Invalid content for XCB test: %d\n", content);
return NULL;
}
/* slow, but sure */
if (xcb_request_check (c, cookie) != NULL) {
xcb_disconnect (c);
free (xtc);
return NULL;
}
render_format = xcb_render_util_find_standard_format (xcb_render_util_query_formats (c), format);
if (render_format->id == 0)
return NULL;
surface = cairo_xcb_surface_create_with_xrender_format (c, xtc->pixmap, root,
render_format,
width, height);
status = cairo_surface_set_user_data (surface, &xcb_closure_key, xtc, NULL);
if (status == CAIRO_STATUS_SUCCESS)
return surface;
cairo_surface_destroy (surface);
surface = cairo_boilerplate_surface_create_in_error (status);
_cairo_boilerplate_xcb_cleanup (xtc);
return surface;
}
static cairo_surface_t *
_cairo_boilerplate_xcb_create_render_0_0 (const char *name,
cairo_content_t content,
double width,
double height,
double max_width,
double max_height,
cairo_boilerplate_mode_t mode,
int id,
void **closure)
{
xcb_screen_t *root;
xcb_target_closure_t *xtc;
xcb_connection_t *c;
xcb_render_pictforminfo_t *render_format;
int depth;
xcb_void_cookie_t cookie;
cairo_surface_t *surface, *tmp;
cairo_status_t status;
void *formats;
*closure = xtc = xmalloc (sizeof (xcb_target_closure_t));
if (width == 0)
width = 1;
if (height == 0)
height = 1;
xtc->c = c = xcb_connect(NULL,NULL);
if (xcb_connection_has_error(c)) {
free (xtc);
return NULL;
}
root = xcb_setup_roots_iterator(xcb_get_setup(c)).data;
xtc->surface = NULL;
xtc->is_pixmap = TRUE;
xtc->drawable = xcb_generate_id (c);
switch (content) {
case CAIRO_CONTENT_COLOR:
depth = 24;
cookie = xcb_create_pixmap_checked (c, depth,
xtc->drawable, root->root,
width, height);
break;
case CAIRO_CONTENT_COLOR_ALPHA:
depth = 32;
cookie = xcb_create_pixmap_checked (c, depth,
xtc->drawable, root->root,
width, height);
break;
case CAIRO_CONTENT_ALPHA: /* would be XCB_PICT_STANDARD_A_8 */
default:
xcb_disconnect (c);
free (xtc);
return NULL;
}
/* slow, but sure */
if (xcb_request_check (c, cookie) != NULL) {
xcb_disconnect (c);
free (xtc);
return NULL;
}
render_format = find_depth (c, depth, &formats);
if (render_format == NULL) {
xcb_disconnect (c);
free (xtc);
return NULL;
}
tmp = cairo_xcb_surface_create_with_xrender_format (c, root,
xtc->drawable,
render_format,
width, height);
if (cairo_surface_status (tmp)) {
free (formats);
xcb_disconnect (c);
free (xtc);
return tmp;
}
xtc->device = cairo_device_reference (cairo_surface_get_device (tmp));
cairo_xcb_device_debug_cap_xrender_version (xtc->device, 0, 0);
/* recreate with impaired connection */
surface = cairo_xcb_surface_create_with_xrender_format (c, root,
xtc->drawable,
render_format,
width, height);
free (formats);
cairo_surface_destroy (tmp);
assert (cairo_surface_get_device (surface) == xtc->device);
status = cairo_surface_set_user_data (surface, &xcb_closure_key, xtc, NULL);
if (status == CAIRO_STATUS_SUCCESS)
return surface;
cairo_surface_destroy (surface);
_cairo_boilerplate_xcb_cleanup (xtc);
return cairo_boilerplate_surface_create_in_error (status);
}
xcbosd *xcbosd_create(xine_t *xine, xcb_connection_t *connection, xcb_screen_t *screen, xcb_window_t window, enum xcbosd_mode mode)
{
xcbosd *osd;
xcb_get_geometry_cookie_t get_geometry_cookie;
xcb_get_geometry_reply_t *get_geometry_reply;
xcb_void_cookie_t generic_cookie;
xcb_generic_error_t *generic_error;
osd = calloc(1, sizeof(xcbosd));
if (!osd)
return NULL;
osd->mode = mode;
osd->xine = xine;
osd->connection = connection;
osd->screen = screen;
osd->window = window;
osd->visual = osd->screen->root_visual;
get_geometry_cookie = xcb_get_geometry(osd->connection, osd->window);
get_geometry_reply = xcb_get_geometry_reply(osd->connection, get_geometry_cookie, NULL);
osd->depth = get_geometry_reply->depth;
osd->width = get_geometry_reply->width;
osd->height = get_geometry_reply->height;
free(get_geometry_reply);
assert(osd->width);
assert(osd->height);
switch (mode) {
case XCBOSD_SHAPED: {
const xcb_query_extension_reply_t *query_extension_reply = xcb_get_extension_data(osd->connection, &xcb_shape_id);
if (!query_extension_reply || !query_extension_reply->present) {
xprintf(osd->xine, XINE_VERBOSITY_LOG, _("x11osd: XShape extension not available. unscaled overlay disabled.\n"));
goto error2;
}
unsigned int window_params[] = { osd->screen->black_pixel, 1, XCB_EVENT_MASK_EXPOSURE };
osd->u.shaped.window = xcb_generate_id(osd->connection);
generic_cookie = xcb_create_window_checked(osd->connection, XCB_COPY_FROM_PARENT, osd->u.shaped.window,
osd->window, 0, 0, osd->width, osd->height, 0, XCB_COPY_FROM_PARENT,
XCB_COPY_FROM_PARENT, XCB_CW_BACK_PIXEL | XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK,
window_params);
generic_error = xcb_request_check(osd->connection, generic_cookie);
if (generic_error != NULL) {
xprintf(osd->xine, XINE_VERBOSITY_LOG, _("x11osd: error creating window. unscaled overlay disabled.\n"));
free(generic_error);
goto error_window;
}
osd->u.shaped.mask_bitmap = xcb_generate_id(osd->connection);
generic_cookie = xcb_create_pixmap_checked(osd->connection, 1, osd->u.shaped.mask_bitmap, osd->u.shaped.window, osd->width, osd->height);
generic_error = xcb_request_check(osd->connection, generic_cookie);
if (generic_error != NULL) {
xprintf(osd->xine, XINE_VERBOSITY_LOG, _("x11osd: error creating pixmap. unscaled overlay disabled.\n"));
free(generic_error);
goto error_aftermaskbitmap;
}
osd->bitmap = xcb_generate_id(osd->connection);
xcb_create_pixmap(osd->connection, osd->depth, osd->bitmap, osd->u.shaped.window, osd->width, osd->height);
osd->gc = xcb_generate_id(osd->connection);
xcb_create_gc(osd->connection, osd->gc, osd->u.shaped.window, 0, NULL);
osd->u.shaped.mask_gc = xcb_generate_id(osd->connection);
xcb_create_gc(osd->connection, osd->u.shaped.mask_gc, osd->u.shaped.mask_bitmap, XCB_GC_FOREGROUND, &osd->screen->white_pixel);
osd->u.shaped.mask_gc_back = xcb_generate_id(osd->connection);
xcb_create_gc(osd->connection, osd->u.shaped.mask_gc_back, osd->u.shaped.mask_bitmap, XCB_GC_FOREGROUND, &osd->screen->black_pixel);
osd->u.shaped.mapped = 0;
osd->cmap = xcb_generate_id(osd->connection);
xcb_create_colormap(osd->connection, XCB_COLORMAP_ALLOC_NONE, osd->cmap, osd->u.shaped.window, osd->visual);
break;
}
case XCBOSD_COLORKEY:
osd->bitmap = xcb_generate_id(osd->connection);
xcb_create_pixmap(osd->connection, osd->depth, osd->bitmap, osd->window, osd->width, osd->height);
osd->gc = xcb_generate_id(osd->connection);
xcb_create_gc(osd->connection, osd->gc, osd->window, 0, NULL);
osd->cmap = xcb_generate_id(osd->connection);
xcb_create_colormap(osd->connection, XCB_COLORMAP_ALLOC_NONE, osd->cmap, osd->window, osd->visual);
/* FIXME: the expose event doesn't seem to happen? */
/*XSelectInput (osd->display, osd->window, ExposureMask);*/
break;
default:
goto error2;
}
osd->clean = UNDEFINED;
xcbosd_expose(osd);
xprintf(osd->xine, XINE_VERBOSITY_DEBUG,
_("x11osd: unscaled overlay created (%s mode).\n"),
(mode==XCBOSD_SHAPED) ? "XShape" : "Colorkey" );
return osd;
/*
XFreeGC (osd->display, osd->gc);
XFreeGC (osd->display, osd->mask_gc);
XFreeGC (osd->display, osd->mask_gc_back);
*/
error_aftermaskbitmap:
if(mode==XCBOSD_SHAPED)
xcb_free_pixmap(osd->connection, osd->u.shaped.mask_bitmap);
error_window:
if(mode==XCBOSD_SHAPED)
xcb_destroy_window(osd->connection, osd->u.shaped.window);
error2:
free (osd);
return NULL;
}
static cairo_surface_t *
_cairo_boilerplate_xcb_create_surface (const char *name,
cairo_content_t content,
double width,
double height,
double max_width,
double max_height,
cairo_boilerplate_mode_t mode,
void **closure)
{
xcb_screen_t *root;
xcb_target_closure_t *xtc;
xcb_connection_t *c;
xcb_render_query_pict_formats_cookie_t formats_cookie;
xcb_render_pictforminfo_t *render_format;
xcb_render_pictforminfo_iterator_t i;
struct xcb_info *info;
int depth;
xcb_void_cookie_t cookie;
cairo_surface_t *surface;
cairo_status_t status;
*closure = xtc = xmalloc (sizeof (xcb_target_closure_t));
info = xcalloc (1, sizeof (struct xcb_info));
if (width == 0)
width = 1;
if (height == 0)
height = 1;
xtc->c = c = xcb_connect(NULL,NULL);
if (c == NULL || xcb_connection_has_error(c)) {
free (xtc);
return NULL;
}
root = xcb_setup_roots_iterator(xcb_get_setup(c)).data;
formats_cookie = xcb_render_query_pict_formats (c);
xtc->surface = NULL;
xtc->is_pixmap = TRUE;
xtc->drawable = xcb_generate_id (c);
switch (content) {
case CAIRO_CONTENT_COLOR:
depth = 24;
break;
case CAIRO_CONTENT_COLOR_ALPHA:
depth = 32;
break;
case CAIRO_CONTENT_ALPHA: /* would be XCB_PICT_STANDARD_A_8 */
default:
xcb_disconnect (c);
free (xtc);
return NULL;
}
cookie = xcb_create_pixmap_checked (c, depth,
xtc->drawable, root->root,
width, height);
/* slow, but sure */
if (xcb_request_check (c, cookie) != NULL) {
xcb_disconnect (c);
free (xtc);
return NULL;
}
info->formats = xcb_render_query_pict_formats_reply (c, formats_cookie, 0);
if (info->formats == NULL)
return NULL;
for (i = xcb_render_query_pict_formats_formats_iterator (info->formats);
i.rem;
xcb_render_pictforminfo_next (&i))
{
if (XCB_RENDER_PICT_TYPE_DIRECT != i.data->type)
continue;
if (i.data->depth == 32) {
if (info->render_format[0] == 0)
info->render_format[0] = i.data;
} else if (i.data->depth == 24) {
if (info->render_format[1] == 0)
info->render_format[1] = i.data;
} else if (i.data->depth == 8) {
if (info->render_format[2] == 0)
info->render_format[2] = i.data;
}
}
assert (info->render_format[0]);
assert (info->render_format[1]);
assert (info->render_format[2]);
switch (content) {
default:
case CAIRO_CONTENT_COLOR_ALPHA:
render_format = info->render_format[0];
break;
case CAIRO_CONTENT_COLOR:
render_format = info->render_format[1];
break;
case CAIRO_CONTENT_ALPHA: /* would be XCB_PICT_STANDARD_A_8 */
render_format = info->render_format[2];
break;
}
surface = cairo_xcb_surface_create_with_xrender_format (c, root,
xtc->drawable,
render_format,
width, height);
cairo_device_set_user_data (cairo_surface_get_device (surface), &key, info, free);
if (mode != CAIRO_BOILERPLATE_MODE_PERF)
_cairo_boilerplate_xcb_setup_test_surface(surface);
xtc->device = cairo_device_reference (cairo_surface_get_device (surface));
status = cairo_surface_set_user_data (surface, &xcb_closure_key, xtc, NULL);
if (status == CAIRO_STATUS_SUCCESS)
return surface;
cairo_surface_destroy (surface);
_cairo_boilerplate_xcb_cleanup (xtc);
return cairo_boilerplate_surface_create_in_error (status);
}
