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