iSAC: Functions for importing and exporting bandwidth est. info

webrtc/modules/audio_coding/codecs/isac/fix/source/bandwidth_estimator.c

 /*
  *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 /*
  * bandwidth_estimator.c
  *
  * This file contains the code for the Bandwidth Estimator designed
  * for iSAC.
  *
  * NOTE! Castings needed for C55, do not remove!
  *
  */
 
 #include "bandwidth_estimator.h"
+
+#include <assert.h>
 #include "settings.h"
 
 
 /* array of quantization levels for bottle neck info; Matlab code: */
 /* sprintf('%4.1ff, ', logspace(log10(5000), log10(40000), 12)) */
 static const int16_t kQRateTable[12] = {
   10000, 11115, 12355, 13733, 15265, 16967,
   18860, 20963, 23301, 25900, 28789, 32000
 };
 
@@ skipping 77 matching lines @@
   bweStr->highSpeedSend         = 0;
   bweStr->inWaitPeriod          = 0;
 
   /* Find the inverse of the max bw and min bw in Q30
    *  (1 / (MAX_ISAC_BW + INIT_HDR_RATE) in Q30
    *  (1 / (MIN_ISAC_BW + INIT_HDR_RATE) in Q30
    */
   bweStr->maxBwInv              = kInvBandwidth[3];
   bweStr->minBwInv              = kInvBandwidth[2];
 
+  bweStr->external_bw_info.in_use = 0;
+
   return 0;
 }
 
 /****************************************************************************
  * WebRtcIsacfix_UpdateUplinkBwImpl(...)
  *
  * This function updates bottle neck rate received from other side in payload
  * and calculates a new bottle neck to send to the other side.
  *
  * Input/Output:
@@ skipping 40 matching lines @@
   int32_t  sign;
 
   uint32_t byteSecondsPerBit;
   uint32_t tempLower;
   uint32_t tempUpper;
   int32_t recBwAvgInv;
   int32_t numPktsExpected;
 
   int16_t errCode;
 
+  assert(!bweStr->external_bw_info.in_use);
+
   /* UPDATE ESTIMATES FROM OTHER SIDE */
 
   /* The function also checks if Index has a valid value */
   errCode = WebRtcIsacfix_UpdateUplinkBwRec(bweStr, Index);
   if (errCode <0) {
     return(errCode);
   }
 
 
   /* UPDATE ESTIMATES ON THIS SIDE */
