RTCMediaStreamTrackStats collected on a per-attachment basis.

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 <sstream>
 #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"
@@ skipping 22 matching lines @@
   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 RTCMediaStreamTrackStatsIDFromTrackID(
-    const std::string& id, bool is_local) {
-  return (is_local ? "RTCMediaStreamTrack_local_" + id
-                   : "RTCMediaStreamTrack_remote_" + id);
+std::string RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
+    bool is_local, const char* kind, const std::string& id, uint32_t ssrc) {
+  RTC_DCHECK(kind == MediaStreamTrackInterface::kAudioKind ||
+             kind == MediaStreamTrackInterface::kVideoKind);
+  std::ostringstream oss;
+  oss << (is_local ? "RTCMediaStreamTrack_local_"
+                   : "RTCMediaStreamTrack_remote_");
+  oss << kind << "_";
+  oss << id << "_";
+  oss << ssrc;
+  return oss.str();
 }
 
 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 74 matching lines @@
     case cricket::DTLS_TRANSPORT_CLOSED:
       return RTCDtlsTransportState::kClosed;
     case cricket::DTLS_TRANSPORT_FAILED:
       return RTCDtlsTransportState::kFailed;
     default:
       RTC_NOTREACHED();
       return nullptr;
   }
 }
 
+double DoubleAudioLevelFromIntAudioLevel(int audio_level) {
+  RTC_DCHECK_GE(audio_level, 0);
+  RTC_DCHECK_LE(audio_level, 32767);
+  return audio_level / 32767.0;
+}
+
 std::unique_ptr<RTCCodecStats> CodecStatsFromRtpCodecParameters(
     uint64_t timestamp_us, bool inbound, bool audio,
     const RtpCodecParameters& codec_params) {
   RTC_DCHECK_GE(codec_params.payload_type, 0);
   RTC_DCHECK_LE(codec_params.payload_type, 127);
   uint32_t payload_type = static_cast<uint32_t>(codec_params.payload_type);
   std::unique_ptr<RTCCodecStats> codec_stats(new RTCCodecStats(
       RTCCodecStatsIDFromDirectionMediaAndPayload(inbound, audio, payload_type),
       timestamp_us));
   codec_stats->payload_type = payload_type;
@@ skipping 151 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();
 }
 
