#include <X11/xshmfence.h>
#include <xcb/dri3.h>
#include <xcb/present.h>
+#include <xcb/xfixes.h>
#include "loader.h"
xcb_special_event_t *special_event;
struct pipe_context *pipe;
+ struct pipe_resource *output_texture;
+ uint32_t clip_width, clip_height;
struct vl_dri3_buffer *back_buffers[BACK_BUFFER_NUM];
int cur_back;
+ int next_back;
struct u_rect dirty_areas[BACK_BUFFER_NUM];
xcb_free_pixmap(scrn->conn, buffer->pixmap);
xcb_sync_destroy_fence(scrn->conn, buffer->sync_fence);
xshmfence_unmap_shm(buffer->shm_fence);
- pipe_resource_reference(&buffer->texture, NULL);
+ if (!scrn->output_texture)
+ pipe_resource_reference(&buffer->texture, NULL);
if (buffer->linear_texture)
pipe_resource_reference(&buffer->linear_texture, NULL);
FREE(buffer);
templ.format = PIPE_FORMAT_B8G8R8X8_UNORM;
templ.target = PIPE_TEXTURE_2D;
templ.last_level = 0;
- templ.width0 = scrn->width;
- templ.height0 = scrn->height;
+ templ.width0 = (scrn->output_texture) ?
+ scrn->output_texture->width0 : scrn->width;
+ templ.height0 = (scrn->output_texture) ?
+ scrn->output_texture->height0 : scrn->height;
templ.depth0 = 1;
templ.array_size = 1;
if (scrn->is_different_gpu) {
- buffer->texture = scrn->base.pscreen->resource_create(scrn->base.pscreen,
- &templ);
+ buffer->texture = (scrn->output_texture) ? scrn->output_texture :
+ scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
if (!buffer->texture)
goto unmap_shm;
templ.bind |= PIPE_BIND_SCANOUT | PIPE_BIND_SHARED |
PIPE_BIND_LINEAR;
- buffer->linear_texture = scrn->base.pscreen->resource_create(scrn->base.pscreen,
- &templ);
+ buffer->linear_texture =
+ scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
pixmap_buffer_texture = buffer->linear_texture;
if (!buffer->linear_texture)
goto no_linear_texture;
} else {
templ.bind |= PIPE_BIND_SCANOUT | PIPE_BIND_SHARED;
- buffer->texture = scrn->base.pscreen->resource_create(scrn->base.pscreen,
- &templ);
+ buffer->texture = (scrn->output_texture) ? scrn->output_texture :
+ scrn->base.pscreen->resource_create(scrn->base.pscreen, &templ);
if (!buffer->texture)
goto unmap_shm;
pixmap_buffer_texture = buffer->texture;
usage);
buffer_fd = whandle.handle;
buffer->pitch = whandle.stride;
+ buffer->width = templ.width0;
+ buffer->height = templ.height0;
+
xcb_dri3_pixmap_from_buffer(scrn->conn,
(pixmap = xcb_generate_id(scrn->conn)),
scrn->drawable,
0,
- scrn->width, scrn->height, buffer->pitch,
+ buffer->width, buffer->height, buffer->pitch,
scrn->depth, 32,
buffer_fd);
xcb_dri3_fence_from_fd(scrn->conn,
buffer->pixmap = pixmap;
buffer->sync_fence = sync_fence;
buffer->shm_fence = shm_fence;
- buffer->width = scrn->width;
- buffer->height = scrn->height;
xshmfence_trigger(buffer->shm_fence);
{
struct vl_dri3_buffer *buffer;
struct pipe_resource *texture = NULL;
+ bool allocate_new_buffer = false;
+ int b, id;
assert(scrn);
return NULL;
buffer = scrn->back_buffers[scrn->cur_back];
- if (!buffer || buffer->width != scrn->width ||
- buffer->height != scrn->height) {
+ if (scrn->output_texture) {
+ if (!buffer || buffer->width < scrn->width ||
+ buffer->height < scrn->height)
+ allocate_new_buffer = true;
+ else if (scrn->is_different_gpu)
+ /* In case of different gpu we can reuse the linear
+ * texture so we only need to set the external
+ * texture for copying
+ */
+ buffer->texture = scrn->output_texture;
+ else {
+ /* In case of a single gpu we search if the texture is
+ * already present as buffer if not we get the
+ * handle and pixmap for the texture that is set
+ */
+ for (b = 0; b < BACK_BUFFER_NUM; b++) {
+ id = (b + scrn->cur_back) % BACK_BUFFER_NUM;
+ buffer = scrn->back_buffers[id];
+ if (buffer && !buffer->busy &&
+ buffer->texture == scrn->output_texture) {
+ scrn->cur_back = id;
+ break;
+ }
+ }
+
+ if (b == BACK_BUFFER_NUM) {
+ allocate_new_buffer = true;
+ scrn->cur_back = scrn->next_back;
+ scrn->next_back = (scrn->next_back + 1) % BACK_BUFFER_NUM;
+ buffer = scrn->back_buffers[scrn->cur_back];
+ }
+ }
+
+ } else {
+ if (!buffer || buffer->width != scrn->width ||
+ buffer->height != scrn->height)
+ allocate_new_buffer = true;
+ }
+
+ if (allocate_new_buffer) {
struct vl_dri3_buffer *new_buffer;
new_buffer = dri3_alloc_back_buffer(scrn);
if (buffer)
dri3_free_back_buffer(scrn, buffer);
- vl_compositor_reset_dirty_area(&scrn->dirty_areas[scrn->cur_back]);
+ if (!scrn->output_texture)
+ vl_compositor_reset_dirty_area(&scrn->dirty_areas[scrn->cur_back]);
buffer = new_buffer;
scrn->back_buffers[scrn->cur_back] = buffer;
}
uint32_t options = XCB_PRESENT_OPTION_NONE;
struct vl_dri3_buffer *back;
struct pipe_box src_box;
+ xcb_xfixes_region_t region;
+ xcb_rectangle_t rectangle;
back = scrn->back_buffers[scrn->cur_back];
if (!back)
return;
}
+ rectangle.x = 0;
+ rectangle.y = 0;
+ rectangle.width = (scrn->output_texture) ? scrn->clip_width : scrn->width;
+ rectangle.height = (scrn->output_texture) ? scrn->clip_height : scrn->height;
+
+ region = xcb_generate_id(scrn->conn);
+ xcb_xfixes_create_region(scrn->conn, region, 2, &rectangle);
+
if (scrn->is_different_gpu) {
- u_box_origin_2d(scrn->width, scrn->height, &src_box);
+ u_box_origin_2d(back->width, back->height, &src_box);
scrn->pipe->resource_copy_region(scrn->pipe,
back->linear_texture,
0, 0, 0, 0,
scrn->drawable,
back->pixmap,
(uint32_t)(++scrn->send_sbc),
- 0, 0, 0, 0,
+ 0, region, 0, 0,
None, None,
back->sync_fence,
options,
}
static void
+vl_dri3_screen_set_back_texture_from_output(struct vl_screen *vscreen,
+ struct pipe_resource *buffer,
+ uint32_t width, uint32_t height)
+{
+ struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
+
+ assert(scrn);
+
+ scrn->output_texture = buffer;
+ scrn->clip_width = (width) ? width : scrn->width;
+ scrn->clip_height = (height) ? height : scrn->height;
+}
+
+static void
vl_dri3_screen_destroy(struct vl_screen *vscreen)
{
struct vl_dri3_screen *scrn = (struct vl_dri3_screen *)vscreen;
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);
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);
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: