* Preamble
*****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#define __STDC_CONSTANT_MACROS 1
+#include <inttypes.h>
+
#include <vlc/vlc.h>
+#include <vlc_plugin.h>
#include <vlc_demux.h>
#include <vlc_interface.h>
#include <vlc_url.h>
#include <iostream>
+#include <limits.h>
+
#if defined( WIN32 )
# include <winsock2.h>
"used for the connection.")
vlc_module_begin();
- set_description( _("RTP/RTSP/SDP demuxer (using Live555)" ) );
- set_capability( "demux2", 50 );
+ set_description( N_("RTP/RTSP/SDP demuxer (using Live555)" ) );
+ set_capability( "demux", 50 );
set_shortname( "RTP/RTSP");
set_callbacks( Open, Close );
add_shortcut( "live" );
set_subcategory( SUBCAT_INPUT_DEMUX );
add_submodule();
- set_description( _("RTSP/RTP access and demux") );
+ set_description( N_("RTSP/RTP access and demux") );
add_shortcut( "rtsp" );
add_shortcut( "sdp" );
set_capability( "access_demux", 0 );
set_callbacks( Open, Close );
add_bool( "rtsp-tcp", 0, NULL,
N_("Use RTP over RTSP (TCP)"),
- N_("Use RTP over RTSP (TCP)"), VLC_TRUE );
+ N_("Use RTP over RTSP (TCP)"), true );
add_integer( "rtp-client-port", -1, NULL,
N_("Client port"),
- N_("Port to use for the RTP source of the session"), VLC_TRUE );
+ N_("Port to use for the RTP source of the session"), true );
add_bool( "rtsp-http", 0, NULL,
N_("Tunnel RTSP and RTP over HTTP"),
- N_("Tunnel RTSP and RTP over HTTP"), VLC_TRUE );
+ N_("Tunnel RTSP and RTP over HTTP"), true );
add_integer( "rtsp-http-port", 80, NULL,
N_("HTTP tunnel port"),
N_("Port to use for tunneling the RTSP/RTP over HTTP."),
- VLC_TRUE );
+ true );
add_integer("rtsp-caching", 4 * DEFAULT_PTS_DELAY / 1000, NULL,
- CACHING_TEXT, CACHING_LONGTEXT, VLC_TRUE );
- add_bool( "rtsp-kasenna", VLC_FALSE, NULL, KASENNA_TEXT,
- KASENNA_LONGTEXT, VLC_TRUE );
+ CACHING_TEXT, CACHING_LONGTEXT, true );
+ add_bool( "rtsp-kasenna", false, NULL, KASENNA_TEXT,
+ KASENNA_LONGTEXT, true );
add_string( "rtsp-user", NULL, NULL, USER_TEXT,
- USER_LONGTEXT, VLC_TRUE );
+ USER_LONGTEXT, true );
add_string( "rtsp-pwd", NULL, NULL, PASS_TEXT,
- PASS_LONGTEXT, VLC_TRUE );
+ PASS_LONGTEXT, true );
vlc_module_end();
es_format_t fmt;
es_out_id_t *p_es;
- vlc_bool_t b_muxed;
- vlc_bool_t b_quicktime;
- vlc_bool_t b_asf;
+ bool b_muxed;
+ bool b_quicktime;
+ bool b_asf;
stream_t *p_out_muxed; /* for muxed stream */
uint8_t *p_buffer;
unsigned int i_buffer;
- vlc_bool_t b_rtcp_sync;
+ bool b_rtcp_sync;
char waiting;
int64_t i_pts;
u_int32_t i_start_seq;
VLC_COMMON_MEMBERS
int64_t i_remain;
- vlc_bool_t b_handle_keep_alive;
+ bool b_handle_keep_alive;
demux_sys_t *p_sys;
};
/* Weird formats */
asf_header_t asfh;
stream_t *p_out_asf;
- vlc_bool_t b_real;
+ bool b_real;
/* */
int64_t i_pcr; /* The clock */
/* timeout thread information */
int i_timeout; /* session timeout value in seconds */
- vlc_bool_t b_timeout_call;/* mark to send an RTSP call to prevent server timeout */
+ bool b_timeout_call;/* mark to send an RTSP call to prevent server timeout */
timeout_thread_t *p_timeout; /* the actual thread that makes sure we don't timeout */
/* */
- vlc_bool_t b_multicast; /* true if one of the tracks is multicasted */
- vlc_bool_t b_no_data; /* true if we never receive any data */
+ bool b_multicast; /* true if one of the tracks is multicasted */
+ bool b_no_data; /* true if we never receive any data */
int i_no_data_ti; /* consecutive number of TaskInterrupt */
char event;
p_sys->i_npt_start = 0;
p_sys->i_npt_length = 0;
p_sys->p_out_asf = NULL;
- p_sys->b_no_data = VLC_TRUE;
+ p_sys->b_no_data = true;
p_sys->i_no_data_ti = 0;
p_sys->p_timeout = NULL;
p_sys->i_timeout = 0;
- p_sys->b_timeout_call = VLC_FALSE;
- p_sys->b_multicast = VLC_FALSE;
- p_sys->b_real = VLC_FALSE;
+ p_sys->b_timeout_call = false;
+ p_sys->b_multicast = false;
+ p_sys->b_real = false;
p_sys->psz_path = strdup( p_demux->psz_path );
/* parse URL for rtsp://[user:[passwd]@]serverip:port/options */
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;
live_track_t *tk = p_sys->track[i];
if( tk->b_muxed ) stream_DemuxDelete( tk->p_out_muxed );
+ es_format_Clean( &tk->fmt );
free( tk->p_buffer );
free( tk );
}
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 );
live_track_t *tk = p_sys->track[i];
if( tk->b_muxed ) stream_DemuxDelete( tk->p_out_muxed );
+ es_format_Clean( &tk->fmt );
free( tk->p_buffer );
free( tk );
}
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 );
{
demux_sys_t *p_sys = p_demux->p_sys;
Authenticator authenticator;
-
+ bool b_firstpass = true;
char *psz_user = NULL;
char *psz_pwd = NULL;
char *psz_url = NULL;
char *p_sdp = NULL;
int i_http_port = 0;
int i_ret = VLC_SUCCESS;
+ int i_lefttries;
- psz_url = (char*)malloc( strlen( p_sys->psz_path ) + 8 );
- if( !psz_url ) return VLC_ENOMEM;
-
+ if( p_sys->url.i_port == 0 ) p_sys->url.i_port = 554;
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 );
+ int err;
+ err = asprintf( &psz_url, "rtsp://%s:%d%s", p_sys->url.psz_host,
+ p_sys->url.i_port, p_sys->url.psz_path );
+ if( err == -1 ) return VLC_ENOMEM;
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 );
+ int err;
+ err = asprintf( &psz_url, "rtsp://%s", p_sys->psz_path );
+ if( err == -1 ) return VLC_ENOMEM;
psz_user = var_CreateGetString( p_demux, "rtsp-user" );
psz_pwd = var_CreateGetString( p_demux, "rtsp-pwd" );
}
+ i_lefttries = 3;
createnew:
+ i_lefttries--;
+ 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,
- p_demux->p_libvlc->i_verbose > 1,
+ var_CreateGetInteger( p_demux, "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_options = p_sys->rtsp->sendOptionsCmd( psz_url, psz_user, psz_pwd,
&authenticator );
- if( psz_options ) delete [] psz_options;
+ delete [] psz_options;
p_sdp = p_sys->rtsp->describeURL( psz_url, &authenticator,
- var_CreateGetBool( p_demux, "rtsp-kasenna" ) );
+ var_GetBool( p_demux, "rtsp-kasenna" ) );
if( p_sdp == NULL )
{
/* failure occurred */
int i_code = 0;
const char *psz_error = p_sys->env->getResultMsg();
- msg_Dbg( p_demux, "DESCRIBE failed with %d: %s", i_code, psz_error );
- if( var_CreateGetBool( p_demux, "rtsp-http" ) )
+ if( var_GetBool( p_demux, "rtsp-http" ) )
sscanf( psz_error, "%*s %*s HTTP GET %*s HTTP/%*u.%*u %3u %*s",
&i_code );
- else sscanf( psz_error, "%*sRTSP/%*s%3u", &i_code );
+ else
+ {
+ const char *psz_tmp = strstr( psz_error, "RTSP" );
+ if( psz_tmp )
+ sscanf( psz_tmp, "RTSP/%*s%3u", &i_code );
+ else
+ i_code = 0;
+ }
+ msg_Dbg( p_demux, "DESCRIBE failed with %d: %s", i_code, psz_error );
+
+ 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 = false;
+ }
if( i_code == 401 )
{
int i_result;
msg_Dbg( p_demux, "authentication failed" );
- if( psz_user ) free( psz_user );
- if( psz_pwd ) free( psz_pwd );
+ free( psz_user );
+ free( psz_pwd );
psz_user = psz_pwd = NULL;
i_result = intf_UserLoginPassword( p_demux, _("RTSP authentication"),
goto describe;
}
}
- else if( !var_GetBool( 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;
+ val.b_bool = true;
msg_Dbg( p_demux, "we will now try HTTP tunneling mode" );
var_Set( p_demux, "rtsp-http", val );
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 );
- goto createnew;
+ p_sys->rtsp = NULL;
+ if( i_lefttries > 0 )
+ goto createnew;
}
i_ret = VLC_EGENERIC;
}
- if( psz_url ) free( psz_url );
/* malloc-ated copy */
- if( psz_user ) free( psz_user );
- if( psz_pwd ) free( psz_pwd );
+ free( psz_url );
+ free( psz_user );
+ free( psz_pwd );
- if( p_sys->p_sdp ) free( p_sys->p_sdp );
+ free( p_sys->p_sdp );
p_sys->p_sdp = NULL;
if( p_sdp ) p_sys->p_sdp = strdup( (char*)p_sdp );
delete[] p_sdp;
MediaSubsessionIterator *iter = NULL;
MediaSubsession *sub = NULL;
- vlc_bool_t b_rtsp_tcp = VLC_FALSE;
+ bool b_rtsp_tcp = false;
int i_client_port;
int i_return = VLC_SUCCESS;
unsigned int i_buffer = 0;
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;
if( strcasestr( sub->codecName(), "REAL" ) )
{
msg_Info( p_demux, "real codec detected, using real-RTSP instead" );
- p_sys->b_real = VLC_TRUE; /* This is a problem, we'll handle it later */
+ p_sys->b_real = true; /* This is a problem, we'll handle it later */
continue;
}
}
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->b_quicktime = VLC_FALSE;
- tk->b_asf = VLC_FALSE;
- tk->b_muxed = VLC_FALSE;
+ tk->b_quicktime = false;
+ tk->b_asf = false;
+ tk->b_muxed = false;
tk->p_out_muxed = NULL;
tk->waiting = 0;
- tk->b_rtcp_sync = VLC_FALSE;
+ tk->b_rtcp_sync = false;
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( !strcmp( sub->codecName(), "X-ASF-PF" ) )
{
- tk->b_asf = VLC_TRUE;
+ tk->b_asf = true;
if( p_sys->p_out_asf == NULL )
p_sys->p_out_asf = stream_DemuxNew( p_demux, "asf",
p_demux->out );
else if( !strcmp( sub->codecName(), "X-QT" ) ||
!strcmp( sub->codecName(), "X-QUICKTIME" ) )
{
- tk->b_quicktime = VLC_TRUE;
+ tk->b_quicktime = true;
}
else if( !strcmp( sub->codecName(), "SPEEX" ) )
{
uint8_t *p_extra = NULL;
tk->fmt.i_codec = VLC_FOURCC( 'h', '2', '6', '4' );
- tk->fmt.b_packetized = VLC_FALSE;
+ tk->fmt.b_packetized = false;
if((p_extra=parseH264ConfigStr( sub->fmtp_spropparametersets(),
i_extra ) ) )
!strcmp( sub->codecName(), "X-SV3V-ES" ) ||
!strcmp( sub->codecName(), "X-SORENSONVIDEO" ) )
{
- tk->b_quicktime = VLC_TRUE;
+ tk->b_quicktime = true;
}
else if( !strcmp( sub->codecName(), "MP2T" ) )
{
- tk->b_muxed = VLC_TRUE;
+ tk->b_muxed = true;
tk->p_out_muxed = stream_DemuxNew( p_demux, "ts", p_demux->out );
}
else if( !strcmp( sub->codecName(), "MP2P" ) ||
!strcmp( sub->codecName(), "MP1S" ) )
{
- tk->b_muxed = VLC_TRUE;
+ tk->b_muxed = true;
tk->p_out_muxed = stream_DemuxNew( p_demux, "ps",
p_demux->out );
}
else if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
{
- tk->b_asf = VLC_TRUE;
+ tk->b_asf = true;
if( p_sys->p_out_asf == NULL )
p_sys->p_out_asf = stream_DemuxNew( p_demux, "asf",
p_demux->out );;
{
/* BUG ??? */
msg_Err( p_demux, "unusable RTSP track. this should not happen" );
+ es_format_Clean( &tk->fmt );
free( tk );
}
}
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
p_sys->i_timeout = p_sys->rtsp->sessionTimeoutParameter();
if( p_sys->i_timeout <= 0 )
p_sys->i_timeout = 60; /* default value from RFC2326 */
- if( !p_sys->p_timeout )
+
+ /* 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) );
p_sys->p_timeout->p_sys = p_demux->p_sys; /* lol, object recursion :D */
if( vlc_thread_create( p_sys->p_timeout, "liveMedia-timeout", TimeoutPrevention,
- VLC_THREAD_PRIORITY_LOW, VLC_TRUE ) )
+ VLC_THREAD_PRIORITY_LOW, 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 );
}
#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
demux_sys_t *p_sys = p_demux->p_sys;
TaskToken task;
- vlc_bool_t b_send_pcr = VLC_TRUE;
+ bool b_send_pcr = true;
int64_t i_pcr = 0;
int i;
{
char *psz_bye = NULL;
p_sys->rtsp->getMediaSessionParameter( *p_sys->ms, NULL, psz_bye );
- p_sys->b_timeout_call = VLC_FALSE;
+ p_sys->b_timeout_call = false;
}
live_track_t *tk = p_sys->track[i];
if( tk->b_asf || tk->b_muxed )
- b_send_pcr = VLC_FALSE;
+ b_send_pcr = false;
#if 0
if( i_pcr == 0 )
{
msg_Dbg( p_demux, "tk->rtpSource->hasBeenSynchronizedUsingRTCP()" );
es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
- tk->b_rtcp_sync = VLC_TRUE;
+ tk->b_rtcp_sync = true;
/* reset PCR */
tk->i_pts = 0;
p_sys->i_pcr = 0;
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" ) ||
+ bool 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, *pb2, b_bool;
+ bool *pb, *pb2, b_bool;
int *pi_int;
switch( i_query )
for( i = 0; i < p_sys->i_track; i++ )
{
//if( !p_sys->track[i]->b_rtcp_sync )
- p_sys->track[i]->b_rtcp_sync = VLC_FALSE;
+ p_sys->track[i]->b_rtcp_sync = 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_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:
- pb = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
+ case DEMUX_CAN_SEEK:
+ pb = (bool*)va_arg( args, bool * );
if( p_sys->rtsp && p_sys->i_npt_length )
/* Not always true, but will be handled in SET_PAUSE_STATE */
- *pb = VLC_TRUE;
+ *pb = true;
else
- *pb = VLC_FALSE;
+ *pb = false;
return VLC_SUCCESS;
case DEMUX_CAN_CONTROL_PACE:
- pb = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
+ pb = (bool*)va_arg( args, bool * );
#if 1 /* Disable for now until we have a clock synchro algo
* which works with something else than MPEG over UDP */
- *pb = VLC_FALSE;
+ *pb = false;
#else
- *pb = VLC_TRUE;
+ *pb = true;
#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 = (bool*)va_arg( args, bool * );
+ pb2 = (bool*)va_arg( args, bool * );
*pb = p_sys->rtsp != NULL && p_sys->i_npt_length > 0 && !var_GetBool( p_demux, "rtsp-kasenna" );
- *pb2 = VLC_FALSE;
+ *pb2 = false;
return VLC_SUCCESS;
case DEMUX_SET_RATE:
case DEMUX_SET_PAUSE_STATE:
{
- double d_npt = (double) p_sys->i_npt / I64C(1000000);
+ double d_npt = (double) p_sys->i_npt / INT64_C(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;
* 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;
+ p_sys->p_timeout->b_handle_keep_alive = true;
else if( !b_bool && p_sys->p_timeout != NULL )
- p_sys->p_timeout->b_handle_keep_alive = VLC_FALSE;
+ p_sys->p_timeout->b_handle_keep_alive = false;
es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
p_sys->i_pcr = 0;
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
demux_sys_t *p_sys = p_demux->p_sys;
int i, i_return;
- var_SetBool( p_demux, "rtsp-tcp", VLC_TRUE );
+ var_SetBool( p_demux, "rtsp-tcp", true );
/* We close the old RTSP session */
for( i = 0; i < p_sys->i_track; i++ )
live_track_t *tk = p_sys->track[i];
if( tk->b_muxed ) stream_DemuxDelete( tk->p_out_muxed );
+ es_format_Clean( &tk->fmt );
free( tk->p_buffer );
free( tk );
}
//msg_Dbg( p_demux, "pts: %d", pts.tv_sec );
- int64_t i_pts = (uint64_t)pts.tv_sec * UI64C(1000000) +
+ int64_t i_pts = (uint64_t)pts.tv_sec * UINT64_C(1000000) +
(uint64_t)pts.tv_usec;
/* XXX Beurk beurk beurk Avoid having negative value XXX */
- i_pts &= UI64C(0x00ffffffffffffff);
+ i_pts &= UINT64_C(0x00ffffffffffffff);
if( tk->b_quicktime && tk->p_es == NULL )
{
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 )
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 )
{
/* we have read data */
tk->waiting = 0;
- p_demux->p_sys->b_no_data = VLC_FALSE;
+ p_demux->p_sys->b_no_data = false;
p_demux->p_sys->i_no_data_ti = 0;
if( i_pts > 0 && !tk->b_muxed )
msg_Dbg( p_demux, "StreamClose" );
p_sys->event = 0xff;
- p_demux->b_error = VLC_TRUE;
+ p_demux->b_error = true;
}
*****************************************************************************/
static void TimeoutPrevention( timeout_thread_t *p_timeout )
{
- p_timeout->b_die = VLC_FALSE;
+ p_timeout->b_die = false;
p_timeout->i_remain = (int64_t)p_timeout->p_sys->i_timeout -2;
p_timeout->i_remain *= 1000000;
p_timeout->i_remain = (int64_t)p_timeout->p_sys->i_timeout -2;
p_timeout->i_remain *= 1000000;
msg_Dbg( p_timeout, "reset the timeout timer" );
- if( p_timeout->b_handle_keep_alive == VLC_TRUE )
+ if( p_timeout->b_handle_keep_alive == 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;
+ p_timeout->p_sys->b_timeout_call = false;
}
else
{
- p_timeout->p_sys->b_timeout_call = VLC_TRUE;
+ p_timeout->p_sys->b_timeout_call = true;
}
}
p_timeout->i_remain -= 200000;
}
/* Parse it to get packet size */
- E_(asf_HeaderParse)( &p_sys->asfh, p_header->p_buffer, p_header->i_buffer );
+ asf_HeaderParse( &p_sys->asfh, p_header->p_buffer, p_header->i_buffer );
/* Send it to demuxer */
stream_DemuxSend( p_sys->p_out_asf, p_header );
psz += strlen(psz)+1;
}
- if( dup ) free( dup );
+ free( dup );
return cfg;
}
projects / vlc / blobdiff