+std::unique_ptr<RTCMediaStreamTrackStats>
+ProduceMediaStreamTrackStatsFromVoiceSenderInfo(
+    int64_t timestamp_us,
+    const AudioTrackInterface& audio_track,
+    const cricket::VoiceSenderInfo& voice_sender_info) {
+  std::unique_ptr<RTCMediaStreamTrackStats> audio_track_stats(
+      new RTCMediaStreamTrackStats(
+          RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
+              true, MediaStreamTrackInterface::kAudioKind, audio_track.id(),
+              voice_sender_info.ssrc()),
+          timestamp_us,
+          RTCMediaStreamTrackKind::kAudio));
+  SetMediaStreamTrackStatsFromMediaStreamTrackInterface(
+      audio_track, audio_track_stats.get());
+  audio_track_stats->remote_source = false;
+  audio_track_stats->detached = false;
+  if (voice_sender_info.audio_level >= 0) {
+    audio_track_stats->audio_level = DoubleAudioLevelFromIntAudioLevel(
+        voice_sender_info.audio_level);
+  }
+  if (voice_sender_info.echo_return_loss != -100) {
+    audio_track_stats->echo_return_loss = static_cast<double>(
+        voice_sender_info.echo_return_loss);
+  }
+  if (voice_sender_info.echo_return_loss_enhancement != -100) {
+    audio_track_stats->echo_return_loss_enhancement = static_cast<double>(
+        voice_sender_info.echo_return_loss_enhancement);
+  }
+  return audio_track_stats;
+}
+
+std::unique_ptr<RTCMediaStreamTrackStats>
+ProduceMediaStreamTrackStatsFromVoiceReceiverInfo(
+    int64_t timestamp_us,
+    const AudioTrackInterface& audio_track,
+    const cricket::VoiceReceiverInfo& voice_receiver_info) {
+  std::unique_ptr<RTCMediaStreamTrackStats> audio_track_stats(
+      new RTCMediaStreamTrackStats(
+          RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
+              false, MediaStreamTrackInterface::kAudioKind, audio_track.id(),
+              voice_receiver_info.ssrc()),
+          timestamp_us,
+          RTCMediaStreamTrackKind::kAudio));
+  SetMediaStreamTrackStatsFromMediaStreamTrackInterface(
+      audio_track, audio_track_stats.get());
+  audio_track_stats->remote_source = true;
+  audio_track_stats->detached = false;
+  if (voice_receiver_info.audio_level >= 0) {
+    audio_track_stats->audio_level = DoubleAudioLevelFromIntAudioLevel(
+        voice_receiver_info.audio_level);
+  }
+  return audio_track_stats;
+}
+
+std::unique_ptr<RTCMediaStreamTrackStats>
+ProduceMediaStreamTrackStatsFromVideoSenderInfo(
+    int64_t timestamp_us,
+    const VideoTrackInterface& video_track,
+    const cricket::VideoSenderInfo& video_sender_info) {
+  std::unique_ptr<RTCMediaStreamTrackStats> video_track_stats(
+      new RTCMediaStreamTrackStats(
+          RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
+              true, MediaStreamTrackInterface::kVideoKind, video_track.id(),
+              video_sender_info.ssrc()),
+          timestamp_us,
+          RTCMediaStreamTrackKind::kVideo));
+  SetMediaStreamTrackStatsFromMediaStreamTrackInterface(
+      video_track, video_track_stats.get());
+  video_track_stats->remote_source = false;
+  video_track_stats->detached = false;
+  video_track_stats->frame_width = static_cast<uint32_t>(
+      video_sender_info.send_frame_width);
+  video_track_stats->frame_height = static_cast<uint32_t>(
+      video_sender_info.send_frame_height);
+  return video_track_stats;
+}
+
+std::unique_ptr<RTCMediaStreamTrackStats>
+ProduceMediaStreamTrackStatsFromVideoReceiverInfo(
+    int64_t timestamp_us,
+    const VideoTrackInterface& video_track,
+    const cricket::VideoReceiverInfo& video_receiver_info) {
+  std::unique_ptr<RTCMediaStreamTrackStats> video_track_stats(
+      new RTCMediaStreamTrackStats(
+          RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
+              false, MediaStreamTrackInterface::kVideoKind, video_track.id(),
+              video_receiver_info.ssrc()),
+          timestamp_us,
+          RTCMediaStreamTrackKind::kVideo));
+  SetMediaStreamTrackStatsFromMediaStreamTrackInterface(
+      video_track, video_track_stats.get());
+  video_track_stats->remote_source = true;
+  video_track_stats->detached = false;
+  if (video_receiver_info.frame_width > 0 &&
+      video_receiver_info.frame_height > 0) {
+    video_track_stats->frame_width = static_cast<uint32_t>(
+        video_receiver_info.frame_width);
+    video_track_stats->frame_height = static_cast<uint32_t>(
+        video_receiver_info.frame_height);
+  }
+  return video_track_stats;
+}
+
 void ProduceMediaStreamAndTrackStats(
     int64_t timestamp_us,
+    const TrackMediaInfoMap& track_media_info_map,
     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(
             (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 = RTCMediaStreamTrackStatsIDFromTrackID(
-          audio_track->id(), is_local);
-      if (report->Get(id)) {
-        // Skip track, stats already exist for it.
-        continue;
-      }
-      std::unique_ptr<RTCMediaStreamTrackStats> audio_track_stats(
-          new RTCMediaStreamTrackStats(id, timestamp_us,
-                                       RTCMediaStreamTrackKind::kAudio));
-      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);
-        if (audio_processor_stats.echo_return_loss != -100) {
-          audio_track_stats->echo_return_loss = static_cast<double>(
-              audio_processor_stats.echo_return_loss);
+    // The track stats are per-attachment to the connection. There can be one
+    // for receiving (remote) tracks and multiple attachments for sending
+    // (local) tracks.
+    if (is_local) {
+      // Local Audio Tracks
+      for (const rtc::scoped_refptr<AudioTrackInterface>& audio_track :
+           stream->GetAudioTracks()) {
+        const std::vector<cricket::VoiceSenderInfo*>* voice_sender_infos =
+            track_media_info_map.GetVoiceSenderInfos(*audio_track);
+        if (!voice_sender_infos) {
+          continue;
         }
-        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);
+        for (const auto& voice_sender_info : *voice_sender_infos) {
+          std::unique_ptr<RTCMediaStreamTrackStats> audio_track_stats =
+              ProduceMediaStreamTrackStatsFromVoiceSenderInfo(
+                  timestamp_us, *audio_track, *voice_sender_info);
+          stream_stats->track_ids->push_back(audio_track_stats->id());
+          report->AddStats(std::move(audio_track_stats));
         }
       }
-      report->AddStats(std::move(audio_track_stats));
-    }
-    // Video Tracks
-    for (const rtc::scoped_refptr<VideoTrackInterface>& video_track :
-         stream->GetVideoTracks()) {
-      std::string id = RTCMediaStreamTrackStatsIDFromTrackID(
-          video_track->id(), is_local);
-      if (report->Get(id)) {
-        // Skip track, stats already exist for it.
-        continue;
-      }
-      std::unique_ptr<RTCMediaStreamTrackStats> video_track_stats(
-          new RTCMediaStreamTrackStats(id, timestamp_us,
-                                       RTCMediaStreamTrackKind::kVideo));
-      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);
+      // Local Video Tracks
+      for (const rtc::scoped_refptr<VideoTrackInterface>& video_track :
+           stream->GetVideoTracks()) {
+        const std::vector<cricket::VideoSenderInfo*>* video_sender_infos =
+            track_media_info_map.GetVideoSenderInfos(*video_track);
+        if (!video_sender_infos) {
+          continue;
+        }
+        for (const auto& video_sender_info : *video_sender_infos) {
+          std::unique_ptr<RTCMediaStreamTrackStats> video_track_stats =
+              ProduceMediaStreamTrackStatsFromVideoSenderInfo(
+                  timestamp_us, *video_track, *video_sender_info);
+          stream_stats->track_ids->push_back(video_track_stats->id());
+          report->AddStats(std::move(video_track_stats));
         }
       }
-      report->AddStats(std::move(video_track_stats));
+    } else {
+      // Remote Audio Tracks
+      for (const rtc::scoped_refptr<AudioTrackInterface>& audio_track :
+           stream->GetAudioTracks()) {
+        const cricket::VoiceReceiverInfo* voice_receiver_info =
+            track_media_info_map.GetVoiceReceiverInfo(*audio_track);
+        if (!voice_receiver_info) {
+          continue;
+        }
+        std::unique_ptr<RTCMediaStreamTrackStats> audio_track_stats =
+            ProduceMediaStreamTrackStatsFromVoiceReceiverInfo(
+                timestamp_us, *audio_track, *voice_receiver_info);
+        stream_stats->track_ids->push_back(audio_track_stats->id());
+        report->AddStats(std::move(audio_track_stats));
+      }
+      // Remote Video Tracks
+      for (const rtc::scoped_refptr<VideoTrackInterface>& video_track :
+           stream->GetVideoTracks()) {
+        const cricket::VideoReceiverInfo* video_receiver_info =
+            track_media_info_map.GetVideoReceiverInfo(*video_track);
+        if (!video_receiver_info) {
+          continue;
+        }
+        std::unique_ptr<RTCMediaStreamTrackStats> video_track_stats =
+            ProduceMediaStreamTrackStatsFromVideoReceiverInfo(
+                timestamp_us, *video_track, *video_receiver_info);
+        stream_stats->track_ids->push_back(video_track_stats->id());
+        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>(
@@ skipping 318 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);
-  ProduceMediaStreamAndTrackStats(
-      timestamp_us, pc_->remote_streams(), false, report);
+  RTC_DCHECK(track_media_info_map_);
+  ProduceMediaStreamAndTrackStats(timestamp_us,
+                                  *track_media_info_map_,
+                                  pc_->local_streams(),
+                                  true,
+                                  report);
+  ProduceMediaStreamAndTrackStats(timestamp_us,
+                                  *track_media_info_map_,
+                                  pc_->remote_streams(),
+                                  false,
+                                  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 22 matching lines @@
               RTCInboundRTPStreamStatsIDFromSSRC(
                   true, voice_receiver_info.ssrc()),
               timestamp_us));
       SetInboundRTPStreamStatsFromVoiceReceiverInfo(
           voice_receiver_info, inbound_audio.get());
       rtc::scoped_refptr<AudioTrackInterface> audio_track =
           track_media_info_map_->GetAudioTrack(voice_receiver_info);
       if (audio_track) {
         RTC_DCHECK(track_to_id_.find(audio_track.get()) != track_to_id_.end());
         inbound_audio->media_track_id =
-            RTCMediaStreamTrackStatsIDFromTrackID(
-                track_to_id_.find(audio_track.get())->second, false);
+            RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
+                false,
+                MediaStreamTrackInterface::kAudioKind,
+                track_to_id_.find(audio_track.get())->second,
+                voice_receiver_info.ssrc());
       }
       inbound_audio->transport_id = transport_id;
       if (voice_receiver_info.codec_payload_type) {
         inbound_audio->codec_id =
             RTCCodecStatsIDFromDirectionMediaAndPayload(
                 true, true, *voice_receiver_info.codec_payload_type);
       }
       report->AddStats(std::move(inbound_audio));
     }
     // Outbound
     for (const cricket::VoiceSenderInfo& voice_sender_info :
          track_media_info_map.voice_media_info()->senders) {
       // TODO(nisse): SSRC == 0 currently means none. Delete check when that
       // is fixed.
       if (voice_sender_info.ssrc() == 0)
         continue;
       std::unique_ptr<RTCOutboundRTPStreamStats> outbound_audio(
           new RTCOutboundRTPStreamStats(
               RTCOutboundRTPStreamStatsIDFromSSRC(
                   true, voice_sender_info.ssrc()),
               timestamp_us));
       SetOutboundRTPStreamStatsFromVoiceSenderInfo(
           voice_sender_info, outbound_audio.get());
       rtc::scoped_refptr<AudioTrackInterface> audio_track =
           track_media_info_map_->GetAudioTrack(voice_sender_info);
       if (audio_track) {
         RTC_DCHECK(track_to_id_.find(audio_track.get()) != track_to_id_.end());
         outbound_audio->media_track_id =
-            RTCMediaStreamTrackStatsIDFromTrackID(
-                track_to_id_.find(audio_track.get())->second, true);
+            RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
+                true,
+                MediaStreamTrackInterface::kAudioKind,
+                track_to_id_.find(audio_track.get())->second,
+                voice_sender_info.ssrc());
       }
       outbound_audio->transport_id = transport_id;
       if (voice_sender_info.codec_payload_type) {
         outbound_audio->codec_id =
             RTCCodecStatsIDFromDirectionMediaAndPayload(
                 false, true, *voice_sender_info.codec_payload_type);
       }
       report->AddStats(std::move(outbound_audio));
     }
   }
