VdpStatus
vlVdpPresentationQueueDisplay(VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
uint32_t clip_width,
uint32_t clip_height,
VdpTime earliest_presentation_time)
{
static int dump_window = -1;
vlVdpPresentationQueue *pq;
vlVdpOutputSurface *surf;
struct pipe_surface *drawable_surface;
pq = vlGetDataHTAB(presentation_queue);
if (!pq)
return VDP_STATUS_INVALID_HANDLE;
drawable_surface = vl_drawable_surface_get(pq->device->context, pq->drawable);
if (!drawable_surface)
return VDP_STATUS_INVALID_HANDLE;
surf = vlGetDataHTAB(surface);
if (!surf)
return VDP_STATUS_INVALID_HANDLE;
vl_compositor_clear_layers(&pq->compositor);
vl_compositor_set_rgba_layer(&pq->compositor, 0, surf->sampler_view, NULL, NULL);
vl_compositor_render(&pq->compositor, PIPE_MPEG12_PICTURE_TYPE_FRAME,
drawable_surface, NULL, NULL);
pq->device->context->pipe->screen->flush_frontbuffer
(
pq->device->context->pipe->screen,
drawable_surface->texture,
0, 0,
vl_contextprivate_get(pq->device->context, drawable_surface)
);
if(dump_window == -1) {
dump_window = debug_get_num_option("VDPAU_DUMP", 0);
}
if(dump_window) {
static unsigned int framenum = 0;
char cmd[256];
sprintf(cmd, "xwd -id %d -out vdpau_frame_%08d.xwd", (int)pq->drawable, ++framenum);
if (system(cmd) != 0)
VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Dumping surface %d failed.\n", surface);
}
pipe_surface_reference(&drawable_surface, NULL);
return VDP_STATUS_OK;
}
/**
* Composite a sub-rectangle of a VdpBitmapSurface into a sub-rectangle of
* a VdpOutputSurface; Output Surface object VdpOutputSurface.
*/
VdpStatus
vlVdpOutputSurfaceRenderBitmapSurface(VdpOutputSurface destination_surface,
VdpRect const *destination_rect,
VdpBitmapSurface source_surface,
VdpRect const *source_rect,
VdpColor const *colors,
VdpOutputSurfaceRenderBlendState const *blend_state,
uint32_t flags)
{
vlVdpOutputSurface *dst_vlsurface;
vlVdpBitmapSurface *src_vlsurface;
struct pipe_context *context;
struct vl_compositor *compositor;
struct vl_compositor_state *cstate;
struct u_rect src_rect, dst_rect;
struct vertex4f vlcolors[4];
void *blend;
dst_vlsurface = vlGetDataHTAB(destination_surface);
if (!dst_vlsurface)
return VDP_STATUS_INVALID_HANDLE;
src_vlsurface = vlGetDataHTAB(source_surface);
if (!src_vlsurface)
return VDP_STATUS_INVALID_HANDLE;
if (dst_vlsurface->device != src_vlsurface->device)
return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
context = dst_vlsurface->device->context;
compositor = &dst_vlsurface->device->compositor;
cstate = &dst_vlsurface->cstate;
pipe_mutex_lock(dst_vlsurface->device->mutex);
vlVdpResolveDelayedRendering(dst_vlsurface->device, NULL, NULL);
blend = BlenderToPipe(context, blend_state);
vl_compositor_clear_layers(cstate);
vl_compositor_set_layer_blend(cstate, 0, blend, false);
vl_compositor_set_rgba_layer(cstate, compositor, 0, src_vlsurface->sampler_view,
RectToPipe(source_rect, &src_rect), NULL,
ColorsToPipe(colors, flags, vlcolors));
vl_compositor_set_layer_dst_area(cstate, 0, RectToPipe(destination_rect, &dst_rect));
vl_compositor_render(cstate, compositor, dst_vlsurface->surface, NULL);
context->delete_blend_state(context, blend);
pipe_mutex_unlock(dst_vlsurface->device->mutex);
return VDP_STATUS_OK;
}
/**
* Composite a sub-rectangle of a VdpOutputSurface into a sub-rectangle of
* another VdpOutputSurface; Output Surface object VdpOutputSurface.
*/
VdpStatus
vlVdpOutputSurfaceRenderOutputSurface(VdpOutputSurface destination_surface,
VdpRect const *destination_rect,
VdpOutputSurface source_surface,
VdpRect const *source_rect,
VdpColor const *colors,
VdpOutputSurfaceRenderBlendState const *blend_state,
uint32_t flags)
{
vlVdpOutputSurface *dst_vlsurface;
vlVdpOutputSurface *src_vlsurface;
struct pipe_context *context;
struct vl_compositor *compositor;
struct pipe_video_rect src_rect;
struct pipe_video_rect dst_rect;
void *blend;
VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Composing output surfaces\n");
dst_vlsurface = vlGetDataHTAB(destination_surface);
if (!dst_vlsurface)
return VDP_STATUS_INVALID_HANDLE;
src_vlsurface = vlGetDataHTAB(source_surface);
if (!src_vlsurface)
return VDP_STATUS_INVALID_HANDLE;
if (dst_vlsurface->device != src_vlsurface->device)
return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
context = dst_vlsurface->device->context->pipe;
compositor = &dst_vlsurface->device->compositor;
blend = BlenderToPipe(context, blend_state);
vl_compositor_clear_layers(compositor);
vl_compositor_set_layer_blend(compositor, 0, blend, false);
vl_compositor_set_rgba_layer(compositor, 0, src_vlsurface->sampler_view,
RectToPipe(source_rect, &src_rect), NULL);
vl_compositor_render(compositor, dst_vlsurface->surface,
RectToPipe(destination_rect, &dst_rect), NULL, false);
context->delete_blend_state(context, blend);
return VDP_STATUS_OK;
}
PUBLIC
Status XvMCPutSurface(Display *dpy, XvMCSurface *surface, Drawable drawable,
short srcx, short srcy, unsigned short srcw, unsigned short srch,
short destx, short desty, unsigned short destw, unsigned short desth,
int flags)
{
static int dump_window = -1;
struct pipe_context *pipe;
struct vl_compositor *compositor;
struct vl_compositor_state *cstate;
struct vl_screen *vscreen;
XvMCSurfacePrivate *surface_priv;
XvMCContextPrivate *context_priv;
XvMCSubpicturePrivate *subpicture_priv;
XvMCContext *context;
struct u_rect src_rect = {srcx, srcx + srcw, srcy, srcy + srch};
struct u_rect dst_rect = {destx, destx + destw, desty, desty + desth};
struct pipe_resource *tex;
struct pipe_surface surf_templ, *surf;
struct u_rect *dirty_area;
XVMC_MSG(XVMC_TRACE, "[XvMC] Displaying surface %p.\n", surface);
assert(dpy);
if (!surface || !surface->privData)
return XvMCBadSurface;
surface_priv = surface->privData;
context = surface_priv->context;
context_priv = context->privData;
assert(flags == XVMC_TOP_FIELD || flags == XVMC_BOTTOM_FIELD || flags == XVMC_FRAME_PICTURE);
assert(srcx + srcw - 1 < surface->width);
assert(srcy + srch - 1 < surface->height);
subpicture_priv = surface_priv->subpicture ? surface_priv->subpicture->privData : NULL;
pipe = context_priv->pipe;
compositor = &context_priv->compositor;
cstate = &context_priv->cstate;
vscreen = context_priv->vscreen;
tex = vscreen->texture_from_drawable(vscreen, (void *)drawable);
dirty_area = vscreen->get_dirty_area(vscreen);
memset(&surf_templ, 0, sizeof(surf_templ));
surf_templ.format = tex->format;
surf = pipe->create_surface(pipe, tex, &surf_templ);
if (!surf)
return BadDrawable;
/*
* Some apps (mplayer) hit these asserts because they call
* this function after the window has been resized by the WM
* but before they've handled the corresponding XEvent and
* know about the new dimensions. The output should be clipped
* until the app updates destw and desth.
*/
/*
assert(destx + destw - 1 < drawable_surface->width);
assert(desty + desth - 1 < drawable_surface->height);
*/
RecursiveEndFrame(surface_priv);
context_priv->decoder->flush(context_priv->decoder);
vl_compositor_clear_layers(cstate);
vl_compositor_set_buffer_layer(cstate, compositor, 0, surface_priv->video_buffer,
&src_rect, NULL, VL_COMPOSITOR_WEAVE);
if (subpicture_priv) {
XVMC_MSG(XVMC_TRACE, "[XvMC] Surface %p has subpicture %p.\n", surface, surface_priv->subpicture);
assert(subpicture_priv->surface == surface);
if (subpicture_priv->palette)
vl_compositor_set_palette_layer(cstate, compositor, 1, subpicture_priv->sampler, subpicture_priv->palette,
&subpicture_priv->src_rect, &subpicture_priv->dst_rect, true);
else
vl_compositor_set_rgba_layer(cstate, compositor, 1, subpicture_priv->sampler,
&subpicture_priv->src_rect, &subpicture_priv->dst_rect, NULL);
surface_priv->subpicture = NULL;
subpicture_priv->surface = NULL;
}
// Workaround for r600g, there seems to be a bug in the fence refcounting code
pipe->screen->fence_reference(pipe->screen, &surface_priv->fence, NULL);
vl_compositor_set_layer_dst_area(cstate, 0, &dst_rect);
vl_compositor_set_layer_dst_area(cstate, 1, &dst_rect);
vl_compositor_render(cstate, compositor, surf, dirty_area, true);
pipe->flush(pipe, &surface_priv->fence, 0);
XVMC_MSG(XVMC_TRACE, "[XvMC] Submitted surface %p for display. Pushing to front buffer.\n", surface);
pipe->screen->flush_frontbuffer(pipe->screen, tex, 0, 0,
vscreen->get_private(vscreen), NULL);
if(dump_window == -1) {
dump_window = debug_get_num_option("XVMC_DUMP", 0);
}
if(dump_window) {
static unsigned int framenum = 0;
char cmd[256];
sprintf(cmd, "xwd -id %d -out xvmc_frame_%08d.xwd", (int)drawable, ++framenum);
if (system(cmd) != 0)
XVMC_MSG(XVMC_ERR, "[XvMC] Dumping surface %p failed.\n", surface);
}
XVMC_MSG(XVMC_TRACE, "[XvMC] Pushed surface %p to front buffer.\n", surface);
return Success;
}
static VAStatus
vlVaPutSubpictures(vlVaSurface *surf, vlVaDriver *drv,
struct pipe_surface *surf_draw, struct u_rect *dirty_area,
struct u_rect *src_rect, struct u_rect *dst_rect)
{
vlVaSubpicture *sub;
int i;
if (!(surf->subpics.data || surf->subpics.size))
return VA_STATUS_SUCCESS;
for (i = 0; i < surf->subpics.size/sizeof(vlVaSubpicture *); i++) {
struct pipe_blend_state blend;
void *blend_state;
vlVaBuffer *buf;
struct pipe_box box;
struct u_rect *s, *d, sr, dr, c;
int sw, sh, dw, dh;
sub = ((vlVaSubpicture **)surf->subpics.data)[i];
if (!sub)
continue;
buf = handle_table_get(drv->htab, sub->image->buf);
if (!buf)
return VA_STATUS_ERROR_INVALID_IMAGE;
box.x = 0;
box.y = 0;
box.z = 0;
box.width = sub->dst_rect.x1 - sub->dst_rect.x0;
box.height = sub->dst_rect.y1 - sub->dst_rect.y0;
box.depth = 1;
s = &sub->src_rect;
d = &sub->dst_rect;
sw = s->x1 - s->x0;
sh = s->y1 - s->y0;
dw = d->x1 - d->x0;
dh = d->y1 - d->y0;
c.x0 = MAX2(d->x0, s->x0);
c.y0 = MAX2(d->y0, s->y0);
c.x1 = MIN2(d->x0 + dw, src_rect->x1);
c.y1 = MIN2(d->y0 + dh, src_rect->y1);
sr.x0 = s->x0 + (c.x0 - d->x0)*(sw/(float)dw);
sr.y0 = s->y0 + (c.y0 - d->y0)*(sh/(float)dh);
sr.x1 = s->x0 + (c.x1 - d->x0)*(sw/(float)dw);
sr.y1 = s->y0 + (c.y1 - d->y0)*(sh/(float)dh);
s = src_rect;
d = dst_rect;
sw = s->x1 - s->x0;
sh = s->y1 - s->y0;
dw = d->x1 - d->x0;
dh = d->y1 - d->y0;
dr.x0 = d->x0 + c.x0*(dw/(float)sw);
dr.y0 = d->y0 + c.y0*(dh/(float)sh);
dr.x1 = d->x0 + c.x1*(dw/(float)sw);
dr.y1 = d->y0 + c.y1*(dh/(float)sh);
memset(&blend, 0, sizeof(blend));
blend.independent_blend_enable = 0;
blend.rt[0].blend_enable = 1;
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ZERO;
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
blend.rt[0].rgb_func = PIPE_BLEND_ADD;
blend.rt[0].alpha_func = PIPE_BLEND_ADD;
blend.rt[0].colormask = PIPE_MASK_RGBA;
blend.logicop_enable = 0;
blend.logicop_func = PIPE_LOGICOP_CLEAR;
blend.dither = 0;
blend_state = drv->pipe->create_blend_state(drv->pipe, &blend);
vl_compositor_clear_layers(&drv->cstate);
vl_compositor_set_layer_blend(&drv->cstate, 0, blend_state, false);
upload_sampler(drv->pipe, sub->sampler, &box, buf->data,
sub->image->pitches[0], 0, 0);
vl_compositor_set_rgba_layer(&drv->cstate, &drv->compositor, 0, sub->sampler,
&sr, NULL, NULL);
vl_compositor_set_layer_dst_area(&drv->cstate, 0, &dr);
vl_compositor_render(&drv->cstate, &drv->compositor, surf_draw, dirty_area, false);
drv->pipe->delete_blend_state(drv->pipe, blend_state);
}
return VA_STATUS_SUCCESS;
}
/**
* Perform a video post-processing and compositing operation.
*/
VdpStatus vlVdpVideoMixerRender(VdpVideoMixer mixer,
VdpOutputSurface background_surface,
VdpRect const *background_source_rect,
VdpVideoMixerPictureStructure current_picture_structure,
uint32_t video_surface_past_count,
VdpVideoSurface const *video_surface_past,
VdpVideoSurface video_surface_current,
uint32_t video_surface_future_count,
VdpVideoSurface const *video_surface_future,
VdpRect const *video_source_rect,
VdpOutputSurface destination_surface,
VdpRect const *destination_rect,
VdpRect const *destination_video_rect,
uint32_t layer_count,
VdpLayer const *layers)
{
enum vl_compositor_deinterlace deinterlace;
struct u_rect rect, clip, *prect;
unsigned i, layer = 0;
struct pipe_video_buffer *video_buffer;
vlVdpVideoMixer *vmixer;
vlVdpSurface *surf;
vlVdpOutputSurface *dst, *bg = NULL;
struct vl_compositor *compositor;
vmixer = vlGetDataHTAB(mixer);
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
compositor = &vmixer->device->compositor;
surf = vlGetDataHTAB(video_surface_current);
if (!surf)
return VDP_STATUS_INVALID_HANDLE;
video_buffer = surf->video_buffer;
if (surf->device != vmixer->device)
return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
if (vmixer->video_width > video_buffer->width ||
vmixer->video_height > video_buffer->height ||
vmixer->chroma_format != video_buffer->chroma_format)
return VDP_STATUS_INVALID_SIZE;
if (layer_count > vmixer->max_layers)
return VDP_STATUS_INVALID_VALUE;
dst = vlGetDataHTAB(destination_surface);
if (!dst)
return VDP_STATUS_INVALID_HANDLE;
if (background_surface != VDP_INVALID_HANDLE) {
bg = vlGetDataHTAB(background_surface);
if (!bg)
return VDP_STATUS_INVALID_HANDLE;
}
pipe_mutex_lock(vmixer->device->mutex);
vlVdpResolveDelayedRendering(vmixer->device, NULL, NULL);
vl_compositor_clear_layers(&vmixer->cstate);
if (bg)
vl_compositor_set_rgba_layer(&vmixer->cstate, compositor, layer++, bg->sampler_view,
RectToPipe(background_source_rect, &rect), NULL, NULL);
switch (current_picture_structure) {
case VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD:
deinterlace = VL_COMPOSITOR_BOB_TOP;
break;
case VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD:
deinterlace = VL_COMPOSITOR_BOB_BOTTOM;
break;
case VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME:
deinterlace = VL_COMPOSITOR_WEAVE;
break;
default:
pipe_mutex_unlock(vmixer->device->mutex);
return VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE;
}
if (deinterlace != VL_COMPOSITOR_WEAVE && vmixer->deint.enabled &&
video_surface_past_count > 1 && video_surface_future_count > 0) {
vlVdpSurface *prevprev = vlGetDataHTAB(video_surface_past[1]);
vlVdpSurface *prev = vlGetDataHTAB(video_surface_past[0]);
vlVdpSurface *next = vlGetDataHTAB(video_surface_future[0]);
if (prevprev && prev && next &&
vl_deint_filter_check_buffers(vmixer->deint.filter,
prevprev->video_buffer, prev->video_buffer, surf->video_buffer, next->video_buffer)) {
vl_deint_filter_render(vmixer->deint.filter, prevprev->video_buffer,
prev->video_buffer, surf->video_buffer,
next->video_buffer,
deinterlace == VL_COMPOSITOR_BOB_BOTTOM);
deinterlace = VL_COMPOSITOR_WEAVE;
video_buffer = vmixer->deint.filter->video_buffer;
}
}
prect = RectToPipe(video_source_rect, &rect);
if (!prect) {
rect.x0 = 0;
rect.y0 = 0;
rect.x1 = surf->templat.width;
rect.y1 = surf->templat.height;
prect = ▭
}
vl_compositor_set_buffer_layer(&vmixer->cstate, compositor, layer, video_buffer, prect, NULL, deinterlace);
vl_compositor_set_layer_dst_area(&vmixer->cstate, layer++, RectToPipe(destination_video_rect, &rect));
for (i = 0; i < layer_count; ++i) {
vlVdpOutputSurface *src = vlGetDataHTAB(layers->source_surface);
if (!src) {
pipe_mutex_unlock(vmixer->device->mutex);
return VDP_STATUS_INVALID_HANDLE;
}
assert(layers->struct_version == VDP_LAYER_VERSION);
vl_compositor_set_rgba_layer(&vmixer->cstate, compositor, layer, src->sampler_view,
RectToPipe(layers->source_rect, &rect), NULL, NULL);
vl_compositor_set_layer_dst_area(&vmixer->cstate, layer++, RectToPipe(layers->destination_rect, &rect));
++layers;
}
vl_compositor_set_dst_clip(&vmixer->cstate, RectToPipe(destination_rect, &clip));
if (!vmixer->noise_reduction.filter && !vmixer->sharpness.filter)
vlVdpSave4DelayedRendering(vmixer->device, destination_surface, &vmixer->cstate);
else {
vl_compositor_render(&vmixer->cstate, compositor, dst->surface, &dst->dirty_area, true);
/* applying the noise reduction after scaling is actually not very
clever, but currently we should avoid to copy around the image
data once more. */
if (vmixer->noise_reduction.filter)
vl_median_filter_render(vmixer->noise_reduction.filter,
dst->sampler_view, dst->surface);
if (vmixer->sharpness.filter)
vl_matrix_filter_render(vmixer->sharpness.filter,
dst->sampler_view, dst->surface);
}
pipe_mutex_unlock(vmixer->device->mutex);
return VDP_STATUS_OK;
}
/**
* Enter a surface into the presentation queue.
*/
VdpStatus
vlVdpPresentationQueueDisplay(VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
uint32_t clip_width,
uint32_t clip_height,
VdpTime earliest_presentation_time)
{
static int dump_window = -1;
vlVdpPresentationQueue *pq;
vlVdpOutputSurface *surf;
struct pipe_context *pipe;
struct pipe_resource *tex;
struct pipe_surface surf_templ, *surf_draw;
struct u_rect src_rect, dst_clip, *dirty_area;
struct vl_compositor *compositor;
struct vl_compositor_state *cstate;
pq = vlGetDataHTAB(presentation_queue);
if (!pq)
return VDP_STATUS_INVALID_HANDLE;
surf = vlGetDataHTAB(surface);
if (!surf)
return VDP_STATUS_INVALID_HANDLE;
pipe = pq->device->context;
compositor = &pq->device->compositor;
cstate = &pq->cstate;
pipe_mutex_lock(pq->device->mutex);
tex = vl_screen_texture_from_drawable(pq->device->vscreen, pq->drawable);
if (!tex) {
pipe_mutex_unlock(pq->device->mutex);
return VDP_STATUS_INVALID_HANDLE;
}
dirty_area = vl_screen_get_dirty_area(pq->device->vscreen);
memset(&surf_templ, 0, sizeof(surf_templ));
surf_templ.format = tex->format;
surf_templ.usage = PIPE_BIND_RENDER_TARGET;
surf_draw = pipe->create_surface(pipe, tex, &surf_templ);
surf->timestamp = (vlVdpTime)earliest_presentation_time;
dst_clip.x0 = 0;
dst_clip.y0 = 0;
dst_clip.x1 = clip_width ? clip_width : surf_draw->width;
dst_clip.y1 = clip_height ? clip_height : surf_draw->height;
if (pq->device->delayed_rendering.surface == surface &&
dst_clip.x1 == surf_draw->width && dst_clip.y1 == surf_draw->height) {
// TODO: we correctly support the clipping here, but not the pq background color in the clipped area....
cstate = pq->device->delayed_rendering.cstate;
vl_compositor_set_dst_clip(cstate, &dst_clip);
vlVdpResolveDelayedRendering(pq->device, surf_draw, dirty_area);
} else {
vlVdpResolveDelayedRendering(pq->device, NULL, NULL);
src_rect.x0 = 0;
src_rect.y0 = 0;
src_rect.x1 = surf_draw->width;
src_rect.y1 = surf_draw->height;
vl_compositor_clear_layers(cstate);
vl_compositor_set_rgba_layer(cstate, compositor, 0, surf->sampler_view, &src_rect, NULL, NULL);
vl_compositor_set_dst_clip(cstate, &dst_clip);
vl_compositor_render(cstate, compositor, surf_draw, dirty_area);
}
vl_screen_set_next_timestamp(pq->device->vscreen, earliest_presentation_time);
pipe->screen->flush_frontbuffer
(
pipe->screen, tex, 0, 0,
vl_screen_get_private(pq->device->vscreen)
);
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) {
static unsigned int framenum = 0;
char cmd[256];
if (framenum) {
sprintf(cmd, "xwd -id %d -silent -out vdpau_frame_%08d.xwd", (int)pq->drawable, framenum);
if (system(cmd) != 0)
VDPAU_MSG(VDPAU_ERR, "[VDPAU] Dumping surface %d failed.\n", surface);
}
framenum++;
}
pipe_resource_reference(&tex, NULL);
pipe_surface_reference(&surf_draw, NULL);
pipe_mutex_unlock(pq->device->mutex);
return VDP_STATUS_OK;
}
