mirror of
https://github.com/oxen-io/session-android.git
synced 2025-12-13 12:22:39 +00:00
Support for Signal calls.
Merge in RedPhone // FREEBIE
This commit is contained in:
Moxie Marlinspike
44
jni/webrtc/modules/audio_processing/utility/Android.mk
Normal file
44
jni/webrtc/modules/audio_processing/utility/Android.mk
Normal file
@@ -0,0 +1,44 @@
|
||||
# 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.
|
||||
|
||||
LOCAL_PATH := $(call my-dir)
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
include $(LOCAL_PATH)/../../../../android-webrtc.mk
|
||||
|
||||
LOCAL_ARM_MODE := arm
|
||||
LOCAL_MODULE_CLASS := STATIC_LIBRARIES
|
||||
LOCAL_MODULE := libwebrtc_apm_utility
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
LOCAL_SRC_FILES := \
|
||||
fft4g.c \
|
||||
ring_buffer.c \
|
||||
delay_estimator.c \
|
||||
delay_estimator_wrapper.c
|
||||
|
||||
# Flags passed to both C and C++ files.
|
||||
LOCAL_CFLAGS := \
|
||||
$(MY_WEBRTC_COMMON_DEFS)
|
||||
|
||||
# Include paths placed before CFLAGS/CPPFLAGS
|
||||
LOCAL_C_INCLUDES := \
|
||||
$(LOCAL_PATH) \
|
||||
$(LOCAL_PATH)/../../.. \
|
||||
$(LOCAL_PATH)/../../../common_audio/signal_processing/include \
|
||||
$(LOCAL_PATH)/../../../..
|
||||
|
||||
LOCAL_SHARED_LIBRARIES := \
|
||||
libcutils \
|
||||
libdl \
|
||||
libstlport
|
||||
|
||||
ifndef NDK_ROOT
|
||||
include external/stlport/libstlport.mk
|
||||
endif
|
||||
include $(BUILD_STATIC_LIBRARY)
|
||||
685
jni/webrtc/modules/audio_processing/utility/delay_estimator.c
Normal file
685
jni/webrtc/modules/audio_processing/utility/delay_estimator.c
Normal file
@@ -0,0 +1,685 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include "webrtc/modules/audio_processing/utility/delay_estimator.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.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.
|
||||
|
||||
// Robust validation settings
|
||||
static const float kHistogramMax = 3000.f;
|
||||
static const float kLastHistogramMax = 250.f;
|
||||
static const float kMinHistogramThreshold = 1.5f;
|
||||
static const int kMinRequiredHits = 10;
|
||||
static const int kMaxHitsWhenPossiblyNonCausal = 10;
|
||||
static const int kMaxHitsWhenPossiblyCausal = 1000;
|
||||
static const float kQ14Scaling = 1.f / (1 << 14); // Scaling by 2^14 to get Q0.
|
||||
static const float kFractionSlope = 0.05f;
|
||||
static const float kMinFractionWhenPossiblyCausal = 0.5f;
|
||||
static const float kMinFractionWhenPossiblyNonCausal = 0.25f;
|
||||
|
||||
// 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
|
||||
// per row the number of times they have the same value.
|
||||
//
|
||||
// Inputs:
|
||||
// - binary_vector : binary "vector" stored in a long
|
||||
// - binary_matrix : binary "matrix" stored as a vector of long
|
||||
// - matrix_size : size of binary "matrix"
|
||||
//
|
||||
// Output:
|
||||
// - bit_counts : "Vector" stored as a long, containing for each
|
||||
// row the number of times the matrix row and the
|
||||
// input vector have the same value
|
||||
//
|
||||
static void BitCountComparison(uint32_t binary_vector,
|
||||
const uint32_t* binary_matrix,
|
||||
int matrix_size,
|
||||
int32_t* bit_counts) {
|
||||
int n = 0;
|
||||
|
||||
// Compare |binary_vector| with all rows of the |binary_matrix|
|
||||
for (; n < matrix_size; n++) {
|
||||
bit_counts[n] = (int32_t) BitCount(binary_vector ^ binary_matrix[n]);
|
||||
}
|
||||
}
|
||||
|
||||
// Collects necessary statistics for the HistogramBasedValidation(). This
|
||||
// function has to be called prior to calling HistogramBasedValidation(). The
|
||||
// statistics updated and used by the HistogramBasedValidation() are:
|
||||
// 1. the number of |candidate_hits|, which states for how long we have had the
|
||||
// same |candidate_delay|
|
||||
// 2. the |histogram| of candidate delays over time. This histogram is
|
||||
// weighted with respect to a reliability measure and time-varying to cope
|
||||
// with possible delay shifts.
|
||||
// For further description see commented code.
|
||||
//
|
||||
// Inputs:
|
||||
// - candidate_delay : The delay to validate.
|
||||
// - valley_depth_q14 : The cost function has a valley/minimum at the
|
||||
// |candidate_delay| location. |valley_depth_q14| is the
|
||||
// cost function difference between the minimum and
|
||||
// maximum locations. The value is in the Q14 domain.
|
||||
// - valley_level_q14 : Is the cost function value at the minimum, in Q14.
|
||||
static void UpdateRobustValidationStatistics(BinaryDelayEstimator* self,
|
||||
int candidate_delay,
|
||||
int32_t valley_depth_q14,
|
||||
int32_t valley_level_q14) {
|
||||
const float valley_depth = valley_depth_q14 * kQ14Scaling;
|
||||
float decrease_in_last_set = valley_depth;
|
||||
const int max_hits_for_slow_change = (candidate_delay < self->last_delay) ?
|
||||
kMaxHitsWhenPossiblyNonCausal : kMaxHitsWhenPossiblyCausal;
|
||||
int i = 0;
|
||||
|
||||
assert(self->history_size == self->farend->history_size);
|
||||
// Reset |candidate_hits| if we have a new candidate.
|
||||
if (candidate_delay != self->last_candidate_delay) {
|
||||
self->candidate_hits = 0;
|
||||
self->last_candidate_delay = candidate_delay;
|
||||
}
|
||||
self->candidate_hits++;
|
||||
|
||||
// The |histogram| is updated differently across the bins.
|
||||
// 1. The |candidate_delay| histogram bin is increased with the
|
||||
// |valley_depth|, which is a simple measure of how reliable the
|
||||
// |candidate_delay| is. The histogram is not increased above
|
||||
// |kHistogramMax|.
|
||||
self->histogram[candidate_delay] += valley_depth;
|
||||
if (self->histogram[candidate_delay] > kHistogramMax) {
|
||||
self->histogram[candidate_delay] = kHistogramMax;
|
||||
}
|
||||
// 2. The histogram bins in the neighborhood of |candidate_delay| are
|
||||
// unaffected. The neighborhood is defined as x + {-2, -1, 0, 1}.
|
||||
// 3. The histogram bins in the neighborhood of |last_delay| are decreased
|
||||
// with |decrease_in_last_set|. This value equals the difference between
|
||||
// the cost function values at the locations |candidate_delay| and
|
||||
// |last_delay| until we reach |max_hits_for_slow_change| consecutive hits
|
||||
// at the |candidate_delay|. If we exceed this amount of hits the
|
||||
// |candidate_delay| is a "potential" candidate and we start decreasing
|
||||
// these histogram bins more rapidly with |valley_depth|.
|
||||
if (self->candidate_hits < max_hits_for_slow_change) {
|
||||
decrease_in_last_set = (self->mean_bit_counts[self->compare_delay] -
|
||||
valley_level_q14) * kQ14Scaling;
|
||||
}
|
||||
// 4. All other bins are decreased with |valley_depth|.
|
||||
// TODO(bjornv): Investigate how to make this loop more efficient. Split up
|
||||
// the loop? Remove parts that doesn't add too much.
|
||||
for (i = 0; i < self->history_size; ++i) {
|
||||
int is_in_last_set = (i >= self->last_delay - 2) &&
|
||||
(i <= self->last_delay + 1) && (i != candidate_delay);
|
||||
int is_in_candidate_set = (i >= candidate_delay - 2) &&
|
||||
(i <= candidate_delay + 1);
|
||||
self->histogram[i] -= decrease_in_last_set * is_in_last_set +
|
||||
valley_depth * (!is_in_last_set && !is_in_candidate_set);
|
||||
// 5. No histogram bin can go below 0.
|
||||
if (self->histogram[i] < 0) {
|
||||
self->histogram[i] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Validates the |candidate_delay|, estimated in WebRtc_ProcessBinarySpectrum(),
|
||||
// based on a mix of counting concurring hits with a modified histogram
|
||||
// of recent delay estimates. In brief a candidate is valid (returns 1) if it
|
||||
// is the most likely according to the histogram. There are a couple of
|
||||
// exceptions that are worth mentioning:
|
||||
// 1. If the |candidate_delay| < |last_delay| it can be that we are in a
|
||||
// non-causal state, breaking a possible echo control algorithm. Hence, we
|
||||
// open up for a quicker change by allowing the change even if the
|
||||
// |candidate_delay| is not the most likely one according to the histogram.
|
||||
// 2. There's a minimum number of hits (kMinRequiredHits) and the histogram
|
||||
// value has to reached a minimum (kMinHistogramThreshold) to be valid.
|
||||
// 3. The action is also depending on the filter length used for echo control.
|
||||
// If the delay difference is larger than what the filter can capture, we
|
||||
// also move quicker towards a change.
|
||||
// For further description see commented code.
|
||||
//
|
||||
// Input:
|
||||
// - candidate_delay : The delay to validate.
|
||||
//
|
||||
// Return value:
|
||||
// - is_histogram_valid : 1 - The |candidate_delay| is valid.
|
||||
// 0 - Otherwise.
|
||||
static int HistogramBasedValidation(const BinaryDelayEstimator* self,
|
||||
int candidate_delay) {
|
||||
float fraction = 1.f;
|
||||
float histogram_threshold = self->histogram[self->compare_delay];
|
||||
const int delay_difference = candidate_delay - self->last_delay;
|
||||
int is_histogram_valid = 0;
|
||||
|
||||
// The histogram based validation of |candidate_delay| is done by comparing
|
||||
// the |histogram| at bin |candidate_delay| with a |histogram_threshold|.
|
||||
// This |histogram_threshold| equals a |fraction| of the |histogram| at bin
|
||||
// |last_delay|. The |fraction| is a piecewise linear function of the
|
||||
// |delay_difference| between the |candidate_delay| and the |last_delay|
|
||||
// allowing for a quicker move if
|
||||
// i) a potential echo control filter can not handle these large differences.
|
||||
// ii) keeping |last_delay| instead of updating to |candidate_delay| could
|
||||
// force an echo control into a non-causal state.
|
||||
// We further require the histogram to have reached a minimum value of
|
||||
// |kMinHistogramThreshold|. In addition, we also require the number of
|
||||
// |candidate_hits| to be more than |kMinRequiredHits| to remove spurious
|
||||
// values.
|
||||
|
||||
// Calculate a comparison histogram value (|histogram_threshold|) that is
|
||||
// depending on the distance between the |candidate_delay| and |last_delay|.
|
||||
// TODO(bjornv): How much can we gain by turning the fraction calculation
|
||||
// into tables?
|
||||
if (delay_difference > self->allowed_offset) {
|
||||
fraction = 1.f - kFractionSlope * (delay_difference - self->allowed_offset);
|
||||
fraction = (fraction > kMinFractionWhenPossiblyCausal ? fraction :
|
||||
kMinFractionWhenPossiblyCausal);
|
||||
} else if (delay_difference < 0) {
|
||||
fraction = kMinFractionWhenPossiblyNonCausal -
|
||||
kFractionSlope * delay_difference;
|
||||
fraction = (fraction > 1.f ? 1.f : fraction);
|
||||
}
|
||||
histogram_threshold *= fraction;
|
||||
histogram_threshold = (histogram_threshold > kMinHistogramThreshold ?
|
||||
histogram_threshold : kMinHistogramThreshold);
|
||||
|
||||
is_histogram_valid =
|
||||
(self->histogram[candidate_delay] >= histogram_threshold) &&
|
||||
(self->candidate_hits > kMinRequiredHits);
|
||||
|
||||
return is_histogram_valid;
|
||||
}
|
||||
|
||||
// Performs a robust validation of the |candidate_delay| estimated in
|
||||
// WebRtc_ProcessBinarySpectrum(). The algorithm takes the
|
||||
// |is_instantaneous_valid| and the |is_histogram_valid| and combines them
|
||||
// into a robust validation. The HistogramBasedValidation() has to be called
|
||||
// prior to this call.
|
||||
// For further description on how the combination is done, see commented code.
|
||||
//
|
||||
// Inputs:
|
||||
// - candidate_delay : The delay to validate.
|
||||
// - is_instantaneous_valid : The instantaneous validation performed in
|
||||
// WebRtc_ProcessBinarySpectrum().
|
||||
// - is_histogram_valid : The histogram based validation.
|
||||
//
|
||||
// Return value:
|
||||
// - is_robust : 1 - The candidate_delay is valid according to a
|
||||
// combination of the two inputs.
|
||||
// : 0 - Otherwise.
|
||||
static int RobustValidation(const BinaryDelayEstimator* self,
|
||||
int candidate_delay,
|
||||
int is_instantaneous_valid,
|
||||
int is_histogram_valid) {
|
||||
int is_robust = 0;
|
||||
|
||||
// The final robust validation is based on the two algorithms; 1) the
|
||||
// |is_instantaneous_valid| and 2) the histogram based with result stored in
|
||||
// |is_histogram_valid|.
|
||||
// i) Before we actually have a valid estimate (|last_delay| == -2), we say
|
||||
// a candidate is valid if either algorithm states so
|
||||
// (|is_instantaneous_valid| OR |is_histogram_valid|).
|
||||
is_robust = (self->last_delay < 0) &&
|
||||
(is_instantaneous_valid || is_histogram_valid);
|
||||
// ii) Otherwise, we need both algorithms to be certain
|
||||
// (|is_instantaneous_valid| AND |is_histogram_valid|)
|
||||
is_robust |= is_instantaneous_valid && is_histogram_valid;
|
||||
// iii) With one exception, i.e., the histogram based algorithm can overrule
|
||||
// the instantaneous one if |is_histogram_valid| = 1 and the histogram
|
||||
// is significantly strong.
|
||||
is_robust |= is_histogram_valid &&
|
||||
(self->histogram[candidate_delay] > self->last_delay_histogram);
|
||||
|
||||
return is_robust;
|
||||
}
|
||||
|
||||
void WebRtc_FreeBinaryDelayEstimatorFarend(BinaryDelayEstimatorFarend* self) {
|
||||
|
||||
if (self == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
free(self->binary_far_history);
|
||||
self->binary_far_history = NULL;
|
||||
|
||||
free(self->far_bit_counts);
|
||||
self->far_bit_counts = NULL;
|
||||
|
||||
free(self);
|
||||
}
|
||||
|
||||
BinaryDelayEstimatorFarend* WebRtc_CreateBinaryDelayEstimatorFarend(
|
||||
int history_size) {
|
||||
BinaryDelayEstimatorFarend* self = NULL;
|
||||
|
||||
if (history_size > 1) {
|
||||
// Sanity conditions fulfilled.
|
||||
self = malloc(sizeof(BinaryDelayEstimatorFarend));
|
||||
}
|
||||
if (self == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
self->history_size = 0;
|
||||
self->binary_far_history = NULL;
|
||||
self->far_bit_counts = NULL;
|
||||
if (WebRtc_AllocateFarendBufferMemory(self, history_size) == 0) {
|
||||
WebRtc_FreeBinaryDelayEstimatorFarend(self);
|
||||
self = NULL;
|
||||
}
|
||||
return self;
|
||||
}
|
||||
|
||||
int WebRtc_AllocateFarendBufferMemory(BinaryDelayEstimatorFarend* self,
|
||||
int history_size) {
|
||||
assert(self != NULL);
|
||||
// (Re-)Allocate memory for history buffers.
|
||||
self->binary_far_history =
|
||||
realloc(self->binary_far_history,
|
||||
history_size * sizeof(*self->binary_far_history));
|
||||
self->far_bit_counts = realloc(self->far_bit_counts,
|
||||
history_size * sizeof(*self->far_bit_counts));
|
||||
if ((self->binary_far_history == NULL) || (self->far_bit_counts == NULL)) {
|
||||
history_size = 0;
|
||||
}
|
||||
// Fill with zeros if we have expanded the buffers.
|
||||
if (history_size > self->history_size) {
|
||||
int size_diff = history_size - self->history_size;
|
||||
memset(&self->binary_far_history[self->history_size],
|
||||
0,
|
||||
sizeof(*self->binary_far_history) * size_diff);
|
||||
memset(&self->far_bit_counts[self->history_size],
|
||||
0,
|
||||
sizeof(*self->far_bit_counts) * size_diff);
|
||||
}
|
||||
self->history_size = history_size;
|
||||
|
||||
return self->history_size;
|
||||
}
|
||||
|
||||
void WebRtc_InitBinaryDelayEstimatorFarend(BinaryDelayEstimatorFarend* self) {
|
||||
assert(self != NULL);
|
||||
memset(self->binary_far_history, 0, sizeof(uint32_t) * self->history_size);
|
||||
memset(self->far_bit_counts, 0, sizeof(int) * self->history_size);
|
||||
}
|
||||
|
||||
void WebRtc_SoftResetBinaryDelayEstimatorFarend(
|
||||
BinaryDelayEstimatorFarend* self, int delay_shift) {
|
||||
int abs_shift = abs(delay_shift);
|
||||
int shift_size = 0;
|
||||
int dest_index = 0;
|
||||
int src_index = 0;
|
||||
int padding_index = 0;
|
||||
|
||||
assert(self != NULL);
|
||||
shift_size = self->history_size - abs_shift;
|
||||
assert(shift_size > 0);
|
||||
if (delay_shift == 0) {
|
||||
return;
|
||||
} else if (delay_shift > 0) {
|
||||
dest_index = abs_shift;
|
||||
} else if (delay_shift < 0) {
|
||||
src_index = abs_shift;
|
||||
padding_index = shift_size;
|
||||
}
|
||||
|
||||
// Shift and zero pad buffers.
|
||||
memmove(&self->binary_far_history[dest_index],
|
||||
&self->binary_far_history[src_index],
|
||||
sizeof(*self->binary_far_history) * shift_size);
|
||||
memset(&self->binary_far_history[padding_index], 0,
|
||||
sizeof(*self->binary_far_history) * abs_shift);
|
||||
memmove(&self->far_bit_counts[dest_index],
|
||||
&self->far_bit_counts[src_index],
|
||||
sizeof(*self->far_bit_counts) * shift_size);
|
||||
memset(&self->far_bit_counts[padding_index], 0,
|
||||
sizeof(*self->far_bit_counts) * abs_shift);
|
||||
}
|
||||
|
||||
void WebRtc_AddBinaryFarSpectrum(BinaryDelayEstimatorFarend* handle,
|
||||
uint32_t binary_far_spectrum) {
|
||||
assert(handle != NULL);
|
||||
// Shift binary spectrum history and insert current |binary_far_spectrum|.
|
||||
memmove(&(handle->binary_far_history[1]), &(handle->binary_far_history[0]),
|
||||
(handle->history_size - 1) * sizeof(uint32_t));
|
||||
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);
|
||||
}
|
||||
|
||||
void WebRtc_FreeBinaryDelayEstimator(BinaryDelayEstimator* self) {
|
||||
|
||||
if (self == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
free(self->mean_bit_counts);
|
||||
self->mean_bit_counts = NULL;
|
||||
|
||||
free(self->bit_counts);
|
||||
self->bit_counts = NULL;
|
||||
|
||||
free(self->binary_near_history);
|
||||
self->binary_near_history = NULL;
|
||||
|
||||
free(self->histogram);
|
||||
self->histogram = NULL;
|
||||
|
||||
// BinaryDelayEstimator does not have ownership of |farend|, hence we do not
|
||||
// free the memory here. That should be handled separately by the user.
|
||||
self->farend = NULL;
|
||||
|
||||
free(self);
|
||||
}
|
||||
|
||||
BinaryDelayEstimator* WebRtc_CreateBinaryDelayEstimator(
|
||||
BinaryDelayEstimatorFarend* farend, int max_lookahead) {
|
||||
BinaryDelayEstimator* self = NULL;
|
||||
|
||||
if ((farend != NULL) && (max_lookahead >= 0)) {
|
||||
// Sanity conditions fulfilled.
|
||||
self = malloc(sizeof(BinaryDelayEstimator));
|
||||
}
|
||||
if (self == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
self->farend = farend;
|
||||
self->near_history_size = max_lookahead + 1;
|
||||
self->history_size = 0;
|
||||
self->robust_validation_enabled = 0; // Disabled by default.
|
||||
self->allowed_offset = 0;
|
||||
|
||||
self->lookahead = max_lookahead;
|
||||
|
||||
// Allocate memory for spectrum and history buffers.
|
||||
self->mean_bit_counts = NULL;
|
||||
self->bit_counts = NULL;
|
||||
self->histogram = NULL;
|
||||
self->binary_near_history =
|
||||
malloc((max_lookahead + 1) * sizeof(*self->binary_near_history));
|
||||
if (self->binary_near_history == NULL ||
|
||||
WebRtc_AllocateHistoryBufferMemory(self, farend->history_size) == 0) {
|
||||
WebRtc_FreeBinaryDelayEstimator(self);
|
||||
self = NULL;
|
||||
}
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
int WebRtc_AllocateHistoryBufferMemory(BinaryDelayEstimator* self,
|
||||
int history_size) {
|
||||
BinaryDelayEstimatorFarend* far = self->farend;
|
||||
// (Re-)Allocate memory for spectrum and history buffers.
|
||||
if (history_size != far->history_size) {
|
||||
// Only update far-end buffers if we need.
|
||||
history_size = WebRtc_AllocateFarendBufferMemory(far, history_size);
|
||||
}
|
||||
// The extra array element in |mean_bit_counts| and |histogram| is a dummy
|
||||
// element only used while |last_delay| == -2, i.e., before we have a valid
|
||||
// estimate.
|
||||
self->mean_bit_counts =
|
||||
realloc(self->mean_bit_counts,
|
||||
(history_size + 1) * sizeof(*self->mean_bit_counts));
|
||||
self->bit_counts =
|
||||
realloc(self->bit_counts, history_size * sizeof(*self->bit_counts));
|
||||
self->histogram =
|
||||
realloc(self->histogram, (history_size + 1) * sizeof(*self->histogram));
|
||||
|
||||
if ((self->mean_bit_counts == NULL) ||
|
||||
(self->bit_counts == NULL) ||
|
||||
(self->histogram == NULL)) {
|
||||
history_size = 0;
|
||||
}
|
||||
// Fill with zeros if we have expanded the buffers.
|
||||
if (history_size > self->history_size) {
|
||||
int size_diff = history_size - self->history_size;
|
||||
memset(&self->mean_bit_counts[self->history_size],
|
||||
0,
|
||||
sizeof(*self->mean_bit_counts) * size_diff);
|
||||
memset(&self->bit_counts[self->history_size],
|
||||
0,
|
||||
sizeof(*self->bit_counts) * size_diff);
|
||||
memset(&self->histogram[self->history_size],
|
||||
0,
|
||||
sizeof(*self->histogram) * size_diff);
|
||||
}
|
||||
self->history_size = history_size;
|
||||
|
||||
return self->history_size;
|
||||
}
|
||||
|
||||
void WebRtc_InitBinaryDelayEstimator(BinaryDelayEstimator* self) {
|
||||
int i = 0;
|
||||
assert(self != NULL);
|
||||
|
||||
memset(self->bit_counts, 0, sizeof(int32_t) * self->history_size);
|
||||
memset(self->binary_near_history,
|
||||
0,
|
||||
sizeof(uint32_t) * self->near_history_size);
|
||||
for (i = 0; i <= self->history_size; ++i) {
|
||||
self->mean_bit_counts[i] = (20 << 9); // 20 in Q9.
|
||||
self->histogram[i] = 0.f;
|
||||
}
|
||||
self->minimum_probability = kMaxBitCountsQ9; // 32 in Q9.
|
||||
self->last_delay_probability = (int) kMaxBitCountsQ9; // 32 in Q9.
|
||||
|
||||
// Default return value if we're unable to estimate. -1 is used for errors.
|
||||
self->last_delay = -2;
|
||||
|
||||
self->last_candidate_delay = -2;
|
||||
self->compare_delay = self->history_size;
|
||||
self->candidate_hits = 0;
|
||||
self->last_delay_histogram = 0.f;
|
||||
}
|
||||
|
||||
int WebRtc_SoftResetBinaryDelayEstimator(BinaryDelayEstimator* self,
|
||||
int delay_shift) {
|
||||
int lookahead = 0;
|
||||
assert(self != NULL);
|
||||
lookahead = self->lookahead;
|
||||
self->lookahead -= delay_shift;
|
||||
if (self->lookahead < 0) {
|
||||
self->lookahead = 0;
|
||||
}
|
||||
if (self->lookahead > self->near_history_size - 1) {
|
||||
self->lookahead = self->near_history_size - 1;
|
||||
}
|
||||
return lookahead - self->lookahead;
|
||||
}
|
||||
|
||||
int WebRtc_ProcessBinarySpectrum(BinaryDelayEstimator* self,
|
||||
uint32_t binary_near_spectrum) {
|
||||
int i = 0;
|
||||
int candidate_delay = -1;
|
||||
int valid_candidate = 0;
|
||||
|
||||
int32_t value_best_candidate = kMaxBitCountsQ9;
|
||||
int32_t value_worst_candidate = 0;
|
||||
int32_t valley_depth = 0;
|
||||
|
||||
assert(self != NULL);
|
||||
if (self->farend->history_size != self->history_size) {
|
||||
// Non matching history sizes.
|
||||
return -1;
|
||||
}
|
||||
if (self->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(&(self->binary_near_history[1]), &(self->binary_near_history[0]),
|
||||
(self->near_history_size - 1) * sizeof(uint32_t));
|
||||
self->binary_near_history[0] = binary_near_spectrum;
|
||||
binary_near_spectrum = self->binary_near_history[self->lookahead];
|
||||
}
|
||||
|
||||
// Compare with delayed spectra and store the |bit_counts| for each delay.
|
||||
BitCountComparison(binary_near_spectrum, self->farend->binary_far_history,
|
||||
self->history_size, self->bit_counts);
|
||||
|
||||
// Update |mean_bit_counts|, which is the smoothed version of |bit_counts|.
|
||||
for (i = 0; i < self->history_size; i++) {
|
||||
// |bit_counts| is constrained to [0, 32], meaning we can smooth with a
|
||||
// factor up to 2^26. We use Q9.
|
||||
int32_t bit_count = (self->bit_counts[i] << 9); // Q9.
|
||||
|
||||
// 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 (self->farend->far_bit_counts[i] > 0) {
|
||||
// Make number of right shifts piecewise linear w.r.t. |far_bit_counts|.
|
||||
int shifts = kShiftsAtZero;
|
||||
shifts -= (kShiftsLinearSlope * self->farend->far_bit_counts[i]) >> 4;
|
||||
WebRtc_MeanEstimatorFix(bit_count, shifts, &(self->mean_bit_counts[i]));
|
||||
}
|
||||
}
|
||||
|
||||
// Find |candidate_delay|, |value_best_candidate| and |value_worst_candidate|
|
||||
// of |mean_bit_counts|.
|
||||
for (i = 0; i < self->history_size; i++) {
|
||||
if (self->mean_bit_counts[i] < value_best_candidate) {
|
||||
value_best_candidate = self->mean_bit_counts[i];
|
||||
candidate_delay = i;
|
||||
}
|
||||
if (self->mean_bit_counts[i] > value_worst_candidate) {
|
||||
value_worst_candidate = self->mean_bit_counts[i];
|
||||
}
|
||||
}
|
||||
valley_depth = value_worst_candidate - value_best_candidate;
|
||||
|
||||
// The |value_best_candidate| is a good indicator on the probability of
|
||||
// |candidate_delay| being an accurate delay (a small |value_best_candidate|
|
||||
// means a good binary match). In the following sections we make a decision
|
||||
// whether to update |last_delay| or not.
|
||||
// 1) If the difference bit counts between the best and the worst delay
|
||||
// candidates is too small we consider the situation to be unreliable and
|
||||
// don't update |last_delay|.
|
||||
// 2) If the situation is reliable we update |last_delay| if the value of the
|
||||
// best candidate delay has a value less than
|
||||
// i) an adaptive threshold |minimum_probability|, or
|
||||
// ii) this corresponding value |last_delay_probability|, but updated at
|
||||
// this time instant.
|
||||
|
||||
// Update |minimum_probability|.
|
||||
if ((self->minimum_probability > kProbabilityLowerLimit) &&
|
||||
(valley_depth > kProbabilityMinSpread)) {
|
||||
// The "hard" threshold can't be lower than 17 (in Q9).
|
||||
// The valley in the curve also has to be distinct, i.e., the
|
||||
// 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 (self->minimum_probability > threshold) {
|
||||
self->minimum_probability = threshold;
|
||||
}
|
||||
}
|
||||
// Update |last_delay_probability|.
|
||||
// We use a Markov type model, i.e., a slowly increasing level over time.
|
||||
self->last_delay_probability++;
|
||||
// Validate |candidate_delay|. We have a reliable instantaneous delay
|
||||
// estimate if
|
||||
// 1) The valley is distinct enough (|valley_depth| > |kProbabilityOffset|)
|
||||
// and
|
||||
// 2) The depth of the valley is deep enough
|
||||
// (|value_best_candidate| < |minimum_probability|)
|
||||
// and deeper than the best estimate so far
|
||||
// (|value_best_candidate| < |last_delay_probability|)
|
||||
valid_candidate = ((valley_depth > kProbabilityOffset) &&
|
||||
((value_best_candidate < self->minimum_probability) ||
|
||||
(value_best_candidate < self->last_delay_probability)));
|
||||
|
||||
if (self->robust_validation_enabled) {
|
||||
int is_histogram_valid = 0;
|
||||
UpdateRobustValidationStatistics(self, candidate_delay, valley_depth,
|
||||
value_best_candidate);
|
||||
is_histogram_valid = HistogramBasedValidation(self, candidate_delay);
|
||||
valid_candidate = RobustValidation(self, candidate_delay, valid_candidate,
|
||||
is_histogram_valid);
|
||||
|
||||
}
|
||||
if (valid_candidate) {
|
||||
if (candidate_delay != self->last_delay) {
|
||||
self->last_delay_histogram =
|
||||
(self->histogram[candidate_delay] > kLastHistogramMax ?
|
||||
kLastHistogramMax : self->histogram[candidate_delay]);
|
||||
// Adjust the histogram if we made a change to |last_delay|, though it was
|
||||
// not the most likely one according to the histogram.
|
||||
if (self->histogram[candidate_delay] <
|
||||
self->histogram[self->compare_delay]) {
|
||||
self->histogram[self->compare_delay] = self->histogram[candidate_delay];
|
||||
}
|
||||
}
|
||||
self->last_delay = candidate_delay;
|
||||
if (value_best_candidate < self->last_delay_probability) {
|
||||
self->last_delay_probability = value_best_candidate;
|
||||
}
|
||||
self->compare_delay = self->last_delay;
|
||||
}
|
||||
|
||||
return self->last_delay;
|
||||
}
|
||||
|
||||
int WebRtc_binary_last_delay(BinaryDelayEstimator* self) {
|
||||
assert(self != NULL);
|
||||
return self->last_delay;
|
||||
}
|
||||
|
||||
float WebRtc_binary_last_delay_quality(BinaryDelayEstimator* self) {
|
||||
float quality = 0;
|
||||
assert(self != NULL);
|
||||
|
||||
if (self->robust_validation_enabled) {
|
||||
// Simply a linear function of the histogram height at delay estimate.
|
||||
quality = self->histogram[self->compare_delay] / kHistogramMax;
|
||||
} else {
|
||||
// Note that |last_delay_probability| states how deep the minimum of the
|
||||
// cost function is, so it is rather an error probability.
|
||||
quality = (float) (kMaxBitCountsQ9 - self->last_delay_probability) /
|
||||
kMaxBitCountsQ9;
|
||||
if (quality < 0) {
|
||||
quality = 0;
|
||||
}
|
||||
}
|
||||
return quality;
|
||||
}
|
||||
|
||||
void WebRtc_MeanEstimatorFix(int32_t new_value,
|
||||
int factor,
|
||||
int32_t* mean_value) {
|
||||
int32_t diff = new_value - *mean_value;
|
||||
|
||||
// mean_new = mean_value + ((new_value - mean_value) >> factor);
|
||||
if (diff < 0) {
|
||||
diff = -((-diff) >> factor);
|
||||
} else {
|
||||
diff = (diff >> factor);
|
||||
}
|
||||
*mean_value += diff;
|
||||
}
|
||||
251
jni/webrtc/modules/audio_processing/utility/delay_estimator.h
Normal file
251
jni/webrtc/modules/audio_processing/utility/delay_estimator.h
Normal file
@@ -0,0 +1,251 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
// Performs delay estimation on binary converted spectra.
|
||||
// The return value is 0 - OK and -1 - Error, unless otherwise stated.
|
||||
|
||||
#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_H_
|
||||
#define WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_H_
|
||||
|
||||
#include "webrtc/typedefs.h"
|
||||
|
||||
static const int32_t kMaxBitCountsQ9 = (32 << 9); // 32 matching bits in Q9.
|
||||
|
||||
typedef struct {
|
||||
// Pointer to bit counts.
|
||||
int* far_bit_counts;
|
||||
// Binary history variables.
|
||||
uint32_t* binary_far_history;
|
||||
int history_size;
|
||||
} BinaryDelayEstimatorFarend;
|
||||
|
||||
typedef struct {
|
||||
// Pointer to bit counts.
|
||||
int32_t* mean_bit_counts;
|
||||
// Array only used locally in ProcessBinarySpectrum() but whose size is
|
||||
// determined at run-time.
|
||||
int32_t* bit_counts;
|
||||
|
||||
// Binary history variables.
|
||||
uint32_t* binary_near_history;
|
||||
int near_history_size;
|
||||
int history_size;
|
||||
|
||||
// Delay estimation variables.
|
||||
int32_t minimum_probability;
|
||||
int last_delay_probability;
|
||||
|
||||
// Delay memory.
|
||||
int last_delay;
|
||||
|
||||
// Robust validation
|
||||
int robust_validation_enabled;
|
||||
int allowed_offset;
|
||||
int last_candidate_delay;
|
||||
int compare_delay;
|
||||
int candidate_hits;
|
||||
float* histogram;
|
||||
float last_delay_histogram;
|
||||
|
||||
// For dynamically changing the lookahead when using SoftReset...().
|
||||
int lookahead;
|
||||
|
||||
// Far-end binary spectrum history buffer etc.
|
||||
BinaryDelayEstimatorFarend* farend;
|
||||
} BinaryDelayEstimator;
|
||||
|
||||
// Releases the memory allocated by
|
||||
// WebRtc_CreateBinaryDelayEstimatorFarend(...).
|
||||
// Input:
|
||||
// - self : Pointer to the binary delay estimation far-end
|
||||
// instance which is the return value of
|
||||
// WebRtc_CreateBinaryDelayEstimatorFarend().
|
||||
//
|
||||
void WebRtc_FreeBinaryDelayEstimatorFarend(BinaryDelayEstimatorFarend* self);
|
||||
|
||||
// Allocates the memory needed by the far-end part of the binary delay
|
||||
// estimation. The memory needs to be initialized separately through
|
||||
// WebRtc_InitBinaryDelayEstimatorFarend(...).
|
||||
//
|
||||
// Inputs:
|
||||
// - history_size : Size of the far-end binary spectrum history.
|
||||
//
|
||||
// Return value:
|
||||
// - BinaryDelayEstimatorFarend*
|
||||
// : Created |handle|. If the memory can't be allocated
|
||||
// or if any of the input parameters are invalid NULL
|
||||
// is returned.
|
||||
//
|
||||
BinaryDelayEstimatorFarend* WebRtc_CreateBinaryDelayEstimatorFarend(
|
||||
int history_size);
|
||||
|
||||
// Re-allocates the buffers.
|
||||
//
|
||||
// Inputs:
|
||||
// - self : Pointer to the binary estimation far-end instance
|
||||
// which is the return value of
|
||||
// WebRtc_CreateBinaryDelayEstimatorFarend().
|
||||
// - history_size : Size of the far-end binary spectrum history.
|
||||
//
|
||||
// Return value:
|
||||
// - history_size : The history size allocated.
|
||||
int WebRtc_AllocateFarendBufferMemory(BinaryDelayEstimatorFarend* self,
|
||||
int history_size);
|
||||
|
||||
// Initializes the delay estimation far-end instance created with
|
||||
// WebRtc_CreateBinaryDelayEstimatorFarend(...).
|
||||
//
|
||||
// Input:
|
||||
// - self : Pointer to the delay estimation far-end instance.
|
||||
//
|
||||
// Output:
|
||||
// - self : Initialized far-end instance.
|
||||
//
|
||||
void WebRtc_InitBinaryDelayEstimatorFarend(BinaryDelayEstimatorFarend* self);
|
||||
|
||||
// Soft resets the delay estimation far-end instance created with
|
||||
// WebRtc_CreateBinaryDelayEstimatorFarend(...).
|
||||
//
|
||||
// Input:
|
||||
// - delay_shift : The amount of blocks to shift history buffers.
|
||||
//
|
||||
void WebRtc_SoftResetBinaryDelayEstimatorFarend(
|
||||
BinaryDelayEstimatorFarend* self, int delay_shift);
|
||||
|
||||
// Adds the binary far-end spectrum to the internal far-end history buffer. This
|
||||
// spectrum is used as reference when calculating the delay using
|
||||
// WebRtc_ProcessBinarySpectrum().
|
||||
//
|
||||
// Inputs:
|
||||
// - self : Pointer to the delay estimation far-end
|
||||
// instance.
|
||||
// - binary_far_spectrum : Far-end binary spectrum.
|
||||
//
|
||||
// Output:
|
||||
// - self : Updated far-end instance.
|
||||
//
|
||||
void WebRtc_AddBinaryFarSpectrum(BinaryDelayEstimatorFarend* self,
|
||||
uint32_t binary_far_spectrum);
|
||||
|
||||
// Releases the memory allocated by WebRtc_CreateBinaryDelayEstimator(...).
|
||||
//
|
||||
// Note that BinaryDelayEstimator utilizes BinaryDelayEstimatorFarend, but does
|
||||
// not take ownership of it, hence the BinaryDelayEstimator has to be torn down
|
||||
// before the far-end.
|
||||
//
|
||||
// Input:
|
||||
// - self : Pointer to the binary delay estimation instance
|
||||
// which is the return value of
|
||||
// WebRtc_CreateBinaryDelayEstimator().
|
||||
//
|
||||
void WebRtc_FreeBinaryDelayEstimator(BinaryDelayEstimator* self);
|
||||
|
||||
// Allocates the memory needed by the binary delay estimation. The memory needs
|
||||
// to be initialized separately through WebRtc_InitBinaryDelayEstimator(...).
|
||||
//
|
||||
// See WebRtc_CreateDelayEstimator(..) in delay_estimator_wrapper.c for detailed
|
||||
// description.
|
||||
BinaryDelayEstimator* WebRtc_CreateBinaryDelayEstimator(
|
||||
BinaryDelayEstimatorFarend* farend, int max_lookahead);
|
||||
|
||||
// Re-allocates |history_size| dependent buffers. The far-end buffers will be
|
||||
// updated at the same time if needed.
|
||||
//
|
||||
// Input:
|
||||
// - self : Pointer to the binary estimation instance which is
|
||||
// the return value of
|
||||
// WebRtc_CreateBinaryDelayEstimator().
|
||||
// - history_size : Size of the history buffers.
|
||||
//
|
||||
// Return value:
|
||||
// - history_size : The history size allocated.
|
||||
int WebRtc_AllocateHistoryBufferMemory(BinaryDelayEstimator* self,
|
||||
int history_size);
|
||||
|
||||
// Initializes the delay estimation instance created with
|
||||
// WebRtc_CreateBinaryDelayEstimator(...).
|
||||
//
|
||||
// Input:
|
||||
// - self : Pointer to the delay estimation instance.
|
||||
//
|
||||
// Output:
|
||||
// - self : Initialized instance.
|
||||
//
|
||||
void WebRtc_InitBinaryDelayEstimator(BinaryDelayEstimator* self);
|
||||
|
||||
// Soft resets the delay estimation instance created with
|
||||
// WebRtc_CreateBinaryDelayEstimator(...).
|
||||
//
|
||||
// Input:
|
||||
// - delay_shift : The amount of blocks to shift history buffers.
|
||||
//
|
||||
// Return value:
|
||||
// - actual_shifts : The actual number of shifts performed.
|
||||
//
|
||||
int WebRtc_SoftResetBinaryDelayEstimator(BinaryDelayEstimator* self,
|
||||
int delay_shift);
|
||||
|
||||
// Estimates and returns the delay between the binary far-end and binary near-
|
||||
// end spectra. It is assumed the binary far-end spectrum has been added using
|
||||
// WebRtc_AddBinaryFarSpectrum() prior to this call. The value will be offset by
|
||||
// the lookahead (i.e. the lookahead should be subtracted from the returned
|
||||
// value).
|
||||
//
|
||||
// Inputs:
|
||||
// - self : Pointer to the delay estimation instance.
|
||||
// - binary_near_spectrum : Near-end binary spectrum of the current block.
|
||||
//
|
||||
// Output:
|
||||
// - self : Updated instance.
|
||||
//
|
||||
// Return value:
|
||||
// - delay : >= 0 - Calculated delay value.
|
||||
// -2 - Insufficient data for estimation.
|
||||
//
|
||||
int WebRtc_ProcessBinarySpectrum(BinaryDelayEstimator* self,
|
||||
uint32_t binary_near_spectrum);
|
||||
|
||||
// Returns the last calculated delay updated by the function
|
||||
// WebRtc_ProcessBinarySpectrum(...).
|
||||
//
|
||||
// Input:
|
||||
// - self : Pointer to the delay estimation instance.
|
||||
//
|
||||
// Return value:
|
||||
// - delay : >= 0 - Last calculated delay value
|
||||
// -2 - Insufficient data for estimation.
|
||||
//
|
||||
int WebRtc_binary_last_delay(BinaryDelayEstimator* self);
|
||||
|
||||
// Returns the estimation quality of the last calculated delay updated by the
|
||||
// function WebRtc_ProcessBinarySpectrum(...). The estimation quality is a value
|
||||
// in the interval [0, 1]. The higher the value, the better the quality.
|
||||
//
|
||||
// Return value:
|
||||
// - delay_quality : >= 0 - Estimation quality of last calculated
|
||||
// delay value.
|
||||
float WebRtc_binary_last_delay_quality(BinaryDelayEstimator* self);
|
||||
|
||||
// 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
|
||||
// Fixed point wrapper.
|
||||
//
|
||||
// Inputs:
|
||||
// - new_value : The new value the mean should be updated with.
|
||||
// - factor : The step size, in number of right shifts.
|
||||
//
|
||||
// Input/Output:
|
||||
// - mean_value : Pointer to the mean value.
|
||||
//
|
||||
void WebRtc_MeanEstimatorFix(int32_t new_value,
|
||||
int factor,
|
||||
int32_t* mean_value);
|
||||
|
||||
#endif // WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_H_
|
||||
@@ -0,0 +1,48 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
// Header file including the delay estimator handle used for testing.
|
||||
|
||||
#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_INTERNAL_H_
|
||||
#define WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_INTERNAL_H_
|
||||
|
||||
#include "webrtc/modules/audio_processing/utility/delay_estimator.h"
|
||||
#include "webrtc/typedefs.h"
|
||||
|
||||
typedef union {
|
||||
float float_;
|
||||
int32_t int32_;
|
||||
} SpectrumType;
|
||||
|
||||
typedef struct {
|
||||
// Pointers to mean values of spectrum.
|
||||
SpectrumType* mean_far_spectrum;
|
||||
// |mean_far_spectrum| initialization indicator.
|
||||
int far_spectrum_initialized;
|
||||
|
||||
int spectrum_size;
|
||||
|
||||
// Far-end part of binary spectrum based delay estimation.
|
||||
BinaryDelayEstimatorFarend* binary_farend;
|
||||
} DelayEstimatorFarend;
|
||||
|
||||
typedef struct {
|
||||
// Pointers to mean values of spectrum.
|
||||
SpectrumType* mean_near_spectrum;
|
||||
// |mean_near_spectrum| initialization indicator.
|
||||
int near_spectrum_initialized;
|
||||
|
||||
int spectrum_size;
|
||||
|
||||
// Binary spectrum based delay estimator
|
||||
BinaryDelayEstimator* binary_handle;
|
||||
} DelayEstimator;
|
||||
|
||||
#endif // WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_INTERNAL_H_
|
||||
@@ -0,0 +1,621 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
|
||||
extern "C" {
|
||||
#include "webrtc/modules/audio_processing/utility/delay_estimator.h"
|
||||
#include "webrtc/modules/audio_processing/utility/delay_estimator_internal.h"
|
||||
#include "webrtc/modules/audio_processing/utility/delay_estimator_wrapper.h"
|
||||
}
|
||||
#include "webrtc/typedefs.h"
|
||||
|
||||
namespace {
|
||||
|
||||
enum { kSpectrumSize = 65 };
|
||||
// Delay history sizes.
|
||||
enum { kMaxDelay = 100 };
|
||||
enum { kLookahead = 10 };
|
||||
enum { kHistorySize = kMaxDelay + kLookahead };
|
||||
// Length of binary spectrum sequence.
|
||||
enum { kSequenceLength = 400 };
|
||||
|
||||
const int kDifferentHistorySize = 3;
|
||||
const int kDifferentLookahead = 1;
|
||||
|
||||
const int kEnable[] = { 0, 1 };
|
||||
const size_t kSizeEnable = sizeof(kEnable) / sizeof(*kEnable);
|
||||
|
||||
class DelayEstimatorTest : public ::testing::Test {
|
||||
protected:
|
||||
DelayEstimatorTest();
|
||||
virtual void SetUp();
|
||||
virtual void TearDown();
|
||||
|
||||
void Init();
|
||||
void InitBinary();
|
||||
void VerifyDelay(BinaryDelayEstimator* binary_handle, int offset, int delay);
|
||||
void RunBinarySpectra(BinaryDelayEstimator* binary1,
|
||||
BinaryDelayEstimator* binary2,
|
||||
int near_offset, int lookahead_offset, int far_offset);
|
||||
void RunBinarySpectraTest(int near_offset, int lookahead_offset,
|
||||
int ref_robust_validation, int robust_validation);
|
||||
|
||||
void* handle_;
|
||||
DelayEstimator* self_;
|
||||
void* farend_handle_;
|
||||
DelayEstimatorFarend* farend_self_;
|
||||
BinaryDelayEstimator* binary_;
|
||||
BinaryDelayEstimatorFarend* binary_farend_;
|
||||
int spectrum_size_;
|
||||
// Dummy input spectra.
|
||||
float far_f_[kSpectrumSize];
|
||||
float near_f_[kSpectrumSize];
|
||||
uint16_t far_u16_[kSpectrumSize];
|
||||
uint16_t near_u16_[kSpectrumSize];
|
||||
uint32_t binary_spectrum_[kSequenceLength + kHistorySize];
|
||||
};
|
||||
|
||||
DelayEstimatorTest::DelayEstimatorTest()
|
||||
: handle_(NULL),
|
||||
self_(NULL),
|
||||
farend_handle_(NULL),
|
||||
farend_self_(NULL),
|
||||
binary_(NULL),
|
||||
binary_farend_(NULL),
|
||||
spectrum_size_(kSpectrumSize) {
|
||||
// Dummy input data are set with more or less arbitrary non-zero values.
|
||||
memset(far_f_, 1, sizeof(far_f_));
|
||||
memset(near_f_, 2, sizeof(near_f_));
|
||||
memset(far_u16_, 1, sizeof(far_u16_));
|
||||
memset(near_u16_, 2, sizeof(near_u16_));
|
||||
// Construct a sequence of binary spectra used to verify delay estimate. The
|
||||
// |kSequenceLength| has to be long enough for the delay estimation to leave
|
||||
// the initialized state.
|
||||
binary_spectrum_[0] = 1;
|
||||
for (int i = 1; i < (kSequenceLength + kHistorySize); i++) {
|
||||
binary_spectrum_[i] = 3 * binary_spectrum_[i - 1];
|
||||
}
|
||||
}
|
||||
|
||||
void DelayEstimatorTest::SetUp() {
|
||||
farend_handle_ = WebRtc_CreateDelayEstimatorFarend(kSpectrumSize,
|
||||
kHistorySize);
|
||||
ASSERT_TRUE(farend_handle_ != NULL);
|
||||
farend_self_ = reinterpret_cast<DelayEstimatorFarend*>(farend_handle_);
|
||||
handle_ = WebRtc_CreateDelayEstimator(farend_handle_, kLookahead);
|
||||
ASSERT_TRUE(handle_ != NULL);
|
||||
self_ = reinterpret_cast<DelayEstimator*>(handle_);
|
||||
binary_farend_ = WebRtc_CreateBinaryDelayEstimatorFarend(kHistorySize);
|
||||
ASSERT_TRUE(binary_farend_ != NULL);
|
||||
binary_ = WebRtc_CreateBinaryDelayEstimator(binary_farend_, kLookahead);
|
||||
ASSERT_TRUE(binary_ != NULL);
|
||||
}
|
||||
|
||||
void DelayEstimatorTest::TearDown() {
|
||||
WebRtc_FreeDelayEstimator(handle_);
|
||||
handle_ = NULL;
|
||||
self_ = NULL;
|
||||
WebRtc_FreeDelayEstimatorFarend(farend_handle_);
|
||||
farend_handle_ = NULL;
|
||||
farend_self_ = NULL;
|
||||
WebRtc_FreeBinaryDelayEstimator(binary_);
|
||||
binary_ = NULL;
|
||||
WebRtc_FreeBinaryDelayEstimatorFarend(binary_farend_);
|
||||
binary_farend_ = NULL;
|
||||
}
|
||||
|
||||
void DelayEstimatorTest::Init() {
|
||||
// Initialize Delay Estimator
|
||||
EXPECT_EQ(0, WebRtc_InitDelayEstimatorFarend(farend_handle_));
|
||||
EXPECT_EQ(0, WebRtc_InitDelayEstimator(handle_));
|
||||
// Verify initialization.
|
||||
EXPECT_EQ(0, farend_self_->far_spectrum_initialized);
|
||||
EXPECT_EQ(0, self_->near_spectrum_initialized);
|
||||
EXPECT_EQ(-2, WebRtc_last_delay(handle_)); // Delay in initial state.
|
||||
EXPECT_FLOAT_EQ(0, WebRtc_last_delay_quality(handle_)); // Zero quality.
|
||||
}
|
||||
|
||||
void DelayEstimatorTest::InitBinary() {
|
||||
// Initialize Binary Delay Estimator (far-end part).
|
||||
WebRtc_InitBinaryDelayEstimatorFarend(binary_farend_);
|
||||
// Initialize Binary Delay Estimator
|
||||
WebRtc_InitBinaryDelayEstimator(binary_);
|
||||
// Verify initialization. This does not guarantee a complete check, since
|
||||
// |last_delay| may be equal to -2 before initialization if done on the fly.
|
||||
EXPECT_EQ(-2, binary_->last_delay);
|
||||
}
|
||||
|
||||
void DelayEstimatorTest::VerifyDelay(BinaryDelayEstimator* binary_handle,
|
||||
int offset, int delay) {
|
||||
// Verify that we WebRtc_binary_last_delay() returns correct delay.
|
||||
EXPECT_EQ(delay, WebRtc_binary_last_delay(binary_handle));
|
||||
|
||||
if (delay != -2) {
|
||||
// Verify correct delay estimate. In the non-causal case the true delay
|
||||
// is equivalent with the |offset|.
|
||||
EXPECT_EQ(offset, delay);
|
||||
}
|
||||
}
|
||||
|
||||
void DelayEstimatorTest::RunBinarySpectra(BinaryDelayEstimator* binary1,
|
||||
BinaryDelayEstimator* binary2,
|
||||
int near_offset,
|
||||
int lookahead_offset,
|
||||
int far_offset) {
|
||||
int different_validations = binary1->robust_validation_enabled ^
|
||||
binary2->robust_validation_enabled;
|
||||
WebRtc_InitBinaryDelayEstimatorFarend(binary_farend_);
|
||||
WebRtc_InitBinaryDelayEstimator(binary1);
|
||||
WebRtc_InitBinaryDelayEstimator(binary2);
|
||||
// Verify initialization. This does not guarantee a complete check, since
|
||||
// |last_delay| may be equal to -2 before initialization if done on the fly.
|
||||
EXPECT_EQ(-2, binary1->last_delay);
|
||||
EXPECT_EQ(-2, binary2->last_delay);
|
||||
for (int i = kLookahead; i < (kSequenceLength + kLookahead); i++) {
|
||||
WebRtc_AddBinaryFarSpectrum(binary_farend_,
|
||||
binary_spectrum_[i + far_offset]);
|
||||
int delay_1 = WebRtc_ProcessBinarySpectrum(binary1, binary_spectrum_[i]);
|
||||
int delay_2 =
|
||||
WebRtc_ProcessBinarySpectrum(binary2,
|
||||
binary_spectrum_[i - near_offset]);
|
||||
|
||||
VerifyDelay(binary1, far_offset + kLookahead, delay_1);
|
||||
VerifyDelay(binary2,
|
||||
far_offset + kLookahead + lookahead_offset + near_offset,
|
||||
delay_2);
|
||||
// Expect the two delay estimates to be offset by |lookahead_offset| +
|
||||
// |near_offset| when we have left the initial state.
|
||||
if ((delay_1 != -2) && (delay_2 != -2)) {
|
||||
EXPECT_EQ(delay_1, delay_2 - lookahead_offset - near_offset);
|
||||
}
|
||||
// For the case of identical signals |delay_1| and |delay_2| should match
|
||||
// all the time, unless one of them has robust validation turned on. In
|
||||
// that case the robust validation leaves the initial state faster.
|
||||
if ((near_offset == 0) && (lookahead_offset == 0)) {
|
||||
if (!different_validations) {
|
||||
EXPECT_EQ(delay_1, delay_2);
|
||||
} else {
|
||||
if (binary1->robust_validation_enabled) {
|
||||
EXPECT_GE(delay_1, delay_2);
|
||||
} else {
|
||||
EXPECT_GE(delay_2, delay_1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Verify that we have left the initialized state.
|
||||
EXPECT_NE(-2, WebRtc_binary_last_delay(binary1));
|
||||
EXPECT_LT(0, WebRtc_binary_last_delay_quality(binary1));
|
||||
EXPECT_NE(-2, WebRtc_binary_last_delay(binary2));
|
||||
EXPECT_LT(0, WebRtc_binary_last_delay_quality(binary2));
|
||||
}
|
||||
|
||||
void DelayEstimatorTest::RunBinarySpectraTest(int near_offset,
|
||||
int lookahead_offset,
|
||||
int ref_robust_validation,
|
||||
int robust_validation) {
|
||||
BinaryDelayEstimator* binary2 =
|
||||
WebRtc_CreateBinaryDelayEstimator(binary_farend_,
|
||||
kLookahead + lookahead_offset);
|
||||
// Verify the delay for both causal and non-causal systems. For causal systems
|
||||
// the delay is equivalent with a positive |offset| of the far-end sequence.
|
||||
// For non-causal systems the delay is equivalent with a negative |offset| of
|
||||
// the far-end sequence.
|
||||
binary_->robust_validation_enabled = ref_robust_validation;
|
||||
binary2->robust_validation_enabled = robust_validation;
|
||||
for (int offset = -kLookahead;
|
||||
offset < kMaxDelay - lookahead_offset - near_offset;
|
||||
offset++) {
|
||||
RunBinarySpectra(binary_, binary2, near_offset, lookahead_offset, offset);
|
||||
}
|
||||
WebRtc_FreeBinaryDelayEstimator(binary2);
|
||||
binary2 = NULL;
|
||||
binary_->robust_validation_enabled = 0; // Reset reference.
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, CorrectErrorReturnsOfWrapper) {
|
||||
// In this test we verify correct error returns on invalid API calls.
|
||||
|
||||
// WebRtc_CreateDelayEstimatorFarend() and WebRtc_CreateDelayEstimator()
|
||||
// should return a NULL pointer on invalid input values.
|
||||
// Make sure we have a non-NULL value at start, so we can detect NULL after
|
||||
// create failure.
|
||||
void* handle = farend_handle_;
|
||||
handle = WebRtc_CreateDelayEstimatorFarend(33, kHistorySize);
|
||||
EXPECT_TRUE(handle == NULL);
|
||||
handle = WebRtc_CreateDelayEstimatorFarend(kSpectrumSize, 1);
|
||||
EXPECT_TRUE(handle == NULL);
|
||||
|
||||
handle = handle_;
|
||||
handle = WebRtc_CreateDelayEstimator(NULL, kLookahead);
|
||||
EXPECT_TRUE(handle == NULL);
|
||||
handle = WebRtc_CreateDelayEstimator(farend_handle_, -1);
|
||||
EXPECT_TRUE(handle == NULL);
|
||||
|
||||
// WebRtc_InitDelayEstimatorFarend() and WebRtc_InitDelayEstimator() should
|
||||
// return -1 if we have a NULL pointer as |handle|.
|
||||
EXPECT_EQ(-1, WebRtc_InitDelayEstimatorFarend(NULL));
|
||||
EXPECT_EQ(-1, WebRtc_InitDelayEstimator(NULL));
|
||||
|
||||
// WebRtc_AddFarSpectrumFloat() should return -1 if we have:
|
||||
// 1) NULL pointer as |handle|.
|
||||
// 2) NULL pointer as far-end spectrum.
|
||||
// 3) Incorrect spectrum size.
|
||||
EXPECT_EQ(-1, WebRtc_AddFarSpectrumFloat(NULL, far_f_, spectrum_size_));
|
||||
// Use |farend_handle_| which is properly created at SetUp().
|
||||
EXPECT_EQ(-1, WebRtc_AddFarSpectrumFloat(farend_handle_, NULL,
|
||||
spectrum_size_));
|
||||
EXPECT_EQ(-1, WebRtc_AddFarSpectrumFloat(farend_handle_, far_f_,
|
||||
spectrum_size_ + 1));
|
||||
|
||||
// WebRtc_AddFarSpectrumFix() should return -1 if we have:
|
||||
// 1) NULL pointer as |handle|.
|
||||
// 2) NULL pointer as far-end spectrum.
|
||||
// 3) Incorrect spectrum size.
|
||||
// 4) Too high precision in far-end spectrum (Q-domain > 15).
|
||||
EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(NULL, far_u16_, spectrum_size_, 0));
|
||||
EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(farend_handle_, NULL, spectrum_size_,
|
||||
0));
|
||||
EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(farend_handle_, far_u16_,
|
||||
spectrum_size_ + 1, 0));
|
||||
EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(farend_handle_, far_u16_,
|
||||
spectrum_size_, 16));
|
||||
|
||||
// WebRtc_set_history_size() should return -1 if:
|
||||
// 1) |handle| is a NULL.
|
||||
// 2) |history_size| <= 1.
|
||||
EXPECT_EQ(-1, WebRtc_set_history_size(NULL, 1));
|
||||
EXPECT_EQ(-1, WebRtc_set_history_size(handle_, 1));
|
||||
// WebRtc_history_size() should return -1 if:
|
||||
// 1) NULL pointer input.
|
||||
EXPECT_EQ(-1, WebRtc_history_size(NULL));
|
||||
// 2) there is a mismatch between history size.
|
||||
void* tmp_handle = WebRtc_CreateDelayEstimator(farend_handle_, kHistorySize);
|
||||
EXPECT_EQ(0, WebRtc_InitDelayEstimator(tmp_handle));
|
||||
EXPECT_EQ(kDifferentHistorySize,
|
||||
WebRtc_set_history_size(tmp_handle, kDifferentHistorySize));
|
||||
EXPECT_EQ(kDifferentHistorySize, WebRtc_history_size(tmp_handle));
|
||||
EXPECT_EQ(kHistorySize, WebRtc_set_history_size(handle_, kHistorySize));
|
||||
EXPECT_EQ(-1, WebRtc_history_size(tmp_handle));
|
||||
|
||||
// WebRtc_set_lookahead() should return -1 if we try a value outside the
|
||||
/// buffer.
|
||||
EXPECT_EQ(-1, WebRtc_set_lookahead(handle_, kLookahead + 1));
|
||||
EXPECT_EQ(-1, WebRtc_set_lookahead(handle_, -1));
|
||||
|
||||
// WebRtc_set_allowed_offset() should return -1 if we have:
|
||||
// 1) NULL pointer as |handle|.
|
||||
// 2) |allowed_offset| < 0.
|
||||
EXPECT_EQ(-1, WebRtc_set_allowed_offset(NULL, 0));
|
||||
EXPECT_EQ(-1, WebRtc_set_allowed_offset(handle_, -1));
|
||||
|
||||
EXPECT_EQ(-1, WebRtc_get_allowed_offset(NULL));
|
||||
|
||||
// WebRtc_enable_robust_validation() should return -1 if we have:
|
||||
// 1) NULL pointer as |handle|.
|
||||
// 2) Incorrect |enable| value (not 0 or 1).
|
||||
EXPECT_EQ(-1, WebRtc_enable_robust_validation(NULL, kEnable[0]));
|
||||
EXPECT_EQ(-1, WebRtc_enable_robust_validation(handle_, -1));
|
||||
EXPECT_EQ(-1, WebRtc_enable_robust_validation(handle_, 2));
|
||||
|
||||
// WebRtc_is_robust_validation_enabled() should return -1 if we have NULL
|
||||
// pointer as |handle|.
|
||||
EXPECT_EQ(-1, WebRtc_is_robust_validation_enabled(NULL));
|
||||
|
||||
// WebRtc_DelayEstimatorProcessFloat() should return -1 if we have:
|
||||
// 1) NULL pointer as |handle|.
|
||||
// 2) NULL pointer as near-end spectrum.
|
||||
// 3) Incorrect spectrum size.
|
||||
// 4) Non matching history sizes if multiple delay estimators using the same
|
||||
// far-end reference.
|
||||
EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFloat(NULL, near_f_,
|
||||
spectrum_size_));
|
||||
// Use |handle_| which is properly created at SetUp().
|
||||
EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFloat(handle_, NULL,
|
||||
spectrum_size_));
|
||||
EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFloat(handle_, near_f_,
|
||||
spectrum_size_ + 1));
|
||||
// |tmp_handle| is already in a non-matching state.
|
||||
EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFloat(tmp_handle,
|
||||
near_f_,
|
||||
spectrum_size_));
|
||||
|
||||
// WebRtc_DelayEstimatorProcessFix() should return -1 if we have:
|
||||
// 1) NULL pointer as |handle|.
|
||||
// 2) NULL pointer as near-end spectrum.
|
||||
// 3) Incorrect spectrum size.
|
||||
// 4) Too high precision in near-end spectrum (Q-domain > 15).
|
||||
// 5) Non matching history sizes if multiple delay estimators using the same
|
||||
// far-end reference.
|
||||
EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(NULL, near_u16_, spectrum_size_,
|
||||
0));
|
||||
EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(handle_, NULL, spectrum_size_,
|
||||
0));
|
||||
EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(handle_, near_u16_,
|
||||
spectrum_size_ + 1, 0));
|
||||
EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(handle_, near_u16_,
|
||||
spectrum_size_, 16));
|
||||
// |tmp_handle| is already in a non-matching state.
|
||||
EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(tmp_handle,
|
||||
near_u16_,
|
||||
spectrum_size_,
|
||||
0));
|
||||
WebRtc_FreeDelayEstimator(tmp_handle);
|
||||
|
||||
// WebRtc_last_delay() should return -1 if we have a NULL pointer as |handle|.
|
||||
EXPECT_EQ(-1, WebRtc_last_delay(NULL));
|
||||
|
||||
// Free any local memory if needed.
|
||||
WebRtc_FreeDelayEstimator(handle);
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, VerifyAllowedOffset) {
|
||||
// Is set to zero by default.
|
||||
EXPECT_EQ(0, WebRtc_get_allowed_offset(handle_));
|
||||
for (int i = 1; i >= 0; i--) {
|
||||
EXPECT_EQ(0, WebRtc_set_allowed_offset(handle_, i));
|
||||
EXPECT_EQ(i, WebRtc_get_allowed_offset(handle_));
|
||||
Init();
|
||||
// Unaffected over a reset.
|
||||
EXPECT_EQ(i, WebRtc_get_allowed_offset(handle_));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, VerifyEnableRobustValidation) {
|
||||
// Disabled by default.
|
||||
EXPECT_EQ(0, WebRtc_is_robust_validation_enabled(handle_));
|
||||
for (size_t i = 0; i < kSizeEnable; ++i) {
|
||||
EXPECT_EQ(0, WebRtc_enable_robust_validation(handle_, kEnable[i]));
|
||||
EXPECT_EQ(kEnable[i], WebRtc_is_robust_validation_enabled(handle_));
|
||||
Init();
|
||||
// Unaffected over a reset.
|
||||
EXPECT_EQ(kEnable[i], WebRtc_is_robust_validation_enabled(handle_));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, InitializedSpectrumAfterProcess) {
|
||||
// In this test we verify that the mean spectra are initialized after first
|
||||
// time we call WebRtc_AddFarSpectrum() and Process() respectively. The test
|
||||
// also verifies the state is not left for zero spectra.
|
||||
const float kZerosFloat[kSpectrumSize] = { 0.0 };
|
||||
const uint16_t kZerosU16[kSpectrumSize] = { 0 };
|
||||
|
||||
// For floating point operations, process one frame and verify initialization
|
||||
// flag.
|
||||
Init();
|
||||
EXPECT_EQ(0, WebRtc_AddFarSpectrumFloat(farend_handle_, kZerosFloat,
|
||||
spectrum_size_));
|
||||
EXPECT_EQ(0, farend_self_->far_spectrum_initialized);
|
||||
EXPECT_EQ(0, WebRtc_AddFarSpectrumFloat(farend_handle_, far_f_,
|
||||
spectrum_size_));
|
||||
EXPECT_EQ(1, farend_self_->far_spectrum_initialized);
|
||||
EXPECT_EQ(-2, WebRtc_DelayEstimatorProcessFloat(handle_, kZerosFloat,
|
||||
spectrum_size_));
|
||||
EXPECT_EQ(0, self_->near_spectrum_initialized);
|
||||
EXPECT_EQ(-2, WebRtc_DelayEstimatorProcessFloat(handle_, near_f_,
|
||||
spectrum_size_));
|
||||
EXPECT_EQ(1, self_->near_spectrum_initialized);
|
||||
|
||||
// For fixed point operations, process one frame and verify initialization
|
||||
// flag.
|
||||
Init();
|
||||
EXPECT_EQ(0, WebRtc_AddFarSpectrumFix(farend_handle_, kZerosU16,
|
||||
spectrum_size_, 0));
|
||||
EXPECT_EQ(0, farend_self_->far_spectrum_initialized);
|
||||
EXPECT_EQ(0, WebRtc_AddFarSpectrumFix(farend_handle_, far_u16_,
|
||||
spectrum_size_, 0));
|
||||
EXPECT_EQ(1, farend_self_->far_spectrum_initialized);
|
||||
EXPECT_EQ(-2, WebRtc_DelayEstimatorProcessFix(handle_, kZerosU16,
|
||||
spectrum_size_, 0));
|
||||
EXPECT_EQ(0, self_->near_spectrum_initialized);
|
||||
EXPECT_EQ(-2, WebRtc_DelayEstimatorProcessFix(handle_, near_u16_,
|
||||
spectrum_size_, 0));
|
||||
EXPECT_EQ(1, self_->near_spectrum_initialized);
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, CorrectLastDelay) {
|
||||
// In this test we verify that we get the correct last delay upon valid call.
|
||||
// We simply process the same data until we leave the initialized state
|
||||
// (|last_delay| = -2). Then we compare the Process() output with the
|
||||
// last_delay() call.
|
||||
|
||||
// TODO(bjornv): Update quality values for robust validation.
|
||||
int last_delay = 0;
|
||||
// Floating point operations.
|
||||
Init();
|
||||
for (int i = 0; i < 200; i++) {
|
||||
EXPECT_EQ(0, WebRtc_AddFarSpectrumFloat(farend_handle_, far_f_,
|
||||
spectrum_size_));
|
||||
last_delay = WebRtc_DelayEstimatorProcessFloat(handle_, near_f_,
|
||||
spectrum_size_);
|
||||
if (last_delay != -2) {
|
||||
EXPECT_EQ(last_delay, WebRtc_last_delay(handle_));
|
||||
if (!WebRtc_is_robust_validation_enabled(handle_)) {
|
||||
EXPECT_FLOAT_EQ(7203.f / kMaxBitCountsQ9,
|
||||
WebRtc_last_delay_quality(handle_));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Verify that we have left the initialized state.
|
||||
EXPECT_NE(-2, WebRtc_last_delay(handle_));
|
||||
EXPECT_LT(0, WebRtc_last_delay_quality(handle_));
|
||||
|
||||
// Fixed point operations.
|
||||
Init();
|
||||
for (int i = 0; i < 200; i++) {
|
||||
EXPECT_EQ(0, WebRtc_AddFarSpectrumFix(farend_handle_, far_u16_,
|
||||
spectrum_size_, 0));
|
||||
last_delay = WebRtc_DelayEstimatorProcessFix(handle_, near_u16_,
|
||||
spectrum_size_, 0);
|
||||
if (last_delay != -2) {
|
||||
EXPECT_EQ(last_delay, WebRtc_last_delay(handle_));
|
||||
if (!WebRtc_is_robust_validation_enabled(handle_)) {
|
||||
EXPECT_FLOAT_EQ(7203.f / kMaxBitCountsQ9,
|
||||
WebRtc_last_delay_quality(handle_));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Verify that we have left the initialized state.
|
||||
EXPECT_NE(-2, WebRtc_last_delay(handle_));
|
||||
EXPECT_LT(0, WebRtc_last_delay_quality(handle_));
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, CorrectErrorReturnsOfBinaryEstimatorFarend) {
|
||||
// In this test we verify correct output on invalid API calls to the Binary
|
||||
// Delay Estimator (far-end part).
|
||||
|
||||
BinaryDelayEstimatorFarend* binary = binary_farend_;
|
||||
// WebRtc_CreateBinaryDelayEstimatorFarend() should return -1 if the input
|
||||
// history size is less than 2. This is to make sure the buffer shifting
|
||||
// applies properly.
|
||||
// Make sure we have a non-NULL value at start, so we can detect NULL after
|
||||
// create failure.
|
||||
binary = WebRtc_CreateBinaryDelayEstimatorFarend(1);
|
||||
EXPECT_TRUE(binary == NULL);
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, CorrectErrorReturnsOfBinaryEstimator) {
|
||||
// In this test we verify correct output on invalid API calls to the Binary
|
||||
// Delay Estimator.
|
||||
|
||||
BinaryDelayEstimator* binary_handle = binary_;
|
||||
// WebRtc_CreateBinaryDelayEstimator() should return -1 if we have a NULL
|
||||
// pointer as |binary_farend| or invalid input values. Upon failure, the
|
||||
// |binary_handle| should be NULL.
|
||||
// Make sure we have a non-NULL value at start, so we can detect NULL after
|
||||
// create failure.
|
||||
binary_handle = WebRtc_CreateBinaryDelayEstimator(NULL, kLookahead);
|
||||
EXPECT_TRUE(binary_handle == NULL);
|
||||
binary_handle = WebRtc_CreateBinaryDelayEstimator(binary_farend_, -1);
|
||||
EXPECT_TRUE(binary_handle == NULL);
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, MeanEstimatorFix) {
|
||||
// In this test we verify that we update the mean value in correct direction
|
||||
// only. With "direction" we mean increase or decrease.
|
||||
|
||||
int32_t mean_value = 4000;
|
||||
int32_t mean_value_before = mean_value;
|
||||
int32_t new_mean_value = mean_value * 2;
|
||||
|
||||
// Increasing |mean_value|.
|
||||
WebRtc_MeanEstimatorFix(new_mean_value, 10, &mean_value);
|
||||
EXPECT_LT(mean_value_before, mean_value);
|
||||
EXPECT_GT(new_mean_value, mean_value);
|
||||
|
||||
// Decreasing |mean_value|.
|
||||
new_mean_value = mean_value / 2;
|
||||
mean_value_before = mean_value;
|
||||
WebRtc_MeanEstimatorFix(new_mean_value, 10, &mean_value);
|
||||
EXPECT_GT(mean_value_before, mean_value);
|
||||
EXPECT_LT(new_mean_value, mean_value);
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, ExactDelayEstimateMultipleNearSameSpectrum) {
|
||||
// In this test we verify that we get the correct delay estimates if we shift
|
||||
// the signal accordingly. We create two Binary Delay Estimators and feed them
|
||||
// with the same signals, so they should output the same results.
|
||||
// We verify both causal and non-causal delays.
|
||||
// For these noise free signals, the robust validation should not have an
|
||||
// impact, hence we turn robust validation on/off for both reference and
|
||||
// delayed near end.
|
||||
|
||||
for (size_t i = 0; i < kSizeEnable; ++i) {
|
||||
for (size_t j = 0; j < kSizeEnable; ++j) {
|
||||
RunBinarySpectraTest(0, 0, kEnable[i], kEnable[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, ExactDelayEstimateMultipleNearDifferentSpectrum) {
|
||||
// In this test we use the same setup as above, but we now feed the two Binary
|
||||
// Delay Estimators with different signals, so they should output different
|
||||
// results.
|
||||
// For these noise free signals, the robust validation should not have an
|
||||
// impact, hence we turn robust validation on/off for both reference and
|
||||
// delayed near end.
|
||||
|
||||
const int kNearOffset = 1;
|
||||
for (size_t i = 0; i < kSizeEnable; ++i) {
|
||||
for (size_t j = 0; j < kSizeEnable; ++j) {
|
||||
RunBinarySpectraTest(kNearOffset, 0, kEnable[i], kEnable[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, ExactDelayEstimateMultipleNearDifferentLookahead) {
|
||||
// In this test we use the same setup as above, feeding the two Binary
|
||||
// Delay Estimators with the same signals. The difference is that we create
|
||||
// them with different lookahead.
|
||||
// For these noise free signals, the robust validation should not have an
|
||||
// impact, hence we turn robust validation on/off for both reference and
|
||||
// delayed near end.
|
||||
|
||||
const int kLookaheadOffset = 1;
|
||||
for (size_t i = 0; i < kSizeEnable; ++i) {
|
||||
for (size_t j = 0; j < kSizeEnable; ++j) {
|
||||
RunBinarySpectraTest(0, kLookaheadOffset, kEnable[i], kEnable[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, AllowedOffsetNoImpactWhenRobustValidationDisabled) {
|
||||
// The same setup as in ExactDelayEstimateMultipleNearSameSpectrum with the
|
||||
// difference that |allowed_offset| is set for the reference binary delay
|
||||
// estimator.
|
||||
|
||||
binary_->allowed_offset = 10;
|
||||
RunBinarySpectraTest(0, 0, 0, 0);
|
||||
binary_->allowed_offset = 0; // Reset reference.
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, VerifyLookaheadAtCreate) {
|
||||
void* farend_handle = WebRtc_CreateDelayEstimatorFarend(kSpectrumSize,
|
||||
kMaxDelay);
|
||||
ASSERT_TRUE(farend_handle != NULL);
|
||||
void* handle = WebRtc_CreateDelayEstimator(farend_handle, kLookahead);
|
||||
ASSERT_TRUE(handle != NULL);
|
||||
EXPECT_EQ(kLookahead, WebRtc_lookahead(handle));
|
||||
WebRtc_FreeDelayEstimator(handle);
|
||||
WebRtc_FreeDelayEstimatorFarend(farend_handle);
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, VerifyLookaheadIsSetAndKeptAfterInit) {
|
||||
EXPECT_EQ(kLookahead, WebRtc_lookahead(handle_));
|
||||
EXPECT_EQ(kDifferentLookahead,
|
||||
WebRtc_set_lookahead(handle_, kDifferentLookahead));
|
||||
EXPECT_EQ(kDifferentLookahead, WebRtc_lookahead(handle_));
|
||||
EXPECT_EQ(0, WebRtc_InitDelayEstimatorFarend(farend_handle_));
|
||||
EXPECT_EQ(kDifferentLookahead, WebRtc_lookahead(handle_));
|
||||
EXPECT_EQ(0, WebRtc_InitDelayEstimator(handle_));
|
||||
EXPECT_EQ(kDifferentLookahead, WebRtc_lookahead(handle_));
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, VerifyHistorySizeAtCreate) {
|
||||
EXPECT_EQ(kHistorySize, WebRtc_history_size(handle_));
|
||||
}
|
||||
|
||||
TEST_F(DelayEstimatorTest, VerifyHistorySizeIsSetAndKeptAfterInit) {
|
||||
EXPECT_EQ(kHistorySize, WebRtc_history_size(handle_));
|
||||
EXPECT_EQ(kDifferentHistorySize,
|
||||
WebRtc_set_history_size(handle_, kDifferentHistorySize));
|
||||
EXPECT_EQ(kDifferentHistorySize, WebRtc_history_size(handle_));
|
||||
EXPECT_EQ(0, WebRtc_InitDelayEstimator(handle_));
|
||||
EXPECT_EQ(kDifferentHistorySize, WebRtc_history_size(handle_));
|
||||
EXPECT_EQ(0, WebRtc_InitDelayEstimatorFarend(farend_handle_));
|
||||
EXPECT_EQ(kDifferentHistorySize, WebRtc_history_size(handle_));
|
||||
}
|
||||
|
||||
// TODO(bjornv): Add tests for SoftReset...(...).
|
||||
|
||||
} // namespace
|
||||
@@ -0,0 +1,485 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include "webrtc/modules/audio_processing/utility/delay_estimator_wrapper.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "webrtc/modules/audio_processing/utility/delay_estimator.h"
|
||||
#include "webrtc/modules/audio_processing/utility/delay_estimator_internal.h"
|
||||
#include "webrtc/system_wrappers/interface/compile_assert_c.h"
|
||||
|
||||
// Only bit |kBandFirst| through bit |kBandLast| are processed and
|
||||
// |kBandFirst| - |kBandLast| must be < 32.
|
||||
enum { kBandFirst = 12 };
|
||||
enum { kBandLast = 43 };
|
||||
|
||||
static __inline uint32_t SetBit(uint32_t in, int pos) {
|
||||
uint32_t mask = (1 << pos);
|
||||
uint32_t out = (in | mask);
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
// Calculates the mean recursively. Same version as WebRtc_MeanEstimatorFix(),
|
||||
// but for float.
|
||||
//
|
||||
// Inputs:
|
||||
// - new_value : New additional value.
|
||||
// - scale : Scale for smoothing (should be less than 1.0).
|
||||
//
|
||||
// Input/Output:
|
||||
// - mean_value : Pointer to the mean value for updating.
|
||||
//
|
||||
static void MeanEstimatorFloat(float new_value,
|
||||
float scale,
|
||||
float* mean_value) {
|
||||
assert(scale < 1.0f);
|
||||
*mean_value += (new_value - *mean_value) * scale;
|
||||
}
|
||||
|
||||
// Computes the binary spectrum by comparing the input |spectrum| with a
|
||||
// |threshold_spectrum|. Float and fixed point versions.
|
||||
//
|
||||
// Inputs:
|
||||
// - spectrum : Spectrum of which the binary spectrum should be
|
||||
// calculated.
|
||||
// - threshold_spectrum : Threshold spectrum with which the input
|
||||
// spectrum is compared.
|
||||
// Return:
|
||||
// - out : Binary spectrum.
|
||||
//
|
||||
static uint32_t BinarySpectrumFix(const uint16_t* spectrum,
|
||||
SpectrumType* threshold_spectrum,
|
||||
int q_domain,
|
||||
int* threshold_initialized) {
|
||||
int i = kBandFirst;
|
||||
uint32_t out = 0;
|
||||
|
||||
assert(q_domain < 16);
|
||||
|
||||
if (!(*threshold_initialized)) {
|
||||
// Set the |threshold_spectrum| to half the input |spectrum| as starting
|
||||
// value. This speeds up the convergence.
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
static uint32_t BinarySpectrumFloat(const float* spectrum,
|
||||
SpectrumType* threshold_spectrum,
|
||||
int* threshold_initialized) {
|
||||
int i = kBandFirst;
|
||||
uint32_t out = 0;
|
||||
const float kScale = 1 / 64.0;
|
||||
|
||||
if (!(*threshold_initialized)) {
|
||||
// Set the |threshold_spectrum| to half the input |spectrum| as starting
|
||||
// value. This speeds up the convergence.
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
void WebRtc_FreeDelayEstimatorFarend(void* handle) {
|
||||
DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
|
||||
|
||||
if (handle == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
free(self->mean_far_spectrum);
|
||||
self->mean_far_spectrum = NULL;
|
||||
|
||||
WebRtc_FreeBinaryDelayEstimatorFarend(self->binary_farend);
|
||||
self->binary_farend = NULL;
|
||||
|
||||
free(self);
|
||||
}
|
||||
|
||||
void* WebRtc_CreateDelayEstimatorFarend(int spectrum_size, int history_size) {
|
||||
DelayEstimatorFarend* self = NULL;
|
||||
|
||||
// Check if the sub band used in the delay estimation is small enough to fit
|
||||
// the binary spectra in a uint32_t.
|
||||
COMPILE_ASSERT(kBandLast - kBandFirst < 32);
|
||||
|
||||
if (spectrum_size >= kBandLast) {
|
||||
self = malloc(sizeof(DelayEstimatorFarend));
|
||||
}
|
||||
|
||||
if (self != NULL) {
|
||||
int memory_fail = 0;
|
||||
|
||||
// Allocate memory for the binary far-end spectrum handling.
|
||||
self->binary_farend = WebRtc_CreateBinaryDelayEstimatorFarend(history_size);
|
||||
memory_fail |= (self->binary_farend == NULL);
|
||||
|
||||
// Allocate memory for spectrum buffers.
|
||||
self->mean_far_spectrum = malloc(spectrum_size * sizeof(SpectrumType));
|
||||
memory_fail |= (self->mean_far_spectrum == NULL);
|
||||
|
||||
self->spectrum_size = spectrum_size;
|
||||
|
||||
if (memory_fail) {
|
||||
WebRtc_FreeDelayEstimatorFarend(self);
|
||||
self = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
int WebRtc_InitDelayEstimatorFarend(void* handle) {
|
||||
DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
|
||||
|
||||
if (self == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Initialize far-end part of binary delay estimator.
|
||||
WebRtc_InitBinaryDelayEstimatorFarend(self->binary_farend);
|
||||
|
||||
// Set averaged far and near end spectra to zero.
|
||||
memset(self->mean_far_spectrum, 0,
|
||||
sizeof(SpectrumType) * self->spectrum_size);
|
||||
// Reset initialization indicators.
|
||||
self->far_spectrum_initialized = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void WebRtc_SoftResetDelayEstimatorFarend(void* handle, int delay_shift) {
|
||||
DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
|
||||
assert(self != NULL);
|
||||
WebRtc_SoftResetBinaryDelayEstimatorFarend(self->binary_farend, delay_shift);
|
||||
}
|
||||
|
||||
int WebRtc_AddFarSpectrumFix(void* handle,
|
||||
const uint16_t* far_spectrum,
|
||||
int spectrum_size,
|
||||
int far_q) {
|
||||
DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
|
||||
uint32_t binary_spectrum = 0;
|
||||
|
||||
if (self == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (far_spectrum == NULL) {
|
||||
// Empty far end spectrum.
|
||||
return -1;
|
||||
}
|
||||
if (spectrum_size != self->spectrum_size) {
|
||||
// Data sizes don't match.
|
||||
return -1;
|
||||
}
|
||||
if (far_q > 15) {
|
||||
// If |far_q| is larger than 15 we cannot guarantee no wrap around.
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Get binary spectrum.
|
||||
binary_spectrum = BinarySpectrumFix(far_spectrum, self->mean_far_spectrum,
|
||||
far_q, &(self->far_spectrum_initialized));
|
||||
WebRtc_AddBinaryFarSpectrum(self->binary_farend, binary_spectrum);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int WebRtc_AddFarSpectrumFloat(void* handle,
|
||||
const float* far_spectrum,
|
||||
int spectrum_size) {
|
||||
DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
|
||||
uint32_t binary_spectrum = 0;
|
||||
|
||||
if (self == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (far_spectrum == NULL) {
|
||||
// Empty far end spectrum.
|
||||
return -1;
|
||||
}
|
||||
if (spectrum_size != self->spectrum_size) {
|
||||
// Data sizes don't match.
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Get binary spectrum.
|
||||
binary_spectrum = BinarySpectrumFloat(far_spectrum, self->mean_far_spectrum,
|
||||
&(self->far_spectrum_initialized));
|
||||
WebRtc_AddBinaryFarSpectrum(self->binary_farend, binary_spectrum);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void WebRtc_FreeDelayEstimator(void* handle) {
|
||||
DelayEstimator* self = (DelayEstimator*) handle;
|
||||
|
||||
if (handle == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
free(self->mean_near_spectrum);
|
||||
self->mean_near_spectrum = NULL;
|
||||
|
||||
WebRtc_FreeBinaryDelayEstimator(self->binary_handle);
|
||||
self->binary_handle = NULL;
|
||||
|
||||
free(self);
|
||||
}
|
||||
|
||||
void* WebRtc_CreateDelayEstimator(void* farend_handle, int max_lookahead) {
|
||||
DelayEstimator* self = NULL;
|
||||
DelayEstimatorFarend* farend = (DelayEstimatorFarend*) farend_handle;
|
||||
|
||||
if (farend_handle != NULL) {
|
||||
self = malloc(sizeof(DelayEstimator));
|
||||
}
|
||||
|
||||
if (self != NULL) {
|
||||
int memory_fail = 0;
|
||||
|
||||
// Allocate memory for the farend spectrum handling.
|
||||
self->binary_handle =
|
||||
WebRtc_CreateBinaryDelayEstimator(farend->binary_farend, max_lookahead);
|
||||
memory_fail |= (self->binary_handle == NULL);
|
||||
|
||||
// Allocate memory for spectrum buffers.
|
||||
self->mean_near_spectrum = malloc(farend->spectrum_size *
|
||||
sizeof(SpectrumType));
|
||||
memory_fail |= (self->mean_near_spectrum == NULL);
|
||||
|
||||
self->spectrum_size = farend->spectrum_size;
|
||||
|
||||
if (memory_fail) {
|
||||
WebRtc_FreeDelayEstimator(self);
|
||||
self = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
int WebRtc_InitDelayEstimator(void* handle) {
|
||||
DelayEstimator* self = (DelayEstimator*) handle;
|
||||
|
||||
if (self == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Initialize binary delay estimator.
|
||||
WebRtc_InitBinaryDelayEstimator(self->binary_handle);
|
||||
|
||||
// Set averaged far and near end spectra to zero.
|
||||
memset(self->mean_near_spectrum, 0,
|
||||
sizeof(SpectrumType) * self->spectrum_size);
|
||||
// Reset initialization indicators.
|
||||
self->near_spectrum_initialized = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int WebRtc_SoftResetDelayEstimator(void* handle, int delay_shift) {
|
||||
DelayEstimator* self = (DelayEstimator*) handle;
|
||||
assert(self != NULL);
|
||||
return WebRtc_SoftResetBinaryDelayEstimator(self->binary_handle, delay_shift);
|
||||
}
|
||||
|
||||
int WebRtc_set_history_size(void* handle, int history_size) {
|
||||
DelayEstimator* self = handle;
|
||||
|
||||
if ((self == NULL) || (history_size <= 1)) {
|
||||
return -1;
|
||||
}
|
||||
return WebRtc_AllocateHistoryBufferMemory(self->binary_handle, history_size);
|
||||
}
|
||||
|
||||
int WebRtc_history_size(const void* handle) {
|
||||
const DelayEstimator* self = handle;
|
||||
|
||||
if (self == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (self->binary_handle->farend->history_size !=
|
||||
self->binary_handle->history_size) {
|
||||
// Non matching history sizes.
|
||||
return -1;
|
||||
}
|
||||
return self->binary_handle->history_size;
|
||||
}
|
||||
|
||||
int WebRtc_set_lookahead(void* handle, int lookahead) {
|
||||
DelayEstimator* self = (DelayEstimator*) handle;
|
||||
assert(self != NULL);
|
||||
assert(self->binary_handle != NULL);
|
||||
if ((lookahead > self->binary_handle->near_history_size - 1) ||
|
||||
(lookahead < 0)) {
|
||||
return -1;
|
||||
}
|
||||
self->binary_handle->lookahead = lookahead;
|
||||
return self->binary_handle->lookahead;
|
||||
}
|
||||
|
||||
int WebRtc_lookahead(void* handle) {
|
||||
DelayEstimator* self = (DelayEstimator*) handle;
|
||||
assert(self != NULL);
|
||||
assert(self->binary_handle != NULL);
|
||||
return self->binary_handle->lookahead;
|
||||
}
|
||||
|
||||
int WebRtc_set_allowed_offset(void* handle, int allowed_offset) {
|
||||
DelayEstimator* self = (DelayEstimator*) handle;
|
||||
|
||||
if ((self == NULL) || (allowed_offset < 0)) {
|
||||
return -1;
|
||||
}
|
||||
self->binary_handle->allowed_offset = allowed_offset;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int WebRtc_get_allowed_offset(const void* handle) {
|
||||
const DelayEstimator* self = (const DelayEstimator*) handle;
|
||||
|
||||
if (self == NULL) {
|
||||
return -1;
|
||||
}
|
||||
return self->binary_handle->allowed_offset;
|
||||
}
|
||||
|
||||
int WebRtc_enable_robust_validation(void* handle, int enable) {
|
||||
DelayEstimator* self = (DelayEstimator*) handle;
|
||||
|
||||
if (self == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if ((enable < 0) || (enable > 1)) {
|
||||
return -1;
|
||||
}
|
||||
assert(self->binary_handle != NULL);
|
||||
self->binary_handle->robust_validation_enabled = enable;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int WebRtc_is_robust_validation_enabled(const void* handle) {
|
||||
const DelayEstimator* self = (const DelayEstimator*) handle;
|
||||
|
||||
if (self == NULL) {
|
||||
return -1;
|
||||
}
|
||||
return self->binary_handle->robust_validation_enabled;
|
||||
}
|
||||
|
||||
int WebRtc_DelayEstimatorProcessFix(void* handle,
|
||||
const uint16_t* near_spectrum,
|
||||
int spectrum_size,
|
||||
int near_q) {
|
||||
DelayEstimator* self = (DelayEstimator*) handle;
|
||||
uint32_t binary_spectrum = 0;
|
||||
|
||||
if (self == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (near_spectrum == NULL) {
|
||||
// Empty near end spectrum.
|
||||
return -1;
|
||||
}
|
||||
if (spectrum_size != self->spectrum_size) {
|
||||
// Data sizes don't match.
|
||||
return -1;
|
||||
}
|
||||
if (near_q > 15) {
|
||||
// If |near_q| is larger than 15 we cannot guarantee no wrap around.
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Get binary spectra.
|
||||
binary_spectrum = BinarySpectrumFix(near_spectrum,
|
||||
self->mean_near_spectrum,
|
||||
near_q,
|
||||
&(self->near_spectrum_initialized));
|
||||
|
||||
return WebRtc_ProcessBinarySpectrum(self->binary_handle, binary_spectrum);
|
||||
}
|
||||
|
||||
int WebRtc_DelayEstimatorProcessFloat(void* handle,
|
||||
const float* near_spectrum,
|
||||
int spectrum_size) {
|
||||
DelayEstimator* self = (DelayEstimator*) handle;
|
||||
uint32_t binary_spectrum = 0;
|
||||
|
||||
if (self == NULL) {
|
||||
return -1;
|
||||
}
|
||||
if (near_spectrum == NULL) {
|
||||
// Empty near end spectrum.
|
||||
return -1;
|
||||
}
|
||||
if (spectrum_size != self->spectrum_size) {
|
||||
// Data sizes don't match.
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Get binary spectrum.
|
||||
binary_spectrum = BinarySpectrumFloat(near_spectrum, self->mean_near_spectrum,
|
||||
&(self->near_spectrum_initialized));
|
||||
|
||||
return WebRtc_ProcessBinarySpectrum(self->binary_handle, binary_spectrum);
|
||||
}
|
||||
|
||||
int WebRtc_last_delay(void* handle) {
|
||||
DelayEstimator* self = (DelayEstimator*) handle;
|
||||
|
||||
if (self == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return WebRtc_binary_last_delay(self->binary_handle);
|
||||
}
|
||||
|
||||
float WebRtc_last_delay_quality(void* handle) {
|
||||
DelayEstimator* self = (DelayEstimator*) handle;
|
||||
assert(self != NULL);
|
||||
return WebRtc_binary_last_delay_quality(self->binary_handle);
|
||||
}
|
||||
@@ -0,0 +1,244 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
// Performs delay estimation on block by block basis.
|
||||
// The return value is 0 - OK and -1 - Error, unless otherwise stated.
|
||||
|
||||
#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_WRAPPER_H_
|
||||
#define WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_WRAPPER_H_
|
||||
|
||||
#include "webrtc/typedefs.h"
|
||||
|
||||
// Releases the memory allocated by WebRtc_CreateDelayEstimatorFarend(...)
|
||||
void WebRtc_FreeDelayEstimatorFarend(void* handle);
|
||||
|
||||
// Allocates the memory needed by the far-end part of the delay estimation. The
|
||||
// memory needs to be initialized separately through
|
||||
// WebRtc_InitDelayEstimatorFarend(...).
|
||||
//
|
||||
// Inputs:
|
||||
// - spectrum_size : Size of the spectrum used both in far-end and
|
||||
// near-end. Used to allocate memory for spectrum
|
||||
// specific buffers.
|
||||
// - history_size : The far-end history buffer size. A change in buffer
|
||||
// size can be forced with WebRtc_set_history_size().
|
||||
// Note that the maximum delay which can be estimated is
|
||||
// determined together with WebRtc_set_lookahead().
|
||||
//
|
||||
// Return value:
|
||||
// - void* : Created |handle|. If the memory can't be allocated or
|
||||
// if any of the input parameters are invalid NULL is
|
||||
// returned.
|
||||
void* WebRtc_CreateDelayEstimatorFarend(int spectrum_size, int history_size);
|
||||
|
||||
// Initializes the far-end part of the delay estimation instance returned by
|
||||
// WebRtc_CreateDelayEstimatorFarend(...)
|
||||
int WebRtc_InitDelayEstimatorFarend(void* handle);
|
||||
|
||||
// Soft resets the far-end part of the delay estimation instance returned by
|
||||
// WebRtc_CreateDelayEstimatorFarend(...).
|
||||
// Input:
|
||||
// - delay_shift : The amount of blocks to shift history buffers.
|
||||
void WebRtc_SoftResetDelayEstimatorFarend(void* handle, int delay_shift);
|
||||
|
||||
// Adds the far-end spectrum to the far-end history buffer. This spectrum is
|
||||
// used as reference when calculating the delay using
|
||||
// WebRtc_ProcessSpectrum().
|
||||
//
|
||||
// Inputs:
|
||||
// - far_spectrum : Far-end spectrum.
|
||||
// - spectrum_size : The size of the data arrays (same for both far- and
|
||||
// near-end).
|
||||
// - far_q : The Q-domain of the far-end data.
|
||||
//
|
||||
// Output:
|
||||
// - handle : Updated far-end instance.
|
||||
//
|
||||
int WebRtc_AddFarSpectrumFix(void* handle,
|
||||
const uint16_t* far_spectrum,
|
||||
int spectrum_size,
|
||||
int far_q);
|
||||
|
||||
// See WebRtc_AddFarSpectrumFix() for description.
|
||||
int WebRtc_AddFarSpectrumFloat(void* handle,
|
||||
const float* far_spectrum,
|
||||
int spectrum_size);
|
||||
|
||||
// Releases the memory allocated by WebRtc_CreateDelayEstimator(...)
|
||||
void WebRtc_FreeDelayEstimator(void* handle);
|
||||
|
||||
// Allocates the memory needed by the delay estimation. The memory needs to be
|
||||
// initialized separately through WebRtc_InitDelayEstimator(...).
|
||||
//
|
||||
// Inputs:
|
||||
// - farend_handle : Pointer to the far-end part of the delay estimation
|
||||
// instance created prior to this call using
|
||||
// WebRtc_CreateDelayEstimatorFarend().
|
||||
//
|
||||
// Note that WebRtc_CreateDelayEstimator does not take
|
||||
// ownership of |farend_handle|, which has to be torn
|
||||
// down properly after this instance.
|
||||
//
|
||||
// - max_lookahead : Maximum amount of non-causal lookahead allowed. The
|
||||
// actual amount of lookahead used can be controlled by
|
||||
// WebRtc_set_lookahead(...). The default |lookahead| is
|
||||
// set to |max_lookahead| at create time. Use
|
||||
// WebRtc_set_lookahead(...) before start if a different
|
||||
// value is desired.
|
||||
//
|
||||
// Using lookahead can detect cases in which a near-end
|
||||
// signal occurs before the corresponding far-end signal.
|
||||
// It will delay the estimate for the current block by an
|
||||
// equal amount, and the returned values will be offset
|
||||
// by it.
|
||||
//
|
||||
// A value of zero is the typical no-lookahead case.
|
||||
// This also represents the minimum delay which can be
|
||||
// estimated.
|
||||
//
|
||||
// Note that the effective range of delay estimates is
|
||||
// [-|lookahead|,... ,|history_size|-|lookahead|)
|
||||
// where |history_size| is set through
|
||||
// WebRtc_set_history_size().
|
||||
//
|
||||
// Return value:
|
||||
// - void* : Created |handle|. If the memory can't be allocated or
|
||||
// if any of the input parameters are invalid NULL is
|
||||
// returned.
|
||||
void* WebRtc_CreateDelayEstimator(void* farend_handle, int max_lookahead);
|
||||
|
||||
// Initializes the delay estimation instance returned by
|
||||
// WebRtc_CreateDelayEstimator(...)
|
||||
int WebRtc_InitDelayEstimator(void* handle);
|
||||
|
||||
// Soft resets the delay estimation instance returned by
|
||||
// WebRtc_CreateDelayEstimator(...)
|
||||
// Input:
|
||||
// - delay_shift : The amount of blocks to shift history buffers.
|
||||
//
|
||||
// Return value:
|
||||
// - actual_shifts : The actual number of shifts performed.
|
||||
int WebRtc_SoftResetDelayEstimator(void* handle, int delay_shift);
|
||||
|
||||
// Sets the effective |history_size| used. Valid values from 2. We simply need
|
||||
// at least two delays to compare to perform an estimate. If |history_size| is
|
||||
// changed, buffers are reallocated filling in with zeros if necessary.
|
||||
// Note that changing the |history_size| affects both buffers in far-end and
|
||||
// near-end. Hence it is important to change all DelayEstimators that use the
|
||||
// same reference far-end, to the same |history_size| value.
|
||||
// Inputs:
|
||||
// - handle : Pointer to the delay estimation instance.
|
||||
// - history_size : Effective history size to be used.
|
||||
// Return value:
|
||||
// - new_history_size : The new history size used. If the memory was not able
|
||||
// to be allocated 0 is returned.
|
||||
int WebRtc_set_history_size(void* handle, int history_size);
|
||||
|
||||
// Returns the history_size currently used.
|
||||
// Input:
|
||||
// - handle : Pointer to the delay estimation instance.
|
||||
int WebRtc_history_size(const void* handle);
|
||||
|
||||
// Sets the amount of |lookahead| to use. Valid values are [0, max_lookahead]
|
||||
// where |max_lookahead| was set at create time through
|
||||
// WebRtc_CreateDelayEstimator(...).
|
||||
//
|
||||
// Input:
|
||||
// - handle : Pointer to the delay estimation instance.
|
||||
// - lookahead : The amount of lookahead to be used.
|
||||
//
|
||||
// Return value:
|
||||
// - new_lookahead : The actual amount of lookahead set, unless |handle| is
|
||||
// a NULL pointer or |lookahead| is invalid, for which an
|
||||
// error is returned.
|
||||
int WebRtc_set_lookahead(void* handle, int lookahead);
|
||||
|
||||
// Returns the amount of lookahead we currently use.
|
||||
// Input:
|
||||
// - handle : Pointer to the delay estimation instance.
|
||||
int WebRtc_lookahead(void* handle);
|
||||
|
||||
// Sets the |allowed_offset| used in the robust validation scheme. If the
|
||||
// delay estimator is used in an echo control component, this parameter is
|
||||
// related to the filter length. In principle |allowed_offset| should be set to
|
||||
// the echo control filter length minus the expected echo duration, i.e., the
|
||||
// delay offset the echo control can handle without quality regression. The
|
||||
// default value, used if not set manually, is zero. Note that |allowed_offset|
|
||||
// has to be non-negative.
|
||||
// Inputs:
|
||||
// - handle : Pointer to the delay estimation instance.
|
||||
// - allowed_offset : The amount of delay offset, measured in partitions,
|
||||
// the echo control filter can handle.
|
||||
int WebRtc_set_allowed_offset(void* handle, int allowed_offset);
|
||||
|
||||
// Returns the |allowed_offset| in number of partitions.
|
||||
int WebRtc_get_allowed_offset(const void* handle);
|
||||
|
||||
// Enables/Disables a robust validation functionality in the delay estimation.
|
||||
// This is by default set to disabled at create time. The state is preserved
|
||||
// over a reset.
|
||||
// Inputs:
|
||||
// - handle : Pointer to the delay estimation instance.
|
||||
// - enable : Enable (1) or disable (0) this feature.
|
||||
int WebRtc_enable_robust_validation(void* handle, int enable);
|
||||
|
||||
// Returns 1 if robust validation is enabled and 0 if disabled.
|
||||
int WebRtc_is_robust_validation_enabled(const void* handle);
|
||||
|
||||
// Estimates and returns the delay between the far-end and near-end blocks. The
|
||||
// value will be offset by the lookahead (i.e. the lookahead should be
|
||||
// subtracted from the returned value).
|
||||
// Inputs:
|
||||
// - handle : Pointer to the delay estimation instance.
|
||||
// - near_spectrum : Pointer to the near-end spectrum data of the current
|
||||
// block.
|
||||
// - spectrum_size : The size of the data arrays (same for both far- and
|
||||
// near-end).
|
||||
// - near_q : The Q-domain of the near-end data.
|
||||
//
|
||||
// Output:
|
||||
// - handle : Updated instance.
|
||||
//
|
||||
// Return value:
|
||||
// - delay : >= 0 - Calculated delay value.
|
||||
// -1 - Error.
|
||||
// -2 - Insufficient data for estimation.
|
||||
int WebRtc_DelayEstimatorProcessFix(void* handle,
|
||||
const uint16_t* near_spectrum,
|
||||
int spectrum_size,
|
||||
int near_q);
|
||||
|
||||
// See WebRtc_DelayEstimatorProcessFix() for description.
|
||||
int WebRtc_DelayEstimatorProcessFloat(void* handle,
|
||||
const float* near_spectrum,
|
||||
int spectrum_size);
|
||||
|
||||
// Returns the last calculated delay updated by the function
|
||||
// WebRtc_DelayEstimatorProcess(...).
|
||||
//
|
||||
// Input:
|
||||
// - handle : Pointer to the delay estimation instance.
|
||||
//
|
||||
// Return value:
|
||||
// - delay : >= 0 - Last calculated delay value.
|
||||
// -1 - Error.
|
||||
// -2 - Insufficient data for estimation.
|
||||
int WebRtc_last_delay(void* handle);
|
||||
|
||||
// Returns the estimation quality/probability of the last calculated delay
|
||||
// updated by the function WebRtc_DelayEstimatorProcess(...). The estimation
|
||||
// quality is a value in the interval [0, 1]. The higher the value, the better
|
||||
// the quality.
|
||||
//
|
||||
// Return value:
|
||||
// - delay_quality : >= 0 - Estimation quality of last calculated delay.
|
||||
float WebRtc_last_delay_quality(void* handle);
|
||||
|
||||
#endif // WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_DELAY_ESTIMATOR_WRAPPER_H_
|
||||
1326
jni/webrtc/modules/audio_processing/utility/fft4g.c
Normal file
1326
jni/webrtc/modules/audio_processing/utility/fft4g.c
Normal file
File diff suppressed because it is too large
Load Diff
17
jni/webrtc/modules/audio_processing/utility/fft4g.h
Normal file
17
jni/webrtc/modules/audio_processing/utility/fft4g.h
Normal file
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_FFT4G_H_
|
||||
#define WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_FFT4G_H_
|
||||
|
||||
void WebRtc_rdft(int, int, float *, int *, float *);
|
||||
void WebRtc_cdft(int, int, float *, int *, float *);
|
||||
|
||||
#endif
|
||||
252
jni/webrtc/modules/audio_processing/utility/ring_buffer.c
Normal file
252
jni/webrtc/modules/audio_processing/utility/ring_buffer.c
Normal file
@@ -0,0 +1,252 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
// A ring buffer to hold arbitrary data. Provides no thread safety. Unless
|
||||
// otherwise specified, functions return 0 on success and -1 on error.
|
||||
|
||||
#include "webrtc/modules/audio_processing/utility/ring_buffer.h"
|
||||
|
||||
#include <stddef.h> // size_t
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
enum Wrap {
|
||||
SAME_WRAP,
|
||||
DIFF_WRAP
|
||||
};
|
||||
|
||||
struct RingBuffer {
|
||||
size_t read_pos;
|
||||
size_t write_pos;
|
||||
size_t element_count;
|
||||
size_t element_size;
|
||||
enum Wrap rw_wrap;
|
||||
char* data;
|
||||
};
|
||||
|
||||
// Get address of region(s) from which we can read data.
|
||||
// If the region is contiguous, |data_ptr_bytes_2| will be zero.
|
||||
// If non-contiguous, |data_ptr_bytes_2| will be the size in bytes of the second
|
||||
// region. Returns room available to be read or |element_count|, whichever is
|
||||
// smaller.
|
||||
static size_t GetBufferReadRegions(RingBuffer* buf,
|
||||
size_t element_count,
|
||||
void** data_ptr_1,
|
||||
size_t* data_ptr_bytes_1,
|
||||
void** data_ptr_2,
|
||||
size_t* data_ptr_bytes_2) {
|
||||
|
||||
const size_t readable_elements = WebRtc_available_read(buf);
|
||||
const size_t read_elements = (readable_elements < element_count ?
|
||||
readable_elements : element_count);
|
||||
const size_t margin = buf->element_count - buf->read_pos;
|
||||
|
||||
// Check to see if read is not contiguous.
|
||||
if (read_elements > margin) {
|
||||
// Write data in two blocks that wrap the buffer.
|
||||
*data_ptr_1 = buf->data + buf->read_pos * buf->element_size;
|
||||
*data_ptr_bytes_1 = margin * buf->element_size;
|
||||
*data_ptr_2 = buf->data;
|
||||
*data_ptr_bytes_2 = (read_elements - margin) * buf->element_size;
|
||||
} else {
|
||||
*data_ptr_1 = buf->data + buf->read_pos * buf->element_size;
|
||||
*data_ptr_bytes_1 = read_elements * buf->element_size;
|
||||
*data_ptr_2 = NULL;
|
||||
*data_ptr_bytes_2 = 0;
|
||||
}
|
||||
|
||||
return read_elements;
|
||||
}
|
||||
|
||||
RingBuffer* WebRtc_CreateBuffer(size_t element_count, size_t element_size) {
|
||||
RingBuffer* self = NULL;
|
||||
if (element_count == 0 || element_size == 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
self = malloc(sizeof(RingBuffer));
|
||||
if (!self) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
self->data = malloc(element_count * element_size);
|
||||
if (!self->data) {
|
||||
free(self);
|
||||
self = NULL;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
self->element_count = element_count;
|
||||
self->element_size = element_size;
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
int WebRtc_InitBuffer(RingBuffer* self) {
|
||||
if (!self) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
self->read_pos = 0;
|
||||
self->write_pos = 0;
|
||||
self->rw_wrap = SAME_WRAP;
|
||||
|
||||
// Initialize buffer to zeros
|
||||
memset(self->data, 0, self->element_count * self->element_size);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void WebRtc_FreeBuffer(void* handle) {
|
||||
RingBuffer* self = (RingBuffer*)handle;
|
||||
if (!self) {
|
||||
return;
|
||||
}
|
||||
|
||||
free(self->data);
|
||||
free(self);
|
||||
}
|
||||
|
||||
size_t WebRtc_ReadBuffer(RingBuffer* self,
|
||||
void** data_ptr,
|
||||
void* data,
|
||||
size_t element_count) {
|
||||
|
||||
if (self == NULL) {
|
||||
return 0;
|
||||
}
|
||||
if (data == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
{
|
||||
void* buf_ptr_1 = NULL;
|
||||
void* buf_ptr_2 = NULL;
|
||||
size_t buf_ptr_bytes_1 = 0;
|
||||
size_t buf_ptr_bytes_2 = 0;
|
||||
const size_t read_count = GetBufferReadRegions(self,
|
||||
element_count,
|
||||
&buf_ptr_1,
|
||||
&buf_ptr_bytes_1,
|
||||
&buf_ptr_2,
|
||||
&buf_ptr_bytes_2);
|
||||
|
||||
if (buf_ptr_bytes_2 > 0) {
|
||||
// We have a wrap around when reading the buffer. Copy the buffer data to
|
||||
// |data| and point to it.
|
||||
memcpy(data, buf_ptr_1, buf_ptr_bytes_1);
|
||||
memcpy(((char*) data) + buf_ptr_bytes_1, buf_ptr_2, buf_ptr_bytes_2);
|
||||
buf_ptr_1 = data;
|
||||
} else if (!data_ptr) {
|
||||
// No wrap, but a memcpy was requested.
|
||||
memcpy(data, buf_ptr_1, buf_ptr_bytes_1);
|
||||
}
|
||||
if (data_ptr) {
|
||||
// |buf_ptr_1| == |data| in the case of a wrap.
|
||||
*data_ptr = buf_ptr_1;
|
||||
}
|
||||
|
||||
// Update read position
|
||||
WebRtc_MoveReadPtr(self, (int) read_count);
|
||||
|
||||
return read_count;
|
||||
}
|
||||
}
|
||||
|
||||
size_t WebRtc_WriteBuffer(RingBuffer* self,
|
||||
const void* data,
|
||||
size_t element_count) {
|
||||
if (!self) {
|
||||
return 0;
|
||||
}
|
||||
if (!data) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
{
|
||||
const size_t free_elements = WebRtc_available_write(self);
|
||||
const size_t write_elements = (free_elements < element_count ? free_elements
|
||||
: element_count);
|
||||
size_t n = write_elements;
|
||||
const size_t margin = self->element_count - self->write_pos;
|
||||
|
||||
if (write_elements > margin) {
|
||||
// Buffer wrap around when writing.
|
||||
memcpy(self->data + self->write_pos * self->element_size,
|
||||
data, margin * self->element_size);
|
||||
self->write_pos = 0;
|
||||
n -= margin;
|
||||
self->rw_wrap = DIFF_WRAP;
|
||||
}
|
||||
memcpy(self->data + self->write_pos * self->element_size,
|
||||
((const char*) data) + ((write_elements - n) * self->element_size),
|
||||
n * self->element_size);
|
||||
self->write_pos += n;
|
||||
|
||||
return write_elements;
|
||||
}
|
||||
}
|
||||
|
||||
int WebRtc_MoveReadPtr(RingBuffer* self, int element_count) {
|
||||
if (!self) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
{
|
||||
// We need to be able to take care of negative changes, hence use "int"
|
||||
// instead of "size_t".
|
||||
const int free_elements = (int) WebRtc_available_write(self);
|
||||
const int readable_elements = (int) WebRtc_available_read(self);
|
||||
int read_pos = (int) self->read_pos;
|
||||
|
||||
if (element_count > readable_elements) {
|
||||
element_count = readable_elements;
|
||||
}
|
||||
if (element_count < -free_elements) {
|
||||
element_count = -free_elements;
|
||||
}
|
||||
|
||||
read_pos += element_count;
|
||||
if (read_pos > (int) self->element_count) {
|
||||
// Buffer wrap around. Restart read position and wrap indicator.
|
||||
read_pos -= (int) self->element_count;
|
||||
self->rw_wrap = SAME_WRAP;
|
||||
}
|
||||
if (read_pos < 0) {
|
||||
// Buffer wrap around. Restart read position and wrap indicator.
|
||||
read_pos += (int) self->element_count;
|
||||
self->rw_wrap = DIFF_WRAP;
|
||||
}
|
||||
|
||||
self->read_pos = (size_t) read_pos;
|
||||
|
||||
return element_count;
|
||||
}
|
||||
}
|
||||
|
||||
size_t WebRtc_available_read(const RingBuffer* self) {
|
||||
if (!self) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (self->rw_wrap == SAME_WRAP) {
|
||||
return self->write_pos - self->read_pos;
|
||||
} else {
|
||||
return self->element_count - self->read_pos + self->write_pos;
|
||||
}
|
||||
}
|
||||
|
||||
size_t WebRtc_available_write(const RingBuffer* self) {
|
||||
if (!self) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return self->element_count - WebRtc_available_read(self);
|
||||
}
|
||||
58
jni/webrtc/modules/audio_processing/utility/ring_buffer.h
Normal file
58
jni/webrtc/modules/audio_processing/utility/ring_buffer.h
Normal file
@@ -0,0 +1,58 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
// A ring buffer to hold arbitrary data. Provides no thread safety. Unless
|
||||
// otherwise specified, functions return 0 on success and -1 on error.
|
||||
|
||||
#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_RING_BUFFER_H_
|
||||
#define WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_RING_BUFFER_H_
|
||||
|
||||
#include <stddef.h> // size_t
|
||||
|
||||
typedef struct RingBuffer RingBuffer;
|
||||
|
||||
// Returns NULL on failure.
|
||||
RingBuffer* WebRtc_CreateBuffer(size_t element_count, size_t element_size);
|
||||
int WebRtc_InitBuffer(RingBuffer* handle);
|
||||
void WebRtc_FreeBuffer(void* handle);
|
||||
|
||||
// Reads data from the buffer. The |data_ptr| will point to the address where
|
||||
// it is located. If all |element_count| data are feasible to read without
|
||||
// buffer wrap around |data_ptr| will point to the location in the buffer.
|
||||
// Otherwise, the data will be copied to |data| (memory allocation done by the
|
||||
// user) and |data_ptr| points to the address of |data|. |data_ptr| is only
|
||||
// guaranteed to be valid until the next call to WebRtc_WriteBuffer().
|
||||
//
|
||||
// To force a copying to |data|, pass a NULL |data_ptr|.
|
||||
//
|
||||
// Returns number of elements read.
|
||||
size_t WebRtc_ReadBuffer(RingBuffer* handle,
|
||||
void** data_ptr,
|
||||
void* data,
|
||||
size_t element_count);
|
||||
|
||||
// Writes |data| to buffer and returns the number of elements written.
|
||||
size_t WebRtc_WriteBuffer(RingBuffer* handle, const void* data,
|
||||
size_t element_count);
|
||||
|
||||
// Moves the buffer read position and returns the number of elements moved.
|
||||
// Positive |element_count| moves the read position towards the write position,
|
||||
// that is, flushing the buffer. Negative |element_count| moves the read
|
||||
// position away from the the write position, that is, stuffing the buffer.
|
||||
// Returns number of elements moved.
|
||||
int WebRtc_MoveReadPtr(RingBuffer* handle, int element_count);
|
||||
|
||||
// Returns number of available elements to read.
|
||||
size_t WebRtc_available_read(const RingBuffer* handle);
|
||||
|
||||
// Returns number of available elements for write.
|
||||
size_t WebRtc_available_write(const RingBuffer* handle);
|
||||
|
||||
#endif // WEBRTC_MODULES_AUDIO_PROCESSING_UTILITY_RING_BUFFER_H_
|
||||
@@ -0,0 +1,152 @@
|
||||
/*
|
||||
* Copyright (c) 2013 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.
|
||||
*/
|
||||
|
||||
// TODO(ajm): Make this a comprehensive test.
|
||||
|
||||
extern "C" {
|
||||
#include "webrtc/modules/audio_processing/utility/ring_buffer.h"
|
||||
}
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
|
||||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
struct FreeBufferDeleter {
|
||||
inline void operator()(void* ptr) const {
|
||||
WebRtc_FreeBuffer(ptr);
|
||||
}
|
||||
};
|
||||
typedef scoped_ptr<RingBuffer, FreeBufferDeleter> scoped_ring_buffer;
|
||||
|
||||
static void AssertElementEq(int expected, int actual) {
|
||||
ASSERT_EQ(expected, actual);
|
||||
}
|
||||
|
||||
static int SetIncrementingData(int* data, int num_elements,
|
||||
int starting_value) {
|
||||
for (int i = 0; i < num_elements; i++) {
|
||||
data[i] = starting_value++;
|
||||
}
|
||||
return starting_value;
|
||||
}
|
||||
|
||||
static int CheckIncrementingData(int* data, int num_elements,
|
||||
int starting_value) {
|
||||
for (int i = 0; i < num_elements; i++) {
|
||||
AssertElementEq(starting_value++, data[i]);
|
||||
}
|
||||
return starting_value;
|
||||
}
|
||||
|
||||
// We use ASSERTs in this test to avoid obscuring the seed in the case of a
|
||||
// failure.
|
||||
static void RandomStressTest(int** data_ptr) {
|
||||
const int kNumTests = 10;
|
||||
const int kNumOps = 1000;
|
||||
const int kMaxBufferSize = 1000;
|
||||
|
||||
unsigned int seed = time(NULL);
|
||||
printf("seed=%u\n", seed);
|
||||
srand(seed);
|
||||
for (int i = 0; i < kNumTests; i++) {
|
||||
const int buffer_size = std::max(rand() % kMaxBufferSize, 1);
|
||||
scoped_ptr<int[]> write_data(new int[buffer_size]);
|
||||
scoped_ptr<int[]> read_data(new int[buffer_size]);
|
||||
scoped_ring_buffer buffer(WebRtc_CreateBuffer(buffer_size, sizeof(int)));
|
||||
ASSERT_TRUE(buffer.get() != NULL);
|
||||
ASSERT_EQ(0, WebRtc_InitBuffer(buffer.get()));
|
||||
int buffer_consumed = 0;
|
||||
int write_element = 0;
|
||||
int read_element = 0;
|
||||
for (int j = 0; j < kNumOps; j++) {
|
||||
const bool write = rand() % 2 == 0 ? true : false;
|
||||
const int num_elements = rand() % buffer_size;
|
||||
if (write) {
|
||||
const int buffer_available = buffer_size - buffer_consumed;
|
||||
ASSERT_EQ(static_cast<size_t>(buffer_available),
|
||||
WebRtc_available_write(buffer.get()));
|
||||
const int expected_elements = std::min(num_elements, buffer_available);
|
||||
write_element = SetIncrementingData(write_data.get(), expected_elements,
|
||||
write_element);
|
||||
ASSERT_EQ(static_cast<size_t>(expected_elements),
|
||||
WebRtc_WriteBuffer(buffer.get(), write_data.get(),
|
||||
num_elements));
|
||||
buffer_consumed = std::min(buffer_consumed + expected_elements,
|
||||
buffer_size);
|
||||
} else {
|
||||
const int expected_elements = std::min(num_elements,
|
||||
buffer_consumed);
|
||||
ASSERT_EQ(static_cast<size_t>(buffer_consumed),
|
||||
WebRtc_available_read(buffer.get()));
|
||||
ASSERT_EQ(static_cast<size_t>(expected_elements),
|
||||
WebRtc_ReadBuffer(buffer.get(),
|
||||
reinterpret_cast<void**>(data_ptr),
|
||||
read_data.get(),
|
||||
num_elements));
|
||||
int* check_ptr = read_data.get();
|
||||
if (data_ptr) {
|
||||
check_ptr = *data_ptr;
|
||||
}
|
||||
read_element = CheckIncrementingData(check_ptr, expected_elements,
|
||||
read_element);
|
||||
buffer_consumed = std::max(buffer_consumed - expected_elements, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(RingBufferTest, RandomStressTest) {
|
||||
int* data_ptr = NULL;
|
||||
RandomStressTest(&data_ptr);
|
||||
}
|
||||
|
||||
TEST(RingBufferTest, RandomStressTestWithNullPtr) {
|
||||
RandomStressTest(NULL);
|
||||
}
|
||||
|
||||
TEST(RingBufferTest, PassingNulltoReadBufferForcesMemcpy) {
|
||||
const size_t kDataSize = 2;
|
||||
int write_data[kDataSize];
|
||||
int read_data[kDataSize];
|
||||
int* data_ptr;
|
||||
|
||||
scoped_ring_buffer buffer(WebRtc_CreateBuffer(kDataSize, sizeof(int)));
|
||||
ASSERT_TRUE(buffer.get() != NULL);
|
||||
ASSERT_EQ(0, WebRtc_InitBuffer(buffer.get()));
|
||||
|
||||
SetIncrementingData(write_data, kDataSize, 0);
|
||||
EXPECT_EQ(kDataSize, WebRtc_WriteBuffer(buffer.get(), write_data, kDataSize));
|
||||
SetIncrementingData(read_data, kDataSize, kDataSize);
|
||||
EXPECT_EQ(kDataSize, WebRtc_ReadBuffer(buffer.get(),
|
||||
reinterpret_cast<void**>(&data_ptr), read_data, kDataSize));
|
||||
// Copying was not necessary, so |read_data| has not been updated.
|
||||
CheckIncrementingData(data_ptr, kDataSize, 0);
|
||||
CheckIncrementingData(read_data, kDataSize, kDataSize);
|
||||
|
||||
EXPECT_EQ(kDataSize, WebRtc_WriteBuffer(buffer.get(), write_data, kDataSize));
|
||||
EXPECT_EQ(kDataSize, WebRtc_ReadBuffer(buffer.get(), NULL, read_data,
|
||||
kDataSize));
|
||||
// Passing NULL forces a memcpy, so |read_data| is now updated.
|
||||
CheckIncrementingData(read_data, kDataSize, 0);
|
||||
}
|
||||
|
||||
TEST(RingBufferTest, CreateHandlesErrors) {
|
||||
EXPECT_TRUE(WebRtc_CreateBuffer(0, 1) == NULL);
|
||||
EXPECT_TRUE(WebRtc_CreateBuffer(1, 0) == NULL);
|
||||
RingBuffer* buffer = WebRtc_CreateBuffer(1, 1);
|
||||
EXPECT_TRUE(buffer != NULL);
|
||||
WebRtc_FreeBuffer(buffer);
|
||||
}
|
||||
|
||||
} // namespace webrtc
|
||||
Reference in New Issue
Block a user