mixer.c revision 0f269c5e7b593eb29d5c1058dcd53fc6476871a9
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 */ 40VdpStatus 41vlVdpVideoMixerCreate(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 153no_params: 154 vlRemoveDataHTAB(*mixer); 155 156no_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 */ 166VdpStatus 167vlVdpVideoMixerDestroy(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 */ 202VdpStatus 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 */ 336static void 337vlVdpVideoMixerUpdateNoiseReductionFilter(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 358static void 359vlVdpVideoMixerUpdateSharpnessFilter(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 */ 406VdpStatus 407vlVdpVideoMixerGetFeatureSupport(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 */ 460VdpStatus 461vlVdpVideoMixerSetFeatureEnables(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 */ 518VdpStatus 519vlVdpVideoMixerGetFeatureEnables(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 */ 571VdpStatus 572vlVdpVideoMixerSetAttributeValues(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 */ 663VdpStatus 664vlVdpVideoMixerGetParameterValues(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 */ 702VdpStatus 703vlVdpVideoMixerGetAttributeValues(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 */ 761VdpStatus 762vlVdpGenerateCSCMatrix(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