bool vl_compositor_init_state(struct vl_compositor_state *s, struct pipe_context *pipe) { vl_csc_matrix csc_matrix; assert(s); memset(s, 0, sizeof(*s)); s->pipe = pipe; s->clear_color.f[0] = s->clear_color.f[1] = 0.0f; s->clear_color.f[2] = s->clear_color.f[3] = 0.0f; /* * Create our fragment shader's constant buffer * Const buffer contains the color conversion matrix and bias vectors */ /* XXX: Create with IMMUTABLE/STATIC... although it does change every once in a long while... */ s->csc_matrix = pipe_buffer_create ( pipe->screen, PIPE_BIND_CONSTANT_BUFFER, PIPE_USAGE_STATIC, sizeof(csc_matrix) ); vl_compositor_clear_layers(s); vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_IDENTITY, NULL, true, &csc_matrix); vl_compositor_set_csc_matrix(s, (const vl_csc_matrix *)&csc_matrix); return true; }
static VAStatus vlVaPostProcCompositor(vlVaDriver *drv, vlVaContext *context, const VARectangle *src_region, const VARectangle *dst_region, struct pipe_video_buffer *src, struct pipe_video_buffer *dst, enum vl_compositor_deinterlace deinterlace) { struct pipe_surface **surfaces; struct u_rect src_rect; struct u_rect dst_rect; surfaces = dst->get_surfaces(dst); if (!surfaces || !surfaces[0]) return VA_STATUS_ERROR_INVALID_SURFACE; src_rect.x0 = src_region->x; src_rect.y0 = src_region->y; src_rect.x1 = src_region->x + src_region->width; src_rect.y1 = src_region->y + src_region->height; dst_rect.x0 = dst_region->x; dst_rect.y0 = dst_region->y; dst_rect.x1 = dst_region->x + dst_region->width; dst_rect.y1 = dst_region->y + dst_region->height; vl_compositor_clear_layers(&drv->cstate); vl_compositor_set_buffer_layer(&drv->cstate, &drv->compositor, 0, src, &src_rect, NULL, deinterlace); vl_compositor_set_layer_dst_area(&drv->cstate, 0, &dst_rect); vl_compositor_render(&drv->cstate, &drv->compositor, surfaces[0], NULL, false); return VA_STATUS_SUCCESS; }
void vl_compositor_cleanup_state(struct vl_compositor_state *s) { assert(s); vl_compositor_clear_layers(s); pipe_resource_reference(&s->csc_matrix, NULL); }
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; }
/** * Copy image data from application memory in a specific YCbCr format to * a VdpOutputSurface. */ VdpStatus vlVdpOutputSurfacePutBitsYCbCr(VdpOutputSurface surface, VdpYCbCrFormat source_ycbcr_format, void const *const *source_data, uint32_t const *source_pitches, VdpRect const *destination_rect, VdpCSCMatrix const *csc_matrix) { vlVdpOutputSurface *vlsurface; struct vl_compositor *compositor; struct vl_compositor_state *cstate; struct pipe_context *pipe; enum pipe_format format; struct pipe_video_buffer vtmpl, *vbuffer; struct u_rect dst_rect; struct pipe_sampler_view **sampler_views; unsigned i; vlsurface = vlGetDataHTAB(surface); if (!vlsurface) return VDP_STATUS_INVALID_HANDLE; pipe = vlsurface->device->context; compositor = &vlsurface->device->compositor; cstate = &vlsurface->cstate; format = FormatYCBCRToPipe(source_ycbcr_format); if (format == PIPE_FORMAT_NONE) return VDP_STATUS_INVALID_Y_CB_CR_FORMAT; if (!source_data || !source_pitches) return VDP_STATUS_INVALID_POINTER; pipe_mutex_lock(vlsurface->device->mutex); vlVdpResolveDelayedRendering(vlsurface->device, NULL, NULL); memset(&vtmpl, 0, sizeof(vtmpl)); vtmpl.buffer_format = format; vtmpl.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420; if (destination_rect) { vtmpl.width = abs(destination_rect->x0-destination_rect->x1); vtmpl.height = abs(destination_rect->y0-destination_rect->y1); } else { vtmpl.width = vlsurface->surface->texture->width0; vtmpl.height = vlsurface->surface->texture->height0; } vbuffer = pipe->create_video_buffer(pipe, &vtmpl); if (!vbuffer) { pipe_mutex_unlock(vlsurface->device->mutex); return VDP_STATUS_RESOURCES; } sampler_views = vbuffer->get_sampler_view_planes(vbuffer); if (!sampler_views) { vbuffer->destroy(vbuffer); pipe_mutex_unlock(vlsurface->device->mutex); return VDP_STATUS_RESOURCES; } for (i = 0; i < 3; ++i) { struct pipe_sampler_view *sv = sampler_views[i]; if (!sv) continue; struct pipe_box dst_box = { 0, 0, 0, sv->texture->width0, sv->texture->height0, 1 }; pipe->transfer_inline_write(pipe, sv->texture, 0, PIPE_TRANSFER_WRITE, &dst_box, source_data[i], source_pitches[i], 0); } if (!csc_matrix) { vl_csc_matrix csc; vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, 1, &csc); vl_compositor_set_csc_matrix(cstate, (const vl_csc_matrix*)&csc); } else { vl_compositor_set_csc_matrix(cstate, csc_matrix); } vl_compositor_clear_layers(cstate); vl_compositor_set_buffer_layer(cstate, compositor, 0, vbuffer, NULL, NULL, VL_COMPOSITOR_WEAVE); vl_compositor_set_layer_dst_area(cstate, 0, RectToPipe(destination_rect, &dst_rect)); vl_compositor_render(cstate, compositor, vlsurface->surface, NULL); vbuffer->destroy(vbuffer); pipe_mutex_unlock(vlsurface->device->mutex); return VDP_STATUS_OK; }
/** * Copy image data from application memory in a specific indexed format to * a VdpOutputSurface. */ VdpStatus vlVdpOutputSurfacePutBitsIndexed(VdpOutputSurface surface, VdpIndexedFormat source_indexed_format, void const *const *source_data, uint32_t const *source_pitch, VdpRect const *destination_rect, VdpColorTableFormat color_table_format, void const *color_table) { vlVdpOutputSurface *vlsurface; struct pipe_context *context; struct vl_compositor *compositor; struct vl_compositor_state *cstate; enum pipe_format index_format; enum pipe_format colortbl_format; struct pipe_resource *res, res_tmpl; struct pipe_sampler_view sv_tmpl; struct pipe_sampler_view *sv_idx = NULL, *sv_tbl = NULL; struct pipe_box box; struct u_rect dst_rect; vlsurface = vlGetDataHTAB(surface); if (!vlsurface) return VDP_STATUS_INVALID_HANDLE; context = vlsurface->device->context; compositor = &vlsurface->device->compositor; cstate = &vlsurface->cstate; index_format = FormatIndexedToPipe(source_indexed_format); if (index_format == PIPE_FORMAT_NONE) return VDP_STATUS_INVALID_INDEXED_FORMAT; if (!source_data || !source_pitch) return VDP_STATUS_INVALID_POINTER; colortbl_format = FormatColorTableToPipe(color_table_format); if (colortbl_format == PIPE_FORMAT_NONE) return VDP_STATUS_INVALID_COLOR_TABLE_FORMAT; if (!color_table) return VDP_STATUS_INVALID_POINTER; memset(&res_tmpl, 0, sizeof(res_tmpl)); res_tmpl.target = PIPE_TEXTURE_2D; res_tmpl.format = index_format; if (destination_rect) { res_tmpl.width0 = abs(destination_rect->x0-destination_rect->x1); res_tmpl.height0 = abs(destination_rect->y0-destination_rect->y1); } else { res_tmpl.width0 = vlsurface->surface->texture->width0; res_tmpl.height0 = vlsurface->surface->texture->height0; } res_tmpl.depth0 = 1; res_tmpl.array_size = 1; res_tmpl.usage = PIPE_USAGE_STAGING; res_tmpl.bind = PIPE_BIND_SAMPLER_VIEW; pipe_mutex_lock(vlsurface->device->mutex); vlVdpResolveDelayedRendering(vlsurface->device, NULL, NULL); res = context->screen->resource_create(context->screen, &res_tmpl); if (!res) goto error_resource; box.x = box.y = box.z = 0; box.width = res->width0; box.height = res->height0; box.depth = res->depth0; context->transfer_inline_write(context, res, 0, PIPE_TRANSFER_WRITE, &box, source_data[0], source_pitch[0], source_pitch[0] * res->height0); memset(&sv_tmpl, 0, sizeof(sv_tmpl)); u_sampler_view_default_template(&sv_tmpl, res, res->format); sv_idx = context->create_sampler_view(context, res, &sv_tmpl); pipe_resource_reference(&res, NULL); if (!sv_idx) goto error_resource; memset(&res_tmpl, 0, sizeof(res_tmpl)); res_tmpl.target = PIPE_TEXTURE_1D; res_tmpl.format = colortbl_format; res_tmpl.width0 = 1 << util_format_get_component_bits( index_format, UTIL_FORMAT_COLORSPACE_RGB, 0); res_tmpl.height0 = 1; res_tmpl.depth0 = 1; res_tmpl.array_size = 1; res_tmpl.usage = PIPE_USAGE_STAGING; res_tmpl.bind = PIPE_BIND_SAMPLER_VIEW; res = context->screen->resource_create(context->screen, &res_tmpl); if (!res) goto error_resource; box.x = box.y = box.z = 0; box.width = res->width0; box.height = res->height0; box.depth = res->depth0; context->transfer_inline_write(context, res, 0, PIPE_TRANSFER_WRITE, &box, color_table, util_format_get_stride(colortbl_format, res->width0), 0); memset(&sv_tmpl, 0, sizeof(sv_tmpl)); u_sampler_view_default_template(&sv_tmpl, res, res->format); sv_tbl = context->create_sampler_view(context, res, &sv_tmpl); pipe_resource_reference(&res, NULL); if (!sv_tbl) goto error_resource; vl_compositor_clear_layers(cstate); vl_compositor_set_palette_layer(cstate, compositor, 0, sv_idx, sv_tbl, NULL, NULL, false); vl_compositor_set_layer_dst_area(cstate, 0, RectToPipe(destination_rect, &dst_rect)); vl_compositor_render(cstate, compositor, vlsurface->surface, NULL); pipe_sampler_view_reference(&sv_idx, NULL); pipe_sampler_view_reference(&sv_tbl, NULL); pipe_mutex_unlock(vlsurface->device->mutex); return VDP_STATUS_OK; error_resource: pipe_sampler_view_reference(&sv_idx, NULL); pipe_sampler_view_reference(&sv_tbl, NULL); pipe_mutex_unlock(vlsurface->device->mutex); return VDP_STATUS_RESOURCES; }
VAStatus vlVaPutSurface(VADriverContextP ctx, VASurfaceID surface_id, void* draw, short srcx, short srcy, unsigned short srcw, unsigned short srch, short destx, short desty, unsigned short destw, unsigned short desth, VARectangle *cliprects, unsigned int number_cliprects, unsigned int flags) { vlVaDriver *drv; vlVaSurface *surf; struct pipe_screen *screen; struct pipe_resource *tex; struct pipe_surface surf_templ, *surf_draw; struct u_rect src_rect, *dirty_area; struct u_rect dst_rect = {destx, destx + destw, desty, desty + desth}; VAStatus status; if (!ctx) return VA_STATUS_ERROR_INVALID_CONTEXT; drv = VL_VA_DRIVER(ctx); surf = handle_table_get(drv->htab, surface_id); if (!surf) return VA_STATUS_ERROR_INVALID_SURFACE; screen = drv->pipe->screen; if(surf->fence) { screen->fence_finish(screen, surf->fence, PIPE_TIMEOUT_INFINITE); screen->fence_reference(screen, &surf->fence, NULL); } tex = vl_screen_texture_from_drawable(drv->vscreen, (Drawable)draw); if (!tex) return VA_STATUS_ERROR_INVALID_DISPLAY; dirty_area = vl_screen_get_dirty_area(drv->vscreen); memset(&surf_templ, 0, sizeof(surf_templ)); surf_templ.format = tex->format; surf_draw = drv->pipe->create_surface(drv->pipe, tex, &surf_templ); if (!surf_draw) { pipe_resource_reference(&tex, NULL); return VA_STATUS_ERROR_INVALID_DISPLAY; } src_rect.x0 = srcx; src_rect.y0 = srcy; src_rect.x1 = srcw + srcx; src_rect.y1 = srch + srcy; vl_compositor_clear_layers(&drv->cstate); vl_compositor_set_buffer_layer(&drv->cstate, &drv->compositor, 0, surf->buffer, &src_rect, NULL, VL_COMPOSITOR_WEAVE); vl_compositor_set_layer_dst_area(&drv->cstate, 0, &dst_rect); vl_compositor_render(&drv->cstate, &drv->compositor, surf_draw, dirty_area, true); status = vlVaPutSubpictures(surf, drv, surf_draw, dirty_area, &src_rect, &dst_rect); if (status) return status; screen->flush_frontbuffer ( screen, tex, 0, 0, vl_screen_get_private(drv->vscreen), NULL ); screen->fence_reference(screen, &surf->fence, NULL); drv->pipe->flush(drv->pipe, &surf->fence, 0); pipe_resource_reference(&tex, NULL); pipe_surface_reference(&surf_draw, NULL); return VA_STATUS_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; }