iSAC: Functions for importing and exporting bandwidth est. info

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

 /*
  *  Copyright (c) 2012 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.
  */
 
 /*
  * BwEstimator.c
  *
  * This file contains the code for the Bandwidth Estimator designed
  * for iSAC.
  *
  */
 
 #include "bandwidth_estimator.h"
 #include "settings.h"
 #include "isac.h"
 
+#include <assert.h>
 #include <math.h>
+#include <string.h>
 
 /* array of quantization levels for bottle neck info; Matlab code: */
 /* sprintf('%4.1ff, ', logspace(log10(5000), log10(40000), 12)) */
 static const float kQRateTableWb[12] =
 {
   10000.0f, 11115.3f, 12355.1f, 13733.1f, 15264.8f, 16967.3f,
   18859.8f, 20963.3f, 23301.4f, 25900.3f, 28789.0f, 32000.0f};
 
 
 static const float kQRateTableSwb[24] =
@@ skipping 78 matching lines @@
 
   bwest_str->in_wait_period = 0;
 
   bwest_str->change_to_WB = 0;
 
   bwest_str->numConsecLatePkts = 0;
   bwest_str->consecLatency = 0;
   bwest_str->inWaitLatePkts = 0;
   bwest_str->senderTimestamp = 0;
   bwest_str->receiverTimestamp = 0;
+
+  bwest_str->external_bw_info.in_use = 0;
+
   return 0;
 }
 
 /* This function updates both bottle neck rates                                                      */
 /* Parameters:                                                                                       */
 /* rtp_number    - value from RTP packet, from NetEq                                                 */
 /* frame length  - length of signal frame in ms, from iSAC decoder                                   */
 /* send_ts       - value in RTP header giving send time in samples                                     */
 /* arr_ts        - value given by timeGetTime() time of arrival in samples of packet from NetEq      */
 /* pksize        - size of packet in bytes, from NetEq                                               */
@@ skipping 15 matching lines @@
   float arr_ts_diff;
   float send_ts_diff;
   float arr_time_noise;
   float arr_time_noise_abs;
 
   float delay_correction_factor = 1;
   float late_diff = 0.0f;
   int immediate_set = 0;
   int num_pkts_expected;
 
+  assert(!bwest_str->external_bw_info.in_use);
 
   // We have to adjust the header-rate if the first packet has a
   // frame-size different than the initialized value.
   if ( frame_length != bwest_str->prev_frame_length )
   {
     bwest_str->rec_header_rate = (float)HEADER_SIZE * 8.0f *
         1000.0f / (float)frame_length;     /* bits/s */
   }
 
   /* UPDATE ESTIMATES ON THIS SIDE */
