Line data    Source code

       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/accelerate.h"
      12             : 
      13             : #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
      14             : 
      15             : namespace webrtc {
      16             : 
      17           0 : Accelerate::ReturnCodes Accelerate::Process(const int16_t* input,
      18             :                                             size_t input_length,
      19             :                                             bool fast_accelerate,
      20             :                                             AudioMultiVector* output,
      21             :                                             size_t* length_change_samples) {
      22             :   // Input length must be (almost) 30 ms.
      23             :   static const size_t k15ms = 120;  // 15 ms = 120 samples at 8 kHz sample rate.
      24           0 :   if (num_channels_ == 0 ||
      25           0 :       input_length / num_channels_ < (2 * k15ms - 1) * fs_mult_) {
      26             :     // Length of input data too short to do accelerate. Simply move all data
      27             :     // from input to output.
      28           0 :     output->PushBackInterleaved(input, input_length);
      29           0 :     return kError;
      30             :   }
      31           0 :   return TimeStretch::Process(input, input_length, fast_accelerate, output,
      32           0 :                               length_change_samples);
      33             : }
      34             : 
      35           0 : void Accelerate::SetParametersForPassiveSpeech(size_t /*len*/,
      36             :                                                int16_t* best_correlation,
      37             :                                                size_t* /*peak_index*/) const {
      38             :   // When the signal does not contain any active speech, the correlation does
      39             :   // not matter. Simply set it to zero.
      40           0 :   *best_correlation = 0;
      41           0 : }
      42             : 
      43           0 : Accelerate::ReturnCodes Accelerate::CheckCriteriaAndStretch(
      44             :     const int16_t* input,
      45             :     size_t input_length,
      46             :     size_t peak_index,
      47             :     int16_t best_correlation,
      48             :     bool active_speech,
      49             :     bool fast_mode,
      50             :     AudioMultiVector* output) const {
      51             :   // Check for strong correlation or passive speech.
      52             :   // Use 8192 (0.5 in Q14) in fast mode.
      53           0 :   const int correlation_threshold = fast_mode ? 8192 : kCorrelationThreshold;
      54           0 :   if ((best_correlation > correlation_threshold) || !active_speech) {
      55             :     // Do accelerate operation by overlap add.
      56             : 
      57             :     // Pre-calculate common multiplication with |fs_mult_|.
      58             :     // 120 corresponds to 15 ms.
      59           0 :     size_t fs_mult_120 = fs_mult_ * 120;
      60             : 
      61           0 :     if (fast_mode) {
      62             :       // Fit as many multiples of |peak_index| as possible in fs_mult_120.
      63             :       // TODO(henrik.lundin) Consider finding multiple correlation peaks and
      64             :       // pick the one with the longest correlation lag in this case.
      65           0 :       peak_index = (fs_mult_120 / peak_index) * peak_index;
      66             :     }
      67             : 
      68           0 :     assert(fs_mult_120 >= peak_index);  // Should be handled in Process().
      69             :     // Copy first part; 0 to 15 ms.
      70           0 :     output->PushBackInterleaved(input, fs_mult_120 * num_channels_);
      71             :     // Copy the |peak_index| starting at 15 ms to |temp_vector|.
      72           0 :     AudioMultiVector temp_vector(num_channels_);
      73           0 :     temp_vector.PushBackInterleaved(&input[fs_mult_120 * num_channels_],
      74           0 :                                     peak_index * num_channels_);
      75             :     // Cross-fade |temp_vector| onto the end of |output|.
      76           0 :     output->CrossFade(temp_vector, peak_index);
      77             :     // Copy the last unmodified part, 15 ms + pitch period until the end.
      78           0 :     output->PushBackInterleaved(
      79           0 :         &input[(fs_mult_120 + peak_index) * num_channels_],
      80           0 :         input_length - (fs_mult_120 + peak_index) * num_channels_);
      81             : 
      82           0 :     if (active_speech) {
      83           0 :       return kSuccess;
      84             :     } else {
      85           0 :       return kSuccessLowEnergy;
      86             :     }
      87             :   } else {
      88             :     // Accelerate not allowed. Simply move all data from decoded to outData.
      89           0 :     output->PushBackInterleaved(input, input_length);
      90           0 :     return kNoStretch;
      91             :   }
      92             : }
      93             : 
      94           0 : Accelerate* AccelerateFactory::Create(
      95             :     int sample_rate_hz,
      96             :     size_t num_channels,
      97             :     const BackgroundNoise& background_noise) const {
      98           0 :   return new Accelerate(sample_rate_hz, num_channels, background_noise);
      99             : }
     100             : 
     101             : }  // namespace webrtc