b25eb35b9528d3b917b12ab5658893cc6d48ec45
[vlc.git] / modules / mux / rtp / rtcp.c
1 /*****************************************************************************
2  * rtcp.c: RTP/RTCP source file
3  *****************************************************************************
4  * Copyright (C) 2005-2007 M2X
5  *
6  * $Id$
7  *
8  * Authors: Jean-Paul Saman <jpsaman #_at_# videolan dot org>
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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 #include <netinet/in.h>
26 #include <sys/time.h>
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33 #include <vlc_bits.h>
34 #include <vlc_block.h>
35
36 #include "rtp.h"
37 #include "rtcp.h"
38
39 void send_RTCP( vlc_object_t *p_this, rtcp_event_t );
40 void rtcp_schedule( vlc_object_t *p_this, mtime_t, rtcp_event_t );
41
42 /* SDES support functions */
43 static int SDES_client_item_add( rtcp_client_t *p_client, int i_item, char *psz_name )
44 {
45     rtcp_SDES_item_t *p_item = NULL;
46     
47     p_item = (rtcp_SDES_item_t *) malloc( sizeof( rtcp_SDES_item_t ) );
48     if( !p_item )
49         return VLC_ENOMEM;
50     p_item->u_type = i_item;
51     p_item->psz_data = strdup( psz_name );
52     p_item->i_index = p_client->i_items + 1;;
53     INSERT_ELEM( p_client->pp_sdes, p_client->i_items,
54                  p_item->i_index, p_item );
55     return VLC_EGENERIC;
56 }
57
58 static int SDES_client_item_del( rtcp_client_t *p_client )
59 {
60     uint32_t i = 0;
61
62     for( i=0; i < p_client->i_items; i++ )
63     {
64         rtcp_SDES_item_t *p_old = p_client->pp_sdes[i];
65         REMOVE_ELEM( p_client->pp_sdes, p_client->i_items, i );
66         p_client->i_items--;
67         free( p_old->psz_data );
68         free( p_old );
69     }
70     return VLC_SUCCESS;
71 }
72
73 int rtcp_add_client( vlc_object_t *p_this, uint32_t u_ssrc, uint32_t *i_pos )
74 {
75     rtcp_t *p_rtcp = (rtcp_t *) p_this;
76     rtcp_client_t *p_client = NULL;
77
78     vlc_object_lock( p_rtcp );
79     p_client = (rtcp_client_t*) malloc( sizeof(rtcp_client_t) );
80     if( !p_client )
81         return VLC_ENOMEM;
82     p_client->i_index = p_rtcp->i_clients + 1;
83     p_client->b_deleted = false;
84     *i_pos = p_client->i_index ;
85     INSERT_ELEM( p_rtcp->pp_clients, p_rtcp->i_clients,
86                  p_client->i_index, p_client );
87     p_rtcp->i_clients++;
88     p_rtcp->u_clients++;
89     vlc_object_unlock( p_rtcp );
90     return VLC_SUCCESS;
91 }
92
93 int rtcp_del_client( vlc_object_t *p_this, uint32_t u_ssrc )
94 {
95     rtcp_t *p_rtcp = (rtcp_t *) p_this;
96     uint32_t i_pos = 0;
97
98     vlc_object_lock( p_rtcp );
99     if( p_rtcp->pf_find_client( p_this, u_ssrc, &i_pos ) == VLC_SUCCESS )
100     {
101         rtcp_client_t *p_old = p_rtcp->pp_clients[i_pos];
102
103         p_old->b_deleted = true;
104         p_old->i_timeout = 5 * (p_rtcp->i_date - p_rtcp->i_last_date) +
105                            p_rtcp->i_next_date;
106         p_rtcp->u_clients--;
107         /* BYE message is sent by rtcp_destroy_client() */
108     }
109     vlc_object_unlock( p_rtcp );
110     return VLC_SUCCESS;
111 }
112
113 /* rtcp_cleanup_clients should not be called too often */
114 int rtcp_cleanup_clients( vlc_object_t *p_this )
115 {
116     rtcp_t *p_rtcp = (rtcp_t *) p_this;
117     uint32_t i = 0;
118
119     vlc_object_lock( p_rtcp );
120     for( i=0; i < p_rtcp->i_clients; i++ )
121     {
122         rtcp_client_t *p_old = p_rtcp->pp_clients[i];
123
124         if( p_old->b_deleted &&
125            (p_old->i_timeout > mdate()) )
126         {
127             REMOVE_ELEM( p_rtcp->pp_clients, p_rtcp->i_clients, i );
128             p_rtcp->i_clients--;
129             SDES_client_item_del( p_old );
130             free( p_old );
131         }
132     }
133     vlc_object_unlock( p_rtcp );
134     return VLC_SUCCESS;
135 }
136
137 /* Close communication with clients and release allocated objects */
138 int rtcp_destroy_clients( vlc_object_t *p_this )
139 {
140     rtcp_t *p_rtcp = (rtcp_t *) p_this;
141     uint32_t i = 0;
142
143     for( i=0; i < p_rtcp->i_clients; i++ )
144     {
145         rtcp_pkt_t *pkt = NULL;
146         rtcp_client_t *p_old = p_rtcp->pp_clients[i];
147
148         p_rtcp->pf_del_client( p_this, p_old->u_ssrc );
149     pkt = rtcp_pkt_new( p_this, RTCP_BYE );
150     if( pkt )
151     {
152         block_t *p_block = NULL;
153         p_block = rtcp_encode_BYE( p_this, pkt, strdup("server is leaving") );
154             /* FIXME:
155              * if( p_block )
156          *    send_RTCP( p_this, p_block );
157              */
158     }
159             
160     }
161     /* wait till all clients have been signalled */
162     while( p_rtcp->i_clients != 0 )
163     {
164         p_rtcp->pf_cleanup_clients( p_this );
165         msleep( 500 );
166     }
167     return VLC_SUCCESS;
168 }
169
170 /*  rtcp_find_client should be called with the object lock held.
171  *  vlc_mutex_lock( &p_rtcp->obj_lock );
172  */
173 int rtcp_find_client( vlc_object_t *p_this, uint32_t u_ssrc, uint32_t *i_pos )
174 {
175     rtcp_t *p_rtcp = (rtcp_t *) p_this;
176     uint32_t i = 0;
177
178     for( i=0; i < p_rtcp->i_clients; i++ )
179     {
180         if( p_rtcp->pp_clients[i]->u_ssrc == u_ssrc )
181         {
182             *i_pos = i;
183             return VLC_SUCCESS;
184         }
185     }
186     *i_pos = -1;
187     return VLC_EGENERIC;
188 }
189
190 /*--------------------------------------------------------------------------
191  * rtcp_interval - Calculate the interval in seconds for sending RTCP packets.
192  *--------------------------------------------------------------------------
193  */
194 uint64_t rtcp_interval( vlc_object_t *p_this, uint64_t u_bandwidth, uint32_t u_ssrc,
195                         bool b_sender, bool b_first )
196 {
197     rtcp_t *p_rtcp = (rtcp_t *) p_this;
198     rtcp_client_t *p_client = NULL;
199     uint32_t i_rtcp_min = 5; /* seconds */
200     uint32_t i_pos = 0;
201     double i_bandwidth = u_bandwidth;
202     const double i_compensation = 2.71828 - 1.5;
203     double i_interval = 0;
204     int n = p_rtcp->i_clients;
205
206     if( b_first )
207         i_rtcp_min = (i_rtcp_min >> 1);
208
209     if( (double)(p_rtcp->u_active) <= (double)(p_rtcp->u_clients * 0.25) )
210     {
211         if( b_sender )
212         {
213             i_bandwidth = i_bandwidth * 0.25;
214             n = p_rtcp->u_active;
215         }
216         else
217         {
218             i_bandwidth = i_bandwidth * ( 1 - 0.25 );
219             n = n - p_rtcp->u_active;
220         }
221     }
222     /* calculate average time between reports */
223     p_client = p_rtcp->pf_find_client( p_this, u_ssrc, &i_pos );
224     if( !p_client )
225         return -1;
226         
227     i_interval = p_client->p_stats->u_avg_pkt_size * ( n / i_bandwidth );
228     if( i_interval < i_rtcp_min )
229         i_interval = i_rtcp_min;
230     i_interval = i_interval * ( drand48() + 0.5 );
231     i_interval = (double) (i_interval / i_compensation);
232
233     return (uint64_t)i_interval;
234 }
235
236 /*--------------------------------------------------------------------------
237  * rtcp_expire - decides to sent an RTCP report or a BYE record
238  *--------------------------------------------------------------------------
239  */
240 void rtcp_expire( vlc_object_t *p_this, rtcp_event_t rtcp_event, uint64_t u_bandwidth,
241           uint32_t u_ssrc, bool b_sender, bool *b_first )
242 {
243     rtcp_t *p_rtcp = (rtcp_t *) p_this;
244     rtcp_client_t *p_client = NULL;
245     rtcp_stats_t *p_stats = NULL;
246     mtime_t i_interval = 0;
247     uint32_t i_pos = 0;
248
249     p_client = p_rtcp->pf_find_client( p_this, u_ssrc, &i_pos );
250     if( !p_client )
251         return;
252     p_stats = (rtcp_stats_t*) p_client->p_stats;
253     i_interval = (mtime_t) rtcp_interval( p_this, u_bandwidth,
254                                           u_ssrc, b_sender, *b_first );
255     p_rtcp->i_next_date = p_rtcp->i_last_date + i_interval;
256
257     switch( rtcp_event )
258     {
259         case EVENT_BYE:
260             if( p_rtcp->i_next_date <= p_rtcp->i_date )
261                 send_RTCP( p_this, rtcp_event );
262             else
263                 rtcp_schedule( p_this, p_rtcp->i_next_date, rtcp_event );
264             break;
265
266         case EVENT_REPORT:
267             if( p_rtcp->i_next_date <= p_rtcp->i_date )
268             {
269                 send_RTCP( p_this, rtcp_event );
270
271                 /* Magic numbers are from RFC 3550 page 92
272                  * 1.0/16.0 = 0.0625 and
273                  * 15.0/16.0 = 0.9375
274                  */
275                 p_stats->u_avg_pkt_size = (uint64_t)
276                       ( (double) ( (double)p_stats->u_sent_pkt_size / ((double)0.0625) ) +
277                       ( ((double)0.9357) * p_stats->u_avg_pkt_size ) );
278
279                 /* recalculate */
280                 p_rtcp->i_last_date = p_rtcp->i_date;
281                 i_interval = rtcp_interval( p_this, u_bandwidth,
282                                             u_ssrc, b_sender, *b_first );
283                 rtcp_schedule( p_this, p_rtcp->i_next_date + i_interval, rtcp_event );
284                 *b_first = false;
285             }
286             else
287             {
288                 rtcp_schedule( p_this, p_rtcp->i_next_date, rtcp_event );
289             }
290             break;
291     }
292     p_rtcp->i_date = p_rtcp->i_next_date;
293 }
294
295 /*--------------------------------------------------------------------------
296  * Local functions prototoypes
297  *--------------------------------------------------------------------------
298  */
299 static int rtcp_decode_SR( vlc_object_t *p_this, rtcp_pkt_t *p_pkt );
300 static int rtcp_decode_RR( vlc_object_t *p_this, rtcp_pkt_t *p_pkt );
301 static int rtcp_decode_SR( vlc_object_t *p_this, rtcp_pkt_t *p_pkt );
302 static int rtcp_decode_SDES( vlc_object_t *p_this, rtcp_pkt_t *p_pkt );
303 static int rtcp_decode_BYE( vlc_object_t *p_this, rtcp_pkt_t *p_pkt );
304 static int rtcp_decode_APP( vlc_object_t *p_this, rtcp_pkt_t *p_pkt );
305
306 /*--------------------------------------------------------------------------
307  * Local functions
308  *--------------------------------------------------------------------------
309  */
310 static int rtcp_decode_SR( vlc_object_t *p_this, rtcp_pkt_t *p_pkt )
311 {
312     rtcp_t *p_rtcp = (rtcp_t *) p_this;
313     unsigned int i = 0;
314
315     if( !p_pkt )
316         return VLC_EGENERIC;
317
318     msg_Dbg( p_this, "decoding record: SR" );
319
320     /* parse sender info */
321     p_pkt->u_payload_type = RTCP_SR;
322     p_pkt->report.sr.ntp_timestampH = bs_read( p_rtcp->bs, 32 );
323     p_pkt->report.sr.ntp_timestampL = bs_read( p_rtcp->bs, 32 );
324     p_pkt->report.sr.rtp_timestamp  = bs_read( p_rtcp->bs, 32 );
325     p_pkt->report.sr.u_pkt_count    = bs_read( p_rtcp->bs, 32 ); /*sender*/
326     p_pkt->report.sr.u_octet_count  = bs_read( p_rtcp->bs, 32 ); /*sender*/
327
328     /* parse report block */
329     for( i=0; i < p_pkt->u_report; i++ )
330     {
331         rtcp_client_t *p_client = NULL;
332         uint32_t i_pos = 0;
333         uint32_t u_ssrc = 0;
334
335         u_ssrc = bs_read( p_rtcp->bs, 32 );
336
337         if( p_rtcp->pf_find_client( p_this, u_ssrc, &i_pos ) == VLC_EGENERIC )
338         {
339             if( p_rtcp->pf_add_client( p_this, p_pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
340                 return VLC_ENOMEM;
341         }
342         vlc_object_lock( p_rtcp );
343         p_client = p_rtcp->pp_clients[i_pos];
344
345         p_client->p_stats->u_SR_received++;
346         p_client->p_stats->u_pkt_count++;
347         p_client->p_stats->u_octet_count++;
348
349         msg_Dbg( p_this, "SR received %d, packet count %d, octect count %d, SSRC count %d",
350             p_client->p_stats->u_SR_received,
351             p_client->p_stats->u_pkt_count,
352             p_client->p_stats->u_octet_count,
353             p_pkt->u_ssrc );
354         
355         p_client->p_stats->u_fraction_lost = bs_read( p_rtcp->bs, 8 );
356         p_client->p_stats->u_pkt_lost = bs_read( p_rtcp->bs, 24 );
357         p_client->p_stats->u_highest_seq_no = bs_read( p_rtcp->bs, 32 );
358         p_client->p_stats->u_jitter  = bs_read( p_rtcp->bs, 32 );
359         p_client->p_stats->u_last_SR = bs_read( p_rtcp->bs, 32 );
360         p_client->p_stats->u_delay_since_last_SR = (mtime_t) bs_read( p_rtcp->bs, 32 );
361
362         /* Magic numbers are from RFC 3550 page 92
363          * 1.0/16.0 = 0.0625 and
364          * 15.0/16.0 = 0.9375
365          */
366         p_client->p_stats->u_avg_pkt_size = (uint64_t)
367             ( (double)((double)p_client->p_stats->u_sent_pkt_size * (double)(0.0625)) +
368               ((double)(0.9375) * p_client->p_stats->u_avg_pkt_size) );
369
370         msg_Dbg( p_this, "fract lost %d, packet lost %d, highest seqno %d, "
371                          "jitter %d, last SR %d, delay %lld",
372             p_client->p_stats->u_fraction_lost,
373             p_client->p_stats->u_pkt_lost,
374             p_client->p_stats->u_highest_seq_no,
375             p_client->p_stats->u_jitter,
376             p_client->p_stats->u_last_SR,
377             p_client->p_stats->u_delay_since_last_SR );
378         p_client = NULL;
379         vlc_object_unlock( p_rtcp );
380     }
381     return VLC_SUCCESS;
382 }
383
384 static int rtcp_decode_RR( vlc_object_t *p_this, rtcp_pkt_t *p_pkt )
385 {
386     rtcp_t *p_rtcp = (rtcp_t *) p_this;
387     unsigned int i = 0;
388
389     if( !p_pkt )
390         return VLC_EGENERIC;
391
392     msg_Dbg( p_this, "decoding record: RR" );
393
394     for( i=0; i < p_pkt->u_report; i++ )
395     {
396         rtcp_client_t *p_client = NULL;
397         uint32_t i_pos = 0;
398         uint32_t u_ssrc = 0;
399
400         u_ssrc = bs_read( p_rtcp->bs, 32 );
401
402         if( p_rtcp->pf_find_client( p_this, u_ssrc, &i_pos ) == VLC_EGENERIC )
403         {
404             if( p_rtcp->pf_add_client( p_this, p_pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
405                 return VLC_ENOMEM;
406         }
407
408         vlc_object_lock( p_rtcp );
409         p_client = p_rtcp->pp_clients[i_pos];
410
411         p_client->p_stats->u_RR_received++;
412         msg_Dbg( p_this, "RR received %d, SSRC %d",
413                  p_client->p_stats->u_RR_received, u_ssrc );
414
415         p_client->p_stats->u_fraction_lost = bs_read( p_rtcp->bs, 8 );
416         p_client->p_stats->u_pkt_lost = bs_read( p_rtcp->bs, 24 );
417         p_client->p_stats->u_highest_seq_no = bs_read( p_rtcp->bs, 32 );
418         p_client->p_stats->u_jitter  = bs_read( p_rtcp->bs, 32 );
419         p_client->p_stats->u_last_SR = bs_read( p_rtcp->bs, 32 );
420         p_client->p_stats->u_delay_since_last_SR = (mtime_t) bs_read( p_rtcp->bs, 32 );
421
422         /* Magic numbers are from RFC 3550 page 92
423          * 1.0/16.0 = 0.0625 and
424          * 15.0/16.0 = 0.9375
425          */
426         p_client->p_stats->u_avg_pkt_size = (uint64_t)
427             ( (double)((double)p_client->p_stats->u_sent_pkt_size * (double)(0.0625)) +
428               ((double)(0.9375) * p_client->p_stats->u_avg_pkt_size) );
429
430         msg_Dbg( p_this, "fract lost %d, packet lost %d, highest seqno %d, "
431                          "jitter %d, last SR %d, delay %lld",
432             p_client->p_stats->u_fraction_lost,
433             p_client->p_stats->u_pkt_lost,
434             p_client->p_stats->u_highest_seq_no,
435             p_client->p_stats->u_jitter,
436             p_client->p_stats->u_last_SR,
437             p_client->p_stats->u_delay_since_last_SR );
438         p_client = NULL;
439         vlc_object_unlock( p_rtcp );
440     }
441     return VLC_SUCCESS;
442 }
443
444 static int rtcp_decode_SDES( vlc_object_t *p_this, rtcp_pkt_t *p_pkt )
445 {
446     rtcp_t *p_rtcp = (rtcp_t *) p_this;
447     unsigned int i = 0;
448
449     if( !p_pkt )
450         return VLC_EGENERIC;
451
452     msg_Dbg( p_this, "decoding record: SDES" );
453
454     for( i = 0; i < p_pkt->u_report; i++ )
455     {
456         rtcp_client_t *p_client = NULL;
457         uint32_t i_pos = 0;
458         uint32_t u_ssrc = 0;
459         uint8_t  u_item = 0;
460         uint8_t  u_length = 0;
461         int   i = 0;
462
463         u_ssrc = bs_read( p_rtcp->bs, 32 );
464
465         if( p_rtcp->pf_find_client( p_this, u_ssrc, &i_pos ) == VLC_EGENERIC )
466         {
467             if( p_rtcp->pf_add_client( p_this, p_pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
468                 return VLC_ENOMEM;
469         }
470
471         vlc_object_lock( p_rtcp );
472         p_client = p_rtcp->pp_clients[i_pos];
473
474         u_item = bs_read( p_rtcp->bs, 8 );
475         switch( u_item )
476         {
477             case RTCP_SDES_CNAME:
478             case RTCP_SDES_NAME:
479             case RTCP_SDES_EMAIL:
480             case RTCP_SDES_PHONE:
481             case RTCP_SDES_LOC:
482             case RTCP_SDES_TOOL:
483             case RTCP_SDES_NOTE:
484             {
485                 char psz_name[255];
486
487                 u_length = bs_read( p_rtcp->bs, 8 );
488                 for( i = 0 ; i < u_length; i++ )
489                 {
490                     psz_name[i] = bs_read( p_rtcp->bs, 8 );
491                 }
492                 SDES_client_item_add( p_client, u_item, psz_name );
493             }
494             break;
495
496             case RTCP_SDES_PRIV: /* ignoring these */
497             {
498                 uint8_t u_prefix_len = 0;
499                 uint8_t u_length = 0;
500                 char psz_prefix_name[255];
501                 char psz_name[255];
502
503                 u_length = bs_read( p_rtcp->bs, 8 );
504                 u_prefix_len = bs_read( p_rtcp->bs, 8 );
505                 if( u_prefix_len > 254 )
506                     u_prefix_len = 254;
507
508                 for( i=0 ; i < u_prefix_len; i++ )
509                 {
510                     psz_prefix_name[i] = bs_read( p_rtcp->bs, 8 );
511                 }
512                 psz_prefix_name[255] = '\0';
513                 SDES_client_item_add( p_client, u_item, psz_prefix_name );
514
515                 for( i=0 ; i < u_length; i++ )
516                 {
517                     psz_name[i] = bs_read( p_rtcp->bs, 8 );
518                 }
519                 psz_name[255] = '\0';
520                 SDES_client_item_add( p_client, u_item, psz_name );
521             }
522             break;
523
524             default:
525                 return VLC_EGENERIC;
526         }
527         /* Magic numbers are from RFC 3550 page 92
528          * 1.0/16.0 = 0.0625 and
529          * 15.0/16.0 = 0.9375
530          */
531         p_client->p_stats->u_avg_pkt_size = (uint64_t)
532             ( (double)((double)p_client->p_stats->u_sent_pkt_size * (double)(0.0625)) +
533               ((double)(0.9375) * p_client->p_stats->u_avg_pkt_size) );
534
535         p_client = NULL;
536         vlc_object_unlock( p_rtcp );
537     }
538     return VLC_SUCCESS;
539 }
540
541 static int rtcp_decode_BYE( vlc_object_t *p_this, rtcp_pkt_t *p_pkt )
542 {
543     rtcp_t    *p_rtcp = (rtcp_t *) p_this;
544     uint32_t  u_ssrc = 0;
545     uint8_t   u_length = 0;
546     int       i = 0;
547
548     if( !p_pkt )
549         return VLC_EGENERIC;
550
551     msg_Dbg( p_this, "decoding record: BYE" );
552
553     u_ssrc = bs_read( p_rtcp->bs, 32 );
554     p_rtcp->pf_del_client( p_this, u_ssrc );
555     u_length = p_pkt->u_length-1;
556     for( i = 0 ; i < u_length; i++ )
557     {
558         u_ssrc = bs_read( p_rtcp->bs, 8 );
559         p_rtcp->pf_del_client( p_this, u_ssrc );
560     }
561     return VLC_SUCCESS;
562 }
563
564 static int rtcp_decode_APP( vlc_object_t *p_this, rtcp_pkt_t *p_pkt )
565 {
566     rtcp_t        *p_rtcp = (rtcp_t *) p_this;
567     rtcp_client_t *p_client = NULL;
568     char  psz_name[4];
569     char* psz_data = NULL;
570     uint32_t u_ssrc = 0;
571     uint32_t i_pos = 0;
572     uint32_t i = 0;
573
574     if( !p_pkt )
575         return VLC_EGENERIC;
576
577     msg_Dbg( p_this, "decoding record: APP" );
578
579     u_ssrc = bs_read( p_rtcp->bs, 32 );
580
581     if( p_rtcp->pf_find_client( p_this, u_ssrc, &i_pos ) == VLC_EGENERIC )
582     {
583         if( p_rtcp->pf_add_client( p_this, p_pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
584             return VLC_ENOMEM;
585     }
586
587     vlc_object_lock( p_rtcp );
588     p_client = p_rtcp->pp_clients[i_pos];
589
590     for( i = 0 ; i < 4; i++ )
591     {
592         psz_name[i] = bs_read( p_rtcp->bs, 8 );
593     }
594     psz_name[4] = '\0';
595     
596     p_pkt->u_payload_type = RTCP_APP;
597     p_pkt->report.app.psz_prefix = strdup( psz_name );
598     p_pkt->report.app.u_prefix_len = 4;
599     p_pkt->u_length -= 4;
600
601     psz_data = (char *) malloc( p_pkt->u_length );
602     if( !psz_data ) {
603         vlc_object_unlock( p_rtcp );
604         return VLC_EGENERIC;
605     }
606
607     for( i = 0; i < p_pkt->u_length; i-- )
608     {
609         psz_data[i] = bs_read( p_rtcp->bs, 8 );
610     }
611     psz_data[p_pkt->u_length] = '\0';
612
613     p_pkt->report.app.psz_data = strdup( psz_data );
614     p_pkt->report.app.u_length = p_pkt->u_length;
615
616     p_client = NULL;
617     vlc_object_unlock( p_rtcp );
618
619     /* Just ignore this packet */
620     return VLC_SUCCESS;
621 }
622
623 /* Decode RTCP packet
624  * Decode incoming RTCP packet and inspect the records types.
625  */
626 int rtcp_pkt_decode( vlc_object_t *p_this, rtcp_pkt_t *p_pkt, block_t *p_block )
627 {
628     rtcp_t *p_rtcp = (rtcp_t *) p_this;
629
630     if( !p_pkt && !p_block )
631         return VLC_EGENERIC;
632
633     bs_init( p_rtcp->bs, p_block->p_buffer, p_block->i_buffer );
634
635     p_pkt->u_version = bs_read( p_rtcp->bs, 2 );
636     p_pkt->b_padding = bs_read( p_rtcp->bs, 1 ) ? true : false;
637     p_pkt->u_report  = bs_read( p_rtcp->bs, 5 );
638     p_pkt->u_payload_type = bs_read( p_rtcp->bs, 8 );
639     p_pkt->u_length = bs_read( p_rtcp->bs, 16 );
640
641     if( p_pkt->u_payload_type != RTCP_SDES )
642         p_pkt->u_ssrc = bs_read( p_rtcp->bs, 32 );
643
644     msg_Dbg( p_this, "New RTCP packet: version %d, padding %s, count %d, "
645                      "type %d, length %d, SSRC %d",
646         p_pkt->u_version,
647         p_pkt->b_padding ? "true" : "false",
648         p_pkt->u_report,
649         p_pkt->u_payload_type,
650         p_pkt->u_length,
651         p_pkt->u_ssrc );
652
653     while( !bs_eof( p_rtcp->bs ) )
654     {
655         uint32_t i_pos = 0;
656         
657         switch( p_pkt->u_payload_type )
658         {
659             case RTCP_SR:
660                 if( p_rtcp->pf_find_client( p_this, p_pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
661                     p_rtcp->pf_add_client( p_this, p_pkt->u_ssrc, &i_pos );
662                 rtcp_decode_SR( p_this, p_pkt );
663                 break;
664
665             case RTCP_RR:
666                 if( p_rtcp->pf_find_client( p_this, p_pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
667                     p_rtcp->pf_add_client( p_this, p_pkt->u_ssrc, &i_pos );
668                 rtcp_decode_RR( p_this, p_pkt );
669                 break;
670
671             case RTCP_SDES:
672                 if( p_rtcp->pf_find_client( p_this, p_pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
673                     p_rtcp->pf_add_client( p_this, p_pkt->u_ssrc, &i_pos );
674                 rtcp_decode_SDES( p_this, p_pkt );
675                 break;
676
677             case RTCP_BYE:
678                 rtcp_decode_BYE( p_this, p_pkt );
679 #if 0
680                  if( p_rtcp->pf_find_sender( p_this, pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
681                      p_rtcp->pf_del_sender( p_this, p_pkt->u_ssrc );
682 #endif
683                 if( p_rtcp->pf_find_client( p_this, p_pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
684                     p_rtcp->pf_del_client( p_this, p_pkt->u_ssrc );
685
686                 if( p_rtcp->u_active < p_rtcp->u_members )
687                 {
688                     rtcp_event_t event = EVENT_BYE;
689                     
690                     p_rtcp->i_next_date = p_rtcp->i_date +
691                                 (mtime_t) ( (p_rtcp->u_active / p_rtcp->u_members) *
692                                             (p_rtcp->i_next_date - p_rtcp->i_date) );
693                     p_rtcp->i_last_date = p_rtcp->i_date -
694                                         (mtime_t)
695                                             ( (mtime_t)(p_rtcp->u_active / p_rtcp->u_members) *
696                                               (p_rtcp->i_date - p_rtcp->i_last_date) );
697                     /* schedule for next period */
698                     rtcp_schedule( VLC_OBJECT(p_rtcp), p_rtcp->i_next_date, event );
699                     p_rtcp->u_members = p_rtcp->u_active;
700                 }
701                 else p_rtcp->u_members++;
702                 break;
703
704             case RTCP_APP:
705                 if( p_rtcp->pf_find_client( p_this, p_pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
706                     p_rtcp->pf_add_client( p_this, p_pkt->u_ssrc, &i_pos );
707                 rtcp_decode_APP( p_this, p_pkt );
708                 break;
709
710             default:
711                 return VLC_EGENERIC;
712         }
713     }
714     return VLC_SUCCESS;
715 }
716
717 /*
718  * Create RTCP records for reporting to server.
719  */
720 rtcp_pkt_t *rtcp_pkt_new( vlc_object_t *p_this, int type )
721 {
722     rtcp_pkt_t *p_pkt = NULL;
723
724     p_pkt = (rtcp_pkt_t *) malloc( sizeof( rtcp_pkt_t ) );
725     if( !p_pkt )
726         return NULL;
727
728     memset( p_pkt, 0 , sizeof( rtcp_pkt_t ) );
729     p_pkt->u_version = 2;
730     p_pkt->u_payload_type = type;
731     p_pkt->u_length = RTCP_HEADER_LEN;
732
733     switch( type )
734     {
735         case RTCP_SR:
736             p_pkt->u_length += sizeof(rtcp_SR_t);
737             break;
738         case RTCP_RR:
739             p_pkt->u_length += sizeof(rtcp_RR_t);
740             break;
741         case RTCP_SDES:
742             p_pkt->u_length += sizeof(rtcp_SDES_t);
743             if( p_pkt->report.sdes.pp_items )
744                 p_pkt->u_length += p_pkt->report.sdes.u_items;
745             break;
746         case RTCP_BYE:
747             p_pkt->u_length += sizeof(rtcp_BYE_t);
748             break;
749         case RTCP_APP:
750             p_pkt->u_length += sizeof(rtcp_APP_t);
751             break;
752         default:
753             free(p_pkt);
754             return NULL;
755     }
756     return p_pkt;
757 }
758
759 void rtcp_pkt_del( vlc_object_t *p_this, rtcp_pkt_t *p_pkt )
760 {
761     if( !p_pkt )
762         return;
763
764     switch( p_pkt->u_payload_type )
765     {
766         case RTCP_SR:
767         case RTCP_RR:
768             break;
769         case RTCP_SDES:
770             if( p_pkt->report.sdes.pp_items )
771             {
772                 uint32_t i = 0;
773
774                 for( i = 0; i < p_pkt->report.sdes.u_items; i++ )
775                 {
776                     rtcp_SDES_item_t *p_old =
777                         p_pkt->report.sdes.pp_items[i];
778                     REMOVE_ELEM( p_pkt->report.sdes.pp_items,
779                                  p_pkt->report.sdes.u_items, i );
780                     p_pkt->report.sdes.u_items--;
781                     if( p_old->psz_data )
782                         free( p_old->psz_data );
783                     free( p_old );
784                 }
785             }
786             break;
787         case RTCP_BYE:
788             break;
789         case RTCP_APP:
790             if( p_pkt->report.app.psz_prefix )
791                 free( p_pkt->report.app.psz_prefix );
792             if( p_pkt->report.app.psz_data )
793                 free( p_pkt->report.app.psz_data );
794             break;
795         default:
796             msg_Err( p_this, "unknown RTCP packet type %d: "
797                              "possible leaking of memory.",
798                             p_pkt->u_payload_type );
799             break;
800     }
801     free( p_pkt );
802 }
803
804 block_t *rtcp_encode_SR( vlc_object_t *p_this, rtcp_pkt_t *p_pkt )
805 {
806     rtcp_t *p_rtcp = (rtcp_t *) p_this;
807     mtime_t ntp_time;
808     bs_t bits, *s = &bits;
809     block_t *p_block = NULL;
810     rtcp_stats_t *p_stats = NULL;
811     rtcp_client_t *p_client = NULL;
812     uint32_t i_pos = 0;
813
814     if( p_pkt->u_payload_type != RTCP_SR )
815         return NULL;
816
817     /* FIXME: Maybe this should be a buffer pool instead */
818     p_block = block_New( p_this, p_pkt->u_length );
819     if( !p_block )
820         return NULL;
821
822     bs_init( s, p_block->p_buffer, p_block->i_buffer );
823
824     /* Fill in header */
825     bs_write( s, 2, p_pkt->u_version );
826     bs_write( s, 1, 0 ); /* padding */
827     bs_write( s, 5, p_pkt->u_report );
828     bs_write( s, 8, p_pkt->u_payload_type );
829     bs_write( s, 16, p_pkt->u_length );
830     bs_write( s, 32, p_pkt->u_ssrc );
831
832     /* sender info */
833     ntp_time = mdate();
834     bs_write( s, 32, ((unsigned int)(ntp_time>>32)) ); /* ntp_timestampH */
835     bs_write( s, 32, ((unsigned int)ntp_time) );/* ntp_timestampL */
836
837     /* FIXME: Make sure to generate a good RTP server timestamp.
838         p_pkt->report.sr.rtp_timestamp = htonl(
839         (unsigned int) ((double)ntp_time.tv_sec +
840         (double)ntp_time.tv_usec/1000000.) * p_mux->rate
841         + session->start_rtptime ); */
842     bs_write( s, 32, p_pkt->report.sr.rtp_timestamp );
843     bs_write( s, 32, p_pkt->report.sr.u_pkt_count );
844     bs_write( s, 32, p_pkt->report.sr.u_octet_count );
845
846     /* report block */
847     if( p_rtcp->pf_find_client( p_this, p_pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
848     {
849         msg_Err( p_this, "SR: SSRC identifier doesn't exists", p_pkt->u_ssrc );
850         free( p_block );
851         return NULL;
852     }
853
854     vlc_object_lock( p_rtcp );
855     p_client = p_rtcp->pp_clients[i_pos];
856
857     p_stats = p_client->p_stats;
858     if( !p_stats ) {
859         msg_Err( p_this, "SR: SSRC identifier doesn't exists", p_pkt->u_ssrc );
860         free( p_block );
861         return NULL;
862     }
863     bs_write( s, 32, p_stats->l_dest_SSRC );
864     bs_write( s,  8, p_stats->u_fraction_lost );
865     bs_write( s, 24, p_stats->u_pkt_lost );
866     bs_write( s, 32, p_stats->u_highest_seq_no );
867     bs_write( s, 32, p_stats->u_jitter );
868     bs_write( s, 32, p_stats->u_last_SR );
869     bs_write( s, 32, p_stats->u_delay_since_last_SR );
870
871     p_client = NULL;
872     vlc_object_unlock( p_rtcp );
873
874     /* possible SR extension */
875     return p_block;
876 }
877
878 block_t *rtcp_encode_RR( vlc_object_t *p_this, rtcp_pkt_t *p_pkt )
879 {
880     rtcp_t *p_rtcp = (rtcp_t *) p_this;
881     bs_t bits, *s = &bits;
882     block_t *p_block = NULL;
883     rtcp_stats_t *p_stats = NULL;
884     rtcp_client_t *p_client = NULL;
885     uint32_t i_pos = 0;
886
887     if( p_pkt->u_payload_type != RTCP_RR )
888         return NULL;
889
890     /* FIXME: Maybe this should be a buffer pool instead */
891     p_block = block_New( p_this, p_pkt->u_length );
892     if( !p_block )
893         return NULL;
894
895     bs_init( s, p_block->p_buffer, p_block->i_buffer );
896
897     /* Fill in header */
898     bs_write( s, 2, p_pkt->u_version );
899     bs_write( s, 1, 0 ); /* padding */
900     bs_write( s, 5, p_pkt->u_report );
901     bs_write( s, 8, p_pkt->u_payload_type );
902     bs_write( s, 16, p_pkt->u_length );
903     bs_write( s, 32, p_pkt->u_ssrc );
904
905     /* report block */
906     if( p_rtcp->pf_find_client( p_this, p_pkt->u_ssrc, &i_pos ) == VLC_EGENERIC )
907     {
908         msg_Err( p_this, "RR: SSRC identifier doesn't exists", p_pkt->u_ssrc );
909         free( p_block );
910         return NULL;
911     }
912
913     vlc_object_lock( p_rtcp );
914     p_client = p_rtcp->pp_clients[i_pos];
915
916     p_stats = p_client->p_stats;
917     if( !p_stats ) {
918         msg_Err( p_this, "RR: SSRC identifier doesn't exists", p_pkt->u_ssrc );
919         free( p_block );
920         return NULL;
921     }
922     bs_write( s, 32, p_stats->l_dest_SSRC );
923     bs_write( s,  8, p_stats->u_fraction_lost );
924     bs_write( s, 24, p_stats->u_pkt_lost );
925     bs_write( s, 32, p_stats->u_highest_seq_no );
926     bs_write( s, 32, p_stats->u_jitter );
927     bs_write( s, 32, p_stats->u_last_RR );
928     bs_write( s, 32, p_stats->u_delay_since_last_RR );
929
930     p_client = NULL;
931     vlc_object_unlock( p_rtcp );
932
933     /* possible RR extension */
934     return p_block;
935 }
936
937 block_t *rtcp_encode_SDES( vlc_object_t *p_this, rtcp_pkt_t *p_pkt )
938 {
939     bs_t bits, *s = &bits;
940     block_t *p_block = NULL;
941     uint32_t i_chunks;
942
943     if( p_pkt->u_payload_type != RTCP_SDES )
944         return NULL;
945
946     /* FIXME: Maybe this should be a buffer pool instead */
947     p_block = block_New( p_this, p_pkt->u_length );
948     if( !p_block )
949         return NULL;
950
951     bs_init( s, p_block->p_buffer, p_block->i_buffer );
952
953     /* Fill in header */
954     bs_write( s, 2, p_pkt->u_version );
955     bs_write( s, 1, 0 ); /* padding */
956     bs_write( s, 5, p_pkt->u_report ); /* Number of SSRC/CSRC chunks */
957     bs_write( s, 8, p_pkt->u_payload_type );
958     bs_write( s, 16, p_pkt->u_length );
959     bs_write( s, 32, p_pkt->u_ssrc );
960
961     /* fill in record */
962     for( i_chunks = 0; i_chunks < p_pkt->u_report; i_chunks++ )
963     {
964         uint32_t i_item;
965
966         for( i_item = 0 ; i_item < p_pkt->report.sdes.u_items; i_item++ )
967         {
968             uint32_t i_count = strlen( p_pkt->report.sdes.pp_items[i_item]->psz_data );
969             uint8_t  u_octet = i_count / 8;  /* Octect count ??*/
970             rtcp_SDES_item_t *p_item = p_pkt->report.sdes.pp_items[i_item];
971             uint32_t i_pos, i_pad, i_padding;
972
973             bs_write( s, 8, p_item->u_type );
974             bs_write( s, 8, u_octet );
975
976             for( i_pos = 0; i_pos < i_count; i_pos++ )
977             {
978                 /* FIXME: must be UTF 8 encoded */
979                 bs_write( s, 8, p_item->psz_data[i_pos] );
980             }
981
982             /* do we need padding to 32 bit boundary? */
983             i_padding = 0;
984             if( ((i_count + 2) % 4) != 0 )
985                 i_padding = (i_count + 2) - (((i_count + 2) % 4) << 2);
986             for( i_pad = 0; i_pad < i_padding; i_pad++ )
987             {
988                 bs_write( s, 8, 0 );
989             }
990         }
991     }
992     return p_block;
993 }
994
995 block_t *rtcp_encode_BYE( vlc_object_t *p_this, rtcp_pkt_t *p_pkt, char *psz_reason )
996 {
997     bs_t bits, *s = &bits;
998     block_t *p_block = NULL;
999     uint32_t i_count = strlen( psz_reason );
1000     uint8_t  u_octet = i_count / 8;  /* Octect count ??*/
1001     int32_t i_pos, i_pad, i_padding;
1002
1003     if( p_pkt->u_payload_type != RTCP_BYE )
1004         return NULL;
1005
1006     /* FIXME: Maybe this should be a buffer pool instead */
1007     p_block = block_New( p_this, p_pkt->u_length );
1008     if( !p_block )
1009         return NULL;
1010
1011     bs_init( s, p_block->p_buffer, p_block->i_buffer );
1012
1013     /* Fill in header */
1014     bs_write( s, 2, p_pkt->u_version );
1015     bs_write( s, 1, 0 ); /* padding */
1016     bs_write( s, 5, p_pkt->u_report ); /* Number of SSRC/CSRC chunks */
1017     bs_write( s, 8, p_pkt->u_payload_type );
1018     bs_write( s, 16, p_pkt->u_length );
1019     bs_write( s, 32, p_pkt->u_ssrc );
1020
1021     /* Give reason for leaving */
1022     //FIXME: bs_write( s, 8, p_item->u_type );
1023     bs_write( s, 8, u_octet );
1024     
1025     for( i_pos = 0; i_pos < i_count; i_pos++ )
1026     {
1027         /* FIXME: must be UTF 8 encoded */
1028         bs_write( s, 8, psz_reason[i_pos] );
1029     }
1030
1031     /* do we need padding to 32 bit boundary? */
1032     i_padding = 0;
1033     if( ((i_count + 2) % 4) != 0 )
1034         i_padding = (i_count + 2) - (((i_count + 2) % 4) << 2);
1035     for( i_pad = 0; i_pad < i_padding; i_pad++ )
1036     {
1037         bs_write( s, 8, 0 );
1038     }
1039     return p_block;
1040 }