Home | History | Annotate | Download | only in neteq
      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_NETEQ_DSP_HELPER_H_
     12 #define WEBRTC_MODULES_AUDIO_CODING_NETEQ_DSP_HELPER_H_
     13 
     14 #include <string.h>  // Access to size_t.
     15 
     16 #include "webrtc/base/constructormagic.h"
     17 #include "webrtc/modules/audio_coding/neteq/audio_multi_vector.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|.
     70   static int RampSignal(AudioMultiVector* signal,
     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,
    106                         size_t length, int16_t* mix_factor,
    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.
    112   static void UnmuteSignal(const int16_t* input, size_t length, int16_t* factor,
    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.
    117   static void MuteSignal(int16_t* signal, int16_t mute_slope, size_t length);
    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.
    124   static int DownsampleTo4kHz(const int16_t* input, size_t input_length,
    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_NETEQ_DSP_HELPER_H_
    137