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", DEFAULT_PTS_DELAY
/ 1000,
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", "",
256 RTSP_PASS_TEXT
, RTSP_PASS_LONGTEXT
, true )
260 /*****************************************************************************
261 * Exported prototypes
262 *****************************************************************************/
263 static const char *const ppsz_sout_options
[] = {
264 "dst", "name", "cat", "port", "port-audio", "port-video", "*sdp", "ttl",
265 "mux", "sap", "description", "url", "email",
266 "proto", "rtcp-mux", "caching",
273 static sout_stream_id_sys_t
*Add( sout_stream_t
*, const es_format_t
* );
274 static void Del ( sout_stream_t
*, sout_stream_id_sys_t
* );
275 static int Send( sout_stream_t
*, sout_stream_id_sys_t
*,
277 static sout_stream_id_sys_t
*MuxAdd( sout_stream_t
*, const es_format_t
* );
278 static void MuxDel ( sout_stream_t
*, sout_stream_id_sys_t
* );
279 static int MuxSend( sout_stream_t
*, sout_stream_id_sys_t
*,
282 static sout_access_out_t
*GrabberCreate( sout_stream_t
*p_sout
);
283 static void* ThreadSend( void * );
284 static void *rtp_listen_thread( void * );
286 static void SDPHandleUrl( sout_stream_t
*, const char * );
288 static int SapSetup( sout_stream_t
*p_stream
);
289 static int FileSetup( sout_stream_t
*p_stream
);
290 static int HttpSetup( sout_stream_t
*p_stream
, const vlc_url_t
* );
292 static int64_t rtp_init_ts( const vod_media_t
*p_media
,
293 const char *psz_vod_session
);
295 struct sout_stream_sys_t
299 vlc_mutex_t lock_sdp
;
306 session_descriptor_t
*p_session
;
309 httpd_host_t
*p_httpd_host
;
310 httpd_file_t
*p_httpd_file
;
315 /* RTSP NPT and timestamp computations */
316 mtime_t i_npt_zero
; /* when NPT=0 packet is sent */
317 int64_t i_pts_zero
; /* predicts PTS of NPT=0 packet */
318 int64_t i_pts_offset
; /* matches actual PTS to prediction */
322 char *psz_destination
;
324 uint16_t i_port_audio
;
325 uint16_t i_port_video
;
331 vod_media_t
*p_vod_media
;
332 char *psz_vod_session
;
334 /* in case we do TS/PS over rtp */
336 sout_access_out_t
*p_grab
;
342 sout_stream_id_sys_t
**es
;
345 typedef struct rtp_sink_t
351 struct sout_stream_id_sys_t
353 sout_stream_t
*p_stream
;
355 /* For RFC 4175, seqnum is extended to 32-bits */
359 uint32_t i_ts_offset
;
363 uint16_t i_seq_sent_next
;
366 rtp_format_t rtp_fmt
;
369 /* Packetizer specific fields */
372 srtp_session_t
*srtp
;
377 vlc_mutex_t lock_sink
;
380 rtsp_stream_id_t
*rtsp_id
;
386 block_fifo_t
*p_fifo
;
390 /*****************************************************************************
392 *****************************************************************************/
393 static int Open( vlc_object_t
*p_this
)
395 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
396 sout_stream_sys_t
*p_sys
= NULL
;
400 config_ChainParse( p_stream
, SOUT_CFG_PREFIX
,
401 ppsz_sout_options
, p_stream
->p_cfg
);
403 p_sys
= malloc( sizeof( sout_stream_sys_t
) );
407 p_sys
->psz_destination
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"dst" );
409 p_sys
->i_port
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port" );
410 p_sys
->i_port_audio
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port-audio" );
411 p_sys
->i_port_video
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port-video" );
412 p_sys
->rtcp_mux
= var_GetBool( p_stream
, SOUT_CFG_PREFIX
"rtcp-mux" );
414 if( p_sys
->i_port_audio
&& p_sys
->i_port_video
== p_sys
->i_port_audio
)
416 msg_Err( p_stream
, "audio and video RTP port must be distinct" );
417 free( p_sys
->psz_destination
);
422 for( config_chain_t
*p_cfg
= p_stream
->p_cfg
; p_cfg
!= NULL
; p_cfg
= p_cfg
->p_next
)
424 if( !strcmp( p_cfg
->psz_name
, "sdp" )
425 && ( p_cfg
->psz_value
!= NULL
)
426 && !strncasecmp( p_cfg
->psz_value
, "rtsp:", 5 ) )
434 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"sdp" );
437 if( !strncasecmp( psz
, "rtsp:", 5 ) )
443 /* Transport protocol */
444 p_sys
->proto
= IPPROTO_UDP
;
445 psz
= var_GetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"proto");
447 if ((psz
== NULL
) || !strcasecmp (psz
, "udp"))
448 (void)0; /* default */
450 if (!strcasecmp (psz
, "dccp"))
452 p_sys
->proto
= IPPROTO_DCCP
;
453 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
457 if (!strcasecmp (psz
, "sctp"))
459 p_sys
->proto
= IPPROTO_TCP
;
460 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
465 if (!strcasecmp (psz
, "tcp"))
467 p_sys
->proto
= IPPROTO_TCP
;
468 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
472 if (!strcasecmp (psz
, "udplite") || !strcasecmp (psz
, "udp-lite"))
473 p_sys
->proto
= IPPROTO_UDPLITE
;
475 msg_Warn (p_this
, "unknown or unsupported transport protocol \"%s\"",
478 var_Create (p_this
, "dccp-service", VLC_VAR_STRING
);
480 p_sys
->p_vod_media
= NULL
;
481 p_sys
->psz_vod_session
= NULL
;
483 if (! strcmp(p_stream
->psz_name
, "vod"))
485 /* The VLM stops all instances before deleting a media, so this
486 * reference will remain valid during the lifetime of the rtp
488 p_sys
->p_vod_media
= var_InheritAddress(p_stream
, "vod-media");
490 if (p_sys
->p_vod_media
!= NULL
)
492 p_sys
->psz_vod_session
= var_InheritString(p_stream
, "vod-session");
493 if (p_sys
->psz_vod_session
== NULL
)
495 msg_Err(p_stream
, "missing VoD session");
500 const char *mux
= vod_get_mux(p_sys
->p_vod_media
);
501 var_SetString(p_stream
, SOUT_CFG_PREFIX
"mux", mux
);
505 if( p_sys
->psz_destination
== NULL
&& !b_rtsp
506 && p_sys
->p_vod_media
== NULL
)
508 msg_Err( p_stream
, "missing destination and not in RTSP mode" );
513 int i_ttl
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"ttl" );
516 var_Create( p_stream
, "ttl", VLC_VAR_INTEGER
);
517 var_SetInteger( p_stream
, "ttl", i_ttl
);
520 p_sys
->b_latm
= var_GetBool( p_stream
, SOUT_CFG_PREFIX
"mp4a-latm" );
522 /* NPT=0 time will be determined when we packetize the first packet
523 * (of any ES). But we want to be able to report rtptime in RTSP
524 * without waiting (and already did in the VoD case). So until then,
525 * we use an arbitrary reference PTS for timestamp computations, and
526 * then actual PTS will catch up using offsets. */
527 p_sys
->i_npt_zero
= VLC_TS_INVALID
;
528 p_sys
->i_pts_zero
= rtp_init_ts(p_sys
->p_vod_media
,
529 p_sys
->psz_vod_session
);
533 p_sys
->psz_sdp
= NULL
;
535 p_sys
->b_export_sap
= false;
536 p_sys
->p_session
= NULL
;
537 p_sys
->psz_sdp_file
= NULL
;
539 p_sys
->p_httpd_host
= NULL
;
540 p_sys
->p_httpd_file
= NULL
;
542 p_stream
->p_sys
= p_sys
;
544 vlc_mutex_init( &p_sys
->lock_sdp
);
545 vlc_mutex_init( &p_sys
->lock_ts
);
546 vlc_mutex_init( &p_sys
->lock_es
);
548 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"mux" );
551 /* Check muxer type */
552 if( strncasecmp( psz
, "ps", 2 )
553 && strncasecmp( psz
, "mpeg1", 5 )
554 && strncasecmp( psz
, "ts", 2 ) )
556 msg_Err( p_stream
, "unsupported muxer type for RTP (only TS/PS)" );
558 vlc_mutex_destroy( &p_sys
->lock_sdp
);
559 vlc_mutex_destroy( &p_sys
->lock_ts
);
560 vlc_mutex_destroy( &p_sys
->lock_es
);
561 free( p_sys
->psz_vod_session
);
562 free( p_sys
->psz_destination
);
567 p_sys
->p_grab
= GrabberCreate( p_stream
);
568 p_sys
->p_mux
= sout_MuxNew( p_stream
->p_sout
, psz
, p_sys
->p_grab
);
571 if( p_sys
->p_mux
== NULL
)
573 msg_Err( p_stream
, "cannot create muxer" );
574 sout_AccessOutDelete( p_sys
->p_grab
);
575 vlc_mutex_destroy( &p_sys
->lock_sdp
);
576 vlc_mutex_destroy( &p_sys
->lock_ts
);
577 vlc_mutex_destroy( &p_sys
->lock_es
);
578 free( p_sys
->psz_vod_session
);
579 free( p_sys
->psz_destination
);
584 p_sys
->packet
= NULL
;
586 p_stream
->pf_add
= MuxAdd
;
587 p_stream
->pf_del
= MuxDel
;
588 p_stream
->pf_send
= MuxSend
;
593 p_sys
->p_grab
= NULL
;
595 p_stream
->pf_add
= Add
;
596 p_stream
->pf_del
= Del
;
597 p_stream
->pf_send
= Send
;
599 p_stream
->pace_nocontrol
= true;
601 if( var_GetBool( p_stream
, SOUT_CFG_PREFIX
"sap" ) )
602 SDPHandleUrl( p_stream
, "sap" );
604 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"sdp" );
607 config_chain_t
*p_cfg
;
609 SDPHandleUrl( p_stream
, psz
);
611 for( p_cfg
= p_stream
->p_cfg
; p_cfg
!= NULL
; p_cfg
= p_cfg
->p_next
)
613 if( !strcmp( p_cfg
->psz_name
, "sdp" ) )
615 if( p_cfg
->psz_value
== NULL
|| *p_cfg
->psz_value
== '\0' )
618 /* needed both :sout-rtp-sdp= and rtp{sdp=} can be used */
619 if( !strcmp( p_cfg
->psz_value
, psz
) )
622 SDPHandleUrl( p_stream
, p_cfg
->psz_value
);
628 if( p_sys
->p_mux
!= NULL
)
630 sout_stream_id_sys_t
*id
= Add( p_stream
, NULL
);
641 /*****************************************************************************
643 *****************************************************************************/
644 static void Close( vlc_object_t
* p_this
)
646 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
647 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
651 assert( p_sys
->i_es
<= 1 );
653 sout_MuxDelete( p_sys
->p_mux
);
654 if ( p_sys
->i_es
> 0 )
655 Del( p_stream
, p_sys
->es
[0] );
656 sout_AccessOutDelete( p_sys
->p_grab
);
660 block_Release( p_sys
->packet
);
664 if( p_sys
->rtsp
!= NULL
)
665 RtspUnsetup( p_sys
->rtsp
);
667 vlc_mutex_destroy( &p_sys
->lock_sdp
);
668 vlc_mutex_destroy( &p_sys
->lock_ts
);
669 vlc_mutex_destroy( &p_sys
->lock_es
);
671 if( p_sys
->p_httpd_file
)
672 httpd_FileDelete( p_sys
->p_httpd_file
);
674 if( p_sys
->p_httpd_host
)
675 httpd_HostDelete( p_sys
->p_httpd_host
);
677 free( p_sys
->psz_sdp
);
679 if( p_sys
->psz_sdp_file
!= NULL
)
681 unlink( p_sys
->psz_sdp_file
);
682 free( p_sys
->psz_sdp_file
);
684 free( p_sys
->psz_vod_session
);
685 free( p_sys
->psz_destination
);
689 /*****************************************************************************
691 *****************************************************************************/
692 static void SDPHandleUrl( sout_stream_t
*p_stream
, const char *psz_url
)
694 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
697 vlc_UrlParse( &url
, psz_url
);
698 if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "http" ) )
700 if( p_sys
->p_httpd_file
)
702 msg_Err( p_stream
, "you can use sdp=http:// only once" );
706 if( HttpSetup( p_stream
, &url
) )
708 msg_Err( p_stream
, "cannot export SDP as HTTP" );
711 else if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "rtsp" ) )
713 if( p_sys
->rtsp
!= NULL
)
715 msg_Err( p_stream
, "you can use sdp=rtsp:// only once" );
719 if( url
.psz_host
!= NULL
&& *url
.psz_host
)
721 msg_Warn( p_stream
, "\"%s\" RTSP host might be ignored in "
722 "multiple-host configurations, use at your own risks.",
724 msg_Info( p_stream
, "Consider passing --rtsp-host=IP on the "
725 "command line instead." );
727 var_Create( p_stream
, "rtsp-host", VLC_VAR_STRING
);
728 var_SetString( p_stream
, "rtsp-host", url
.psz_host
);
730 if( url
.i_port
!= 0 )
732 /* msg_Info( p_stream, "Consider passing --rtsp-port=%u on "
733 "the command line instead.", url.i_port ); */
735 var_Create( p_stream
, "rtsp-port", VLC_VAR_INTEGER
);
736 var_SetInteger( p_stream
, "rtsp-port", url
.i_port
);
739 p_sys
->rtsp
= RtspSetup( VLC_OBJECT(p_stream
), NULL
, url
.psz_path
);
740 if( p_sys
->rtsp
== NULL
)
741 msg_Err( p_stream
, "cannot export SDP as RTSP" );
743 else if( ( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "sap" ) ) ||
744 ( url
.psz_host
&& !strcasecmp( url
.psz_host
, "sap" ) ) )
746 p_sys
->b_export_sap
= true;
747 SapSetup( p_stream
);
749 else if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "file" ) )
751 if( p_sys
->psz_sdp_file
!= NULL
)
753 msg_Err( p_stream
, "you can use sdp=file:// only once" );
756 p_sys
->psz_sdp_file
= vlc_uri2path( psz_url
);
757 if( p_sys
->psz_sdp_file
== NULL
)
759 FileSetup( p_stream
);
763 msg_Warn( p_stream
, "unknown protocol for SDP (%s)",
768 vlc_UrlClean( &url
);
771 /*****************************************************************************
773 *****************************************************************************/
775 char *SDPGenerate( sout_stream_t
*p_stream
, const char *rtsp_url
)
777 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
778 struct vlc_memstream sdp
;
779 struct sockaddr_storage dst
;
780 char *psz_sdp
= NULL
;
784 * When we have a fixed destination (typically when we do multicast),
785 * we need to put the actual port numbers in the SDP.
786 * When there is no fixed destination, we only support RTSP unicast
787 * on-demand setup, so we should rather let the clients decide which ports
789 * When there is both a fixed destination and RTSP unicast, we need to
790 * put port numbers used by the fixed destination, otherwise the SDP would
791 * become totally incorrect for multicast use. It should be noted that
792 * port numbers from SDP with RTSP are only "recommendation" from the
793 * server to the clients (per RFC2326), so only broken clients will fail
794 * to handle this properly. There is no solution but to use two differents
795 * output chain with two different RTSP URLs if you need to handle this
800 vlc_mutex_lock( &p_sys
->lock_es
);
801 if( unlikely(p_sys
->i_es
== 0 || (rtsp_url
!= NULL
&& !p_sys
->es
[0]->rtsp_id
)) )
802 goto out
; /* hmm... */
804 if( p_sys
->psz_destination
!= NULL
)
808 /* Oh boy, this is really ugly! */
809 dstlen
= sizeof( dst
);
810 if( p_sys
->es
[0]->listen
.fd
!= NULL
)
811 getsockname( p_sys
->es
[0]->listen
.fd
[0],
812 (struct sockaddr
*)&dst
, &dstlen
);
814 getpeername( p_sys
->es
[0]->sinkv
[0].rtp_fd
,
815 (struct sockaddr
*)&dst
, &dstlen
);
821 /* Check against URL format rtsp://[<ipv6>]:<port>/<path> */
822 bool ipv6
= rtsp_url
!= NULL
&& strlen( rtsp_url
) > 7
823 && rtsp_url
[7] == '[';
825 /* Dummy destination address for RTSP */
826 dstlen
= ipv6
? sizeof( struct sockaddr_in6
)
827 : sizeof( struct sockaddr_in
);
828 memset (&dst
, 0, dstlen
);
829 dst
.ss_family
= ipv6
? AF_INET6
: AF_INET
;
835 if( vlc_sdp_Start( &sdp
, VLC_OBJECT( p_stream
), SOUT_CFG_PREFIX
,
836 NULL
, 0, (struct sockaddr
*)&dst
, dstlen
) )
839 /* TODO: a=source-filter */
840 if( p_sys
->rtcp_mux
)
841 sdp_AddAttribute( &sdp
, "rtcp-mux", NULL
);
843 if( rtsp_url
!= NULL
)
844 sdp_AddAttribute ( &sdp
, "control", "%s", rtsp_url
);
846 const char *proto
= "RTP/AVP"; /* protocol */
847 if( rtsp_url
== NULL
)
849 switch( p_sys
->proto
)
854 proto
= "TCP/RTP/AVP";
857 proto
= "DCCP/RTP/AVP";
859 case IPPROTO_UDPLITE
:
864 for( i
= 0; i
< p_sys
->i_es
; i
++ )
866 sout_stream_id_sys_t
*id
= p_sys
->es
[i
];
867 rtp_format_t
*rtp_fmt
= &id
->rtp_fmt
;
868 const char *mime_major
; /* major MIME type */
870 switch( rtp_fmt
->cat
)
873 mime_major
= "video";
876 mime_major
= "audio";
885 sdp_AddMedia( &sdp
, mime_major
, proto
, inclport
* id
->i_port
,
886 rtp_fmt
->payload_type
, false, rtp_fmt
->bitrate
,
887 rtp_fmt
->ptname
, rtp_fmt
->clock_rate
, rtp_fmt
->channels
,
890 /* cf RFC4566 §5.14 */
891 if( inclport
&& !p_sys
->rtcp_mux
&& (id
->i_port
& 1) )
892 sdp_AddAttribute( &sdp
, "rtcp", "%u", id
->i_port
+ 1 );
894 if( rtsp_url
!= NULL
)
896 char *track_url
= RtspAppendTrackPath( id
->rtsp_id
, rtsp_url
);
897 if( track_url
!= NULL
)
899 sdp_AddAttribute( &sdp
, "control", "%s", track_url
);
905 if( id
->listen
.fd
!= NULL
)
906 sdp_AddAttribute( &sdp
, "setup", "passive" );
907 if( p_sys
->proto
== IPPROTO_DCCP
)
908 sdp_AddAttribute( &sdp
, "dccp-service-code", "SC:RTP%c",
909 toupper( (unsigned char)mime_major
[0] ) );
913 if( vlc_memstream_close( &sdp
) == 0 )
916 vlc_mutex_unlock( &p_sys
->lock_es
);
920 /*****************************************************************************
922 *****************************************************************************/
925 * Shrink the MTU down to a fixed packetization time (for audio).
928 rtp_set_ptime (sout_stream_id_sys_t
*id
, unsigned ptime_ms
, size_t bytes
)
930 /* Samples per second */
931 size_t spl
= (id
->rtp_fmt
.clock_rate
- 1) * ptime_ms
/ 1000 + 1;
932 bytes
*= id
->rtp_fmt
.channels
;
935 if (spl
< rtp_mtu (id
)) /* MTU is big enough for ptime */
936 id
->i_mtu
= 12 + spl
;
937 else /* MTU is too small for ptime, align to a sample boundary */
938 id
->i_mtu
= 12 + (((id
->i_mtu
- 12) / bytes
) * bytes
);
941 uint32_t rtp_compute_ts( unsigned i_clock_rate
, int64_t i_pts
)
943 /* This is an overflow-proof way of doing:
944 * return i_pts * (int64_t)i_clock_rate / CLOCK_FREQ;
946 * NOTE: this plays nice with offsets because the (equivalent)
947 * calculations are linear. */
948 lldiv_t q
= lldiv(i_pts
, CLOCK_FREQ
);
949 return q
.quot
* (int64_t)i_clock_rate
950 + q
.rem
* (int64_t)i_clock_rate
/ CLOCK_FREQ
;
953 /** Add an ES as a new RTP stream */
954 static sout_stream_id_sys_t
*Add( sout_stream_t
*p_stream
,
955 const es_format_t
*p_fmt
)
957 /* NOTE: As a special case, if we use a non-RTP
958 * mux (TS/PS), then p_fmt is NULL. */
959 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
962 sout_stream_id_sys_t
*id
= malloc( sizeof( *id
) );
963 if( unlikely(id
== NULL
) )
965 id
->p_stream
= p_stream
;
967 id
->i_mtu
= var_InheritInteger( p_stream
, "mtu" );
968 if( id
->i_mtu
<= 12 + 16 )
969 id
->i_mtu
= 576 - 20 - 8; /* pessimistic */
970 msg_Dbg( p_stream
, "maximum RTP packet size: %d bytes", id
->i_mtu
);
975 vlc_mutex_init( &id
->lock_sink
);
980 id
->listen
.fd
= NULL
;
982 id
->b_first_packet
= true;
984 (int64_t)1000 * var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"caching");
986 vlc_rand_bytes (&id
->i_sequence
, sizeof (id
->i_sequence
));
987 vlc_rand_bytes (id
->ssrc
, sizeof (id
->ssrc
));
991 if (p_sys
->p_vod_media
!= NULL
)
993 id
->rtp_fmt
.ptname
= NULL
;
995 int val
= vod_init_id(p_sys
->p_vod_media
, p_sys
->psz_vod_session
,
996 p_fmt
? p_fmt
->i_id
: 0, id
, &id
->rtp_fmt
,
997 &ssrc
, &id
->i_seq_sent_next
);
998 if (val
== VLC_SUCCESS
)
1000 memcpy(id
->ssrc
, &ssrc
, sizeof(id
->ssrc
));
1001 /* This is ugly, but id->i_seq_sent_next needs to be
1002 * initialized inside vod_init_id() to avoid race
1004 id
->i_sequence
= id
->i_seq_sent_next
;
1006 /* vod_init_id() may fail either because the ES wasn't found in
1007 * the VoD media, or because the RTSP session is gone. In the
1008 * former case, id->rtp_fmt was left untouched. */
1009 format
= (id
->rtp_fmt
.ptname
!= NULL
);
1014 id
->rtp_fmt
.fmtp
= NULL
; /* don't free() garbage on error */
1015 char *psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"mux" );
1016 if (p_fmt
== NULL
&& psz
== NULL
)
1018 int val
= rtp_get_fmt(VLC_OBJECT(p_stream
), p_fmt
, psz
, &id
->rtp_fmt
);
1020 if (val
!= VLC_SUCCESS
)
1025 char *key
= var_GetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"key");
1029 id
->srtp
= srtp_create (SRTP_ENCR_AES_CM
, SRTP_AUTH_HMAC_SHA1
, 10,
1030 SRTP_PRF_AES_CM
, SRTP_RCC_MODE1
);
1031 if (id
->srtp
== NULL
)
1037 char *salt
= var_GetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"salt");
1038 int val
= srtp_setkeystring (id
->srtp
, key
, salt
? salt
: "");
1043 msg_Err (p_stream
, "bad SRTP key/salt combination (%s)",
1044 vlc_strerror_c(val
));
1047 id
->i_sequence
= 0; /* FIXME: awful hack for libvlc_srtp */
1051 id
->i_seq_sent_next
= id
->i_sequence
;
1054 if( p_sys
->psz_destination
!= NULL
)
1056 /* Choose the port */
1057 uint16_t i_port
= 0;
1061 if( p_fmt
->i_cat
== AUDIO_ES
&& p_sys
->i_port_audio
> 0 )
1062 i_port
= p_sys
->i_port_audio
;
1064 if( p_fmt
->i_cat
== VIDEO_ES
&& p_sys
->i_port_video
> 0 )
1065 i_port
= p_sys
->i_port_video
;
1067 /* We do not need the ES lock (p_sys->lock_es) here, because
1068 * this is the only one thread that can *modify* the ES table.
1069 * The ES lock protects the other threads from our modifications
1070 * (TAB_APPEND, TAB_REMOVE). */
1071 for (int i
= 0; i_port
&& (i
< p_sys
->i_es
); i
++)
1072 if (i_port
== p_sys
->es
[i
]->i_port
)
1073 i_port
= 0; /* Port already in use! */
1074 for (uint16_t p
= p_sys
->i_port
; i_port
== 0; p
+= 2)
1078 msg_Err (p_stream
, "too many RTP elementary streams");
1082 for (int i
= 0; i_port
&& (i
< p_sys
->i_es
); i
++)
1083 if (p
== p_sys
->es
[i
]->i_port
)
1087 id
->i_port
= i_port
;
1089 int type
= SOCK_STREAM
;
1091 switch( p_sys
->proto
)
1097 switch (id
->rtp_fmt
.cat
)
1099 case VIDEO_ES
: code
= "RTPV"; break;
1100 case AUDIO_ES
: code
= "RTPARTPV"; break;
1101 case SPU_ES
: code
= "RTPTRTPV"; break;
1102 default: code
= "RTPORTPV"; break;
1104 var_SetString (p_stream
, "dccp-service", code
);
1110 id
->listen
.fd
= net_Listen( VLC_OBJECT(p_stream
),
1111 p_sys
->psz_destination
, i_port
,
1112 type
, p_sys
->proto
);
1113 if( id
->listen
.fd
== NULL
)
1115 msg_Err( p_stream
, "passive COMEDIA RTP socket failed" );
1118 if( vlc_clone( &id
->listen
.thread
, rtp_listen_thread
, id
,
1119 VLC_THREAD_PRIORITY_LOW
) )
1121 net_ListenClose( id
->listen
.fd
);
1122 id
->listen
.fd
= NULL
;
1129 int fd
= net_ConnectDgram( p_stream
, p_sys
->psz_destination
,
1130 i_port
, -1, p_sys
->proto
);
1133 msg_Err( p_stream
, "cannot create RTP socket" );
1136 /* Ignore any unexpected incoming packet (including RTCP-RR
1137 * packets in case of rtcp-mux) */
1138 setsockopt (fd
, SOL_SOCKET
, SO_RCVBUF
, &(int){ 0 },
1140 rtp_add_sink( id
, fd
, p_sys
->rtcp_mux
, NULL
);
1141 /* FIXME: test if this is multicast */
1148 switch( p_fmt
->i_codec
)
1150 case VLC_CODEC_MULAW
:
1151 case VLC_CODEC_ALAW
:
1153 rtp_set_ptime (id
, 20, 1);
1155 case VLC_CODEC_S16B
:
1156 case VLC_CODEC_S16L
:
1157 rtp_set_ptime (id
, 20, 2);
1159 case VLC_CODEC_S24B
:
1160 rtp_set_ptime (id
, 20, 3);
1166 #if 0 /* No payload formats sets this at the moment */
1169 cscov
+= 8 /* UDP */ + 12 /* RTP */;
1171 net_SetCSCov( id
->sinkv
[0].rtp_fd
, cscov
, -1 );
1174 vlc_mutex_lock( &p_sys
->lock_ts
);
1175 id
->b_ts_init
= ( p_sys
->i_npt_zero
!= VLC_TS_INVALID
);
1176 vlc_mutex_unlock( &p_sys
->lock_ts
);
1178 id
->i_ts_offset
= rtp_compute_ts( id
->rtp_fmt
.clock_rate
,
1179 p_sys
->i_pts_offset
);
1181 if( p_sys
->rtsp
!= NULL
)
1182 id
->rtsp_id
= RtspAddId( p_sys
->rtsp
, id
, GetDWBE( id
->ssrc
),
1183 id
->rtp_fmt
.clock_rate
, mcast_fd
);
1185 id
->p_fifo
= block_FifoNew();
1186 if( unlikely(id
->p_fifo
== NULL
) )
1188 if( vlc_clone( &id
->thread
, ThreadSend
, id
, VLC_THREAD_PRIORITY_HIGHEST
) )
1190 block_FifoRelease( id
->p_fifo
);
1195 /* Update p_sys context */
1196 vlc_mutex_lock( &p_sys
->lock_es
);
1197 TAB_APPEND( p_sys
->i_es
, p_sys
->es
, id
);
1198 vlc_mutex_unlock( &p_sys
->lock_es
);
1200 psz_sdp
= SDPGenerate( p_stream
, NULL
);
1202 vlc_mutex_lock( &p_sys
->lock_sdp
);
1203 free( p_sys
->psz_sdp
);
1204 p_sys
->psz_sdp
= psz_sdp
;
1205 vlc_mutex_unlock( &p_sys
->lock_sdp
);
1207 msg_Dbg( p_stream
, "sdp=\n%s", p_sys
->psz_sdp
);
1209 /* Update SDP (sap/file) */
1210 if( p_sys
->b_export_sap
) SapSetup( p_stream
);
1211 if( p_sys
->psz_sdp_file
!= NULL
) FileSetup( p_stream
);
1216 Del( p_stream
, id
);
1220 static void Del( sout_stream_t
*p_stream
, sout_stream_id_sys_t
*id
)
1222 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1224 vlc_mutex_lock( &p_sys
->lock_es
);
1225 TAB_REMOVE( p_sys
->i_es
, p_sys
->es
, id
);
1226 vlc_mutex_unlock( &p_sys
->lock_es
);
1228 if( likely(id
->p_fifo
!= NULL
) )
1230 vlc_cancel( id
->thread
);
1231 vlc_join( id
->thread
, NULL
);
1232 block_FifoRelease( id
->p_fifo
);
1235 free( id
->rtp_fmt
.fmtp
);
1237 if (p_sys
->p_vod_media
!= NULL
)
1238 vod_detach_id(p_sys
->p_vod_media
, p_sys
->psz_vod_session
, id
);
1240 RtspDelId( p_sys
->rtsp
, id
->rtsp_id
);
1241 if( id
->listen
.fd
!= NULL
)
1243 vlc_cancel( id
->listen
.thread
);
1244 vlc_join( id
->listen
.thread
, NULL
);
1245 net_ListenClose( id
->listen
.fd
);
1247 /* Delete remaining sinks (incoming connections or explicit
1249 while( id
->sinkc
> 0 )
1250 rtp_del_sink( id
, id
->sinkv
[0].rtp_fd
);
1252 if( id
->srtp
!= NULL
)
1253 srtp_destroy( id
->srtp
);
1256 vlc_mutex_destroy( &id
->lock_sink
);
1258 /* Update SDP (sap/file) */
1259 if( p_sys
->b_export_sap
) SapSetup( p_stream
);
1260 if( p_sys
->psz_sdp_file
!= NULL
) FileSetup( p_stream
);
1265 static int Send( sout_stream_t
*p_stream
, sout_stream_id_sys_t
*id
,
1268 assert( p_stream
->p_sys
->p_mux
== NULL
);
1271 while( p_buffer
!= NULL
)
1273 block_t
*p_next
= p_buffer
->p_next
;
1274 p_buffer
->p_next
= NULL
;
1276 /* Send a Vorbis/Theora Packed Configuration packet (RFC 5215 §3.1)
1277 * as the first packet of the stream */
1278 if (id
->b_first_packet
)
1280 id
->b_first_packet
= false;
1281 if (!strcmp(id
->rtp_fmt
.ptname
, "vorbis") ||
1282 !strcmp(id
->rtp_fmt
.ptname
, "theora"))
1283 rtp_packetize_xiph_config(id
, id
->rtp_fmt
.fmtp
,
1287 if( id
->rtp_fmt
.pf_packetize( id
, p_buffer
) )
1295 /****************************************************************************
1297 ****************************************************************************/
1298 static int SapSetup( sout_stream_t
*p_stream
)
1300 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1302 /* Remove the previous session */
1303 if( p_sys
->p_session
!= NULL
)
1305 sout_AnnounceUnRegister( p_stream
, p_sys
->p_session
);
1306 p_sys
->p_session
= NULL
;
1309 if( p_sys
->i_es
> 0 && p_sys
->psz_sdp
&& *p_sys
->psz_sdp
)
1310 p_sys
->p_session
= sout_AnnounceRegisterSDP( p_stream
,
1312 p_sys
->psz_destination
);
1317 /****************************************************************************
1319 ****************************************************************************/
1320 static int FileSetup( sout_stream_t
*p_stream
)
1322 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1325 if( p_sys
->psz_sdp
== NULL
)
1326 return VLC_EGENERIC
; /* too early */
1328 if( ( f
= vlc_fopen( p_sys
->psz_sdp_file
, "wt" ) ) == NULL
)
1330 msg_Err( p_stream
, "cannot open file '%s' (%s)",
1331 p_sys
->psz_sdp_file
, vlc_strerror_c(errno
) );
1332 return VLC_EGENERIC
;
1335 fputs( p_sys
->psz_sdp
, f
);
1341 /****************************************************************************
1343 ****************************************************************************/
1344 static int HttpCallback( httpd_file_sys_t
*p_args
,
1345 httpd_file_t
*, uint8_t *p_request
,
1346 uint8_t **pp_data
, int *pi_data
);
1348 static int HttpSetup( sout_stream_t
*p_stream
, const vlc_url_t
*url
)
1350 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1352 p_sys
->p_httpd_host
= vlc_http_HostNew( VLC_OBJECT(p_stream
) );
1353 if( p_sys
->p_httpd_host
)
1355 p_sys
->p_httpd_file
= httpd_FileNew( p_sys
->p_httpd_host
,
1356 url
->psz_path
? url
->psz_path
: "/",
1359 HttpCallback
, (void*)p_sys
);
1361 if( p_sys
->p_httpd_file
== NULL
)
1363 return VLC_EGENERIC
;
1368 static int HttpCallback( httpd_file_sys_t
*p_args
,
1369 httpd_file_t
*f
, uint8_t *p_request
,
1370 uint8_t **pp_data
, int *pi_data
)
1372 VLC_UNUSED(f
); VLC_UNUSED(p_request
);
1373 sout_stream_sys_t
*p_sys
= (sout_stream_sys_t
*)p_args
;
1375 vlc_mutex_lock( &p_sys
->lock_sdp
);
1376 if( p_sys
->psz_sdp
&& *p_sys
->psz_sdp
)
1378 *pi_data
= strlen( p_sys
->psz_sdp
);
1379 *pp_data
= malloc( *pi_data
);
1380 memcpy( *pp_data
, p_sys
->psz_sdp
, *pi_data
);
1387 vlc_mutex_unlock( &p_sys
->lock_sdp
);
1392 /****************************************************************************
1394 ****************************************************************************/
1395 static void* ThreadSend( void *data
)
1398 # define ENOBUFS WSAENOBUFS
1399 # define EAGAIN WSAEWOULDBLOCK
1400 # define EWOULDBLOCK WSAEWOULDBLOCK
1402 sout_stream_id_sys_t
*id
= data
;
1403 unsigned i_caching
= id
->i_caching
;
1407 block_t
*out
= block_FifoGet( id
->p_fifo
);
1408 block_cleanup_push (out
);
1412 { /* FIXME: this is awfully inefficient */
1413 size_t len
= out
->i_buffer
;
1414 out
= block_Realloc( out
, 0, len
+ 10 );
1415 out
->i_buffer
= len
;
1417 int canc
= vlc_savecancel ();
1418 int val
= srtp_send( id
->srtp
, out
->p_buffer
, &len
, len
+ 10 );
1419 vlc_restorecancel (canc
);
1422 msg_Dbg( id
->p_stream
, "SRTP sending error: %s",
1423 vlc_strerror_c(val
) );
1424 block_Release( out
);
1428 out
->i_buffer
= len
;
1431 mwait (out
->i_dts
+ i_caching
);
1436 mwait (out
->i_dts
+ i_caching
);
1440 ssize_t len
= out
->i_buffer
;
1441 int canc
= vlc_savecancel ();
1443 vlc_mutex_lock( &id
->lock_sink
);
1444 unsigned deadc
= 0; /* How many dead sockets? */
1445 int deadv
[id
->sinkc
? id
->sinkc
: 1]; /* Dead sockets list */
1447 for( int i
= 0; i
< id
->sinkc
; i
++ )
1450 if( !id
->srtp
) /* FIXME: SRTCP support */
1452 SendRTCP( id
->sinkv
[i
].rtcp
, out
);
1454 if( send( id
->sinkv
[i
].rtp_fd
, out
->p_buffer
, len
, 0 ) == -1
1455 && net_errno
!= EAGAIN
&& net_errno
!= EWOULDBLOCK
1456 && net_errno
!= ENOBUFS
&& net_errno
!= ENOMEM
)
1459 getsockopt( id
->sinkv
[i
].rtp_fd
, SOL_SOCKET
, SO_TYPE
,
1460 &type
, &(socklen_t
){ sizeof(type
) });
1461 if( type
== SOCK_DGRAM
)
1462 /* ICMP soft error: ignore and retry */
1463 send( id
->sinkv
[i
].rtp_fd
, out
->p_buffer
, len
, 0 );
1465 /* Broken connection */
1466 deadv
[deadc
++] = id
->sinkv
[i
].rtp_fd
;
1469 id
->i_seq_sent_next
= ntohs(((uint16_t *) out
->p_buffer
)[1]) + 1;
1470 vlc_mutex_unlock( &id
->lock_sink
);
1471 block_Release( out
);
1473 for( unsigned i
= 0; i
< deadc
; i
++ )
1475 msg_Dbg( id
->p_stream
, "removing socket %d", deadv
[i
] );
1476 rtp_del_sink( id
, deadv
[i
] );
1478 vlc_restorecancel (canc
);
1484 /* This thread dequeues incoming connections (DCCP streaming) */
1485 static void *rtp_listen_thread( void *data
)
1487 sout_stream_id_sys_t
*id
= data
;
1489 assert( id
->listen
.fd
!= NULL
);
1493 int fd
= net_Accept( id
->p_stream
, id
->listen
.fd
);
1496 int canc
= vlc_savecancel( );
1497 rtp_add_sink( id
, fd
, true, NULL
);
1498 vlc_restorecancel( canc
);
1501 vlc_assert_unreachable();
1505 int rtp_add_sink( sout_stream_id_sys_t
*id
, int fd
, bool rtcp_mux
, uint16_t *seq
)
1507 rtp_sink_t sink
= { fd
, NULL
};
1508 sink
.rtcp
= OpenRTCP( VLC_OBJECT( id
->p_stream
), fd
, IPPROTO_UDP
,
1510 if( sink
.rtcp
== NULL
)
1511 msg_Err( id
->p_stream
, "RTCP failed!" );
1513 vlc_mutex_lock( &id
->lock_sink
);
1514 TAB_APPEND(id
->sinkc
, id
->sinkv
, sink
);
1516 *seq
= id
->i_seq_sent_next
;
1517 vlc_mutex_unlock( &id
->lock_sink
);
1521 void rtp_del_sink( sout_stream_id_sys_t
*id
, int fd
)
1523 rtp_sink_t sink
= { fd
, NULL
};
1525 /* NOTE: must be safe to use if fd is not included */
1526 vlc_mutex_lock( &id
->lock_sink
);
1527 for( int i
= 0; i
< id
->sinkc
; i
++ )
1529 if (id
->sinkv
[i
].rtp_fd
== fd
)
1531 sink
= id
->sinkv
[i
];
1532 TAB_ERASE(id
->sinkc
, id
->sinkv
, i
);
1536 vlc_mutex_unlock( &id
->lock_sink
);
1538 CloseRTCP( sink
.rtcp
);
1539 net_Close( sink
.rtp_fd
);
1542 uint16_t rtp_get_seq( sout_stream_id_sys_t
*id
)
1544 /* This will return values for the next packet. */
1547 vlc_mutex_lock( &id
->lock_sink
);
1548 seq
= id
->i_seq_sent_next
;
1549 vlc_mutex_unlock( &id
->lock_sink
);
1554 /* Return an arbitrary initial timestamp for RTP timestamp computations.
1555 * RFC 3550 states that the resulting initial RTP timestamps SHOULD be
1556 * random (although we use the same reference for all the ES as a
1557 * feature). In the VoD case, this function is called independently
1558 * from several parts of the code, so we need to always return the same
1560 static int64_t rtp_init_ts( const vod_media_t
*p_media
,
1561 const char *psz_vod_session
)
1563 if (p_media
== NULL
|| psz_vod_session
== NULL
)
1567 /* As per RFC 2326, session identifiers are at least 8 bytes long */
1568 strncpy((char *)&i_ts_init
, psz_vod_session
, sizeof(uint64_t));
1569 i_ts_init
^= (uintptr_t)p_media
;
1570 /* Limit the timestamp to 48 bits, this is enough and allows us
1571 * to stay away from overflows */
1572 i_ts_init
&= 0xFFFFFFFFFFFF;
1576 /* Return a timestamp corresponding to packets being sent now, and that
1577 * can be passed to rtp_compute_ts() to get rtptime values for each ES.
1578 * Also return the NPT corresponding to this timestamp. If the stream
1579 * output is not started, the initial timestamp that will be used with
1580 * the first packets for NPT=0 is returned instead. */
1581 int64_t rtp_get_ts( const sout_stream_t
*p_stream
, const sout_stream_id_sys_t
*id
,
1582 const vod_media_t
*p_media
, const char *psz_vod_session
,
1589 p_stream
= id
->p_stream
;
1591 if (p_stream
== NULL
)
1592 return rtp_init_ts(p_media
, psz_vod_session
);
1594 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1596 vlc_mutex_lock( &p_sys
->lock_ts
);
1597 i_npt_zero
= p_sys
->i_npt_zero
;
1598 vlc_mutex_unlock( &p_sys
->lock_ts
);
1600 if( i_npt_zero
== VLC_TS_INVALID
)
1601 return p_sys
->i_pts_zero
;
1603 mtime_t now
= mdate();
1604 if( now
< i_npt_zero
)
1605 return p_sys
->i_pts_zero
;
1607 int64_t npt
= now
- i_npt_zero
;
1611 return p_sys
->i_pts_zero
+ npt
;
1614 void rtp_packetize_common( sout_stream_id_sys_t
*id
, block_t
*out
,
1615 bool b_m_bit
, int64_t i_pts
)
1617 if( !id
->b_ts_init
)
1619 sout_stream_sys_t
*p_sys
= id
->p_stream
->p_sys
;
1620 vlc_mutex_lock( &p_sys
->lock_ts
);
1621 if( p_sys
->i_npt_zero
== VLC_TS_INVALID
)
1623 /* This is the first packet of any ES. We initialize the
1624 * NPT=0 time reference, and the offset to match the
1625 * arbitrary PTS reference. */
1626 p_sys
->i_npt_zero
= i_pts
+ id
->i_caching
;
1627 p_sys
->i_pts_offset
= p_sys
->i_pts_zero
- i_pts
;
1629 vlc_mutex_unlock( &p_sys
->lock_ts
);
1631 /* And in any case this is the first packet of this ES, so we
1632 * initialize the offset for this ES. */
1633 id
->i_ts_offset
= rtp_compute_ts( id
->rtp_fmt
.clock_rate
,
1634 p_sys
->i_pts_offset
);
1635 id
->b_ts_init
= true;
1638 uint32_t i_timestamp
= rtp_compute_ts( id
->rtp_fmt
.clock_rate
, i_pts
)
1641 out
->p_buffer
[0] = 0x80;
1642 out
->p_buffer
[1] = (b_m_bit
?0x80:0x00)|id
->rtp_fmt
.payload_type
;
1643 out
->p_buffer
[2] = ( id
->i_sequence
>> 8)&0xff;
1644 out
->p_buffer
[3] = ( id
->i_sequence
)&0xff;
1645 out
->p_buffer
[4] = ( i_timestamp
>> 24 )&0xff;
1646 out
->p_buffer
[5] = ( i_timestamp
>> 16 )&0xff;
1647 out
->p_buffer
[6] = ( i_timestamp
>> 8 )&0xff;
1648 out
->p_buffer
[7] = ( i_timestamp
)&0xff;
1650 memcpy( out
->p_buffer
+ 8, id
->ssrc
, 4 );
1655 uint16_t rtp_get_extended_sequence( sout_stream_id_sys_t
*id
)
1657 return id
->i_sequence
>> 16;
1660 void rtp_packetize_send( sout_stream_id_sys_t
*id
, block_t
*out
)
1662 block_FifoPut( id
->p_fifo
, out
);
1666 * @return configured max RTP payload size (including payload type-specific
1667 * headers, excluding RTP and transport headers)
1669 size_t rtp_mtu (const sout_stream_id_sys_t
*id
)
1671 return id
->i_mtu
- 12;
1674 /*****************************************************************************
1676 *****************************************************************************/
1678 /** Add an ES to a non-RTP muxed stream */
1679 static sout_stream_id_sys_t
*MuxAdd( sout_stream_t
*p_stream
,
1680 const es_format_t
*p_fmt
)
1682 sout_input_t
*p_input
;
1683 sout_mux_t
*p_mux
= p_stream
->p_sys
->p_mux
;
1684 assert( p_mux
!= NULL
);
1686 p_input
= sout_MuxAddStream( p_mux
, p_fmt
);
1687 if( p_input
== NULL
)
1689 msg_Err( p_stream
, "cannot add this stream to the muxer" );
1693 return (sout_stream_id_sys_t
*)p_input
;
1697 static int MuxSend( sout_stream_t
*p_stream
, sout_stream_id_sys_t
*id
,
1700 sout_mux_t
*p_mux
= p_stream
->p_sys
->p_mux
;
1701 assert( p_mux
!= NULL
);
1703 return sout_MuxSendBuffer( p_mux
, (sout_input_t
*)id
, p_buffer
);
1707 /** Remove an ES from a non-RTP muxed stream */
1708 static void MuxDel( sout_stream_t
*p_stream
, sout_stream_id_sys_t
*id
)
1710 sout_mux_t
*p_mux
= p_stream
->p_sys
->p_mux
;
1711 assert( p_mux
!= NULL
);
1713 sout_MuxDeleteStream( p_mux
, (sout_input_t
*)id
);
1717 static ssize_t
AccessOutGrabberWriteBuffer( sout_stream_t
*p_stream
,
1718 const block_t
*p_buffer
)
1720 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1721 sout_stream_id_sys_t
*id
= p_sys
->es
[0];
1723 int64_t i_dts
= p_buffer
->i_dts
;
1725 uint8_t *p_data
= p_buffer
->p_buffer
;
1726 size_t i_data
= p_buffer
->i_buffer
;
1727 size_t i_max
= id
->i_mtu
- 12;
1728 bool b_dis
= (p_buffer
->i_flags
& BLOCK_FLAG_DISCONTINUITY
);
1730 size_t i_packet
= ( p_buffer
->i_buffer
+ i_max
- 1 ) / i_max
;
1736 /* output complete packet */
1737 if( p_sys
->packet
&&
1738 p_sys
->packet
->i_buffer
+ i_data
> i_max
)
1740 rtp_packetize_send( id
, p_sys
->packet
);
1741 p_sys
->packet
= NULL
;
1744 if( p_sys
->packet
== NULL
)
1746 /* allocate a new packet */
1747 p_sys
->packet
= block_Alloc( id
->i_mtu
);
1748 /* m-bit is discontinuity for MPEG1/2 PS and TS, RFC2250 2.1 */
1749 rtp_packetize_common( id
, p_sys
->packet
, b_dis
, i_dts
);
1750 p_sys
->packet
->i_buffer
= 12;
1751 p_sys
->packet
->i_dts
= i_dts
;
1752 p_sys
->packet
->i_length
= p_buffer
->i_length
/ i_packet
;
1753 i_dts
+= p_sys
->packet
->i_length
;
1757 i_size
= __MIN( i_data
,
1758 (unsigned)(id
->i_mtu
- p_sys
->packet
->i_buffer
) );
1760 memcpy( &p_sys
->packet
->p_buffer
[p_sys
->packet
->i_buffer
],
1763 p_sys
->packet
->i_buffer
+= i_size
;
1772 static ssize_t
AccessOutGrabberWrite( sout_access_out_t
*p_access
,
1775 sout_stream_t
*p_stream
= (sout_stream_t
*)p_access
->p_sys
;
1781 AccessOutGrabberWriteBuffer( p_stream
, p_buffer
);
1783 p_next
= p_buffer
->p_next
;
1784 block_Release( p_buffer
);
1792 static sout_access_out_t
*GrabberCreate( sout_stream_t
*p_stream
)
1794 sout_access_out_t
*p_grab
;
1796 p_grab
= vlc_object_create( p_stream
, sizeof( *p_grab
) );
1797 if( p_grab
== NULL
)
1800 p_grab
->p_module
= NULL
;
1801 p_grab
->psz_access
= strdup( "grab" );
1802 p_grab
->p_cfg
= NULL
;
1803 p_grab
->psz_path
= strdup( "" );
1804 p_grab
->p_sys
= (sout_access_out_sys_t
*)p_stream
;
1805 p_grab
->pf_seek
= NULL
;
1806 p_grab
->pf_write
= AccessOutGrabberWrite
;
1810 void rtp_get_video_geometry( sout_stream_id_sys_t
*id
, int *width
, int *height
)
1812 int ret
= sscanf( id
->rtp_fmt
.fmtp
, "%*s width=%d; height=%d; ", width
, height
);