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