libvo/vo_xvmc.c

   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)(void);
 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(rez != Success)
1108     {
1109     int i;
1110         mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc::slice: RenderSirface returned %d\n",rez);
1111
1112         mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc::slice: pict=%d,flags=%x,start_blocks=%d,num_blocks=%d\n",
1113                 rndr->picture_structure,rndr->flags,rndr->start_mv_blocks_num,
1114                 rndr->filled_mv_blocks_num);
1115         mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc::slice: this_surf=%p, past_surf=%p, future_surf=%p\n",
1116                 rndr->p_surface,rndr->p_past_surface,rndr->p_future_surface);
1117
1118         for(i=0; i<rndr->filled_mv_blocks_num; i++){
1119             XvMCMacroBlock* testblock;
1120             testblock = &mv_blocks.macro_blocks[i];
1121
1122             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",
1123                     testblock->x,testblock->y,testblock->macroblock_type,
1124                     testblock->motion_type,testblock->motion_vertical_field_select);
1125             mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc::slice: dct_type=%d,data_index=0x%x,cbp=%d,pad0=%d\n",
1126                     testblock->dct_type,testblock->index,testblock->coded_block_pattern,
1127                     testblock->pad0);
1128             mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc::slice: PMV[0][0][0/1]=(%d,%d)\n",
1129                     testblock->PMV[0][0][0],testblock->PMV[0][0][1]);
1130         }
1131     }
1132     assert(rez==Success);
1133     mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: flush surface\n");
1134     rez = XvMCFlushSurface(mDisplay, rndr->p_surface);
1135     assert(rez==Success);
1136
1137 //   rndr->start_mv_blocks_num += rndr->filled_mv_blocks_num;
1138     rndr->start_mv_blocks_num = 0;
1139     rndr->filled_mv_blocks_num = 0;
1140
1141     rndr->next_free_data_block_num = 0;
1142
1143     return VO_TRUE;
1144 }
1145
1146 //XvMCHide hides the surface on next retrace, so
1147 //check if the surface is not still displaying
1148 static void check_osd_source(struct xvmc_pix_fmt *src_rndr) {
1149     struct xvmc_pix_fmt *osd_rndr;
1150     int stat;
1151
1152     //If this is source surface, check does the OSD rendering is compleate
1153     if(src_rndr->state & AV_XVMC_STATE_OSD_SOURCE){
1154         mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: OSD surface=%p quering\n",src_rndr);
1155         osd_rndr = src_rndr->p_osd_target_surface_render;
1156         XvMCGetSurfaceStatus(mDisplay, osd_rndr->p_surface, &stat);
1157         if(!(stat & XVMC_RENDERING))
1158             src_rndr->state &= ~AV_XVMC_STATE_OSD_SOURCE;
1159     }
1160 }
1161 static int count_free_surfaces(void) {
1162     int i,num;
1163
1164     num=0;
1165     for(i=0; i<number_of_surfaces; i++){
1166         check_osd_source(&surface_render[i]);
1167         if(surface_render[i].state == 0)
1168             num++;
1169     }
1170     return num;
1171 }
1172
1173 static struct xvmc_pix_fmt *find_free_surface(void) {
1174     int i,t;
1175     int stat;
1176     struct xvmc_pix_fmt *visible_rndr;
1177
1178     visible_rndr = NULL;
1179     for(i=0; i<number_of_surfaces; i++){
1180
1181         check_osd_source(&surface_render[i]);
1182         if( surface_render[i].state == 0){
1183             XvMCGetSurfaceStatus(mDisplay, surface_render[i].p_surface,&stat);
1184             if( (stat & XVMC_DISPLAYING) == 0 )
1185                 return &surface_render[i];
1186             visible_rndr = &surface_render[i];// remember it, use as last resort
1187         }
1188     }
1189
1190     //all surfaces are busy, but there is one that will be free
1191     //on next monitor retrace, we just have to wait
1192     if(visible_rndr != NULL){
1193         mp_msg(MSGT_VO,MSGL_INFO,"vo_xvmc: waiting retrace\n");
1194         for(t=0;t<1000;t++){
1195             usec_sleep(1000);//1ms
1196             XvMCGetSurfaceStatus(mDisplay, visible_rndr->p_surface,&stat);
1197             if( (stat & XVMC_DISPLAYING) == 0 )
1198                 return visible_rndr;
1199         }
1200     }
1201 //todo remove when stable
1202     mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: no free surfaces, this should not happen in g1\n");
1203     for(i=0;i<number_of_surfaces;i++)
1204         mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: surface[%d].state=%d\n",i,surface_render[i].state);
1205     return NULL;
1206 }
1207
1208 static void xvmc_clean_surfaces(void){
1209     int i;
1210
1211     for(i=0; i<number_of_surfaces; i++){
1212
1213         surface_render[i].state&=!( AV_XVMC_STATE_DISPLAY_PENDING |
1214                                     AV_XVMC_STATE_OSD_SOURCE |
1215                                     0);
1216         surface_render[i].p_osd_target_surface_render=NULL;
1217         if(surface_render[i].state != 0){
1218             mp_msg(MSGT_VO,MSGL_WARN,"vo_xvmc: surface[%d].state=%d\n",
1219                                    i,surface_render[i].state);
1220         }
1221     }
1222     free_element=0;//clean up the queue
1223 }
1224
1225 static uint32_t get_image(mp_image_t *mpi){
1226     struct xvmc_pix_fmt *rndr;
1227
1228     rndr = find_free_surface();
1229
1230     if(rndr == NULL){
1231         mp_msg(MSGT_VO,MSGL_ERR,"vo_xvmc: get_image failed\n");
1232         return VO_FALSE;
1233     }
1234
1235 assert(rndr->start_mv_blocks_num == 0);
1236 assert(rndr->filled_mv_blocks_num == 0);
1237 assert(rndr->next_free_data_block_num == 0);
1238
1239     mpi->flags |= MP_IMGFLAG_DIRECT;
1240 //keep strides 0 to avoid field manipulations
1241     mpi->stride[0] = 0;
1242     mpi->stride[1] = 0;
1243     mpi->stride[2] = 0;
1244
1245 // these are shared!! so watch out
1246 // do call RenderSurface before overwriting
1247     mpi->planes[0] = (char*)data_blocks.blocks;
1248     mpi->planes[1] = (char*)mv_blocks.macro_blocks;
1249     mpi->priv =
1250     mpi->planes[2] = (char*)rndr;
1251
1252     rndr->picture_structure = 0;
1253     rndr->flags = 0;
1254     rndr->state = 0;
1255     rndr->start_mv_blocks_num = 0;
1256     rndr->filled_mv_blocks_num = 0;
1257     rndr->next_free_data_block_num = 0;
1258
1259     mp_msg(MSGT_VO,MSGL_DBG4,"vo_xvmc: get_image: rndr=%p (surface=%p) \n",
1260                 rndr,rndr->p_surface);
1261 return VO_TRUE;
1262 }
1263
1264 static int control(uint32_t request, void *data)
1265 {
1266     switch (request){
1267         case VOCTRL_GET_DEINTERLACE:
1268             *(int*)data = bob_deinterlace;
1269             return VO_TRUE;
1270         case VOCTRL_SET_DEINTERLACE:
1271             bob_deinterlace = *(int*)data;
1272             return VO_TRUE;
1273         case VOCTRL_QUERY_FORMAT:
1274             return query_format(*((uint32_t*)data));
1275         case VOCTRL_DRAW_IMAGE:
1276             return xvmc_draw_image((mp_image_t *)data);
1277         case VOCTRL_GET_IMAGE:
1278             return get_image((mp_image_t *)data);
1279         //vo_xv
1280         case VOCTRL_ONTOP:
1281             vo_x11_ontop();
1282             return VO_TRUE;
1283         case VOCTRL_FULLSCREEN:
1284             vo_x11_fullscreen();
1285         // indended, fallthrough to update panscan on fullscreen/windowed switch
1286         case VOCTRL_SET_PANSCAN:
1287             if ( ( vo_fs && ( vo_panscan != vo_panscan_amount ) ) || ( !vo_fs && vo_panscan_amount ) )
1288             {
1289                 int old_y = vo_panscan_y;
1290                 panscan_calc();
1291
1292                 if(old_y != vo_panscan_y)
1293                 {
1294                     //this also draws the colorkey
1295                     put_xvmc_image(p_render_surface_visible,1);
1296                 }
1297             }
1298             return VO_TRUE;
1299         case VOCTRL_GET_PANSCAN:
1300             if ( !vo_config_count || !vo_fs ) return VO_FALSE;
1301             return VO_TRUE;
1302         case VOCTRL_SET_EQUALIZER:
1303         {
1304             struct voctrl_set_equalizer_args *args = data;
1305             return vo_xv_set_eq(xv_port, args->name, args->value);
1306         }
1307
1308         case VOCTRL_GET_EQUALIZER:
1309         {
1310             struct voctrl_get_equalizer_args *args = data;
1311             return vo_xv_get_eq(xv_port, args->name, args->valueptr);
1312         }
1313         case VOCTRL_UPDATE_SCREENINFO:
1314             update_xinerama_info();
1315             return VO_TRUE;
1316     }
1317     return VO_NOTIMPL;
1318 }