henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
| 11 | #ifndef WEBRTC_MODULES_AUDIO_CODING_NETEQ4_DSP_HELPER_H_ |
| 12 | #define WEBRTC_MODULES_AUDIO_CODING_NETEQ4_DSP_HELPER_H_ |
| 13 | |
pbos@webrtc.org | 3f45c2e | 2013-08-05 16:22:53 +0000 | [diff] [blame] | 14 | #include <string.h> // Access to size_t. |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 15 | |
| 16 | #include "webrtc/modules/audio_coding/neteq4/audio_multi_vector.h" |
| 17 | #include "webrtc/system_wrappers/interface/constructor_magic.h" |
| 18 | #include "webrtc/typedefs.h" |
| 19 | |
| 20 | namespace webrtc { |
| 21 | |
| 22 | // This class contains various signal processing functions, all implemented as |
| 23 | // static methods. |
| 24 | class DspHelper { |
| 25 | public: |
| 26 | // Filter coefficients used when downsampling from the indicated sample rates |
| 27 | // (8, 16, 32, 48 kHz) to 4 kHz. Coefficients are in Q12. |
| 28 | static const int16_t kDownsample8kHzTbl[3]; |
| 29 | static const int16_t kDownsample16kHzTbl[5]; |
| 30 | static const int16_t kDownsample32kHzTbl[7]; |
| 31 | static const int16_t kDownsample48kHzTbl[7]; |
| 32 | |
| 33 | // Constants used to mute and unmute over 5 samples. The coefficients are |
| 34 | // in Q15. |
| 35 | static const int kMuteFactorStart8kHz = 27307; |
| 36 | static const int kMuteFactorIncrement8kHz = -5461; |
| 37 | static const int kUnmuteFactorStart8kHz = 5461; |
| 38 | static const int kUnmuteFactorIncrement8kHz = 5461; |
| 39 | static const int kMuteFactorStart16kHz = 29789; |
| 40 | static const int kMuteFactorIncrement16kHz = -2979; |
| 41 | static const int kUnmuteFactorStart16kHz = 2979; |
| 42 | static const int kUnmuteFactorIncrement16kHz = 2979; |
| 43 | static const int kMuteFactorStart32kHz = 31208; |
| 44 | static const int kMuteFactorIncrement32kHz = -1560; |
| 45 | static const int kUnmuteFactorStart32kHz = 1560; |
| 46 | static const int kUnmuteFactorIncrement32kHz = 1560; |
| 47 | static const int kMuteFactorStart48kHz = 31711; |
| 48 | static const int kMuteFactorIncrement48kHz = -1057; |
| 49 | static const int kUnmuteFactorStart48kHz = 1057; |
| 50 | static const int kUnmuteFactorIncrement48kHz = 1057; |
| 51 | |
| 52 | // Multiplies the signal with a gradually changing factor. |
| 53 | // The first sample is multiplied with |factor| (in Q14). For each sample, |
| 54 | // |factor| is increased (additive) by the |increment| (in Q20), which can |
| 55 | // be negative. Returns the scale factor after the last increment. |
| 56 | static int RampSignal(const int16_t* input, |
| 57 | size_t length, |
| 58 | int factor, |
| 59 | int increment, |
| 60 | int16_t* output); |
| 61 | |
| 62 | // Same as above, but with the samples of |signal| being modified in-place. |
| 63 | static int RampSignal(int16_t* signal, |
| 64 | size_t length, |
| 65 | int factor, |
| 66 | int increment); |
| 67 | |
| 68 | // Same as above, but processes |length| samples from |signal|, starting at |
| 69 | // |start_index|. |
henrik.lundin@webrtc.org | 0e9c399 | 2013-09-30 20:38:44 +0000 | [diff] [blame^] | 70 | static int RampSignal(AudioMultiVector* signal, |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 71 | size_t start_index, |
| 72 | size_t length, |
| 73 | int factor, |
| 74 | int increment); |
| 75 | |
| 76 | // Peak detection with parabolic fit. Looks for |num_peaks| maxima in |data|, |
| 77 | // having length |data_length| and sample rate multiplier |fs_mult|. The peak |
| 78 | // locations and values are written to the arrays |peak_index| and |
| 79 | // |peak_value|, respectively. Both arrays must hold at least |num_peaks| |
| 80 | // elements. |
| 81 | static void PeakDetection(int16_t* data, int data_length, |
| 82 | int num_peaks, int fs_mult, |
| 83 | int* peak_index, int16_t* peak_value); |
| 84 | |
| 85 | // Estimates the height and location of a maximum. The three values in the |
| 86 | // array |signal_points| are used as basis for a parabolic fit, which is then |
| 87 | // used to find the maximum in an interpolated signal. The |signal_points| are |
| 88 | // assumed to be from a 4 kHz signal, while the maximum, written to |
| 89 | // |peak_index| and |peak_value| is given in the full sample rate, as |
| 90 | // indicated by the sample rate multiplier |fs_mult|. |
| 91 | static void ParabolicFit(int16_t* signal_points, int fs_mult, |
| 92 | int* peak_index, int16_t* peak_value); |
| 93 | |
| 94 | // Calculates the sum-abs-diff for |signal| when compared to a displaced |
| 95 | // version of itself. Returns the displacement lag that results in the minimum |
| 96 | // distortion. The resulting distortion is written to |distortion_value|. |
| 97 | // The values of |min_lag| and |max_lag| are boundaries for the search. |
| 98 | static int MinDistortion(const int16_t* signal, int min_lag, |
| 99 | int max_lag, int length, int32_t* distortion_value); |
| 100 | |
| 101 | // Mixes |length| samples from |input1| and |input2| together and writes the |
| 102 | // result to |output|. The gain for |input1| starts at |mix_factor| (Q14) and |
| 103 | // is decreased by |factor_decrement| (Q14) for each sample. The gain for |
| 104 | // |input2| is the complement 16384 - mix_factor. |
| 105 | static void CrossFade(const int16_t* input1, const int16_t* input2, |
turaj@webrtc.org | 045e45e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 106 | size_t length, int16_t* mix_factor, |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 107 | int16_t factor_decrement, int16_t* output); |
| 108 | |
| 109 | // Scales |input| with an increasing gain. Applies |factor| (Q14) to the first |
| 110 | // sample and increases the gain by |increment| (Q20) for each sample. The |
| 111 | // result is written to |output|. |length| samples are processed. |
turaj@webrtc.org | 045e45e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 112 | static void UnmuteSignal(const int16_t* input, size_t length, int16_t* factor, |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 113 | int16_t increment, int16_t* output); |
| 114 | |
| 115 | // Starts at unity gain and gradually fades out |signal|. For each sample, |
| 116 | // the gain is reduced by |mute_slope| (Q14). |length| samples are processed. |
turaj@webrtc.org | 045e45e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 117 | static void MuteSignal(int16_t* signal, int16_t mute_slope, size_t length); |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 118 | |
| 119 | // Downsamples |input| from |sample_rate_hz| to 4 kHz sample rate. The input |
| 120 | // has |input_length| samples, and the method will write |output_length| |
| 121 | // samples to |output|. Compensates for the phase delay of the downsampling |
| 122 | // filters if |compensate_delay| is true. Returns -1 if the input is too short |
| 123 | // to produce |output_length| samples, otherwise 0. |
turaj@webrtc.org | 045e45e | 2013-09-20 16:25:28 +0000 | [diff] [blame] | 124 | static int DownsampleTo4kHz(const int16_t* input, size_t input_length, |
henrik.lundin@webrtc.org | 9a40081 | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 125 | int output_length, int input_rate_hz, |
| 126 | bool compensate_delay, int16_t* output); |
| 127 | |
| 128 | private: |
| 129 | // Table of constants used in method DspHelper::ParabolicFit(). |
| 130 | static const int16_t kParabolaCoefficients[17][3]; |
| 131 | |
| 132 | DISALLOW_COPY_AND_ASSIGN(DspHelper); |
| 133 | }; |
| 134 | |
| 135 | } // namespace webrtc |
| 136 | #endif // WEBRTC_MODULES_AUDIO_CODING_NETEQ4_DSP_HELPER_H_ |