Implement AudioSendStream::GetStats().

webrtc/audio/audio_receive_stream.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 10 matching lines @@
 #include "webrtc/voice_engine/include/voe_codec.h"
 #include "webrtc/voice_engine/include/voe_neteq_stats.h"
 #include "webrtc/voice_engine/include/voe_rtp_rtcp.h"
 #include "webrtc/voice_engine/include/voe_video_sync.h"
 #include "webrtc/voice_engine/include/voe_volume_control.h"
 
 namespace webrtc {
 std::string AudioReceiveStream::Config::Rtp::ToString() const {
   std::stringstream ss;
   ss << "{remote_ssrc: " << remote_ssrc;
+  ss << ", local_ssrc: " << local_ssrc;
   ss << ", extensions: [";
   for (size_t i = 0; i < extensions.size(); ++i) {
     ss << extensions[i].ToString();
     if (i != extensions.size() - 1) {
       ss << ", ";
     }
   }
   ss << ']';
   ss << '}';
   return ss.str();
 }
 
 std::string AudioReceiveStream::Config::ToString() const {
   std::stringstream ss;
   ss << "{rtp: " << rtp.ToString();
+  ss << ", receive_transport: "
+     << (receive_transport ? "(Transport)" : "nullptr");
+  ss << ", rtcp_send_transport: "
+     << (rtcp_send_transport ? "(Transport)" : "nullptr");
   ss << ", voe_channel_id: " << voe_channel_id;
   if (!sync_group.empty()) {
     ss << ", sync_group: " << sync_group;
   }
+  ss << ", combined_audio_video_bwe: "
+     << (combined_audio_video_bwe ? "true" : "false");
   ss << '}';
   return ss.str();
 }
 
 namespace internal {
 AudioReceiveStream::AudioReceiveStream(
       RemoteBitrateEstimator* remote_bitrate_estimator,
       const webrtc::AudioReceiveStream::Config& config,
       VoiceEngine* voice_engine)
     : remote_bitrate_estimator_(remote_bitrate_estimator),
@@ skipping 34 matching lines @@
 webrtc::AudioReceiveStream::Stats AudioReceiveStream::GetStats() const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   webrtc::AudioReceiveStream::Stats stats;
   stats.remote_ssrc = config_.rtp.remote_ssrc;
   ScopedVoEInterface<VoECodec> codec(voice_engine_);
   ScopedVoEInterface<VoENetEqStats> neteq(voice_engine_);
   ScopedVoEInterface<VoERTP_RTCP> rtp(voice_engine_);
   ScopedVoEInterface<VoEVideoSync> sync(voice_engine_);
   ScopedVoEInterface<VoEVolumeControl> volume(voice_engine_);
   unsigned int ssrc = 0;
-  webrtc::CallStatistics cs = {0};
-  webrtc::CodecInst ci = {0};
+  webrtc::CallStatistics call_stats = {0};

[tommi, 2015/10/23 12:50:37]

nice :)

[the sun, 2015/10/23 15:14:17]

Acknowledged.

+  webrtc::CodecInst codec_inst = {0};
   // Only collect stats if we have seen some traffic with the SSRC.
   if (rtp->GetRemoteSSRC(config_.voe_channel_id, ssrc) == -1 ||
-      rtp->GetRTCPStatistics(config_.voe_channel_id, cs) == -1 ||
-      codec->GetRecCodec(config_.voe_channel_id, ci) == -1) {
+      rtp->GetRTCPStatistics(config_.voe_channel_id, call_stats) == -1 ||
+      codec->GetRecCodec(config_.voe_channel_id, codec_inst) == -1) {
     return stats;
   }
 
-  stats.bytes_rcvd = cs.bytesReceived;
-  stats.packets_rcvd = cs.packetsReceived;
-  stats.packets_lost = cs.cumulativeLost;
-  stats.fraction_lost = static_cast<float>(cs.fractionLost) / (1 << 8);
-  if (ci.pltype != -1) {
-    stats.codec_name = ci.plname;
+  stats.bytes_rcvd = call_stats.bytesReceived;
+  stats.packets_rcvd = call_stats.packetsReceived;
+  stats.packets_lost = call_stats.cumulativeLost;
+  stats.fraction_lost = Q8ToFloat(call_stats.fractionLost);
+  if (codec_inst.pltype != -1) {
+    stats.codec_name = codec_inst.plname;
   }
-
-  stats.ext_seqnum = cs.extendedMax;
-  if (ci.plfreq / 1000 > 0) {
-    stats.jitter_ms = cs.jitterSamples / (ci.plfreq / 1000);
+  stats.ext_seqnum = call_stats.extendedMax;
+  if (codec_inst.plfreq / 1000 > 0) {
+    stats.jitter_ms = call_stats.jitterSamples / (codec_inst.plfreq / 1000);
   }
   {
     int jitter_buffer_delay_ms = 0;
     int playout_buffer_delay_ms = 0;
     sync->GetDelayEstimate(config_.voe_channel_id, &jitter_buffer_delay_ms,
                            &playout_buffer_delay_ms);
     stats.delay_estimate_ms =
         jitter_buffer_delay_ms + playout_buffer_delay_ms;
   }
   {
@@ skipping 20 matching lines @@
   if (neteq->GetDecodingCallStatistics(config_.voe_channel_id, &ds) != -1) {
     stats.decoding_calls_to_silence_generator =
         ds.calls_to_silence_generator;
     stats.decoding_calls_to_neteq = ds.calls_to_neteq;
     stats.decoding_normal = ds.decoded_normal;
     stats.decoding_plc = ds.decoded_plc;
     stats.decoding_cng = ds.decoded_cng;
     stats.decoding_plc_cng = ds.decoded_plc_cng;
   }
 
-  stats.capture_start_ntp_time_ms = cs.capture_start_ntp_time_ms_;
+  stats.capture_start_ntp_time_ms = call_stats.capture_start_ntp_time_ms_;
 
   return stats;
 }
 
 const webrtc::AudioReceiveStream::Config& AudioReceiveStream::config() const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return config_;
 }
 
 void AudioReceiveStream::Start() {
@@ skipping 37 matching lines @@
     if (packet_time.timestamp >= 0)
       arrival_time_ms = (packet_time.timestamp + 500) / 1000;
     size_t payload_size = length - header.headerLength;
     remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size,
                                               header, false);
   }
   return true;
 }
 }  // namespace internal
 }  // namespace webrtc