query.c revision e8e0756bd35e5e3b70a0eee323f5aaa3707fe11d 
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 */
40VdpStatus
41vlVdpGetApiVersion(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 */
54VdpStatus
55vlVdpGetInformationString(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 */
67VdpStatus
68vlVdpVideoSurfaceQueryCapabilities(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 */
106VdpStatus
107vlVdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities(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 */
140VdpStatus
141vlVdpDecoderQueryCapabilities(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 */
187VdpStatus
188vlVdpOutputSurfaceQueryCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
189                                    VdpBool *is_supported, uint32_t *max_width, uint32_t *max_height)
190{
191   if (!(is_supported && max_width && max_height))
192      return VDP_STATUS_INVALID_POINTER;
193
194   VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpOutputSurface capabilities\n");
195
196   return VDP_STATUS_NO_IMPLEMENTATION;
197}
198
199/**
200 * Query the implementation's capability to perform a PutBits operation using
201 * application data matching the surface's format.
202 */
203VdpStatus
204vlVdpOutputSurfaceQueryGetPutBitsNativeCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
205                                                    VdpBool *is_supported)
206{
207   VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpOutputSurface get/put bits native capabilities\n");
208
209   if (!is_supported)
210      return VDP_STATUS_INVALID_POINTER;
211
212   return VDP_STATUS_NO_IMPLEMENTATION;
213}
214
215/**
216 * Query the implementation's capability to perform a PutBits operation using
217 * application data in a specific indexed format.
218 */
219VdpStatus
220vlVdpOutputSurfaceQueryPutBitsIndexedCapabilities(VdpDevice device,
221                                                  VdpRGBAFormat surface_rgba_format,
222                                                  VdpIndexedFormat bits_indexed_format,
223                                                  VdpColorTableFormat color_table_format,
224                                                  VdpBool *is_supported)
225{
226   VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpOutputSurface put bits indexed capabilities\n");
227
228   if (!is_supported)
229      return VDP_STATUS_INVALID_POINTER;
230
231   return VDP_STATUS_NO_IMPLEMENTATION;
232}
233
234/**
235 * Query the implementation's capability to perform a PutBits operation using
236 * application data in a specific YCbCr/YUB format.
237 */
238VdpStatus
239vlVdpOutputSurfaceQueryPutBitsYCbCrCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
240                                                VdpYCbCrFormat bits_ycbcr_format,
241                                                VdpBool *is_supported)
242{
243   VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpOutputSurface put bits YCbCr capabilities\n");
244
245   if (!is_supported)
246      return VDP_STATUS_INVALID_POINTER;
247
248   return VDP_STATUS_NO_IMPLEMENTATION;
249}
250
251/**
252 * Query the implementation's VdpBitmapSurface capabilities.
253 */
254VdpStatus
255vlVdpBitmapSurfaceQueryCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
256                                    VdpBool *is_supported, uint32_t *max_width, uint32_t *max_height)
257{
258   VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpBitmapSurface capabilities\n");
259
260   if (!(is_supported && max_width && max_height))
261      return VDP_STATUS_INVALID_POINTER;
262
263   return VDP_STATUS_NO_IMPLEMENTATION;
264}
265
266/**
267 * Query the implementation's support for a specific feature.
268 */
269VdpStatus
270vlVdpVideoMixerQueryFeatureSupport(VdpDevice device, VdpVideoMixerFeature feature,
271                                   VdpBool *is_supported)
272{
273   VDPAU_MSG(VDPAU_TRACE, "[VDPAU] Querying VdpVideoMixer feature support\n");
274
275   if (!is_supported)
276      return VDP_STATUS_INVALID_POINTER;
277
278   return VDP_STATUS_NO_IMPLEMENTATION;
279}
280
281/**
282 * Query the implementation's support for a specific parameter.
283 */
284VdpStatus
285vlVdpVideoMixerQueryParameterSupport(VdpDevice device, VdpVideoMixerParameter parameter,
286                                     VdpBool *is_supported)
287{
288   if (!is_supported)
289      return VDP_STATUS_INVALID_POINTER;
290
291   switch (parameter) {
292   case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH:
293   case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT:
294   case VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE:
295   case VDP_VIDEO_MIXER_PARAMETER_LAYERS:
296      *is_supported = VDP_TRUE;
297      break;
298   default:
299      *is_supported = VDP_FALSE;
300      break;
301   }
302   return VDP_STATUS_OK;
303}
304
305/**
306 * Query the implementation's supported for a specific parameter.
307 */
308VdpStatus
309vlVdpVideoMixerQueryParameterValueRange(VdpDevice device, VdpVideoMixerParameter parameter,
310                                        void *min_value, void *max_value)
311{
312   vlVdpDevice *dev = vlGetDataHTAB(device);
313   struct pipe_screen *screen;
314   enum pipe_video_profile prof = PIPE_VIDEO_PROFILE_UNKNOWN;
315   if (!dev)
316      return VDP_STATUS_INVALID_HANDLE;
317   if (!(min_value && max_value))
318      return VDP_STATUS_INVALID_POINTER;
319   screen = dev->vscreen->pscreen;
320   switch (parameter) {
321   case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH:
322      *(uint32_t*)min_value = 48;
323      *(uint32_t*)max_value = screen->get_video_param(screen, prof, PIPE_VIDEO_CAP_MAX_WIDTH);
324      break;
325   case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT:
326      *(uint32_t*)min_value = 48;
327      *(uint32_t*)max_value = screen->get_video_param(screen, prof, PIPE_VIDEO_CAP_MAX_HEIGHT);
328      break;
329
330   case VDP_VIDEO_MIXER_PARAMETER_LAYERS:
331      *(uint32_t*)min_value = 0;
332      *(uint32_t*)max_value = 4;
333      break;
334
335   case VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE:
336   default:
337      return VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER;
338   }
339   return VDP_STATUS_OK;
340}
341
342/**
343 * Query the implementation's support for a specific attribute.
344 */
345VdpStatus
346vlVdpVideoMixerQueryAttributeSupport(VdpDevice device, VdpVideoMixerAttribute attribute,
347                                     VdpBool *is_supported)
348{
349   if (!is_supported)
350      return VDP_STATUS_INVALID_POINTER;
351
352   switch (attribute) {
353   case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
354   case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX:
355   case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL:
356   case VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL:
357   case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA:
358   case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA:
359   case VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE:
360      *is_supported = VDP_TRUE;
361      break;
362   default:
363      *is_supported = VDP_FALSE;
364   }
365   return VDP_STATUS_OK;
366}
367
368/**
369 * Query the implementation's supported for a specific attribute.
370 */
371VdpStatus
372vlVdpVideoMixerQueryAttributeValueRange(VdpDevice device, VdpVideoMixerAttribute attribute,
373                                        void *min_value, void *max_value)
374{
375   if (!(min_value && max_value))
376      return VDP_STATUS_INVALID_POINTER;
377
378   switch (attribute) {
379   case VDP_VIDEO_MIXER_ATTRIBUTE_NOISE_REDUCTION_LEVEL:
380   case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MIN_LUMA:
381   case VDP_VIDEO_MIXER_ATTRIBUTE_LUMA_KEY_MAX_LUMA:
382      *(float*)min_value = 0.f;
383      *(float*)max_value = 1.f;
384      break;
385   case VDP_VIDEO_MIXER_ATTRIBUTE_SHARPNESS_LEVEL:
386      *(float*)min_value = -1.f;
387      *(float*)max_value = 1.f;
388      break;
389   case VDP_VIDEO_MIXER_ATTRIBUTE_SKIP_CHROMA_DEINTERLACE:
390      *(uint8_t*)min_value = 0;
391      *(uint8_t*)max_value = 1;
392      break;
393   case VDP_VIDEO_MIXER_ATTRIBUTE_BACKGROUND_COLOR:
394   case VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX:
395   default:
396      return VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE;
397   }
398   return VDP_STATUS_OK;
399}
400