Adding stats that can be used to compute output audio levels.

webrtc/audio/audio_send_stream_unittest.cc

 /*
  *  Copyright (c) 2015 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 37 matching lines @@
 const uint32_t kSsrc = 1234;
 const char* kCName = "foo_name";
 const int kAudioLevelId = 2;
 const int kTransportSequenceNumberId = 4;
 const int kEchoDelayMedian = 254;
 const int kEchoDelayStdDev = -3;
 const int kEchoReturnLoss = -65;
 const int kEchoReturnLossEnhancement = 101;
 const float kResidualEchoLikelihood = -1.0f;
 const int32_t kSpeechInputLevel = 96;
+const double kTotalInputEnergy = 0.25;
+const double kTotalInputDuration = 0.5;
 const CallStatistics kCallStats = {
     1345,  1678,  1901, 1234,  112, 13456, 17890, 1567, -1890, -1123};
 const ReportBlock kReportBlock = {456, 780, 123, 567, 890, 132, 143, 13354};
 const int kTelephoneEventPayloadType = 123;
 const int kTelephoneEventPayloadFrequency = 65432;
 const int kTelephoneEventCode = 45;
 const int kTelephoneEventDuration = 6789;
 const CodecInst kIsacCodec = {103, "isac", 16000, 320, 1, 32000};
 constexpr int kIsacPayloadType = 103;
 const SdpAudioFormat kIsacFormat = {"isac", 16000, 1};
 const SdpAudioFormat kOpusFormat = {"opus", 48000, 2};
 const SdpAudioFormat kG722Format = {"g722", 8000, 1};
 const AudioCodecSpec kCodecSpecs[] = {
     {kIsacFormat, {16000, 1, 32000, 10000, 32000}},
     {kOpusFormat, {48000, 1, 32000, 6000, 510000}},
     {kG722Format, {16000, 1, 64000}}};
 
 class MockLimitObserver : public BitrateAllocator::LimitObserver {
  public:
   MOCK_METHOD2(OnAllocationLimitsChanged,
                void(uint32_t min_send_bitrate_bps,
                     uint32_t max_padding_bitrate_bps));
 };
 
 class MockTransmitMixer : public voe::TransmitMixer {
  public:
   MOCK_CONST_METHOD0(AudioLevelFullRange, int16_t());
+  MOCK_CONST_METHOD0(GetTotalInputEnergy, double());
+  MOCK_CONST_METHOD0(GetTotalInputDuration, double());
 };
 
 std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock(
     int payload_type,
     const SdpAudioFormat& format) {
   for (const auto& spec : kCodecSpecs) {
     if (format == spec.format) {
       std::unique_ptr<MockAudioEncoder> encoder(new MockAudioEncoder);
       ON_CALL(*encoder.get(), SampleRateHz())
           .WillByDefault(Return(spec.info.sample_rate_hz));
@@ skipping 180 matching lines @@
     EXPECT_TRUE(channel_proxy_);
     EXPECT_CALL(*channel_proxy_, GetRTCPStatistics())
         .WillRepeatedly(Return(kCallStats));
     EXPECT_CALL(*channel_proxy_, GetRemoteRTCPReportBlocks())
         .WillRepeatedly(Return(report_blocks));
     EXPECT_CALL(voice_engine_, transmit_mixer())
         .WillRepeatedly(Return(&transmit_mixer_));
 
     EXPECT_CALL(transmit_mixer_, AudioLevelFullRange())
         .WillRepeatedly(Return(kSpeechInputLevel));
+    EXPECT_CALL(transmit_mixer_, GetTotalInputEnergy())
+        .WillRepeatedly(Return(kTotalInputEnergy));
+    EXPECT_CALL(transmit_mixer_, GetTotalInputDuration())
+        .WillRepeatedly(Return(kTotalInputDuration));
 
     // We have to set the instantaneous value, the average, min and max. We only
     // care about the instantaneous value, so we set all to the same value.
     audio_processing_stats_.echo_return_loss.Set(
         kEchoReturnLoss, kEchoReturnLoss, kEchoReturnLoss, kEchoReturnLoss);
     audio_processing_stats_.echo_return_loss_enhancement.Set(
         kEchoReturnLossEnhancement, kEchoReturnLossEnhancement,
         kEchoReturnLossEnhancement, kEchoReturnLossEnhancement);
     audio_processing_stats_.delay_median = kEchoDelayMedian;
     audio_processing_stats_.delay_standard_deviation = kEchoDelayStdDev;
@@ skipping 114 matching lines @@
             stats.packets_lost);
   EXPECT_EQ(Q8ToFloat(kReportBlock.fraction_lost), stats.fraction_lost);
   EXPECT_EQ(std::string(kIsacCodec.plname), stats.codec_name);
   EXPECT_EQ(static_cast<int32_t>(kReportBlock.extended_highest_sequence_number),
             stats.ext_seqnum);
   EXPECT_EQ(static_cast<int32_t>(kReportBlock.interarrival_jitter /
                                  (kIsacCodec.plfreq / 1000)),
             stats.jitter_ms);
   EXPECT_EQ(kCallStats.rttMs, stats.rtt_ms);
   EXPECT_EQ(static_cast<int32_t>(kSpeechInputLevel), stats.audio_level);
+  EXPECT_EQ(kTotalInputEnergy, stats.total_input_energy);
+  EXPECT_EQ(kTotalInputDuration, stats.total_input_duration);
   EXPECT_EQ(-1, stats.aec_quality_min);
   EXPECT_EQ(kEchoDelayMedian, stats.echo_delay_median_ms);
   EXPECT_EQ(kEchoDelayStdDev, stats.echo_delay_std_ms);
   EXPECT_EQ(kEchoReturnLoss, stats.echo_return_loss);
   EXPECT_EQ(kEchoReturnLossEnhancement, stats.echo_return_loss_enhancement);
   EXPECT_EQ(kResidualEchoLikelihood, stats.residual_echo_likelihood);
   EXPECT_FALSE(stats.typing_noise_detected);
 }
 
 TEST(AudioSendStreamTest, GetStatsTypingNoiseDetected) {
@@ skipping 107 matching lines @@
   stream_config.send_codec_spec->cng_payload_type = rtc::Optional<int>(105);
   internal::AudioSendStream send_stream(
       stream_config, helper.audio_state(), helper.worker_queue(),
       helper.transport(), helper.bitrate_allocator(), helper.event_log(),
       helper.rtcp_rtt_stats(), rtc::Optional<RtpState>());
   send_stream.Reconfigure(stream_config);
 }
 
 }  // namespace test
 }  // namespace webrtc