1 /**************************************************************************
2 *
3 * Copyright 2010 Thomas Balling Sørensen.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 #include <vdpau/vdpau.h>
29
30 #include "util/u_memory.h"
31 #include "util/u_debug.h"
32
33 #include "vl/vl_csc.h"
34
35 #include "vdpau_private.h"
36
37 /**
38 * Create a VdpVideoMixer.
39 */
40 VdpStatus
vlVdpVideoMixerCreate(VdpDevice device,uint32_t feature_count,VdpVideoMixerFeature const * features,uint32_t parameter_count,VdpVideoMixerParameter const * parameters,void const * const * parameter_values,VdpVideoMixer * mixer)41 vlVdpVideoMixerCreate(VdpDevice device,
42 uint32_t feature_count,
43 VdpVideoMixerFeature const *features,
44 uint32_t parameter_count,
45 VdpVideoMixerParameter const *parameters,
46 void const *const *parameter_values,
47 VdpVideoMixer *mixer)
48 {
49 vlVdpVideoMixer *vmixer = NULL;
50 VdpStatus ret;
51 struct pipe_screen *screen;
52 unsigned max_width, max_height, i;
53 enum pipe_video_profile prof = PIPE_VIDEO_PROFILE_UNKNOWN;
54
55 vlVdpDevice *dev = vlGetDataHTAB(device);
56 if (!dev)
57 return VDP_STATUS_INVALID_HANDLE;
58 screen = dev->vscreen->pscreen;
59
60 vmixer = CALLOC(1, sizeof(vlVdpVideoMixer));
61 if (!vmixer)
62 return VDP_STATUS_RESOURCES;
63
64 vmixer->device = dev;
65
66 pipe_mutex_lock(dev->mutex);
67
68 vl_compositor_init_state(&vmixer->cstate, dev->context);
69
70 vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, true, &vmixer->csc);
71 if (!debug_get_bool_option("G3DVL_NO_CSC", FALSE))
72 vl_compositor_set_csc_matrix(&vmixer->cstate, (const vl_csc_matrix *)&vmixer->csc);
73
74 *mixer = vlAddDataHTAB(vmixer);
75 if (*mixer == 0) {
76 ret = VDP_STATUS_ERROR;
77 goto no_handle;
78 }
79
80 ret = VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE;
81 for (i = 0; i < feature_count; ++i) {
82 switch (features[i]) {
83 /* they are valid, but we doesn't support them */
84 case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL:
85 case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL:
86 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1:
87 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2:
88 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3:
89 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4:
90 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5:
91 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6:
92 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7:
93 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8:
94 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9:
95 case VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE:
96 case VDP_VIDEO_MIXER_FEATURE_LUMA_KEY:
97 break;
98
99 case VDP_VIDEO_MIXER_FEATURE_SHARPNESS:
100 vmixer->sharpness.supported = true;
101 break;
102
103 case VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION:
104 vmixer->noise_reduction.supported = true;
105 break;
106
107 default: goto no_params;
108 }
109 }
110
111 vmixer->chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
112 ret = VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER;
113 for (i = 0; i < parameter_count; ++i) {
114 switch (parameters[i]) {
115 case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH:
116 vmixer->video_width = *(uint32_t*)parameter_values[i];
117 break;
118 case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT:
119 vmixer->video_height = *(uint32_t*)parameter_values[i];
120 break;
121 case VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE:
122 vmixer->chroma_format = ChromaToPipe(*(VdpChromaType*)parameter_values[i]);
123 break;
124 case VDP_VIDEO_MIXER_PARAMETER_LAYERS:
125 vmixer->max_layers = *(uint32_t*)parameter_values[i];
126 break;
127 default: goto no_params;
128 }
129 }
130 ret = VDP_STATUS_INVALID_VALUE;
131 if (vmixer->max_layers > 4) {
132 VDPAU_MSG(VDPAU_WARN, "[VDPAU] Max layers > 4 not supported\n", vmixer->max_layers);
133 goto no_params;
134 }
135 max_width = screen->get_video_param(screen, prof, PIPE_VIDEO_CAP_MAX_WIDTH);
136 max_height = screen->get_video_param(screen, prof, PIPE_VIDEO_CAP_MAX_HEIGHT);
137 if (vmixer->video_width < 48 ||
138 vmixer->video_width > max_width) {
139 VDPAU_MSG(VDPAU_WARN, "[VDPAU] 48 < %u < %u not valid for width\n", vmixer->video_width, max_width);
140 goto no_params;
141 }
142 if (vmixer->video_height < 48 ||
143 vmixer->video_height > max_height) {
144 VDPAU_MSG(VDPAU_WARN, "[VDPAU] 48 < %u < %u not valid for height\n", vmixer->video_height, max_height);
145 goto no_params;
146 }
147 vmixer->luma_key_min = 0.f;
148 vmixer->luma_key_max = 1.f;
149 pipe_mutex_unlock(dev->mutex);
150
151 return VDP_STATUS_OK;
152
153 no_params:
154 vlRemoveDataHTAB(*mixer);
155
156 no_handle:
157 vl_compositor_cleanup_state(&vmixer->cstate);
158 pipe_mutex_unlock(dev->mutex);
159 FREE(vmixer);
160 return ret;
161 }
162
163 /**
164 * Destroy a VdpVideoMixer.
165 */
166 VdpStatus
vlVdpVideoMixerDestroy(VdpVideoMixer mixer)167 vlVdpVideoMixerDestroy(VdpVideoMixer mixer)
168 {
169 vlVdpVideoMixer *vmixer;
170
171 vmixer = vlGetDataHTAB(mixer);
172 if (!vmixer)
173 return VDP_STATUS_INVALID_HANDLE;
174
175 pipe_mutex_lock(vmixer->device->mutex);
176
177 vlVdpResolveDelayedRendering(vmixer->device, NULL, NULL);
178
179 vlRemoveDataHTAB(mixer);
180
181 vl_compositor_cleanup_state(&vmixer->cstate);
182
183 if (vmixer->noise_reduction.filter) {
184 vl_median_filter_cleanup(vmixer->noise_reduction.filter);
185 FREE(vmixer->noise_reduction.filter);
186 }
187
188 if (vmixer->sharpness.filter) {
189 vl_matrix_filter_cleanup(vmixer->sharpness.filter);
190 FREE(vmixer->sharpness.filter);
191 }
192 pipe_mutex_unlock(vmixer->device->mutex);
193
194 FREE(vmixer);
195
196 return VDP_STATUS_OK;
197 }
198
199 /**
200 * Perform a video post-processing and compositing operation.
201 */
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)202 VdpStatus vlVdpVideoMixerRender(VdpVideoMixer mixer,
203 VdpOutputSurface background_surface,
204 VdpRect const *background_source_rect,
205 VdpVideoMixerPictureStructure current_picture_structure,
206 uint32_t video_surface_past_count,
207 VdpVideoSurface const *video_surface_past,
208 VdpVideoSurface video_surface_current,
209 uint32_t video_surface_future_count,
210 VdpVideoSurface const *video_surface_future,
211 VdpRect const *video_source_rect,
212 VdpOutputSurface destination_surface,
213 VdpRect const *destination_rect,
214 VdpRect const *destination_video_rect,
215 uint32_t layer_count,
216 VdpLayer const *layers)
217 {
218 enum vl_compositor_deinterlace deinterlace;
219 struct u_rect rect, clip, *prect;
220 unsigned i, layer = 0;
221
222 vlVdpVideoMixer *vmixer;
223 vlVdpSurface *surf;
224 vlVdpOutputSurface *dst;
225
226 struct vl_compositor *compositor;
227
228 vmixer = vlGetDataHTAB(mixer);
229 if (!vmixer)
230 return VDP_STATUS_INVALID_HANDLE;
231
232 compositor = &vmixer->device->compositor;
233
234 surf = vlGetDataHTAB(video_surface_current);
235 if (!surf)
236 return VDP_STATUS_INVALID_HANDLE;
237
238 if (surf->device != vmixer->device)
239 return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
240
241 if (vmixer->video_width > surf->video_buffer->width ||
242 vmixer->video_height > surf->video_buffer->height ||
243 vmixer->chroma_format != surf->video_buffer->chroma_format)
244 return VDP_STATUS_INVALID_SIZE;
245
246 if (layer_count > vmixer->max_layers)
247 return VDP_STATUS_INVALID_VALUE;
248
249 dst = vlGetDataHTAB(destination_surface);
250 if (!dst)
251 return VDP_STATUS_INVALID_HANDLE;
252
253 pipe_mutex_lock(vmixer->device->mutex);
254 vlVdpResolveDelayedRendering(vmixer->device, NULL, NULL);
255 if (background_surface != VDP_INVALID_HANDLE) {
256 vlVdpOutputSurface *bg = vlGetDataHTAB(background_surface);
257 if (!bg) {
258 pipe_mutex_unlock(vmixer->device->mutex);
259 return VDP_STATUS_INVALID_HANDLE;
260 }
261 vl_compositor_set_rgba_layer(&vmixer->cstate, compositor, layer++, bg->sampler_view,
262 RectToPipe(background_source_rect, &rect), NULL, NULL);
263 }
264
265 vl_compositor_clear_layers(&vmixer->cstate);
266
267 switch (current_picture_structure) {
268 case VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD:
269 deinterlace = VL_COMPOSITOR_BOB_TOP;
270 break;
271
272 case VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD:
273 deinterlace = VL_COMPOSITOR_BOB_BOTTOM;
274 break;
275
276 case VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME:
277 deinterlace = VL_COMPOSITOR_WEAVE;
278 break;
279
280 default:
281 pipe_mutex_unlock(vmixer->device->mutex);
282 return VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE;
283 };
284 prect = RectToPipe(video_source_rect, &rect);
285 if (!prect) {
286 rect.x0 = 0;
287 rect.y0 = 0;
288 rect.x1 = surf->templat.width;
289 rect.y1 = surf->templat.height;
290 prect = ▭
291 }
292 vl_compositor_set_buffer_layer(&vmixer->cstate, compositor, layer, surf->video_buffer, prect, NULL, deinterlace);
293 vl_compositor_set_layer_dst_area(&vmixer->cstate, layer++, RectToPipe(destination_video_rect, &rect));
294
295 for (i = 0; i < layer_count; ++i) {
296 vlVdpOutputSurface *src = vlGetDataHTAB(layers->source_surface);
297 if (!src) {
298 pipe_mutex_unlock(vmixer->device->mutex);
299 return VDP_STATUS_INVALID_HANDLE;
300 }
301
302 assert(layers->struct_version == VDP_LAYER_VERSION);
303
304 vl_compositor_set_rgba_layer(&vmixer->cstate, compositor, layer, src->sampler_view,
305 RectToPipe(layers->source_rect, &rect), NULL, NULL);
306 vl_compositor_set_layer_dst_area(&vmixer->cstate, layer++, RectToPipe(layers->destination_rect, &rect));
307
308 ++layers;
309 }
310
311 vl_compositor_set_dst_clip(&vmixer->cstate, RectToPipe(destination_rect, &clip));
312 if (!vmixer->noise_reduction.filter && !vmixer->sharpness.filter)
313 vlVdpSave4DelayedRendering(vmixer->device, destination_surface, &vmixer->cstate);
314 else {
315 vl_compositor_render(&vmixer->cstate, compositor, dst->surface, &dst->dirty_area);
316
317 /* applying the noise reduction after scaling is actually not very
318 clever, but currently we should avoid to copy around the image
319 data once more. */
320 if (vmixer->noise_reduction.filter)
321 vl_median_filter_render(vmixer->noise_reduction.filter,
322 dst->sampler_view, dst->surface);
323
324 if (vmixer->sharpness.filter)
325 vl_matrix_filter_render(vmixer->sharpness.filter,
326 dst->sampler_view, dst->surface);
327 }
328 pipe_mutex_unlock(vmixer->device->mutex);
329
330 return VDP_STATUS_OK;
331 }
332
333 /**
334 * Update the noise reduction setting
335 */
336 static void
vlVdpVideoMixerUpdateNoiseReductionFilter(vlVdpVideoMixer * vmixer)337 vlVdpVideoMixerUpdateNoiseReductionFilter(vlVdpVideoMixer *vmixer)
338 {
339 assert(vmixer);
340
341 /* if present remove the old filter first */
342 if (vmixer->noise_reduction.filter) {
343 vl_median_filter_cleanup(vmixer->noise_reduction.filter);
344 FREE(vmixer->noise_reduction.filter);
345 vmixer->noise_reduction.filter = NULL;
346 }
347
348 /* and create a new filter as needed */
349 if (vmixer->noise_reduction. enabled && vmixer->noise_reduction.level > 0) {
350 vmixer->noise_reduction.filter = MALLOC(sizeof(struct vl_median_filter));
351 vl_median_filter_init(vmixer->noise_reduction.filter, vmixer->device->context,
352 vmixer->video_width, vmixer->video_height,
353 vmixer->noise_reduction.level + 1,
354 VL_MEDIAN_FILTER_CROSS);
355 }
356 }
357
358 static void
vlVdpVideoMixerUpdateSharpnessFilter(vlVdpVideoMixer * vmixer)359 vlVdpVideoMixerUpdateSharpnessFilter(vlVdpVideoMixer *vmixer)
360 {
361 assert(vmixer);
362
363 /* if present remove the old filter first */
364 if (vmixer->sharpness.filter) {
365 vl_matrix_filter_cleanup(vmixer->sharpness.filter);
366 FREE(vmixer->sharpness.filter);
367 vmixer->sharpness.filter = NULL;
368 }
369
370 /* and create a new filter as needed */
371 if (vmixer->sharpness.enabled && vmixer->sharpness.value != 0.0f) {
372 float matrix[9];
373 unsigned i;
374
375 if (vmixer->sharpness.value > 0.0f) {
376 matrix[0] = -1.0f; matrix[1] = -1.0f; matrix[2] = -1.0f;
377 matrix[3] = -1.0f; matrix[4] = 8.0f; matrix[5] = -1.0f;
378 matrix[6] = -1.0f; matrix[7] = -1.0f; matrix[8] = -1.0f;
379
380 for (i = 0; i < 9; ++i)
381 matrix[i] *= vmixer->sharpness.value;
382
383 matrix[4] += 1.0f;
384
385 } else {
386 matrix[0] = 1.0f; matrix[1] = 2.0f; matrix[2] = 1.0f;
387 matrix[3] = 2.0f; matrix[4] = 4.0f; matrix[5] = 2.0f;
388 matrix[6] = 1.0f; matrix[7] = 2.0f; matrix[8] = 1.0f;
389
390 for (i = 0; i < 9; ++i)
391 matrix[i] *= fabsf(vmixer->sharpness.value) / 16.0f;
392
393 matrix[4] += 1.0f - fabsf(vmixer->sharpness.value);
394 }
395
396 vmixer->sharpness.filter = MALLOC(sizeof(struct vl_matrix_filter));
397 vl_matrix_filter_init(vmixer->sharpness.filter, vmixer->device->context,
398 vmixer->video_width, vmixer->video_height,
399 3, 3, matrix);
400 }
401 }
402
403 /**
404 * Retrieve whether features were requested at creation time.
405 */
406 VdpStatus
vlVdpVideoMixerGetFeatureSupport(VdpVideoMixer mixer,uint32_t feature_count,VdpVideoMixerFeature const * features,VdpBool * feature_supports)407 vlVdpVideoMixerGetFeatureSupport(VdpVideoMixer mixer,
408 uint32_t feature_count,
409 VdpVideoMixerFeature const *features,
410 VdpBool *feature_supports)
411 {
412 vlVdpVideoMixer *vmixer;
413 unsigned i;
414
415 if (!(features && feature_supports))
416 return VDP_STATUS_INVALID_POINTER;
417
418 vmixer = vlGetDataHTAB(mixer);
419 if (!vmixer)
420 return VDP_STATUS_INVALID_HANDLE;
421
422 for (i = 0; i < feature_count; ++i) {
423 switch (features[i]) {
424 /* they are valid, but we doesn't support them */
425 case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL:
426 case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL:
427 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1:
428 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2:
429 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3:
430 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4:
431 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5:
432 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6:
433 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7:
434 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8:
435 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9:
436 case VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE:
437 case VDP_VIDEO_MIXER_FEATURE_LUMA_KEY:
438 feature_supports[i] = false;
439 break;
440
441 case VDP_VIDEO_MIXER_FEATURE_SHARPNESS:
442 feature_supports[i] = vmixer->sharpness.supported;
443 break;
444
445 case VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION:
446 feature_supports[i] = vmixer->noise_reduction.supported;
447 break;
448
449 default:
450 return VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE;
451 }
452 }
453
454 return VDP_STATUS_OK;
455 }
456
457 /**
458 * Enable or disable features.
459 */
460 VdpStatus
vlVdpVideoMixerSetFeatureEnables(VdpVideoMixer mixer,uint32_t feature_count,VdpVideoMixerFeature const * features,VdpBool const * feature_enables)461 vlVdpVideoMixerSetFeatureEnables(VdpVideoMixer mixer,
462 uint32_t feature_count,
463 VdpVideoMixerFeature const *features,
464 VdpBool const *feature_enables)
465 {
466 vlVdpVideoMixer *vmixer;
467 unsigned i;
468
469 if (!(features && feature_enables))
470 return VDP_STATUS_INVALID_POINTER;
471
472 vmixer = vlGetDataHTAB(mixer);
473 if (!vmixer)
474 return VDP_STATUS_INVALID_HANDLE;
475
476 pipe_mutex_lock(vmixer->device->mutex);
477 for (i = 0; i < feature_count; ++i) {
478 switch (features[i]) {
479 /* they are valid, but we doesn't support them */
480 case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL:
481 case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL:
482 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1:
483 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2:
484 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3:
485 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4:
486 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5:
487 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6:
488 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7:
489 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8:
490 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9:
491 case VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE:
492 case VDP_VIDEO_MIXER_FEATURE_LUMA_KEY:
493 break;
494
495 case VDP_VIDEO_MIXER_FEATURE_SHARPNESS:
496 vmixer->sharpness.enabled = feature_enables[i];
497 vlVdpVideoMixerUpdateSharpnessFilter(vmixer);
498 break;
499
500 case VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION:
501 vmixer->noise_reduction.enabled = feature_enables[i];
502 vlVdpVideoMixerUpdateNoiseReductionFilter(vmixer);
503 break;
504
505 default:
506 pipe_mutex_unlock(vmixer->device->mutex);
507 return VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE;
508 }
509 }
510 pipe_mutex_unlock(vmixer->device->mutex);
511
512 return VDP_STATUS_OK;
513 }
514
515 /**
516 * Retrieve whether features are enabled.
517 */
518 VdpStatus
vlVdpVideoMixerGetFeatureEnables(VdpVideoMixer mixer,uint32_t feature_count,VdpVideoMixerFeature const * features,VdpBool * feature_enables)519 vlVdpVideoMixerGetFeatureEnables(VdpVideoMixer mixer,
520 uint32_t feature_count,
521 VdpVideoMixerFeature const *features,
522 VdpBool *feature_enables)
523 {
524 vlVdpVideoMixer *vmixer;
525 unsigned i;
526
527 if (!(features && feature_enables))
528 return VDP_STATUS_INVALID_POINTER;
529
530 vmixer = vlGetDataHTAB(mixer);
531 if (!vmixer)
532 return VDP_STATUS_INVALID_HANDLE;
533
534 for (i = 0; i < feature_count; ++i) {
535 switch (features[i]) {
536 /* they are valid, but we doesn't support them */
537 case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL:
538 case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL:
539 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1:
540 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2:
541 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3:
542 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4:
543 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5:
544 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6:
545 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7:
546 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8:
547 case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9:
548 case VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE:
549 case VDP_VIDEO_MIXER_FEATURE_LUMA_KEY:
550 break;
551
552 case VDP_VIDEO_MIXER_FEATURE_SHARPNESS:
553 feature_enables[i] = vmixer->sharpness.enabled;
554 break;
555
556 case VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION:
557 feature_enables[i] = vmixer->noise_reduction.enabled;
558 break;
559
560 default:
561 return VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE;
562 }
563 }
564
565 return VDP_STATUS_OK;
566 }
567
568 /**
569 * Set attribute values.
570 */
571 VdpStatus
vlVdpVideoMixerSetAttributeValues(VdpVideoMixer mixer,uint32_t attribute_count,VdpVideoMixerAttribute const * attributes,void const * const * attribute_values)572 vlVdpVideoMixerSetAttributeValues(VdpVideoMixer mixer,
573 uint32_t attribute_count,
574 VdpVideoMixerAttribute const *attributes,
575 void const *const *attribute_values)
576 {
577 const VdpColor *background_color;
578 union pipe_color_union color;
579 const float *vdp_csc;
580 float val;
581 unsigned i;
582
583 if (!(attributes && attribute_values))
584 return VDP_STATUS_INVALID_POINTER;
585
586 vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
587 if (!vmixer)
588 return VDP_STATUS_INVALID_HANDLE;
589
590 pipe_mutex_lock(vmixer->device->mutex);
591 for (i = 0; i < attribute_count; ++i) {
592 switch (attributes[i]) {
593 case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
594 background_color = attribute_values[i];
595 color.f[0] = background_color->red;
596 color.f[1] = background_color->green;
597 color.f[2] = background_color->blue;
598 color.f[3] = background_color->alpha;
599 vl_compositor_set_clear_color(&vmixer->cstate, &color);
600 break;
601 case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX:
602 vdp_csc = attribute_values[i];
603 vmixer->custom_csc = !!vdp_csc;
604 if (!vdp_csc)
605 vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, 1, &vmixer->csc);
606 else
607 memcpy(vmixer->csc, vdp_csc, sizeof(vl_csc_matrix));
608 if (!debug_get_bool_option("G3DVL_NO_CSC", FALSE))
609 vl_compositor_set_csc_matrix(&vmixer->cstate, (const vl_csc_matrix *)&vmixer->csc);
610 break;
611
612 case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL:
613
614 val = *(float*)attribute_values[i];
615 if (val < 0.f || val > 1.f)
616 return VDP_STATUS_INVALID_VALUE;
617
618 vmixer->noise_reduction.level = val * 10;
619 vlVdpVideoMixerUpdateNoiseReductionFilter(vmixer);
620 break;
621
622 case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA:
623 val = *(float*)attribute_values[i];
624 if (val < 0.f || val > 1.f)
625 return VDP_STATUS_INVALID_VALUE;
626 vmixer->luma_key_min = val;
627 break;
628 case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA:
629 val = *(float*)attribute_values[i];
630 if (val < 0.f || val > 1.f)
631 return VDP_STATUS_INVALID_VALUE;
632 vmixer->luma_key_max = val;
633 break;
634
635 case VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL:
636
637 val = *(float*)attribute_values[i];
638 if (val < -1.f || val > 1.f)
639 return VDP_STATUS_INVALID_VALUE;
640
641 vmixer->sharpness.value = val;
642 vlVdpVideoMixerUpdateSharpnessFilter(vmixer);
643 break;
644
645 case VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE:
646 if (*(uint8_t*)attribute_values[i] > 1)
647 return VDP_STATUS_INVALID_VALUE;
648 vmixer->skip_chroma_deint = *(uint8_t*)attribute_values[i];
649 break;
650 default:
651 pipe_mutex_unlock(vmixer->device->mutex);
652 return VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE;
653 }
654 }
655 pipe_mutex_unlock(vmixer->device->mutex);
656
657 return VDP_STATUS_OK;
658 }
659
660 /**
661 * Retrieve parameter values given at creation time.
662 */
663 VdpStatus
vlVdpVideoMixerGetParameterValues(VdpVideoMixer mixer,uint32_t parameter_count,VdpVideoMixerParameter const * parameters,void * const * parameter_values)664 vlVdpVideoMixerGetParameterValues(VdpVideoMixer mixer,
665 uint32_t parameter_count,
666 VdpVideoMixerParameter const *parameters,
667 void *const *parameter_values)
668 {
669 vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
670 unsigned i;
671 if (!vmixer)
672 return VDP_STATUS_INVALID_HANDLE;
673
674 if (!parameter_count)
675 return VDP_STATUS_OK;
676 if (!(parameters && parameter_values))
677 return VDP_STATUS_INVALID_POINTER;
678 for (i = 0; i < parameter_count; ++i) {
679 switch (parameters[i]) {
680 case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH:
681 *(uint32_t*)parameter_values[i] = vmixer->video_width;
682 break;
683 case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT:
684 *(uint32_t*)parameter_values[i] = vmixer->video_height;
685 break;
686 case VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE:
687 *(VdpChromaType*)parameter_values[i] = PipeToChroma(vmixer->chroma_format);
688 break;
689 case VDP_VIDEO_MIXER_PARAMETER_LAYERS:
690 *(uint32_t*)parameter_values[i] = vmixer->max_layers;
691 break;
692 default:
693 return VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER;
694 }
695 }
696 return VDP_STATUS_OK;
697 }
698
699 /**
700 * Retrieve current attribute values.
701 */
702 VdpStatus
vlVdpVideoMixerGetAttributeValues(VdpVideoMixer mixer,uint32_t attribute_count,VdpVideoMixerAttribute const * attributes,void * const * attribute_values)703 vlVdpVideoMixerGetAttributeValues(VdpVideoMixer mixer,
704 uint32_t attribute_count,
705 VdpVideoMixerAttribute const *attributes,
706 void *const *attribute_values)
707 {
708 unsigned i;
709 VdpCSCMatrix **vdp_csc;
710
711 if (!(attributes && attribute_values))
712 return VDP_STATUS_INVALID_POINTER;
713
714 vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
715 if (!vmixer)
716 return VDP_STATUS_INVALID_HANDLE;
717
718 pipe_mutex_lock(vmixer->device->mutex);
719 for (i = 0; i < attribute_count; ++i) {
720 switch (attributes[i]) {
721 case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
722 vl_compositor_get_clear_color(&vmixer->cstate, attribute_values[i]);
723 break;
724 case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX:
725 vdp_csc = attribute_values[i];
726 if (!vmixer->custom_csc) {
727 *vdp_csc = NULL;
728 break;
729 }
730 memcpy(*vdp_csc, vmixer->csc, sizeof(float)*12);
731 break;
732
733 case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL:
734 *(float*)attribute_values[i] = (float)vmixer->noise_reduction.level / 10.0f;
735 break;
736
737 case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA:
738 *(float*)attribute_values[i] = vmixer->luma_key_min;
739 break;
740 case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA:
741 *(float*)attribute_values[i] = vmixer->luma_key_max;
742 break;
743 case VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL:
744 *(float*)attribute_values[i] = vmixer->sharpness.value;
745 break;
746 case VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE:
747 *(uint8_t*)attribute_values[i] = vmixer->skip_chroma_deint;
748 break;
749 default:
750 pipe_mutex_unlock(vmixer->device->mutex);
751 return VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE;
752 }
753 }
754 pipe_mutex_unlock(vmixer->device->mutex);
755 return VDP_STATUS_OK;
756 }
757
758 /**
759 * Generate a color space conversion matrix.
760 */
761 VdpStatus
vlVdpGenerateCSCMatrix(VdpProcamp * procamp,VdpColorStandard standard,VdpCSCMatrix * csc_matrix)762 vlVdpGenerateCSCMatrix(VdpProcamp *procamp,
763 VdpColorStandard standard,
764 VdpCSCMatrix *csc_matrix)
765 {
766 enum VL_CSC_COLOR_STANDARD vl_std;
767 struct vl_procamp camp;
768
769 if (!(csc_matrix && procamp))
770 return VDP_STATUS_INVALID_POINTER;
771
772 if (procamp->struct_version > VDP_PROCAMP_VERSION)
773 return VDP_STATUS_INVALID_STRUCT_VERSION;
774
775 switch (standard) {
776 case VDP_COLOR_STANDARD_ITUR_BT_601: vl_std = VL_CSC_COLOR_STANDARD_BT_601; break;
777 case VDP_COLOR_STANDARD_ITUR_BT_709: vl_std = VL_CSC_COLOR_STANDARD_BT_709; break;
778 case VDP_COLOR_STANDARD_SMPTE_240M: vl_std = VL_CSC_COLOR_STANDARD_SMPTE_240M; break;
779 default: return VDP_STATUS_INVALID_COLOR_STANDARD;
780 }
781 camp.brightness = procamp->brightness;
782 camp.contrast = procamp->contrast;
783 camp.saturation = procamp->saturation;
784 camp.hue = procamp->hue;
785 vl_csc_get_matrix(vl_std, &camp, true, csc_matrix);
786 return VDP_STATUS_OK;
787 }
788