Added a new echo likelihood stat that reports the maximum value from a previous time period.

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 86 matching lines @@
   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,
-                             float residual_echo_likelihood) {
+                             float residual_echo_likelihood,
+                             float residual_echo_likelihood_recent_max) {
   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);
+    report->AddFloat(

[hbos, 2017/01/16 11:29:49]

This can leak the default residual_echo_likelihood_recent_max -1 to the stats,
there should be an "if (residual_echo_likelihood_recent_max >= 0.0f)" or if the
two are tied together there should be a RTC_DCHECK_GE but that check would get
hit before Chrome's implementation is able to land.

[hbos, 2017/01/16 11:36:54]

If the stat is optional, prefer rtc::Optional to -1.

[hlundin-webrtc, 2017/01/16 13:44:56]

I'm making a minimal fix for now in https://codereview.webrtc.org/2632243002/.

+        StatsReport::kStatsValueNameResidualEchoLikelihoodRecentMax,
+        residual_echo_likelihood_recent_max);
   }
 }
 
 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 },
@@ skipping 40 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.residual_echo_likelihood);
+      info.residual_echo_likelihood, info.residual_echo_likelihood_recent_max);
 
   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 732 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.residual_echo_likelihood);
+        stats.residual_echo_likelihood,
+        stats.residual_echo_likelihood_recent_max);
 
     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