Removed unused old_flags.
[obnox/wireshark/wip.git] / tap-rtp-common.c
1 /* tap-rtp-common.c
2  * RTP stream handler functions used by tshark and wireshark
3  *
4  * $Id$
5  *
6  * Copyright 2008, Ericsson AB
7  * By Balint Reczey <balint.reczey@ericsson.com>
8  *
9  * most functions are copied from gtk/rtp_stream.c and gtk/rtp_analisys.c
10  * Copyright 2003, Alcatel Business Systems
11  * By Lars Ruoff <lars.ruoff@gmx.net>
12  *
13  * Wireshark - Network traffic analyzer
14  * By Gerald Combs <gerald@wireshark.org>
15  * Copyright 1998 Gerald Combs
16  *
17  * This program is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU General Public License
19  * as published by the Free Software Foundation; either version 2
20  * of the License, or (at your option) any later version.
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, write to the Free Software
29  * Foundation,  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
30  */
31
32 #ifdef HAVE_CONFIG_H
33 # include "config.h"
34 #endif
35
36 #include <stdio.h>
37 #include <math.h>
38 #include "globals.h"
39
40 #include <epan/tap.h>
41 #include "register.h"
42 #include <string.h>
43 #include <epan/rtp_pt.h>
44 #include <epan/addr_resolv.h>
45 #include <epan/dissectors/packet-rtp.h>
46 #include "gtk/rtp_stream.h"
47 #include "tap-rtp-common.h"
48
49
50
51 /****************************************************************************/
52 /* GCompareFunc style comparison function for _rtp_stream_info */
53 gint rtp_stream_info_cmp(gconstpointer aa, gconstpointer bb)
54 {
55         const struct _rtp_stream_info* a = aa;
56         const struct _rtp_stream_info* b = bb;
57
58         if (a==b)
59                 return 0;
60         if (a==NULL || b==NULL)
61                 return 1;
62         if (ADDRESSES_EQUAL(&(a->src_addr), &(b->src_addr))
63                 && (a->src_port == b->src_port)
64                 && ADDRESSES_EQUAL(&(a->dest_addr), &(b->dest_addr))
65                 && (a->dest_port == b->dest_port)
66                 && (a->ssrc == b->ssrc))
67                 return 0;
68         else
69                 return 1;
70 }
71
72
73 /****************************************************************************/
74 /* when there is a [re]reading of packet's */
75 void rtpstream_reset(rtpstream_tapinfo_t *tapinfo)
76 {
77         GList* list;
78
79         if (tapinfo->mode == TAP_ANALYSE) {
80                 /* free the data items first */
81                 list = g_list_first(tapinfo->strinfo_list);
82                 while (list)
83                 {
84                         g_free(list->data);
85                         list = g_list_next(list);
86                 }
87                 g_list_free(tapinfo->strinfo_list);
88                 tapinfo->strinfo_list = NULL;
89                 tapinfo->nstreams = 0;
90                 tapinfo->npackets = 0;
91         }
92
93         ++(tapinfo->launch_count);
94
95         return;
96 }
97
98 void rtpstream_reset_cb(void *arg)
99 {
100         rtpstream_reset(arg);
101 }
102
103 /*
104 * rtpdump file format
105 *
106 * The file starts with the tool to be used for playing this file,
107 * the multicast/unicast receive address and the port.
108 *
109 * #!rtpplay1.0 224.2.0.1/3456\n
110 *
111 * This is followed by one binary header (RD_hdr_t) and one RD_packet_t
112 * structure for each received packet.  All fields are in network byte
113 * order.  We don't need the source IP address since we can do mapping
114 * based on SSRC.  This saves (a little) space, avoids non-IPv4
115 * problems and privacy/security concerns. The header is followed by
116 * the RTP/RTCP header and (optionally) the actual payload.
117 */
118
119 #define RTPFILE_VERSION "1.0"
120
121 /*
122 * Write a header to the current output file.
123 * The header consists of an identifying string, followed
124 * by a binary structure.
125 */
126 void rtp_write_header(rtp_stream_info_t *strinfo, FILE *file)
127 {
128         guint32 start_sec;     /* start of recording (GMT) (seconds) */
129         guint32 start_usec;    /* start of recording (GMT) (microseconds)*/
130         guint32 source;        /* network source (multicast address) */
131         size_t sourcelen;
132         guint16 port;          /* UDP port */
133         guint16 padding;       /* 2 padding bytes */
134
135         fprintf(file, "#!rtpplay%s %s/%u\n", RTPFILE_VERSION,
136                 get_addr_name(&(strinfo->dest_addr)),
137                 strinfo->dest_port);
138
139         start_sec = g_htonl(strinfo->start_sec);
140         start_usec = g_htonl(strinfo->start_usec);
141         /* rtpdump only accepts guint32 as source, will be fake for IPv6 */
142         memset(&source, 0, sizeof source);
143         sourcelen = strinfo->src_addr.len;
144         if (sourcelen > sizeof source)
145                 sourcelen = sizeof source;
146         memcpy(&source, strinfo->src_addr.data, sourcelen);
147         port = g_htons(strinfo->src_port);
148         padding = 0;
149
150         if (fwrite(&start_sec, 4, 1, file) == 0)
151                 return;
152         if (fwrite(&start_usec, 4, 1, file) == 0)
153                 return;
154         if (fwrite(&source, 4, 1, file) == 0)
155                 return;
156         if (fwrite(&port, 2, 1, file) == 0)
157                 return;
158         if (fwrite(&padding, 2, 1, file) == 0)
159                 return;
160 }
161
162 /* utility function for writing a sample to file in rtpdump -F dump format (.rtp)*/
163 void rtp_write_sample(rtp_sample_t* sample, FILE* file)
164 {
165         guint16 length;    /* length of packet, including this header (may
166                              be smaller than plen if not whole packet recorded) */
167         guint16 plen;      /* actual header+payload length for RTP, 0 for RTCP */
168         guint32 offset;    /* milliseconds since the start of recording */
169
170         length = g_htons(sample->header.frame_length + 8);
171         plen = g_htons(sample->header.frame_length);
172         offset = g_htonl(sample->header.rec_time);
173
174         if (fwrite(&length, 2, 1, file) == 0)
175                 return;
176         if (fwrite(&plen, 2, 1, file) == 0)
177                 return;
178         if (fwrite(&offset, 4, 1, file) == 0)
179                 return;
180         if (fwrite(sample->frame, sample->header.frame_length, 1, file) == 0)
181                 return;
182 }
183
184
185 /****************************************************************************/
186 /* whenever a RTP packet is seen by the tap listener */
187 int rtpstream_packet(void *arg, packet_info *pinfo, epan_dissect_t *edt _U_, const void *arg2)
188 {
189         rtpstream_tapinfo_t *tapinfo = arg;
190         const struct _rtp_info *rtpinfo = arg2;
191         rtp_stream_info_t tmp_strinfo;
192         rtp_stream_info_t *strinfo = NULL;
193         GList* list;
194         rtp_sample_t sample;
195
196         struct _rtp_conversation_info *p_conv_data = NULL;
197
198         /* gather infos on the stream this packet is part of */
199         COPY_ADDRESS(&(tmp_strinfo.src_addr), &(pinfo->src));
200         tmp_strinfo.src_port = pinfo->srcport;
201         COPY_ADDRESS(&(tmp_strinfo.dest_addr), &(pinfo->dst));
202         tmp_strinfo.dest_port = pinfo->destport;
203         tmp_strinfo.ssrc = rtpinfo->info_sync_src;
204         tmp_strinfo.pt = rtpinfo->info_payload_type;
205         tmp_strinfo.info_payload_type_str = rtpinfo->info_payload_type_str;
206
207         if (tapinfo->mode == TAP_ANALYSE) {
208                 /* check whether we already have a stream with these parameters in the list */
209                 list = g_list_first(tapinfo->strinfo_list);
210                 while (list)
211                 {
212                         if (rtp_stream_info_cmp(&tmp_strinfo, (rtp_stream_info_t*)(list->data))==0)
213                         {
214                                 strinfo = (rtp_stream_info_t*)(list->data);  /*found!*/
215                                 break;
216                         }
217                         list = g_list_next(list);
218                 }
219
220                 /* not in the list? then create a new entry */
221                 if (!strinfo) {
222                         tmp_strinfo.npackets = 0;
223                         tmp_strinfo.first_frame_num = pinfo->fd->num;
224                         tmp_strinfo.start_sec = (guint32) pinfo->fd->abs_ts.secs;
225                         tmp_strinfo.start_usec = pinfo->fd->abs_ts.nsecs/1000;
226                         tmp_strinfo.start_rel_sec = (guint32) pinfo->fd->rel_ts.secs;
227                         tmp_strinfo.start_rel_usec = pinfo->fd->rel_ts.nsecs/1000;
228                         tmp_strinfo.tag_vlan_error = 0;
229                         tmp_strinfo.tag_diffserv_error = 0;
230                         tmp_strinfo.vlan_id = 0;
231                         tmp_strinfo.problem = FALSE;
232
233                         /* reset RTP stats */
234                         tmp_strinfo.rtp_stats.first_packet = TRUE;
235                         tmp_strinfo.rtp_stats.max_delta = 0;
236                         tmp_strinfo.rtp_stats.max_jitter = 0;
237                         tmp_strinfo.rtp_stats.mean_jitter = 0;
238                         tmp_strinfo.rtp_stats.delta = 0;
239                         tmp_strinfo.rtp_stats.diff = 0;
240                         tmp_strinfo.rtp_stats.jitter = 0;
241                         tmp_strinfo.rtp_stats.bandwidth = 0;
242                         tmp_strinfo.rtp_stats.total_bytes = 0;
243                         tmp_strinfo.rtp_stats.bw_start_index = 0;
244                         tmp_strinfo.rtp_stats.bw_index = 0;
245                         tmp_strinfo.rtp_stats.timestamp = 0;
246                         tmp_strinfo.rtp_stats.max_nr = 0;
247                         tmp_strinfo.rtp_stats.total_nr = 0;
248                         tmp_strinfo.rtp_stats.sequence = 0;
249                         tmp_strinfo.rtp_stats.start_seq_nr = 0;
250                         tmp_strinfo.rtp_stats.stop_seq_nr = 0;
251                         tmp_strinfo.rtp_stats.cycles = 0;
252                         tmp_strinfo.rtp_stats.under = FALSE;
253                         tmp_strinfo.rtp_stats.start_time = 0;
254                         tmp_strinfo.rtp_stats.time = 0;
255                         tmp_strinfo.rtp_stats.reg_pt = PT_UNDEFINED;
256
257             /* Get the Setup frame number who set this RTP stream */
258             p_conv_data = p_get_proto_data(pinfo->fd, proto_get_id_by_filter_name("rtp"));
259             if (p_conv_data)
260                                 tmp_strinfo.setup_frame_number = p_conv_data->frame_number;
261             else
262                 tmp_strinfo.setup_frame_number = 0xFFFFFFFF;
263
264                         strinfo = g_malloc(sizeof(rtp_stream_info_t));
265                         *strinfo = tmp_strinfo;  /* memberwise copy of struct */
266                         tapinfo->strinfo_list = g_list_append(tapinfo->strinfo_list, strinfo);
267                 }
268
269                 /* get RTP stats for the packet */
270                 rtp_packet_analyse(&(strinfo->rtp_stats), pinfo, rtpinfo);
271                 if (strinfo->rtp_stats.flags & STAT_FLAG_WRONG_TIMESTAMP
272                         || strinfo->rtp_stats.flags & STAT_FLAG_WRONG_SEQ)
273                         strinfo->problem = TRUE;
274
275
276                 /* increment the packets counter for this stream */
277                 ++(strinfo->npackets);
278                 strinfo->stop_rel_sec = (guint32) pinfo->fd->rel_ts.secs;
279                 strinfo->stop_rel_usec = pinfo->fd->rel_ts.nsecs/1000;
280
281                 /* increment the packets counter of all streams */
282                 ++(tapinfo->npackets);
283
284                 return 1;  /* refresh output */
285         }
286         else if (tapinfo->mode == TAP_SAVE) {
287                 if (rtp_stream_info_cmp(&tmp_strinfo, tapinfo->filter_stream_fwd)==0) {
288                         /* XXX - what if rtpinfo->info_all_data_present is
289                            FALSE, so that we don't *have* all the data? */
290                         sample.header.rec_time =
291                                 (pinfo->fd->abs_ts.nsecs/1000 + 1000000 - tapinfo->filter_stream_fwd->start_usec)/1000
292                                 + (guint32) (pinfo->fd->abs_ts.secs - tapinfo->filter_stream_fwd->start_sec - 1)*1000;
293                         sample.header.frame_length = rtpinfo->info_data_len;
294                         sample.frame = rtpinfo->info_data;
295                         rtp_write_sample(&sample, tapinfo->save_file);
296                 }
297         }
298         /* TODO: This doesn't belong here. We really shouldn't refer to cf_mark_frame()
299          * which only make sense if we're using the GTK UI backend. This effectively forces
300          * tshark/rawshark to implement a cf_mark_frame() stub */
301         else if (tapinfo->mode == TAP_MARK) {
302                 if (rtp_stream_info_cmp(&tmp_strinfo, tapinfo->filter_stream_fwd)==0
303                         || rtp_stream_info_cmp(&tmp_strinfo, tapinfo->filter_stream_rev)==0)
304                 {
305                         cf_mark_frame(&cfile, pinfo->fd);
306                 }
307         }
308
309         return 0;
310 }
311
312
313 typedef struct _key_value {
314   guint32  key;
315   guint32  value;
316 } key_value;
317
318
319 /* RTP sampling clock rates for fixed payload types as defined in
320  http://www.iana.org/assignments/rtp-parameters */
321 static const key_value clock_map[] = {
322         {PT_PCMU,       8000},
323         {PT_1016,       8000},
324         {PT_G721,       8000},
325         {PT_GSM,        8000},
326         {PT_G723,       8000},
327         {PT_DVI4_8000,  8000},
328         {PT_DVI4_16000, 16000},
329         {PT_LPC,        8000},
330         {PT_PCMA,       8000},
331         {PT_G722,       8000},
332         {PT_L16_STEREO, 44100},
333         {PT_L16_MONO,   44100},
334         {PT_QCELP,      8000},
335         {PT_CN,         8000},
336         {PT_MPA,        90000},
337         {PT_G728,       8000},
338         {PT_G728,       8000},
339         {PT_DVI4_11025, 11025},
340         {PT_DVI4_22050, 22050},
341         {PT_G729,       8000},
342         {PT_CN_OLD,     8000},
343         {PT_CELB,       90000},
344         {PT_JPEG,       90000},
345         {PT_NV,         90000},
346         {PT_H261,       90000},
347         {PT_MPV,        90000},
348         {PT_MP2T,       90000},
349         {PT_H263,       90000},
350 };
351
352 #define NUM_CLOCK_VALUES        (sizeof clock_map / sizeof clock_map[0])
353
354 static guint32
355 get_clock_rate(guint32 key)
356 {
357         size_t i;
358
359         for (i = 0; i < NUM_CLOCK_VALUES; i++) {
360                 if (clock_map[i].key == key)
361                         return clock_map[i].value;
362         }
363         return 0;
364 }
365
366 typedef struct _mimetype_and_clock {
367         const gchar   *pt_mime_name_str;
368         guint32 value;
369 } mimetype_and_clock;
370 /*      RTP sampling clock rates for
371         "In addition to the RTP payload formats (encodings) listed in the RTP
372         Payload Types table, there are additional payload formats that do not
373         have static RTP payload types assigned but instead use dynamic payload
374         type number assignment.  Each payload format is named by a registered
375         MIME subtype"
376         http://www.iana.org/assignments/rtp-parameters.
377
378         NOTE: Please keep the mimetypes in case insensitive alphabetical order.
379 */
380 static const mimetype_and_clock mimetype_and_clock_map[] = {
381         {"AMR",         8000},                  /* [RFC4867][RFC3267] */
382         {"AMR-WB",      16000},                 /* [RFC4867][RFC3267] */
383         {"BMPEG",       90000},                 /* [RFC2343],[RFC3555] */
384         {"BT656",       90000},                 /* [RFC2431],[RFC3555] */
385         {"DV",          90000},                 /* [RFC3189] */
386         {"EVRC",        8000},                  /* [RFC3558] */
387         {"EVRC0",       8000},                  /* [RFC4788] */
388         {"EVRC1",       8000},                  /* [RFC4788] */
389         {"EVRCB",       8000},                  /* [RFC4788] */
390         {"EVRCB0",      8000},                  /* [RFC4788] */
391         {"EVRCB1",      8000},                  /* [RFC4788] */
392         {"EVRCWB",      16000},                 /* [RFC5188] */
393         {"EVRCWB0",     16000},                 /* [RFC5188] */
394         {"EVRCWB1",     16000},                 /* [RFC5188] */
395         {"G7221",       16000},                 /* [RFC3047] */
396         {"G726-16",     8000},                  /* [RFC3551][RFC4856] */
397         {"G726-24",     8000},                  /* [RFC3551][RFC4856] */
398         {"G726-32",     8000},                  /* [RFC3551][RFC4856] */
399         {"G726-40",     8000},                  /* [RFC3551][RFC4856] */
400         {"G729D",       8000},                  /* [RFC3551][RFC4856] */
401         {"G729E",       8000},                  /* [RFC3551][RFC4856] */
402         {"GSM-EFR",     8000},                  /* [RFC3551] */
403         {"H263-1998",   90000},         /* [RFC2429],[RFC3555] */
404         {"H263-2000",   90000},         /* [RFC2429],[RFC3555] */
405         {"H264",        90000},         /* [RFC3984] */
406         {"MP1S",        90000},                 /* [RFC2250],[RFC3555] */
407         {"MP2P",        90000},                 /* [RFC2250],[RFC3555] */
408         {"MP4V-ES",     90000},                 /* [RFC3016] */
409         {"mpa-robust",  90000},         /* [RFC3119] */
410         {"pointer",     90000},                 /* [RFC2862] */
411         {"raw",         90000},                 /* [RFC4175] */
412         {"red",         1000},                  /* [RFC4102] */
413         {"SMV",         8000},                  /* [RFC3558] */
414         {"SMV0",        8000},                  /* [RFC3558] */
415         {"t140",        1000},                  /* [RFC4103] */
416         {"telephone-event", 8000},  /* [RFC4733] */
417 };
418
419 #define NUM_DYN_CLOCK_VALUES    (sizeof mimetype_and_clock_map / sizeof mimetype_and_clock_map[0])
420
421 static guint32
422 get_dyn_pt_clock_rate(gchar *payload_type_str)
423 {
424         int i;
425
426         /* Search for matching mimetype in reverse order to avoid false matches
427          * when pt_mime_name_str is the prefix of payload_type_str */
428         for (i = NUM_DYN_CLOCK_VALUES - 1; i > -1 ; i--) {
429                 if (g_ascii_strncasecmp(mimetype_and_clock_map[i].pt_mime_name_str,payload_type_str,(strlen(mimetype_and_clock_map[i].pt_mime_name_str))) == 0)
430                         return mimetype_and_clock_map[i].value;
431         }
432
433         return 0;
434 }
435
436 /****************************************************************************/
437 int rtp_packet_analyse(tap_rtp_stat_t *statinfo,
438                               packet_info *pinfo,
439                               const struct _rtp_info *rtpinfo)
440 {
441         double current_time;
442         double current_jitter;
443         double current_diff = 0;
444         double nominaltime;
445         double arrivaltime;             /* Time relative to start_time */
446         double expected_time;
447         double absskew;
448         guint32 clock_rate;
449
450         /* Store the current time */
451         current_time = nstime_to_msec(&pinfo->fd->rel_ts);
452
453         /*  Is this the first packet we got in this direction? */
454         if (statinfo->first_packet) {
455                 statinfo->start_seq_nr = rtpinfo->info_seq_num;
456                 statinfo->stop_seq_nr = rtpinfo->info_seq_num;
457                 statinfo->seq_num = rtpinfo->info_seq_num;
458                 statinfo->start_time = current_time;
459                 statinfo->timestamp = rtpinfo->info_timestamp;
460                 statinfo->first_timestamp = rtpinfo->info_timestamp;
461                 statinfo->time = current_time;
462                 statinfo->pt = rtpinfo->info_payload_type;
463                 statinfo->reg_pt = rtpinfo->info_payload_type;
464                 statinfo->bw_history[statinfo->bw_index].bytes = rtpinfo->info_data_len + 28;
465                 statinfo->bw_history[statinfo->bw_index].time = current_time;
466                 statinfo->bw_index++;
467                 statinfo->total_bytes += rtpinfo->info_data_len + 28;
468                 statinfo->bandwidth = (double)(statinfo->total_bytes*8)/1000;
469                 /* Not needed ? initialised to zero? */
470                 statinfo->delta = 0;
471                 statinfo->jitter = 0;
472                 statinfo->diff = 0;
473
474                 statinfo->total_nr++;
475                 statinfo->flags |= STAT_FLAG_FIRST;
476                 if (rtpinfo->info_marker_set) {
477                         statinfo->flags |= STAT_FLAG_MARKER;
478                 }
479                 statinfo->first_packet = FALSE;
480                 return 0;
481         }
482
483         /* Reset flags */
484         statinfo->flags = 0;
485
486         /* When calculating expected rtp packets the seq number can wrap around
487          * so we have to count the number of cycles
488          * Variable cycles counts the wraps around in forwarding connection and
489          * under is flag that indicates where we are
490          *
491          * XXX How to determine number of cycles with all possible lost, late
492          * and duplicated packets without any doubt? It seems to me, that
493          * because of all possible combination of late, duplicated or lost
494          * packets, this can only be more or less good approximation
495          *
496          * There are some combinations (rare but theoretically possible),
497          * where below code won't work correctly - statistic may be wrong then.
498          */
499
500         /* So if the current sequence number is less than the start one
501          * we assume, that there is another cycle running
502          */
503         if ((rtpinfo->info_seq_num < statinfo->start_seq_nr) && (statinfo->under == FALSE)){
504                 statinfo->cycles++;
505                 statinfo->under = TRUE;
506         }
507         /* what if the start seq nr was 0? Then the above condition will never
508          * be true, so we add another condition. XXX The problem would arise
509          * if one of the packets with seq nr 0 or 65535 would be lost or late
510          */
511         else if ((rtpinfo->info_seq_num == 0) && (statinfo->stop_seq_nr == 65535) &&
512                 (statinfo->under == FALSE)){
513                 statinfo->cycles++;
514                 statinfo->under = TRUE;
515         }
516         /* the whole round is over, so reset the flag */
517         else if ((rtpinfo->info_seq_num > statinfo->start_seq_nr) && (statinfo->under != FALSE)) {
518                 statinfo->under = FALSE;
519         }
520
521         /* Since it is difficult to count lost, duplicate or late packets separately,
522          * we would like to know at least how many times the sequence number was not ok
523          */
524
525         /* If the current seq number equals the last one or if we are here for
526          * the first time, then it is ok, we just store the current one as the last one
527          */
528         if ( (statinfo->seq_num+1 == rtpinfo->info_seq_num) || (statinfo->flags & STAT_FLAG_FIRST) )
529                 statinfo->seq_num = rtpinfo->info_seq_num;
530         /* If the first one is 65535. XXX same problem as above: if seq 65535 or 0 is lost... */
531         else if ( (statinfo->seq_num == 65535) && (rtpinfo->info_seq_num == 0) )
532                 statinfo->seq_num = rtpinfo->info_seq_num;
533         /* Lost packets */
534         else if (statinfo->seq_num+1 < rtpinfo->info_seq_num) {
535                 statinfo->seq_num = rtpinfo->info_seq_num;
536                 statinfo->sequence++;
537                 statinfo->flags |= STAT_FLAG_WRONG_SEQ;
538         }
539         /* Late or duplicated */
540         else if (statinfo->seq_num+1 > rtpinfo->info_seq_num) {
541                 statinfo->sequence++;
542                 statinfo->flags |= STAT_FLAG_WRONG_SEQ;
543         }
544
545         /* Check payload type */
546         if (rtpinfo->info_payload_type == PT_CN
547                 || rtpinfo->info_payload_type == PT_CN_OLD)
548                 statinfo->flags |= STAT_FLAG_PT_CN;
549         if (statinfo->pt == PT_CN
550                 || statinfo->pt == PT_CN_OLD)
551                 statinfo->flags |= STAT_FLAG_FOLLOW_PT_CN;
552         if (rtpinfo->info_payload_type != statinfo->pt)
553                 statinfo->flags |= STAT_FLAG_PT_CHANGE;
554         statinfo->pt = rtpinfo->info_payload_type;
555
556         /*
557          * Return 0 for unknown payload types
558          * Ignore jitter calculation for clockrate = 0
559          */
560         if (statinfo->pt < 96 ){
561                 clock_rate = get_clock_rate(statinfo->pt);
562         }else{ /* Dynamic PT */
563                 if ( rtpinfo->info_payload_type_str != NULL ){
564                         /* Is it a "telephone-event" ?
565                          * Timestamp is not increased for telepone-event packets impacting
566                          * calculation of Jitter Skew and clock drift.
567                          * see 2.2.1 of RFC 4733
568                          */
569                         if (g_ascii_strncasecmp("telephone-event",rtpinfo->info_payload_type_str,(strlen("telephone-event")))==0){
570                                 clock_rate = 0;
571                                 statinfo->flags |= STAT_FLAG_PT_T_EVENT;
572                         }else{
573                                 clock_rate = get_dyn_pt_clock_rate(rtpinfo-> info_payload_type_str);
574                         }
575                 }else{
576                         clock_rate = 0;
577                 }
578         }
579
580                 /* Handle wraparound ? */
581         arrivaltime = current_time - statinfo->start_time;
582
583         if (statinfo->first_timestamp > rtpinfo->info_timestamp){
584                 /* Handle wraparound */
585                 nominaltime = (double)(rtpinfo->info_timestamp + 0xffffffff - statinfo->first_timestamp + 1);
586         }else{
587                 nominaltime = (double)(rtpinfo->info_timestamp - statinfo->first_timestamp);
588         }
589
590         /* Can only analyze defined sampling rates */
591     if (clock_rate != 0) {
592                 statinfo->clock_rate = clock_rate;
593                 /* Convert from sampling clock to ms */
594                 nominaltime = nominaltime /(clock_rate/1000);
595
596                 /* Calculate the current jitter(in ms) */
597                 if (!statinfo->first_packet) {
598                         expected_time = statinfo->time + (nominaltime - statinfo->lastnominaltime);
599                         current_diff = fabs(current_time - expected_time);
600                         current_jitter = (15 * statinfo->jitter + current_diff) / 16;
601
602                         statinfo->delta = current_time-(statinfo->time);
603                         statinfo->jitter = current_jitter;
604                         statinfo->diff = current_diff;
605                 }
606                 statinfo->lastnominaltime = nominaltime;
607                 /* Calculate skew, i.e. absolute jitter that also catches clock drift
608                  * Skew is positive if TS (nominal) is too fast
609                  */
610                 statinfo->skew    = nominaltime - arrivaltime;
611                 absskew = fabs(statinfo->skew);
612                 if(absskew > fabs(statinfo->max_skew)){
613                         statinfo->max_skew = statinfo->skew;
614                 }
615                 /* Gather data for calculation of average, minimum and maximum framerate based on timestamp */
616 #if 0
617                 if (numPackets > 0 && (!hardPayloadType || !alternatePayloadType)) {
618                         /* Skip first packet and possibly alternate payload type packets */
619                         double dt;
620                         dt     = nominaltime - statinfo->lastnominaltime;
621                         sumdt += 1.0 * dt;
622                         numdt += (dt != 0 ? 1 : 0);
623                         mindt  = (dt < mindt ? dt : mindt);
624                         maxdt  = (dt > maxdt ? dt : maxdt);
625                 }
626 #endif
627                 /* Gather data for calculation of skew least square */
628                 statinfo->sumt   += 1.0 * current_time;
629                 statinfo->sumTS  += 1.0 * nominaltime;
630                 statinfo->sumt2  += 1.0 * current_time * current_time;
631                 statinfo->sumtTS += 1.0 * current_time * nominaltime;
632         }
633
634         /* Calculate the BW in Kbps adding the IP+UDP header to the RTP -> 20bytes(IP)+8bytes(UDP) = 28bytes */
635         statinfo->bw_history[statinfo->bw_index].bytes = rtpinfo->info_data_len + 28;
636         statinfo->bw_history[statinfo->bw_index].time = current_time;
637
638         /* Check if there are more than 1sec in the history buffer to calculate BW in bps. If so, remove those for the calculation */
639         while ((statinfo->bw_history[statinfo->bw_start_index].time+1000/* ms */)<current_time){
640                 statinfo->total_bytes -= statinfo->bw_history[statinfo->bw_start_index].bytes;
641                 statinfo->bw_start_index++;
642                 if (statinfo->bw_start_index == BUFF_BW) statinfo->bw_start_index=0;
643         };
644         statinfo->total_bytes += rtpinfo->info_data_len + 28;
645         statinfo->bandwidth = (double)(statinfo->total_bytes*8)/1000;
646         statinfo->bw_index++;
647         if (statinfo->bw_index == BUFF_BW) statinfo->bw_index = 0;
648
649
650         /* Is it a packet with the mark bit set? */
651         if (rtpinfo->info_marker_set) {
652                 statinfo->delta_timestamp = rtpinfo->info_timestamp - statinfo->timestamp;
653                 if (rtpinfo->info_timestamp > statinfo->timestamp){
654                         statinfo->flags |= STAT_FLAG_MARKER;
655                 }
656                 else{
657                         statinfo->flags |= STAT_FLAG_WRONG_TIMESTAMP;
658                 }
659         }
660         /* Is it a regular packet? */
661         if (!(statinfo->flags & STAT_FLAG_FIRST)
662                 && !(statinfo->flags & STAT_FLAG_MARKER)
663                 && !(statinfo->flags & STAT_FLAG_PT_CN)
664                 && !(statinfo->flags & STAT_FLAG_WRONG_TIMESTAMP)
665                 && !(statinfo->flags & STAT_FLAG_FOLLOW_PT_CN)) {
666                 /* Include it in maximum delta calculation */
667                 if (statinfo->delta > statinfo->max_delta) {
668                         statinfo->max_delta = statinfo->delta;
669                         statinfo->max_nr = pinfo->fd->num;
670                 }
671                 if (clock_rate != 0) {
672                         /* Maximum and mean jitter calculation */
673                         if (statinfo->jitter > statinfo->max_jitter) {
674                                 statinfo->max_jitter = statinfo->jitter;
675                         }
676                         statinfo->mean_jitter = (statinfo->mean_jitter*statinfo->total_nr + current_diff) / (statinfo->total_nr+1);
677                 }
678         }
679         /* Regular payload change? (CN ignored) */
680         if (!(statinfo->flags & STAT_FLAG_FIRST)
681                 && !(statinfo->flags & STAT_FLAG_PT_CN)) {
682                 if ((statinfo->pt != statinfo->reg_pt)
683                         && (statinfo->reg_pt != PT_UNDEFINED)) {
684                         statinfo->flags |= STAT_FLAG_REG_PT_CHANGE;
685                 }
686         }
687
688         /* Set regular payload*/
689         if (!(statinfo->flags & STAT_FLAG_PT_CN)) {
690                 statinfo->reg_pt = statinfo->pt;
691         }
692
693         statinfo->time = current_time;
694         statinfo->timestamp = rtpinfo->info_timestamp;
695         statinfo->stop_seq_nr = rtpinfo->info_seq_num;
696         statinfo->total_nr++;
697
698         return 0;
699 }
700
701