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)) */ 27static 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 */ 34static 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 */ 43static const int32_t kBitsByteSec = 4369000; 44 45/* Received header rate. First value is for 30 ms packets and second for 60 ms */ 46static 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*/ 54static const int32_t kInvBandwidth[4] = { 55 55539, 25978, 56 73213, 29284 57}; 58 59/* Number of samples in 25 msec */ 60static 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 */ 73int32_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 */ 142int32_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 */ 544int16_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 */ 607uint16_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 */ 717uint16_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) */ 775int16_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 */ 792int16_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 */ 811int16_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 */ 834uint16_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 */ 944void 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 964void 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 977int16_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 1002int16_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