?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
demux: heif: send extradata with avif
[vlc.git] / modules / stream_out / rtp.c
blob3341bde9c5889925202eed2ec26364a12364419d
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
6 *
7 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8 * Pierre Ynard
9 *
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.
14 *
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.
19 *
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 *****************************************************************************/
24
25 /*****************************************************************************
26 * Preamble
27 *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #define VLC_MODULE_LICENSE VLC_LICENSE_GPL_2_PLUS
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
36 #include <vlc_sout.h>
37 #include <vlc_block.h>
38
39 #include <vlc_httpd.h>
40 #include <vlc_url.h>
41 #include <vlc_network.h>
42 #include <vlc_fs.h>
43 #include <vlc_rand.h>
44 #include <vlc_memstream.h>
45 #ifdef HAVE_SRTP
46 # include <srtp.h>
47 # include <gcrypt.h>
48 # include <vlc_gcrypt.h>
49 #endif
50
51 #include "rtp.h"
52
53 #include <sys/types.h>
54 #include <unistd.h>
55 #ifdef HAVE_ARPA_INET_H
56 # include <arpa/inet.h>
57 #endif
58 #ifdef HAVE_LINUX_DCCP_H
59 # include <linux/dccp.h>
60 #endif
61 #ifndef IPPROTO_DCCP
62 # define IPPROTO_DCCP 33
63 #endif
64 #ifndef IPPROTO_UDPLITE
65 # define IPPROTO_UDPLITE 136
66 #endif
67
68 #include <ctype.h>
69 #include <errno.h>
70 #include <assert.h>
71
72 /*****************************************************************************
73 * Module descriptor
74 *****************************************************************************/
75
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)." )
91
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)." )
113
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." )
123
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).")
129
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 " \
133 "as RTP packets." )
134
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." )
139
140 #define PROTO_TEXT N_("Transport protocol")
141 #define PROTO_LONGTEXT N_( \
142 "This selects which transport protocol to use for RTP." )
143
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.")
149
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.")
154
155 static const char *const ppsz_protos[] = {
156 "dccp", "sctp", "tcp", "udp", "udplite",
157 };
158
159 static const char *const ppsz_protocols[] = {
160 "DCCP", "SCTP", "TCP", "UDP", "UDP-Lite",
161 };
162
163 #define RFC3016_TEXT N_("MP4A LATM")
164 #define RFC3016_LONGTEXT N_( \
165 "This allows you to stream MPEG4 LATM audio streams (see RFC3016)." )
166
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 " \
171 "minute)." )
172
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." )
179
180 static int Open ( vlc_object_t * );
181 static void Close( vlc_object_t * );
182
183 #define SOUT_CFG_PREFIX "sout-rtp-"
184 #define MAX_EMPTY_BLOCKS 200
185
186 vlc_module_begin ()
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 )
193
194 add_string( SOUT_CFG_PREFIX "dst", "", DEST_TEXT,
195 DEST_LONGTEXT, true )
196 add_string( SOUT_CFG_PREFIX "sdp", "", SDP_TEXT,
197 SDP_LONGTEXT, true )
198 add_string( SOUT_CFG_PREFIX "mux", "", MUX_TEXT,
199 MUX_LONGTEXT, true )
200 add_bool( SOUT_CFG_PREFIX "sap", false, SAP_TEXT, SAP_LONGTEXT,
201 true )
202
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,
209 URL_LONGTEXT, true )
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 */
213
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 )
223
224 add_integer( SOUT_CFG_PREFIX "ttl", -1, TTL_TEXT,
225 TTL_LONGTEXT, true )
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 )
230
231 #ifdef HAVE_SRTP
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 )
236 #endif
237
238 add_bool( SOUT_CFG_PREFIX "mp4a-latm", false, RFC3016_TEXT,
239 RFC3016_LONGTEXT, false )
240
241 set_callbacks( Open, Close )
242
243 add_submodule ()
244 set_shortname( N_("RTSP VoD" ) )
245 set_description( N_("RTSP VoD server") )
246 set_category( CAT_SOUT )
247 set_subcategory( SUBCAT_SOUT_VOD )
248 set_capability( "vod server", 10 )
249 set_callbacks( OpenVoD, CloseVoD )
250 add_shortcut( "rtsp" )
251 add_integer( "rtsp-timeout", 60, RTSP_TIMEOUT_TEXT,
252 RTSP_TIMEOUT_LONGTEXT, true )
253 add_string( "sout-rtsp-user", "",
254 RTSP_USER_TEXT, RTSP_USER_LONGTEXT, true )
255 add_password("sout-rtsp-pwd", "", RTSP_PASS_TEXT, RTSP_PASS_LONGTEXT)
256
257 vlc_module_end ()
258
259 /*****************************************************************************
260 * Exported prototypes
261 *****************************************************************************/
262 static const char *const ppsz_sout_options[] = {
263 "dst", "name", "cat", "port", "port-audio", "port-video", "*sdp", "ttl",
264 "mux", "sap", "description", "url", "email",
265 "proto", "rtcp-mux", "caching",
266 #ifdef HAVE_SRTP
267 "key", "salt",
268 #endif
269 "mp4a-latm", NULL
270 };
271
272 static void *Add( sout_stream_t *, const es_format_t * );
273 static void Del( sout_stream_t *, void * );
274 static int Send( sout_stream_t *, void *, block_t * );
275
276 static void *MuxAdd( sout_stream_t *, const es_format_t * );
277 static void MuxDel( sout_stream_t *, void * );
278 static int MuxSend( sout_stream_t *, void *, block_t * );
279
280 static sout_access_out_t *GrabberCreate( sout_stream_t *p_sout );
281 static void* ThreadSend( void * );
282 static void *rtp_listen_thread( void * );
283
284 static void SDPHandleUrl( sout_stream_t *, const char * );
285
286 static int SapSetup( sout_stream_t *p_stream );
287 static int FileSetup( sout_stream_t *p_stream );
288 static int HttpSetup( sout_stream_t *p_stream, const vlc_url_t * );
289
290 static vlc_tick_t rtp_init_ts( const vod_media_t *p_media,
291 const char *psz_vod_session );
292
293 typedef struct
294 {
295 /* SDP */
296 char *psz_sdp;
297 vlc_mutex_t lock_sdp;
298
299 /* SDP to disk */
300 char *psz_sdp_file;
301
302 /* SDP via SAP */
303 bool b_export_sap;
304 session_descriptor_t *p_session;
305
306 /* SDP via HTTP */
307 httpd_host_t *p_httpd_host;
308 httpd_file_t *p_httpd_file;
309
310 /* RTSP */
311 rtsp_stream_t *rtsp;
312
313 /* RTSP NPT and timestamp computations */
314 vlc_tick_t i_npt_zero; /* when NPT=0 packet is sent */
315 vlc_tick_t i_pts_zero; /* predicts PTS of NPT=0 packet */
316 vlc_tick_t i_pts_offset; /* matches actual PTS to prediction */
317 vlc_mutex_t lock_ts;
318
319 /* */
320 char *psz_destination;
321 uint16_t i_port;
322 uint16_t i_port_audio;
323 uint16_t i_port_video;
324 uint8_t proto;
325 bool rtcp_mux;
326 bool b_latm;
327
328 /* VoD */
329 vod_media_t *p_vod_media;
330 char *psz_vod_session;
331
332 /* in case we do TS/PS over rtp */
333 sout_mux_t *p_mux;
334 sout_access_out_t *p_grab;
335 block_t *packet;
336
337 /* */
338 vlc_mutex_t lock_es;
339 int i_es;
340 sout_stream_id_sys_t **es;
341 } sout_stream_sys_t;
342
343 typedef struct rtp_sink_t
344 {
345 int rtp_fd;
346 rtcp_sender_t *rtcp;
347 } rtp_sink_t;
348
349 struct sout_stream_id_sys_t
350 {
351 sout_stream_t *p_stream;
352 /* rtp field */
353 /* For RFC 4175, seqnum is extended to 32-bits */
354 uint32_t i_sequence;
355 bool b_first_packet;
356 bool b_ts_init;
357 uint32_t i_ts_offset;
358 uint8_t ssrc[4];
359
360 /* for rtsp */
361 uint16_t i_seq_sent_next;
362
363 /* for sdp */
364 rtp_format_t rtp_fmt;
365 int i_port;
366
367 /* Packetizer specific fields */
368 int i_mtu;
369 #ifdef HAVE_SRTP
370 srtp_session_t *srtp;
371 #endif
372
373 /* Packets sinks */
374 vlc_thread_t thread;
375 vlc_mutex_t lock_sink;
376 int sinkc;
377 rtp_sink_t *sinkv;
378 rtsp_stream_id_t *rtsp_id;
379 struct {
380 int *fd;
381 vlc_thread_t thread;
382 } listen;
383
384 block_fifo_t *p_fifo;
385 vlc_tick_t i_caching;
386 };
387
388 /*****************************************************************************
389 * Open:
390 *****************************************************************************/
391 static int Open( vlc_object_t *p_this )
392 {
393 sout_stream_t *p_stream = (sout_stream_t*)p_this;
394 sout_stream_sys_t *p_sys = NULL;
395 char *psz;
396 bool b_rtsp = false;
397
398 config_ChainParse( p_stream, SOUT_CFG_PREFIX,
399 ppsz_sout_options, p_stream->p_cfg );
400
401 p_sys = malloc( sizeof( sout_stream_sys_t ) );
402 if( p_sys == NULL )
403 return VLC_ENOMEM;
404
405 p_sys->psz_destination = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "dst" );
406
407 p_sys->i_port = var_GetInteger( p_stream, SOUT_CFG_PREFIX "port" );
408 p_sys->i_port_audio = var_GetInteger( p_stream, SOUT_CFG_PREFIX "port-audio" );
409 p_sys->i_port_video = var_GetInteger( p_stream, SOUT_CFG_PREFIX "port-video" );
410 p_sys->rtcp_mux = var_GetBool( p_stream, SOUT_CFG_PREFIX "rtcp-mux" );
411
412 if( p_sys->i_port_audio && p_sys->i_port_video == p_sys->i_port_audio )
413 {
414 msg_Err( p_stream, "audio and video RTP port must be distinct" );
415 free( p_sys->psz_destination );
416 free( p_sys );
417 return VLC_EGENERIC;
418 }
419
420 for( config_chain_t *p_cfg = p_stream->p_cfg; p_cfg != NULL; p_cfg = p_cfg->p_next )
421 {
422 if( !strcmp( p_cfg->psz_name, "sdp" )
423 && ( p_cfg->psz_value != NULL )
424 && !strncasecmp( p_cfg->psz_value, "rtsp:", 5 ) )
425 {
426 b_rtsp = true;
427 break;
428 }
429 }
430 if( !b_rtsp )
431 {
432 psz = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "sdp" );
433 if( psz != NULL )
434 {
435 if( !strncasecmp( psz, "rtsp:", 5 ) )
436 b_rtsp = true;
437 free( psz );
438 }
439 }
440
441 /* Transport protocol */
442 p_sys->proto = IPPROTO_UDP;
443 psz = var_GetNonEmptyString (p_stream, SOUT_CFG_PREFIX"proto");
444
445 if ((psz == NULL) || !strcasecmp (psz, "udp"))
446 (void)0; /* default */
447 else
448 if (!strcasecmp (psz, "dccp"))
449 {
450 p_sys->proto = IPPROTO_DCCP;
451 p_sys->rtcp_mux = true; /* Force RTP/RTCP mux */
452 }
453 #if 0
454 else
455 if (!strcasecmp (psz, "sctp"))
456 {
457 p_sys->proto = IPPROTO_TCP;
458 p_sys->rtcp_mux = true; /* Force RTP/RTCP mux */
459 }
460 #endif
461 #if 0
462 else
463 if (!strcasecmp (psz, "tcp"))
464 {
465 p_sys->proto = IPPROTO_TCP;
466 p_sys->rtcp_mux = true; /* Force RTP/RTCP mux */
467 }
468 #endif
469 else
470 if (!strcasecmp (psz, "udplite") || !strcasecmp (psz, "udp-lite"))
471 p_sys->proto = IPPROTO_UDPLITE;
472 else
473 msg_Warn (p_this, "unknown or unsupported transport protocol \"%s\"",
474 psz);
475 free (psz);
476 var_Create (p_this, "dccp-service", VLC_VAR_STRING);
477
478 p_sys->p_vod_media = NULL;
479 p_sys->psz_vod_session = NULL;
480
481 if (! strcmp(p_stream->psz_name, "vod"))
482 {
483 /* The VLM stops all instances before deleting a media, so this
484 * reference will remain valid during the lifetime of the rtp
485 * stream output. */
486 p_sys->p_vod_media = var_InheritAddress(p_stream, "vod-media");
487
488 if (p_sys->p_vod_media != NULL)
489 {
490 p_sys->psz_vod_session = var_InheritString(p_stream, "vod-session");
491 if (p_sys->psz_vod_session == NULL)
492 {
493 msg_Err(p_stream, "missing VoD session");
494 free(p_sys);
495 return VLC_EGENERIC;
496 }
497
498 const char *mux = vod_get_mux(p_sys->p_vod_media);
499 var_SetString(p_stream, SOUT_CFG_PREFIX "mux", mux);
500 }
501 }
502
503 if( p_sys->psz_destination == NULL && !b_rtsp
504 && p_sys->p_vod_media == NULL )
505 {
506 msg_Err( p_stream, "missing destination and not in RTSP mode" );
507 free( p_sys );
508 return VLC_EGENERIC;
509 }
510
511 int i_ttl = var_GetInteger( p_stream, SOUT_CFG_PREFIX "ttl" );
512 if( i_ttl != -1 )
513 {
514 var_Create( p_stream, "ttl", VLC_VAR_INTEGER );
515 var_SetInteger( p_stream, "ttl", i_ttl );
516 }
517
518 p_sys->b_latm = var_GetBool( p_stream, SOUT_CFG_PREFIX "mp4a-latm" );
519
520 /* NPT=0 time will be determined when we packetize the first packet
521 * (of any ES). But we want to be able to report rtptime in RTSP
522 * without waiting (and already did in the VoD case). So until then,
523 * we use an arbitrary reference PTS for timestamp computations, and
524 * then actual PTS will catch up using offsets. */
525 p_sys->i_npt_zero = VLC_TICK_INVALID;
526 p_sys->i_pts_zero = rtp_init_ts(p_sys->p_vod_media,
527 p_sys->psz_vod_session);
528 p_sys->i_es = 0;
529 p_sys->es = NULL;
530 p_sys->rtsp = NULL;
531 p_sys->psz_sdp = NULL;
532
533 p_sys->b_export_sap = false;
534 p_sys->p_session = NULL;
535 p_sys->psz_sdp_file = NULL;
536
537 p_sys->p_httpd_host = NULL;
538 p_sys->p_httpd_file = NULL;
539
540 p_stream->p_sys = p_sys;
541
542 vlc_mutex_init( &p_sys->lock_sdp );
543 vlc_mutex_init( &p_sys->lock_ts );
544 vlc_mutex_init( &p_sys->lock_es );
545
546 psz = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "mux" );
547 if( psz != NULL )
548 {
549 /* Check muxer type */
550 if( strncasecmp( psz, "ps", 2 )
551 && strncasecmp( psz, "mpeg1", 5 )
552 && strncasecmp( psz, "ts", 2 ) )
553 {
554 msg_Err( p_stream, "unsupported muxer type for RTP (only TS/PS)" );
555 free( psz );
556 vlc_mutex_destroy( &p_sys->lock_sdp );
557 vlc_mutex_destroy( &p_sys->lock_ts );
558 vlc_mutex_destroy( &p_sys->lock_es );
559 free( p_sys->psz_vod_session );
560 free( p_sys->psz_destination );
561 free( p_sys );
562 return VLC_EGENERIC;
563 }
564
565 p_sys->p_grab = GrabberCreate( p_stream );
566 p_sys->p_mux = sout_MuxNew( p_stream->p_sout, psz, p_sys->p_grab );
567 free( psz );
568
569 if( p_sys->p_mux == NULL )
570 {
571 msg_Err( p_stream, "cannot create muxer" );
572 sout_AccessOutDelete( p_sys->p_grab );
573 vlc_mutex_destroy( &p_sys->lock_sdp );
574 vlc_mutex_destroy( &p_sys->lock_ts );
575 vlc_mutex_destroy( &p_sys->lock_es );
576 free( p_sys->psz_vod_session );
577 free( p_sys->psz_destination );
578 free( p_sys );
579 return VLC_EGENERIC;
580 }
581
582 p_sys->packet = NULL;
583
584 p_stream->pf_add = MuxAdd;
585 p_stream->pf_del = MuxDel;
586 p_stream->pf_send = MuxSend;
587 }
588 else
589 {
590 p_sys->p_mux = NULL;
591 p_sys->p_grab = NULL;
592
593 p_stream->pf_add = Add;
594 p_stream->pf_del = Del;
595 p_stream->pf_send = Send;
596 }
597 p_stream->pace_nocontrol = true;
598
599 if( var_GetBool( p_stream, SOUT_CFG_PREFIX"sap" ) )
600 SDPHandleUrl( p_stream, "sap" );
601
602 psz = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "sdp" );
603 if( psz != NULL )
604 {
605 config_chain_t *p_cfg;
606
607 SDPHandleUrl( p_stream, psz );
608
609 for( p_cfg = p_stream->p_cfg; p_cfg != NULL; p_cfg = p_cfg->p_next )
610 {
611 if( !strcmp( p_cfg->psz_name, "sdp" ) )
612 {
613 if( p_cfg->psz_value == NULL || *p_cfg->psz_value == '\0' )
614 continue;
615
616 /* needed both :sout-rtp-sdp= and rtp{sdp=} can be used */
617 if( !strcmp( p_cfg->psz_value, psz ) )
618 continue;
619
620 SDPHandleUrl( p_stream, p_cfg->psz_value );
621 }
622 }
623 free( psz );
624 }
625
626 if( p_sys->p_mux != NULL )
627 {
628 sout_stream_id_sys_t *id = Add( p_stream, NULL );
629 if( id == NULL )
630 {
631 Close( p_this );
632 return VLC_EGENERIC;
633 }
634 }
635
636 return VLC_SUCCESS;
637 }
638
639 /*****************************************************************************
640 * Close:
641 *****************************************************************************/
642 static void Close( vlc_object_t * p_this )
643 {
644 sout_stream_t *p_stream = (sout_stream_t*)p_this;
645 sout_stream_sys_t *p_sys = p_stream->p_sys;
646
647 if( p_sys->p_mux )
648 {
649 assert( p_sys->i_es <= 1 );
650
651 sout_MuxDelete( p_sys->p_mux );
652 if ( p_sys->i_es > 0 )
653 Del( p_stream, p_sys->es[0] );
654 sout_AccessOutDelete( p_sys->p_grab );
655
656 if( p_sys->packet )
657 {
658 block_Release( p_sys->packet );
659 }
660 }
661
662 if( p_sys->rtsp != NULL )
663 RtspUnsetup( p_sys->rtsp );
664
665 vlc_mutex_destroy( &p_sys->lock_sdp );
666 vlc_mutex_destroy( &p_sys->lock_ts );
667 vlc_mutex_destroy( &p_sys->lock_es );
668
669 if( p_sys->p_httpd_file )
670 httpd_FileDelete( p_sys->p_httpd_file );
671
672 if( p_sys->p_httpd_host )
673 httpd_HostDelete( p_sys->p_httpd_host );
674
675 free( p_sys->psz_sdp );
676
677 if( p_sys->psz_sdp_file != NULL )
678 {
679 unlink( p_sys->psz_sdp_file );
680 free( p_sys->psz_sdp_file );
681 }
682 free( p_sys->psz_vod_session );
683 free( p_sys->psz_destination );
684 free( p_sys );
685 }
686
687 /*****************************************************************************
688 * SDPHandleUrl:
689 *****************************************************************************/
690 static void SDPHandleUrl( sout_stream_t *p_stream, const char *psz_url )
691 {
692 sout_stream_sys_t *p_sys = p_stream->p_sys;
693 vlc_url_t url;
694
695 vlc_UrlParse( &url, psz_url );
696 if( url.psz_protocol && !strcasecmp( url.psz_protocol, "http" ) )
697 {
698 if( p_sys->p_httpd_file )
699 {
700 msg_Err( p_stream, "you can use sdp=http:// only once" );
701 goto out;
702 }
703
704 if( HttpSetup( p_stream, &url ) )
705 {
706 msg_Err( p_stream, "cannot export SDP as HTTP" );
707 }
708 }
709 else if( url.psz_protocol && !strcasecmp( url.psz_protocol, "rtsp" ) )
710 {
711 if( p_sys->rtsp != NULL )
712 {
713 msg_Err( p_stream, "you can use sdp=rtsp:// only once" );
714 goto out;
715 }
716
717 if( url.psz_host != NULL && *url.psz_host )
718 {
719 msg_Warn( p_stream, "\"%s\" RTSP host might be ignored in "
720 "multiple-host configurations, use at your own risks.",
721 url.psz_host );
722 msg_Info( p_stream, "Consider passing --rtsp-host=IP on the "
723 "command line instead." );
724
725 var_Create( p_stream, "rtsp-host", VLC_VAR_STRING );
726 var_SetString( p_stream, "rtsp-host", url.psz_host );
727 }
728 if( url.i_port != 0 )
729 {
730 /* msg_Info( p_stream, "Consider passing --rtsp-port=%u on "
731 "the command line instead.", url.i_port ); */
732
733 var_Create( p_stream, "rtsp-port", VLC_VAR_INTEGER );
734 var_SetInteger( p_stream, "rtsp-port", url.i_port );
735 }
736
737 p_sys->rtsp = RtspSetup( VLC_OBJECT(p_stream), NULL, url.psz_path );
738 if( p_sys->rtsp == NULL )
739 msg_Err( p_stream, "cannot export SDP as RTSP" );
740 }
741 else if( ( url.psz_protocol && !strcasecmp( url.psz_protocol, "sap" ) ) ||
742 ( url.psz_host && !strcasecmp( url.psz_host, "sap" ) ) )
743 {
744 p_sys->b_export_sap = true;
745 SapSetup( p_stream );
746 }
747 else if( url.psz_protocol && !strcasecmp( url.psz_protocol, "file" ) )
748 {
749 if( p_sys->psz_sdp_file != NULL )
750 {
751 msg_Err( p_stream, "you can use sdp=file:// only once" );
752 goto out;
753 }
754 p_sys->psz_sdp_file = vlc_uri2path( psz_url );
755 if( p_sys->psz_sdp_file == NULL )
756 goto out;
757 FileSetup( p_stream );
758 }
759 else
760 {
761 msg_Warn( p_stream, "unknown protocol for SDP (%s)",
762 url.psz_protocol );
763 }
764
765 out:
766 vlc_UrlClean( &url );
767 }
768
769 /*****************************************************************************
770 * SDPGenerate
771 *****************************************************************************/
772 /*static*/
773 char *SDPGenerate( sout_stream_t *p_stream, const char *rtsp_url )
774 {
775 sout_stream_sys_t *p_sys = p_stream->p_sys;
776 struct vlc_memstream sdp;
777 struct sockaddr_storage dst;
778 char *psz_sdp = NULL;
779 socklen_t dstlen;
780 int i;
781 /*
782 * When we have a fixed destination (typically when we do multicast),
783 * we need to put the actual port numbers in the SDP.
784 * When there is no fixed destination, we only support RTSP unicast
785 * on-demand setup, so we should rather let the clients decide which ports
786 * to use.
787 * When there is both a fixed destination and RTSP unicast, we need to
788 * put port numbers used by the fixed destination, otherwise the SDP would
789 * become totally incorrect for multicast use. It should be noted that
790 * port numbers from SDP with RTSP are only "recommendation" from the
791 * server to the clients (per RFC2326), so only broken clients will fail
792 * to handle this properly. There is no solution but to use two differents
793 * output chain with two different RTSP URLs if you need to handle this
794 * scenario.
795 */
796 int inclport;
797
798 vlc_mutex_lock( &p_sys->lock_es );
799 if( unlikely(p_sys->i_es == 0 || (rtsp_url != NULL && !p_sys->es[0]->rtsp_id)) )
800 goto out; /* hmm... */
801
802 if( p_sys->psz_destination != NULL )
803 {
804 inclport = 1;
805
806 /* Oh boy, this is really ugly! */
807 dstlen = sizeof( dst );
808 if( p_sys->es[0]->listen.fd != NULL )
809 getsockname( p_sys->es[0]->listen.fd[0],
810 (struct sockaddr *)&dst, &dstlen );
811 else
812 getpeername( p_sys->es[0]->sinkv[0].rtp_fd,
813 (struct sockaddr *)&dst, &dstlen );
814 }
815 else
816 {
817 inclport = 0;
818
819 /* Check against URL format rtsp://[<ipv6>]:<port>/<path> */
820 bool ipv6 = rtsp_url != NULL && strlen( rtsp_url ) > 7
821 && rtsp_url[7] == '[';
822
823 /* Dummy destination address for RTSP */
824 dstlen = ipv6 ? sizeof( struct sockaddr_in6 )
825 : sizeof( struct sockaddr_in );
826 memset (&dst, 0, dstlen);
827 dst.ss_family = ipv6 ? AF_INET6 : AF_INET;
828 #ifdef HAVE_SA_LEN
829 dst.ss_len = dstlen;
830 #endif
831 }
832
833 if( vlc_sdp_Start( &sdp, VLC_OBJECT( p_stream ), SOUT_CFG_PREFIX,
834 NULL, 0, (struct sockaddr *)&dst, dstlen ) )
835 goto out;
836
837 /* TODO: a=source-filter */
838 if( p_sys->rtcp_mux )
839 sdp_AddAttribute( &sdp, "rtcp-mux", NULL );
840
841 if( rtsp_url != NULL )
842 sdp_AddAttribute ( &sdp, "control", "%s", rtsp_url );
843
844 const char *proto = "RTP/AVP"; /* protocol */
845 if( rtsp_url == NULL )
846 {
847 switch( p_sys->proto )
848 {
849 case IPPROTO_UDP:
850 break;
851 case IPPROTO_TCP:
852 proto = "TCP/RTP/AVP";
853 break;
854 case IPPROTO_DCCP:
855 proto = "DCCP/RTP/AVP";
856 break;
857 case IPPROTO_UDPLITE:
858 return psz_sdp;
859 }
860 }
861
862 for( i = 0; i < p_sys->i_es; i++ )
863 {
864 sout_stream_id_sys_t *id = p_sys->es[i];
865 rtp_format_t *rtp_fmt = &id->rtp_fmt;
866 const char *mime_major; /* major MIME type */
867
868 switch( rtp_fmt->cat )
869 {
870 case VIDEO_ES:
871 mime_major = "video";
872 break;
873 case AUDIO_ES:
874 mime_major = "audio";
875 break;
876 case SPU_ES:
877 mime_major = "text";
878 break;
879 default:
880 continue;
881 }
882
883 sdp_AddMedia( &sdp, mime_major, proto, inclport * id->i_port,
884 rtp_fmt->payload_type, false, rtp_fmt->bitrate,
885 rtp_fmt->ptname, rtp_fmt->clock_rate, rtp_fmt->channels,
886 rtp_fmt->fmtp);
887
888 /* cf RFC4566 §5.14 */
889 if( inclport && !p_sys->rtcp_mux && (id->i_port & 1) )
890 sdp_AddAttribute( &sdp, "rtcp", "%u", id->i_port + 1 );
891
892 if( rtsp_url != NULL )
893 {
894 char *track_url = RtspAppendTrackPath( id->rtsp_id, rtsp_url );
895 if( track_url != NULL )
896 {
897 sdp_AddAttribute( &sdp, "control", "%s", track_url );
898 free( track_url );
899 }
900 }
901 else
902 {
903 if( id->listen.fd != NULL )
904 sdp_AddAttribute( &sdp, "setup", "passive" );
905 if( p_sys->proto == IPPROTO_DCCP )
906 sdp_AddAttribute( &sdp, "dccp-service-code", "SC:RTP%c",
907 toupper( (unsigned char)mime_major[0] ) );
908 }
909 }
910
911 if( vlc_memstream_close( &sdp ) == 0 )
912 psz_sdp = sdp.ptr;
913 out:
914 vlc_mutex_unlock( &p_sys->lock_es );
915 return psz_sdp;
916 }
917
918 /*****************************************************************************
919 * RTP mux
920 *****************************************************************************/
921
922 /**
923 * Shrink the MTU down to a fixed packetization time (for audio).
924 */
925 static void
926 rtp_set_ptime (sout_stream_id_sys_t *id, unsigned ptime_ms, size_t bytes)
927 {
928 /* Samples per second */
929 size_t spl = (id->rtp_fmt.clock_rate - 1) * ptime_ms / 1000 + 1;
930 bytes *= id->rtp_fmt.channels;
931 spl *= bytes;
932
933 if (spl < rtp_mtu (id)) /* MTU is big enough for ptime */
934 id->i_mtu = 12 + spl;
935 else /* MTU is too small for ptime, align to a sample boundary */
936 id->i_mtu = 12 + (((id->i_mtu - 12) / bytes) * bytes);
937 }
938
939 uint32_t rtp_compute_ts( unsigned i_clock_rate, vlc_tick_t i_pts )
940 {
941 /* This is an overflow-proof way of doing:
942 * return i_pts * (int64_t)i_clock_rate / CLOCK_FREQ;
943 *
944 * NOTE: this plays nice with offsets because the (equivalent)
945 * calculations are linear. */
946 lldiv_t q = lldiv(i_pts, CLOCK_FREQ);
947 return q.quot * (int64_t)i_clock_rate
948 + q.rem * (int64_t)i_clock_rate / CLOCK_FREQ;
949 }
950
951 /** Add an ES as a new RTP stream */
952 static void *Add( sout_stream_t *p_stream, const es_format_t *p_fmt )
953 {
954 /* NOTE: As a special case, if we use a non-RTP
955 * mux (TS/PS), then p_fmt is NULL. */
956 sout_stream_sys_t *p_sys = p_stream->p_sys;
957 char *psz_sdp;
958
959 sout_stream_id_sys_t *id = malloc( sizeof( *id ) );
960 if( unlikely(id == NULL) )
961 return NULL;
962 id->p_stream = p_stream;
963
964 id->i_mtu = var_InheritInteger( p_stream, "mtu" );
965 if( id->i_mtu <= 12 + 16 )
966 id->i_mtu = 576 - 20 - 8; /* pessimistic */
967 msg_Dbg( p_stream, "maximum RTP packet size: %d bytes", id->i_mtu );
968
969 #ifdef HAVE_SRTP
970 id->srtp = NULL;
971 #endif
972 vlc_mutex_init( &id->lock_sink );
973 id->sinkc = 0;
974 id->sinkv = NULL;
975 id->rtsp_id = NULL;
976 id->p_fifo = NULL;
977 id->listen.fd = NULL;
978
979 id->b_first_packet = true;
980 id->i_caching =
981 VLC_TICK_FROM_MS(var_GetInteger( p_stream, SOUT_CFG_PREFIX "caching"));
982
983 vlc_rand_bytes (&id->i_sequence, sizeof (id->i_sequence));
984 vlc_rand_bytes (id->ssrc, sizeof (id->ssrc));
985
986 bool format = false;
987
988 if (p_sys->p_vod_media != NULL)
989 {
990 id->rtp_fmt.ptname = NULL;
991 uint32_t ssrc;
992 int val = vod_init_id(p_sys->p_vod_media, p_sys->psz_vod_session,
993 p_fmt ? p_fmt->i_id : 0, id, &id->rtp_fmt,
994 &ssrc, &id->i_seq_sent_next);
995 if (val == VLC_SUCCESS)
996 {
997 memcpy(id->ssrc, &ssrc, sizeof(id->ssrc));
998 /* This is ugly, but id->i_seq_sent_next needs to be
999 * initialized inside vod_init_id() to avoid race
1000 * conditions. */
1001 id->i_sequence = id->i_seq_sent_next;
1002 }
1003 /* vod_init_id() may fail either because the ES wasn't found in
1004 * the VoD media, or because the RTSP session is gone. In the
1005 * former case, id->rtp_fmt was left untouched. */
1006 format = (id->rtp_fmt.ptname != NULL);
1007 }
1008
1009 if (!format)
1010 {
1011 id->rtp_fmt.fmtp = NULL; /* don't free() garbage on error */
1012 char *psz = var_GetNonEmptyString( p_stream, SOUT_CFG_PREFIX "mux" );
1013 if (p_fmt == NULL && psz == NULL)
1014 goto error;
1015 int val = rtp_get_fmt(VLC_OBJECT(p_stream), p_fmt, psz, &id->rtp_fmt);
1016 free( psz );
1017 if (val != VLC_SUCCESS)
1018 goto error;
1019 }
1020
1021 #ifdef HAVE_SRTP
1022 char *key = var_GetNonEmptyString (p_stream, SOUT_CFG_PREFIX"key");
1023 if (key)
1024 {
1025 vlc_gcrypt_init ();
1026 id->srtp = srtp_create (SRTP_ENCR_AES_CM, SRTP_AUTH_HMAC_SHA1, 10,
1027 SRTP_PRF_AES_CM, SRTP_RCC_MODE1);
1028 if (id->srtp == NULL)
1029 {
1030 free (key);
1031 goto error;
1032 }
1033
1034 char *salt = var_GetNonEmptyString (p_stream, SOUT_CFG_PREFIX"salt");
1035 int val = srtp_setkeystring (id->srtp, key, salt ? salt : "");
1036 free (salt);
1037 free (key);
1038 if (val)
1039 {
1040 msg_Err (p_stream, "bad SRTP key/salt combination (%s)",
1041 vlc_strerror_c(val));
1042 goto error;
1043 }
1044 id->i_sequence = 0; /* FIXME: awful hack for libvlc_srtp */
1045 }
1046 #endif
1047
1048 id->i_seq_sent_next = id->i_sequence;
1049
1050 int mcast_fd = -1;
1051 if( p_sys->psz_destination != NULL )
1052 {
1053 /* Choose the port */
1054 uint16_t i_port = 0;
1055 if( p_fmt == NULL )
1056 ;
1057 else
1058 if( p_fmt->i_cat == AUDIO_ES && p_sys->i_port_audio > 0 )
1059 i_port = p_sys->i_port_audio;
1060 else
1061 if( p_fmt->i_cat == VIDEO_ES && p_sys->i_port_video > 0 )
1062 i_port = p_sys->i_port_video;
1063
1064 /* We do not need the ES lock (p_sys->lock_es) here, because
1065 * this is the only one thread that can *modify* the ES table.
1066 * The ES lock protects the other threads from our modifications
1067 * (TAB_APPEND, TAB_REMOVE). */
1068 for (int i = 0; i_port && (i < p_sys->i_es); i++)
1069 if (i_port == p_sys->es[i]->i_port)
1070 i_port = 0; /* Port already in use! */
1071 for (uint16_t p = p_sys->i_port; i_port == 0; p += 2)
1072 {
1073 if (p == 0)
1074 {
1075 msg_Err (p_stream, "too many RTP elementary streams");
1076 goto error;
1077 }
1078 i_port = p;
1079 for (int i = 0; i_port && (i < p_sys->i_es); i++)
1080 if (p == p_sys->es[i]->i_port)
1081 i_port = 0;
1082 }
1083
1084 id->i_port = i_port;
1085
1086 int type = SOCK_STREAM;
1087
1088 switch( p_sys->proto )
1089 {
1090 #ifdef SOCK_DCCP
1091 case IPPROTO_DCCP:
1092 {
1093 const char *code;
1094 switch (id->rtp_fmt.cat)
1095 {
1096 case VIDEO_ES: code = "RTPV"; break;
1097 case AUDIO_ES: code = "RTPARTPV"; break;
1098 case SPU_ES: code = "RTPTRTPV"; break;
1099 default: code = "RTPORTPV"; break;
1100 }
1101 var_SetString (p_stream, "dccp-service", code);
1102 type = SOCK_DCCP;
1103 }
1104 #endif
1105 /* fall through */
1106 case IPPROTO_TCP:
1107 id->listen.fd = net_Listen( VLC_OBJECT(p_stream),
1108 p_sys->psz_destination, i_port,
1109 type, p_sys->proto );
1110 if( id->listen.fd == NULL )
1111 {
1112 msg_Err( p_stream, "passive COMEDIA RTP socket failed" );
1113 goto error;
1114 }
1115 if( vlc_clone( &id->listen.thread, rtp_listen_thread, id,
1116 VLC_THREAD_PRIORITY_LOW ) )
1117 {
1118 net_ListenClose( id->listen.fd );
1119 id->listen.fd = NULL;
1120 goto error;
1121 }
1122 break;
1123
1124 default:
1125 {
1126 int fd = net_ConnectDgram( p_stream, p_sys->psz_destination,
1127 i_port, -1, p_sys->proto );
1128 if( fd == -1 )
1129 {
1130 msg_Err( p_stream, "cannot create RTP socket" );
1131 goto error;
1132 }
1133 /* Ignore any unexpected incoming packet (including RTCP-RR
1134 * packets in case of rtcp-mux) */
1135 setsockopt (fd, SOL_SOCKET, SO_RCVBUF, &(int){ 0 },
1136 sizeof (int));
1137 rtp_add_sink( id, fd, p_sys->rtcp_mux, NULL );
1138 /* FIXME: test if this is multicast */
1139 mcast_fd = fd;
1140 }
1141 }
1142 }
1143
1144 if( p_fmt != NULL )
1145 switch( p_fmt->i_codec )
1146 {
1147 case VLC_CODEC_MULAW:
1148 case VLC_CODEC_ALAW:
1149 case VLC_CODEC_U8:
1150 rtp_set_ptime (id, 20, 1);
1151 break;
1152 case VLC_CODEC_S16B:
1153 case VLC_CODEC_S16L:
1154 rtp_set_ptime (id, 20, 2);
1155 break;
1156 case VLC_CODEC_S24B:
1157 rtp_set_ptime (id, 20, 3);
1158 break;
1159 default:
1160 break;
1161 }
1162
1163 #if 0 /* No payload formats sets this at the moment */
1164 int cscov = -1;
1165 if( cscov != -1 )
1166 cscov += 8 /* UDP */ + 12 /* RTP */;
1167 if( id->sinkc > 0 )
1168 net_SetCSCov( id->sinkv[0].rtp_fd, cscov, -1 );
1169 #endif
1170
1171 vlc_mutex_lock( &p_sys->lock_ts );
1172 id->b_ts_init = ( p_sys->i_npt_zero != VLC_TICK_INVALID );
1173 vlc_mutex_unlock( &p_sys->lock_ts );
1174 if( id->b_ts_init )
1175 id->i_ts_offset = rtp_compute_ts( id->rtp_fmt.clock_rate,
1176 p_sys->i_pts_offset );
1177
1178 if( p_sys->rtsp != NULL )
1179 id->rtsp_id = RtspAddId( p_sys->rtsp, id, GetDWBE( id->ssrc ),
1180 id->rtp_fmt.clock_rate, mcast_fd );
1181
1182 id->p_fifo = block_FifoNew();
1183 if( unlikely(id->p_fifo == NULL) )
1184 goto error;
1185 if( vlc_clone( &id->thread, ThreadSend, id, VLC_THREAD_PRIORITY_HIGHEST ) )
1186 {
1187 block_FifoRelease( id->p_fifo );
1188 id->p_fifo = NULL;
1189 goto error;
1190 }
1191
1192 /* Update p_sys context */
1193 vlc_mutex_lock( &p_sys->lock_es );
1194 TAB_APPEND( p_sys->i_es, p_sys->es, id );
1195 vlc_mutex_unlock( &p_sys->lock_es );
1196
1197 psz_sdp = SDPGenerate( p_stream, NULL );
1198
1199 vlc_mutex_lock( &p_sys->lock_sdp );
1200 free( p_sys->psz_sdp );
1201 p_sys->psz_sdp = psz_sdp;
1202 vlc_mutex_unlock( &p_sys->lock_sdp );
1203
1204 msg_Dbg( p_stream, "sdp=\n%s", p_sys->psz_sdp );
1205
1206 /* Update SDP (sap/file) */
1207 if( p_sys->b_export_sap ) SapSetup( p_stream );
1208 if( p_sys->psz_sdp_file != NULL ) FileSetup( p_stream );
1209
1210 return id;
1211
1212 error:
1213 Del( p_stream, id );
1214 return NULL;
1215 }
1216
1217 static void Del( sout_stream_t *p_stream, void *_id )
1218 {
1219 sout_stream_sys_t *p_sys = p_stream->p_sys;
1220 sout_stream_id_sys_t *id = (sout_stream_id_sys_t *)_id;
1221
1222 vlc_mutex_lock( &p_sys->lock_es );
1223 TAB_REMOVE( p_sys->i_es, p_sys->es, id );
1224 vlc_mutex_unlock( &p_sys->lock_es );
1225
1226 if( likely(id->p_fifo != NULL) )
1227 {
1228 vlc_cancel( id->thread );
1229 vlc_join( id->thread, NULL );
1230 block_FifoRelease( id->p_fifo );
1231 }
1232
1233 free( id->rtp_fmt.fmtp );
1234
1235 if (p_sys->p_vod_media != NULL)
1236 vod_detach_id(p_sys->p_vod_media, p_sys->psz_vod_session, id);
1237 if( id->rtsp_id )
1238 RtspDelId( p_sys->rtsp, id->rtsp_id );
1239 if( id->listen.fd != NULL )
1240 {
1241 vlc_cancel( id->listen.thread );
1242 vlc_join( id->listen.thread, NULL );
1243 net_ListenClose( id->listen.fd );
1244 }
1245 /* Delete remaining sinks (incoming connections or explicit
1246 * outgoing dst=) */
1247 while( id->sinkc > 0 )
1248 rtp_del_sink( id, id->sinkv[0].rtp_fd );
1249 #ifdef HAVE_SRTP
1250 if( id->srtp != NULL )
1251 srtp_destroy( id->srtp );
1252 #endif
1253
1254 vlc_mutex_destroy( &id->lock_sink );
1255
1256 /* Update SDP (sap/file) */
1257 if( p_sys->b_export_sap ) SapSetup( p_stream );
1258 if( p_sys->psz_sdp_file != NULL ) FileSetup( p_stream );
1259
1260 free( id );
1261 }
1262
1263 static int Send( sout_stream_t *p_stream, void *_id, block_t *p_buffer )
1264 {
1265 sout_stream_id_sys_t *id = (sout_stream_id_sys_t *)_id;
1266 assert( ((sout_stream_sys_t *)p_stream->p_sys)->p_mux == NULL );
1267
1268 while( p_buffer != NULL )
1269 {
1270 block_t *p_next = p_buffer->p_next;
1271 p_buffer->p_next = NULL;
1272
1273 /* Send a Vorbis/Theora Packed Configuration packet (RFC 5215 §3.1)
1274 * as the first packet of the stream */
1275 if (id->b_first_packet)
1276 {
1277 id->b_first_packet = false;
1278 if (!strcmp(id->rtp_fmt.ptname, "vorbis") ||
1279 !strcmp(id->rtp_fmt.ptname, "theora"))
1280 rtp_packetize_xiph_config(id, id->rtp_fmt.fmtp,
1281 p_buffer->i_pts);
1282 }
1283
1284 if( id->rtp_fmt.pf_packetize( id, p_buffer ) )
1285 break;
1286
1287 p_buffer = p_next;
1288 }
1289 return VLC_SUCCESS;
1290 }
1291
1292 /****************************************************************************
1293 * SAP:
1294 ****************************************************************************/
1295 static int SapSetup( sout_stream_t *p_stream )
1296 {
1297 sout_stream_sys_t *p_sys = p_stream->p_sys;
1298
1299 /* Remove the previous session */
1300 if( p_sys->p_session != NULL)
1301 {
1302 sout_AnnounceUnRegister( p_stream, p_sys->p_session);
1303 p_sys->p_session = NULL;
1304 }
1305
1306 if( p_sys->i_es > 0 && p_sys->psz_sdp && *p_sys->psz_sdp )
1307 p_sys->p_session = sout_AnnounceRegisterSDP( p_stream,
1308 p_sys->psz_sdp,
1309 p_sys->psz_destination );
1310
1311 return VLC_SUCCESS;
1312 }
1313
1314 /****************************************************************************
1315 * File:
1316 ****************************************************************************/
1317 static int FileSetup( sout_stream_t *p_stream )
1318 {
1319 sout_stream_sys_t *p_sys = p_stream->p_sys;
1320 FILE *f;
1321
1322 if( p_sys->psz_sdp == NULL )
1323 return VLC_EGENERIC; /* too early */
1324
1325 if( ( f = vlc_fopen( p_sys->psz_sdp_file, "wt" ) ) == NULL )
1326 {
1327 msg_Err( p_stream, "cannot open file '%s' (%s)",
1328 p_sys->psz_sdp_file, vlc_strerror_c(errno) );
1329 return VLC_EGENERIC;
1330 }
1331
1332 fputs( p_sys->psz_sdp, f );
1333 fclose( f );
1334
1335 return VLC_SUCCESS;
1336 }
1337
1338 /****************************************************************************
1339 * HTTP:
1340 ****************************************************************************/
1341 static int HttpCallback( httpd_file_sys_t *p_args,
1342 httpd_file_t *, uint8_t *p_request,
1343 uint8_t **pp_data, int *pi_data );
1344
1345 static int HttpSetup( sout_stream_t *p_stream, const vlc_url_t *url)
1346 {
1347 sout_stream_sys_t *p_sys = p_stream->p_sys;
1348
1349 p_sys->p_httpd_host = vlc_http_HostNew( VLC_OBJECT(p_stream) );
1350 if( p_sys->p_httpd_host )
1351 {
1352 p_sys->p_httpd_file = httpd_FileNew( p_sys->p_httpd_host,
1353 url->psz_path ? url->psz_path : "/",
1354 "application/sdp",
1355 NULL, NULL,
1356 HttpCallback, (void*)p_sys );
1357 }
1358 if( p_sys->p_httpd_file == NULL )
1359 {
1360 return VLC_EGENERIC;
1361 }
1362 return VLC_SUCCESS;
1363 }
1364
1365 static int HttpCallback( httpd_file_sys_t *p_args,
1366 httpd_file_t *f, uint8_t *p_request,
1367 uint8_t **pp_data, int *pi_data )
1368 {
1369 VLC_UNUSED(f); VLC_UNUSED(p_request);
1370 sout_stream_sys_t *p_sys = (sout_stream_sys_t*)p_args;
1371
1372 vlc_mutex_lock( &p_sys->lock_sdp );
1373 if( p_sys->psz_sdp && *p_sys->psz_sdp )
1374 {
1375 *pi_data = strlen( p_sys->psz_sdp );
1376 *pp_data = malloc( *pi_data );
1377 memcpy( *pp_data, p_sys->psz_sdp, *pi_data );
1378 }
1379 else
1380 {
1381 *pp_data = NULL;
1382 *pi_data = 0;
1383 }
1384 vlc_mutex_unlock( &p_sys->lock_sdp );
1385
1386 return VLC_SUCCESS;
1387 }
1388
1389 /****************************************************************************
1390 * RTP send
1391 ****************************************************************************/
1392 static void* ThreadSend( void *data )
1393 {
1394 #ifdef _WIN32
1395 # define ENOBUFS WSAENOBUFS
1396 # define EAGAIN WSAEWOULDBLOCK
1397 # define EWOULDBLOCK WSAEWOULDBLOCK
1398 #endif
1399 sout_stream_id_sys_t *id = data;
1400 vlc_tick_t i_caching = id->i_caching;
1401
1402 for (;;)
1403 {
1404 block_t *out = block_FifoGet( id->p_fifo );
1405 block_cleanup_push (out);
1406
1407 #ifdef HAVE_SRTP
1408 if( id->srtp )
1409 { /* FIXME: this is awfully inefficient */
1410 size_t len = out->i_buffer;
1411 out = block_Realloc( out, 0, len + 10 );
1412 out->i_buffer = len;
1413
1414 int canc = vlc_savecancel ();
1415 int val = srtp_send( id->srtp, out->p_buffer, &len, len + 10 );
1416 vlc_restorecancel (canc);
1417 if( val )
1418 {
1419 msg_Dbg( id->p_stream, "SRTP sending error: %s",
1420 vlc_strerror_c(val) );
1421 block_Release( out );
1422 out = NULL;
1423 }
1424 else
1425 out->i_buffer = len;
1426 }
1427 if (out)
1428 vlc_tick_wait (out->i_dts + i_caching);
1429 vlc_cleanup_pop ();
1430 if (out == NULL)
1431 continue;
1432 #else
1433 vlc_tick_wait (out->i_dts + i_caching);
1434 vlc_cleanup_pop ();
1435 #endif
1436
1437 ssize_t len = out->i_buffer;
1438 int canc = vlc_savecancel ();
1439
1440 vlc_mutex_lock( &id->lock_sink );
1441 unsigned deadc = 0; /* How many dead sockets? */
1442 int deadv[id->sinkc ? id->sinkc : 1]; /* Dead sockets list */
1443
1444 for( int i = 0; i < id->sinkc; i++ )
1445 {
1446 #ifdef HAVE_SRTP
1447 if( !id->srtp ) /* FIXME: SRTCP support */
1448 #endif
1449 SendRTCP( id->sinkv[i].rtcp, out );
1450
1451 if( send( id->sinkv[i].rtp_fd, out->p_buffer, len, 0 ) == -1
1452 && net_errno != EAGAIN && net_errno != EWOULDBLOCK
1453 && net_errno != ENOBUFS && net_errno != ENOMEM )
1454 {
1455 int type;
1456 getsockopt( id->sinkv[i].rtp_fd, SOL_SOCKET, SO_TYPE,
1457 &type, &(socklen_t){ sizeof(type) });
1458 if( type == SOCK_DGRAM )
1459 /* ICMP soft error: ignore and retry */
1460 send( id->sinkv[i].rtp_fd, out->p_buffer, len, 0 );
1461 else
1462 /* Broken connection */
1463 deadv[deadc++] = id->sinkv[i].rtp_fd;
1464 }
1465 }
1466 id->i_seq_sent_next = ntohs(((uint16_t *) out->p_buffer)[1]) + 1;
1467 vlc_mutex_unlock( &id->lock_sink );
1468 block_Release( out );
1469
1470 for( unsigned i = 0; i < deadc; i++ )
1471 {
1472 msg_Dbg( id->p_stream, "removing socket %d", deadv[i] );
1473 rtp_del_sink( id, deadv[i] );
1474 }
1475 vlc_restorecancel (canc);
1476 }
1477 return NULL;
1478 }
1479
1480
1481 /* This thread dequeues incoming connections (DCCP streaming) */
1482 static void *rtp_listen_thread( void *data )
1483 {
1484 sout_stream_id_sys_t *id = data;
1485
1486 assert( id->listen.fd != NULL );
1487
1488 for( ;; )
1489 {
1490 int fd = net_Accept( id->p_stream, id->listen.fd );
1491 if( fd == -1 )
1492 continue;
1493 int canc = vlc_savecancel( );
1494 rtp_add_sink( id, fd, true, NULL );
1495 vlc_restorecancel( canc );
1496 }
1497
1498 vlc_assert_unreachable();
1499 }
1500
1501
1502 int rtp_add_sink( sout_stream_id_sys_t *id, int fd, bool rtcp_mux, uint16_t *seq )
1503 {
1504 rtp_sink_t sink = { fd, NULL };
1505 sink.rtcp = OpenRTCP( VLC_OBJECT( id->p_stream ), fd, IPPROTO_UDP,
1506 rtcp_mux );
1507 if( sink.rtcp == NULL )
1508 msg_Err( id->p_stream, "RTCP failed!" );
1509
1510 vlc_mutex_lock( &id->lock_sink );
1511 TAB_APPEND(id->sinkc, id->sinkv, sink);
1512 if( seq != NULL )
1513 *seq = id->i_seq_sent_next;
1514 vlc_mutex_unlock( &id->lock_sink );
1515 return VLC_SUCCESS;
1516 }
1517
1518 void rtp_del_sink( sout_stream_id_sys_t *id, int fd )
1519 {
1520 rtp_sink_t sink = { fd, NULL };
1521
1522 /* NOTE: must be safe to use if fd is not included */
1523 vlc_mutex_lock( &id->lock_sink );
1524 for( int i = 0; i < id->sinkc; i++ )
1525 {
1526 if (id->sinkv[i].rtp_fd == fd)
1527 {
1528 sink = id->sinkv[i];
1529 TAB_ERASE(id->sinkc, id->sinkv, i);
1530 break;
1531 }
1532 }
1533 vlc_mutex_unlock( &id->lock_sink );
1534
1535 CloseRTCP( sink.rtcp );
1536 net_Close( sink.rtp_fd );
1537 }
1538
1539 uint16_t rtp_get_seq( sout_stream_id_sys_t *id )
1540 {
1541 /* This will return values for the next packet. */
1542 uint16_t seq;
1543
1544 vlc_mutex_lock( &id->lock_sink );
1545 seq = id->i_seq_sent_next;
1546 vlc_mutex_unlock( &id->lock_sink );
1547
1548 return seq;
1549 }
1550
1551 /* Return an arbitrary initial timestamp for RTP timestamp computations.
1552 * RFC 3550 states that the resulting initial RTP timestamps SHOULD be
1553 * random (although we use the same reference for all the ES as a
1554 * feature). In the VoD case, this function is called independently
1555 * from several parts of the code, so we need to always return the same
1556 * value. */
1557 static vlc_tick_t rtp_init_ts( const vod_media_t *p_media,
1558 const char *psz_vod_session )
1559 {
1560 if (p_media == NULL || psz_vod_session == NULL)
1561 return vlc_tick_now();
1562
1563 uint64_t i_ts_init;
1564 /* As per RFC 2326, session identifiers are at least 8 bytes long */
1565 strncpy((char *)&i_ts_init, psz_vod_session, sizeof(uint64_t));
1566 i_ts_init ^= (uintptr_t)p_media;
1567 /* Limit the timestamp to 48 bits, this is enough and allows us
1568 * to stay away from overflows */
1569 i_ts_init &= 0xFFFFFFFFFFFF;
1570 return i_ts_init;
1571 }
1572
1573 /* Return a timestamp corresponding to packets being sent now, and that
1574 * can be passed to rtp_compute_ts() to get rtptime values for each ES.
1575 * Also return the NPT corresponding to this timestamp. If the stream
1576 * output is not started, the initial timestamp that will be used with
1577 * the first packets for NPT=0 is returned instead. */
1578 vlc_tick_t rtp_get_ts( const sout_stream_t *p_stream, const sout_stream_id_sys_t *id,
1579 const vod_media_t *p_media, const char *psz_vod_session,
1580 vlc_tick_t *p_npt )
1581 {
1582 if (p_npt != NULL)
1583 *p_npt = 0;
1584
1585 if (id != NULL)
1586 p_stream = id->p_stream;
1587
1588 if (p_stream == NULL)
1589 return rtp_init_ts(p_media, psz_vod_session);
1590
1591 sout_stream_sys_t *p_sys = p_stream->p_sys;
1592 vlc_tick_t i_npt_zero;
1593 vlc_mutex_lock( &p_sys->lock_ts );
1594 i_npt_zero = p_sys->i_npt_zero;
1595 vlc_mutex_unlock( &p_sys->lock_ts );
1596
1597 if( i_npt_zero == VLC_TICK_INVALID )
1598 return p_sys->i_pts_zero;
1599
1600 vlc_tick_t now = vlc_tick_now();
1601 if( now < i_npt_zero )
1602 return p_sys->i_pts_zero;
1603
1604 vlc_tick_t npt = now - i_npt_zero;
1605 if (p_npt != NULL)
1606 *p_npt = npt;
1607
1608 return p_sys->i_pts_zero + npt;
1609 }
1610
1611 void rtp_packetize_common( sout_stream_id_sys_t *id, block_t *out,
1612 bool b_m_bit, vlc_tick_t i_pts )
1613 {
1614 if( !id->b_ts_init )
1615 {
1616 sout_stream_sys_t *p_sys = id->p_stream->p_sys;
1617 vlc_mutex_lock( &p_sys->lock_ts );
1618 if( p_sys->i_npt_zero == VLC_TICK_INVALID )
1619 {
1620 /* This is the first packet of any ES. We initialize the
1621 * NPT=0 time reference, and the offset to match the
1622 * arbitrary PTS reference. */
1623 p_sys->i_npt_zero = i_pts + id->i_caching;
1624 p_sys->i_pts_offset = p_sys->i_pts_zero - i_pts;
1625 }
1626 vlc_mutex_unlock( &p_sys->lock_ts );
1627
1628 /* And in any case this is the first packet of this ES, so we
1629 * initialize the offset for this ES. */
1630 id->i_ts_offset = rtp_compute_ts( id->rtp_fmt.clock_rate,
1631 p_sys->i_pts_offset );
1632 id->b_ts_init = true;
1633 }
1634
1635 uint32_t i_timestamp = rtp_compute_ts( id->rtp_fmt.clock_rate, i_pts )
1636 + id->i_ts_offset;
1637
1638 out->p_buffer[0] = 0x80;
1639 out->p_buffer[1] = (b_m_bit?0x80:0x00)|id->rtp_fmt.payload_type;
1640 out->p_buffer[2] = ( id->i_sequence >> 8)&0xff;
1641 out->p_buffer[3] = ( id->i_sequence )&0xff;
1642 out->p_buffer[4] = ( i_timestamp >> 24 )&0xff;
1643 out->p_buffer[5] = ( i_timestamp >> 16 )&0xff;
1644 out->p_buffer[6] = ( i_timestamp >> 8 )&0xff;
1645 out->p_buffer[7] = ( i_timestamp )&0xff;
1646
1647 memcpy( out->p_buffer + 8, id->ssrc, 4 );
1648
1649 id->i_sequence++;
1650 }
1651
1652 uint16_t rtp_get_extended_sequence( sout_stream_id_sys_t *id )
1653 {
1654 return id->i_sequence >> 16;
1655 }
1656
1657 void rtp_packetize_send( sout_stream_id_sys_t *id, block_t *out )
1658 {
1659 block_FifoPut( id->p_fifo, out );
1660 }
1661
1662 /**
1663 * @return configured max RTP payload size (including payload type-specific
1664 * headers, excluding RTP and transport headers)
1665 */
1666 size_t rtp_mtu (const sout_stream_id_sys_t *id)
1667 {
1668 return id->i_mtu - 12;
1669 }
1670
1671 /*****************************************************************************
1672 * Non-RTP mux
1673 *****************************************************************************/
1674
1675 /** Add an ES to a non-RTP muxed stream */
1676 static void *MuxAdd( sout_stream_t *p_stream, const es_format_t *p_fmt )
1677 {
1678 sout_input_t *p_input;
1679 sout_stream_sys_t *p_sys = p_stream->p_sys;
1680 sout_mux_t *p_mux = p_sys->p_mux;
1681 assert( p_mux != NULL );
1682
1683 p_input = sout_MuxAddStream( p_mux, p_fmt );
1684 if( p_input == NULL )
1685 {
1686 msg_Err( p_stream, "cannot add this stream to the muxer" );
1687 return NULL;
1688 }
1689
1690 return (sout_stream_id_sys_t *)p_input;
1691 }
1692
1693
1694 static int MuxSend( sout_stream_t *p_stream, void *id, block_t *p_buffer )
1695 {
1696 sout_stream_sys_t *p_sys = p_stream->p_sys;
1697 sout_mux_t *p_mux = p_sys->p_mux;
1698 assert( p_mux != NULL );
1699
1700 return sout_MuxSendBuffer( p_mux, (sout_input_t *)id, p_buffer );
1701 }
1702
1703
1704 /** Remove an ES from a non-RTP muxed stream */
1705 static void MuxDel( sout_stream_t *p_stream, void *id )
1706 {
1707 sout_stream_sys_t *p_sys = p_stream->p_sys;
1708 sout_mux_t *p_mux = p_sys->p_mux;
1709 assert( p_mux != NULL );
1710
1711 sout_MuxDeleteStream( p_mux, (sout_input_t *)id );
1712 }
1713
1714
1715 static ssize_t AccessOutGrabberWriteBuffer( sout_stream_t *p_stream,
1716 const block_t *p_buffer )
1717 {
1718 sout_stream_sys_t *p_sys = p_stream->p_sys;
1719 sout_stream_id_sys_t *id = p_sys->es[0];
1720
1721 vlc_tick_t i_dts = p_buffer->i_dts;
1722
1723 uint8_t *p_data = p_buffer->p_buffer;
1724 size_t i_data = p_buffer->i_buffer;
1725 size_t i_max = id->i_mtu - 12;
1726 bool b_dis = (p_buffer->i_flags & BLOCK_FLAG_DISCONTINUITY);
1727
1728 size_t i_packet = ( p_buffer->i_buffer + i_max - 1 ) / i_max;
1729
1730 while( i_data > 0 )
1731 {
1732 size_t i_size;
1733
1734 /* output complete packet */
1735 if( p_sys->packet &&
1736 p_sys->packet->i_buffer + i_data > i_max )
1737 {
1738 rtp_packetize_send( id, p_sys->packet );
1739 p_sys->packet = NULL;
1740 }
1741
1742 if( p_sys->packet == NULL )
1743 {
1744 /* allocate a new packet */
1745 p_sys->packet = block_Alloc( id->i_mtu );
1746 /* m-bit is discontinuity for MPEG1/2 PS and TS, RFC2250 2.1 */
1747 rtp_packetize_common( id, p_sys->packet, b_dis, i_dts );
1748 p_sys->packet->i_buffer = 12;
1749 p_sys->packet->i_dts = i_dts;
1750 p_sys->packet->i_length = p_buffer->i_length / i_packet;
1751 i_dts += p_sys->packet->i_length;
1752 b_dis = false;
1753 }
1754
1755 i_size = __MIN( i_data,
1756 (unsigned)(id->i_mtu - p_sys->packet->i_buffer) );
1757
1758 memcpy( &p_sys->packet->p_buffer[p_sys->packet->i_buffer],
1759 p_data, i_size );
1760
1761 p_sys->packet->i_buffer += i_size;
1762 p_data += i_size;
1763 i_data -= i_size;
1764 }
1765
1766 return VLC_SUCCESS;
1767 }
1768
1769
1770 static ssize_t AccessOutGrabberWrite( sout_access_out_t *p_access,
1771 block_t *p_buffer )
1772 {
1773 sout_stream_t *p_stream = (sout_stream_t*)p_access->p_sys;
1774
1775 while( p_buffer )
1776 {
1777 block_t *p_next;
1778
1779 AccessOutGrabberWriteBuffer( p_stream, p_buffer );
1780
1781 p_next = p_buffer->p_next;
1782 block_Release( p_buffer );
1783 p_buffer = p_next;
1784 }
1785
1786 return VLC_SUCCESS;
1787 }
1788
1789
1790 static sout_access_out_t *GrabberCreate( sout_stream_t *p_stream )
1791 {
1792 sout_access_out_t *p_grab;
1793
1794 p_grab = vlc_object_create( p_stream, sizeof( *p_grab ) );
1795 if( p_grab == NULL )
1796 return NULL;
1797
1798 p_grab->p_module = NULL;
1799 p_grab->psz_access = strdup( "grab" );
1800 p_grab->p_cfg = NULL;
1801 p_grab->psz_path = strdup( "" );
1802 p_grab->p_sys = p_stream;
1803 p_grab->pf_seek = NULL;
1804 p_grab->pf_write = AccessOutGrabberWrite;
1805 return p_grab;
1806 }
1807
1808 void rtp_get_video_geometry( sout_stream_id_sys_t *id, int *width, int *height )
1809 {
1810 int ret = sscanf( id->rtp_fmt.fmtp, "%*s width=%d; height=%d; ", width, height );
1811 assert( ret == 2 );
1812 }
VLC Development tree mirror