static void vl_dri3_screen_destroy(struct vl_screen *vscreen) { struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen; int i; assert(vscreen); dri3_flush_present_events(scrn); if (scrn->front_buffer) { dri3_free_front_buffer(scrn, scrn->front_buffer); scrn->front_buffer = NULL; return; } for (i = 0; i < BACK_BUFFER_NUM; ++i) { if (scrn->back_buffers[i]) { dri3_free_back_buffer(scrn, scrn->back_buffers[i]); scrn->back_buffers[i] = NULL; } } if (scrn->special_event) xcb_unregister_for_special_event(scrn->conn, scrn->special_event); scrn->base.pscreen->destroy(scrn->base.pscreen); pipe_loader_release(&scrn->base.dev, 1); FREE(scrn); return; }
static bool dri3_set_drawable(struct vl_dri3_screen *scrn, Drawable drawable) { xcb_get_geometry_cookie_t geom_cookie; xcb_get_geometry_reply_t *geom_reply; xcb_void_cookie_t cookie; xcb_generic_error_t *error; xcb_present_event_t peid; bool ret = true; assert(drawable); if (scrn->drawable == drawable) return true; scrn->drawable = drawable; geom_cookie = xcb_get_geometry(scrn->conn, scrn->drawable); geom_reply = xcb_get_geometry_reply(scrn->conn, geom_cookie, NULL); if (!geom_reply) return false; scrn->width = geom_reply->width; scrn->height = geom_reply->height; scrn->depth = geom_reply->depth; free(geom_reply); if (scrn->special_event) { xcb_unregister_for_special_event(scrn->conn, scrn->special_event); scrn->special_event = NULL; } scrn->is_pixmap = false; peid = xcb_generate_id(scrn->conn); cookie = xcb_present_select_input_checked(scrn->conn, peid, scrn->drawable, XCB_PRESENT_EVENT_MASK_CONFIGURE_NOTIFY | XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY | XCB_PRESENT_EVENT_MASK_IDLE_NOTIFY); error = xcb_request_check(scrn->conn, cookie); if (error) { if (error->error_code != BadWindow) ret = false; else { scrn->is_pixmap = true; if (scrn->front_buffer) { dri3_free_front_buffer(scrn, scrn->front_buffer); scrn->front_buffer = NULL; } } free(error); } else scrn->special_event = xcb_register_for_special_xge(scrn->conn, &xcb_present_id, peid, 0); dri3_flush_present_events(scrn); return ret; }
static void vl_dri3_screen_destroy(struct vl_screen *vscreen) { struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen; int i; assert(vscreen); dri3_flush_present_events(scrn); if (scrn->front_buffer) { dri3_free_front_buffer(scrn, scrn->front_buffer); scrn->front_buffer = NULL; } for (i = 0; i < BACK_BUFFER_NUM; ++i) { if (scrn->back_buffers[i]) { dri3_free_back_buffer(scrn, scrn->back_buffers[i]); scrn->back_buffers[i] = NULL; } } if (scrn->special_event) { xcb_void_cookie_t cookie = xcb_present_select_input_checked(scrn->conn, scrn->eid, scrn->drawable, XCB_PRESENT_EVENT_MASK_NO_EVENT); xcb_discard_reply(scrn->conn, cookie.sequence); xcb_unregister_for_special_event(scrn->conn, scrn->special_event); } scrn->pipe->destroy(scrn->pipe); scrn->base.pscreen->destroy(scrn->base.pscreen); pipe_loader_release(&scrn->base.dev, 1); FREE(scrn); return; }
/** loader_dri3_update_drawable * * Called the first time we use the drawable and then * after we receive present configure notify events to * track the geometry of the drawable */ static int dri3_update_drawable(__DRIdrawable *driDrawable, struct loader_dri3_drawable *draw) { if (draw->first_init) { xcb_get_geometry_cookie_t geom_cookie; xcb_get_geometry_reply_t *geom_reply; xcb_void_cookie_t cookie; xcb_generic_error_t *error; xcb_present_query_capabilities_cookie_t present_capabilities_cookie; xcb_present_query_capabilities_reply_t *present_capabilities_reply; draw->first_init = false; /* Try to select for input on the window. * * If the drawable is a window, this will get our events * delivered. * * Otherwise, we'll get a BadWindow error back from this request which * will let us know that the drawable is a pixmap instead. */ draw->eid = xcb_generate_id(draw->conn); cookie = xcb_present_select_input_checked(draw->conn, draw->eid, draw->drawable, XCB_PRESENT_EVENT_MASK_CONFIGURE_NOTIFY | XCB_PRESENT_EVENT_MASK_COMPLETE_NOTIFY | XCB_PRESENT_EVENT_MASK_IDLE_NOTIFY); present_capabilities_cookie = xcb_present_query_capabilities(draw->conn, draw->drawable); /* Create an XCB event queue to hold present events outside of the usual * application event queue */ draw->special_event = xcb_register_for_special_xge(draw->conn, &xcb_present_id, draw->eid, draw->stamp); geom_cookie = xcb_get_geometry(draw->conn, draw->drawable); geom_reply = xcb_get_geometry_reply(draw->conn, geom_cookie, NULL); if (!geom_reply) return false; draw->width = geom_reply->width; draw->height = geom_reply->height; draw->depth = geom_reply->depth; draw->vtable->set_drawable_size(draw, draw->width, draw->height); free(geom_reply); draw->is_pixmap = false; /* Check to see if our select input call failed. If it failed with a * BadWindow error, then assume the drawable is a pixmap. Destroy the * special event queue created above and mark the drawable as a pixmap */ error = xcb_request_check(draw->conn, cookie); present_capabilities_reply = xcb_present_query_capabilities_reply(draw->conn, present_capabilities_cookie, NULL); if (present_capabilities_reply) { draw->present_capabilities = present_capabilities_reply->capabilities; free(present_capabilities_reply); } else draw->present_capabilities = 0; if (error) { if (error->error_code != BadWindow) { free(error); return false; } draw->is_pixmap = true; xcb_unregister_for_special_event(draw->conn, draw->special_event); draw->special_event = NULL; } } dri3_flush_present_events(draw); return true; }
/** loader_dri3_swap_buffers_msc * * Make the current back buffer visible using the present extension */ int64_t loader_dri3_swap_buffers_msc(struct loader_dri3_drawable *draw, int64_t target_msc, int64_t divisor, int64_t remainder, unsigned flush_flags, bool force_copy) { struct loader_dri3_buffer *back; __DRIcontext *dri_context; int64_t ret = 0; uint32_t options = XCB_PRESENT_OPTION_NONE; int swap_interval; dri_context = draw->vtable->get_dri_context(draw); swap_interval = draw->vtable->get_swap_interval(draw); draw->vtable->flush_drawable(draw, flush_flags); back = draw->buffers[LOADER_DRI3_BACK_ID(draw->cur_back)]; if (draw->is_different_gpu && back) { /* Update the linear buffer before presenting the pixmap */ draw->ext->image->blitImage(dri_context, back->linear_buffer, back->image, 0, 0, back->width, back->height, 0, 0, back->width, back->height, __BLIT_FLAG_FLUSH); /* Update the fake front */ if (draw->have_fake_front) draw->ext->image->blitImage(dri_context, draw->buffers[LOADER_DRI3_FRONT_ID]->image, back->image, 0, 0, draw->width, draw->height, 0, 0, draw->width, draw->height, __BLIT_FLAG_FLUSH); } dri3_flush_present_events(draw); if (back && !draw->is_pixmap) { dri3_fence_reset(draw->conn, back); /* Compute when we want the frame shown by taking the last known * successful MSC and adding in a swap interval for each outstanding swap * request. target_msc=divisor=remainder=0 means "Use glXSwapBuffers() * semantic" */ ++draw->send_sbc; if (target_msc == 0 && divisor == 0 && remainder == 0) target_msc = draw->msc + swap_interval * (draw->send_sbc - draw->recv_sbc); else if (divisor == 0 && remainder > 0) { /* From the GLX_OML_sync_control spec: * "If <divisor> = 0, the swap will occur when MSC becomes * greater than or equal to <target_msc>." * * Note that there's no mention of the remainder. The Present * extension throws BadValue for remainder != 0 with divisor == 0, so * just drop the passed in value. */ remainder = 0; } /* From the GLX_EXT_swap_control spec * and the EGL 1.4 spec (page 53): * * "If <interval> is set to a value of 0, buffer swaps are not * synchronized to a video frame." * * Implementation note: It is possible to enable triple buffering * behaviour by not using XCB_PRESENT_OPTION_ASYNC, but this should not be * the default. */ if (swap_interval == 0) options |= XCB_PRESENT_OPTION_ASYNC; if (force_copy) options |= XCB_PRESENT_OPTION_COPY; back->busy = 1; back->last_swap = draw->send_sbc; xcb_present_pixmap(draw->conn, draw->drawable, back->pixmap, (uint32_t) draw->send_sbc, 0, /* valid */ 0, /* update */ 0, /* x_off */ 0, /* y_off */ None, /* target_crtc */ None, back->sync_fence, options, target_msc, divisor, remainder, 0, NULL); ret = (int64_t) draw->send_sbc; /* If there's a fake front, then copy the source back buffer * to the fake front to keep it up to date. This needs * to reset the fence and make future users block until * the X server is done copying the bits */ if (draw->have_fake_front && !draw->is_different_gpu) { dri3_fence_reset(draw->conn, draw->buffers[LOADER_DRI3_FRONT_ID]); dri3_copy_area(draw->conn, back->pixmap, draw->buffers[LOADER_DRI3_FRONT_ID]->pixmap, dri3_drawable_gc(draw), 0, 0, 0, 0, draw->width, draw->height); dri3_fence_trigger(draw->conn, draw->buffers[LOADER_DRI3_FRONT_ID]); } xcb_flush(draw->conn); if (draw->stamp) ++(*draw->stamp); } (draw->ext->flush->invalidate)(draw->dri_drawable); return ret; }