1ebf65f5b7b4b8bed44f17d25c8a3c2d2f4dd566
[vlc.git] / modules / access / rtp / rtp.c
1 /**
2  * @file rtp.c
3  * @brief Real-Time Protocol (RTP) demux module for VLC media player
4  */
5 /*****************************************************************************
6  * Copyright (C) 2001-2005 the VideoLAN team
7  * Copyright © 2007-2008 Rémi Denis-Courmont
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2.0
12  * of the License, or (at your option) any later version.
13  *
14  * This library 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.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
22  ****************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 # include <config.h>
26 #endif
27 #include <stdarg.h>
28 #include <assert.h>
29
30 #include <vlc_common.h>
31 #include <vlc_demux.h>
32 #include <vlc_aout.h>
33 #include <vlc_network.h>
34 #include <vlc_plugin.h>
35
36 #include <vlc_codecs.h>
37
38 #include "rtp.h"
39 #include <srtp.h>
40
41 #define RTP_CACHING_TEXT N_("RTP de-jitter buffer length (msec)")
42 #define RTP_CACHING_LONGTEXT N_( \
43     "How long to wait for late RTP packets (and delay the performance)." )
44
45 #define SRTP_KEY_TEXT N_("SRTP key (hexadecimal)")
46 #define SRTP_KEY_LONGTEXT N_( \
47     "RTP packets will be authenticated and deciphered "\
48     "with this Secure RTP master shared secret key.")
49
50 #define SRTP_SALT_TEXT N_("SRTP salt (hexadecimal)")
51 #define SRTP_SALT_LONGTEXT N_( \
52     "Secure RTP requires a (non-secret) master salt value.")
53
54 #define RTP_MAX_SRC_TEXT N_("Maximum RTP sources")
55 #define RTP_MAX_SRC_LONGTEXT N_( \
56     "How many distinct active RTP sources are allowed at a time." )
57
58 #define RTP_TIMEOUT_TEXT N_("RTP source timeout (sec)")
59 #define RTP_TIMEOUT_LONGTEXT N_( \
60     "How long to wait for any packet before a source is expired.")
61
62 #define RTP_MAX_DROPOUT_TEXT N_("Maximum RTP sequence number dropout")
63 #define RTP_MAX_DROPOUT_LONGTEXT N_( \
64     "RTP packets will be discarded if they are too much ahead (i.e. in the " \
65     "future) by this many packets from the last received packet." )
66
67 #define RTP_MAX_MISORDER_TEXT N_("Maximum RTP sequence number misordering")
68 #define RTP_MAX_MISORDER_LONGTEXT N_( \
69     "RTP packets will be discarded if they are too far behind (i.e. in the " \
70     "past) by this many packets from the last received packet." )
71
72 static int  Open (vlc_object_t *);
73 static void Close (vlc_object_t *);
74
75 /*
76  * Module descriptor
77  */
78 vlc_module_begin ()
79     set_shortname (_("RTP"))
80     set_description (_("(Experimental) Real-Time Protocol demuxer"))
81     set_category (CAT_INPUT)
82     set_subcategory (SUBCAT_INPUT_DEMUX)
83     set_capability ("access_demux", 0)
84     set_callbacks (Open, Close)
85
86     add_integer ("rtp-caching", 1000, NULL, RTP_CACHING_TEXT,
87                  RTP_CACHING_LONGTEXT, true);
88         change_integer_range (0, 65535)
89     add_string ("srtp-key", "", NULL,
90                 SRTP_KEY_TEXT, SRTP_KEY_LONGTEXT, false);
91     add_string ("srtp-salt", "", NULL,
92                 SRTP_SALT_TEXT, SRTP_SALT_LONGTEXT, false);
93     add_integer ("rtp-max-src", 1, NULL, RTP_MAX_SRC_TEXT,
94                  RTP_MAX_SRC_LONGTEXT, true);
95         change_integer_range (1, 255)
96     add_integer ("rtp-timeout", 5, NULL, RTP_TIMEOUT_TEXT,
97                  RTP_TIMEOUT_LONGTEXT, true);
98     add_integer ("rtp-max-dropout", 3000, NULL, RTP_MAX_DROPOUT_TEXT,
99                  RTP_MAX_DROPOUT_LONGTEXT, true);
100         change_integer_range (0, 32767)
101     add_integer ("rtp-max-misorder", 100, NULL, RTP_MAX_MISORDER_TEXT,
102                  RTP_MAX_MISORDER_LONGTEXT, true);
103         change_integer_range (0, 32767)
104
105     add_shortcut ("dccp")
106     /*add_shortcut ("sctp")*/
107     add_shortcut ("rtptcp") /* "tcp" is already taken :( */
108     add_shortcut ("rtp")
109     add_shortcut ("udplite")
110 vlc_module_end ()
111
112 /*
113  * TODO: so much stuff
114  * - send RTCP-RR and RTCP-BYE
115  * - dynamic payload types (need SDP parser)
116  * - multiple medias (need SDP parser, and RTCP-SR parser for lip-sync)
117  * - support for access_filter in case of stream_Demux (MPEG-TS)
118  */
119
120 #ifndef IPPROTO_DCCP
121 # define IPPROTO_DCCP 33 /* IANA */
122 #endif
123
124 #ifndef IPPROTO_UDPLITE
125 # define IPPROTO_UDPLITE 136 /* from IANA */
126 #endif
127
128
129 /*
130  * Local prototypes
131  */
132 static int Demux (demux_t *);
133 static int Control (demux_t *, int i_query, va_list args);
134 static int extract_port (char **phost);
135
136 /**
137  * Probes and initializes.
138  */
139 static int Open (vlc_object_t *obj)
140 {
141     demux_t *demux = (demux_t *)obj;
142     int tp; /* transport protocol */
143
144     if (!strcmp (demux->psz_access, "dccp"))
145         tp = IPPROTO_DCCP;
146     else
147     if (!strcmp (demux->psz_access, "rtptcp"))
148         tp = IPPROTO_TCP;
149     else
150     if (!strcmp (demux->psz_access, "rtp"))
151         tp = IPPROTO_UDP;
152     else
153     if (!strcmp (demux->psz_access, "udplite"))
154         tp = IPPROTO_UDPLITE;
155     else
156         return VLC_EGENERIC;
157
158     char *tmp = strdup (demux->psz_path);
159     char *shost = tmp;
160     if (shost == NULL)
161         return VLC_ENOMEM;
162
163     char *dhost = strchr (shost, '@');
164     if (dhost)
165         *dhost++ = '\0';
166
167     /* Parses the port numbers */
168     int sport = 0, dport = 0;
169     sport = extract_port (&shost);
170     if (dhost != NULL)
171         dport = extract_port (&dhost);
172     if (dport == 0)
173         dport = 5004; /* avt-profile-1 port */
174
175     /* Try to connect */
176     int fd = -1, rtcp_fd = -1;
177
178     switch (tp)
179     {
180         case IPPROTO_UDP:
181         case IPPROTO_UDPLITE:
182             if ((dport & 1) != 0 || (sport & 1) != 0)
183                 msg_Err (obj, "Using odd port number is higly discouraged");
184
185             fd = net_OpenDgram (obj, dhost, dport,
186                                 shost, sport, AF_UNSPEC, tp);
187             if (fd == -1)
188                 break;
189             rtcp_fd = net_OpenDgram (obj, dhost, dport + 1, shost,
190                                      sport ? (sport + 1) : 0, AF_UNSPEC, tp);
191             break;
192
193          case IPPROTO_DCCP:
194 #ifndef SOCK_DCCP /* provisional API (FIXME) */
195 # ifdef __linux__
196 #  define SOCK_DCCP 6
197 # endif
198 #endif
199 #ifdef SOCK_DCCP
200             var_Create (obj, "dccp-service", VLC_VAR_STRING);
201             var_SetString (obj, "dccp-service", "RTPV"); /* FIXME: RTPA? */
202             fd = net_Connect (obj, shost, (sport + 1) & ~1, SOCK_DCCP, tp);
203 #else
204             msg_Err (obj, "DCCP support not included");
205 #endif
206             break;
207
208         case IPPROTO_TCP:
209             fd = net_Connect (obj, shost, (sport + 1) & ~1, SOCK_STREAM, tp);
210             break;
211     }
212
213     free (tmp);
214     if (fd == -1)
215         return VLC_EGENERIC;
216     net_SetCSCov (fd, -1, 12);
217
218     /* Initializes demux */
219     demux_sys_t *p_sys = malloc (sizeof (*p_sys));
220     if (p_sys == NULL)
221     {
222         net_Close (fd);
223         if (rtcp_fd != -1)
224             net_Close (rtcp_fd);
225         return VLC_EGENERIC;
226     }
227
228     vlc_mutex_init (&p_sys->lock);
229     vlc_cond_init (&p_sys->wait);
230     p_sys->srtp         = NULL;
231     p_sys->fd           = fd;
232     p_sys->rtcp_fd      = rtcp_fd;
233     p_sys->caching      = var_CreateGetInteger (obj, "rtp-caching");
234     p_sys->max_src      = var_CreateGetInteger (obj, "rtp-max-src");
235     p_sys->timeout      = var_CreateGetInteger (obj, "rtp-timeout");
236     p_sys->max_dropout  = var_CreateGetInteger (obj, "rtp-max-dropout");
237     p_sys->max_misorder = var_CreateGetInteger (obj, "rtp-max-misorder");
238     p_sys->autodetect   = true;
239     p_sys->framed_rtp   = (tp == IPPROTO_TCP);
240     p_sys->dead         = false;
241
242     demux->pf_demux   = Demux;
243     demux->pf_control = Control;
244     demux->p_sys      = p_sys;
245
246     p_sys->session = rtp_session_create (demux);
247     if (p_sys->session == NULL)
248         goto error;
249
250     char *key = var_CreateGetNonEmptyString (demux, "srtp-key");
251     if (key)
252     {
253         p_sys->srtp = srtp_create (SRTP_ENCR_AES_CM, SRTP_AUTH_HMAC_SHA1, 10,
254                                    SRTP_PRF_AES_CM, SRTP_RCC_MODE1);
255         if (p_sys->srtp == NULL)
256         {
257             free (key);
258             goto error;
259         }
260
261         char *salt = var_CreateGetNonEmptyString (demux, "srtp-salt");
262         errno = srtp_setkeystring (p_sys->srtp, key, salt ? salt : "");
263         free (salt);
264         free (key);
265         if (errno)
266         {
267             msg_Err (obj, "bad SRTP key/salt combination (%m)");
268             goto error;
269         }
270     }
271
272     if (vlc_clone (&p_sys->thread, rtp_thread, demux,
273                    VLC_THREAD_PRIORITY_INPUT))
274         goto error;
275     p_sys->thread_ready = true;
276     return VLC_SUCCESS;
277
278 error:
279     Close (obj);
280     return VLC_EGENERIC;
281 }
282
283
284 /**
285  * Releases resources
286  */
287 static void Close (vlc_object_t *obj)
288 {
289     demux_t *demux = (demux_t *)obj;
290     demux_sys_t *p_sys = demux->p_sys;
291
292     if (p_sys->thread_ready)
293     {
294         vlc_cancel (p_sys->thread);
295         vlc_join (p_sys->thread, NULL);
296     }
297     vlc_cond_destroy (&p_sys->wait);
298     vlc_mutex_destroy (&p_sys->lock);
299
300     if (p_sys->srtp)
301         srtp_destroy (p_sys->srtp);
302     if (p_sys->session)
303         rtp_session_destroy (demux, p_sys->session);
304     if (p_sys->rtcp_fd != -1)
305         net_Close (p_sys->rtcp_fd);
306     net_Close (p_sys->fd);
307     free (p_sys);
308 }
309
310
311 /**
312  * Extracts port number from "[host]:port" or "host:port" strings,
313  * and remove brackets from the host name.
314  * @param phost pointer to the string upon entry,
315  * pointer to the hostname upon return.
316  * @return port number, 0 if missing.
317  */
318 static int extract_port (char **phost)
319 {
320     char *host = *phost, *port;
321
322     if (host[0] == '[')
323     {
324         host = ++*phost; /* skip '[' */
325         port = strchr (host, ']');
326         if (port)
327             *port++ = '\0'; /* skip ']' */
328     }
329     else
330         port = strchr (host, ':');
331
332     if (port == NULL)
333         return 0;
334     *port++ = '\0'; /* skip ':' */
335     return atoi (port);
336 }
337
338
339 /**
340  * Control callback
341  */
342 static int Control (demux_t *demux, int i_query, va_list args)
343 {
344     demux_sys_t *p_sys = demux->p_sys;
345
346     switch (i_query)
347     {
348         case DEMUX_GET_POSITION:
349         {
350             float *v = va_arg (args, float *);
351             *v = 0.;
352             return VLC_SUCCESS;
353         }
354
355         case DEMUX_GET_LENGTH:
356         case DEMUX_GET_TIME:
357         {
358             int64_t *v = va_arg (args, int64_t *);
359             *v = 0;
360             return VLC_SUCCESS;
361         }
362
363         case DEMUX_GET_PTS_DELAY:
364         {
365             int64_t *v = va_arg (args, int64_t *);
366             *v = p_sys->caching * 1000;
367             return VLC_SUCCESS;
368         }
369
370         case DEMUX_CAN_PAUSE:
371         case DEMUX_CAN_SEEK:
372         case DEMUX_CAN_CONTROL_PACE:
373         {
374             bool *v = (bool*)va_arg( args, bool * );
375             *v = false;
376             return VLC_SUCCESS;
377         }
378     }
379
380     return VLC_EGENERIC;
381 }
382
383
384 /*
385  * Generic packet handlers
386  */
387
388 static void *codec_init (demux_t *demux, es_format_t *fmt)
389 {
390     return es_out_Add (demux->out, fmt);
391 }
392
393 static void codec_destroy (demux_t *demux, void *data)
394 {
395     if (data)
396         es_out_Del (demux->out, (es_out_id_t *)data);
397 }
398
399 /* Send a packet to decoder */
400 static void codec_decode (demux_t *demux, void *data, block_t *block)
401 {
402     if (data)
403     {
404         block->i_dts = 0; /* RTP does not specify this */
405         es_out_Control (demux->out, ES_OUT_SET_PCR, block->i_pts );
406         es_out_Send (demux->out, (es_out_id_t *)data, block);
407     }
408     else
409         block_Release (block);
410 }
411
412
413 static void *stream_init (demux_t *demux, const char *name)
414 {
415     return stream_DemuxNew (demux, name, demux->out);
416 }
417
418 static void stream_destroy (demux_t *demux, void *data)
419 {
420     if (data)
421         stream_Delete ((stream_t *)data);
422     (void)demux;
423 }
424
425 /* Send a packet to a chained demuxer */
426 static void stream_decode (demux_t *demux, void *data, block_t *block)
427 {
428     if (data)
429         stream_DemuxSend ((stream_t *)data, block);
430     else
431         block_Release (block);
432     (void)demux;
433 }
434
435 /*
436  * Static payload types handler
437  */
438
439 /* PT=0
440  * PCMU: G.711 µ-law (RFC3551)
441  */
442 static void *pcmu_init (demux_t *demux)
443 {
444     es_format_t fmt;
445
446     es_format_Init (&fmt, AUDIO_ES, VLC_FOURCC ('u', 'l', 'a', 'w'));
447     fmt.audio.i_rate = 8000;
448     fmt.audio.i_channels = 1;
449     return codec_init (demux, &fmt);
450 }
451
452 /* PT=3
453  * GSM
454  */
455 static void *gsm_init (demux_t *demux)
456 {
457     es_format_t fmt;
458
459     es_format_Init (&fmt, AUDIO_ES, VLC_FOURCC ('g', 's', 'm', ' '));
460     fmt.audio.i_rate = 8000;
461     fmt.audio.i_channels = 1;
462     return codec_init (demux, &fmt);
463 }
464
465 /* PT=8
466  * PCMA: G.711 A-law (RFC3551)
467  */
468 static void *pcma_init (demux_t *demux)
469 {
470     es_format_t fmt;
471
472     es_format_Init (&fmt, AUDIO_ES, VLC_FOURCC ('a', 'l', 'a', 'w'));
473     fmt.audio.i_rate = 8000;
474     fmt.audio.i_channels = 1;
475     return codec_init (demux, &fmt);
476 }
477
478 /* PT=10,11
479  * L16: 16-bits (network byte order) PCM
480  */
481 static void *l16s_init (demux_t *demux)
482 {
483     es_format_t fmt;
484
485     es_format_Init (&fmt, AUDIO_ES, VLC_FOURCC ('s', '1', '6', 'b'));
486     fmt.audio.i_rate = 44100;
487     fmt.audio.i_channels = 2;
488     return codec_init (demux, &fmt);
489 }
490
491 static void *l16m_init (demux_t *demux)
492 {
493     es_format_t fmt;
494
495     es_format_Init (&fmt, AUDIO_ES, VLC_FOURCC ('s', '1', '6', 'b'));
496     fmt.audio.i_rate = 44100;
497     fmt.audio.i_channels = 1;
498     return codec_init (demux, &fmt);
499 }
500
501 /* PT=12
502  * QCELP
503  */
504 static void *qcelp_init (demux_t *demux)
505 {
506     es_format_t fmt;
507
508     es_format_Init (&fmt, AUDIO_ES, VLC_FOURCC ('Q', 'c', 'l', 'p'));
509     fmt.audio.i_rate = 8000;
510     fmt.audio.i_channels = 1;
511     return codec_init (demux, &fmt);
512 }
513
514 /* PT=14
515  * MPA: MPEG Audio (RFC2250, §3.4)
516  */
517 static void *mpa_init (demux_t *demux)
518 {
519     es_format_t fmt;
520
521     es_format_Init (&fmt, AUDIO_ES, VLC_FOURCC ('m', 'p', 'g', 'a'));
522     fmt.audio.i_channels = 2;
523     return codec_init (demux, &fmt);
524 }
525
526 static void mpa_decode (demux_t *demux, void *data, block_t *block)
527 {
528     if (block->i_buffer < 4)
529     {
530         block_Release (block);
531         return;
532     }
533
534     block->i_buffer -= 4; /* 32-bits RTP/MPA header */
535     block->p_buffer += 4;
536
537     codec_decode (demux, data, block);
538 }
539
540
541 /* PT=32
542  * MPV: MPEG Video (RFC2250, §3.5)
543  */
544 static void *mpv_init (demux_t *demux)
545 {
546     es_format_t fmt;
547
548     es_format_Init (&fmt, VIDEO_ES, VLC_FOURCC ('m', 'p', 'g', 'v'));
549     return codec_init (demux, &fmt);
550 }
551
552 static void mpv_decode (demux_t *demux, void *data, block_t *block)
553 {
554     if (block->i_buffer < 4)
555     {
556         block_Release (block);
557         return;
558     }
559
560     block->i_buffer -= 4; /* 32-bits RTP/MPV header */
561     block->p_buffer += 4;
562 #if 0
563     if (block->p_buffer[-3] & 0x4)
564     {
565         /* MPEG2 Video extension header */
566         /* TODO: shouldn't we skip this too ? */
567     }
568 #endif
569     codec_decode (demux, data, block);
570 }
571
572
573 /* PT=33
574  * MP2: MPEG TS (RFC2250, §2)
575  */
576 static void *ts_init (demux_t *demux)
577 {
578     return stream_init (demux, *demux->psz_demux ? demux->psz_demux : "ts");
579 }
580
581
582 /* Not using SDP, we need to guess the payload format used */
583 /* see http://www.iana.org/assignments/rtp-parameters */
584 int rtp_autodetect (demux_t *demux, rtp_session_t *session,
585                     const block_t *block)
586 {
587     uint8_t ptype = rtp_ptype (block);
588     rtp_pt_t pt = {
589         .init = NULL,
590         .destroy = codec_destroy,
591         .decode = codec_decode,
592         .frequency = 0,
593         .number = ptype,
594     };
595
596     switch (ptype)
597     {
598       case 0:
599         msg_Dbg (demux, "detected G.711 mu-law");
600         pt.init = pcmu_init;
601         pt.frequency = 8000;
602         break;
603
604       case 3:
605         msg_Dbg (demux, "detected GSM");
606         pt.init = gsm_init;
607         pt.frequency = 8000;
608         break;
609
610       case 8:
611         msg_Dbg (demux, "detected G.711 A-law");
612         pt.init = pcma_init;
613         pt.frequency = 8000;
614         break;
615
616       case 10:
617         msg_Dbg (demux, "detected stereo PCM");
618         pt.init = l16s_init;
619         pt.frequency = 44100;
620         break;
621
622       case 11:
623         msg_Dbg (demux, "detected mono PCM");
624         pt.init = l16m_init;
625         pt.frequency = 44100;
626         break;
627
628       case 12:
629         msg_Dbg (demux, "detected QCELP");
630         pt.init = qcelp_init;
631         pt.frequency = 8000;
632         break;
633
634       case 14:
635         msg_Dbg (demux, "detected MPEG Audio");
636         pt.init = mpa_init;
637         pt.decode = mpa_decode;
638         pt.frequency = 90000;
639         break;
640
641       case 32:
642         msg_Dbg (demux, "detected MPEG Video");
643         pt.init = mpv_init;
644         pt.decode = mpv_decode;
645         pt.frequency = 90000;
646         break;
647
648       case 33:
649         msg_Dbg (demux, "detected MPEG2 TS");
650         pt.init = ts_init;
651         pt.destroy = stream_destroy;
652         pt.decode = stream_decode;
653         pt.frequency = 90000;
654         break;
655
656       default:
657         return -1;
658     }
659     rtp_add_type (demux, session, &pt);
660     return 0;
661 }
662
663 /*
664  * Dynamic payload type handlers
665  * Hmm, none implemented yet.
666  */
667
668 /**
669  * Processing callback
670  */
671 static int Demux (demux_t *demux)
672 {
673     return rtp_process (demux) ? 0 : 1;
674 }