libvo/vo_xvmc.c

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