@@ skipping 14 matching lines @@
               RTCInboundRTPStreamStatsIDFromSSRC(
                   false, video_receiver_info.ssrc()),
               timestamp_us));
       SetInboundRTPStreamStatsFromVideoReceiverInfo(
           video_receiver_info, inbound_video.get());
       rtc::scoped_refptr<VideoTrackInterface> video_track =
           track_media_info_map_->GetVideoTrack(video_receiver_info);
       if (video_track) {
         RTC_DCHECK(track_to_id_.find(video_track.get()) != track_to_id_.end());
         inbound_video->media_track_id =
-            RTCMediaStreamTrackStatsIDFromTrackID(
-                track_to_id_.find(video_track.get())->second, false);
+            RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
+                false,
+                MediaStreamTrackInterface::kVideoKind,
+                track_to_id_.find(video_track.get())->second,
+                video_receiver_info.ssrc());
       }
       inbound_video->transport_id = transport_id;
       if (video_receiver_info.codec_payload_type) {
         inbound_video->codec_id =
             RTCCodecStatsIDFromDirectionMediaAndPayload(
                 true, false, *video_receiver_info.codec_payload_type);
       }
       report->AddStats(std::move(inbound_video));
     }
     // Outbound
     for (const cricket::VideoSenderInfo& video_sender_info :
          track_media_info_map.video_media_info()->senders) {
       // TODO(nisse): SSRC == 0 currently means none. Delete check when that
       // is fixed.
       if (video_sender_info.ssrc() == 0)
         continue;
       std::unique_ptr<RTCOutboundRTPStreamStats> outbound_video(
           new RTCOutboundRTPStreamStats(
               RTCOutboundRTPStreamStatsIDFromSSRC(
                   false, video_sender_info.ssrc()),
               timestamp_us));
       SetOutboundRTPStreamStatsFromVideoSenderInfo(
           video_sender_info, outbound_video.get());
       rtc::scoped_refptr<VideoTrackInterface> video_track =
           track_media_info_map_->GetVideoTrack(video_sender_info);
       if (video_track) {
         RTC_DCHECK(track_to_id_.find(video_track.get()) != track_to_id_.end());
         outbound_video->media_track_id =
-            RTCMediaStreamTrackStatsIDFromTrackID(
-                track_to_id_.find(video_track.get())->second, true);
+            RTCMediaStreamTrackStatsIDFromTrackKindIDAndSsrc(
+                true,
+                MediaStreamTrackInterface::kVideoKind,
+                track_to_id_.find(video_track.get())->second,
+                video_sender_info.ssrc());
       }
       outbound_video->transport_id = transport_id;
       if (video_sender_info.codec_payload_type) {
         outbound_video->codec_id =
             RTCCodecStatsIDFromDirectionMediaAndPayload(
                 false, false, *video_sender_info.codec_payload_type);
       }
       report->AddStats(std::move(outbound_video));
     }
   }
@@ skipping 168 matching lines @@
     const std::string& type) {
   return CandidateTypeToRTCIceCandidateType(type);
 }
 
 const char* DataStateToRTCDataChannelStateForTesting(
     DataChannelInterface::DataState state) {
   return DataStateToRTCDataChannelState(state);
 }
 
 }  // namespace webrtc