@@ skipping 349 matching lines @@
 }
 
 /* This function updates the send bottle neck rate                                                   */
 /* Index         - integer (range 0...23) indicating bottle neck & jitter as estimated by other side */
 /* returns 0 if everything went fine, -1 otherwise                                                   */
 int16_t WebRtcIsacfix_UpdateUplinkBwRec(BwEstimatorstr *bweStr,
                                         const int16_t Index)
 {
   uint16_t RateInd;
 
+  assert(!bweStr->external_bw_info.in_use);
+
   if ( (Index < 0) || (Index > 23) ) {
     return -ISAC_RANGE_ERROR_BW_ESTIMATOR;
   }
 
   /* UPDATE ESTIMATES FROM OTHER SIDE */
 
   if ( Index > 11 ) {
     RateInd = Index - 12;
     /* compute the jitter estimate as decoded on the other side in Q9 */
     /* sendMaxDelayAvg = 0.9 * sendMaxDelayAvg + 0.1 * MAX_ISAC_MD */
@@ skipping 51 matching lines @@
   int32_t  maxDelay;
   uint16_t rateInd;
   uint16_t maxDelayBit;
   int32_t  tempTerm1;
   int32_t  tempTerm2;
   int32_t  tempTermX;
   int32_t  tempTermY;
   int32_t  tempMin;
   int32_t  tempMax;
 
+  if (bweStr->external_bw_info.in_use)
+    return bweStr->external_bw_info.bottleneck_idx;
+
   /* Get Rate Index */
 
   /* Get unquantized rate. Always returns 10000 <= rate <= 32000 */
   rate = WebRtcIsacfix_GetDownlinkBandwidth(bweStr);
 
   /* Compute the averaged BN estimate on this side */
 
   /* recBwAvg = 0.9 * recBwAvg + 0.1 * (rate + bweStr->recHeaderRate), 0.9 and 0.1 in Q9 */
   bweStr->recBwAvg = 922 * bweStr->recBwAvg +
       102 * (((uint32_t)rate + bweStr->recHeaderRate) << 5);
@@ skipping 85 matching lines @@
 
 /* get the bottle neck rate from far side to here, as estimated on this side */
 uint16_t WebRtcIsacfix_GetDownlinkBandwidth(const BwEstimatorstr *bweStr)
 {
   uint32_t  recBw;
   int32_t   jitter_sign; /* Q8 */
   int32_t   bw_adjust;   /* Q16 */
   int32_t   rec_jitter_short_term_abs_inv; /* Q18 */
   int32_t   temp;
 
+  assert(!bweStr->external_bw_info.in_use);
+
   /* Q18  rec jitter short term abs is in Q13, multiply it by 2^13 to save precision
      2^18 then needs to be shifted 13 bits to 2^31 */
   rec_jitter_short_term_abs_inv = 0x80000000u / bweStr->recJitterShortTermAbs;
 
   /* Q27 = 9 + 18 */
   jitter_sign = (bweStr->recJitterShortTerm >> 4) *
       rec_jitter_short_term_abs_inv;
 
   if (jitter_sign < 0) {
     temp = -jitter_sign;
@@ skipping 36 matching lines @@
   }
 
   return  (uint16_t) recBw;
 }
 
 /* Returns the mmax delay (in ms) */
 int16_t WebRtcIsacfix_GetDownlinkMaxDelay(const BwEstimatorstr *bweStr)
 {
   int16_t recMaxDelay = (int16_t)(bweStr->recMaxDelay >> 15);
 
+  assert(!bweStr->external_bw_info.in_use);
+
   /* limit range of jitter estimate */
   if (recMaxDelay < MIN_ISAC_MD) {
     recMaxDelay = MIN_ISAC_MD;
   } else if (recMaxDelay > MAX_ISAC_MD) {
     recMaxDelay = MAX_ISAC_MD;
   }
 
   return recMaxDelay;
 }
 
-/* get the bottle neck rate from here to far side, as estimated by far side */
-int16_t WebRtcIsacfix_GetUplinkBandwidth(const BwEstimatorstr *bweStr)
-{
-  int16_t send_bw;
-
-  send_bw = (int16_t) WEBRTC_SPL_RSHIFT_U32(bweStr->sendBwAvg, 7);
-
-  /* limit range of bottle neck rate */
-  if (send_bw < MIN_ISAC_BW) {
-    send_bw = MIN_ISAC_BW;
-  } else if (send_bw > MAX_ISAC_BW) {
-    send_bw = MAX_ISAC_BW;
-  }
-
-  return send_bw;
+/* Clamp val to the closed interval [min,max]. */
+static int16_t clamp(int16_t val, int16_t min, int16_t max) {
+  assert(min <= max);
+  if (val <= min)

[hlundin-webrtc, 2015/06/26 10:35:14]

Consider
return val <= min ? min : (val >= max ? max : val);
Optional....

[kwiberg-webrtc, 2015/06/28 03:17:41]

Done.

+    return min;
+  if (val >= max)
+    return max;
+  return val;
 }
 
-
-
-/* Returns the max delay value from the other side in ms */
-int16_t WebRtcIsacfix_GetUplinkMaxDelay(const BwEstimatorstr *bweStr)
-{
-  int16_t send_max_delay = (int16_t)(bweStr->sendMaxDelayAvg >> 9);
-
-  /* limit range of jitter estimate */
-  if (send_max_delay < MIN_ISAC_MD) {
-    send_max_delay = MIN_ISAC_MD;
-  } else if (send_max_delay > MAX_ISAC_MD) {
-    send_max_delay = MAX_ISAC_MD;
-  }
-
-  return send_max_delay;
+int16_t WebRtcIsacfix_GetUplinkBandwidth(const BwEstimatorstr* bweStr) {
+  return bweStr->external_bw_info.in_use
+             ? bweStr->external_bw_info.send_bw_avg
+             : clamp(bweStr->sendBwAvg >> 7, MIN_ISAC_BW, MAX_ISAC_BW);
 }
 
+int16_t WebRtcIsacfix_GetUplinkMaxDelay(const BwEstimatorstr* bweStr) {
+  return bweStr->external_bw_info.in_use
+             ? bweStr->external_bw_info.send_max_delay_avg
+             : clamp(bweStr->sendMaxDelayAvg >> 9, MIN_ISAC_MD, MAX_ISAC_MD);
+}
 
+void WebRtcIsacfixBw_GetBandwidthInfo(BwEstimatorstr* bweStr,
+                                   IsacBandwidthInfo* bwinfo) {
+  assert(!bweStr->external_bw_info.in_use);
+  bwinfo->in_use = 1;
+  bwinfo->send_bw_avg = WebRtcIsacfix_GetUplinkBandwidth(bweStr);
+  bwinfo->send_max_delay_avg = WebRtcIsacfix_GetUplinkMaxDelay(bweStr);
+  bwinfo->bottleneck_idx = WebRtcIsacfix_GetDownlinkBwIndexImpl(bweStr);
+  bwinfo->jitter_info = 0;  // Not used.
+}
 
+void WebRtcIsacfixBw_SetBandwidthInfo(BwEstimatorstr* bweStr,
+                                   const IsacBandwidthInfo* bwinfo) {
+  memcpy(&bweStr->external_bw_info, bwinfo,
+         sizeof bweStr->external_bw_info);
+}
 
 /*
  * update long-term average bitrate and amount of data in buffer
  * returns minimum payload size (bytes)
  */
 uint16_t WebRtcIsacfix_GetMinBytes(RateModel *State,
                                    int16_t StreamSize,                    /* bytes in bitstream */
                                    const int16_t FrameSamples,            /* samples per frame */
                                    const int16_t BottleNeck,        /* bottle neck rate; excl headers (bps) */
                                    const int16_t DelayBuildUp)      /* max delay from bottle neck buffering (ms) */
@@ skipping 181 matching lines @@
       /*s2nr = -1*(a_60 << 10) + ((b_60 * bottle_neck) >> 10);*/
       s2nr = -22500 + (int16_t)(500 * bottle_neck >> 10);
       break;
     default:
       s2nr = -1; /* Error */
   }
 
   return s2nr; //return in Q10
 
 }