RTCMediaStreamTrackStats.ssrcIds collected by RTCStatsCollector.

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.
  */
 
@@ skipping 11 matching lines @@
 #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 {
 
+// If the track is associated with multiple SSRCs, the |uint32_t| is the first
+// one in the group, used as an identifier for that group. The SSRCs are listed
+// in ||Voice/Video][Sender/Receiver]Info::ssrcs()|.
+typedef std::map<MediaStreamTrackInterface*, uint32_t> TracksToSsrcs;

[hbos, 2016/12/28 16:12:29]

There is also std::vector<SsrcGroup> ssrc_groups of Video[Sender/Receiver]Info
(but not Voice[...]), is this something else? Should I refer to multiple SSRCs
as something other than "SSRC groups" in comments like this?

+
 std::string RTCCertificateIDFromFingerprint(const std::string& fingerprint) {
   return "RTCCertificate_" + fingerprint;
 }
 
 std::string RTCCodecStatsIDFromDirectionMediaAndPayload(
     bool inbound, bool audio, uint32_t payload_type) {
   // TODO(hbos): When we are able to handle multiple m= lines of the same media
   // type (and multiple BaseChannels for the same type is possible?) this needs
   // to be updated to differentiate the transport being used, and stats need to
   // be collected for all of them. crbug.com/659117
   if (inbound) {
     return audio ? "RTCCodec_InboundAudio_" + rtc::ToString<>(payload_type)
                  : "RTCCodec_InboundVideo_" + rtc::ToString<>(payload_type);
   }
   return audio ? "RTCCodec_OutboundAudio_" + rtc::ToString<>(payload_type)
                : "RTCCodec_OutboundVideo_" + rtc::ToString<>(payload_type);
 }
 
 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();
+    const MediaStreamTrackInterface& track, bool is_local) {
+  return (is_local ? "RTCMediaStreamTrack_local_" :
+                     "RTCMediaStreamTrack_remote_") + 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,
@@ skipping 204 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();
 }
 
+TracksToSsrcs GetTracksToSsrcs(
+    const std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders) {
+  TracksToSsrcs tracks_to_ssrcs;
+  for (const rtc::scoped_refptr<RtpSenderInterface>& sender : senders) {
+    if (!sender->track())
+      continue;
+    if (sender->ssrc() != 0) {
+      // TODO(hbos): What if multiple |RtpSenderInterface| have the same track
+      // attached yielding multiple SSRCs groups? Only one of them would
+      // currently be used. crbug.com/659137
+      // TODO(hbos): What if |GetParameters().encodings.size() > 1| yields
+      // multiple SSRC groups per sender? crbug.com/659137

[hbos, 2016/12/28 16:12:30]

Looking for input about what to do in either of these cases, whether we address
them here or in follow-up CLs.

+      tracks_to_ssrcs[sender->track().get()] = sender->ssrc();
+    }
+  }
+  return tracks_to_ssrcs;
+}
+// TODO(hbos,deadbeef): With template argument |T| for both |RtpSenderInterface|
+// and |RtpReceiverInterface| this function should be able to cover both sender
+// and receiver cases. But the |RtpSenderInterface| needs to be updated first,
+// when this comment was written it could have an |ssrc()| and still not a value
+// for |GetParameters().encodings[0].ssrc|.

[hbos, 2016/12/28 16:12:30]

(Discovered by debugging rtcstats_integrationtest.cc when sender case also used
GetParameters)

