Moved the AEC C code to be built using C++

webrtc/modules/audio_processing/aec/aec_core_mips.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
 /*
  * The core AEC algorithm, which is presented with time-aligned signals.
  */
 
 #include "webrtc/modules/audio_processing/aec/aec_core.h"
 
 #include <math.h>
 
+extern "C" {
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
+}
 #include "webrtc/modules/audio_processing/aec/aec_core_internal.h"
+extern "C" {
 #include "webrtc/modules/audio_processing/aec/aec_rdft.h"
+}
 
 extern const float WebRtcAec_weightCurve[65];
 extern const float WebRtcAec_overDriveCurve[65];
 
 void WebRtcAec_ComfortNoise_mips(AecCore* aec,
                                  float efw[2][PART_LEN1],
                                  float comfortNoiseHband[2][PART_LEN1],
                                  const float* noisePow,
                                  const float* lambda) {
   int i, num;
@@ skipping 154 matching lines @@
     "lwc1     %[tmp10f],      12(%[u_ptr])                                \n\t"
 #if !defined(MIPS32_R2_LE)
     "mul.s    %[tmp3f],       %[tmp1f],         %[tmp3f]                  \n\t"
     "add.s    %[tmp2f],       %[tmp2f],         %[tmp3f]                  \n\t"
     "mul.s    %[tmp3f],       %[tmp1f],         %[tmp5f]                  \n\t"
     "add.s    %[tmp4f],       %[tmp4f],         %[tmp3f]                  \n\t"
     "mul.s    %[tmp3f],       %[tmp6f],         %[tmp8f]                  \n\t"
     "add.s    %[tmp7f],       %[tmp7f],         %[tmp3f]                  \n\t"
     "mul.s    %[tmp3f],       %[tmp6f],         %[tmp10f]                 \n\t"
     "add.s    %[tmp9f],       %[tmp9f],         %[tmp3f]                  \n\t"
-#else // #if !defined(MIPS32_R2_LE)
+#else  // #if !defined(MIPS32_R2_LE)
     "madd.s   %[tmp2f],       %[tmp2f],         %[tmp1f],     %[tmp3f]    \n\t"
     "madd.s   %[tmp4f],       %[tmp4f],         %[tmp1f],     %[tmp5f]    \n\t"
     "madd.s   %[tmp7f],       %[tmp7f],         %[tmp6f],     %[tmp8f]    \n\t"
     "madd.s   %[tmp9f],       %[tmp9f],         %[tmp6f],     %[tmp10f]   \n\t"
-#endif // #if !defined(MIPS32_R2_LE)
+#endif  // #if !defined(MIPS32_R2_LE)
     "swc1     %[tmp2f],       0(%[efw_ptr_0])                             \n\t"
     "swc1     %[tmp4f],       0(%[efw_ptr_1])                             \n\t"
     "swc1     %[tmp7f],       4(%[efw_ptr_0])                             \n\t"
     "b        5f                                                          \n\t"
     " swc1    %[tmp9f],       4(%[efw_ptr_1])                             \n\t"
    "3:                                                                    \n\t"
     "mul.s    %[tmp1f],       %[tmp1f],         %[tmp1f]                  \n\t"
     "sub.s    %[tmp1f],       %[tmp1c],         %[tmp1f]                  \n\t"
     "sqrt.s   %[tmp1f],       %[tmp1f]                                    \n\t"
     "lwc1     %[tmp2f],       0(%[efw_ptr_0])                             \n\t"
     "lwc1     %[tmp3f],       0(%[u_ptr])                                 \n\t"
     "lwc1     %[tmp4f],       0(%[efw_ptr_1])                             \n\t"
     "lwc1     %[tmp5f],       4(%[u_ptr])                                 \n\t"
 #if !defined(MIPS32_R2_LE)
     "mul.s    %[tmp3f],       %[tmp1f],         %[tmp3f]                  \n\t"
     "add.s    %[tmp2f],       %[tmp2f],         %[tmp3f]                  \n\t"
     "mul.s    %[tmp3f],       %[tmp1f],         %[tmp5f]                  \n\t"
     "add.s    %[tmp4f],       %[tmp4f],         %[tmp3f]                  \n\t"
-#else // #if !defined(MIPS32_R2_LE)
+#else  // #if !defined(MIPS32_R2_LE)
     "madd.s   %[tmp2f],       %[tmp2f],         %[tmp1f],     %[tmp3f]    \n\t"
     "madd.s   %[tmp4f],       %[tmp4f],         %[tmp1f],     %[tmp5f]    \n\t"
-#endif // #if !defined(MIPS32_R2_LE)
+#endif  // #if !defined(MIPS32_R2_LE)
     "swc1     %[tmp2f],       0(%[efw_ptr_0])                             \n\t"
     "b        5f                                                          \n\t"
     " swc1    %[tmp4f],       0(%[efw_ptr_1])                             \n\t"
    "4:                                                                    \n\t"
     "c.lt.s   %[tmp6f],       %[tmp1c]                                    \n\t"
     "bc1f     5f                                                          \n\t"
     " nop                                                                 \n\t"
     "mul.s    %[tmp6f],       %[tmp6f],         %[tmp6f]                  \n\t"
     "sub.s    %[tmp6f],       %[tmp1c],         %[tmp6f]                  \n\t"
     "sqrt.s   %[tmp6f],       %[tmp6f]                                    \n\t"
     "lwc1     %[tmp7f],       4(%[efw_ptr_0])                             \n\t"
     "lwc1     %[tmp8f],       8(%[u_ptr])                                 \n\t"
     "lwc1     %[tmp9f],       4(%[efw_ptr_1])                             \n\t"
     "lwc1     %[tmp10f],      12(%[u_ptr])                                \n\t"
 #if !defined(MIPS32_R2_LE)
     "mul.s    %[tmp3f],       %[tmp6f],         %[tmp8f]                  \n\t"
     "add.s    %[tmp7f],       %[tmp7f],         %[tmp3f]                  \n\t"
     "mul.s    %[tmp3f],       %[tmp6f],         %[tmp10f]                 \n\t"
     "add.s    %[tmp9f],       %[tmp9f],         %[tmp3f]                  \n\t"
-#else // #if !defined(MIPS32_R2_LE)
+#else  // #if !defined(MIPS32_R2_LE)
     "madd.s   %[tmp7f],       %[tmp7f],         %[tmp6f],     %[tmp8f]    \n\t"
     "madd.s   %[tmp9f],       %[tmp9f],         %[tmp6f],     %[tmp10f]   \n\t"
-#endif // #if !defined(MIPS32_R2_LE)
+#endif  // #if !defined(MIPS32_R2_LE)
     "swc1     %[tmp7f],       4(%[efw_ptr_0])                             \n\t"
     "swc1     %[tmp9f],       4(%[efw_ptr_1])                             \n\t"
    "5:                                                                    \n\t"
     "addiu    %[u_ptr],       %[u_ptr],         16                        \n\t"
     "addiu    %[efw_ptr_0],   %[efw_ptr_0],     8                         \n\t"
     "bne      %[u_ptr],       %[u_ptr_end],     1b                        \n\t"
     " addiu   %[efw_ptr_1],   %[efw_ptr_1],     8                         \n\t"
     ".set     pop                                                         \n\t"
     : [lambda] "+r" (lambda), [u_ptr] "+r" (u_ptr),
       [efw_ptr_0] "+r" (efw_ptr_0), [efw_ptr_1] "+r" (efw_ptr_1),
       [tmp1f] "=&f" (tmp1f), [tmp2f] "=&f" (tmp2f), [tmp3f] "=&f" (tmp3f),
       [tmp4f] "=&f" (tmp4f), [tmp5f] "=&f" (tmp5f),
       [tmp6f] "=&f" (tmp6f), [tmp7f] "=&f" (tmp7f), [tmp8f] "=&f" (tmp8f),
       [tmp9f] "=&f" (tmp9f), [tmp10f] "=&f" (tmp10f)
     : [tmp1c] "f" (tmp1c), [u_ptr_end] "r" (u_ptr_end)
     : "memory"
   );
 
   lambda -= PART_LEN;
   tmp = sqrtf(WEBRTC_SPL_MAX(1 - lambda[PART_LEN] * lambda[PART_LEN], 0));
   // tmp = 1 - lambda[i];
   efw[0][PART_LEN] += tmp * u[PART_LEN][0];
   efw[1][PART_LEN] += tmp * u[PART_LEN][1];
 
   // For H band comfort noise
