Removed the indirect error message reporting in aec and aecm.

webrtc/modules/audio_processing/aec/echo_cancellation.c

 /*
  *  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 128 matching lines @@
   // largest possible drift compensation (kResamplerBufferSize) + "almost" an
   // FFT buffer (PART_LEN2 - 1).
   aecpc->far_pre_buf =
       WebRtc_CreateBuffer(PART_LEN2 + kResamplerBufferSize, sizeof(float));
   if (!aecpc->far_pre_buf) {
     WebRtcAec_Free(aecpc);
     return NULL;
   }
 
   aecpc->initFlag = 0;
-  aecpc->lastError = 0;
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
   {
     char filename[64];
     sprintf(filename, "aec_buf%d.dat", webrtc_aec_instance_count);
     aecpc->bufFile = fopen(filename, "wb");
     sprintf(filename, "aec_skew%d.dat", webrtc_aec_instance_count);
     aecpc->skewFile = fopen(filename, "wb");
     sprintf(filename, "aec_delay%d.dat", webrtc_aec_instance_count);
     aecpc->delayFile = fopen(filename, "wb");
@@ skipping 25 matching lines @@
 }
 
 int32_t WebRtcAec_Init(void* aecInst, int32_t sampFreq, int32_t scSampFreq) {
   Aec* aecpc = aecInst;
   AecConfig aecConfig;
 
   if (sampFreq != 8000 &&
       sampFreq != 16000 &&
       sampFreq != 32000 &&
       sampFreq != 48000) {
-    aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
-    return -1;
+    return AEC_BAD_PARAMETER_ERROR;
   }
   aecpc->sampFreq = sampFreq;
 
   if (scSampFreq < 1 || scSampFreq > 96000) {
-    aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
-    return -1;
+    return AEC_BAD_PARAMETER_ERROR;
   }
   aecpc->scSampFreq = scSampFreq;
 
   // Initialize echo canceller core
   if (WebRtcAec_InitAec(aecpc->aec, aecpc->sampFreq) == -1) {
-    aecpc->lastError = AEC_UNSPECIFIED_ERROR;
-    return -1;
+    return AEC_UNSPECIFIED_ERROR;
   }
 
   if (WebRtcAec_InitResampler(aecpc->resampler, aecpc->scSampFreq) == -1) {
-    aecpc->lastError = AEC_UNSPECIFIED_ERROR;
-    return -1;
+    return AEC_UNSPECIFIED_ERROR;
   }
 
   WebRtc_InitBuffer(aecpc->far_pre_buf);
   WebRtc_MoveReadPtr(aecpc->far_pre_buf, -PART_LEN);  // Start overlap.
 
   aecpc->initFlag = initCheck;  // indicates that initialization has been done
 
   if (aecpc->sampFreq == 32000 || aecpc->sampFreq == 48000) {
     aecpc->splitSampFreq = 16000;
   } else {
@@ skipping 29 matching lines @@
 
   aecpc->farend_started = 0;
 
   // Default settings.
   aecConfig.nlpMode = kAecNlpModerate;
   aecConfig.skewMode = kAecFalse;
   aecConfig.metricsMode = kAecFalse;
   aecConfig.delay_logging = kAecFalse;
 
   if (WebRtcAec_set_config(aecpc, aecConfig) == -1) {
-    aecpc->lastError = AEC_UNSPECIFIED_ERROR;
-    return -1;
+    return AEC_UNSPECIFIED_ERROR;
   }
 
   return 0;
 }
 
+// Returns any error that is caused when buffering the
+// far-end signal.
+int32_t WebRtcAec_GetBufferFarendError(void* aecInst,
+                                       const float* farend,
+                                       size_t nrOfSamples) {
+  Aec* aecpc = aecInst;
+
+  if (!farend)
+    return AEC_NULL_POINTER_ERROR;
+
+  if (aecpc->initFlag != initCheck)
+    return AEC_UNINITIALIZED_ERROR;
+
+  // number of samples == 160 for SWB input
+  if (nrOfSamples != 80 && nrOfSamples != 160)
+    return AEC_BAD_PARAMETER_ERROR;
+
+  return 0;
+}
+
 // only buffer L band for farend
 int32_t WebRtcAec_BufferFarend(void* aecInst,
                                const float* farend,
                                size_t nrOfSamples) {
   Aec* aecpc = aecInst;
   size_t newNrOfSamples = nrOfSamples;
   float new_farend[MAX_RESAMP_LEN];
   const float* farend_ptr = farend;
 
-  if (farend == NULL) {
-    aecpc->lastError = AEC_NULL_POINTER_ERROR;
-    return -1;
-  }
+  // Get any error caused by buffering the farend signal.
+  int32_t error_code = WebRtcAec_GetBufferFarendError(aecInst, farend,
+                                                      nrOfSamples);
 
-  if (aecpc->initFlag != initCheck) {
-    aecpc->lastError = AEC_UNINITIALIZED_ERROR;
-    return -1;
-  }
+  if (error_code != 0)
+    return error_code;
 
-  // number of samples == 160 for SWB input
-  if (nrOfSamples != 80 && nrOfSamples != 160) {
-    aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
-    return -1;
-  }
 
   if (aecpc->skewMode == kAecTrue && aecpc->resample == kAecTrue) {
     // Resample and get a new number of samples
     WebRtcAec_ResampleLinear(aecpc->resampler,
                              farend,
                              nrOfSamples,
                              aecpc->skew,
                              new_farend,
                              &newNrOfSamples);
     farend_ptr = new_farend;
@@ skipping 31 matching lines @@
                           const float* const* nearend,
                           size_t num_bands,
                           float* const* out,
                           size_t nrOfSamples,
                           int16_t msInSndCardBuf,
                           int32_t skew) {
   Aec* aecpc = aecInst;
   int32_t retVal = 0;
 
   if (out == NULL) {
-    aecpc->lastError = AEC_NULL_POINTER_ERROR;
-    return -1;
+    return AEC_NULL_POINTER_ERROR;
   }
 
   if (aecpc->initFlag != initCheck) {
-    aecpc->lastError = AEC_UNINITIALIZED_ERROR;
-    return -1;
+    return AEC_UNINITIALIZED_ERROR;
   }
 
   // number of samples == 160 for SWB input
   if (nrOfSamples != 80 && nrOfSamples != 160) {
-    aecpc->lastError = AEC_BAD_PARAMETER_ERROR;
-    return -1;
+    return AEC_BAD_PARAMETER_ERROR;
   }
 
   if (msInSndCardBuf < 0) {
     msInSndCardBuf = 0;
-    aecpc->lastError = AEC_BAD_PARAMETER_WARNING;
-    retVal = -1;
+    retVal = AEC_BAD_PARAMETER_WARNING;
   } else if (msInSndCardBuf > kMaxTrustedDelayMs) {
     // The clamping is now done in ProcessExtended/Normal().
-    aecpc->lastError = AEC_BAD_PARAMETER_WARNING;
-    retVal = -1;
+    retVal = AEC_BAD_PARAMETER_WARNING;
   }
 
   // This returns the value of aec->extended_filter_enabled.
   if (WebRtcAec_extended_filter_enabled(aecpc->aec)) {
     ProcessExtended(aecpc,
                     nearend,
                     num_bands,
                     out,
                     nrOfSamples,
                     msInSndCardBuf,
                     skew);
   } else {
-    if (ProcessNormal(aecpc,
-                      nearend,
-                      num_bands,
-                      out,
-                      nrOfSamples,
-                      msInSndCardBuf,
-                      skew) != 0) {
-      retVal = -1;
-    }
+    retVal = ProcessNormal(aecpc,
+                           nearend,
+                           num_bands,
+                           out,
+                           nrOfSamples,
+                           msInSndCardBuf,
+                           skew);
   }
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
   {
     int16_t far_buf_size_ms = (int16_t)(WebRtcAec_system_delay(aecpc->aec) /
                                         (sampMsNb * aecpc->rate_factor));
     (void)fwrite(&far_buf_size_ms, 2, 1, aecpc->bufFile);
     (void)fwrite(
         &aecpc->knownDelay, sizeof(aecpc->knownDelay), 1, aecpc->delayFile);
   }
 #endif
 
   return retVal;
 }
 
 int WebRtcAec_set_config(void* handle, AecConfig config) {
   Aec* self = (Aec*)handle;
   if (self->initFlag != initCheck) {
-    self->lastError = AEC_UNINITIALIZED_ERROR;
-    return -1;
+    return AEC_UNINITIALIZED_ERROR;
   }
 
   if (config.skewMode != kAecFalse && config.skewMode != kAecTrue) {
-    self->lastError = AEC_BAD_PARAMETER_ERROR;
-    return -1;
+    return AEC_BAD_PARAMETER_ERROR;
   }
   self->skewMode = config.skewMode;
 
   if (config.nlpMode != kAecNlpConservative &&
       config.nlpMode != kAecNlpModerate &&
       config.nlpMode != kAecNlpAggressive) {
-    self->lastError = AEC_BAD_PARAMETER_ERROR;
-    return -1;
+    return AEC_BAD_PARAMETER_ERROR;
   }
 
   if (config.metricsMode != kAecFalse && config.metricsMode != kAecTrue) {
-    self->lastError = AEC_BAD_PARAMETER_ERROR;
-    return -1;
+    return AEC_BAD_PARAMETER_ERROR;
   }
 
   if (config.delay_logging != kAecFalse && config.delay_logging != kAecTrue) {
-    self->lastError = AEC_BAD_PARAMETER_ERROR;
-    return -1;
+    return AEC_BAD_PARAMETER_ERROR;
   }
 
   WebRtcAec_SetConfigCore(
       self->aec, config.nlpMode, config.metricsMode, config.delay_logging);
   return 0;
 }
 
 int WebRtcAec_get_echo_status(void* handle, int* status) {
   Aec* self = (Aec*)handle;
   if (status == NULL) {
-    self->lastError = AEC_NULL_POINTER_ERROR;
-    return -1;
+    return AEC_NULL_POINTER_ERROR;
   }
   if (self->initFlag != initCheck) {
-    self->lastError = AEC_UNINITIALIZED_ERROR;
-    return -1;
+    return AEC_UNINITIALIZED_ERROR;
   }
 
   *status = WebRtcAec_echo_state(self->aec);
 
   return 0;
 }
 
 int WebRtcAec_GetMetrics(void* handle, AecMetrics* metrics) {
   const float kUpWeight = 0.7f;
   float dtmp;
   int stmp;
   Aec* self = (Aec*)handle;
   Stats erl;
   Stats erle;
   Stats a_nlp;
 
   if (handle == NULL) {
     return -1;
   }
   if (metrics == NULL) {
-    self->lastError = AEC_NULL_POINTER_ERROR;
-    return -1;
+    return AEC_NULL_POINTER_ERROR;
   }
   if (self->initFlag != initCheck) {
-    self->lastError = AEC_UNINITIALIZED_ERROR;
-    return -1;
+    return AEC_UNINITIALIZED_ERROR;
   }
 
   WebRtcAec_GetEchoStats(self->aec, &erl, &erle, &a_nlp);
 
   // ERL
   metrics->erl.instant = (int)erl.instant;
 
   if ((erl.himean > kOffsetLevel) && (erl.average > kOffsetLevel)) {
     // Use a mix between regular average and upper part average.
     dtmp = kUpWeight * erl.himean + (1 - kUpWeight) * erl.average;
@@ skipping 64 matching lines @@
 
   return 0;
 }
 
 int WebRtcAec_GetDelayMetrics(void* handle,
                               int* median,
                               int* std,
                               float* fraction_poor_delays) {
   Aec* self = handle;
   if (median == NULL) {
-    self->lastError = AEC_NULL_POINTER_ERROR;
-    return -1;
+    return AEC_NULL_POINTER_ERROR;
   }
   if (std == NULL) {
-    self->lastError = AEC_NULL_POINTER_ERROR;
-    return -1;
+    return AEC_NULL_POINTER_ERROR;
   }
   if (self->initFlag != initCheck) {
-    self->lastError = AEC_UNINITIALIZED_ERROR;
-    return -1;
+    return AEC_UNINITIALIZED_ERROR;
   }
   if (WebRtcAec_GetDelayMetricsCore(self->aec, median, std,
                                     fraction_poor_delays) ==
       -1) {
     // Logging disabled.
-    self->lastError = AEC_UNSUPPORTED_FUNCTION_ERROR;
-    return -1;
+    return AEC_UNSUPPORTED_FUNCTION_ERROR;
   }
 
   return 0;
 }
 
-int32_t WebRtcAec_get_error_code(void* aecInst) {
-  Aec* aecpc = aecInst;
-  return aecpc->lastError;
-}
 
 AecCore* WebRtcAec_aec_core(void* handle) {
   if (!handle) {
     return NULL;
   }
   return ((Aec*)handle)->aec;
 }
 
 static int ProcessNormal(Aec* aecpc,
                          const float* const* nearend,
@@ skipping 15 matching lines @@
   msInSndCardBuf += 10;
   aecpc->msInSndCardBuf = msInSndCardBuf;
 
   if (aecpc->skewMode == kAecTrue) {
     if (aecpc->skewFrCtr < 25) {
       aecpc->skewFrCtr++;
     } else {
       retVal = WebRtcAec_GetSkew(aecpc->resampler, skew, &aecpc->skew);
       if (retVal == -1) {
         aecpc->skew = 0;
-        aecpc->lastError = AEC_BAD_PARAMETER_WARNING;
+        retVal = AEC_BAD_PARAMETER_WARNING;
       }
 
       aecpc->skew /= aecpc->sampFactor * nrOfSamples;
 
       if (aecpc->skew < 1.0e-3 && aecpc->skew > -1.0e-3) {
         aecpc->resample = kAecFalse;
       } else {
         aecpc->resample = kAecTrue;
       }
 
@@ skipping 283 matching lines @@
     }
   } else {
     self->timeForDelayChange = 0;
   }
   self->lastDelayDiff = delay_difference;
 
   if (self->timeForDelayChange > 25) {
     self->knownDelay = WEBRTC_SPL_MAX((int)self->filtDelay - 256, 0);
   }
 }