718 lines
23 KiB
C
718 lines
23 KiB
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.
|
|
*/
|
|
|
|
/*
|
|
* This file contains the implementation of automatic buffer level optimization.
|
|
*/
|
|
|
|
#include "automode.h"
|
|
|
|
#include "signal_processing_library.h"
|
|
|
|
#include "neteq_defines.h"
|
|
|
|
#ifdef NETEQ_DELAY_LOGGING
|
|
/* special code for offline delay logging */
|
|
#include <stdio.h>
|
|
#include "delay_logging.h"
|
|
|
|
extern FILE *delay_fid2; /* file pointer to delay log file */
|
|
#endif /* NETEQ_DELAY_LOGGING */
|
|
|
|
|
|
int WebRtcNetEQ_UpdateIatStatistics(AutomodeInst_t *inst, int maxBufLen,
|
|
WebRtc_UWord16 seqNumber, WebRtc_UWord32 timeStamp,
|
|
WebRtc_Word32 fsHz, int mdCodec, int streamingMode)
|
|
{
|
|
WebRtc_UWord32 timeIat; /* inter-arrival time */
|
|
int i;
|
|
WebRtc_Word32 tempsum = 0; /* temp summation */
|
|
WebRtc_Word32 tempvar; /* temporary variable */
|
|
int retval = 0; /* return value */
|
|
WebRtc_Word16 packetLenSamp; /* packet speech length in samples */
|
|
|
|
/****************/
|
|
/* Sanity check */
|
|
/****************/
|
|
|
|
if (maxBufLen <= 1 || fsHz <= 0)
|
|
{
|
|
/* maxBufLen must be at least 2 and fsHz must both be strictly positive */
|
|
return -1;
|
|
}
|
|
|
|
/****************************/
|
|
/* Update packet statistics */
|
|
/****************************/
|
|
|
|
/* Try calculating packet length from current and previous timestamps */
|
|
if ((timeStamp <= inst->lastTimeStamp) || (seqNumber <= inst->lastSeqNo))
|
|
{
|
|
/* Wrong timestamp or sequence order; revert to backup plan */
|
|
packetLenSamp = inst->packetSpeechLenSamp; /* use stored value */
|
|
}
|
|
else if (timeStamp > inst->lastTimeStamp)
|
|
{
|
|
/* calculate timestamps per packet */
|
|
packetLenSamp = (WebRtc_Word16) WebRtcSpl_DivU32U16(timeStamp - inst->lastTimeStamp,
|
|
seqNumber - inst->lastSeqNo);
|
|
}
|
|
|
|
/* Check that the packet size is positive; if not, the statistics cannot be updated. */
|
|
if (packetLenSamp > 0)
|
|
{ /* packet size ok */
|
|
|
|
/* calculate inter-arrival time in integer packets (rounding down) */
|
|
timeIat = WebRtcSpl_DivW32W16(inst->packetIatCountSamp, packetLenSamp);
|
|
|
|
/* Special operations for streaming mode */
|
|
if (streamingMode != 0)
|
|
{
|
|
/*
|
|
* Calculate IAT in Q8, including fractions of a packet (i.e., more accurate
|
|
* than timeIat).
|
|
*/
|
|
WebRtc_Word16 timeIatQ8 = (WebRtc_Word16) WebRtcSpl_DivW32W16(
|
|
WEBRTC_SPL_LSHIFT_W32(inst->packetIatCountSamp, 8), packetLenSamp);
|
|
|
|
/*
|
|
* Calculate cumulative sum iat with sequence number compensation (ideal arrival
|
|
* times makes this sum zero).
|
|
*/
|
|
inst->cSumIatQ8 += (timeIatQ8
|
|
- WEBRTC_SPL_LSHIFT_W32(seqNumber - inst->lastSeqNo, 8));
|
|
|
|
/* subtract drift term */
|
|
inst->cSumIatQ8 -= CSUM_IAT_DRIFT;
|
|
|
|
/* ensure not negative */
|
|
inst->cSumIatQ8 = WEBRTC_SPL_MAX(inst->cSumIatQ8, 0);
|
|
|
|
/* remember max */
|
|
if (inst->cSumIatQ8 > inst->maxCSumIatQ8)
|
|
{
|
|
inst->maxCSumIatQ8 = inst->cSumIatQ8;
|
|
inst->maxCSumUpdateTimer = 0;
|
|
}
|
|
|
|
/* too long since the last maximum was observed; decrease max value */
|
|
if (inst->maxCSumUpdateTimer > (WebRtc_UWord32) WEBRTC_SPL_MUL_32_16(fsHz,
|
|
MAX_STREAMING_PEAK_PERIOD))
|
|
{
|
|
inst->maxCSumIatQ8 -= 4; /* remove 1000*4/256 = 15.6 ms/s */
|
|
}
|
|
} /* end of streaming mode */
|
|
|
|
/* check for discontinuous packet sequence and re-ordering */
|
|
if (seqNumber > inst->lastSeqNo + 1)
|
|
{
|
|
/* Compensate for gap in the sequence numbers.
|
|
* Reduce IAT with expected extra time due to lost packets, but ensure that
|
|
* the IAT is not negative.
|
|
*/
|
|
timeIat -= WEBRTC_SPL_MIN(timeIat,
|
|
(WebRtc_UWord32) (seqNumber - inst->lastSeqNo - 1));
|
|
}
|
|
else if (seqNumber < inst->lastSeqNo)
|
|
{
|
|
/* compensate for re-ordering */
|
|
timeIat += (WebRtc_UWord32) (inst->lastSeqNo + 1 - seqNumber);
|
|
}
|
|
|
|
/* saturate IAT at maximum value */
|
|
timeIat = WEBRTC_SPL_MIN( timeIat, MAX_IAT );
|
|
|
|
/* update iatProb = forgetting_factor * iatProb for all elements */
|
|
for (i = 0; i <= MAX_IAT; i++)
|
|
{
|
|
WebRtc_Word32 tempHi, tempLo; /* Temporary variables */
|
|
|
|
/*
|
|
* Multiply iatProbFact (Q15) with iatProb (Q30) and right-shift 15 steps
|
|
* to come back to Q30. The operation is done in two steps:
|
|
*/
|
|
|
|
/*
|
|
* 1) Multiply the high 16 bits (15 bits + sign) of iatProb. Shift iatProb
|
|
* 16 steps right to get the high 16 bits in a WebRtc_Word16 prior to
|
|
* multiplication, and left-shift with 1 afterwards to come back to
|
|
* Q30 = (Q15 * (Q30>>16)) << 1.
|
|
*/
|
|
tempHi = WEBRTC_SPL_MUL_16_16(inst->iatProbFact,
|
|
(WebRtc_Word16) WEBRTC_SPL_RSHIFT_W32(inst->iatProb[i], 16));
|
|
tempHi = WEBRTC_SPL_LSHIFT_W32(tempHi, 1); /* left-shift 1 step */
|
|
|
|
/*
|
|
* 2) Isolate and multiply the low 16 bits of iatProb. Right-shift 15 steps
|
|
* afterwards to come back to Q30 = (Q15 * Q30) >> 15.
|
|
*/
|
|
tempLo = inst->iatProb[i] & 0x0000FFFF; /* sift out the 16 low bits */
|
|
tempLo = WEBRTC_SPL_MUL_16_U16(inst->iatProbFact,
|
|
(WebRtc_UWord16) tempLo);
|
|
tempLo = WEBRTC_SPL_RSHIFT_W32(tempLo, 15);
|
|
|
|
/* Finally, add the high and low parts */
|
|
inst->iatProb[i] = tempHi + tempLo;
|
|
|
|
/* Sum all vector elements while we are at it... */
|
|
tempsum += inst->iatProb[i];
|
|
}
|
|
|
|
/*
|
|
* Increase the probability for the currently observed inter-arrival time
|
|
* with 1 - iatProbFact. The factor is in Q15, iatProb in Q30;
|
|
* hence, left-shift 15 steps to obtain result in Q30.
|
|
*/
|
|
inst->iatProb[timeIat] += (32768 - inst->iatProbFact) << 15;
|
|
|
|
tempsum += (32768 - inst->iatProbFact) << 15; /* add to vector sum */
|
|
|
|
/*
|
|
* Update iatProbFact (changes only during the first seconds after reset)
|
|
* The factor converges to IAT_PROB_FACT.
|
|
*/
|
|
inst->iatProbFact += (IAT_PROB_FACT - inst->iatProbFact + 3) >> 2;
|
|
|
|
/* iatProb should sum up to 1 (in Q30). */
|
|
tempsum -= 1 << 30; /* should be zero */
|
|
|
|
/* Check if it does, correct if it doesn't. */
|
|
if (tempsum > 0)
|
|
{
|
|
/* tempsum too large => decrease a few values in the beginning */
|
|
i = 0;
|
|
while (i <= MAX_IAT && tempsum > 0)
|
|
{
|
|
/* Remove iatProb[i] / 16 from iatProb, but not more than tempsum */
|
|
tempvar = WEBRTC_SPL_MIN(tempsum, inst->iatProb[i] >> 4);
|
|
inst->iatProb[i++] -= tempvar;
|
|
tempsum -= tempvar;
|
|
}
|
|
}
|
|
else if (tempsum < 0)
|
|
{
|
|
/* tempsum too small => increase a few values in the beginning */
|
|
i = 0;
|
|
while (i <= MAX_IAT && tempsum < 0)
|
|
{
|
|
/* Add iatProb[i] / 16 to iatProb, but not more than tempsum */
|
|
tempvar = WEBRTC_SPL_MIN(-tempsum, inst->iatProb[i] >> 4);
|
|
inst->iatProb[i++] += tempvar;
|
|
tempsum += tempvar;
|
|
}
|
|
}
|
|
|
|
/* Calculate optimal buffer level based on updated statistics */
|
|
tempvar = (WebRtc_Word32) WebRtcNetEQ_CalcOptimalBufLvl(inst, fsHz, mdCodec, timeIat,
|
|
streamingMode);
|
|
if (tempvar > 0)
|
|
{
|
|
inst->optBufLevel = (WebRtc_UWord16) tempvar;
|
|
|
|
if (streamingMode != 0)
|
|
{
|
|
inst->optBufLevel = WEBRTC_SPL_MAX(inst->optBufLevel,
|
|
inst->maxCSumIatQ8);
|
|
}
|
|
|
|
/*********/
|
|
/* Limit */
|
|
/*********/
|
|
|
|
/* Subtract extra delay from maxBufLen */
|
|
if (inst->extraDelayMs > 0 && inst->packetSpeechLenSamp > 0)
|
|
{
|
|
maxBufLen -= inst->extraDelayMs / inst->packetSpeechLenSamp * fsHz / 1000;
|
|
maxBufLen = WEBRTC_SPL_MAX(maxBufLen, 1); // sanity: at least one packet
|
|
}
|
|
|
|
maxBufLen = WEBRTC_SPL_LSHIFT_W32(maxBufLen, 8); /* shift to Q8 */
|
|
|
|
/* Enforce upper limit; 75% of maxBufLen */
|
|
inst->optBufLevel = (WebRtc_UWord16) WEBRTC_SPL_MIN( inst->optBufLevel,
|
|
(maxBufLen >> 1) + (maxBufLen >> 2) ); /* 1/2 + 1/4 = 75% */
|
|
}
|
|
else
|
|
{
|
|
retval = (int) tempvar;
|
|
}
|
|
|
|
} /* end if */
|
|
|
|
/*******************************/
|
|
/* Update post-call statistics */
|
|
/*******************************/
|
|
|
|
/* Calculate inter-arrival time in ms = packetIatCountSamp / (fsHz / 1000) */
|
|
timeIat = WEBRTC_SPL_UDIV(
|
|
WEBRTC_SPL_UMUL_32_16(inst->packetIatCountSamp, (WebRtc_Word16) 1000),
|
|
(WebRtc_UWord32) fsHz);
|
|
|
|
/* Increase counter corresponding to current inter-arrival time */
|
|
if (timeIat > 2000)
|
|
{
|
|
inst->countIAT2000ms++;
|
|
}
|
|
else if (timeIat > 1000)
|
|
{
|
|
inst->countIAT1000ms++;
|
|
}
|
|
else if (timeIat > 500)
|
|
{
|
|
inst->countIAT500ms++;
|
|
}
|
|
|
|
if (timeIat > inst->longestIATms)
|
|
{
|
|
/* update maximum value */
|
|
inst->longestIATms = timeIat;
|
|
}
|
|
|
|
/***********************************/
|
|
/* Prepare for next packet arrival */
|
|
/***********************************/
|
|
|
|
inst->packetIatCountSamp = 0; /* reset inter-arrival time counter */
|
|
|
|
inst->lastSeqNo = seqNumber; /* remember current sequence number */
|
|
|
|
inst->lastTimeStamp = timeStamp; /* remember current timestamp */
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
WebRtc_Word16 WebRtcNetEQ_CalcOptimalBufLvl(AutomodeInst_t *inst, WebRtc_Word32 fsHz,
|
|
int mdCodec, WebRtc_UWord32 timeIatPkts,
|
|
int streamingMode)
|
|
{
|
|
|
|
WebRtc_Word32 sum1 = 1 << 30; /* assign to 1 in Q30 */
|
|
WebRtc_Word16 B;
|
|
WebRtc_UWord16 Bopt;
|
|
int i;
|
|
WebRtc_Word32 betaInv; /* optimization parameter */
|
|
|
|
#ifdef NETEQ_DELAY_LOGGING
|
|
/* special code for offline delay logging */
|
|
int temp_var;
|
|
#endif
|
|
|
|
/****************/
|
|
/* Sanity check */
|
|
/****************/
|
|
|
|
if (fsHz <= 0)
|
|
{
|
|
/* fsHz must be strictly positive */
|
|
return -1;
|
|
}
|
|
|
|
/***********************************************/
|
|
/* Get betaInv parameter based on playout mode */
|
|
/***********************************************/
|
|
|
|
if (streamingMode)
|
|
{
|
|
/* streaming (listen-only) mode */
|
|
betaInv = AUTOMODE_STREAMING_BETA_INV_Q30;
|
|
}
|
|
else
|
|
{
|
|
/* normal mode */
|
|
betaInv = AUTOMODE_BETA_INV_Q30;
|
|
}
|
|
|
|
/*******************************************************************/
|
|
/* Calculate optimal buffer level without considering jitter peaks */
|
|
/*******************************************************************/
|
|
|
|
/*
|
|
* Find the B for which the probability of observing an inter-arrival time larger
|
|
* than or equal to B is less than or equal to betaInv.
|
|
*/
|
|
B = 0; /* start from the beginning of iatProb */
|
|
sum1 -= inst->iatProb[B]; /* ensure that optimal level is not less than 1 */
|
|
|
|
do
|
|
{
|
|
/*
|
|
* Subtract the probabilities one by one until the sum is no longer greater
|
|
* than betaInv.
|
|
*/
|
|
sum1 -= inst->iatProb[++B];
|
|
}
|
|
while ((sum1 > betaInv) && (B < MAX_IAT));
|
|
|
|
Bopt = B; /* This is our primary value for the optimal buffer level Bopt */
|
|
|
|
if (mdCodec)
|
|
{
|
|
/*
|
|
* Use alternative cost function when multiple description codec is in use.
|
|
* Do not have to re-calculate all points, just back off a few steps from
|
|
* previous value of B.
|
|
*/
|
|
WebRtc_Word32 sum2 = sum1; /* copy sum1 */
|
|
|
|
while ((sum2 <= betaInv + inst->iatProb[Bopt]) && (Bopt > 0))
|
|
{
|
|
/* Go backwards in the sum until the modified cost function solution is found */
|
|
sum2 += inst->iatProb[Bopt--];
|
|
}
|
|
|
|
Bopt++; /* This is the optimal level when using an MD codec */
|
|
|
|
/* Now, Bopt and B can have different values. */
|
|
}
|
|
|
|
#ifdef NETEQ_DELAY_LOGGING
|
|
/* special code for offline delay logging */
|
|
temp_var = NETEQ_DELAY_LOGGING_SIGNAL_OPTBUF;
|
|
fwrite( &temp_var, sizeof(int), 1, delay_fid2 );
|
|
temp_var = (int) (Bopt * inst->packetSpeechLenSamp);
|
|
#endif
|
|
|
|
/******************************************************************/
|
|
/* Make levelFiltFact adaptive: Larger B <=> larger levelFiltFact */
|
|
/******************************************************************/
|
|
|
|
switch (B)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
{
|
|
inst->levelFiltFact = 251;
|
|
break;
|
|
}
|
|
case 2:
|
|
case 3:
|
|
{
|
|
inst->levelFiltFact = 252;
|
|
break;
|
|
}
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
{
|
|
inst->levelFiltFact = 253;
|
|
break;
|
|
}
|
|
default: /* B > 7 */
|
|
{
|
|
inst->levelFiltFact = 254;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/************************/
|
|
/* Peak mode operations */
|
|
/************************/
|
|
|
|
/* Compare current IAT with peak threshold
|
|
*
|
|
* If IAT > optimal level + threshold (+1 for MD codecs)
|
|
* or if IAT > 2 * optimal level (note: optimal level is in Q8):
|
|
*/
|
|
if (timeIatPkts > (WebRtc_UWord32) (Bopt + inst->peakThresholdPkt + (mdCodec != 0))
|
|
|| timeIatPkts > (WebRtc_UWord32) WEBRTC_SPL_LSHIFT_U16(Bopt, 1))
|
|
{
|
|
/* A peak is observed */
|
|
|
|
if (inst->peakIndex == -1)
|
|
{
|
|
/* this is the first peak; prepare for next peak */
|
|
inst->peakIndex = 0;
|
|
/* set the mode-disable counter */
|
|
inst->peakModeDisabled = WEBRTC_SPL_LSHIFT_W16(1, NUM_PEAKS_REQUIRED-2);
|
|
}
|
|
else if (inst->peakIatCountSamp
|
|
<=
|
|
(WebRtc_UWord32) WEBRTC_SPL_MUL_32_16(fsHz, MAX_PEAK_PERIOD))
|
|
{
|
|
/* This is not the first peak and the period time is valid */
|
|
|
|
/* store time elapsed since last peak */
|
|
inst->peakPeriodSamp[inst->peakIndex] = inst->peakIatCountSamp;
|
|
|
|
/* saturate height to 16 bits */
|
|
inst->peakHeightPkt[inst->peakIndex]
|
|
=
|
|
(WebRtc_Word16) WEBRTC_SPL_MIN(timeIatPkts, WEBRTC_SPL_WORD16_MAX);
|
|
|
|
/* increment peakIndex and wrap/modulo */
|
|
inst->peakIndex = ++inst->peakIndex & PEAK_INDEX_MASK;
|
|
|
|
/* process peak vectors */
|
|
inst->curPeakHeight = 0;
|
|
inst->curPeakPeriod = 0;
|
|
|
|
for (i = 0; i < NUM_PEAKS; i++)
|
|
{
|
|
/* Find maximum of peak heights and peak periods */
|
|
inst->curPeakHeight
|
|
= WEBRTC_SPL_MAX(inst->curPeakHeight, inst->peakHeightPkt[i]);
|
|
inst->curPeakPeriod
|
|
= WEBRTC_SPL_MAX(inst->curPeakPeriod, inst->peakPeriodSamp[i]);
|
|
|
|
}
|
|
|
|
inst->peakModeDisabled >>= 1; /* decrease mode-disable "counter" */
|
|
|
|
}
|
|
else if (inst->peakIatCountSamp > (WebRtc_UWord32) WEBRTC_SPL_MUL_32_16(fsHz,
|
|
WEBRTC_SPL_LSHIFT_W16(MAX_PEAK_PERIOD, 1)))
|
|
{
|
|
/*
|
|
* More than 2 * MAX_PEAK_PERIOD has elapsed since last peak;
|
|
* too long time => reset peak statistics
|
|
*/
|
|
inst->curPeakHeight = 0;
|
|
inst->curPeakPeriod = 0;
|
|
for (i = 0; i < NUM_PEAKS; i++)
|
|
{
|
|
inst->peakHeightPkt[i] = 0;
|
|
inst->peakPeriodSamp[i] = 0;
|
|
}
|
|
|
|
inst->peakIndex = -1; /* Next peak is first peak */
|
|
inst->peakIatCountSamp = 0;
|
|
}
|
|
|
|
inst->peakIatCountSamp = 0; /* Reset peak interval timer */
|
|
} /* end if peak is observed */
|
|
|
|
/* Evaluate peak mode conditions */
|
|
|
|
/*
|
|
* If not disabled (enough peaks have been observed) and
|
|
* time since last peak is less than two peak periods.
|
|
*/
|
|
if ((!inst->peakModeDisabled) && (inst->peakIatCountSamp
|
|
<= WEBRTC_SPL_LSHIFT_W32(inst->curPeakPeriod , 1)))
|
|
{
|
|
/* Engage peak mode */
|
|
|
|
/* Set optimal buffer level to curPeakHeight (if it's not already larger) */
|
|
Bopt = WEBRTC_SPL_MAX(Bopt, inst->curPeakHeight);
|
|
|
|
#ifdef NETEQ_DELAY_LOGGING
|
|
/* special code for offline delay logging */
|
|
temp_var = (int) -(Bopt * inst->packetSpeechLenSamp);
|
|
#endif
|
|
}
|
|
|
|
/* Scale Bopt to Q8 */
|
|
Bopt = WEBRTC_SPL_LSHIFT_U16(Bopt,8);
|
|
|
|
#ifdef NETEQ_DELAY_LOGGING
|
|
/* special code for offline delay logging */
|
|
fwrite( &temp_var, sizeof(int), 1, delay_fid2 );
|
|
#endif
|
|
|
|
/* Sanity check: Bopt must be strictly positive */
|
|
if (Bopt <= 0)
|
|
{
|
|
Bopt = WEBRTC_SPL_LSHIFT_W16(1, 8); /* 1 in Q8 */
|
|
}
|
|
|
|
return Bopt; /* return value in Q8 */
|
|
}
|
|
|
|
|
|
int WebRtcNetEQ_BufferLevelFilter(WebRtc_Word32 curSizeMs8, AutomodeInst_t *inst,
|
|
int sampPerCall, WebRtc_Word16 fsMult)
|
|
{
|
|
|
|
WebRtc_Word16 curSizeFrames;
|
|
|
|
/****************/
|
|
/* Sanity check */
|
|
/****************/
|
|
|
|
if (sampPerCall <= 0 || fsMult <= 0)
|
|
{
|
|
/* sampPerCall and fsMult must both be strictly positive */
|
|
return -1;
|
|
}
|
|
|
|
/* Check if packet size has been detected */
|
|
if (inst->packetSpeechLenSamp > 0)
|
|
{
|
|
/*
|
|
* Current buffer level in packet lengths
|
|
* = (curSizeMs8 * fsMult) / packetSpeechLenSamp
|
|
*/
|
|
curSizeFrames = (WebRtc_Word16) WebRtcSpl_DivW32W16(
|
|
WEBRTC_SPL_MUL_32_16(curSizeMs8, fsMult), inst->packetSpeechLenSamp);
|
|
}
|
|
else
|
|
{
|
|
curSizeFrames = 0;
|
|
}
|
|
|
|
/* Filter buffer level */
|
|
if (inst->levelFiltFact > 0) /* check that filter factor is set */
|
|
{
|
|
/* Filter:
|
|
* buffLevelFilt = levelFiltFact * buffLevelFilt
|
|
* + (1-levelFiltFact) * curSizeFrames
|
|
*
|
|
* levelFiltFact is in Q8
|
|
*/
|
|
inst->buffLevelFilt = (WebRtc_UWord16) (WEBRTC_SPL_RSHIFT_W32(
|
|
WEBRTC_SPL_MUL_16_U16(inst->levelFiltFact, inst->buffLevelFilt), 8)
|
|
+ WEBRTC_SPL_MUL_16_16(256 - inst->levelFiltFact, curSizeFrames));
|
|
}
|
|
|
|
/* Account for time-scale operations (accelerate and pre-emptive expand) */
|
|
if (inst->prevTimeScale)
|
|
{
|
|
/*
|
|
* Time-scaling has been performed since last filter update.
|
|
* Subtract the sampleMemory from buffLevelFilt after converting sampleMemory
|
|
* from samples to packets in Q8. Make sure that the filtered value is
|
|
* non-negative.
|
|
*/
|
|
inst->buffLevelFilt = (WebRtc_UWord16) WEBRTC_SPL_MAX( inst->buffLevelFilt -
|
|
WebRtcSpl_DivW32W16(
|
|
WEBRTC_SPL_LSHIFT_W32(inst->sampleMemory, 8), /* sampleMemory in Q8 */
|
|
inst->packetSpeechLenSamp ), /* divide by packetSpeechLenSamp */
|
|
0);
|
|
|
|
/*
|
|
* Reset flag and set timescaleHoldOff timer to prevent further time-scaling
|
|
* for some time.
|
|
*/
|
|
inst->prevTimeScale = 0;
|
|
inst->timescaleHoldOff = AUTOMODE_TIMESCALE_LIMIT;
|
|
}
|
|
|
|
/* Update time counters and HoldOff timer */
|
|
inst->packetIatCountSamp += sampPerCall; /* packet inter-arrival time */
|
|
inst->peakIatCountSamp += sampPerCall; /* peak inter-arrival time */
|
|
inst->timescaleHoldOff >>= 1; /* time-scaling limiter */
|
|
inst->maxCSumUpdateTimer += sampPerCall; /* cumulative-sum timer */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
int WebRtcNetEQ_SetPacketSpeechLen(AutomodeInst_t *inst, WebRtc_Word16 newLenSamp,
|
|
WebRtc_Word32 fsHz)
|
|
{
|
|
|
|
/* Sanity check for newLenSamp and fsHz */
|
|
if (newLenSamp <= 0 || fsHz <= 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
inst->packetSpeechLenSamp = newLenSamp; /* Store packet size in instance */
|
|
|
|
/* Make NetEQ wait for first regular packet before starting the timer */
|
|
inst->lastPackCNGorDTMF = 1;
|
|
|
|
inst->packetIatCountSamp = 0; /* Reset packet time counter */
|
|
|
|
/*
|
|
* Calculate peak threshold from packet size. The threshold is defined as
|
|
* the (fractional) number of packets that corresponds to PEAK_HEIGHT
|
|
* (in Q8 seconds). That is, threshold = PEAK_HEIGHT/256 * fsHz / packLen.
|
|
*/
|
|
inst->peakThresholdPkt = (WebRtc_UWord16) WebRtcSpl_DivW32W16ResW16(
|
|
WEBRTC_SPL_MUL_16_16_RSFT(PEAK_HEIGHT,
|
|
(WebRtc_Word16) WEBRTC_SPL_RSHIFT_W32(fsHz, 6), 2), inst->packetSpeechLenSamp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int WebRtcNetEQ_ResetAutomode(AutomodeInst_t *inst, int maxBufLenPackets)
|
|
{
|
|
|
|
int i;
|
|
WebRtc_UWord16 tempprob = 0x4002; /* 16384 + 2 = 100000000000010 binary; */
|
|
|
|
/* Sanity check for maxBufLenPackets */
|
|
if (maxBufLenPackets <= 1)
|
|
{
|
|
/* Invalid value; set to 10 instead (arbitary small number) */
|
|
maxBufLenPackets = 10;
|
|
}
|
|
|
|
/* Reset filtered buffer level */
|
|
inst->buffLevelFilt = 0;
|
|
|
|
/* Reset packet size to unknown */
|
|
inst->packetSpeechLenSamp = 0;
|
|
|
|
/*
|
|
* Flag that last packet was special payload, so that automode will treat the next speech
|
|
* payload as the first payload received.
|
|
*/
|
|
inst->lastPackCNGorDTMF = 1;
|
|
|
|
/* Reset peak detection parameters */
|
|
inst->peakModeDisabled = 1; /* disable peak mode */
|
|
inst->peakIatCountSamp = 0;
|
|
inst->peakIndex = -1; /* indicates that no peak is registered */
|
|
inst->curPeakHeight = 0;
|
|
inst->curPeakPeriod = 0;
|
|
for (i = 0; i < NUM_PEAKS; i++)
|
|
{
|
|
inst->peakHeightPkt[i] = 0;
|
|
inst->peakPeriodSamp[i] = 0;
|
|
}
|
|
|
|
/*
|
|
* Set the iatProb PDF vector to an exponentially decaying distribution
|
|
* iatProb[i] = 0.5^(i+1), i = 0, 1, 2, ...
|
|
* iatProb is in Q30.
|
|
*/
|
|
for (i = 0; i <= MAX_IAT; i++)
|
|
{
|
|
/* iatProb[i] = 0.5^(i+1) = iatProb[i-1] / 2 */
|
|
tempprob = WEBRTC_SPL_RSHIFT_U16(tempprob, 1);
|
|
/* store in PDF vector */
|
|
inst->iatProb[i] = WEBRTC_SPL_LSHIFT_W32((WebRtc_Word32) tempprob, 16);
|
|
}
|
|
|
|
/*
|
|
* Calculate the optimal buffer level corresponing to the initial PDF.
|
|
* No need to call WebRtcNetEQ_CalcOptimalBufLvl() since we have just hard-coded
|
|
* all the variables that the buffer level depends on => we know the result
|
|
*/
|
|
inst->optBufLevel = WEBRTC_SPL_MIN(4,
|
|
(maxBufLenPackets >> 1) + (maxBufLenPackets >> 1)); /* 75% of maxBufLenPackets */
|
|
inst->levelFiltFact = 253;
|
|
|
|
/*
|
|
* Reset the iat update forgetting factor to 0 to make the impact of the first
|
|
* incoming packets greater.
|
|
*/
|
|
inst->iatProbFact = 0;
|
|
|
|
/* Reset packet inter-arrival time counter */
|
|
inst->packetIatCountSamp = 0;
|
|
|
|
/* Clear time-scaling related variables */
|
|
inst->prevTimeScale = 0;
|
|
inst->timescaleHoldOff = AUTOMODE_TIMESCALE_LIMIT; /* don't allow time-scaling immediately */
|
|
|
|
inst->cSumIatQ8 = 0;
|
|
inst->maxCSumIatQ8 = 0;
|
|
|
|
return 0;
|
|
}
|
|
|