* Preamble
*****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
#include <vlc/vlc.h>
-#include <stdlib.h> /* malloc(), free() */
-#include <string.h>
#include <vlc_demux.h>
#include <vlc_interface.h>
#include <vlc_network.h>
+#include <vlc_url.h>
#include <iostream>
+#include <limits.h>
#if defined( WIN32 )
# include <winsock2.h>
#endif
+#include "UsageEnvironment.hh"
#include "BasicUsageEnvironment.hh"
#include "GroupsockHelper.hh"
#include "liveMedia.hh"
VLC_COMMON_MEMBERS
int64_t i_remain;
+ vlc_bool_t b_handle_keep_alive;
demux_sys_t *p_sys;
};
{
char *p_sdp; /* XXX mallocated */
char *psz_path; /* URL-encoded path */
+ vlc_url_t url;
MediaSession *ms;
TaskScheduler *scheduler;
MediaSubsessionIterator *iter = NULL;
MediaSubsession *sub = NULL;
int i, i_return;
+ int i_error = VLC_EGENERIC;
if( p_demux->s )
{
/* See if it looks like a SDP
v, o, s fields are mandatory and in this order */
- uint8_t *p_peek;
+ const uint8_t *p_peek;
if( stream_Peek( p_demux->s, &p_peek, 7 ) < 7 ) return VLC_EGENERIC;
- if( memcmp( (char*)p_peek, "v=0\r\n", 5 ) &&
- memcmp( (char*)p_peek, "v=0\n", 4 ) &&
+ if( memcmp( p_peek, "v=0\r\n", 5 ) &&
+ memcmp( p_peek, "v=0\n", 4 ) &&
( p_peek[0] < 'a' || p_peek[0] > 'z' || p_peek[1] != '=' ) )
{
return VLC_EGENERIC;
p_sys->b_real = VLC_FALSE;
p_sys->psz_path = strdup( p_demux->psz_path );
+ /* parse URL for rtsp://[user:[passwd]@]serverip:port/options */
+ vlc_UrlParse( &p_sys->url, p_sys->psz_path, 0 );
+
if( ( p_sys->scheduler = BasicTaskScheduler::createNew() ) == NULL )
{
msg_Err( p_demux, "BasicTaskScheduler::createNew failed" );
int i_sdp_max = 1000;
uint8_t *p_sdp = (uint8_t*) malloc( i_sdp_max );
+ if( !p_sdp )
+ {
+ i_error = VLC_ENOMEM;
+ goto error;
+ }
+
for( ;; )
{
int i_read = stream_Read( p_demux->s, &p_sdp[i_sdp],
i_sdp_max - i_sdp - 1 );
+ if( p_demux->b_die || p_demux->b_error )
+ {
+ free( p_sdp );
+ goto error;
+ }
+
if( i_read < 0 )
{
msg_Err( p_demux, "failed to read SDP" );
- free( p_sys );
- return VLC_EGENERIC;
+ free( p_sdp );
+ goto error;
}
i_sdp += i_read;
}
p_sys->p_sdp = (char*)p_sdp;
}
- else if( p_demux->s == NULL && !strcasecmp( p_demux->psz_access, "sdp" ) )
+ else if( ( p_demux->s == NULL ) &&
+ !strcasecmp( p_demux->psz_access, "sdp" ) )
{
/* sdp:// link from SAP */
p_sys->p_sdp = strdup( p_sys->psz_path );
if( p_sys->p_sdp == NULL )
{
msg_Err( p_demux, "Failed to retrieve the RTSP Session Description" );
+ i_error = VLC_ENOMEM;
goto error;
}
vlc_object_kill( p_sys->p_timeout );
vlc_thread_join( p_sys->p_timeout );
vlc_object_detach( p_sys->p_timeout );
- vlc_object_destroy( p_sys->p_timeout );
+ vlc_object_release( p_sys->p_timeout );
}
- if( p_sys->scheduler ) delete p_sys->scheduler;
- if( p_sys->p_sdp ) free( p_sys->p_sdp );
- if( p_sys->psz_path ) free( p_sys->psz_path );
+ delete p_sys->scheduler;
+ free( p_sys->p_sdp );
+ free( p_sys->psz_path );
+
+ vlc_UrlClean( &p_sys->url );
free( p_sys );
- return VLC_EGENERIC;
+ return i_error;
}
/*****************************************************************************
vlc_object_kill( p_sys->p_timeout );
vlc_thread_join( p_sys->p_timeout );
vlc_object_detach( p_sys->p_timeout );
- vlc_object_destroy( p_sys->p_timeout );
+ vlc_object_release( p_sys->p_timeout );
}
- if( p_sys->scheduler ) delete p_sys->scheduler;
- if( p_sys->p_sdp ) free( p_sys->p_sdp );
- if( p_sys->psz_path ) free( p_sys->psz_path );
+ delete p_sys->scheduler;
+ free( p_sys->p_sdp );
+ free( p_sys->psz_path );
+
+ vlc_UrlClean( &p_sys->url );
free( p_sys );
}
{
demux_sys_t *p_sys = p_demux->p_sys;
Authenticator authenticator;
+ vlc_bool_t b_firstpass = VLC_TRUE;
char *psz_user = NULL;
char *psz_pwd = NULL;
int i_http_port = 0;
int i_ret = VLC_SUCCESS;
+ psz_url = (char*)malloc( strlen( p_sys->psz_path ) + 8 );
+ if( !psz_url ) return VLC_ENOMEM;
+
+ if( p_sys->url.psz_username || p_sys->url.psz_password )
+ {
+ sprintf( psz_url, "rtsp://%s%s", p_sys->url.psz_host,
+ p_sys->url.psz_path );
+
+ psz_user = strdup( p_sys->url.psz_username );
+ psz_pwd = strdup( p_sys->url.psz_password );
+ }
+ else
+ {
+ sprintf( psz_url, "rtsp://%s", p_sys->psz_path );
+
+ psz_user = var_CreateGetString( p_demux, "rtsp-user" );
+ psz_pwd = var_CreateGetString( p_demux, "rtsp-pwd" );
+ }
+
createnew:
+ if( p_demux->b_die || p_demux->b_error )
+ {
+ free( psz_user );
+ free( psz_pwd );
+ free( psz_url );
+ return VLC_EGENERIC;
+ }
+
if( var_CreateGetBool( p_demux, "rtsp-http" ) )
i_http_port = var_CreateGetInteger( p_demux, "rtsp-http-port" );
- if( ( p_sys->rtsp = RTSPClient::createNew(*p_sys->env, 1 /*verbose*/,
+ if( ( p_sys->rtsp = RTSPClient::createNew( *p_sys->env,
+ p_demux->p_libvlc->i_verbose > 1,
"VLC media player", i_http_port ) ) == NULL )
{
msg_Err( p_demux, "RTSPClient::createNew failed (%s)",
p_sys->env->getResultMsg() );
+ free( psz_user );
+ free( psz_pwd );
+ free( psz_url );
return VLC_EGENERIC;
}
- psz_url = (char*)malloc( strlen( p_sys->psz_path ) + 8 );
- sprintf( psz_url, "rtsp://%s", p_sys->psz_path );
-
- psz_options = p_sys->rtsp->sendOptionsCmd( psz_url );
- if( psz_options ) delete [] psz_options;
- psz_user = var_CreateGetString( p_demux, "rtsp-user" );
- psz_pwd = var_CreateGetString( p_demux, "rtsp-pwd" );
+ /* Kasenna enables KeepAlive by analysing the User-Agent string.
+ * Appending _KA to the string should be enough to enable this feature,
+ * however, there is a bug where the _KA doesn't get parsed from the
+ * default User-Agent as created by VLC/Live555 code. This is probably due
+ * to spaces in the string or the string being too long. Here we override
+ * the default string with a more compact version.
+ */
+ if( var_CreateGetBool( p_demux, "rtsp-kasenna" ))
+ {
+#if LIVEMEDIA_LIBRARY_VERSION_INT > 1130457500
+ p_sys->rtsp->setUserAgentString( "VLC_MEDIA_PLAYER_KA" );
+#endif
+ }
describe:
- authenticator.setUsernameAndPassword( (const char*)psz_user, (const char*)psz_pwd );
- p_sdp = p_sys->rtsp->describeURL( psz_url,
- &authenticator, var_CreateGetBool( p_demux, "rtsp-kasenna" ) );
+ authenticator.setUsernameAndPassword( (const char*)psz_user,
+ (const char*)psz_pwd );
- if( psz_user ) free( psz_user );
- if( psz_pwd ) free( psz_pwd );
+ psz_options = p_sys->rtsp->sendOptionsCmd( psz_url, psz_user, psz_pwd,
+ &authenticator );
+ delete [] psz_options;
+ p_sdp = p_sys->rtsp->describeURL( psz_url, &authenticator,
+ var_GetBool( p_demux, "rtsp-kasenna" ) );
if( p_sdp == NULL )
{
/* failure occurred */
int i_code = 0;
const char *psz_error = p_sys->env->getResultMsg();
+ if( var_GetBool( p_demux, "rtsp-http" ) )
+ sscanf( psz_error, "%*s %*s HTTP GET %*s HTTP/%*u.%*u %3u %*s",
+ &i_code );
+ else
+ {
+ const char *psz_tmp = strstr( psz_error, "RTSP" );
+ sscanf( psz_tmp, "RTSP/%*s%3u", &i_code );
+ }
msg_Dbg( p_demux, "DESCRIBE failed with %d: %s", i_code, psz_error );
- sscanf( psz_error, "%*sRTSP/%*s%3u", &i_code );
+
+ if( b_firstpass )
+ { /* describeURL always returns an "RTSP/1.0 401 Unauthorized" the
+ * first time. This is a workaround to avoid asking for a
+ * user/passwd the first time the code passess here. */
+ i_code = 0;
+ b_firstpass = VLC_FALSE;
+ }
if( i_code == 401 )
{
- char *psz_login = NULL; char *psz_password = NULL;
+ int i_result;
msg_Dbg( p_demux, "authentication failed" );
- i_ret = intf_UserLoginPassword( p_demux, _("RTSP authentication"),
+ free( psz_user );
+ free( psz_pwd );
+ psz_user = psz_pwd = NULL;
+
+ i_result = intf_UserLoginPassword( p_demux, _("RTSP authentication"),
_("Please enter a valid login name and a password."),
- &psz_login, &psz_password );
- if( i_ret == DIALOG_OK_YES )
+ &psz_user, &psz_pwd );
+ if( i_result == DIALOG_OK_YES )
{
- msg_Dbg( p_demux, "retrying with user=%s, pwd=%s",
- psz_login, psz_password );
- if( psz_login ) psz_user = psz_login;
- if( psz_password ) psz_pwd = psz_password;
- goto describe;
+ msg_Dbg( p_demux, "retrying with user=%s, pwd=%s",
+ psz_user, psz_pwd );
+ goto describe;
}
- if( psz_login ) free( psz_login );
- if( psz_password ) free( psz_password );
}
- else if( !var_CreateGetBool( p_demux, "rtsp-http" ) )
+ else if( (i_code != 0) && !var_GetBool( p_demux, "rtsp-http" ) )
{
/* Perhaps a firewall is being annoying. Try HTTP tunneling mode */
vlc_value_t val;
val.b_bool = VLC_TRUE;
msg_Dbg( p_demux, "we will now try HTTP tunneling mode" );
var_Set( p_demux, "rtsp-http", val );
- if( psz_url ) free( psz_url );
if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
+ p_sys->rtsp = NULL;
+ goto createnew;
+ }
+ else
+ {
+ msg_Dbg( p_demux, "connection timeout, retrying" );
+ if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
+ p_sys->rtsp = NULL;
goto createnew;
}
i_ret = VLC_EGENERIC;
}
- if( psz_url ) free( psz_url );
/* malloc-ated copy */
- if( p_sys->p_sdp ) free( p_sys->p_sdp );
+ free( psz_url );
+ free( psz_user );
+ free( psz_pwd );
+
+ free( p_sys->p_sdp );
+ p_sys->p_sdp = NULL;
if( p_sdp ) p_sys->p_sdp = strdup( (char*)p_sdp );
delete[] p_sdp;
}
/*****************************************************************************
- * Connect: prepares the subsessions and does the SETUP
+ * SessionsSetup: prepares the subsessions and does the SETUP
*****************************************************************************/
static int SessionsSetup( demux_t *p_demux )
{
unsigned int i_buffer = 0;
unsigned const thresh = 200000; /* RTP reorder threshold .2 second (default .1) */
- b_rtsp_tcp = var_CreateGetBool( p_demux, "rtsp-tcp" );
+ b_rtsp_tcp = var_CreateGetBool( p_demux, "rtsp-tcp" ) ||
+ var_GetBool( p_demux, "rtsp-http" );
i_client_port = var_CreateGetInteger( p_demux, "rtp-client-port" );
/* Create the session from the SDP */
Boolean bInit;
live_track_t *tk;
+ if( p_demux->b_die || p_demux->b_error )
+ {
+ delete iter;
+ return VLC_EGENERIC;
+ }
+
/* Value taken from mplayer */
if( !strcmp( sub->mediumName(), "audio" ) )
i_buffer = 100000;
}
tk = (live_track_t*)malloc( sizeof( live_track_t ) );
+ if( !tk )
+ {
+ delete iter;
+ return VLC_ENOMEM;
+ }
tk->p_demux = p_demux;
tk->sub = sub;
tk->p_es = NULL;
tk->i_pts = 0;
tk->i_buffer = 65536;
tk->p_buffer = (uint8_t *)malloc( 65536 );
+ if( !tk->p_buffer )
+ {
+ delete iter;
+ return VLC_ENOMEM;
+ }
/* Value taken from mplayer */
if( !strcmp( sub->mediumName(), "audio" ) )
}
else if( !strncmp( sub->codecName(), "G726", 4 ) )
{
- tk->fmt.i_codec = VLC_FOURCC( 'g', '7', '2', '6' );
+ tk->fmt.i_codec = VLC_FOURCC( 'g', '7', '2', '6' );
tk->fmt.audio.i_rate = 8000;
tk->fmt.audio.i_channels = 1;
if( !strcmp( sub->codecName()+5, "40" ) )
{
tk->b_quicktime = VLC_TRUE;
}
+ else if( !strcmp( sub->codecName(), "SPEEX" ) )
+ {
+ tk->fmt.i_codec = VLC_FOURCC( 's', 'p', 'x', 'r' );
+ if ( sub->rtpTimestampFrequency() )
+ tk->fmt.audio.i_rate = sub->rtpTimestampFrequency();
+ else
+ {
+ msg_Warn( p_demux,"Using 8kHz as default sample rate." );
+ tk->fmt.audio.i_rate = 8000;
+ }
+ }
}
else if( !strcmp( sub->mediumName(), "video" ) )
{
delete iter;
if( p_sys->i_track <= 0 ) i_return = VLC_EGENERIC;
-#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
+#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1199404800)
/* Retrieve the starttime if possible */
p_sys->i_npt_start = (int64_t)( p_sys->ms->playStartTime() * (double)1000000.0 );
#else
if( p_sys->i_npt_start < 0 )
p_sys->i_npt_start = -1;
-#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
+#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1199404800)
/* Retrieve the duration if possible */
p_sys->i_npt_length = (int64_t)( p_sys->ms->playEndTime() * (double)1000000.0 );
#else
/* Retrieve the timeout value and set up a timeout prevention thread */
p_sys->i_timeout = p_sys->rtsp->sessionTimeoutParameter();
- if( p_sys->i_timeout > 0 && !p_sys->p_timeout )
+ if( p_sys->i_timeout <= 0 )
+ p_sys->i_timeout = 60; /* default value from RFC2326 */
+
+ /* start timeout-thread only on x-asf streams (wms), it has rtcp support but doesn't
+ * seem to use it for liveness/keep-alive, get_parameter seems to work for it. get_parameter
+ * doesn't work with dss 5.5.4 & 5.5.5, they seems to work with rtcp */
+ if( !p_sys->p_timeout && p_sys->p_out_asf )
{
msg_Dbg( p_demux, "We have a timeout of %d seconds", p_sys->i_timeout );
p_sys->p_timeout = (timeout_thread_t *)vlc_object_create( p_demux, sizeof(timeout_thread_t) );
VLC_THREAD_PRIORITY_LOW, VLC_TRUE ) )
{
msg_Err( p_demux, "cannot spawn liveMedia timeout thread" );
- vlc_object_destroy( p_sys->p_timeout );
+ vlc_object_release( p_sys->p_timeout );
}
msg_Dbg( p_demux, "spawned timeout thread" );
vlc_object_attach( p_sys->p_timeout, p_demux );
}
p_sys->i_pcr = 0;
-#if 0
- /* TODO */
+#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1195257600)
for( i = 0; i < p_sys->i_track; i++ )
{
- //p_sys->track[i]->i_pts = 0;
+ if( !p_sys->track[i]->b_rtcp_sync )
+ p_sys->track[i]->i_pts = (int64_t) ( p_sys->track[i]->sub->rtpInfo.timestamp * (double)1000000.0 );
p_sys->track[i]->i_start_seq = (int)p_sys->track[i]->sub->rtpInfo.seqNum;
- msg_Dbg( p_demux, "set startseq: %u", p_sys->track[i]->i_start_seq );
+ msg_Info( p_demux, "set startseq: %u", p_sys->track[i]->i_start_seq );
}
#endif
-#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
+#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1199404800)
/* Retrieve the starttime if possible */
p_sys->i_npt_start = (int64_t)( p_sys->ms->playStartTime() * (double)1000000.0 );
#else
else
p_sys->i_npt = p_sys->i_npt_start;
-#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
+#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1199404800)
/* Retrieve the duration if possible */
p_sys->i_npt_length = (int64_t)( p_sys->ms->playEndTime() * (double)1000000.0 );
#else
es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
tk->b_rtcp_sync = VLC_TRUE;
-#if 0
/* reset PCR */
tk->i_pts = 0;
p_sys->i_pcr = 0;
i_pcr = 0;
-#endif
}
}
- if( p_sys->b_multicast && p_sys->b_no_data && p_sys->i_no_data_ti > 120 )
+ if( p_sys->b_multicast && p_sys->b_no_data &&
+ ( p_sys->i_no_data_ti > 120 ) )
{
/* FIXME Make this configurable
msg_Err( p_demux, "no multicast data received in 36s, aborting" );
return 0;
*/
}
- else if( !p_sys->b_multicast && p_sys->b_no_data && p_sys->i_no_data_ti > 34 )
+ else if( !p_sys->b_multicast && p_sys->b_no_data &&
+ ( p_sys->i_no_data_ti > 34 ) )
{
- vlc_bool_t b_rtsp_tcp = var_GetBool( p_demux, "rtsp-tcp" );
+ vlc_bool_t b_rtsp_tcp = var_GetBool( p_demux, "rtsp-tcp" ) ||
+ var_GetBool( p_demux, "rtsp-http" );
if( !b_rtsp_tcp && p_sys->rtsp && p_sys->ms )
{
demux_sys_t *p_sys = p_demux->p_sys;
int64_t *pi64;
double *pf, f;
- vlc_bool_t *pb, b_bool;
+ vlc_bool_t *pb, *pb2, b_bool;
+ int *pi_int;
switch( i_query )
{
if( p_sys->rtsp && p_sys->i_npt_length > 0 )
{
int i;
- time = f * (double)p_sys->i_npt_length / 1000000.0; /* in second */
+ time = f * (double)p_sys->i_npt_length / (double)1000000.0; /* in second */
if( !p_sys->rtsp->playMediaSession( *p_sys->ms, time, -1, 1 ) )
{
msg_Err( p_demux, "PLAY failed %s",
}
es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
p_sys->i_pcr = 0;
-#if 0
+#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1195257600)
/* Retrieve RTP-Info values */
for( i = 0; i < p_sys->i_track; i++ )
{
- //p_sys->track[i]->i_pts = 0;
+ //if( !p_sys->track[i]->b_rtcp_sync )
+ p_sys->track[i]->b_rtcp_sync = VLC_FALSE;
+ p_sys->track[i]->i_pts = (int64_t) ( p_sys->track[i]->sub->rtpInfo.timestamp * (double)1000000.0 );
p_sys->track[i]->i_start_seq = p_sys->track[i]->sub->rtpInfo.seqNum;
- msg_Dbg( p_demux, "set pos startseq: %u", p_sys->track[i]->i_start_seq );
+ msg_Info( p_demux, "set pos startseq: %u", p_sys->track[i]->i_start_seq );
}
#endif
-#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
+#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1199404800)
/* Retrieve the starttime if possible */
p_sys->i_npt_start = (int64_t)( p_sys->ms->playStartTime() * (double)1000000.0 );
#else
else
p_sys->i_npt = p_sys->i_npt_start;
-#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
+#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1199404800)
/* Retrieve the duration if possible */
p_sys->i_npt_length = (int64_t)( p_sys->ms->playEndTime() * (double)1000000.0 );
#else
}
/* Special for access_demux */
case DEMUX_CAN_PAUSE:
+ case DEMUX_CAN_SEEK:
pb = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
if( p_sys->rtsp && p_sys->i_npt_length )
/* Not always true, but will be handled in SET_PAUSE_STATE */
#endif
return VLC_SUCCESS;
+#if 0
+ case DEMUX_CAN_CONTROL_RATE:
+ pb = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
+ pb2 = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
+
+ *pb = p_sys->rtsp != NULL && p_sys->i_npt_length > 0 && !var_GetBool( p_demux, "rtsp-kasenna" );
+ *pb2 = VLC_FALSE;
+ return VLC_SUCCESS;
+
+ case DEMUX_SET_RATE:
+ {
+ double f_scale;
+
+ if( !p_sys->rtsp || p_sys->i_npt_length <= 0 || var_GetBool( p_demux, "rtsp-kasenna" ) )
+ return VLC_EGENERIC;
+
+ /* TODO we might want to ensure that the new rate is different from
+ * old rate after playMediaSession...
+ * I have no idea how the server map the requested rate to the
+ * ones it supports.
+ * ex:
+ * current is x2 we request x1.5 if the server return x2 we will
+ * never succeed to return to x1.
+ * In this case we should retry with a lower rate until we have
+ * one (even x1).
+ */
+
+ pi_int = (int*)va_arg( args, int * );
+ f_scale = (double)INPUT_RATE_DEFAULT / (*p_int);
+
+ /* Passing -1 for the start and end time will mean liveMedia won't
+ * create a Range: section for the RTSP message. The server should
+ * pick up from the current position */
+ if( !p_sys->rtsp->playMediaSession( *p_sys->ms, -1, -1, f_scale ) )
+ {
+ msg_Err( p_demux, "PLAY with Scale %0.2f failed %s", f_scale,
+ p_sys->env->getResultMsg() );
+ return VLC_EGENERIC;
+ }
+ /* ReSync the stream */
+ p_sys->i_npt_start = 0;
+ p_sys->i_pcr = 0;
+ es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
+
+ *pi_int = (int)( INPUT_RATE_DEFAULT / p_sys->ms->scale() + 0.5 );
+ return VLC_SUCCESS;
+ }
+#endif
+
case DEMUX_SET_PAUSE_STATE:
{
double d_npt = (double) p_sys->i_npt / I64C(1000000);
int i;
- b_bool = (vlc_bool_t)va_arg( args, vlc_bool_t );
+ b_bool = (bool)va_arg( args, int );
if( p_sys->rtsp == NULL )
return VLC_EGENERIC;
msg_Err( p_demux, "PLAY or PAUSE failed %s", p_sys->env->getResultMsg() );
return VLC_EGENERIC;
}
+
+ /* When we Pause, we'll need the TimeoutPrevention thread to
+ * handle sending the "Keep Alive" message to the server.
+ * Unfortunately Live555 isn't thread safe and so can't
+ * do this normally while the main Demux thread is handling
+ * a live stream. We end up with the Timeout thread blocking
+ * waiting for a response from the server. So when we PAUSE
+ * we set a flag that the TimeoutPrevention function will check
+ * and if it's set, it will trigger the GET_PARAMETER message */
+ if( b_bool && p_sys->p_timeout != NULL )
+ p_sys->p_timeout->b_handle_keep_alive = VLC_TRUE;
+ else if( !b_bool && p_sys->p_timeout != NULL )
+ p_sys->p_timeout->b_handle_keep_alive = VLC_FALSE;
+
es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
p_sys->i_pcr = 0;
-#if 0
+#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1195257600)
for( i = 0; i < p_sys->i_track; i++ )
{
- //p_sys->track[i]->i_pts = 0;
+ if( !p_sys->track[i]->b_rtcp_sync )
+ p_sys->track[i]->i_pts = 0; // (int64_t) ( p_sys->track[i]->sub->rtpInfo.timestamp * (double)1000000.0 );
p_sys->track[i]->i_start_seq = p_sys->track[i]->sub->rtpInfo.seqNum;
- msg_Dbg( p_demux, "set pause startseq: %u", p_sys->track[i]->i_start_seq );
+ msg_Info( p_demux, "set pause startseq: %u", p_sys->track[i]->i_start_seq );
}
#endif
-#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
+#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1199404800)
/* Retrieve the starttime if possible */
p_sys->i_npt_start = (int64_t)( p_sys->ms->playStartTime() * (double)1000000.0 );
#else
else
p_sys->i_npt = p_sys->i_npt_start;
-#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 9999999999)
+#if (LIVEMEDIA_LIBRARY_VERSION_INT >= 1199404800)
/* Retrieve the duration if possible */
p_sys->i_npt_length = (int64_t)( p_sys->ms->playEndTime() * (double)1000000.0 );
#else
p_sys->i_track = 0;
/* Reopen rtsp client */
- if( p_demux->s != NULL && ( i_return = Connect( p_demux ) ) != VLC_SUCCESS )
+ if( ( p_demux->s != NULL ) &&
+ ( i_return = Connect( p_demux ) ) != VLC_SUCCESS )
{
- msg_Err( p_demux, "Failed to connect with rtsp://%s", p_sys->psz_path );
+ msg_Err( p_demux, "Failed to connect with rtsp://%s",
+ p_sys->psz_path );
goto error;
}
demux_sys_t *p_sys = p_demux->p_sys;
block_t *p_block;
- msg_Dbg( p_demux, "pts: %d", pts.tv_sec );
+ //msg_Dbg( p_demux, "pts: %d", pts.tv_sec );
int64_t i_pts = (uint64_t)pts.tv_sec * UI64C(1000000) +
(uint64_t)pts.tv_usec;
uint8_t *endpos = (uint8_t*)qtRTPSource->qtState.sdAtom
+ qtRTPSource->qtState.sdAtomSize;
while (pos+8 < endpos) {
- unsigned atomLength = pos[0]<<24 | pos[1]<<16 | pos[2]<<8 | pos[3];
- if( atomLength == 0 || atomLength > endpos-pos) break;
+ unsigned int atomLength = pos[0]<<24 | pos[1]<<16 | pos[2]<<8 | pos[3];
+ if( atomLength == 0 || atomLength > (unsigned int)(endpos-pos)) break;
if( memcmp(pos+4, "avcC", 4) == 0 &&
atomLength > 8 &&
atomLength <= INT_MAX )
{
p_sys->i_npt += __MAX( 0, i_pts - p_sys->i_pcr );
p_sys->i_pcr = i_pts;
- msg_Dbg( p_demux, "npt update" );
+ //msg_Dbg( p_demux, "npt update" );
}
- else if( (tk->fmt.i_cat == VIDEO_ES) && (p_sys->i_pcr < i_pts) )
+ else if( /*tk->fmt.i_cat == VIDEO_ES &&*/ p_sys->i_pcr < i_pts )
{
p_sys->i_pcr = i_pts;
}
- msg_Dbg( p_demux, "npt %lld", p_sys->i_npt );
+ //msg_Dbg( p_demux, "npt %lld", p_sys->i_npt );
if( (i_pts != tk->i_pts) && (!tk->b_muxed) )
{
- p_block->i_dts = ( tk->fmt.i_cat == VIDEO_ES ) ? 0 : i_pts;
p_block->i_pts = i_pts;
}
+ if( !tk->b_muxed )
+ {
+ /*FIXME: for h264 you should check that packetization-mode=1 in sdp-file */
+ p_block->i_dts = ( tk->fmt.i_codec == VLC_FOURCC( 'm', 'p', 'g', 'v' ) ) ? 0 : i_pts;
+ }
if( tk->b_muxed )
{
}
/*****************************************************************************
- *
+ *
*****************************************************************************/
static void TimeoutPrevention( timeout_thread_t *p_timeout )
{
{
if( p_timeout->i_remain <= 0 )
{
+ char *psz_bye = NULL;
p_timeout->i_remain = (int64_t)p_timeout->p_sys->i_timeout -2;
p_timeout->i_remain *= 1000000;
- p_timeout->p_sys->b_timeout_call = VLC_TRUE;
msg_Dbg( p_timeout, "reset the timeout timer" );
+ if( p_timeout->b_handle_keep_alive == VLC_TRUE )
+ {
+#if LIVEMEDIA_LIBRARY_VERSION_INT >= 1138089600
+ p_timeout->p_sys->rtsp->getMediaSessionParameter( *p_timeout->p_sys->ms, NULL, psz_bye );
+#endif
+ p_timeout->p_sys->b_timeout_call = VLC_FALSE;
+ }
+ else
+ {
+ p_timeout->p_sys->b_timeout_call = VLC_TRUE;
+ }
}
p_timeout->i_remain -= 200000;
msleep( 200000 ); /* 200 ms */
psz += strlen(psz)+1;
}
- if( dup ) free( dup );
+ free( dup );
return cfg;
}
projects / vlc / blobdiff