generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Delay estimator improvements.

Browse Source 
Robustness improvements to the delay estimator used in AECM and AEC. In AEC only for logging. Faster convergence.

TEST=audioproc_unittest + offline file tests.

output_data_fixed.pb updated despite unverified changes in r1112.
Review URL: http://webrtc-codereview.appspot.com/337006

git-svn-id: http://webrtc.googlecode.com/svn/trunk@1306 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
bjornv@webrtc.org 2011-12-29 14:51:21 +00:00
parent efd0a48c61
commit 70adcd46b2
8 changed files with 297 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/modules/audio_processing/aec/aec_core.c
View File

@ -751,8 +751,7 @@ static void ProcessBlock(aec_t* aec) {
delay_estimate = WebRtc_DelayEstimatorProcessFloat(aec->delay_estimator, delay_estimate = WebRtc_DelayEstimatorProcessFloat(aec->delay_estimator,
abs_far_spectrum, abs_far_spectrum,
abs_near_spectrum, abs_near_spectrum,
PART_LEN1, PART_LEN1);
aec->echoState);
if (delay_estimate >= 0) { if (delay_estimate >= 0) {
// Update delay estimate buffer. // Update delay estimate buffer.
aec->delay_histogram[delay_estimate]++; aec->delay_histogram[delay_estimate]++;

2
src/modules/audio_processing/aecm/aecm_core.c
View File

@ -1612,7 +1612,7 @@ int WebRtcAecm_ProcessBlock(AecmCore_t * aecm,
dfaNoisy, dfaNoisy,
PART_LEN1, PART_LEN1,
far_q, far_q,
aecm->currentVADValue); zerosDBufNoisy);
if (delay == -1) if (delay == -1)
{ {
return -1; return -1;

217
src/modules/audio_processing/utility/delay_estimator.c
View File

@ -14,7 +14,25 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "signal_processing_library.h" // Number of right shifts for scaling is linearly depending on number of bits in
// the far-end binary spectrum.
static const int kShiftsAtZero = 13; // Right shifts at zero binary spectrum.
static const int kShiftsLinearSlope = 3;
static const int32_t kProbabilityOffset = 1024; // 2 in Q9.
static const int32_t kProbabilityLowerLimit = 8704; // 17 in Q9.
static const int32_t kProbabilityMinSpread = 2816; // 5.5 in Q9.
// Counts and returns number of bits of a 32-bit word.
static int BitCount(uint32_t u32) {
uint32_t tmp = u32 - ((u32 >> 1) & 033333333333) -
((u32 >> 2) & 011111111111);
tmp = ((tmp + (tmp >> 3)) & 030707070707);
tmp = (tmp + (tmp >> 6));
tmp = (tmp + (tmp >> 12) + (tmp >> 24)) & 077;
return ((int) tmp);
}
// Compares the |binary_vector| with all rows of the |binary_matrix| and counts // Compares the |binary_vector| with all rows of the |binary_matrix| and counts
// per row the number of times they have the same value. // per row the number of times they have the same value.
@ -34,23 +52,14 @@ static void BitCountComparison(uint32_t binary_vector,
int matrix_size, int matrix_size,
int32_t* bit_counts) { int32_t* bit_counts) {
int n = 0; int n = 0;
uint32_t a = binary_vector;
register uint32_t tmp;
// compare |binary_vector| with all rows of the |binary_matrix| // Compare |binary_vector| with all rows of the |binary_matrix|
for (; n < matrix_size; n++) { for (; n < matrix_size; n++) {
a = (binary_vector ^ binary_matrix[n]); bit_counts[n] = (int32_t) BitCount(binary_vector ^ binary_matrix[n]);
// Returns bit counts in tmp
tmp = a - ((a >> 1) & 033333333333) - ((a >> 2) & 011111111111);
tmp = ((tmp + (tmp >> 3)) & 030707070707);
tmp = (tmp + (tmp >> 6));
tmp = (tmp + (tmp >> 12) + (tmp >> 24)) & 077;
bit_counts[n] = (int32_t) tmp;
} }
} }
int WebRtc_FreeBinaryDelayEstimator(BinaryDelayEstimator_t* handle) { int WebRtc_FreeBinaryDelayEstimator(BinaryDelayEstimator* handle) {
assert(handle != NULL); assert(handle != NULL);
if (handle->mean_bit_counts != NULL) { if (handle->mean_bit_counts != NULL) {
@ -69,9 +78,9 @@ int WebRtc_FreeBinaryDelayEstimator(BinaryDelayEstimator_t* handle) {
free(handle->binary_near_history); free(handle->binary_near_history);
handle->binary_near_history = NULL; handle->binary_near_history = NULL;
} }
if (handle->delay_histogram != NULL) { if (handle->far_bit_counts != NULL) {
free(handle->delay_histogram); free(handle->far_bit_counts);
handle->delay_histogram = NULL; handle->far_bit_counts = NULL;
} }
free(handle); free(handle);
@ -79,10 +88,10 @@ int WebRtc_FreeBinaryDelayEstimator(BinaryDelayEstimator_t* handle) {
return 0; return 0;
} }
int WebRtc_CreateBinaryDelayEstimator(BinaryDelayEstimator_t** handle, int WebRtc_CreateBinaryDelayEstimator(BinaryDelayEstimator** handle,
int max_delay, int max_delay,
int lookahead) { int lookahead) {
BinaryDelayEstimator_t* self = NULL; BinaryDelayEstimator* self = NULL;
int history_size = max_delay + lookahead; int history_size = max_delay + lookahead;
if (handle == NULL) { if (handle == NULL) {
@ -99,7 +108,7 @@ int WebRtc_CreateBinaryDelayEstimator(BinaryDelayEstimator_t** handle,
return -1; return -1;
} }
self = malloc(sizeof(BinaryDelayEstimator_t)); self = malloc(sizeof(BinaryDelayEstimator));
*handle = self; *handle = self;
if (self == NULL) { if (self == NULL) {
return -1; return -1;
@ -108,12 +117,12 @@ int WebRtc_CreateBinaryDelayEstimator(BinaryDelayEstimator_t** handle,
self->mean_bit_counts = NULL; self->mean_bit_counts = NULL;
self->bit_counts = NULL; self->bit_counts = NULL;
self->binary_far_history = NULL; self->binary_far_history = NULL;
self->delay_histogram = NULL; self->far_bit_counts = NULL;
self->history_size = history_size; self->history_size = history_size;
self->near_history_size = lookahead + 1; self->near_history_size = lookahead + 1;
// Allocate memory for spectrum buffers // Allocate memory for spectrum buffers.
self->mean_bit_counts = malloc(history_size * sizeof(int32_t)); self->mean_bit_counts = malloc(history_size * sizeof(int32_t));
if (self->mean_bit_counts == NULL) { if (self->mean_bit_counts == NULL) {
WebRtc_FreeBinaryDelayEstimator(self); WebRtc_FreeBinaryDelayEstimator(self);
@ -126,7 +135,7 @@ int WebRtc_CreateBinaryDelayEstimator(BinaryDelayEstimator_t** handle,
self = NULL; self = NULL;
return -1; return -1;
} }
// Allocate memory for history buffers // Allocate memory for history buffers.
self->binary_far_history = malloc(history_size * sizeof(uint32_t)); self->binary_far_history = malloc(history_size * sizeof(uint32_t));
if (self->binary_far_history == NULL) { if (self->binary_far_history == NULL) {
WebRtc_FreeBinaryDelayEstimator(self); WebRtc_FreeBinaryDelayEstimator(self);
@ -140,8 +149,8 @@ int WebRtc_CreateBinaryDelayEstimator(BinaryDelayEstimator_t** handle,
self = NULL; self = NULL;
return -1; return -1;
} }
self->delay_histogram = malloc(history_size * sizeof(int)); self->far_bit_counts = malloc(history_size * sizeof(int));
if (self->delay_histogram == NULL) { if (self->far_bit_counts == NULL) {
WebRtc_FreeBinaryDelayEstimator(self); WebRtc_FreeBinaryDelayEstimator(self);
self = NULL; self = NULL;
return -1; return -1;
@ -150,48 +159,52 @@ int WebRtc_CreateBinaryDelayEstimator(BinaryDelayEstimator_t** handle,
return 0; return 0;
} }
int WebRtc_InitBinaryDelayEstimator(BinaryDelayEstimator_t* handle) { int WebRtc_InitBinaryDelayEstimator(BinaryDelayEstimator* handle) {
int i = 0;
assert(handle != NULL); assert(handle != NULL);
memset(handle->mean_bit_counts, 0, sizeof(int32_t) * handle->history_size);
memset(handle->bit_counts, 0, sizeof(int32_t) * handle->history_size); memset(handle->bit_counts, 0, sizeof(int32_t) * handle->history_size);
memset(handle->binary_far_history, 0, memset(handle->binary_far_history, 0,
sizeof(uint32_t) * handle->history_size); sizeof(uint32_t) * handle->history_size);
memset(handle->binary_near_history, 0, memset(handle->binary_near_history, 0,
sizeof(uint32_t) * handle->near_history_size); sizeof(uint32_t) * handle->near_history_size);
memset(handle->delay_histogram, 0, sizeof(int) * handle->history_size); memset(handle->far_bit_counts, 0, sizeof(int) * handle->history_size);
for (i = 0; i < handle->history_size; ++i) {
handle->mean_bit_counts[i] = (20 << 9); // 20 in Q9.
}
handle->minimum_probability = (32 << 9); // 32 in Q9.
handle->last_delay_probability = (32 << 9); // 32 in Q9.
handle->vad_counter = 0; // Default return value if we're unable to estimate. -1 is used for errors.
// Default value to return if we're unable to estimate. -1 is used for
// errors.
handle->last_delay = -2; handle->last_delay = -2;
return 0; return 0;
} }
int WebRtc_ProcessBinarySpectrum(BinaryDelayEstimator_t* handle, int WebRtc_ProcessBinarySpectrum(BinaryDelayEstimator* handle,
uint32_t binary_far_spectrum, uint32_t binary_far_spectrum,
uint32_t binary_near_spectrum, uint32_t binary_near_spectrum) {
int vad_value) {
const int kVadCountThreshold = 25;
const int kMaxHistogram = 600;
int histogram_bin = 0;
int i = 0; int i = 0;
int max_histogram_level = 0; int candidate_delay = -1;
int min_position = -1;
int32_t bit_counts_tmp = 0; int32_t value_best_candidate = 16384; // 32 in Q9, (max |mean_bit_counts|).
int32_t value_worst_candidate = 0;
assert(handle != NULL); assert(handle != NULL);
// Shift binary spectrum history // Shift binary spectrum history and insert current |binary_far_spectrum|.
memmove(&(handle->binary_far_history[1]), &(handle->binary_far_history[0]), memmove(&(handle->binary_far_history[1]), &(handle->binary_far_history[0]),
(handle->history_size - 1) * sizeof(uint32_t)); (handle->history_size - 1) * sizeof(uint32_t));
// Insert new binary spectrum
handle->binary_far_history[0] = binary_far_spectrum; handle->binary_far_history[0] = binary_far_spectrum;
// Shift history of far-end binary spectrum bit counts and insert bit count
// of current |binary_far_spectrum|.
memmove(&(handle->far_bit_counts[1]), &(handle->far_bit_counts[0]),
(handle->history_size - 1) * sizeof(int));
handle->far_bit_counts[0] = BitCount(binary_far_spectrum);
if (handle->near_history_size > 1) { if (handle->near_history_size > 1) {
// If we apply lookahead, shift near-end binary spectrum history. Insert
// current |binary_near_spectrum| and pull out the delayed one.
memmove(&(handle->binary_near_history[1]), memmove(&(handle->binary_near_history[1]),
&(handle->binary_near_history[0]), &(handle->binary_near_history[0]),
(handle->near_history_size - 1) * sizeof(uint32_t)); (handle->near_history_size - 1) * sizeof(uint32_t));
@ -200,66 +213,93 @@ int WebRtc_ProcessBinarySpectrum(BinaryDelayEstimator_t* handle,
handle->binary_near_history[handle->near_history_size - 1]; handle->binary_near_history[handle->near_history_size - 1];
} }
// Compare with delayed spectra // Compare with delayed spectra and store the |bit_counts| for each delay.
BitCountComparison(binary_near_spectrum, BitCountComparison(binary_near_spectrum,
handle->binary_far_history, handle->binary_far_history,
handle->history_size, handle->history_size,
handle->bit_counts); handle->bit_counts);
// Smooth bit count curve // Update |mean_bit_counts|, which is the smoothed version of |bit_counts|.
for (i = 0; i < handle->history_size; i++) { for (i = 0; i < handle->history_size; i++) {
// Update sum
// |bit_counts| is constrained to [0, 32], meaning we can smooth with a // |bit_counts| is constrained to [0, 32], meaning we can smooth with a
// factor up to 2^26. We use Q9. // factor up to 2^26. We use Q9.
bit_counts_tmp = WEBRTC_SPL_LSHIFT_W32(handle->bit_counts[i], 9); // Q9 int32_t bit_count = (handle->bit_counts[i] << 9); // Q9.
WebRtc_MeanEstimatorFix(bit_counts_tmp, 9, &(handle->mean_bit_counts[i]));
// Update |mean_bit_counts| only when far-end signal has something to
// contribute. If |far_bit_counts| is zero the far-end signal is weak and
// we likely have a poor echo condition, hence don't update.
if (handle->far_bit_counts[i] > 0) {
// Make number of right shifts piecewise linear w.r.t. |far_bit_counts|.
int shifts = kShiftsAtZero;
shifts -= (kShiftsLinearSlope * handle->far_bit_counts[i]) >> 4;
WebRtc_MeanEstimatorFix(bit_count, shifts, &(handle->mean_bit_counts[i]));
}
} }
// Find minimum position of bit count curve // Find |candidate_delay|, |value_best_candidate| and |value_worst_candidate|
min_position = (int) WebRtcSpl_MinIndexW32(handle->mean_bit_counts, // of |mean_bit_counts|.
(int16_t) handle->history_size); for (i = 0; i < handle->history_size; i++) {
if (handle->mean_bit_counts[i] < value_best_candidate) {
// If the far end has been active sufficiently long, begin accumulating a value_best_candidate = handle->mean_bit_counts[i];
// histogram of the minimum positions. Search for the maximum bin to candidate_delay = i;
// determine the delay. }
if (vad_value == 1) { if (handle->mean_bit_counts[i] > value_worst_candidate) {
if (handle->vad_counter >= kVadCountThreshold) { value_worst_candidate = handle->mean_bit_counts[i];
// Increment the histogram at the current minimum position. }
if (handle->delay_histogram[min_position] < kMaxHistogram) { }
handle->delay_histogram[min_position] += 3;
} // The |value_best_candidate| is a good indicator on the probability of
// |candidate_delay| being an accurate delay (a small |value_best_candidate|
for (i = 0; i < handle->history_size; i++) { // means a good binary match). In the following sections we make a decision
histogram_bin = handle->delay_histogram[i]; // whether to update |last_delay| or not.
// 1) If the difference bit counts between the best and the worst delay
// Decrement the histogram bin. // candidates is too small we consider the situation to be unreliable and
if (histogram_bin > 0) { // don't update |last_delay|.
histogram_bin--; // 2) If the situation is reliable we update |last_delay| if the value of the
handle->delay_histogram[i] = histogram_bin; // best candidate delay has a value less than
// Select the histogram index corresponding to the maximum bin as the // i) an adaptive threshold |minimum_probability|, or
// delay. // ii) this corresponding value |last_delay_probability|, but updated at
if (histogram_bin > max_histogram_level) { // this time instant.
max_histogram_level = histogram_bin;
handle->last_delay = i; // Update |minimum_probability|.
} if ((handle->minimum_probability > kProbabilityLowerLimit) &&
} (value_worst_candidate - value_best_candidate > kProbabilityMinSpread)) {
} // The "hard" threshold can't be lower than 17 (in Q9).
} else { // The valley in the curve also has to be distinct, i.e., the
handle->vad_counter++; // difference between |value_worst_candidate| and |value_best_candidate| has
// to be large enough.
int32_t threshold = value_best_candidate + kProbabilityOffset;
if (threshold < kProbabilityLowerLimit) {
threshold = kProbabilityLowerLimit;
}
if (handle->minimum_probability > threshold) {
handle->minimum_probability = threshold;
}
}
// Update |last_delay_probability|.
// We use a Markov type model, i.e., a slowly increasing level over time.
handle->last_delay_probability++;
if (value_worst_candidate > value_best_candidate + kProbabilityOffset) {
// Reliable delay value for usage.
if (value_best_candidate < handle->minimum_probability) {
handle->last_delay = candidate_delay;
}
if (value_best_candidate < handle->last_delay_probability) {
handle->last_delay = candidate_delay;
// Reset |last_delay_probability|.
handle->last_delay_probability = value_best_candidate;
} }
} else {
handle->vad_counter = 0;
} }
return handle->last_delay; return handle->last_delay;
} }
int WebRtc_binary_last_delay(BinaryDelayEstimator_t* handle) { int WebRtc_binary_last_delay(BinaryDelayEstimator* handle) {
assert(handle != NULL); assert(handle != NULL);
return handle->last_delay; return handle->last_delay;
} }
int WebRtc_history_size(BinaryDelayEstimator_t* handle) { int WebRtc_history_size(BinaryDelayEstimator* handle) {
assert(handle != NULL); assert(handle != NULL);
return handle->history_size; return handle->history_size;
} }
@ -267,16 +307,13 @@ int WebRtc_history_size(BinaryDelayEstimator_t* handle) {
void WebRtc_MeanEstimatorFix(int32_t new_value, void WebRtc_MeanEstimatorFix(int32_t new_value,
int factor, int factor,
int32_t* mean_value) { int32_t* mean_value) {
int32_t mean_new = *mean_value; int32_t diff = new_value - *mean_value;
int32_t diff = new_value - mean_new;
// mean_new = mean_value + ((new_value - mean_value) >> factor); // mean_new = mean_value + ((new_value - mean_value) >> factor);
if (diff < 0) { if (diff < 0) {
diff = -WEBRTC_SPL_RSHIFT_W32(-diff, factor); diff = -((-diff) >> factor);
} else { } else {
diff = WEBRTC_SPL_RSHIFT_W32(diff, factor); diff = (diff >> factor);
} }
mean_new += diff; *mean_value += diff;
*mean_value = mean_new;
} }

62
src/modules/audio_processing/utility/delay_estimator.h
View File

@ -14,12 +14,12 @@
#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_H_ #ifndef WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_H_
#define WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_H_ #define WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_H_
#include "signal_processing_library.h"
#include "typedefs.h" #include "typedefs.h"
typedef struct { typedef struct {
// Pointer to bit counts // Pointer to bit counts.
int32_t* mean_bit_counts; int32_t* mean_bit_counts;
int* far_bit_counts;
// Array only used locally in ProcessBinarySpectrum() but whose size is // Array only used locally in ProcessBinarySpectrum() but whose size is
// determined at run-time. // determined at run-time.
@ -29,9 +29,9 @@ typedef struct {
uint32_t* binary_far_history; uint32_t* binary_far_history;
uint32_t* binary_near_history; uint32_t* binary_near_history;
// Delay histogram variables. // Delay estimation variables.
int* delay_histogram; int32_t minimum_probability;
int vad_counter; int last_delay_probability;
// Delay memory. // Delay memory.
int last_delay; int last_delay;
@ -41,75 +41,73 @@ typedef struct {
// Near-end buffer size. // Near-end buffer size.
int near_history_size; int near_history_size;
} BinaryDelayEstimator_t; } BinaryDelayEstimator;
// Releases the memory allocated by WebRtc_CreateBinaryDelayEstimator(...) // Releases the memory allocated by WebRtc_CreateBinaryDelayEstimator(...).
// Input: // Input:
// - handle : Pointer to the delay estimation instance // - handle : Pointer to the delay estimation instance.
// //
int WebRtc_FreeBinaryDelayEstimator(BinaryDelayEstimator_t* handle); int WebRtc_FreeBinaryDelayEstimator(BinaryDelayEstimator* handle);
// Refer to WebRtc_CreateDelayEstimator() in delay_estimator_wrapper.h // Refer to WebRtc_CreateDelayEstimator() in delay_estimator_wrapper.h.
int WebRtc_CreateBinaryDelayEstimator(BinaryDelayEstimator_t** handle, int WebRtc_CreateBinaryDelayEstimator(BinaryDelayEstimator** handle,
int max_delay, int max_delay,
int lookahead); int lookahead);
// Initializes the delay estimation instance created with // Initializes the delay estimation instance created with
// WebRtc_CreateBinaryDelayEstimator(...) // WebRtc_CreateBinaryDelayEstimator(...).
// Input: // Input:
// - handle : Pointer to the delay estimation instance // - handle : Pointer to the delay estimation instance.
// //
// Output: // Output:
// - handle : Initialized instance // - handle : Initialized instance.
// //
int WebRtc_InitBinaryDelayEstimator(BinaryDelayEstimator_t* handle); int WebRtc_InitBinaryDelayEstimator(BinaryDelayEstimator* handle);
// Estimates and returns the delay between the binary far-end and binary near- // Estimates and returns the delay between the binary far-end and binary near-
// end spectra. The value will be offset by the lookahead (i.e. the lookahead // end spectra. The value will be offset by the lookahead (i.e. the lookahead
// should be subtracted from the returned value). // should be subtracted from the returned value).
// Inputs: // Inputs:
// - handle : Pointer to the delay estimation instance // - handle : Pointer to the delay estimation instance.
// - binary_far_spectrum : Far-end binary spectrum // - binary_far_spectrum : Far-end binary spectrum.
// - binary_near_spectrum : Near-end binary spectrum of the current block // - binary_near_spectrum : Near-end binary spectrum of the current block.
// - vad_value : The VAD decision of the current block
// //
// Output: // Output:
// - handle : Updated instance // - handle : Updated instance.
// //
// Return value: // Return value:
// - delay : >= 0 - Calculated delay value // - delay : >= 0 - Calculated delay value.
// -1 - Error // -1 - Error.
// -2 - Insufficient data for estimation. // -2 - Insufficient data for estimation.
// //
int WebRtc_ProcessBinarySpectrum(BinaryDelayEstimator_t* handle, int WebRtc_ProcessBinarySpectrum(BinaryDelayEstimator* handle,
uint32_t binary_far_spectrum, uint32_t binary_far_spectrum,
uint32_t binary_near_spectrum, uint32_t binary_near_spectrum);
int vad_value);
// Returns the last calculated delay updated by the function // Returns the last calculated delay updated by the function
// WebRtc_ProcessBinarySpectrum(...) // WebRtc_ProcessBinarySpectrum(...).
// //
// Input: // Input:
// - handle : Pointer to the delay estimation instance // - handle : Pointer to the delay estimation instance.
// //
// Return value: // Return value:
// - delay : >= 0 - Last calculated delay value // - delay : >= 0 - Last calculated delay value
// -1 - Error // -1 - Error
// -2 - Insufficient data for estimation. // -2 - Insufficient data for estimation.
// //
int WebRtc_binary_last_delay(BinaryDelayEstimator_t* handle); int WebRtc_binary_last_delay(BinaryDelayEstimator* handle);
// Returns the history size used in the far-end buffers to calculate the delay // Returns the history size used in the far-end buffers to calculate the delay
// over. // over.
// //
// Input: // Input:
// - handle : Pointer to the delay estimation instance // - handle : Pointer to the delay estimation instance.
// //
// Return value: // Return value:
// - history_size : > 0 - Far-end history size // - history_size : > 0 - Far-end history size.
// -1 - Error // -1 - Error.
// //
int WebRtc_history_size(BinaryDelayEstimator_t* handle); int WebRtc_history_size(BinaryDelayEstimator* handle);
// Updates the |mean_value| recursively with a step size of 2^-|factor|. This // Updates the |mean_value| recursively with a step size of 2^-|factor|. This
// function is used internally in the Binary Delay Estimator as well as the // function is used internally in the Binary Delay Estimator as well as the

182
src/modules/audio_processing/utility/delay_estimator_wrapper.c
View File

@ -15,32 +15,33 @@
#include <string.h> #include <string.h>
#include "delay_estimator.h" #include "delay_estimator.h"
#include "signal_processing_library.h"
typedef union { typedef union {
float float_; float float_;
int32_t int32_; int32_t int32_;
} SpectrumType_t; } SpectrumType;
typedef struct { typedef struct {
// Pointers to mean values of spectrum // Pointers to mean values of spectrum.
SpectrumType_t* mean_far_spectrum; SpectrumType* mean_far_spectrum;
SpectrumType_t* mean_near_spectrum; SpectrumType* mean_near_spectrum;
// |mean_*_spectrum| initialization indicator.
int far_spectrum_initialized;
int near_spectrum_initialized;
// Spectrum size
int spectrum_size; int spectrum_size;
// Binary spectrum based delay estimator // Binary spectrum based delay estimator
BinaryDelayEstimator_t* binary_handle; BinaryDelayEstimator* binary_handle;
} DelayEstimator_t; } DelayEstimator;
// Only bit |kBandFirst| through bit |kBandLast| are processed // Only bit |kBandFirst| through bit |kBandLast| are processed and
// |kBandFirst| - |kBandLast| must be < 32 // |kBandFirst| - |kBandLast| must be < 32.
static const int kBandFirst = 12; static const int kBandFirst = 12;
static const int kBandLast = 43; static const int kBandLast = 43;
static __inline uint32_t SetBit(uint32_t in, int pos) { static __inline uint32_t SetBit(uint32_t in, int pos) {
uint32_t mask = WEBRTC_SPL_LSHIFT_W32(1, pos); uint32_t mask = (1 << pos);
uint32_t out = (in | mask); uint32_t out = (in | mask);
return out; return out;
@ -50,17 +51,16 @@ static __inline uint32_t SetBit(uint32_t in, int pos) {
// but for float. // but for float.
// //
// Inputs: // Inputs:
// - new_value : new additional value. // - new_value : New additional value.
// - scale : scale for smoothing (should be less than 1.0). // - scale : Scale for smoothing (should be less than 1.0).
// //
// Input/Output: // Input/Output:
// - mean_value : pointer to the mean value for updating. // - mean_value : Pointer to the mean value for updating.
// //
static void MeanEstimatorFloat(float new_value, static void MeanEstimatorFloat(float new_value,
float scale, float scale,
float* mean_value) { float* mean_value) {
assert(scale < 1.0f); assert(scale < 1.0f);
// mean_new = mean_value + ((new_value - mean_value) * scale);
*mean_value += (new_value - *mean_value) * scale; *mean_value += (new_value - *mean_value) * scale;
} }
@ -73,19 +73,37 @@ static void MeanEstimatorFloat(float new_value,
// - threshold_spectrum : Threshold spectrum with which the input // - threshold_spectrum : Threshold spectrum with which the input
// spectrum is compared. // spectrum is compared.
// Return: // Return:
// - out : Binary spectrum // - out : Binary spectrum.
// //
static uint32_t BinarySpectrumFix(uint16_t* spectrum, static uint32_t BinarySpectrumFix(uint16_t* spectrum,
SpectrumType_t* threshold_spectrum) { SpectrumType* threshold_spectrum,
int k = kBandFirst; int q_domain,
int* threshold_initialized) {
int i = kBandFirst;
uint32_t out = 0; uint32_t out = 0;
for (; k <= kBandLast; k++) { assert(q_domain < 16);
WebRtc_MeanEstimatorFix((int32_t) spectrum[k],
6, if (!(*threshold_initialized)) {
&(threshold_spectrum[k].int32_)); // Set the |threshold_spectrum| to half the input |spectrum| as starting
if (spectrum[k] > threshold_spectrum[k].int32_) { // value. This speeds up the convergence.
out = SetBit(out, k - kBandFirst); for (i = kBandFirst; i <= kBandLast; i++) {
if (spectrum[i] > 0) {
// Convert input spectrum from Q(|q_domain|) to Q15.
int32_t spectrum_q15 = ((int32_t) spectrum[i]) << (15 - q_domain);
threshold_spectrum[i].int32_ = (spectrum_q15 >> 1);
*threshold_initialized = 1;
}
}
}
for (i = kBandFirst; i <= kBandLast; i++) {
// Convert input spectrum from Q(|q_domain|) to Q15.
int32_t spectrum_q15 = ((int32_t) spectrum[i]) << (15 - q_domain);
// Update the |threshold_spectrum|.
WebRtc_MeanEstimatorFix(spectrum_q15, 6, &(threshold_spectrum[i].int32_));
// Convert |spectrum| at current frequency bin to a binary value.
if (spectrum_q15 > threshold_spectrum[i].int32_) {
out = SetBit(out, i - kBandFirst);
} }
} }
@ -93,15 +111,29 @@ static uint32_t BinarySpectrumFix(uint16_t* spectrum,
} }
static uint32_t BinarySpectrumFloat(float* spectrum, static uint32_t BinarySpectrumFloat(float* spectrum,
SpectrumType_t* threshold_spectrum) { SpectrumType* threshold_spectrum,
int k = kBandFirst; int* threshold_initialized) {
int i = kBandFirst;
uint32_t out = 0; uint32_t out = 0;
float scale = 1 / 64.0; const float kScale = 1 / 64.0;
for (; k <= kBandLast; k++) { if (!(*threshold_initialized)) {
MeanEstimatorFloat(spectrum[k], scale, &(threshold_spectrum[k].float_)); // Set the |threshold_spectrum| to half the input |spectrum| as starting
if (spectrum[k] > threshold_spectrum[k].float_) { // value. This speeds up the convergence.
out = SetBit(out, k - kBandFirst); for (i = kBandFirst; i <= kBandLast; i++) {
if (spectrum[i] > 0.0f) {
threshold_spectrum[i].float_ = (spectrum[i] / 2);
*threshold_initialized = 1;
}
}
}
for (i = kBandFirst; i <= kBandLast; i++) {
// Update the |threshold_spectrum|.
MeanEstimatorFloat(spectrum[i], kScale, &(threshold_spectrum[i].float_));
// Convert |spectrum| at current frequency bin to a binary value.
if (spectrum[i] > threshold_spectrum[i].float_) {
out = SetBit(out, i - kBandFirst);
} }
} }
@ -109,7 +141,7 @@ static uint32_t BinarySpectrumFloat(float* spectrum,
} }
int WebRtc_FreeDelayEstimator(void* handle) { int WebRtc_FreeDelayEstimator(void* handle) {
DelayEstimator_t* self = (DelayEstimator_t*) handle; DelayEstimator* self = (DelayEstimator*) handle;
if (self == NULL) { if (self == NULL) {
return -1; return -1;
@ -135,10 +167,10 @@ int WebRtc_CreateDelayEstimator(void** handle,
int spectrum_size, int spectrum_size,
int max_delay, int max_delay,
int lookahead) { int lookahead) {
DelayEstimator_t *self = NULL; DelayEstimator* self = NULL;
// Check if the sub band used in the delay estimation is small enough to // Check if the sub band used in the delay estimation is small enough to fit
// fit the binary spectra in a uint32. // the binary spectra in a uint32_t.
assert(kBandLast - kBandFirst < 32); assert(kBandLast - kBandFirst < 32);
if (handle == NULL) { if (handle == NULL) {
@ -148,7 +180,7 @@ int WebRtc_CreateDelayEstimator(void** handle,
return -1; return -1;
} }
self = malloc(sizeof(DelayEstimator_t)); self = malloc(sizeof(DelayEstimator));
*handle = self; *handle = self;
if (self == NULL) { if (self == NULL) {
return -1; return -1;
@ -165,14 +197,14 @@ int WebRtc_CreateDelayEstimator(void** handle,
self = NULL; self = NULL;
return -1; return -1;
} }
// Allocate memory for spectrum buffers // Allocate memory for spectrum buffers.
self->mean_far_spectrum = malloc(spectrum_size * sizeof(SpectrumType_t)); self->mean_far_spectrum = malloc(spectrum_size * sizeof(SpectrumType));
if (self->mean_far_spectrum == NULL) { if (self->mean_far_spectrum == NULL) {
WebRtc_FreeDelayEstimator(self); WebRtc_FreeDelayEstimator(self);
self = NULL; self = NULL;
return -1; return -1;
} }
self->mean_near_spectrum = malloc(spectrum_size * sizeof(SpectrumType_t)); self->mean_near_spectrum = malloc(spectrum_size * sizeof(SpectrumType));
if (self->mean_near_spectrum == NULL) { if (self->mean_near_spectrum == NULL) {
WebRtc_FreeDelayEstimator(self); WebRtc_FreeDelayEstimator(self);
self = NULL; self = NULL;
@ -185,23 +217,24 @@ int WebRtc_CreateDelayEstimator(void** handle,
} }
int WebRtc_InitDelayEstimator(void* handle) { int WebRtc_InitDelayEstimator(void* handle) {
DelayEstimator_t* self = (DelayEstimator_t*) handle; DelayEstimator* self = (DelayEstimator*) handle;
if (self == NULL) { if (self == NULL) {
return -1; return -1;
} }
// Initialize binary delay estimator // Initialize binary delay estimator.
if (WebRtc_InitBinaryDelayEstimator(self->binary_handle) != 0) { if (WebRtc_InitBinaryDelayEstimator(self->binary_handle) != 0) {
return -1; return -1;
} }
// Set averaged far and near end spectra to zero // Set averaged far and near end spectra to zero.
memset(self->mean_far_spectrum, memset(self->mean_far_spectrum, 0,
0, sizeof(SpectrumType) * self->spectrum_size);
sizeof(SpectrumType_t) * self->spectrum_size); memset(self->mean_near_spectrum, 0,
memset(self->mean_near_spectrum, sizeof(SpectrumType) * self->spectrum_size);
0, // Reset initialization indicators.
sizeof(SpectrumType_t) * self->spectrum_size); self->far_spectrum_initialized = 0;
self->near_spectrum_initialized = 0;
return 0; return 0;
} }
@ -211,8 +244,8 @@ int WebRtc_DelayEstimatorProcessFix(void* handle,
uint16_t* near_spectrum, uint16_t* near_spectrum,
int spectrum_size, int spectrum_size,
int far_q, int far_q,
int vad_value) { int near_q) {
DelayEstimator_t* self = (DelayEstimator_t*) handle; DelayEstimator* self = (DelayEstimator*) handle;
uint32_t binary_far_spectrum = 0; uint32_t binary_far_spectrum = 0;
uint32_t binary_near_spectrum = 0; uint32_t binary_near_spectrum = 0;
@ -220,40 +253,46 @@ int WebRtc_DelayEstimatorProcessFix(void* handle,
return -1; return -1;
} }
if (far_spectrum == NULL) { if (far_spectrum == NULL) {
// Empty far end spectrum // Empty far end spectrum.
return -1; return -1;
} }
if (near_spectrum == NULL) { if (near_spectrum == NULL) {
// Empty near end spectrum // Empty near end spectrum.
return -1; return -1;
} }
if (spectrum_size != self->spectrum_size) { if (spectrum_size != self->spectrum_size) {
// Data sizes don't match // Data sizes don't match.
return -1; return -1;
} }
if (far_q > 15) { if (far_q > 15) {
// If |far_q| is larger than 15 we cannot guarantee no wrap around // If |far_q| is larger than 15 we cannot guarantee no wrap around.
return -1;
}
if (near_q > 15) {
// If |near_q| is larger than 15 we cannot guarantee no wrap around.
return -1; return -1;
} }
// Get binary spectra // Get binary spectra.
binary_far_spectrum = BinarySpectrumFix(far_spectrum, binary_far_spectrum = BinarySpectrumFix(far_spectrum,
self->mean_far_spectrum); self->mean_far_spectrum,
far_q,
&(self->far_spectrum_initialized));
binary_near_spectrum = BinarySpectrumFix(near_spectrum, binary_near_spectrum = BinarySpectrumFix(near_spectrum,
self->mean_near_spectrum); self->mean_near_spectrum,
near_q,
&(self->near_spectrum_initialized));
return WebRtc_ProcessBinarySpectrum(self->binary_handle, return WebRtc_ProcessBinarySpectrum(self->binary_handle,
binary_far_spectrum, binary_far_spectrum,
binary_near_spectrum, binary_near_spectrum);
vad_value);
} }
int WebRtc_DelayEstimatorProcessFloat(void* handle, int WebRtc_DelayEstimatorProcessFloat(void* handle,
float* far_spectrum, float* far_spectrum,
float* near_spectrum, float* near_spectrum,
int spectrum_size, int spectrum_size) {
int vad_value) { DelayEstimator* self = (DelayEstimator*) handle;
DelayEstimator_t* self = (DelayEstimator_t*) handle;
uint32_t binary_far_spectrum = 0; uint32_t binary_far_spectrum = 0;
uint32_t binary_near_spectrum = 0; uint32_t binary_near_spectrum = 0;
@ -261,32 +300,33 @@ int WebRtc_DelayEstimatorProcessFloat(void* handle,
return -1; return -1;
} }
if (far_spectrum == NULL) { if (far_spectrum == NULL) {
// Empty far end spectrum // Empty far end spectrum.
return -1; return -1;
} }
if (near_spectrum == NULL) { if (near_spectrum == NULL) {
// Empty near end spectrum // Empty near end spectrum.
return -1; return -1;
} }
if (spectrum_size != self->spectrum_size) { if (spectrum_size != self->spectrum_size) {
// Data sizes don't match // Data sizes don't match.
return -1; return -1;
} }
// Get binary spectra // Get binary spectra.
binary_far_spectrum = BinarySpectrumFloat(far_spectrum, binary_far_spectrum = BinarySpectrumFloat(far_spectrum,
self->mean_far_spectrum); self->mean_far_spectrum,
&(self->far_spectrum_initialized));
binary_near_spectrum = BinarySpectrumFloat(near_spectrum, binary_near_spectrum = BinarySpectrumFloat(near_spectrum,
self->mean_near_spectrum); self->mean_near_spectrum,
&(self->near_spectrum_initialized));
return WebRtc_ProcessBinarySpectrum(self->binary_handle, return WebRtc_ProcessBinarySpectrum(self->binary_handle,
binary_far_spectrum, binary_far_spectrum,
binary_near_spectrum, binary_near_spectrum);
vad_value);
} }
int WebRtc_last_delay(void* handle) { int WebRtc_last_delay(void* handle) {
DelayEstimator_t* self = (DelayEstimator_t*) handle; DelayEstimator* self = (DelayEstimator*) handle;
if (self == NULL) { if (self == NULL) {
return -1; return -1;

55
src/modules/audio_processing/utility/delay_estimator_wrapper.h
View File

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
// Performs delay estimation on a block by block basis // Performs delay estimation on block by block basis.
// The return value is 0 - OK and -1 - Error, unless otherwise stated. // The return value is 0 - OK and -1 - Error, unless otherwise stated.
#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_WRAPPER_H_ #ifndef WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_WRAPPER_H_
@ -18,7 +18,7 @@
// Releases the memory allocated by WebRtc_CreateDelayEstimator(...) // Releases the memory allocated by WebRtc_CreateDelayEstimator(...)
// Input: // Input:
// - handle : Pointer to the delay estimation instance // - handle : Pointer to the delay estimation instance.
// //
int WebRtc_FreeDelayEstimator(void* handle); int WebRtc_FreeDelayEstimator(void* handle);
@ -30,20 +30,20 @@ int WebRtc_FreeDelayEstimator(void* handle);
// - spectrum_size : Size of the spectrum used both in far-end and // - spectrum_size : Size of the spectrum used both in far-end and
// near-end. Used to allocate memory for spectrum // near-end. Used to allocate memory for spectrum
// specific buffers. // specific buffers.
// - max_delay : The maximum delay which can be estimated. Needed // - max_delay : The maximum delay which can be estimated. Needed to
// to allocate memory for history buffers. // allocate memory for history buffers.
// - lookahead : Amount of non-causal lookahead to use. This can detect // - lookahead : Amount of non-causal lookahead to use. This can
// cases in which a near-end signal occurs before the // detect cases in which a near-end signal occurs before
// corresponding far-end signal. It will delay the // the corresponding far-end signal. It will delay the
// estimate for the current block by an equal amount, // estimate for the current block by an equal amount,
// and the returned values will be offset by it. // and the returned values will be offset by it.
// //
// A value of zero is the typical no-lookahead case. This // A value of zero is the typical no-lookahead case.
// also represents the minimum delay which can be // This also represents the minimum delay which can be
// estimated. // estimated.
// //
// Output: // Output:
// - handle : Created instance // - handle : Created instance.
// //
int WebRtc_CreateDelayEstimator(void** handle, int WebRtc_CreateDelayEstimator(void** handle,
int spectrum_size, int spectrum_size,
@ -53,10 +53,10 @@ int WebRtc_CreateDelayEstimator(void** handle,
// Initializes the delay estimation instance created with // Initializes the delay estimation instance created with
// WebRtc_CreateDelayEstimator(...) // WebRtc_CreateDelayEstimator(...)
// Input: // Input:
// - handle : Pointer to the delay estimation instance // - handle : Pointer to the delay estimation instance.
// //
// Output: // Output:
// - handle : Initialized instance // - handle : Initialized instance.
// //
int WebRtc_InitDelayEstimator(void* handle); int WebRtc_InitDelayEstimator(void* handle);
@ -64,21 +64,21 @@ int WebRtc_InitDelayEstimator(void* handle);
// value will be offset by the lookahead (i.e. the lookahead should be // value will be offset by the lookahead (i.e. the lookahead should be
// subtracted from the returned value). // subtracted from the returned value).
// Inputs: // Inputs:
// - handle : Pointer to the delay estimation instance // - handle : Pointer to the delay estimation instance.
// - far_spectrum : Pointer to the far-end spectrum data // - far_spectrum : Pointer to the far-end spectrum data.
// - near_spectrum : Pointer to the near-end spectrum data of the current // - near_spectrum : Pointer to the near-end spectrum data of the current
// block // block.
// - spectrum_size : The size of the data arrays (same for both far- and // - spectrum_size : The size of the data arrays (same for both far- and
// near-end) // near-end).
// - far_q : The Q-domain of the far-end data // - far_q : The Q-domain of the far-end data.
// - vad_value : The VAD decision of the current block // - near_q : The Q-domain of the near-end data.
// //
// Output: // Output:
// - handle : Updated instance // - handle : Updated instance.
// //
// Return value: // Return value:
// - delay : >= 0 - Calculated delay value // - delay : >= 0 - Calculated delay value.
// -1 - Error // -1 - Error.
// -2 - Insufficient data for estimation. // -2 - Insufficient data for estimation.
// //
int WebRtc_DelayEstimatorProcessFix(void* handle, int WebRtc_DelayEstimatorProcessFix(void* handle,
@ -86,24 +86,23 @@ int WebRtc_DelayEstimatorProcessFix(void* handle,
uint16_t* near_spectrum, uint16_t* near_spectrum,
int spectrum_size, int spectrum_size,
int far_q, int far_q,
int vad_value); int near_q);
// See WebRtc_DelayEstimatorProcessFix() for description. // See WebRtc_DelayEstimatorProcessFix() for description.
int WebRtc_DelayEstimatorProcessFloat(void* handle, int WebRtc_DelayEstimatorProcessFloat(void* handle,
float* far_spectrum, float* far_spectrum,
float* near_spectrum, float* near_spectrum,
int spectrum_size, int spectrum_size);
int vad_value);
// Returns the last calculated delay updated by the function // Returns the last calculated delay updated by the function
// WebRtc_DelayEstimatorProcess(...) // WebRtc_DelayEstimatorProcess(...).
// //
// Input: // Input:
// - handle : Pointer to the delay estimation instance // - handle : Pointer to the delay estimation instance.
// //
// Return value: // Return value:
// - delay : >= 0 - Last calculated delay value // - delay : >= 0 - Last calculated delay value.
// -1 - Error // -1 - Error.
// -2 - Insufficient data for estimation. // -2 - Insufficient data for estimation.
// //
int WebRtc_last_delay(void* handle); int WebRtc_last_delay(void* handle);

BIN
test/data/audio_processing/output_data_fixed.pb
View File

Binary file not shown.

BIN
test/data/audio_processing/output_data_float.pb
View File

Binary file not shown.