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'\n", path);
 150 #ifdef LOADER
 151     Setup_LDT_Keeper();
 152 #endif
 153     handle = LoadLibraryA(path);
 154     msg_Dbg( p_dec, "win32 real codec handle=%p  \n",handle);
 155     if (!handle)
 156     {
 157         msg_Err( p_dec, "Error loading dll\n");
 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?)\n");
 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'\n", path);
 181
 182     handle = dlopen (path, RTLD_LAZY);
 183     if (!handle)
 184     {
 185         msg_Err( p_dec,"Error: %s\n",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?)\n");
 201     dlclose(handle);
 202     return 0;
 203 }
 204 #endif
 205
 206 static int InitVideo(decoder_t *p_dec)
 207 {
 208     int result;
 209     struct rv_init_t init_data;
 210     char fcc[4];
 211     vlc_mutex_t  *lock;
 212     char *g_decode_path;
 213
 214     int  i_vide = p_dec->fmt_in.i_extra;
 215     unsigned int *p_vide = p_dec->fmt_in.p_extra;
 216     decoder_sys_t *p_sys = malloc( sizeof( decoder_sys_t ) );
 217     memset(p_sys,0,sizeof( decoder_sys_t ) );
 218
 219     if( i_vide < 8 )
 220     {
 221             msg_Err( p_dec, "missing extra info" );
 222             free( p_sys );
 223             return VLC_EGENERIC;
 224     }
 225     if (p_sys->plane) free(p_sys->plane);
 226     p_sys->plane = malloc (p_dec->fmt_in.video.i_width*p_dec->fmt_in.video.i_height*3/2 + 1024 );
 227     if (NULL == p_sys->plane)
 228     {
 229         msg_Err( p_dec, "cannot alloc plane buffer" );
 230         free( p_sys );
 231         return VLC_EGENERIC;
 232     }
 233
 234     p_dec->p_sys = p_sys;
 235     p_dec->pf_decode_video = DecodeVideo;
 236
 237     memcpy( fcc, &p_dec->fmt_in.i_codec, 4 );
 238     init_data.unk1 = 11;
 239     init_data.w = p_dec->fmt_in.video.i_width ;
 240     init_data.h = p_dec->fmt_in.video.i_height ;
 241     init_data.unk3 = 0;
 242     init_data.unk2 = 0;
 243     init_data.subformat = (unsigned int*)p_vide[0];
 244     init_data.unk5 = 1;
 245     init_data.format = (unsigned int*)p_vide[1];
 246
 247     /* first try to load linux dlls, if failed and we're supporting win32 dlls,
 248        then try to load the windows ones */
 249     bool b_so_opened = false;
 250
 251 #ifdef WIN32
 252     g_decode_path="plugins\\drv43260.dll";
 253
 254     if( (p_sys->rv_handle = load_syms(p_dec, g_decode_path)) )
 255         b_so_opened = true;
 256 #else
 257     const char *ppsz_path[] =
 258     {
 259         "/usr/lib/win32",
 260         "/usr/lib/codecs",
 261         "/usr/local/RealPlayer8/Codecs",
 262         "/usr/RealPlayer8/Codecs",
 263         "/usr/lib/RealPlayer8/Codecs",
 264         "/opt/RealPlayer8/Codecs",
 265         "/usr/lib/RealPlayer9/users/Real/Codecs",
 266         "/usr/lib/RealPlayer10/codecs",
 267         "/usr/lib/RealPlayer10GOLD/codecs",
 268         "/usr/lib/helix/player/codecs",
 269         "/usr/lib64/RealPlayer8/Codecs",
 270         "/usr/lib64/RealPlayer9/users/Real/Codecs",
 271         "/usr/lib64/RealPlayer10/codecs",
 272         "/usr/lib64/RealPlayer10GOLD/codecs",
 273         "/usr/local/lib/codecs",
 274         NULL
 275     };
 276
 277     for( int i = 0; ppsz_path[i]; i++ )
 278     {
 279         asprintf( &g_decode_path, "%s/drv4.so.6.0", ppsz_path[i] );
 280         if( (p_sys->rv_handle = load_syms_linux(p_dec, g_decode_path)) )
 281         {
 282             b_so_opened = true;
 283             free( g_decode_path );
 284             break;
 285         }
 286
 287         asprintf( &g_decode_path, "%s/drv3.so.6.0", ppsz_path[i] );
 288         if( (p_sys->rv_handle = load_syms_linux(p_dec, g_decode_path)) )
 289         {
 290             b_so_opened = true;
 291             free( g_decode_path );
 292             break;
 293         }
 294
 295         msg_Dbg( p_dec, "Cannot load real decoder library: %s", g_decode_path);
 296         free( g_decode_path );
 297     }
 298 #endif
 299
 300     if(!b_so_opened )
 301     {
 302         msg_Err( p_dec, "Cannot any real decoder library" );
 303         free( p_sys );
 304         return VLC_EGENERIC;
 305     }
 306
 307     lock = var_AcquireMutex( "rm_mutex" );
 308     if ( lock == NULL )
 309         return VLC_EGENERIC;
 310
 311     p_sys->handle=NULL;
 312     #ifdef WIN32
 313     if (dll_type == 1)
 314         result=(*wrvyuv_init)(&init_data, &p_sys->handle);
 315     else
 316     #endif
 317         result=(*rvyuv_init)(&init_data, &p_sys->handle);
 318     if (result)
 319     {
 320         msg_Err( p_dec, "Cannot Init real decoder library: %s",  g_decode_path);
 321         free( p_sys );
 322         return VLC_EGENERIC;
 323     }
 324
 325     /* setup rv30 codec (codec sub-type and image dimensions): */
 326     /*if ( p_dec->fmt_in.i_codec == VLC_FOURCC('R','V','3','0') )*/
 327     if (p_vide[1]>=0x20200002)
 328     {
 329         int i, cmsg_cnt;
 330         uint32_t cmsg24[16]={p_dec->fmt_in.video.i_width,p_dec->fmt_in.video.i_height};
 331         cmsg_data_t cmsg_data={0x24,1+(p_vide[1]&7), &cmsg24[0]};
 332         cmsg_cnt = (p_vide[1]&7)*2;
 333         if (i_vide - 8 < cmsg_cnt) {
 334                     cmsg_cnt = i_vide - 8;
 335         }
 336         for (i = 0; i < cmsg_cnt; i++)
 337             cmsg24[2+i] = p_vide[8+i]*4;
 338         #ifdef WIN32
 339         if (dll_type == 1)
 340             (*wrvyuv_custom_message)(&cmsg_data,p_sys->handle);
 341         else
 342         #endif
 343             (*rvyuv_custom_message)(&cmsg_data,p_sys->handle);
 344     }
 345     /*
 346     es_format_Init( &p_dec->fmt_out, VIDEO_ES, VLC_FOURCC( 'Y','V','1','2' ));
 347     es_format_Init( &p_dec->fmt_out, VIDEO_ES, VLC_FOURCC( 'Y','U','Y','2' ));
 348      */
 349     es_format_Init( &p_dec->fmt_out, VIDEO_ES, VLC_FOURCC( 'I', '4', '2', '0'));
 350
 351     p_dec->fmt_out.video.i_width = p_dec->fmt_in.video.i_width;
 352     p_dec->fmt_out.video.i_height= p_dec->fmt_in.video.i_height;
 353     p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR * p_dec->fmt_in.video.i_width / p_dec->fmt_in.video.i_height;
 354     p_sys->inited = 0;
 355
 356     vlc_mutex_unlock( lock );
 357     return VLC_SUCCESS;
 358 }
 359
 360 /*****************************************************************************
 361  * Open: probe the decoder and return score
 362  *****************************************************************************
 363  * Tries to launch a decoder and return score so that the interface is able
 364  * to choose.
 365  *****************************************************************************/
 366 static int Open( vlc_object_t *p_this )
 367 {
 368     decoder_t *p_dec = (decoder_t*)p_this;
 369
 370     /* create a mutex */
 371     var_Create( p_this->p_libvlc, "rm_mutex", VLC_VAR_MUTEX );
 372
 373     switch ( p_dec->fmt_in.i_codec )
 374     {
 375     case VLC_FOURCC('R','V','1','0'):
 376     case VLC_FOURCC('R','V','2','0'):
 377     case VLC_FOURCC('R','V','3','0'):
 378     case VLC_FOURCC('R','V','4','0'):
 379         p_dec->p_sys = NULL;
 380         p_dec->pf_decode_video = DecodeVideo;
 381         return InitVideo(p_dec);
 382
 383     default:
 384         return VLC_EGENERIC;
 385     }
 386 }
 387
 388 /*****************************************************************************
 389  * Close:
 390  *****************************************************************************/
 391 static void Close( vlc_object_t *p_this )
 392 {
 393     decoder_t     *p_dec = (decoder_t*)p_this;
 394     decoder_sys_t *p_sys = p_dec->p_sys;
 395     vlc_mutex_t   *lock;
 396
 397     /* get lock, avoid segfault */
 398     lock = var_AcquireMutex( "rm_mutex" );
 399
 400     #ifdef WIN32
 401     if (dll_type == 1)
 402     {
 403         if (wrvyuv_free)
 404             wrvyuv_free(p_sys->handle);
 405     }
 406     else
 407     #endif
 408         if (rvyuv_free)
 409             rvyuv_free(p_sys->handle);
 410 #ifdef WIN32
 411     if (dll_type == 1)
 412     {
 413         if (p_sys->rv_handle)
 414             FreeLibrary(p_sys->rv_handle);
 415     }
 416     else
 417 #endif
 418         p_sys->rv_handle=NULL;
 419
 420     if (p_sys->plane)
 421     {
 422         free(p_sys->plane);
 423         p_sys->plane = NULL;
 424     }
 425
 426     msg_Dbg( p_dec, "FreeLibrary ok." );
 427 #ifdef LOADER
 428     Restore_LDT_Keeper( p_sys->ldt_fs );
 429     msg_Dbg( p_dec, "Restore_LDT_Keeper" );
 430 #endif
 431     p_sys->inited = 0;
 432
 433     if ( lock )
 434     vlc_mutex_unlock( lock );
 435
 436     if ( p_sys )
 437         free( p_sys );
 438 }
 439
 440 /*****************************************************************************
 441  * DecodeVideo:
 442  *****************************************************************************/
 443 static picture_t *DecodeVideo( decoder_t *p_dec, block_t **pp_block )
 444 {
 445     decoder_sys_t *p_sys = p_dec->p_sys;
 446     vlc_mutex_t   *lock;
 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     lock = var_AcquireMutex( "rm_mutex" );
 464     if ( lock == NULL )
 465         return NULL;
 466
 467     p_pic = p_dec->pf_vout_buffer_new( p_dec );
 468
 469     if ( p_pic )
 470     {
 471         unsigned int transform_out[5];
 472         dp_hdr_t dp_hdr;
 473         transform_in_t transform_in;
 474         uint32_t pkg_len = ((uint32_t*)p_block->p_buffer)[0];
 475         unsigned char* dp_data=((unsigned char*)p_block->p_buffer)+8;
 476         uint32_t* extra=(uint32_t*)(((char*)p_block->p_buffer)+8+pkg_len);
 477         uint32_t img_size;
 478
 479
 480         dp_hdr.len = pkg_len;
 481         dp_hdr.chunktab = 8 + pkg_len;
 482         dp_hdr.chunks = ((uint32_t*)p_block->p_buffer)[1]-1;
 483         dp_hdr.timestamp = i_pts;
 484
 485         memset(&transform_in, 0, sizeof(transform_in_t));
 486
 487         transform_in.len = dp_hdr.len;
 488         transform_in.extra = extra;
 489         transform_in.chunks = dp_hdr.chunks;
 490         transform_in.timestamp = dp_hdr.timestamp;
 491
 492         memset (p_sys->plane, 0, p_dec->fmt_in.video.i_width * p_dec->fmt_in.video.i_height *3/2 );
 493
 494         #ifdef WIN32
 495         if (dll_type == 1)
 496             result=(*wrvyuv_transform)(dp_data, p_sys->plane, &transform_in, transform_out, p_sys->handle);
 497         else
 498         #endif
 499             result=(*rvyuv_transform)(dp_data, p_sys->plane, &transform_in, transform_out, p_sys->handle);
 500
 501         /* msg_Warn(p_dec, "Real Size %d X %d", transform_out[3],
 502                  transform_out[4]); */
 503         /* some bug rm file will print the messages :
 504                 [00000551] realvideo decoder warning: Real Size 320 X 240
 505                 [00000551] realvideo decoder warning: Real Size 480 X 272
 506                 [00000551] realvideo decoder warning: Real Size 320 X 240
 507                 [00000551] realvideo decoder warning: Real Size 320 X 240
 508                 ...
 509             so it needs fixing!
 510         */
 511         if ( p_sys->inited == 0 )
 512         {
 513             /* fix and get the correct image size! */
 514             if ( p_dec->fmt_in.video.i_width != transform_out[3]
 515              || p_dec->fmt_in.video.i_height  != transform_out[4] )
 516             {
 517                 msg_Warn(p_dec, "Warning, Real's Header give a wrong "
 518                          "information about media's width and height!\n"
 519                          "\tRealHeader: \t %d X %d  \t %d X %d",
 520                          p_dec->fmt_in.video.i_width,
 521                          p_dec->fmt_in.video.i_height,
 522                          transform_out[3],transform_out[4]);
 523
 524                 if ( p_dec->fmt_in.video.i_width * p_dec->fmt_in.video.i_height >= transform_out[3] * transform_out[4] )
 525                 {
 526                     p_dec->fmt_out.video.i_width =
 527                     p_dec->fmt_out.video.i_visible_width =
 528                     p_dec->fmt_in.video.i_width = transform_out[3] ;
 529
 530                     p_dec->fmt_out.video.i_height=
 531                     p_dec->fmt_out.video.i_visible_height =
 532                     p_dec->fmt_in.video.i_height= transform_out[4];
 533
 534                     p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR * p_dec->fmt_in.video.i_width / p_dec->fmt_in.video.i_height;
 535                 }
 536                 else
 537                 {
 538                     // TODO: realloc plane's size! but [in fact] it maybe not happen!
 539                     msg_Err(p_dec,"plane space not enough ,skip");
 540                 }
 541             }
 542             p_sys->inited = 1;
 543         }
 544
 545         img_size = p_dec->fmt_in.video.i_width * p_dec->fmt_in.video.i_height;
 546         memcpy( p_pic->p[0].p_pixels, p_sys->plane,  img_size);
 547         memcpy( p_pic->p[1].p_pixels, p_sys->plane + img_size, img_size/4);
 548         memcpy( p_pic->p[2].p_pixels, p_sys->plane + img_size * 5/4, img_size/4);
 549         p_pic->date = i_pts ;
 550
 551         /*  real video frame is small( frame and frame's time-shift is short),
 552             so it will become late picture easier (when render-time changed)and
 553             droped by video-output.*/
 554         p_pic->b_force = 1;
 555     }
 556
 557     vlc_mutex_unlock( lock );
 558
 559     block_Release( p_block );
 560     return p_pic;
 561 }
 562