Track SSRCs configured for each media type in event log visualization tool.

webrtc/tools/event_log_visualizer/analyzer.cc

 /*
  *  Copyright (c) 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 82 matching lines @@
   }
 }
 
 constexpr float kLeftMargin = 0.01f;
 constexpr float kRightMargin = 0.02f;
 constexpr float kBottomMargin = 0.02f;
 constexpr float kTopMargin = 0.05f;
 
 }  // namespace
 
-bool EventLogAnalyzer::StreamId::operator<(const StreamId& other) const {
-  if (ssrc_ < other.ssrc_) {
-    return true;
-  }
-  if (ssrc_ == other.ssrc_) {
-    if (direction_ < other.direction_) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool EventLogAnalyzer::StreamId::operator==(const StreamId& other) const {
-  return ssrc_ == other.ssrc_ && direction_ == other.direction_;
-}
-
-
 EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log)
     : parsed_log_(log), window_duration_(250000), step_(10000) {
   uint64_t first_timestamp = std::numeric_limits<uint64_t>::max();
   uint64_t last_timestamp = std::numeric_limits<uint64_t>::min();
 
   // Maps a stream identifier consisting of ssrc and direction
   // to the header extensions used by that stream,
   std::map<StreamId, RtpHeaderExtensionMap> extension_maps;
 
   PacketDirection direction;
@@ skipping 14 matching lines @@
       last_timestamp = std::max(last_timestamp, timestamp);
     }
 
     switch (parsed_log_.GetEventType(i)) {
       case ParsedRtcEventLog::VIDEO_RECEIVER_CONFIG_EVENT: {
         VideoReceiveStream::Config config(nullptr);
         parsed_log_.GetVideoReceiveConfig(i, &config);
         StreamId stream(config.rtp.remote_ssrc, kIncomingPacket);
         RegisterHeaderExtensions(config.rtp.extensions,
                                  &extension_maps[stream]);
+        video_ssrcs_.insert(stream);
         for (auto kv : config.rtp.rtx) {
           StreamId rtx_stream(kv.second.ssrc, kIncomingPacket);
           RegisterHeaderExtensions(config.rtp.extensions,
                                    &extension_maps[rtx_stream]);
+          video_ssrcs_.insert(rtx_stream);
+          rtx_ssrcs_.insert(rtx_stream);
         }
         break;
       }
       case ParsedRtcEventLog::VIDEO_SENDER_CONFIG_EVENT: {
         VideoSendStream::Config config(nullptr);
         parsed_log_.GetVideoSendConfig(i, &config);
         for (auto ssrc : config.rtp.ssrcs) {
           StreamId stream(ssrc, kOutgoingPacket);
           RegisterHeaderExtensions(config.rtp.extensions,
                                    &extension_maps[stream]);
+          video_ssrcs_.insert(stream);
         }
         for (auto ssrc : config.rtp.rtx.ssrcs) {
-          StreamId stream(ssrc, kOutgoingPacket);
+          StreamId rtx_stream(ssrc, kOutgoingPacket);
           RegisterHeaderExtensions(config.rtp.extensions,
-                                   &extension_maps[stream]);
+                                   &extension_maps[rtx_stream]);
+          video_ssrcs_.insert(rtx_stream);
+          rtx_ssrcs_.insert(rtx_stream);
         }
         break;
       }
       case ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT: {
         AudioReceiveStream::Config config;
         // TODO(terelius): Parse the audio configs once we have them.
         break;
       }
       case ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT: {
         AudioSendStream::Config config(nullptr);
@@ skipping 113 matching lines @@
     bool bitrate_updated = bitrate_updated_;
     bitrate_updated_ = false;
     return bitrate_updated;
   }
 
  private:
   uint32_t last_bitrate_bps_;
   bool bitrate_updated_;
 };
 
+bool EventLogAnalyzer::IsRtxSsrc(StreamId stream_id) {
+  return rtx_ssrcs_.count(stream_id) == 1;
+}
+
+bool EventLogAnalyzer::IsVideoSsrc(StreamId stream_id) {
+  return video_ssrcs_.count(stream_id) == 1;
+}
+
+bool EventLogAnalyzer::IsAudioSsrc(StreamId stream_id) {
+  return audio_ssrcs_.count(stream_id) == 1;
+}
+
 void EventLogAnalyzer::CreatePacketGraph(PacketDirection desired_direction,
                                          Plot* plot) {
   std::map<uint32_t, TimeSeries> time_series;
 
   PacketDirection direction;
   MediaType media_type;
   uint8_t header[IP_PACKET_SIZE];
   size_t header_length, total_length;
 
   for (size_t i = 0; i < parsed_log_.GetNumberOfEvents(); i++) {
@@ skipping 477 matching lines @@
   // Add the data set to the plot.
   plot->series_list_.push_back(std::move(time_series));
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 10, "Bitrate (kbps)", kBottomMargin, kTopMargin);
   plot->SetTitle("Simulated BWE behavior");
 }
 
 }  // namespace plotting
 }  // namespace webrtc