RTCMediaStream[Track]Stats added.

webrtc/api/rtcstatscollector.cc

 /*
  *  Copyright 2016 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 "webrtc/api/rtcstatscollector.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "webrtc/api/peerconnection.h"
+#include "webrtc/api/peerconnectioninterface.h"
+#include "webrtc/api/mediastreaminterface.h"
 #include "webrtc/api/webrtcsession.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/p2p/base/candidate.h"
 #include "webrtc/p2p/base/p2pconstants.h"
 #include "webrtc/p2p/base/port.h"
 
 namespace webrtc {
 
 namespace {
 
 std::string RTCCertificateIDFromFingerprint(const std::string& fingerprint) {
   return "RTCCertificate_" + fingerprint;
 }
 
 std::string RTCIceCandidatePairStatsIDFromConnectionInfo(
     const cricket::ConnectionInfo& info) {
   return "RTCIceCandidatePair_" + info.local_candidate.id() + "_" +
       info.remote_candidate.id();
 }
 
+std::string RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface(
+    const MediaStreamTrackInterface& track) {
+  return "RTCMediaStreamTrack_" + track.id();
+}
+
 std::string RTCTransportStatsIDFromTransportChannel(
     const std::string& transport_name, int channel_component) {
   return "RTCTransport_" + transport_name + "_" +
       rtc::ToString<>(channel_component);
 }
 
 std::string RTCTransportStatsIDFromBaseChannel(
     const ProxyTransportMap& proxy_to_transport,
     const cricket::BaseChannel& base_channel) {
   auto proxy_it = proxy_to_transport.find(base_channel.content_name());
@@ skipping 36 matching lines @@
     case DataChannelInterface::kClosing:
       return RTCDataChannelState::kClosing;
     case DataChannelInterface::kClosed:
       return RTCDataChannelState::kClosed;
     default:
       RTC_NOTREACHED();
       return nullptr;
   }
 }
 
+void SetMediaStreamTrackStatsFromMediaStreamTrackInterface(
+    const MediaStreamTrackInterface& track,
+    RTCMediaStreamTrackStats* track_stats) {
+  track_stats->track_identifier = track.id();
+  track_stats->ended = (track.state() == MediaStreamTrackInterface::kEnded);
+}
+
 void SetInboundRTPStreamStatsFromMediaReceiverInfo(
     const cricket::MediaReceiverInfo& media_receiver_info,
     RTCInboundRTPStreamStats* inbound_stats) {
   RTC_DCHECK(inbound_stats);
   inbound_stats->ssrc = rtc::ToString<>(media_receiver_info.ssrc());
   // TODO(hbos): Support the remote case. crbug.com/657855
   inbound_stats->is_remote = false;
   // TODO(hbos): Set |codec_id| when we have |RTCCodecStats|. Maybe relevant:
   // |media_receiver_info.codec_name|. crbug.com/657854, 657855, 659117
   inbound_stats->packets_received =
@@ skipping 101 matching lines @@
     candidate_stats->priority = static_cast<int32_t>(candidate.priority());
 
     stats = candidate_stats.get();
     report->AddStats(std::move(candidate_stats));
   }
   RTC_DCHECK_EQ(stats->type(), is_local ? RTCLocalIceCandidateStats::kType
                                         : RTCRemoteIceCandidateStats::kType);
   return stats->id();
 }
 
+void ProduceMediaStreamAndTrackStats(
+    int64_t timestamp_us,
+    rtc::scoped_refptr<StreamCollectionInterface> streams,
+    bool is_local,
+    RTCStatsReport* report) {
+  // TODO(hbos): When "AddTrack" is implemented we should iterate tracks to
+  // find which streams exist, not iterate streams to find tracks.
+  // crbug.com/659137
+  // TODO(hbos): Return stats of detached tracks. We have to perform stats
+  // gathering at the time of detachment to get accurate stats and timestamps.
+  // crbug.com/659137
+  if (!streams)
+    return;
+  for (size_t i = 0; i < streams->count(); ++i) {
+    MediaStreamInterface* stream = streams->at(i);
+
+    std::unique_ptr<RTCMediaStreamStats> stream_stats(
+        new RTCMediaStreamStats("RTCMediaStream_" + stream->label(),
+                                timestamp_us));
+    stream_stats->stream_identifier = stream->label();
+    stream_stats->track_ids = std::vector<std::string>();
+    // Audio Tracks
+    for (rtc::scoped_refptr<AudioTrackInterface> audio_track :
+         stream->GetAudioTracks()) {
+      std::string id = RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface(
+        *audio_track.get());
+      if (report->Get(id)) {
+        // Skip track, stats already exist for it.
+        continue;
+      }
+      std::unique_ptr<RTCMediaStreamTrackStats> audio_track_stats(
+          new RTCMediaStreamTrackStats(id, timestamp_us));
+      stream_stats->track_ids->push_back(audio_track_stats->id());
+      SetMediaStreamTrackStatsFromMediaStreamTrackInterface(
+          *audio_track.get(),
+          audio_track_stats.get());
+      audio_track_stats->remote_source = !is_local;
+      audio_track_stats->detached = false;
+      int signal_level;
+      if (audio_track->GetSignalLevel(&signal_level)) {
+        // Convert signal level from [0,32767] int to [0,1] double.
+        RTC_DCHECK_GE(signal_level, 0);
+        RTC_DCHECK_LE(signal_level, 32767);
+        audio_track_stats->audio_level = signal_level / 32767.0;
+      }
+      if (audio_track->GetAudioProcessor()) {
+        AudioProcessorInterface::AudioProcessorStats audio_processor_stats;
+        audio_track->GetAudioProcessor()->GetStats(&audio_processor_stats);
+        audio_track_stats->echo_return_loss = static_cast<double>(
+            audio_processor_stats.echo_return_loss);
+        audio_track_stats->echo_return_loss_enhancement = static_cast<double>(
+            audio_processor_stats.echo_return_loss_enhancement);
+      }
+      report->AddStats(std::move(audio_track_stats));
+    }
+    // Video Tracks
+    for (rtc::scoped_refptr<VideoTrackInterface> video_track :
+         stream->GetVideoTracks()) {
+      std::string id = RTCMediaStreamTrackStatsIDFromMediaStreamTrackInterface(
+          *video_track.get());
+      if (report->Get(id)) {
+        // Skip track, stats already exist for it.
+        continue;
+      }
+      std::unique_ptr<RTCMediaStreamTrackStats> video_track_stats(
+          new RTCMediaStreamTrackStats(id, timestamp_us));
+      stream_stats->track_ids->push_back(video_track_stats->id());
+      SetMediaStreamTrackStatsFromMediaStreamTrackInterface(
+          *video_track.get(),
+          video_track_stats.get());
+      video_track_stats->remote_source = !is_local;
+      video_track_stats->detached = false;
+      if (video_track->GetSource()) {
+        VideoTrackSourceInterface::Stats video_track_source_stats;
+        if (video_track->GetSource()->GetStats(&video_track_source_stats)) {
+          video_track_stats->frame_width = static_cast<uint32_t>(
+              video_track_source_stats.input_width);
+          video_track_stats->frame_height = static_cast<uint32_t>(
+              video_track_source_stats.input_height);
+        }
+      }
+      report->AddStats(std::move(video_track_stats));
+    }
+    report->AddStats(std::move(stream_stats));
+  }
+}
+
 }  // namespace
 
 rtc::scoped_refptr<RTCStatsCollector> RTCStatsCollector::Create(
     PeerConnection* pc, int64_t cache_lifetime_us) {
   return rtc::scoped_refptr<RTCStatsCollector>(
       new rtc::RefCountedObject<RTCStatsCollector>(pc, cache_lifetime_us));
 }
 
 RTCStatsCollector::RTCStatsCollector(PeerConnection* pc,
                                      int64_t cache_lifetime_us)
@@ skipping 67 matching lines @@
     ProduceCertificateStats_s(
         timestamp_us, transport_cert_stats, report.get());
     ProduceIceCandidateAndPairStats_s(
         timestamp_us, session_stats, report.get());
     ProduceRTPStreamStats_s(
         timestamp_us, session_stats, report.get());
     ProduceTransportStats_s(
         timestamp_us, session_stats, transport_cert_stats, report.get());
   }
   ProduceDataChannelStats_s(timestamp_us, report.get());
+  ProduceMediaStreamAndTrackStats_s(timestamp_us, report.get());
   ProducePeerConnectionStats_s(timestamp_us, report.get());
 
   AddPartialResults(report);
 }
 
 void RTCStatsCollector::ProducePartialResultsOnWorkerThread(
     int64_t timestamp_us) {
   RTC_DCHECK(worker_thread_->IsCurrent());
   rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create(
       timestamp_us);
@@ skipping 146 matching lines @@
             static_cast<uint64_t>(info.recv_ping_responses);
         candidate_pair_stats->responses_sent =
             static_cast<uint64_t>(info.sent_ping_responses);
 
         report->AddStats(std::move(candidate_pair_stats));
       }
     }
   }
 }
 
+void RTCStatsCollector::ProduceMediaStreamAndTrackStats_s(
+    int64_t timestamp_us, RTCStatsReport* report) const {
+  RTC_DCHECK(signaling_thread_->IsCurrent());
+  ProduceMediaStreamAndTrackStats(
+      timestamp_us, pc_->local_streams(), true, report);
+  ProduceMediaStreamAndTrackStats(
+      timestamp_us, pc_->remote_streams(), false, report);
+}
+
 void RTCStatsCollector::ProducePeerConnectionStats_s(
     int64_t timestamp_us, RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   // TODO(hbos): If data channels are removed from the peer connection this will
   // yield incorrect counts. Address before closing crbug.com/636818. See
   // https://w3c.github.io/webrtc-stats/webrtc-stats.html#pcstats-dict*.
   uint32_t data_channels_opened = 0;
   const std::vector<rtc::scoped_refptr<DataChannel>>& data_channels =
       pc_->sctp_data_channels();
   for (const rtc::scoped_refptr<DataChannel>& data_channel : data_channels) {
@@ skipping 199 matching lines @@
     const std::string& type) {
   return CandidateTypeToRTCIceCandidateType(type);
 }
 
 const char* DataStateToRTCDataChannelStateForTesting(
     DataChannelInterface::DataState state) {
   return DataStateToRTCDataChannelState(state);
 }
 
 }  // namespace webrtc