Reland "Upconvert various types to int.", neteq portion.

webrtc/modules/audio_coding/neteq/expand.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 221 matching lines @@
           voiced_vector + temp_length, parameters.current_voice_mix_factor,
           unvoiced_vector + temp_length, temp_scale, 14,
           temp_data + temp_length, static_cast<int>(current_lag - temp_length));
     }
 
     // Select muting slope depending on how many consecutive expands we have
     // done.
     if (consecutive_expands_ == 3) {
       // Let the mute factor decrease from 1.0 to 0.95 in 6.25 ms.
       // mute_slope = 0.0010 / fs_mult in Q20.
-      parameters.mute_slope = std::max(parameters.mute_slope,
-                                       static_cast<int16_t>(1049 / fs_mult));
+      parameters.mute_slope = std::max(parameters.mute_slope, 1049 / fs_mult);
     }
     if (consecutive_expands_ == 7) {
       // Let the mute factor decrease from 1.0 to 0.90 in 6.25 ms.
       // mute_slope = 0.0020 / fs_mult in Q20.
-      parameters.mute_slope = std::max(parameters.mute_slope,
-                                       static_cast<int16_t>(2097 / fs_mult));
+      parameters.mute_slope = std::max(parameters.mute_slope, 2097 / fs_mult);
     }
 
     // Mute segment according to slope value.
     if ((consecutive_expands_ != 0) || !parameters.onset) {
       // Mute to the previous level, then continue with the muting.
       WebRtcSpl_AffineTransformVector(temp_data, temp_data,
                                       parameters.mute_factor, 8192,
                                       14, static_cast<int>(current_lag));
 
       if (!stop_muting_) {
@@ skipping 101 matching lines @@
   int fs_mult_lpc_analysis_len = fs_mult * kLpcAnalysisLength;
 
   const size_t signal_length = 256 * fs_mult;
   const int16_t* audio_history =
       &(*sync_buffer_)[0][sync_buffer_->Size() - signal_length];
 
   // Initialize.
   InitializeForAnExpandPeriod();
 
   // Calculate correlation in downsampled domain (4 kHz sample rate).
-  int16_t correlation_scale;
+  int correlation_scale;
   int correlation_length = 51;  // TODO(hlundin): Legacy bit-exactness.
   // If it is decided to break bit-exactness |correlation_length| should be
   // initialized to the return value of Correlation().
   Correlation(audio_history, signal_length, correlation_vector,
               &correlation_scale);
 
   // Find peaks in correlation vector.
   DspHelper::PeakDetection(correlation_vector, correlation_length,
                            kNumCorrelationCandidates, fs_mult,
                            best_correlation_index, best_correlation);
@@ skipping 56 matching lines @@
 
   for (size_t channel_ix = 0; channel_ix < num_channels_; ++channel_ix) {
     ChannelParameters& parameters = channel_parameters_[channel_ix];
     // Calculate suitable scaling.
     int16_t signal_max = WebRtcSpl_MaxAbsValueW16(
         &audio_history[signal_length - correlation_length - start_index
                        - correlation_lags],
                        correlation_length + start_index + correlation_lags - 1);
     correlation_scale = ((31 - WebRtcSpl_NormW32(signal_max * signal_max))
         + (31 - WebRtcSpl_NormW32(correlation_length))) - 31;
-    correlation_scale = std::max(static_cast<int16_t>(0), correlation_scale);
+    correlation_scale = std::max(0, correlation_scale);
 
     // Calculate the correlation, store in |correlation_vector2|.
     WebRtcSpl_CrossCorrelation(
         correlation_vector2,
         &(audio_history[signal_length - correlation_length]),
         &(audio_history[signal_length - correlation_length - start_index]),
         correlation_length, correlation_lags, correlation_scale, -1);
 
     // Find maximizing index.
     best_index = WebRtcSpl_MaxIndexW32(correlation_vector2, correlation_lags);
     int32_t max_correlation = correlation_vector2[best_index];
     // Compensate index with start offset.
     best_index = best_index + start_index;
 
     // Calculate energies.
     int32_t energy1 = WebRtcSpl_DotProductWithScale(
         &(audio_history[signal_length - correlation_length]),
         &(audio_history[signal_length - correlation_length]),
         correlation_length, correlation_scale);
     int32_t energy2 = WebRtcSpl_DotProductWithScale(
         &(audio_history[signal_length - correlation_length - best_index]),
         &(audio_history[signal_length - correlation_length - best_index]),
         correlation_length, correlation_scale);
 
     // Calculate the correlation coefficient between the two portions of the
     // signal.
-    int16_t corr_coefficient;
+    int32_t corr_coefficient;
     if ((energy1 > 0) && (energy2 > 0)) {
       int energy1_scale = std::max(16 - WebRtcSpl_NormW32(energy1), 0);
       int energy2_scale = std::max(16 - WebRtcSpl_NormW32(energy2), 0);
       // Make sure total scaling is even (to simplify scale factor after sqrt).
       if ((energy1_scale + energy2_scale) & 1) {
         // If sum is odd, add 1 to make it even.
         energy1_scale += 1;
       }
-      int16_t scaled_energy1 = energy1 >> energy1_scale;
-      int16_t scaled_energy2 = energy2 >> energy2_scale;
-      int16_t sqrt_energy_product = WebRtcSpl_SqrtFloor(
-          scaled_energy1 * scaled_energy2);
+      int32_t scaled_energy1 = energy1 >> energy1_scale;
+      int32_t scaled_energy2 = energy2 >> energy2_scale;
+      int16_t sqrt_energy_product = static_cast<int16_t>(
+          WebRtcSpl_SqrtFloor(scaled_energy1 * scaled_energy2));
       // Calculate max_correlation / sqrt(energy1 * energy2) in Q14.
       int cc_shift = 14 - (energy1_scale + energy2_scale) / 2;
       max_correlation = WEBRTC_SPL_SHIFT_W32(max_correlation, cc_shift);
       corr_coefficient = WebRtcSpl_DivW32W16(max_correlation,
                                              sqrt_energy_product);
-      corr_coefficient = std::min(static_cast<int16_t>(16384),
-                                  corr_coefficient);  // Cap at 1.0 in Q14.
+      // Cap at 1.0 in Q14.
+      corr_coefficient = std::min(16384, corr_coefficient);
     } else {
       corr_coefficient = 0;
     }
 
     // Extract the two vectors expand_vector0 and expand_vector1 from
     // |audio_history|.
     int16_t expansion_length = static_cast<int16_t>(max_lag_ + overlap_length_);
     const int16_t* vector1 = &(audio_history[signal_length - expansion_length]);
     const int16_t* vector2 = vector1 - distortion_lag;
     // Normalize the second vector to the same energy as the first.
     energy1 = WebRtcSpl_DotProductWithScale(vector1, vector1, expansion_length,
                                             correlation_scale);
     energy2 = WebRtcSpl_DotProductWithScale(vector2, vector2, expansion_length,
                                             correlation_scale);
     // Confirm that amplitude ratio sqrt(energy1 / energy2) is within 0.5 - 2.0,
     // i.e., energy1 / energy1 is within 0.25 - 4.
     int16_t amplitude_ratio;
     if ((energy1 / 4 < energy2) && (energy1 > energy2 / 4)) {
       // Energy constraint fulfilled. Use both vectors and scale them
       // accordingly.
-      int16_t scaled_energy2 = std::max(16 - WebRtcSpl_NormW32(energy2), 0);
-      int16_t scaled_energy1 = scaled_energy2 - 13;
+      int32_t scaled_energy2 = std::max(16 - WebRtcSpl_NormW32(energy2), 0);
+      int32_t scaled_energy1 = scaled_energy2 - 13;
       // Calculate scaled_energy1 / scaled_energy2 in Q13.
       int32_t energy_ratio = WebRtcSpl_DivW32W16(
           WEBRTC_SPL_SHIFT_W32(energy1, -scaled_energy1),
           energy2 >> scaled_energy2);
       // Calculate sqrt ratio in Q13 (sqrt of en1/en2 in Q26).
       amplitude_ratio = WebRtcSpl_SqrtFloor(energy_ratio << 13);
       // Copy the two vectors and give them the same energy.
       parameters.expand_vector0.Clear();
       parameters.expand_vector0.PushBack(vector1, expansion_length);
       parameters.expand_vector1.Clear();
@@ skipping 148 matching lines @@
     parameters.ar_gain = unvoiced_gain;
 
     // Calculate voice_mix_factor from corr_coefficient.
     // Let x = corr_coefficient. Then, we compute:
     // if (x > 0.48)
     //   voice_mix_factor = (-5179 + 19931x - 16422x^2 + 5776x^3) / 4096;
     // else
     //   voice_mix_factor = 0;
     if (corr_coefficient > 7875) {
       int16_t x1, x2, x3;
-      x1 = corr_coefficient;  // |corr_coefficient| is in Q14.
+      // |corr_coefficient| is in Q14.
+      x1 = static_cast<int16_t>(corr_coefficient);
       x2 = (x1 * x1) >> 14;   // Shift 14 to keep result in Q14.
       x3 = (x1 * x2) >> 14;
       static const int kCoefficients[4] = { -5179, 19931, -16422, 5776 };
       int32_t temp_sum = kCoefficients[0] << 14;
       temp_sum += kCoefficients[1] * x1;
       temp_sum += kCoefficients[2] * x2;
       temp_sum += kCoefficients[3] * x3;
       parameters.voice_mix_factor =
           static_cast<int16_t>(std::min(temp_sum / 4096, 16384));
       parameters.voice_mix_factor = std::max(parameters.voice_mix_factor,
                                              static_cast<int16_t>(0));
     } else {
       parameters.voice_mix_factor = 0;
     }
 
     // Calculate muting slope. Reuse value from earlier scaling of
     // |expand_vector0| and |expand_vector1|.
     int16_t slope = amplitude_ratio;
     if (slope > 12288) {
       // slope > 1.5.
       // Calculate (1 - (1 / slope)) / distortion_lag =
       // (slope - 1) / (distortion_lag * slope).
       // |slope| is in Q13, so 1 corresponds to 8192. Shift up to Q25 before
       // the division.
       // Shift the denominator from Q13 to Q5 before the division. The result of
       // the division will then be in Q20.
-      int16_t temp_ratio = WebRtcSpl_DivW32W16(
+      int temp_ratio = WebRtcSpl_DivW32W16(
           (slope - 8192) << 12,
           static_cast<int16_t>((distortion_lag * slope) >> 8));
       if (slope > 14746) {
         // slope > 1.8.
         // Divide by 2, with proper rounding.
         parameters.mute_slope = (temp_ratio + 1) / 2;
       } else {
         // Divide by 8, with proper rounding.
         parameters.mute_slope = (temp_ratio + 4) / 8;
       }
       parameters.onset = true;
     } else {
       // Calculate (1 - slope) / distortion_lag.
       // Shift |slope| by 7 to Q20 before the division. The result is in Q20.
       parameters.mute_slope = WebRtcSpl_DivW32W16(
           (8192 - slope) << 7, static_cast<int16_t>(distortion_lag));
       if (parameters.voice_mix_factor <= 13107) {
         // Make sure the mute factor decreases from 1.0 to 0.9 in no more than
         // 6.25 ms.
         // mute_slope >= 0.005 / fs_mult in Q20.
-        parameters.mute_slope = std::max(static_cast<int16_t>(5243 / fs_mult),
-                                         parameters.mute_slope);
+        parameters.mute_slope = std::max(5243 / fs_mult, parameters.mute_slope);
       } else if (slope > 8028) {
         parameters.mute_slope = 0;
       }
       parameters.onset = false;
     }
   }
 }
 
 Expand::ChannelParameters::ChannelParameters()
     : mute_factor(16384),
       ar_gain(0),
       ar_gain_scale(0),
       voice_mix_factor(0),
       current_voice_mix_factor(0),
       onset(false),
       mute_slope(0) {
   memset(ar_filter, 0, sizeof(ar_filter));
   memset(ar_filter_state, 0, sizeof(ar_filter_state));
 }
 
 void Expand::Correlation(const int16_t* input,
                          size_t input_length,
                          int16_t* output,
-                         int16_t* output_scale) const {
+                         int* output_scale) const {
   // Set parameters depending on sample rate.
   const int16_t* filter_coefficients;
   int16_t num_coefficients;
   int16_t downsampling_factor;
   if (fs_hz_ == 8000) {
     num_coefficients = 3;
     downsampling_factor = 2;
     filter_coefficients = DspHelper::kDownsample8kHzTbl;
   } else if (fs_hz_ == 16000) {
     num_coefficients = 5;
@@ skipping 68 matching lines @@
                               RandomVector* random_vector,
                               int fs,
                               size_t num_channels) const {
   return new Expand(background_noise, sync_buffer, random_vector, fs,
                     num_channels);
 }
 
 // TODO(turajs): This can be moved to BackgroundNoise class.
 void Expand::GenerateBackgroundNoise(int16_t* random_vector,
                                      size_t channel,
-                                     int16_t mute_slope,
+                                     int mute_slope,
                                      bool too_many_expands,
                                      size_t num_noise_samples,
                                      int16_t* buffer) {
   static const int kNoiseLpcOrder = BackgroundNoise::kMaxLpcOrder;
   int16_t scaled_random_vector[kMaxSampleRate / 8000 * 125];
   assert(num_noise_samples <= static_cast<size_t>(kMaxSampleRate / 8000 * 125));
   int16_t* noise_samples = &buffer[kNoiseLpcOrder];
   if (background_noise_->initialized()) {
     // Use background noise parameters.
     memcpy(noise_samples - kNoiseLpcOrder,
@@ skipping 22 matching lines @@
         &(noise_samples[num_noise_samples - kNoiseLpcOrder]),
         kNoiseLpcOrder);
 
     // Unmute the background noise.
     int16_t bgn_mute_factor = background_noise_->MuteFactor(channel);
     NetEq::BackgroundNoiseMode bgn_mode = background_noise_->mode();
     if (bgn_mode == NetEq::kBgnFade && too_many_expands &&
         bgn_mute_factor > 0) {
       // Fade BGN to zero.
       // Calculate muting slope, approximately -2^18 / fs_hz.
-      int16_t mute_slope;
+      int mute_slope;
       if (fs_hz_ == 8000) {
         mute_slope = -32;
       } else if (fs_hz_ == 16000) {
         mute_slope = -16;
       } else if (fs_hz_ == 32000) {
         mute_slope = -8;
       } else {
         mute_slope = -5;
       }
       // Use UnmuteSignal function with negative slope.
@@ skipping 39 matching lines @@
   const size_t kMaxRandSamples = RandomVector::kRandomTableSize;
   while (samples_generated < length) {
     size_t rand_length = std::min(length - samples_generated, kMaxRandSamples);
     random_vector_->IncreaseSeedIncrement(seed_increment);
     random_vector_->Generate(rand_length, &random_vector[samples_generated]);
     samples_generated += rand_length;
   }
 }
 
 }  // namespace webrtc