+ enum vl_compositor_deinterlace deinterlace;
+ struct u_rect rect, clip;
+ unsigned i, layer = 0;
+
+ vlVdpVideoMixer *vmixer;
+ vlVdpSurface *surf;
+ vlVdpOutputSurface *dst;
+
+ 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;
+
+ if (surf->device != vmixer->device)
+ return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
+
+ if (vmixer->video_width > surf->video_buffer->width ||
+ vmixer->video_height > surf->video_buffer->height ||
+ vmixer->chroma_format != surf->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;
+
+ pipe_mutex_lock(vmixer->device->mutex);
+ vlVdpResolveDelayedRendering(vmixer->device, NULL, NULL);
+ if (background_surface != VDP_INVALID_HANDLE) {
+ vlVdpOutputSurface *bg = vlGetDataHTAB(background_surface);
+ if (!bg) {
+ pipe_mutex_unlock(vmixer->device->mutex);
+ return VDP_STATUS_INVALID_HANDLE;
+ }
+ vl_compositor_set_rgba_layer(&vmixer->cstate, compositor, layer++, bg->sampler_view,
+ RectToPipe(background_source_rect, &rect), NULL, NULL);
+ }
+
+ vl_compositor_clear_layers(&vmixer->cstate);
+
+ 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;
+ };
+ vl_compositor_set_buffer_layer(&vmixer->cstate, compositor, layer, surf->video_buffer,
+ RectToPipe(video_source_rect, &rect), 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);
+
+ /* 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;
+}
+
+/**
+ * Update the noise reduction setting
+ */
+static void
+vlVdpVideoMixerUpdateNoiseReductionFilter(vlVdpVideoMixer *vmixer)
+{
+ assert(vmixer);
+
+ /* if present remove the old filter first */
+ if (vmixer->noise_reduction.filter) {
+ vl_median_filter_cleanup(vmixer->noise_reduction.filter);
+ FREE(vmixer->noise_reduction.filter);
+ vmixer->noise_reduction.filter = NULL;
+ }
+
+ /* and create a new filter as needed */
+ if (vmixer->noise_reduction. enabled && vmixer->noise_reduction.level > 0) {
+ vmixer->noise_reduction.filter = MALLOC(sizeof(struct vl_median_filter));
+ vl_median_filter_init(vmixer->noise_reduction.filter, vmixer->device->context,
+ vmixer->video_width, vmixer->video_height,
+ vmixer->noise_reduction.level + 1,
+ VL_MEDIAN_FILTER_CROSS);
+ }
+}
+
+static void
+vlVdpVideoMixerUpdateSharpnessFilter(vlVdpVideoMixer *vmixer)
+{
+ assert(vmixer);
+
+ /* if present remove the old filter first */
+ if (vmixer->sharpness.filter) {
+ vl_matrix_filter_cleanup(vmixer->sharpness.filter);
+ FREE(vmixer->sharpness.filter);
+ vmixer->sharpness.filter = NULL;
+ }
+
+ /* and create a new filter as needed */
+ if (vmixer->sharpness.enabled && vmixer->sharpness.value != 0.0f) {
+ float matrix[9];
+ unsigned i;
+
+ if (vmixer->sharpness.value > 0.0f) {
+ matrix[0] = -1.0f; matrix[1] = -1.0f; matrix[2] = -1.0f;
+ matrix[3] = -1.0f; matrix[4] = 8.0f; matrix[5] = -1.0f;
+ matrix[6] = -1.0f; matrix[7] = -1.0f; matrix[8] = -1.0f;
+
+ for (i = 0; i < 9; ++i)
+ matrix[i] *= vmixer->sharpness.value;
+
+ matrix[4] += 1.0f;
+
+ } else {
+ matrix[0] = 1.0f; matrix[1] = 2.0f; matrix[2] = 1.0f;
+ matrix[3] = 2.0f; matrix[4] = 4.0f; matrix[5] = 2.0f;
+ matrix[6] = 1.0f; matrix[7] = 2.0f; matrix[8] = 1.0f;
+
+ for (i = 0; i < 9; ++i)
+ matrix[i] *= fabsf(vmixer->sharpness.value) / 16.0f;
+
+ matrix[4] += 1.0f - fabsf(vmixer->sharpness.value);
+ }
+
+ vmixer->sharpness.filter = MALLOC(sizeof(struct vl_matrix_filter));
+ vl_matrix_filter_init(vmixer->sharpness.filter, vmixer->device->context,
+ vmixer->video_width, vmixer->video_height,
+ 3, 3, matrix);
+ }
+}
+
+/**
+ * Retrieve whether features were requested at creation time.
+ */
+VdpStatus
+vlVdpVideoMixerGetFeatureSupport(VdpVideoMixer mixer,
+ uint32_t feature_count,
+ VdpVideoMixerFeature const *features,
+ VdpBool *feature_supports)
+{
+ vlVdpVideoMixer *vmixer;
+ unsigned i;
+
+ if (!(features && feature_supports))
+ return VDP_STATUS_INVALID_POINTER;
+
+ vmixer = vlGetDataHTAB(mixer);
+ if (!vmixer)
+ return VDP_STATUS_INVALID_HANDLE;
+
+ for (i = 0; i < feature_count; ++i) {
+ switch (features[i]) {
+ /* they are valid, but we doesn't support them */
+ case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL:
+ case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL:
+ case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1:
+ case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2:
+ case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3:
+ case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4:
+ case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5:
+ case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6:
+ case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7:
+ case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8:
+ case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9:
+ case VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE:
+ case VDP_VIDEO_MIXER_FEATURE_LUMA_KEY:
+ feature_supports[i] = false;
+ break;
+
+ case VDP_VIDEO_MIXER_FEATURE_SHARPNESS:
+ feature_supports[i] = vmixer->sharpness.supported;
+ break;
+
+ case VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION:
+ feature_supports[i] = vmixer->noise_reduction.supported;
+ break;
+
+ default:
+ return VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE;
+ }
+ }
+
+ return VDP_STATUS_OK;
+}
+
+/**
+ * Enable or disable features.
+ */
+VdpStatus
+vlVdpVideoMixerSetFeatureEnables(VdpVideoMixer mixer,
+ uint32_t feature_count,
+ VdpVideoMixerFeature const *features,
+ VdpBool const *feature_enables)
+{
+ vlVdpVideoMixer *vmixer;
+ unsigned i;
+
+ if (!(features && feature_enables))