1 /*****************************************************************************
2 * rtp.c: rtp stream output module
3 *****************************************************************************
4 * Copyright (C) 2003-2004, 2010 the VideoLAN team
5 * Copyright © 2007-2008 Rémi Denis-Courmont
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
33 #define VLC_MODULE_LICENSE VLC_LICENSE_GPL_2_PLUS
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
37 #include <vlc_block.h>
39 #include <vlc_httpd.h>
41 #include <vlc_network.h>
44 #include <vlc_memstream.h>
48 # include <vlc_gcrypt.h>
53 #include <sys/types.h>
55 #ifdef HAVE_ARPA_INET_H
56 # include <arpa/inet.h>
58 #ifdef HAVE_LINUX_DCCP_H
59 # include <linux/dccp.h>
62 # define IPPROTO_DCCP 33
64 #ifndef IPPROTO_UDPLITE
65 # define IPPROTO_UDPLITE 136
72 /*****************************************************************************
74 *****************************************************************************/
76 #define DEST_TEXT N_("Destination")
77 #define DEST_LONGTEXT N_( \
78 "This is the output URL that will be used." )
79 #define SDP_TEXT N_("SDP")
80 #define SDP_LONGTEXT N_( \
81 "This allows you to specify how the SDP (Session Descriptor) for this RTP "\
82 "session will be made available. You must use a url: http://location to " \
83 "access the SDP via HTTP, rtsp://location for RTSP access, and sap:// " \
84 "for the SDP to be announced via SAP." )
85 #define SAP_TEXT N_("SAP announcing")
86 #define SAP_LONGTEXT N_("Announce this session with SAP.")
87 #define MUX_TEXT N_("Muxer")
88 #define MUX_LONGTEXT N_( \
89 "This allows you to specify the muxer used for the streaming output. " \
90 "Default is to use no muxer (standard RTP stream)." )
92 #define NAME_TEXT N_("Session name")
93 #define NAME_LONGTEXT N_( \
94 "This is the name of the session that will be announced in the SDP " \
95 "(Session Descriptor)." )
96 #define CAT_TEXT N_("Session category")
97 #define CAT_LONGTEXT N_( \
98 "This allows you to specify a category for the session, " \
99 "that will be announced if you choose to use SAP." )
100 #define DESC_TEXT N_("Session description")
101 #define DESC_LONGTEXT N_( \
102 "This allows you to give a short description with details about the stream, " \
103 "that will be announced in the SDP (Session Descriptor)." )
104 #define URL_TEXT N_("Session URL")
105 #define URL_LONGTEXT N_( \
106 "This allows you to give a URL with more details about the stream " \
107 "(often the website of the streaming organization), that will " \
108 "be announced in the SDP (Session Descriptor)." )
109 #define EMAIL_TEXT N_("Session email")
110 #define EMAIL_LONGTEXT N_( \
111 "This allows you to give a contact mail address for the stream, that will " \
112 "be announced in the SDP (Session Descriptor)." )
114 #define PORT_TEXT N_("Port")
115 #define PORT_LONGTEXT N_( \
116 "This allows you to specify the base port for the RTP streaming." )
117 #define PORT_AUDIO_TEXT N_("Audio port")
118 #define PORT_AUDIO_LONGTEXT N_( \
119 "This allows you to specify the default audio port for the RTP streaming." )
120 #define PORT_VIDEO_TEXT N_("Video port")
121 #define PORT_VIDEO_LONGTEXT N_( \
122 "This allows you to specify the default video port for the RTP streaming." )
124 #define TTL_TEXT N_("Hop limit (TTL)")
125 #define TTL_LONGTEXT N_( \
126 "This is the hop limit (also known as \"Time-To-Live\" or TTL) of " \
127 "the multicast packets sent by the stream output (-1 = use operating " \
128 "system built-in default).")
130 #define RTCP_MUX_TEXT N_("RTP/RTCP multiplexing")
131 #define RTCP_MUX_LONGTEXT N_( \
132 "This sends and receives RTCP packet multiplexed over the same port " \
135 #define CACHING_TEXT N_("Caching value (ms)")
136 #define CACHING_LONGTEXT N_( \
137 "Default caching value for outbound RTP streams. This " \
138 "value should be set in milliseconds." )
140 #define PROTO_TEXT N_("Transport protocol")
141 #define PROTO_LONGTEXT N_( \
142 "This selects which transport protocol to use for RTP." )
144 #define SRTP_KEY_TEXT N_("SRTP key (hexadecimal)")
145 #define SRTP_KEY_LONGTEXT N_( \
146 "RTP packets will be integrity-protected and ciphered "\
147 "with this Secure RTP master shared secret key. "\
148 "This must be a 32-character-long hexadecimal string.")
150 #define SRTP_SALT_TEXT N_("SRTP salt (hexadecimal)")
151 #define SRTP_SALT_LONGTEXT N_( \
152 "Secure RTP requires a (non-secret) master salt value. " \
153 "This must be a 28-character-long hexadecimal string.")
155 static const char *const ppsz_protos
[] = {
156 "dccp", "sctp", "tcp", "udp", "udplite",
159 static const char *const ppsz_protocols
[] = {
160 "DCCP", "SCTP", "TCP", "UDP", "UDP-Lite",
163 #define RFC3016_TEXT N_("MP4A LATM")
164 #define RFC3016_LONGTEXT N_( \
165 "This allows you to stream MPEG4 LATM audio streams (see RFC3016)." )
167 #define RTSP_TIMEOUT_TEXT N_( "RTSP session timeout (s)" )
168 #define RTSP_TIMEOUT_LONGTEXT N_( "RTSP sessions will be closed after " \
169 "not receiving any RTSP request for this long. Setting it to a " \
170 "negative value or zero disables timeouts. The default is 60 (one " \
173 #define RTSP_USER_TEXT N_("Username")
174 #define RTSP_USER_LONGTEXT N_("Username that will be " \
175 "requested to access the stream." )
176 #define RTSP_PASS_TEXT N_("Password")
177 #define RTSP_PASS_LONGTEXT N_("Password that will be " \
178 "requested to access the stream." )
180 static int Open ( vlc_object_t
* );
181 static void Close( vlc_object_t
* );
183 #define SOUT_CFG_PREFIX "sout-rtp-"
184 #define MAX_EMPTY_BLOCKS 200
187 set_shortname( N_("RTP"))
188 set_description( N_("RTP stream output") )
189 set_capability( "sout stream", 0 )
190 add_shortcut( "rtp", "vod" )
191 set_category( CAT_SOUT
)
192 set_subcategory( SUBCAT_SOUT_STREAM
)
194 add_string( SOUT_CFG_PREFIX
"dst", "", DEST_TEXT
,
195 DEST_LONGTEXT
, true )
196 add_string( SOUT_CFG_PREFIX
"sdp", "", SDP_TEXT
,
198 add_string( SOUT_CFG_PREFIX
"mux", "", MUX_TEXT
,
200 add_bool( SOUT_CFG_PREFIX
"sap", false, SAP_TEXT
, SAP_LONGTEXT
,
203 add_string( SOUT_CFG_PREFIX
"name", "", NAME_TEXT
,
204 NAME_LONGTEXT
, true )
205 add_string( SOUT_CFG_PREFIX
"cat", "", CAT_TEXT
, CAT_LONGTEXT
, true )
206 add_string( SOUT_CFG_PREFIX
"description", "", DESC_TEXT
,
207 DESC_LONGTEXT
, true )
208 add_string( SOUT_CFG_PREFIX
"url", "", URL_TEXT
,
210 add_string( SOUT_CFG_PREFIX
"email", "", EMAIL_TEXT
,
211 EMAIL_LONGTEXT
, true )
212 add_obsolete_string( SOUT_CFG_PREFIX
"phone" ) /* since 3.0.0 */
214 add_string( SOUT_CFG_PREFIX
"proto", "udp", PROTO_TEXT
,
215 PROTO_LONGTEXT
, false )
216 change_string_list( ppsz_protos
, ppsz_protocols
)
217 add_integer( SOUT_CFG_PREFIX
"port", 5004, PORT_TEXT
,
218 PORT_LONGTEXT
, true )
219 add_integer( SOUT_CFG_PREFIX
"port-audio", 0, PORT_AUDIO_TEXT
,
220 PORT_AUDIO_LONGTEXT
, true )
221 add_integer( SOUT_CFG_PREFIX
"port-video", 0, PORT_VIDEO_TEXT
,
222 PORT_VIDEO_LONGTEXT
, true )
224 add_integer( SOUT_CFG_PREFIX
"ttl", -1, TTL_TEXT
,
226 add_bool( SOUT_CFG_PREFIX
"rtcp-mux", false,
227 RTCP_MUX_TEXT
, RTCP_MUX_LONGTEXT
, false )
228 add_integer( SOUT_CFG_PREFIX
"caching", MS_FROM_VLC_TICK(DEFAULT_PTS_DELAY
),
229 CACHING_TEXT
, CACHING_LONGTEXT
, true )
232 add_string( SOUT_CFG_PREFIX
"key", "",
233 SRTP_KEY_TEXT
, SRTP_KEY_LONGTEXT
, false )
234 add_string( SOUT_CFG_PREFIX
"salt", "",
235 SRTP_SALT_TEXT
, SRTP_SALT_LONGTEXT
, false )
238 add_bool( SOUT_CFG_PREFIX
"mp4a-latm", false, RFC3016_TEXT
,
239 RFC3016_LONGTEXT
, false )
241 set_callbacks( Open
, Close
)
244 set_shortname( N_("RTSP VoD" ) )
245 set_description( N_("RTSP VoD server") )
246 set_category( CAT_SOUT
)
247 set_subcategory( SUBCAT_SOUT_VOD
)
248 set_capability( "vod server", 10 )
249 set_callbacks( OpenVoD
, CloseVoD
)
250 add_shortcut( "rtsp" )
251 add_integer( "rtsp-timeout", 60, RTSP_TIMEOUT_TEXT
,
252 RTSP_TIMEOUT_LONGTEXT
, true )
253 add_string( "sout-rtsp-user", "",
254 RTSP_USER_TEXT
, RTSP_USER_LONGTEXT
, true )
255 add_password("sout-rtsp-pwd", "", RTSP_PASS_TEXT
, RTSP_PASS_LONGTEXT
)
259 /*****************************************************************************
260 * Exported prototypes
261 *****************************************************************************/
262 static const char *const ppsz_sout_options
[] = {
263 "dst", "name", "cat", "port", "port-audio", "port-video", "*sdp", "ttl",
264 "mux", "sap", "description", "url", "email",
265 "proto", "rtcp-mux", "caching",
272 static void *Add( sout_stream_t
*, const es_format_t
* );
273 static void Del( sout_stream_t
*, void * );
274 static int Send( sout_stream_t
*, void *, block_t
* );
276 static void *MuxAdd( sout_stream_t
*, const es_format_t
* );
277 static void MuxDel( sout_stream_t
*, void * );
278 static int MuxSend( sout_stream_t
*, void *, block_t
* );
280 static sout_access_out_t
*GrabberCreate( sout_stream_t
*p_sout
);
281 static void* ThreadSend( void * );
282 static void *rtp_listen_thread( void * );
284 static void SDPHandleUrl( sout_stream_t
*, const char * );
286 static int SapSetup( sout_stream_t
*p_stream
);
287 static int FileSetup( sout_stream_t
*p_stream
);
288 static int HttpSetup( sout_stream_t
*p_stream
, const vlc_url_t
* );
290 static vlc_tick_t
rtp_init_ts( const vod_media_t
*p_media
,
291 const char *psz_vod_session
);
297 vlc_mutex_t lock_sdp
;
304 session_descriptor_t
*p_session
;
307 httpd_host_t
*p_httpd_host
;
308 httpd_file_t
*p_httpd_file
;
313 /* RTSP NPT and timestamp computations */
314 vlc_tick_t i_npt_zero
; /* when NPT=0 packet is sent */
315 vlc_tick_t i_pts_zero
; /* predicts PTS of NPT=0 packet */
316 vlc_tick_t i_pts_offset
; /* matches actual PTS to prediction */
320 char *psz_destination
;
322 uint16_t i_port_audio
;
323 uint16_t i_port_video
;
329 vod_media_t
*p_vod_media
;
330 char *psz_vod_session
;
332 /* in case we do TS/PS over rtp */
334 sout_access_out_t
*p_grab
;
340 sout_stream_id_sys_t
**es
;
343 typedef struct rtp_sink_t
349 struct sout_stream_id_sys_t
351 sout_stream_t
*p_stream
;
353 /* For RFC 4175, seqnum is extended to 32-bits */
357 uint32_t i_ts_offset
;
361 uint16_t i_seq_sent_next
;
364 rtp_format_t rtp_fmt
;
367 /* Packetizer specific fields */
370 srtp_session_t
*srtp
;
375 vlc_mutex_t lock_sink
;
378 rtsp_stream_id_t
*rtsp_id
;
384 block_fifo_t
*p_fifo
;
385 vlc_tick_t i_caching
;
388 /*****************************************************************************
390 *****************************************************************************/
391 static int Open( vlc_object_t
*p_this
)
393 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
394 sout_stream_sys_t
*p_sys
= NULL
;
398 config_ChainParse( p_stream
, SOUT_CFG_PREFIX
,
399 ppsz_sout_options
, p_stream
->p_cfg
);
401 p_sys
= malloc( sizeof( sout_stream_sys_t
) );
405 p_sys
->psz_destination
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"dst" );
407 p_sys
->i_port
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port" );
408 p_sys
->i_port_audio
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port-audio" );
409 p_sys
->i_port_video
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port-video" );
410 p_sys
->rtcp_mux
= var_GetBool( p_stream
, SOUT_CFG_PREFIX
"rtcp-mux" );
412 if( p_sys
->i_port_audio
&& p_sys
->i_port_video
== p_sys
->i_port_audio
)
414 msg_Err( p_stream
, "audio and video RTP port must be distinct" );
415 free( p_sys
->psz_destination
);
420 for( config_chain_t
*p_cfg
= p_stream
->p_cfg
; p_cfg
!= NULL
; p_cfg
= p_cfg
->p_next
)
422 if( !strcmp( p_cfg
->psz_name
, "sdp" )
423 && ( p_cfg
->psz_value
!= NULL
)
424 && !strncasecmp( p_cfg
->psz_value
, "rtsp:", 5 ) )
432 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"sdp" );
435 if( !strncasecmp( psz
, "rtsp:", 5 ) )
441 /* Transport protocol */
442 p_sys
->proto
= IPPROTO_UDP
;
443 psz
= var_GetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"proto");
445 if ((psz
== NULL
) || !strcasecmp (psz
, "udp"))
446 (void)0; /* default */
448 if (!strcasecmp (psz
, "dccp"))
450 p_sys
->proto
= IPPROTO_DCCP
;
451 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
455 if (!strcasecmp (psz
, "sctp"))
457 p_sys
->proto
= IPPROTO_TCP
;
458 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
463 if (!strcasecmp (psz
, "tcp"))
465 p_sys
->proto
= IPPROTO_TCP
;
466 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
470 if (!strcasecmp (psz
, "udplite") || !strcasecmp (psz
, "udp-lite"))
471 p_sys
->proto
= IPPROTO_UDPLITE
;
473 msg_Warn (p_this
, "unknown or unsupported transport protocol \"%s\"",
476 var_Create (p_this
, "dccp-service", VLC_VAR_STRING
);
478 p_sys
->p_vod_media
= NULL
;
479 p_sys
->psz_vod_session
= NULL
;
481 if (! strcmp(p_stream
->psz_name
, "vod"))
483 /* The VLM stops all instances before deleting a media, so this
484 * reference will remain valid during the lifetime of the rtp
486 p_sys
->p_vod_media
= var_InheritAddress(p_stream
, "vod-media");
488 if (p_sys
->p_vod_media
!= NULL
)
490 p_sys
->psz_vod_session
= var_InheritString(p_stream
, "vod-session");
491 if (p_sys
->psz_vod_session
== NULL
)
493 msg_Err(p_stream
, "missing VoD session");
498 const char *mux
= vod_get_mux(p_sys
->p_vod_media
);
499 var_SetString(p_stream
, SOUT_CFG_PREFIX
"mux", mux
);
503 if( p_sys
->psz_destination
== NULL
&& !b_rtsp
504 && p_sys
->p_vod_media
== NULL
)
506 msg_Err( p_stream
, "missing destination and not in RTSP mode" );
511 int i_ttl
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"ttl" );
514 var_Create( p_stream
, "ttl", VLC_VAR_INTEGER
);
515 var_SetInteger( p_stream
, "ttl", i_ttl
);
518 p_sys
->b_latm
= var_GetBool( p_stream
, SOUT_CFG_PREFIX
"mp4a-latm" );
520 /* NPT=0 time will be determined when we packetize the first packet
521 * (of any ES). But we want to be able to report rtptime in RTSP
522 * without waiting (and already did in the VoD case). So until then,
523 * we use an arbitrary reference PTS for timestamp computations, and
524 * then actual PTS will catch up using offsets. */
525 p_sys
->i_npt_zero
= VLC_TICK_INVALID
;
526 p_sys
->i_pts_zero
= rtp_init_ts(p_sys
->p_vod_media
,
527 p_sys
->psz_vod_session
);
531 p_sys
->psz_sdp
= NULL
;
533 p_sys
->b_export_sap
= false;
534 p_sys
->p_session
= NULL
;
535 p_sys
->psz_sdp_file
= NULL
;
537 p_sys
->p_httpd_host
= NULL
;
538 p_sys
->p_httpd_file
= NULL
;
540 p_stream
->p_sys
= p_sys
;
542 vlc_mutex_init( &p_sys
->lock_sdp
);
543 vlc_mutex_init( &p_sys
->lock_ts
);
544 vlc_mutex_init( &p_sys
->lock_es
);
546 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"mux" );
549 /* Check muxer type */
550 if( strncasecmp( psz
, "ps", 2 )
551 && strncasecmp( psz
, "mpeg1", 5 )
552 && strncasecmp( psz
, "ts", 2 ) )
554 msg_Err( p_stream
, "unsupported muxer type for RTP (only TS/PS)" );
556 vlc_mutex_destroy( &p_sys
->lock_sdp
);
557 vlc_mutex_destroy( &p_sys
->lock_ts
);
558 vlc_mutex_destroy( &p_sys
->lock_es
);
559 free( p_sys
->psz_vod_session
);
560 free( p_sys
->psz_destination
);
565 p_sys
->p_grab
= GrabberCreate( p_stream
);
566 p_sys
->p_mux
= sout_MuxNew( p_stream
->p_sout
, psz
, p_sys
->p_grab
);
569 if( p_sys
->p_mux
== NULL
)
571 msg_Err( p_stream
, "cannot create muxer" );
572 sout_AccessOutDelete( p_sys
->p_grab
);
573 vlc_mutex_destroy( &p_sys
->lock_sdp
);
574 vlc_mutex_destroy( &p_sys
->lock_ts
);
575 vlc_mutex_destroy( &p_sys
->lock_es
);
576 free( p_sys
->psz_vod_session
);
577 free( p_sys
->psz_destination
);
582 p_sys
->packet
= NULL
;
584 p_stream
->pf_add
= MuxAdd
;
585 p_stream
->pf_del
= MuxDel
;
586 p_stream
->pf_send
= MuxSend
;
591 p_sys
->p_grab
= NULL
;
593 p_stream
->pf_add
= Add
;
594 p_stream
->pf_del
= Del
;
595 p_stream
->pf_send
= Send
;
597 p_stream
->pace_nocontrol
= true;
599 if( var_GetBool( p_stream
, SOUT_CFG_PREFIX
"sap" ) )
600 SDPHandleUrl( p_stream
, "sap" );
602 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"sdp" );
605 config_chain_t
*p_cfg
;
607 SDPHandleUrl( p_stream
, psz
);
609 for( p_cfg
= p_stream
->p_cfg
; p_cfg
!= NULL
; p_cfg
= p_cfg
->p_next
)
611 if( !strcmp( p_cfg
->psz_name
, "sdp" ) )
613 if( p_cfg
->psz_value
== NULL
|| *p_cfg
->psz_value
== '\0' )
616 /* needed both :sout-rtp-sdp= and rtp{sdp=} can be used */
617 if( !strcmp( p_cfg
->psz_value
, psz
) )
620 SDPHandleUrl( p_stream
, p_cfg
->psz_value
);
626 if( p_sys
->p_mux
!= NULL
)
628 sout_stream_id_sys_t
*id
= Add( p_stream
, NULL
);
639 /*****************************************************************************
641 *****************************************************************************/
642 static void Close( vlc_object_t
* p_this
)
644 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
645 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
649 assert( p_sys
->i_es
<= 1 );
651 sout_MuxDelete( p_sys
->p_mux
);
652 if ( p_sys
->i_es
> 0 )
653 Del( p_stream
, p_sys
->es
[0] );
654 sout_AccessOutDelete( p_sys
->p_grab
);
658 block_Release( p_sys
->packet
);
662 if( p_sys
->rtsp
!= NULL
)
663 RtspUnsetup( p_sys
->rtsp
);
665 vlc_mutex_destroy( &p_sys
->lock_sdp
);
666 vlc_mutex_destroy( &p_sys
->lock_ts
);
667 vlc_mutex_destroy( &p_sys
->lock_es
);
669 if( p_sys
->p_httpd_file
)
670 httpd_FileDelete( p_sys
->p_httpd_file
);
672 if( p_sys
->p_httpd_host
)
673 httpd_HostDelete( p_sys
->p_httpd_host
);
675 free( p_sys
->psz_sdp
);
677 if( p_sys
->psz_sdp_file
!= NULL
)
679 unlink( p_sys
->psz_sdp_file
);
680 free( p_sys
->psz_sdp_file
);
682 free( p_sys
->psz_vod_session
);
683 free( p_sys
->psz_destination
);
687 /*****************************************************************************
689 *****************************************************************************/
690 static void SDPHandleUrl( sout_stream_t
*p_stream
, const char *psz_url
)
692 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
695 vlc_UrlParse( &url
, psz_url
);
696 if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "http" ) )
698 if( p_sys
->p_httpd_file
)
700 msg_Err( p_stream
, "you can use sdp=http:// only once" );
704 if( HttpSetup( p_stream
, &url
) )
706 msg_Err( p_stream
, "cannot export SDP as HTTP" );
709 else if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "rtsp" ) )
711 if( p_sys
->rtsp
!= NULL
)
713 msg_Err( p_stream
, "you can use sdp=rtsp:// only once" );
717 if( url
.psz_host
!= NULL
&& *url
.psz_host
)
719 msg_Warn( p_stream
, "\"%s\" RTSP host might be ignored in "
720 "multiple-host configurations, use at your own risks.",
722 msg_Info( p_stream
, "Consider passing --rtsp-host=IP on the "
723 "command line instead." );
725 var_Create( p_stream
, "rtsp-host", VLC_VAR_STRING
);
726 var_SetString( p_stream
, "rtsp-host", url
.psz_host
);
728 if( url
.i_port
!= 0 )
730 /* msg_Info( p_stream, "Consider passing --rtsp-port=%u on "
731 "the command line instead.", url.i_port ); */
733 var_Create( p_stream
, "rtsp-port", VLC_VAR_INTEGER
);
734 var_SetInteger( p_stream
, "rtsp-port", url
.i_port
);
737 p_sys
->rtsp
= RtspSetup( VLC_OBJECT(p_stream
), NULL
, url
.psz_path
);
738 if( p_sys
->rtsp
== NULL
)
739 msg_Err( p_stream
, "cannot export SDP as RTSP" );
741 else if( ( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "sap" ) ) ||
742 ( url
.psz_host
&& !strcasecmp( url
.psz_host
, "sap" ) ) )
744 p_sys
->b_export_sap
= true;
745 SapSetup( p_stream
);
747 else if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "file" ) )
749 if( p_sys
->psz_sdp_file
!= NULL
)
751 msg_Err( p_stream
, "you can use sdp=file:// only once" );
754 p_sys
->psz_sdp_file
= vlc_uri2path( psz_url
);
755 if( p_sys
->psz_sdp_file
== NULL
)
757 FileSetup( p_stream
);
761 msg_Warn( p_stream
, "unknown protocol for SDP (%s)",
766 vlc_UrlClean( &url
);
769 /*****************************************************************************
771 *****************************************************************************/
773 char *SDPGenerate( sout_stream_t
*p_stream
, const char *rtsp_url
)
775 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
776 struct vlc_memstream sdp
;
777 struct sockaddr_storage dst
;
778 char *psz_sdp
= NULL
;
782 * When we have a fixed destination (typically when we do multicast),
783 * we need to put the actual port numbers in the SDP.
784 * When there is no fixed destination, we only support RTSP unicast
785 * on-demand setup, so we should rather let the clients decide which ports
787 * When there is both a fixed destination and RTSP unicast, we need to
788 * put port numbers used by the fixed destination, otherwise the SDP would
789 * become totally incorrect for multicast use. It should be noted that
790 * port numbers from SDP with RTSP are only "recommendation" from the
791 * server to the clients (per RFC2326), so only broken clients will fail
792 * to handle this properly. There is no solution but to use two differents
793 * output chain with two different RTSP URLs if you need to handle this
798 vlc_mutex_lock( &p_sys
->lock_es
);
799 if( unlikely(p_sys
->i_es
== 0 || (rtsp_url
!= NULL
&& !p_sys
->es
[0]->rtsp_id
)) )
800 goto out
; /* hmm... */
802 if( p_sys
->psz_destination
!= NULL
)
806 /* Oh boy, this is really ugly! */
807 dstlen
= sizeof( dst
);
808 if( p_sys
->es
[0]->listen
.fd
!= NULL
)
809 getsockname( p_sys
->es
[0]->listen
.fd
[0],
810 (struct sockaddr
*)&dst
, &dstlen
);
812 getpeername( p_sys
->es
[0]->sinkv
[0].rtp_fd
,
813 (struct sockaddr
*)&dst
, &dstlen
);
819 /* Check against URL format rtsp://[<ipv6>]:<port>/<path> */
820 bool ipv6
= rtsp_url
!= NULL
&& strlen( rtsp_url
) > 7
821 && rtsp_url
[7] == '[';
823 /* Dummy destination address for RTSP */
824 dstlen
= ipv6
? sizeof( struct sockaddr_in6
)
825 : sizeof( struct sockaddr_in
);
826 memset (&dst
, 0, dstlen
);
827 dst
.ss_family
= ipv6
? AF_INET6
: AF_INET
;
833 if( vlc_sdp_Start( &sdp
, VLC_OBJECT( p_stream
), SOUT_CFG_PREFIX
,
834 NULL
, 0, (struct sockaddr
*)&dst
, dstlen
) )
837 /* TODO: a=source-filter */
838 if( p_sys
->rtcp_mux
)
839 sdp_AddAttribute( &sdp
, "rtcp-mux", NULL
);
841 if( rtsp_url
!= NULL
)
842 sdp_AddAttribute ( &sdp
, "control", "%s", rtsp_url
);
844 const char *proto
= "RTP/AVP"; /* protocol */
845 if( rtsp_url
== NULL
)
847 switch( p_sys
->proto
)
852 proto
= "TCP/RTP/AVP";
855 proto
= "DCCP/RTP/AVP";
857 case IPPROTO_UDPLITE
:
862 for( i
= 0; i
< p_sys
->i_es
; i
++ )
864 sout_stream_id_sys_t
*id
= p_sys
->es
[i
];
865 rtp_format_t
*rtp_fmt
= &id
->rtp_fmt
;
866 const char *mime_major
; /* major MIME type */
868 switch( rtp_fmt
->cat
)
871 mime_major
= "video";
874 mime_major
= "audio";
883 sdp_AddMedia( &sdp
, mime_major
, proto
, inclport
* id
->i_port
,
884 rtp_fmt
->payload_type
, false, rtp_fmt
->bitrate
,
885 rtp_fmt
->ptname
, rtp_fmt
->clock_rate
, rtp_fmt
->channels
,
888 /* cf RFC4566 §5.14 */
889 if( inclport
&& !p_sys
->rtcp_mux
&& (id
->i_port
& 1) )
890 sdp_AddAttribute( &sdp
, "rtcp", "%u", id
->i_port
+ 1 );
892 if( rtsp_url
!= NULL
)
894 char *track_url
= RtspAppendTrackPath( id
->rtsp_id
, rtsp_url
);
895 if( track_url
!= NULL
)
897 sdp_AddAttribute( &sdp
, "control", "%s", track_url
);
903 if( id
->listen
.fd
!= NULL
)
904 sdp_AddAttribute( &sdp
, "setup", "passive" );
905 if( p_sys
->proto
== IPPROTO_DCCP
)
906 sdp_AddAttribute( &sdp
, "dccp-service-code", "SC:RTP%c",
907 toupper( (unsigned char)mime_major
[0] ) );
911 if( vlc_memstream_close( &sdp
) == 0 )
914 vlc_mutex_unlock( &p_sys
->lock_es
);
918 /*****************************************************************************
920 *****************************************************************************/
923 * Shrink the MTU down to a fixed packetization time (for audio).
926 rtp_set_ptime (sout_stream_id_sys_t
*id
, unsigned ptime_ms
, size_t bytes
)
928 /* Samples per second */
929 size_t spl
= (id
->rtp_fmt
.clock_rate
- 1) * ptime_ms
/ 1000 + 1;
930 bytes
*= id
->rtp_fmt
.channels
;
933 if (spl
< rtp_mtu (id
)) /* MTU is big enough for ptime */
934 id
->i_mtu
= 12 + spl
;
935 else /* MTU is too small for ptime, align to a sample boundary */
936 id
->i_mtu
= 12 + (((id
->i_mtu
- 12) / bytes
) * bytes
);
939 uint32_t rtp_compute_ts( unsigned i_clock_rate
, vlc_tick_t i_pts
)
941 /* This is an overflow-proof way of doing:
942 * return i_pts * (int64_t)i_clock_rate / CLOCK_FREQ;
944 * NOTE: this plays nice with offsets because the (equivalent)
945 * calculations are linear. */
946 lldiv_t q
= lldiv(i_pts
, CLOCK_FREQ
);
947 return q
.quot
* (int64_t)i_clock_rate
948 + q
.rem
* (int64_t)i_clock_rate
/ CLOCK_FREQ
;
951 /** Add an ES as a new RTP stream */
952 static void *Add( sout_stream_t
*p_stream
, const es_format_t
*p_fmt
)
954 /* NOTE: As a special case, if we use a non-RTP
955 * mux (TS/PS), then p_fmt is NULL. */
956 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
959 sout_stream_id_sys_t
*id
= malloc( sizeof( *id
) );
960 if( unlikely(id
== NULL
) )
962 id
->p_stream
= p_stream
;
964 id
->i_mtu
= var_InheritInteger( p_stream
, "mtu" );
965 if( id
->i_mtu
<= 12 + 16 )
966 id
->i_mtu
= 576 - 20 - 8; /* pessimistic */
967 msg_Dbg( p_stream
, "maximum RTP packet size: %d bytes", id
->i_mtu
);
972 vlc_mutex_init( &id
->lock_sink
);
977 id
->listen
.fd
= NULL
;
979 id
->b_first_packet
= true;
981 VLC_TICK_FROM_MS(var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"caching"));
983 vlc_rand_bytes (&id
->i_sequence
, sizeof (id
->i_sequence
));
984 vlc_rand_bytes (id
->ssrc
, sizeof (id
->ssrc
));
988 if (p_sys
->p_vod_media
!= NULL
)
990 id
->rtp_fmt
.ptname
= NULL
;
992 int val
= vod_init_id(p_sys
->p_vod_media
, p_sys
->psz_vod_session
,
993 p_fmt
? p_fmt
->i_id
: 0, id
, &id
->rtp_fmt
,
994 &ssrc
, &id
->i_seq_sent_next
);
995 if (val
== VLC_SUCCESS
)
997 memcpy(id
->ssrc
, &ssrc
, sizeof(id
->ssrc
));
998 /* This is ugly, but id->i_seq_sent_next needs to be
999 * initialized inside vod_init_id() to avoid race
1001 id
->i_sequence
= id
->i_seq_sent_next
;
1003 /* vod_init_id() may fail either because the ES wasn't found in
1004 * the VoD media, or because the RTSP session is gone. In the
1005 * former case, id->rtp_fmt was left untouched. */
1006 format
= (id
->rtp_fmt
.ptname
!= NULL
);
1011 id
->rtp_fmt
.fmtp
= NULL
; /* don't free() garbage on error */
1012 char *psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"mux" );
1013 if (p_fmt
== NULL
&& psz
== NULL
)
1015 int val
= rtp_get_fmt(VLC_OBJECT(p_stream
), p_fmt
, psz
, &id
->rtp_fmt
);
1017 if (val
!= VLC_SUCCESS
)
1022 char *key
= var_GetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"key");
1026 id
->srtp
= srtp_create (SRTP_ENCR_AES_CM
, SRTP_AUTH_HMAC_SHA1
, 10,
1027 SRTP_PRF_AES_CM
, SRTP_RCC_MODE1
);
1028 if (id
->srtp
== NULL
)
1034 char *salt
= var_GetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"salt");
1035 int val
= srtp_setkeystring (id
->srtp
, key
, salt
? salt
: "");
1040 msg_Err (p_stream
, "bad SRTP key/salt combination (%s)",
1041 vlc_strerror_c(val
));
1044 id
->i_sequence
= 0; /* FIXME: awful hack for libvlc_srtp */
1048 id
->i_seq_sent_next
= id
->i_sequence
;
1051 if( p_sys
->psz_destination
!= NULL
)
1053 /* Choose the port */
1054 uint16_t i_port
= 0;
1058 if( p_fmt
->i_cat
== AUDIO_ES
&& p_sys
->i_port_audio
> 0 )
1059 i_port
= p_sys
->i_port_audio
;
1061 if( p_fmt
->i_cat
== VIDEO_ES
&& p_sys
->i_port_video
> 0 )
1062 i_port
= p_sys
->i_port_video
;
1064 /* We do not need the ES lock (p_sys->lock_es) here, because
1065 * this is the only one thread that can *modify* the ES table.
1066 * The ES lock protects the other threads from our modifications
1067 * (TAB_APPEND, TAB_REMOVE). */
1068 for (int i
= 0; i_port
&& (i
< p_sys
->i_es
); i
++)
1069 if (i_port
== p_sys
->es
[i
]->i_port
)
1070 i_port
= 0; /* Port already in use! */
1071 for (uint16_t p
= p_sys
->i_port
; i_port
== 0; p
+= 2)
1075 msg_Err (p_stream
, "too many RTP elementary streams");
1079 for (int i
= 0; i_port
&& (i
< p_sys
->i_es
); i
++)
1080 if (p
== p_sys
->es
[i
]->i_port
)
1084 id
->i_port
= i_port
;
1086 int type
= SOCK_STREAM
;
1088 switch( p_sys
->proto
)
1094 switch (id
->rtp_fmt
.cat
)
1096 case VIDEO_ES
: code
= "RTPV"; break;
1097 case AUDIO_ES
: code
= "RTPARTPV"; break;
1098 case SPU_ES
: code
= "RTPTRTPV"; break;
1099 default: code
= "RTPORTPV"; break;
1101 var_SetString (p_stream
, "dccp-service", code
);
1107 id
->listen
.fd
= net_Listen( VLC_OBJECT(p_stream
),
1108 p_sys
->psz_destination
, i_port
,
1109 type
, p_sys
->proto
);
1110 if( id
->listen
.fd
== NULL
)
1112 msg_Err( p_stream
, "passive COMEDIA RTP socket failed" );
1115 if( vlc_clone( &id
->listen
.thread
, rtp_listen_thread
, id
,
1116 VLC_THREAD_PRIORITY_LOW
) )
1118 net_ListenClose( id
->listen
.fd
);
1119 id
->listen
.fd
= NULL
;
1126 int fd
= net_ConnectDgram( p_stream
, p_sys
->psz_destination
,
1127 i_port
, -1, p_sys
->proto
);
1130 msg_Err( p_stream
, "cannot create RTP socket" );
1133 /* Ignore any unexpected incoming packet (including RTCP-RR
1134 * packets in case of rtcp-mux) */
1135 setsockopt (fd
, SOL_SOCKET
, SO_RCVBUF
, &(int){ 0 },
1137 rtp_add_sink( id
, fd
, p_sys
->rtcp_mux
, NULL
);
1138 /* FIXME: test if this is multicast */
1145 switch( p_fmt
->i_codec
)
1147 case VLC_CODEC_MULAW
:
1148 case VLC_CODEC_ALAW
:
1150 rtp_set_ptime (id
, 20, 1);
1152 case VLC_CODEC_S16B
:
1153 case VLC_CODEC_S16L
:
1154 rtp_set_ptime (id
, 20, 2);
1156 case VLC_CODEC_S24B
:
1157 rtp_set_ptime (id
, 20, 3);
1163 #if 0 /* No payload formats sets this at the moment */
1166 cscov
+= 8 /* UDP */ + 12 /* RTP */;
1168 net_SetCSCov( id
->sinkv
[0].rtp_fd
, cscov
, -1 );
1171 vlc_mutex_lock( &p_sys
->lock_ts
);
1172 id
->b_ts_init
= ( p_sys
->i_npt_zero
!= VLC_TICK_INVALID
);
1173 vlc_mutex_unlock( &p_sys
->lock_ts
);
1175 id
->i_ts_offset
= rtp_compute_ts( id
->rtp_fmt
.clock_rate
,
1176 p_sys
->i_pts_offset
);
1178 if( p_sys
->rtsp
!= NULL
)
1179 id
->rtsp_id
= RtspAddId( p_sys
->rtsp
, id
, GetDWBE( id
->ssrc
),
1180 id
->rtp_fmt
.clock_rate
, mcast_fd
);
1182 id
->p_fifo
= block_FifoNew();
1183 if( unlikely(id
->p_fifo
== NULL
) )
1185 if( vlc_clone( &id
->thread
, ThreadSend
, id
, VLC_THREAD_PRIORITY_HIGHEST
) )
1187 block_FifoRelease( id
->p_fifo
);
1192 /* Update p_sys context */
1193 vlc_mutex_lock( &p_sys
->lock_es
);
1194 TAB_APPEND( p_sys
->i_es
, p_sys
->es
, id
);
1195 vlc_mutex_unlock( &p_sys
->lock_es
);
1197 psz_sdp
= SDPGenerate( p_stream
, NULL
);
1199 vlc_mutex_lock( &p_sys
->lock_sdp
);
1200 free( p_sys
->psz_sdp
);
1201 p_sys
->psz_sdp
= psz_sdp
;
1202 vlc_mutex_unlock( &p_sys
->lock_sdp
);
1204 msg_Dbg( p_stream
, "sdp=\n%s", p_sys
->psz_sdp
);
1206 /* Update SDP (sap/file) */
1207 if( p_sys
->b_export_sap
) SapSetup( p_stream
);
1208 if( p_sys
->psz_sdp_file
!= NULL
) FileSetup( p_stream
);
1213 Del( p_stream
, id
);
1217 static void Del( sout_stream_t
*p_stream
, void *_id
)
1219 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1220 sout_stream_id_sys_t
*id
= (sout_stream_id_sys_t
*)_id
;
1222 vlc_mutex_lock( &p_sys
->lock_es
);
1223 TAB_REMOVE( p_sys
->i_es
, p_sys
->es
, id
);
1224 vlc_mutex_unlock( &p_sys
->lock_es
);
1226 if( likely(id
->p_fifo
!= NULL
) )
1228 vlc_cancel( id
->thread
);
1229 vlc_join( id
->thread
, NULL
);
1230 block_FifoRelease( id
->p_fifo
);
1233 free( id
->rtp_fmt
.fmtp
);
1235 if (p_sys
->p_vod_media
!= NULL
)
1236 vod_detach_id(p_sys
->p_vod_media
, p_sys
->psz_vod_session
, id
);
1238 RtspDelId( p_sys
->rtsp
, id
->rtsp_id
);
1239 if( id
->listen
.fd
!= NULL
)
1241 vlc_cancel( id
->listen
.thread
);
1242 vlc_join( id
->listen
.thread
, NULL
);
1243 net_ListenClose( id
->listen
.fd
);
1245 /* Delete remaining sinks (incoming connections or explicit
1247 while( id
->sinkc
> 0 )
1248 rtp_del_sink( id
, id
->sinkv
[0].rtp_fd
);
1250 if( id
->srtp
!= NULL
)
1251 srtp_destroy( id
->srtp
);
1254 vlc_mutex_destroy( &id
->lock_sink
);
1256 /* Update SDP (sap/file) */
1257 if( p_sys
->b_export_sap
) SapSetup( p_stream
);
1258 if( p_sys
->psz_sdp_file
!= NULL
) FileSetup( p_stream
);
1263 static int Send( sout_stream_t
*p_stream
, void *_id
, block_t
*p_buffer
)
1265 sout_stream_id_sys_t
*id
= (sout_stream_id_sys_t
*)_id
;
1266 assert( ((sout_stream_sys_t
*)p_stream
->p_sys
)->p_mux
== NULL
);
1268 while( p_buffer
!= NULL
)
1270 block_t
*p_next
= p_buffer
->p_next
;
1271 p_buffer
->p_next
= NULL
;
1273 /* Send a Vorbis/Theora Packed Configuration packet (RFC 5215 §3.1)
1274 * as the first packet of the stream */
1275 if (id
->b_first_packet
)
1277 id
->b_first_packet
= false;
1278 if (!strcmp(id
->rtp_fmt
.ptname
, "vorbis") ||
1279 !strcmp(id
->rtp_fmt
.ptname
, "theora"))
1280 rtp_packetize_xiph_config(id
, id
->rtp_fmt
.fmtp
,
1284 if( id
->rtp_fmt
.pf_packetize( id
, p_buffer
) )
1292 /****************************************************************************
1294 ****************************************************************************/
1295 static int SapSetup( sout_stream_t
*p_stream
)
1297 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1299 /* Remove the previous session */
1300 if( p_sys
->p_session
!= NULL
)
1302 sout_AnnounceUnRegister( p_stream
, p_sys
->p_session
);
1303 p_sys
->p_session
= NULL
;
1306 if( p_sys
->i_es
> 0 && p_sys
->psz_sdp
&& *p_sys
->psz_sdp
)
1307 p_sys
->p_session
= sout_AnnounceRegisterSDP( p_stream
,
1309 p_sys
->psz_destination
);
1314 /****************************************************************************
1316 ****************************************************************************/
1317 static int FileSetup( sout_stream_t
*p_stream
)
1319 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1322 if( p_sys
->psz_sdp
== NULL
)
1323 return VLC_EGENERIC
; /* too early */
1325 if( ( f
= vlc_fopen( p_sys
->psz_sdp_file
, "wt" ) ) == NULL
)
1327 msg_Err( p_stream
, "cannot open file '%s' (%s)",
1328 p_sys
->psz_sdp_file
, vlc_strerror_c(errno
) );
1329 return VLC_EGENERIC
;
1332 fputs( p_sys
->psz_sdp
, f
);
1338 /****************************************************************************
1340 ****************************************************************************/
1341 static int HttpCallback( httpd_file_sys_t
*p_args
,
1342 httpd_file_t
*, uint8_t *p_request
,
1343 uint8_t **pp_data
, int *pi_data
);
1345 static int HttpSetup( sout_stream_t
*p_stream
, const vlc_url_t
*url
)
1347 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1349 p_sys
->p_httpd_host
= vlc_http_HostNew( VLC_OBJECT(p_stream
) );
1350 if( p_sys
->p_httpd_host
)
1352 p_sys
->p_httpd_file
= httpd_FileNew( p_sys
->p_httpd_host
,
1353 url
->psz_path
? url
->psz_path
: "/",
1356 HttpCallback
, (void*)p_sys
);
1358 if( p_sys
->p_httpd_file
== NULL
)
1360 return VLC_EGENERIC
;
1365 static int HttpCallback( httpd_file_sys_t
*p_args
,
1366 httpd_file_t
*f
, uint8_t *p_request
,
1367 uint8_t **pp_data
, int *pi_data
)
1369 VLC_UNUSED(f
); VLC_UNUSED(p_request
);
1370 sout_stream_sys_t
*p_sys
= (sout_stream_sys_t
*)p_args
;
1372 vlc_mutex_lock( &p_sys
->lock_sdp
);
1373 if( p_sys
->psz_sdp
&& *p_sys
->psz_sdp
)
1375 *pi_data
= strlen( p_sys
->psz_sdp
);
1376 *pp_data
= malloc( *pi_data
);
1377 memcpy( *pp_data
, p_sys
->psz_sdp
, *pi_data
);
1384 vlc_mutex_unlock( &p_sys
->lock_sdp
);
1389 /****************************************************************************
1391 ****************************************************************************/
1392 static void* ThreadSend( void *data
)
1395 # define ENOBUFS WSAENOBUFS
1396 # define EAGAIN WSAEWOULDBLOCK
1397 # define EWOULDBLOCK WSAEWOULDBLOCK
1399 sout_stream_id_sys_t
*id
= data
;
1400 vlc_tick_t i_caching
= id
->i_caching
;
1404 block_t
*out
= block_FifoGet( id
->p_fifo
);
1405 block_cleanup_push (out
);
1409 { /* FIXME: this is awfully inefficient */
1410 size_t len
= out
->i_buffer
;
1411 out
= block_Realloc( out
, 0, len
+ 10 );
1412 out
->i_buffer
= len
;
1414 int canc
= vlc_savecancel ();
1415 int val
= srtp_send( id
->srtp
, out
->p_buffer
, &len
, len
+ 10 );
1416 vlc_restorecancel (canc
);
1419 msg_Dbg( id
->p_stream
, "SRTP sending error: %s",
1420 vlc_strerror_c(val
) );
1421 block_Release( out
);
1425 out
->i_buffer
= len
;
1428 vlc_tick_wait (out
->i_dts
+ i_caching
);
1433 vlc_tick_wait (out
->i_dts
+ i_caching
);
1437 ssize_t len
= out
->i_buffer
;
1438 int canc
= vlc_savecancel ();
1440 vlc_mutex_lock( &id
->lock_sink
);
1441 unsigned deadc
= 0; /* How many dead sockets? */
1442 int deadv
[id
->sinkc
? id
->sinkc
: 1]; /* Dead sockets list */
1444 for( int i
= 0; i
< id
->sinkc
; i
++ )
1447 if( !id
->srtp
) /* FIXME: SRTCP support */
1449 SendRTCP( id
->sinkv
[i
].rtcp
, out
);
1451 if( send( id
->sinkv
[i
].rtp_fd
, out
->p_buffer
, len
, 0 ) == -1
1452 && net_errno
!= EAGAIN
&& net_errno
!= EWOULDBLOCK
1453 && net_errno
!= ENOBUFS
&& net_errno
!= ENOMEM
)
1456 getsockopt( id
->sinkv
[i
].rtp_fd
, SOL_SOCKET
, SO_TYPE
,
1457 &type
, &(socklen_t
){ sizeof(type
) });
1458 if( type
== SOCK_DGRAM
)
1459 /* ICMP soft error: ignore and retry */
1460 send( id
->sinkv
[i
].rtp_fd
, out
->p_buffer
, len
, 0 );
1462 /* Broken connection */
1463 deadv
[deadc
++] = id
->sinkv
[i
].rtp_fd
;
1466 id
->i_seq_sent_next
= ntohs(((uint16_t *) out
->p_buffer
)[1]) + 1;
1467 vlc_mutex_unlock( &id
->lock_sink
);
1468 block_Release( out
);
1470 for( unsigned i
= 0; i
< deadc
; i
++ )
1472 msg_Dbg( id
->p_stream
, "removing socket %d", deadv
[i
] );
1473 rtp_del_sink( id
, deadv
[i
] );
1475 vlc_restorecancel (canc
);
1481 /* This thread dequeues incoming connections (DCCP streaming) */
1482 static void *rtp_listen_thread( void *data
)
1484 sout_stream_id_sys_t
*id
= data
;
1486 assert( id
->listen
.fd
!= NULL
);
1490 int fd
= net_Accept( id
->p_stream
, id
->listen
.fd
);
1493 int canc
= vlc_savecancel( );
1494 rtp_add_sink( id
, fd
, true, NULL
);
1495 vlc_restorecancel( canc
);
1498 vlc_assert_unreachable();
1502 int rtp_add_sink( sout_stream_id_sys_t
*id
, int fd
, bool rtcp_mux
, uint16_t *seq
)
1504 rtp_sink_t sink
= { fd
, NULL
};
1505 sink
.rtcp
= OpenRTCP( VLC_OBJECT( id
->p_stream
), fd
, IPPROTO_UDP
,
1507 if( sink
.rtcp
== NULL
)
1508 msg_Err( id
->p_stream
, "RTCP failed!" );
1510 vlc_mutex_lock( &id
->lock_sink
);
1511 TAB_APPEND(id
->sinkc
, id
->sinkv
, sink
);
1513 *seq
= id
->i_seq_sent_next
;
1514 vlc_mutex_unlock( &id
->lock_sink
);
1518 void rtp_del_sink( sout_stream_id_sys_t
*id
, int fd
)
1520 rtp_sink_t sink
= { fd
, NULL
};
1522 /* NOTE: must be safe to use if fd is not included */
1523 vlc_mutex_lock( &id
->lock_sink
);
1524 for( int i
= 0; i
< id
->sinkc
; i
++ )
1526 if (id
->sinkv
[i
].rtp_fd
== fd
)
1528 sink
= id
->sinkv
[i
];
1529 TAB_ERASE(id
->sinkc
, id
->sinkv
, i
);
1533 vlc_mutex_unlock( &id
->lock_sink
);
1535 CloseRTCP( sink
.rtcp
);
1536 net_Close( sink
.rtp_fd
);
1539 uint16_t rtp_get_seq( sout_stream_id_sys_t
*id
)
1541 /* This will return values for the next packet. */
1544 vlc_mutex_lock( &id
->lock_sink
);
1545 seq
= id
->i_seq_sent_next
;
1546 vlc_mutex_unlock( &id
->lock_sink
);
1551 /* Return an arbitrary initial timestamp for RTP timestamp computations.
1552 * RFC 3550 states that the resulting initial RTP timestamps SHOULD be
1553 * random (although we use the same reference for all the ES as a
1554 * feature). In the VoD case, this function is called independently
1555 * from several parts of the code, so we need to always return the same
1557 static vlc_tick_t
rtp_init_ts( const vod_media_t
*p_media
,
1558 const char *psz_vod_session
)
1560 if (p_media
== NULL
|| psz_vod_session
== NULL
)
1561 return vlc_tick_now();
1564 /* As per RFC 2326, session identifiers are at least 8 bytes long */
1565 strncpy((char *)&i_ts_init
, psz_vod_session
, sizeof(uint64_t));
1566 i_ts_init
^= (uintptr_t)p_media
;
1567 /* Limit the timestamp to 48 bits, this is enough and allows us
1568 * to stay away from overflows */
1569 i_ts_init
&= 0xFFFFFFFFFFFF;
1573 /* Return a timestamp corresponding to packets being sent now, and that
1574 * can be passed to rtp_compute_ts() to get rtptime values for each ES.
1575 * Also return the NPT corresponding to this timestamp. If the stream
1576 * output is not started, the initial timestamp that will be used with
1577 * the first packets for NPT=0 is returned instead. */
1578 vlc_tick_t
rtp_get_ts( const sout_stream_t
*p_stream
, const sout_stream_id_sys_t
*id
,
1579 const vod_media_t
*p_media
, const char *psz_vod_session
,
1586 p_stream
= id
->p_stream
;
1588 if (p_stream
== NULL
)
1589 return rtp_init_ts(p_media
, psz_vod_session
);
1591 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1592 vlc_tick_t i_npt_zero
;
1593 vlc_mutex_lock( &p_sys
->lock_ts
);
1594 i_npt_zero
= p_sys
->i_npt_zero
;
1595 vlc_mutex_unlock( &p_sys
->lock_ts
);
1597 if( i_npt_zero
== VLC_TICK_INVALID
)
1598 return p_sys
->i_pts_zero
;
1600 vlc_tick_t now
= vlc_tick_now();
1601 if( now
< i_npt_zero
)
1602 return p_sys
->i_pts_zero
;
1604 vlc_tick_t npt
= now
- i_npt_zero
;
1608 return p_sys
->i_pts_zero
+ npt
;
1611 void rtp_packetize_common( sout_stream_id_sys_t
*id
, block_t
*out
,
1612 bool b_m_bit
, vlc_tick_t i_pts
)
1614 if( !id
->b_ts_init
)
1616 sout_stream_sys_t
*p_sys
= id
->p_stream
->p_sys
;
1617 vlc_mutex_lock( &p_sys
->lock_ts
);
1618 if( p_sys
->i_npt_zero
== VLC_TICK_INVALID
)
1620 /* This is the first packet of any ES. We initialize the
1621 * NPT=0 time reference, and the offset to match the
1622 * arbitrary PTS reference. */
1623 p_sys
->i_npt_zero
= i_pts
+ id
->i_caching
;
1624 p_sys
->i_pts_offset
= p_sys
->i_pts_zero
- i_pts
;
1626 vlc_mutex_unlock( &p_sys
->lock_ts
);
1628 /* And in any case this is the first packet of this ES, so we
1629 * initialize the offset for this ES. */
1630 id
->i_ts_offset
= rtp_compute_ts( id
->rtp_fmt
.clock_rate
,
1631 p_sys
->i_pts_offset
);
1632 id
->b_ts_init
= true;
1635 uint32_t i_timestamp
= rtp_compute_ts( id
->rtp_fmt
.clock_rate
, i_pts
)
1638 out
->p_buffer
[0] = 0x80;
1639 out
->p_buffer
[1] = (b_m_bit
?0x80:0x00)|id
->rtp_fmt
.payload_type
;
1640 out
->p_buffer
[2] = ( id
->i_sequence
>> 8)&0xff;
1641 out
->p_buffer
[3] = ( id
->i_sequence
)&0xff;
1642 out
->p_buffer
[4] = ( i_timestamp
>> 24 )&0xff;
1643 out
->p_buffer
[5] = ( i_timestamp
>> 16 )&0xff;
1644 out
->p_buffer
[6] = ( i_timestamp
>> 8 )&0xff;
1645 out
->p_buffer
[7] = ( i_timestamp
)&0xff;
1647 memcpy( out
->p_buffer
+ 8, id
->ssrc
, 4 );
1652 uint16_t rtp_get_extended_sequence( sout_stream_id_sys_t
*id
)
1654 return id
->i_sequence
>> 16;
1657 void rtp_packetize_send( sout_stream_id_sys_t
*id
, block_t
*out
)
1659 block_FifoPut( id
->p_fifo
, out
);
1663 * @return configured max RTP payload size (including payload type-specific
1664 * headers, excluding RTP and transport headers)
1666 size_t rtp_mtu (const sout_stream_id_sys_t
*id
)
1668 return id
->i_mtu
- 12;
1671 /*****************************************************************************
1673 *****************************************************************************/
1675 /** Add an ES to a non-RTP muxed stream */
1676 static void *MuxAdd( sout_stream_t
*p_stream
, const es_format_t
*p_fmt
)
1678 sout_input_t
*p_input
;
1679 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1680 sout_mux_t
*p_mux
= p_sys
->p_mux
;
1681 assert( p_mux
!= NULL
);
1683 p_input
= sout_MuxAddStream( p_mux
, p_fmt
);
1684 if( p_input
== NULL
)
1686 msg_Err( p_stream
, "cannot add this stream to the muxer" );
1690 return (sout_stream_id_sys_t
*)p_input
;
1694 static int MuxSend( sout_stream_t
*p_stream
, void *id
, block_t
*p_buffer
)
1696 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1697 sout_mux_t
*p_mux
= p_sys
->p_mux
;
1698 assert( p_mux
!= NULL
);
1700 return sout_MuxSendBuffer( p_mux
, (sout_input_t
*)id
, p_buffer
);
1704 /** Remove an ES from a non-RTP muxed stream */
1705 static void MuxDel( sout_stream_t
*p_stream
, void *id
)
1707 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1708 sout_mux_t
*p_mux
= p_sys
->p_mux
;
1709 assert( p_mux
!= NULL
);
1711 sout_MuxDeleteStream( p_mux
, (sout_input_t
*)id
);
1715 static ssize_t
AccessOutGrabberWriteBuffer( sout_stream_t
*p_stream
,
1716 const block_t
*p_buffer
)
1718 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1719 sout_stream_id_sys_t
*id
= p_sys
->es
[0];
1721 vlc_tick_t i_dts
= p_buffer
->i_dts
;
1723 uint8_t *p_data
= p_buffer
->p_buffer
;
1724 size_t i_data
= p_buffer
->i_buffer
;
1725 size_t i_max
= id
->i_mtu
- 12;
1726 bool b_dis
= (p_buffer
->i_flags
& BLOCK_FLAG_DISCONTINUITY
);
1728 size_t i_packet
= ( p_buffer
->i_buffer
+ i_max
- 1 ) / i_max
;
1734 /* output complete packet */
1735 if( p_sys
->packet
&&
1736 p_sys
->packet
->i_buffer
+ i_data
> i_max
)
1738 rtp_packetize_send( id
, p_sys
->packet
);
1739 p_sys
->packet
= NULL
;
1742 if( p_sys
->packet
== NULL
)
1744 /* allocate a new packet */
1745 p_sys
->packet
= block_Alloc( id
->i_mtu
);
1746 /* m-bit is discontinuity for MPEG1/2 PS and TS, RFC2250 2.1 */
1747 rtp_packetize_common( id
, p_sys
->packet
, b_dis
, i_dts
);
1748 p_sys
->packet
->i_buffer
= 12;
1749 p_sys
->packet
->i_dts
= i_dts
;
1750 p_sys
->packet
->i_length
= p_buffer
->i_length
/ i_packet
;
1751 i_dts
+= p_sys
->packet
->i_length
;
1755 i_size
= __MIN( i_data
,
1756 (unsigned)(id
->i_mtu
- p_sys
->packet
->i_buffer
) );
1758 memcpy( &p_sys
->packet
->p_buffer
[p_sys
->packet
->i_buffer
],
1761 p_sys
->packet
->i_buffer
+= i_size
;
1770 static ssize_t
AccessOutGrabberWrite( sout_access_out_t
*p_access
,
1773 sout_stream_t
*p_stream
= (sout_stream_t
*)p_access
->p_sys
;
1779 AccessOutGrabberWriteBuffer( p_stream
, p_buffer
);
1781 p_next
= p_buffer
->p_next
;
1782 block_Release( p_buffer
);
1790 static sout_access_out_t
*GrabberCreate( sout_stream_t
*p_stream
)
1792 sout_access_out_t
*p_grab
;
1794 p_grab
= vlc_object_create( p_stream
, sizeof( *p_grab
) );
1795 if( p_grab
== NULL
)
1798 p_grab
->p_module
= NULL
;
1799 p_grab
->psz_access
= strdup( "grab" );
1800 p_grab
->p_cfg
= NULL
;
1801 p_grab
->psz_path
= strdup( "" );
1802 p_grab
->p_sys
= p_stream
;
1803 p_grab
->pf_seek
= NULL
;
1804 p_grab
->pf_write
= AccessOutGrabberWrite
;
1808 void rtp_get_video_geometry( sout_stream_id_sys_t
*id
, int *width
, int *height
)
1810 int ret
= sscanf( id
->rtp_fmt
.fmtp
, "%*s width=%d; height=%d; ", width
, height
);