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;
 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    vl_compositor_set_buffer_layer(&vmixer->cstate, compositor, layer, surf->video_buffer,
 285                                   RectToPipe(video_source_rect, &rect), NULL, deinterlace);
 286    vl_compositor_set_layer_dst_area(&vmixer->cstate, layer++, RectToPipe(destination_video_rect, &rect));
 287
 288    for (i = 0; i < layer_count; ++i) {
 289       vlVdpOutputSurface *src = vlGetDataHTAB(layers->source_surface);
 290       if (!src) {
 291          pipe_mutex_unlock(vmixer->device->mutex);
 292          return VDP_STATUS_INVALID_HANDLE;
 293       }
 294
 295       assert(layers->struct_version == VDP_LAYER_VERSION);
 296
 297       vl_compositor_set_rgba_layer(&vmixer->cstate, compositor, layer, src->sampler_view,
 298                                    RectToPipe(layers->source_rect, &rect), NULL, NULL);
 299       vl_compositor_set_layer_dst_area(&vmixer->cstate, layer++, RectToPipe(layers->destination_rect, &rect));
 300
 301       ++layers;
 302    }
 303
 304    vl_compositor_set_dst_clip(&vmixer->cstate, RectToPipe(destination_rect, &clip));
 305    if (!vmixer->noise_reduction.filter && !vmixer->sharpness.filter)
 306       vlVdpSave4DelayedRendering(vmixer->device, destination_surface, &vmixer->cstate);
 307    else {
 308       vl_compositor_render(&vmixer->cstate, compositor, dst->surface, &dst->dirty_area);
 309
 310       /* applying the noise reduction after scaling is actually not very
 311          clever, but currently we should avoid to copy around the image
 312          data once more. */
 313       if (vmixer->noise_reduction.filter)
 314          vl_median_filter_render(vmixer->noise_reduction.filter,
 315                                  dst->sampler_view, dst->surface);
 316
 317       if (vmixer->sharpness.filter)
 318          vl_matrix_filter_render(vmixer->sharpness.filter,
 319                                  dst->sampler_view, dst->surface);
 320    }
 321    pipe_mutex_unlock(vmixer->device->mutex);
 322
 323    return VDP_STATUS_OK;
 324 }
 325
 326 /**
 327  * Update the noise reduction setting
 328  */
 329 static void
 330 vlVdpVideoMixerUpdateNoiseReductionFilter(vlVdpVideoMixer *vmixer)
 331 {
 332    assert(vmixer);
 333
 334    /* if present remove the old filter first */
 335    if (vmixer->noise_reduction.filter) {
 336       vl_median_filter_cleanup(vmixer->noise_reduction.filter);
 337       FREE(vmixer->noise_reduction.filter);
 338       vmixer->noise_reduction.filter = NULL;
 339    }
 340
 341    /* and create a new filter as needed */
 342    if (vmixer->noise_reduction. enabled && vmixer->noise_reduction.level > 0) {
 343       vmixer->noise_reduction.filter = MALLOC(sizeof(struct vl_median_filter));
 344       vl_median_filter_init(vmixer->noise_reduction.filter, vmixer->device->context,
 345                             vmixer->video_width, vmixer->video_height,
 346                             vmixer->noise_reduction.level + 1,
 347                             VL_MEDIAN_FILTER_CROSS);
 348    }
 349 }
 350
 351 static void
 352 vlVdpVideoMixerUpdateSharpnessFilter(vlVdpVideoMixer *vmixer)
 353 {
 354    assert(vmixer);
 355
 356    /* if present remove the old filter first */
 357    if (vmixer->sharpness.filter) {
 358       vl_matrix_filter_cleanup(vmixer->sharpness.filter);
 359       FREE(vmixer->sharpness.filter);
 360       vmixer->sharpness.filter = NULL;
 361    }
 362
 363    /* and create a new filter as needed */
 364    if (vmixer->sharpness.enabled && vmixer->sharpness.value != 0.0f) {
 365       float matrix[9];
 366       unsigned i;
 367
 368       if (vmixer->sharpness.value > 0.0f) {
 369          matrix[0] = -1.0f; matrix[1] = -1.0f; matrix[2] = -1.0f;
 370          matrix[3] = -1.0f; matrix[4] =  8.0f; matrix[5] = -1.0f;
 371          matrix[6] = -1.0f; matrix[7] = -1.0f; matrix[8] = -1.0f;
 372
 373          for (i = 0; i < 9; ++i)
 374             matrix[i] *= vmixer->sharpness.value;
 375
 376          matrix[4] += 1.0f;
 377
 378       } else {
 379          matrix[0] = 1.0f; matrix[1] = 2.0f; matrix[2] = 1.0f;
 380          matrix[3] = 2.0f; matrix[4] = 4.0f; matrix[5] = 2.0f;
 381          matrix[6] = 1.0f; matrix[7] = 2.0f; matrix[8] = 1.0f;
 382
 383          for (i = 0; i < 9; ++i)
 384                matrix[i] *= fabsf(vmixer->sharpness.value) / 16.0f;
 385
 386          matrix[4] += 1.0f - fabsf(vmixer->sharpness.value);
 387       }
 388
 389       vmixer->sharpness.filter = MALLOC(sizeof(struct vl_matrix_filter));
 390       vl_matrix_filter_init(vmixer->sharpness.filter, vmixer->device->context,
 391                             vmixer->video_width, vmixer->video_height,
 392                             3, 3, matrix);
 393    }
 394 }
 395
 396 /**
 397  * Retrieve whether features were requested at creation time.
 398  */
 399 VdpStatus
 400 vlVdpVideoMixerGetFeatureSupport(VdpVideoMixer mixer,
 401                                  uint32_t feature_count,
 402                                  VdpVideoMixerFeature const *features,
 403                                  VdpBool *feature_supports)
 404 {
 405    vlVdpVideoMixer *vmixer;
 406    unsigned i;
 407
 408    if (!(features && feature_supports))
 409       return VDP_STATUS_INVALID_POINTER;
 410
 411    vmixer = vlGetDataHTAB(mixer);
 412    if (!vmixer)
 413       return VDP_STATUS_INVALID_HANDLE;
 414
 415    for (i = 0; i < feature_count; ++i) {
 416       switch (features[i]) {
 417       /* they are valid, but we doesn't support them */
 418       case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL:
 419       case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL:
 420       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1:
 421       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2:
 422       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3:
 423       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4:
 424       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5:
 425       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6:
 426       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7:
 427       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8:
 428       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9:
 429       case VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE:
 430       case VDP_VIDEO_MIXER_FEATURE_LUMA_KEY:
 431          feature_supports[i] = false;
 432          break;
 433
 434       case VDP_VIDEO_MIXER_FEATURE_SHARPNESS:
 435          feature_supports[i] = vmixer->sharpness.supported;
 436          break;
 437
 438       case VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION:
 439          feature_supports[i] = vmixer->noise_reduction.supported;
 440          break;
 441
 442       default:
 443          return VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE;
 444       }
 445    }
 446
 447    return VDP_STATUS_OK;
 448 }
 449
 450 /**
 451  * Enable or disable features.
 452  */
 453 VdpStatus
 454 vlVdpVideoMixerSetFeatureEnables(VdpVideoMixer mixer,
 455                                  uint32_t feature_count,
 456                                  VdpVideoMixerFeature const *features,
 457                                  VdpBool const *feature_enables)
 458 {
 459    vlVdpVideoMixer *vmixer;
 460    unsigned i;
 461
 462    if (!(features && feature_enables))
 463       return VDP_STATUS_INVALID_POINTER;
 464
 465    vmixer = vlGetDataHTAB(mixer);
 466    if (!vmixer)
 467       return VDP_STATUS_INVALID_HANDLE;
 468
 469    pipe_mutex_lock(vmixer->device->mutex);
 470    for (i = 0; i < feature_count; ++i) {
 471       switch (features[i]) {
 472       /* they are valid, but we doesn't support them */
 473       case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL:
 474       case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL:
 475       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1:
 476       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2:
 477       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3:
 478       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4:
 479       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5:
 480       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6:
 481       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7:
 482       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8:
 483       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9:
 484       case VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE:
 485       case VDP_VIDEO_MIXER_FEATURE_LUMA_KEY:
 486          break;
 487
 488       case VDP_VIDEO_MIXER_FEATURE_SHARPNESS:
 489          vmixer->sharpness.enabled = feature_enables[i];
 490          vlVdpVideoMixerUpdateSharpnessFilter(vmixer);
 491          break;
 492
 493       case VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION:
 494          vmixer->noise_reduction.enabled = feature_enables[i];
 495          vlVdpVideoMixerUpdateNoiseReductionFilter(vmixer);
 496          break;
 497
 498       default:
 499          pipe_mutex_unlock(vmixer->device->mutex);
 500          return VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE;
 501       }
 502    }
 503    pipe_mutex_unlock(vmixer->device->mutex);
 504
 505    return VDP_STATUS_OK;
 506 }
 507
 508 /**
 509  * Retrieve whether features are enabled.
 510  */
 511 VdpStatus
 512 vlVdpVideoMixerGetFeatureEnables(VdpVideoMixer mixer,
 513                                  uint32_t feature_count,
 514                                  VdpVideoMixerFeature const *features,
 515                                  VdpBool *feature_enables)
 516 {
 517    vlVdpVideoMixer *vmixer;
 518    unsigned i;
 519
 520    if (!(features && feature_enables))
 521       return VDP_STATUS_INVALID_POINTER;
 522
 523    vmixer = vlGetDataHTAB(mixer);
 524    if (!vmixer)
 525       return VDP_STATUS_INVALID_HANDLE;
 526
 527    for (i = 0; i < feature_count; ++i) {
 528       switch (features[i]) {
 529       /* they are valid, but we doesn't support them */
 530       case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL:
 531       case VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL:
 532       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L1:
 533       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L2:
 534       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L3:
 535       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L4:
 536       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L5:
 537       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L6:
 538       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L7:
 539       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L8:
 540       case VDP_VIDEO_MIXER_FEATURE_HIGH_QUALITY_SCALING_L9:
 541       case VDP_VIDEO_MIXER_FEATURE_INVERSE_TELECINE:
 542       case VDP_VIDEO_MIXER_FEATURE_LUMA_KEY:
 543          break;
 544
 545       case VDP_VIDEO_MIXER_FEATURE_SHARPNESS:
 546          feature_enables[i] = vmixer->sharpness.enabled;
 547          break;
 548
 549       case VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION:
 550          feature_enables[i] = vmixer->noise_reduction.enabled;
 551          break;
 552
 553       default:
 554          return VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE;
 555       }
 556    }
 557
 558    return VDP_STATUS_OK;
 559 }
 560
 561 /**
 562  * Set attribute values.
 563  */
 564 VdpStatus
 565 vlVdpVideoMixerSetAttributeValues(VdpVideoMixer mixer,
 566                                   uint32_t attribute_count,
 567                                   VdpVideoMixerAttribute const *attributes,
 568                                   void const *const *attribute_values)
 569 {
 570    const VdpColor *background_color;
 571    union pipe_color_union color;
 572    const float *vdp_csc;
 573    float val;
 574    unsigned i;
 575
 576    if (!(attributes && attribute_values))
 577       return VDP_STATUS_INVALID_POINTER;
 578
 579    vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
 580    if (!vmixer)
 581       return VDP_STATUS_INVALID_HANDLE;
 582
 583    pipe_mutex_lock(vmixer->device->mutex);
 584    for (i = 0; i < attribute_count; ++i) {
 585       switch (attributes[i]) {
 586       case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
 587          background_color = attribute_values[i];
 588          color.f[0] = background_color->red;
 589          color.f[1] = background_color->green;
 590          color.f[2] = background_color->blue;
 591          color.f[3] = background_color->alpha;
 592          vl_compositor_set_clear_color(&vmixer->cstate, &color);
 593          break;
 594       case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX:
 595          vdp_csc = attribute_values[i];
 596          vmixer->custom_csc = !!vdp_csc;
 597          if (!vdp_csc)
 598             vl_csc_get_matrix(VL_CSC_COLOR_STANDARD_BT_601, NULL, 1, &vmixer->csc);
 599          else
 600             memcpy(vmixer->csc, vdp_csc, sizeof(vl_csc_matrix));
 601          if (!debug_get_bool_option("G3DVL_NO_CSC", FALSE))
 602             vl_compositor_set_csc_matrix(&vmixer->cstate, (const vl_csc_matrix *)&vmixer->csc);
 603          break;
 604
 605       case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL:
 606
 607          val = *(float*)attribute_values[i];
 608          if (val < 0.f || val > 1.f)
 609             return VDP_STATUS_INVALID_VALUE;
 610
 611          vmixer->noise_reduction.level = val * 10;
 612          vlVdpVideoMixerUpdateNoiseReductionFilter(vmixer);
 613          break;
 614
 615       case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA:
 616          val = *(float*)attribute_values[i];
 617          if (val < 0.f || val > 1.f)
 618             return VDP_STATUS_INVALID_VALUE;
 619          vmixer->luma_key_min = val;
 620          break;
 621       case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA:
 622          val = *(float*)attribute_values[i];
 623          if (val < 0.f || val > 1.f)
 624             return VDP_STATUS_INVALID_VALUE;
 625          vmixer->luma_key_max = val;
 626          break;
 627
 628       case VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL:
 629
 630          val = *(float*)attribute_values[i];
 631          if (val < -1.f || val > 1.f)
 632             return VDP_STATUS_INVALID_VALUE;
 633
 634          vmixer->sharpness.value = val;
 635          vlVdpVideoMixerUpdateSharpnessFilter(vmixer);
 636          break;
 637
 638       case VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE:
 639          if (*(uint8_t*)attribute_values[i] > 1)
 640             return VDP_STATUS_INVALID_VALUE;
 641          vmixer->skip_chroma_deint = *(uint8_t*)attribute_values[i];
 642          break;
 643       default:
 644          pipe_mutex_unlock(vmixer->device->mutex);
 645          return VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE;
 646       }
 647    }
 648    pipe_mutex_unlock(vmixer->device->mutex);
 649
 650    return VDP_STATUS_OK;
 651 }
 652
 653 /**
 654  * Retrieve parameter values given at creation time.
 655  */
 656 VdpStatus
 657 vlVdpVideoMixerGetParameterValues(VdpVideoMixer mixer,
 658                                   uint32_t parameter_count,
 659                                   VdpVideoMixerParameter const *parameters,
 660                                   void *const *parameter_values)
 661 {
 662    vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
 663    unsigned i;
 664    if (!vmixer)
 665       return VDP_STATUS_INVALID_HANDLE;
 666
 667    if (!parameter_count)
 668       return VDP_STATUS_OK;
 669    if (!(parameters && parameter_values))
 670       return VDP_STATUS_INVALID_POINTER;
 671    for (i = 0; i < parameter_count; ++i) {
 672       switch (parameters[i]) {
 673       case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH:
 674          *(uint32_t*)parameter_values[i] = vmixer->video_width;
 675          break;
 676       case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT:
 677          *(uint32_t*)parameter_values[i] = vmixer->video_height;
 678          break;
 679       case VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE:
 680          *(VdpChromaType*)parameter_values[i] = PipeToChroma(vmixer->chroma_format);
 681          break;
 682       case VDP_VIDEO_MIXER_PARAMETER_LAYERS:
 683          *(uint32_t*)parameter_values[i] = vmixer->max_layers;
 684          break;
 685       default:
 686          return VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER;
 687       }
 688    }
 689    return VDP_STATUS_OK;
 690 }
 691
 692 /**
 693  * Retrieve current attribute values.
 694  */
 695 VdpStatus
 696 vlVdpVideoMixerGetAttributeValues(VdpVideoMixer mixer,
 697                                   uint32_t attribute_count,
 698                                   VdpVideoMixerAttribute const *attributes,
 699                                   void *const *attribute_values)
 700 {
 701    unsigned i;
 702    VdpCSCMatrix **vdp_csc;
 703
 704    if (!(attributes && attribute_values))
 705       return VDP_STATUS_INVALID_POINTER;
 706
 707    vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
 708    if (!vmixer)
 709       return VDP_STATUS_INVALID_HANDLE;
 710
 711    pipe_mutex_lock(vmixer->device->mutex);
 712    for (i = 0; i < attribute_count; ++i) {
 713       switch (attributes[i]) {
 714       case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
 715          vl_compositor_get_clear_color(&vmixer->cstate, attribute_values[i]);
 716          break;
 717       case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX:
 718          vdp_csc = attribute_values[i];
 719          if (!vmixer->custom_csc) {
 720              *vdp_csc = NULL;
 721             break;
 722          }
 723          memcpy(*vdp_csc, vmixer->csc, sizeof(float)*12);
 724          break;
 725
 726       case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL:
 727          *(float*)attribute_values[i] = (float)vmixer->noise_reduction.level / 10.0f;
 728          break;
 729
 730       case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA:
 731          *(float*)attribute_values[i] = vmixer->luma_key_min;
 732          break;
 733       case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA:
 734          *(float*)attribute_values[i] = vmixer->luma_key_max;
 735          break;
 736       case VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL:
 737          *(float*)attribute_values[i] = vmixer->sharpness.value;
 738          break;
 739       case VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE:
 740          *(uint8_t*)attribute_values[i] = vmixer->skip_chroma_deint;
 741          break;
 742       default:
 743          pipe_mutex_unlock(vmixer->device->mutex);
 744          return VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE;
 745       }
 746    }
 747    pipe_mutex_unlock(vmixer->device->mutex);
 748    return VDP_STATUS_OK;
 749 }
 750
 751 /**
 752  * Generate a color space conversion matrix.
 753  */
 754 VdpStatus
 755 vlVdpGenerateCSCMatrix(VdpProcamp *procamp,
 756                        VdpColorStandard standard,
 757                        VdpCSCMatrix *csc_matrix)
 758 {
 759    enum VL_CSC_COLOR_STANDARD vl_std;
 760    struct vl_procamp camp;
 761
 762    if (!(csc_matrix && procamp))
 763       return VDP_STATUS_INVALID_POINTER;
 764
 765    if (procamp->struct_version > VDP_PROCAMP_VERSION)
 766       return VDP_STATUS_INVALID_STRUCT_VERSION;
 767
 768    switch (standard) {
 769       case VDP_COLOR_STANDARD_ITUR_BT_601: vl_std = VL_CSC_COLOR_STANDARD_BT_601; break;
 770       case VDP_COLOR_STANDARD_ITUR_BT_709: vl_std = VL_CSC_COLOR_STANDARD_BT_709; break;
 771       case VDP_COLOR_STANDARD_SMPTE_240M:  vl_std = VL_CSC_COLOR_STANDARD_SMPTE_240M; break;
 772       default: return VDP_STATUS_INVALID_COLOR_STANDARD;
 773    }
 774    camp.brightness = procamp->brightness;
 775    camp.contrast = procamp->contrast;
 776    camp.saturation = procamp->saturation;
 777    camp.hue = procamp->hue;
 778    vl_csc_get_matrix(vl_std, &camp, true, csc_matrix);
 779    return VDP_STATUS_OK;
 780 }