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 output", 0 )
190 add_shortcut( "rtp" )
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 /*****************************************************************************
245 * Exported prototypes
246 *****************************************************************************/
247 static const char *const ppsz_sout_options
[] = {
248 "dst", "name", "cat", "port", "port-audio", "port-video", "*sdp", "ttl",
249 "mux", "sap", "description", "url", "email",
250 "proto", "rtcp-mux", "caching",
257 static void *Add( sout_stream_t
*, const es_format_t
* );
258 static void Del( sout_stream_t
*, void * );
259 static int Send( sout_stream_t
*, void *, block_t
* );
261 static void *MuxAdd( sout_stream_t
*, const es_format_t
* );
262 static void MuxDel( sout_stream_t
*, void * );
263 static int MuxSend( sout_stream_t
*, void *, block_t
* );
265 static sout_access_out_t
*GrabberCreate( sout_stream_t
*p_sout
);
266 static void* ThreadSend( void * );
267 static void *rtp_listen_thread( void * );
269 static void SDPHandleUrl( sout_stream_t
*, const char * );
271 static int SapSetup( sout_stream_t
*p_stream
);
272 static int FileSetup( sout_stream_t
*p_stream
);
273 static int HttpSetup( sout_stream_t
*p_stream
, const vlc_url_t
* );
279 vlc_mutex_t lock_sdp
;
286 session_descriptor_t
*p_session
;
289 httpd_host_t
*p_httpd_host
;
290 httpd_file_t
*p_httpd_file
;
295 /* RTSP NPT and timestamp computations */
296 vlc_tick_t i_npt_zero
; /* when NPT=0 packet is sent */
297 vlc_tick_t i_pts_zero
; /* predicts PTS of NPT=0 packet */
298 vlc_tick_t i_pts_offset
; /* matches actual PTS to prediction */
302 char *psz_destination
;
304 uint16_t i_port_audio
;
305 uint16_t i_port_video
;
310 /* in case we do TS/PS over rtp */
312 sout_access_out_t
*p_grab
;
318 sout_stream_id_sys_t
**es
;
321 typedef struct rtp_sink_t
327 struct sout_stream_id_sys_t
329 sout_stream_t
*p_stream
;
331 /* For RFC 4175, seqnum is extended to 32-bits */
335 uint32_t i_ts_offset
;
339 uint16_t i_seq_sent_next
;
342 rtp_format_t rtp_fmt
;
345 /* Packetizer specific fields */
348 srtp_session_t
*srtp
;
353 vlc_mutex_t lock_sink
;
356 rtsp_stream_id_t
*rtsp_id
;
362 block_fifo_t
*p_fifo
;
363 vlc_tick_t i_caching
;
366 /*****************************************************************************
368 *****************************************************************************/
369 static int Open( vlc_object_t
*p_this
)
371 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
372 sout_stream_sys_t
*p_sys
= NULL
;
376 config_ChainParse( p_stream
, SOUT_CFG_PREFIX
,
377 ppsz_sout_options
, p_stream
->p_cfg
);
379 p_sys
= malloc( sizeof( sout_stream_sys_t
) );
383 p_sys
->psz_destination
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"dst" );
385 p_sys
->i_port
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port" );
386 p_sys
->i_port_audio
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port-audio" );
387 p_sys
->i_port_video
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port-video" );
388 p_sys
->rtcp_mux
= var_GetBool( p_stream
, SOUT_CFG_PREFIX
"rtcp-mux" );
390 if( p_sys
->i_port_audio
&& p_sys
->i_port_video
== p_sys
->i_port_audio
)
392 msg_Err( p_stream
, "audio and video RTP port must be distinct" );
393 free( p_sys
->psz_destination
);
398 for( config_chain_t
*p_cfg
= p_stream
->p_cfg
; p_cfg
!= NULL
; p_cfg
= p_cfg
->p_next
)
400 if( !strcmp( p_cfg
->psz_name
, "sdp" )
401 && ( p_cfg
->psz_value
!= NULL
)
402 && !strncasecmp( p_cfg
->psz_value
, "rtsp:", 5 ) )
410 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"sdp" );
413 if( !strncasecmp( psz
, "rtsp:", 5 ) )
419 /* Transport protocol */
420 p_sys
->proto
= IPPROTO_UDP
;
421 psz
= var_GetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"proto");
423 if ((psz
== NULL
) || !strcasecmp (psz
, "udp"))
424 (void)0; /* default */
426 if (!strcasecmp (psz
, "dccp"))
428 p_sys
->proto
= IPPROTO_DCCP
;
429 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
433 if (!strcasecmp (psz
, "sctp"))
435 p_sys
->proto
= IPPROTO_TCP
;
436 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
441 if (!strcasecmp (psz
, "tcp"))
443 p_sys
->proto
= IPPROTO_TCP
;
444 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
448 if (!strcasecmp (psz
, "udplite") || !strcasecmp (psz
, "udp-lite"))
449 p_sys
->proto
= IPPROTO_UDPLITE
;
451 msg_Warn (p_this
, "unknown or unsupported transport protocol \"%s\"",
454 var_Create (p_this
, "dccp-service", VLC_VAR_STRING
);
456 if( p_sys
->psz_destination
== NULL
&& !b_rtsp
)
458 msg_Err( p_stream
, "missing destination and not in RTSP mode" );
463 int i_ttl
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"ttl" );
466 var_Create( p_stream
, "ttl", VLC_VAR_INTEGER
);
467 var_SetInteger( p_stream
, "ttl", i_ttl
);
470 p_sys
->b_latm
= var_GetBool( p_stream
, SOUT_CFG_PREFIX
"mp4a-latm" );
472 /* NPT=0 time will be determined when we packetize the first packet
473 * (of any ES). But we want to be able to report rtptime in RTSP
474 * without waiting. So until then,
475 * we use an arbitrary reference PTS for timestamp computations, and
476 * then actual PTS will catch up using offsets. */
477 p_sys
->i_npt_zero
= VLC_TICK_INVALID
;
478 p_sys
->i_pts_zero
= vlc_tick_now();
482 p_sys
->psz_sdp
= NULL
;
484 p_sys
->b_export_sap
= false;
485 p_sys
->p_session
= NULL
;
486 p_sys
->psz_sdp_file
= NULL
;
488 p_sys
->p_httpd_host
= NULL
;
489 p_sys
->p_httpd_file
= NULL
;
491 p_stream
->p_sys
= p_sys
;
493 vlc_mutex_init( &p_sys
->lock_sdp
);
494 vlc_mutex_init( &p_sys
->lock_ts
);
495 vlc_mutex_init( &p_sys
->lock_es
);
497 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"mux" );
500 /* Check muxer type */
501 if( strncasecmp( psz
, "ps", 2 )
502 && strncasecmp( psz
, "mpeg1", 5 )
503 && strncasecmp( psz
, "ts", 2 ) )
505 msg_Err( p_stream
, "unsupported muxer type for RTP (only TS/PS)" );
507 free( p_sys
->psz_destination
);
512 p_sys
->p_grab
= GrabberCreate( p_stream
);
513 p_sys
->p_mux
= sout_MuxNew( p_sys
->p_grab
, psz
);
516 if( p_sys
->p_mux
== NULL
)
518 msg_Err( p_stream
, "cannot create muxer" );
519 sout_AccessOutDelete( p_sys
->p_grab
);
520 free( p_sys
->psz_destination
);
525 p_sys
->packet
= NULL
;
527 p_stream
->pf_add
= MuxAdd
;
528 p_stream
->pf_del
= MuxDel
;
529 p_stream
->pf_send
= MuxSend
;
534 p_sys
->p_grab
= NULL
;
536 p_stream
->pf_add
= Add
;
537 p_stream
->pf_del
= Del
;
538 p_stream
->pf_send
= Send
;
540 p_stream
->pace_nocontrol
= true;
542 if( var_GetBool( p_stream
, SOUT_CFG_PREFIX
"sap" ) )
543 SDPHandleUrl( p_stream
, "sap://" );
545 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"sdp" );
548 config_chain_t
*p_cfg
;
550 SDPHandleUrl( p_stream
, psz
);
552 for( p_cfg
= p_stream
->p_cfg
; p_cfg
!= NULL
; p_cfg
= p_cfg
->p_next
)
554 if( !strcmp( p_cfg
->psz_name
, "sdp" ) )
556 if( p_cfg
->psz_value
== NULL
|| *p_cfg
->psz_value
== '\0' )
559 /* needed both :sout-rtp-sdp= and rtp{sdp=} can be used */
560 if( !strcmp( p_cfg
->psz_value
, psz
) )
563 SDPHandleUrl( p_stream
, p_cfg
->psz_value
);
569 if( p_sys
->p_mux
!= NULL
)
571 sout_stream_id_sys_t
*id
= Add( p_stream
, NULL
);
582 /*****************************************************************************
584 *****************************************************************************/
585 static void Close( vlc_object_t
* p_this
)
587 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
588 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
592 assert( p_sys
->i_es
<= 1 );
594 sout_MuxDelete( p_sys
->p_mux
);
595 if ( p_sys
->i_es
> 0 )
596 Del( p_stream
, p_sys
->es
[0] );
597 sout_AccessOutDelete( p_sys
->p_grab
);
601 block_Release( p_sys
->packet
);
605 if( p_sys
->rtsp
!= NULL
)
606 RtspUnsetup( p_sys
->rtsp
);
608 if( p_sys
->p_httpd_file
)
609 httpd_FileDelete( p_sys
->p_httpd_file
);
611 if( p_sys
->p_httpd_host
)
612 httpd_HostDelete( p_sys
->p_httpd_host
);
614 free( p_sys
->psz_sdp
);
616 if( p_sys
->psz_sdp_file
!= NULL
)
618 unlink( p_sys
->psz_sdp_file
);
619 free( p_sys
->psz_sdp_file
);
621 free( p_sys
->psz_destination
);
625 /*****************************************************************************
627 *****************************************************************************/
628 static void SDPHandleUrl( sout_stream_t
*p_stream
, const char *psz_url
)
630 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
633 vlc_UrlParse( &url
, psz_url
);
634 if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "http" ) )
636 if( p_sys
->p_httpd_file
)
638 msg_Err( p_stream
, "you can use sdp=http:// only once" );
642 if( HttpSetup( p_stream
, &url
) )
644 msg_Err( p_stream
, "cannot export SDP as HTTP" );
647 else if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "rtsp" ) )
649 if( p_sys
->rtsp
!= NULL
)
651 msg_Err( p_stream
, "you can use sdp=rtsp:// only once" );
655 if( url
.psz_host
!= NULL
&& *url
.psz_host
)
657 msg_Warn( p_stream
, "\"%s\" RTSP host might be ignored in "
658 "multiple-host configurations, use at your own risks.",
660 msg_Info( p_stream
, "Consider passing --rtsp-host=IP on the "
661 "command line instead." );
663 var_Create( p_stream
, "rtsp-host", VLC_VAR_STRING
);
664 var_SetString( p_stream
, "rtsp-host", url
.psz_host
);
666 if( url
.i_port
!= 0 )
668 /* msg_Info( p_stream, "Consider passing --rtsp-port=%u on "
669 "the command line instead.", url.i_port ); */
671 var_Create( p_stream
, "rtsp-port", VLC_VAR_INTEGER
);
672 var_SetInteger( p_stream
, "rtsp-port", url
.i_port
);
675 p_sys
->rtsp
= RtspSetup( VLC_OBJECT(p_stream
), url
.psz_path
);
676 if( p_sys
->rtsp
== NULL
)
677 msg_Err( p_stream
, "cannot export SDP as RTSP" );
679 else if( ( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "sap" ) ) ||
680 ( url
.psz_host
&& !strcasecmp( url
.psz_host
, "sap" ) ) )
682 p_sys
->b_export_sap
= true;
683 SapSetup( p_stream
);
685 else if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "file" ) )
687 if( p_sys
->psz_sdp_file
!= NULL
)
689 msg_Err( p_stream
, "you can use sdp=file:// only once" );
692 p_sys
->psz_sdp_file
= vlc_uri2path( psz_url
);
693 if( p_sys
->psz_sdp_file
== NULL
)
695 FileSetup( p_stream
);
699 msg_Warn( p_stream
, "unknown protocol for SDP (%s)",
704 vlc_UrlClean( &url
);
707 /*****************************************************************************
709 *****************************************************************************/
711 char *SDPGenerate( sout_stream_t
*p_stream
, const char *rtsp_url
)
713 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
714 struct vlc_memstream sdp
;
715 struct sockaddr_storage dst
;
716 char *psz_sdp
= NULL
;
720 * When we have a fixed destination (typically when we do multicast),
721 * we need to put the actual port numbers in the SDP.
722 * When there is no fixed destination, we only support RTSP unicast
723 * on-demand setup, so we should rather let the clients decide which ports
725 * When there is both a fixed destination and RTSP unicast, we need to
726 * put port numbers used by the fixed destination, otherwise the SDP would
727 * become totally incorrect for multicast use. It should be noted that
728 * port numbers from SDP with RTSP are only "recommendation" from the
729 * server to the clients (per RFC2326), so only broken clients will fail
730 * to handle this properly. There is no solution but to use two differents
731 * output chain with two different RTSP URLs if you need to handle this
736 vlc_mutex_lock( &p_sys
->lock_es
);
737 if( unlikely(p_sys
->i_es
== 0 || (rtsp_url
!= NULL
&& !p_sys
->es
[0]->rtsp_id
)) )
738 goto out
; /* hmm... */
740 if( p_sys
->psz_destination
!= NULL
)
744 /* Oh boy, this is really ugly! */
745 dstlen
= sizeof( dst
);
746 if( p_sys
->es
[0]->listen
.fd
!= NULL
)
747 getsockname( p_sys
->es
[0]->listen
.fd
[0],
748 (struct sockaddr
*)&dst
, &dstlen
);
750 getpeername( p_sys
->es
[0]->sinkv
[0].rtp_fd
,
751 (struct sockaddr
*)&dst
, &dstlen
);
757 /* Check against URL format rtsp://[<ipv6>]:<port>/<path> */
758 bool ipv6
= rtsp_url
!= NULL
&& strlen( rtsp_url
) > 7
759 && rtsp_url
[7] == '[';
761 /* Dummy destination address for RTSP */
762 dstlen
= ipv6
? sizeof( struct sockaddr_in6
)
763 : sizeof( struct sockaddr_in
);
764 memset (&dst
, 0, dstlen
);
765 dst
.ss_family
= ipv6
? AF_INET6
: AF_INET
;
771 if( vlc_sdp_Start( &sdp
, VLC_OBJECT( p_stream
), SOUT_CFG_PREFIX
,
772 NULL
, 0, (struct sockaddr
*)&dst
, dstlen
) )
775 /* TODO: a=source-filter */
776 if( p_sys
->rtcp_mux
)
777 sdp_AddAttribute( &sdp
, "rtcp-mux", NULL
);
779 if( rtsp_url
!= NULL
)
780 sdp_AddAttribute ( &sdp
, "control", "%s", rtsp_url
);
782 const char *proto
= "RTP/AVP"; /* protocol */
783 if( rtsp_url
== NULL
)
785 switch( p_sys
->proto
)
790 proto
= "TCP/RTP/AVP";
793 proto
= "DCCP/RTP/AVP";
795 case IPPROTO_UDPLITE
:
800 for( i
= 0; i
< p_sys
->i_es
; i
++ )
802 sout_stream_id_sys_t
*id
= p_sys
->es
[i
];
803 rtp_format_t
*rtp_fmt
= &id
->rtp_fmt
;
804 const char *mime_major
; /* major MIME type */
806 switch( rtp_fmt
->cat
)
809 mime_major
= "video";
812 mime_major
= "audio";
821 sdp_AddMedia( &sdp
, mime_major
, proto
, inclport
* id
->i_port
,
822 rtp_fmt
->payload_type
, false, rtp_fmt
->bitrate
,
823 rtp_fmt
->ptname
, rtp_fmt
->clock_rate
, rtp_fmt
->channels
,
826 /* cf RFC4566 §5.14 */
827 if( inclport
&& !p_sys
->rtcp_mux
&& (id
->i_port
& 1) )
828 sdp_AddAttribute( &sdp
, "rtcp", "%u", id
->i_port
+ 1 );
830 if( rtsp_url
!= NULL
)
832 char *track_url
= RtspAppendTrackPath( id
->rtsp_id
, rtsp_url
);
833 if( track_url
!= NULL
)
835 sdp_AddAttribute( &sdp
, "control", "%s", track_url
);
841 if( id
->listen
.fd
!= NULL
)
842 sdp_AddAttribute( &sdp
, "setup", "passive" );
843 if( p_sys
->proto
== IPPROTO_DCCP
)
844 sdp_AddAttribute( &sdp
, "dccp-service-code", "SC:RTP%c",
845 toupper( (unsigned char)mime_major
[0] ) );
849 if( vlc_memstream_close( &sdp
) == 0 )
852 vlc_mutex_unlock( &p_sys
->lock_es
);
856 /*****************************************************************************
858 *****************************************************************************/
861 * Shrink the MTU down to a fixed packetization time (for audio).
864 rtp_set_ptime (sout_stream_id_sys_t
*id
, unsigned ptime_ms
, size_t bytes
)
866 /* Samples per second */
867 size_t spl
= (id
->rtp_fmt
.clock_rate
- 1) * ptime_ms
/ 1000 + 1;
868 bytes
*= id
->rtp_fmt
.channels
;
871 if (spl
< rtp_mtu (id
)) /* MTU is big enough for ptime */
872 id
->i_mtu
= 12 + spl
;
873 else /* MTU is too small for ptime, align to a sample boundary */
874 id
->i_mtu
= 12 + (((id
->i_mtu
- 12) / bytes
) * bytes
);
877 uint32_t rtp_compute_ts( unsigned i_clock_rate
, vlc_tick_t i_pts
)
879 /* This is an overflow-proof way of doing:
880 * return i_pts * (int64_t)i_clock_rate / CLOCK_FREQ;
882 * NOTE: this plays nice with offsets because the (equivalent)
883 * calculations are linear. */
884 lldiv_t q
= lldiv(i_pts
, CLOCK_FREQ
);
885 return q
.quot
* (int64_t)i_clock_rate
886 + q
.rem
* (int64_t)i_clock_rate
/ CLOCK_FREQ
;
889 /** Add an ES as a new RTP stream */
890 static void *Add( sout_stream_t
*p_stream
, const es_format_t
*p_fmt
)
892 /* NOTE: As a special case, if we use a non-RTP
893 * mux (TS/PS), then p_fmt is NULL. */
894 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
897 sout_stream_id_sys_t
*id
= malloc( sizeof( *id
) );
898 if( unlikely(id
== NULL
) )
900 id
->p_stream
= p_stream
;
902 id
->i_mtu
= var_InheritInteger( p_stream
, "mtu" );
903 if( id
->i_mtu
<= 12 + 16 )
904 id
->i_mtu
= 576 - 20 - 8; /* pessimistic */
905 msg_Dbg( p_stream
, "maximum RTP packet size: %d bytes", id
->i_mtu
);
910 vlc_mutex_init( &id
->lock_sink
);
915 id
->listen
.fd
= NULL
;
917 id
->b_first_packet
= true;
919 VLC_TICK_FROM_MS(var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"caching"));
921 vlc_rand_bytes (&id
->i_sequence
, sizeof (id
->i_sequence
));
922 vlc_rand_bytes (id
->ssrc
, sizeof (id
->ssrc
));
928 id
->rtp_fmt
.fmtp
= NULL
; /* don't free() garbage on error */
929 char *psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"mux" );
930 if (p_fmt
== NULL
&& psz
== NULL
)
932 int val
= rtp_get_fmt(VLC_OBJECT(p_stream
), p_fmt
, psz
, &id
->rtp_fmt
);
934 if (val
!= VLC_SUCCESS
)
939 char *key
= var_GetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"key");
943 id
->srtp
= srtp_create (SRTP_ENCR_AES_CM
, SRTP_AUTH_HMAC_SHA1
, 10,
944 SRTP_PRF_AES_CM
, SRTP_RCC_MODE1
);
945 if (id
->srtp
== NULL
)
951 char *salt
= var_GetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"salt");
952 int val
= srtp_setkeystring (id
->srtp
, key
, salt
? salt
: "");
957 msg_Err (p_stream
, "bad SRTP key/salt combination (%s)",
958 vlc_strerror_c(val
));
961 id
->i_sequence
= 0; /* FIXME: awful hack for libvlc_srtp */
965 id
->i_seq_sent_next
= id
->i_sequence
;
968 if( p_sys
->psz_destination
!= NULL
)
970 /* Choose the port */
975 if( p_fmt
->i_cat
== AUDIO_ES
&& p_sys
->i_port_audio
> 0 )
976 i_port
= p_sys
->i_port_audio
;
978 if( p_fmt
->i_cat
== VIDEO_ES
&& p_sys
->i_port_video
> 0 )
979 i_port
= p_sys
->i_port_video
;
981 /* We do not need the ES lock (p_sys->lock_es) here, because
982 * this is the only one thread that can *modify* the ES table.
983 * The ES lock protects the other threads from our modifications
984 * (TAB_APPEND, TAB_REMOVE). */
985 for (int i
= 0; i_port
&& (i
< p_sys
->i_es
); i
++)
986 if (i_port
== p_sys
->es
[i
]->i_port
)
987 i_port
= 0; /* Port already in use! */
988 for (uint16_t p
= p_sys
->i_port
; i_port
== 0; p
+= 2)
992 msg_Err (p_stream
, "too many RTP elementary streams");
996 for (int i
= 0; i_port
&& (i
< p_sys
->i_es
); i
++)
997 if (p
== p_sys
->es
[i
]->i_port
)
1001 id
->i_port
= i_port
;
1003 int type
= SOCK_STREAM
;
1005 switch( p_sys
->proto
)
1011 switch (id
->rtp_fmt
.cat
)
1013 case VIDEO_ES
: code
= "RTPV"; break;
1014 case AUDIO_ES
: code
= "RTPARTPV"; break;
1015 case SPU_ES
: code
= "RTPTRTPV"; break;
1016 default: code
= "RTPORTPV"; break;
1018 var_SetString (p_stream
, "dccp-service", code
);
1024 id
->listen
.fd
= net_Listen( VLC_OBJECT(p_stream
),
1025 p_sys
->psz_destination
, i_port
,
1026 type
, p_sys
->proto
);
1027 if( id
->listen
.fd
== NULL
)
1029 msg_Err( p_stream
, "passive COMEDIA RTP socket failed" );
1032 if( vlc_clone( &id
->listen
.thread
, rtp_listen_thread
, id
,
1033 VLC_THREAD_PRIORITY_LOW
) )
1035 net_ListenClose( id
->listen
.fd
);
1036 id
->listen
.fd
= NULL
;
1043 int fd
= net_ConnectDgram( p_stream
, p_sys
->psz_destination
,
1044 i_port
, -1, p_sys
->proto
);
1047 msg_Err( p_stream
, "cannot create RTP socket" );
1050 /* Ignore any unexpected incoming packet (including RTCP-RR
1051 * packets in case of rtcp-mux) */
1052 setsockopt (fd
, SOL_SOCKET
, SO_RCVBUF
, &(int){ 0 },
1054 rtp_add_sink( id
, fd
, p_sys
->rtcp_mux
, NULL
);
1055 /* FIXME: test if this is multicast */
1062 switch( p_fmt
->i_codec
)
1064 case VLC_CODEC_MULAW
:
1065 case VLC_CODEC_ALAW
:
1067 rtp_set_ptime (id
, 20, 1);
1069 case VLC_CODEC_S16B
:
1070 case VLC_CODEC_S16L
:
1071 rtp_set_ptime (id
, 20, 2);
1073 case VLC_CODEC_S24B
:
1074 rtp_set_ptime (id
, 20, 3);
1080 #if 0 /* No payload formats sets this at the moment */
1083 cscov
+= 8 /* UDP */ + 12 /* RTP */;
1085 net_SetCSCov( id
->sinkv
[0].rtp_fd
, cscov
, -1 );
1088 vlc_mutex_lock( &p_sys
->lock_ts
);
1089 id
->b_ts_init
= ( p_sys
->i_npt_zero
!= VLC_TICK_INVALID
);
1090 vlc_mutex_unlock( &p_sys
->lock_ts
);
1092 id
->i_ts_offset
= rtp_compute_ts( id
->rtp_fmt
.clock_rate
,
1093 p_sys
->i_pts_offset
);
1095 if( p_sys
->rtsp
!= NULL
)
1096 id
->rtsp_id
= RtspAddId( p_sys
->rtsp
, id
, GetDWBE( id
->ssrc
),
1097 id
->rtp_fmt
.clock_rate
, mcast_fd
);
1099 id
->p_fifo
= block_FifoNew();
1100 if( unlikely(id
->p_fifo
== NULL
) )
1102 if( vlc_clone( &id
->thread
, ThreadSend
, id
, VLC_THREAD_PRIORITY_HIGHEST
) )
1104 block_FifoRelease( id
->p_fifo
);
1109 /* Update p_sys context */
1110 vlc_mutex_lock( &p_sys
->lock_es
);
1111 TAB_APPEND( p_sys
->i_es
, p_sys
->es
, id
);
1112 vlc_mutex_unlock( &p_sys
->lock_es
);
1114 psz_sdp
= SDPGenerate( p_stream
, NULL
);
1116 vlc_mutex_lock( &p_sys
->lock_sdp
);
1117 free( p_sys
->psz_sdp
);
1118 p_sys
->psz_sdp
= psz_sdp
;
1119 vlc_mutex_unlock( &p_sys
->lock_sdp
);
1121 msg_Dbg( p_stream
, "sdp=\n%s", p_sys
->psz_sdp
);
1123 /* Update SDP (sap/file) */
1124 if( p_sys
->b_export_sap
) SapSetup( p_stream
);
1125 if( p_sys
->psz_sdp_file
!= NULL
) FileSetup( p_stream
);
1130 Del( p_stream
, id
);
1134 static void Del( sout_stream_t
*p_stream
, void *_id
)
1136 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1137 sout_stream_id_sys_t
*id
= (sout_stream_id_sys_t
*)_id
;
1139 vlc_mutex_lock( &p_sys
->lock_es
);
1140 TAB_REMOVE( p_sys
->i_es
, p_sys
->es
, id
);
1141 vlc_mutex_unlock( &p_sys
->lock_es
);
1143 if( likely(id
->p_fifo
!= NULL
) )
1145 vlc_cancel( id
->thread
);
1146 vlc_join( id
->thread
, NULL
);
1147 block_FifoRelease( id
->p_fifo
);
1150 free( id
->rtp_fmt
.fmtp
);
1153 RtspDelId( p_sys
->rtsp
, id
->rtsp_id
);
1154 if( id
->listen
.fd
!= NULL
)
1156 vlc_cancel( id
->listen
.thread
);
1157 vlc_join( id
->listen
.thread
, NULL
);
1158 net_ListenClose( id
->listen
.fd
);
1160 /* Delete remaining sinks (incoming connections or explicit
1162 while( id
->sinkc
> 0 )
1163 rtp_del_sink( id
, id
->sinkv
[0].rtp_fd
);
1165 if( id
->srtp
!= NULL
)
1166 srtp_destroy( id
->srtp
);
1169 /* Update SDP (sap/file) */
1170 if( p_sys
->b_export_sap
) SapSetup( p_stream
);
1171 if( p_sys
->psz_sdp_file
!= NULL
) FileSetup( p_stream
);
1176 static int Send( sout_stream_t
*p_stream
, void *_id
, block_t
*p_buffer
)
1178 sout_stream_id_sys_t
*id
= (sout_stream_id_sys_t
*)_id
;
1179 assert( ((sout_stream_sys_t
*)p_stream
->p_sys
)->p_mux
== NULL
);
1181 while( p_buffer
!= NULL
)
1183 block_t
*p_next
= p_buffer
->p_next
;
1184 p_buffer
->p_next
= NULL
;
1186 /* Send a Vorbis/Theora Packed Configuration packet (RFC 5215 §3.1)
1187 * as the first packet of the stream */
1188 if (id
->b_first_packet
)
1190 id
->b_first_packet
= false;
1191 if (!strcmp(id
->rtp_fmt
.ptname
, "vorbis") ||
1192 !strcmp(id
->rtp_fmt
.ptname
, "theora"))
1193 rtp_packetize_xiph_config(id
, id
->rtp_fmt
.fmtp
,
1197 if( id
->rtp_fmt
.pf_packetize( id
, p_buffer
) )
1205 /****************************************************************************
1207 ****************************************************************************/
1208 static int SapSetup( sout_stream_t
*p_stream
)
1210 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1212 /* Remove the previous session */
1213 if( p_sys
->p_session
!= NULL
)
1215 sout_AnnounceUnRegister( p_stream
, p_sys
->p_session
);
1216 p_sys
->p_session
= NULL
;
1219 if( p_sys
->i_es
> 0 && p_sys
->psz_sdp
&& *p_sys
->psz_sdp
)
1220 p_sys
->p_session
= sout_AnnounceRegisterSDP( p_stream
,
1222 p_sys
->psz_destination
);
1227 /****************************************************************************
1229 ****************************************************************************/
1230 static int FileSetup( sout_stream_t
*p_stream
)
1232 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1235 if( p_sys
->psz_sdp
== NULL
)
1236 return VLC_EGENERIC
; /* too early */
1238 if( ( f
= vlc_fopen( p_sys
->psz_sdp_file
, "wt" ) ) == NULL
)
1240 msg_Err( p_stream
, "cannot open file '%s' (%s)",
1241 p_sys
->psz_sdp_file
, vlc_strerror_c(errno
) );
1242 return VLC_EGENERIC
;
1245 fputs( p_sys
->psz_sdp
, f
);
1251 /****************************************************************************
1253 ****************************************************************************/
1254 static int HttpCallback( httpd_file_sys_t
*p_args
,
1255 httpd_file_t
*, uint8_t *p_request
,
1256 uint8_t **pp_data
, int *pi_data
);
1258 static int HttpSetup( sout_stream_t
*p_stream
, const vlc_url_t
*url
)
1260 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1262 p_sys
->p_httpd_host
= vlc_http_HostNew( VLC_OBJECT(p_stream
) );
1263 if( p_sys
->p_httpd_host
)
1265 p_sys
->p_httpd_file
= httpd_FileNew( p_sys
->p_httpd_host
,
1266 url
->psz_path
? url
->psz_path
: "/",
1269 HttpCallback
, (void*)p_sys
);
1271 if( p_sys
->p_httpd_file
== NULL
)
1273 return VLC_EGENERIC
;
1278 static int HttpCallback( httpd_file_sys_t
*p_args
,
1279 httpd_file_t
*f
, uint8_t *p_request
,
1280 uint8_t **pp_data
, int *pi_data
)
1282 VLC_UNUSED(f
); VLC_UNUSED(p_request
);
1283 sout_stream_sys_t
*p_sys
= (sout_stream_sys_t
*)p_args
;
1285 vlc_mutex_lock( &p_sys
->lock_sdp
);
1286 if( p_sys
->psz_sdp
&& *p_sys
->psz_sdp
)
1288 *pi_data
= strlen( p_sys
->psz_sdp
);
1289 *pp_data
= malloc( *pi_data
);
1290 memcpy( *pp_data
, p_sys
->psz_sdp
, *pi_data
);
1297 vlc_mutex_unlock( &p_sys
->lock_sdp
);
1302 /****************************************************************************
1304 ****************************************************************************/
1305 static void* ThreadSend( void *data
)
1308 # define ENOBUFS WSAENOBUFS
1309 # define EAGAIN WSAEWOULDBLOCK
1310 # define EWOULDBLOCK WSAEWOULDBLOCK
1312 sout_stream_id_sys_t
*id
= data
;
1313 vlc_tick_t i_caching
= id
->i_caching
;
1317 block_t
*out
= block_FifoGet( id
->p_fifo
);
1318 block_cleanup_push (out
);
1322 { /* FIXME: this is awfully inefficient */
1323 size_t len
= out
->i_buffer
;
1324 out
= block_Realloc( out
, 0, len
+ 10 );
1325 out
->i_buffer
= len
;
1327 int canc
= vlc_savecancel ();
1328 int val
= srtp_send( id
->srtp
, out
->p_buffer
, &len
, len
+ 10 );
1329 vlc_restorecancel (canc
);
1332 msg_Dbg( id
->p_stream
, "SRTP sending error: %s",
1333 vlc_strerror_c(val
) );
1334 block_Release( out
);
1338 out
->i_buffer
= len
;
1341 vlc_tick_wait (out
->i_dts
+ i_caching
);
1346 vlc_tick_wait (out
->i_dts
+ i_caching
);
1350 ssize_t len
= out
->i_buffer
;
1351 int canc
= vlc_savecancel ();
1353 vlc_mutex_lock( &id
->lock_sink
);
1354 unsigned deadc
= 0; /* How many dead sockets? */
1355 int deadv
[id
->sinkc
? id
->sinkc
: 1]; /* Dead sockets list */
1357 for( int i
= 0; i
< id
->sinkc
; i
++ )
1360 if( !id
->srtp
) /* FIXME: SRTCP support */
1362 SendRTCP( id
->sinkv
[i
].rtcp
, out
);
1364 if( send( id
->sinkv
[i
].rtp_fd
, out
->p_buffer
, len
, 0 ) == -1
1365 && net_errno
!= EAGAIN
&& net_errno
!= EWOULDBLOCK
1366 && net_errno
!= ENOBUFS
&& net_errno
!= ENOMEM
)
1369 getsockopt( id
->sinkv
[i
].rtp_fd
, SOL_SOCKET
, SO_TYPE
,
1370 &type
, &(socklen_t
){ sizeof(type
) });
1371 if( type
== SOCK_DGRAM
)
1372 /* ICMP soft error: ignore and retry */
1373 send( id
->sinkv
[i
].rtp_fd
, out
->p_buffer
, len
, 0 );
1375 /* Broken connection */
1376 deadv
[deadc
++] = id
->sinkv
[i
].rtp_fd
;
1379 id
->i_seq_sent_next
= ntohs(((uint16_t *) out
->p_buffer
)[1]) + 1;
1380 vlc_mutex_unlock( &id
->lock_sink
);
1381 block_Release( out
);
1383 for( unsigned i
= 0; i
< deadc
; i
++ )
1385 msg_Dbg( id
->p_stream
, "removing socket %d", deadv
[i
] );
1386 rtp_del_sink( id
, deadv
[i
] );
1388 vlc_restorecancel (canc
);
1394 /* This thread dequeues incoming connections (DCCP streaming) */
1395 static void *rtp_listen_thread( void *data
)
1397 sout_stream_id_sys_t
*id
= data
;
1399 assert( id
->listen
.fd
!= NULL
);
1403 int fd
= net_Accept( id
->p_stream
, id
->listen
.fd
);
1406 int canc
= vlc_savecancel( );
1407 rtp_add_sink( id
, fd
, true, NULL
);
1408 vlc_restorecancel( canc
);
1411 vlc_assert_unreachable();
1415 int rtp_add_sink( sout_stream_id_sys_t
*id
, int fd
, bool rtcp_mux
, uint16_t *seq
)
1417 rtp_sink_t sink
= { fd
, NULL
};
1418 sink
.rtcp
= OpenRTCP( VLC_OBJECT( id
->p_stream
), fd
, IPPROTO_UDP
,
1420 if( sink
.rtcp
== NULL
)
1421 msg_Err( id
->p_stream
, "RTCP failed!" );
1423 vlc_mutex_lock( &id
->lock_sink
);
1424 TAB_APPEND(id
->sinkc
, id
->sinkv
, sink
);
1426 *seq
= id
->i_seq_sent_next
;
1427 vlc_mutex_unlock( &id
->lock_sink
);
1431 void rtp_del_sink( sout_stream_id_sys_t
*id
, int fd
)
1433 rtp_sink_t sink
= { fd
, NULL
};
1435 /* NOTE: must be safe to use if fd is not included */
1436 vlc_mutex_lock( &id
->lock_sink
);
1437 for( int i
= 0; i
< id
->sinkc
; i
++ )
1439 if (id
->sinkv
[i
].rtp_fd
== fd
)
1441 sink
= id
->sinkv
[i
];
1442 TAB_ERASE(id
->sinkc
, id
->sinkv
, i
);
1446 vlc_mutex_unlock( &id
->lock_sink
);
1448 CloseRTCP( sink
.rtcp
);
1449 net_Close( sink
.rtp_fd
);
1452 uint16_t rtp_get_seq( sout_stream_id_sys_t
*id
)
1454 /* This will return values for the next packet. */
1457 vlc_mutex_lock( &id
->lock_sink
);
1458 seq
= id
->i_seq_sent_next
;
1459 vlc_mutex_unlock( &id
->lock_sink
);
1464 /* Return a timestamp corresponding to packets being sent now, and that
1465 * can be passed to rtp_compute_ts() to get rtptime values for each ES.
1466 * Also return the NPT corresponding to this timestamp. If the stream
1467 * output is not started, the initial timestamp that will be used with
1468 * the first packets for NPT=0 is returned instead. */
1469 vlc_tick_t
rtp_get_ts( const sout_stream_t
*p_stream
, const sout_stream_id_sys_t
*id
,
1476 p_stream
= id
->p_stream
;
1478 if (p_stream
== NULL
)
1479 return vlc_tick_now();
1481 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1482 vlc_tick_t i_npt_zero
;
1483 vlc_mutex_lock( &p_sys
->lock_ts
);
1484 i_npt_zero
= p_sys
->i_npt_zero
;
1485 vlc_mutex_unlock( &p_sys
->lock_ts
);
1487 if( i_npt_zero
== VLC_TICK_INVALID
)
1488 return p_sys
->i_pts_zero
;
1490 vlc_tick_t now
= vlc_tick_now();
1491 if( now
< i_npt_zero
)
1492 return p_sys
->i_pts_zero
;
1494 vlc_tick_t npt
= now
- i_npt_zero
;
1498 return p_sys
->i_pts_zero
+ npt
;
1501 void rtp_packetize_common( sout_stream_id_sys_t
*id
, block_t
*out
,
1502 bool b_m_bit
, vlc_tick_t i_pts
)
1504 if( !id
->b_ts_init
)
1506 sout_stream_sys_t
*p_sys
= id
->p_stream
->p_sys
;
1507 vlc_mutex_lock( &p_sys
->lock_ts
);
1508 if( p_sys
->i_npt_zero
== VLC_TICK_INVALID
)
1510 /* This is the first packet of any ES. We initialize the
1511 * NPT=0 time reference, and the offset to match the
1512 * arbitrary PTS reference. */
1513 p_sys
->i_npt_zero
= i_pts
+ id
->i_caching
;
1514 p_sys
->i_pts_offset
= p_sys
->i_pts_zero
- i_pts
;
1516 vlc_mutex_unlock( &p_sys
->lock_ts
);
1518 /* And in any case this is the first packet of this ES, so we
1519 * initialize the offset for this ES. */
1520 id
->i_ts_offset
= rtp_compute_ts( id
->rtp_fmt
.clock_rate
,
1521 p_sys
->i_pts_offset
);
1522 id
->b_ts_init
= true;
1525 uint32_t i_timestamp
= rtp_compute_ts( id
->rtp_fmt
.clock_rate
, i_pts
)
1528 out
->p_buffer
[0] = 0x80;
1529 out
->p_buffer
[1] = (b_m_bit
?0x80:0x00)|id
->rtp_fmt
.payload_type
;
1530 out
->p_buffer
[2] = ( id
->i_sequence
>> 8)&0xff;
1531 out
->p_buffer
[3] = ( id
->i_sequence
)&0xff;
1532 out
->p_buffer
[4] = ( i_timestamp
>> 24 )&0xff;
1533 out
->p_buffer
[5] = ( i_timestamp
>> 16 )&0xff;
1534 out
->p_buffer
[6] = ( i_timestamp
>> 8 )&0xff;
1535 out
->p_buffer
[7] = ( i_timestamp
)&0xff;
1537 memcpy( out
->p_buffer
+ 8, id
->ssrc
, 4 );
1542 uint16_t rtp_get_extended_sequence( sout_stream_id_sys_t
*id
)
1544 return id
->i_sequence
>> 16;
1547 void rtp_packetize_send( sout_stream_id_sys_t
*id
, block_t
*out
)
1549 block_FifoPut( id
->p_fifo
, out
);
1553 * @return configured max RTP payload size (including payload type-specific
1554 * headers, excluding RTP and transport headers)
1556 size_t rtp_mtu (const sout_stream_id_sys_t
*id
)
1558 return id
->i_mtu
- 12;
1561 /*****************************************************************************
1563 *****************************************************************************/
1565 /** Add an ES to a non-RTP muxed stream */
1566 static void *MuxAdd( sout_stream_t
*p_stream
, const es_format_t
*p_fmt
)
1568 sout_input_t
*p_input
;
1569 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1570 sout_mux_t
*p_mux
= p_sys
->p_mux
;
1571 assert( p_mux
!= NULL
);
1573 p_input
= sout_MuxAddStream( p_mux
, p_fmt
);
1574 if( p_input
== NULL
)
1576 msg_Err( p_stream
, "cannot add this stream to the muxer" );
1580 return (sout_stream_id_sys_t
*)p_input
;
1584 static int MuxSend( sout_stream_t
*p_stream
, void *id
, block_t
*p_buffer
)
1586 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1587 sout_mux_t
*p_mux
= p_sys
->p_mux
;
1588 assert( p_mux
!= NULL
);
1590 return sout_MuxSendBuffer( p_mux
, (sout_input_t
*)id
, p_buffer
);
1594 /** Remove an ES from a non-RTP muxed stream */
1595 static void MuxDel( sout_stream_t
*p_stream
, void *id
)
1597 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1598 sout_mux_t
*p_mux
= p_sys
->p_mux
;
1599 assert( p_mux
!= NULL
);
1601 sout_MuxDeleteStream( p_mux
, (sout_input_t
*)id
);
1605 static ssize_t
AccessOutGrabberWriteBuffer( sout_stream_t
*p_stream
,
1606 const block_t
*p_buffer
)
1608 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1609 sout_stream_id_sys_t
*id
= p_sys
->es
[0];
1611 vlc_tick_t i_dts
= p_buffer
->i_dts
;
1613 uint8_t *p_data
= p_buffer
->p_buffer
;
1614 size_t i_data
= p_buffer
->i_buffer
;
1615 size_t i_max
= id
->i_mtu
- 12;
1616 bool b_dis
= (p_buffer
->i_flags
& BLOCK_FLAG_DISCONTINUITY
);
1618 size_t i_packet
= ( p_buffer
->i_buffer
+ i_max
- 1 ) / i_max
;
1624 /* output complete packet */
1625 if( p_sys
->packet
&&
1626 p_sys
->packet
->i_buffer
+ i_data
> i_max
)
1628 rtp_packetize_send( id
, p_sys
->packet
);
1629 p_sys
->packet
= NULL
;
1632 if( p_sys
->packet
== NULL
)
1634 /* allocate a new packet */
1635 p_sys
->packet
= block_Alloc( id
->i_mtu
);
1636 /* m-bit is discontinuity for MPEG1/2 PS and TS, RFC2250 2.1 */
1637 rtp_packetize_common( id
, p_sys
->packet
, b_dis
, i_dts
);
1638 p_sys
->packet
->i_buffer
= 12;
1639 p_sys
->packet
->i_dts
= i_dts
;
1640 p_sys
->packet
->i_length
= p_buffer
->i_length
/ i_packet
;
1641 i_dts
+= p_sys
->packet
->i_length
;
1645 i_size
= __MIN( i_data
,
1646 (unsigned)(id
->i_mtu
- p_sys
->packet
->i_buffer
) );
1648 memcpy( &p_sys
->packet
->p_buffer
[p_sys
->packet
->i_buffer
],
1651 p_sys
->packet
->i_buffer
+= i_size
;
1660 static ssize_t
AccessOutGrabberWrite( sout_access_out_t
*p_access
,
1663 sout_stream_t
*p_stream
= (sout_stream_t
*)p_access
->p_sys
;
1669 AccessOutGrabberWriteBuffer( p_stream
, p_buffer
);
1671 p_next
= p_buffer
->p_next
;
1672 block_Release( p_buffer
);
1680 static sout_access_out_t
*GrabberCreate( sout_stream_t
*p_stream
)
1682 sout_access_out_t
*p_grab
;
1684 p_grab
= vlc_object_create( p_stream
, sizeof( *p_grab
) );
1685 if( p_grab
== NULL
)
1688 p_grab
->p_module
= NULL
;
1689 p_grab
->psz_access
= strdup( "grab" );
1690 p_grab
->p_cfg
= NULL
;
1691 p_grab
->psz_path
= strdup( "" );
1692 p_grab
->p_sys
= p_stream
;
1693 p_grab
->pf_seek
= NULL
;
1694 p_grab
->pf_write
= AccessOutGrabberWrite
;
1698 void rtp_get_video_geometry( sout_stream_id_sys_t
*id
, int *width
, int *height
)
1700 int ret
= sscanf( id
->rtp_fmt
.fmtp
, "%*s width=%d; height=%d; ", width
, height
);