1 /**************************************************************************
2 *
3 * Copyright 2009 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
30 #include <X11/Xlibint.h>
31 #include <X11/extensions/XvMClib.h>
32
33 #include "pipe/p_screen.h"
34 #include "pipe/p_video_decoder.h"
35 #include "pipe/p_video_state.h"
36 #include "pipe/p_state.h"
37
38 #include "util/u_memory.h"
39
40 #include "vl/vl_csc.h"
41 #include "vl/vl_winsys.h"
42
43 #include "xvmc_private.h"
44
Validate(Display * dpy,XvPortID port,int surface_type_id,unsigned int width,unsigned int height,int flags,bool * found_port,int * screen,int * chroma_format,int * mc_type,int * surface_flags,unsigned short * subpic_max_w,unsigned short * subpic_max_h)45 static Status Validate(Display *dpy, XvPortID port, int surface_type_id,
46 unsigned int width, unsigned int height, int flags,
47 bool *found_port, int *screen, int *chroma_format,
48 int *mc_type, int *surface_flags,
49 unsigned short *subpic_max_w,
50 unsigned short *subpic_max_h)
51 {
52 bool found_surface = false;
53 XvAdaptorInfo *adaptor_info;
54 unsigned int num_adaptors;
55 int num_types;
56 unsigned int max_width = 0, max_height = 0;
57 Status ret;
58
59 assert(dpy);
60 assert(found_port);
61 assert(screen);
62 assert(chroma_format);
63 assert(mc_type);
64 assert(surface_flags);
65 assert(subpic_max_w);
66 assert(subpic_max_h);
67
68 *found_port = false;
69
70 for (unsigned int i = 0; i < XScreenCount(dpy); ++i) {
71 ret = XvQueryAdaptors(dpy, XRootWindow(dpy, i), &num_adaptors, &adaptor_info);
72 if (ret != Success)
73 return ret;
74
75 for (unsigned int j = 0; j < num_adaptors && !*found_port; ++j) {
76 for (unsigned int k = 0; k < adaptor_info[j].num_ports && !*found_port; ++k) {
77 XvMCSurfaceInfo *surface_info;
78
79 if (adaptor_info[j].base_id + k != port)
80 continue;
81
82 *found_port = true;
83
84 surface_info = XvMCListSurfaceTypes(dpy, adaptor_info[j].base_id, &num_types);
85 if (!surface_info) {
86 XvFreeAdaptorInfo(adaptor_info);
87 return BadAlloc;
88 }
89
90 for (unsigned int l = 0; l < num_types && !found_surface; ++l) {
91 if (surface_info[l].surface_type_id != surface_type_id)
92 continue;
93
94 found_surface = true;
95 max_width = surface_info[l].max_width;
96 max_height = surface_info[l].max_height;
97 *chroma_format = surface_info[l].chroma_format;
98 *mc_type = surface_info[l].mc_type;
99 *surface_flags = surface_info[l].flags;
100 *subpic_max_w = surface_info[l].subpicture_max_width;
101 *subpic_max_h = surface_info[l].subpicture_max_height;
102 *screen = i;
103
104 XVMC_MSG(XVMC_TRACE, "[XvMC] Found requested context surface format.\n" \
105 "[XvMC] screen=%u, port=%u\n" \
106 "[XvMC] id=0x%08X\n" \
107 "[XvMC] max width=%u, max height=%u\n" \
108 "[XvMC] chroma format=0x%08X\n" \
109 "[XvMC] acceleration level=0x%08X\n" \
110 "[XvMC] flags=0x%08X\n" \
111 "[XvMC] subpicture max width=%u, max height=%u\n",
112 i, port, surface_type_id, max_width, max_height, *chroma_format,
113 *mc_type, *surface_flags, *subpic_max_w, *subpic_max_h);
114 }
115
116 XFree(surface_info);
117 }
118 }
119
120 XvFreeAdaptorInfo(adaptor_info);
121 }
122
123 if (!*found_port) {
124 XVMC_MSG(XVMC_ERR, "[XvMC] Could not find a suitable port.\n");
125 return XvBadPort;
126 }
127 if (!found_surface) {
128 XVMC_MSG(XVMC_ERR, "[XvMC] Could not find a suitable surface.\n");
129 return BadMatch;
130 }
131 if (width > max_width || height > max_height) {
132 XVMC_MSG(XVMC_ERR, "[XvMC] Requested context dimensions (w=%u,h=%u) too large (max w=%u,h=%u).\n",
133 width, height, max_width, max_height);
134 return BadValue;
135 }
136 if (flags != XVMC_DIRECT && flags != 0) {
137 XVMC_MSG(XVMC_ERR, "[XvMC] Invalid context flags 0x%08X.\n", flags);
138 return BadValue;
139 }
140
141 return Success;
142 }
143
ProfileToPipe(int xvmc_profile)144 static enum pipe_video_profile ProfileToPipe(int xvmc_profile)
145 {
146 if (xvmc_profile & XVMC_MPEG_1)
147 assert(0);
148 if (xvmc_profile & XVMC_MPEG_2)
149 return PIPE_VIDEO_PROFILE_MPEG2_MAIN;
150 if (xvmc_profile & XVMC_H263)
151 assert(0);
152 if (xvmc_profile & XVMC_MPEG_4)
153 assert(0);
154
155 assert(0);
156
157 XVMC_MSG(XVMC_ERR, "[XvMC] Unrecognized profile 0x%08X.\n", xvmc_profile);
158
159 return -1;
160 }
161
FormatToPipe(int xvmc_format)162 static enum pipe_video_chroma_format FormatToPipe(int xvmc_format)
163 {
164 switch (xvmc_format) {
165 case XVMC_CHROMA_FORMAT_420:
166 return PIPE_VIDEO_CHROMA_FORMAT_420;
167 case XVMC_CHROMA_FORMAT_422:
168 return PIPE_VIDEO_CHROMA_FORMAT_422;
169 case XVMC_CHROMA_FORMAT_444:
170 return PIPE_VIDEO_CHROMA_FORMAT_444;
171 default:
172 assert(0);
173 }
174
175 XVMC_MSG(XVMC_ERR, "[XvMC] Unrecognized format 0x%08X.\n", xvmc_format);
176
177 return -1;
178 }
179
180 PUBLIC
XvMCCreateContext(Display * dpy,XvPortID port,int surface_type_id,int width,int height,int flags,XvMCContext * context)181 Status XvMCCreateContext(Display *dpy, XvPortID port, int surface_type_id,
182 int width, int height, int flags, XvMCContext *context)
183 {
184 bool found_port;
185 int scrn = 0;
186 int chroma_format = 0;
187 int mc_type = 0;
188 int surface_flags = 0;
189 unsigned short subpic_max_w = 0;
190 unsigned short subpic_max_h = 0;
191 Status ret;
192 struct vl_screen *vscreen;
193 struct pipe_context *pipe;
194 XvMCContextPrivate *context_priv;
195 vl_csc_matrix csc;
196
197 XVMC_MSG(XVMC_TRACE, "[XvMC] Creating context %p.\n", context);
198
199 assert(dpy);
200
201 if (!context)
202 return XvMCBadContext;
203
204 ret = Validate(dpy, port, surface_type_id, width, height, flags,
205 &found_port, &scrn, &chroma_format, &mc_type, &surface_flags,
206 &subpic_max_w, &subpic_max_h);
207
208 /* Success and XvBadPort have the same value */
209 if (ret != Success || !found_port)
210 return ret;
211
212 /* XXX: Current limits */
213 if (chroma_format != XVMC_CHROMA_FORMAT_420) {
214 XVMC_MSG(XVMC_ERR, "[XvMC] Cannot decode requested surface type. Unsupported chroma format.\n");
215 return BadImplementation;
216 }
217 if ((mc_type & ~XVMC_IDCT) != (XVMC_MOCOMP | XVMC_MPEG_2)) {
218 XVMC_MSG(XVMC_ERR, "[XvMC] Cannot decode requested surface type. Non-MPEG2/Mocomp/iDCT acceleration unsupported.\n");
219 return BadImplementation;
220 }
221 if (surface_flags & XVMC_INTRA_UNSIGNED) {
222 XVMC_MSG(XVMC_ERR, "[XvMC] Cannot decode requested surface type. Unsigned intra unsupported.\n");
223 return BadImplementation;
224 }
225
226 context_priv = CALLOC(1, sizeof(XvMCContextPrivate));
227 if (!context_priv)
228 return BadAlloc;
229
230 /* TODO: Reuse screen if process creates another context */
231 vscreen = vl_screen_create(dpy, scrn);
232
233 if (!vscreen) {
234 XVMC_MSG(XVMC_ERR, "[XvMC] Could not create VL screen.\n");
235 FREE(context_priv);
236 return BadAlloc;
237 }
238
239 pipe = vscreen->pscreen->context_create(vscreen->pscreen, vscreen);
240 if (!pipe) {
241 XVMC_MSG(XVMC_ERR, "[XvMC] Could not create VL context.\n");
242 vl_screen_destroy(vscreen);
243 FREE(context_priv);
244 return BadAlloc;
245 }
246
247 context_priv->decoder = pipe->create_video_decoder
248 (
249 pipe, ProfileToPipe(mc_type),
250 (mc_type & XVMC_IDCT) ? PIPE_VIDEO_ENTRYPOINT_IDCT : PIPE_VIDEO_ENTRYPOINT_MC,
251 FormatToPipe(chroma_format),
252 width, height, 2,
253 true
254 );
255
256 if (!context_priv->decoder) {
257 XVMC_MSG(XVMC_ERR, "[XvMC] Could not create VL decoder.\n");
258 pipe->destroy(pipe);
259 vl_screen_destroy(vscreen);
260 FREE(context_priv);
261 return BadAlloc;
262 }
263
264 if (!vl_compositor_init(&context_priv->compositor, pipe)) {
265 XVMC_MSG(XVMC_ERR, "[XvMC] Could not create VL compositor.\n");
266 context_priv->decoder->destroy(context_priv->decoder);
267 pipe->destroy(pipe);
268 vl_screen_destroy(vscreen);
269 FREE(context_priv);
270 return BadAlloc;
271 }
272
273 if (!vl_compositor_init_state(&context_priv->cstate, pipe)) {
274 XVMC_MSG(XVMC_ERR, "[XvMC] Could not create VL compositor state.\n");
275 vl_compositor_cleanup(&context_priv->compositor);
276 context_priv->decoder->destroy(context_priv->decoder);
277 pipe->destroy(pipe);
278 vl_screen_destroy(vscreen);
279 FREE(context_priv);
280 return BadAlloc;
281 }
282
283
284 context_priv->color_standard =
285 debug_get_bool_option("G3DVL_NO_CSC", FALSE) ?
286 VL_CSC_COLOR_STANDARD_IDENTITY : VL_CSC_COLOR_STANDARD_BT_601;
287 context_priv->procamp = vl_default_procamp;
288
289 vl_csc_get_matrix
290 (
291 context_priv->color_standard,
292 &context_priv->procamp, true, &csc
293 );
294 vl_compositor_set_csc_matrix(&context_priv->cstate, (const vl_csc_matrix *)&csc);
295
296 context_priv->vscreen = vscreen;
297 context_priv->pipe = pipe;
298 context_priv->subpicture_max_width = subpic_max_w;
299 context_priv->subpicture_max_height = subpic_max_h;
300
301 context->context_id = XAllocID(dpy);
302 context->surface_type_id = surface_type_id;
303 context->width = width;
304 context->height = height;
305 context->flags = flags;
306 context->port = port;
307 context->privData = context_priv;
308
309 SyncHandle();
310
311 XVMC_MSG(XVMC_TRACE, "[XvMC] Context %p created.\n", context);
312
313 return Success;
314 }
315
316 PUBLIC
XvMCDestroyContext(Display * dpy,XvMCContext * context)317 Status XvMCDestroyContext(Display *dpy, XvMCContext *context)
318 {
319 XvMCContextPrivate *context_priv;
320
321 XVMC_MSG(XVMC_TRACE, "[XvMC] Destroying context %p.\n", context);
322
323 assert(dpy);
324
325 if (!context || !context->privData)
326 return XvMCBadContext;
327
328 context_priv = context->privData;
329 context_priv->decoder->destroy(context_priv->decoder);
330 vl_compositor_cleanup_state(&context_priv->cstate);
331 vl_compositor_cleanup(&context_priv->compositor);
332 context_priv->pipe->destroy(context_priv->pipe);
333 vl_screen_destroy(context_priv->vscreen);
334 FREE(context_priv);
335 context->privData = NULL;
336
337 XVMC_MSG(XVMC_TRACE, "[XvMC] Context %p destroyed.\n", context);
338
339 return Success;
340 }
341