Implement AudioReceiveStream::GetStats().

webrtc/audio/audio_receive_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.
  */
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/audio/audio_receive_stream.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_estimator.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/test/fake_voice_engine.h"
 
-namespace webrtc {
+namespace {
+
+using webrtc::ByteWriter;
 
 const size_t kAbsoluteSendTimeLength = 4;
 
 void BuildAbsoluteSendTimeExtension(uint8_t* buffer,
                                     int id,
                                     uint32_t abs_send_time) {
   const size_t kRtpOneByteHeaderLength = 4;
   const uint16_t kRtpOneByteHeaderExtensionId = 0xBEDE;
   ByteWriter<uint16_t>::WriteBigEndian(buffer, kRtpOneByteHeaderExtensionId);
 
@@ skipping 10 matching lines @@
 size_t CreateRtpHeaderWithAbsSendTime(uint8_t* header,
                                       int extension_id,
                                       uint32_t abs_send_time) {
   header[0] = 0x80;   // Version 2.
   header[0] |= 0x10;  // Set extension bit.
   header[1] = 100;    // Payload type.
   header[1] |= 0x80;  // Marker bit is set.
   ByteWriter<uint16_t>::WriteBigEndian(header + 2, 0x1234);  // Sequence number.
   ByteWriter<uint32_t>::WriteBigEndian(header + 4, 0x5678);  // Timestamp.
   ByteWriter<uint32_t>::WriteBigEndian(header + 8, 0x4321);  // SSRC.
-  int32_t rtp_header_length = kRtpHeaderSize;
+  int32_t rtp_header_length = webrtc::kRtpHeaderSize;
 
   BuildAbsoluteSendTimeExtension(header + rtp_header_length, extension_id,
                                  abs_send_time);
   rtp_header_length += kAbsoluteSendTimeLength;
   return rtp_header_length;
 }
 
+float Q14ToFloat(uint16_t v) {

[tommi, 2015/10/19 12:36:24]

ah, is this why?
Can we move this method to a common header and call it in the previous file
instead of having all the /(1<<14)'d inline?

[the sun, 2015/10/19 14:25:02]

Done.

+  return static_cast<float>(v) / (1 << 14);
+}
+} // namespace
+
+namespace webrtc {
+namespace test {
+
 TEST(AudioReceiveStreamTest, AudioPacketUpdatesBweWithTimestamp) {
   MockRemoteBitrateEstimator rbe;
+  FakeVoiceEngine fve;
   AudioReceiveStream::Config config;
   config.combined_audio_video_bwe = true;
-  config.voe_channel_id = 1;
+  config.voe_channel_id = fve.kReceiveChannelId;
   const int kAbsSendTimeId = 3;
   config.rtp.extensions.push_back(
       RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeId));
-  internal::AudioReceiveStream recv_stream(&rbe, config);
+  internal::AudioReceiveStream recv_stream(&rbe, config, &fve);
   uint8_t rtp_packet[30];
   const int kAbsSendTimeValue = 1234;
   CreateRtpHeaderWithAbsSendTime(rtp_packet, kAbsSendTimeId, kAbsSendTimeValue);
   PacketTime packet_time(5678000, 0);
   const size_t kExpectedHeaderLength = 20;
   EXPECT_CALL(rbe, IncomingPacket(packet_time.timestamp / 1000,
                                   sizeof(rtp_packet) - kExpectedHeaderLength,
                                   testing::_, false))
       .Times(1);
   EXPECT_TRUE(
       recv_stream.DeliverRtp(rtp_packet, sizeof(rtp_packet), packet_time));
 }
+
+TEST(AudioReceiveStreamTest, GetStats) {
+  const uint32_t kSsrc1 = 667;

[tommi, 2015/10/19 12:36:24]

if ssrc is uint32_t, it would be good to have that consistently be the case.  I
think that in general the style guide doesn't like 'unsigned' though, so fwiw...

[the sun, 2015/10/19 14:25:02]

The best option would be to create a template to represent an ID of type T, then
pass that around. It falls way outside of this CL though and the scope to
implement throughout the code base is huge.

[tommi, 2015/10/19 14:55:44]

agreed and sgtm

+
+  MockRemoteBitrateEstimator rbe;
+  FakeVoiceEngine fve;
+  AudioReceiveStream::Config config;
+  config.rtp.remote_ssrc = kSsrc1;
+  config.voe_channel_id = fve.kReceiveChannelId;
+  internal::AudioReceiveStream recv_stream(&rbe, config, &fve);
+
+  AudioReceiveStream::Stats stats = recv_stream.GetStats();
+  const CallStatistics& kCallStats = fve.GetRecvCallStats();

[tommi, 2015/10/19 12:36:24]

this should just be call_stats.  Even though it's const, it's not really a
constant since it's a constructed object and each instance of it can be
different from the next when this function is called. Constants are typically
global or class scope and are compile-time const, not runtime.

[the sun, 2015/10/19 14:25:02]

As long as you don't mind me keeping the const qualifier...

I didn't know the style guide made that distinction; thanks.

+  const CodecInst& kCodecInst = fve.GetRecvRecCodecInst();

[tommi, 2015/10/19 12:36:24]

same here and throughout.

[the sun, 2015/10/19 14:25:02]

Done.

+  const NetworkStatistics& kNetStats = fve.GetRecvNetworkStats();
+  const AudioDecodingCallStats& kDecodeStats =
+      fve.GetRecvAudioDecodingCallStats();
+  EXPECT_EQ(kSsrc1, stats.remote_ssrc);
+  EXPECT_EQ(static_cast<int64_t>(kCallStats.bytesReceived), stats.bytes_rcvd);
+  EXPECT_EQ(static_cast<uint32_t>(kCallStats.packetsReceived),
+            stats.packets_rcvd);
+  EXPECT_EQ(kCallStats.cumulativeLost, stats.packets_lost);
+  EXPECT_EQ(static_cast<float>(kCallStats.fractionLost) / 256,
+            stats.fraction_lost);
+  EXPECT_EQ(std::string(kCodecInst.plname), stats.codec_name);
+  EXPECT_EQ(kCallStats.extendedMax, stats.ext_seqnum);
+  EXPECT_EQ(kCallStats.jitterSamples / (kCodecInst.plfreq / 1000),
+            stats.jitter_ms);
+  EXPECT_EQ(kNetStats.currentBufferSize, stats.jitter_buffer_ms);
+  EXPECT_EQ(kNetStats.preferredBufferSize, stats.jitter_buffer_preferred_ms);
+  EXPECT_EQ(static_cast<uint32_t>(fve.kRecvJitterBufferDelay +
+      fve.kRecvPlayoutBufferDelay), stats.delay_estimate_ms);
+  EXPECT_EQ(static_cast<int32_t>(fve.kRecvSpeechOutputLevel),
+            stats.audio_level);
+  EXPECT_EQ(Q14ToFloat(kNetStats.currentExpandRate), stats.expand_rate);
+  EXPECT_EQ(Q14ToFloat(kNetStats.currentSpeechExpandRate),
+            stats.speech_expand_rate);
+  EXPECT_EQ(Q14ToFloat(kNetStats.currentSecondaryDecodedRate),
+            stats.secondary_decoded_rate);
+  EXPECT_EQ(Q14ToFloat(kNetStats.currentAccelerateRate), stats.accelerate_rate);
+  EXPECT_EQ(Q14ToFloat(kNetStats.currentPreemptiveRate),
+            stats.preemptive_expand_rate);
+  EXPECT_EQ(kDecodeStats.calls_to_silence_generator,
+            stats.decoding_calls_to_silence_generator);
+  EXPECT_EQ(kDecodeStats.calls_to_neteq, stats.decoding_calls_to_neteq);
+  EXPECT_EQ(kDecodeStats.decoded_normal, stats.decoding_normal);
+  EXPECT_EQ(kDecodeStats.decoded_plc, stats.decoding_plc);
+  EXPECT_EQ(kDecodeStats.decoded_cng, stats.decoding_cng);
+  EXPECT_EQ(kDecodeStats.decoded_plc_cng, stats.decoding_plc_cng);
+  EXPECT_EQ(kCallStats.capture_start_ntp_time_ms_,
+            stats.capture_start_ntp_time_ms);
+}
+}  // namespace test
 }  // namespace webrtc