src/gallium/state_trackers/vdpau/mixer.c

   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
  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
 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  */
 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 = &rect;
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 }