1 /*
2 * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 /*
12 * bandwidth_estimator.c
13 *
14 * This file contains the code for the Bandwidth Estimator designed
15 * for iSAC.
16 *
17 * NOTE! Castings needed for C55, do not remove!
18 *
19 */
20
21 #include "bandwidth_estimator.h"
22 #include "settings.h"
23
24
25 /* array of quantization levels for bottle neck info; Matlab code: */
26 /* sprintf('%4.1ff, ', logspace(log10(5000), log10(40000), 12)) */
27 static const int16_t kQRateTable[12] = {
28 10000, 11115, 12355, 13733, 15265, 16967,
29 18860, 20963, 23301, 25900, 28789, 32000
30 };
31
32 /* 0.1 times the values in the table kQRateTable */
33 /* values are in Q16 */
34 static const int32_t KQRate01[12] = {
35 65536000, 72843264, 80969728, 90000589, 100040704, 111194931,
36 123600896, 137383117, 152705434, 169738240, 188671590, 209715200
37 };
38
39 /* Bits per Bytes Seconds
40 * 8 bits/byte * 1000 msec/sec * 1/framelength (in msec)->bits/byte*sec
41 * frame length will either be 30 or 60 msec. 8738 is 1/60 in Q19 and 1/30 in Q18
42 * The following number is either in Q15 or Q14 depending on the current frame length */
43 static const int32_t kBitsByteSec = 4369000;
44
45 /* Received header rate. First value is for 30 ms packets and second for 60 ms */
46 static const int16_t kRecHeaderRate[2] = {
47 9333, 4666
48 };
49
50 /* Inverted minimum and maximum bandwidth in Q30.
51 minBwInv 30 ms, maxBwInv 30 ms,
52 minBwInv 60 ms, maxBwInv 69 ms
53 */
54 static const int32_t kInvBandwidth[4] = {
55 55539, 25978,
56 73213, 29284
57 };
58
59 /* Number of samples in 25 msec */
60 static const int32_t kSamplesIn25msec = 400;
61
62
63 /****************************************************************************
64 * WebRtcIsacfix_InitBandwidthEstimator(...)
65 *
66 * This function initializes the struct for the bandwidth estimator
67 *
68 * Input/Output:
69 * - bweStr : Struct containing bandwidth information.
70 *
71 * Return value : 0
72 */
WebRtcIsacfix_InitBandwidthEstimator(BwEstimatorstr * bweStr)73 int32_t WebRtcIsacfix_InitBandwidthEstimator(BwEstimatorstr *bweStr)
74 {
75 bweStr->prevFrameSizeMs = INIT_FRAME_LEN;
76 bweStr->prevRtpNumber = 0;
77 bweStr->prevSendTime = 0;
78 bweStr->prevArrivalTime = 0;
79 bweStr->prevRtpRate = 1;
80 bweStr->lastUpdate = 0;
81 bweStr->lastReduction = 0;
82 bweStr->countUpdates = -9;
83
84 /* INIT_BN_EST = 20000
85 * INIT_BN_EST_Q7 = 2560000
86 * INIT_HDR_RATE = 4666
87 * INIT_REC_BN_EST_Q5 = 789312
88 *
89 * recBwInv = 1/(INIT_BN_EST + INIT_HDR_RATE) in Q30
90 * recBwAvg = INIT_BN_EST + INIT_HDR_RATE in Q5
91 */
92 bweStr->recBwInv = 43531;
93 bweStr->recBw = INIT_BN_EST;
94 bweStr->recBwAvgQ = INIT_BN_EST_Q7;
95 bweStr->recBwAvg = INIT_REC_BN_EST_Q5;
96 bweStr->recJitter = (int32_t) 327680; /* 10 in Q15 */
97 bweStr->recJitterShortTerm = 0;
98 bweStr->recJitterShortTermAbs = (int32_t) 40960; /* 5 in Q13 */
99 bweStr->recMaxDelay = (int32_t) 10;
100 bweStr->recMaxDelayAvgQ = (int32_t) 5120; /* 10 in Q9 */
101 bweStr->recHeaderRate = INIT_HDR_RATE;
102 bweStr->countRecPkts = 0;
103 bweStr->sendBwAvg = INIT_BN_EST_Q7;
104 bweStr->sendMaxDelayAvg = (int32_t) 5120; /* 10 in Q9 */
105
106 bweStr->countHighSpeedRec = 0;
107 bweStr->highSpeedRec = 0;
108 bweStr->countHighSpeedSent = 0;
109 bweStr->highSpeedSend = 0;
110 bweStr->inWaitPeriod = 0;
111
112 /* Find the inverse of the max bw and min bw in Q30
113 * (1 / (MAX_ISAC_BW + INIT_HDR_RATE) in Q30
114 * (1 / (MIN_ISAC_BW + INIT_HDR_RATE) in Q30
115 */
116 bweStr->maxBwInv = kInvBandwidth[3];
117 bweStr->minBwInv = kInvBandwidth[2];
118
119 return 0;
120 }
121
122 /****************************************************************************
123 * WebRtcIsacfix_UpdateUplinkBwImpl(...)
124 *
125 * This function updates bottle neck rate received from other side in payload
126 * and calculates a new bottle neck to send to the other side.
127 *
128 * Input/Output:
129 * - bweStr : struct containing bandwidth information.
130 * - rtpNumber : value from RTP packet, from NetEq
131 * - frameSize : length of signal frame in ms, from iSAC decoder
132 * - sendTime : value in RTP header giving send time in samples
133 * - arrivalTime : value given by timeGetTime() time of arrival in
134 * samples of packet from NetEq
135 * - pksize : size of packet in bytes, from NetEq
136 * - Index : integer (range 0...23) indicating bottle neck &
137 * jitter as estimated by other side
138 *
139 * Return value : 0 if everything went fine,
140 * -1 otherwise
141 */
WebRtcIsacfix_UpdateUplinkBwImpl(BwEstimatorstr * bweStr,const uint16_t rtpNumber,const int16_t frameSize,const uint32_t sendTime,const uint32_t arrivalTime,const int16_t pksize,const uint16_t Index)142 int32_t WebRtcIsacfix_UpdateUplinkBwImpl(BwEstimatorstr *bweStr,
143 const uint16_t rtpNumber,
144 const int16_t frameSize,
145 const uint32_t sendTime,
146 const uint32_t arrivalTime,
147 const int16_t pksize,
148 const uint16_t Index)
149 {
150 uint16_t weight = 0;
151 uint32_t currBwInv = 0;
152 uint16_t recRtpRate;
153 uint32_t arrTimeProj;
154 int32_t arrTimeDiff;
155 int32_t arrTimeNoise;
156 int32_t arrTimeNoiseAbs;
157 int32_t sendTimeDiff;
158
159 int32_t delayCorrFactor = DELAY_CORRECTION_MED;
160 int32_t lateDiff = 0;
161 int16_t immediateSet = 0;
162 int32_t frameSizeSampl;
163
164 int32_t temp;
165 int32_t msec;
166 uint32_t exponent;
167 uint32_t reductionFactor;
168 uint32_t numBytesInv;
169 int32_t sign;
170
171 uint32_t byteSecondsPerBit;
172 uint32_t tempLower;
173 uint32_t tempUpper;
174 int32_t recBwAvgInv;
175 int32_t numPktsExpected;
176
177 int16_t errCode;
178
179 /* UPDATE ESTIMATES FROM OTHER SIDE */
180
181 /* The function also checks if Index has a valid value */
182 errCode = WebRtcIsacfix_UpdateUplinkBwRec(bweStr, Index);
183 if (errCode <0) {
184 return(errCode);
185 }
186
187
188 /* UPDATE ESTIMATES ON THIS SIDE */
189
190 /* Bits per second per byte * 1/30 or 1/60 */
191 if (frameSize == 60) {
192 /* If frameSize changed since last call, from 30 to 60, recalculate some values */
193 if ( (frameSize != bweStr->prevFrameSizeMs) && (bweStr->countUpdates > 0)) {
194 bweStr->countUpdates = 10;
195 bweStr->recHeaderRate = kRecHeaderRate[1];
196
197 bweStr->maxBwInv = kInvBandwidth[3];
198 bweStr->minBwInv = kInvBandwidth[2];
199 bweStr->recBwInv = 1073741824 / (bweStr->recBw + bweStr->recHeaderRate);
200 }
201
202 /* kBitsByteSec is in Q15 */
203 recRtpRate = (int16_t)WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(kBitsByteSec,
204 (int32_t)pksize), 15) + bweStr->recHeaderRate;
205
206 } else {
207 /* If frameSize changed since last call, from 60 to 30, recalculate some values */
208 if ( (frameSize != bweStr->prevFrameSizeMs) && (bweStr->countUpdates > 0)) {
209 bweStr->countUpdates = 10;
210 bweStr->recHeaderRate = kRecHeaderRate[0];
211
212 bweStr->maxBwInv = kInvBandwidth[1];
213 bweStr->minBwInv = kInvBandwidth[0];
214 bweStr->recBwInv = 1073741824 / (bweStr->recBw + bweStr->recHeaderRate);
215 }
216
217 /* kBitsByteSec is in Q14 */
218 recRtpRate = (uint16_t)WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(kBitsByteSec,
219 (int32_t)pksize), 14) + bweStr->recHeaderRate;
220 }
221
222
223 /* Check for timer wrap-around */
224 if (arrivalTime < bweStr->prevArrivalTime) {
225 bweStr->prevArrivalTime = arrivalTime;
226 bweStr->lastUpdate = arrivalTime;
227 bweStr->lastReduction = arrivalTime + FS3;
228
229 bweStr->countRecPkts = 0;
230
231 /* store frame size */
232 bweStr->prevFrameSizeMs = frameSize;
233
234 /* store far-side transmission rate */
235 bweStr->prevRtpRate = recRtpRate;
236
237 /* store far-side RTP time stamp */
238 bweStr->prevRtpNumber = rtpNumber;
239
240 return 0;
241 }
242
243 bweStr->countRecPkts++;
244
245 /* Calculate framesize in msec */
246 frameSizeSampl = WEBRTC_SPL_MUL_16_16((int16_t)SAMPLES_PER_MSEC, frameSize);
247
248 /* Check that it's not one of the first 9 packets */
249 if ( bweStr->countUpdates > 0 ) {
250
251 /* Stay in Wait Period for 1.5 seconds (no updates in wait period) */
252 if(bweStr->inWaitPeriod) {
253 if ((arrivalTime - bweStr->startWaitPeriod)> FS_1_HALF) {
254 bweStr->inWaitPeriod = 0;
255 }
256 }
257
258 /* If not been updated for a long time, reduce the BN estimate */
259
260 /* Check send time difference between this packet and previous received */
261 sendTimeDiff = sendTime - bweStr->prevSendTime;
262 if (sendTimeDiff <= WEBRTC_SPL_LSHIFT_W32(frameSizeSampl, 1)) {
263
264 /* Only update if 3 seconds has past since last update */
265 if ((arrivalTime - bweStr->lastUpdate) > FS3) {
266
267 /* Calculate expected number of received packets since last update */
268 numPktsExpected = (arrivalTime - bweStr->lastUpdate) / frameSizeSampl;
269
270 /* If received number of packets is more than 90% of expected (922 = 0.9 in Q10): */
271 /* do the update, else not */
272 if(WEBRTC_SPL_LSHIFT_W32(bweStr->countRecPkts, 10) > WEBRTC_SPL_MUL_16_16(922, numPktsExpected)) {
273 /* Q4 chosen to approx dividing by 16 */
274 msec = (arrivalTime - bweStr->lastReduction);
275
276 /* the number below represents 13 seconds, highly unlikely
277 but to insure no overflow when reduction factor is multiplied by recBw inverse */
278 if (msec > 208000) {
279 msec = 208000;
280 }
281
282 /* Q20 2^(negative number: - 76/1048576) = .99995
283 product is Q24 */
284 exponent = WEBRTC_SPL_UMUL(0x0000004C, msec);
285
286 /* do the approx with positive exponent so that value is actually rf^-1
287 and multiply by bw inverse */
288 reductionFactor = WEBRTC_SPL_RSHIFT_U32(0x01000000 | (exponent & 0x00FFFFFF),
289 WEBRTC_SPL_RSHIFT_U32(exponent, 24));
290
291 /* reductionFactor in Q13 */
292 reductionFactor = WEBRTC_SPL_RSHIFT_U32(reductionFactor, 11);
293
294 if ( reductionFactor != 0 ) {
295 bweStr->recBwInv = WEBRTC_SPL_MUL((int32_t)bweStr->recBwInv, (int32_t)reductionFactor);
296 bweStr->recBwInv = WEBRTC_SPL_RSHIFT_W32((int32_t)bweStr->recBwInv, 13);
297
298 } else {
299 static const uint32_t kInitRate = INIT_BN_EST + INIT_HDR_RATE;
300 /* recBwInv = 1 / kInitRate in Q26 (Q30??)*/
301 bweStr->recBwInv = (1073741824 + kInitRate / 2) / kInitRate;
302 }
303
304 /* reset time-since-update counter */
305 bweStr->lastReduction = arrivalTime;
306 } else {
307 /* Delay last reduction with 3 seconds */
308 bweStr->lastReduction = arrivalTime + FS3;
309 bweStr->lastUpdate = arrivalTime;
310 bweStr->countRecPkts = 0;
311 }
312 }
313 } else {
314 bweStr->lastReduction = arrivalTime + FS3;
315 bweStr->lastUpdate = arrivalTime;
316 bweStr->countRecPkts = 0;
317 }
318
319
320 /* update only if previous packet was not lost */
321 if ( rtpNumber == bweStr->prevRtpNumber + 1 ) {
322 arrTimeDiff = arrivalTime - bweStr->prevArrivalTime;
323
324 if (!(bweStr->highSpeedSend && bweStr->highSpeedRec)) {
325 if (arrTimeDiff > frameSizeSampl) {
326 if (sendTimeDiff > 0) {
327 lateDiff = arrTimeDiff - sendTimeDiff -
328 WEBRTC_SPL_LSHIFT_W32(frameSizeSampl, 1);
329 } else {
330 lateDiff = arrTimeDiff - frameSizeSampl;
331 }
332
333 /* 8000 is 1/2 second (in samples at FS) */
334 if (lateDiff > 8000) {
335 delayCorrFactor = (int32_t) DELAY_CORRECTION_MAX;
336 bweStr->inWaitPeriod = 1;
337 bweStr->startWaitPeriod = arrivalTime;
338 immediateSet = 1;
339 } else if (lateDiff > 5120) {
340 delayCorrFactor = (int32_t) DELAY_CORRECTION_MED;
341 immediateSet = 1;
342 bweStr->inWaitPeriod = 1;
343 bweStr->startWaitPeriod = arrivalTime;
344 }
345 }
346 }
347
348 if ((bweStr->prevRtpRate > WEBRTC_SPL_RSHIFT_W32((int32_t) bweStr->recBwAvg, 5)) &&
349 (recRtpRate > WEBRTC_SPL_RSHIFT_W32((int32_t)bweStr->recBwAvg, 5)) &&
350 !bweStr->inWaitPeriod) {
351
352 /* test if still in initiation period and increment counter */
353 if (bweStr->countUpdates++ > 99) {
354 /* constant weight after initiation part, 0.01 in Q13 */
355 weight = (uint16_t) 82;
356 } else {
357 /* weight decreases with number of updates, 1/countUpdates in Q13 */
358 weight = (uint16_t) WebRtcSpl_DivW32W16(
359 (int32_t)(8192 + WEBRTC_SPL_RSHIFT_W32((int32_t) bweStr->countUpdates, 1)),
360 (int16_t)bweStr->countUpdates);
361 }
362
363 /* Bottle Neck Estimation */
364
365 /* limit outliers, if more than 25 ms too much */
366 if (arrTimeDiff > frameSizeSampl + kSamplesIn25msec) {
367 arrTimeDiff = frameSizeSampl + kSamplesIn25msec;
368 }
369
370 /* don't allow it to be less than frame rate - 10 ms */
371 if (arrTimeDiff < frameSizeSampl - FRAMESAMPLES_10ms) {
372 arrTimeDiff = frameSizeSampl - FRAMESAMPLES_10ms;
373 }
374
375 /* compute inverse receiving rate for last packet, in Q19 */
376 numBytesInv = (uint16_t) WebRtcSpl_DivW32W16(
377 (int32_t)(524288 + WEBRTC_SPL_RSHIFT_W32(((int32_t)pksize + HEADER_SIZE), 1)),
378 (int16_t)(pksize + HEADER_SIZE));
379
380 /* 8389 is ~ 1/128000 in Q30 */
381 byteSecondsPerBit = WEBRTC_SPL_MUL_16_16(arrTimeDiff, 8389);
382
383 /* get upper N bits */
384 tempUpper = WEBRTC_SPL_RSHIFT_U32(byteSecondsPerBit, 15);
385
386 /* get lower 15 bits */
387 tempLower = byteSecondsPerBit & 0x00007FFF;
388
389 tempUpper = WEBRTC_SPL_MUL(tempUpper, numBytesInv);
390 tempLower = WEBRTC_SPL_MUL(tempLower, numBytesInv);
391 tempLower = WEBRTC_SPL_RSHIFT_U32(tempLower, 15);
392
393 currBwInv = tempUpper + tempLower;
394 currBwInv = WEBRTC_SPL_RSHIFT_U32(currBwInv, 4);
395
396 /* Limit inv rate. Note that minBwInv > maxBwInv! */
397 if(currBwInv < bweStr->maxBwInv) {
398 currBwInv = bweStr->maxBwInv;
399 } else if(currBwInv > bweStr->minBwInv) {
400 currBwInv = bweStr->minBwInv;
401 }
402
403 /* update bottle neck rate estimate */
404 bweStr->recBwInv = WEBRTC_SPL_UMUL(weight, currBwInv) +
405 WEBRTC_SPL_UMUL((uint32_t) 8192 - weight, bweStr->recBwInv);
406
407 /* Shift back to Q30 from Q40 (actual used bits shouldn't be more than 27 based on minBwInv)
408 up to 30 bits used with Q13 weight */
409 bweStr->recBwInv = WEBRTC_SPL_RSHIFT_U32(bweStr->recBwInv, 13);
410
411 /* reset time-since-update counter */
412 bweStr->lastUpdate = arrivalTime;
413 bweStr->lastReduction = arrivalTime + FS3;
414 bweStr->countRecPkts = 0;
415
416 /* to save resolution compute the inverse of recBwAvg in Q26 by left shifting numerator to 2^31
417 and NOT right shifting recBwAvg 5 bits to an integer
418 At max 13 bits are used
419 shift to Q5 */
420 recBwAvgInv = (0x80000000 + bweStr->recBwAvg / 2) / bweStr->recBwAvg;
421
422 /* Calculate Projected arrival time difference */
423
424 /* The numerator of the quotient can be 22 bits so right shift inv by 4 to avoid overflow
425 result in Q22 */
426 arrTimeProj = WEBRTC_SPL_MUL((int32_t)8000, recBwAvgInv);
427 /* shift to Q22 */
428 arrTimeProj = WEBRTC_SPL_RSHIFT_U32(arrTimeProj, 4);
429 /* complete calulation */
430 arrTimeProj = WEBRTC_SPL_MUL(((int32_t)pksize + HEADER_SIZE), arrTimeProj);
431 /* shift to Q10 */
432 arrTimeProj = WEBRTC_SPL_RSHIFT_U32(arrTimeProj, 12);
433
434 /* difference between projected and actual arrival time differences */
435 /* Q9 (only shift arrTimeDiff by 5 to simulate divide by 16 (need to revisit if change sampling rate) DH */
436 if (WEBRTC_SPL_LSHIFT_W32(arrTimeDiff, 6) > (int32_t)arrTimeProj) {
437 arrTimeNoise = WEBRTC_SPL_LSHIFT_W32(arrTimeDiff, 6) - arrTimeProj;
438 sign = 1;
439 } else {
440 arrTimeNoise = arrTimeProj - WEBRTC_SPL_LSHIFT_W32(arrTimeDiff, 6);
441 sign = -1;
442 }
443
444 /* Q9 */
445 arrTimeNoiseAbs = arrTimeNoise;
446
447 /* long term averaged absolute jitter, Q15 */
448 weight = WEBRTC_SPL_RSHIFT_W32(weight, 3);
449 bweStr->recJitter = WEBRTC_SPL_MUL(weight, WEBRTC_SPL_LSHIFT_W32(arrTimeNoiseAbs, 5))
450 + WEBRTC_SPL_MUL(1024 - weight, bweStr->recJitter);
451
452 /* remove the fractional portion */
453 bweStr->recJitter = WEBRTC_SPL_RSHIFT_W32(bweStr->recJitter, 10);
454
455 /* Maximum jitter is 10 msec in Q15 */
456 if (bweStr->recJitter > (int32_t)327680) {
457 bweStr->recJitter = (int32_t)327680;
458 }
459
460 /* short term averaged absolute jitter */
461 /* Calculation in Q13 products in Q23 */
462 bweStr->recJitterShortTermAbs = WEBRTC_SPL_MUL(51, WEBRTC_SPL_LSHIFT_W32(arrTimeNoiseAbs, 3)) +
463 WEBRTC_SPL_MUL(973, bweStr->recJitterShortTermAbs);
464 bweStr->recJitterShortTermAbs = WEBRTC_SPL_RSHIFT_W32(bweStr->recJitterShortTermAbs , 10);
465
466 /* short term averaged jitter */
467 /* Calculation in Q13 products in Q23 */
468 bweStr->recJitterShortTerm = WEBRTC_SPL_MUL(205, WEBRTC_SPL_LSHIFT_W32(arrTimeNoise, 3)) * sign +
469 WEBRTC_SPL_MUL(3891, bweStr->recJitterShortTerm);
470
471 if (bweStr->recJitterShortTerm < 0) {
472 temp = -bweStr->recJitterShortTerm;
473 temp = WEBRTC_SPL_RSHIFT_W32(temp, 12);
474 bweStr->recJitterShortTerm = -temp;
475 } else {
476 bweStr->recJitterShortTerm = WEBRTC_SPL_RSHIFT_W32(bweStr->recJitterShortTerm, 12);
477 }
478 }
479 }
480 } else {
481 /* reset time-since-update counter when receiving the first 9 packets */
482 bweStr->lastUpdate = arrivalTime;
483 bweStr->lastReduction = arrivalTime + FS3;
484 bweStr->countRecPkts = 0;
485 bweStr->countUpdates++;
486 }
487
488 /* Limit to minimum or maximum bottle neck rate (in Q30) */
489 if (bweStr->recBwInv > bweStr->minBwInv) {
490 bweStr->recBwInv = bweStr->minBwInv;
491 } else if (bweStr->recBwInv < bweStr->maxBwInv) {
492 bweStr->recBwInv = bweStr->maxBwInv;
493 }
494
495
496 /* store frame length */
497 bweStr->prevFrameSizeMs = frameSize;
498
499 /* store far-side transmission rate */
500 bweStr->prevRtpRate = recRtpRate;
501
502 /* store far-side RTP time stamp */
503 bweStr->prevRtpNumber = rtpNumber;
504
505 /* Replace bweStr->recMaxDelay by the new value (atomic operation) */
506 if (bweStr->prevArrivalTime != 0xffffffff) {
507 bweStr->recMaxDelay = WEBRTC_SPL_MUL(3, bweStr->recJitter);
508 }
509
510 /* store arrival time stamp */
511 bweStr->prevArrivalTime = arrivalTime;
512 bweStr->prevSendTime = sendTime;
513
514 /* Replace bweStr->recBw by the new value */
515 bweStr->recBw = 1073741824 / bweStr->recBwInv - bweStr->recHeaderRate;
516
517 if (immediateSet) {
518 /* delay correction factor is in Q10 */
519 bweStr->recBw = WEBRTC_SPL_UMUL(delayCorrFactor, bweStr->recBw);
520 bweStr->recBw = WEBRTC_SPL_RSHIFT_U32(bweStr->recBw, 10);
521
522 if (bweStr->recBw < (int32_t) MIN_ISAC_BW) {
523 bweStr->recBw = (int32_t) MIN_ISAC_BW;
524 }
525
526 bweStr->recBwAvg = WEBRTC_SPL_LSHIFT_U32(bweStr->recBw + bweStr->recHeaderRate, 5);
527
528 bweStr->recBwAvgQ = WEBRTC_SPL_LSHIFT_U32(bweStr->recBw, 7);
529
530 bweStr->recJitterShortTerm = 0;
531
532 bweStr->recBwInv = 1073741824 / (bweStr->recBw + bweStr->recHeaderRate);
533
534 immediateSet = 0;
535 }
536
537
538 return 0;
539 }
540
541 /* This function updates the send bottle neck rate */
542 /* Index - integer (range 0...23) indicating bottle neck & jitter as estimated by other side */
543 /* returns 0 if everything went fine, -1 otherwise */
WebRtcIsacfix_UpdateUplinkBwRec(BwEstimatorstr * bweStr,const int16_t Index)544 int16_t WebRtcIsacfix_UpdateUplinkBwRec(BwEstimatorstr *bweStr,
545 const int16_t Index)
546 {
547 uint16_t RateInd;
548
549 if ( (Index < 0) || (Index > 23) ) {
550 return -ISAC_RANGE_ERROR_BW_ESTIMATOR;
551 }
552
553 /* UPDATE ESTIMATES FROM OTHER SIDE */
554
555 if ( Index > 11 ) {
556 RateInd = Index - 12;
557 /* compute the jitter estimate as decoded on the other side in Q9 */
558 /* sendMaxDelayAvg = 0.9 * sendMaxDelayAvg + 0.1 * MAX_ISAC_MD */
559 bweStr->sendMaxDelayAvg = WEBRTC_SPL_MUL(461, bweStr->sendMaxDelayAvg) +
560 WEBRTC_SPL_MUL(51, WEBRTC_SPL_LSHIFT_W32((int32_t)MAX_ISAC_MD, 9));
561 bweStr->sendMaxDelayAvg = WEBRTC_SPL_RSHIFT_W32(bweStr->sendMaxDelayAvg, 9);
562
563 } else {
564 RateInd = Index;
565 /* compute the jitter estimate as decoded on the other side in Q9 */
566 /* sendMaxDelayAvg = 0.9 * sendMaxDelayAvg + 0.1 * MIN_ISAC_MD */
567 bweStr->sendMaxDelayAvg = WEBRTC_SPL_MUL(461, bweStr->sendMaxDelayAvg) +
568 WEBRTC_SPL_MUL(51, WEBRTC_SPL_LSHIFT_W32((int32_t)MIN_ISAC_MD,9));
569 bweStr->sendMaxDelayAvg = WEBRTC_SPL_RSHIFT_W32(bweStr->sendMaxDelayAvg, 9);
570
571 }
572
573
574 /* compute the BN estimate as decoded on the other side */
575 /* sendBwAvg = 0.9 * sendBwAvg + 0.1 * kQRateTable[RateInd]; */
576 bweStr->sendBwAvg = WEBRTC_SPL_UMUL(461, bweStr->sendBwAvg) +
577 WEBRTC_SPL_UMUL(51, WEBRTC_SPL_LSHIFT_U32(kQRateTable[RateInd], 7));
578 bweStr->sendBwAvg = WEBRTC_SPL_RSHIFT_U32(bweStr->sendBwAvg, 9);
579
580
581 if (WEBRTC_SPL_RSHIFT_U32(bweStr->sendBwAvg, 7) > 28000 && !bweStr->highSpeedSend) {
582 bweStr->countHighSpeedSent++;
583
584 /* approx 2 seconds with 30ms frames */
585 if (bweStr->countHighSpeedSent >= 66) {
586 bweStr->highSpeedSend = 1;
587 }
588 } else if (!bweStr->highSpeedSend) {
589 bweStr->countHighSpeedSent = 0;
590 }
591
592 return 0;
593 }
594
595 /****************************************************************************
596 * WebRtcIsacfix_GetDownlinkBwIndexImpl(...)
597 *
598 * This function calculates and returns the bandwidth/jitter estimation code
599 * (integer 0...23) to put in the sending iSAC payload.
600 *
601 * Input:
602 * - bweStr : BWE struct
603 *
604 * Return:
605 * bandwith and jitter index (0..23)
606 */
WebRtcIsacfix_GetDownlinkBwIndexImpl(BwEstimatorstr * bweStr)607 uint16_t WebRtcIsacfix_GetDownlinkBwIndexImpl(BwEstimatorstr *bweStr)
608 {
609 int32_t rate;
610 int32_t maxDelay;
611 uint16_t rateInd;
612 uint16_t maxDelayBit;
613 int32_t tempTerm1;
614 int32_t tempTerm2;
615 int32_t tempTermX;
616 int32_t tempTermY;
617 int32_t tempMin;
618 int32_t tempMax;
619
620 /* Get Rate Index */
621
622 /* Get unquantized rate. Always returns 10000 <= rate <= 32000 */
623 rate = WebRtcIsacfix_GetDownlinkBandwidth(bweStr);
624
625 /* Compute the averaged BN estimate on this side */
626
627 /* recBwAvg = 0.9 * recBwAvg + 0.1 * (rate + bweStr->recHeaderRate), 0.9 and 0.1 in Q9 */
628 bweStr->recBwAvg = WEBRTC_SPL_UMUL(922, bweStr->recBwAvg) +
629 WEBRTC_SPL_UMUL(102, WEBRTC_SPL_LSHIFT_U32((uint32_t)rate + bweStr->recHeaderRate, 5));
630 bweStr->recBwAvg = WEBRTC_SPL_RSHIFT_U32(bweStr->recBwAvg, 10);
631
632 /* Find quantization index that gives the closest rate after averaging.
633 * Note that we don't need to check the last value, rate <= kQRateTable[11],
634 * because we will use rateInd = 11 even if rate > kQRateTable[11]. */
635 for (rateInd = 1; rateInd < 11; rateInd++) {
636 if (rate <= kQRateTable[rateInd]){
637 break;
638 }
639 }
640
641 /* find closest quantization index, and update quantized average by taking: */
642 /* 0.9*recBwAvgQ + 0.1*kQRateTable[rateInd] */
643
644 /* 0.9 times recBwAvgQ in Q16 */
645 /* 461/512 - 25/65536 =0.900009 */
646 tempTerm1 = WEBRTC_SPL_MUL(bweStr->recBwAvgQ, 25);
647 tempTerm1 = WEBRTC_SPL_RSHIFT_W32(tempTerm1, 7);
648 tempTermX = WEBRTC_SPL_UMUL(461, bweStr->recBwAvgQ) - tempTerm1;
649
650 /* rate in Q16 */
651 tempTermY = WEBRTC_SPL_LSHIFT_W32((int32_t)rate, 16);
652
653 /* 0.1 * kQRateTable[rateInd] = KQRate01[rateInd] */
654 tempTerm1 = tempTermX + KQRate01[rateInd] - tempTermY;
655 tempTerm2 = tempTermY - tempTermX - KQRate01[rateInd-1];
656
657 /* Compare (0.9 * recBwAvgQ + 0.1 * kQRateTable[rateInd] - rate) >
658 (rate - 0.9 * recBwAvgQ - 0.1 * kQRateTable[rateInd-1]) */
659 if (tempTerm1 > tempTerm2) {
660 rateInd--;
661 }
662
663 /* Update quantized average by taking: */
664 /* 0.9*recBwAvgQ + 0.1*kQRateTable[rateInd] */
665
666 /* Add 0.1 times kQRateTable[rateInd], in Q16 */
667 tempTermX += KQRate01[rateInd];
668
669 /* Shift back to Q7 */
670 bweStr->recBwAvgQ = WEBRTC_SPL_RSHIFT_W32(tempTermX, 9);
671
672 /* Count consecutive received bandwidth above 28000 kbps (28000 in Q7 = 3584000) */
673 /* If 66 high estimates in a row, set highSpeedRec to one */
674 /* 66 corresponds to ~2 seconds in 30 msec mode */
675 if ((bweStr->recBwAvgQ > 3584000) && !bweStr->highSpeedRec) {
676 bweStr->countHighSpeedRec++;
677 if (bweStr->countHighSpeedRec >= 66) {
678 bweStr->highSpeedRec = 1;
679 }
680 } else if (!bweStr->highSpeedRec) {
681 bweStr->countHighSpeedRec = 0;
682 }
683
684 /* Get Max Delay Bit */
685
686 /* get unquantized max delay */
687 maxDelay = WebRtcIsacfix_GetDownlinkMaxDelay(bweStr);
688
689 /* Update quantized max delay average */
690 tempMax = 652800; /* MAX_ISAC_MD * 0.1 in Q18 */
691 tempMin = 130560; /* MIN_ISAC_MD * 0.1 in Q18 */
692 tempTermX = WEBRTC_SPL_MUL((int32_t)bweStr->recMaxDelayAvgQ, (int32_t)461);
693 tempTermY = WEBRTC_SPL_LSHIFT_W32((int32_t)maxDelay, 18);
694
695 tempTerm1 = tempTermX + tempMax - tempTermY;
696 tempTerm2 = tempTermY - tempTermX - tempMin;
697
698 if ( tempTerm1 > tempTerm2) {
699 maxDelayBit = 0;
700 tempTerm1 = tempTermX + tempMin;
701
702 /* update quantized average, shift back to Q9 */
703 bweStr->recMaxDelayAvgQ = WEBRTC_SPL_RSHIFT_W32(tempTerm1, 9);
704 } else {
705 maxDelayBit = 12;
706 tempTerm1 = tempTermX + tempMax;
707
708 /* update quantized average, shift back to Q9 */
709 bweStr->recMaxDelayAvgQ = WEBRTC_SPL_RSHIFT_W32(tempTerm1, 9);
710 }
711
712 /* Return bandwitdh and jitter index (0..23) */
713 return (uint16_t)(rateInd + maxDelayBit);
714 }
715
716 /* get the bottle neck rate from far side to here, as estimated on this side */
WebRtcIsacfix_GetDownlinkBandwidth(const BwEstimatorstr * bweStr)717 uint16_t WebRtcIsacfix_GetDownlinkBandwidth(const BwEstimatorstr *bweStr)
718 {
719 uint32_t recBw;
720 int32_t jitter_sign; /* Q8 */
721 int32_t bw_adjust; /* Q16 */
722 int32_t rec_jitter_short_term_abs_inv; /* Q18 */
723 int32_t temp;
724
725 /* Q18 rec jitter short term abs is in Q13, multiply it by 2^13 to save precision
726 2^18 then needs to be shifted 13 bits to 2^31 */
727 rec_jitter_short_term_abs_inv = 0x80000000u / bweStr->recJitterShortTermAbs;
728
729 /* Q27 = 9 + 18 */
730 jitter_sign = WEBRTC_SPL_MUL(WEBRTC_SPL_RSHIFT_W32(bweStr->recJitterShortTerm, 4), (int32_t)rec_jitter_short_term_abs_inv);
731
732 if (jitter_sign < 0) {
733 temp = -jitter_sign;
734 temp = WEBRTC_SPL_RSHIFT_W32(temp, 19);
735 jitter_sign = -temp;
736 } else {
737 jitter_sign = WEBRTC_SPL_RSHIFT_W32(jitter_sign, 19);
738 }
739
740 /* adjust bw proportionally to negative average jitter sign */
741 //bw_adjust = 1.0f - jitter_sign * (0.15f + 0.15f * jitter_sign * jitter_sign);
742 //Q8 -> Q16 .15 +.15 * jitter^2 first term is .15 in Q16 latter term is Q8*Q8*Q8
743 //38 in Q8 ~.15 9830 in Q16 ~.15
744 temp = 9830 + WEBRTC_SPL_RSHIFT_W32((WEBRTC_SPL_MUL(38, WEBRTC_SPL_MUL(jitter_sign, jitter_sign))), 8);
745
746 if (jitter_sign < 0) {
747 temp = WEBRTC_SPL_MUL(jitter_sign, temp);
748 temp = -temp;
749 temp = WEBRTC_SPL_RSHIFT_W32(temp, 8);
750 bw_adjust = (uint32_t)65536 + temp; /* (1 << 16) + temp; */
751 } else {
752 bw_adjust = (uint32_t)65536 - WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(jitter_sign, temp), 8);/* (1 << 16) - ((jitter_sign * temp) >> 8); */
753 }
754
755 //make sure following multiplication won't overflow
756 //bw adjust now Q14
757 bw_adjust = WEBRTC_SPL_RSHIFT_W32(bw_adjust, 2);//see if good resolution is maintained
758
759 /* adjust Rate if jitter sign is mostly constant */
760 recBw = WEBRTC_SPL_UMUL(bweStr->recBw, bw_adjust);
761
762 recBw = WEBRTC_SPL_RSHIFT_W32(recBw, 14);
763
764 /* limit range of bottle neck rate */
765 if (recBw < MIN_ISAC_BW) {
766 recBw = MIN_ISAC_BW;
767 } else if (recBw > MAX_ISAC_BW) {
768 recBw = MAX_ISAC_BW;
769 }
770
771 return (uint16_t) recBw;
772 }
773
774 /* Returns the mmax delay (in ms) */
WebRtcIsacfix_GetDownlinkMaxDelay(const BwEstimatorstr * bweStr)775 int16_t WebRtcIsacfix_GetDownlinkMaxDelay(const BwEstimatorstr *bweStr)
776 {
777 int16_t recMaxDelay;
778
779 recMaxDelay = (int16_t) WEBRTC_SPL_RSHIFT_W32(bweStr->recMaxDelay, 15);
780
781 /* limit range of jitter estimate */
782 if (recMaxDelay < MIN_ISAC_MD) {
783 recMaxDelay = MIN_ISAC_MD;
784 } else if (recMaxDelay > MAX_ISAC_MD) {
785 recMaxDelay = MAX_ISAC_MD;
786 }
787
788 return recMaxDelay;
789 }
790
791 /* get the bottle neck rate from here to far side, as estimated by far side */
WebRtcIsacfix_GetUplinkBandwidth(const BwEstimatorstr * bweStr)792 int16_t WebRtcIsacfix_GetUplinkBandwidth(const BwEstimatorstr *bweStr)
793 {
794 int16_t send_bw;
795
796 send_bw = (int16_t) WEBRTC_SPL_RSHIFT_U32(bweStr->sendBwAvg, 7);
797
798 /* limit range of bottle neck rate */
799 if (send_bw < MIN_ISAC_BW) {
800 send_bw = MIN_ISAC_BW;
801 } else if (send_bw > MAX_ISAC_BW) {
802 send_bw = MAX_ISAC_BW;
803 }
804
805 return send_bw;
806 }
807
808
809
810 /* Returns the max delay value from the other side in ms */
WebRtcIsacfix_GetUplinkMaxDelay(const BwEstimatorstr * bweStr)811 int16_t WebRtcIsacfix_GetUplinkMaxDelay(const BwEstimatorstr *bweStr)
812 {
813 int16_t send_max_delay;
814
815 send_max_delay = (int16_t) WEBRTC_SPL_RSHIFT_W32(bweStr->sendMaxDelayAvg, 9);
816
817 /* limit range of jitter estimate */
818 if (send_max_delay < MIN_ISAC_MD) {
819 send_max_delay = MIN_ISAC_MD;
820 } else if (send_max_delay > MAX_ISAC_MD) {
821 send_max_delay = MAX_ISAC_MD;
822 }
823
824 return send_max_delay;
825 }
826
827
828
829
830 /*
831 * update long-term average bitrate and amount of data in buffer
832 * returns minimum payload size (bytes)
833 */
WebRtcIsacfix_GetMinBytes(RateModel * State,int16_t StreamSize,const int16_t FrameSamples,const int16_t BottleNeck,const int16_t DelayBuildUp)834 uint16_t WebRtcIsacfix_GetMinBytes(RateModel *State,
835 int16_t StreamSize, /* bytes in bitstream */
836 const int16_t FrameSamples, /* samples per frame */
837 const int16_t BottleNeck, /* bottle neck rate; excl headers (bps) */
838 const int16_t DelayBuildUp) /* max delay from bottle neck buffering (ms) */
839 {
840 int32_t MinRate = 0;
841 uint16_t MinBytes;
842 int16_t TransmissionTime;
843 int32_t inv_Q12;
844 int32_t den;
845
846
847 /* first 10 packets @ low rate, then INIT_BURST_LEN packets @ fixed rate of INIT_RATE bps */
848 if (State->InitCounter > 0) {
849 if (State->InitCounter-- <= INIT_BURST_LEN) {
850 MinRate = INIT_RATE;
851 } else {
852 MinRate = 0;
853 }
854 } else {
855 /* handle burst */
856 if (State->BurstCounter) {
857 if (State->StillBuffered <
858 (((512 - 512 / BURST_LEN) * DelayBuildUp) >> 9)) {
859 /* max bps derived from BottleNeck and DelayBuildUp values */
860 inv_Q12 = 4096 / (BURST_LEN * FrameSamples);
861 MinRate = WEBRTC_SPL_MUL(512 + WEBRTC_SPL_MUL(SAMPLES_PER_MSEC, WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(DelayBuildUp, inv_Q12), 3)), BottleNeck);
862 } else {
863 /* max bps derived from StillBuffered and DelayBuildUp values */
864 inv_Q12 = 4096 / FrameSamples;
865 if (DelayBuildUp > State->StillBuffered) {
866 MinRate = WEBRTC_SPL_MUL(512 + WEBRTC_SPL_MUL(SAMPLES_PER_MSEC, WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(DelayBuildUp - State->StillBuffered, inv_Q12), 3)), BottleNeck);
867 } else if ((den = WEBRTC_SPL_MUL(SAMPLES_PER_MSEC, (State->StillBuffered - DelayBuildUp))) >= FrameSamples) {
868 /* MinRate will be negative here */
869 MinRate = 0;
870 } else {
871 MinRate = WEBRTC_SPL_MUL((512 - WEBRTC_SPL_RSHIFT_W32(WEBRTC_SPL_MUL(den, inv_Q12), 3)), BottleNeck);
872 }
873 //if (MinRate < 1.04 * BottleNeck)
874 // MinRate = 1.04 * BottleNeck;
875 //Q9
876 if (MinRate < WEBRTC_SPL_MUL(532, BottleNeck)) {
877 MinRate += WEBRTC_SPL_MUL(22, BottleNeck);
878 }
879 }
880
881 State->BurstCounter--;
882 }
883 }
884
885
886 /* convert rate from bits/second to bytes/packet */
887 //round and shift before conversion
888 MinRate += 256;
889 MinRate = WEBRTC_SPL_RSHIFT_W32(MinRate, 9);
890 MinBytes = MinRate * FrameSamples / FS8;
891
892 /* StreamSize will be adjusted if less than MinBytes */
893 if (StreamSize < MinBytes) {
894 StreamSize = MinBytes;
895 }
896
897 /* keep track of when bottle neck was last exceeded by at least 1% */
898 //517/512 ~ 1.01
899 if ((StreamSize * (int32_t)FS8) / FrameSamples > (517 * BottleNeck) >> 9) {
900 if (State->PrevExceed) {
901 /* bottle_neck exceded twice in a row, decrease ExceedAgo */
902 State->ExceedAgo -= BURST_INTERVAL / (BURST_LEN - 1);
903 if (State->ExceedAgo < 0) {
904 State->ExceedAgo = 0;
905 }
906 } else {
907 State->ExceedAgo += (int16_t)WEBRTC_SPL_RSHIFT_W16(FrameSamples, 4); /* ms */
908 State->PrevExceed = 1;
909 }
910 } else {
911 State->PrevExceed = 0;
912 State->ExceedAgo += (int16_t)WEBRTC_SPL_RSHIFT_W16(FrameSamples, 4); /* ms */
913 }
914
915 /* set burst flag if bottle neck not exceeded for long time */
916 if ((State->ExceedAgo > BURST_INTERVAL) && (State->BurstCounter == 0)) {
917 if (State->PrevExceed) {
918 State->BurstCounter = BURST_LEN - 1;
919 } else {
920 State->BurstCounter = BURST_LEN;
921 }
922 }
923
924
925 /* Update buffer delay */
926 TransmissionTime = (StreamSize * 8000) / BottleNeck; /* ms */
927 State->StillBuffered += TransmissionTime;
928 State->StillBuffered -= (int16_t)WEBRTC_SPL_RSHIFT_W16(FrameSamples, 4); //>>4 = SAMPLES_PER_MSEC /* ms */
929 if (State->StillBuffered < 0) {
930 State->StillBuffered = 0;
931 }
932
933 if (State->StillBuffered > 2000) {
934 State->StillBuffered = 2000;
935 }
936
937 return MinBytes;
938 }
939
940
941 /*
942 * update long-term average bitrate and amount of data in buffer
943 */
WebRtcIsacfix_UpdateRateModel(RateModel * State,int16_t StreamSize,const int16_t FrameSamples,const int16_t BottleNeck)944 void WebRtcIsacfix_UpdateRateModel(RateModel *State,
945 int16_t StreamSize, /* bytes in bitstream */
946 const int16_t FrameSamples, /* samples per frame */
947 const int16_t BottleNeck) /* bottle neck rate; excl headers (bps) */
948 {
949 const int16_t TransmissionTime = (StreamSize * 8000) / BottleNeck; /* ms */
950
951 /* avoid the initial "high-rate" burst */
952 State->InitCounter = 0;
953
954 /* Update buffer delay */
955 State->StillBuffered += TransmissionTime;
956 State->StillBuffered -= (int16_t)WEBRTC_SPL_RSHIFT_W16(FrameSamples, 4); /* ms */
957 if (State->StillBuffered < 0) {
958 State->StillBuffered = 0;
959 }
960
961 }
962
963
WebRtcIsacfix_InitRateModel(RateModel * State)964 void WebRtcIsacfix_InitRateModel(RateModel *State)
965 {
966 State->PrevExceed = 0; /* boolean */
967 State->ExceedAgo = 0; /* ms */
968 State->BurstCounter = 0; /* packets */
969 State->InitCounter = INIT_BURST_LEN + 10; /* packets */
970 State->StillBuffered = 1; /* ms */
971 }
972
973
974
975
976
WebRtcIsacfix_GetNewFrameLength(int16_t bottle_neck,int16_t current_framesamples)977 int16_t WebRtcIsacfix_GetNewFrameLength(int16_t bottle_neck, int16_t current_framesamples)
978 {
979 int16_t new_framesamples;
980
981 new_framesamples = current_framesamples;
982
983 /* find new framelength */
984 switch(current_framesamples) {
985 case 480:
986 if (bottle_neck < Thld_30_60) {
987 new_framesamples = 960;
988 }
989 break;
990 case 960:
991 if (bottle_neck >= Thld_60_30) {
992 new_framesamples = 480;
993 }
994 break;
995 default:
996 new_framesamples = -1; /* Error */
997 }
998
999 return new_framesamples;
1000 }
1001
WebRtcIsacfix_GetSnr(int16_t bottle_neck,int16_t framesamples)1002 int16_t WebRtcIsacfix_GetSnr(int16_t bottle_neck, int16_t framesamples)
1003 {
1004 int16_t s2nr = 0;
1005
1006 /* find new SNR value */
1007 //consider BottleNeck to be in Q10 ( * 1 in Q10)
1008 switch(framesamples) {
1009 case 480:
1010 /*s2nr = -1*(a_30 << 10) + ((b_30 * bottle_neck) >> 10);*/
1011 s2nr = -22500 + (int16_t)WEBRTC_SPL_MUL_16_16_RSFT(500, bottle_neck, 10); //* 0.001; //+ c_30 * bottle_neck * bottle_neck * 0.000001;
1012 break;
1013 case 960:
1014 /*s2nr = -1*(a_60 << 10) + ((b_60 * bottle_neck) >> 10);*/
1015 s2nr = -22500 + (int16_t)WEBRTC_SPL_MUL_16_16_RSFT(500, bottle_neck, 10); //* 0.001; //+ c_30 * bottle_neck * bottle_neck * 0.000001;
1016 break;
1017 default:
1018 s2nr = -1; /* Error */
1019 }
1020
1021 return s2nr; //return in Q10
1022
1023 }
1024