Format the rest of C files in the repo
Formatting done via: git ls-files | grep -E '.*\.c$' | grep -Ev '^common_audio/signal_processing.*\.c$' | xargs clang-format -i No-Iwyu: Includes didn't change and it isn't related to formatting Bug: webrtc:42225392 Change-Id: Id78af8e3eceada9995e53b6a0fdc1a8cb5ffd1f3 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/373907 Reviewed-by: Danil Chapovalov <danilchap@webrtc.org> Reviewed-by: Harald Alvestrand <hta@webrtc.org> Commit-Queue: Harald Alvestrand <hta@webrtc.org> Cr-Commit-Position: refs/heads/main@{#43699}
This commit is contained in:
Boris Tsirkin
WebRTC LUCI CQ
parent
7eb83a3a18
commit
c940dba16a
@ -28,10 +28,9 @@ static size_t GetBufferReadRegions(RingBuffer* buf,
|
||||
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 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.
|
||||
@ -99,7 +98,6 @@ size_t WebRtc_ReadBuffer(RingBuffer* self,
|
||||
void** data_ptr,
|
||||
void* data,
|
||||
size_t element_count) {
|
||||
|
||||
if (self == NULL) {
|
||||
return 0;
|
||||
}
|
||||
@ -112,12 +110,9 @@ size_t WebRtc_ReadBuffer(RingBuffer* self,
|
||||
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);
|
||||
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.
|
||||
@ -152,15 +147,15 @@ size_t WebRtc_WriteBuffer(RingBuffer* self,
|
||||
|
||||
{
|
||||
const size_t free_elements = WebRtc_available_write(self);
|
||||
const size_t write_elements = (free_elements < element_count ? free_elements
|
||||
: element_count);
|
||||
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);
|
||||
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;
|
||||
|
||||
@ -10,11 +10,11 @@
|
||||
|
||||
#include "common_audio/vad/vad_core.h"
|
||||
|
||||
#include "rtc_base/sanitizer.h"
|
||||
#include "common_audio/signal_processing/include/signal_processing_library.h"
|
||||
#include "common_audio/vad/vad_filterbank.h"
|
||||
#include "common_audio/vad/vad_gmm.h"
|
||||
#include "common_audio/vad/vad_sp.h"
|
||||
#include "rtc_base/sanitizer.h"
|
||||
|
||||
// Spectrum Weighting
|
||||
static const int16_t kSpectrumWeight[kNumChannels] = {6, 8, 10, 12, 14, 16};
|
||||
@ -22,30 +22,30 @@ static const int16_t kNoiseUpdateConst = 655; // Q15
|
||||
static const int16_t kSpeechUpdateConst = 6554; // Q15
|
||||
static const int16_t kBackEta = 154; // Q8
|
||||
// Minimum difference between the two models, Q5
|
||||
static const int16_t kMinimumDifference[kNumChannels] = {
|
||||
544, 544, 576, 576, 576, 576 };
|
||||
static const int16_t kMinimumDifference[kNumChannels] = {544, 544, 576,
|
||||
576, 576, 576};
|
||||
// Upper limit of mean value for speech model, Q7
|
||||
static const int16_t kMaximumSpeech[kNumChannels] = {
|
||||
11392, 11392, 11520, 11520, 11520, 11520 };
|
||||
static const int16_t kMaximumSpeech[kNumChannels] = {11392, 11392, 11520,
|
||||
11520, 11520, 11520};
|
||||
// Minimum value for mean value
|
||||
static const int16_t kMinimumMean[kNumGaussians] = {640, 768};
|
||||
// Upper limit of mean value for noise model, Q7
|
||||
static const int16_t kMaximumNoise[kNumChannels] = {
|
||||
9216, 9088, 8960, 8832, 8704, 8576 };
|
||||
static const int16_t kMaximumNoise[kNumChannels] = {9216, 9088, 8960,
|
||||
8832, 8704, 8576};
|
||||
// Start values for the Gaussian models, Q7
|
||||
// Weights for the two Gaussians for the six channels (noise)
|
||||
static const int16_t kNoiseDataWeights[kTableSize] = {
|
||||
34, 62, 72, 66, 53, 25, 94, 66, 56, 62, 75, 103 };
|
||||
static const int16_t kNoiseDataWeights[kTableSize] = {34, 62, 72, 66, 53, 25,
|
||||
94, 66, 56, 62, 75, 103};
|
||||
// Weights for the two Gaussians for the six channels (speech)
|
||||
static const int16_t kSpeechDataWeights[kTableSize] = {
|
||||
48, 82, 45, 87, 50, 47, 80, 46, 83, 41, 78, 81 };
|
||||
static const int16_t kSpeechDataWeights[kTableSize] = {48, 82, 45, 87, 50, 47,
|
||||
80, 46, 83, 41, 78, 81};
|
||||
// Means for the two Gaussians for the six channels (noise)
|
||||
static const int16_t kNoiseDataMeans[kTableSize] = {
|
||||
6738, 4892, 7065, 6715, 6771, 3369, 7646, 3863, 7820, 7266, 5020, 4362};
|
||||
// Means for the two Gaussians for the six channels (speech)
|
||||
static const int16_t kSpeechDataMeans[kTableSize] = {
|
||||
8306, 10085, 10078, 11823, 11843, 6309, 9473, 9571, 10879, 7581, 8180, 7483
|
||||
};
|
||||
static const int16_t kSpeechDataMeans[kTableSize] = {8306, 10085, 10078, 11823,
|
||||
11843, 6309, 9473, 9571,
|
||||
10879, 7581, 8180, 7483};
|
||||
// Stds for the two Gaussians for the six channels (noise)
|
||||
static const int16_t kNoiseDataStds[kTableSize] = {
|
||||
378, 1064, 493, 582, 688, 593, 474, 697, 475, 688, 421, 455};
|
||||
@ -98,7 +98,8 @@ static const int16_t kGlobalThresholdVAG[3] = { 1100, 1050, 1100 };
|
||||
// - weights [i] : Weights used for averaging.
|
||||
//
|
||||
// returns : The weighted average.
|
||||
static int32_t WeightedAverage(int16_t* data, int16_t offset,
|
||||
static int32_t WeightedAverage(int16_t* data,
|
||||
int16_t offset,
|
||||
const int16_t* weights) {
|
||||
int k;
|
||||
int32_t weighted_average = 0;
|
||||
@ -130,8 +131,10 @@ static inline int32_t RTC_NO_SANITIZE("signed-integer-overflow")
|
||||
// - frame_length [i] : Number of input samples
|
||||
//
|
||||
// - returns : the VAD decision (0 - noise, 1 - speech).
|
||||
static int16_t GmmProbability(VadInstT* self, int16_t* features,
|
||||
int16_t total_power, size_t frame_length) {
|
||||
static int16_t GmmProbability(VadInstT* self,
|
||||
int16_t* features,
|
||||
int16_t total_power,
|
||||
size_t frame_length) {
|
||||
int channel, k;
|
||||
int16_t feature_minimum;
|
||||
int16_t h0, h1;
|
||||
@ -194,19 +197,17 @@ static int16_t GmmProbability(VadInstT* self, int16_t* features,
|
||||
gaussian = channel + k * kNumChannels;
|
||||
// Probability under H0, that is, probability of frame being noise.
|
||||
// Value given in Q27 = Q7 * Q20.
|
||||
tmp1_s32 = WebRtcVad_GaussianProbability(features[channel],
|
||||
self->noise_means[gaussian],
|
||||
self->noise_stds[gaussian],
|
||||
&deltaN[gaussian]);
|
||||
tmp1_s32 = WebRtcVad_GaussianProbability(
|
||||
features[channel], self->noise_means[gaussian],
|
||||
self->noise_stds[gaussian], &deltaN[gaussian]);
|
||||
noise_probability[k] = kNoiseDataWeights[gaussian] * tmp1_s32;
|
||||
h0_test += noise_probability[k]; // Q27
|
||||
|
||||
// Probability under H1, that is, probability of frame being speech.
|
||||
// Value given in Q27 = Q7 * Q20.
|
||||
tmp1_s32 = WebRtcVad_GaussianProbability(features[channel],
|
||||
self->speech_means[gaussian],
|
||||
self->speech_stds[gaussian],
|
||||
&deltaS[gaussian]);
|
||||
tmp1_s32 = WebRtcVad_GaussianProbability(
|
||||
features[channel], self->speech_means[gaussian],
|
||||
self->speech_stds[gaussian], &deltaS[gaussian]);
|
||||
speech_probability[k] = kSpeechDataWeights[gaussian] * tmp1_s32;
|
||||
h1_test += speech_probability[k]; // Q27
|
||||
}
|
||||
@ -277,7 +278,6 @@ static int16_t GmmProbability(VadInstT* self, int16_t* features,
|
||||
// Update the model parameters.
|
||||
maxspe = 12800;
|
||||
for (channel = 0; channel < kNumChannels; channel++) {
|
||||
|
||||
// Get minimum value in past which is used for long term correction in Q4.
|
||||
feature_minimum = WebRtcVad_FindMinimum(self, features[channel], channel);
|
||||
|
||||
@ -432,15 +432,15 @@ static int16_t GmmProbability(VadInstT* self, int16_t* features,
|
||||
// Move Gaussian means for speech model by `tmp1_s16` and update
|
||||
// `speech_global_mean`. Note that `self->speech_means[channel]` is
|
||||
// changed after the call.
|
||||
speech_global_mean = WeightedAverage(&self->speech_means[channel],
|
||||
tmp1_s16,
|
||||
speech_global_mean =
|
||||
WeightedAverage(&self->speech_means[channel], tmp1_s16,
|
||||
&kSpeechDataWeights[channel]);
|
||||
|
||||
// Move Gaussian means for noise model by -`tmp2_s16` and update
|
||||
// `noise_global_mean`. Note that `self->noise_means[channel]` is
|
||||
// changed after the call.
|
||||
noise_global_mean = WeightedAverage(&self->noise_means[channel],
|
||||
-tmp2_s16,
|
||||
noise_global_mean =
|
||||
WeightedAverage(&self->noise_means[channel], -tmp2_s16,
|
||||
&kNoiseDataWeights[channel]);
|
||||
}
|
||||
|
||||
@ -555,10 +555,8 @@ int WebRtcVad_set_mode_core(VadInstT* self, int mode) {
|
||||
sizeof(self->over_hang_max_1));
|
||||
memcpy(self->over_hang_max_2, kOverHangMax2Q,
|
||||
sizeof(self->over_hang_max_2));
|
||||
memcpy(self->individual, kLocalThresholdQ,
|
||||
sizeof(self->individual));
|
||||
memcpy(self->total, kGlobalThresholdQ,
|
||||
sizeof(self->total));
|
||||
memcpy(self->individual, kLocalThresholdQ, sizeof(self->individual));
|
||||
memcpy(self->total, kGlobalThresholdQ, sizeof(self->total));
|
||||
break;
|
||||
case 1:
|
||||
// Low bitrate mode.
|
||||
@ -566,10 +564,8 @@ int WebRtcVad_set_mode_core(VadInstT* self, int mode) {
|
||||
sizeof(self->over_hang_max_1));
|
||||
memcpy(self->over_hang_max_2, kOverHangMax2LBR,
|
||||
sizeof(self->over_hang_max_2));
|
||||
memcpy(self->individual, kLocalThresholdLBR,
|
||||
sizeof(self->individual));
|
||||
memcpy(self->total, kGlobalThresholdLBR,
|
||||
sizeof(self->total));
|
||||
memcpy(self->individual, kLocalThresholdLBR, sizeof(self->individual));
|
||||
memcpy(self->total, kGlobalThresholdLBR, sizeof(self->total));
|
||||
break;
|
||||
case 2:
|
||||
// Aggressive mode.
|
||||
@ -577,10 +573,8 @@ int WebRtcVad_set_mode_core(VadInstT* self, int mode) {
|
||||
sizeof(self->over_hang_max_1));
|
||||
memcpy(self->over_hang_max_2, kOverHangMax2AGG,
|
||||
sizeof(self->over_hang_max_2));
|
||||
memcpy(self->individual, kLocalThresholdAGG,
|
||||
sizeof(self->individual));
|
||||
memcpy(self->total, kGlobalThresholdAGG,
|
||||
sizeof(self->total));
|
||||
memcpy(self->individual, kLocalThresholdAGG, sizeof(self->individual));
|
||||
memcpy(self->total, kGlobalThresholdAGG, sizeof(self->total));
|
||||
break;
|
||||
case 3:
|
||||
// Very aggressive mode.
|
||||
@ -588,10 +582,8 @@ int WebRtcVad_set_mode_core(VadInstT* self, int mode) {
|
||||
sizeof(self->over_hang_max_1));
|
||||
memcpy(self->over_hang_max_2, kOverHangMax2VAG,
|
||||
sizeof(self->over_hang_max_2));
|
||||
memcpy(self->individual, kLocalThresholdVAG,
|
||||
sizeof(self->individual));
|
||||
memcpy(self->total, kGlobalThresholdVAG,
|
||||
sizeof(self->total));
|
||||
memcpy(self->individual, kLocalThresholdVAG, sizeof(self->individual));
|
||||
memcpy(self->total, kGlobalThresholdVAG, sizeof(self->total));
|
||||
break;
|
||||
default:
|
||||
return_value = -1;
|
||||
@ -604,7 +596,8 @@ int WebRtcVad_set_mode_core(VadInstT* self, int mode) {
|
||||
// Calculate VAD decision by first extracting feature values and then calculate
|
||||
// probability for both speech and background noise.
|
||||
|
||||
int WebRtcVad_CalcVad48khz(VadInstT* inst, const int16_t* speech_frame,
|
||||
int WebRtcVad_CalcVad48khz(VadInstT* inst,
|
||||
const int16_t* speech_frame,
|
||||
size_t frame_length) {
|
||||
int vad;
|
||||
size_t i;
|
||||
@ -619,8 +612,7 @@ int WebRtcVad_CalcVad48khz(VadInstT* inst, const int16_t* speech_frame,
|
||||
for (i = 0; i < num_10ms_frames; i++) {
|
||||
WebRtcSpl_Resample48khzTo8khz(speech_frame,
|
||||
&speech_nb[i * kFrameLen10ms8khz],
|
||||
&inst->state_48_to_8,
|
||||
tmp_mem);
|
||||
&inst->state_48_to_8, tmp_mem);
|
||||
}
|
||||
|
||||
// Do VAD on an 8 kHz signal
|
||||
@ -629,21 +621,21 @@ int WebRtcVad_CalcVad48khz(VadInstT* inst, const int16_t* speech_frame,
|
||||
return vad;
|
||||
}
|
||||
|
||||
int WebRtcVad_CalcVad32khz(VadInstT* inst, const int16_t* speech_frame,
|
||||
size_t frame_length)
|
||||
{
|
||||
int WebRtcVad_CalcVad32khz(VadInstT* inst,
|
||||
const int16_t* speech_frame,
|
||||
size_t frame_length) {
|
||||
size_t len;
|
||||
int vad;
|
||||
int16_t speechWB[480]; // Downsampled speech frame: 960 samples (30ms in SWB)
|
||||
int16_t speechNB[240]; // Downsampled speech frame: 480 samples (30ms in WB)
|
||||
|
||||
|
||||
// Downsample signal 32->16->8 before doing VAD
|
||||
WebRtcVad_Downsampling(speech_frame, speechWB, &(inst->downsampling_filter_states[2]),
|
||||
frame_length);
|
||||
WebRtcVad_Downsampling(speech_frame, speechWB,
|
||||
&(inst->downsampling_filter_states[2]), frame_length);
|
||||
len = frame_length / 2;
|
||||
|
||||
WebRtcVad_Downsampling(speechWB, speechNB, inst->downsampling_filter_states, len);
|
||||
WebRtcVad_Downsampling(speechWB, speechNB, inst->downsampling_filter_states,
|
||||
len);
|
||||
len /= 2;
|
||||
|
||||
// Do VAD on an 8 kHz signal
|
||||
@ -652,16 +644,16 @@ int WebRtcVad_CalcVad32khz(VadInstT* inst, const int16_t* speech_frame,
|
||||
return vad;
|
||||
}
|
||||
|
||||
int WebRtcVad_CalcVad16khz(VadInstT* inst, const int16_t* speech_frame,
|
||||
size_t frame_length)
|
||||
{
|
||||
int WebRtcVad_CalcVad16khz(VadInstT* inst,
|
||||
const int16_t* speech_frame,
|
||||
size_t frame_length) {
|
||||
size_t len;
|
||||
int vad;
|
||||
int16_t speechNB[240]; // Downsampled speech frame: 480 samples (30ms in WB)
|
||||
|
||||
// Wideband: Downsample signal before doing VAD
|
||||
WebRtcVad_Downsampling(speech_frame, speechNB, inst->downsampling_filter_states,
|
||||
frame_length);
|
||||
WebRtcVad_Downsampling(speech_frame, speechNB,
|
||||
inst->downsampling_filter_states, frame_length);
|
||||
|
||||
len = frame_length / 2;
|
||||
vad = WebRtcVad_CalcVad8khz(inst, speechNB, len);
|
||||
@ -669,9 +661,9 @@ int WebRtcVad_CalcVad16khz(VadInstT* inst, const int16_t* speech_frame,
|
||||
return vad;
|
||||
}
|
||||
|
||||
int WebRtcVad_CalcVad8khz(VadInstT* inst, const int16_t* speech_frame,
|
||||
size_t frame_length)
|
||||
{
|
||||
int WebRtcVad_CalcVad8khz(VadInstT* inst,
|
||||
const int16_t* speech_frame,
|
||||
size_t frame_length) {
|
||||
int16_t feature_vector[kNumChannels], total_power;
|
||||
|
||||
// Get power in the bands
|
||||
|
||||
@ -10,8 +10,8 @@
|
||||
|
||||
#include "common_audio/vad/vad_filterbank.h"
|
||||
|
||||
#include "rtc_base/checks.h"
|
||||
#include "common_audio/signal_processing/include/signal_processing_library.h"
|
||||
#include "rtc_base/checks.h"
|
||||
|
||||
// Constants used in LogOfEnergy().
|
||||
static const int16_t kLogConst = 24660; // 160*log10(2) in Q9.
|
||||
@ -36,14 +36,15 @@ static const int16_t kOffsetVector[6] = { 368, 368, 272, 176, 176, 176 };
|
||||
// - filter_state [i/o] : State of the filter.
|
||||
// - data_out [o] : Output audio data in the frequency interval
|
||||
// 80 - 250 Hz.
|
||||
static void HighPassFilter(const int16_t* data_in, size_t data_length,
|
||||
int16_t* filter_state, int16_t* data_out) {
|
||||
static void HighPassFilter(const int16_t* data_in,
|
||||
size_t data_length,
|
||||
int16_t* filter_state,
|
||||
int16_t* data_out) {
|
||||
size_t i;
|
||||
const int16_t* in_ptr = data_in;
|
||||
int16_t* out_ptr = data_out;
|
||||
int32_t tmp32 = 0;
|
||||
|
||||
|
||||
// The sum of the absolute values of the impulse response:
|
||||
// The zero/pole-filter has a max amplification of a single sample of: 1.4546
|
||||
// Impulse response: 0.4047 -0.6179 -0.0266 0.1993 0.1035 -0.0194
|
||||
@ -78,8 +79,10 @@ static void HighPassFilter(const int16_t* data_in, size_t data_length,
|
||||
// - filter_coefficient [i] : Given in Q15.
|
||||
// - filter_state [i/o] : State of the filter given in Q(-1).
|
||||
// - data_out [o] : Output audio signal given in Q(-1).
|
||||
static void AllPassFilter(const int16_t* data_in, size_t data_length,
|
||||
int16_t filter_coefficient, int16_t* filter_state,
|
||||
static void AllPassFilter(const int16_t* data_in,
|
||||
size_t data_length,
|
||||
int16_t filter_coefficient,
|
||||
int16_t* filter_state,
|
||||
int16_t* data_out) {
|
||||
// The filter can only cause overflow (in the w16 output variable)
|
||||
// if more than 4 consecutive input numbers are of maximum value and
|
||||
@ -115,9 +118,12 @@ static void AllPassFilter(const int16_t* data_in, size_t data_length,
|
||||
// The length is `data_length` / 2.
|
||||
// - lp_data_out [o] : Output audio data of the lower half of the spectrum.
|
||||
// The length is `data_length` / 2.
|
||||
static void SplitFilter(const int16_t* data_in, size_t data_length,
|
||||
int16_t* upper_state, int16_t* lower_state,
|
||||
int16_t* hp_data_out, int16_t* lp_data_out) {
|
||||
static void SplitFilter(const int16_t* data_in,
|
||||
size_t data_length,
|
||||
int16_t* upper_state,
|
||||
int16_t* lower_state,
|
||||
int16_t* hp_data_out,
|
||||
int16_t* lp_data_out) {
|
||||
size_t i;
|
||||
size_t half_length = data_length >> 1; // Downsampling by 2.
|
||||
int16_t tmp_out;
|
||||
@ -149,8 +155,10 @@ static void SplitFilter(const int16_t* data_in, size_t data_length,
|
||||
// NOTE: `total_energy` is only updated if
|
||||
// `total_energy` <= `kMinEnergy`.
|
||||
// - log_energy [o] : 10 * log10("energy of `data_in`") given in Q4.
|
||||
static void LogOfEnergy(const int16_t* data_in, size_t data_length,
|
||||
int16_t offset, int16_t* total_energy,
|
||||
static void LogOfEnergy(const int16_t* data_in,
|
||||
size_t data_length,
|
||||
int16_t offset,
|
||||
int16_t* total_energy,
|
||||
int16_t* log_energy) {
|
||||
// `tot_rshifts` accumulates the number of right shifts performed on `energy`.
|
||||
int tot_rshifts = 0;
|
||||
@ -161,8 +169,8 @@ static void LogOfEnergy(const int16_t* data_in, size_t data_length,
|
||||
RTC_DCHECK(data_in);
|
||||
RTC_DCHECK_GT(data_length, 0);
|
||||
|
||||
energy = (uint32_t) WebRtcSpl_Energy((int16_t*) data_in, data_length,
|
||||
&tot_rshifts);
|
||||
energy =
|
||||
(uint32_t)WebRtcSpl_Energy((int16_t*)data_in, data_length, &tot_rshifts);
|
||||
|
||||
if (energy != 0) {
|
||||
// By construction, normalizing to 15 bits is equivalent with 17 leading
|
||||
@ -240,8 +248,10 @@ static void LogOfEnergy(const int16_t* data_in, size_t data_length,
|
||||
}
|
||||
}
|
||||
|
||||
int16_t WebRtcVad_CalculateFeatures(VadInstT* self, const int16_t* data_in,
|
||||
size_t data_length, int16_t* features) {
|
||||
int16_t WebRtcVad_CalculateFeatures(VadInstT* self,
|
||||
const int16_t* data_in,
|
||||
size_t data_length,
|
||||
int16_t* features) {
|
||||
int16_t total_energy = 0;
|
||||
// We expect `data_length` to be 80, 160 or 240 samples, which corresponds to
|
||||
// 10, 20 or 30 ms in 8 kHz. Therefore, the intermediate downsampled data will
|
||||
|
||||
@ -10,9 +10,9 @@
|
||||
|
||||
#include "common_audio/vad/vad_sp.h"
|
||||
|
||||
#include "rtc_base/checks.h"
|
||||
#include "common_audio/signal_processing/include/signal_processing_library.h"
|
||||
#include "common_audio/vad/vad_core.h"
|
||||
#include "rtc_base/checks.h"
|
||||
|
||||
// Allpass filter coefficients, upper and lower, in Q13.
|
||||
// Upper: 0.64, Lower: 0.17.
|
||||
@ -36,14 +36,14 @@ void WebRtcVad_Downsampling(const int16_t* signal_in,
|
||||
// Filter coefficients in Q13, filter state in Q0.
|
||||
for (n = 0; n < half_length; n++) {
|
||||
// All-pass filtering upper branch.
|
||||
tmp16_1 = (int16_t) ((tmp32_1 >> 1) +
|
||||
((kAllPassCoefsQ13[0] * *signal_in) >> 14));
|
||||
tmp16_1 =
|
||||
(int16_t)((tmp32_1 >> 1) + ((kAllPassCoefsQ13[0] * *signal_in) >> 14));
|
||||
*signal_out = tmp16_1;
|
||||
tmp32_1 = (int32_t)(*signal_in++) - ((kAllPassCoefsQ13[0] * tmp16_1) >> 12);
|
||||
|
||||
// All-pass filtering lower branch.
|
||||
tmp16_2 = (int16_t) ((tmp32_2 >> 1) +
|
||||
((kAllPassCoefsQ13[1] * *signal_in) >> 14));
|
||||
tmp16_2 =
|
||||
(int16_t)((tmp32_2 >> 1) + ((kAllPassCoefsQ13[1] * *signal_in) >> 14));
|
||||
*signal_out++ += tmp16_2;
|
||||
tmp32_2 = (int32_t)(*signal_in++) - ((kAllPassCoefsQ13[1] * tmp16_2) >> 12);
|
||||
}
|
||||
|
||||
@ -53,7 +53,9 @@ int WebRtcVad_set_mode(VadInst* handle, int mode) {
|
||||
return WebRtcVad_set_mode_core(self, mode);
|
||||
}
|
||||
|
||||
int WebRtcVad_Process(VadInst* handle, int fs, const int16_t* audio_frame,
|
||||
int WebRtcVad_Process(VadInst* handle,
|
||||
int fs,
|
||||
const int16_t* audio_frame,
|
||||
size_t frame_length) {
|
||||
int vad = -1;
|
||||
VadInstT* self = (VadInstT*)handle;
|
||||
|
||||
@ -8,10 +8,11 @@
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#include "modules/audio_coding/codecs/g711/g711_interface.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "modules/third_party/g711/g711.h"
|
||||
#include "modules/audio_coding/codecs/g711/g711_interface.h"
|
||||
|
||||
size_t WebRtcG711_EncodeA(const int16_t* speechIn,
|
||||
size_t len,
|
||||
|
||||
@ -8,14 +8,14 @@
|
||||
* be found in the AUTHORS file in the root of the source tree.
|
||||
*/
|
||||
|
||||
#include "modules/audio_coding/codecs/g722/g722_interface.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "modules/audio_coding/codecs/g722/g722_interface.h"
|
||||
#include "modules/third_party/g722/g722_enc_dec.h"
|
||||
|
||||
int16_t WebRtcG722_CreateEncoder(G722EncInst **G722enc_inst)
|
||||
{
|
||||
int16_t WebRtcG722_CreateEncoder(G722EncInst** G722enc_inst) {
|
||||
*G722enc_inst = (G722EncInst*)malloc(sizeof(G722EncoderState));
|
||||
if (*G722enc_inst != NULL) {
|
||||
return (0);
|
||||
@ -24,8 +24,7 @@ int16_t WebRtcG722_CreateEncoder(G722EncInst **G722enc_inst)
|
||||
}
|
||||
}
|
||||
|
||||
int16_t WebRtcG722_EncoderInit(G722EncInst *G722enc_inst)
|
||||
{
|
||||
int16_t WebRtcG722_EncoderInit(G722EncInst* G722enc_inst) {
|
||||
// Create and/or reset the G.722 encoder
|
||||
// Bitrate 64 kbps and wideband mode (2)
|
||||
G722enc_inst = (G722EncInst*)WebRtc_g722_encode_init(
|
||||
@ -37,8 +36,7 @@ int16_t WebRtcG722_EncoderInit(G722EncInst *G722enc_inst)
|
||||
}
|
||||
}
|
||||
|
||||
int WebRtcG722_FreeEncoder(G722EncInst *G722enc_inst)
|
||||
{
|
||||
int WebRtcG722_FreeEncoder(G722EncInst* G722enc_inst) {
|
||||
// Free encoder memory
|
||||
return WebRtc_g722_encode_release((G722EncoderState*)G722enc_inst);
|
||||
}
|
||||
@ -46,16 +44,14 @@ int WebRtcG722_FreeEncoder(G722EncInst *G722enc_inst)
|
||||
size_t WebRtcG722_Encode(G722EncInst* G722enc_inst,
|
||||
const int16_t* speechIn,
|
||||
size_t len,
|
||||
uint8_t* encoded)
|
||||
{
|
||||
uint8_t* encoded) {
|
||||
unsigned char* codechar = (unsigned char*)encoded;
|
||||
// Encode the input speech vector
|
||||
return WebRtc_g722_encode((G722EncoderState*) G722enc_inst, codechar,
|
||||
speechIn, len);
|
||||
return WebRtc_g722_encode((G722EncoderState*)G722enc_inst, codechar, speechIn,
|
||||
len);
|
||||
}
|
||||
|
||||
int16_t WebRtcG722_CreateDecoder(G722DecInst **G722dec_inst)
|
||||
{
|
||||
int16_t WebRtcG722_CreateDecoder(G722DecInst** G722dec_inst) {
|
||||
*G722dec_inst = (G722DecInst*)malloc(sizeof(G722DecoderState));
|
||||
if (*G722dec_inst != NULL) {
|
||||
return (0);
|
||||
@ -70,8 +66,7 @@ void WebRtcG722_DecoderInit(G722DecInst* inst) {
|
||||
WebRtc_g722_decode_init((G722DecoderState*)inst, 64000, 2);
|
||||
}
|
||||
|
||||
int WebRtcG722_FreeDecoder(G722DecInst *G722dec_inst)
|
||||
{
|
||||
int WebRtcG722_FreeDecoder(G722DecInst* G722dec_inst) {
|
||||
// Free encoder memory
|
||||
return WebRtc_g722_decode_release((G722DecoderState*)G722dec_inst);
|
||||
}
|
||||
@ -80,25 +75,20 @@ size_t WebRtcG722_Decode(G722DecInst *G722dec_inst,
|
||||
const uint8_t* encoded,
|
||||
size_t len,
|
||||
int16_t* decoded,
|
||||
int16_t *speechType)
|
||||
{
|
||||
int16_t* speechType) {
|
||||
// Decode the G.722 encoder stream
|
||||
*speechType = G722_WEBRTC_SPEECH;
|
||||
return WebRtc_g722_decode((G722DecoderState*) G722dec_inst, decoded,
|
||||
encoded, len);
|
||||
return WebRtc_g722_decode((G722DecoderState*)G722dec_inst, decoded, encoded,
|
||||
len);
|
||||
}
|
||||
|
||||
int16_t WebRtcG722_Version(char *versionStr, short len)
|
||||
{
|
||||
int16_t WebRtcG722_Version(char* versionStr, short len) {
|
||||
// Get version string
|
||||
char version[30] = "2.0.0\n";
|
||||
if (strlen(version) < (unsigned int)len)
|
||||
{
|
||||
if (strlen(version) < (unsigned int)len) {
|
||||
strcpy(versionStr, version);
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
@ -14,8 +14,8 @@
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#include "modules/audio_coding/codecs/isac/main/source/pitch_estimator.h"
|
||||
#include "modules/audio_coding/codecs/isac/main/source/isac_vad.h"
|
||||
#include "modules/audio_coding/codecs/isac/main/source/pitch_estimator.h"
|
||||
|
||||
static void WebRtcIsac_AllPoleFilter(double* InOut,
|
||||
double* Coef,
|
||||
@ -28,22 +28,17 @@ static void WebRtcIsac_AllPoleFilter(double* InOut,
|
||||
int k;
|
||||
|
||||
// if (fabs(Coef[0]-1.0)<0.001) {
|
||||
if ( (Coef[0] > 0.9999) && (Coef[0] < 1.0001) )
|
||||
{
|
||||
for(n = 0; n < lengthInOut; n++)
|
||||
{
|
||||
if ((Coef[0] > 0.9999) && (Coef[0] < 1.0001)) {
|
||||
for (n = 0; n < lengthInOut; n++) {
|
||||
sum = Coef[1] * InOut[-1];
|
||||
for (k = 2; k <= orderCoef; k++) {
|
||||
sum += Coef[k] * InOut[-k];
|
||||
}
|
||||
*InOut++ -= sum;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
scal = 1.0 / Coef[0];
|
||||
for(n=0;n<lengthInOut;n++)
|
||||
{
|
||||
for (n = 0; n < lengthInOut; n++) {
|
||||
*InOut *= scal;
|
||||
for (k = 1; k <= orderCoef; k++) {
|
||||
*InOut -= scal * Coef[k] * InOut[-k];
|
||||
@ -64,8 +59,7 @@ static void WebRtcIsac_AllZeroFilter(double* In,
|
||||
int k;
|
||||
double tmp;
|
||||
|
||||
for(n = 0; n < lengthInOut; n++)
|
||||
{
|
||||
for (n = 0; n < lengthInOut; n++) {
|
||||
tmp = In[0] * Coef[0];
|
||||
|
||||
for (k = 1; k <= orderCoef; k++) {
|
||||
@ -83,21 +77,21 @@ static void WebRtcIsac_ZeroPoleFilter(double* In,
|
||||
size_t lengthInOut,
|
||||
int orderCoef,
|
||||
double* Out) {
|
||||
/* the state of the zero section is assumed to be in In[-1] to In[-orderCoef] */
|
||||
/* the state of the pole section is assumed to be in Out[-1] to Out[-orderCoef] */
|
||||
/* the state of the zero section is assumed to be in In[-1] to In[-orderCoef]
|
||||
*/
|
||||
/* the state of the pole section is assumed to be in Out[-1] to
|
||||
* Out[-orderCoef] */
|
||||
|
||||
WebRtcIsac_AllZeroFilter(In, ZeroCoef, lengthInOut, orderCoef, Out);
|
||||
WebRtcIsac_AllPoleFilter(Out, PoleCoef, lengthInOut, orderCoef);
|
||||
}
|
||||
|
||||
|
||||
void WebRtcIsac_AutoCorr(double* r, const double* x, size_t N, size_t order) {
|
||||
size_t lag, n;
|
||||
double sum, prod;
|
||||
const double* x_lag;
|
||||
|
||||
for (lag = 0; lag <= order; lag++)
|
||||
{
|
||||
for (lag = 0; lag <= order; lag++) {
|
||||
sum = 0.0f;
|
||||
x_lag = &x[lag];
|
||||
prod = x[0] * x_lag[0];
|
||||
@ -108,7 +102,6 @@ void WebRtcIsac_AutoCorr(double* r, const double* x, size_t N, size_t order) {
|
||||
sum += prod;
|
||||
r[lag] = sum;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static void WebRtcIsac_BwExpand(double* out,
|
||||
@ -143,7 +136,8 @@ void WebRtcIsac_WeightingFilter(const double* in,
|
||||
/* Set up buffer and states */
|
||||
memcpy(tmpbuffer, wfdata->buffer, sizeof(double) * PITCH_WLPCBUFLEN);
|
||||
memcpy(tmpbuffer + PITCH_WLPCBUFLEN, in, sizeof(double) * PITCH_FRAME_LEN);
|
||||
memcpy(wfdata->buffer, tmpbuffer+PITCH_FRAME_LEN, sizeof(double) * PITCH_WLPCBUFLEN);
|
||||
memcpy(wfdata->buffer, tmpbuffer + PITCH_FRAME_LEN,
|
||||
sizeof(double) * PITCH_WLPCBUFLEN);
|
||||
|
||||
dp = weoutbuf;
|
||||
dp2 = whoutbuf;
|
||||
@ -174,8 +168,10 @@ void WebRtcIsac_WeightingFilter(const double* in,
|
||||
WebRtcIsac_BwExpand(apolr, apol, rho, PITCH_WLPCORDER + 1);
|
||||
|
||||
/* Filtering */
|
||||
WebRtcIsac_ZeroPoleFilter(inp, apol, apolr, PITCH_SUBFRAME_LEN, PITCH_WLPCORDER, weo);
|
||||
WebRtcIsac_ZeroPoleFilter(inp, apolr, opol, PITCH_SUBFRAME_LEN, PITCH_WLPCORDER, who);
|
||||
WebRtcIsac_ZeroPoleFilter(inp, apol, apolr, PITCH_SUBFRAME_LEN,
|
||||
PITCH_WLPCORDER, weo);
|
||||
WebRtcIsac_ZeroPoleFilter(inp, apolr, opol, PITCH_SUBFRAME_LEN,
|
||||
PITCH_WLPCORDER, who);
|
||||
|
||||
inp += PITCH_SUBFRAME_LEN;
|
||||
endpos += PITCH_SUBFRAME_LEN;
|
||||
|
||||
@ -21,12 +21,12 @@
|
||||
#include "modules/audio_coding/codecs/isac/main/source/pitch_filter.h"
|
||||
#include "rtc_base/system/ignore_warnings.h"
|
||||
|
||||
static const double kInterpolWin[8] = {-0.00067556028640, 0.02184247643159, -0.12203175715679, 0.60086484101160,
|
||||
static const double kInterpolWin[8] = {
|
||||
-0.00067556028640, 0.02184247643159, -0.12203175715679, 0.60086484101160,
|
||||
0.60086484101160, -0.12203175715679, 0.02184247643159, -0.00067556028640};
|
||||
|
||||
/* interpolation filter */
|
||||
__inline static void IntrepolFilter(double *data_ptr, double *intrp)
|
||||
{
|
||||
__inline static void IntrepolFilter(double* data_ptr, double* intrp) {
|
||||
*intrp = kInterpolWin[0] * data_ptr[-3];
|
||||
*intrp += kInterpolWin[1] * data_ptr[-2];
|
||||
*intrp += kInterpolWin[2] * data_ptr[-1];
|
||||
@ -37,16 +37,17 @@ __inline static void IntrepolFilter(double *data_ptr, double *intrp)
|
||||
*intrp += kInterpolWin[7] * data_ptr[4];
|
||||
}
|
||||
|
||||
|
||||
/* 2D parabolic interpolation */
|
||||
/* probably some 0.5 factors can be eliminated, and the square-roots can be removed from the Cholesky fact. */
|
||||
__inline static void Intrpol2D(double T[3][3], double *x, double *y, double *peak_val)
|
||||
{
|
||||
/* probably some 0.5 factors can be eliminated, and the square-roots can be
|
||||
* removed from the Cholesky fact. */
|
||||
__inline static void Intrpol2D(double T[3][3],
|
||||
double* x,
|
||||
double* y,
|
||||
double* peak_val) {
|
||||
double c, b[2], A[2][2];
|
||||
double t1, t2, d;
|
||||
double delta1, delta2;
|
||||
|
||||
|
||||
// double T[3][3] = {{-1.25, -.25,-.25}, {-.25, .75, .75}, {-.25, .75, .75}};
|
||||
// should result in: delta1 = 0.5; delta2 = 0.0; peak_val = 1.0
|
||||
|
||||
@ -91,9 +92,7 @@ __inline static void Intrpol2D(double T[3][3], double *x, double *y, double *pea
|
||||
*y += delta2;
|
||||
}
|
||||
|
||||
|
||||
static void PCorr(const double *in, double *outcorr)
|
||||
{
|
||||
static void PCorr(const double* in, double* outcorr) {
|
||||
double sum, ysum, prod;
|
||||
const double *x, *inptr;
|
||||
int k, n;
|
||||
@ -198,30 +197,38 @@ static void WebRtcIsac_InitializePitch(const double* in,
|
||||
double T[3][3];
|
||||
int row;
|
||||
|
||||
for(k = 0; k < 2*PITCH_BW+3; k++)
|
||||
{
|
||||
for (k = 0; k < 2 * PITCH_BW + 3; k++) {
|
||||
CorrSurf[k] = &corrSurfBuff[10 + k * (PITCH_LAG_SPAN2 + 4)];
|
||||
}
|
||||
/* reset CorrSurf matrix */
|
||||
memset(corrSurfBuff, 0, sizeof(double) * (10 + (2*PITCH_BW+3) * (PITCH_LAG_SPAN2+4)));
|
||||
memset(corrSurfBuff, 0,
|
||||
sizeof(double) * (10 + (2 * PITCH_BW + 3) * (PITCH_LAG_SPAN2 + 4)));
|
||||
|
||||
// warnings -DH
|
||||
max_ind = 0;
|
||||
peak = 0;
|
||||
|
||||
/* copy old values from state buffer */
|
||||
memcpy(buf_dec, State->dec_buffer, sizeof(double) * (PITCH_CORR_LEN2+PITCH_CORR_STEP2+PITCH_MAX_LAG/2-PITCH_FRAME_LEN/2+2));
|
||||
memcpy(buf_dec, State->dec_buffer,
|
||||
sizeof(double) * (PITCH_CORR_LEN2 + PITCH_CORR_STEP2 +
|
||||
PITCH_MAX_LAG / 2 - PITCH_FRAME_LEN / 2 + 2));
|
||||
|
||||
/* decimation; put result after the old values */
|
||||
WebRtcIsac_DecimateAllpass(in, State->decimator_state, PITCH_FRAME_LEN,
|
||||
&buf_dec[PITCH_CORR_LEN2+PITCH_CORR_STEP2+PITCH_MAX_LAG/2-PITCH_FRAME_LEN/2+2]);
|
||||
WebRtcIsac_DecimateAllpass(
|
||||
in, State->decimator_state, PITCH_FRAME_LEN,
|
||||
&buf_dec[PITCH_CORR_LEN2 + PITCH_CORR_STEP2 + PITCH_MAX_LAG / 2 -
|
||||
PITCH_FRAME_LEN / 2 + 2]);
|
||||
|
||||
/* low-pass filtering */
|
||||
for (k = PITCH_CORR_LEN2+PITCH_CORR_STEP2+PITCH_MAX_LAG/2-PITCH_FRAME_LEN/2+2; k < PITCH_CORR_LEN2+PITCH_CORR_STEP2+PITCH_MAX_LAG/2+2; k++)
|
||||
for (k = PITCH_CORR_LEN2 + PITCH_CORR_STEP2 + PITCH_MAX_LAG / 2 -
|
||||
PITCH_FRAME_LEN / 2 + 2;
|
||||
k < PITCH_CORR_LEN2 + PITCH_CORR_STEP2 + PITCH_MAX_LAG / 2 + 2; k++)
|
||||
buf_dec[k] += 0.75 * buf_dec[k - 1] - 0.25 * buf_dec[k - 2];
|
||||
|
||||
/* copy end part back into state buffer */
|
||||
memcpy(State->dec_buffer, buf_dec+PITCH_FRAME_LEN/2, sizeof(double) * (PITCH_CORR_LEN2+PITCH_CORR_STEP2+PITCH_MAX_LAG/2-PITCH_FRAME_LEN/2+2));
|
||||
memcpy(State->dec_buffer, buf_dec + PITCH_FRAME_LEN / 2,
|
||||
sizeof(double) * (PITCH_CORR_LEN2 + PITCH_CORR_STEP2 +
|
||||
PITCH_MAX_LAG / 2 - PITCH_FRAME_LEN / 2 + 2));
|
||||
|
||||
/* compute correlation for first and second half of the frame */
|
||||
PCorr(buf_dec, corrvec1);
|
||||
@ -230,9 +237,9 @@ static void WebRtcIsac_InitializePitch(const double* in,
|
||||
/* bias towards pitch lag of previous frame */
|
||||
log_lag = log(0.5 * old_lag);
|
||||
gain_bias = 4.0 * old_gain * old_gain;
|
||||
if (gain_bias > 0.8) gain_bias = 0.8;
|
||||
for (k = 0; k < PITCH_LAG_SPAN2; k++)
|
||||
{
|
||||
if (gain_bias > 0.8)
|
||||
gain_bias = 0.8;
|
||||
for (k = 0; k < PITCH_LAG_SPAN2; k++) {
|
||||
ratio = log((double)(k + (PITCH_MIN_LAG / 2 - 2))) - log_lag;
|
||||
bias = 1.0 + gain_bias * exp(-5.0 * ratio * ratio);
|
||||
corrvec1[k] *= bias;
|
||||
@ -267,7 +274,8 @@ static void WebRtcIsac_InitializePitch(const double* in,
|
||||
CorrSurfPtr2 = &CorrSurf[2 * PITCH_BW][PITCH_BW + 2];
|
||||
for (k = 0; k < PITCH_LAG_SPAN2 - PITCH_BW; k++) {
|
||||
ratio = ((double)(ind1 + 12)) / ((double)(ind2 + 12));
|
||||
adj = 0.2 * ratio * (2.0 - ratio); /* adjustment factor; inverse parabola as a function of ratio */
|
||||
adj = 0.2 * ratio * (2.0 - ratio); /* adjustment factor; inverse parabola as
|
||||
a function of ratio */
|
||||
corr = adj * (corrvec1[ind1] + corrvec2[ind2]);
|
||||
CorrSurfPtr1[k] = corr;
|
||||
if (corr > corr_max) {
|
||||
@ -288,7 +296,8 @@ static void WebRtcIsac_InitializePitch(const double* in,
|
||||
CorrSurfPtr2 = &CorrSurf[2 * PITCH_BW - 1][PITCH_BW + 1];
|
||||
for (k = 0; k < PITCH_LAG_SPAN2 - PITCH_BW + 1; k++) {
|
||||
ratio = ((double)(ind1 + 12)) / ((double)(ind2 + 12));
|
||||
adj = 0.9 * ratio * (2.0 - ratio); /* adjustment factor; inverse parabola as a function of ratio */
|
||||
adj = 0.9 * ratio * (2.0 - ratio); /* adjustment factor; inverse parabola as
|
||||
a function of ratio */
|
||||
corr = adj * (corrvec1[ind1] + corrvec2[ind2]);
|
||||
CorrSurfPtr1[k] = corr;
|
||||
if (corr > corr_max) {
|
||||
@ -310,7 +319,8 @@ static void WebRtcIsac_InitializePitch(const double* in,
|
||||
CorrSurfPtr2 = &CorrSurf[2 * PITCH_BW - m][PITCH_BW + 2 - m];
|
||||
for (k = 0; k < PITCH_LAG_SPAN2 - PITCH_BW + m; k++) {
|
||||
ratio = ((double)(ind1 + 12)) / ((double)(ind2 + 12));
|
||||
adj = ratio * (2.0 - ratio); /* adjustment factor; inverse parabola as a function of ratio */
|
||||
adj = ratio * (2.0 - ratio); /* adjustment factor; inverse parabola as a
|
||||
function of ratio */
|
||||
corr = adj * (corrvec1[ind1] + corrvec2[ind2]);
|
||||
CorrSurfPtr1[k] = corr;
|
||||
if (corr > corr_max) {
|
||||
@ -332,32 +342,40 @@ static void WebRtcIsac_InitializePitch(const double* in,
|
||||
peaks_ind = 0;
|
||||
/* find peaks */
|
||||
for (m = 1; m < PITCH_BW + 1; m++) {
|
||||
if (peaks_ind == PITCH_MAX_NUM_PEAKS) break;
|
||||
if (peaks_ind == PITCH_MAX_NUM_PEAKS)
|
||||
break;
|
||||
CorrSurfPtr1 = &CorrSurf[m][2];
|
||||
for (k = 2; k < PITCH_LAG_SPAN2 - PITCH_BW - 2 + m; k++) {
|
||||
corr = CorrSurfPtr1[k];
|
||||
if (corr > corr_max) {
|
||||
if ( (corr > CorrSurfPtr1[k - (PITCH_LAG_SPAN2+5)]) && (corr > CorrSurfPtr1[k - (PITCH_LAG_SPAN2+4)]) ) {
|
||||
if ( (corr > CorrSurfPtr1[k + (PITCH_LAG_SPAN2+4)]) && (corr > CorrSurfPtr1[k + (PITCH_LAG_SPAN2+5)]) ) {
|
||||
if ((corr > CorrSurfPtr1[k - (PITCH_LAG_SPAN2 + 5)]) &&
|
||||
(corr > CorrSurfPtr1[k - (PITCH_LAG_SPAN2 + 4)])) {
|
||||
if ((corr > CorrSurfPtr1[k + (PITCH_LAG_SPAN2 + 4)]) &&
|
||||
(corr > CorrSurfPtr1[k + (PITCH_LAG_SPAN2 + 5)])) {
|
||||
/* found a peak; store index into matrix */
|
||||
peaks[peaks_ind++] = (int)(&CorrSurfPtr1[k] - &CorrSurf[0][0]);
|
||||
if (peaks_ind == PITCH_MAX_NUM_PEAKS) break;
|
||||
if (peaks_ind == PITCH_MAX_NUM_PEAKS)
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (m = PITCH_BW + 1; m < 2 * PITCH_BW; m++) {
|
||||
if (peaks_ind == PITCH_MAX_NUM_PEAKS) break;
|
||||
if (peaks_ind == PITCH_MAX_NUM_PEAKS)
|
||||
break;
|
||||
CorrSurfPtr1 = &CorrSurf[m][2];
|
||||
for (k = 2 + m - PITCH_BW; k < PITCH_LAG_SPAN2 - 2; k++) {
|
||||
corr = CorrSurfPtr1[k];
|
||||
if (corr > corr_max) {
|
||||
if ( (corr > CorrSurfPtr1[k - (PITCH_LAG_SPAN2+5)]) && (corr > CorrSurfPtr1[k - (PITCH_LAG_SPAN2+4)]) ) {
|
||||
if ( (corr > CorrSurfPtr1[k + (PITCH_LAG_SPAN2+4)]) && (corr > CorrSurfPtr1[k + (PITCH_LAG_SPAN2+5)]) ) {
|
||||
if ((corr > CorrSurfPtr1[k - (PITCH_LAG_SPAN2 + 5)]) &&
|
||||
(corr > CorrSurfPtr1[k - (PITCH_LAG_SPAN2 + 4)])) {
|
||||
if ((corr > CorrSurfPtr1[k + (PITCH_LAG_SPAN2 + 4)]) &&
|
||||
(corr > CorrSurfPtr1[k + (PITCH_LAG_SPAN2 + 5)])) {
|
||||
/* found a peak; store index into matrix */
|
||||
peaks[peaks_ind++] = (int)(&CorrSurfPtr1[k] - &CorrSurf[0][0]);
|
||||
if (peaks_ind == PITCH_MAX_NUM_PEAKS) break;
|
||||
if (peaks_ind == PITCH_MAX_NUM_PEAKS)
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -379,13 +397,17 @@ static void WebRtcIsac_InitializePitch(const double* in,
|
||||
/* determine maximum of the interpolated values */
|
||||
corr = CorrSurfPtr1[peak];
|
||||
corr_max = intrp_a;
|
||||
if (intrp_b > corr_max) corr_max = intrp_b;
|
||||
if (intrp_c > corr_max) corr_max = intrp_c;
|
||||
if (intrp_d > corr_max) corr_max = intrp_d;
|
||||
if (intrp_b > corr_max)
|
||||
corr_max = intrp_b;
|
||||
if (intrp_c > corr_max)
|
||||
corr_max = intrp_c;
|
||||
if (intrp_d > corr_max)
|
||||
corr_max = intrp_d;
|
||||
|
||||
/* determine where the peak sits and fill a 3x3 matrix around it */
|
||||
row = peak / (PITCH_LAG_SPAN2 + 4);
|
||||
lags1[k] = (double) ((peak - row * (PITCH_LAG_SPAN2+4)) + PITCH_MIN_LAG/2 - 4);
|
||||
lags1[k] = (double)((peak - row * (PITCH_LAG_SPAN2 + 4)) +
|
||||
PITCH_MIN_LAG / 2 - 4);
|
||||
lags2[k] = (double)(lags1[k] + PITCH_BW - row);
|
||||
if (corr > corr_max) {
|
||||
T[0][0] = CorrSurfPtr1[peak - (PITCH_LAG_SPAN2 + 5)];
|
||||
@ -401,8 +423,10 @@ static void WebRtcIsac_InitializePitch(const double* in,
|
||||
if (intrp_a == corr_max) {
|
||||
lags1[k] -= 0.5;
|
||||
lags2[k] += 0.5;
|
||||
IntrepolFilter(&CorrSurfPtr1[peak - 2*(PITCH_LAG_SPAN2+5)], &T[0][0]);
|
||||
IntrepolFilter(&CorrSurfPtr1[peak - (2*PITCH_LAG_SPAN2+9)], &T[2][0]);
|
||||
IntrepolFilter(&CorrSurfPtr1[peak - 2 * (PITCH_LAG_SPAN2 + 5)],
|
||||
&T[0][0]);
|
||||
IntrepolFilter(&CorrSurfPtr1[peak - (2 * PITCH_LAG_SPAN2 + 9)],
|
||||
&T[2][0]);
|
||||
T[1][1] = intrp_a;
|
||||
T[0][2] = intrp_b;
|
||||
T[2][2] = intrp_c;
|
||||
@ -440,8 +464,10 @@ static void WebRtcIsac_InitializePitch(const double* in,
|
||||
T[0][0] = intrp_b;
|
||||
T[2][0] = intrp_c;
|
||||
T[1][1] = intrp_d;
|
||||
IntrepolFilter(&CorrSurfPtr1[peak + 2*(PITCH_LAG_SPAN2+4)], &T[0][2]);
|
||||
IntrepolFilter(&CorrSurfPtr1[peak + (2*PITCH_LAG_SPAN2+9)], &T[2][2]);
|
||||
IntrepolFilter(&CorrSurfPtr1[peak + 2 * (PITCH_LAG_SPAN2 + 4)],
|
||||
&T[0][2]);
|
||||
IntrepolFilter(&CorrSurfPtr1[peak + (2 * PITCH_LAG_SPAN2 + 9)],
|
||||
&T[2][2]);
|
||||
T[1][0] = corr;
|
||||
T[0][1] = CorrSurfPtr1[peak + (PITCH_LAG_SPAN2 + 4)];
|
||||
T[2][1] = CorrSurfPtr1[peak + (PITCH_LAG_SPAN2 + 5)];
|
||||
@ -466,27 +492,34 @@ static void WebRtcIsac_InitializePitch(const double* in,
|
||||
lags1[peak] *= 2.0;
|
||||
lags2[peak] *= 2.0;
|
||||
|
||||
if (lags1[peak] < (double) PITCH_MIN_LAG) lags1[peak] = (double) PITCH_MIN_LAG;
|
||||
if (lags2[peak] < (double) PITCH_MIN_LAG) lags2[peak] = (double) PITCH_MIN_LAG;
|
||||
if (lags1[peak] > (double) PITCH_MAX_LAG) lags1[peak] = (double) PITCH_MAX_LAG;
|
||||
if (lags2[peak] > (double) PITCH_MAX_LAG) lags2[peak] = (double) PITCH_MAX_LAG;
|
||||
if (lags1[peak] < (double)PITCH_MIN_LAG)
|
||||
lags1[peak] = (double)PITCH_MIN_LAG;
|
||||
if (lags2[peak] < (double)PITCH_MIN_LAG)
|
||||
lags2[peak] = (double)PITCH_MIN_LAG;
|
||||
if (lags1[peak] > (double)PITCH_MAX_LAG)
|
||||
lags1[peak] = (double)PITCH_MAX_LAG;
|
||||
if (lags2[peak] > (double)PITCH_MAX_LAG)
|
||||
lags2[peak] = (double)PITCH_MAX_LAG;
|
||||
|
||||
/* store lags of highest peak in output array */
|
||||
lags[0] = lags1[peak];
|
||||
lags[1] = lags1[peak];
|
||||
lags[2] = lags2[peak];
|
||||
lags[3] = lags2[peak];
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
row = max_ind / (PITCH_LAG_SPAN2 + 4);
|
||||
lags1[0] = (double) ((max_ind - row * (PITCH_LAG_SPAN2+4)) + PITCH_MIN_LAG/2 - 4);
|
||||
lags1[0] = (double)((max_ind - row * (PITCH_LAG_SPAN2 + 4)) +
|
||||
PITCH_MIN_LAG / 2 - 4);
|
||||
lags2[0] = (double)(lags1[0] + PITCH_BW - row);
|
||||
|
||||
if (lags1[0] < (double) PITCH_MIN_LAG) lags1[0] = (double) PITCH_MIN_LAG;
|
||||
if (lags2[0] < (double) PITCH_MIN_LAG) lags2[0] = (double) PITCH_MIN_LAG;
|
||||
if (lags1[0] > (double) PITCH_MAX_LAG) lags1[0] = (double) PITCH_MAX_LAG;
|
||||
if (lags2[0] > (double) PITCH_MAX_LAG) lags2[0] = (double) PITCH_MAX_LAG;
|
||||
if (lags1[0] < (double)PITCH_MIN_LAG)
|
||||
lags1[0] = (double)PITCH_MIN_LAG;
|
||||
if (lags2[0] < (double)PITCH_MIN_LAG)
|
||||
lags2[0] = (double)PITCH_MIN_LAG;
|
||||
if (lags1[0] > (double)PITCH_MAX_LAG)
|
||||
lags1[0] = (double)PITCH_MAX_LAG;
|
||||
if (lags2[0] > (double)PITCH_MAX_LAG)
|
||||
lags2[0] = (double)PITCH_MAX_LAG;
|
||||
|
||||
/* store lags of highest peak in output array */
|
||||
lags[0] = lags1[0];
|
||||
@ -498,18 +531,20 @@ static void WebRtcIsac_InitializePitch(const double* in,
|
||||
|
||||
RTC_POP_IGNORING_WFRAME_LARGER_THAN()
|
||||
|
||||
/* create weighting matrix by orthogonalizing a basis of polynomials of increasing order
|
||||
* t = (0:4)';
|
||||
* A = [t.^0, t.^1, t.^2, t.^3, t.^4];
|
||||
* [Q, dummy] = qr(A);
|
||||
* P.Weight = Q * diag([0, .1, .5, 1, 1]) * Q'; */
|
||||
/* create weighting matrix by orthogonalizing a basis of polynomials of
|
||||
* increasing order t = (0:4)'; A = [t.^0, t.^1, t.^2, t.^3, t.^4]; [Q, dummy] =
|
||||
* qr(A); P.Weight = Q * diag([0, .1, .5, 1, 1]) * Q'; */
|
||||
static const double kWeight[5][5] = {
|
||||
{ 0.29714285714286, -0.30857142857143, -0.05714285714286, 0.05142857142857, 0.01714285714286},
|
||||
{-0.30857142857143, 0.67428571428571, -0.27142857142857, -0.14571428571429, 0.05142857142857},
|
||||
{-0.05714285714286, -0.27142857142857, 0.65714285714286, -0.27142857142857, -0.05714285714286},
|
||||
{ 0.05142857142857, -0.14571428571429, -0.27142857142857, 0.67428571428571, -0.30857142857143},
|
||||
{ 0.01714285714286, 0.05142857142857, -0.05714285714286, -0.30857142857143, 0.29714285714286}
|
||||
};
|
||||
{0.29714285714286, -0.30857142857143, -0.05714285714286, 0.05142857142857,
|
||||
0.01714285714286},
|
||||
{-0.30857142857143, 0.67428571428571, -0.27142857142857, -0.14571428571429,
|
||||
0.05142857142857},
|
||||
{-0.05714285714286, -0.27142857142857, 0.65714285714286, -0.27142857142857,
|
||||
-0.05714285714286},
|
||||
{0.05142857142857, -0.14571428571429, -0.27142857142857, 0.67428571428571,
|
||||
-0.30857142857143},
|
||||
{0.01714285714286, 0.05142857142857, -0.05714285714286, -0.30857142857143,
|
||||
0.29714285714286}};
|
||||
|
||||
/* second order high-pass filter */
|
||||
static void WebRtcIsac_Highpass(const double* in,
|
||||
@ -535,17 +570,18 @@ static void WebRtcIsac_Highpass(const double* in,
|
||||
|
||||
RTC_PUSH_IGNORING_WFRAME_LARGER_THAN()
|
||||
|
||||
void WebRtcIsac_PitchAnalysis(const double *in, /* PITCH_FRAME_LEN samples */
|
||||
void WebRtcIsac_PitchAnalysis(
|
||||
const double* in, /* PITCH_FRAME_LEN samples */
|
||||
double* out, /* PITCH_FRAME_LEN+QLOOKAHEAD samples */
|
||||
PitchAnalysisStruct* State,
|
||||
double* lags,
|
||||
double *gains)
|
||||
{
|
||||
double* gains) {
|
||||
double HPin[PITCH_FRAME_LEN];
|
||||
double Weighted[PITCH_FRAME_LEN];
|
||||
double Whitened[PITCH_FRAME_LEN + QLOOKAHEAD];
|
||||
double inbuf[PITCH_FRAME_LEN + QLOOKAHEAD];
|
||||
double out_G[PITCH_FRAME_LEN + QLOOKAHEAD]; // could be removed by using out instead
|
||||
double out_G[PITCH_FRAME_LEN +
|
||||
QLOOKAHEAD]; // could be removed by using out instead
|
||||
double out_dG[4][PITCH_FRAME_LEN + QLOOKAHEAD];
|
||||
double old_lag, old_gain;
|
||||
double nrg_wht, tmp;
|
||||
@ -562,10 +598,12 @@ void WebRtcIsac_PitchAnalysis(const double *in, /* PITCH_FRAME_LEN
|
||||
memcpy(Whitened, State->whitened_buf, sizeof(double) * QLOOKAHEAD);
|
||||
|
||||
/* compute weighted and whitened signals */
|
||||
WebRtcIsac_WeightingFilter(HPin, &Weighted[0], &Whitened[QLOOKAHEAD], &(State->Wghtstr));
|
||||
WebRtcIsac_WeightingFilter(HPin, &Weighted[0], &Whitened[QLOOKAHEAD],
|
||||
&(State->Wghtstr));
|
||||
|
||||
/* copy from buffer into state */
|
||||
memcpy(State->whitened_buf, Whitened+PITCH_FRAME_LEN, sizeof(double) * QLOOKAHEAD);
|
||||
memcpy(State->whitened_buf, Whitened + PITCH_FRAME_LEN,
|
||||
sizeof(double) * QLOOKAHEAD);
|
||||
|
||||
old_lag = State->PFstr_wght.oldlagp[0];
|
||||
old_gain = State->PFstr_wght.oldgainp[0];
|
||||
@ -573,7 +611,6 @@ void WebRtcIsac_PitchAnalysis(const double *in, /* PITCH_FRAME_LEN
|
||||
/* inital pitch estimate */
|
||||
WebRtcIsac_InitializePitch(Weighted, old_lag, old_gain, State, lags);
|
||||
|
||||
|
||||
/* Iterative optimization of lags - to be done */
|
||||
|
||||
/* compute energy of whitened signal */
|
||||
@ -581,10 +618,10 @@ void WebRtcIsac_PitchAnalysis(const double *in, /* PITCH_FRAME_LEN
|
||||
for (k = 0; k < PITCH_FRAME_LEN + QLOOKAHEAD; k++)
|
||||
nrg_wht += Whitened[k] * Whitened[k];
|
||||
|
||||
|
||||
/* Iterative optimization of gains */
|
||||
|
||||
/* set weights for energy, gain fluctiation, and spectral gain penalty functions */
|
||||
/* set weights for energy, gain fluctiation, and spectral gain penalty
|
||||
* functions */
|
||||
Wnrg = 1.0 / nrg_wht;
|
||||
Wgain = 0.005;
|
||||
Wfluct = 3.0;
|
||||
@ -596,9 +633,11 @@ void WebRtcIsac_PitchAnalysis(const double *in, /* PITCH_FRAME_LEN
|
||||
/* two iterations should be enough */
|
||||
for (iter = 0; iter < 2; iter++) {
|
||||
/* compute Jacobian of pre-filter output towards gains */
|
||||
WebRtcIsac_PitchfilterPre_gains(Whitened, out_G, out_dG, &(State->PFstr_wght), lags, gains);
|
||||
WebRtcIsac_PitchfilterPre_gains(Whitened, out_G, out_dG,
|
||||
&(State->PFstr_wght), lags, gains);
|
||||
|
||||
/* gradient and approximate Hessian (lower triangle) for minimizing the filter's output power */
|
||||
/* gradient and approximate Hessian (lower triangle) for minimizing the
|
||||
* filter's output power */
|
||||
for (k = 0; k < 4; k++) {
|
||||
tmp = 0.0;
|
||||
for (n = 0; n < PITCH_FRAME_LEN + QLOOKAHEAD; n++)
|
||||
@ -614,7 +653,8 @@ void WebRtcIsac_PitchAnalysis(const double *in, /* PITCH_FRAME_LEN
|
||||
}
|
||||
}
|
||||
|
||||
/* add gradient and Hessian (lower triangle) for dampening fast gain changes */
|
||||
/* add gradient and Hessian (lower triangle) for dampening fast gain changes
|
||||
*/
|
||||
for (k = 0; k < 4; k++) {
|
||||
tmp = kWeight[k + 1][0] * old_gain;
|
||||
for (m = 0; m < 4; m++)
|
||||
@ -637,10 +677,10 @@ void WebRtcIsac_PitchAnalysis(const double *in, /* PITCH_FRAME_LEN
|
||||
grad[3] += 1.33 * (tmp * tmp * Wgain);
|
||||
H[3][3] += 2.66 * tmp * (tmp * tmp * Wgain);
|
||||
|
||||
|
||||
/* compute Cholesky factorization of Hessian
|
||||
* by overwritting the upper triangle; scale factors on diagonal
|
||||
* (for non pc-platforms store the inverse of the diagonals seperately to minimize divisions) */
|
||||
* (for non pc-platforms store the inverse of the diagonals seperately to
|
||||
* minimize divisions) */
|
||||
H[0][1] = H[1][0] / H[0][0];
|
||||
H[0][2] = H[2][0] / H[0][0];
|
||||
H[0][3] = H[3][0] / H[0][0];
|
||||
@ -648,8 +688,10 @@ void WebRtcIsac_PitchAnalysis(const double *in, /* PITCH_FRAME_LEN
|
||||
H[1][2] = (H[2][1] - H[0][1] * H[2][0]) / H[1][1];
|
||||
H[1][3] = (H[3][1] - H[0][1] * H[3][0]) / H[1][1];
|
||||
H[2][2] -= H[0][0] * H[0][2] * H[0][2] + H[1][1] * H[1][2] * H[1][2];
|
||||
H[2][3] = (H[3][2] - H[0][2] * H[3][0] - H[1][2] * H[1][1] * H[1][3]) / H[2][2];
|
||||
H[3][3] -= H[0][0] * H[0][3] * H[0][3] + H[1][1] * H[1][3] * H[1][3] + H[2][2] * H[2][3] * H[2][3];
|
||||
H[2][3] =
|
||||
(H[3][2] - H[0][2] * H[3][0] - H[1][2] * H[1][1] * H[1][3]) / H[2][2];
|
||||
H[3][3] -= H[0][0] * H[0][3] * H[0][3] + H[1][1] * H[1][3] * H[1][3] +
|
||||
H[2][2] * H[2][3] * H[2][3];
|
||||
|
||||
/* Compute update as delta_gains = -inv(H) * grad */
|
||||
/* copy and negate */
|
||||
|
||||
@ -12,8 +12,8 @@
|
||||
#include <memory.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "modules/audio_coding/codecs/isac/main/source/pitch_estimator.h"
|
||||
#include "modules/audio_coding/codecs/isac/main/source/os_specific_inline.h"
|
||||
#include "modules/audio_coding/codecs/isac/main/source/pitch_estimator.h"
|
||||
#include "rtc_base/compile_assert_c.h"
|
||||
|
||||
/*
|
||||
@ -58,8 +58,7 @@ static const double kIntrpCoef[PITCH_FRACS][PITCH_FRACORDER] = {
|
||||
-0.01463300534216},
|
||||
{0.01654127246315, -0.04533310458085, 0.09585268418557, -0.20266133815190,
|
||||
0.79117042386878, 0.44560418147640, -0.13991265473712, 0.05816126837865,
|
||||
-0.01985640750433}
|
||||
};
|
||||
-0.01985640750433}};
|
||||
|
||||
/*
|
||||
* Enumerating the operation of the filter.
|
||||
@ -78,7 +77,10 @@ static const double kIntrpCoef[PITCH_FRACS][PITCH_FRACORDER] = {
|
||||
* used to find the optimal gain.
|
||||
*/
|
||||
typedef enum {
|
||||
kPitchFilterPre, kPitchFilterPost, kPitchFilterPreLa, kPitchFilterPreGain
|
||||
kPitchFilterPre,
|
||||
kPitchFilterPost,
|
||||
kPitchFilterPreLa,
|
||||
kPitchFilterPreGain
|
||||
} PitchFilterOperation;
|
||||
|
||||
/*
|
||||
@ -132,7 +134,8 @@ typedef struct {
|
||||
* where the output of different gain values (differential
|
||||
* change to gain) is written.
|
||||
*/
|
||||
static void FilterSegment(const double* in_data, PitchFilterParam* parameters,
|
||||
static void FilterSegment(const double* in_data,
|
||||
PitchFilterParam* parameters,
|
||||
double* out_data,
|
||||
double out_dg[][PITCH_FRAME_LEN + QLOOKAHEAD]) {
|
||||
int n;
|
||||
@ -180,8 +183,8 @@ static void FilterSegment(const double* in_data, PitchFilterParam* parameters,
|
||||
sum2 += out_dg[j][lag_index + m] * parameters->interpol_coeff[m];
|
||||
}
|
||||
/* Add the contribution of differential gain change. */
|
||||
parameters->damper_state_dg[j][0] = parameters->gain_mult[j] * sum +
|
||||
parameters->gain * sum2;
|
||||
parameters->damper_state_dg[j][0] =
|
||||
parameters->gain_mult[j] * sum + parameters->gain * sum2;
|
||||
}
|
||||
|
||||
/* Filter with damping filter, and store the results. */
|
||||
@ -201,8 +204,8 @@ static void FilterSegment(const double* in_data, PitchFilterParam* parameters,
|
||||
|
||||
/* Subtract from input and update buffer. */
|
||||
out_data[parameters->index] = in_data[parameters->index] - sum;
|
||||
parameters->buffer[pos] = in_data[parameters->index] +
|
||||
out_data[parameters->index];
|
||||
parameters->buffer[pos] =
|
||||
in_data[parameters->index] + out_data[parameters->index];
|
||||
|
||||
++parameters->index;
|
||||
++pos;
|
||||
@ -216,8 +219,8 @@ static void Update(PitchFilterParam* parameters) {
|
||||
double fraction;
|
||||
int fraction_index;
|
||||
/* Compute integer lag-offset. */
|
||||
parameters->lag_offset = WebRtcIsac_lrint(parameters->lag + PITCH_FILTDELAY +
|
||||
0.5);
|
||||
parameters->lag_offset =
|
||||
WebRtcIsac_lrint(parameters->lag + PITCH_FILTDELAY + 0.5);
|
||||
/* Find correct set of coefficients for computing fractional pitch. */
|
||||
fraction = parameters->lag_offset - (parameters->lag + PITCH_FILTDELAY);
|
||||
fraction_index = WebRtcIsac_lrint(PITCH_FRACS * fraction - 0.5);
|
||||
@ -257,8 +260,11 @@ static void Update(PitchFilterParam* parameters) {
|
||||
* where the output of different gain values (differential
|
||||
* change to gain) is written.
|
||||
*/
|
||||
static void FilterFrame(const double* in_data, PitchFiltstr* filter_state,
|
||||
double* lags, double* gains, PitchFilterOperation mode,
|
||||
static void FilterFrame(const double* in_data,
|
||||
PitchFiltstr* filter_state,
|
||||
double* lags,
|
||||
double* gains,
|
||||
PitchFilterOperation mode,
|
||||
double* out_data,
|
||||
double out_dg[][PITCH_FRAME_LEN + QLOOKAHEAD]) {
|
||||
PitchFilterParam filter_parameters;
|
||||
@ -360,29 +366,38 @@ static void FilterFrame(const double* in_data, PitchFiltstr* filter_state,
|
||||
}
|
||||
}
|
||||
|
||||
void WebRtcIsac_PitchfilterPre(double* in_data, double* out_data,
|
||||
PitchFiltstr* pf_state, double* lags,
|
||||
void WebRtcIsac_PitchfilterPre(double* in_data,
|
||||
double* out_data,
|
||||
PitchFiltstr* pf_state,
|
||||
double* lags,
|
||||
double* gains) {
|
||||
FilterFrame(in_data, pf_state, lags, gains, kPitchFilterPre, out_data, NULL);
|
||||
}
|
||||
|
||||
void WebRtcIsac_PitchfilterPre_la(double* in_data, double* out_data,
|
||||
PitchFiltstr* pf_state, double* lags,
|
||||
void WebRtcIsac_PitchfilterPre_la(double* in_data,
|
||||
double* out_data,
|
||||
PitchFiltstr* pf_state,
|
||||
double* lags,
|
||||
double* gains) {
|
||||
FilterFrame(in_data, pf_state, lags, gains, kPitchFilterPreLa, out_data,
|
||||
NULL);
|
||||
}
|
||||
|
||||
void WebRtcIsac_PitchfilterPre_gains(
|
||||
double* in_data, double* out_data,
|
||||
double out_dg[][PITCH_FRAME_LEN + QLOOKAHEAD], PitchFiltstr *pf_state,
|
||||
double* lags, double* gains) {
|
||||
double* in_data,
|
||||
double* out_data,
|
||||
double out_dg[][PITCH_FRAME_LEN + QLOOKAHEAD],
|
||||
PitchFiltstr* pf_state,
|
||||
double* lags,
|
||||
double* gains) {
|
||||
FilterFrame(in_data, pf_state, lags, gains, kPitchFilterPreGain, out_data,
|
||||
out_dg);
|
||||
}
|
||||
|
||||
void WebRtcIsac_PitchfilterPost(double* in_data, double* out_data,
|
||||
PitchFiltstr* pf_state, double* lags,
|
||||
void WebRtcIsac_PitchfilterPost(double* in_data,
|
||||
double* out_data,
|
||||
PitchFiltstr* pf_state,
|
||||
double* lags,
|
||||
double* gains) {
|
||||
FilterFrame(in_data, pf_state, lags, gains, kPitchFilterPost, out_data, NULL);
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user