unsigned max_width, max_height, i;
enum pipe_video_profile prof = PIPE_VIDEO_PROFILE_UNKNOWN;
- VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Creating VideoMixer\n");
-
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
return VDP_STATUS_RESOURCES;
vmixer->device = dev;
- vl_compositor_init(&vmixer->compositor, dev->context->pipe);
- vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, true, vmixer->csc);
+ pipe_mutex_lock(dev->mutex);
+
+ vl_compositor_init_state(&vmixer->cstate, dev->context);
+
+ vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, true, &vmixer->csc);
if (!debug_get_bool_option("G3DVL_NO_CSC", FALSE))
- vl_compositor_set_csc_matrix(&vmixer->compositor, vmixer->csc);
+ vl_compositor_set_csc_matrix(&vmixer->cstate, (const vl_csc_matrix *)&vmixer->csc);
*mixer = vlAddDataHTAB(vmixer);
if (*mixer == 0) {
}
ret = VDP_STATUS_INVALID_VALUE;
if (vmixer->max_layers > 4) {
- VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Max layers > 4 not supported\n", vmixer->max_layers);
+ VDPAU_MSG(VDPAU_WARN, "[VDPAU] Max layers > 4 not supported\n", vmixer->max_layers);
goto no_params;
}
max_width = screen->get_video_param(screen, prof, PIPE_VIDEO_CAP_MAX_WIDTH);
max_height = screen->get_video_param(screen, prof, PIPE_VIDEO_CAP_MAX_HEIGHT);
if (vmixer->video_width < 48 ||
vmixer->video_width > max_width) {
- VDPAU_MSG(VDPAU_TRACE, "[VDPAU] 48 < %u < %u not valid for width\n", vmixer->video_width, max_width);
+ VDPAU_MSG(VDPAU_WARN, "[VDPAU] 48 < %u < %u not valid for width\n", vmixer->video_width, max_width);
goto no_params;
}
if (vmixer->video_height < 48 ||
vmixer->video_height > max_height) {
- VDPAU_MSG(VDPAU_TRACE, "[VDPAU] 48 < %u < %u not valid for height\n", vmixer->video_height, max_height);
+ VDPAU_MSG(VDPAU_WARN, "[VDPAU] 48 < %u < %u not valid for height\n", vmixer->video_height, max_height);
goto no_params;
}
vmixer->luma_key_min = 0.f;
vmixer->luma_key_max = 1.f;
+ pipe_mutex_unlock(dev->mutex);
return VDP_STATUS_OK;
no_params:
vlRemoveDataHTAB(*mixer);
+
no_handle:
- vl_compositor_cleanup(&vmixer->compositor);
+ vl_compositor_cleanup_state(&vmixer->cstate);
+ pipe_mutex_unlock(dev->mutex);
FREE(vmixer);
return ret;
}
{
vlVdpVideoMixer *vmixer;
- VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Destroying VideoMixer\n");
-
vmixer = vlGetDataHTAB(mixer);
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
+
+ pipe_mutex_lock(vmixer->device->mutex);
+
+ vlVdpResolveDelayedRendering(vmixer->device, NULL, NULL);
+
vlRemoveDataHTAB(mixer);
- vl_compositor_cleanup(&vmixer->compositor);
+ vl_compositor_cleanup_state(&vmixer->cstate);
if (vmixer->noise_reduction.filter) {
vl_median_filter_cleanup(vmixer->noise_reduction.filter);
FREE(vmixer->noise_reduction.filter);
}
+ if (vmixer->sharpness.filter) {
+ vl_matrix_filter_cleanup(vmixer->sharpness.filter);
+ FREE(vmixer->sharpness.filter);
+ }
+ pipe_mutex_unlock(vmixer->device->mutex);
+
FREE(vmixer);
return VDP_STATUS_OK;
uint32_t layer_count,
VdpLayer const *layers)
{
- struct pipe_video_rect src_rect, dst_rect, dst_clip;
- unsigned layer = 0;
+ enum vl_compositor_deinterlace deinterlace;
+ struct u_rect rect, clip, *prect;
+ 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 (!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)
+ if (!bg) {
+ pipe_mutex_unlock(vmixer->device->mutex);
return VDP_STATUS_INVALID_HANDLE;
- vl_compositor_set_rgba_layer(&vmixer->compositor, layer++, bg->sampler_view,
- RectToPipe(background_source_rect, &src_rect), NULL);
+ }
+ vl_compositor_set_rgba_layer(&vmixer->cstate, compositor, layer++, bg->sampler_view,
+ RectToPipe(background_source_rect, &rect), NULL, NULL);
}
- vl_compositor_clear_layers(&vmixer->compositor);
- vl_compositor_set_buffer_layer(&vmixer->compositor, layer++, surf->video_buffer,
- RectToPipe(video_source_rect, &src_rect), NULL);
- vl_compositor_render(&vmixer->compositor, dst->surface,
- RectToPipe(destination_video_rect, &dst_rect),
- RectToPipe(destination_rect, &dst_clip),
- &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);
+ 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;
+ };
+ 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, surf->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);
+
+ /* 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;
}
}
/* and create a new filter as needed */
- if (vmixer->noise_reduction. enabled && vmixer->noise_reduction.level > 0.0f) {
+ 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->pipe,
+ vl_median_filter_init(vmixer->noise_reduction.filter, vmixer->device->context,
vmixer->video_width, vmixer->video_height,
- 9 * vmixer->noise_reduction.level,
+ vmixer->noise_reduction.level + 1,
VL_MEDIAN_FILTER_CROSS);
}
}
}
vmixer->sharpness.filter = MALLOC(sizeof(struct vl_matrix_filter));
- vl_matrix_filter_init(vmixer->sharpness.filter,
- vmixer->device->context->pipe,
+ vl_matrix_filter_init(vmixer->sharpness.filter, vmixer->device->context,
vmixer->video_width, vmixer->video_height,
3, 3, matrix);
}
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
+ pipe_mutex_lock(vmixer->device->mutex);
for (i = 0; i < feature_count; ++i) {
switch (features[i]) {
/* they are valid, but we doesn't support them */
break;
default:
+ pipe_mutex_unlock(vmixer->device->mutex);
return VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE;
}
}
+ pipe_mutex_unlock(vmixer->device->mutex);
return VDP_STATUS_OK;
}
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
+ pipe_mutex_lock(vmixer->device->mutex);
for (i = 0; i < attribute_count; ++i) {
switch (attributes[i]) {
case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
color.f[1] = background_color->green;
color.f[2] = background_color->blue;
color.f[3] = background_color->alpha;
- vl_compositor_set_clear_color(&vmixer->compositor, &color);
+ vl_compositor_set_clear_color(&vmixer->cstate, &color);
break;
case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX:
vdp_csc = attribute_values[i];
vmixer->custom_csc = !!vdp_csc;
if (!vdp_csc)
- vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, 1, vmixer->csc);
+ vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, 1, &vmixer->csc);
else
- memcpy(vmixer->csc, vdp_csc, sizeof(float)*12);
+ memcpy(vmixer->csc, vdp_csc, sizeof(vl_csc_matrix));
if (!debug_get_bool_option("G3DVL_NO_CSC", FALSE))
- vl_compositor_set_csc_matrix(&vmixer->compositor, vmixer->csc);
+ vl_compositor_set_csc_matrix(&vmixer->cstate, (const vl_csc_matrix *)&vmixer->csc);
break;
case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL:
if (val < 0.f || val > 1.f)
return VDP_STATUS_INVALID_VALUE;
- vmixer->noise_reduction.level = val;
+ vmixer->noise_reduction.level = val * 10;
vlVdpVideoMixerUpdateNoiseReductionFilter(vmixer);
break;
vmixer->skip_chroma_deint = *(uint8_t*)attribute_values[i];
break;
default:
+ pipe_mutex_unlock(vmixer->device->mutex);
return VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE;
}
}
+ pipe_mutex_unlock(vmixer->device->mutex);
return VDP_STATUS_OK;
}
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
+ pipe_mutex_lock(vmixer->device->mutex);
for (i = 0; i < attribute_count; ++i) {
switch (attributes[i]) {
case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
- vl_compositor_get_clear_color(&vmixer->compositor, attribute_values[i]);
+ vl_compositor_get_clear_color(&vmixer->cstate, attribute_values[i]);
break;
case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX:
vdp_csc = attribute_values[i];
break;
case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL:
- *(float*)attribute_values[i] = vmixer->noise_reduction.level;
+ *(float*)attribute_values[i] = (float)vmixer->noise_reduction.level / 10.0f;
break;
case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA:
*(uint8_t*)attribute_values[i] = vmixer->skip_chroma_deint;
break;
default:
+ pipe_mutex_unlock(vmixer->device->mutex);
return VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE;
}
}
+ pipe_mutex_unlock(vmixer->device->mutex);
return VDP_STATUS_OK;
}
VdpColorStandard standard,
VdpCSCMatrix *csc_matrix)
{
- float matrix[16];
enum VL_CSC_COLOR_STANDARD vl_std;
struct vl_procamp camp;
camp.contrast = procamp->contrast;
camp.saturation = procamp->saturation;
camp.hue = procamp->hue;
- vl_csc_get_matrix(vl_std, &camp, 1, matrix);
- memcpy(csc_matrix, matrix, sizeof(float)*12);
+ vl_csc_get_matrix(vl_std, &camp, true, csc_matrix);
return VDP_STATUS_OK;
}
projects / mesa.git / blobdiff