-  // TODO: don't compute noise and "tmp" twice. Use the previous results.
+  // TODO(peah): don't compute noise and "tmp" twice. Use the previous results.
   noiseAvg = 0.0;
   tmpAvg = 0.0;
   num = 0;
   if (aec->num_bands > 1) {
     for (i = 0; i < PART_LEN; i++) {
-      rand[i] = ((float)randW16[i]) / 32768;
+      rand[i] = (static_cast<float>(randW16[i])) / 32768;
     }
 
     // average noise scale
     // average over second half of freq spectrum (i.e., 4->8khz)
-    // TODO: we shouldn't need num. We know how many elements we're summing.
+    // TODO(peah): we shouldn't need num. We know how many elements we're
+    // summing.
     for (i = PART_LEN1 >> 1; i < PART_LEN1; i++) {
       num++;
       noiseAvg += sqrtf(noisePow[i]);
     }
-    noiseAvg /= (float)num;
+    noiseAvg /= static_cast<float>(num);
 
     // average nlp scale
     // average over second half of freq spectrum (i.e., 4->8khz)
-    // TODO: we shouldn't need num. We know how many elements we're summing.
+    // TODO(peah): we shouldn't need num. We know how many elements we're
+    // summing.
     num = 0;
     for (i = PART_LEN1 >> 1; i < PART_LEN1; i++) {
       num++;
       tmpAvg += sqrtf(WEBRTC_SPL_MAX(1 - lambda[i] * lambda[i], 0));
     }
-    tmpAvg /= (float)num;
+    tmpAvg /= static_cast<float>(num);
 
     // Use average noise for H band
-    // TODO: we should probably have a new random vector here.
+    // TODO(peah): we should probably have a new random vector here.
     // Reject LF noise
     u[0][0] = 0;
     u[0][1] = 0;
     for (i = 1; i < PART_LEN1; i++) {
       tmp = pi2 * rand[i - 1];
 
       // Use average noise for H band
-      u[i][0] = noiseAvg * (float)cos(tmp);
-      u[i][1] = -noiseAvg * (float)sin(tmp);
+      u[i][0] = noiseAvg * static_cast<float>(cos(tmp));
+      u[i][1] = -noiseAvg * static_cast<float>(sin(tmp));
     }
     u[PART_LEN][1] = 0;
 
     for (i = 0; i < PART_LEN1; i++) {
       // Use average NLP weight for H band
       comfortNoiseHband[0][i] = tmpAvg * u[i][0];
       comfortNoiseHband[1][i] = tmpAvg * u[i][1];
     }
   } else {
     memset(comfortNoiseHband, 0,
@@ skipping 48 matching lines @@
       "addiu      %[aIm],     %[aIm],         8                       \n\t"
       "addiu      %[len],     %[len],         -1                      \n\t"
       "sub.s      %[f8],      %[f8],          %[f12]                  \n\t"
       "mul.s      %[f12],     %[f7],          %[f5]                   \n\t"
       "lwc1       %[f2],      0(%[yf0])                               \n\t"
       "add.s      %[f1],      %[f0],          %[f1]                   \n\t"
       "lwc1       %[f3],      0(%[yf1])                               \n\t"
       "sub.s      %[f9],      %[f9],          %[f11]                  \n\t"
       "lwc1       %[f6],      4(%[yf0])                               \n\t"
       "add.s      %[f4],      %[f4],          %[f12]                  \n\t"
-#else // #if !defined(MIPS32_R2_LE)
+#else  // #if !defined(MIPS32_R2_LE)
       "addiu      %[aRe],     %[aRe],         8                       \n\t"
       "addiu      %[aIm],     %[aIm],         8                       \n\t"
       "addiu      %[len],     %[len],         -1                      \n\t"
       "nmsub.s    %[f8],      %[f8],          %[f2],      %[f3]       \n\t"
       "lwc1       %[f2],      0(%[yf0])                               \n\t"
       "madd.s     %[f1],      %[f0],          %[f3],      %[f1]       \n\t"
       "lwc1       %[f3],      0(%[yf1])                               \n\t"
       "nmsub.s    %[f9],      %[f9],          %[f6],      %[f7]       \n\t"
       "lwc1       %[f6],      4(%[yf0])                               \n\t"
       "madd.s     %[f4],      %[f4],          %[f7],      %[f5]       \n\t"
-#endif // #if !defined(MIPS32_R2_LE)
+#endif  // #if !defined(MIPS32_R2_LE)
       "lwc1       %[f5],      4(%[yf1])                               \n\t"
       "add.s      %[f2],      %[f2],          %[f8]                   \n\t"
       "addiu      %[bRe],     %[bRe],         8                       \n\t"
       "addiu      %[bIm],     %[bIm],         8                       \n\t"
       "add.s      %[f3],      %[f3],          %[f1]                   \n\t"
       "add.s      %[f6],      %[f6],          %[f9]                   \n\t"
       "add.s      %[f5],      %[f5],          %[f4]                   \n\t"
       "swc1       %[f2],      0(%[yf0])                               \n\t"
       "swc1       %[f3],      0(%[yf1])                               \n\t"
       "swc1       %[f6],      4(%[yf0])                               \n\t"
       "swc1       %[f5],      4(%[yf1])                               \n\t"
       "addiu      %[yf0],     %[yf0],         8                       \n\t"
       "bgtz       %[len],     1b                                      \n\t"
       " addiu     %[yf1],     %[yf1],         8                       \n\t"
       "lwc1       %[f0],      0(%[aRe])                               \n\t"
       "lwc1       %[f1],      0(%[bRe])                               \n\t"
       "lwc1       %[f2],      0(%[bIm])                               \n\t"
       "lwc1       %[f3],      0(%[aIm])                               \n\t"
       "mul.s      %[f8],      %[f0],          %[f1]                   \n\t"
       "mul.s      %[f0],      %[f0],          %[f2]                   \n\t"
 #if !defined(MIPS32_R2_LE)
       "mul.s      %[f12],     %[f2],          %[f3]                   \n\t"
       "mul.s      %[f1],      %[f3],          %[f1]                   \n\t"
       "sub.s      %[f8],      %[f8],          %[f12]                  \n\t"
       "lwc1       %[f2],      0(%[yf0])                               \n\t"
       "add.s      %[f1],      %[f0],          %[f1]                   \n\t"
       "lwc1       %[f3],      0(%[yf1])                               \n\t"
-#else // #if !defined(MIPS32_R2_LE)
+#else  // #if !defined(MIPS32_R2_LE)
       "nmsub.s    %[f8],      %[f8],          %[f2],      %[f3]       \n\t"
       "lwc1       %[f2],      0(%[yf0])                               \n\t"
       "madd.s     %[f1],      %[f0],          %[f3],      %[f1]       \n\t"
       "lwc1       %[f3],      0(%[yf1])                               \n\t"
-#endif // #if !defined(MIPS32_R2_LE)
+#endif  // #if !defined(MIPS32_R2_LE)
       "add.s      %[f2],      %[f2],          %[f8]                   \n\t"
       "add.s      %[f3],      %[f3],          %[f1]                   \n\t"
       "swc1       %[f2],      0(%[yf0])                               \n\t"
       "swc1       %[f3],      0(%[yf1])                               \n\t"
       ".set       pop                                                 \n\t"
       : [f0] "=&f" (f0), [f1] "=&f" (f1), [f2] "=&f" (f2),
         [f3] "=&f" (f3), [f4] "=&f" (f4), [f5] "=&f" (f5),
         [f6] "=&f" (f6), [f7] "=&f" (f7), [f8] "=&f" (f8),
         [f9] "=&f" (f9), [f10] "=&f" (f10), [f11] "=&f" (f11),
         [f12] "=&f" (f12), [f13] "=&f" (f13), [aRe] "+r" (aRe),
@@ skipping 55 matching lines @@
       "mul.s      %[f1],      %[f3],          %[f1]                   \n\t"
       "mul.s      %[f11],     %[f7],          %[f6]                   \n\t"
       "mul.s      %[f5],      %[f7],          %[f5]                   \n\t"
       "addiu      %[aIm],     %[aIm],         8                       \n\t"
       "addiu      %[bIm],     %[bIm],         8                       \n\t"
       "addiu      %[len],     %[len],         -1                      \n\t"
       "add.s      %[f8],      %[f8],          %[f10]                  \n\t"
       "sub.s      %[f1],      %[f0],          %[f1]                   \n\t"
       "add.s      %[f9],      %[f9],          %[f11]                  \n\t"
       "sub.s      %[f5],      %[f4],          %[f5]                   \n\t"
-#else // #if !defined(MIPS32_R2_LE)
+#else  // #if !defined(MIPS32_R2_LE)
       "addiu      %[aIm],     %[aIm],         8                       \n\t"
       "addiu      %[bIm],     %[bIm],         8                       \n\t"
       "addiu      %[len],     %[len],         -1                      \n\t"
       "madd.s     %[f8],      %[f8],          %[f3],      %[f2]       \n\t"
       "nmsub.s    %[f1],      %[f0],          %[f3],      %[f1]       \n\t"
       "madd.s     %[f9],      %[f9],          %[f7],      %[f6]       \n\t"
       "nmsub.s    %[f5],      %[f4],          %[f7],      %[f5]       \n\t"
-#endif // #if !defined(MIPS32_R2_LE)
+#endif  // #if !defined(MIPS32_R2_LE)
       "swc1       %[f8],      0(%[fft_tmp])                           \n\t"
       "swc1       %[f1],      4(%[fft_tmp])                           \n\t"
       "swc1       %[f9],      8(%[fft_tmp])                           \n\t"
       "swc1       %[f5],      12(%[fft_tmp])                          \n\t"
       "bgtz       %[len],     1b                                      \n\t"
       " addiu     %[fft_tmp], %[fft_tmp],     16                      \n\t"
       "lwc1       %[f0],      0(%[aRe])                               \n\t"
       "lwc1       %[f1],      0(%[bRe])                               \n\t"
       "lwc1       %[f2],      0(%[bIm])                               \n\t"
       "lwc1       %[f3],      0(%[aIm])                               \n\t"
       "mul.s      %[f8],      %[f0],          %[f1]                   \n\t"
 #if !defined(MIPS32_R2_LE)
       "mul.s      %[f10],     %[f3],          %[f2]                   \n\t"
       "add.s      %[f8],      %[f8],          %[f10]                  \n\t"
-#else // #if !defined(MIPS32_R2_LE)
+#else  // #if !defined(MIPS32_R2_LE)
       "madd.s     %[f8],      %[f8],          %[f3],      %[f2]       \n\t"
-#endif // #if !defined(MIPS32_R2_LE)
+#endif  // #if !defined(MIPS32_R2_LE)
       "swc1       %[f8],      4(%[fft])                               \n\t"
       ".set       pop                                                 \n\t"
       : [f0] "=&f" (f0), [f1] "=&f" (f1), [f2] "=&f" (f2),
         [f3] "=&f" (f3), [f4] "=&f" (f4), [f5] "=&f" (f5),
         [f6] "=&f" (f6), [f7] "=&f" (f7), [f8] "=&f" (f8),
         [f9] "=&f" (f9), [f10] "=&f" (f10), [f11] "=&f" (f11),
         [f12] "=&f" (f12), [aRe] "+r" (aRe), [aIm] "+r" (aIm),
         [bRe] "+r" (bRe), [bIm] "+r" (bIm), [fft_tmp] "=&r" (fft_tmp),
         [len] "+r" (len)
       : [fft] "r" (fft)
@@ skipping 116 matching lines @@
   const float one = 1.0;
   float* p_hNl;
   float* p_efw0;
   float* p_efw1;
   float* p_WebRtcAec_wC;
   float temp1, temp2, temp3, temp4;
 
   p_hNl = &hNl[0];
   p_efw0 = &efw[0][0];
   p_efw1 = &efw[1][0];
-  p_WebRtcAec_wC = (float*)&WebRtcAec_weightCurve[0];
+  p_WebRtcAec_wC = reinterpret_cast<float*>(&WebRtcAec_weightCurve[0]);
 
   for (i = 0; i < PART_LEN1; i++) {
     // Weight subbands
     __asm __volatile (
       ".set      push                                              \n\t"
       ".set      noreorder                                         \n\t"
       "lwc1      %[temp1],    0(%[p_hNl])                          \n\t"
       "lwc1      %[temp2],    0(%[p_wC])                           \n\t"
       "c.lt.s    %[hNlFb],    %[temp1]                             \n\t"
       "bc1f      1f                                                \n\t"
       " mul.s    %[temp3],    %[temp2],     %[hNlFb]               \n\t"
       "sub.s     %[temp4],    %[one],       %[temp2]               \n\t"
 #if !defined(MIPS32_R2_LE)
       "mul.s     %[temp1],    %[temp1],     %[temp4]               \n\t"
       "add.s     %[temp1],    %[temp3],     %[temp1]               \n\t"
-#else // #if !defined(MIPS32_R2_LE)
+#else  // #if !defined(MIPS32_R2_LE)
       "madd.s    %[temp1],    %[temp3],     %[temp1],   %[temp4]   \n\t"
-#endif // #if !defined(MIPS32_R2_LE)
+#endif  // #if !defined(MIPS32_R2_LE)
       "swc1      %[temp1],    0(%[p_hNl])                          \n\t"
      "1:                                                           \n\t"
       "addiu     %[p_wC],     %[p_wC],      4                      \n\t"
       ".set      pop                                               \n\t"
       : [temp1] "=&f" (temp1), [temp2] "=&f" (temp2), [temp3] "=&f" (temp3),
         [temp4] "=&f" (temp4), [p_wC] "+r" (p_WebRtcAec_wC)
       : [hNlFb] "f" (hNlFb), [one] "f" (one), [p_hNl] "r" (p_hNl)
       : "memory"
     );
 
@@ skipping 88 matching lines @@
   );
 }
 
 void WebRtcAec_InitAec_mips(void) {
   WebRtcAec_FilterFar = WebRtcAec_FilterFar_mips;
   WebRtcAec_FilterAdaptation = WebRtcAec_FilterAdaptation_mips;
   WebRtcAec_ScaleErrorSignal = WebRtcAec_ScaleErrorSignal_mips;
   WebRtcAec_ComfortNoise = WebRtcAec_ComfortNoise_mips;
   WebRtcAec_OverdriveAndSuppress = WebRtcAec_OverdriveAndSuppress_mips;
 }