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

webrtc/tools/event_log_visualizer/analyzer.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_TOOLS_EVENT_LOG_VISUALIZER_ANALYZER_H_
 #define WEBRTC_TOOLS_EVENT_LOG_VISUALIZER_ANALYZER_H_
 
 #include <vector>
 #include <map>
 #include <memory>
+#include <set>
 #include <utility>
 
 #include "webrtc/call/rtc_event_log_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
 #include "webrtc/tools/event_log_visualizer/plot_base.h"
 
 namespace webrtc {
 namespace plotting {
 
+class StreamId {
+ public:
+  StreamId(uint32_t ssrc, webrtc::PacketDirection direction)
+      : ssrc_(ssrc), direction_(direction) {}

[philipel, 2016/08/04 12:56:02]

Move implementation to .cc file.

[terelius, 2016/08/05 12:24:57]

I prefer to keep trivial constructors in the class definition.

[philipel, 2016/08/05 12:43:21]

I was thinking of moving the full implementation to the .cc file. Now the
implementation is both in the .h and .cc file.

Also, any specific reason to keep trivial constructors in the .h file?

[terelius, 2016/08/05 13:00:17]

It makes it easier to verify that all members are initialized properly. The code
also becomes shorter since it avoids boiler-plate code in two places.

I moved the remaining two definitions from the .cc file to the header file.

+  bool operator<(const StreamId& other) const;
+  bool operator==(const StreamId& other) const;
+  uint32_t GetSsrc() const { return ssrc_; }
+  webrtc::PacketDirection GetDirection() const { return direction_; }
+
+ private:
+  uint32_t ssrc_;
+  webrtc::PacketDirection direction_;
+};
+
 class EventLogAnalyzer {
  public:
   // The EventLogAnalyzer keeps a reference to the ParsedRtcEventLog for the
   // duration of its lifetime. The ParsedRtcEventLog must not be destroyed or
   // modified while the EventLogAnalyzer is being used.
   explicit EventLogAnalyzer(const ParsedRtcEventLog& log);
 
+  bool IsRtxSsrc(StreamId stream_id);
+
+  bool IsVideoSsrc(StreamId stream_id);
+
+  bool IsAudioSsrc(StreamId stream_id);
+
   void CreatePacketGraph(PacketDirection desired_direction, Plot* plot);
 
   void CreatePlayoutGraph(Plot* plot);
 
   void CreateSequenceNumberGraph(Plot* plot);
 
   void CreateDelayChangeGraph(Plot* plot);
 
   void CreateAccumulatedDelayChangeGraph(Plot* plot);
 
   void CreateTotalBitrateGraph(PacketDirection desired_direction, Plot* plot);
 
   void CreateStreamBitrateGraph(PacketDirection desired_direction, Plot* plot);
 
   void CreateBweGraph(Plot* plot);
 
  private:
-  class StreamId {
-   public:
-    StreamId(uint32_t ssrc, webrtc::PacketDirection direction)
-        : ssrc_(ssrc), direction_(direction) {}
-    bool operator<(const StreamId& other) const;
-    bool operator==(const StreamId& other) const;
-    uint32_t GetSsrc() const { return ssrc_; }
-    webrtc::PacketDirection GetDirection() const { return direction_; }
-
-   private:
-    uint32_t ssrc_;
-    webrtc::PacketDirection direction_;
-  };
-
   struct LoggedRtpPacket {
     LoggedRtpPacket(uint64_t timestamp, RTPHeader header, size_t total_length)
         : timestamp(timestamp), header(header), total_length(total_length) {}
     uint64_t timestamp;
     RTPHeader header;
     size_t total_length;
   };
 
   struct LoggedRtcpPacket {
     LoggedRtcpPacket(uint64_t timestamp,
@@ skipping 13 matching lines @@
     uint8_t fraction_loss;
     int32_t expected_packets;
   };
 
   const ParsedRtcEventLog& parsed_log_;
 
   // A list of SSRCs we are interested in analysing.
   // If left empty, all SSRCs will be considered relevant.
   std::vector<uint32_t> desired_ssrc_;
 
-  // Maps a stream identifier consisting of ssrc, direction and MediaType
-  // to the parsed RTP headers in that stream. Header extensions are parsed
-  // if the stream has been configured.
+  // Tracks what each stream is configured for. Note that a single SSRC can be
+  // in several sets. For example, the SSRC used for sending video over RTX
+  // will appear in both video_ssrcs_ and rtx_ssrcs_. In the unlikely case that
+  // an SSRC is reconfigured to a different media type mid-call, it will also
+  // appear in multiple sets.
+  std::set<StreamId> rtx_ssrcs_;
+  std::set<StreamId> video_ssrcs_;
+  std::set<StreamId> audio_ssrcs_;
+
+  // Maps a stream identifier consisting of ssrc and direction to the parsed
+  // RTP headers in that stream. Header extensions are parsed if the stream
+  // has been configured.
   std::map<StreamId, std::vector<LoggedRtpPacket>> rtp_packets_;
 
   std::map<StreamId, std::vector<LoggedRtcpPacket>> rtcp_packets_;
 
   // A list of all updates from the send-side loss-based bandwidth estimator.
   std::vector<BwePacketLossEvent> bwe_loss_updates_;
 
   // Window and step size used for calculating moving averages, e.g. bitrate.
   // The generated data points will be |step_| microseconds apart.
   // Only events occuring at most |window_duration_| microseconds before the
   // current data point will be part of the average.
   uint64_t window_duration_;
   uint64_t step_;
 
   // First and last events of the log.
   uint64_t begin_time_;
   uint64_t end_time_;
 
   // Duration (in seconds) of log file.
   float call_duration_s_;
 };
 
 }  // namespace plotting
 }  // namespace webrtc
 
 #endif  // WEBRTC_TOOLS_EVENT_LOG_VISUALIZER_ANALYZER_H_