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 #include "webrtc/modules/audio_coding/neteq/preemptive_expand.h"
     12 
     13 #include <algorithm>  // min, max
     14 
     15 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
     16 
     17 namespace webrtc {
     18 
     19 PreemptiveExpand::ReturnCodes PreemptiveExpand::Process(
     20     const int16_t* input,
     21     size_t input_length,
     22     size_t old_data_length,
     23     AudioMultiVector* output,
     24     size_t* length_change_samples) {
     25   old_data_length_per_channel_ = old_data_length;
     26   // Input length must be (almost) 30 ms.
     27   // Also, the new part must be at least |overlap_samples_| elements.
     28   static const size_t k15ms = 120;  // 15 ms = 120 samples at 8 kHz sample rate.
     29   if (num_channels_ == 0 ||
     30       input_length / num_channels_ < (2 * k15ms - 1) * fs_mult_ ||
     31       old_data_length >= input_length / num_channels_ - overlap_samples_) {
     32     // Length of input data too short to do preemptive expand. Simply move all
     33     // data from input to output.
     34     output->PushBackInterleaved(input, input_length);
     35     return kError;
     36   }
     37   const bool kFastMode = false;  // Fast mode is not available for PE Expand.
     38   return TimeStretch::Process(input, input_length, kFastMode, output,
     39                               length_change_samples);
     40 }
     41 
     42 void PreemptiveExpand::SetParametersForPassiveSpeech(size_t len,
     43                                                      int16_t* best_correlation,
     44                                                      size_t* peak_index) const {
     45   // When the signal does not contain any active speech, the correlation does
     46   // not matter. Simply set it to zero.
     47   *best_correlation = 0;
     48 
     49   // For low energy expansion, the new data can be less than 15 ms,
     50   // but we must ensure that best_correlation is not larger than the length of
     51   // the new data.
     52   // but we must ensure that best_correlation is not larger than the new data.
     53   *peak_index = std::min(*peak_index,
     54                          len - old_data_length_per_channel_);
     55 }
     56 
     57 PreemptiveExpand::ReturnCodes PreemptiveExpand::CheckCriteriaAndStretch(
     58     const int16_t* input,
     59     size_t input_length,
     60     size_t peak_index,
     61     int16_t best_correlation,
     62     bool active_speech,
     63     bool /*fast_mode*/,
     64     AudioMultiVector* output) const {
     65   // Pre-calculate common multiplication with |fs_mult_|.
     66   // 120 corresponds to 15 ms.
     67   size_t fs_mult_120 = static_cast<size_t>(fs_mult_ * 120);
     68   // Check for strong correlation (>0.9 in Q14) and at least 15 ms new data,
     69   // or passive speech.
     70   if (((best_correlation > kCorrelationThreshold) &&
     71       (old_data_length_per_channel_ <= fs_mult_120)) ||
     72       !active_speech) {
     73     // Do accelerate operation by overlap add.
     74 
     75     // Set length of the first part, not to be modified.
     76     size_t unmodified_length = std::max(old_data_length_per_channel_,
     77                                         fs_mult_120);
     78     // Copy first part, including cross-fade region.
     79     output->PushBackInterleaved(
     80         input, (unmodified_length + peak_index) * num_channels_);
     81     // Copy the last |peak_index| samples up to 15 ms to |temp_vector|.
     82     AudioMultiVector temp_vector(num_channels_);
     83     temp_vector.PushBackInterleaved(
     84         &input[(unmodified_length - peak_index) * num_channels_],
     85         peak_index * num_channels_);
     86     // Cross-fade |temp_vector| onto the end of |output|.
     87     output->CrossFade(temp_vector, peak_index);
     88     // Copy the last unmodified part, 15 ms + pitch period until the end.
     89     output->PushBackInterleaved(
     90         &input[unmodified_length * num_channels_],
     91         input_length - unmodified_length * num_channels_);
     92 
     93     if (active_speech) {
     94       return kSuccess;
     95     } else {
     96       return kSuccessLowEnergy;
     97     }
     98   } else {
     99     // Accelerate not allowed. Simply move all data from decoded to outData.
    100     output->PushBackInterleaved(input, input_length);
    101     return kNoStretch;
    102   }
    103 }
    104 
    105 PreemptiveExpand* PreemptiveExpandFactory::Create(
    106     int sample_rate_hz,
    107     size_t num_channels,
    108     const BackgroundNoise& background_noise,
    109     size_t overlap_samples) const {
    110   return new PreemptiveExpand(
    111       sample_rate_hz, num_channels, background_noise, overlap_samples);
    112 }
    113 
    114 }  // namespace webrtc
    115