Cosmetic
[vlc.git] / modules / access / rtp / session.c
1 /**
2  * @file session.c
3  * @brief RTP session handling
4  */
5 /*****************************************************************************
6  * Copyright © 2008 Rémi Denis-Courmont
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2.0
11  * of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
21  ****************************************************************************/
22
23 #ifdef HAVE_CONFIG_H
24 # include <config.h>
25 #endif
26
27 #include <stdlib.h>
28 #include <assert.h>
29 #include <errno.h>
30
31 #include <vlc/vlc.h>
32 #include <vlc_demux.h>
33
34 #include "rtp.h"
35
36 typedef struct rtp_source_t rtp_source_t;
37
38 /** State for a RTP session: */
39 struct rtp_session_t
40 {
41     rtp_source_t **srcv;
42     unsigned       srcc;
43     uint8_t        ptc;
44     rtp_pt_t      *ptv;
45 };
46
47 static rtp_source_t *
48 rtp_source_create (demux_t *, const rtp_session_t *, uint32_t, uint16_t);
49 static void
50 rtp_source_destroy (demux_t *, const rtp_session_t *, rtp_source_t *);
51
52 static void rtp_decode (demux_t *, const rtp_session_t *, rtp_source_t *);
53
54 /**
55  * Creates a new RTP session.
56  */
57 rtp_session_t *
58 rtp_session_create (demux_t *demux)
59 {
60     rtp_session_t *session = malloc (sizeof (*session));
61     if (session == NULL)
62         return NULL;
63
64     session->srcv = NULL;
65     session->srcc = 0;
66     session->ptc = 0;
67     session->ptv = NULL;
68
69     (void)demux;
70     return session;
71 }
72
73
74 /**
75  * Destroys an RTP session.
76  */
77 void rtp_session_destroy (demux_t *demux, rtp_session_t *session)
78 {
79     for (unsigned i = 0; i < session->srcc; i++)
80         rtp_source_destroy (demux, session, session->srcv[i]);
81
82     free (session->srcv);
83     free (session->ptv);
84     free (session);
85     (void)demux;
86 }
87
88 static void *no_init (demux_t *demux)
89 {
90     (void)demux;
91     return NULL;
92 }
93
94 static void no_destroy (demux_t *demux, void *opaque)
95 {
96     (void)demux; (void)opaque;
97 }
98
99 static void no_decode (demux_t *demux, void *opaque, block_t *block)
100 {
101     (void)demux; (void)opaque;
102     block_Release (block);
103 }
104
105 /**
106  * Adds a payload type to an RTP session.
107  */
108 int rtp_add_type (demux_t *demux, rtp_session_t *ses, const rtp_pt_t *pt)
109 {
110     if (ses->srcc > 0)
111     {
112         msg_Err (demux, "cannot change RTP payload formats during session");
113         return EINVAL;
114     }
115
116     rtp_pt_t *ppt = realloc (ses->ptv, (ses->ptc + 1) * sizeof (rtp_pt_t));
117     if (ppt == NULL)
118         return ENOMEM;
119
120     ses->ptv = ppt;
121     ppt += ses->ptc++;
122
123     ppt->init = pt->init ? pt->init : no_init;
124     ppt->destroy = pt->destroy ? pt->destroy : no_destroy;
125     ppt->decode = pt->decode ? pt->decode : no_decode;
126     ppt->frequency = pt->frequency;
127     ppt->number = pt->number;
128     msg_Dbg (demux, "added payload type %"PRIu8" (f = %"PRIu32" Hz)",
129              ppt->number, ppt->frequency);
130
131     assert (ppt->frequency > 0); /* SIGFPE! */
132     (void)demux;
133     return 0;
134 }
135
136 /** State for an RTP source */
137 struct rtp_source_t
138 {
139     uint32_t ssrc;
140     uint32_t jitter;  /* interarrival delay jitter estimate */
141     mtime_t  last_rx; /* last received packet local timestamp */
142     uint32_t last_ts; /* last received packet RTP timestamp */
143
144     uint16_t bad_seq; /* tentatively next expected sequence for resync */
145     uint16_t max_seq; /* next expected sequence */
146
147     uint16_t last_seq; /* sequence of the last dequeued packet */
148     block_t *blocks; /* re-ordered blocks queue */
149     void    *opaque[0]; /* Per-source private payload data */
150 };
151
152 /**
153  * Initializes a new RTP source within an RTP session.
154  */
155 static rtp_source_t *
156 rtp_source_create (demux_t *demux, const rtp_session_t *session,
157                    uint32_t ssrc, uint16_t init_seq)
158 {
159     rtp_source_t *source;
160
161     source = malloc (sizeof (*source) + (sizeof (void *) * session->ptc));
162     if (source == NULL)
163         return NULL;
164
165     source->ssrc = ssrc;
166     source->jitter = 0;
167     source->max_seq = source->bad_seq = init_seq;
168     source->last_seq = init_seq - 1;
169     source->blocks = NULL;
170
171     /* Initializes all payload */
172     for (unsigned i = 0; i < session->ptc; i++)
173         source->opaque[i] = session->ptv[i].init (demux);
174
175     msg_Dbg (demux, "added RTP source (%08x)", ssrc);
176     return source;
177 }
178
179
180 /**
181  * Destroys an RTP source and its associated streams.
182  */
183 static void
184 rtp_source_destroy (demux_t *demux, const rtp_session_t *session,
185                     rtp_source_t *source)
186 {
187     msg_Dbg (demux, "removing RTP source (%08x)", source->ssrc);
188
189     for (unsigned i = 0; i < session->ptc; i++)
190         session->ptv[i].destroy (demux, source->opaque[i]);
191     block_ChainRelease (source->blocks);
192     free (source);
193 }
194
195 static inline uint16_t rtp_seq (const block_t *block)
196 {
197     assert (block->i_buffer >= 4);
198     return GetWBE (block->p_buffer + 2);
199 }
200
201 static inline uint32_t rtp_timestamp (const block_t *block)
202 {
203     assert (block->i_buffer >= 12);
204     return GetDWBE (block->p_buffer + 4);
205 }
206
207 static const struct rtp_pt_t *
208 rtp_find_ptype (const rtp_session_t *session, rtp_source_t *source,
209                 const block_t *block, void **pt_data)
210 {
211     uint8_t ptype = rtp_ptype (block);
212
213     for (unsigned i = 0; i < session->ptc; i++)
214     {
215         if (session->ptv[i].number == ptype)
216         {
217             if (pt_data != NULL)
218                 *pt_data = source->opaque[i];
219             return &session->ptv[i];
220         }
221     }
222     return NULL;
223 }
224
225 /**
226  * Receives an RTP packet and queues it. Not a cancellation point.
227  *
228  * @param demux VLC demux object
229  * @param session RTP session receiving the packet
230  * @param block RTP packet including the RTP header
231  */
232 void
233 rtp_queue (demux_t *demux, rtp_session_t *session, block_t *block)
234 {
235     demux_sys_t *p_sys = demux->p_sys;
236
237     /* RTP header sanity checks (see RFC 3550) */
238     if (block->i_buffer < 12)
239         goto drop;
240     if ((block->p_buffer[0] >> 6 ) != 2) /* RTP version number */
241         goto drop;
242
243     /* Remove padding if present */
244     if (block->p_buffer[0] & 0x20)
245     {
246         uint8_t padding = block->p_buffer[block->i_buffer - 1];
247         if ((padding == 0) || (block->i_buffer < (12u + padding)))
248             goto drop; /* illegal value */
249
250         block->i_buffer -= padding;
251     }
252
253     mtime_t        now = mdate ();
254     rtp_source_t  *src  = NULL;
255     const uint16_t seq  = rtp_seq (block);
256     const uint32_t ssrc = GetDWBE (block->p_buffer + 8);
257
258     /* In most case, we know this source already */
259     for (unsigned i = 0, max = session->srcc; i < max; i++)
260     {
261         rtp_source_t *tmp = session->srcv[i];
262         if (tmp->ssrc == ssrc)
263         {
264             src = tmp;
265             break;
266         }
267
268         /* RTP source garbage collection */
269         if ((tmp->last_rx + (p_sys->timeout * CLOCK_FREQ)) < now)
270         {
271             rtp_source_destroy (demux, session, tmp);
272             if (--session->srcc > 0)
273                 session->srcv[i] = session->srcv[session->srcc - 1];
274         }
275     }
276
277     if (src == NULL)
278     {
279         /* New source */
280         if (session->srcc >= p_sys->max_src)
281         {
282             msg_Warn (demux, "too many RTP sessions");
283             goto drop;
284         }
285
286         rtp_source_t **tab;
287         tab = realloc (session->srcv, (session->srcc + 1) * sizeof (*tab));
288         if (tab == NULL)
289             goto drop;
290         session->srcv = tab;
291
292         src = rtp_source_create (demux, session, ssrc, seq);
293         if (src == NULL)
294             goto drop;
295
296         tab[session->srcc++] = src;
297         /* Cannot compute jitter yet */
298     }
299     else
300     {
301         const rtp_pt_t *pt = rtp_find_ptype (session, src, block, NULL);
302
303         if (pt != NULL)
304         {
305             /* Recompute jitter estimate.
306              * That is computed from the RTP timestamps and the system clock.
307              * It is independent of RTP sequence. */
308             uint32_t freq = pt->frequency;
309             uint32_t ts = rtp_timestamp (block);
310             int64_t d = ((now - src->last_rx) * freq) / CLOCK_FREQ;
311             d        -=    ts - src->last_ts;
312             if (d < 0) d = -d;
313             src->jitter += ((d - src->jitter) + 8) >> 4;
314         }
315     }
316     src->last_rx = now;
317     src->last_ts = rtp_timestamp (block);
318
319     /* Be optimistic for the first packet. Certain codec, such as Vorbis
320      * do not like loosing the first packet(s), so we cannot just wait
321      * for proper sequence synchronization. And we don't want to assume that
322      * the sender starts at seq=0 either. */
323     if (src->blocks == NULL)
324         src->max_seq = seq - p_sys->max_dropout;
325
326     /* Check sequence number */
327     /* NOTE: the sequence number is per-source,
328      * but is independent from the payload type. */
329     uint16_t delta_seq = seq - (src->max_seq + 1);
330     if ((delta_seq < 0x8000) ? (delta_seq > p_sys->max_dropout)
331                              : ((65535 - delta_seq) > p_sys->max_misorder))
332     {
333         msg_Dbg (demux, "sequence discontinuity (got: %u, expected: %u)",
334                  seq, (src->max_seq + 1) & 0xffff);
335         if (seq == ((src->bad_seq + 1) & 0xffff))
336         {
337             src->max_seq = src->bad_seq = seq;
338             msg_Warn (demux, "sequence resynchronized");
339             block_ChainRelease (src->blocks);
340             src->blocks = NULL;
341         }
342         else
343         {
344             src->bad_seq = seq;
345             goto drop;
346         }
347     }
348     else
349     if (delta_seq < 0x8000)
350         src->max_seq = seq;
351
352     /* Queues the block in sequence order,
353      * hence there is a single queue for all payload types. */
354     block_t **pp = &src->blocks;
355     for (block_t *prev = *pp; prev != NULL; prev = *pp)
356     {
357         int16_t delta_seq = seq - rtp_seq (prev);
358         if (delta_seq < 0)
359             break;
360         if (delta_seq == 0)
361             goto drop; /* duplicate */
362         pp = &prev->p_next;
363     }
364     block->p_next = *pp;
365     *pp = block;
366
367     /*rtp_decode (demux, session, src);*/
368     return;
369
370 drop:
371     block_Release (block);
372 }
373
374
375 static void
376 rtp_decode (demux_t *demux, const rtp_session_t *session, rtp_source_t *src)
377 {
378     block_t *block = src->blocks;
379
380     assert (block);
381     src->blocks = block->p_next;
382     block->p_next = NULL;
383
384     /* Discontinuity detection */
385     uint16_t delta_seq = rtp_seq (block) - (src->last_seq + 1);
386     if (delta_seq != 0)
387     {
388         if (delta_seq >= 0x8000)
389         {   /* Unrecoverable if later packets have already been dequeued */
390             msg_Warn (demux, "ignoring late packet (sequence: %u)",
391                       rtp_seq (block));
392             goto drop;
393         }
394         block->i_flags |= BLOCK_FLAG_DISCONTINUITY;
395     }
396     src->last_seq = rtp_seq (block);
397
398     /* Match the payload type */
399     void *pt_data;
400     const rtp_pt_t *pt = rtp_find_ptype (session, src, block, &pt_data);
401     if (pt == NULL)
402     {
403         msg_Dbg (demux, "ignoring unknown payload (%"PRIu8")",
404                  rtp_ptype (block));
405         goto drop;
406     }
407
408     /* Computes the PTS from the RTP timestamp and payload RTP frequency.
409      * DTS is unknown. Also, while the clock frequency depends on the payload
410      * format, a single source MUST only use payloads of a chosen frequency.
411      * Otherwise it would be impossible to compute consistent timestamps. */
412     /* FIXME: handle timestamp wrap properly */
413     /* TODO: inter-medias/sessions sync (using RTCP-SR) */
414     const uint32_t timestamp = rtp_timestamp (block);
415     block->i_pts = UINT64_C(1) * CLOCK_FREQ * timestamp / pt->frequency;
416
417     /* CSRC count */
418     size_t skip = 12u + (block->p_buffer[0] & 0x0F) * 4;
419
420     /* Extension header (ignored for now) */
421     if (block->p_buffer[0] & 0x10)
422     {
423         skip += 4;
424         if (block->i_buffer < skip)
425             goto drop;
426
427         skip += 4 * GetWBE (block->p_buffer + skip - 2);
428     }
429
430     if (block->i_buffer < skip)
431         goto drop;
432
433     block->p_buffer += skip;
434     block->i_buffer -= skip;
435
436     pt->decode (demux, pt_data, block);
437     return;
438
439 drop:
440     block_Release (block);
441 }
442
443
444 /**
445  * Dequeues an RTP packet and pass it to decoder. Not cancellation-safe(?).
446  *
447  * @param demux VLC demux object
448  * @param session RTP session receiving the packet
449  * @param deadlinep pointer to deadline to call rtp_dequeue() again
450  * @return true if the buffer is not empty, false otherwise.
451  * In the later case, *deadlinep is undefined.
452  */
453 bool rtp_dequeue (demux_t *demux, const rtp_session_t *session,
454                   mtime_t *restrict deadlinep)
455 {
456     mtime_t now = mdate ();
457     bool pending = false;
458
459     for (unsigned i = 0, max = session->srcc; i < max; i++)
460     {
461         rtp_source_t *src = session->srcv[i];
462         block_t *block;
463
464         /* Because of IP packet delay variation (IPDV), we need to guesstimate
465          * how long to wait for a missing packet in the RTP sequence
466          * (see RFC3393 for background on IPDV).
467          *
468          * This situation occurs if a packet got lost, or if the network has
469          * re-ordered packets. Unfortunately, the MSL is 2 minutes, orders of
470          * magnitude too long for multimedia. We need a tradeoff.
471          * If we underestimated IPDV, we may have to discard valid but late
472          * packets. If we overestimate it, we will either cause too much
473          * delay, or worse, underflow our downstream buffers, as we wait for
474          * definitely a lost packets.
475          *
476          * The rest of the "de-jitter buffer" work is done by the interval
477          * LibVLC E/S-out clock synchronization. Here, we need to bother about
478          * re-ordering packets, as decoders can't cope with mis-ordered data.
479          */
480         while (((block = src->blocks)) != NULL)
481         {
482 #if 0
483             if (rtp_seq (block) == ((src->last_seq + 1) & 0xffff))
484             {   /* Next block ready, no need to wait */
485                 rtp_decode (demux, session, src);
486                 continue;
487             }
488 #endif
489             /* Wait for 3 times the inter-arrival delay variance (about 99.7%
490              * match for random gaussian jitter). Additionnaly, we implicitly
491              * wait for misordering times the packetization time.
492              */
493             mtime_t deadline = src->last_rx;
494             const rtp_pt_t *pt = rtp_find_ptype (session, src, block, NULL);
495             if (pt)
496                 deadline += UINT64_C(3) * CLOCK_FREQ * src->jitter
497                             / pt->frequency;
498
499             if (now >= deadline)
500             {
501                 rtp_decode (demux, session, src);
502                 continue;
503             }
504             if (*deadlinep > deadline)
505                 *deadlinep = deadline;
506             pending = true; /* packet pending in buffer */
507             break;
508         }
509     }
510     return pending;
511 }