git.sesse.net Git - vlc/blob - modules/demux/live555.cpp

   1 /*****************************************************************************
   2  * live555.cpp : LIVE555 Streaming Media support.
   3  *****************************************************************************
   4  * Copyright (C) 2003-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Derk-Jan Hartman <hartman at videolan. org>
   9  *          Derk-Jan Hartman <djhartman at m2x .dot. nl> for M2X
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29
  30 #include <vlc/vlc.h>
  31
  32 #include <vlc_demux.h>
  33 #include <vlc_interface.h>
  34 #include <vlc_network.h>
  35 #include <vlc_url.h>
  36
  37 #include <iostream>
  38
  39 #if defined( WIN32 )
  40 #   include <winsock2.h>
  41 #endif
  42
  43 #include "UsageEnvironment.hh"
  44 #include "BasicUsageEnvironment.hh"
  45 #include "GroupsockHelper.hh"
  46 #include "liveMedia.hh"
  47
  48 extern "C" {
  49 #include "../access/mms/asf.h"  /* Who said ugly ? */
  50 }
  51
  52 using namespace std;
  53
  54 /*****************************************************************************
  55  * Module descriptor
  56  *****************************************************************************/
  57 static int  Open ( vlc_object_t * );
  58 static void Close( vlc_object_t * );
  59
  60 #define CACHING_TEXT N_("Caching value (ms)")
  61 #define CACHING_LONGTEXT N_( \
  62     "Allows you to modify the default caching value for RTSP streams. This " \
  63     "value should be set in millisecond units." )
  64
  65 #define KASENNA_TEXT N_( "Kasenna RTSP dialect")
  66 #define KASENNA_LONGTEXT N_( "Kasenna servers use an old and unstandard " \
  67     "dialect of RTSP. When you set this parameter, VLC will try this dialect "\
  68     "for communication. In this mode you cannot connect to normal RTSP servers." )
  69
  70 #define USER_TEXT N_("RTSP user name")
  71 #define USER_LONGTEXT N_("Allows you to modify the user name that will " \
  72     "be used for authenticating the connection.")
  73 #define PASS_TEXT N_("RTSP password")
  74 #define PASS_LONGTEXT N_("Allows you to modify the password that will be " \
  75     "used for the connection.")
  76
  77 vlc_module_begin();
  78     set_description( _("RTP/RTSP/SDP demuxer (using Live555)" ) );
  79     set_capability( "demux2", 50 );
  80     set_shortname( "RTP/RTSP");
  81     set_callbacks( Open, Close );
  82     add_shortcut( "live" );
  83     add_shortcut( "livedotcom" );
  84     set_category( CAT_INPUT );
  85     set_subcategory( SUBCAT_INPUT_DEMUX );
  86
  87     add_submodule();
  88         set_description( _("RTSP/RTP access and demux") );
  89         add_shortcut( "rtsp" );
  90         add_shortcut( "sdp" );
  91         set_capability( "access_demux", 0 );
  92         set_callbacks( Open, Close );
  93         add_bool( "rtsp-tcp", 0, NULL,
  94                   N_("Use RTP over RTSP (TCP)"),
  95                   N_("Use RTP over RTSP (TCP)"), VLC_TRUE );
  96         add_integer( "rtp-client-port", -1, NULL,
  97                   N_("Client port"),
  98                   N_("Port to use for the RTP source of the session"), VLC_TRUE );
  99         add_bool( "rtsp-http", 0, NULL,
 100                   N_("Tunnel RTSP and RTP over HTTP"),
 101                   N_("Tunnel RTSP and RTP over HTTP"), VLC_TRUE );
 102         add_integer( "rtsp-http-port", 80, NULL,
 103                   N_("HTTP tunnel port"),
 104                   N_("Port to use for tunneling the RTSP/RTP over HTTP."),
 105                   VLC_TRUE );
 106         add_integer("rtsp-caching", 4 * DEFAULT_PTS_DELAY / 1000, NULL,
 107                     CACHING_TEXT, CACHING_LONGTEXT, VLC_TRUE );
 108         add_bool(   "rtsp-kasenna", VLC_FALSE, NULL, KASENNA_TEXT,
 109                     KASENNA_LONGTEXT, VLC_TRUE );
 110         add_string( "rtsp-user", NULL, NULL, USER_TEXT,
 111                     USER_LONGTEXT, VLC_TRUE );
 112         add_string( "rtsp-pwd", NULL, NULL, PASS_TEXT,
 113                     PASS_LONGTEXT, VLC_TRUE );
 114 vlc_module_end();
 115
 116
 117 /*****************************************************************************
 118  * Local prototypes
 119  *****************************************************************************/
 120
 121 typedef struct
 122 {
 123     demux_t         *p_demux;
 124     MediaSubsession *sub;
 125
 126     es_format_t     fmt;
 127     es_out_id_t     *p_es;
 128
 129     vlc_bool_t      b_muxed;
 130     vlc_bool_t      b_quicktime;
 131     vlc_bool_t      b_asf;
 132     stream_t        *p_out_muxed;    /* for muxed stream */
 133
 134     uint8_t         *p_buffer;
 135     unsigned int    i_buffer;
 136
 137     vlc_bool_t      b_rtcp_sync;
 138     char            waiting;
 139     int64_t         i_pts;
 140     u_int32_t       i_start_seq;
 141
 142 } live_track_t;
 143
 144 struct timeout_thread_t
 145 {
 146     VLC_COMMON_MEMBERS
 147
 148     int64_t      i_remain;
 149     demux_sys_t  *p_sys;
 150 };
 151
 152 struct demux_sys_t
 153 {
 154     char            *p_sdp;    /* XXX mallocated */
 155     char            *psz_path; /* URL-encoded path */
 156     vlc_url_t       url;
 157
 158     MediaSession     *ms;
 159     TaskScheduler    *scheduler;
 160     UsageEnvironment *env ;
 161     RTSPClient       *rtsp;
 162
 163     /* */
 164     int              i_track;
 165     live_track_t     **track;   /* XXX mallocated */
 166
 167     /* Weird formats */
 168     asf_header_t     asfh;
 169     stream_t         *p_out_asf;
 170     vlc_bool_t       b_real;
 171
 172     /* */
 173     int64_t          i_pcr; /* The clock */
 174     int64_t          i_npt; /* The current time in the stream */
 175     int64_t          i_npt_length;
 176     int64_t          i_npt_start;
 177
 178     /* timeout thread information */
 179     int              i_timeout;     /* session timeout value in seconds */
 180     vlc_bool_t       b_timeout_call;/* mark to send an RTSP call to prevent server timeout */
 181     timeout_thread_t *p_timeout;    /* the actual thread that makes sure we don't timeout */
 182
 183     /* */
 184     vlc_bool_t       b_multicast;   /* true if one of the tracks is multicasted */
 185     vlc_bool_t       b_no_data;     /* true if we never receive any data */
 186     int              i_no_data_ti;  /* consecutive number of TaskInterrupt */
 187
 188     char             event;
 189 };
 190
 191 static int Demux  ( demux_t * );
 192 static int Control( demux_t *, int, va_list );
 193
 194 static int Connect      ( demux_t * );
 195 static int SessionsSetup( demux_t * );
 196 static int Play         ( demux_t *);
 197 static int ParseASF     ( demux_t * );
 198 static int RollOverTcp  ( demux_t * );
 199
 200 static void StreamRead  ( void *, unsigned int, unsigned int,
 201                           struct timeval, unsigned int );
 202 static void StreamClose ( void * );
 203 static void TaskInterrupt( void * );
 204
 205 static void TimeoutPrevention( timeout_thread_t * );
 206
 207 static unsigned char* parseH264ConfigStr( char const* configStr,
 208                                           unsigned int& configSize );
 209
 210 /*****************************************************************************
 211  * DemuxOpen:
 212  *****************************************************************************/
 213 static int  Open ( vlc_object_t *p_this )
 214 {
 215     demux_t     *p_demux = (demux_t*)p_this;
 216     demux_sys_t *p_sys = NULL;
 217
 218     MediaSubsessionIterator *iter   = NULL;
 219     MediaSubsession         *sub    = NULL;
 220     int i, i_return;
 221
 222     if( p_demux->s )
 223     {
 224         /* See if it looks like a SDP
 225            v, o, s fields are mandatory and in this order */
 226         const uint8_t *p_peek;
 227         if( stream_Peek( p_demux->s, &p_peek, 7 ) < 7 ) return VLC_EGENERIC;
 228
 229         if( memcmp( p_peek, "v=0\r\n", 5 ) &&
 230             memcmp( p_peek, "v=0\n", 4 ) &&
 231             ( p_peek[0] < 'a' || p_peek[0] > 'z' || p_peek[1] != '=' ) )
 232         {
 233             return VLC_EGENERIC;
 234         }
 235     }
 236     else
 237     {
 238         var_Create( p_demux, "rtsp-caching", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
 239     }
 240
 241     p_demux->pf_demux  = Demux;
 242     p_demux->pf_control= Control;
 243     p_demux->p_sys     = p_sys = (demux_sys_t*)malloc( sizeof( demux_sys_t ) );
 244     if( !p_sys ) return VLC_ENOMEM;
 245
 246     p_sys->p_sdp = NULL;
 247     p_sys->scheduler = NULL;
 248     p_sys->env = NULL;
 249     p_sys->ms = NULL;
 250     p_sys->rtsp = NULL;
 251     p_sys->i_track = 0;
 252     p_sys->track   = NULL;
 253     p_sys->i_pcr = 0;
 254     p_sys->i_npt = 0;
 255     p_sys->i_npt_start = 0;
 256     p_sys->i_npt_length = 0;
 257     p_sys->p_out_asf = NULL;
 258     p_sys->b_no_data = VLC_TRUE;
 259     p_sys->i_no_data_ti = 0;
 260     p_sys->p_timeout = NULL;
 261     p_sys->i_timeout = 0;
 262     p_sys->b_timeout_call = VLC_FALSE;
 263     p_sys->b_multicast = VLC_FALSE;
 264     p_sys->b_real = VLC_FALSE;
 265     p_sys->psz_path = strdup( p_demux->psz_path );
 266
 267     /* parse URL for rtsp://[user:[passwd]@]serverip:port/options */
 268     vlc_UrlParse( &p_sys->url, p_sys->psz_path, 0 );
 269
 270     if( ( p_sys->scheduler = BasicTaskScheduler::createNew() ) == NULL )
 271     {
 272         msg_Err( p_demux, "BasicTaskScheduler::createNew failed" );
 273         goto error;
 274     }
 275     if( !( p_sys->env = BasicUsageEnvironment::createNew(*p_sys->scheduler) ) )
 276     {
 277         msg_Err( p_demux, "BasicUsageEnvironment::createNew failed" );
 278         goto error;
 279     }
 280
 281     if( strcasecmp( p_demux->psz_access, "sdp" ) )
 282     {
 283         char *p = p_sys->psz_path;
 284         while( (p = strchr( p, ' ' )) != NULL ) *p = '+';
 285     }
 286
 287     if( p_demux->s != NULL )
 288     {
 289         /* Gather the complete sdp file */
 290         int     i_sdp       = 0;
 291         int     i_sdp_max   = 1000;
 292         uint8_t *p_sdp      = (uint8_t*) malloc( i_sdp_max );
 293
 294         for( ;; )
 295         {
 296             int i_read = stream_Read( p_demux->s, &p_sdp[i_sdp],
 297                                       i_sdp_max - i_sdp - 1 );
 298
 299             if( i_read < 0 )
 300             {
 301                 msg_Err( p_demux, "failed to read SDP" );
 302                 free( p_sys );
 303                 return VLC_EGENERIC;
 304             }
 305
 306             i_sdp += i_read;
 307
 308             if( i_read < i_sdp_max - i_sdp - 1 )
 309             {
 310                 p_sdp[i_sdp] = '\0';
 311                 break;
 312             }
 313
 314             i_sdp_max += 1000;
 315             p_sdp = (uint8_t*)realloc( p_sdp, i_sdp_max );
 316         }
 317         p_sys->p_sdp = (char*)p_sdp;
 318     }
 319     else if( ( p_demux->s == NULL ) &&
 320              !strcasecmp( p_demux->psz_access, "sdp" ) )
 321     {
 322         /* sdp:// link from SAP */
 323         p_sys->p_sdp = strdup( p_sys->psz_path );
 324     }
 325     else if( ( i_return = Connect( p_demux ) ) != VLC_SUCCESS )
 326     {
 327         msg_Err( p_demux, "Failed to connect with rtsp://%s", p_sys->psz_path );
 328         goto error;
 329     }
 330
 331     if( p_sys->p_sdp == NULL )
 332     {
 333         msg_Err( p_demux, "Failed to retrieve the RTSP Session Description" );
 334         goto error;
 335     }
 336
 337     if( ( i_return = SessionsSetup( p_demux ) ) != VLC_SUCCESS )
 338     {
 339         msg_Err( p_demux, "Nothing to play for rtsp://%s", p_sys->psz_path );
 340         goto error;
 341     }
 342
 343     if( p_sys->b_real ) goto error;
 344
 345     if( ( i_return = Play( p_demux ) ) != VLC_SUCCESS )
 346         goto error;
 347
 348     if( p_sys->p_out_asf && ParseASF( p_demux ) )
 349     {
 350         msg_Err( p_demux, "cannot find a usable asf header" );
 351         /* TODO Clean tracks */
 352         goto error;
 353     }
 354
 355     if( p_sys->i_track <= 0 )
 356         goto error;
 357
 358     return VLC_SUCCESS;
 359
 360 error:
 361     for( i = 0; i < p_sys->i_track; i++ )
 362     {
 363         live_track_t *tk = p_sys->track[i];
 364
 365         if( tk->b_muxed ) stream_DemuxDelete( tk->p_out_muxed );
 366         free( tk->p_buffer );
 367         free( tk );
 368     }
 369
 370     if( p_sys->i_track ) free( p_sys->track );
 371     if( p_sys->p_out_asf ) stream_DemuxDelete( p_sys->p_out_asf );
 372     if( p_sys->rtsp && p_sys->ms ) p_sys->rtsp->teardownMediaSession( *p_sys->ms );
 373     if( p_sys->ms ) Medium::close( p_sys->ms );
 374     if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
 375     if( p_sys->env ) p_sys->env->reclaim();
 376     if( p_sys->p_timeout )
 377     {
 378         vlc_object_kill( p_sys->p_timeout );
 379         vlc_thread_join( p_sys->p_timeout );
 380         vlc_object_detach( p_sys->p_timeout );
 381         vlc_object_destroy( p_sys->p_timeout );
 382     }
 383     if( p_sys->scheduler ) delete p_sys->scheduler;
 384     if( p_sys->p_sdp ) free( p_sys->p_sdp );
 385     if( p_sys->psz_path ) free( p_sys->psz_path );
 386
 387     vlc_UrlClean( &p_sys->url );
 388
 389     free( p_sys );
 390     return VLC_EGENERIC;
 391 }
 392
 393 /*****************************************************************************
 394  * DemuxClose:
 395  *****************************************************************************/
 396 static void Close( vlc_object_t *p_this )
 397 {
 398     demux_t *p_demux = (demux_t*)p_this;
 399     demux_sys_t *p_sys = p_demux->p_sys;
 400     int i;
 401
 402     for( i = 0; i < p_sys->i_track; i++ )
 403     {
 404         live_track_t *tk = p_sys->track[i];
 405
 406         if( tk->b_muxed ) stream_DemuxDelete( tk->p_out_muxed );
 407         free( tk->p_buffer );
 408         free( tk );
 409     }
 410
 411     if( p_sys->i_track ) free( p_sys->track );
 412     if( p_sys->p_out_asf ) stream_DemuxDelete( p_sys->p_out_asf );
 413     if( p_sys->rtsp && p_sys->ms ) p_sys->rtsp->teardownMediaSession( *p_sys->ms );
 414     if( p_sys->ms ) Medium::close( p_sys->ms );
 415     if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
 416     if( p_sys->env ) p_sys->env->reclaim();
 417     if( p_sys->p_timeout )
 418     {
 419         vlc_object_kill( p_sys->p_timeout );
 420         vlc_thread_join( p_sys->p_timeout );
 421         vlc_object_detach( p_sys->p_timeout );
 422         vlc_object_destroy( p_sys->p_timeout );
 423     }
 424     if( p_sys->scheduler ) delete p_sys->scheduler;
 425     if( p_sys->p_sdp ) free( p_sys->p_sdp );
 426     if( p_sys->psz_path ) free( p_sys->psz_path );
 427
 428     vlc_UrlClean( &p_sys->url );
 429
 430     free( p_sys );
 431 }
 432
 433 /*****************************************************************************
 434  * Connect: connects to the RTSP server to setup the session DESCRIBE
 435  *****************************************************************************/
 436 static int Connect( demux_t *p_demux )
 437 {
 438     demux_sys_t *p_sys = p_demux->p_sys;
 439     Authenticator authenticator;
 440
 441     char *psz_user    = NULL;
 442     char *psz_pwd     = NULL;
 443     char *psz_url     = NULL;
 444     char *psz_options = NULL;
 445     char *p_sdp       = NULL;
 446     int  i_http_port  = 0;
 447     int  i_ret        = VLC_SUCCESS;
 448
 449 createnew:
 450     if( var_CreateGetBool( p_demux, "rtsp-http" ) )
 451         i_http_port = var_CreateGetInteger( p_demux, "rtsp-http-port" );
 452
 453     if( ( p_sys->rtsp = RTSPClient::createNew( *p_sys->env,
 454           p_demux->p_libvlc->i_verbose > 1,
 455           "VLC media player", i_http_port ) ) == NULL )
 456     {
 457         msg_Err( p_demux, "RTSPClient::createNew failed (%s)",
 458                  p_sys->env->getResultMsg() );
 459         return VLC_EGENERIC;
 460     }
 461
 462     psz_url = (char*)malloc( strlen( p_sys->psz_path ) + 8 );
 463     if( !psz_url ) return VLC_ENOMEM;
 464
 465     if( p_sys->url.psz_username || p_sys->url.psz_password )
 466     {
 467         sprintf( psz_url, "rtsp://%s%s", p_sys->url.psz_host,
 468                  p_sys->url.psz_path );
 469
 470         psz_user = strdup( p_sys->url.psz_username );
 471         psz_pwd  = strdup( p_sys->url.psz_password );
 472     }
 473     else
 474     {
 475         sprintf( psz_url, "rtsp://%s", p_sys->psz_path );
 476
 477         psz_user = var_CreateGetString( p_demux, "rtsp-user" );
 478         psz_pwd  = var_CreateGetString( p_demux, "rtsp-pwd" );
 479     }
 480
 481 describe:
 482 msg_Info( p_demux, "[%s] user=%s pwd=%s", psz_url, psz_user, psz_pwd );
 483     authenticator.setUsernameAndPassword( (const char*)psz_user,
 484                                           (const char*)psz_pwd );
 485
 486     psz_options = p_sys->rtsp->sendOptionsCmd( psz_url, psz_user, psz_pwd,
 487                                                &authenticator );
 488     if( psz_options ) delete [] psz_options;
 489
 490     p_sdp = p_sys->rtsp->describeURL( psz_url,
 491                 &authenticator, var_CreateGetBool( p_demux, "rtsp-kasenna" ) );
 492
 493     if( psz_user ) free( psz_user );
 494     if( psz_pwd ) free( psz_pwd );
 495
 496     if( p_sdp == NULL )
 497     {
 498         /* failure occurred */
 499         int i_code = 0;
 500         const char *psz_error = p_sys->env->getResultMsg();
 501
 502         msg_Dbg( p_demux, "DESCRIBE failed with %d: %s", i_code, psz_error );
 503         if( var_CreateGetBool( p_demux, "rtsp-http" ) )
 504             sscanf( psz_error, "%*s %*s HTTP GET %*s HTTP/%*u.%*u %3u %*s", &i_code );
 505         else sscanf( psz_error, "%*sRTSP/%*s%3u", &i_code );
 506
 507         if( i_code == 401 )
 508         {
 509             char *psz_login = NULL; char *psz_password = NULL;
 510             msg_Dbg( p_demux, "authentication failed" );
 511
 512             i_ret = intf_UserLoginPassword( p_demux, _("RTSP authentication"),
 513                            _("Please enter a valid login name and a password."),
 514                                                    &psz_login, &psz_password );
 515             if( i_ret == DIALOG_OK_YES )
 516             {
 517                 msg_Dbg( p_demux, "retrying with user=%s, pwd=%s",
 518                             psz_login, psz_password );
 519                 if( psz_login ) psz_user = psz_login;
 520                 if( psz_password ) psz_pwd = psz_password;
 521                 i_ret = VLC_SUCCESS;
 522                 goto describe;
 523             }
 524             if( psz_login ) free( psz_login );
 525             if( psz_password ) free( psz_password );
 526         }
 527         else if( !var_GetBool( p_demux, "rtsp-http" ) )
 528         {
 529             /* Perhaps a firewall is being annoying. Try HTTP tunneling mode */
 530             vlc_value_t val;
 531             val.b_bool = VLC_TRUE;
 532             msg_Dbg( p_demux, "we will now try HTTP tunneling mode" );
 533             var_Set( p_demux, "rtsp-http", val );
 534             if( psz_url ) free( psz_url );
 535             if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
 536             goto createnew;
 537         }
 538         i_ret = VLC_EGENERIC;
 539     }
 540     if( psz_url ) free( psz_url );
 541
 542     /* malloc-ated copy */
 543     if( p_sys->p_sdp ) free( p_sys->p_sdp );
 544     p_sys->p_sdp = NULL;
 545     if( p_sdp ) p_sys->p_sdp = strdup( (char*)p_sdp );
 546     delete[] p_sdp;
 547
 548     return i_ret;
 549 }
 550
 551 /*****************************************************************************
 552  * SessionsSetup: prepares the subsessions and does the SETUP
 553  *****************************************************************************/
 554 static int SessionsSetup( demux_t *p_demux )
 555 {
 556     demux_sys_t             *p_sys  = p_demux->p_sys;
 557     MediaSubsessionIterator *iter   = NULL;
 558     MediaSubsession         *sub    = NULL;
 559
 560     vlc_bool_t     b_rtsp_tcp = VLC_FALSE;
 561     int            i_client_port;
 562     int            i_return = VLC_SUCCESS;
 563     unsigned int   i_buffer = 0;
 564     unsigned const thresh = 200000; /* RTP reorder threshold .2 second (default .1) */
 565
 566     b_rtsp_tcp    = var_CreateGetBool( p_demux, "rtsp-tcp" ) ||
 567                     var_GetBool( p_demux, "rtsp-http" );
 568     i_client_port = var_CreateGetInteger( p_demux, "rtp-client-port" );
 569
 570     /* Create the session from the SDP */
 571     if( !( p_sys->ms = MediaSession::createNew( *p_sys->env, p_sys->p_sdp ) ) )
 572     {
 573         msg_Err( p_demux, "Could not create the RTSP Session: %s",
 574             p_sys->env->getResultMsg() );
 575         return VLC_EGENERIC;
 576     }
 577
 578     /* Initialise each media subsession */
 579     iter = new MediaSubsessionIterator( *p_sys->ms );
 580     while( ( sub = iter->next() ) != NULL )
 581     {
 582         Boolean bInit;
 583         live_track_t *tk;
 584
 585         /* Value taken from mplayer */
 586         if( !strcmp( sub->mediumName(), "audio" ) )
 587             i_buffer = 100000;
 588         else if( !strcmp( sub->mediumName(), "video" ) )
 589             i_buffer = 2000000;
 590         else continue;
 591
 592         if( i_client_port != -1 )
 593         {
 594             sub->setClientPortNum( i_client_port );
 595             i_client_port += 2;
 596         }
 597
 598         if( strcasestr( sub->codecName(), "REAL" ) )
 599         {
 600             msg_Info( p_demux, "real codec detected, using real-RTSP instead" );
 601             p_sys->b_real = VLC_TRUE; /* This is a problem, we'll handle it later */
 602             continue;
 603         }
 604
 605         if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
 606             bInit = sub->initiate( 4 ); /* Constant ? */
 607         else
 608             bInit = sub->initiate();
 609
 610         if( !bInit )
 611         {
 612             msg_Warn( p_demux, "RTP subsession '%s/%s' failed (%s)",
 613                       sub->mediumName(), sub->codecName(),
 614                       p_sys->env->getResultMsg() );
 615         }
 616         else
 617         {
 618             if( sub->rtpSource() != NULL )
 619             {
 620                 int fd = sub->rtpSource()->RTPgs()->socketNum();
 621
 622                 /* Increase the buffer size */
 623                 if( i_buffer > 0 )
 624                     increaseReceiveBufferTo( *p_sys->env, fd, i_buffer );
 625
 626                 /* Increase the RTP reorder timebuffer just a bit */
 627                 sub->rtpSource()->setPacketReorderingThresholdTime(thresh);
 628             }
 629             msg_Dbg( p_demux, "RTP subsession '%s/%s'", sub->mediumName(),
 630                      sub->codecName() );
 631
 632             /* Issue the SETUP */
 633             if( p_sys->rtsp )
 634             {
 635                 if( !( p_sys->rtsp->setupMediaSubsession( *sub, False,
 636                                                    b_rtsp_tcp ? True : False ) ) )
 637                 {
 638                     /* if we get an unsupported transport error, toggle TCP use and try again */
 639                     if( !strstr(p_sys->env->getResultMsg(), "461 Unsupported Transport")
 640                      || !( p_sys->rtsp->setupMediaSubsession( *sub, False,
 641                                                    b_rtsp_tcp ? False : True ) ) )
 642                     {
 643                         msg_Err( p_demux, "SETUP of'%s/%s' failed %s", sub->mediumName(),
 644                                  sub->codecName(), p_sys->env->getResultMsg() );
 645                         continue;
 646                     }
 647                 }
 648             }
 649
 650             /* Check if we will receive data from this subsession for this track */
 651             if( sub->readSource() == NULL ) continue;
 652             if( !p_sys->b_multicast )
 653             {
 654                 /* Check, because we need diff. rollover behaviour for multicast */
 655                 p_sys->b_multicast = IsMulticastAddress( sub->connectionEndpointAddress() );
 656             }
 657
 658             tk = (live_track_t*)malloc( sizeof( live_track_t ) );
 659             tk->p_demux     = p_demux;
 660             tk->sub         = sub;
 661             tk->p_es        = NULL;
 662             tk->b_quicktime = VLC_FALSE;
 663             tk->b_asf       = VLC_FALSE;
 664             tk->b_muxed     = VLC_FALSE;
 665             tk->p_out_muxed = NULL;
 666             tk->waiting     = 0;
 667             tk->b_rtcp_sync = VLC_FALSE;
 668             tk->i_pts       = 0;
 669             tk->i_buffer    = 65536;
 670             tk->p_buffer    = (uint8_t *)malloc( 65536 );
 671
 672             /* Value taken from mplayer */
 673             if( !strcmp( sub->mediumName(), "audio" ) )
 674             {
 675                 es_format_Init( &tk->fmt, AUDIO_ES, VLC_FOURCC('u','n','d','f') );
 676                 tk->fmt.audio.i_channels = sub->numChannels();
 677                 tk->fmt.audio.i_rate = sub->rtpTimestampFrequency();
 678
 679                 if( !strcmp( sub->codecName(), "MPA" ) ||
 680                     !strcmp( sub->codecName(), "MPA-ROBUST" ) ||
 681                     !strcmp( sub->codecName(), "X-MP3-DRAFT-00" ) )
 682                 {
 683                     tk->fmt.i_codec = VLC_FOURCC( 'm', 'p', 'g', 'a' );
 684                     tk->fmt.audio.i_rate = 0;
 685                 }
 686                 else if( !strcmp( sub->codecName(), "AC3" ) )
 687                 {
 688                     tk->fmt.i_codec = VLC_FOURCC( 'a', '5', '2', ' ' );
 689                     tk->fmt.audio.i_rate = 0;
 690                 }
 691                 else if( !strcmp( sub->codecName(), "L16" ) )
 692                 {
 693                     tk->fmt.i_codec = VLC_FOURCC( 't', 'w', 'o', 's' );
 694                     tk->fmt.audio.i_bitspersample = 16;
 695                 }
 696                 else if( !strcmp( sub->codecName(), "L8" ) )
 697                 {
 698                     tk->fmt.i_codec = VLC_FOURCC( 'a', 'r', 'a', 'w' );
 699                     tk->fmt.audio.i_bitspersample = 8;
 700                 }
 701                 else if( !strcmp( sub->codecName(), "PCMU" ) )
 702                 {
 703                     tk->fmt.i_codec = VLC_FOURCC( 'u', 'l', 'a', 'w' );
 704                 }
 705                 else if( !strcmp( sub->codecName(), "PCMA" ) )
 706                 {
 707                     tk->fmt.i_codec = VLC_FOURCC( 'a', 'l', 'a', 'w' );
 708                 }
 709                 else if( !strncmp( sub->codecName(), "G726", 4 ) )
 710                 {
 711                     tk->fmt.i_codec = VLC_FOURCC( 'g', '7', '2', '6' );
 712                     tk->fmt.audio.i_rate = 8000;
 713                     tk->fmt.audio.i_channels = 1;
 714                     if( !strcmp( sub->codecName()+5, "40" ) )
 715                         tk->fmt.i_bitrate = 40000;
 716                     else if( !strcmp( sub->codecName()+5, "32" ) )
 717                         tk->fmt.i_bitrate = 32000;
 718                     else if( !strcmp( sub->codecName()+5, "24" ) )
 719                         tk->fmt.i_bitrate = 24000;
 720                     else if( !strcmp( sub->codecName()+5, "16" ) )
 721                         tk->fmt.i_bitrate = 16000;
 722                 }
 723                 else if( !strcmp( sub->codecName(), "AMR" ) )
 724                 {
 725                     tk->fmt.i_codec = VLC_FOURCC( 's', 'a', 'm', 'r' );
 726                 }
 727                 else if( !strcmp( sub->codecName(), "AMR-WB" ) )
 728                 {
 729                     tk->fmt.i_codec = VLC_FOURCC( 's', 'a', 'w', 'b' );
 730                 }
 731                 else if( !strcmp( sub->codecName(), "MP4A-LATM" ) )
 732                 {
 733                     unsigned int i_extra;
 734                     uint8_t      *p_extra;
 735
 736                     tk->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'a' );
 737
 738                     if( ( p_extra = parseStreamMuxConfigStr( sub->fmtp_config(),
 739                                                              i_extra ) ) )
 740                     {
 741                         tk->fmt.i_extra = i_extra;
 742                         tk->fmt.p_extra = malloc( i_extra );
 743                         memcpy( tk->fmt.p_extra, p_extra, i_extra );
 744                         delete[] p_extra;
 745                     }
 746                     /* Because the "faad" decoder does not handle the LATM data length field
 747                        at the start of each returned LATM frame, tell the RTP source to omit it. */
 748                     ((MPEG4LATMAudioRTPSource*)sub->rtpSource())->omitLATMDataLengthField();
 749                 }
 750                 else if( !strcmp( sub->codecName(), "MPEG4-GENERIC" ) )
 751                 {
 752                     unsigned int i_extra;
 753                     uint8_t      *p_extra;
 754
 755                     tk->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'a' );
 756
 757                     if( ( p_extra = parseGeneralConfigStr( sub->fmtp_config(),
 758                                                            i_extra ) ) )
 759                     {
 760                         tk->fmt.i_extra = i_extra;
 761                         tk->fmt.p_extra = malloc( i_extra );
 762                         memcpy( tk->fmt.p_extra, p_extra, i_extra );
 763                         delete[] p_extra;
 764                     }
 765                 }
 766                 else if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
 767                 {
 768                     tk->b_asf = VLC_TRUE;
 769                     if( p_sys->p_out_asf == NULL )
 770                         p_sys->p_out_asf = stream_DemuxNew( p_demux, "asf",
 771                                                             p_demux->out );
 772                 }
 773                 else if( !strcmp( sub->codecName(), "X-QT" ) ||
 774                          !strcmp( sub->codecName(), "X-QUICKTIME" ) )
 775                 {
 776                     tk->b_quicktime = VLC_TRUE;
 777                 }
 778                 else if( !strcmp( sub->codecName(), "SPEEX" ) )
 779                 {
 780                     tk->fmt.i_codec = VLC_FOURCC( 's', 'p', 'x', 'r' );
 781                     if ( sub->rtpTimestampFrequency() )
 782                         tk->fmt.audio.i_rate = sub->rtpTimestampFrequency();
 783                     else
 784                     {
 785                         msg_Warn( p_demux,"Using 8kHz as default sample rate." );
 786                         tk->fmt.audio.i_rate = 8000;
 787                     }
 788                 }
 789             }
 790             else if( !strcmp( sub->mediumName(), "video" ) )
 791             {
 792                 es_format_Init( &tk->fmt, VIDEO_ES, VLC_FOURCC('u','n','d','f') );
 793                 if( !strcmp( sub->codecName(), "MPV" ) )
 794                 {
 795                     tk->fmt.i_codec = VLC_FOURCC( 'm', 'p', 'g', 'v' );
 796                 }
 797                 else if( !strcmp( sub->codecName(), "H263" ) ||
 798                          !strcmp( sub->codecName(), "H263-1998" ) ||
 799                          !strcmp( sub->codecName(), "H263-2000" ) )
 800                 {
 801                     tk->fmt.i_codec = VLC_FOURCC( 'H', '2', '6', '3' );
 802                 }
 803                 else if( !strcmp( sub->codecName(), "H261" ) )
 804                 {
 805                     tk->fmt.i_codec = VLC_FOURCC( 'H', '2', '6', '1' );
 806                 }
 807                 else if( !strcmp( sub->codecName(), "H264" ) )
 808                 {
 809                     unsigned int i_extra = 0;
 810                     uint8_t      *p_extra = NULL;
 811
 812                     tk->fmt.i_codec = VLC_FOURCC( 'h', '2', '6', '4' );
 813                     tk->fmt.b_packetized = VLC_FALSE;
 814
 815                     if((p_extra=parseH264ConfigStr( sub->fmtp_spropparametersets(),
 816                                                     i_extra ) ) )
 817                     {
 818                         tk->fmt.i_extra = i_extra;
 819                         tk->fmt.p_extra = malloc( i_extra );
 820                         memcpy( tk->fmt.p_extra, p_extra, i_extra );
 821
 822                         delete[] p_extra;
 823                     }
 824                 }
 825                 else if( !strcmp( sub->codecName(), "JPEG" ) )
 826                 {
 827                     tk->fmt.i_codec = VLC_FOURCC( 'M', 'J', 'P', 'G' );
 828                 }
 829                 else if( !strcmp( sub->codecName(), "MP4V-ES" ) )
 830                 {
 831                     unsigned int i_extra;
 832                     uint8_t      *p_extra;
 833
 834                     tk->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'v' );
 835
 836                     if( ( p_extra = parseGeneralConfigStr( sub->fmtp_config(),
 837                                                            i_extra ) ) )
 838                     {
 839                         tk->fmt.i_extra = i_extra;
 840                         tk->fmt.p_extra = malloc( i_extra );
 841                         memcpy( tk->fmt.p_extra, p_extra, i_extra );
 842                         delete[] p_extra;
 843                     }
 844                 }
 845                 else if( !strcmp( sub->codecName(), "X-QT" ) ||
 846                          !strcmp( sub->codecName(), "X-QUICKTIME" ) ||
 847                          !strcmp( sub->codecName(), "X-QDM" ) ||
 848                          !strcmp( sub->codecName(), "X-SV3V-ES" )  ||
 849                          !strcmp( sub->codecName(), "X-SORENSONVIDEO" ) )
 850                 {
 851                     tk->b_quicktime = VLC_TRUE;
 852                 }
 853                 else if( !strcmp( sub->codecName(), "MP2T" ) )
 854                 {
 855                     tk->b_muxed = VLC_TRUE;
 856                     tk->p_out_muxed = stream_DemuxNew( p_demux, "ts", p_demux->out );
 857                 }
 858                 else if( !strcmp( sub->codecName(), "MP2P" ) ||
 859                          !strcmp( sub->codecName(), "MP1S" ) )
 860                 {
 861                     tk->b_muxed = VLC_TRUE;
 862                     tk->p_out_muxed = stream_DemuxNew( p_demux, "ps",
 863                                                        p_demux->out );
 864                 }
 865                 else if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
 866                 {
 867                     tk->b_asf = VLC_TRUE;
 868                     if( p_sys->p_out_asf == NULL )
 869                         p_sys->p_out_asf = stream_DemuxNew( p_demux, "asf",
 870                                                             p_demux->out );;
 871                 }
 872             }
 873
 874             if( !tk->b_quicktime && !tk->b_muxed && !tk->b_asf )
 875             {
 876                 tk->p_es = es_out_Add( p_demux->out, &tk->fmt );
 877             }
 878
 879             if( sub->rtcpInstance() != NULL )
 880             {
 881                 sub->rtcpInstance()->setByeHandler( StreamClose, tk );
 882             }
 883
 884             if( tk->p_es || tk->b_quicktime || tk->b_muxed || tk->b_asf )
 885             {
 886                 /* Append */
 887                 p_sys->track = (live_track_t**)realloc( p_sys->track, sizeof( live_track_t ) * ( p_sys->i_track + 1 ) );
 888                 p_sys->track[p_sys->i_track++] = tk;
 889             }
 890             else
 891             {
 892                 /* BUG ??? */
 893                 msg_Err( p_demux, "unusable RTSP track. this should not happen" );
 894                 free( tk );
 895             }
 896         }
 897     }
 898     delete iter;
 899     if( p_sys->i_track <= 0 ) i_return = VLC_EGENERIC;
 900
 901 #if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
 902     /* Retrieve the starttime if possible */
 903     p_sys->i_npt_start = (int64_t)( p_sys->ms->playStartTime() * (double)1000000.0 );
 904 #else
 905     p_sys->i_npt_start = (int64_t) -1;
 906 #endif
 907     if( p_sys->i_npt_start < 0 )
 908         p_sys->i_npt_start = -1;
 909
 910 #if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
 911     /* Retrieve the duration if possible */
 912     p_sys->i_npt_length = (int64_t)( p_sys->ms->playEndTime() * (double)1000000.0 );
 913 #else
 914     p_sys->i_npt_length = (int64_t) -1;
 915 #endif
 916     if( p_sys->i_npt_length < 0 )
 917         p_sys->i_npt_length = -1;
 918
 919     msg_Dbg( p_demux, "setup start: %lld stop:%lld", p_sys->i_npt_start, p_sys->i_npt_length );
 920     return i_return;
 921 }
 922
 923 /*****************************************************************************
 924  * Play: starts the actual playback of the stream
 925  *****************************************************************************/
 926 static int Play( demux_t *p_demux )
 927 {
 928     demux_sys_t *p_sys = p_demux->p_sys;
 929     int i;
 930
 931     if( p_sys->rtsp )
 932     {
 933         /* The PLAY */
 934         if( !p_sys->rtsp->playMediaSession( *p_sys->ms, p_sys->i_npt_start, -1, 1 ) )
 935         {
 936             msg_Err( p_demux, "RTSP PLAY failed %s", p_sys->env->getResultMsg() );
 937             return VLC_EGENERIC;
 938         }
 939
 940         /* Retrieve the timeout value and set up a timeout prevention thread */
 941         p_sys->i_timeout = p_sys->rtsp->sessionTimeoutParameter();
 942         if( p_sys->i_timeout <= 0 )
 943             p_sys->i_timeout = 60; /* default value from RFC2326 */
 944         if( !p_sys->p_timeout )
 945         {
 946             msg_Dbg( p_demux, "We have a timeout of %d seconds",  p_sys->i_timeout );
 947             p_sys->p_timeout = (timeout_thread_t *)vlc_object_create( p_demux, sizeof(timeout_thread_t) );
 948             p_sys->p_timeout->p_sys = p_demux->p_sys; /* lol, object recursion :D */
 949             if( vlc_thread_create( p_sys->p_timeout, "liveMedia-timeout", TimeoutPrevention,
 950                                    VLC_THREAD_PRIORITY_LOW, VLC_TRUE ) )
 951             {
 952                 msg_Err( p_demux, "cannot spawn liveMedia timeout thread" );
 953                 vlc_object_destroy( p_sys->p_timeout );
 954             }
 955             msg_Dbg( p_demux, "spawned timeout thread" );
 956             vlc_object_attach( p_sys->p_timeout, p_demux );
 957         }
 958     }
 959     p_sys->i_pcr = 0;
 960
 961 #if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1195257600)
 962     /* TODO */
 963     for( i = 0; i < p_sys->i_track; i++ )
 964     {
 965         p_sys->track[i]->i_pts = (int64_t) ( p_sys->track[i]->sub->rtpInfo.timestamp * (double)1000000.0 );
 966         p_sys->track[i]->i_start_seq = (int)p_sys->track[i]->sub->rtpInfo.seqNum;
 967         msg_Info( p_demux, "set startseq: %u", p_sys->track[i]->i_start_seq );
 968     }
 969 #endif
 970
 971 #if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
 972     /* Retrieve the starttime if possible */
 973     p_sys->i_npt_start = (int64_t)( p_sys->ms->playStartTime() * (double)1000000.0 );
 974 #else
 975     p_sys->i_npt_start = -1;
 976 #endif
 977     if( p_sys->i_npt_start < 0 )
 978     {
 979         p_sys->i_npt_start = -1;
 980         p_sys->i_npt = 0;
 981     }
 982     else
 983         p_sys->i_npt = p_sys->i_npt_start;
 984
 985 #if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
 986     /* Retrieve the duration if possible */
 987     p_sys->i_npt_length = (int64_t)( p_sys->ms->playEndTime() * (double)1000000.0 );
 988 #else
 989     p_sys->i_npt_length = -1;
 990 #endif
 991     if( p_sys->i_npt_length < 0 )
 992         p_sys->i_npt_length = -1;
 993
 994     msg_Dbg( p_demux, "play start: %lld stop:%lld", p_sys->i_npt_start, p_sys->i_npt_length );
 995     return VLC_SUCCESS;
 996 }
 997
 998
 999 /*****************************************************************************
1000  * Demux:
1001  *****************************************************************************/
1002 static int Demux( demux_t *p_demux )
1003 {
1004     demux_sys_t    *p_sys = p_demux->p_sys;
1005     TaskToken      task;
1006
1007     vlc_bool_t      b_send_pcr = VLC_TRUE;
1008     int64_t         i_pcr = 0;
1009     int             i;
1010
1011     /* Check if we need to send the server a Keep-A-Live signal */
1012     if( p_sys->b_timeout_call && p_sys->rtsp && p_sys->ms )
1013     {
1014         p_sys->rtsp->setMediaSessionParameter( *p_sys->ms, "vlc" , "1" );
1015         p_sys->b_timeout_call = VLC_FALSE;
1016     }
1017
1018
1019     for( i = 0; i < p_sys->i_track; i++ )
1020     {
1021         live_track_t *tk = p_sys->track[i];
1022
1023         if( tk->b_asf || tk->b_muxed )
1024             b_send_pcr = VLC_FALSE;
1025 #if 0
1026         if( i_pcr == 0 )
1027         {
1028             i_pcr = tk->i_pts;
1029         }
1030         else if( tk->i_pts != 0 && i_pcr > tk->i_pts )
1031         {
1032             i_pcr = tk->i_pts ;
1033         }
1034 #endif
1035     }
1036     if( p_sys->i_pcr > 0 )
1037     {
1038         if( b_send_pcr )
1039             es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_pcr );
1040     }
1041
1042     /* First warn we want to read data */
1043     p_sys->event = 0;
1044     for( i = 0; i < p_sys->i_track; i++ )
1045     {
1046         live_track_t *tk = p_sys->track[i];
1047
1048         if( tk->waiting == 0 )
1049         {
1050             tk->waiting = 1;
1051             tk->sub->readSource()->getNextFrame( tk->p_buffer, tk->i_buffer,
1052                                           StreamRead, tk, StreamClose, tk );
1053         }
1054     }
1055     /* Create a task that will be called if we wait more than 300ms */
1056     task = p_sys->scheduler->scheduleDelayedTask( 300000, TaskInterrupt, p_demux );
1057
1058     /* Do the read */
1059     p_sys->scheduler->doEventLoop( &p_sys->event );
1060
1061     /* remove the task */
1062     p_sys->scheduler->unscheduleDelayedTask( task );
1063
1064     /* Check for gap in pts value */
1065     for( i = 0; i < p_sys->i_track; i++ )
1066     {
1067         live_track_t *tk = p_sys->track[i];
1068
1069         if( !tk->b_muxed && !tk->b_rtcp_sync &&
1070             tk->sub->rtpSource() && tk->sub->rtpSource()->hasBeenSynchronizedUsingRTCP() )
1071         {
1072             msg_Dbg( p_demux, "tk->rtpSource->hasBeenSynchronizedUsingRTCP()" );
1073
1074             es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
1075             tk->b_rtcp_sync = VLC_TRUE;
1076             /* reset PCR */
1077             tk->i_pts = 0;
1078             p_sys->i_pcr = 0;
1079             i_pcr = 0;
1080         }
1081     }
1082
1083     if( p_sys->b_multicast && p_sys->b_no_data &&
1084         ( p_sys->i_no_data_ti > 120 ) )
1085     {
1086         /* FIXME Make this configurable
1087         msg_Err( p_demux, "no multicast data received in 36s, aborting" );
1088         return 0;
1089         */
1090     }
1091     else if( !p_sys->b_multicast && p_sys->b_no_data &&
1092              ( p_sys->i_no_data_ti > 34 ) )
1093     {
1094         vlc_bool_t b_rtsp_tcp = var_GetBool( p_demux, "rtsp-tcp" ) ||
1095                                 var_GetBool( p_demux, "rtsp-http" );
1096
1097         if( !b_rtsp_tcp && p_sys->rtsp && p_sys->ms )
1098         {
1099             msg_Warn( p_demux, "no data received in 10s. Switching to TCP" );
1100             if( RollOverTcp( p_demux ) )
1101             {
1102                 msg_Err( p_demux, "TCP rollover failed, aborting" );
1103                 return 0;
1104             }
1105         }
1106         else if( p_sys->i_no_data_ti > 34 )
1107         {
1108             msg_Err( p_demux, "no data received in 10s, aborting" );
1109             return 0;
1110         }
1111     }
1112     else if( !p_sys->b_multicast && p_sys->b_no_data && p_sys->i_no_data_ti > 34 )
1113     {
1114         /* EOF ? */
1115         msg_Warn( p_demux, "no data received in 10s, eof ?" );
1116         return 0;
1117     }
1118     return p_demux->b_error ? 0 : 1;
1119 }
1120
1121 /*****************************************************************************
1122  * Control:
1123  *****************************************************************************/
1124 static int Control( demux_t *p_demux, int i_query, va_list args )
1125 {
1126     demux_sys_t *p_sys = p_demux->p_sys;
1127     int64_t *pi64;
1128     double  *pf, f;
1129     vlc_bool_t *pb, b_bool;
1130
1131     switch( i_query )
1132     {
1133         case DEMUX_GET_TIME:
1134             pi64 = (int64_t*)va_arg( args, int64_t * );
1135             if( p_sys->i_npt > 0 )
1136             {
1137                 *pi64 = p_sys->i_npt;
1138                 return VLC_SUCCESS;
1139             }
1140             return VLC_EGENERIC;
1141
1142         case DEMUX_GET_LENGTH:
1143             pi64 = (int64_t*)va_arg( args, int64_t * );
1144             if( p_sys->i_npt_length > 0 )
1145             {
1146                 *pi64 = p_sys->i_npt_length;
1147                 return VLC_SUCCESS;
1148             }
1149             return VLC_EGENERIC;
1150
1151         case DEMUX_GET_POSITION:
1152             pf = (double*)va_arg( args, double* );
1153             if( p_sys->i_npt_length > 0 && p_sys->i_npt > 0 )
1154             {
1155                 *pf = (double)p_sys->i_npt / (double)p_sys->i_npt_length;
1156                 return VLC_SUCCESS;
1157             }
1158             return VLC_EGENERIC;
1159
1160         case DEMUX_SET_POSITION:
1161         {
1162             float time;
1163
1164             f = (double)va_arg( args, double );
1165             if( p_sys->rtsp && p_sys->i_npt_length > 0 )
1166             {
1167                 int i;
1168                 time = f * (double)p_sys->i_npt_length / 1000000.0;   /* in second */
1169                 if( !p_sys->rtsp->playMediaSession( *p_sys->ms, time, -1, 1 ) )
1170                 {
1171                     msg_Err( p_demux, "PLAY failed %s",
1172                         p_sys->env->getResultMsg() );
1173                     return VLC_EGENERIC;
1174                 }
1175                 es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
1176                 p_sys->i_pcr = 0;
1177 #if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1195257600)
1178                 /* Retrieve RTP-Info values */
1179                 for( i = 0; i < p_sys->i_track; i++ )
1180                 {
1181                     p_sys->track[i]->i_pts = (int64_t) ( p_sys->track[i]->sub->rtpInfo.timestamp * (double)1000000.0 );
1182                     p_sys->track[i]->i_start_seq = p_sys->track[i]->sub->rtpInfo.seqNum;
1183                     msg_Info( p_demux, "set pos startseq: %u", p_sys->track[i]->i_start_seq );
1184                 }
1185 #endif
1186 #if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
1187                 /* Retrieve the starttime if possible */
1188                 p_sys->i_npt_start = (int64_t)( p_sys->ms->playStartTime() * (double)1000000.0 );
1189 #else
1190                 p_sys->i_npt_start = -1;
1191 #endif
1192                 if( p_sys->i_npt_start < 0 )
1193                 {
1194                     p_sys->i_npt_start = -1;
1195                     p_sys->i_npt = 0;
1196                 }
1197                 else
1198                     p_sys->i_npt = p_sys->i_npt_start;
1199
1200 #if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
1201                 /* Retrieve the duration if possible */
1202                 p_sys->i_npt_length = (int64_t)( p_sys->ms->playEndTime() * (double)1000000.0 );
1203 #else
1204                 p_sys->i_npt_length = -1;
1205 #endif
1206                 if( p_sys->i_npt_length < 0 )
1207                     p_sys->i_npt_length = -1;
1208
1209                 msg_Dbg( p_demux, "seek start: %lld stop:%lld", p_sys->i_npt_start, p_sys->i_npt_length );
1210                 return VLC_SUCCESS;
1211             }
1212             return VLC_EGENERIC;
1213         }
1214         /* Special for access_demux */
1215         case DEMUX_CAN_PAUSE:
1216             pb = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
1217             if( p_sys->rtsp && p_sys->i_npt_length )
1218                 /* Not always true, but will be handled in SET_PAUSE_STATE */
1219                 *pb = VLC_TRUE;
1220             else
1221                 *pb = VLC_FALSE;
1222             return VLC_SUCCESS;
1223
1224         case DEMUX_CAN_CONTROL_PACE:
1225             pb = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
1226
1227 #if 1       /* Disable for now until we have a clock synchro algo
1228              * which works with something else than MPEG over UDP */
1229             *pb = VLC_FALSE;
1230 #else
1231             *pb = VLC_TRUE;
1232 #endif
1233             return VLC_SUCCESS;
1234
1235         case DEMUX_SET_PAUSE_STATE:
1236         {
1237             double d_npt = (double) p_sys->i_npt / I64C(1000000);
1238             int i;
1239
1240             b_bool = (vlc_bool_t)va_arg( args, vlc_bool_t );
1241             if( p_sys->rtsp == NULL )
1242                 return VLC_EGENERIC;
1243
1244             /* FIXME */
1245             if( ( b_bool && !p_sys->rtsp->pauseMediaSession( *p_sys->ms ) ) ||
1246                     ( !b_bool && !p_sys->rtsp->playMediaSession( *p_sys->ms,
1247                       d_npt > 0 ? d_npt : -1 ) ) )
1248             {
1249                     msg_Err( p_demux, "PLAY or PAUSE failed %s", p_sys->env->getResultMsg() );
1250                     return VLC_EGENERIC;
1251             }
1252             es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
1253             p_sys->i_pcr = 0;
1254 #if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1195257600)
1255             for( i = 0; i < p_sys->i_track; i++ )
1256             {
1257                 p_sys->track[i]->i_pts = (int64_t) ( p_sys->track[i]->sub->rtpInfo.timestamp * (double)1000000.0 );
1258                 p_sys->track[i]->i_start_seq = p_sys->track[i]->sub->rtpInfo.seqNum;
1259                 msg_Info( p_demux, "set pause startseq: %u", p_sys->track[i]->i_start_seq );
1260             }
1261 #endif
1262 #if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
1263             /* Retrieve the starttime if possible */
1264             p_sys->i_npt_start = (int64_t)( p_sys->ms->playStartTime() * (double)1000000.0 );
1265 #else
1266             p_sys->i_npt_start = -1;
1267 #endif
1268             if( p_sys->i_npt_start < 0 )
1269             {
1270                 p_sys->i_npt_start = -1;
1271                 p_sys->i_npt = 0;
1272             }
1273             else
1274                 p_sys->i_npt = p_sys->i_npt_start;
1275
1276 #if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
1277             /* Retrieve the duration if possible */
1278             p_sys->i_npt_length = (int64_t)( p_sys->ms->playEndTime() * (double)1000000.0 );
1279 #else
1280             p_sys->i_npt_length = -1;
1281 #endif
1282             if( p_sys->i_npt_length < 0 )
1283                 p_sys->i_npt_length = -1;
1284
1285             msg_Dbg( p_demux, "pause start: %lld stop:%lld", p_sys->i_npt_start, p_sys->i_npt_length );
1286             return VLC_SUCCESS;
1287         }
1288         case DEMUX_GET_TITLE_INFO:
1289         case DEMUX_SET_TITLE:
1290         case DEMUX_SET_SEEKPOINT:
1291             return VLC_EGENERIC;
1292
1293         case DEMUX_GET_PTS_DELAY:
1294             pi64 = (int64_t*)va_arg( args, int64_t * );
1295             *pi64 = (int64_t)var_GetInteger( p_demux, "rtsp-caching" ) * 1000;
1296             return VLC_SUCCESS;
1297
1298         default:
1299             return VLC_EGENERIC;
1300     }
1301 }
1302
1303 /*****************************************************************************
1304  * RollOverTcp: reopen the rtsp into TCP mode
1305  * XXX: ugly, a lot of code are duplicated from Open()
1306  * This should REALLY be fixed
1307  *****************************************************************************/
1308 static int RollOverTcp( demux_t *p_demux )
1309 {
1310     demux_sys_t *p_sys = p_demux->p_sys;
1311     int i, i_return;
1312
1313     var_SetBool( p_demux, "rtsp-tcp", VLC_TRUE );
1314
1315     /* We close the old RTSP session */
1316     for( i = 0; i < p_sys->i_track; i++ )
1317     {
1318         live_track_t *tk = p_sys->track[i];
1319
1320         if( tk->b_muxed ) stream_DemuxDelete( tk->p_out_muxed );
1321         free( tk->p_buffer );
1322         free( tk );
1323     }
1324     if( p_sys->i_track ) free( p_sys->track );
1325     if( p_sys->p_out_asf ) stream_DemuxDelete( p_sys->p_out_asf );
1326
1327     p_sys->rtsp->teardownMediaSession( *p_sys->ms );
1328     Medium::close( p_sys->ms );
1329     RTSPClient::close( p_sys->rtsp );
1330
1331     p_sys->ms = NULL;
1332     p_sys->rtsp = NULL;
1333     p_sys->track = NULL;
1334     p_sys->i_track = 0;
1335
1336     /* Reopen rtsp client */
1337     if( ( p_demux->s != NULL ) &&
1338         ( i_return = Connect( p_demux ) ) != VLC_SUCCESS )
1339     {
1340         msg_Err( p_demux, "Failed to connect with rtsp://%s",
1341                  p_sys->psz_path );
1342         goto error;
1343     }
1344
1345     if( p_sys->p_sdp == NULL )
1346     {
1347         msg_Err( p_demux, "Failed to retrieve the RTSP Session Description" );
1348         goto error;
1349     }
1350
1351     if( ( i_return = SessionsSetup( p_demux ) ) != VLC_SUCCESS )
1352     {
1353         msg_Err( p_demux, "Nothing to play for rtsp://%s", p_sys->psz_path );
1354         goto error;
1355     }
1356
1357     if( ( i_return = Play( p_demux ) ) != VLC_SUCCESS )
1358         goto error;
1359
1360     return VLC_SUCCESS;
1361
1362 error:
1363     return VLC_EGENERIC;
1364 }
1365
1366
1367 /*****************************************************************************
1368  *
1369  *****************************************************************************/
1370 static void StreamRead( void *p_private, unsigned int i_size,
1371                         unsigned int i_truncated_bytes, struct timeval pts,
1372                         unsigned int duration )
1373 {
1374     live_track_t   *tk = (live_track_t*)p_private;
1375     demux_t        *p_demux = tk->p_demux;
1376     demux_sys_t    *p_sys = p_demux->p_sys;
1377     block_t        *p_block;
1378
1379     //msg_Dbg( p_demux, "pts: %d", pts.tv_sec );
1380
1381     int64_t i_pts = (uint64_t)pts.tv_sec * UI64C(1000000) +
1382         (uint64_t)pts.tv_usec;
1383
1384     /* XXX Beurk beurk beurk Avoid having negative value XXX */
1385     i_pts &= UI64C(0x00ffffffffffffff);
1386
1387     if( tk->b_quicktime && tk->p_es == NULL )
1388     {
1389         QuickTimeGenericRTPSource *qtRTPSource =
1390             (QuickTimeGenericRTPSource*)tk->sub->rtpSource();
1391         QuickTimeGenericRTPSource::QTState &qtState = qtRTPSource->qtState;
1392         uint8_t *sdAtom = (uint8_t*)&qtState.sdAtom[4];
1393
1394         if( tk->fmt.i_cat == VIDEO_ES ) {
1395             if( qtState.sdAtomSize < 16 + 32 )
1396             {
1397                 /* invalid */
1398                 p_sys->event = 0xff;
1399                 tk->waiting = 0;
1400                 return;
1401             }
1402             tk->fmt.i_codec = VLC_FOURCC(sdAtom[0],sdAtom[1],sdAtom[2],sdAtom[3]);
1403             tk->fmt.video.i_width  = (sdAtom[28] << 8) | sdAtom[29];
1404             tk->fmt.video.i_height = (sdAtom[30] << 8) | sdAtom[31];
1405
1406             if( tk->fmt.i_codec == VLC_FOURCC('a', 'v', 'c', '1') )
1407             {
1408                 uint8_t *pos = (uint8_t*)qtRTPSource->qtState.sdAtom + 86;
1409                 uint8_t *endpos = (uint8_t*)qtRTPSource->qtState.sdAtom
1410                                   + qtRTPSource->qtState.sdAtomSize;
1411                 while (pos+8 < endpos) {
1412                     unsigned atomLength = pos[0]<<24 | pos[1]<<16 | pos[2]<<8 | pos[3];
1413                     if( atomLength == 0 || atomLength > endpos-pos) break;
1414                     if( memcmp(pos+4, "avcC", 4) == 0 &&
1415                         atomLength > 8 &&
1416                         atomLength <= INT_MAX )
1417                     {
1418                         tk->fmt.i_extra = atomLength-8;
1419                         tk->fmt.p_extra = malloc( tk->fmt.i_extra );
1420                         memcpy(tk->fmt.p_extra, pos+8, atomLength-8);
1421                         break;
1422                     }
1423                     pos += atomLength;
1424                 }
1425             }
1426             else
1427             {
1428                 tk->fmt.i_extra        = qtState.sdAtomSize - 16;
1429                 tk->fmt.p_extra        = malloc( tk->fmt.i_extra );
1430                 memcpy( tk->fmt.p_extra, &sdAtom[12], tk->fmt.i_extra );
1431             }
1432         }
1433         else {
1434             if( qtState.sdAtomSize < 4 )
1435             {
1436                 /* invalid */
1437                 p_sys->event = 0xff;
1438                 tk->waiting = 0;
1439                 return;
1440             }
1441             tk->fmt.i_codec = VLC_FOURCC(sdAtom[0],sdAtom[1],sdAtom[2],sdAtom[3]);
1442         }
1443         tk->p_es = es_out_Add( p_demux->out, &tk->fmt );
1444     }
1445
1446 #if 0
1447     fprintf( stderr, "StreamRead size=%d pts=%lld\n",
1448              i_size,
1449              pts.tv_sec * 1000000LL + pts.tv_usec );
1450 #endif
1451
1452     /* grow buffer if it looks like buffer is too small, but don't eat
1453      * up all the memory on strange streams */
1454     if( i_truncated_bytes > 0 && tk->i_buffer < 2000000 )
1455     {
1456         void *p_tmp;
1457         msg_Dbg( p_demux, "lost %d bytes", i_truncated_bytes );
1458         msg_Dbg( p_demux, "increasing buffer size to %d", tk->i_buffer * 2 );
1459         tk->i_buffer *= 2;
1460         p_tmp = realloc( tk->p_buffer, tk->i_buffer );
1461         if( p_tmp == NULL )
1462         {
1463             msg_Warn( p_demux, "realloc failed" );
1464         }
1465         else
1466         {
1467             tk->p_buffer = (uint8_t*)p_tmp;
1468         }
1469     }
1470     if( i_size > tk->i_buffer )
1471     {
1472         msg_Warn( p_demux, "buffer overflow" );
1473     }
1474     /* FIXME could i_size be > buffer size ? */
1475     if( tk->fmt.i_codec == VLC_FOURCC('s','a','m','r') ||
1476         tk->fmt.i_codec == VLC_FOURCC('s','a','w','b') )
1477     {
1478         AMRAudioSource *amrSource = (AMRAudioSource*)tk->sub->readSource();
1479
1480         p_block = block_New( p_demux, i_size + 1 );
1481         p_block->p_buffer[0] = amrSource->lastFrameHeader();
1482         memcpy( p_block->p_buffer + 1, tk->p_buffer, i_size );
1483     }
1484     else if( tk->fmt.i_codec == VLC_FOURCC('H','2','6','1') )
1485     {
1486 #if LIVEMEDIA_LIBRARY_VERSION_INT >= 1081468800
1487         H261VideoRTPSource *h261Source = (H261VideoRTPSource*)tk->sub->rtpSource();
1488         uint32_t header = h261Source->lastSpecialHeader();
1489 #else
1490         uint32_t header = 0;
1491         msg_Warn( p_demux, "need livemedia library >= \"2004.04.09\"" );
1492 #endif
1493         p_block = block_New( p_demux, i_size + 4 );
1494         memcpy( p_block->p_buffer, &header, 4 );
1495         memcpy( p_block->p_buffer + 4, tk->p_buffer, i_size );
1496
1497         if( tk->sub->rtpSource()->curPacketMarkerBit() )
1498             p_block->i_flags |= BLOCK_FLAG_END_OF_FRAME;
1499     }
1500     else if( tk->fmt.i_codec == VLC_FOURCC('h','2','6','4') )
1501     {
1502         if( (tk->p_buffer[0] & 0x1f) >= 24 )
1503             msg_Warn( p_demux, "unsupported NAL type for H264" );
1504
1505         /* Normal NAL type */
1506         p_block = block_New( p_demux, i_size + 4 );
1507         p_block->p_buffer[0] = 0x00;
1508         p_block->p_buffer[1] = 0x00;
1509         p_block->p_buffer[2] = 0x00;
1510         p_block->p_buffer[3] = 0x01;
1511         memcpy( &p_block->p_buffer[4], tk->p_buffer, i_size );
1512     }
1513     else if( tk->b_asf )
1514     {
1515         int i_copy = __MIN( p_sys->asfh.i_min_data_packet_size, (int)i_size );
1516         p_block = block_New( p_demux, p_sys->asfh.i_min_data_packet_size );
1517
1518         memcpy( p_block->p_buffer, tk->p_buffer, i_copy );
1519     }
1520     else
1521     {
1522         p_block = block_New( p_demux, i_size );
1523         memcpy( p_block->p_buffer, tk->p_buffer, i_size );
1524     }
1525
1526     /* Update NPT */
1527     //msg_Dbg( p_demux, "current %d, start_seq %u", (int)tk->sub->rtpSource()->curPacketRTPSeqNum(), tk->i_start_seq );
1528     if( (tk->fmt.i_cat == VIDEO_ES) && (p_sys->i_pcr < i_pts) &&
1529         (i_pts > 0) && (p_sys->i_pcr > 0) )
1530     {
1531         p_sys->i_npt += __MAX( 0, i_pts - p_sys->i_pcr );
1532         p_sys->i_pcr = i_pts;
1533         //msg_Dbg( p_demux, "npt update" );
1534     }
1535     else if( /*tk->fmt.i_cat == VIDEO_ES &&*/ p_sys->i_pcr < i_pts )
1536     {
1537         p_sys->i_pcr = i_pts;
1538     }
1539     //msg_Dbg( p_demux, "npt %lld", p_sys->i_npt );
1540
1541     if( (i_pts != tk->i_pts) && (!tk->b_muxed) )
1542     {
1543         p_block->i_dts = ( tk->fmt.i_cat == VIDEO_ES ) ? 0 : i_pts;
1544         p_block->i_pts = i_pts;
1545     }
1546
1547     if( tk->b_muxed )
1548     {
1549         stream_DemuxSend( tk->p_out_muxed, p_block );
1550     }
1551     else if( tk->b_asf )
1552     {
1553         stream_DemuxSend( p_sys->p_out_asf, p_block );
1554     }
1555     else
1556     {
1557         es_out_Send( p_demux->out, tk->p_es, p_block );
1558     }
1559
1560     /* warn that's ok */
1561     p_sys->event = 0xff;
1562
1563     /* we have read data */
1564     tk->waiting = 0;
1565     p_demux->p_sys->b_no_data = VLC_FALSE;
1566     p_demux->p_sys->i_no_data_ti = 0;
1567
1568     if( i_pts > 0 && !tk->b_muxed )
1569     {
1570         tk->i_pts = i_pts;
1571     }
1572 }
1573
1574 /*****************************************************************************
1575  *
1576  *****************************************************************************/
1577 static void StreamClose( void *p_private )
1578 {
1579     live_track_t   *tk = (live_track_t*)p_private;
1580     demux_t        *p_demux = tk->p_demux;
1581     demux_sys_t    *p_sys = p_demux->p_sys;
1582
1583     msg_Dbg( p_demux, "StreamClose" );
1584
1585     p_sys->event = 0xff;
1586     p_demux->b_error = VLC_TRUE;
1587 }
1588
1589
1590 /*****************************************************************************
1591  *
1592  *****************************************************************************/
1593 static void TaskInterrupt( void *p_private )
1594 {
1595     demux_t *p_demux = (demux_t*)p_private;
1596
1597     p_demux->p_sys->i_no_data_ti++;
1598
1599     /* Avoid lock */
1600     p_demux->p_sys->event = 0xff;
1601 }
1602
1603 /*****************************************************************************
1604  *
1605  *****************************************************************************/
1606 static void TimeoutPrevention( timeout_thread_t *p_timeout )
1607 {
1608     p_timeout->b_die = VLC_FALSE;
1609     p_timeout->i_remain = (int64_t)p_timeout->p_sys->i_timeout -2;
1610     p_timeout->i_remain *= 1000000;
1611
1612     vlc_thread_ready( p_timeout );
1613
1614     /* Avoid lock */
1615     while( !p_timeout->b_die )
1616     {
1617         if( p_timeout->i_remain <= 0 )
1618         {
1619             p_timeout->i_remain = (int64_t)p_timeout->p_sys->i_timeout -2;
1620             p_timeout->i_remain *= 1000000;
1621             p_timeout->p_sys->b_timeout_call = VLC_TRUE;
1622             msg_Dbg( p_timeout, "reset the timeout timer" );
1623         }
1624         p_timeout->i_remain -= 200000;
1625         msleep( 200000 ); /* 200 ms */
1626     }
1627 }
1628
1629 /*****************************************************************************
1630  *
1631  *****************************************************************************/
1632 static int b64_decode( char *dest, char *src );
1633
1634 static int ParseASF( demux_t *p_demux )
1635 {
1636     demux_sys_t    *p_sys = p_demux->p_sys;
1637
1638     const char *psz_marker = "a=pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,";
1639     char *psz_asf = strcasestr( p_sys->p_sdp, psz_marker );
1640     char *psz_end;
1641     block_t *p_header;
1642
1643     /* Parse the asf header */
1644     if( psz_asf == NULL )
1645         return VLC_EGENERIC;
1646
1647     psz_asf += strlen( psz_marker );
1648     psz_asf = strdup( psz_asf );    /* Duplicate it */
1649     psz_end = strchr( psz_asf, '\n' );
1650
1651     while( psz_end > psz_asf && ( *psz_end == '\n' || *psz_end == '\r' ) )
1652         *psz_end-- = '\0';
1653
1654     if( psz_asf >= psz_end )
1655     {
1656         free( psz_asf );
1657         return VLC_EGENERIC;
1658     }
1659
1660     /* Always smaller */
1661     p_header = block_New( p_demux, psz_end - psz_asf );
1662     p_header->i_buffer = b64_decode( (char*)p_header->p_buffer, psz_asf );
1663     //msg_Dbg( p_demux, "Size=%d Hdrb64=%s", p_header->i_buffer, psz_asf );
1664     if( p_header->i_buffer <= 0 )
1665     {
1666         free( psz_asf );
1667         return VLC_EGENERIC;
1668     }
1669
1670     /* Parse it to get packet size */
1671     E_(asf_HeaderParse)( &p_sys->asfh, p_header->p_buffer, p_header->i_buffer );
1672
1673     /* Send it to demuxer */
1674     stream_DemuxSend( p_sys->p_out_asf, p_header );
1675
1676     free( psz_asf );
1677     return VLC_SUCCESS;
1678 }
1679
1680
1681 static unsigned char* parseH264ConfigStr( char const* configStr,
1682                                           unsigned int& configSize )
1683 {
1684     char *dup, *psz;
1685     int i, i_records = 1;
1686
1687     if( configSize )
1688     configSize = 0;
1689
1690     if( configStr == NULL || *configStr == '\0' )
1691         return NULL;
1692
1693     psz = dup = strdup( configStr );
1694
1695     /* Count the number of comma's */
1696     for( psz = dup; *psz != '\0'; ++psz )
1697     {
1698         if( *psz == ',')
1699         {
1700             ++i_records;
1701             *psz = '\0';
1702         }
1703     }
1704
1705     unsigned char *cfg = new unsigned char[5 * strlen(dup)];
1706     psz = dup;
1707     for( i = 0; i < i_records; i++ )
1708     {
1709         cfg[configSize++] = 0x00;
1710         cfg[configSize++] = 0x00;
1711         cfg[configSize++] = 0x00;
1712         cfg[configSize++] = 0x01;
1713
1714         configSize += b64_decode( (char*)&cfg[configSize], psz );
1715         psz += strlen(psz)+1;
1716     }
1717
1718     if( dup ) free( dup );
1719     return cfg;
1720 }
1721
1722 /*char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";*/
1723 static int b64_decode( char *dest, char *src )
1724 {
1725     const char *dest_start = dest;
1726     int  i_level;
1727     int  last = 0;
1728     int  b64[256] = {
1729         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 00-0F */
1730         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 10-1F */
1731         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,  /* 20-2F */
1732         52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,  /* 30-3F */
1733         -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,  /* 40-4F */
1734         15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,  /* 50-5F */
1735         -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,  /* 60-6F */
1736         41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,  /* 70-7F */
1737         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 80-8F */
1738         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 90-9F */
1739         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* A0-AF */
1740         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* B0-BF */
1741         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* C0-CF */
1742         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* D0-DF */
1743         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* E0-EF */
1744         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1   /* F0-FF */
1745         };
1746
1747     for( i_level = 0; *src != '\0'; src++ )
1748     {
1749         int  c;
1750
1751         c = b64[(unsigned int)*src];
1752         if( c == -1 )
1753         {
1754             continue;
1755         }
1756
1757         switch( i_level )
1758         {
1759             case 0:
1760                 i_level++;
1761                 break;
1762             case 1:
1763                 *dest++ = ( last << 2 ) | ( ( c >> 4)&0x03 );
1764                 i_level++;
1765                 break;
1766             case 2:
1767                 *dest++ = ( ( last << 4 )&0xf0 ) | ( ( c >> 2 )&0x0f );
1768                 i_level++;
1769                 break;
1770             case 3:
1771                 *dest++ = ( ( last &0x03 ) << 6 ) | c;
1772                 i_level = 0;
1773         }
1774         last = c;
1775     }
1776
1777     *dest = '\0';
1778
1779     return dest - dest_start;
1780 }