src/gallium/state_trackers/vdpau/query.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 Younes Manton.
   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 <assert.h>
  29 #include <math.h>
  30
  31 #include "vdpau_private.h"
  32 #include "vl_winsys.h"
  33 #include "pipe/p_screen.h"
  34 #include "pipe/p_defines.h"
  35 #include "util/u_debug.h"
  36
  37 /**
  38  * Retrieve the VDPAU version implemented by the backend.
  39  */
  40 VdpStatus
  41 vlVdpGetApiVersion(uint32_t *api_version)
  42 {
  43    if (!api_version)
  44       return VDP_STATUS_INVALID_POINTER;
  45
  46    *api_version = 1;
  47    return VDP_STATUS_OK;
  48 }
  49
  50 /**
  51  * Retrieve an implementation-specific string description of the implementation.
  52  * This typically includes detailed version information.
  53  */
  54 VdpStatus
  55 vlVdpGetInformationString(char const **information_string)
  56 {
  57    if (!information_string)
  58       return VDP_STATUS_INVALID_POINTER;
  59
  60    *information_string = INFORMATION_STRING;
  61    return VDP_STATUS_OK;
  62 }
  63
  64 /**
  65  * Query the implementation's VdpVideoSurface capabilities.
  66  */
  67 VdpStatus
  68 vlVdpVideoSurfaceQueryCapabilities(VdpDevice device, VdpChromaType surface_chroma_type,
  69                                    VdpBool *is_supported, uint32_t *max_width, uint32_t *max_height)
  70 {
  71    vlVdpDevice *dev;
  72    struct pipe_screen *pscreen;
  73    uint32_t max_2d_texture_level;
  74
  75    VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpVideoSurface capabilities\n");
  76
  77    if (!(is_supported && max_width && max_height))
  78       return VDP_STATUS_INVALID_POINTER;
  79
  80    dev = vlGetDataHTAB(device);
  81    if (!dev)
  82       return VDP_STATUS_INVALID_HANDLE;
  83
  84    pscreen = dev->vscreen->pscreen;
  85    if (!pscreen)
  86       return VDP_STATUS_RESOURCES;
  87
  88    /* XXX: Current limits */
  89    *is_supported = true;
  90    if (surface_chroma_type != VDP_CHROMA_TYPE_420)
  91       *is_supported = false;
  92
  93    max_2d_texture_level = pscreen->get_param(pscreen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS);
  94    if (!max_2d_texture_level)
  95       return VDP_STATUS_RESOURCES;
  96
  97    /* I am not quite sure if it is max_2d_texture_level-1 or just max_2d_texture_level */
  98    *max_width = *max_height = pow(2,max_2d_texture_level-1);
  99
 100    return VDP_STATUS_OK;
 101 }
 102
 103 /**
 104  * Query the implementation's VdpVideoSurface GetBits/PutBits capabilities.
 105  */
 106 VdpStatus
 107 vlVdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities(VdpDevice device, VdpChromaType surface_chroma_type,
 108                                                   VdpYCbCrFormat bits_ycbcr_format,
 109                                                   VdpBool *is_supported)
 110 {
 111    vlVdpDevice *dev;
 112    struct pipe_screen *pscreen;
 113
 114    VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpVideoSurface get/put bits YCbCr capabilities\n");
 115
 116    if (!is_supported)
 117       return VDP_STATUS_INVALID_POINTER;
 118
 119    dev = vlGetDataHTAB(device);
 120    if (!dev)
 121       return VDP_STATUS_INVALID_HANDLE;
 122
 123    pscreen = dev->vscreen->pscreen;
 124    if (!pscreen)
 125       return VDP_STATUS_RESOURCES;
 126
 127    *is_supported = pscreen->is_video_format_supported
 128    (
 129       pscreen,
 130       FormatYCBCRToPipe(bits_ycbcr_format),
 131       PIPE_VIDEO_PROFILE_UNKNOWN
 132    );
 133
 134    return VDP_STATUS_OK;
 135 }
 136
 137 /**
 138  * Query the implementation's VdpDecoder capabilities.
 139  */
 140 VdpStatus
 141 vlVdpDecoderQueryCapabilities(VdpDevice device, VdpDecoderProfile profile,
 142                               VdpBool *is_supported, uint32_t *max_level, uint32_t *max_macroblocks,
 143                               uint32_t *max_width, uint32_t *max_height)
 144 {
 145    vlVdpDevice *dev;
 146    struct pipe_screen *pscreen;
 147    enum pipe_video_profile p_profile;
 148
 149    VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpDecoder capabilities\n");
 150
 151    if (!(is_supported && max_level && max_macroblocks && max_width && max_height))
 152       return VDP_STATUS_INVALID_POINTER;
 153
 154    dev = vlGetDataHTAB(device);
 155    if (!dev)
 156       return VDP_STATUS_INVALID_HANDLE;
 157
 158    pscreen = dev->vscreen->pscreen;
 159    if (!pscreen)
 160       return VDP_STATUS_RESOURCES;
 161
 162    p_profile = ProfileToPipe(profile);
 163    if (p_profile == PIPE_VIDEO_PROFILE_UNKNOWN) {
 164       *is_supported = false;
 165       return VDP_STATUS_OK;
 166    }
 167
 168    *is_supported = pscreen->get_video_param(pscreen, p_profile, PIPE_VIDEO_CAP_SUPPORTED);
 169    if (*is_supported) {
 170       *max_width = pscreen->get_video_param(pscreen, p_profile, PIPE_VIDEO_CAP_MAX_WIDTH);
 171       *max_height = pscreen->get_video_param(pscreen, p_profile, PIPE_VIDEO_CAP_MAX_HEIGHT);
 172       *max_level = 16;
 173       *max_macroblocks = (*max_width/16)*(*max_height/16);
 174    } else {
 175       *max_width = 0;
 176       *max_height = 0;
 177       *max_level = 0;
 178       *max_macroblocks = 0;
 179    }
 180
 181    return VDP_STATUS_OK;
 182 }
 183
 184 /**
 185  * Query the implementation's VdpOutputSurface capabilities.
 186  */
 187 VdpStatus
 188 vlVdpOutputSurfaceQueryCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
 189                                     VdpBool *is_supported, uint32_t *max_width, uint32_t *max_height)
 190 {
 191    vlVdpDevice *dev;
 192    struct pipe_screen *pscreen;
 193    enum pipe_format format;
 194
 195    VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpOutputSurface capabilities\n");
 196
 197    dev = vlGetDataHTAB(device);
 198    if (!dev)
 199       return VDP_STATUS_INVALID_HANDLE;
 200
 201    pscreen = dev->vscreen->pscreen;
 202    if (!pscreen)
 203       return VDP_STATUS_RESOURCES;
 204
 205    format = FormatRGBAToPipe(surface_rgba_format);
 206    if (format == PIPE_FORMAT_NONE || format == PIPE_FORMAT_A8_UNORM)
 207       return VDP_STATUS_INVALID_RGBA_FORMAT;
 208
 209    if (!(is_supported && max_width && max_height))
 210       return VDP_STATUS_INVALID_POINTER;
 211
 212    *is_supported = pscreen->is_format_supported
 213    (
 214       pscreen, format, PIPE_TEXTURE_3D, 1,
 215       PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET
 216    );
 217    if (*is_supported) {
 218       uint32_t max_2d_texture_level = pscreen->get_param(
 219          pscreen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS);
 220
 221       if (!max_2d_texture_level)
 222          return VDP_STATUS_ERROR;
 223
 224       *max_width = *max_height = pow(2, max_2d_texture_level - 1);
 225    } else {
 226       *max_width = 0;
 227       *max_height = 0;
 228    }
 229
 230    return VDP_STATUS_OK;
 231 }
 232
 233 /**
 234  * Query the implementation's capability to perform a PutBits operation using
 235  * application data matching the surface's format.
 236  */
 237 VdpStatus
 238 vlVdpOutputSurfaceQueryGetPutBitsNativeCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
 239                                                     VdpBool *is_supported)
 240 {
 241    VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpOutputSurface get/put bits native capabilities\n");
 242
 243    if (!is_supported)
 244       return VDP_STATUS_INVALID_POINTER;
 245
 246    return VDP_STATUS_NO_IMPLEMENTATION;
 247 }
 248
 249 /**
 250  * Query the implementation's capability to perform a PutBits operation using
 251  * application data in a specific indexed format.
 252  */
 253 VdpStatus
 254 vlVdpOutputSurfaceQueryPutBitsIndexedCapabilities(VdpDevice device,
 255                                                   VdpRGBAFormat surface_rgba_format,
 256                                                   VdpIndexedFormat bits_indexed_format,
 257                                                   VdpColorTableFormat color_table_format,
 258                                                   VdpBool *is_supported)
 259 {
 260    VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpOutputSurface put bits indexed capabilities\n");
 261
 262    if (!is_supported)
 263       return VDP_STATUS_INVALID_POINTER;
 264
 265    return VDP_STATUS_NO_IMPLEMENTATION;
 266 }
 267
 268 /**
 269  * Query the implementation's capability to perform a PutBits operation using
 270  * application data in a specific YCbCr/YUB format.
 271  */
 272 VdpStatus
 273 vlVdpOutputSurfaceQueryPutBitsYCbCrCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
 274                                                 VdpYCbCrFormat bits_ycbcr_format,
 275                                                 VdpBool *is_supported)
 276 {
 277    VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpOutputSurface put bits YCbCr capabilities\n");
 278
 279    if (!is_supported)
 280       return VDP_STATUS_INVALID_POINTER;
 281
 282    return VDP_STATUS_NO_IMPLEMENTATION;
 283 }
 284
 285 /**
 286  * Query the implementation's VdpBitmapSurface capabilities.
 287  */
 288 VdpStatus
 289 vlVdpBitmapSurfaceQueryCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
 290                                     VdpBool *is_supported, uint32_t *max_width, uint32_t *max_height)
 291 {
 292    VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpBitmapSurface capabilities\n");
 293
 294    if (!(is_supported && max_width && max_height))
 295       return VDP_STATUS_INVALID_POINTER;
 296
 297    return VDP_STATUS_NO_IMPLEMENTATION;
 298 }
 299
 300 /**
 301  * Query the implementation's support for a specific feature.
 302  */
 303 VdpStatus
 304 vlVdpVideoMixerQueryFeatureSupport(VdpDevice device, VdpVideoMixerFeature feature,
 305                                    VdpBool *is_supported)
 306 {
 307    if (!is_supported)
 308       return VDP_STATUS_INVALID_POINTER;
 309
 310    switch (feature) {
 311    case VDP_VIDEO_MIXER_FEATURE_NOISE_REDUCTION:
 312       *is_supported = VDP_TRUE;
 313       break;
 314    default:
 315       *is_supported = VDP_FALSE;
 316       break;
 317    }
 318    return VDP_STATUS_OK;
 319 }
 320
 321 /**
 322  * Query the implementation's support for a specific parameter.
 323  */
 324 VdpStatus
 325 vlVdpVideoMixerQueryParameterSupport(VdpDevice device, VdpVideoMixerParameter parameter,
 326                                      VdpBool *is_supported)
 327 {
 328    if (!is_supported)
 329       return VDP_STATUS_INVALID_POINTER;
 330
 331    switch (parameter) {
 332    case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH:
 333    case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT:
 334    case VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE:
 335    case VDP_VIDEO_MIXER_PARAMETER_LAYERS:
 336       *is_supported = VDP_TRUE;
 337       break;
 338    default:
 339       *is_supported = VDP_FALSE;
 340       break;
 341    }
 342    return VDP_STATUS_OK;
 343 }
 344
 345 /**
 346  * Query the implementation's supported for a specific parameter.
 347  */
 348 VdpStatus
 349 vlVdpVideoMixerQueryParameterValueRange(VdpDevice device, VdpVideoMixerParameter parameter,
 350                                         void *min_value, void *max_value)
 351 {
 352    vlVdpDevice *dev = vlGetDataHTAB(device);
 353    struct pipe_screen *screen;
 354    enum pipe_video_profile prof = PIPE_VIDEO_PROFILE_UNKNOWN;
 355    if (!dev)
 356       return VDP_STATUS_INVALID_HANDLE;
 357    if (!(min_value && max_value))
 358       return VDP_STATUS_INVALID_POINTER;
 359    screen = dev->vscreen->pscreen;
 360    switch (parameter) {
 361    case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH:
 362       *(uint32_t*)min_value = 48;
 363       *(uint32_t*)max_value = screen->get_video_param(screen, prof, PIPE_VIDEO_CAP_MAX_WIDTH);
 364       break;
 365    case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT:
 366       *(uint32_t*)min_value = 48;
 367       *(uint32_t*)max_value = screen->get_video_param(screen, prof, PIPE_VIDEO_CAP_MAX_HEIGHT);
 368       break;
 369
 370    case VDP_VIDEO_MIXER_PARAMETER_LAYERS:
 371       *(uint32_t*)min_value = 0;
 372       *(uint32_t*)max_value = 4;
 373       break;
 374
 375    case VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE:
 376    default:
 377       return VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER;
 378    }
 379    return VDP_STATUS_OK;
 380 }
 381
 382 /**
 383  * Query the implementation's support for a specific attribute.
 384  */
 385 VdpStatus
 386 vlVdpVideoMixerQueryAttributeSupport(VdpDevice device, VdpVideoMixerAttribute attribute,
 387                                      VdpBool *is_supported)
 388 {
 389    if (!is_supported)
 390       return VDP_STATUS_INVALID_POINTER;
 391
 392    switch (attribute) {
 393    case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
 394    case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX:
 395    case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL:
 396    case VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL:
 397    case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA:
 398    case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA:
 399    case VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE:
 400       *is_supported = VDP_TRUE;
 401       break;
 402    default:
 403       *is_supported = VDP_FALSE;
 404    }
 405    return VDP_STATUS_OK;
 406 }
 407
 408 /**
 409  * Query the implementation's supported for a specific attribute.
 410  */
 411 VdpStatus
 412 vlVdpVideoMixerQueryAttributeValueRange(VdpDevice device, VdpVideoMixerAttribute attribute,
 413                                         void *min_value, void *max_value)
 414 {
 415    if (!(min_value && max_value))
 416       return VDP_STATUS_INVALID_POINTER;
 417
 418    switch (attribute) {
 419    case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL:
 420    case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA:
 421    case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA:
 422       *(float*)min_value = 0.f;
 423       *(float*)max_value = 1.f;
 424       break;
 425    case VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL:
 426       *(float*)min_value = -1.f;
 427       *(float*)max_value = 1.f;
 428       break;
 429    case VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE:
 430       *(uint8_t*)min_value = 0;
 431       *(uint8_t*)max_value = 1;
 432       break;
 433    case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
 434    case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX:
 435    default:
 436       return VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE;
 437    }
 438    return VDP_STATUS_OK;
 439 }