+TracksToSsrcs GetTracksToSsrcs(
+    const std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers) {
+  TracksToSsrcs tracks_to_ssrcs;
+  for (const rtc::scoped_refptr<RtpReceiverInterface>& receiver : receivers) {
+    if (!receiver->track())
+      continue;
+    RTC_DCHECK(
+        tracks_to_ssrcs.find(receiver->track().get()) == tracks_to_ssrcs.end());
+    RtpParameters parameters = receiver->GetParameters();
+    if (parameters.encodings.empty())
+      continue;
+    RTC_DCHECK_EQ(1u, parameters.encodings.size());
+    rtc::Optional<uint32_t> ssrc = parameters.encodings[0].ssrc;
+    if (ssrc)
+      tracks_to_ssrcs[receiver->track().get()] = *ssrc;
+  }
+  return tracks_to_ssrcs;
+}
+
+// |T| can be any |MediaSenderInfo| or |MediaReceiverInfo|.
+template<typename T>
+const T* GetMediaInfoFromSsrc(const std::vector<T>& infos, uint32_t ssrc) {
+  for (const T& info : infos) {
+    if (info.ssrc() == ssrc)
+      return &info;
+  }
+  return nullptr;
+}
+
+std::vector<std::string> StringSsrcsFromSsrcs(
+    const std::vector<uint32_t>& ssrcs) {
+  std::vector<std::string> string_ssrcs;
+  for (uint32_t ssrc : ssrcs) {
+    string_ssrcs.push_back(rtc::ToString<>(ssrc));
+  }
+  return string_ssrcs;
+}
+
 void ProduceMediaStreamAndTrackStats(
     int64_t timestamp_us,
     rtc::scoped_refptr<StreamCollectionInterface> streams,
     bool is_local,
+    const TracksToSsrcs& tracks_to_ssrcs,
+    const rtc::Optional<cricket::VoiceMediaInfo>& voice_info,
+    const rtc::Optional<cricket::VideoMediaInfo>& video_info,
     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(
             (is_local ? "RTCMediaStream_local_" : "RTCMediaStream_remote_") +
             stream->label(), timestamp_us));
     stream_stats->stream_identifier = stream->label();
     stream_stats->track_ids = std::vector<std::string>();
     // Audio Tracks
     for (const 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;
-      }
+        *audio_track.get(), is_local);
       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());
+      TracksToSsrcs::const_iterator it = tracks_to_ssrcs.find(
+          audio_track.get());
+      if (it != tracks_to_ssrcs.end() && voice_info) {
+        uint32_t ssrc = it->second;
+        if (is_local) {

[hbos, 2016/12/29 09:53:55]

So I'm assuming it's either [Voice/Video]SenderInfo or
[Voice/Video]ReceiverInfo. But could a track both receive and send? E.g. we're
retransmitting what we're receiving from some external source. Or would a setup
like that use one local and one remote track to achieve this?

+          const cricket::VoiceSenderInfo* sender_info =
+              GetMediaInfoFromSsrc(voice_info->senders, ssrc);
+          if (sender_info) {
+            audio_track_stats->ssrc_ids = StringSsrcsFromSsrcs(
+                sender_info->ssrcs());
+          }
+        } else {
+          const cricket::VoiceReceiverInfo* receiver_info =
+              GetMediaInfoFromSsrc(voice_info->receivers, ssrc);
+          if (receiver_info) {
+            audio_track_stats->ssrc_ids = StringSsrcsFromSsrcs(
+                receiver_info->ssrcs());
+          }
+        }
+      }
       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);
         if (audio_processor_stats.echo_return_loss != -100) {
           audio_track_stats->echo_return_loss = static_cast<double>(
               audio_processor_stats.echo_return_loss);
         }
         if (audio_processor_stats.echo_return_loss_enhancement != -100) {
           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 (const 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;
-      }
+          *video_track.get(), is_local);
       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());
+      TracksToSsrcs::const_iterator it = tracks_to_ssrcs.find(
+          video_track.get());
+      if (it != tracks_to_ssrcs.end() && video_info) {
+        uint32_t ssrc = it->second;
+        if (is_local) {
+          const cricket::VideoSenderInfo* sender_info =
+              GetMediaInfoFromSsrc(video_info->senders, ssrc);
+          if (sender_info) {
+            video_track_stats->ssrc_ids = StringSsrcsFromSsrcs(
+                sender_info->ssrcs());
+          }
+        } else {
+          const cricket::VideoReceiverInfo* receiver_info =
+              GetMediaInfoFromSsrc(video_info->receivers, ssrc);
+          if (receiver_info) {
+            video_track_stats->ssrc_ids = StringSsrcsFromSsrcs(
+                receiver_info->ssrcs());
+          }
+        }
+      }
       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);
         }
