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/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;
 
 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;
 }
+}  // 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);
   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;
+
+  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