vl/dri3: use external texture as back buffers(v4)

dri3 allows us to send handle of a texture directly to X
so this patch allows a state tracker to directly send its
texture to X to be used as back buffer and avoids extra
copying

v2: use clip width/height to display a portion of the surface
v3: remove redundant variables, fix wrapping, rename variables
    handle vaapi path
v3.1: we need clip_width/height for every frame so we don't need
      to maintain it for each buffer instead use a global variable
v4: In case of single gpu we can cache the buffers as applications
    use constant number of buffer and we can avoid calls to present
    extension for every frame

Reviewed and Suggested-by: Leo Liu <leo.liu@amd.com>
Acked-by: Christian König <christian.koenig@amd.com>
Tested-by: Andy Furniss <adf.lists@gmail.com>
Signed-off-by: Nayan Deshmukh <nayan26deshmukh@gmail.com>

diff --git a/configure.ac b/configure.ac
index 459f3e8b0a5745f922732b602f4e3e20cc12fa32..3e2d79abdf682257d690cfe6248014e85ae7a67a 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -2081,7 +2081,7 @@ if test "x$enable_xvmc" = xyes -o \
         "x$enable_va" = xyes; then
     if test x"$enable_dri3" = xyes; then
         PKG_CHECK_MODULES([VL], [xcb-dri3 xcb-present xcb-sync xshmfence >= $XSHMFENCE_REQUIRED
-                                 x11-xcb xcb xcb-dri2 >= $XCBDRI2_REQUIRED])
+                                 xcb-xfixes x11-xcb xcb xcb-dri2 >= $XCBDRI2_REQUIRED])
     else
         PKG_CHECK_MODULES([VL], [x11-xcb xcb xcb-dri2 >= $XCBDRI2_REQUIRED])
     fi

diff --git a/src/gallium/auxiliary/vl/vl_winsys.h b/src/gallium/auxiliary/vl/vl_winsys.h
index 26db9f2634602fb2441c9a7c8ca02fa36d58a3cb..e1f9b274fccc2a7c9fbd14f9ed623edd7513e6e8 100644 (file)
--- a/src/gallium/auxiliary/vl/vl_winsys.h
+++ b/src/gallium/auxiliary/vl/vl_winsys.h
@@ -59,6 +59,11 @@ struct vl_screen
    void *
    (*get_private)(struct vl_screen *vscreen);
 
+   void
+   (*set_back_texture_from_output)(struct vl_screen *vscreen,
+                                   struct pipe_resource *buffer,
+                                   uint32_t width, uint32_t height);
+
    struct pipe_screen *pscreen;
    struct pipe_loader_device *dev;
 };

diff --git a/src/gallium/auxiliary/vl/vl_winsys_dri3.c b/src/gallium/auxiliary/vl/vl_winsys_dri3.c
index 29299289feabdc044d326e0fddf66c1670b6ba08..a810dea6c026a6769cac4029e9683c2e9ad8b437 100644 (file)
--- a/src/gallium/auxiliary/vl/vl_winsys_dri3.c
+++ b/src/gallium/auxiliary/vl/vl_winsys_dri3.c
@@ -31,6 +31,7 @@
 #include <X11/xshmfence.h>
 #include <xcb/dri3.h>
 #include <xcb/present.h>
+#include <xcb/xfixes.h>
 
 #include "loader.h"
 
@@ -71,9 +72,12 @@ struct vl_dri3_screen
    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];
 
@@ -105,7 +109,8 @@ dri3_free_back_buffer(struct vl_dri3_screen *scrn,
    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);
@@ -236,29 +241,31 @@ dri3_alloc_back_buffer(struct vl_dri3_screen *scrn)
    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;
@@ -271,11 +278,14 @@ dri3_alloc_back_buffer(struct vl_dri3_screen *scrn)
                                            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,
@@ -287,8 +297,6 @@ dri3_alloc_back_buffer(struct vl_dri3_screen *scrn)
    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);
 
@@ -310,6 +318,8 @@ dri3_get_back_buffer(struct vl_dri3_screen *scrn)
 {
    struct vl_dri3_buffer *buffer;
    struct pipe_resource *texture = NULL;
+   bool allocate_new_buffer = false;
+   int b, id;
 
    assert(scrn);
 
@@ -318,8 +328,46 @@ dri3_get_back_buffer(struct vl_dri3_screen *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);
@@ -329,7 +377,8 @@ dri3_get_back_buffer(struct vl_dri3_screen *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;
    }
@@ -500,6 +549,8 @@ vl_dri3_flush_frontbuffer(struct pipe_screen *screen,
    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)
@@ -511,8 +562,16 @@ vl_dri3_flush_frontbuffer(struct pipe_screen *screen,
             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,
@@ -528,7 +587,7 @@ vl_dri3_flush_frontbuffer(struct pipe_screen *screen,
                       scrn->drawable,
                       back->pixmap,
                       (uint32_t)(++scrn->send_sbc),
-                      0, 0, 0, 0,
+                      0, region, 0, 0,
                       None, None,
                       back->sync_fence,
                       options,
@@ -626,6 +685,20 @@ vl_dri3_screen_get_private(struct vl_screen *vscreen)
    return vscreen;
 }
 
+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)
 {
@@ -675,6 +748,9 @@ vl_dri3_screen_create(Display *display, int screen)
    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);
@@ -689,12 +765,26 @@ vl_dri3_screen_create(Display *display, int 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);
@@ -744,7 +834,9 @@ vl_dri3_screen_create(Display *display, int screen)
    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: