Implement AudioReceiveStream::GetStats().

webrtc/audio/audio_receive_stream_unittest.cc

Index: webrtc/audio/audio_receive_stream_unittest.cc
diff --git a/webrtc/audio/audio_receive_stream_unittest.cc b/webrtc/audio/audio_receive_stream_unittest.cc
index d6cce69dbf09d7b6053abecd43b970819591acd0..4a1c8c6343fdacc9f2e57dd2a4ac856102fe5556 100644
--- a/webrtc/audio/audio_receive_stream_unittest.cc
+++ b/webrtc/audio/audio_receive_stream_unittest.cc
@@ -11,10 +11,14 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/audio/audio_receive_stream.h"
+#include "webrtc/audio/conversion.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;
 
@@ -45,23 +49,28 @@ size_t CreateRtpHeaderWithAbsSendTime(uint8_t* header,
   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;
 }
+}  // namespace
+
+namespace webrtc {
+namespace test {
 
 TEST(AudioReceiveStreamTest, AudioPacketUpdatesBweWithTimestamp) {
   MockRemoteBitrateEstimator rbe;
+  FakeVoiceEngine fve;

[hta-webrtc, 2015/10/20 21:29:00]

My eyes tend to glaze over for names like "fve".

https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#General_Nami...
says "use meaningful names", more or less. Can we call it voice_engine?

[the sun, 2015/10/20 22:44:16]

Well, can't argue with that. Or, hey, turns out I can. :) I will change it
anyway, but first, here's my point of view:

I find that using these abbreviated nonsense names *locally* actually enhance
readability. Especially with the 80 chars/line limit (you know, there's a
*reason* certain Java style guides allow 100 chars/line).

It's hard to draw a definite line I think. Just glancing at the code below, I
spot "bwe", "voe", "plc", "cng"; members of data structures with much wider
scope than these local variables. Yes, these are more or less well known
acronyms of the field, but they are much harder to figure out the meaning of
(try Google "RED"). The definition of "fve" in this case is 3 lines above its
use.

Anyhow, I'll make it nice and verbose, with extra line breaks...

[tommi, 2015/10/21 07:35:08]

+1 on more readable code and less debating with the reviewer.

[the sun, 2015/10/21 08:29:13]

Acknowledged.

[the sun, 2015/10/21 08:29:13]

Done.

   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);
@@ -74,4 +83,57 @@ TEST(AudioReceiveStreamTest, AudioPacketUpdatesBweWithTimestamp) {
   EXPECT_TRUE(
       recv_stream.DeliverRtp(rtp_packet, sizeof(rtp_packet), packet_time));
 }
+
+TEST(AudioReceiveStreamTest, GetStats) {
+  const uint32_t kSsrc1 = 667;
+
+  MockRemoteBitrateEstimator rbe;
+  FakeVoiceEngine fve;

[hta-webrtc, 2015/10/20 21:29:00]

Here too, for both rbe and fve.

[the sun, 2015/10/21 08:29:13]

Done.

+  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& call_stats = fve.GetRecvCallStats();
+  const CodecInst& codec_inst = fve.GetRecvRecCodecInst();
+  const NetworkStatistics& net_stats = fve.GetRecvNetworkStats();
+  const AudioDecodingCallStats& decode_stats =
+      fve.GetRecvAudioDecodingCallStats();
+  EXPECT_EQ(kSsrc1, stats.remote_ssrc);
+  EXPECT_EQ(static_cast<int64_t>(call_stats.bytesReceived), stats.bytes_rcvd);
+  EXPECT_EQ(static_cast<uint32_t>(call_stats.packetsReceived),
+            stats.packets_rcvd);
+  EXPECT_EQ(call_stats.cumulativeLost, stats.packets_lost);
+  EXPECT_EQ(static_cast<float>(call_stats.fractionLost) / 256,
+            stats.fraction_lost);
+  EXPECT_EQ(std::string(codec_inst.plname), stats.codec_name);
+  EXPECT_EQ(call_stats.extendedMax, stats.ext_seqnum);
+  EXPECT_EQ(call_stats.jitterSamples / (codec_inst.plfreq / 1000),
+            stats.jitter_ms);
+  EXPECT_EQ(net_stats.currentBufferSize, stats.jitter_buffer_ms);
+  EXPECT_EQ(net_stats.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(net_stats.currentExpandRate), stats.expand_rate);
+  EXPECT_EQ(Q14ToFloat(net_stats.currentSpeechExpandRate),
+            stats.speech_expand_rate);
+  EXPECT_EQ(Q14ToFloat(net_stats.currentSecondaryDecodedRate),
+            stats.secondary_decoded_rate);
+  EXPECT_EQ(Q14ToFloat(net_stats.currentAccelerateRate), stats.accelerate_rate);
+  EXPECT_EQ(Q14ToFloat(net_stats.currentPreemptiveRate),
+            stats.preemptive_expand_rate);
+  EXPECT_EQ(decode_stats.calls_to_silence_generator,
+            stats.decoding_calls_to_silence_generator);
+  EXPECT_EQ(decode_stats.calls_to_neteq, stats.decoding_calls_to_neteq);
+  EXPECT_EQ(decode_stats.decoded_normal, stats.decoding_normal);
+  EXPECT_EQ(decode_stats.decoded_plc, stats.decoding_plc);
+  EXPECT_EQ(decode_stats.decoded_cng, stats.decoding_cng);
+  EXPECT_EQ(decode_stats.decoded_plc_cng, stats.decoding_plc_cng);
+  EXPECT_EQ(call_stats.capture_start_ntp_time_ms_,
+            stats.capture_start_ntp_time_ms);
+}
+}  // namespace test
 }  // namespace webrtc