1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
/*
The oRTP library is an RTP (Realtime Transport Protocol - rfc1889) stack.
Copyright (C) 2001 Simon MORLAT simon.morlat@linphone.org
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/***************************************************************************
* jitterctl.c
*
* Mon Nov 8 11:53:21 2004
* Copyright 2004 Simon MORLAT
* Email simon.morlat@linphone.org
****************************************************************************/
#include <rtpsession.h>
#include <payloadtype.h>
#include <math.h>
#include <stdlib.h>
#define JC_BETA 0.03 /*allows a clock slide around 3% */
#define JC_GAMMA (JC_BETA)
#include "jitterctl.h"
void jitter_control_init(JitterControl *ctl, int base_jiitt_time, PayloadType *payload){
ctl->count=0;
ctl->slide=0;
ctl->jitter=0;
ctl->inter_jitter=0;
ctl->slide=0;
if (base_jiitt_time!=-1) ctl->jitt_comp = base_jiitt_time;
/* convert in timestamp unit: */
if (payload!=NULL){
jitter_control_set_payload(ctl,payload);
}
ctl->adapt_jitt_comp_ts=ctl->jitt_comp_ts;
ctl->corrective_slide=0;
}
void jitter_control_enable_adaptive(JitterControl *ctl, gboolean val){
ctl->adaptive=val;
}
void jitter_control_set_payload(JitterControl *ctl, PayloadType *pt){
ctl->jitt_comp_ts =
(gint) (((double) ctl->jitt_comp / 1000.0) * (pt->clock_rate));
ctl->corrective_step=(160 * 8000 )/pt->clock_rate; /* This formula got to me after some beers */
ctl->adapt_jitt_comp_ts=ctl->jitt_comp_ts;
}
void jitter_control_dump_stats(JitterControl *ctl){
g_log("oRTP-stats",G_LOG_LEVEL_MESSAGE,"JitterControl:\n\tslide=%g,jitter=%g,count=%i",
ctl->slide,ctl->jitter, ctl->count);
}
/*
The algorithm computes two values:
slide: an average of difference between the expected and the socket-received timestamp
jitter: an average of the absolute value of the difference between socket-received timestamp and slide.
slide is used to make clock-slide detection and correction.
jitter is added to the initial jitt_comp_time value. It compensates bursty packets arrival (packets
not arriving at regular interval ).
*/
void jitter_control_new_packet(JitterControl *ctl, guint32 packet_ts, guint32 cur_str_ts, gint32 * slide, gint32 *safe_delay){
int diff=packet_ts - cur_str_ts;
float gap;
int d;
//printf("diff=%g\n",diff);
ctl->count++;
ctl->slide= (ctl->slide*(1-JC_BETA)) + ((float)diff*JC_BETA);
gap=fabs((float)diff - ctl->slide);
ctl->jitter=(ctl->jitter*(1-JC_GAMMA)) + (gap*JC_GAMMA);
d=diff-ctl->olddiff;
ctl->inter_jitter=ctl->inter_jitter+ (( (float)abs(d) - ctl->inter_jitter)*(1/16.0));
ctl->olddiff=diff;
if (ctl->adaptive){
int tmp;
if (ctl->count%50==0) {
/*jitter_control_dump_stats(ctl);*/
}
tmp=(int)(ctl->slide)-ctl->corrective_slide;
if (tmp>ctl->corrective_step) ctl->corrective_slide+=ctl->corrective_step;
else if (tmp<-ctl->corrective_step) ctl->corrective_slide-=ctl->corrective_step;
/* the following is nearly equivalent, but maybe it consumes more CPU: ?*/
/*ctl->corrective_slide=(((gint)ctl->slide)/ctl->corrective_step)*ctl->corrective_step;*/
ctl->adapt_jitt_comp_ts=MAX(ctl->jitt_comp_ts,ctl->jitter);
*slide=(gint32)ctl->slide;
*safe_delay=(gint32)ctl->adapt_jitt_comp_ts;
}else {
*slide=0;
*safe_delay=(gint32)ctl->jitt_comp_ts;
}
return ;
}
/**
*rtp_session_set_jitter_compensation:
*@session: a RtpSession
*@milisec: the time interval in milisec to be jitter compensed.
*
* Sets the time interval for which packet are buffered instead of being delivered to the
* application.
**/
void
rtp_session_set_jitter_compensation (RtpSession * session, gint milisec)
{
PayloadType *payload = rtp_profile_get_payload (session->profile,
session->
payload_type);
if (payload==NULL){
g_warning("rtp_session_set_jitter_compensation: cannot set because the payload type is unknown");
return;
}
jitter_control_init(&session->rtp.jittctl,milisec,payload);
}
void rtp_session_enable_adaptive_jitter_compensation(RtpSession *session, gboolean val){
jitter_control_enable_adaptive(&session->rtp.jittctl,val);
}
gboolean rtp_session_adaptive_jitter_compensation_enabled(RtpSession *session){
return session->rtp.jittctl.adaptive;
}
|