@@ skipping 52 matching lines @@
     // case of already gathering stats, |callback_| will be invoked when there
     // are no more pending partial reports.
 
     // "Now" using a system clock, relative to the UNIX epoch (Jan 1, 1970,
     // UTC), in microseconds. The system clock could be modified and is not
     // necessarily monotonically increasing.
     int64_t timestamp_us = rtc::TimeUTCMicros();
 
     num_pending_partial_reports_ = 3;
     partial_report_timestamp_us_ = cache_now_us;
-    invoker_.AsyncInvoke<void>(RTC_FROM_HERE, signaling_thread_,
-        rtc::Bind(&RTCStatsCollector::ProducePartialResultsOnSignalingThread,
-            rtc::scoped_refptr<RTCStatsCollector>(this), timestamp_us));
 
     // TODO(hbos): No stats are gathered by
     // |ProducePartialResultsOnWorkerThread|, remove it.
     invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_,
         rtc::Bind(&RTCStatsCollector::ProducePartialResultsOnWorkerThread,
             rtc::scoped_refptr<RTCStatsCollector>(this), timestamp_us));
 
-    // Prepare |channel_names_| and |media_info_| for use in
-    // |ProducePartialResultsOnNetworkThread|.
+    // Prepare |channel_names_| and |media_info_|. These are read in
+    // |ProducePartialResultsOnNetworkThread|, and |media_info_| is also used in
+    // |ProducePartialResultsOnSignalingThread|.
     channel_name_pairs_.reset(new ChannelNamePairs());
     if (pc_->session()->voice_channel()) {
       channel_name_pairs_->voice = rtc::Optional<ChannelNamePair>(
           ChannelNamePair(pc_->session()->voice_channel()->content_name(),
                           pc_->session()->voice_channel()->transport_name()));
     }
     if (pc_->session()->video_channel()) {
       channel_name_pairs_->video = rtc::Optional<ChannelNamePair>(
           ChannelNamePair(pc_->session()->video_channel()->content_name(),
                           pc_->session()->video_channel()->transport_name()));
     }
     if (pc_->session()->data_channel()) {
       channel_name_pairs_->data = rtc::Optional<ChannelNamePair>(
           ChannelNamePair(pc_->session()->data_channel()->content_name(),
                           pc_->session()->data_channel()->transport_name()));
     }
     media_info_.reset(PrepareMediaInfo_s().release());
     invoker_.AsyncInvoke<void>(RTC_FROM_HERE, network_thread_,
         rtc::Bind(&RTCStatsCollector::ProducePartialResultsOnNetworkThread,
             rtc::scoped_refptr<RTCStatsCollector>(this), timestamp_us));
+    ProducePartialResultsOnSignalingThread(timestamp_us);
   }
 }
 
 void RTCStatsCollector::ClearCachedStatsReport() {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   cached_report_ = nullptr;
 }
 
 void RTCStatsCollector::WaitForPendingRequest() {
   RTC_DCHECK(signaling_thread_->IsCurrent());
@@ skipping 223 matching lines @@
         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);
+      timestamp_us,
+      pc_->local_streams(),
+      true,
+      GetTracksToSsrcs(pc_->GetSenders()),
+      media_info_->voice,
+      media_info_->video,
+      report);
   ProduceMediaStreamAndTrackStats(
-      timestamp_us, pc_->remote_streams(), false, report);
+      timestamp_us,
+      pc_->remote_streams(),
+      false,
+      GetTracksToSsrcs(pc_->GetReceivers()),
+      media_info_->voice,
+      media_info_->video,
+      report);
 }
 
 void RTCStatsCollector::ProducePeerConnectionStats_s(
     int64_t timestamp_us, RTCStatsReport* report) const {
   RTC_DCHECK(signaling_thread_->IsCurrent());
   std::unique_ptr<RTCPeerConnectionStats> stats(
     new RTCPeerConnectionStats("RTCPeerConnection", timestamp_us));
   stats->data_channels_opened = internal_record_.data_channels_opened;
   stats->data_channels_closed = internal_record_.data_channels_closed;
   report->AddStats(std::move(stats));
@@ skipping 247 matching lines @@
     const std::string& type) {
   return CandidateTypeToRTCIceCandidateType(type);
 }
 
 const char* DataStateToRTCDataChannelStateForTesting(
     DataChannelInterface::DataState state) {
   return DataStateToRTCDataChannelState(state);
 }
 
 }  // namespace webrtc