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