git.sesse.net Git - vlc/blob - modules/video_output/x11/xvmc.c

   1 /*****************************************************************************
   2  * xvmc.c : XVMC plugin for vlc
   3  *****************************************************************************
   4  * Copyright (C) 1998-2001 VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Shane Harper <shanegh@optusnet.com.au>
   8  *          Vincent Seguin <seguin@via.ecp.fr>
   9  *          Samuel Hocevar <sam@zoy.org>
  10  *          David Kennedy <dkennedy@tinytoad.com>
  11  *          Jean-Paul Saman <jpsaman _at_ videolan _dot_ org>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  26  *****************************************************************************/
  27
  28 /*****************************************************************************
  29  * Preamble
  30  *****************************************************************************/
  31
  32 #ifdef HAVE_CONFIG_H
  33 # include "config.h"
  34 #endif
  35
  36 #include <vlc/vlc.h>
  37 #include <vlc_interface.h>
  38 #include <vlc_vout.h>
  39 #include <vlc_keys.h>
  40
  41 #ifdef HAVE_MACHINE_PARAM_H
  42     /* BSD */
  43 #   include <machine/param.h>
  44 #   include <sys/types.h>                                  /* typedef ushort */
  45 #   include <sys/ipc.h>
  46 #endif
  47
  48 #ifndef WIN32
  49 #   include <netinet/in.h>                            /* BSD: struct in_addr */
  50 #endif
  51
  52 #ifdef HAVE_SYS_SHM_H
  53 #   include <sys/shm.h>                                /* shmget(), shmctl() */
  54 #endif
  55
  56 #include <X11/Xlib.h>
  57 #include <X11/Xmd.h>
  58 #include <X11/Xutil.h>
  59 #include <X11/keysym.h>
  60 #ifdef HAVE_SYS_SHM_H
  61 #   include <X11/extensions/XShm.h>
  62 #endif
  63 #ifdef DPMSINFO_IN_DPMS_H
  64 #   include <X11/extensions/dpms.h>
  65 #endif
  66
  67 #include <X11/extensions/Xv.h>
  68 #include <X11/extensions/Xvlib.h>
  69 #include <X11/extensions/vldXvMC.h>
  70
  71 #include "../../codec/xvmc/accel_xvmc.h"
  72 #include "xcommon.h"
  73 #include "../../codec/spudec/spudec.h"
  74 #include <unistd.h>
  75
  76 /* picture structure */
  77 #define TOP_FIELD 1
  78 #define BOTTOM_FIELD 2
  79 #define FRAME_PICTURE 3
  80
  81 /* picture coding type */
  82 #define I_TYPE 1
  83 #define P_TYPE 2
  84 #define B_TYPE 3
  85 #define D_TYPE 4
  86
  87 /*****************************************************************************
  88  * Exported prototypes
  89  *****************************************************************************/
  90 extern int  E_(Activate)   ( vlc_object_t * );
  91 extern void E_(Deactivate) ( vlc_object_t * );
  92
  93 /*****************************************************************************
  94  * Module descriptor
  95  *****************************************************************************/
  96 #define ADAPTOR_TEXT N_("XVMC adaptor number")
  97 #define ADAPTOR_LONGTEXT N_( \
  98     "If you graphics card provides several adaptors, this option allows you " \
  99     "to choose which one will be used (you shouldn't have to change this).")
 100
 101 #define ALT_FS_TEXT N_("Alternate fullscreen method")
 102 #define ALT_FS_LONGTEXT N_( \
 103     "There are two ways to make a fullscreen window, unfortunately each one " \
 104     "has its drawbacks.\n" \
 105     "1) Let the window manager handle your fullscreen window (default), but " \
 106     "things like taskbars will likely show on top of the video.\n" \
 107     "2) Completely bypass the window manager, but then nothing will be able " \
 108     "to show on top of the video.")
 109
 110 #define DISPLAY_TEXT N_("X11 display name")
 111 #define DISPLAY_LONGTEXT N_( \
 112     "Specify the X11 hardware display you want to use. By default VLC will " \
 113     "use the value of the DISPLAY environment variable.")
 114
 115 #define CHROMA_TEXT N_("XVimage chroma format")
 116 #define CHROMA_LONGTEXT N_( \
 117     "Force the XVideo renderer to use a specific chroma format instead of " \
 118     "trying to improve performances by using the most efficient one.")
 119
 120 #define SHM_TEXT N_("Use shared memory")
 121 #define SHM_LONGTEXT N_( \
 122     "Use shared memory to communicate between VLC and the X server.")
 123
 124 #define SCREEN_TEXT N_("Screen to be used for fullscreen mode.")
 125 #define SCREEN_LONGTEXT N_( \
 126     "Choose the screen you want to use in fullscreen mode. For instance " \
 127     "set it to 0 for first screen, 1 for the second.")
 128
 129 #define MODE_TEXT N_("Deinterlace mode")
 130 #define MODE_LONGTEXT N_("You can choose the default deinterlace mode")
 131
 132 #define CROP_TEXT N_("Crop")
 133 #define CROP_LONGTEXT N_("You can choose the crop style to apply.")
 134
 135 vlc_module_begin();
 136     set_shortname( "XVMC" );
 137     add_string( "xvmc-display", NULL, NULL, DISPLAY_TEXT, DISPLAY_LONGTEXT, VLC_TRUE );
 138     add_integer( "xvmc-adaptor", -1, NULL, ADAPTOR_TEXT, ADAPTOR_LONGTEXT, VLC_TRUE );
 139     add_bool( "xvmc-altfullscreen", 0, NULL, ALT_FS_TEXT, ALT_FS_LONGTEXT, VLC_TRUE );
 140     add_string( "xvmc-chroma", NULL, NULL, CHROMA_TEXT, CHROMA_LONGTEXT, VLC_TRUE );
 141 #ifdef HAVE_SYS_SHM_H
 142     add_bool( "xvmc-shm", 1, NULL, SHM_TEXT, SHM_LONGTEXT, VLC_TRUE );
 143 #endif
 144 #ifdef HAVE_XINERAMA
 145     add_integer ( "xvmc-xineramascreen", 0, NULL, SCREEN_TEXT, SCREEN_LONGTEXT, VLC_TRUE );
 146 #endif
 147     add_string( "xvmc-deinterlace-mode", "bob", NULL, MODE_TEXT, MODE_LONGTEXT, VLC_FALSE );
 148     add_string( "xvmc-crop-style", "eq", NULL, CROP_TEXT, CROP_LONGTEXT, VLC_FALSE );
 149
 150     set_description( _("XVMC extension video output") );
 151     set_capability( "video output", 160 );
 152     set_callbacks( E_(Activate), E_(Deactivate) );
 153 vlc_module_end();
 154
 155 /* following functions are local */
 156
 157 static unsigned accel_priority[] = {
 158     VLC_XVMC_ACCEL_VLD,
 159 };
 160
 161 #define NUM_ACCEL_PRIORITY (sizeof(accel_priority)/sizeof(accel_priority[0]))
 162
 163 /*
 164  * Additional thread safety, since the plugin may decide to destroy a context
 165  * while it's surfaces are still active in the video-out loop.
 166  * When / If XvMC libs are reasonably thread-safe, the locks can be made
 167  * more efficient by allowing multiple threads in that do not destroy
 168  * the context or surfaces that may be active in other threads.
 169  */
 170
 171 static void init_context_lock( context_lock_t *c )
 172 {
 173     pthread_cond_init(&c->cond,NULL);
 174     pthread_mutex_init(&c->mutex,NULL);
 175     c->num_readers = 0;
 176 }
 177
 178 void free_context_lock( context_lock_t *c )
 179 {
 180     pthread_mutex_destroy(&c->mutex);
 181     pthread_cond_destroy(&c->cond);
 182 }
 183
 184 void xvmc_context_reader_lock( context_lock_t *c )
 185 {
 186     pthread_mutex_lock(&c->mutex);
 187     c->num_readers++;
 188     pthread_mutex_unlock(&c->mutex);
 189 }
 190
 191 void xvmc_context_reader_unlock( context_lock_t *c )
 192 {
 193     pthread_mutex_lock(&c->mutex);
 194     if (c->num_readers > 0) {
 195         if (--(c->num_readers) == 0) {
 196         pthread_cond_broadcast(&c->cond);
 197         }
 198     }
 199     pthread_mutex_unlock(&c->mutex);
 200 }
 201
 202 void xvmc_context_writer_lock( context_lock_t *c )
 203 {
 204     pthread_mutex_lock(&c->mutex);
 205     while(c->num_readers) {
 206         pthread_cond_wait( &c->cond, &c->mutex );
 207     }
 208 }
 209
 210 void xvmc_context_writer_unlock( context_lock_t *c )
 211 {
 212     pthread_mutex_unlock( &c->mutex );
 213 }
 214
 215 void clear_xx44_palette( xx44_palette_t *p )
 216 {
 217     int i;
 218     uint32_t *cluts = p->cluts;
 219     int *ids = p->lookup_cache;
 220
 221     i= p->size;
 222     while(i--)
 223         *cluts++ = 0;
 224     i = 2*OVL_PALETTE_SIZE;
 225     while(i--)
 226         *ids++ = -1;
 227     p->max_used=1;
 228 }
 229
 230 static void init_xx44_palette( xx44_palette_t *p, unsigned num_entries )
 231 {
 232     p->size = (num_entries > XX44_PALETTE_SIZE) ?
 233                     XX44_PALETTE_SIZE : num_entries;
 234 }
 235
 236 static void dispose_xx44_palette(xx44_palette_t *p)
 237 {
 238     /* Nothing to do */
 239 }
 240
 241 static void colorToPalette( const uint32_t *icolor, unsigned char *palette_p,
 242                             unsigned num_xvmc_components, char *xvmc_components )
 243 {
 244     const clut_t *color = (const clut_t *) icolor;
 245     unsigned int i;
 246
 247     for (i=0; i<num_xvmc_components; ++i)
 248     {
 249         switch(xvmc_components[i])
 250         {
 251             case 'V': *palette_p = color->cr; break;
 252             case 'U': *palette_p = color->cb; break;
 253             case 'Y':
 254             default:  *palette_p = color->y; break;
 255         }
 256         *palette_p++;
 257     }
 258 }
 259
 260
 261 void xx44_to_xvmc_palette( const xx44_palette_t *p,unsigned char *xvmc_palette,
 262                            unsigned first_xx44_entry, unsigned num_xx44_entries,
 263                            unsigned num_xvmc_components, char *xvmc_components )
 264 {
 265     unsigned int i;
 266     const uint32_t *cluts = p->cluts + first_xx44_entry;
 267
 268     for( i=0; i<num_xx44_entries; ++i )
 269     {
 270         if( (cluts - p->cluts) < p->size )
 271         {
 272             colorToPalette( cluts++, xvmc_palette,
 273                             num_xvmc_components, xvmc_components );
 274             xvmc_palette += num_xvmc_components;
 275         }
 276     }
 277 }
 278
 279 static int xx44_paletteIndex( xx44_palette_t *p, int color, uint32_t clut )
 280 {
 281     unsigned int i;
 282     uint32_t *cluts = p->cluts;
 283     int tmp;
 284
 285     if( (tmp = p->lookup_cache[color]) >= 0 )
 286     {
 287         if (cluts[tmp] == clut)
 288             return tmp;
 289     }
 290     for (i=0; i<p->max_used; ++i)
 291     {
 292         if (*cluts++ == clut) {
 293             p->lookup_cache[color] = i;
 294             return p->lookup_cache[color];
 295         }
 296     }
 297
 298     if( p->max_used == (p->size -1) )
 299     {
 300         //printf("video_out: Warning! Out of xx44 palette colors!\n");
 301         return 1;
 302     }
 303     p->cluts[p->max_used] = clut;
 304     p->lookup_cache[color] = p->max_used++;
 305     return p->lookup_cache[color];
 306 }
 307
 308 static void memblend_xx44( uint8_t *mem, uint8_t val,
 309                            size_t size, uint8_t mask )
 310 {
 311     uint8_t masked_val = val & mask;
 312
 313 /* size_t is unsigned, therefore always positive
 314    if (size < 0)
 315         return;*/
 316
 317     while(size--)
 318     {
 319         if( (*mem & mask) <= masked_val )
 320             *mem = val;
 321         mem++;
 322     }
 323 }
 324
 325 void blend_xx44( uint8_t *dst_img, subpicture_t *sub_img,
 326                  int dst_width, int dst_height, int dst_pitch,
 327                  xx44_palette_t *palette, int ia44 )
 328 {
 329     int src_width;
 330     int src_height;
 331     int mask;
 332     int x_off;
 333     int y_off;
 334     int x, y;
 335     uint8_t norm_pixel,clip_pixel;
 336     uint8_t *dst_y;
 337     uint8_t *dst;
 338     uint8_t alphamask;
 339     int clip_right;
 340     int i_len, i_color;
 341     uint16_t *p_source = NULL;
 342
 343     if (!sub_img)
 344         return;
 345
 346     src_width  = sub_img->i_width;
 347     src_height = sub_img->i_height;
 348     x_off = sub_img->i_x;
 349     y_off = sub_img->i_y;
 350     alphamask = (ia44) ? 0x0F : 0xF0;
 351     p_source = (uint16_t *)sub_img->p_sys->p_data;
 352
 353     dst_y = dst_img + dst_pitch*y_off + x_off;
 354
 355     if( (x_off + sub_img->i_width) <= dst_width )
 356         clip_right = sub_img->i_width;
 357     else
 358         clip_right = dst_width - x_off;
 359
 360     if ((src_height + y_off) > dst_height)
 361         src_height = dst_height - y_off;
 362
 363     for (y = 0; y < src_height; y++)
 364     {
 365         mask = !( (y < sub_img->p_sys->i_y_start) ||
 366                   (y >= sub_img->p_sys->i_y_end) );
 367         dst = dst_y;
 368
 369         for (x = 0; x < src_width;)
 370         {
 371             i_color = *p_source & 0x3;
 372             i_len = *p_source++ >> 2;
 373
 374             if( (i_len > 0) && ((x+i_len) <= src_width) )
 375             {
 376                 /* Get the RLE part, then draw the line */
 377                 uint32_t color = (sub_img->p_sys->pi_yuv[i_color][0] << 16) |
 378                                  (sub_img->p_sys->pi_yuv[i_color][1] << 0) |
 379                                  (sub_img->p_sys->pi_yuv[i_color][2] << 8);
 380
 381                 norm_pixel = (uint8_t)(
 382                             (xx44_paletteIndex( palette,i_color, color ) << 4) |
 383                             (sub_img->p_sys->pi_alpha[i_color] & 0x0F) );
 384                 clip_pixel = (uint8_t)(
 385                             (xx44_paletteIndex( palette,i_color + OVL_PALETTE_SIZE,
 386                                                 sub_img->p_sys->pi_yuv[i_color][0] ) << 4) |
 387                             (sub_img->p_sys->pi_alpha[i_color] & 0x0F));
 388
 389                 if( !ia44 )
 390                 {
 391                     norm_pixel = ((norm_pixel & 0x0F) << 4) | ((norm_pixel & 0xF0) >> 4);
 392                     clip_pixel = ((clip_pixel & 0x0F) << 4) | ((clip_pixel & 0xF0) >> 4);
 393                 }
 394                 if( mask )
 395                 {
 396                     if( x < sub_img->p_sys->i_x_start )
 397                     {
 398                         if( (x + i_len) <= sub_img->p_sys->i_x_start )
 399                         {
 400                             memblend_xx44( dst, norm_pixel, i_len, alphamask );
 401                             dst += i_len;
 402                         }
 403                         else
 404                         {
 405                             memblend_xx44( dst, norm_pixel,
 406                                            sub_img->p_sys->i_x_start - x,
 407                                            alphamask );
 408                             dst += sub_img->p_sys->i_x_start - x;
 409                             i_len -= sub_img->p_sys->i_x_start - x;
 410                             if( i_len <= (sub_img->p_sys->i_x_end -
 411                                           sub_img->p_sys->i_x_start) )
 412                             {
 413                                 memblend_xx44( dst, clip_pixel,
 414                                                i_len, alphamask);
 415                                 dst += i_len;
 416                             }
 417                             else
 418                             {
 419                                 memblend_xx44( dst, clip_pixel,
 420                                                sub_img->p_sys->i_x_end -
 421                                                     sub_img->p_sys->i_x_start,
 422                                                alphamask );
 423                                 dst += (sub_img->p_sys->i_x_end -
 424                                         sub_img->p_sys->i_x_start);
 425                                 i_len -= (sub_img->p_sys->i_x_end -
 426                                           sub_img->p_sys->i_x_start);
 427                                 memblend_xx44( dst, norm_pixel,
 428                                                i_len, alphamask );
 429                                 dst += i_len;
 430                             }
 431                         }
 432                     }
 433                     else if( x < sub_img->p_sys->i_x_end )
 434                     {
 435                         if( i_len <= (sub_img->p_sys->i_x_end - x) )
 436                         {
 437                             memblend_xx44( dst, clip_pixel, i_len, alphamask);
 438                             dst += i_len;
 439                         }
 440                         else
 441                         {
 442                             memblend_xx44( dst, clip_pixel,
 443                                            sub_img->p_sys->i_x_end - x,
 444                                            alphamask);
 445                             dst += (sub_img->p_sys->i_x_end - x);
 446                             i_len -= (sub_img->p_sys->i_x_end - x);
 447                             memblend_xx44( dst, norm_pixel, i_len, alphamask);
 448                             dst += i_len;
 449                         }
 450                     }
 451                     else
 452                     {
 453                         memblend_xx44( dst, norm_pixel, i_len, alphamask );
 454                         dst += i_len;
 455                     }
 456                 }
 457                 else
 458                 {
 459                     memblend_xx44( dst, norm_pixel, i_len, alphamask );
 460                     dst += i_len;
 461                 }
 462             }
 463             else
 464             {
 465                 return;
 466             }
 467             x += i_len;
 468         }
 469         dst_y += dst_pitch;
 470     }
 471 }
 472
 473 int xxmc_xvmc_surface_valid( vout_thread_t *p_vout, XvMCSurface *surf )
 474 {
 475     xvmc_surface_handler_t *handler = &p_vout->p_sys->xvmc_surf_handler;
 476     unsigned int index = surf - handler->surfaces;
 477     int ret;
 478
 479     if (index >= XVMC_MAX_SURFACES)
 480         return 0;
 481     pthread_mutex_lock(&handler->mutex);
 482     ret = handler->surfValid[index];
 483     pthread_mutex_unlock(&handler->mutex);
 484     return ret;
 485 }
 486
 487 static void xxmc_xvmc_dump_subpictures( vout_thread_t *p_vout )
 488 {
 489     int i;
 490     xvmc_surface_handler_t *handler = &p_vout->p_sys->xvmc_surf_handler;
 491
 492     for( i=0; i < XVMC_MAX_SUBPICTURES; ++i )
 493     {
 494         msg_Dbg( p_vout, "handler in use %d, valid %d",
 495                          handler->subInUse[i],
 496                          handler->subValid[i]);
 497     }
 498 }
 499
 500 XvMCSubpicture *xxmc_xvmc_alloc_subpicture( vout_thread_t *p_vout,
 501                     XvMCContext *context, unsigned short width,
 502                     unsigned short height, int xvimage_id )
 503 {
 504     int i;
 505     xvmc_surface_handler_t *handler = &p_vout->p_sys->xvmc_surf_handler;
 506     int status;
 507
 508     pthread_mutex_lock(&handler->mutex);
 509     /* xxmc_xvmc_dump_subpictures(p_vout); */
 510     for( i=0; i<XVMC_MAX_SUBPICTURES; ++i )
 511     {
 512         if( handler->subValid[i] && !handler->subInUse[i] )
 513         {
 514             XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
 515             if( XvMCGetSubpictureStatus( p_vout->p_sys->p_display,
 516                                          handler->subpictures + i,
 517                                          &status ) )
 518             {
 519                 XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 520                 continue;
 521             }
 522             XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 523             if( status & XVMC_DISPLAYING )
 524                 continue;
 525             handler->subInUse[i] = 1;
 526             /* xxmc_xvmc_dump_subpictures(p_vout); */
 527             pthread_mutex_unlock(&handler->mutex);
 528             return (handler->subpictures + i);
 529         }
 530     }
 531     for (i=0; i<XVMC_MAX_SUBPICTURES; ++i)
 532     {
 533         if( !handler->subInUse[i] )
 534         {
 535             XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
 536             if( Success != XvMCCreateSubpicture( p_vout->p_sys->p_display,
 537                                                  context,
 538                                                  handler->subpictures + i,
 539                                                  width, height, xvimage_id ) )
 540             {
 541                 XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 542                 pthread_mutex_unlock( &handler->mutex );
 543                 return NULL;
 544             }
 545             XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 546             msg_Dbg( p_vout, "video_out_xxmc: created subpicture %d\n", i );
 547             handler->subInUse[i] = 1;
 548             handler->subValid[i] = 1;
 549             pthread_mutex_unlock( &handler->mutex );
 550             return (handler->subpictures + i);
 551         }
 552     }
 553     pthread_mutex_unlock( &handler->mutex );
 554     return NULL;
 555 }
 556
 557 void xxmc_xvmc_free_subpicture( vout_thread_t *p_vout, XvMCSubpicture *sub )
 558 {
 559     xvmc_surface_handler_t *handler = &p_vout->p_sys->xvmc_surf_handler;
 560     unsigned int index = sub - handler->subpictures;
 561
 562     if( index >= XVMC_MAX_SUBPICTURES )
 563         return;
 564
 565     pthread_mutex_lock( &handler->mutex );
 566     handler->subInUse[index] = 0;
 567     /* xxmc_xvmc_dump_subpictures(p_vout); */
 568     pthread_mutex_unlock( &handler->mutex );
 569 }
 570
 571 static void xxmc_xvmc_surface_handler_construct( vout_thread_t *p_vout )
 572 {
 573     int i;
 574     xvmc_surface_handler_t *handler = &p_vout->p_sys->xvmc_surf_handler;
 575
 576     pthread_mutex_init( &handler->mutex, NULL );
 577     for( i=0; i<XVMC_MAX_SURFACES; ++i )
 578     {
 579         handler->surfInUse[i] = 0;
 580         handler->surfValid[i] = 0;
 581     }
 582     for( i=0; i<XVMC_MAX_SUBPICTURES; ++i )
 583     {
 584         handler->subInUse[i] = 0;
 585         handler->subValid[i] = 0;
 586     }
 587 }
 588
 589 static void xxmc_xvmc_dump_surfaces( vout_thread_t *p_vout )
 590 {
 591     int i;
 592     xvmc_surface_handler_t *handler = &p_vout->p_sys->xvmc_surf_handler;
 593
 594     for (i=0; i<XVMC_MAX_SURFACES; ++i)
 595     {
 596         msg_Dbg(p_vout, "surfaces in use %d, valid %d;",
 597                         handler->surfInUse[i],
 598                         handler->surfValid[i]);
 599     }
 600 }
 601
 602 void xxmc_xvmc_free_surface( vout_thread_t *p_vout, XvMCSurface *surf )
 603 {
 604     xvmc_surface_handler_t *handler = &p_vout->p_sys->xvmc_surf_handler;
 605     unsigned int index = 0;
 606
 607     index = (surf - handler->surfaces);
 608
 609     if (index < XVMC_MAX_SURFACES)
 610     {
 611         pthread_mutex_lock(&handler->mutex);
 612         msg_Dbg( p_vout,"free surface %d",index );
 613         handler->surfInUse[index]--;
 614         xxmc_xvmc_dump_surfaces(p_vout);
 615         pthread_mutex_unlock(&handler->mutex);
 616     }
 617 }
 618
 619 int checkXvMCCap( vout_thread_t *p_vout )
 620 {
 621     int i_xvport = 0;
 622     int numSurf = 0;
 623     int numSub = 0;
 624     int i,j;
 625     XvMCSurfaceInfo     *surfaceInfo =NULL;
 626     XvMCSurfaceInfo     *curInfo = NULL;
 627     XvMCContext         c;
 628     xvmc_capabilities_t *curCap = NULL;
 629     XvImageFormatValues *formatValues = NULL;
 630
 631     i_xvport = p_vout->p_sys->i_xvport;
 632     p_vout->p_sys->xvmc_cap = 0;
 633
 634     init_context_lock( &p_vout->p_sys->xvmc_lock );
 635     xvmc_context_writer_lock( &p_vout->p_sys->xvmc_lock );
 636
 637     p_vout->p_sys->old_subpic = NULL;
 638     p_vout->p_sys->new_subpic = NULL;
 639     p_vout->p_sys->contextActive = 0;
 640     p_vout->p_sys->subImage = NULL;
 641     p_vout->p_sys->hwSubpictures = 0;
 642     p_vout->p_sys->xvmc_palette = NULL;
 643
 644     XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
 645
 646     if( !XvMCQueryExtension( p_vout->p_sys->p_display,
 647                              &p_vout->p_sys->xvmc_eventbase,
 648                              &p_vout->p_sys->xvmc_errbase ) )
 649     {
 650         XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 651         xvmc_context_writer_unlock( &p_vout->p_sys->xvmc_lock );
 652         return VLC_EGENERIC;
 653     }
 654     msg_Dbg( p_vout,"XvMC extension found" );
 655
 656     surfaceInfo = XvMCListSurfaceTypes(p_vout->p_sys->p_display, i_xvport, &numSurf);
 657     if( !surfaceInfo )
 658     {
 659         XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 660         xvmc_context_writer_unlock( &p_vout->p_sys->xvmc_lock );
 661         return VLC_EGENERIC;
 662     }
 663
 664     p_vout->p_sys->xvmc_cap =
 665             (xvmc_capabilities_t *) malloc( numSurf *
 666                                             sizeof(xvmc_capabilities_t) );
 667     if( !p_vout->p_sys->xvmc_cap )
 668     {
 669         XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 670         xvmc_context_writer_unlock( &p_vout->p_sys->xvmc_lock );
 671         return VLC_EGENERIC;
 672     }
 673
 674     p_vout->p_sys->xvmc_num_cap = numSurf;
 675     curInfo = surfaceInfo;
 676     curCap = p_vout->p_sys->xvmc_cap;
 677
 678     msg_Dbg( p_vout,"found %d XvMC surface types", numSurf );
 679
 680     for( i=0; i< numSurf; ++i )
 681     {
 682         curCap->mpeg_flags = 0;
 683         curCap->accel_flags = 0;
 684         if( curInfo->chroma_format == XVMC_CHROMA_FORMAT_420 )
 685         {
 686             curCap->mpeg_flags |= ((curInfo->mc_type & XVMC_MPEG_1) ?
 687                                                 VLC_XVMC_MPEG_1 : 0);
 688             curCap->mpeg_flags |= ((curInfo->mc_type & XVMC_MPEG_2) ?
 689                                                 VLC_XVMC_MPEG_2 : 0);
 690             curCap->mpeg_flags |= ((curInfo->mc_type & XVMC_MPEG_4) ?
 691                                                 VLC_XVMC_MPEG_4 : 0);
 692             curCap->accel_flags |= ((curInfo->mc_type & XVMC_VLD) ?
 693                                               VLC_XVMC_ACCEL_VLD : 0);
 694             curCap->accel_flags |= ((curInfo->mc_type & XVMC_IDCT) ?
 695                                              VLC_XVMC_ACCEL_IDCT : 0);
 696             curCap->accel_flags |= ((curInfo->mc_type & (XVMC_VLD | XVMC_IDCT)) ?
 697                                             0 : VLC_XVMC_ACCEL_MOCOMP);
 698             curCap->max_width = curInfo->max_width;
 699             curCap->max_height = curInfo->max_height;
 700             curCap->sub_max_width = curInfo->subpicture_max_width;
 701             curCap->sub_max_height = curInfo->subpicture_max_height;
 702             curCap->flags = curInfo->flags;
 703
 704             msg_Dbg (p_vout, "surface type %d: Max size: %d %d.",
 705                             i, curCap->max_width, curCap->max_height);
 706             msg_Dbg (p_vout, "surface subtype %d: Max subpic size: %d %d.",
 707                             i, curCap->sub_max_width, curCap->sub_max_height);
 708
 709             curCap->type_id = curInfo->surface_type_id;
 710             formatValues = XvMCListSubpictureTypes( p_vout->p_sys->p_display,
 711                                                     i_xvport,
 712                                                     curCap->type_id,
 713                                                     &numSub );
 714             curCap->subPicType.id = 0;
 715             if( formatValues )
 716             {
 717                 msg_Dbg( p_vout, "surface type %d: found %d XvMC subpicture types",
 718                                 i, numSub);
 719                 for( j = 0; j<numSub; ++j )
 720                 {
 721                     if( formatValues[j].id == FOURCC_IA44 )
 722                     {
 723                         curCap->subPicType = formatValues[j];
 724                         msg_Dbg( p_vout,
 725                                     "surface type %d: detected and using "
 726                                     "IA44 subpicture type.", i );
 727                         /* Prefer IA44 */
 728                         break;
 729                     }
 730                     else if( formatValues[j].id == FOURCC_AI44 )
 731                     {
 732                         curCap->subPicType = formatValues[j];
 733                         msg_Dbg( p_vout,
 734                                  "surface type %d: detected AI44 "
 735                                  "subpicture type.", i );
 736                     }
 737                 }
 738             }
 739             XFree(formatValues);
 740             curInfo++;
 741             curCap++;
 742         }
 743     }
 744     XFree(surfaceInfo);
 745
 746     /*
 747     * Try to create a direct rendering context. This will fail if we are not
 748     * on the displaying computer or an indirect context is not available.
 749     */
 750     XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 751     curCap = p_vout->p_sys->xvmc_cap;
 752     if( Success == XvMCCreateContext( p_vout->p_sys->p_display, i_xvport,
 753                                       curCap->type_id,
 754                                       curCap->max_width,
 755                                       curCap->max_height,
 756                                       XVMC_DIRECT, &c) )
 757     {
 758             p_vout->p_sys->context_flags = XVMC_DIRECT;
 759     }
 760     else if( Success == XvMCCreateContext( p_vout->p_sys->p_display, i_xvport,
 761                                            curCap->type_id,
 762                                            curCap->max_width,
 763                                            curCap->max_height,
 764                                            0, &c) )
 765     {
 766         p_vout->p_sys->context_flags = 0;
 767     }
 768     else
 769     {
 770         if( p_vout->p_sys->xvmc_cap )
 771             free( p_vout->p_sys->xvmc_cap );
 772         p_vout->p_sys->xvmc_cap = NULL;
 773         msg_Err( p_vout, "use of direct XvMC context on a remote display failed"
 774                          " falling back to XV." );
 775         xvmc_context_writer_unlock( &p_vout->p_sys->xvmc_lock );
 776         return VLC_SUCCESS;
 777     }
 778     XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
 779     XvMCDestroyContext( p_vout->p_sys->p_display, &c );
 780     xxmc_xvmc_surface_handler_construct(p_vout );
 781     /*  p_vout->p_sys->capabilities |= VO_CAP_XXMC; */
 782     XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 783     init_xx44_palette( &p_vout->p_sys->palette , 0 );
 784     p_vout->p_sys->last_accel_request = 0xFFFFFFFF;
 785     xvmc_context_writer_unlock( &p_vout->p_sys->xvmc_lock );
 786     return VLC_SUCCESS;
 787 }
 788
 789 static int xxmc_setup_subpictures( vout_thread_t *p_vout,
 790         unsigned int width, unsigned int height )
 791 {
 792     xvmc_capabilities_t *curCap = NULL;
 793     XvMCSubpicture *sp = NULL;
 794
 795     if( p_vout->p_sys->contextActive )
 796     {
 797         curCap = p_vout->p_sys->xvmc_cap + p_vout->p_sys->xvmc_cur_cap;
 798
 799         if( (width > curCap->sub_max_width) ||
 800             (height > curCap->sub_max_height) )
 801             return VLC_EGENERIC;
 802
 803         if( (p_vout->p_sys->xvmc_backend_subpic =
 804                 (curCap->flags & XVMC_BACKEND_SUBPICTURE)) )
 805             msg_Dbg( p_vout, "using backend subpictures." );
 806
 807         if (!p_vout->p_sys->subImage)
 808         {
 809             XLockDisplay( p_vout->p_sys->p_display );
 810             msg_Dbg(p_vout, "xxmc_setup_subpictures");
 811 #ifdef HAVE_SYS_SHM_H
 812             if( p_vout->p_sys->i_shm_opcode )
 813             {
 814                 /* Create image using XShm extension */
 815                 p_vout->p_sys->subImage = CreateShmImage( p_vout,
 816                                             p_vout->p_sys->p_display,
 817                                             p_vout->p_sys->i_xvport,
 818                                             curCap->subPicType.id,
 819                                             /* VLC2X11_FOURCC( p_vout->output. i_chroma ), */
 820                                             &p_vout->p_sys->subShmInfo,
 821                                             p_vout->output.i_width,
 822                                             p_vout->output.i_height );
 823             }
 824 #endif /* HAVE_SYS_SHM_H */
 825             XUnlockDisplay( p_vout->p_sys->p_display );
 826             if( !p_vout->p_sys->subImage )
 827             {
 828                 msg_Dbg(p_vout, "failed allocating XvImage for supbictures" );
 829                 return VLC_EGENERIC;
 830             }
 831         }
 832
 833         sp = xxmc_xvmc_alloc_subpicture( p_vout, &p_vout->p_sys->context,
 834                                          width, height,
 835                                          curCap->subPicType.id );
 836         if( sp )
 837         {
 838             init_xx44_palette( &p_vout->p_sys->palette, sp->num_palette_entries );
 839             p_vout->p_sys->xvmc_palette = (char *) malloc( sp->num_palette_entries
 840                     * sp->entry_bytes );
 841             xxmc_xvmc_free_subpicture( p_vout, sp);
 842             if( !p_vout->p_sys->xvmc_palette )
 843                 return VLC_EGENERIC;
 844             p_vout->p_sys->hwSubpictures = 1;
 845         }
 846     }
 847     return VLC_SUCCESS;
 848 }
 849
 850 static void xvmc_check_colorkey_properties( vout_thread_t *p_vout )
 851 {
 852     int num,i;
 853     XvAttribute *xvmc_attributes = NULL;
 854     Atom ap;
 855
 856     /*
 857     * Determine if the context is of "Overlay" type. If so,
 858     * check whether we can autopaint.
 859     */
 860     p_vout->p_sys->have_xvmc_autopaint = 0;
 861     if( p_vout->p_sys->context_flags & XVMC_OVERLAID_SURFACE )
 862     {
 863         msg_Dbg( p_vout, "check colorkey properties" );
 864         XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
 865         xvmc_attributes = XvMCQueryAttributes( p_vout->p_sys->p_display,
 866                                                &p_vout->p_sys->context,
 867                                                &num );
 868         if( xvmc_attributes )
 869         {
 870             for( i = 0; i < num; ++i )
 871             {
 872                 if( strncmp( "XV_AUTOPAINT_COLORKEY",
 873                              xvmc_attributes[i].name,
 874                              21) == 0)
 875                 {
 876                     ap = XInternAtom( p_vout->p_sys->p_display,
 877                                       "XV_AUTOPAINT_COLORKEY",
 878                                        False );
 879                     XvMCSetAttribute( p_vout->p_sys->p_display,
 880                                       &p_vout->p_sys->context,
 881                                       ap,
 882                                       1 ); /* p_vout->p_sys->props[VO_PROP_AUTOPAINT_COLORKEY].value */
 883                     p_vout->p_sys->have_xvmc_autopaint = 1;
 884                     msg_Dbg( p_vout, "has xvmc autopaint" );
 885                 }
 886             }
 887         }
 888         XFree( xvmc_attributes );
 889         XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 890         /* p_vout->p_sys->xvmc_xoverlay_type = X11OSD_COLORKEY; */
 891     }
 892 #if 0
 893     else
 894     {
 895         p_vout->p_sys->xvmc_xoverlay_type = X11OSD_SHAPED;
 896     }
 897 #endif
 898 }
 899
 900 static void xxmc_xvmc_destroy_surfaces( vout_thread_t *p_vout )
 901 {
 902     int i;
 903     xvmc_surface_handler_t *handler = NULL;
 904
 905     handler = &p_vout->p_sys->xvmc_surf_handler;
 906
 907     pthread_mutex_lock( &handler->mutex );
 908     for( i = 0; i < XVMC_MAX_SURFACES; ++i )
 909     {
 910         XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
 911         if( handler->surfValid[i] )
 912         {
 913             XvMCFlushSurface( p_vout->p_sys->p_display , handler->surfaces+i);
 914             XvMCSyncSurface( p_vout->p_sys->p_display, handler->surfaces+i );
 915             XvMCHideSurface( p_vout->p_sys->p_display, handler->surfaces+i );
 916             XvMCDestroySurface( p_vout->p_sys->p_display, handler->surfaces+i );
 917         }
 918         XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 919         handler->surfValid[i] = 0;
 920     }
 921     pthread_mutex_unlock( &handler->mutex );
 922 }
 923
 924 static void xxmc_xvmc_destroy_subpictures( vout_thread_t *p_vout )
 925 {
 926     int i;
 927     xvmc_surface_handler_t *handler = NULL;
 928
 929     handler = &p_vout->p_sys->xvmc_surf_handler;
 930
 931     pthread_mutex_lock( &handler->mutex );
 932     for( i = 0; i < XVMC_MAX_SUBPICTURES; ++i )
 933     {
 934         XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
 935         if( handler->subValid[i] )
 936         {
 937             XvMCFlushSubpicture( p_vout->p_sys->p_display , handler->subpictures+i);
 938             XvMCSyncSubpicture( p_vout->p_sys->p_display, handler->subpictures+i );
 939             XvMCDestroySubpicture( p_vout->p_sys->p_display, handler->subpictures+i );
 940         }
 941         XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 942         handler->subValid[i] = 0;
 943     }
 944     pthread_mutex_unlock( &handler->mutex );
 945 }
 946
 947 static XvMCSurface *xxmc_xvmc_alloc_surface( vout_thread_t *p_vout,
 948         XvMCContext *context )
 949 {
 950     xvmc_surface_handler_t *handler = NULL;
 951     int i;
 952
 953     handler = &p_vout->p_sys->xvmc_surf_handler;
 954
 955     pthread_mutex_lock( &handler->mutex );
 956     xxmc_xvmc_dump_surfaces( p_vout );
 957     for( i = 0; i < XVMC_MAX_SURFACES; ++i )
 958     {
 959         if( handler->surfValid[i] && !handler->surfInUse[i] )
 960         {
 961             handler->surfInUse[i] = 1;
 962             xxmc_xvmc_dump_surfaces( p_vout );
 963             pthread_mutex_unlock( &handler->mutex );
 964             return (handler->surfaces + i);
 965         }
 966     }
 967     for( i = 0; i < XVMC_MAX_SURFACES; ++i )
 968     {
 969         if( !handler->surfInUse[i] )
 970         {
 971             XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
 972             if( Success != XvMCCreateSurface( p_vout->p_sys->p_display,
 973                                               context,
 974                                               handler->surfaces + i) )
 975             {
 976                 XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 977                 pthread_mutex_unlock( &handler->mutex );
 978                 return NULL;
 979             }
 980             XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
 981
 982             msg_Dbg( p_vout, "created surface %d", i );
 983             handler->surfInUse[i] = 1;
 984             handler->surfValid[i] = 1;
 985             pthread_mutex_unlock( &handler->mutex );
 986             return (handler->surfaces + i);
 987         }
 988     }
 989     pthread_mutex_unlock( &handler->mutex );
 990     return NULL;
 991 }
 992
 993 void xxmc_dispose_context( vout_thread_t *p_vout )
 994 {
 995     if( p_vout->p_sys->contextActive )
 996     {
 997         if( p_vout->p_sys->xvmc_accel &
 998             (VLC_XVMC_ACCEL_MOCOMP | VLC_XVMC_ACCEL_IDCT) )
 999         {
1000             xvmc_macroblocks_t *macroblocks = NULL;
1001
1002             macroblocks = &p_vout->p_sys->macroblocks;
1003             XvMCDestroyMacroBlocks( p_vout->p_sys->p_display,
1004                                     &macroblocks->macro_blocks );
1005             XvMCDestroyBlocks( p_vout->p_sys->p_display,
1006                                &macroblocks->blocks );
1007         }
1008
1009         msg_Dbg( p_vout, "freeing up XvMC surfaces and subpictures" );
1010         if( p_vout->p_sys->xvmc_palette )
1011             free( p_vout->p_sys->xvmc_palette );
1012         dispose_xx44_palette( &p_vout->p_sys->palette );
1013         xxmc_xvmc_destroy_subpictures( p_vout );
1014         xxmc_xvmc_destroy_surfaces( p_vout );
1015
1016         msg_Dbg(p_vout, "freeing up XvMC Context.");
1017         XLockDisplay( p_vout->p_sys->p_display );
1018         if( p_vout->p_sys->subImage )
1019         {
1020             XFree( p_vout->p_sys->subImage );
1021             p_vout->p_sys->subImage = NULL;
1022         }
1023         p_vout->p_sys->subImage = NULL;
1024         XUnlockDisplay( p_vout->p_sys->p_display );
1025         XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
1026         XvMCDestroyContext( p_vout->p_sys->p_display,
1027                             &p_vout->p_sys->context );
1028         XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
1029         p_vout->p_sys->contextActive = 0;
1030         p_vout->p_sys->hwSubpictures = 0;
1031         p_vout->p_sys->xvmc_accel = 0;
1032     }
1033 }
1034
1035 static int xxmc_find_context( vout_thread_t *p_vout, vlc_xxmc_t *xxmc,
1036         unsigned int width, unsigned int height )
1037 {
1038     unsigned int i, k;
1039     vlc_bool_t found = VLC_FALSE;
1040     xvmc_capabilities_t *curCap = NULL;
1041     unsigned int request_mpeg_flags, request_accel_flags;
1042
1043     request_mpeg_flags = xxmc->mpeg;
1044     for( k = 0; k < NUM_ACCEL_PRIORITY; ++k )
1045     {
1046         request_accel_flags = xxmc->acceleration & accel_priority[k];
1047         if( !request_accel_flags )
1048             continue;
1049
1050         curCap = p_vout->p_sys->xvmc_cap;
1051         for( i =0; i < p_vout->p_sys->xvmc_num_cap; ++i )
1052         {
1053             msg_Dbg( p_vout, "surface type %d, capabilities 0x%8x 0x%8x",
1054                              i,
1055                              curCap->mpeg_flags,
1056                              curCap->accel_flags );
1057             msg_Dbg( p_vout, "fequests: 0x%8x 0x%8x",
1058                              request_mpeg_flags,
1059                              request_accel_flags );
1060             if( ( (curCap->mpeg_flags & request_mpeg_flags) == request_mpeg_flags) &&
1061                   (curCap->accel_flags & request_accel_flags) &&
1062                   (width <= curCap->max_width) &&
1063                   (height <= curCap->max_height) )
1064             {
1065                 found = VLC_TRUE;
1066                 break;
1067             }
1068             curCap++;
1069         }
1070         if( found )
1071         {
1072             p_vout->p_sys->xvmc_cur_cap = i;
1073             break;
1074         }
1075     }
1076     if( found )
1077     {
1078         p_vout->p_sys->xvmc_accel = request_accel_flags;
1079         p_vout->p_sys->unsigned_intra = (curCap->flags & XVMC_INTRA_UNSIGNED);
1080         return 1;
1081     }
1082     p_vout->p_sys->xvmc_accel = 0;
1083     return 0;
1084 }
1085
1086 static int xxmc_create_context( vout_thread_t *p_vout,
1087         unsigned int width, unsigned int height )
1088 {
1089     xvmc_capabilities_t *curCap = NULL;
1090
1091     curCap = p_vout->p_sys->xvmc_cap + p_vout->p_sys->xvmc_cur_cap;
1092
1093     msg_Dbg( p_vout, "creating new XvMC context %d", curCap->type_id );
1094
1095     XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
1096     if( Success == XvMCCreateContext( p_vout->p_sys->p_display,
1097                                       p_vout->p_sys->i_xvport,
1098                                       curCap->type_id,
1099                                       width,
1100                                       height,
1101                                       p_vout->p_sys->context_flags,
1102                                       &p_vout->p_sys->context ) )
1103     {
1104         p_vout->p_sys->xvmc_mpeg = curCap->mpeg_flags;
1105         p_vout->p_sys->xvmc_width = width;
1106         p_vout->p_sys->xvmc_height = height;
1107         p_vout->p_sys->contextActive = 1;
1108     }
1109     XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
1110     return p_vout->p_sys->contextActive;
1111 }
1112
1113 static void xvmc_flushsync(picture_t *picture)
1114 {
1115     vout_thread_t *p_vout = picture->p_sys->p_vout;
1116
1117     xvmc_context_reader_lock( &p_vout->p_sys->xvmc_lock );
1118
1119     if( ! xxmc_xvmc_surface_valid( p_vout, picture->p_sys->xvmc_surf)) {
1120         msg_Dbg(p_vout, "xvmc_flushsync 1 : %d", picture->p_sys->xxmc_data.result );
1121         picture->p_sys->xxmc_data.result = 128;
1122         xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
1123         return;
1124     }
1125
1126     XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
1127     picture->p_sys->xxmc_data.result =
1128             XvMCFlushSurface( p_vout->p_sys->p_display,
1129                               picture->p_sys->xvmc_surf );
1130     XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
1131     xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
1132 }
1133
1134 static void xvmc_flush(picture_t *picture)
1135 {
1136     vout_thread_t *p_vout = picture->p_sys->p_vout;
1137
1138     xvmc_context_reader_lock( &p_vout->p_sys->xvmc_lock );
1139
1140     if ( !xxmc_xvmc_surface_valid( p_vout, picture->p_sys->xvmc_surf ) )
1141     {
1142         msg_Dbg(p_vout, "xvmc flush 1 : %d", picture->p_sys->xxmc_data.result );
1143         picture->p_sys->xxmc_data.result = 128;
1144         xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
1145         return;
1146     }
1147
1148     XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
1149     picture->p_sys->xxmc_data.result =
1150             XvMCFlushSurface( p_vout->p_sys->p_display,
1151                               picture->p_sys->xvmc_surf );
1152     XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
1153     xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
1154 }
1155
1156 static int xxmc_frame_updates( vout_thread_t *p_vout, picture_t *picture )
1157 {
1158     vlc_xxmc_t *xxmc = &picture->p_sys->xxmc_data;
1159
1160     /*
1161      * If we have changed context since the surface was updated, xvmc_surf
1162      * is either NULL or invalid. If it is invalid. Set it to NULL.
1163      * Also if there are other users of this surface, deregister our use of
1164      * it and later try to allocate a new, fresh one.
1165      */
1166
1167     if( picture->p_sys->xvmc_surf )
1168     {
1169         if( !xxmc_xvmc_surface_valid( p_vout, picture->p_sys->xvmc_surf ) )
1170         {
1171             xxmc_xvmc_free_surface( p_vout , picture->p_sys->xvmc_surf );
1172             picture->p_sys->xvmc_surf = NULL;
1173         }
1174     }
1175 #if 0
1176     if( picture->p_sys->p_image )
1177     {
1178         memset( picture->p_sys->p_image->data, 0,
1179                 picture->p_sys->p_image->width
1180                     * picture->p_sys->p_image->height );
1181     }
1182 #endif
1183     /*
1184      * If it is NULL create a new surface.
1185      */
1186     if( !picture->p_sys->xvmc_surf )
1187     {
1188         picture->p_sys->xvmc_surf = xxmc_xvmc_alloc_surface( p_vout,
1189                                                     &p_vout->p_sys->context );
1190         if( !picture->p_sys->xvmc_surf )
1191         {
1192             msg_Err( p_vout, "accelerated surface allocation failed.\n"
1193                             " You are probably out of framebuffer memory.\n"
1194                             " Falling back to software decoding." );
1195             p_vout->p_sys->xvmc_accel = 0;
1196             xxmc_dispose_context( p_vout );
1197             return VLC_EGENERIC;
1198         }
1199     }
1200     xxmc->acceleration = p_vout->p_sys->xvmc_accel;
1201
1202     xxmc->proc_xxmc_flush = xvmc_flush;
1203     xxmc->proc_xxmc_flushsync = xvmc_flushsync;
1204     xxmc->xvmc.proc_macro_block = NULL;
1205 #if 0
1206     frame->vo_frame.proc_duplicate_frame_data = xxmc_duplicate_frame_data;
1207 #endif
1208     xxmc->proc_xxmc_begin = xvmc_vld_frame;
1209     xxmc->proc_xxmc_slice = xvmc_vld_slice;
1210     return VLC_SUCCESS;
1211 }
1212
1213 static int xxmc_xvmc_update_context( vout_thread_t *p_vout,
1214     picture_t *picture, uint32_t width, uint32_t height )
1215 {
1216     vlc_xxmc_t *xxmc = &picture->p_sys->xxmc_data;
1217
1218     /*
1219      * Are we at all capable of doing XvMC ?
1220      */
1221     if( p_vout->p_sys->xvmc_cap == 0 )
1222         return VLC_EGENERIC;
1223
1224     msg_Dbg( p_vout, "new format: need to change XvMC context. "
1225                      "width: %d height: %d mpeg: %d acceleration: %d",
1226                      width, height,
1227                      xxmc->mpeg, xxmc->acceleration );
1228
1229     if( picture->p_sys->xvmc_surf )
1230         xxmc_xvmc_free_surface( p_vout , picture->p_sys->xvmc_surf );
1231     picture->p_sys->xvmc_surf = NULL;
1232
1233     xxmc_dispose_context( p_vout );
1234
1235     if( xxmc_find_context( p_vout, xxmc, width, height ) )
1236     {
1237         xxmc_create_context( p_vout, width, height);
1238         xvmc_check_colorkey_properties( p_vout );
1239         xxmc_setup_subpictures(p_vout, width, height);
1240     }
1241
1242     if( !p_vout->p_sys->contextActive )
1243     {
1244         msg_Dbg( p_vout, "using software decoding for this stream" );
1245         p_vout->p_sys->xvmc_accel = 0;
1246     }
1247     else
1248     {
1249         msg_Dbg(p_vout, "using hardware decoding for this stream." );
1250     }
1251
1252     p_vout->p_sys->xvmc_mpeg = xxmc->mpeg;
1253     p_vout->p_sys->xvmc_width = width;
1254     p_vout->p_sys->xvmc_height = height;
1255     return p_vout->p_sys->contextActive;
1256 }
1257
1258
1259 void xxmc_do_update_frame( picture_t *picture, uint32_t width, uint32_t height,
1260         double ratio, int format, int flags)
1261 {
1262     vout_thread_t *p_vout = picture->p_sys->p_vout;
1263     int indextime = 0;
1264     int status = 0;
1265
1266     picture->p_sys->xxmc_data.decoded = 0;
1267     picture->p_sys->nb_display = 0;
1268     picture->b_force = 0;
1269     vlc_xxmc_t *xxmc = &picture->p_sys->xxmc_data;
1270
1271     xvmc_context_writer_lock( &p_vout->p_sys->xvmc_lock);
1272     if( (p_vout->p_sys->last_accel_request != xxmc->acceleration) ||
1273         (p_vout->p_sys->xvmc_mpeg != xxmc->mpeg) ||
1274         (p_vout->p_sys->xvmc_width != width) ||
1275         (p_vout->p_sys->xvmc_height != height))
1276     {
1277         p_vout->p_sys->last_accel_request = xxmc->acceleration;
1278         xxmc_xvmc_update_context( p_vout, picture, width, height );
1279     }
1280
1281     if( p_vout->p_sys->contextActive )
1282         xxmc_frame_updates( p_vout, picture );
1283
1284     if( !p_vout->p_sys->contextActive )
1285     {
1286         xxmc->acceleration = 0;
1287         xxmc->xvmc.macroblocks = 0;
1288     }
1289     else
1290     {
1291         picture->format.i_chroma = format;
1292     }
1293     xvmc_context_writer_unlock( &p_vout->p_sys->xvmc_lock);
1294
1295     XvMCGetSurfaceStatus( p_vout->p_sys->p_display,
1296                           picture->p_sys->xvmc_surf,
1297                           &status );
1298     /* Wait a little till frame is being displayed */
1299     while( status & XVMC_DISPLAYING )
1300     {
1301         msleep(1);
1302
1303         XvMCGetSurfaceStatus( p_vout->p_sys->p_display,
1304                               picture->p_sys->xvmc_surf,
1305                               &status );
1306
1307         indextime++;
1308         if( indextime > 4 )
1309             break;
1310     }
1311 }
1312
1313 #if 0
1314 /* called xlocked */
1315 static void dispose_ximage( vout_thread_t *p_vout, XShmSegmentInfo *shminfo,
1316                 XvImage *myimage )
1317 {
1318 # ifdef HAVE_SYS_SHM_H
1319     if( p_vout->p_sys->i_shm_opcode )
1320     {
1321         XShmDetach( p_vout->p_sys->p_display, shminfo );
1322         XFree( myimage );
1323         shmdt( shminfo->shmaddr );
1324         if( shminfo->shmid >= 0 )
1325         {
1326             shmctl( shminfo->shmid, IPC_RMID, 0 );
1327             shminfo->shmid = -1;
1328         }
1329     }
1330     else
1331 #endif
1332     {
1333         if( myimage->data )
1334             free(myimage->data);
1335         XFree (myimage);
1336     }
1337 }
1338 #endif
1339
1340 void xvmc_vld_frame( picture_t *picture )
1341 {
1342     picture_sys_t *p_sys  = picture->p_sys;
1343     vout_thread_t *p_vout = p_sys->p_vout;
1344     vlc_vld_frame_t *vft  = &(p_sys->xxmc_data.vld_frame);
1345     picture_t *ff         = (picture_t *) vft->forward_reference_picture;
1346     picture_t *bf         = (picture_t *) vft->backward_reference_picture;
1347     XvMCMpegControl ctl;
1348     XvMCSurface *fs=0, *bs=0;
1349     XvMCQMatrix qmx;
1350
1351     ctl.BHMV_range = vft->mv_ranges[0][0];
1352     ctl.BVMV_range = vft->mv_ranges[0][1];
1353     ctl.FHMV_range = vft->mv_ranges[1][0];
1354     ctl.FVMV_range = vft->mv_ranges[1][1];
1355     ctl.picture_structure = vft->picture_structure;
1356     ctl.intra_dc_precision = vft->intra_dc_precision;
1357     ctl.picture_coding_type = vft->picture_coding_type;
1358     ctl.mpeg_coding = (vft->mpeg_coding == 0) ? XVMC_MPEG_1 : XVMC_MPEG_2;
1359     ctl.flags = 0;
1360     ctl.flags |= (vft->progressive_sequence) ? XVMC_PROGRESSIVE_SEQUENCE : 0;
1361     ctl.flags |= (vft->scan) ? XVMC_ALTERNATE_SCAN : XVMC_ZIG_ZAG_SCAN;
1362     ctl.flags |= (vft->pred_dct_frame) ?
1363                     XVMC_PRED_DCT_FRAME : XVMC_PRED_DCT_FIELD;
1364     ctl.flags |= (picture->b_top_field_first) ?
1365                     XVMC_TOP_FIELD_FIRST : XVMC_BOTTOM_FIELD_FIRST;
1366     ctl.flags |= (vft->concealment_motion_vectors) ?
1367                     XVMC_CONCEALMENT_MOTION_VECTORS : 0;
1368     ctl.flags |= (vft->q_scale_type) ? XVMC_Q_SCALE_TYPE : 0;
1369     ctl.flags |= (vft->intra_vlc_format) ? XVMC_INTRA_VLC_FORMAT : 0;
1370     ctl.flags |= (vft->second_field) ? XVMC_SECOND_FIELD : 0;
1371
1372     if( ff )
1373         fs = ff->p_sys->xvmc_surf;
1374     if( bf )
1375         bs = bf->p_sys->xvmc_surf;
1376
1377     /*
1378      * Below is for interlaced streams and second_field.
1379      */
1380     if( ctl.picture_coding_type == P_TYPE ) /* XVMC_P_PICTURE) */
1381         bs = picture->p_sys->xvmc_surf;
1382
1383     if( (qmx.load_intra_quantiser_matrix = vft->load_intra_quantizer_matrix) )
1384     {
1385         memcpy( qmx.intra_quantiser_matrix, vft->intra_quantizer_matrix,
1386                 sizeof(qmx.intra_quantiser_matrix) );
1387     }
1388     if( (qmx.load_non_intra_quantiser_matrix =
1389                 vft->load_non_intra_quantizer_matrix) )
1390     {
1391         memcpy( qmx.non_intra_quantiser_matrix, vft->non_intra_quantizer_matrix,
1392                sizeof(qmx.non_intra_quantiser_matrix) );
1393     }
1394     qmx.load_chroma_intra_quantiser_matrix = 0;
1395     qmx.load_chroma_non_intra_quantiser_matrix = 0;
1396     xvmc_context_reader_lock( &p_vout->p_sys->xvmc_lock );
1397
1398     if( ! xxmc_xvmc_surface_valid( p_vout, picture->p_sys->xvmc_surf) )
1399     {
1400         picture->p_sys->xxmc_data.result = 128;
1401         xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
1402         return;
1403     }
1404
1405     XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
1406     XvMCLoadQMatrix( p_vout->p_sys->p_display, &p_vout->p_sys->context, &qmx );
1407     do {
1408         picture->p_sys->xxmc_data.result =
1409                 XvMCBeginSurface( p_vout->p_sys->p_display,
1410                                   &p_vout->p_sys->context,
1411                                   picture->p_sys->xvmc_surf,
1412                                   fs, bs, &ctl );
1413     } while( !picture->p_sys->xxmc_data.result );
1414     XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
1415     xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
1416 }
1417
1418 void xvmc_vld_slice( picture_t *picture )
1419 {
1420     picture_sys_t *p_sys  = picture->p_sys;
1421     vout_thread_t *p_vout = p_sys->p_vout;
1422
1423     xvmc_context_reader_lock( &p_vout->p_sys->xvmc_lock );
1424     if( !xxmc_xvmc_surface_valid( p_vout, picture->p_sys->xvmc_surf ) )
1425     {
1426         picture->p_sys->xxmc_data.result = 128;
1427         xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
1428         msg_Err(p_vout, "vld slice error" );
1429         return;
1430     }
1431
1432     XVMCLOCKDISPLAY( p_vout->p_sys->p_display );
1433     picture->p_sys->xxmc_data.result =
1434             XvMCPutSlice2( p_vout->p_sys->p_display,
1435                            &p_vout->p_sys->context,
1436                             (char *)picture->p_sys->xxmc_data.slice_data,
1437                             picture->p_sys->xxmc_data.slice_data_size,
1438                             picture->p_sys->xxmc_data.slice_code );
1439
1440     if( picture->p_sys->xxmc_data.result != 0 )
1441         msg_Err( p_vout, "vlc slice error %d",
1442                  picture->p_sys->xxmc_data.result );
1443     /*
1444      * If CPU-saving mode is enabled, sleep after every xxmc->sleep slice. This will free
1445      * up the cpu while the decoder is working on the slice. The value of xxmc->sleep is calculated
1446      * so that the decoder thread sleeps at most 50% of the frame delay,
1447      * assuming a 2.6 kernel clock of 1000 Hz.
1448      */
1449     XVMCUNLOCKDISPLAY( p_vout->p_sys->p_display );
1450     xvmc_context_reader_unlock( &p_vout->p_sys->xvmc_lock );
1451 #if 0
1452     if( p_vout->p_sys->cpu_save_enabled )
1453     {
1454         p_vout->p_sys->cpu_saver += 1.;
1455         if( p_vout->p_sys->cpu_saver >= picture->p_sys->xxmc_data.sleep )
1456         {
1457             usleep(1);
1458             p_vout->p_sys->cpu_saver -= picture->p_sys->xxmc_data.sleep;
1459         }
1460     }
1461 #endif
1462 }