src/gallium/state_trackers/vdpau/presentation.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 Thomas Balling Sørensen.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include <stdio.h>
  29 #include <vdpau/vdpau.h>
  30
  31 #include "util/u_debug.h"
  32 #include "util/u_memory.h"
  33
  34 #include "vdpau_private.h"
  35
  36 /**
  37  * Create a VdpPresentationQueue.
  38  */
  39 VdpStatus
  40 vlVdpPresentationQueueCreate(VdpDevice device,
  41                              VdpPresentationQueueTarget presentation_queue_target,
  42                              VdpPresentationQueue *presentation_queue)
  43 {
  44    vlVdpPresentationQueue *pq = NULL;
  45    VdpStatus ret;
  46
  47    if (!presentation_queue)
  48       return VDP_STATUS_INVALID_POINTER;
  49
  50    vlVdpDevice *dev = vlGetDataHTAB(device);
  51    if (!dev)
  52       return VDP_STATUS_INVALID_HANDLE;
  53
  54    vlVdpPresentationQueueTarget *pqt = vlGetDataHTAB(presentation_queue_target);
  55    if (!pqt)
  56       return VDP_STATUS_INVALID_HANDLE;
  57
  58    if (dev != pqt->device)
  59       return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
  60
  61    pq = CALLOC(1, sizeof(vlVdpPresentationQueue));
  62    if (!pq)
  63       return VDP_STATUS_RESOURCES;
  64
  65    pq->device = dev;
  66    pq->drawable = pqt->drawable;
  67
  68    pipe_mutex_lock(dev->mutex);
  69    if (!vl_compositor_init_state(&pq->cstate, dev->context)) {
  70       pipe_mutex_unlock(dev->mutex);
  71       ret = VDP_STATUS_ERROR;
  72       goto no_compositor;
  73    }
  74    pipe_mutex_unlock(dev->mutex);
  75
  76    *presentation_queue = vlAddDataHTAB(pq);
  77    if (*presentation_queue == 0) {
  78       ret = VDP_STATUS_ERROR;
  79       goto no_handle;
  80    }
  81
  82    return VDP_STATUS_OK;
  83
  84 no_handle:
  85 no_compositor:
  86    FREE(pq);
  87    return ret;
  88 }
  89
  90 /**
  91  * Destroy a VdpPresentationQueue.
  92  */
  93 VdpStatus
  94 vlVdpPresentationQueueDestroy(VdpPresentationQueue presentation_queue)
  95 {
  96    vlVdpPresentationQueue *pq;
  97
  98    pq = vlGetDataHTAB(presentation_queue);
  99    if (!pq)
 100       return VDP_STATUS_INVALID_HANDLE;
 101
 102    pipe_mutex_lock(pq->device->mutex);
 103    vl_compositor_cleanup_state(&pq->cstate);
 104    pipe_mutex_unlock(pq->device->mutex);
 105
 106    vlRemoveDataHTAB(presentation_queue);
 107    FREE(pq);
 108
 109    return VDP_STATUS_OK;
 110 }
 111
 112 /**
 113  * Configure the background color setting.
 114  */
 115 VdpStatus
 116 vlVdpPresentationQueueSetBackgroundColor(VdpPresentationQueue presentation_queue,
 117                                          VdpColor *const background_color)
 118 {
 119    vlVdpPresentationQueue *pq;
 120    union pipe_color_union color;
 121
 122    if (!background_color)
 123       return VDP_STATUS_INVALID_POINTER;
 124
 125    pq = vlGetDataHTAB(presentation_queue);
 126    if (!pq)
 127       return VDP_STATUS_INVALID_HANDLE;
 128
 129    color.f[0] = background_color->red;
 130    color.f[1] = background_color->green;
 131    color.f[2] = background_color->blue;
 132    color.f[3] = background_color->alpha;
 133
 134    pipe_mutex_lock(pq->device->mutex);
 135    vl_compositor_set_clear_color(&pq->cstate, &color);
 136    pipe_mutex_unlock(pq->device->mutex);
 137
 138    return VDP_STATUS_OK;
 139 }
 140
 141 /**
 142  * Retrieve the current background color setting.
 143  */
 144 VdpStatus
 145 vlVdpPresentationQueueGetBackgroundColor(VdpPresentationQueue presentation_queue,
 146                                          VdpColor *const background_color)
 147 {
 148    vlVdpPresentationQueue *pq;
 149    union pipe_color_union color;
 150
 151    if (!background_color)
 152       return VDP_STATUS_INVALID_POINTER;
 153
 154    pq = vlGetDataHTAB(presentation_queue);
 155    if (!pq)
 156       return VDP_STATUS_INVALID_HANDLE;
 157
 158    pipe_mutex_lock(pq->device->mutex);
 159    vl_compositor_get_clear_color(&pq->cstate, &color);
 160    pipe_mutex_unlock(pq->device->mutex);
 161
 162    background_color->red = color.f[0];
 163    background_color->green = color.f[1];
 164    background_color->blue = color.f[2];
 165    background_color->alpha = color.f[3];
 166
 167    return VDP_STATUS_OK;
 168 }
 169
 170 /**
 171  * Retrieve the presentation queue's "current" time.
 172  */
 173 VdpStatus
 174 vlVdpPresentationQueueGetTime(VdpPresentationQueue presentation_queue,
 175                               VdpTime *current_time)
 176 {
 177    vlVdpPresentationQueue *pq;
 178
 179    if (!current_time)
 180       return VDP_STATUS_INVALID_POINTER;
 181
 182    pq = vlGetDataHTAB(presentation_queue);
 183    if (!pq)
 184       return VDP_STATUS_INVALID_HANDLE;
 185
 186    pipe_mutex_lock(pq->device->mutex);
 187    *current_time = vl_screen_get_timestamp(pq->device->vscreen, pq->drawable);
 188    pipe_mutex_unlock(pq->device->mutex);
 189
 190    return VDP_STATUS_OK;
 191 }
 192
 193 /**
 194  * Enter a surface into the presentation queue.
 195  */
 196 VdpStatus
 197 vlVdpPresentationQueueDisplay(VdpPresentationQueue presentation_queue,
 198                               VdpOutputSurface surface,
 199                               uint32_t clip_width,
 200                               uint32_t clip_height,
 201                               VdpTime  earliest_presentation_time)
 202 {
 203    static int dump_window = -1;
 204
 205    vlVdpPresentationQueue *pq;
 206    vlVdpOutputSurface *surf;
 207
 208    struct pipe_context *pipe;
 209    struct pipe_resource *tex;
 210    struct pipe_surface surf_templ, *surf_draw;
 211    struct u_rect src_rect, dst_clip, *dirty_area;
 212
 213    struct vl_compositor *compositor;
 214    struct vl_compositor_state *cstate;
 215
 216    pq = vlGetDataHTAB(presentation_queue);
 217    if (!pq)
 218       return VDP_STATUS_INVALID_HANDLE;
 219
 220    surf = vlGetDataHTAB(surface);
 221    if (!surf)
 222       return VDP_STATUS_INVALID_HANDLE;
 223
 224    pipe = pq->device->context;
 225    compositor = &pq->device->compositor;
 226    cstate = &pq->cstate;
 227
 228    pipe_mutex_lock(pq->device->mutex);
 229    tex = vl_screen_texture_from_drawable(pq->device->vscreen, pq->drawable);
 230    if (!tex) {
 231       pipe_mutex_unlock(pq->device->mutex);
 232       return VDP_STATUS_INVALID_HANDLE;
 233    }
 234
 235    dirty_area = vl_screen_get_dirty_area(pq->device->vscreen);
 236
 237    memset(&surf_templ, 0, sizeof(surf_templ));
 238    surf_templ.format = tex->format;
 239    surf_draw = pipe->create_surface(pipe, tex, &surf_templ);
 240
 241    surf->timestamp = (vlVdpTime)earliest_presentation_time;
 242
 243    dst_clip.x0 = 0;
 244    dst_clip.y0 = 0;
 245    dst_clip.x1 = clip_width ? clip_width : surf_draw->width;
 246    dst_clip.y1 = clip_height ? clip_height : surf_draw->height;
 247
 248    if (pq->device->delayed_rendering.surface == surface &&
 249        dst_clip.x1 == surf_draw->width && dst_clip.y1 == surf_draw->height) {
 250
 251       // TODO: we correctly support the clipping here, but not the pq background color in the clipped area....
 252       cstate = pq->device->delayed_rendering.cstate;
 253       vl_compositor_set_dst_clip(cstate, &dst_clip);
 254       vlVdpResolveDelayedRendering(pq->device, surf_draw, dirty_area);
 255
 256    } else {
 257       vlVdpResolveDelayedRendering(pq->device, NULL, NULL);
 258
 259       src_rect.x0 = 0;
 260       src_rect.y0 = 0;
 261       src_rect.x1 = surf_draw->width;
 262       src_rect.y1 = surf_draw->height;
 263
 264       vl_compositor_clear_layers(cstate);
 265       vl_compositor_set_rgba_layer(cstate, compositor, 0, surf->sampler_view, &src_rect, NULL, NULL);
 266       vl_compositor_set_dst_clip(cstate, &dst_clip);
 267       vl_compositor_render(cstate, compositor, surf_draw, dirty_area);
 268    }
 269
 270    vl_screen_set_next_timestamp(pq->device->vscreen, earliest_presentation_time);
 271    pipe->screen->flush_frontbuffer
 272    (
 273       pipe->screen, tex, 0, 0,
 274       vl_screen_get_private(pq->device->vscreen)
 275    );
 276
 277    pipe->screen->fence_reference(pipe->screen, &surf->fence, NULL);
 278    pipe->flush(pipe, &surf->fence, 0);
 279
 280    if (dump_window == -1) {
 281       dump_window = debug_get_num_option("VDPAU_DUMP", 0);
 282    }
 283
 284    if (dump_window) {
 285       static unsigned int framenum = 0;
 286       char cmd[256];
 287
 288       if (framenum) {
 289          sprintf(cmd, "xwd -id %d -silent -out vdpau_frame_%08d.xwd", (int)pq->drawable, framenum);
 290          if (system(cmd) != 0)
 291             VDPAU_MSG(VDPAU_ERR, "[VDPAU] Dumping surface %d failed.\n", surface);
 292       }
 293       framenum++;
 294    }
 295
 296    pipe_resource_reference(&tex, NULL);
 297    pipe_surface_reference(&surf_draw, NULL);
 298    pipe_mutex_unlock(pq->device->mutex);
 299
 300    return VDP_STATUS_OK;
 301 }
 302
 303 /**
 304  * Wait for a surface to finish being displayed.
 305  */
 306 VdpStatus
 307 vlVdpPresentationQueueBlockUntilSurfaceIdle(VdpPresentationQueue presentation_queue,
 308                                             VdpOutputSurface surface,
 309                                             VdpTime *first_presentation_time)
 310 {
 311    vlVdpPresentationQueue *pq;
 312    vlVdpOutputSurface *surf;
 313    struct pipe_screen *screen;
 314
 315    if (!first_presentation_time)
 316       return VDP_STATUS_INVALID_POINTER;
 317
 318    pq = vlGetDataHTAB(presentation_queue);
 319    if (!pq)
 320       return VDP_STATUS_INVALID_HANDLE;
 321
 322    surf = vlGetDataHTAB(surface);
 323    if (!surf)
 324       return VDP_STATUS_INVALID_HANDLE;
 325
 326    pipe_mutex_lock(pq->device->mutex);
 327    if (surf->fence) {
 328       screen = pq->device->vscreen->pscreen;
 329       screen->fence_finish(screen, surf->fence, 0);
 330    }
 331    pipe_mutex_unlock(pq->device->mutex);
 332
 333    return vlVdpPresentationQueueGetTime(presentation_queue, first_presentation_time);
 334 }
 335
 336 /**
 337  * Poll the current queue status of a surface.
 338  */
 339 VdpStatus
 340 vlVdpPresentationQueueQuerySurfaceStatus(VdpPresentationQueue presentation_queue,
 341                                          VdpOutputSurface surface,
 342                                          VdpPresentationQueueStatus *status,
 343                                          VdpTime *first_presentation_time)
 344 {
 345    vlVdpPresentationQueue *pq;
 346    vlVdpOutputSurface *surf;
 347    struct pipe_screen *screen;
 348
 349    if (!(status && first_presentation_time))
 350       return VDP_STATUS_INVALID_POINTER;
 351
 352    pq = vlGetDataHTAB(presentation_queue);
 353    if (!pq)
 354       return VDP_STATUS_INVALID_HANDLE;
 355
 356    surf = vlGetDataHTAB(surface);
 357    if (!surf)
 358       return VDP_STATUS_INVALID_HANDLE;
 359
 360    *first_presentation_time = 0;
 361
 362    if (!surf->fence) {
 363       *status = VDP_PRESENTATION_QUEUE_STATUS_IDLE;
 364    } else {
 365       pipe_mutex_lock(pq->device->mutex);
 366       screen = pq->device->vscreen->pscreen;
 367       if (screen->fence_signalled(screen, surf->fence)) {
 368          screen->fence_reference(screen, &surf->fence, NULL);
 369          *status = VDP_PRESENTATION_QUEUE_STATUS_VISIBLE;
 370          pipe_mutex_unlock(pq->device->mutex);
 371
 372          // We actually need to query the timestamp of the last VSYNC event from the hardware
 373          vlVdpPresentationQueueGetTime(presentation_queue, first_presentation_time);
 374          *first_presentation_time += 1;
 375       } else {
 376          *status = VDP_PRESENTATION_QUEUE_STATUS_QUEUED;
 377          pipe_mutex_unlock(pq->device->mutex);
 378       }
 379    }
 380
 381    return VDP_STATUS_OK;
 382 }