1 /*****************************************************************************
2 * rtp.c: rtp stream output module
3 *****************************************************************************
4 * Copyright (C) 2003-2004 the VideoLAN team
5 * Copyright © 2007-2008 Rémi Denis-Courmont
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
24 /*****************************************************************************
26 *****************************************************************************/
32 #include <vlc_common.h>
33 #include <vlc_plugin.h>
35 #include <vlc_block.h>
37 #include <vlc_httpd.h>
39 #include <vlc_network.h>
40 #include <vlc_charset.h>
41 #include <vlc_strings.h>
47 # include <sys/types.h>
50 # include <sys/stat.h>
52 #ifdef HAVE_LINUX_DCCP_H
53 # include <linux/dccp.h>
56 # define IPPROTO_DCCP 33
58 #ifndef IPPROTO_UDPLITE
59 # define IPPROTO_UDPLITE 136
66 /*****************************************************************************
68 *****************************************************************************/
70 #define DEST_TEXT N_("Destination")
71 #define DEST_LONGTEXT N_( \
72 "This is the output URL that will be used." )
73 #define SDP_TEXT N_("SDP")
74 #define SDP_LONGTEXT N_( \
75 "This allows you to specify how the SDP (Session Descriptor) for this RTP "\
76 "session will be made available. You must use an url: http://location to " \
77 "access the SDP via HTTP, rtsp://location for RTSP access, and sap:// " \
78 "for the SDP to be announced via SAP." )
79 #define SAP_TEXT N_("SAP announcing")
80 #define SAP_LONGTEXT N_("Announce this session with SAP.")
81 #define MUX_TEXT N_("Muxer")
82 #define MUX_LONGTEXT N_( \
83 "This allows you to specify the muxer used for the streaming output. " \
84 "Default is to use no muxer (standard RTP stream)." )
86 #define NAME_TEXT N_("Session name")
87 #define NAME_LONGTEXT N_( \
88 "This is the name of the session that will be announced in the SDP " \
89 "(Session Descriptor)." )
90 #define DESC_TEXT N_("Session description")
91 #define DESC_LONGTEXT N_( \
92 "This allows you to give a short description with details about the stream, " \
93 "that will be announced in the SDP (Session Descriptor)." )
94 #define URL_TEXT N_("Session URL")
95 #define URL_LONGTEXT N_( \
96 "This allows you to give an URL with more details about the stream " \
97 "(often the website of the streaming organization), that will " \
98 "be announced in the SDP (Session Descriptor)." )
99 #define EMAIL_TEXT N_("Session email")
100 #define EMAIL_LONGTEXT N_( \
101 "This allows you to give a contact mail address for the stream, that will " \
102 "be announced in the SDP (Session Descriptor)." )
103 #define PHONE_TEXT N_("Session phone number")
104 #define PHONE_LONGTEXT N_( \
105 "This allows you to give a contact telephone number for the stream, that will " \
106 "be announced in the SDP (Session Descriptor)." )
108 #define PORT_TEXT N_("Port")
109 #define PORT_LONGTEXT N_( \
110 "This allows you to specify the base port for the RTP streaming." )
111 #define PORT_AUDIO_TEXT N_("Audio port")
112 #define PORT_AUDIO_LONGTEXT N_( \
113 "This allows you to specify the default audio port for the RTP streaming." )
114 #define PORT_VIDEO_TEXT N_("Video port")
115 #define PORT_VIDEO_LONGTEXT N_( \
116 "This allows you to specify the default video port for the RTP streaming." )
118 #define TTL_TEXT N_("Hop limit (TTL)")
119 #define TTL_LONGTEXT N_( \
120 "This is the hop limit (also known as \"Time-To-Live\" or TTL) of " \
121 "the multicast packets sent by the stream output (-1 = use operating " \
122 "system built-in default).")
124 #define RTCP_MUX_TEXT N_("RTP/RTCP multiplexing")
125 #define RTCP_MUX_LONGTEXT N_( \
126 "This sends and receives RTCP packet multiplexed over the same port " \
129 #define PROTO_TEXT N_("Transport protocol")
130 #define PROTO_LONGTEXT N_( \
131 "This selects which transport protocol to use for RTP." )
133 #define SRTP_KEY_TEXT N_("SRTP key (hexadecimal)")
134 #define SRTP_KEY_LONGTEXT N_( \
135 "RTP packets will be integrity-protected and ciphered "\
136 "with this Secure RTP master shared secret key.")
138 #define SRTP_SALT_TEXT N_("SRTP salt (hexadecimal)")
139 #define SRTP_SALT_LONGTEXT N_( \
140 "Secure RTP requires a (non-secret) master salt value.")
142 static const char *const ppsz_protos
[] = {
143 "dccp", "sctp", "tcp", "udp", "udplite",
146 static const char *const ppsz_protocols
[] = {
147 "DCCP", "SCTP", "TCP", "UDP", "UDP-Lite",
150 #define RFC3016_TEXT N_("MP4A LATM")
151 #define RFC3016_LONGTEXT N_( \
152 "This allows you to stream MPEG4 LATM audio streams (see RFC3016)." )
154 static int Open ( vlc_object_t
* );
155 static void Close( vlc_object_t
* );
157 #define SOUT_CFG_PREFIX "sout-rtp-"
158 #define MAX_EMPTY_BLOCKS 200
161 set_shortname( N_("RTP"))
162 set_description( N_("RTP stream output") )
163 set_capability( "sout stream", 0 )
164 add_shortcut( "rtp" )
165 set_category( CAT_SOUT
)
166 set_subcategory( SUBCAT_SOUT_STREAM
)
168 add_string( SOUT_CFG_PREFIX
"dst", "", NULL
, DEST_TEXT
,
169 DEST_LONGTEXT
, true );
170 add_string( SOUT_CFG_PREFIX
"sdp", "", NULL
, SDP_TEXT
,
171 SDP_LONGTEXT
, true );
172 add_string( SOUT_CFG_PREFIX
"mux", "", NULL
, MUX_TEXT
,
173 MUX_LONGTEXT
, true );
174 add_bool( SOUT_CFG_PREFIX
"sap", false, NULL
, SAP_TEXT
, SAP_LONGTEXT
,
177 add_string( SOUT_CFG_PREFIX
"name", "", NULL
, NAME_TEXT
,
178 NAME_LONGTEXT
, true );
179 add_string( SOUT_CFG_PREFIX
"description", "", NULL
, DESC_TEXT
,
180 DESC_LONGTEXT
, true );
181 add_string( SOUT_CFG_PREFIX
"url", "", NULL
, URL_TEXT
,
182 URL_LONGTEXT
, true );
183 add_string( SOUT_CFG_PREFIX
"email", "", NULL
, EMAIL_TEXT
,
184 EMAIL_LONGTEXT
, true );
185 add_string( SOUT_CFG_PREFIX
"phone", "", NULL
, PHONE_TEXT
,
186 PHONE_LONGTEXT
, true );
188 add_string( SOUT_CFG_PREFIX
"proto", "udp", NULL
, PROTO_TEXT
,
189 PROTO_LONGTEXT
, false );
190 change_string_list( ppsz_protos
, ppsz_protocols
, NULL
);
191 add_integer( SOUT_CFG_PREFIX
"port", 50004, NULL
, PORT_TEXT
,
192 PORT_LONGTEXT
, true );
193 add_integer( SOUT_CFG_PREFIX
"port-audio", 50000, NULL
, PORT_AUDIO_TEXT
,
194 PORT_AUDIO_LONGTEXT
, true );
195 add_integer( SOUT_CFG_PREFIX
"port-video", 50002, NULL
, PORT_VIDEO_TEXT
,
196 PORT_VIDEO_LONGTEXT
, true );
198 add_integer( SOUT_CFG_PREFIX
"ttl", -1, NULL
, TTL_TEXT
,
199 TTL_LONGTEXT
, true );
200 add_bool( SOUT_CFG_PREFIX
"rtcp-mux", false, NULL
,
201 RTCP_MUX_TEXT
, RTCP_MUX_LONGTEXT
, false );
203 add_string( SOUT_CFG_PREFIX
"key", "", NULL
,
204 SRTP_KEY_TEXT
, SRTP_KEY_LONGTEXT
, false );
205 add_string( SOUT_CFG_PREFIX
"salt", "", NULL
,
206 SRTP_SALT_TEXT
, SRTP_SALT_LONGTEXT
, false );
208 add_bool( SOUT_CFG_PREFIX
"mp4a-latm", 0, NULL
, RFC3016_TEXT
,
209 RFC3016_LONGTEXT
, false );
211 set_callbacks( Open
, Close
)
214 /*****************************************************************************
215 * Exported prototypes
216 *****************************************************************************/
217 static const char *const ppsz_sout_options
[] = {
218 "dst", "name", "port", "port-audio", "port-video", "*sdp", "ttl", "mux",
219 "sap", "description", "url", "email", "phone",
220 "proto", "rtcp-mux", "key", "salt",
224 static sout_stream_id_t
*Add ( sout_stream_t
*, es_format_t
* );
225 static int Del ( sout_stream_t
*, sout_stream_id_t
* );
226 static int Send( sout_stream_t
*, sout_stream_id_t
*,
228 static sout_stream_id_t
*MuxAdd ( sout_stream_t
*, es_format_t
* );
229 static int MuxDel ( sout_stream_t
*, sout_stream_id_t
* );
230 static int MuxSend( sout_stream_t
*, sout_stream_id_t
*,
233 static sout_access_out_t
*GrabberCreate( sout_stream_t
*p_sout
);
234 static void* ThreadSend( vlc_object_t
*p_this
);
236 static void SDPHandleUrl( sout_stream_t
*, const char * );
238 static int SapSetup( sout_stream_t
*p_stream
);
239 static int FileSetup( sout_stream_t
*p_stream
);
240 static int HttpSetup( sout_stream_t
*p_stream
, const vlc_url_t
* );
242 struct sout_stream_sys_t
246 vlc_mutex_t lock_sdp
;
249 bool b_export_sdp_file
;
254 session_descriptor_t
*p_session
;
257 httpd_host_t
*p_httpd_host
;
258 httpd_file_t
*p_httpd_file
;
264 char *psz_destination
;
265 uint32_t payload_bitmap
;
267 uint16_t i_port_audio
;
268 uint16_t i_port_video
;
274 /* in case we do TS/PS over rtp */
276 sout_access_out_t
*p_grab
;
282 sout_stream_id_t
**es
;
285 typedef int (*pf_rtp_packetizer_t
)( sout_stream_id_t
*, block_t
* );
287 typedef struct rtp_sink_t
293 struct sout_stream_id_t
297 sout_stream_t
*p_stream
;
300 uint8_t i_payload_type
;
312 /* Packetizer specific fields */
314 srtp_session_t
*srtp
;
315 pf_rtp_packetizer_t pf_packetize
;
318 vlc_mutex_t lock_sink
;
321 rtsp_stream_id_t
*rtsp_id
;
324 block_fifo_t
*p_fifo
;
328 /*****************************************************************************
330 *****************************************************************************/
331 static int Open( vlc_object_t
*p_this
)
333 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
334 sout_instance_t
*p_sout
= p_stream
->p_sout
;
335 sout_stream_sys_t
*p_sys
= NULL
;
336 config_chain_t
*p_cfg
= NULL
;
340 config_ChainParse( p_stream
, SOUT_CFG_PREFIX
,
341 ppsz_sout_options
, p_stream
->p_cfg
);
343 p_sys
= malloc( sizeof( sout_stream_sys_t
) );
347 p_sys
->psz_destination
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"dst" );
349 p_sys
->i_port
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port" );
350 p_sys
->i_port_audio
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port-audio" );
351 p_sys
->i_port_video
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"port-video" );
352 p_sys
->rtcp_mux
= var_GetBool( p_stream
, SOUT_CFG_PREFIX
"rtcp-mux" );
354 p_sys
->psz_sdp_file
= NULL
;
356 if( p_sys
->i_port_audio
== p_sys
->i_port_video
)
358 msg_Err( p_stream
, "audio and video port cannot be the same" );
359 p_sys
->i_port_audio
= 0;
360 p_sys
->i_port_video
= 0;
363 for( p_cfg
= p_stream
->p_cfg
; p_cfg
!= NULL
; p_cfg
= p_cfg
->p_next
)
365 if( !strcmp( p_cfg
->psz_name
, "sdp" )
366 && ( p_cfg
->psz_value
!= NULL
)
367 && !strncasecmp( p_cfg
->psz_value
, "rtsp:", 5 ) )
375 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"sdp" );
378 if( !strncasecmp( psz
, "rtsp:", 5 ) )
384 /* Transport protocol */
385 p_sys
->proto
= IPPROTO_UDP
;
386 psz
= var_GetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"proto");
388 if ((psz
== NULL
) || !strcasecmp (psz
, "udp"))
389 (void)0; /* default */
391 if (!strcasecmp (psz
, "dccp"))
393 p_sys
->proto
= IPPROTO_DCCP
;
394 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
398 if (!strcasecmp (psz
, "sctp"))
400 p_sys
->proto
= IPPROTO_TCP
;
401 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
406 if (!strcasecmp (psz
, "tcp"))
408 p_sys
->proto
= IPPROTO_TCP
;
409 p_sys
->rtcp_mux
= true; /* Force RTP/RTCP mux */
413 if (!strcasecmp (psz
, "udplite") || !strcasecmp (psz
, "udp-lite"))
414 p_sys
->proto
= IPPROTO_UDPLITE
;
416 msg_Warn (p_this
, "unknown or unsupported transport protocol \"%s\"",
419 var_Create (p_this
, "dccp-service", VLC_VAR_STRING
);
421 if( ( p_sys
->psz_destination
== NULL
) && !b_rtsp
)
423 msg_Err( p_stream
, "missing destination and not in RTSP mode" );
428 p_sys
->i_ttl
= var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"ttl" );
429 if( p_sys
->i_ttl
== -1 )
431 /* Normally, we should let the default hop limit up to the core,
432 * but we have to know it to build our SDP properly, which is why
433 * we ask the core. FIXME: broken when neither sout-rtp-ttl nor
435 p_sys
->i_ttl
= config_GetInt( p_stream
, "ttl" );
438 p_sys
->b_latm
= var_GetBool( p_stream
, SOUT_CFG_PREFIX
"mp4a-latm" );
440 p_sys
->payload_bitmap
= 0;
444 p_sys
->psz_sdp
= NULL
;
446 p_sys
->b_export_sap
= false;
447 p_sys
->b_export_sdp_file
= false;
448 p_sys
->p_session
= NULL
;
450 p_sys
->p_httpd_host
= NULL
;
451 p_sys
->p_httpd_file
= NULL
;
453 p_stream
->p_sys
= p_sys
;
455 vlc_mutex_init( &p_sys
->lock_sdp
);
456 vlc_mutex_init( &p_sys
->lock_es
);
458 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"mux" );
461 sout_stream_id_t
*id
;
463 /* Check muxer type */
464 if( strncasecmp( psz
, "ps", 2 )
465 && strncasecmp( psz
, "mpeg1", 5 )
466 && strncasecmp( psz
, "ts", 2 ) )
468 msg_Err( p_stream
, "unsupported muxer type for RTP (only TS/PS)" );
470 vlc_mutex_destroy( &p_sys
->lock_sdp
);
471 vlc_mutex_destroy( &p_sys
->lock_es
);
476 p_sys
->p_grab
= GrabberCreate( p_stream
);
477 p_sys
->p_mux
= sout_MuxNew( p_sout
, psz
, p_sys
->p_grab
);
480 if( p_sys
->p_mux
== NULL
)
482 msg_Err( p_stream
, "cannot create muxer" );
483 sout_AccessOutDelete( p_sys
->p_grab
);
484 vlc_mutex_destroy( &p_sys
->lock_sdp
);
485 vlc_mutex_destroy( &p_sys
->lock_es
);
490 id
= Add( p_stream
, NULL
);
493 sout_MuxDelete( p_sys
->p_mux
);
494 sout_AccessOutDelete( p_sys
->p_grab
);
495 vlc_mutex_destroy( &p_sys
->lock_sdp
);
496 vlc_mutex_destroy( &p_sys
->lock_es
);
501 p_sys
->packet
= NULL
;
503 p_stream
->pf_add
= MuxAdd
;
504 p_stream
->pf_del
= MuxDel
;
505 p_stream
->pf_send
= MuxSend
;
510 p_sys
->p_grab
= NULL
;
512 p_stream
->pf_add
= Add
;
513 p_stream
->pf_del
= Del
;
514 p_stream
->pf_send
= Send
;
517 if( var_GetBool( p_stream
, SOUT_CFG_PREFIX
"sap" ) )
518 SDPHandleUrl( p_stream
, "sap" );
520 psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"sdp" );
523 config_chain_t
*p_cfg
;
525 SDPHandleUrl( p_stream
, psz
);
527 for( p_cfg
= p_stream
->p_cfg
; p_cfg
!= NULL
; p_cfg
= p_cfg
->p_next
)
529 if( !strcmp( p_cfg
->psz_name
, "sdp" ) )
531 if( p_cfg
->psz_value
== NULL
|| *p_cfg
->psz_value
== '\0' )
534 /* needed both :sout-rtp-sdp= and rtp{sdp=} can be used */
535 if( !strcmp( p_cfg
->psz_value
, psz
) )
538 SDPHandleUrl( p_stream
, p_cfg
->psz_value
);
544 /* update p_sout->i_out_pace_nocontrol */
545 p_stream
->p_sout
->i_out_pace_nocontrol
++;
550 /*****************************************************************************
552 *****************************************************************************/
553 static void Close( vlc_object_t
* p_this
)
555 sout_stream_t
*p_stream
= (sout_stream_t
*)p_this
;
556 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
558 /* update p_sout->i_out_pace_nocontrol */
559 p_stream
->p_sout
->i_out_pace_nocontrol
--;
563 assert( p_sys
->i_es
== 1 );
564 Del( p_stream
, p_sys
->es
[0] );
566 sout_MuxDelete( p_sys
->p_mux
);
567 sout_AccessOutDelete( p_sys
->p_grab
);
570 block_Release( p_sys
->packet
);
572 if( p_sys
->b_export_sap
)
575 SapSetup( p_stream
);
579 if( p_sys
->rtsp
!= NULL
)
580 RtspUnsetup( p_sys
->rtsp
);
582 vlc_mutex_destroy( &p_sys
->lock_sdp
);
583 vlc_mutex_destroy( &p_sys
->lock_es
);
585 if( p_sys
->p_httpd_file
)
586 httpd_FileDelete( p_sys
->p_httpd_file
);
588 if( p_sys
->p_httpd_host
)
589 httpd_HostDelete( p_sys
->p_httpd_host
);
591 free( p_sys
->psz_sdp
);
593 if( p_sys
->b_export_sdp_file
)
596 unlink( p_sys
->psz_sdp_file
);
598 free( p_sys
->psz_sdp_file
);
600 free( p_sys
->psz_destination
);
604 /*****************************************************************************
606 *****************************************************************************/
607 static void SDPHandleUrl( sout_stream_t
*p_stream
, const char *psz_url
)
609 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
612 vlc_UrlParse( &url
, psz_url
, 0 );
613 if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "http" ) )
615 if( p_sys
->p_httpd_file
)
617 msg_Err( p_stream
, "you can use sdp=http:// only once" );
621 if( HttpSetup( p_stream
, &url
) )
623 msg_Err( p_stream
, "cannot export SDP as HTTP" );
626 else if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "rtsp" ) )
628 if( p_sys
->rtsp
!= NULL
)
630 msg_Err( p_stream
, "you can use sdp=rtsp:// only once" );
634 /* FIXME test if destination is multicast or no destination at all */
635 p_sys
->rtsp
= RtspSetup( p_stream
, &url
);
636 if( p_sys
->rtsp
== NULL
)
637 msg_Err( p_stream
, "cannot export SDP as RTSP" );
639 if( p_sys
->p_mux
!= NULL
)
641 sout_stream_id_t
*id
= p_sys
->es
[0];
642 id
->rtsp_id
= RtspAddId( p_sys
->rtsp
, id
, 0, GetDWBE( id
->ssrc
),
643 p_sys
->psz_destination
, p_sys
->i_ttl
,
644 id
->i_port
, id
->i_port
+ 1 );
647 else if( ( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "sap" ) ) ||
648 ( url
.psz_host
&& !strcasecmp( url
.psz_host
, "sap" ) ) )
650 p_sys
->b_export_sap
= true;
651 SapSetup( p_stream
);
653 else if( url
.psz_protocol
&& !strcasecmp( url
.psz_protocol
, "file" ) )
655 if( p_sys
->b_export_sdp_file
)
657 msg_Err( p_stream
, "you can use sdp=file:// only once" );
660 p_sys
->b_export_sdp_file
= true;
661 psz_url
= &psz_url
[5];
662 if( psz_url
[0] == '/' && psz_url
[1] == '/' )
664 p_sys
->psz_sdp_file
= strdup( psz_url
);
668 msg_Warn( p_stream
, "unknown protocol for SDP (%s)",
673 vlc_UrlClean( &url
);
676 /*****************************************************************************
678 *****************************************************************************/
680 char *SDPGenerate( const sout_stream_t
*p_stream
, const char *rtsp_url
)
682 const sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
684 struct sockaddr_storage dst
;
688 * When we have a fixed destination (typically when we do multicast),
689 * we need to put the actual port numbers in the SDP.
690 * When there is no fixed destination, we only support RTSP unicast
691 * on-demand setup, so we should rather let the clients decide which ports
693 * When there is both a fixed destination and RTSP unicast, we need to
694 * put port numbers used by the fixed destination, otherwise the SDP would
695 * become totally incorrect for multicast use. It should be noted that
696 * port numbers from SDP with RTSP are only "recommendation" from the
697 * server to the clients (per RFC2326), so only broken clients will fail
698 * to handle this properly. There is no solution but to use two differents
699 * output chain with two different RTSP URLs if you need to handle this
704 if( p_sys
->psz_destination
!= NULL
)
708 /* Oh boy, this is really ugly! (+ race condition on lock_es) */
709 dstlen
= sizeof( dst
);
710 if( p_sys
->es
[0]->listen_fd
!= NULL
)
711 getsockname( p_sys
->es
[0]->listen_fd
[0],
712 (struct sockaddr
*)&dst
, &dstlen
);
714 getpeername( p_sys
->es
[0]->sinkv
[0].rtp_fd
,
715 (struct sockaddr
*)&dst
, &dstlen
);
721 /* Dummy destination address for RTSP */
722 memset (&dst
, 0, sizeof( struct sockaddr_in
) );
723 dst
.ss_family
= AF_INET
;
727 dstlen
= sizeof( struct sockaddr_in
);
730 psz_sdp
= vlc_sdp_Start( VLC_OBJECT( p_stream
), SOUT_CFG_PREFIX
,
731 NULL
, 0, (struct sockaddr
*)&dst
, dstlen
);
732 if( psz_sdp
== NULL
)
735 /* TODO: a=source-filter */
736 if( p_sys
->rtcp_mux
)
737 sdp_AddAttribute( &psz_sdp
, "rtcp-mux", NULL
);
739 if( rtsp_url
!= NULL
)
740 sdp_AddAttribute ( &psz_sdp
, "control", "%s", rtsp_url
);
742 /* FIXME: locking?! */
743 for( i
= 0; i
< p_sys
->i_es
; i
++ )
745 sout_stream_id_t
*id
= p_sys
->es
[i
];
746 const char *mime_major
; /* major MIME type */
747 const char *proto
= "RTP/AVP"; /* protocol */
752 mime_major
= "video";
755 mime_major
= "audio";
764 if( rtsp_url
== NULL
)
766 switch( p_sys
->proto
)
771 proto
= "TCP/RTP/AVP";
774 proto
= "DCCP/RTP/AVP";
776 case IPPROTO_UDPLITE
:
781 sdp_AddMedia( &psz_sdp
, mime_major
, proto
, inclport
* id
->i_port
,
782 id
->i_payload_type
, false, id
->i_bitrate
,
783 id
->psz_enc
, id
->i_clock_rate
, id
->i_channels
,
786 if( rtsp_url
!= NULL
)
788 assert( strlen( rtsp_url
) > 0 );
789 bool addslash
= ( rtsp_url
[strlen( rtsp_url
) - 1] != '/' );
790 sdp_AddAttribute ( &psz_sdp
, "control",
791 addslash
? "%s/trackID=%u" : "%strackID=%u",
796 if( id
->listen_fd
!= NULL
)
797 sdp_AddAttribute( &psz_sdp
, "setup", "passive" );
798 if( p_sys
->proto
== IPPROTO_DCCP
)
799 sdp_AddAttribute( &psz_sdp
, "dccp-service-code",
800 "SC:RTP%c", toupper( mime_major
[0] ) );
807 /*****************************************************************************
809 *****************************************************************************/
811 static void sprintf_hexa( char *s
, uint8_t *p_data
, int i_data
)
813 static const char hex
[16] = "0123456789abcdef";
816 for( i
= 0; i
< i_data
; i
++ )
818 s
[2*i
+0] = hex
[(p_data
[i
]>>4)&0xf];
819 s
[2*i
+1] = hex
[(p_data
[i
] )&0xf];
825 * Shrink the MTU down to a fixed packetization time (for audio).
828 rtp_set_ptime (sout_stream_id_t
*id
, unsigned ptime_ms
, size_t bytes
)
830 /* Samples per second */
831 size_t spl
= (id
->i_clock_rate
- 1) * ptime_ms
/ 1000 + 1;
832 bytes
*= id
->i_channels
;
835 if (spl
< rtp_mtu (id
)) /* MTU is big enough for ptime */
836 id
->i_mtu
= 12 + spl
;
837 else /* MTU is too small for ptime, align to a sample boundary */
838 id
->i_mtu
= 12 + (((id
->i_mtu
- 12) / bytes
) * bytes
);
841 /** Add an ES as a new RTP stream */
842 static sout_stream_id_t
*Add( sout_stream_t
*p_stream
, es_format_t
*p_fmt
)
844 /* NOTE: As a special case, if we use a non-RTP
845 * mux (TS/PS), then p_fmt is NULL. */
846 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
847 sout_stream_id_t
*id
;
848 int i_port
, cscov
= -1;
851 if (0xffffffff == p_sys
->payload_bitmap
)
853 msg_Err (p_stream
, "too many RTP elementary streams");
857 id
= vlc_object_create( p_stream
, sizeof( sout_stream_id_t
) );
860 vlc_object_attach( id
, p_stream
);
862 /* Choose the port */
867 if( p_fmt
->i_cat
== AUDIO_ES
&& p_sys
->i_port_audio
> 0 )
869 i_port
= p_sys
->i_port_audio
;
870 p_sys
->i_port_audio
= 0;
873 if( p_fmt
->i_cat
== VIDEO_ES
&& p_sys
->i_port_video
> 0 )
875 i_port
= p_sys
->i_port_video
;
876 p_sys
->i_port_video
= 0;
881 if( p_sys
->i_port
!= p_sys
->i_port_audio
882 && p_sys
->i_port
!= p_sys
->i_port_video
)
884 i_port
= p_sys
->i_port
;
891 id
->p_stream
= p_stream
;
893 id
->i_sequence
= rand()&0xffff;
894 /* Look for free dymanic payload type */
895 id
->i_payload_type
= 96;
896 while (p_sys
->payload_bitmap
& (1 << (id
->i_payload_type
- 96)))
897 id
->i_payload_type
++;
898 assert (id
->i_payload_type
< 128);
900 id
->ssrc
[0] = rand()&0xff;
901 id
->ssrc
[1] = rand()&0xff;
902 id
->ssrc
[2] = rand()&0xff;
903 id
->ssrc
[3] = rand()&0xff;
907 id
->i_clock_rate
= 90000; /* most common case for video */
912 id
->i_cat
= p_fmt
->i_cat
;
913 if( p_fmt
->i_cat
== AUDIO_ES
)
915 id
->i_clock_rate
= p_fmt
->audio
.i_rate
;
916 id
->i_channels
= p_fmt
->audio
.i_channels
;
918 id
->i_bitrate
= p_fmt
->i_bitrate
/1000; /* Stream bitrate in kbps */
922 id
->i_cat
= VIDEO_ES
;
926 id
->i_mtu
= config_GetInt( p_stream
, "mtu" );
927 if( id
->i_mtu
<= 12 + 16 )
928 id
->i_mtu
= 576 - 20 - 8; /* pessimistic */
929 msg_Dbg( p_stream
, "maximum RTP packet size: %d bytes", id
->i_mtu
);
932 id
->pf_packetize
= NULL
;
934 char *key
= var_CreateGetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"key");
937 id
->srtp
= srtp_create (SRTP_ENCR_AES_CM
, SRTP_AUTH_HMAC_SHA1
, 10,
938 SRTP_PRF_AES_CM
, SRTP_RCC_MODE1
);
939 if (id
->srtp
== NULL
)
945 char *salt
= var_CreateGetNonEmptyString (p_stream
, SOUT_CFG_PREFIX
"salt");
946 errno
= srtp_setkeystring (id
->srtp
, key
, salt
? salt
: "");
951 msg_Err (p_stream
, "bad SRTP key/salt combination (%m)");
954 id
->i_sequence
= 0; /* FIXME: awful hack for libvlc_srtp */
957 vlc_mutex_init( &id
->lock_sink
);
962 id
->listen_fd
= NULL
;
965 (int64_t)1000 * var_GetInteger( p_stream
, SOUT_CFG_PREFIX
"caching");
967 if( p_sys
->psz_destination
!= NULL
)
968 switch( p_sys
->proto
)
975 case VIDEO_ES
: code
= "RTPV"; break;
976 case AUDIO_ES
: code
= "RTPARTPV"; break;
977 case SPU_ES
: code
= "RTPTRPTV"; break;
978 default: code
= "RTPORTPV"; break;
980 var_SetString (p_stream
, "dccp-service", code
);
983 id
->listen_fd
= net_Listen( VLC_OBJECT(p_stream
),
984 p_sys
->psz_destination
, i_port
,
986 if( id
->listen_fd
== NULL
)
988 msg_Err( p_stream
, "passive COMEDIA RTP socket failed" );
995 int ttl
= (p_sys
->i_ttl
>= 0) ? p_sys
->i_ttl
: -1;
996 int fd
= net_ConnectDgram( p_stream
, p_sys
->psz_destination
,
997 i_port
, ttl
, p_sys
->proto
);
1000 msg_Err( p_stream
, "cannot create RTP socket" );
1003 rtp_add_sink( id
, fd
, p_sys
->rtcp_mux
);
1009 char *psz
= var_GetNonEmptyString( p_stream
, SOUT_CFG_PREFIX
"mux" );
1011 if( psz
== NULL
) /* Uho! */
1014 if( strncmp( psz
, "ts", 2 ) == 0 )
1016 id
->i_payload_type
= 33;
1017 id
->psz_enc
= "MP2T";
1021 id
->psz_enc
= "MP2P";
1026 switch( p_fmt
->i_codec
)
1028 case VLC_FOURCC( 'u', 'l', 'a', 'w' ):
1029 if( p_fmt
->audio
.i_channels
== 1 && p_fmt
->audio
.i_rate
== 8000 )
1030 id
->i_payload_type
= 0;
1031 id
->psz_enc
= "PCMU";
1032 id
->pf_packetize
= rtp_packetize_split
;
1033 rtp_set_ptime (id
, 20, 1);
1035 case VLC_FOURCC( 'a', 'l', 'a', 'w' ):
1036 if( p_fmt
->audio
.i_channels
== 1 && p_fmt
->audio
.i_rate
== 8000 )
1037 id
->i_payload_type
= 8;
1038 id
->psz_enc
= "PCMA";
1039 id
->pf_packetize
= rtp_packetize_split
;
1040 rtp_set_ptime (id
, 20, 1);
1042 case VLC_FOURCC( 's', '1', '6', 'b' ):
1043 if( p_fmt
->audio
.i_channels
== 1 && p_fmt
->audio
.i_rate
== 44100 )
1045 id
->i_payload_type
= 11;
1047 else if( p_fmt
->audio
.i_channels
== 2 &&
1048 p_fmt
->audio
.i_rate
== 44100 )
1050 id
->i_payload_type
= 10;
1052 id
->psz_enc
= "L16";
1053 id
->pf_packetize
= rtp_packetize_split
;
1054 rtp_set_ptime (id
, 20, 2);
1056 case VLC_FOURCC( 'u', '8', ' ', ' ' ):
1058 id
->pf_packetize
= rtp_packetize_split
;
1059 rtp_set_ptime (id
, 20, 1);
1061 case VLC_FOURCC( 'm', 'p', 'g', 'a' ):
1062 case VLC_FOURCC( 'm', 'p', '3', ' ' ):
1063 id
->i_payload_type
= 14;
1064 id
->psz_enc
= "MPA";
1065 id
->i_clock_rate
= 90000; /* not 44100 */
1066 id
->pf_packetize
= rtp_packetize_mpa
;
1068 case VLC_FOURCC( 'm', 'p', 'g', 'v' ):
1069 id
->i_payload_type
= 32;
1070 id
->psz_enc
= "MPV";
1071 id
->pf_packetize
= rtp_packetize_mpv
;
1073 case VLC_FOURCC( 'G', '7', '2', '6' ):
1074 case VLC_FOURCC( 'g', '7', '2', '6' ):
1075 switch( p_fmt
->i_bitrate
/ 1000 )
1078 id
->psz_enc
= "G726-16";
1079 id
->pf_packetize
= rtp_packetize_g726_16
;
1082 id
->psz_enc
= "G726-24";
1083 id
->pf_packetize
= rtp_packetize_g726_24
;
1086 id
->psz_enc
= "G726-32";
1087 id
->pf_packetize
= rtp_packetize_g726_32
;
1090 id
->psz_enc
= "G726-40";
1091 id
->pf_packetize
= rtp_packetize_g726_40
;
1095 case VLC_FOURCC( 'a', '5', '2', ' ' ):
1096 id
->psz_enc
= "ac3";
1097 id
->pf_packetize
= rtp_packetize_ac3
;
1099 case VLC_FOURCC( 'H', '2', '6', '3' ):
1100 id
->psz_enc
= "H263-1998";
1101 id
->pf_packetize
= rtp_packetize_h263
;
1103 case VLC_FOURCC( 'h', '2', '6', '4' ):
1104 id
->psz_enc
= "H264";
1105 id
->pf_packetize
= rtp_packetize_h264
;
1106 id
->psz_fmtp
= NULL
;
1108 if( p_fmt
->i_extra
> 0 )
1110 uint8_t *p_buffer
= p_fmt
->p_extra
;
1111 int i_buffer
= p_fmt
->i_extra
;
1112 char *p_64_sps
= NULL
;
1113 char *p_64_pps
= NULL
;
1116 while( i_buffer
> 4 &&
1117 p_buffer
[0] == 0 && p_buffer
[1] == 0 &&
1118 p_buffer
[2] == 0 && p_buffer
[3] == 1 )
1120 const int i_nal_type
= p_buffer
[4]&0x1f;
1124 msg_Dbg( p_stream
, "we found a startcode for NAL with TYPE:%d", i_nal_type
);
1127 for( i_offset
= 4; i_offset
+3 < i_buffer
; i_offset
++)
1129 if( !memcmp (p_buffer
+ i_offset
, "\x00\x00\x00\x01", 4 ) )
1131 /* we found another startcode */
1136 if( i_nal_type
== 7 )
1138 p_64_sps
= vlc_b64_encode_binary( &p_buffer
[4], i_size
- 4 );
1139 sprintf_hexa( hexa
, &p_buffer
[5], 3 );
1141 else if( i_nal_type
== 8 )
1143 p_64_pps
= vlc_b64_encode_binary( &p_buffer
[4], i_size
- 4 );
1149 if( p_64_sps
&& p_64_pps
&&
1150 ( asprintf( &id
->psz_fmtp
,
1151 "packetization-mode=1;profile-level-id=%s;"
1152 "sprop-parameter-sets=%s,%s;", hexa
, p_64_sps
,
1153 p_64_pps
) == -1 ) )
1154 id
->psz_fmtp
= NULL
;
1159 id
->psz_fmtp
= strdup( "packetization-mode=1" );
1162 case VLC_FOURCC( 'm', 'p', '4', 'v' ):
1164 char hexa
[2*p_fmt
->i_extra
+1];
1166 id
->psz_enc
= "MP4V-ES";
1167 id
->pf_packetize
= rtp_packetize_split
;
1168 if( p_fmt
->i_extra
> 0 )
1170 sprintf_hexa( hexa
, p_fmt
->p_extra
, p_fmt
->i_extra
);
1171 if( asprintf( &id
->psz_fmtp
,
1172 "profile-level-id=3; config=%s;", hexa
) == -1 )
1173 id
->psz_fmtp
= NULL
;
1177 case VLC_FOURCC( 'm', 'p', '4', 'a' ):
1181 char hexa
[2*p_fmt
->i_extra
+1];
1183 id
->psz_enc
= "mpeg4-generic";
1184 id
->pf_packetize
= rtp_packetize_mp4a
;
1185 sprintf_hexa( hexa
, p_fmt
->p_extra
, p_fmt
->i_extra
);
1186 if( asprintf( &id
->psz_fmtp
,
1187 "streamtype=5; profile-level-id=15; "
1188 "mode=AAC-hbr; config=%s; SizeLength=13; "
1189 "IndexLength=3; IndexDeltaLength=3; Profile=1;",
1191 id
->psz_fmtp
= NULL
;
1197 unsigned char config
[6];
1198 unsigned int aacsrates
[15] = {
1199 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
1200 16000, 12000, 11025, 8000, 7350, 0, 0 };
1202 for( i
= 0; i
< 15; i
++ )
1203 if( p_fmt
->audio
.i_rate
== aacsrates
[i
] )
1209 config
[3]=p_fmt
->audio
.i_channels
<<4;
1213 id
->psz_enc
= "MP4A-LATM";
1214 id
->pf_packetize
= rtp_packetize_mp4a_latm
;
1215 sprintf_hexa( hexa
, config
, 6 );
1216 if( asprintf( &id
->psz_fmtp
, "profile-level-id=15; "
1217 "object=2; cpresent=0; config=%s", hexa
) == -1 )
1218 id
->psz_fmtp
= NULL
;
1222 case VLC_FOURCC( 's', 'a', 'm', 'r' ):
1223 id
->psz_enc
= "AMR";
1224 id
->psz_fmtp
= strdup( "octet-align=1" );
1225 id
->pf_packetize
= rtp_packetize_amr
;
1227 case VLC_FOURCC( 's', 'a', 'w', 'b' ):
1228 id
->psz_enc
= "AMR-WB";
1229 id
->psz_fmtp
= strdup( "octet-align=1" );
1230 id
->pf_packetize
= rtp_packetize_amr
;
1232 case VLC_FOURCC( 's', 'p', 'x', ' ' ):
1233 id
->psz_enc
= "SPEEX";
1234 id
->pf_packetize
= rtp_packetize_spx
;
1236 case VLC_FOURCC( 't', '1', '4', '0' ):
1237 id
->psz_enc
= "t140" ;
1238 id
->i_clock_rate
= 1000;
1239 id
->pf_packetize
= rtp_packetize_t140
;
1243 msg_Err( p_stream
, "cannot add this stream (unsupported "
1244 "codec:%4.4s)", (char*)&p_fmt
->i_codec
);
1247 if (id
->i_payload_type
>= 96)
1248 /* Mark dynamic payload type in use */
1249 p_sys
->payload_bitmap
|= 1 << (id
->i_payload_type
- 96);
1251 #if 0 /* No payload formats sets this at the moment */
1253 cscov
+= 8 /* UDP */ + 12 /* RTP */;
1255 net_SetCSCov( id
->sinkv
[0].rtp_fd
, cscov
, -1 );
1258 if( p_sys
->rtsp
!= NULL
)
1259 id
->rtsp_id
= RtspAddId( p_sys
->rtsp
, id
, p_sys
->i_es
,
1260 GetDWBE( id
->ssrc
),
1261 p_sys
->psz_destination
,
1262 p_sys
->i_ttl
, id
->i_port
, id
->i_port
+ 1 );
1264 id
->p_fifo
= block_FifoNew();
1265 if( vlc_thread_create( id
, "RTP send thread", ThreadSend
,
1266 VLC_THREAD_PRIORITY_HIGHEST
, false ) )
1269 /* Update p_sys context */
1270 vlc_mutex_lock( &p_sys
->lock_es
);
1271 TAB_APPEND( p_sys
->i_es
, p_sys
->es
, id
);
1272 vlc_mutex_unlock( &p_sys
->lock_es
);
1274 psz_sdp
= SDPGenerate( p_stream
, NULL
);
1276 vlc_mutex_lock( &p_sys
->lock_sdp
);
1277 free( p_sys
->psz_sdp
);
1278 p_sys
->psz_sdp
= psz_sdp
;
1279 vlc_mutex_unlock( &p_sys
->lock_sdp
);
1281 msg_Dbg( p_stream
, "sdp=\n%s", p_sys
->psz_sdp
);
1283 /* Update SDP (sap/file) */
1284 if( p_sys
->b_export_sap
) SapSetup( p_stream
);
1285 if( p_sys
->b_export_sdp_file
) FileSetup( p_stream
);
1290 Del( p_stream
, id
);
1294 static int Del( sout_stream_t
*p_stream
, sout_stream_id_t
*id
)
1296 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1298 if( id
->p_fifo
!= NULL
)
1300 vlc_object_kill( id
);
1301 vlc_thread_join( id
);
1302 block_FifoRelease( id
->p_fifo
);
1305 vlc_mutex_lock( &p_sys
->lock_es
);
1306 TAB_REMOVE( p_sys
->i_es
, p_sys
->es
, id
);
1307 vlc_mutex_unlock( &p_sys
->lock_es
);
1310 if( id
->i_port
== var_GetInteger( p_stream
, "port-audio" ) )
1311 p_sys
->i_port_audio
= id
->i_port
;
1312 if( id
->i_port
== var_GetInteger( p_stream
, "port-video" ) )
1313 p_sys
->i_port_video
= id
->i_port
;
1314 /* Release dynamic payload type */
1315 if (id
->i_payload_type
>= 96)
1316 p_sys
->payload_bitmap
&= ~(1 << (id
->i_payload_type
- 96));
1318 free( id
->psz_fmtp
);
1321 RtspDelId( p_sys
->rtsp
, id
->rtsp_id
);
1323 rtp_del_sink( id
, id
->sinkv
[0].rtp_fd
); /* sink for explicit dst= */
1324 if( id
->listen_fd
!= NULL
)
1325 net_ListenClose( id
->listen_fd
);
1326 if( id
->srtp
!= NULL
)
1327 srtp_destroy( id
->srtp
);
1329 vlc_mutex_destroy( &id
->lock_sink
);
1331 /* Update SDP (sap/file) */
1332 if( p_sys
->b_export_sap
&& !p_sys
->p_mux
) SapSetup( p_stream
);
1333 if( p_sys
->b_export_sdp_file
) FileSetup( p_stream
);
1335 vlc_object_detach( id
);
1336 vlc_object_release( id
);
1340 static int Send( sout_stream_t
*p_stream
, sout_stream_id_t
*id
,
1345 assert( p_stream
->p_sys
->p_mux
== NULL
);
1348 while( p_buffer
!= NULL
)
1350 p_next
= p_buffer
->p_next
;
1351 if( id
->pf_packetize( id
, p_buffer
) )
1354 block_Release( p_buffer
);
1360 /****************************************************************************
1362 ****************************************************************************/
1363 static int SapSetup( sout_stream_t
*p_stream
)
1365 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1366 sout_instance_t
*p_sout
= p_stream
->p_sout
;
1368 /* Remove the previous session */
1369 if( p_sys
->p_session
!= NULL
)
1371 sout_AnnounceUnRegister( p_sout
, p_sys
->p_session
);
1372 p_sys
->p_session
= NULL
;
1375 if( ( p_sys
->i_es
> 0 || p_sys
->p_mux
) && p_sys
->psz_sdp
&& *p_sys
->psz_sdp
)
1377 announce_method_t
*p_method
= sout_SAPMethod();
1378 p_sys
->p_session
= sout_AnnounceRegisterSDP( p_sout
,
1380 p_sys
->psz_destination
,
1382 sout_MethodRelease( p_method
);
1388 /****************************************************************************
1390 ****************************************************************************/
1391 static int FileSetup( sout_stream_t
*p_stream
)
1393 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1396 if( ( f
= utf8_fopen( p_sys
->psz_sdp_file
, "wt" ) ) == NULL
)
1398 msg_Err( p_stream
, "cannot open file '%s' (%m)",
1399 p_sys
->psz_sdp_file
);
1400 return VLC_EGENERIC
;
1403 fputs( p_sys
->psz_sdp
, f
);
1409 /****************************************************************************
1411 ****************************************************************************/
1412 static int HttpCallback( httpd_file_sys_t
*p_args
,
1413 httpd_file_t
*, uint8_t *p_request
,
1414 uint8_t **pp_data
, int *pi_data
);
1416 static int HttpSetup( sout_stream_t
*p_stream
, const vlc_url_t
*url
)
1418 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1420 p_sys
->p_httpd_host
= httpd_HostNew( VLC_OBJECT(p_stream
), url
->psz_host
,
1421 url
->i_port
> 0 ? url
->i_port
: 80 );
1422 if( p_sys
->p_httpd_host
)
1424 p_sys
->p_httpd_file
= httpd_FileNew( p_sys
->p_httpd_host
,
1425 url
->psz_path
? url
->psz_path
: "/",
1428 HttpCallback
, (void*)p_sys
);
1430 if( p_sys
->p_httpd_file
== NULL
)
1432 return VLC_EGENERIC
;
1437 static int HttpCallback( httpd_file_sys_t
*p_args
,
1438 httpd_file_t
*f
, uint8_t *p_request
,
1439 uint8_t **pp_data
, int *pi_data
)
1441 VLC_UNUSED(f
); VLC_UNUSED(p_request
);
1442 sout_stream_sys_t
*p_sys
= (sout_stream_sys_t
*)p_args
;
1444 vlc_mutex_lock( &p_sys
->lock_sdp
);
1445 if( p_sys
->psz_sdp
&& *p_sys
->psz_sdp
)
1447 *pi_data
= strlen( p_sys
->psz_sdp
);
1448 *pp_data
= malloc( *pi_data
);
1449 memcpy( *pp_data
, p_sys
->psz_sdp
, *pi_data
);
1456 vlc_mutex_unlock( &p_sys
->lock_sdp
);
1461 /****************************************************************************
1463 ****************************************************************************/
1464 static void* ThreadSend( vlc_object_t
*p_this
)
1466 sout_stream_id_t
*id
= (sout_stream_id_t
*)p_this
;
1467 unsigned i_caching
= id
->i_caching
;
1471 block_t
*out
= block_FifoGet( id
->p_fifo
);
1472 block_cleanup_push (out
);
1475 { /* FIXME: this is awfully inefficient */
1476 size_t len
= out
->i_buffer
;
1477 out
= block_Realloc( out
, 0, len
+ 10 );
1478 out
->i_buffer
= len
;
1480 int canc
= vlc_savecancel ();
1481 int val
= srtp_send( id
->srtp
, out
->p_buffer
, &len
, len
+ 10 );
1482 vlc_restorecancel (canc
);
1486 msg_Dbg( id
, "SRTP sending error: %m" );
1487 block_Release( out
);
1491 out
->i_buffer
= len
;
1495 mwait (out
->i_dts
+ i_caching
);
1500 ssize_t len
= out
->i_buffer
;
1501 int canc
= vlc_savecancel ();
1503 vlc_mutex_lock( &id
->lock_sink
);
1504 unsigned deadc
= 0; /* How many dead sockets? */
1505 int deadv
[id
->sinkc
]; /* Dead sockets list */
1507 for( int i
= 0; i
< id
->sinkc
; i
++ )
1509 if( !id
->srtp
) /* FIXME: SRTCP support */
1510 SendRTCP( id
->sinkv
[i
].rtcp
, out
);
1512 if( send( id
->sinkv
[i
].rtp_fd
, out
->p_buffer
, len
, 0 ) >= 0 )
1514 /* Retry sending to root out soft-errors */
1515 if( send( id
->sinkv
[i
].rtp_fd
, out
->p_buffer
, len
, 0 ) >= 0 )
1518 deadv
[deadc
++] = id
->sinkv
[i
].rtp_fd
;
1520 vlc_mutex_unlock( &id
->lock_sink
);
1521 block_Release( out
);
1523 for( unsigned i
= 0; i
< deadc
; i
++ )
1525 msg_Dbg( id
, "removing socket %d", deadv
[i
] );
1526 rtp_del_sink( id
, deadv
[i
] );
1529 /* Hopefully we won't overflow the SO_MAXCONN accept queue */
1530 while( id
->listen_fd
!= NULL
)
1532 int fd
= net_Accept( id
, id
->listen_fd
, 0 );
1535 msg_Dbg( id
, "adding socket %d", fd
);
1536 rtp_add_sink( id
, fd
, true );
1538 vlc_restorecancel (canc
);
1543 int rtp_add_sink( sout_stream_id_t
*id
, int fd
, bool rtcp_mux
)
1545 rtp_sink_t sink
= { fd
, NULL
};
1546 sink
.rtcp
= OpenRTCP( VLC_OBJECT( id
->p_stream
), fd
, IPPROTO_UDP
,
1548 if( sink
.rtcp
== NULL
)
1549 msg_Err( id
, "RTCP failed!" );
1551 vlc_mutex_lock( &id
->lock_sink
);
1552 INSERT_ELEM( id
->sinkv
, id
->sinkc
, id
->sinkc
, sink
);
1553 vlc_mutex_unlock( &id
->lock_sink
);
1557 void rtp_del_sink( sout_stream_id_t
*id
, int fd
)
1559 rtp_sink_t sink
= { fd
, NULL
};
1561 /* NOTE: must be safe to use if fd is not included */
1562 vlc_mutex_lock( &id
->lock_sink
);
1563 for( int i
= 0; i
< id
->sinkc
; i
++ )
1565 if (id
->sinkv
[i
].rtp_fd
== fd
)
1567 sink
= id
->sinkv
[i
];
1568 REMOVE_ELEM( id
->sinkv
, id
->sinkc
, i
);
1572 vlc_mutex_unlock( &id
->lock_sink
);
1574 CloseRTCP( sink
.rtcp
);
1575 net_Close( sink
.rtp_fd
);
1578 uint16_t rtp_get_seq( const sout_stream_id_t
*id
)
1580 /* This will return values for the next packet.
1581 * Accounting for caching would not be totally trivial. */
1582 return id
->i_sequence
;
1585 /* FIXME: this is pretty bad - if we remove and then insert an ES
1586 * the number will get unsynched from inside RTSP */
1587 unsigned rtp_get_num( const sout_stream_id_t
*id
)
1589 sout_stream_sys_t
*p_sys
= id
->p_stream
->p_sys
;
1592 vlc_mutex_lock( &p_sys
->lock_es
);
1593 for( i
= 0; i
< p_sys
->i_es
; i
++ )
1595 if( id
== p_sys
->es
[i
] )
1598 vlc_mutex_unlock( &p_sys
->lock_es
);
1604 void rtp_packetize_common( sout_stream_id_t
*id
, block_t
*out
,
1605 int b_marker
, int64_t i_pts
)
1607 uint32_t i_timestamp
= i_pts
* (int64_t)id
->i_clock_rate
/ INT64_C(1000000);
1609 out
->p_buffer
[0] = 0x80;
1610 out
->p_buffer
[1] = (b_marker
?0x80:0x00)|id
->i_payload_type
;
1611 out
->p_buffer
[2] = ( id
->i_sequence
>> 8)&0xff;
1612 out
->p_buffer
[3] = ( id
->i_sequence
)&0xff;
1613 out
->p_buffer
[4] = ( i_timestamp
>> 24 )&0xff;
1614 out
->p_buffer
[5] = ( i_timestamp
>> 16 )&0xff;
1615 out
->p_buffer
[6] = ( i_timestamp
>> 8 )&0xff;
1616 out
->p_buffer
[7] = ( i_timestamp
)&0xff;
1618 memcpy( out
->p_buffer
+ 8, id
->ssrc
, 4 );
1624 void rtp_packetize_send( sout_stream_id_t
*id
, block_t
*out
)
1626 block_FifoPut( id
->p_fifo
, out
);
1630 * @return configured max RTP payload size (including payload type-specific
1631 * headers, excluding RTP and transport headers)
1633 size_t rtp_mtu (const sout_stream_id_t
*id
)
1635 return id
->i_mtu
- 12;
1638 /*****************************************************************************
1640 *****************************************************************************/
1642 /** Add an ES to a non-RTP muxed stream */
1643 static sout_stream_id_t
*MuxAdd( sout_stream_t
*p_stream
, es_format_t
*p_fmt
)
1645 sout_input_t
*p_input
;
1646 sout_mux_t
*p_mux
= p_stream
->p_sys
->p_mux
;
1647 assert( p_mux
!= NULL
);
1649 p_input
= sout_MuxAddStream( p_mux
, p_fmt
);
1650 if( p_input
== NULL
)
1652 msg_Err( p_stream
, "cannot add this stream to the muxer" );
1656 return (sout_stream_id_t
*)p_input
;
1660 static int MuxSend( sout_stream_t
*p_stream
, sout_stream_id_t
*id
,
1663 sout_mux_t
*p_mux
= p_stream
->p_sys
->p_mux
;
1664 assert( p_mux
!= NULL
);
1666 sout_MuxSendBuffer( p_mux
, (sout_input_t
*)id
, p_buffer
);
1671 /** Remove an ES from a non-RTP muxed stream */
1672 static int MuxDel( sout_stream_t
*p_stream
, sout_stream_id_t
*id
)
1674 sout_mux_t
*p_mux
= p_stream
->p_sys
->p_mux
;
1675 assert( p_mux
!= NULL
);
1677 sout_MuxDeleteStream( p_mux
, (sout_input_t
*)id
);
1682 static ssize_t
AccessOutGrabberWriteBuffer( sout_stream_t
*p_stream
,
1683 const block_t
*p_buffer
)
1685 sout_stream_sys_t
*p_sys
= p_stream
->p_sys
;
1686 sout_stream_id_t
*id
= p_sys
->es
[0];
1688 int64_t i_dts
= p_buffer
->i_dts
;
1690 uint8_t *p_data
= p_buffer
->p_buffer
;
1691 size_t i_data
= p_buffer
->i_buffer
;
1692 size_t i_max
= id
->i_mtu
- 12;
1694 size_t i_packet
= ( p_buffer
->i_buffer
+ i_max
- 1 ) / i_max
;
1700 /* output complete packet */
1701 if( p_sys
->packet
&&
1702 p_sys
->packet
->i_buffer
+ i_data
> i_max
)
1704 rtp_packetize_send( id
, p_sys
->packet
);
1705 p_sys
->packet
= NULL
;
1708 if( p_sys
->packet
== NULL
)
1710 /* allocate a new packet */
1711 p_sys
->packet
= block_New( p_stream
, id
->i_mtu
);
1712 rtp_packetize_common( id
, p_sys
->packet
, 1, i_dts
);
1713 p_sys
->packet
->i_dts
= i_dts
;
1714 p_sys
->packet
->i_length
= p_buffer
->i_length
/ i_packet
;
1715 i_dts
+= p_sys
->packet
->i_length
;
1718 i_size
= __MIN( i_data
,
1719 (unsigned)(id
->i_mtu
- p_sys
->packet
->i_buffer
) );
1721 memcpy( &p_sys
->packet
->p_buffer
[p_sys
->packet
->i_buffer
],
1724 p_sys
->packet
->i_buffer
+= i_size
;
1733 static ssize_t
AccessOutGrabberWrite( sout_access_out_t
*p_access
,
1736 sout_stream_t
*p_stream
= (sout_stream_t
*)p_access
->p_sys
;
1742 AccessOutGrabberWriteBuffer( p_stream
, p_buffer
);
1744 p_next
= p_buffer
->p_next
;
1745 block_Release( p_buffer
);
1753 static sout_access_out_t
*GrabberCreate( sout_stream_t
*p_stream
)
1755 sout_access_out_t
*p_grab
;
1757 p_grab
= vlc_object_create( p_stream
->p_sout
, sizeof( *p_grab
) );
1758 if( p_grab
== NULL
)
1761 p_grab
->p_module
= NULL
;
1762 p_grab
->psz_access
= strdup( "grab" );
1763 p_grab
->p_cfg
= NULL
;
1764 p_grab
->psz_path
= strdup( "" );
1765 p_grab
->p_sys
= (sout_access_out_sys_t
*)p_stream
;
1766 p_grab
->pf_seek
= NULL
;
1767 p_grab
->pf_write
= AccessOutGrabberWrite
;
1768 vlc_object_attach( p_grab
, p_stream
);