query.c revision fa2a8316cebeb75626ffa3e38dbc1500e82054f6 
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   return VDP_STATUS_NO_IMPLEMENTATION;
292}
293
294/**
295 * Query the implementation's supported for a specific parameter.
296 */
297VdpStatus
298vlVdpVideoMixerQueryParameterValueRange(VdpDevice device, VdpVideoMixerParameter parameter,
299                                        void *min_value, void *max_value)
300{
301   if (!(min_value && max_value))
302      return VDP_STATUS_INVALID_POINTER;
303
304   return VDP_STATUS_NO_IMPLEMENTATION;
305}
306
307/**
308 * Query the implementation's support for a specific attribute.
309 */
310VdpStatus
311vlVdpVideoMixerQueryAttributeSupport(VdpDevice device, VdpVideoMixerAttribute attribute,
312                                     VdpBool *is_supported)
313{
314   if (!is_supported)
315      return VDP_STATUS_INVALID_POINTER;
316
317   return VDP_STATUS_NO_IMPLEMENTATION;
318}
319
320/**
321 * Query the implementation's supported for a specific attribute.
322 */
323VdpStatus
324vlVdpVideoMixerQueryAttributeValueRange(VdpDevice device, VdpVideoMixerAttribute attribute,
325                                        void *min_value, void *max_value)
326{
327   if (!(min_value && max_value))
328      return VDP_STATUS_INVALID_POINTER;
329
330   return VDP_STATUS_NO_IMPLEMENTATION;
331}
332