@@ skipping 334 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 WebRtcIsac_UpdateUplinkBwImpl(
     BwEstimatorstr*           bwest_str,
     int16_t               index,
     enum IsacSamplingRate encoderSamplingFreq)
 {
+  assert(!bwest_str->external_bw_info.in_use);
+
   if((index < 0) || (index > 23))
   {
     return -ISAC_RANGE_ERROR_BW_ESTIMATOR;
   }
 
   /* UPDATE ESTIMATES FROM OTHER SIDE */
   if(encoderSamplingFreq == kIsacWideband)
   {
     if(index > 11)
     {
@@ skipping 36 matching lines @@
   }
   return 0;
 }
 
 // called when there is upper-band bit-stream to update jitter
 // statistics.
 int16_t WebRtcIsac_UpdateUplinkJitter(
     BwEstimatorstr*              bwest_str,
     int32_t                  index)
 {
+  assert(!bwest_str->external_bw_info.in_use);
+
   if((index < 0) || (index > 23))
   {
     return -ISAC_RANGE_ERROR_BW_ESTIMATOR;
   }
 
   if(index > 0)
   {
     /* compute the jitter estimate as decoded on the other side */
     bwest_str->send_max_delay_avg = 0.9f * bwest_str->send_max_delay_avg +
         0.1f * (float)MAX_ISAC_MD;
   }
   else
   {
     /* compute the jitter estimate as decoded on the other side */
     bwest_str->send_max_delay_avg = 0.9f * bwest_str->send_max_delay_avg +
         0.1f * (float)MIN_ISAC_MD;
   }
 
   return 0;
 }
 
 
 
 // Returns the bandwidth/jitter estimation code (integer 0...23)
 // to put in the sending iSAC payload
-uint16_t
+void
 WebRtcIsac_GetDownlinkBwJitIndexImpl(
     BwEstimatorstr*           bwest_str,
     int16_t*              bottleneckIndex,
     int16_t*              jitterInfo,
     enum IsacSamplingRate decoderSamplingFreq)
 {
   float MaxDelay;
   //uint16_t MaxDelayBit;
 
   float rate;
   float r;
   float e1, e2;
   const float weight = 0.1f;
   const float* ptrQuantizationTable;
   int16_t addJitterInfo;
   int16_t minInd;
   int16_t maxInd;
   int16_t midInd;
 
+  if (bwest_str->external_bw_info.in_use) {
+    *bottleneckIndex = bwest_str->external_bw_info.bottleneck_idx;
+    *jitterInfo = bwest_str->external_bw_info.jitter_info;
+    return;
+  }
+
   /* Get Max Delay Bit */
   /* get unquantized max delay */
   MaxDelay = (float)WebRtcIsac_GetDownlinkMaxDelay(bwest_str);
 
   if ( ((1.f - weight) * bwest_str->rec_max_delay_avg_Q + weight *
         MAX_ISAC_MD - MaxDelay) > (MaxDelay - (1.f-weight) *
                                    bwest_str->rec_max_delay_avg_Q - weight * MIN_ISAC_MD) )
   {
     jitterInfo[0] = 0;
     /* update quantized average */
@@ skipping 55 matching lines @@
   {
     bottleneckIndex[0] = maxInd;
   }
 
   bwest_str->rec_bw_avg_Q = (1 - weight) * bwest_str->rec_bw_avg_Q +
       weight * ptrQuantizationTable[bottleneckIndex[0]];
   bottleneckIndex[0] += jitterInfo[0] * 12 * addJitterInfo;
 
   bwest_str->rec_bw_avg = (1 - weight) * bwest_str->rec_bw_avg + weight *
       (rate + bwest_str->rec_header_rate);
-
-  return 0;
 }
 
 
 
 /* get the bottle neck rate from far side to here, as estimated on this side */
 int32_t WebRtcIsac_GetDownlinkBandwidth( const BwEstimatorstr *bwest_str)
 {
   int32_t  rec_bw;
   float   jitter_sign;
   float   bw_adjust;
 
+  assert(!bwest_str->external_bw_info.in_use);
+
   /* create a value between -1.0 and 1.0 indicating "average sign" of jitter */
   jitter_sign = bwest_str->rec_jitter_short_term /
       bwest_str->rec_jitter_short_term_abs;
 
   /* adjust bw proportionally to negative average jitter sign */
   bw_adjust = 1.0f - jitter_sign * (0.15f + 0.15f * jitter_sign * jitter_sign);
 
   /* adjust Rate if jitter sign is mostly constant */
   rec_bw = (int32_t)(bwest_str->rec_bw * bw_adjust);
 
   /* limit range of bottle neck rate */
   if (rec_bw < MIN_ISAC_BW)
   {
     rec_bw = MIN_ISAC_BW;
   }
   else if (rec_bw > MAX_ISAC_BW)
   {
     rec_bw = MAX_ISAC_BW;
   }
   return rec_bw;
 }
 
 /* Returns the max delay (in ms) */
 int32_t
 WebRtcIsac_GetDownlinkMaxDelay(const BwEstimatorstr *bwest_str)
 {
   int32_t rec_max_delay;
 
+  assert(!bwest_str->external_bw_info.in_use);
+
   rec_max_delay = (int32_t)(bwest_str->rec_max_delay);
 
   /* limit range of jitter estimate */
   if (rec_max_delay < MIN_ISAC_MD)
   {
     rec_max_delay = MIN_ISAC_MD;
   }
   else if (rec_max_delay > MAX_ISAC_MD)
   {
     rec_max_delay = MAX_ISAC_MD;
   }
   return rec_max_delay;
 }
 
-/* get the bottle neck rate from here to far side, as estimated by far side */
-void
-WebRtcIsac_GetUplinkBandwidth(
-    const BwEstimatorstr* bwest_str,
-    int32_t*          bitRate)
-{
-  /* limit range of bottle neck rate */
-  if (bwest_str->send_bw_avg < MIN_ISAC_BW)
-  {
-    *bitRate = MIN_ISAC_BW;
-  }
-  else if (bwest_str->send_bw_avg > MAX_ISAC_BW)
-  {
-    *bitRate = MAX_ISAC_BW;
-  }
-  else
-  {
-    *bitRate = (int32_t)(bwest_str->send_bw_avg);
-  }
-  return;
+/* Clamp val to the closed interval [min,max]. */
+static int32_t clamp(int32_t val, int32_t min, int32_t max) {
+  assert(min <= max);
+  return val < min ? min : (val > max ? max : val);
 }
 
-/* Returns the max delay value from the other side in ms */
-int32_t
-WebRtcIsac_GetUplinkMaxDelay(const BwEstimatorstr *bwest_str)
-{
-  int32_t send_max_delay;
-
-  send_max_delay = (int32_t)(bwest_str->send_max_delay_avg);
-
-  /* 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;
+int32_t WebRtcIsac_GetUplinkBandwidth(const BwEstimatorstr* bwest_str) {
+  return bwest_str->external_bw_info.in_use
+             ? bwest_str->external_bw_info.send_bw_avg
+             : clamp(bwest_str->send_bw_avg, MIN_ISAC_BW, MAX_ISAC_BW);
 }
 
+int32_t WebRtcIsac_GetUplinkMaxDelay(const BwEstimatorstr* bwest_str) {
+  return bwest_str->external_bw_info.in_use
+             ? bwest_str->external_bw_info.send_max_delay_avg
+             : clamp(bwest_str->send_max_delay_avg, MIN_ISAC_MD, MAX_ISAC_MD);
+}
+
+void WebRtcIsacBw_GetBandwidthInfo(BwEstimatorstr* bwest_str,
+                                   enum IsacSamplingRate decoder_sample_rate_hz,
+                                   IsacBandwidthInfo* bwinfo) {
+  assert(!bwest_str->external_bw_info.in_use);
+  bwinfo->in_use = 1;
+  bwinfo->send_bw_avg = WebRtcIsac_GetUplinkBandwidth(bwest_str);
+  bwinfo->send_max_delay_avg = WebRtcIsac_GetUplinkMaxDelay(bwest_str);
+  WebRtcIsac_GetDownlinkBwJitIndexImpl(bwest_str, &bwinfo->bottleneck_idx,
+                                       &bwinfo->jitter_info,
+                                       decoder_sample_rate_hz);
+}
+
+void WebRtcIsacBw_SetBandwidthInfo(BwEstimatorstr* bwest_str,
+                                   const IsacBandwidthInfo* bwinfo) {
+  memcpy(&bwest_str->external_bw_info, bwinfo,
+         sizeof bwest_str->external_bw_info);
+}
 
 /*
  * update long-term average bitrate and amount of data in buffer
  * returns minimum payload size (bytes)
  */
 int WebRtcIsac_GetMinBytes(
     RateModel*         State,
     int                StreamSize,    /* bytes in bitstream */
     const int          FrameSamples,  /* samples per frame */
     const double       BottleNeck,    /* bottle neck rate; excl headers (bps) */
@@ skipping 217 matching lines @@
       s2nr = a_60 + b_60 * bottle_neck * 0.001 + c_60 * bottle_neck *
           bottle_neck * 0.000001;
       break;
     default:
       s2nr = 0;
   }
 
   return s2nr;
 
 }