Add a placeholder stat for logging the estimated residual echo likelihood.

webrtc/api/statscollector.cc

 /*
  *  Copyright 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 85 matching lines @@
                                     StatsReport* report) {
   report->AddString(StatsReport::kStatsValueNameCodecName, info.codec_name);
 }
 
 void SetAudioProcessingStats(StatsReport* report,
                              bool typing_noise_detected,
                              int echo_return_loss,
                              int echo_return_loss_enhancement,
                              int echo_delay_median_ms,
                              float aec_quality_min,
-                             int echo_delay_std_ms) {
+                             int echo_delay_std_ms,
+                             float residual_echo_likelihood) {
   report->AddBoolean(StatsReport::kStatsValueNameTypingNoiseState,
                      typing_noise_detected);
   if (aec_quality_min >= 0.0f) {
     report->AddFloat(StatsReport::kStatsValueNameEchoCancellationQualityMin,
                      aec_quality_min);
   }
   const IntForAdd ints[] = {
     { StatsReport::kStatsValueNameEchoDelayMedian, echo_delay_median_ms },
     { StatsReport::kStatsValueNameEchoDelayStdDev, echo_delay_std_ms },
   };
   for (const auto& i : ints) {
     if (i.value >= 0) {
       report->AddInt(i.name, i.value);
     }
   }
   // These can take on valid negative values.
   report->AddInt(StatsReport::kStatsValueNameEchoReturnLoss, echo_return_loss);
   report->AddInt(StatsReport::kStatsValueNameEchoReturnLossEnhancement,
                  echo_return_loss_enhancement);
+  if (residual_echo_likelihood >= 0.0f) {
+    report->AddFloat(StatsReport::kStatsValueNameResidualEchoLikelihood,
+                     residual_echo_likelihood);
+  }
 }
 
 void ExtractStats(const cricket::VoiceReceiverInfo& info, StatsReport* report) {
   ExtractCommonReceiveProperties(info, report);
   const FloatForAdd floats[] = {
     { StatsReport::kStatsValueNameExpandRate, info.expand_rate },
     { StatsReport::kStatsValueNameSecondaryDecodedRate,
       info.secondary_decoded_rate },
     { StatsReport::kStatsValueNameSpeechExpandRate, info.speech_expand_rate },
     { StatsReport::kStatsValueNameAccelerateRate, info.accelerate_rate },
@@ skipping 38 matching lines @@
   }
   report->AddString(StatsReport::kStatsValueNameMediaType, "audio");
 }
 
 void ExtractStats(const cricket::VoiceSenderInfo& info, StatsReport* report) {
   ExtractCommonSendProperties(info, report);
 
   SetAudioProcessingStats(
       report, info.typing_noise_detected, info.echo_return_loss,
       info.echo_return_loss_enhancement, info.echo_delay_median_ms,
-      info.aec_quality_min, info.echo_delay_std_ms);
+      info.aec_quality_min, info.echo_delay_std_ms,
+      info.residual_echo_likelihood);
 
   RTC_DCHECK_GE(info.audio_level, 0);
   const IntForAdd ints[] = {
     { StatsReport::kStatsValueNameAudioInputLevel, info.audio_level},
     { StatsReport::kStatsValueNameJitterReceived, info.jitter_ms },
     { StatsReport::kStatsValueNamePacketsLost, info.packets_lost },
     { StatsReport::kStatsValueNamePacketsSent, info.packets_sent },
   };
 
   for (const auto& i : ints) {
@@ skipping 724 matching lines @@
 
   auto audio_processor(track->GetAudioProcessor());
 
   if (audio_processor.get()) {
     AudioProcessorInterface::AudioProcessorStats stats;
     audio_processor->GetStats(&stats);
 
     SetAudioProcessingStats(
         report, stats.typing_noise_detected, stats.echo_return_loss,
         stats.echo_return_loss_enhancement, stats.echo_delay_median_ms,
-        stats.aec_quality_min, stats.echo_delay_std_ms);
+        stats.aec_quality_min, stats.echo_delay_std_ms,
+        stats.residual_echo_likelihood);
 
     report->AddFloat(StatsReport::kStatsValueNameAecDivergentFilterFraction,
                      stats.aec_divergent_filter_fraction);
   }
 }
 
 bool StatsCollector::GetTrackIdBySsrc(uint32_t ssrc,
                                       std::string* track_id,
                                       StatsReport::Direction direction) {
   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
@@ skipping 24 matching lines @@
     StatsReport* report = entry.second;
     report->set_timestamp(stats_gathering_started_);
   }
 }
 
 void StatsCollector::ClearUpdateStatsCacheForTest() {
   stats_gathering_started_ = 0;
 }
 
 }  // namespace webrtc