X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fstate_trackers%2Fvdpau%2Fpresentation.c;h=25a6c861115d78601e073e6b2ac0c519ed4ab097;hb=36cd50152c76d5a5b34202887af68aab09854d5d;hp=2f029f07fb1c713a4a2aa8eedd611032508cd042;hpb=08f3a7cf7e9133f50adf33f800aa3696c909347f;p=mesa.git diff --git a/src/gallium/state_trackers/vdpau/presentation.c b/src/gallium/state_trackers/vdpau/presentation.c index 2f029f07fb1..25a6c861115 100644 --- a/src/gallium/state_trackers/vdpau/presentation.c +++ b/src/gallium/state_trackers/vdpau/presentation.c @@ -26,21 +26,25 @@ **************************************************************************/ #include +#include +#include #include -#include -#include +#include "util/u_debug.h" +#include "util/u_memory.h" #include "vdpau_private.h" +/** + * Create a VdpPresentationQueue. + */ VdpStatus vlVdpPresentationQueueCreate(VdpDevice device, VdpPresentationQueueTarget presentation_queue_target, VdpPresentationQueue *presentation_queue) { vlVdpPresentationQueue *pq = NULL; - struct pipe_video_context *context; VdpStatus ret; VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Creating PresentationQueue\n"); @@ -59,20 +63,20 @@ vlVdpPresentationQueueCreate(VdpDevice device, if (dev != pqt->device) return VDP_STATUS_HANDLE_DEVICE_MISMATCH; - context = dev->context->vpipe; - pq = CALLOC(1, sizeof(vlVdpPresentationQueue)); if (!pq) return VDP_STATUS_RESOURCES; pq->device = dev; pq->drawable = pqt->drawable; - pq->compositor = context->create_compositor(context); - if (!pq->compositor) { + + if (!vl_compositor_init(&pq->compositor, dev->context->pipe)) { ret = VDP_STATUS_ERROR; goto no_compositor; } + vl_compositor_reset_dirty_area(&pq->dirty_area); + *presentation_queue = vlAddDataHTAB(pq); if (*presentation_queue == 0) { ret = VDP_STATUS_ERROR; @@ -80,12 +84,16 @@ vlVdpPresentationQueueCreate(VdpDevice device, } return VDP_STATUS_OK; + no_handle: no_compositor: FREE(pq); return ret; } +/** + * Destroy a VdpPresentationQueue. + */ VdpStatus vlVdpPresentationQueueDestroy(VdpPresentationQueue presentation_queue) { @@ -97,7 +105,7 @@ vlVdpPresentationQueueDestroy(VdpPresentationQueue presentation_queue) if (!pq) return VDP_STATUS_INVALID_HANDLE; - pq->compositor->destroy(pq->compositor); + vl_compositor_cleanup(&pq->compositor); vlRemoveDataHTAB(presentation_queue); FREE(pq); @@ -105,36 +113,92 @@ vlVdpPresentationQueueDestroy(VdpPresentationQueue presentation_queue) return VDP_STATUS_OK; } +/** + * Configure the background color setting. + */ VdpStatus vlVdpPresentationQueueSetBackgroundColor(VdpPresentationQueue presentation_queue, VdpColor *const background_color) { + vlVdpPresentationQueue *pq; + union pipe_color_union color; + + VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Setting background color\n"); + if (!background_color) return VDP_STATUS_INVALID_POINTER; - return VDP_STATUS_NO_IMPLEMENTATION; + pq = vlGetDataHTAB(presentation_queue); + if (!pq) + return VDP_STATUS_INVALID_HANDLE; + + color.f[0] = background_color->red; + color.f[1] = background_color->green; + color.f[2] = background_color->blue; + color.f[3] = background_color->alpha; + + vl_compositor_set_clear_color(&pq->compositor, &color); + + return VDP_STATUS_OK; } +/** + * Retrieve the current background color setting. + */ VdpStatus vlVdpPresentationQueueGetBackgroundColor(VdpPresentationQueue presentation_queue, VdpColor *const background_color) { + vlVdpPresentationQueue *pq; + union pipe_color_union color; + + VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Getting background color\n"); + if (!background_color) return VDP_STATUS_INVALID_POINTER; - return VDP_STATUS_NO_IMPLEMENTATION; + pq = vlGetDataHTAB(presentation_queue); + if (!pq) + return VDP_STATUS_INVALID_HANDLE; + + vl_compositor_get_clear_color(&pq->compositor, &color); + + background_color->red = color.f[0]; + background_color->green = color.f[1]; + background_color->blue = color.f[2]; + background_color->alpha = color.f[3]; + + return VDP_STATUS_OK; } +/** + * Retrieve the presentation queue's "current" time. + */ VdpStatus vlVdpPresentationQueueGetTime(VdpPresentationQueue presentation_queue, VdpTime *current_time) { + vlVdpPresentationQueue *pq; + struct timespec ts; + + VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Getting queue time\n"); + if (!current_time) return VDP_STATUS_INVALID_POINTER; - return VDP_STATUS_NO_IMPLEMENTATION; + pq = vlGetDataHTAB(presentation_queue); + if (!pq) + return VDP_STATUS_INVALID_HANDLE; + + clock_gettime(CLOCK_REALTIME, &ts); + *current_time = (uint64_t)ts.tv_sec * 1000000000LL + (uint64_t)ts.tv_nsec; + + return VDP_STATUS_OK; } +/** + * Enter a surface into the presentation queue. + */ VdpStatus vlVdpPresentationQueueDisplay(VdpPresentationQueue presentation_queue, VdpOutputSurface surface, @@ -146,7 +210,10 @@ vlVdpPresentationQueueDisplay(VdpPresentationQueue presentation_queue, vlVdpPresentationQueue *pq; vlVdpOutputSurface *surf; + + struct pipe_context *pipe; struct pipe_surface *drawable_surface; + struct pipe_video_rect src_rect, dst_clip; pq = vlGetDataHTAB(presentation_queue); if (!pq) @@ -160,24 +227,40 @@ vlVdpPresentationQueueDisplay(VdpPresentationQueue presentation_queue, if (!surf) return VDP_STATUS_INVALID_HANDLE; - pq->compositor->clear_layers(pq->compositor); - pq->compositor->set_rgba_layer(pq->compositor, 0, surf->sampler_view, NULL, NULL); - pq->compositor->render_picture(pq->compositor, PIPE_MPEG12_PICTURE_TYPE_FRAME, - drawable_surface, NULL, NULL); + surf->timestamp = (vlVdpTime)earliest_presentation_time; - pq->device->context->vpipe->screen->flush_frontbuffer + src_rect.x = 0; + src_rect.y = 0; + src_rect.w = drawable_surface->width; + src_rect.h = drawable_surface->height; + + dst_clip.x = 0; + dst_clip.y = 0; + dst_clip.w = clip_width ? clip_width : drawable_surface->width; + dst_clip.h = clip_height ? clip_height : drawable_surface->height; + + vl_compositor_clear_layers(&pq->compositor); + vl_compositor_set_rgba_layer(&pq->compositor, 0, surf->sampler_view, &src_rect, NULL); + vl_compositor_render(&pq->compositor, drawable_surface, NULL, &dst_clip, &pq->dirty_area); + + pipe = pq->device->context->pipe; + + pipe->screen->flush_frontbuffer ( - pq->device->context->vpipe->screen, + pipe->screen, drawable_surface->texture, 0, 0, vl_contextprivate_get(pq->device->context, drawable_surface) ); - if(dump_window == -1) { + pipe->screen->fence_reference(pipe->screen, &surf->fence, NULL); + pipe->flush(pipe, &surf->fence); + + if (dump_window == -1) { dump_window = debug_get_num_option("VDPAU_DUMP", 0); } - if(dump_window) { + if (dump_window) { static unsigned int framenum = 0; char cmd[256]; @@ -186,29 +269,86 @@ vlVdpPresentationQueueDisplay(VdpPresentationQueue presentation_queue, VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Dumping surface %d failed.\n", surface); } + pipe_surface_reference(&drawable_surface, NULL); + return VDP_STATUS_OK; } +/** + * Wait for a surface to finish being displayed. + */ VdpStatus vlVdpPresentationQueueBlockUntilSurfaceIdle(VdpPresentationQueue presentation_queue, VdpOutputSurface surface, VdpTime *first_presentation_time) { + vlVdpPresentationQueue *pq; + vlVdpOutputSurface *surf; + struct pipe_screen *screen; + if (!first_presentation_time) return VDP_STATUS_INVALID_POINTER; - //return VDP_STATUS_NO_IMPLEMENTATION; + pq = vlGetDataHTAB(presentation_queue); + if (!pq) + return VDP_STATUS_INVALID_HANDLE; + + surf = vlGetDataHTAB(surface); + if (!surf) + return VDP_STATUS_INVALID_HANDLE; + + if (surf->fence) { + screen = pq->device->context->pipe->screen; + screen->fence_finish(screen, surf->fence, 0); + } + + // We actually need to query the timestamp of the last VSYNC event from the hardware + vlVdpPresentationQueueGetTime(presentation_queue, first_presentation_time); + return VDP_STATUS_OK; } +/** + * Poll the current queue status of a surface. + */ VdpStatus vlVdpPresentationQueueQuerySurfaceStatus(VdpPresentationQueue presentation_queue, VdpOutputSurface surface, VdpPresentationQueueStatus *status, VdpTime *first_presentation_time) { + vlVdpPresentationQueue *pq; + vlVdpOutputSurface *surf; + struct pipe_screen *screen; + if (!(status && first_presentation_time)) return VDP_STATUS_INVALID_POINTER; - return VDP_STATUS_NO_IMPLEMENTATION; + pq = vlGetDataHTAB(presentation_queue); + if (!pq) + return VDP_STATUS_INVALID_HANDLE; + + surf = vlGetDataHTAB(surface); + if (!surf) + return VDP_STATUS_INVALID_HANDLE; + + *first_presentation_time = 0; + + if (!surf->fence) { + *status = VDP_PRESENTATION_QUEUE_STATUS_IDLE; + } else { + screen = pq->device->context->pipe->screen; + if (screen->fence_signalled(screen, surf->fence)) { + screen->fence_reference(screen, &surf->fence, NULL); + *status = VDP_PRESENTATION_QUEUE_STATUS_VISIBLE; + + // We actually need to query the timestamp of the last VSYNC event from the hardware + vlVdpPresentationQueueGetTime(presentation_queue, first_presentation_time); + *first_presentation_time += 1; + } else { + *status = VDP_PRESENTATION_QUEUE_STATUS_QUEUED; + } + } + + return VDP_STATUS_OK; }