开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
live555.cpp
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：65k
源码类别：

midi

开发平台：

Unix_Linux

live555.cpp：源码内容
  1. /*****************************************************************************
  2.  * live555.cpp : LIVE555 Streaming Media support.
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2007 the VideoLAN team
  5.  * $Id: 80a59a33d3fb8716e5c1ecc9c844143613629856 $
  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.  *****************************************************************************/
  26. /*****************************************************************************
  27.  * Preamble
  28.  *****************************************************************************/
  30. /* For inttypes.h
  31.  * Note: config.h may include inttypes.h, so make sure we define this option
  32.  * early enough. */
  33. #define __STDC_CONSTANT_MACROS 1
  35. #ifdef HAVE_CONFIG_H
  36. # include "config.h"
  37. #endif
  39. #include <inttypes.h>
  41. #include <vlc_common.h>
  42. #include <vlc_plugin.h>
  43. #include <vlc_input.h>
  44. #include <vlc_demux.h>
  45. #include <vlc_dialog.h>
  46. #include <vlc_network.h>
  47. #include <vlc_url.h>
  49. #include <iostream>
  50. #include <limits.h>
  51. #include <assert.h>
  54. #if defined( WIN32 )
  55. #   include <winsock2.h>
  56. #endif
  58. #include "UsageEnvironment.hh"
  59. #include "BasicUsageEnvironment.hh"
  60. #include "GroupsockHelper.hh"
  61. #include "liveMedia.hh"
  63. extern "C" {
  64. #include "../access/mms/asf.h"  /* Who said ugly ? */
  65. }
  67. using namespace std;
  69. /*****************************************************************************
  70.  * Module descriptor
  71.  *****************************************************************************/
  72. static int  Open ( vlc_object_t * );
  73. static void Close( vlc_object_t * );
  75. #define CACHING_TEXT N_("Caching value (ms)")
  76. #define CACHING_LONGTEXT N_( 
  77.     "Allows you to modify the default caching value for RTSP streams. This " 
  78.     "value should be set in millisecond units." )
  80. #define KASENNA_TEXT N_( "Kasenna RTSP dialect")
  81. #define KASENNA_LONGTEXT N_( "Kasenna servers use an old and unstandard " 
  82.     "dialect of RTSP. When you set this parameter, VLC will try this dialect "
  83.     "for communication. In this mode you cannot connect to normal RTSP servers." )
  85. #define USER_TEXT N_("RTSP user name")
  86. #define USER_LONGTEXT N_("Allows you to modify the user name that will " 
  87.     "be used for authenticating the connection.")
  88. #define PASS_TEXT N_("RTSP password")
  89. #define PASS_LONGTEXT N_("Allows you to modify the password that will be " 
  90.     "used for the connection.")
  92. vlc_module_begin ()
  93.     set_description( N_("RTP/RTSP/SDP demuxer (using Live555)" ) )
  94.     set_capability( "demux", 50 )
  95.     set_shortname( "RTP/RTSP")
  96.     set_callbacks( Open, Close )
  97.     add_shortcut( "live" )
  98.     add_shortcut( "livedotcom" )
  99.     set_category( CAT_INPUT )
  100.     set_subcategory( SUBCAT_INPUT_DEMUX )
  102.     add_submodule ()
  103.         set_description( N_("RTSP/RTP access and demux") )
  104.         add_shortcut( "rtsp" )
  105.         add_shortcut( "sdp" )
  106.         add_shortcut( "live" )
  107.         add_shortcut( "livedotcom" )
  108.         set_capability( "access_demux", 0 )
  109.         set_callbacks( Open, Close )
  110.         add_bool( "rtsp-tcp", 0, NULL,
  111.                   N_("Use RTP over RTSP (TCP)"),
  112.                   N_("Use RTP over RTSP (TCP)"), true )
  113.             change_safe()
  114.         add_integer( "rtp-client-port", -1, NULL,
  115.                   N_("Client port"),
  116.                   N_("Port to use for the RTP source of the session"), true )
  117.         add_bool( "rtsp-mcast", false, NULL,
  118.                   N_("Force multicast RTP via RTSP"),
  119.                   N_("Force multicast RTP via RTSP"), true )
  120.             change_safe()
  121.         add_bool( "rtsp-http", 0, NULL,
  122.                   N_("Tunnel RTSP and RTP over HTTP"),
  123.                   N_("Tunnel RTSP and RTP over HTTP"), true )
  124.             change_safe()
  125.         add_integer( "rtsp-http-port", 80, NULL,
  126.                   N_("HTTP tunnel port"),
  127.                   N_("Port to use for tunneling the RTSP/RTP over HTTP."),
  128.                   true )
  129.         add_integer("rtsp-caching", 4 * DEFAULT_PTS_DELAY / 1000, NULL,
  130.                     CACHING_TEXT, CACHING_LONGTEXT, true )
  131.             change_safe()
  132.         add_bool(   "rtsp-kasenna", false, NULL, KASENNA_TEXT,
  133.                     KASENNA_LONGTEXT, true )
  134.         add_string( "rtsp-user", NULL, NULL, USER_TEXT,
  135.                     USER_LONGTEXT, true )
  136.             change_safe()
  137.         add_string( "rtsp-pwd", NULL, NULL, PASS_TEXT,
  138.                     PASS_LONGTEXT, true )
  139.             change_safe()
  140. vlc_module_end ()
  143. /*****************************************************************************
  144.  * Local prototypes
  145.  *****************************************************************************/
  147. typedef struct
  148. {
  149.     demux_t         *p_demux;
  150.     MediaSubsession *sub;
  152.     es_format_t     fmt;
  153.     es_out_id_t     *p_es;
  155.     bool            b_muxed;
  156.     bool            b_quicktime;
  157.     bool            b_asf;
  158.     stream_t        *p_out_muxed;    /* for muxed stream */
  160.     uint8_t         *p_buffer;
  161.     unsigned int    i_buffer;
  163.     bool            b_rtcp_sync;
  164.     char            waiting;
  165.     int64_t         i_pts;
  166.     float           i_npt;
  168. } live_track_t;
  170. struct timeout_thread_t
  171. {
  172.     demux_sys_t  *p_sys;
  173.     vlc_thread_t handle;
  174.     bool         b_handle_keep_alive;
  175. };
  177. struct demux_sys_t
  178. {
  179.     char            *p_sdp;    /* XXX mallocated */
  180.     char            *psz_path; /* URL-encoded path */
  181.     vlc_url_t       url;
  183.     MediaSession     *ms;
  184.     TaskScheduler    *scheduler;
  185.     UsageEnvironment *env ;
  186.     RTSPClient       *rtsp;
  188.     /* */
  189.     int              i_track;
  190.     live_track_t     **track;   /* XXX mallocated */
  192.     /* Weird formats */
  193.     asf_header_t     asfh;
  194.     stream_t         *p_out_asf;
  195.     bool             b_real;
  197.     /* */
  198.     int64_t          i_pcr; /* The clock */
  199.     float            i_npt;
  200.     float            i_npt_length;
  201.     float            i_npt_start;
  203.     /* timeout thread information */
  204.     int              i_timeout;     /* session timeout value in seconds */
  205.     bool             b_timeout_call;/* mark to send an RTSP call to prevent server timeout */
  206.     timeout_thread_t *p_timeout;    /* the actual thread that makes sure we don't timeout */
  208.     /* */
  209.     bool             b_force_mcast;
  210.     bool             b_multicast;   /* if one of the tracks is multicasted */
  211.     bool             b_no_data;     /* if we never received any data */
  212.     int              i_no_data_ti;  /* consecutive number of TaskInterrupt */
  214.     char             event;
  216.     bool             b_get_param;   /* Does the server support GET_PARAMETER */
  217.     bool             b_paused;      /* Are we paused? */
  218. };
  220. static int Demux  ( demux_t * );
  221. static int Control( demux_t *, int, va_list );
  223. static int Connect      ( demux_t * );
  224. static int SessionsSetup( demux_t * );
  225. static int Play         ( demux_t *);
  226. static int ParseASF     ( demux_t * );
  227. static int RollOverTcp  ( demux_t * );
  229. static void StreamRead  ( void *, unsigned int, unsigned int,
  230.                           struct timeval, unsigned int );
  231. static void StreamClose ( void * );
  232. static void TaskInterrupt( void * );
  234. static void* TimeoutPrevention( void * );
  236. static unsigned char* parseH264ConfigStr( char const* configStr,
  237.                                           unsigned int& configSize );
  239. /*****************************************************************************
  240.  * DemuxOpen:
  241.  *****************************************************************************/
  242. static int  Open ( vlc_object_t *p_this )
  243. {
  244.     demux_t     *p_demux = (demux_t*)p_this;
  245.     demux_sys_t *p_sys = NULL;
  247.     int i, i_return;
  248.     int i_error = VLC_EGENERIC;
  250.     if( p_demux->s )
  251.     {
  252.         /* See if it looks like a SDP
  253.            v, o, s fields are mandatory and in this order */
  254.         const uint8_t *p_peek;
  255.         if( stream_Peek( p_demux->s, &p_peek, 7 ) < 7 ) return VLC_EGENERIC;
  257.         if( memcmp( p_peek, "v=0rn", 5 ) &&
  258.             memcmp( p_peek, "v=0n", 4 ) &&
  259.             ( p_peek[0] < 'a' || p_peek[0] > 'z' || p_peek[1] != '=' ) )
  260.         {
  261.             return VLC_EGENERIC;
  262.         }
  263.     }
  264.     else
  265.     {
  266.         var_Create( p_demux, "rtsp-caching", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
  267.     }
  269.     p_demux->pf_demux  = Demux;
  270.     p_demux->pf_control= Control;
  271.     p_demux->p_sys     = p_sys = (demux_sys_t*)malloc( sizeof( demux_sys_t ) );
  272.     if( !p_sys ) return VLC_ENOMEM;
  274.     p_sys->p_sdp = NULL;
  275.     p_sys->scheduler = NULL;
  276.     p_sys->env = NULL;
  277.     p_sys->ms = NULL;
  278.     p_sys->rtsp = NULL;
  279.     p_sys->i_track = 0;
  280.     p_sys->track   = NULL;
  281.     p_sys->i_pcr = 0;
  282.     p_sys->i_npt = 0.;
  283.     p_sys->i_npt_start = 0.;
  284.     p_sys->i_npt_length = 0.;
  285.     p_sys->p_out_asf = NULL;
  286.     p_sys->b_no_data = true;
  287.     p_sys->i_no_data_ti = 0;
  288.     p_sys->p_timeout = NULL;
  289.     p_sys->i_timeout = 0;
  290.     p_sys->b_timeout_call = false;
  291.     p_sys->b_multicast = false;
  292.     p_sys->b_real = false;
  293.     p_sys->psz_path = strdup( p_demux->psz_path );
  294.     p_sys->b_force_mcast = var_CreateGetBool( p_demux, "rtsp-mcast" );
  295.     p_sys->b_get_param = false;
  296.     p_sys->b_paused = false;
  298.     /* parse URL for rtsp://[user:[passwd]@]serverip:port/options */
  299.     vlc_UrlParse( &p_sys->url, p_sys->psz_path, 0 );
  301.     if( ( p_sys->scheduler = BasicTaskScheduler::createNew() ) == NULL )
  302.     {
  303.         msg_Err( p_demux, "BasicTaskScheduler::createNew failed" );
  304.         goto error;
  305.     }
  306.     if( !( p_sys->env = BasicUsageEnvironment::createNew(*p_sys->scheduler) ) )
  307.     {
  308.         msg_Err( p_demux, "BasicUsageEnvironment::createNew failed" );
  309.         goto error;
  310.     }
  312.     if( strcasecmp( p_demux->psz_access, "sdp" ) )
  313.     {
  314.         char *p = p_sys->psz_path;
  315.         while( (p = strchr( p, ' ' )) != NULL ) *p = '+';
  316.     }
  318.     if( p_demux->s != NULL )
  319.     {
  320.         /* Gather the complete sdp file */
  321.         int     i_sdp       = 0;
  322.         int     i_sdp_max   = 1000;
  323.         uint8_t *p_sdp      = (uint8_t*) malloc( i_sdp_max );
  325.         if( !p_sdp )
  326.         {
  327.             i_error = VLC_ENOMEM;
  328.             goto error;
  329.         }
  331.         for( ;; )
  332.         {
  333.             int i_read = stream_Read( p_demux->s, &p_sdp[i_sdp],
  334.                                       i_sdp_max - i_sdp - 1 );
  336.             if( !vlc_object_alive (p_demux) || p_demux->b_error )
  337.             {
  338.                 free( p_sdp );
  339.                 goto error;
  340.             }
  342.             if( i_read < 0 )
  343.             {
  344.                 msg_Err( p_demux, "failed to read SDP" );
  345.                 free( p_sdp );
  346.                 goto error;
  347.             }
  349.             i_sdp += i_read;
  351.             if( i_read < i_sdp_max - i_sdp - 1 )
  352.             {
  353.                 p_sdp[i_sdp] = '';
  354.                 break;
  355.             }
  357.             i_sdp_max += 1000;
  358.             p_sdp = (uint8_t*)realloc( p_sdp, i_sdp_max );
  359.         }
  360.         p_sys->p_sdp = (char*)p_sdp;
  361.     }
  362.     else if( ( p_demux->s == NULL ) &&
  363.              !strcasecmp( p_demux->psz_access, "sdp" ) )
  364.     {
  365.         /* sdp:// link from SAP */
  366.         p_sys->p_sdp = strdup( p_sys->psz_path );
  367.     }
  368.     else if( ( i_return = Connect( p_demux ) ) != VLC_SUCCESS )
  369.     {
  370.         msg_Err( p_demux, "Failed to connect with rtsp://%s", p_sys->psz_path );
  371.         goto error;
  372.     }
  374.     if( p_sys->p_sdp == NULL )
  375.     {
  376.         msg_Err( p_demux, "Failed to retrieve the RTSP Session Description" );
  377.         i_error = VLC_ENOMEM;
  378.         goto error;
  379.     }
  381.     if( ( i_return = SessionsSetup( p_demux ) ) != VLC_SUCCESS )
  382.     {
  383.         msg_Err( p_demux, "Nothing to play for rtsp://%s", p_sys->psz_path );
  384.         goto error;
  385.     }
  387.     if( p_sys->b_real ) goto error;
  389.     if( ( i_return = Play( p_demux ) ) != VLC_SUCCESS )
  390.         goto error;
  392.     if( p_sys->p_out_asf && ParseASF( p_demux ) )
  393.     {
  394.         msg_Err( p_demux, "cannot find a usable asf header" );
  395.         /* TODO Clean tracks */
  396.         goto error;
  397.     }
  399.     if( p_sys->i_track <= 0 )
  400.         goto error;
  402.     return VLC_SUCCESS;
  404. error:
  405.     for( i = 0; i < p_sys->i_track; i++ )
  406.     {
  407.         live_track_t *tk = p_sys->track[i];
  409.         if( tk->b_muxed ) stream_Delete( tk->p_out_muxed );
  410.         es_format_Clean( &tk->fmt );
  411.         free( tk->p_buffer );
  412.         free( tk );
  413.     }
  415.     if( p_sys->i_track ) free( p_sys->track );
  416.     if( p_sys->p_out_asf ) stream_Delete( p_sys->p_out_asf );
  417.     if( p_sys->rtsp && p_sys->ms ) p_sys->rtsp->teardownMediaSession( *p_sys->ms );
  418.     if( p_sys->p_timeout )
  419.     {
  420.         vlc_cancel( p_sys->p_timeout->handle );
  421.         vlc_join( p_sys->p_timeout->handle, NULL );
  422.         free( p_sys->p_timeout );
  423.     }
  424.     if( p_sys->ms ) Medium::close( p_sys->ms );
  425.     if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
  426.     if( p_sys->env ) p_sys->env->reclaim();
  427.     delete p_sys->scheduler;
  428.     free( p_sys->p_sdp );
  429.     free( p_sys->psz_path );
  431.     vlc_UrlClean( &p_sys->url );
  433.     free( p_sys );
  434.     return i_error;
  435. }
  437. /*****************************************************************************
  438.  * DemuxClose:
  439.  *****************************************************************************/
  440. static void Close( vlc_object_t *p_this )
  441. {
  442.     demux_t *p_demux = (demux_t*)p_this;
  443.     demux_sys_t *p_sys = p_demux->p_sys;
  444.     int i;
  446.     for( i = 0; i < p_sys->i_track; i++ )
  447.     {
  448.         live_track_t *tk = p_sys->track[i];
  450.         if( tk->b_muxed ) stream_Delete( tk->p_out_muxed );
  451.         es_format_Clean( &tk->fmt );
  452.         free( tk->p_buffer );
  453.         free( tk );
  454.     }
  456.     if( p_sys->i_track ) free( p_sys->track );
  457.     if( p_sys->p_out_asf ) stream_Delete( p_sys->p_out_asf );
  458.     if( p_sys->rtsp && p_sys->ms ) p_sys->rtsp->teardownMediaSession( *p_sys->ms );
  459.     if( p_sys->p_timeout )
  460.     {
  461.         vlc_cancel( p_sys->p_timeout->handle );
  462.         vlc_join( p_sys->p_timeout->handle, NULL );
  463.         free( p_sys->p_timeout );
  464.     }
  465.     if( p_sys->ms ) Medium::close( p_sys->ms );
  466.     if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
  467.     if( p_sys->env ) p_sys->env->reclaim();
  468.     delete p_sys->scheduler;
  469.     free( p_sys->p_sdp );
  470.     free( p_sys->psz_path );
  472.     vlc_UrlClean( &p_sys->url );
  474.     free( p_sys );
  475. }
  477. /*****************************************************************************
  478.  * Connect: connects to the RTSP server to setup the session DESCRIBE
  479.  *****************************************************************************/
  480. static int Connect( demux_t *p_demux )
  481. {
  482.     demux_sys_t *p_sys = p_demux->p_sys;
  483.     Authenticator authenticator;
  484.     char *psz_user    = NULL;
  485.     char *psz_pwd     = NULL;
  486.     char *psz_url     = NULL;
  487.     char *psz_options = NULL;
  488.     char *p_sdp       = NULL;
  489.     int  i_http_port  = 0;
  490.     int  i_ret        = VLC_SUCCESS;
  492.     /* Create the url using the port number if available */
  493.     if( p_sys->url.i_port == 0 )
  494.     {
  495.         p_sys->url.i_port = 554;
  496.         if( asprintf( &psz_url, "rtsp://%s", p_sys->psz_path ) == -1 )
  497.             return VLC_ENOMEM;
  498.     }
  499.     else
  500.     {
  501.         if( asprintf( &psz_url, "rtsp://%s:%d%s", p_sys->url.psz_host,
  502.                       p_sys->url.i_port, p_sys->url.psz_path ) == -1 )
  503.             return VLC_ENOMEM;
  504.     }
  506.     /* Get the user name and password */
  507.     if( p_sys->url.psz_username || p_sys->url.psz_password )
  508.     {
  509.         psz_user = strdup( p_sys->url.psz_username ? p_sys->url.psz_username : "" );
  510.         psz_pwd  = strdup( p_sys->url.psz_password ? p_sys->url.psz_password : "");
  511.     }
  512.     else
  513.     {
  514.         psz_user = var_CreateGetString( p_demux, "rtsp-user" );
  515.         psz_pwd  = var_CreateGetString( p_demux, "rtsp-pwd" );
  516.     }
  518. createnew:
  519.     if( !vlc_object_alive (p_demux) || p_demux->b_error )
  520.     {
  521.         free( psz_user );
  522.         free( psz_pwd );
  523.         free( psz_url );
  524.         return VLC_EGENERIC;
  525.     }
  527.     if( var_CreateGetBool( p_demux, "rtsp-http" ) )
  528.         i_http_port = var_CreateGetInteger( p_demux, "rtsp-http-port" );
  530.     if( ( p_sys->rtsp = RTSPClient::createNew( *p_sys->env,
  531.           var_CreateGetInteger( p_demux, "verbose" ) > 1,
  532.           "VLC media player", i_http_port ) ) == NULL )
  533.     {
  534.         msg_Err( p_demux, "RTSPClient::createNew failed (%s)",
  535.                  p_sys->env->getResultMsg() );
  536.         free( psz_user );
  537.         free( psz_pwd );
  538.         free( psz_url );
  539.         return VLC_EGENERIC;
  540.     }
  542.     /* Kasenna enables KeepAlive by analysing the User-Agent string.
  543.      * Appending _KA to the string should be enough to enable this feature,
  544.      * however, there is a bug where the _KA doesn't get parsed from the
  545.      * default User-Agent as created by VLC/Live555 code. This is probably due
  546.      * to spaces in the string or the string being too long. Here we override
  547.      * the default string with a more compact version.
  548.      */
  549.     if( var_CreateGetBool( p_demux, "rtsp-kasenna" ))
  550.     {
  551.         p_sys->rtsp->setUserAgentString( "VLC_MEDIA_PLAYER_KA" );
  552.     }
  554. describe:
  555.     authenticator.setUsernameAndPassword( (const char*)psz_user,
  556.                                           (const char*)psz_pwd );
  558.     /* */
  559.     const int i_timeout = var_CreateGetInteger(p_demux, "ipv4-timeout") / 1000;
  561. #if LIVEMEDIA_LIBRARY_VERSION_INT >= 1223337600
  562.     psz_options = p_sys->rtsp->sendOptionsCmd( psz_url, psz_user, psz_pwd,
  563.                                                &authenticator, i_timeout );
  564. #else
  565.     psz_options = p_sys->rtsp->sendOptionsCmd( psz_url, psz_user, psz_pwd,
  566.                                                &authenticator );
  567. #endif
  568.     if( psz_options == NULL && authenticator.realm() != NULL )
  569.     {
  570.         // try again, with the realm set this time
  571. #if LIVEMEDIA_LIBRARY_VERSION_INT >= 1223337600
  572.         psz_options = p_sys->rtsp->sendOptionsCmd( psz_url, psz_user, psz_pwd,
  573.                                                &authenticator, i_timeout );
  574. #else
  575.         psz_options = p_sys->rtsp->sendOptionsCmd( psz_url, psz_user, psz_pwd,
  576.                                                &authenticator );
  577. #endif
  578.     }
  579.     if( psz_options )
  580.         p_sys->b_get_param = strstr( psz_options, "GET_PARAMETER" ) ? true : false ;
  581.     delete [] psz_options;
  583. #if LIVEMEDIA_LIBRARY_VERSION_INT >= 1223337600
  584.     p_sdp = p_sys->rtsp->describeWithPassword( psz_url, (const char*)psz_user, (const char*)psz_pwd,
  585.                                           var_GetBool( p_demux, "rtsp-kasenna" ), i_timeout );
  586. #else
  587.     p_sdp = p_sys->rtsp->describeWithPassword( psz_url, (const char*)psz_user, (const char*)psz_pwd,
  588.                                           var_GetBool( p_demux, "rtsp-kasenna" ) );
  589. #endif
  591.     if( p_sdp == NULL )
  592.     {
  593.         /* failure occurred */
  594.         int i_code = 0;
  595.         const char *psz_error = p_sys->env->getResultMsg();
  597.         if( var_GetBool( p_demux, "rtsp-http" ) )
  598.             sscanf( psz_error, "%*s %*s HTTP GET %*s HTTP/%*u.%*u %3u %*s",
  599.                     &i_code );
  600.         else
  601.         {
  602.             const char *psz_tmp = strstr( psz_error, "RTSP" );
  603.             if( psz_tmp )
  604.                 sscanf( psz_tmp, "RTSP/%*s%3u", &i_code );
  605.             else
  606.                 i_code = 0;
  607.         }
  608.         msg_Dbg( p_demux, "DESCRIBE failed with %d: %s", i_code, psz_error );
  610.         if( i_code == 401 )
  611.         {
  612.             msg_Dbg( p_demux, "authentication failed" );
  614.             free( psz_user );
  615.             free( psz_pwd );
  616.             dialog_Login( p_demux, &psz_user, &psz_pwd,
  617.                           _("RTSP authentication"), "%s",
  618.                         _("Please enter a valid login name and a password.") );
  619.             if( psz_user != NULL && psz_pwd != NULL )
  620.             {
  621.                 msg_Dbg( p_demux, "retrying with user=%s", psz_user );
  622.                 goto describe;
  623.             }
  624.         }
  625.         else if( (i_code != 0) && !var_GetBool( p_demux, "rtsp-http" ) )
  626.         {
  627.             /* Perhaps a firewall is being annoying. Try HTTP tunneling mode */
  628.             vlc_value_t val;
  629.             val.b_bool = true;
  630.             msg_Dbg( p_demux, "we will now try HTTP tunneling mode" );
  631.             var_Set( p_demux, "rtsp-http", val );
  632.             if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
  633.             p_sys->rtsp = NULL;
  634.             goto createnew;
  635.         }
  636.         else
  637.         {
  638.             msg_Dbg( p_demux, "connection timeout" );
  639.             if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
  640.             p_sys->rtsp = NULL;
  641.         }
  642.         i_ret = VLC_EGENERIC;
  643.     }
  645.     /* malloc-ated copy */
  646.     free( psz_url );
  647.     free( psz_user );
  648.     free( psz_pwd );
  650.     free( p_sys->p_sdp );
  651.     p_sys->p_sdp = NULL;
  652.     if( p_sdp ) p_sys->p_sdp = strdup( (char*)p_sdp );
  653.     delete[] p_sdp;
  655.     return i_ret;
  656. }
  658. /*****************************************************************************
  659.  * SessionsSetup: prepares the subsessions and does the SETUP
  660.  *****************************************************************************/
  661. static int SessionsSetup( demux_t *p_demux )
  662. {
  663.     demux_sys_t             *p_sys  = p_demux->p_sys;
  664.     MediaSubsessionIterator *iter   = NULL;
  665.     MediaSubsession         *sub    = NULL;
  667.     bool           b_rtsp_tcp = false;
  668.     int            i_client_port;
  669.     int            i_return = VLC_SUCCESS;
  670.     unsigned int   i_buffer = 0;
  671.     unsigned const thresh = 200000; /* RTP reorder threshold .2 second (default .1) */
  673.     b_rtsp_tcp    = var_CreateGetBool( p_demux, "rtsp-tcp" ) ||
  674.                     var_GetBool( p_demux, "rtsp-http" );
  675.     i_client_port = var_CreateGetInteger( p_demux, "rtp-client-port" );
  677.     /* Create the session from the SDP */
  678.     if( !( p_sys->ms = MediaSession::createNew( *p_sys->env, p_sys->p_sdp ) ) )
  679.     {
  680.         msg_Err( p_demux, "Could not create the RTSP Session: %s",
  681.             p_sys->env->getResultMsg() );
  682.         return VLC_EGENERIC;
  683.     }
  685.     /* Initialise each media subsession */
  686.     iter = new MediaSubsessionIterator( *p_sys->ms );
  687.     while( ( sub = iter->next() ) != NULL )
  688.     {
  689.         Boolean bInit;
  690.         live_track_t *tk;
  692.         if( !vlc_object_alive (p_demux) || p_demux->b_error )
  693.         {
  694.             delete iter;
  695.             return VLC_EGENERIC;
  696.         }
  698.         /* Value taken from mplayer */
  699.         if( !strcmp( sub->mediumName(), "audio" ) )
  700.             i_buffer = 100000;
  701.         else if( !strcmp( sub->mediumName(), "video" ) )
  702.             i_buffer = 2000000;
  703.         else continue;
  705.         if( i_client_port != -1 )
  706.         {
  707.             sub->setClientPortNum( i_client_port );
  708.             i_client_port += 2;
  709.         }
  711.         if( strcasestr( sub->codecName(), "REAL" ) )
  712.         {
  713.             msg_Info( p_demux, "real codec detected, using real-RTSP instead" );
  714.             p_sys->b_real = true; /* This is a problem, we'll handle it later */
  715.             continue;
  716.         }
  718.         if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
  719.             bInit = sub->initiate( 4 ); /* Constant ? */
  720.         else
  721.             bInit = sub->initiate();
  723.         if( !bInit )
  724.         {
  725.             msg_Warn( p_demux, "RTP subsession '%s/%s' failed (%s)",
  726.                       sub->mediumName(), sub->codecName(),
  727.                       p_sys->env->getResultMsg() );
  728.         }
  729.         else
  730.         {
  731.             if( sub->rtpSource() != NULL )
  732.             {
  733.                 int fd = sub->rtpSource()->RTPgs()->socketNum();
  735.                 /* Increase the buffer size */
  736.                 if( i_buffer > 0 )
  737.                     increaseReceiveBufferTo( *p_sys->env, fd, i_buffer );
  739.                 /* Increase the RTP reorder timebuffer just a bit */
  740.                 sub->rtpSource()->setPacketReorderingThresholdTime(thresh);
  741.             }
  742.             msg_Dbg( p_demux, "RTP subsession '%s/%s'", sub->mediumName(),
  743.                      sub->codecName() );
  745.             /* Issue the SETUP */
  746.             if( p_sys->rtsp )
  747.             {
  748.                 if( !p_sys->rtsp->setupMediaSubsession( *sub, False,
  749.                                            b_rtsp_tcp ? True : False,
  750.                                            ( p_sys->b_force_mcast && !b_rtsp_tcp ) ? True : False ) )
  751.                 {
  752.                     /* if we get an unsupported transport error, toggle TCP use and try again */
  753.                     if( !strstr(p_sys->env->getResultMsg(), "461 Unsupported Transport")
  754.                      || !p_sys->rtsp->setupMediaSubsession( *sub, False,
  755.                                            b_rtsp_tcp ? False : True,
  756.                                            False ) )
  757.                     {
  758.                         msg_Err( p_demux, "SETUP of'%s/%s' failed %s", sub->mediumName(),
  759.                                  sub->codecName(), p_sys->env->getResultMsg() );
  760.                         continue;
  761.                     }
  762.                 }
  763.             }
  765.             /* Check if we will receive data from this subsession for this track */
  766.             if( sub->readSource() == NULL ) continue;
  767.             if( !p_sys->b_multicast )
  768.             {
  769.                 /* Check, because we need diff. rollover behaviour for multicast */
  770.                 p_sys->b_multicast = IsMulticastAddress( sub->connectionEndpointAddress() );
  771.             }
  773.             tk = (live_track_t*)malloc( sizeof( live_track_t ) );
  774.             if( !tk )
  775.             {
  776.                 delete iter;
  777.                 return VLC_ENOMEM;
  778.             }
  779.             tk->p_demux     = p_demux;
  780.             tk->sub         = sub;
  781.             tk->p_es        = NULL;
  782.             tk->b_quicktime = false;
  783.             tk->b_asf       = false;
  784.             tk->b_muxed     = false;
  785.             tk->p_out_muxed = NULL;
  786.             tk->waiting     = 0;
  787.             tk->b_rtcp_sync = false;
  788.             tk->i_pts       = 0;
  789.             tk->i_npt       = 0.;
  790.             tk->i_buffer    = 65536;
  791.             tk->p_buffer    = (uint8_t *)malloc( 65536 );
  792.             if( !tk->p_buffer )
  793.             {
  794.                 free( tk );
  795.                 delete iter;
  796.                 return VLC_ENOMEM;
  797.             }
  799.             /* Value taken from mplayer */
  800.             if( !strcmp( sub->mediumName(), "audio" ) )
  801.             {
  802.                 es_format_Init( &tk->fmt, AUDIO_ES, VLC_FOURCC('u','n','d','f') );
  803.                 tk->fmt.audio.i_channels = sub->numChannels();
  804.                 tk->fmt.audio.i_rate = sub->rtpTimestampFrequency();
  806.                 if( !strcmp( sub->codecName(), "MPA" ) ||
  807.                     !strcmp( sub->codecName(), "MPA-ROBUST" ) ||
  808.                     !strcmp( sub->codecName(), "X-MP3-DRAFT-00" ) )
  809.                 {
  810.                     tk->fmt.i_codec = VLC_FOURCC( 'm', 'p', 'g', 'a' );
  811.                     tk->fmt.audio.i_rate = 0;
  812.                 }
  813.                 else if( !strcmp( sub->codecName(), "AC3" ) )
  814.                 {
  815.                     tk->fmt.i_codec = VLC_FOURCC( 'a', '5', '2', ' ' );
  816.                     tk->fmt.audio.i_rate = 0;
  817.                 }
  818.                 else if( !strcmp( sub->codecName(), "L16" ) )
  819.                 {
  820.                     tk->fmt.i_codec = VLC_FOURCC( 't', 'w', 'o', 's' );
  821.                     tk->fmt.audio.i_bitspersample = 16;
  822.                 }
  823.                 else if( !strcmp( sub->codecName(), "L8" ) )
  824.                 {
  825.                     tk->fmt.i_codec = VLC_FOURCC( 'a', 'r', 'a', 'w' );
  826.                     tk->fmt.audio.i_bitspersample = 8;
  827.                 }
  828.                 else if( !strcmp( sub->codecName(), "PCMU" ) )
  829.                 {
  830.                     tk->fmt.i_codec = VLC_FOURCC( 'u', 'l', 'a', 'w' );
  831.                 }
  832.                 else if( !strcmp( sub->codecName(), "PCMA" ) )
  833.                 {
  834.                     tk->fmt.i_codec = VLC_FOURCC( 'a', 'l', 'a', 'w' );
  835.                 }
  836.                 else if( !strncmp( sub->codecName(), "G726", 4 ) )
  837.                 {
  838.                     tk->fmt.i_codec = VLC_FOURCC( 'g', '7', '2', '6' );
  839.                     tk->fmt.audio.i_rate = 8000;
  840.                     tk->fmt.audio.i_channels = 1;
  841.                     if( !strcmp( sub->codecName()+5, "40" ) )
  842.                         tk->fmt.i_bitrate = 40000;
  843.                     else if( !strcmp( sub->codecName()+5, "32" ) )
  844.                         tk->fmt.i_bitrate = 32000;
  845.                     else if( !strcmp( sub->codecName()+5, "24" ) )
  846.                         tk->fmt.i_bitrate = 24000;
  847.                     else if( !strcmp( sub->codecName()+5, "16" ) )
  848.                         tk->fmt.i_bitrate = 16000;
  849.                 }
  850.                 else if( !strcmp( sub->codecName(), "AMR" ) )
  851.                 {
  852.                     tk->fmt.i_codec = VLC_FOURCC( 's', 'a', 'm', 'r' );
  853.                 }
  854.                 else if( !strcmp( sub->codecName(), "AMR-WB" ) )
  855.                 {
  856.                     tk->fmt.i_codec = VLC_FOURCC( 's', 'a', 'w', 'b' );
  857.                 }
  858.                 else if( !strcmp( sub->codecName(), "MP4A-LATM" ) )
  859.                 {
  860.                     unsigned int i_extra;
  861.                     uint8_t      *p_extra;
  863.                     tk->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'a' );
  865.                     if( ( p_extra = parseStreamMuxConfigStr( sub->fmtp_config(),
  866.                                                              i_extra ) ) )
  867.                     {
  868.                         tk->fmt.i_extra = i_extra;
  869.                         tk->fmt.p_extra = malloc( i_extra );
  870.                         memcpy( tk->fmt.p_extra, p_extra, i_extra );
  871.                         delete[] p_extra;
  872.                     }
  873.                     /* Because the "faad" decoder does not handle the LATM data length field
  874.                        at the start of each returned LATM frame, tell the RTP source to omit it. */
  875.                     ((MPEG4LATMAudioRTPSource*)sub->rtpSource())->omitLATMDataLengthField();
  876.                 }
  877.                 else if( !strcmp( sub->codecName(), "MPEG4-GENERIC" ) )
  878.                 {
  879.                     unsigned int i_extra;
  880.                     uint8_t      *p_extra;
  882.                     tk->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'a' );
  884.                     if( ( p_extra = parseGeneralConfigStr( sub->fmtp_config(),
  885.                                                            i_extra ) ) )
  886.                     {
  887.                         tk->fmt.i_extra = i_extra;
  888.                         tk->fmt.p_extra = malloc( i_extra );
  889.                         memcpy( tk->fmt.p_extra, p_extra, i_extra );
  890.                         delete[] p_extra;
  891.                     }
  892.                 }
  893.                 else if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
  894.                 {
  895.                     tk->b_asf = true;
  896.                     if( p_sys->p_out_asf == NULL )
  897.                         p_sys->p_out_asf = stream_DemuxNew( p_demux, "asf",
  898.                                                             p_demux->out );
  899.                 }
  900.                 else if( !strcmp( sub->codecName(), "X-QT" ) ||
  901.                          !strcmp( sub->codecName(), "X-QUICKTIME" ) )
  902.                 {
  903.                     tk->b_quicktime = true;
  904.                 }
  905.                 else if( !strcmp( sub->codecName(), "SPEEX" ) )
  906.                 {
  907.                     tk->fmt.i_codec = VLC_FOURCC( 's', 'p', 'x', 'r' );
  908.                     if ( sub->rtpTimestampFrequency() )
  909.                         tk->fmt.audio.i_rate = sub->rtpTimestampFrequency();
  910.                     else
  911.                     {
  912.                         msg_Warn( p_demux,"Using 8kHz as default sample rate." );
  913.                         tk->fmt.audio.i_rate = 8000;
  914.                     }
  915.                 }
  916.             }
  917.             else if( !strcmp( sub->mediumName(), "video" ) )
  918.             {
  919.                 es_format_Init( &tk->fmt, VIDEO_ES, VLC_FOURCC('u','n','d','f') );
  920.                 if( !strcmp( sub->codecName(), "MPV" ) )
  921.                 {
  922.                     tk->fmt.i_codec = VLC_FOURCC( 'm', 'p', 'g', 'v' );
  923.                 }
  924.                 else if( !strcmp( sub->codecName(), "H263" ) ||
  925.                          !strcmp( sub->codecName(), "H263-1998" ) ||
  926.                          !strcmp( sub->codecName(), "H263-2000" ) )
  927.                 {
  928.                     tk->fmt.i_codec = VLC_FOURCC( 'H', '2', '6', '3' );
  929.                 }
  930.                 else if( !strcmp( sub->codecName(), "H261" ) )
  931.                 {
  932.                     tk->fmt.i_codec = VLC_FOURCC( 'H', '2', '6', '1' );
  933.                 }
  934.                 else if( !strcmp( sub->codecName(), "H264" ) )
  935.                 {
  936.                     unsigned int i_extra = 0;
  937.                     uint8_t      *p_extra = NULL;
  939.                     tk->fmt.i_codec = VLC_FOURCC( 'h', '2', '6', '4' );
  940.                     tk->fmt.b_packetized = false;
  942.                     if((p_extra=parseH264ConfigStr( sub->fmtp_spropparametersets(),
  943.                                                     i_extra ) ) )
  944.                     {
  945.                         tk->fmt.i_extra = i_extra;
  946.                         tk->fmt.p_extra = malloc( i_extra );
  947.                         memcpy( tk->fmt.p_extra, p_extra, i_extra );
  949.                         delete[] p_extra;
  950.                     }
  951.                 }
  952.                 else if( !strcmp( sub->codecName(), "JPEG" ) )
  953.                 {
  954.                     tk->fmt.i_codec = VLC_FOURCC( 'M', 'J', 'P', 'G' );
  955.                 }
  956.                 else if( !strcmp( sub->codecName(), "MP4V-ES" ) )
  957.                 {
  958.                     unsigned int i_extra;
  959.                     uint8_t      *p_extra;
  961.                     tk->fmt.i_codec = VLC_FOURCC( 'm', 'p', '4', 'v' );
  963.                     if( ( p_extra = parseGeneralConfigStr( sub->fmtp_config(),
  964.                                                            i_extra ) ) )
  965.                     {
  966.                         tk->fmt.i_extra = i_extra;
  967.                         tk->fmt.p_extra = malloc( i_extra );
  968.                         memcpy( tk->fmt.p_extra, p_extra, i_extra );
  969.                         delete[] p_extra;
  970.                     }
  971.                 }
  972.                 else if( !strcmp( sub->codecName(), "X-QT" ) ||
  973.                          !strcmp( sub->codecName(), "X-QUICKTIME" ) ||
  974.                          !strcmp( sub->codecName(), "X-QDM" ) ||
  975.                          !strcmp( sub->codecName(), "X-SV3V-ES" )  ||
  976.                          !strcmp( sub->codecName(), "X-SORENSONVIDEO" ) )
  977.                 {
  978.                     tk->b_quicktime = true;
  979.                 }
  980.                 else if( !strcmp( sub->codecName(), "MP2T" ) )
  981.                 {
  982.                     tk->b_muxed = true;
  983.                     tk->p_out_muxed = stream_DemuxNew( p_demux, "ts", p_demux->out );
  984.                 }
  985.                 else if( !strcmp( sub->codecName(), "MP2P" ) ||
  986.                          !strcmp( sub->codecName(), "MP1S" ) )
  987.                 {
  988.                     tk->b_muxed = true;
  989.                     tk->p_out_muxed = stream_DemuxNew( p_demux, "ps",
  990.                                                        p_demux->out );
  991.                 }
  992.                 else if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
  993.                 {
  994.                     tk->b_asf = true;
  995.                     if( p_sys->p_out_asf == NULL )
  996.                         p_sys->p_out_asf = stream_DemuxNew( p_demux, "asf",
  997.                                                             p_demux->out );;
  998.                 }
  999.             }
  1001.             if( !tk->b_quicktime && !tk->b_muxed && !tk->b_asf )
  1002.             {
  1003.                 tk->p_es = es_out_Add( p_demux->out, &tk->fmt );
  1004.             }
  1006.             if( sub->rtcpInstance() != NULL )
  1007.             {
  1008.                 sub->rtcpInstance()->setByeHandler( StreamClose, tk );
  1009.             }
  1011.             if( tk->p_es || tk->b_quicktime || tk->b_muxed || tk->b_asf )
  1012.             {
  1013.                 /* Append */
  1014.                 p_sys->track = (live_track_t**)realloc( p_sys->track, sizeof( live_track_t ) * ( p_sys->i_track + 1 ) );
  1015.                 p_sys->track[p_sys->i_track++] = tk;
  1016.             }
  1017.             else
  1018.             {
  1019.                 /* BUG ??? */
  1020.                 msg_Err( p_demux, "unusable RTSP track. this should not happen" );
  1021.                 es_format_Clean( &tk->fmt );
  1022.                 free( tk );
  1023.             }
  1024.         }
  1025.     }
  1026.     delete iter;
  1027.     if( p_sys->i_track <= 0 ) i_return = VLC_EGENERIC;
  1029.     /* Retrieve the starttime if possible */
  1030.     p_sys->i_npt_start = p_sys->ms->playStartTime();
  1032.     /* Retrieve the duration if possible */
  1033.     p_sys->i_npt_length = p_sys->ms->playEndTime();
  1035.     /* */
  1036.     msg_Dbg( p_demux, "setup start: %f stop:%f", p_sys->i_npt_start, p_sys->i_npt_length );
  1038.     /* */
  1039.     p_sys->b_no_data = true;
  1040.     p_sys->i_no_data_ti = 0;
  1042.     return i_return;
  1043. }
  1045. /*****************************************************************************
  1046.  * Play: starts the actual playback of the stream
  1047.  *****************************************************************************/
  1048. static int Play( demux_t *p_demux )
  1049. {
  1050.     demux_sys_t *p_sys = p_demux->p_sys;
  1052.     if( p_sys->rtsp )
  1053.     {
  1054.         /* The PLAY */
  1055.         if( !p_sys->rtsp->playMediaSession( *p_sys->ms, p_sys->i_npt_start, -1, 1 ) )
  1056.         {
  1057.             msg_Err( p_demux, "RTSP PLAY failed %s", p_sys->env->getResultMsg() );
  1058.             return VLC_EGENERIC;
  1059.         }
  1061.         /* Retrieve the timeout value and set up a timeout prevention thread */
  1062.         p_sys->i_timeout = p_sys->rtsp->sessionTimeoutParameter();
  1063.         if( p_sys->i_timeout <= 0 )
  1064.             p_sys->i_timeout = 60; /* default value from RFC2326 */
  1066.         /* start timeout-thread only if GET_PARAMETER is supported by the server */
  1067.         if( !p_sys->p_timeout && p_sys->b_get_param )
  1068.         {
  1069.             msg_Dbg( p_demux, "We have a timeout of %d seconds",  p_sys->i_timeout );
  1070.             p_sys->p_timeout = (timeout_thread_t *)malloc( sizeof(timeout_thread_t) );
  1071.             if( p_sys->p_timeout )
  1072.             {
  1073.                 memset( p_sys->p_timeout, 0, sizeof(timeout_thread_t) );
  1074.                 p_sys->p_timeout->p_sys = p_demux->p_sys; /* lol, object recursion :D */
  1075.                 if( vlc_clone( &p_sys->p_timeout->handle,  TimeoutPrevention,
  1076.                                p_sys->p_timeout, VLC_THREAD_PRIORITY_LOW ) )
  1077.                 {
  1078.                     msg_Err( p_demux, "cannot spawn liveMedia timeout thread" );
  1079.                     free( p_sys->p_timeout );
  1080.                     p_sys->p_timeout = NULL;
  1081.                 }
  1082.                 else
  1083.                     msg_Dbg( p_demux, "spawned timeout thread" );
  1084.             }
  1085.             else
  1086.                 msg_Err( p_demux, "cannot spawn liveMedia timeout thread" );
  1087.         }
  1088.     }
  1089.     p_sys->i_pcr = 0;
  1091.     /* Retrieve the starttime if possible */
  1092.     p_sys->i_npt_start = p_sys->ms->playStartTime();
  1093.     p_sys->i_npt_length = p_sys->ms->playEndTime();
  1095.     msg_Dbg( p_demux, "play start: %f stop:%f", p_sys->i_npt_start, p_sys->i_npt_length );
  1096.     return VLC_SUCCESS;
  1097. }
  1100. /*****************************************************************************
  1101.  * Demux:
  1102.  *****************************************************************************/
  1103. static int Demux( demux_t *p_demux )
  1104. {
  1105.     demux_sys_t    *p_sys = p_demux->p_sys;
  1106.     TaskToken      task;
  1108.     bool            b_send_pcr = true;
  1109.     int64_t         i_pcr = 0;
  1110.     int             i;
  1112.     /* Check if we need to send the server a Keep-A-Live signal */
  1113.     if( p_sys->b_timeout_call && p_sys->rtsp && p_sys->ms )
  1114.     {
  1115.         char *psz_bye = NULL;
  1116.         p_sys->rtsp->getMediaSessionParameter( *p_sys->ms, NULL, psz_bye );
  1117.         p_sys->b_timeout_call = false;
  1118.     }
  1120.     for( i = 0; i < p_sys->i_track; i++ )
  1121.     {
  1122.         live_track_t *tk = p_sys->track[i];
  1124.         if( tk->b_asf || tk->b_muxed )
  1125.             b_send_pcr = false;
  1126. #if 0
  1127.         if( i_pcr == 0 )
  1128.         {
  1129.             i_pcr = tk->i_pts;
  1130.         }
  1131.         else if( tk->i_pts != 0 && i_pcr > tk->i_pts )
  1132.         {
  1133.             i_pcr = tk->i_pts ;
  1134.         }
  1135. #endif
  1136.     }
  1137.     if( p_sys->i_pcr > 0 )
  1138.     {
  1139.         if( b_send_pcr )
  1140.             es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_pcr );
  1141.     }
  1143.     /* First warn we want to read data */
  1144.     p_sys->event = 0;
  1145.     for( i = 0; i < p_sys->i_track; i++ )
  1146.     {
  1147.         live_track_t *tk = p_sys->track[i];
  1149.         if( tk->waiting == 0 )
  1150.         {
  1151.             tk->waiting = 1;
  1152.             tk->sub->readSource()->getNextFrame( tk->p_buffer, tk->i_buffer,
  1153.                                           StreamRead, tk, StreamClose, tk );
  1154.         }
  1155.     }
  1156.     /* Create a task that will be called if we wait more than 300ms */
  1157.     task = p_sys->scheduler->scheduleDelayedTask( 300000, TaskInterrupt, p_demux );
  1159.     /* Do the read */
  1160.     p_sys->scheduler->doEventLoop( &p_sys->event );
  1162.     /* remove the task */
  1163.     p_sys->scheduler->unscheduleDelayedTask( task );
  1165.     /* Check for gap in pts value */
  1166.     for( i = 0; i < p_sys->i_track; i++ )
  1167.     {
  1168.         live_track_t *tk = p_sys->track[i];
  1170.         if( !tk->b_muxed && !tk->b_rtcp_sync &&
  1171.             tk->sub->rtpSource() && tk->sub->rtpSource()->hasBeenSynchronizedUsingRTCP() )
  1172.         {
  1173.             msg_Dbg( p_demux, "tk->rtpSource->hasBeenSynchronizedUsingRTCP()" );
  1175.             es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
  1176.             tk->b_rtcp_sync = true;
  1177.             /* reset PCR */
  1178.             tk->i_pts = 0;
  1179.             tk->i_npt = 0.;
  1180.             p_sys->i_pcr = 0;
  1181.             p_sys->i_npt = 0.;
  1182.             i_pcr = 0;
  1183.         }
  1184.     }
  1186.     if( p_sys->b_multicast && p_sys->b_no_data &&
  1187.         ( p_sys->i_no_data_ti > 120 ) )
  1188.     {
  1189.         /* FIXME Make this configurable
  1190.         msg_Err( p_demux, "no multicast data received in 36s, aborting" );
  1191.         return 0;
  1192.         */
  1193.     }
  1194.     else if( !p_sys->b_multicast && !p_sys->b_paused &&
  1195.               p_sys->b_no_data && ( p_sys->i_no_data_ti > 34 ) )
  1196.     {
  1197.         bool b_rtsp_tcp = var_GetBool( p_demux, "rtsp-tcp" ) ||
  1198.                                 var_GetBool( p_demux, "rtsp-http" );
  1200.         if( !b_rtsp_tcp && p_sys->rtsp && p_sys->ms )
  1201.         {
  1202.             msg_Warn( p_demux, "no data received in 10s. Switching to TCP" );
  1203.             if( RollOverTcp( p_demux ) )
  1204.             {
  1205.                 msg_Err( p_demux, "TCP rollover failed, aborting" );
  1206.                 return 0;
  1207.             }
  1208.             return 1;
  1209.         }
  1210.         msg_Err( p_demux, "no data received in 10s, aborting" );
  1211.         return 0;
  1212.     }
  1213.     else if( !p_sys->b_multicast && !p_sys->b_paused &&
  1214.              ( p_sys->i_no_data_ti > 34 ) )
  1215.     {
  1216.         /* EOF ? */
  1217.         msg_Warn( p_demux, "no data received in 10s, eof ?" );
  1218.         return 0;
  1219.     }
  1220.     return p_demux->b_error ? 0 : 1;
  1221. }
  1223. /*****************************************************************************
  1224.  * Control:
  1225.  *****************************************************************************/
  1226. static int Control( demux_t *p_demux, int i_query, va_list args )
  1227. {
  1228.     demux_sys_t *p_sys = p_demux->p_sys;
  1229.     int64_t *pi64, i64;
  1230.     double  *pf, f;
  1231.     bool *pb, *pb2;
  1232.     int *pi_int;
  1234.     switch( i_query )
  1235.     {
  1236.         case DEMUX_GET_TIME:
  1237.             pi64 = (int64_t*)va_arg( args, int64_t * );
  1238.             if( p_sys->i_npt > 0 )
  1239.             {
  1240.                 *pi64 = (int64_t)(p_sys->i_npt * 1000000.);
  1241.                 return VLC_SUCCESS;
  1242.             }
  1243.             return VLC_EGENERIC;
  1245.         case DEMUX_GET_LENGTH:
  1246.             pi64 = (int64_t*)va_arg( args, int64_t * );
  1247.             if( p_sys->i_npt_length > 0 )
  1248.             {
  1249.                 *pi64 = (int64_t)((double)p_sys->i_npt_length * 1000000.0);
  1250.                 return VLC_SUCCESS;
  1251.             }
  1252.             return VLC_EGENERIC;
  1254.         case DEMUX_GET_POSITION:
  1255.             pf = (double*)va_arg( args, double* );
  1256.             if( (p_sys->i_npt_length > 0) && (p_sys->i_npt > 0) )
  1257.             {
  1258.                 *pf = ( (double)p_sys->i_npt / (double)p_sys->i_npt_length );
  1259.                 return VLC_SUCCESS;
  1260.             }
  1261.             return VLC_EGENERIC;
  1263.         case DEMUX_SET_POSITION:
  1264.         case DEMUX_SET_TIME:
  1265.             if( p_sys->rtsp && (p_sys->i_npt_length > 0) )
  1266.             {
  1267.                 int i;
  1268.                 float time;
  1270.                 if( (i_query == DEMUX_SET_TIME) && (p_sys->i_npt > 0) )
  1271.                 {
  1272.                     i64 = (int64_t)va_arg( args, int64_t );
  1273.                     time = (float)((double)i64 / (double)1000000.0); /* in second */
  1274.                 }
  1275.                 else if( i_query == DEMUX_SET_TIME )
  1276.                     return VLC_EGENERIC;
  1277.                 else
  1278.                 {
  1279.                     f = (double)va_arg( args, double );
  1280.                     time = f * (double)p_sys->i_npt_length;   /* in second */
  1281.                 }
  1283.                 if( !p_sys->rtsp->pauseMediaSession( *p_sys->ms ) ||
  1284.                     !p_sys->rtsp->playMediaSession( *p_sys->ms, time, -1, 1 ) )
  1285.                 {
  1286.                     msg_Err( p_demux, "PLAY failed %s",
  1287.                         p_sys->env->getResultMsg() );
  1288.                     return VLC_EGENERIC;
  1289.                 }
  1290.                 p_sys->i_pcr = 0;
  1292.                 /* Retrieve RTP-Info values */
  1293.                 for( i = 0; i < p_sys->i_track; i++ )
  1294.                 {
  1295.                     p_sys->track[i]->b_rtcp_sync = false;
  1296.                     p_sys->track[i]->i_pts = 0;
  1297.                 }
  1299.                 /* Retrieve the starttime if possible */
  1300.                 p_sys->i_npt = p_sys->i_npt_start = p_sys->ms->playStartTime();
  1302.                 /* Retrieve the duration if possible */
  1303.                 p_sys->i_npt_length = p_sys->ms->playEndTime();
  1305.                 msg_Dbg( p_demux, "seek start: %f stop:%f", p_sys->i_npt_start, p_sys->i_npt_length );
  1306.                 return VLC_SUCCESS;
  1307.             }
  1308.             return VLC_EGENERIC;
  1310.         /* Special for access_demux */
  1311.         case DEMUX_CAN_PAUSE:
  1312.         case DEMUX_CAN_SEEK:
  1313.             pb = (bool*)va_arg( args, bool * );
  1314.             if( p_sys->rtsp && p_sys->i_npt_length > 0 )
  1315.                 /* Not always true, but will be handled in SET_PAUSE_STATE */
  1316.                 *pb = true;
  1317.             else
  1318.                 *pb = false;
  1319.             return VLC_SUCCESS;
  1321.         case DEMUX_CAN_CONTROL_PACE:
  1322.             pb = (bool*)va_arg( args, bool * );
  1324. #if 1       /* Disable for now until we have a clock synchro algo
  1325.              * which works with something else than MPEG over UDP */
  1326.             *pb = false;
  1327. #else
  1328.             *pb = true;
  1329. #endif
  1330.             return VLC_SUCCESS;
  1332.         case DEMUX_CAN_CONTROL_RATE:
  1333.             pb = (bool*)va_arg( args, bool * );
  1334.             pb2 = (bool*)va_arg( args, bool * );
  1336.             *pb = (p_sys->rtsp != NULL) &&
  1337.                     (p_sys->i_npt_length > 0) &&
  1338.                     !var_GetBool( p_demux, "rtsp-kasenna" );
  1339.             *pb2 = false;
  1340.             return VLC_SUCCESS;
  1342.         case DEMUX_SET_RATE:
  1343.         {
  1344.             double f_scale, f_old_scale;
  1346.             if( !p_sys->rtsp || (p_sys->i_npt_length <= 0) ||
  1347.                 var_GetBool( p_demux, "rtsp-kasenna" ) )
  1348.                 return VLC_EGENERIC;
  1350.             /* According to RFC 2326 p56 chapter 12.35 a RTSP server that
  1351.              * supports Scale should:
  1352.              *
  1353.              * "The server should try to approximate the viewing rate, but may
  1354.              *  restrict the range of scale values that it supports. The response
  1355.              *  MUST contain the actual scale value chosen by the server."
  1356.              *
  1357.              * Scale = 1 indicates normal play
  1358.              * Scale > 1 indicates fast forward
  1359.              * Scale < 1 && Scale > 0 indicates slow motion
  1360.              * Scale < 0 value indicates rewind
  1361.              */
  1363.             pi_int = (int*)va_arg( args, int * );
  1364.             f_scale = (double)INPUT_RATE_DEFAULT / (*pi_int);
  1365.             f_old_scale = p_sys->ms->scale();
  1367.             /* Passing -1 for the start and end time will mean liveMedia won't
  1368.              * create a Range: section for the RTSP message. The server should
  1369.              * pick up from the current position */
  1370.             if( !p_sys->rtsp->playMediaSession( *p_sys->ms, -1, -1, f_scale ) )
  1371.             {
  1372.                 msg_Err( p_demux, "PLAY with Scale %0.2f failed %s", f_scale,
  1373.                         p_sys->env->getResultMsg() );
  1374.                 return VLC_EGENERIC;
  1375.             }
  1377.             if( p_sys->ms->scale() == f_old_scale )
  1378.             {
  1379.                 msg_Err( p_demux, "no scale change using old Scale %0.2f",
  1380.                           p_sys->ms->scale() );
  1381.                 return VLC_EGENERIC;
  1382.             }
  1384.             /* ReSync the stream */
  1385.             p_sys->i_npt_start = 0;
  1386.             p_sys->i_pcr = 0;
  1387.             p_sys->i_npt = 0.0;
  1389.             *pi_int = (int)( INPUT_RATE_DEFAULT / p_sys->ms->scale() );
  1390.             msg_Dbg( p_demux, "PLAY with new Scale %0.2f (%d)", p_sys->ms->scale(), (*pi_int) );
  1391.             return VLC_SUCCESS;
  1392.         }
  1394.         case DEMUX_SET_PAUSE_STATE:
  1395.         {
  1396.             p_sys->b_paused = (bool)va_arg( args, int );
  1397.             if( p_sys->rtsp == NULL )
  1398.                 return VLC_EGENERIC;
  1400.             /* FIXME */
  1401.             if( ( p_sys->b_paused && !p_sys->rtsp->pauseMediaSession( *p_sys->ms ) ) ||
  1402.                     ( !p_sys->b_paused && !p_sys->rtsp->playMediaSession( *p_sys->ms,
  1403.                        -1 ) ) )
  1404.             {
  1405.                     msg_Err( p_demux, "PLAY or PAUSE failed %s", p_sys->env->getResultMsg() );
  1406.                     return VLC_EGENERIC;
  1407.             }
  1409.             /* When we Pause, we'll need the TimeoutPrevention thread to
  1410.              * handle sending the "Keep Alive" message to the server.
  1411.              * Unfortunately Live555 isn't thread safe and so can't
  1412.              * do this normally while the main Demux thread is handling
  1413.              * a live stream. We end up with the Timeout thread blocking
  1414.              * waiting for a response from the server. So when we PAUSE
  1415.              * we set a flag that the TimeoutPrevention function will check
  1416.              * and if it's set, it will trigger the GET_PARAMETER message */
  1417.             if( p_sys->b_paused && p_sys->p_timeout != NULL )
  1418.                 p_sys->p_timeout->b_handle_keep_alive = true;
  1419.             else if( !p_sys->b_paused && p_sys->p_timeout != NULL )
  1420.                 p_sys->p_timeout->b_handle_keep_alive = false;
  1422.             if( !p_sys->b_paused )
  1423.             {
  1424.                 for( int i = 0; i < p_sys->i_track; i++ )
  1425.                 {
  1426.                     live_track_t *tk = p_sys->track[i];
  1427.                     tk->b_rtcp_sync = false;
  1428.                     tk->i_pts = 0;
  1429.                     p_sys->i_pcr = 0;
  1430.                     es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
  1431.                 }
  1432.             }
  1434.             /* Reset data received counter */
  1435.             p_sys->i_no_data_ti = 0;
  1437.             /* Retrieve the starttime if possible */
  1438.             p_sys->i_npt_start = p_sys->ms->playStartTime();
  1440.             /* Retrieve the duration if possible */
  1441.             p_sys->i_npt_length = p_sys->ms->playEndTime();
  1443.             msg_Dbg( p_demux, "pause start: %f stop:%f", p_sys->i_npt_start, p_sys->i_npt_length );
  1444.             return VLC_SUCCESS;
  1445.         }
  1446.         case DEMUX_GET_TITLE_INFO:
  1447.         case DEMUX_SET_TITLE:
  1448.         case DEMUX_SET_SEEKPOINT:
  1449.             return VLC_EGENERIC;
  1451.         case DEMUX_GET_PTS_DELAY:
  1452.             pi64 = (int64_t*)va_arg( args, int64_t * );
  1453.             *pi64 = (int64_t)var_GetInteger( p_demux, "rtsp-caching" ) * 1000;
  1454.             return VLC_SUCCESS;
  1456.         default:
  1457.             return VLC_EGENERIC;
  1458.     }
  1459. }
  1461. /*****************************************************************************
  1462.  * RollOverTcp: reopen the rtsp into TCP mode
  1463.  * XXX: ugly, a lot of code are duplicated from Open()
  1464.  * This should REALLY be fixed
  1465.  *****************************************************************************/
  1466. static int RollOverTcp( demux_t *p_demux )
  1467. {
  1468.     demux_sys_t *p_sys = p_demux->p_sys;
  1469.     int i, i_return;
  1471.     var_SetBool( p_demux, "rtsp-tcp", true );
  1473.     /* We close the old RTSP session */
  1474.     for( i = 0; i < p_sys->i_track; i++ )
  1475.     {
  1476.         live_track_t *tk = p_sys->track[i];
  1478.         if( tk->b_muxed ) stream_Delete( tk->p_out_muxed );
  1479.         if( tk->p_es ) es_out_Del( p_demux->out, tk->p_es );
  1480.         es_format_Clean( &tk->fmt );
  1481.         free( tk->p_buffer );
  1482.         free( tk );
  1483.     }
  1484.     if( p_sys->i_track ) free( p_sys->track );
  1485.     if( p_sys->p_out_asf ) stream_Delete( p_sys->p_out_asf );
  1487.     p_sys->rtsp->teardownMediaSession( *p_sys->ms );
  1488.     Medium::close( p_sys->ms );
  1489.     RTSPClient::close( p_sys->rtsp );
  1491.     p_sys->ms = NULL;
  1492.     p_sys->rtsp = NULL;
  1493.     p_sys->track = NULL;
  1494.     p_sys->i_track = 0;
  1495.     p_sys->b_no_data = true;
  1496.     p_sys->i_no_data_ti = 0;
  1498.     /* Reopen rtsp client */
  1499.     if( ( i_return = Connect( p_demux ) ) != VLC_SUCCESS )
  1500.     {
  1501.         msg_Err( p_demux, "Failed to connect with rtsp://%s",
  1502.                  p_sys->psz_path );
  1503.         goto error;
  1504.     }
  1506.     if( p_sys->p_sdp == NULL )
  1507.     {
  1508.         msg_Err( p_demux, "Failed to retrieve the RTSP Session Description" );
  1509.         goto error;
  1510.     }
  1512.     if( ( i_return = SessionsSetup( p_demux ) ) != VLC_SUCCESS )
  1513.     {
  1514.         msg_Err( p_demux, "Nothing to play for rtsp://%s", p_sys->psz_path );
  1515.         goto error;
  1516.     }
  1518.     if( ( i_return = Play( p_demux ) ) != VLC_SUCCESS )
  1519.         goto error;
  1521.     return VLC_SUCCESS;
  1523. error:
  1524.     return VLC_EGENERIC;
  1525. }
  1528. /*****************************************************************************
  1529.  *
  1530.  *****************************************************************************/
  1531. static void StreamRead( void *p_private, unsigned int i_size,
  1532.                         unsigned int i_truncated_bytes, struct timeval pts,
  1533.                         unsigned int duration )
  1534. {
  1535.     live_track_t   *tk = (live_track_t*)p_private;
  1536.     demux_t        *p_demux = tk->p_demux;
  1537.     demux_sys_t    *p_sys = p_demux->p_sys;
  1538.     block_t        *p_block;
  1540.     //msg_Dbg( p_demux, "pts: %d", pts.tv_sec );
  1542.     int64_t i_pts = (int64_t)pts.tv_sec * INT64_C(1000000) +
  1543.         (int64_t)pts.tv_usec;
  1545.     /* XXX Beurk beurk beurk Avoid having negative value XXX */
  1546.     i_pts &= INT64_C(0x00ffffffffffffff);
  1548.     /* Retrieve NPT for this pts */
  1549.     tk->i_npt = tk->sub->getNormalPlayTime(pts);
  1551.     if( tk->b_quicktime && tk->p_es == NULL )
  1552.     {
  1553.         QuickTimeGenericRTPSource *qtRTPSource =
  1554.             (QuickTimeGenericRTPSource*)tk->sub->rtpSource();
  1555.         QuickTimeGenericRTPSource::QTState &qtState = qtRTPSource->qtState;
  1556.         uint8_t *sdAtom = (uint8_t*)&qtState.sdAtom[4];
  1558.         if( tk->fmt.i_cat == VIDEO_ES ) {
  1559.             if( qtState.sdAtomSize < 16 + 32 )
  1560.             {
  1561.                 /* invalid */
  1562.                 p_sys->event = 0xff;
  1563.                 tk->waiting = 0;
  1564.                 return;
  1565.             }
  1566.             tk->fmt.i_codec = VLC_FOURCC(sdAtom[0],sdAtom[1],sdAtom[2],sdAtom[3]);
  1567.             tk->fmt.video.i_width  = (sdAtom[28] << 8) | sdAtom[29];
  1568.             tk->fmt.video.i_height = (sdAtom[30] << 8) | sdAtom[31];
  1570.             if( tk->fmt.i_codec == VLC_FOURCC('a', 'v', 'c', '1') )
  1571.             {
  1572.                 uint8_t *pos = (uint8_t*)qtRTPSource->qtState.sdAtom + 86;
  1573.                 uint8_t *endpos = (uint8_t*)qtRTPSource->qtState.sdAtom
  1574.                                   + qtRTPSource->qtState.sdAtomSize;
  1575.                 while (pos+8 < endpos) {
  1576.                     unsigned int atomLength = pos[0]<<24 | pos[1]<<16 | pos[2]<<8 | pos[3];
  1577.                     if( atomLength == 0 || atomLength > (unsigned int)(endpos-pos)) break;
  1578.                     if( memcmp(pos+4, "avcC", 4) == 0 &&
  1579.                         atomLength > 8 &&
  1580.                         atomLength <= INT_MAX )
  1581.                     {
  1582.                         tk->fmt.i_extra = atomLength-8;
  1583.                         tk->fmt.p_extra = malloc( tk->fmt.i_extra );
  1584.                         memcpy(tk->fmt.p_extra, pos+8, atomLength-8);
  1585.                         break;
  1586.                     }
  1587.                     pos += atomLength;
  1588.                 }
  1589.             }
  1590.             else
  1591.             {
  1592.                 tk->fmt.i_extra        = qtState.sdAtomSize - 16;
  1593.                 tk->fmt.p_extra        = malloc( tk->fmt.i_extra );
  1594.                 memcpy( tk->fmt.p_extra, &sdAtom[12], tk->fmt.i_extra );
  1595.             }
  1596.         }
  1597.         else {
  1598.             if( qtState.sdAtomSize < 4 )
  1599.             {
  1600.                 /* invalid */
  1601.                 p_sys->event = 0xff;
  1602.                 tk->waiting = 0;
  1603.                 return;
  1604.             }
  1605.             tk->fmt.i_codec = VLC_FOURCC(sdAtom[0],sdAtom[1],sdAtom[2],sdAtom[3]);
  1606.         }
  1607.         tk->p_es = es_out_Add( p_demux->out, &tk->fmt );
  1608.     }
  1610. #if 0
  1611.     fprintf( stderr, "StreamRead size=%d pts=%lldn",
  1612.              i_size,
  1613.              pts.tv_sec * 1000000LL + pts.tv_usec );
  1614. #endif
  1616.     /* grow buffer if it looks like buffer is too small, but don't eat
  1617.      * up all the memory on strange streams */
  1618.     if( i_truncated_bytes > 0 && tk->i_buffer < 2000000 )
  1619.     {
  1620.         void *p_tmp;
  1621.         msg_Dbg( p_demux, "lost %d bytes", i_truncated_bytes );
  1622.         msg_Dbg( p_demux, "increasing buffer size to %d", tk->i_buffer * 2 );
  1623.         tk->i_buffer *= 2;
  1624.         p_tmp = realloc( tk->p_buffer, tk->i_buffer );
  1625.         if( p_tmp == NULL )
  1626.         {
  1627.             msg_Warn( p_demux, "realloc failed" );
  1628.         }
  1629.         else
  1630.         {
  1631.             tk->p_buffer = (uint8_t*)p_tmp;
  1632.         }
  1633.     }
  1634.     if( i_size > tk->i_buffer )
  1635.     {
  1636.         msg_Warn( p_demux, "buffer overflow" );
  1637.     }
  1638.     /* FIXME could i_size be > buffer size ? */
  1639.     if( tk->fmt.i_codec == VLC_FOURCC('s','a','m','r') ||
  1640.         tk->fmt.i_codec == VLC_FOURCC('s','a','w','b') )
  1641.     {
  1642.         AMRAudioSource *amrSource = (AMRAudioSource*)tk->sub->readSource();
  1644.         p_block = block_New( p_demux, i_size + 1 );
  1645.         p_block->p_buffer[0] = amrSource->lastFrameHeader();
  1646.         memcpy( p_block->p_buffer + 1, tk->p_buffer, i_size );
  1647.     }
  1648.     else if( tk->fmt.i_codec == VLC_FOURCC('H','2','6','1') )
  1649.     {
  1650.         H261VideoRTPSource *h261Source = (H261VideoRTPSource*)tk->sub->rtpSource();
  1651.         uint32_t header = h261Source->lastSpecialHeader();
  1652.         p_block = block_New( p_demux, i_size + 4 );
  1653.         memcpy( p_block->p_buffer, &header, 4 );
  1654.         memcpy( p_block->p_buffer + 4, tk->p_buffer, i_size );
  1656.         if( tk->sub->rtpSource()->curPacketMarkerBit() )
  1657.             p_block->i_flags |= BLOCK_FLAG_END_OF_FRAME;
  1658.     }
  1659.     else if( tk->fmt.i_codec == VLC_FOURCC('h','2','6','4') )
  1660.     {
  1661.         if( (tk->p_buffer[0] & 0x1f) >= 24 )
  1662.             msg_Warn( p_demux, "unsupported NAL type for H264" );
  1664.         /* Normal NAL type */
  1665.         p_block = block_New( p_demux, i_size + 4 );
  1666.         p_block->p_buffer[0] = 0x00;
  1667.         p_block->p_buffer[1] = 0x00;
  1668.         p_block->p_buffer[2] = 0x00;
  1669.         p_block->p_buffer[3] = 0x01;
  1670.         memcpy( &p_block->p_buffer[4], tk->p_buffer, i_size );
  1671.     }
  1672.     else if( tk->b_asf )
  1673.     {
  1674.         int i_copy = __MIN( p_sys->asfh.i_min_data_packet_size, (int)i_size );
  1675.         p_block = block_New( p_demux, p_sys->asfh.i_min_data_packet_size );
  1677.         memcpy( p_block->p_buffer, tk->p_buffer, i_copy );
  1678.     }
  1679.     else
  1680.     {
  1681.         p_block = block_New( p_demux, i_size );
  1682.         memcpy( p_block->p_buffer, tk->p_buffer, i_size );
  1683.     }
  1685.     if( p_sys->i_pcr < i_pts )
  1686.     {
  1687.         p_sys->i_pcr = i_pts;
  1688.     }
  1690.     if( (i_pts != tk->i_pts) && (!tk->b_muxed) )
  1691.     {
  1692.         p_block->i_pts = i_pts;
  1693.     }
  1695.     /* Update our global npt value */
  1696.     if( tk->i_npt > 0 && tk->i_npt > p_sys->i_npt && tk->i_npt < p_sys->i_npt_length)
  1697.         p_sys->i_npt = tk->i_npt;
  1699.     if( !tk->b_muxed )
  1700.     {
  1701.         /*FIXME: for h264 you should check that packetization-mode=1 in sdp-file */
  1702.         p_block->i_dts = ( tk->fmt.i_codec == VLC_FOURCC( 'm', 'p', 'g', 'v' ) ) ? 0 : i_pts;
  1703.     }
  1705.     if( tk->b_muxed )
  1706.     {
  1707.         stream_DemuxSend( tk->p_out_muxed, p_block );
  1708.     }
  1709.     else if( tk->b_asf )
  1710.     {
  1711.         stream_DemuxSend( p_sys->p_out_asf, p_block );
  1712.     }
  1713.     else
  1714.     {
  1715.         es_out_Send( p_demux->out, tk->p_es, p_block );
  1716.     }
  1718.     /* warn that's ok */
  1719.     p_sys->event = 0xff;
  1721.     /* we have read data */
  1722.     tk->waiting = 0;
  1723.     p_demux->p_sys->b_no_data = false;
  1724.     p_demux->p_sys->i_no_data_ti = 0;
  1726.     if( i_pts > 0 && !tk->b_muxed )
  1727.     {
  1728.         tk->i_pts = i_pts;
  1729.     }
  1730. }
  1732. /*****************************************************************************
  1733.  *
  1734.  *****************************************************************************/
  1735. static void StreamClose( void *p_private )
  1736. {
  1737.     live_track_t   *tk = (live_track_t*)p_private;
  1738.     demux_t        *p_demux = tk->p_demux;
  1739.     demux_sys_t    *p_sys = p_demux->p_sys;
  1741.     msg_Dbg( p_demux, "StreamClose" );
  1743.     p_sys->event = 0xff;
  1744.     p_demux->b_error = true;
  1745. }
  1748. /*****************************************************************************
  1749.  *
  1750.  *****************************************************************************/
  1751. static void TaskInterrupt( void *p_private )
  1752. {
  1753.     demux_t *p_demux = (demux_t*)p_private;
  1755.     p_demux->p_sys->i_no_data_ti++;
  1757.     /* Avoid lock */
  1758.     p_demux->p_sys->event = 0xff;
  1759. }
  1761. /*****************************************************************************
  1762.  *
  1763.  *****************************************************************************/
  1764. static void* TimeoutPrevention( void *p_data )
  1765. {
  1766.     timeout_thread_t *p_timeout = (timeout_thread_t *)p_data;
  1768.     for( ;; )
  1769.     {
  1770.         /* Voodoo (= no) thread safety here! *Ahem* */
  1771.         if( p_timeout->b_handle_keep_alive )
  1772.         {
  1773.             char *psz_bye = NULL;
  1774.             int canc = vlc_savecancel ();
  1776.             p_timeout->p_sys->rtsp->getMediaSessionParameter( *p_timeout->p_sys->ms, NULL, psz_bye );
  1777.             vlc_restorecancel (canc);
  1778.         }
  1779.         p_timeout->p_sys->b_timeout_call = !p_timeout->b_handle_keep_alive;
  1781.         msleep (((int64_t)p_timeout->p_sys->i_timeout - 2) * CLOCK_FREQ);
  1782.     }
  1783.     assert(0); /* dead code */
  1784. }
  1786. /*****************************************************************************
  1787.  *
  1788.  *****************************************************************************/
  1789. static int b64_decode( char *dest, char *src );
  1791. static int ParseASF( demux_t *p_demux )
  1792. {
  1793.     demux_sys_t    *p_sys = p_demux->p_sys;
  1795.     const char *psz_marker = "a=pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,";
  1796.     char *psz_asf = strcasestr( p_sys->p_sdp, psz_marker );
  1797.     char *psz_end;
  1798.     block_t *p_header;
  1800.     /* Parse the asf header */
  1801.     if( psz_asf == NULL )
  1802.         return VLC_EGENERIC;
  1804.     psz_asf += strlen( psz_marker );
  1805.     psz_asf = strdup( psz_asf );    /* Duplicate it */
  1806.     psz_end = strchr( psz_asf, 'n' );
  1808.     while( psz_end > psz_asf && ( *psz_end == 'n' || *psz_end == 'r' ) )
  1809.         *psz_end-- = '';
  1811.     if( psz_asf >= psz_end )
  1812.     {
  1813.         free( psz_asf );
  1814.         return VLC_EGENERIC;
  1815.     }
  1817.     /* Always smaller */
  1818.     p_header = block_New( p_demux, psz_end - psz_asf );
  1819.     p_header->i_buffer = b64_decode( (char*)p_header->p_buffer, psz_asf );
  1820.     //msg_Dbg( p_demux, "Size=%d Hdrb64=%s", p_header->i_buffer, psz_asf );
  1821.     if( p_header->i_buffer <= 0 )
  1822.     {
  1823.         free( psz_asf );
  1824.         return VLC_EGENERIC;
  1825.     }
  1827.     /* Parse it to get packet size */
  1828.     asf_HeaderParse( &p_sys->asfh, p_header->p_buffer, p_header->i_buffer );
  1830.     /* Send it to demuxer */
  1831.     stream_DemuxSend( p_sys->p_out_asf, p_header );
  1833.     free( psz_asf );
  1834.     return VLC_SUCCESS;
  1835. }
  1838. static unsigned char* parseH264ConfigStr( char const* configStr,
  1839.                                           unsigned int& configSize )
  1840. {
  1841.     char *dup, *psz;
  1842.     int i, i_records = 1;
  1844.     if( configSize )
  1845.     configSize = 0;
  1847.     if( configStr == NULL || *configStr == '' )
  1848.         return NULL;
  1850.     psz = dup = strdup( configStr );
  1852.     /* Count the number of comma's */
  1853.     for( psz = dup; *psz != ''; ++psz )
  1854.     {
  1855.         if( *psz == ',')
  1856.         {
  1857.             ++i_records;
  1858.             *psz = '';
  1859.         }
  1860.     }
  1862.     unsigned char *cfg = new unsigned char[5 * strlen(dup)];
  1863.     psz = dup;
  1864.     for( i = 0; i < i_records; i++ )
  1865.     {
  1866.         cfg[configSize++] = 0x00;
  1867.         cfg[configSize++] = 0x00;
  1868.         cfg[configSize++] = 0x00;
  1869.         cfg[configSize++] = 0x01;
  1871.         configSize += b64_decode( (char*)&cfg[configSize], psz );
  1872.         psz += strlen(psz)+1;
  1873.     }
  1875.     free( dup );
  1876.     return cfg;
  1877. }
  1879. /*char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";*/
  1880. static int b64_decode( char *dest, char *src )
  1881. {
  1882.     const char *dest_start = dest;
  1883.     int  i_level;
  1884.     int  last = 0;
  1885.     int  b64[256] = {
  1886.         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 00-0F */
  1887.         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 10-1F */
  1888.         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,  /* 20-2F */
  1889.         52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,  /* 30-3F */
  1890.         -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,  /* 40-4F */
  1891.         15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,  /* 50-5F */
  1892.         -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,  /* 60-6F */
  1893.         41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,  /* 70-7F */
  1894.         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 80-8F */
  1895.         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 90-9F */
  1896.         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* A0-AF */
  1897.         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* B0-BF */
  1898.         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* C0-CF */
  1899.         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* D0-DF */
  1900.         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* E0-EF */
  1901.         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1   /* F0-FF */
  1902.         };
  1904.     for( i_level = 0; *src != ''; src++ )
  1905.     {
  1906.         int  c;
  1908.         c = b64[(unsigned int)*src];
  1909.         if( c == -1 )
  1910.         {
  1911.             continue;
  1912.         }
  1914.         switch( i_level )
  1915.         {
  1916.             case 0:
  1917.                 i_level++;
  1918.                 break;
  1919.             case 1:
  1920.                 *dest++ = ( last << 2 ) | ( ( c >> 4)&0x03 );
  1921.                 i_level++;
  1922.                 break;
  1923.             case 2:
  1924.                 *dest++ = ( ( last << 4 )&0xf0 ) | ( ( c >> 2 )&0x0f );
  1925.                 i_level++;
  1926.                 break;
  1927.             case 3:
  1928.                 *dest++ = ( ( last &0x03 ) << 6 ) | c;
  1929.                 i_level = 0;
  1930.         }
  1931.         last = c;
  1932.     }
  1934.     *dest = '';
  1936.     return dest - dest_start;
  1937. }