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
45static 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
144static 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
162static 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
180PUBLIC
181Status 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
316PUBLIC
317Status 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