git.sesse.net Git - vlc/blob - modules/codec/realvideo.c

   1 /*****************************************************************************
   2  * realvideo.c: a realvideo decoder that uses the real's dll
   3  *****************************************************************************
   4  * Copyright (C) 2005 the VideoLAN team
   5  * Copyright (C) 2008 Wang Bo
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  20  *****************************************************************************/
  21
  22 /*****************************************************************************
  23  * Preamble
  24  *****************************************************************************/
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include <vlc_common.h>
  30 #include <vlc_plugin.h>
  31 #include <vlc_vout.h>
  32 #include <vlc_codec.h>
  33
  34 #ifdef LOADER
  35 /* Need the w32dll loader from mplayer */
  36 #   include <wine/winerror.h>
  37 #   include <ldt_keeper.h>
  38 #   include <wine/windef.h>
  39
  40 void *WINAPI LoadLibraryA( char *name );
  41 void *WINAPI GetProcAddress( void *handle, char *func );
  42 int WINAPI FreeLibrary( void *handle );
  43 #endif
  44
  45 #ifndef WINAPI
  46 #   define WINAPI
  47 #endif
  48
  49 #if defined(HAVE_DL_DLOPEN)
  50 #   if defined(HAVE_DLFCN_H) /* Linux, BSD, Hurd */
  51 #       include <dlfcn.h>
  52 #   endif
  53 #   if defined(HAVE_SYS_DL_H)
  54 #       include <sys/dl.h>
  55 #   endif
  56 #endif
  57
  58 typedef struct cmsg_data_s
  59 {
  60     uint32_t data1;
  61     uint32_t data2;
  62     uint32_t* dimensions;
  63 } cmsg_data_t;
  64
  65 typedef struct transform_in_s
  66 {
  67     uint32_t len;
  68     uint32_t unknown1;
  69     uint32_t chunks;
  70     uint32_t* extra;
  71     uint32_t unknown2;
  72     uint32_t timestamp;
  73 } transform_in_t;
  74
  75 // copypaste from demux_real.c - it should match to get it working!
  76 typedef struct dp_hdr_s
  77 {
  78     uint32_t chunks;    // number of chunks
  79     uint32_t timestamp;    // timestamp from packet header
  80     uint32_t len;    // length of actual data
  81     uint32_t chunktab;    // offset to chunk offset array
  82 } dp_hdr_t;
  83
  84 /* we need exact positions */
  85 struct rv_init_t
  86 {
  87     short unk1;
  88     short w;
  89     short h;
  90     short unk3;
  91     int unk2;
  92     unsigned int * subformat;
  93     int unk5;
  94     unsigned int * format;
  95 } rv_init_t;
  96
  97 struct decoder_sys_t
  98 {
  99     /* library */
 100 #ifdef LOADER
 101     ldt_fs_t    *ldt_fs;
 102 #endif
 103     void        *handle;
 104     void         *rv_handle;
 105     int          inited;
 106     char         *plane;
 107 };
 108
 109 int dll_type = 1;
 110
 111 static unsigned long (*rvyuv_custom_message)(cmsg_data_t* ,void*);
 112 static unsigned long (*rvyuv_free)(void*);
 113 static unsigned long (*rvyuv_init)(void*, void*); // initdata,context
 114 static unsigned long (*rvyuv_transform)(char*, char*,transform_in_t*,unsigned int*,void*);
 115 #ifdef WIN32
 116 static unsigned long WINAPI (*wrvyuv_custom_message)(cmsg_data_t* ,void*);
 117 static unsigned long WINAPI (*wrvyuv_free)(void*);
 118 static unsigned long WINAPI (*wrvyuv_init)(void*, void*); // initdata,context
 119 static unsigned long WINAPI (*wrvyuv_transform)(char*, char*,transform_in_t*,unsigned int*,void*);
 120 #endif
 121
 122 /*****************************************************************************
 123  * Module descriptor
 124  *****************************************************************************/
 125 static int  Open ( vlc_object_t * );
 126 static void Close( vlc_object_t * );
 127
 128 //static int  OpenPacketizer( vlc_object_t * );
 129 static picture_t *DecodeVideo( decoder_t *, block_t ** );
 130
 131 vlc_module_begin ()
 132     set_description( N_("RealVideo library decoder") )
 133     set_capability( "decoder", 10 )
 134     set_category( CAT_INPUT )
 135     set_subcategory( SUBCAT_INPUT_VCODEC )
 136     set_callbacks( Open, Close )
 137 vlc_module_end ()
 138
 139
 140 /*****************************************************************************
 141  * Local prototypes
 142  *****************************************************************************/
 143
 144 #ifdef WIN32
 145 static void * load_syms(decoder_t *p_dec, const char *path)
 146 {
 147     void *handle;
 148
 149     msg_Dbg( p_dec, "opening win32 dll '%s'", path);
 150 #ifdef LOADER
 151     Setup_LDT_Keeper();
 152 #endif
 153     handle = LoadLibraryA(path);
 154     msg_Dbg( p_dec, "win32 real codec handle=%p",handle);
 155     if (!handle)
 156     {
 157         msg_Err( p_dec, "Error loading dll");
 158         return NULL;
 159     }
 160
 161     wrvyuv_custom_message = GetProcAddress(handle, "RV20toYUV420CustomMessage");
 162     wrvyuv_free = GetProcAddress(handle, "RV20toYUV420Free");
 163     wrvyuv_init = GetProcAddress(handle, "RV20toYUV420Init");
 164     wrvyuv_transform = GetProcAddress(handle, "RV20toYUV420Transform");
 165
 166     if (wrvyuv_custom_message && wrvyuv_free && wrvyuv_init && wrvyuv_transform)
 167     {
 168         dll_type = 1;
 169         return handle;
 170     }
 171     msg_Err( p_dec, "Error resolving symbols! (version incompatibility?)");
 172     FreeLibrary(handle);
 173     return NULL; // error
 174 }
 175 #else
 176 static void * load_syms_linux(decoder_t *p_dec, const char *path)
 177 {
 178     void *handle;
 179
 180     msg_Dbg( p_dec, "opening shared obj '%s'", path);
 181
 182     handle = dlopen (path, RTLD_LAZY);
 183     if (!handle)
 184     {
 185         msg_Err( p_dec,"Error: %s",dlerror());
 186         return NULL;
 187     }
 188
 189     rvyuv_custom_message = dlsym(handle, "RV20toYUV420CustomMessage");
 190     rvyuv_free = dlsym(handle, "RV20toYUV420Free");
 191     rvyuv_init = dlsym(handle, "RV20toYUV420Init");
 192     rvyuv_transform = dlsym(handle, "RV20toYUV420Transform");
 193
 194     if(rvyuv_custom_message && rvyuv_free && rvyuv_init && rvyuv_transform)
 195     {
 196         dll_type = 0;
 197         return handle;
 198     }
 199
 200     msg_Err( p_dec,"Error resolving symbols! (version incompatibility?)");
 201     dlclose(handle);
 202     return 0;
 203 }
 204 #endif
 205
 206 static vlc_mutex_t rm_mutex = VLC_STATIC_MUTEX;
 207
 208 static int InitVideo(decoder_t *p_dec)
 209 {
 210     int result;
 211     struct rv_init_t init_data;
 212     char fcc[4];
 213     char *g_decode_path;
 214
 215     int  i_vide = p_dec->fmt_in.i_extra;
 216     unsigned int *p_vide = p_dec->fmt_in.p_extra;
 217     decoder_sys_t *p_sys = malloc( sizeof( decoder_sys_t ) );
 218     memset(p_sys,0,sizeof( decoder_sys_t ) );
 219
 220     if( i_vide < 8 )
 221     {
 222             msg_Err( p_dec, "missing extra info" );
 223             free( p_sys );
 224             return VLC_EGENERIC;
 225     }
 226     if (p_sys->plane) free(p_sys->plane);
 227     p_sys->plane = malloc (p_dec->fmt_in.video.i_width*p_dec->fmt_in.video.i_height*3/2 + 1024 );
 228     if (NULL == p_sys->plane)
 229     {
 230         msg_Err( p_dec, "cannot alloc plane buffer" );
 231         free( p_sys );
 232         return VLC_EGENERIC;
 233     }
 234
 235     p_dec->p_sys = p_sys;
 236     p_dec->pf_decode_video = DecodeVideo;
 237
 238     memcpy( fcc, &p_dec->fmt_in.i_codec, 4 );
 239     init_data.unk1 = 11;
 240     init_data.w = p_dec->fmt_in.video.i_width ;
 241     init_data.h = p_dec->fmt_in.video.i_height ;
 242     init_data.unk3 = 0;
 243     init_data.unk2 = 0;
 244     init_data.subformat = (unsigned int*)p_vide[0];
 245     init_data.unk5 = 1;
 246     init_data.format = (unsigned int*)p_vide[1];
 247
 248     /* first try to load linux dlls, if failed and we're supporting win32 dlls,
 249        then try to load the windows ones */
 250     bool b_so_opened = false;
 251
 252 #ifdef WIN32
 253     g_decode_path="plugins\\drv43260.dll";
 254
 255     if( (p_sys->rv_handle = load_syms(p_dec, g_decode_path)) )
 256         b_so_opened = true;
 257 #else
 258     static const char psz_paths[] =
 259     {
 260         "/usr/lib/win32\0"
 261         "/usr/lib/codecs\0"
 262         "/usr/local/RealPlayer8/Codecs\0"
 263         "/usr/RealPlayer8/Codecs\0"
 264         "/usr/lib/RealPlayer8/Codecs\0"
 265         "/opt/RealPlayer8/Codecs\0"
 266         "/usr/lib/RealPlayer9/users/Real/Codecs\0"
 267         "/usr/lib/RealPlayer10/codecs\0"
 268         "/usr/lib/RealPlayer10GOLD/codecs\0"
 269         "/usr/lib/helix/player/codecs\0"
 270         "/usr/lib64/RealPlayer8/Codecs\0"
 271         "/usr/lib64/RealPlayer9/users/Real/Codecs\0"
 272         "/usr/lib64/RealPlayer10/codecs\0"
 273         "/usr/lib64/RealPlayer10GOLD/codecs\0"
 274         "/usr/local/lib/codecs\0"
 275         "\0"
 276     };
 277
 278     for( size_t i = 0; psz_paths[i]; i += strlen( psz_paths + i ) + 1 )
 279     {
 280         if( asprintf( &g_decode_path, "%s/drv4.so.6.0", psz_paths + i ) != -1 )
 281         {
 282             p_sys->rv_handle = load_syms_linux(p_dec, g_decode_path);
 283             free( g_decode_path );
 284         }
 285         if( p_sys->rv_handle )
 286         {
 287             b_so_opened = true;
 288             break;
 289         }
 290
 291         if( asprintf( &g_decode_path, "%s/drv3.so.6.0", psz_paths + i ) != -1 )
 292         {
 293             p_sys->rv_handle = load_syms_linux(p_dec, g_decode_path);
 294             free( g_decode_path );
 295         }
 296         if( p_sys->rv_handle )
 297         {
 298             b_so_opened = true;
 299             break;
 300         }
 301
 302         msg_Dbg( p_dec, "Cannot load real decoder library: %s", g_decode_path);
 303     }
 304 #endif
 305
 306     if(!b_so_opened )
 307     {
 308         msg_Err( p_dec, "Cannot any real decoder library" );
 309         free( p_sys );
 310         return VLC_EGENERIC;
 311     }
 312
 313     vlc_mutex_lock( &rm_mutex );
 314
 315     p_sys->handle=NULL;
 316     #ifdef WIN32
 317     if (dll_type == 1)
 318         result=(*wrvyuv_init)(&init_data, &p_sys->handle);
 319     else
 320     #endif
 321         result=(*rvyuv_init)(&init_data, &p_sys->handle);
 322     if (result)
 323     {
 324         msg_Err( p_dec, "Cannot Init real decoder library: %s",  g_decode_path);
 325         free( p_sys );
 326         return VLC_EGENERIC;
 327     }
 328
 329     /* setup rv30 codec (codec sub-type and image dimensions): */
 330     /*if ( p_dec->fmt_in.i_codec == VLC_FOURCC('R','V','3','0') )*/
 331     if (p_vide[1]>=0x20200002)
 332     {
 333         int i, cmsg_cnt;
 334         uint32_t cmsg24[16]={p_dec->fmt_in.video.i_width,p_dec->fmt_in.video.i_height};
 335         cmsg_data_t cmsg_data={0x24,1+(p_vide[1]&7), &cmsg24[0]};
 336         cmsg_cnt = (p_vide[1]&7)*2;
 337         if (i_vide - 8 < cmsg_cnt) {
 338                     cmsg_cnt = i_vide - 8;
 339         }
 340         for (i = 0; i < cmsg_cnt; i++)
 341             cmsg24[2+i] = p_vide[8+i]*4;
 342         #ifdef WIN32
 343         if (dll_type == 1)
 344             (*wrvyuv_custom_message)(&cmsg_data,p_sys->handle);
 345         else
 346         #endif
 347             (*rvyuv_custom_message)(&cmsg_data,p_sys->handle);
 348     }
 349     /*
 350     es_format_Init( &p_dec->fmt_out, VIDEO_ES, VLC_FOURCC( 'Y','V','1','2' ));
 351     es_format_Init( &p_dec->fmt_out, VIDEO_ES, VLC_FOURCC( 'Y','U','Y','2' ));
 352      */
 353     es_format_Init( &p_dec->fmt_out, VIDEO_ES, VLC_FOURCC( 'I', '4', '2', '0'));
 354
 355     p_dec->fmt_out.video.i_width = p_dec->fmt_in.video.i_width;
 356     p_dec->fmt_out.video.i_height= p_dec->fmt_in.video.i_height;
 357     p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR * p_dec->fmt_in.video.i_width / p_dec->fmt_in.video.i_height;
 358     p_sys->inited = 0;
 359
 360     vlc_mutex_unlock( &rm_mutex );
 361     return VLC_SUCCESS;
 362 }
 363
 364 /*****************************************************************************
 365  * Open: probe the decoder and return score
 366  *****************************************************************************
 367  * Tries to launch a decoder and return score so that the interface is able
 368  * to choose.
 369  *****************************************************************************/
 370 static int Open( vlc_object_t *p_this )
 371 {
 372     decoder_t *p_dec = (decoder_t*)p_this;
 373
 374     /* create a mutex */
 375     var_Create( p_this->p_libvlc, "rm_mutex", VLC_VAR_MUTEX );
 376
 377     switch ( p_dec->fmt_in.i_codec )
 378     {
 379     case VLC_FOURCC('R','V','1','0'):
 380     case VLC_FOURCC('R','V','2','0'):
 381     case VLC_FOURCC('R','V','3','0'):
 382     case VLC_FOURCC('R','V','4','0'):
 383         p_dec->p_sys = NULL;
 384         p_dec->pf_decode_video = DecodeVideo;
 385         return InitVideo(p_dec);
 386
 387     default:
 388         return VLC_EGENERIC;
 389     }
 390 }
 391
 392 /*****************************************************************************
 393  * Close:
 394  *****************************************************************************/
 395 static void Close( vlc_object_t *p_this )
 396 {
 397     decoder_t     *p_dec = (decoder_t*)p_this;
 398     decoder_sys_t *p_sys = p_dec->p_sys;
 399
 400     /* get lock, avoid segfault */
 401     vlc_mutex_lock( &rm_mutex );
 402
 403     #ifdef WIN32
 404     if (dll_type == 1)
 405     {
 406         if (wrvyuv_free)
 407             wrvyuv_free(p_sys->handle);
 408     }
 409     else
 410     #endif
 411         if (rvyuv_free)
 412             rvyuv_free(p_sys->handle);
 413 #ifdef WIN32
 414     if (dll_type == 1)
 415     {
 416         if (p_sys->rv_handle)
 417             FreeLibrary(p_sys->rv_handle);
 418     }
 419     else
 420 #endif
 421         p_sys->rv_handle=NULL;
 422
 423     if (p_sys->plane)
 424     {
 425         free(p_sys->plane);
 426         p_sys->plane = NULL;
 427     }
 428
 429     msg_Dbg( p_dec, "FreeLibrary ok." );
 430 #ifdef LOADER
 431     Restore_LDT_Keeper( p_sys->ldt_fs );
 432     msg_Dbg( p_dec, "Restore_LDT_Keeper" );
 433 #endif
 434     p_sys->inited = 0;
 435
 436     vlc_mutex_unlock( &rm_mutex );
 437
 438     free( p_sys );
 439 }
 440
 441 /*****************************************************************************
 442  * DecodeVideo:
 443  *****************************************************************************/
 444 static picture_t *DecodeVideo( decoder_t *p_dec, block_t **pp_block )
 445 {
 446     decoder_sys_t *p_sys = p_dec->p_sys;
 447     block_t       *p_block;
 448     picture_t     *p_pic;
 449     mtime_t       i_pts;
 450     int           result;
 451
 452     /* We must do open and close in the same thread (unless we do
 453      * Setup_LDT_Keeper in the main thread before all others */
 454     if ( pp_block == NULL || *pp_block == NULL )
 455     {
 456         return NULL;
 457     }
 458     p_block = *pp_block;
 459     *pp_block = NULL;
 460
 461     i_pts = p_block->i_pts ? p_block->i_pts : p_block->i_dts;
 462
 463     vlc_mutex_lock( &rm_mutex );
 464
 465     p_pic = decoder_NewPicture( p_dec );
 466
 467     if ( p_pic )
 468     {
 469         unsigned int transform_out[5];
 470         dp_hdr_t dp_hdr;
 471         transform_in_t transform_in;
 472         uint32_t pkg_len = ((uint32_t*)p_block->p_buffer)[0];
 473         unsigned char* dp_data=((unsigned char*)p_block->p_buffer)+8;
 474         uint32_t* extra=(uint32_t*)(((char*)p_block->p_buffer)+8+pkg_len);
 475         uint32_t img_size;
 476
 477
 478         dp_hdr.len = pkg_len;
 479         dp_hdr.chunktab = 8 + pkg_len;
 480         dp_hdr.chunks = ((uint32_t*)p_block->p_buffer)[1]-1;
 481         dp_hdr.timestamp = i_pts;
 482
 483         memset(&transform_in, 0, sizeof(transform_in_t));
 484
 485         transform_in.len = dp_hdr.len;
 486         transform_in.extra = extra;
 487         transform_in.chunks = dp_hdr.chunks;
 488         transform_in.timestamp = dp_hdr.timestamp;
 489
 490         memset (p_sys->plane, 0, p_dec->fmt_in.video.i_width * p_dec->fmt_in.video.i_height *3/2 );
 491
 492         #ifdef WIN32
 493         if (dll_type == 1)
 494             result=(*wrvyuv_transform)(dp_data, p_sys->plane, &transform_in, transform_out, p_sys->handle);
 495         else
 496         #endif
 497             result=(*rvyuv_transform)(dp_data, p_sys->plane, &transform_in, transform_out, p_sys->handle);
 498
 499         /* msg_Warn(p_dec, "Real Size %d X %d", transform_out[3],
 500                  transform_out[4]); */
 501         /* some bug rm file will print the messages :
 502                 [00000551] realvideo decoder warning: Real Size 320 X 240
 503                 [00000551] realvideo decoder warning: Real Size 480 X 272
 504                 [00000551] realvideo decoder warning: Real Size 320 X 240
 505                 [00000551] realvideo decoder warning: Real Size 320 X 240
 506                 ...
 507             so it needs fixing!
 508         */
 509         if ( p_sys->inited == 0 )
 510         {
 511             /* fix and get the correct image size! */
 512             if ( p_dec->fmt_in.video.i_width != transform_out[3]
 513              || p_dec->fmt_in.video.i_height  != transform_out[4] )
 514             {
 515                 msg_Warn(p_dec, "Warning, Real's Header give a wrong "
 516                          "information about media's width and height!"
 517                          "\tRealHeader: \t %d X %d  \t %d X %d",
 518                          p_dec->fmt_in.video.i_width,
 519                          p_dec->fmt_in.video.i_height,
 520                          transform_out[3],transform_out[4]);
 521
 522                 if ( p_dec->fmt_in.video.i_width * p_dec->fmt_in.video.i_height >= transform_out[3] * transform_out[4] )
 523                 {
 524                     p_dec->fmt_out.video.i_width =
 525                     p_dec->fmt_out.video.i_visible_width =
 526                     p_dec->fmt_in.video.i_width = transform_out[3] ;
 527
 528                     p_dec->fmt_out.video.i_height=
 529                     p_dec->fmt_out.video.i_visible_height =
 530                     p_dec->fmt_in.video.i_height= transform_out[4];
 531
 532                     p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR * p_dec->fmt_in.video.i_width / p_dec->fmt_in.video.i_height;
 533                 }
 534                 else
 535                 {
 536                     // TODO: realloc plane's size! but [in fact] it maybe not happen!
 537                     msg_Err(p_dec,"plane space not enough ,skip");
 538                 }
 539             }
 540             p_sys->inited = 1;
 541         }
 542
 543         img_size = p_dec->fmt_in.video.i_width * p_dec->fmt_in.video.i_height;
 544         memcpy( p_pic->p[0].p_pixels, p_sys->plane,  img_size);
 545         memcpy( p_pic->p[1].p_pixels, p_sys->plane + img_size, img_size/4);
 546         memcpy( p_pic->p[2].p_pixels, p_sys->plane + img_size * 5/4, img_size/4);
 547         p_pic->date = i_pts ;
 548
 549         /*  real video frame is small( frame and frame's time-shift is short),
 550             so it will become late picture easier (when render-time changed)and
 551             droped by video-output.*/
 552         p_pic->b_force = 1;
 553     }
 554
 555     vlc_mutex_unlock( &rm_mutex );
 556
 557     block_Release( p_block );
 558     return p_pic;
 559 }
 560