?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Get rid of completely pointless vt_doit variable
[mplayer/glamo.git] / libvo / vo_xvmc.c
blob1673fa877423d901468123df2214959d6c9b6432
1 /*
2 * This file is part of MPlayer.
3 *
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 */
18
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <unistd.h>
23
24 #include "config.h"
25 #include "mp_msg.h"
26 #include "video_out.h"
27 #include "video_out_internal.h"
28 #include "osdep/timer.h"
29
30 #include <X11/Xlib.h>
31 #include <X11/Xutil.h>
32 #include <X11/Xatom.h>
33
34 #ifdef HAVE_SHM
35 #include <sys/ipc.h>
36 #include <sys/shm.h>
37 #include <X11/extensions/XShm.h>
38 #endif
39
40 #include <X11/extensions/Xv.h>
41 #include <X11/extensions/Xvlib.h>
42 #include <X11/extensions/XvMClib.h>
43
44 #include "x11_common.h"
45 #include "libavcodec/avcodec.h"
46 #include "libavcodec/xvmc.h"
47
48 #include "sub.h"
49 #include "aspect.h"
50
51 #include "subopt-helper.h"
52 #include "gui/interface.h"
53
54 #include "libavutil/common.h"
55
56 //no chance for xinerama to be supported in the near future
57 #undef CONFIG_XINERAMA
58
59 #undef NDEBUG
60 #include <assert.h>
61
62
63 #define UNUSED(x) ((void)(x))
64
65 #if LIBAVCODEC_BUILD < ((51<<16)+(40<<8)+2)
66 #error You need at least libavcodec v51.40.2
67 #endif
68
69
70 static int benchmark;
71 static int use_sleep;
72 static int first_frame;//draw colorkey on first frame
73 static int use_queue;
74 static int xv_port_request = 0;
75 static int xv_adaptor = -1;
76 static int bob_deinterlace;
77 static int top_field_first;
78
79 static int image_width,image_height;
80 static int image_format;
81
82 #define NO_SUBPICTURE 0
83 #define OVERLAY_SUBPICTURE 1
84 #define BLEND_SUBPICTURE 2
85 #define BACKEND_SUBPICTURE 3
86
87 static int subpicture_mode;
88 static int subpicture_alloc;
89 static XvMCSubpicture subpicture;
90 static XvImageFormatValues subpicture_info;
91 static int subpicture_clear_color;//transparent color for the subpicture or color key for overlay
92
93 static XvMCSurfaceInfo surface_info;
94 static XvMCContext ctx;
95 static XvMCBlockArray data_blocks;
96 static XvMCMacroBlockArray mv_blocks;
97
98 #define MAX_SURFACES 8
99 static int number_of_surfaces=0;
100 static XvMCSurface surface_array[MAX_SURFACES];
101 static struct xvmc_pix_fmt *surface_render;
102
103 static struct xvmc_pix_fmt *p_render_surface_to_show = NULL;
104 static struct xvmc_pix_fmt *p_render_surface_visible = NULL;
105
106 //display queue, kinda render ahead
107 static struct xvmc_pix_fmt *show_queue[MAX_SURFACES];
108 static int free_element;
109
110
111 static void (*draw_osd_fnc)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride);
112 static void (*clear_osd_fnc)(int x0,int y0, int w,int h);
113 static void (*init_osd_fnc)(void);
114
115 static void draw_osd_AI44(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride);
116 static void draw_osd_IA44(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride);
117 static void clear_osd_subpic(int x0,int y0, int w,int h);
118 static void init_osd_yuv_pal(void);
119
120
121 static const struct{
122 int id;//id as xvimages or as mplayer RGB|{8,15,16,24,32}
123 void (* init_func_ptr)();
124 void (* draw_func_ptr)();
125 void (* clear_func_ptr)();
126 } osd_render[]={
127 {0x34344149,init_osd_yuv_pal,draw_osd_AI44,clear_osd_subpic},
128 {0x34344941,init_osd_yuv_pal,draw_osd_IA44,clear_osd_subpic},
129 {0,NULL,NULL,NULL}
130 };
131
132 static void xvmc_free(void);
133 static void xvmc_clean_surfaces(void);
134 static int count_free_surfaces(void);
135 static struct xvmc_pix_fmt *find_free_surface(void);
136
137 static const vo_info_t info = {
138 "XVideo Motion Compensation",
139 "xvmc",
140 "Ivan Kalvachev <iive@users.sf.net>",
141 ""
142 };
143
144 const LIBVO_EXTERN(xvmc);
145
146 //shm stuff from vo_xv
147 #ifdef HAVE_SHM
148 static XShmSegmentInfo Shminfo;
149 static int Shmem_Flag;
150 #endif
151 XvImage * xvimage;
152
153
154 static void allocate_xvimage(int xvimage_width,int xvimage_height,int xv_format)
155 {
156 /*
157 * allocate XvImages. FIXME: no error checking, without
158 * mit-shm this will bomb... trzing to fix ::atmos
159 */
160 #ifdef HAVE_SHM
161 if ( mLocalDisplay && XShmQueryExtension( mDisplay ) ) Shmem_Flag = 1;
162 else
163 {
164 Shmem_Flag = 0;
165 mp_msg(MSGT_VO,MSGL_WARN, "Shared memory not supported\nReverting to normal Xv\n" );
166 }
167 if ( Shmem_Flag )
168 {
169 xvimage = (XvImage *) XvShmCreateImage(mDisplay, xv_port, xv_format,
170 NULL, xvimage_width, xvimage_height, &Shminfo);
171
172 Shminfo.shmid = shmget(IPC_PRIVATE, xvimage->data_size, IPC_CREAT | 0777);
173 Shminfo.shmaddr = (char *) shmat(Shminfo.shmid, 0, 0);
174 Shminfo.readOnly = False;
175
176 xvimage->data = Shminfo.shmaddr;
177 XShmAttach(mDisplay, &Shminfo);
178 XSync(mDisplay, False);
179 shmctl(Shminfo.shmid, IPC_RMID, 0);
180 }
181 else
182 #endif
183 {
184 xvimage = (XvImage *) XvCreateImage(mDisplay, xv_port, xv_format, NULL, xvimage_width, xvimage_height);
185 xvimage->data = malloc(xvimage->data_size);
186 XSync(mDisplay,False);
187 }
188 // memset(xvimage->data,128,xvimage->data_size);
189 return;
190 }
191
192 static void deallocate_xvimage(void)
193 {
194 #ifdef HAVE_SHM
195 if ( Shmem_Flag )
196 {
197 XShmDetach( mDisplay,&Shminfo );
198 shmdt( Shminfo.shmaddr );
199 }
200 else
201 #endif
202 {
203 free(xvimage->data);
204 }
205 XFree(xvimage);
206
207 XSync(mDisplay, False);
208 return;
209 }
210 //end of vo_xv shm/xvimage code
211
212 static int xvmc_check_surface_format(uint32_t format, XvMCSurfaceInfo * surf_info){
213 if ( format == IMGFMT_XVMC_IDCT_MPEG2 ){
214 if( surf_info->mc_type != (XVMC_IDCT|XVMC_MPEG_2) ) return -1;
215 if( surf_info->chroma_format != XVMC_CHROMA_FORMAT_420 ) return -1;
216 return 0;
217 }
218 if ( format == IMGFMT_XVMC_MOCO_MPEG2 ){
219 if(surf_info->mc_type != XVMC_MPEG_2) return -1;
220 if(surf_info->chroma_format != XVMC_CHROMA_FORMAT_420) return -1;
221 return 0;
222 }
223 return -1;//fail
224 }
225
226 //print all info needed to add new format
227 static void print_xvimage_format_values(XvImageFormatValues *xifv){
228 int i;
229 const int msgl=MSGL_DBG4;
230
231 mp_msg(MSGT_VO,msgl,"Format_ID = 0x%X\n",xifv->id);
232
233 mp_msg(MSGT_VO,msgl," type = ");
234 if(xifv->type == XvRGB) mp_msg(MSGT_VO,msgl,"RGB\n");
235 else if(xifv->type == XvYUV) mp_msg(MSGT_VO,msgl,"YUV\n");
236 else mp_msg(MSGT_VO,msgl,"Unknown\n");
237
238 mp_msg(MSGT_VO,msgl," byte_order = ");
239 if(xifv->byte_order == LSBFirst) mp_msg(MSGT_VO,msgl,"LSB First\n");
240 else if(xifv->type == MSBFirst) mp_msg(MSGT_VO,msgl,"MSB First\n");
241 else mp_msg(MSGT_VO,msgl,"Unknown\n");//yes Linux support other types too
242
243 mp_msg(MSGT_VO,msgl," guid = ");
244 for(i=0;i<16;i++)
245 mp_msg(MSGT_VO,msgl,"%02X ",(unsigned char)xifv->guid[i]);
246 mp_msg(MSGT_VO,msgl,"\n");
247
248 mp_msg(MSGT_VO,msgl," bits_per_pixel = %d\n",xifv->bits_per_pixel);
249
250 mp_msg(MSGT_VO,msgl," format = ");
251 if(xifv->format == XvPacked) mp_msg(MSGT_VO,msgl,"XvPacked\n");
252 else if(xifv->format == XvPlanar) mp_msg(MSGT_VO,msgl,"XvPlanar\n");
253 else mp_msg(MSGT_VO,msgl,"Unknown\n");
254
255 mp_msg(MSGT_VO,msgl," num_planes = %d\n",xifv->num_planes);
256
257 if(xifv->type == XvRGB){
258 mp_msg(MSGT_VO,msgl," red_mask = %0X\n", xifv->red_mask);
259 mp_msg(MSGT_VO,msgl," green_mask = %0X\n",xifv->green_mask);
260 mp_msg(MSGT_VO,msgl," blue_mask = %0X\n", xifv->blue_mask);
261 }
262 if(xifv->type == XvYUV){
263 mp_msg(MSGT_VO,msgl," y_sample_bits = %d\n u_sample_bits = %d\n v_sample_bits = %d\n",
264 xifv->y_sample_bits,xifv->u_sample_bits,xifv->v_sample_bits);
265 mp_msg(MSGT_VO,msgl," horz_y_period = %d\n horz_u_period = %d\n horz_v_period = %d\n",
266 xifv->horz_y_period,xifv->horz_u_period,xifv->horz_v_period);
267 mp_msg(MSGT_VO,msgl," vert_y_period = %d\n vert_u_period = %d\n vert_v_period = %d\n",
268 xifv->vert_y_period,xifv->vert_u_period,xifv->vert_v_period);
269
270 mp_msg(MSGT_VO,msgl," component_order = ");
271 for(i=0;i<32;i++)
272 if(xifv->component_order[i]>=32)
273 mp_msg(MSGT_VO,msgl,"%c",xifv->component_order[i]);
274 mp_msg(MSGT_VO,msgl,"\n");
275
276 mp_msg(MSGT_VO,msgl," scanline = ");
277 if(xifv->scanline_order == XvTopToBottom) mp_msg(MSGT_VO,msgl,"XvTopToBottom\n");
278 else if(xifv->scanline_order == XvBottomToTop) mp_msg(MSGT_VO,msgl,"XvBottomToTop\n");
279 else mp_msg(MSGT_VO,msgl,"Unknown\n");
280 }
281 mp_msg(MSGT_VO,msgl,"\n");
282 }
283
284 // WARNING This function may changes xv_port and surface_info!
285 static int xvmc_find_surface_by_format(int format,int width,int height,
286 XvMCSurfaceInfo * surf_info,int query){
287 int rez;
288 XvAdaptorInfo * ai;
289 int num_adaptors,i;
290 unsigned long p;
291 int s,mc_surf_num;
292 XvMCSurfaceInfo * mc_surf_list;
293
294 rez = XvQueryAdaptors(mDisplay,DefaultRootWindow(mDisplay),&num_adaptors,&ai);
295 if( rez != Success ) return -1;
296 mp_msg(MSGT_VO,MSGL_DBG3,"vo_xvmc: Querying %d adaptors\n",num_adaptors);
297 for(i=0; i<num_adaptors; i++)
298 {
299 /* check if adaptor number has been specified */
300 if (xv_adaptor != -1 && xv_adaptor != i)
301 continue;
302 mp_msg(MSGT_VO,MSGL_DBG3,"vo_xvmc: Quering adaptor #%d\n",i);
303 if( ai[i].type == 0 ) continue;// we need at least dummy type!
304 //probing ports
305 for(p=ai[i].base_id; p<ai[i].base_id+ai[i].num_ports; p++)
306 {
307 mp_msg(MSGT_VO,MSGL_DBG3,"vo_xvmc: probing port #%ld\n",p);
308 mc_surf_list = XvMCListSurfaceTypes(mDisplay,p,&mc_surf_num);
309 if( mc_surf_list == NULL || mc_surf_num == 0){
310 mp_msg(MSGT_VO,MSGL_DBG3,"vo_xvmc: No XvMC supported. \n");
311 continue;
312 }
313 mp_msg(MSGT_VO,MSGL_DBG3,"vo_xvmc: XvMC list have %d surfaces\n",mc_surf_num);
314 //we have XvMC list!
315 for(s=0; s<mc_surf_num; s++)
316 {
317 if( width > mc_surf_list[s].max_width ) continue;
318 if( height > mc_surf_list[s].max_height ) continue;
319 if( xvmc_check_surface_format(format,&mc_surf_list[s])<0 ) continue;
320 //we have match!
321 /* respect the users wish */
322 if ( xv_port_request != 0 && xv_port_request != p )
323 {
324 continue;
325 }
326
327 if(!query){
328 rez = XvGrabPort(mDisplay,p,CurrentTime);
329 if(rez != Success){
330 mp_msg(MSGT_VO,MSGL_DBG3,"vo_xvmc: Fail to grab port %ld\n",p);
331 continue;
332 }
333 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: Using Xv Adaptor #%d (%s)\n", i, ai[i].name);
334 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: Port %ld grabed\n",p);
335 xv_port = p;
336 }
337 goto surface_found;
338 }//for mc surf
339 XFree(mc_surf_list);//if mc_surf_num==0 is list==NULL ?
340 }//for ports
341 }//for adaptors
342 XvFreeAdaptorInfo(ai);
343
344 if(!query) mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc: Could not find free matching surface. Sorry.\n");
345 return 0;
346
347 // somebody know cleaner way to escape from 3 internal loops?
348 surface_found:
349 XvFreeAdaptorInfo(ai);
350
351 memcpy(surf_info,&mc_surf_list[s],sizeof(XvMCSurfaceInfo));
352 mp_msg(MSGT_VO, query?MSGL_INFO:MSGL_DBG3,
353 "vo_xvmc: Found matching surface with id=%X on %ld port at %d adapter\n",
354 mc_surf_list[s].surface_type_id,p,i);
355 return mc_surf_list[s].surface_type_id;
356 }
357
358 static uint32_t xvmc_draw_image(mp_image_t *mpi){
359 struct xvmc_pix_fmt *rndr;
360
361 assert(mpi!=NULL);
362 assert(mpi->flags &MP_IMGFLAG_DIRECT);
363 // assert(mpi->flags &MP_IMGFLAGS_DRAWBACK);
364
365 rndr = (struct xvmc_pix_fmt*)mpi->priv; //there is copy in plane[2]
366 assert( rndr != NULL );
367 assert( rndr->xvmc_id == AV_XVMC_ID );
368 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: draw_image(show rndr=%p)\n",rndr);
369 // the surface have passed vf system without been skiped, it will be displayed
370 rndr->state |= AV_XVMC_STATE_DISPLAY_PENDING;
371 p_render_surface_to_show = rndr;
372 top_field_first = mpi->fields & MP_IMGFIELD_TOP_FIRST;
373 return VO_TRUE;
374 }
375
376 static int preinit(const char *arg){
377 int xv_version,xv_release,xv_request_base,xv_event_base,xv_error_base;
378 int mc_eventBase,mc_errorBase;
379 int mc_ver,mc_rev;
380 strarg_t ck_src_arg = { 0, NULL };
381 strarg_t ck_method_arg = { 0, NULL };
382 const opt_t subopts [] =
383 {
384 /* name arg type arg var test */
385 { "port", OPT_ARG_INT, &xv_port_request, (opt_test_f)int_pos },
386 { "adaptor", OPT_ARG_INT, &xv_adaptor, (opt_test_f)int_non_neg },
387 { "ck", OPT_ARG_STR, &ck_src_arg, xv_test_ck },
388 { "ck-method", OPT_ARG_STR, &ck_method_arg, xv_test_ckm },
389 { "benchmark", OPT_ARG_BOOL, &benchmark, NULL },
390 { "sleep", OPT_ARG_BOOL, &use_sleep, NULL },
391 { "queue", OPT_ARG_BOOL, &use_queue, NULL },
392 { "bobdeint", OPT_ARG_BOOL, &bob_deinterlace, NULL },
393 { NULL }
394 };
395
396 //Obtain display handler
397 if (!vo_init()) return -1;//vo_xv
398
399 //XvMC is subdivision of XVideo
400 if (Success != XvQueryExtension(mDisplay,&xv_version,&xv_release,&xv_request_base,
401 &xv_event_base,&xv_error_base) ){
402 mp_msg(MSGT_VO,MSGL_ERR,"Sorry, Xv(MC) not supported by this X11 version/driver\n");
403 mp_msg(MSGT_VO,MSGL_ERR,"********** Try with -vo x11 or -vo sdl ***********\n");
404 return -1;
405 }
406 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: X-Video extension %d.%d\n",xv_version,xv_release);
407
408 if( True != XvMCQueryExtension(mDisplay,&mc_eventBase,&mc_errorBase) ){
409 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc: No X-Video MotionCompensation Extension on %s\n",
410 XDisplayName(NULL));
411 return -1;
412 }
413
414 if(Success == XvMCQueryVersion(mDisplay, &mc_ver, &mc_rev) ){
415 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: X-Video MotionCompensation Extension version %i.%i\n",
416 mc_ver,mc_rev);
417 }
418 else{
419 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc: Error querying version info!\n");
420 return -1;
421 }
422 surface_render = NULL;
423 xv_port = 0;
424 number_of_surfaces = 0;
425 subpicture_alloc = 0;
426
427 benchmark = 0; //disable PutImageto allow faster display than screen refresh
428 use_sleep = 0;
429 use_queue = 0;
430 bob_deinterlace = 0;
431
432 /* parse suboptions */
433 if ( subopt_parse( arg, subopts ) != 0 )
434 {
435 return -1;
436 }
437
438 xv_setup_colorkeyhandling( ck_method_arg.str, ck_src_arg.str );
439
440 return 0;
441 }
442
443 static int config(uint32_t width, uint32_t height,
444 uint32_t d_width, uint32_t d_height,
445 uint32_t flags, char *title, uint32_t format){
446 int i,mode_id,rez;
447 int numblocks,blocks_per_macroblock;//bpmb we have 6,8,12
448
449 //from vo_xv
450 XVisualInfo vinfo;
451 XSetWindowAttributes xswa;
452 XWindowAttributes attribs;
453 unsigned long xswamask;
454 int depth;
455 #ifdef CONFIG_XF86VM
456 int vm = flags & VOFLAG_MODESWITCHING;
457 #endif
458 //end of vo_xv
459
460 if( !IMGFMT_IS_XVMC(format) )
461 {
462 assert(0);//should never happen, abort on debug or
463 return 1;//return error on relese
464 }
465
466 // Find free port that supports MC, by querying adaptors
467 if( xv_port != 0 || number_of_surfaces != 0 ){
468 if( height==image_height && width==image_width && image_format==format){
469 xvmc_clean_surfaces();
470 goto skip_surface_allocation;
471 }
472 xvmc_free();
473 };
474 numblocks=((width+15)/16)*((height+15)/16);
475 // Find Supported Surface Type
476 mode_id = xvmc_find_surface_by_format(format,width,height,&surface_info,0);//false=1 to grab port, not query
477 if ( mode_id == 0 )
478 {
479 return -1;
480 }
481
482 rez = XvMCCreateContext(mDisplay, xv_port,mode_id,width,height,XVMC_DIRECT,&ctx);
483 if( rez != Success ){
484 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc: XvMCCreateContext failed with error %d\n",rez);
485 return -1;
486 }
487 if( ctx.flags & XVMC_DIRECT ){
488 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: Allocated Direct Context\n");
489 }else{
490 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: Allocated Indirect Context!\n");
491 }
492
493
494 blocks_per_macroblock = 6;
495 if(surface_info.chroma_format == XVMC_CHROMA_FORMAT_422)
496 blocks_per_macroblock = 8;
497 if(surface_info.chroma_format == XVMC_CHROMA_FORMAT_444)
498 blocks_per_macroblock = 12;
499
500 rez = XvMCCreateBlocks(mDisplay,&ctx,numblocks*blocks_per_macroblock,&data_blocks);
501 if( rez != Success ){
502 XvMCDestroyContext(mDisplay,&ctx);
503 return -1;
504 }
505 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: data_blocks allocated\n");
506
507 rez = XvMCCreateMacroBlocks(mDisplay,&ctx,numblocks,&mv_blocks);
508 if( rez != Success ){
509 XvMCDestroyBlocks(mDisplay,&data_blocks);
510 XvMCDestroyContext(mDisplay,&ctx);
511 return -1;
512 }
513 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: mv_blocks allocated\n");
514
515 if(surface_render==NULL)
516 surface_render = malloc(MAX_SURFACES * sizeof(struct xvmc_pix_fmt)); //easy mem debug
517 memset(surface_render, 0, MAX_SURFACES * sizeof(struct xvmc_pix_fmt));
518
519 for(i=0; i<MAX_SURFACES; i++){
520 rez=XvMCCreateSurface(mDisplay,&ctx,&surface_array[i]);
521 if( rez != Success )
522 break;
523 surface_render[i].xvmc_id = AV_XVMC_ID;
524 surface_render[i].data_blocks = data_blocks.blocks;
525 surface_render[i].mv_blocks = mv_blocks.macro_blocks;
526 surface_render[i].allocated_mv_blocks = numblocks;
527 surface_render[i].allocated_data_blocks = numblocks*blocks_per_macroblock;
528 surface_render[i].idct = (surface_info.mc_type & XVMC_IDCT) == XVMC_IDCT;
529 surface_render[i].unsigned_intra = (surface_info.flags & XVMC_INTRA_UNSIGNED) == XVMC_INTRA_UNSIGNED;
530 surface_render[i].p_surface = &surface_array[i];
531 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: surface[%d] = %p .rndr=%p\n",
532 i,&surface_array[i], &surface_render[i]);
533 }
534 number_of_surfaces = i;
535 if( number_of_surfaces < 4 ){// +2 I or P and +2 for B (to avoid visible motion drawing)
536 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc: Unable to allocate at least 4 Surfaces\n");
537 uninit();
538 return -1;
539 }
540 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: Motion Compensation context allocated - %d surfaces\n",
541 number_of_surfaces);
542
543 //debug
544 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: idct=%d unsigned_intra=%d\n",
545 (surface_info.mc_type & XVMC_IDCT) == XVMC_IDCT,
546 (surface_info.flags & XVMC_INTRA_UNSIGNED) == XVMC_INTRA_UNSIGNED);
547
548 // Find way to display OSD & subtitle
549 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: looking for OSD support\n");
550 subpicture_mode = NO_SUBPICTURE;
551 if(surface_info.flags & XVMC_OVERLAID_SURFACE)
552 subpicture_mode = OVERLAY_SUBPICTURE;
553
554 if(surface_info.subpicture_max_width != 0 &&
555 surface_info.subpicture_max_height != 0 ){
556 int s,k,num_subpic;
557
558 XvImageFormatValues * xvfmv;
559 xvfmv = XvMCListSubpictureTypes(mDisplay, xv_port,
560 surface_info.surface_type_id, &num_subpic);
561
562 if(num_subpic != 0 && xvfmv != NULL){
563 if( mp_msg_test(MSGT_VO,MSGL_DBG4) ){//Print all subpicture types for debug
564 for(s=0;s<num_subpic;s++)
565 print_xvimage_format_values(&xvfmv[s]);
566 }
567
568 for(s=0;s<num_subpic;s++){
569 for(k=0;osd_render[k].draw_func_ptr!=NULL;k++){
570 if(xvfmv[s].id == osd_render[k].id)
571 {
572 init_osd_fnc = osd_render[k].init_func_ptr;
573 draw_osd_fnc = osd_render[k].draw_func_ptr;
574 clear_osd_fnc = osd_render[k].clear_func_ptr;
575
576 subpicture_mode = BLEND_SUBPICTURE;
577 subpicture_info = xvfmv[s];
578 mp_msg(MSGT_VO,MSGL_INFO," Subpicture id 0x%08X\n",subpicture_info.id);
579 goto found_subpic;
580 }
581 }
582 }
583 found_subpic:
584 XFree(xvfmv);
585 }
586 //Blend2 supicture is always possible, blend1 only at backend
587 if( (subpicture_mode == BLEND_SUBPICTURE) &&
588 (surface_info.flags & XVMC_BACKEND_SUBPICTURE) )
589 {
590 subpicture_mode = BACKEND_SUBPICTURE;
591 }
592
593 }
594
595 switch(subpicture_mode){
596 case NO_SUBPICTURE:
597 mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: No OSD support for this mode\n");
598 break;
599 case OVERLAY_SUBPICTURE:
600 mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: OSD support via color key tricks\n");
601 mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: not yet implemented:(\n");
602 break;
603 case BLEND_SUBPICTURE:
604 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: OSD support by additional frontend rendering\n");
605 break;
606 case BACKEND_SUBPICTURE:
607 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: OSD support by backend rendering (fast)\n");
608 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: Please send feedback to confirm that it works,otherwise send bugreport!\n");
609 break;
610 }
611
612 //take keycolor value and choose method for handling it
613 if ( !vo_xv_init_colorkey() )
614 {
615 return -1; // bail out, colorkey setup failed
616 }
617
618 vo_xv_enable_vsync();//it won't break anything
619
620 //taken from vo_xv
621 image_height = height;
622 image_width = width;
623
624 skip_surface_allocation:
625
626 #ifdef CONFIG_GUI
627 if(use_gui)
628 guiGetEvent( guiSetShVideo,0 ); // let the GUI to setup/resize our window
629 else
630 #endif
631 {
632 #ifdef CONFIG_XF86VM
633 if ( vm )
634 {
635 vo_vm_switch();
636 }
637 // else
638 #endif
639 XGetWindowAttributes(mDisplay, DefaultRootWindow(mDisplay), &attribs);
640 depth=attribs.depth;
641 if (depth != 15 && depth != 16 && depth != 24 && depth != 32) depth = 24;
642 XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
643
644 xswa.background_pixel = 0;
645 if (xv_ck_info.method == CK_METHOD_BACKGROUND)
646 xswa.background_pixel = xv_colorkey;
647 xswa.border_pixel = 0;
648 xswamask = CWBackPixel | CWBorderPixel;
649
650 vo_x11_create_vo_window(&vinfo, vo_dx, vo_dy, d_width, d_height, flags,
651 CopyFromParent, "xvmc", title);
652 XChangeWindowAttributes(mDisplay, vo_window, xswamask, &xswa);
653
654 #ifdef CONFIG_XF86VM
655 if ( vm )
656 {
657 /* Grab the mouse pointer in our window */
658 if(vo_grabpointer)
659 XGrabPointer(mDisplay, vo_window, True, 0,
660 GrabModeAsync, GrabModeAsync,
661 vo_window, None, CurrentTime );
662 XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
663 }
664 #endif
665 }
666
667 //end vo_xv
668
669 /* store image dimesions for displaying */
670 p_render_surface_visible = NULL;
671 p_render_surface_to_show = NULL;
672
673 free_element = 0;
674 first_frame = 1;
675
676 image_format=format;
677 return 0;
678 }
679
680 static int draw_frame(uint8_t *srcp[]){
681 UNUSED(srcp);
682 assert(0);
683 }
684
685 static void init_osd_yuv_pal(void) {
686 char * palette;
687 int rez;
688 int i,j;
689 int snum,seb;
690 int Y,U,V;
691
692 subpicture_clear_color = 0;
693
694 if(subpicture.num_palette_entries > 0){
695
696 snum = subpicture.num_palette_entries;
697 seb = subpicture.entry_bytes;
698 palette = malloc(snum*seb);//check fail
699 if(palette == NULL) return;
700 for(i=0; i<snum; i++){
701 // 0-black max-white the other are gradients
702 Y = i*(1 << subpicture_info.y_sample_bits)/snum;//snum=2;->(0),(1*(1<<1)/2)
703 U = 1 << (subpicture_info.u_sample_bits - 1);
704 V = 1 << (subpicture_info.v_sample_bits - 1);
705 for(j=0; j<seb; j++)
706 switch(subpicture.component_order[j]){
707 case 'U': palette[i*seb+j] = U; break;
708 case 'V': palette[i*seb+j] = V; break;
709 case 'Y':
710 default:
711 palette[i*seb+j] = Y; break;
712 }
713 }
714 rez = XvMCSetSubpicturePalette(mDisplay, &subpicture, palette);
715 if(rez!=Success){
716 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc: Setting palette failed.\n");
717 }
718 free(palette);
719 }
720 }
721
722 static void clear_osd_subpic(int x0, int y0, int w, int h){
723 int rez;
724
725 rez=XvMCClearSubpicture(mDisplay, &subpicture,
726 x0, y0, w,h,
727 subpicture_clear_color);
728 if(rez != Success)
729 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc: XvMCClearSubpicture failed!\n");
730 }
731
732 static void OSD_init(void) {
733 unsigned short osd_height, osd_width;
734 int rez;
735
736 if(subpicture_alloc){
737 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: destroying subpicture\n");
738 XvMCDestroySubpicture(mDisplay,&subpicture);
739 deallocate_xvimage();
740 subpicture_alloc = 0;
741 }
742
743 /* if(surface_info.flags & XVMC_SUBPICTURE_INDEPENDENT_SCALING){
744 osd_width = vo_dwidth;
745 osd_height = vo_dheight;
746 }else*/
747 {
748 osd_width = image_width;
749 osd_height = image_height;
750 }
751
752 if(osd_width > surface_info.subpicture_max_width)
753 osd_width = surface_info.subpicture_max_width;
754 if(osd_height > surface_info.subpicture_max_height)
755 osd_height = surface_info.subpicture_max_height;
756 if(osd_width == 0 || osd_height == 0)
757 return;//if called before window size is known
758
759 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: creating subpicture (%d,%d) format %X\n",
760 osd_width,osd_height,subpicture_info.id);
761
762 rez = XvMCCreateSubpicture(mDisplay,&ctx,&subpicture,
763 osd_width,osd_height,subpicture_info.id);
764 if(rez != Success){
765 subpicture_mode = NO_SUBPICTURE;
766 mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: Create Subpicture failed, OSD disabled\n");
767 return;
768 }
769 if( mp_msg_test(MSGT_VO,MSGL_DBG4) ){
770 int i;
771 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: Created Subpicture:\n");
772 mp_msg(MSGT_VO,MSGL_DBG4," xvimage_id=0x%X\n",subpicture.xvimage_id);
773 mp_msg(MSGT_VO,MSGL_DBG4," width=%d\n",subpicture.width);
774 mp_msg(MSGT_VO,MSGL_DBG4," height=%d\n",subpicture.height);
775 mp_msg(MSGT_VO,MSGL_DBG4," num_palette_entries=0x%X\n",subpicture.num_palette_entries);
776 mp_msg(MSGT_VO,MSGL_DBG4," entry_bytes=0x%X\n",subpicture.entry_bytes);
777
778 mp_msg(MSGT_VO,MSGL_DBG4," component_order=\"");
779 for(i=0; i<4; i++)
780 if(subpicture.component_order[i] >= 32)
781 mp_msg(MSGT_VO,MSGL_DBG4,"%c", subpicture.component_order[i]);
782 mp_msg(MSGT_VO,MSGL_DBG4,"\"\n");
783 }
784
785 //call init for the surface type
786 init_osd_fnc();//init palete,clear color etc ...
787 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: clearing subpicture\n");
788 clear_osd_fnc(0, 0, subpicture.width, subpicture.height);
789
790 allocate_xvimage(subpicture.width, subpicture.height, subpicture_info.id);
791 subpicture_alloc = 1;
792 }
793
794 static void draw_osd_IA44(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
795 int ox,oy;
796 int rez;
797
798 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc:composite AI44 subpicture (%d,%d - %d,%d)\n",x0,y0,w,h);
799
800 for(ox=0; ox<w; ox++){
801 for(oy=0; oy<h; oy++){
802 xvimage->data[oy*xvimage->width+ox] = (src[oy*stride+ox]>>4) | ((0-srca[oy*stride+ox])&0xf0);
803 }
804 }
805 rez = XvMCCompositeSubpicture(mDisplay, &subpicture, xvimage, 0, 0,
806 w,h,x0,y0);
807 if(rez != Success){
808 mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: composite subpicture failed\n");
809 assert(0);
810 }
811 }
812
813 static void draw_osd_AI44(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride){
814 int ox,oy;
815 int rez;
816
817 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc:composite AI44 subpicture (%d,%d - %d,%d)\n",x0,y0,w,h);
818
819 for(ox=0; ox<w; ox++){
820 for(oy=0; oy<h; oy++){
821 xvimage->data[oy*xvimage->width+ox] = (src[oy*stride+ox]&0xf0) | (((0-srca[oy*stride+ox])>>4)&0xf);
822 }
823 }
824 rez = XvMCCompositeSubpicture(mDisplay, &subpicture, xvimage, 0, 0,
825 w,h,x0,y0);
826 if(rez != Success){
827 mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: composite subpicture failed\n");
828 assert(0);
829 }
830 }
831
832 static void draw_osd(void){
833 struct xvmc_pix_fmt *osd_rndr;
834 int osd_has_changed;
835 int have_osd_to_draw;
836 int rez;
837
838 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: draw_osd ,OSD_mode=%d, surface_to_show=%p\n",
839 subpicture_mode,p_render_surface_to_show);
840
841 if(subpicture_mode == BLEND_SUBPICTURE ||
842 subpicture_mode == BACKEND_SUBPICTURE ){
843
844 if(!subpicture_alloc) //allocate subpicture when dimensions are known
845 OSD_init();
846 if(!subpicture_alloc)
847 return;//dimensions still unknown.
848
849 osd_has_changed = vo_update_osd(subpicture.width, subpicture.height);
850 have_osd_to_draw = vo_osd_check_range_update(0, 0, subpicture.width,
851 subpicture.height);
852
853 if(!have_osd_to_draw)
854 return;//nothing to draw,no subpic, no blend
855
856 if(osd_has_changed){
857 //vo_remove_text(subpicture.width, subpicture.height,clear_osd_fnc)
858 clear_osd_fnc(0,0,subpicture.width,subpicture.height);
859 vo_draw_text(subpicture.width, subpicture.height, draw_osd_fnc);
860 }
861 XvMCSyncSubpicture(mDisplay,&subpicture);//todo usleeep wait!
862
863 if(subpicture_mode == BLEND_SUBPICTURE){
864 osd_rndr = find_free_surface();
865 if(osd_rndr == NULL)
866 return;// no free surface to draw OSD in
867
868 rez = XvMCBlendSubpicture2(mDisplay,
869 p_render_surface_to_show->p_surface, osd_rndr->p_surface,
870 &subpicture,
871 0, 0, subpicture.width, subpicture.height,
872 0, 0, image_width, image_height);
873 if(rez!=Success){
874 mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: BlendSubpicture failed rez=%d\n",rez);
875 assert(0);
876 return;
877 }
878 // XvMCFlushSurface(mDisplay,osd_rndr->p_surface);//fixme- should I?
879
880 //When replaceing the surface with osd one, save the flags too!
881 osd_rndr->picture_structure = p_render_surface_to_show->picture_structure;
882 //add more if needed osd_rndr-> = p_render_surface_to_show->;
883
884 p_render_surface_to_show->state &= ~AV_XVMC_STATE_DISPLAY_PENDING;
885 p_render_surface_to_show->state |= AV_XVMC_STATE_OSD_SOURCE;
886 p_render_surface_to_show->p_osd_target_surface_render = osd_rndr;
887
888 p_render_surface_to_show = osd_rndr;
889 p_render_surface_to_show->state = AV_XVMC_STATE_DISPLAY_PENDING;
890
891 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc:draw_osd: surface_to_show changed to %p\n",osd_rndr);
892 }//endof if(BLEND)
893 if(subpicture_mode == BACKEND_SUBPICTURE){
894 rez = XvMCBlendSubpicture(mDisplay,
895 p_render_surface_to_show->p_surface,
896 &subpicture,
897 0, 0, subpicture.width, subpicture.height,
898 0, 0, image_width, image_height);
899
900 }
901
902 }//if(BLEND||BACKEND)
903 }
904
905 static void xvmc_sync_surface(XvMCSurface * srf){
906 int status,rez;
907
908 rez = XvMCGetSurfaceStatus(mDisplay,srf,&status);
909 assert(rez==Success);
910 if((status & XVMC_RENDERING) == 0)
911 return;//surface is already complete
912 if(use_sleep){
913 rez = XvMCFlushSurface(mDisplay, srf);
914 assert(rez==Success);
915
916 do{
917 usec_sleep(1000);//1ms (may be 20ms on linux)
918 XvMCGetSurfaceStatus(mDisplay,srf,&status);
919 } while (status & XVMC_RENDERING);
920 return;//done
921 }
922
923 XvMCSyncSurface(mDisplay, srf);
924 }
925
926 static void put_xvmc_image(struct xvmc_pix_fmt *p_render_surface,
927 int draw_ck){
928 int rez;
929 struct vo_rect src_rect, dst_rect;
930 int i;
931
932 if(p_render_surface == NULL)
933 return;
934
935 calc_src_dst_rects(image_width, image_height, &src_rect, &dst_rect, NULL, NULL);
936
937 if(draw_ck)
938 vo_xv_draw_colorkey(dst_rect.left, dst_rect.top, dst_rect.width, dst_rect.height);
939
940 if(benchmark)
941 return;
942
943 for (i = 1; i <= bob_deinterlace + 1; i++) {
944 int field = top_field_first ? i : i ^ 3;
945 rez = XvMCPutSurface(mDisplay, p_render_surface->p_surface,
946 vo_window,
947 src_rect.left, src_rect.top, src_rect.width, src_rect.height,
948 dst_rect.left, dst_rect.top, dst_rect.width, dst_rect.height,
949 bob_deinterlace ? field : 3);
950 if(rez != Success){
951 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc: PutSurface failer, critical error %d!\n",rez);
952 assert(0);
953 }
954 }
955 XFlush(mDisplay);
956 }
957
958 static void flip_page(void){
959 int i,cfs;
960
961 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: flip_page show(rndr=%p)\n\n",p_render_surface_to_show);
962
963 if(p_render_surface_to_show == NULL) return;
964 assert( p_render_surface_to_show->xvmc_id == AV_XVMC_ID );
965 //fixme assert( p_render_surface_to_show != p_render_surface_visible);
966
967 if(use_queue){
968 // fill the queue until only n free surfaces remain
969 // after that start displaying
970 cfs = count_free_surfaces();
971 show_queue[free_element++] = p_render_surface_to_show;
972 if(cfs > 3){//well have 3 free surfaces after add queue
973 if(free_element > 1)//a little voodoo magic
974 xvmc_sync_surface(show_queue[0]->p_surface);
975 return;
976 }
977 p_render_surface_to_show=show_queue[0];
978 mp_msg(MSGT_VO,MSGL_DBG5,"vo_xvmc: flip_queue free_element=%d\n",free_element);
979 free_element--;
980 for(i=0; i<free_element; i++){
981 show_queue[i] = show_queue[i+1];
982 }
983 show_queue[free_element] = NULL;
984 }
985
986 // make sure the rendering is done
987 xvmc_sync_surface(p_render_surface_to_show->p_surface);
988
989 //the visible surface won't be displayed anymore, mark it as free
990 if(p_render_surface_visible != NULL)
991 p_render_surface_visible->state &= ~AV_XVMC_STATE_DISPLAY_PENDING;
992
993 //!!fixme assert(p_render_surface_to_show->state & AV_XVMC_STATE_DISPLAY_PENDING);
994
995 //show it, displaying is always vsynced, so skip it for benchmark
996 put_xvmc_image(p_render_surface_to_show,first_frame);
997 first_frame=0;//make sure we won't draw it anymore
998
999 p_render_surface_visible = p_render_surface_to_show;
1000 p_render_surface_to_show = NULL;
1001 }
1002
1003 static void check_events(void){
1004 int e=vo_x11_check_events(mDisplay);
1005
1006 if(e&VO_EVENT_RESIZE)
1007 {
1008 e |= VO_EVENT_EXPOSE;
1009 }
1010 if ( e & VO_EVENT_EXPOSE )
1011 {
1012 put_xvmc_image(p_render_surface_visible,1);
1013 }
1014 }
1015
1016 static void xvmc_free(void){
1017 int i;
1018
1019 if( subpicture_alloc ){
1020
1021 XvMCDestroySubpicture(mDisplay,&subpicture);
1022 deallocate_xvimage();
1023
1024 subpicture_alloc = 0;
1025
1026 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: subpicture destroyed\n");
1027 }
1028
1029 if( number_of_surfaces ){
1030
1031 XvMCDestroyMacroBlocks(mDisplay,&mv_blocks);
1032 XvMCDestroyBlocks(mDisplay,&data_blocks);
1033
1034 for(i=0; i<number_of_surfaces; i++)
1035 {
1036 XvMCHideSurface(mDisplay,&surface_array[i]);//it doesn't hurt, I hope
1037 XvMCDestroySurface(mDisplay,&surface_array[i]);
1038
1039 if( (surface_render[i].state != 0) &&
1040 (p_render_surface_visible != &surface_render[i]) )
1041 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc::uninit surface_render[%d].status=%d\n",i,
1042 surface_render[i].state);
1043 }
1044
1045 memset(surface_render, 0, MAX_SURFACES * sizeof(struct xvmc_pix_fmt)); //for debugging
1046 free(surface_render);surface_render=NULL;
1047
1048 XvMCDestroyContext(mDisplay,&ctx);
1049 number_of_surfaces = 0;
1050
1051 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: Context sucessfuly freed\n");
1052 }
1053
1054
1055 if( xv_port !=0 ){
1056 XvUngrabPort(mDisplay,xv_port,CurrentTime);
1057 xv_port = 0;
1058 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: xv_port sucessfuly ungrabed\n");
1059 }
1060 }
1061
1062 static void uninit(void){
1063 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: uninit called\n");
1064 xvmc_free();
1065 //from vo_xv
1066 #ifdef CONFIG_XF86VM
1067 vo_vm_close();
1068 #endif
1069 vo_x11_uninit();
1070 }
1071
1072 static int query_format(uint32_t format){
1073 uint32_t flags;
1074 XvMCSurfaceInfo qsurface_info;
1075 int mode_id;
1076
1077 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: query_format=%X\n",format);
1078
1079 if(!IMGFMT_IS_XVMC(format)) return 0;// no caps supported
1080 mode_id = xvmc_find_surface_by_format(format, 16, 16, &qsurface_info, 1);//true=1 - quering
1081
1082 if( mode_id == 0 ) return 0;
1083
1084 flags = VFCAP_CSP_SUPPORTED |
1085 VFCAP_CSP_SUPPORTED_BY_HW |
1086 VFCAP_ACCEPT_STRIDE;
1087
1088 if( (qsurface_info.subpicture_max_width != 0) &&
1089 (qsurface_info.subpicture_max_height != 0) )
1090 flags|=VFCAP_OSD;
1091 return flags;
1092 }
1093
1094
1095 static int draw_slice(uint8_t *image[], int stride[],
1096 int w, int h, int x, int y){
1097 struct xvmc_pix_fmt *rndr;
1098 int rez;
1099
1100 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: draw_slice y=%d\n",y);
1101
1102 rndr = (struct xvmc_pix_fmt*)image[2]; //this is copy of priv-ate
1103 assert( rndr != NULL );
1104 assert( rndr->xvmc_id == AV_XVMC_ID );
1105
1106 rez = XvMCRenderSurface(mDisplay,&ctx,rndr->picture_structure,
1107 rndr->p_surface,
1108 rndr->p_past_surface,
1109 rndr->p_future_surface,
1110 rndr->flags,
1111 rndr->filled_mv_blocks_num,rndr->start_mv_blocks_num,
1112 &mv_blocks,&data_blocks);
1113 #if 1
1114 if(rez != Success)
1115 {
1116 int i;
1117 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc::slice: RenderSirface returned %d\n",rez);
1118
1119 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc::slice: pict=%d,flags=%x,start_blocks=%d,num_blocks=%d\n",
1120 rndr->picture_structure,rndr->flags,rndr->start_mv_blocks_num,
1121 rndr->filled_mv_blocks_num);
1122 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc::slice: this_surf=%p, past_surf=%p, future_surf=%p\n",
1123 rndr->p_surface,rndr->p_past_surface,rndr->p_future_surface);
1124
1125 for(i=0; i<rndr->filled_mv_blocks_num; i++){
1126 XvMCMacroBlock* testblock;
1127 testblock = &mv_blocks.macro_blocks[i];
1128
1129 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc::slice: mv_block - x=%d,y=%d,mb_type=0x%x,mv_type=0x%x,mv_field_select=%d\n",
1130 testblock->x,testblock->y,testblock->macroblock_type,
1131 testblock->motion_type,testblock->motion_vertical_field_select);
1132 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc::slice: dct_type=%d,data_index=0x%x,cbp=%d,pad0=%d\n",
1133 testblock->dct_type,testblock->index,testblock->coded_block_pattern,
1134 testblock->pad0);
1135 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc::slice: PMV[0][0][0/1]=(%d,%d)\n",
1136 testblock->PMV[0][0][0],testblock->PMV[0][0][1]);
1137 }
1138 }
1139 #endif
1140 assert(rez==Success);
1141 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: flush surface\n");
1142 rez = XvMCFlushSurface(mDisplay, rndr->p_surface);
1143 assert(rez==Success);
1144
1145 // rndr->start_mv_blocks_num += rndr->filled_mv_blocks_num;
1146 rndr->start_mv_blocks_num = 0;
1147 rndr->filled_mv_blocks_num = 0;
1148
1149 rndr->next_free_data_block_num = 0;
1150
1151 return VO_TRUE;
1152 }
1153
1154 //XvMCHide hides the surface on next retrace, so
1155 //check if the surface is not still displaying
1156 static void check_osd_source(struct xvmc_pix_fmt *src_rndr) {
1157 struct xvmc_pix_fmt *osd_rndr;
1158 int stat;
1159
1160 //If this is source surface, check does the OSD rendering is compleate
1161 if(src_rndr->state & AV_XVMC_STATE_OSD_SOURCE){
1162 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: OSD surface=%p quering\n",src_rndr);
1163 osd_rndr = src_rndr->p_osd_target_surface_render;
1164 XvMCGetSurfaceStatus(mDisplay, osd_rndr->p_surface, &stat);
1165 if(!(stat & XVMC_RENDERING))
1166 src_rndr->state &= ~AV_XVMC_STATE_OSD_SOURCE;
1167 }
1168 }
1169 static int count_free_surfaces(void) {
1170 int i,num;
1171
1172 num=0;
1173 for(i=0; i<number_of_surfaces; i++){
1174 check_osd_source(&surface_render[i]);
1175 if(surface_render[i].state == 0)
1176 num++;
1177 }
1178 return num;
1179 }
1180
1181 static struct xvmc_pix_fmt *find_free_surface(void) {
1182 int i,t;
1183 int stat;
1184 struct xvmc_pix_fmt *visible_rndr;
1185
1186 visible_rndr = NULL;
1187 for(i=0; i<number_of_surfaces; i++){
1188
1189 check_osd_source(&surface_render[i]);
1190 if( surface_render[i].state == 0){
1191 XvMCGetSurfaceStatus(mDisplay, surface_render[i].p_surface,&stat);
1192 if( (stat & XVMC_DISPLAYING) == 0 )
1193 return &surface_render[i];
1194 visible_rndr = &surface_render[i];// remember it, use as last resort
1195 }
1196 }
1197
1198 //all surfaces are busy, but there is one that will be free
1199 //on next monitor retrace, we just have to wait
1200 if(visible_rndr != NULL){
1201 mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: waiting retrace\n");
1202 for(t=0;t<1000;t++){
1203 usec_sleep(1000);//1ms
1204 XvMCGetSurfaceStatus(mDisplay, visible_rndr->p_surface,&stat);
1205 if( (stat & XVMC_DISPLAYING) == 0 )
1206 return visible_rndr;
1207 }
1208 }
1209 //todo remove when stable
1210 mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: no free surfaces, this should not happen in g1\n");
1211 for(i=0;i<number_of_surfaces;i++)
1212 mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: surface[%d].state=%d\n",i,surface_render[i].state);
1213 return NULL;
1214 }
1215
1216 static void xvmc_clean_surfaces(void){
1217 int i;
1218
1219 for(i=0; i<number_of_surfaces; i++){
1220
1221 surface_render[i].state&=!( AV_XVMC_STATE_DISPLAY_PENDING |
1222 AV_XVMC_STATE_OSD_SOURCE |
1223 0);
1224 surface_render[i].p_osd_target_surface_render=NULL;
1225 if(surface_render[i].state != 0){
1226 mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: surface[%d].state=%d\n",
1227 i,surface_render[i].state);
1228 }
1229 }
1230 free_element=0;//clean up the queue
1231 }
1232
1233 static uint32_t get_image(mp_image_t *mpi){
1234 struct xvmc_pix_fmt *rndr;
1235
1236 rndr = find_free_surface();
1237
1238 if(rndr == NULL){
1239 mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc: get_image failed\n");
1240 return VO_FALSE;
1241 }
1242
1243 assert(rndr->start_mv_blocks_num == 0);
1244 assert(rndr->filled_mv_blocks_num == 0);
1245 assert(rndr->next_free_data_block_num == 0);
1246
1247 mpi->flags |= MP_IMGFLAG_DIRECT;
1248 //keep strides 0 to avoid field manipulations
1249 mpi->stride[0] = 0;
1250 mpi->stride[1] = 0;
1251 mpi->stride[2] = 0;
1252
1253 // these are shared!! so watch out
1254 // do call RenderSurface before overwriting
1255 mpi->planes[0] = (char*)data_blocks.blocks;
1256 mpi->planes[1] = (char*)mv_blocks.macro_blocks;
1257 mpi->priv =
1258 mpi->planes[2] = (char*)rndr;
1259
1260 rndr->picture_structure = 0;
1261 rndr->flags = 0;
1262 rndr->state = 0;
1263 rndr->start_mv_blocks_num = 0;
1264 rndr->filled_mv_blocks_num = 0;
1265 rndr->next_free_data_block_num = 0;
1266
1267 mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: get_image: rndr=%p (surface=%p) \n",
1268 rndr,rndr->p_surface);
1269 return VO_TRUE;
1270 }
1271
1272 static int control(uint32_t request, void *data, ... )
1273 {
1274 switch (request){
1275 case VOCTRL_GET_DEINTERLACE:
1276 *(int*)data = bob_deinterlace;
1277 return VO_TRUE;
1278 case VOCTRL_SET_DEINTERLACE:
1279 bob_deinterlace = *(int*)data;
1280 return VO_TRUE;
1281 case VOCTRL_QUERY_FORMAT:
1282 return query_format(*((uint32_t*)data));
1283 case VOCTRL_DRAW_IMAGE:
1284 return xvmc_draw_image((mp_image_t *)data);
1285 case VOCTRL_GET_IMAGE:
1286 return get_image((mp_image_t *)data);
1287 //vo_xv
1288 case VOCTRL_GUISUPPORT:
1289 return VO_TRUE;
1290 case VOCTRL_ONTOP:
1291 vo_x11_ontop();
1292 return VO_TRUE;
1293 case VOCTRL_FULLSCREEN:
1294 vo_x11_fullscreen();
1295 // indended, fallthrough to update panscan on fullscreen/windowed switch
1296 case VOCTRL_SET_PANSCAN:
1297 if ( ( vo_fs && ( vo_panscan != vo_panscan_amount ) ) || ( !vo_fs && vo_panscan_amount ) )
1298 {
1299 int old_y = vo_panscan_y;
1300 panscan_calc();
1301
1302 if(old_y != vo_panscan_y)
1303 {
1304 //this also draws the colorkey
1305 put_xvmc_image(p_render_surface_visible,1);
1306 }
1307 }
1308 return VO_TRUE;
1309 case VOCTRL_GET_PANSCAN:
1310 if ( !vo_config_count || !vo_fs ) return VO_FALSE;
1311 return VO_TRUE;
1312 case VOCTRL_SET_EQUALIZER:
1313 {
1314 va_list ap;
1315 int value;
1316
1317 va_start(ap, data);
1318 value = va_arg(ap, int);
1319 va_end(ap);
1320
1321 return vo_xv_set_eq(xv_port, data, value);
1322 }
1323
1324 case VOCTRL_GET_EQUALIZER:
1325 {
1326 va_list ap;
1327 int *value;
1328
1329 va_start(ap, data);
1330 value = va_arg(ap, int*);
1331 va_end(ap);
1332
1333 return vo_xv_get_eq(xv_port, data, value);
1334 }
1335 case VOCTRL_UPDATE_SCREENINFO:
1336 update_xinerama_info();
1337 return VO_TRUE;
1338 }
1339 return VO_NOTIMPL;
1340 }
mplayer with SMedia Glamo drivers