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 VMWARE 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    DeviceReference(&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    DeviceReference(&pq->device, NULL);
  87    FREE(pq);
  88    return ret;
  89 }
  90
  91 /**
  92  * Destroy a VdpPresentationQueue.
  93  */
  94 VdpStatus
  95 vlVdpPresentationQueueDestroy(VdpPresentationQueue presentation_queue)
  96 {
  97    vlVdpPresentationQueue *pq;
  98
  99    pq = vlGetDataHTAB(presentation_queue);
 100    if (!pq)
 101       return VDP_STATUS_INVALID_HANDLE;
 102
 103    pipe_mutex_lock(pq->device->mutex);
 104    vl_compositor_cleanup_state(&pq->cstate);
 105    pipe_mutex_unlock(pq->device->mutex);
 106
 107    vlRemoveDataHTAB(presentation_queue);
 108    DeviceReference(&pq->device, NULL);
 109    FREE(pq);
 110
 111    return VDP_STATUS_OK;
 112 }
 113
 114 /**
 115  * Configure the background color setting.
 116  */
 117 VdpStatus
 118 vlVdpPresentationQueueSetBackgroundColor(VdpPresentationQueue presentation_queue,
 119                                          VdpColor *const background_color)
 120 {
 121    vlVdpPresentationQueue *pq;
 122    union pipe_color_union color;
 123
 124    if (!background_color)
 125       return VDP_STATUS_INVALID_POINTER;
 126
 127    pq = vlGetDataHTAB(presentation_queue);
 128    if (!pq)
 129       return VDP_STATUS_INVALID_HANDLE;
 130
 131    color.f[0] = background_color->red;
 132    color.f[1] = background_color->green;
 133    color.f[2] = background_color->blue;
 134    color.f[3] = background_color->alpha;
 135
 136    pipe_mutex_lock(pq->device->mutex);
 137    vl_compositor_set_clear_color(&pq->cstate, &color);
 138    pipe_mutex_unlock(pq->device->mutex);
 139
 140    return VDP_STATUS_OK;
 141 }
 142
 143 /**
 144  * Retrieve the current background color setting.
 145  */
 146 VdpStatus
 147 vlVdpPresentationQueueGetBackgroundColor(VdpPresentationQueue presentation_queue,
 148                                          VdpColor *const background_color)
 149 {
 150    vlVdpPresentationQueue *pq;
 151    union pipe_color_union color;
 152
 153    if (!background_color)
 154       return VDP_STATUS_INVALID_POINTER;
 155
 156    pq = vlGetDataHTAB(presentation_queue);
 157    if (!pq)
 158       return VDP_STATUS_INVALID_HANDLE;
 159
 160    pipe_mutex_lock(pq->device->mutex);
 161    vl_compositor_get_clear_color(&pq->cstate, &color);
 162    pipe_mutex_unlock(pq->device->mutex);
 163
 164    background_color->red = color.f[0];
 165    background_color->green = color.f[1];
 166    background_color->blue = color.f[2];
 167    background_color->alpha = color.f[3];
 168
 169    return VDP_STATUS_OK;
 170 }
 171
 172 /**
 173  * Retrieve the presentation queue's "current" time.
 174  */
 175 VdpStatus
 176 vlVdpPresentationQueueGetTime(VdpPresentationQueue presentation_queue,
 177                               VdpTime *current_time)
 178 {
 179    vlVdpPresentationQueue *pq;
 180
 181    if (!current_time)
 182       return VDP_STATUS_INVALID_POINTER;
 183
 184    pq = vlGetDataHTAB(presentation_queue);
 185    if (!pq)
 186       return VDP_STATUS_INVALID_HANDLE;
 187
 188    pipe_mutex_lock(pq->device->mutex);
 189    *current_time = pq->device->vscreen->get_timestamp(pq->device->vscreen,
 190                                                       (void *)pq->drawable);
 191    pipe_mutex_unlock(pq->device->mutex);
 192
 193    return VDP_STATUS_OK;
 194 }
 195
 196 /**
 197  * Enter a surface into the presentation queue.
 198  */
 199 VdpStatus
 200 vlVdpPresentationQueueDisplay(VdpPresentationQueue presentation_queue,
 201                               VdpOutputSurface surface,
 202                               uint32_t clip_width,
 203                               uint32_t clip_height,
 204                               VdpTime  earliest_presentation_time)
 205 {
 206    static int dump_window = -1;
 207
 208    vlVdpPresentationQueue *pq;
 209    vlVdpOutputSurface *surf;
 210
 211    struct pipe_context *pipe;
 212    struct pipe_resource *tex;
 213    struct pipe_surface surf_templ, *surf_draw;
 214    struct u_rect src_rect, dst_clip, *dirty_area;
 215
 216    struct vl_compositor *compositor;
 217    struct vl_compositor_state *cstate;
 218    struct vl_screen *vscreen;
 219
 220    pq = vlGetDataHTAB(presentation_queue);
 221    if (!pq)
 222       return VDP_STATUS_INVALID_HANDLE;
 223
 224    surf = vlGetDataHTAB(surface);
 225    if (!surf)
 226       return VDP_STATUS_INVALID_HANDLE;
 227
 228    pipe = pq->device->context;
 229    compositor = &pq->device->compositor;
 230    cstate = &pq->cstate;
 231    vscreen = pq->device->vscreen;
 232
 233    pipe_mutex_lock(pq->device->mutex);
 234    tex = vscreen->texture_from_drawable(vscreen, (void *)pq->drawable);
 235    if (!tex) {
 236       pipe_mutex_unlock(pq->device->mutex);
 237       return VDP_STATUS_INVALID_HANDLE;
 238    }
 239
 240    dirty_area = vscreen->get_dirty_area(vscreen);
 241
 242    memset(&surf_templ, 0, sizeof(surf_templ));
 243    surf_templ.format = tex->format;
 244    surf_draw = pipe->create_surface(pipe, tex, &surf_templ);
 245
 246    dst_clip.x0 = 0;
 247    dst_clip.y0 = 0;
 248    dst_clip.x1 = clip_width ? clip_width : surf_draw->width;
 249    dst_clip.y1 = clip_height ? clip_height : surf_draw->height;
 250
 251    if (pq->device->delayed_rendering.surface == surface &&
 252        dst_clip.x1 == surf_draw->width && dst_clip.y1 == surf_draw->height) {
 253
 254       // TODO: we correctly support the clipping here, but not the pq background color in the clipped area....
 255       cstate = pq->device->delayed_rendering.cstate;
 256       vl_compositor_set_dst_clip(cstate, &dst_clip);
 257       vlVdpResolveDelayedRendering(pq->device, surf_draw, dirty_area);
 258
 259    } else {
 260       vlVdpResolveDelayedRendering(pq->device, NULL, NULL);
 261
 262       src_rect.x0 = 0;
 263       src_rect.y0 = 0;
 264       src_rect.x1 = surf_draw->width;
 265       src_rect.y1 = surf_draw->height;
 266
 267       vl_compositor_clear_layers(cstate);
 268       vl_compositor_set_rgba_layer(cstate, compositor, 0, surf->sampler_view, &src_rect, NULL, NULL);
 269       vl_compositor_set_dst_clip(cstate, &dst_clip);
 270       vl_compositor_render(cstate, compositor, surf_draw, dirty_area, true);
 271    }
 272
 273    vscreen->set_next_timestamp(vscreen, earliest_presentation_time);
 274    pipe->screen->flush_frontbuffer(pipe->screen, tex, 0, 0,
 275                                    vscreen->get_private(vscreen), NULL);
 276
 277    pipe->screen->fence_reference(pipe->screen, &surf->fence, NULL);
 278    pipe->flush(pipe, &surf->fence, 0);
 279    pq->last_surf = surf;
 280
 281    if (dump_window == -1) {
 282       dump_window = debug_get_num_option("VDPAU_DUMP", 0);
 283    }
 284
 285    if (dump_window) {
 286       static unsigned int framenum = 0;
 287       char cmd[256];
 288
 289       if (framenum) {
 290          sprintf(cmd, "xwd -id %d -silent -out vdpau_frame_%08d.xwd", (int)pq->drawable, framenum);
 291          if (system(cmd) != 0)
 292             VDPAU_MSG(VDPAU_ERR, "[VDPAU] Dumping surface %d failed.\n", surface);
 293       }
 294       framenum++;
 295    }
 296
 297    pipe_resource_reference(&tex, NULL);
 298    pipe_surface_reference(&surf_draw, NULL);
 299    pipe_mutex_unlock(pq->device->mutex);
 300
 301    return VDP_STATUS_OK;
 302 }
 303
 304 /**
 305  * Wait for a surface to finish being displayed.
 306  */
 307 VdpStatus
 308 vlVdpPresentationQueueBlockUntilSurfaceIdle(VdpPresentationQueue presentation_queue,
 309                                             VdpOutputSurface surface,
 310                                             VdpTime *first_presentation_time)
 311 {
 312    vlVdpPresentationQueue *pq;
 313    vlVdpOutputSurface *surf;
 314    struct pipe_screen *screen;
 315
 316    if (!first_presentation_time)
 317       return VDP_STATUS_INVALID_POINTER;
 318
 319    pq = vlGetDataHTAB(presentation_queue);
 320    if (!pq)
 321       return VDP_STATUS_INVALID_HANDLE;
 322
 323    surf = vlGetDataHTAB(surface);
 324    if (!surf)
 325       return VDP_STATUS_INVALID_HANDLE;
 326
 327    pipe_mutex_lock(pq->device->mutex);
 328    if (surf->fence) {
 329       screen = pq->device->vscreen->pscreen;
 330       screen->fence_finish(screen, surf->fence, PIPE_TIMEOUT_INFINITE);
 331       screen->fence_reference(screen, &surf->fence, NULL);
 332    }
 333    pipe_mutex_unlock(pq->device->mutex);
 334
 335    return vlVdpPresentationQueueGetTime(presentation_queue, first_presentation_time);
 336 }
 337
 338 /**
 339  * Poll the current queue status of a surface.
 340  */
 341 VdpStatus
 342 vlVdpPresentationQueueQuerySurfaceStatus(VdpPresentationQueue presentation_queue,
 343                                          VdpOutputSurface surface,
 344                                          VdpPresentationQueueStatus *status,
 345                                          VdpTime *first_presentation_time)
 346 {
 347    vlVdpPresentationQueue *pq;
 348    vlVdpOutputSurface *surf;
 349    struct pipe_screen *screen;
 350
 351    if (!(status && first_presentation_time))
 352       return VDP_STATUS_INVALID_POINTER;
 353
 354    pq = vlGetDataHTAB(presentation_queue);
 355    if (!pq)
 356       return VDP_STATUS_INVALID_HANDLE;
 357
 358    surf = vlGetDataHTAB(surface);
 359    if (!surf)
 360       return VDP_STATUS_INVALID_HANDLE;
 361
 362    *first_presentation_time = 0;
 363
 364    if (!surf->fence) {
 365       if (pq->last_surf == surf)
 366          *status = VDP_PRESENTATION_QUEUE_STATUS_VISIBLE;
 367       else
 368          *status = VDP_PRESENTATION_QUEUE_STATUS_IDLE;
 369    } else {
 370       pipe_mutex_lock(pq->device->mutex);
 371       screen = pq->device->vscreen->pscreen;
 372       if (screen->fence_finish(screen, surf->fence, 0)) {
 373          screen->fence_reference(screen, &surf->fence, NULL);
 374          *status = VDP_PRESENTATION_QUEUE_STATUS_VISIBLE;
 375          pipe_mutex_unlock(pq->device->mutex);
 376
 377          // We actually need to query the timestamp of the last VSYNC event from the hardware
 378          vlVdpPresentationQueueGetTime(presentation_queue, first_presentation_time);
 379          *first_presentation_time += 1;
 380       } else {
 381          *status = VDP_PRESENTATION_QUEUE_STATUS_QUEUED;
 382          pipe_mutex_unlock(pq->device->mutex);
 383       }
 384    }
 385
 386    return VDP_STATUS_OK;
 387 }