X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fstate_trackers%2Fvdpau%2Fpresentation.c;h=0e086fc18b42ae89517b39e86f8d19253e4a8a3a;hb=e8e0756bd35e5e3b70a0eee323f5aaa3707fe11d;hp=02fcfbd0746d9dbe2a37720bab73f9a8dfa78970;hpb=003401f95c9b59471c22368b7da16fe7a951e490;p=mesa.git diff --git a/src/gallium/state_trackers/vdpau/presentation.c b/src/gallium/state_trackers/vdpau/presentation.c index 02fcfbd0746..0e086fc18b4 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,13 +113,17 @@ 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"); + VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Setting background color\n"); if (!background_color) return VDP_STATUS_INVALID_POINTER; @@ -120,31 +132,73 @@ vlVdpPresentationQueueSetBackgroundColor(VdpPresentationQueue presentation_queue if (!pq) return VDP_STATUS_INVALID_HANDLE; - pq->compositor->set_clear_color(pq->compositor, (float*)background_color); + 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, @@ -156,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) @@ -170,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; + + 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; + dst_clip.h = clip_height; - pq->device->context->vpipe->screen->flush_frontbuffer + 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]; @@ -196,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; }