Register header extensions for rtx streams in the event log analyzer.

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.
  */
 
 #include "webrtc/tools/event_log_visualizer/analyzer.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <sstream>
 #include <string>
 #include <utility>
 
 #include "webrtc/audio_receive_stream.h"
 #include "webrtc/audio_send_stream.h"
 #include "webrtc/base/checks.h"
+#include "webrtc/base/logging.h"
 #include "webrtc/call.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/video_receive_stream.h"
 #include "webrtc/video_send_stream.h"
@@ skipping 39 matching lines @@
   int64_t min_difference = max_difference - modulus + 1;
   if (difference > max_difference) {
     difference -= modulus;
   }
   if (difference < min_difference) {
     difference += modulus;
   }
   return difference;
 }
 
+void RegisterHeaderExtensions(
+    const std::vector<webrtc::RtpExtension>& extensions,
+    webrtc::RtpHeaderExtensionMap* extension_map) {
+  extension_map->Erase();
+  for (const webrtc::RtpExtension& extension : extensions) {
+    extension_map->Register(webrtc::StringToRtpExtensionType(extension.uri),
+                            extension.id);
+  }
+}
+
 const double kXMargin = 1.02;
 const double kYMargin = 1.1;
 const double kDefaultXMin = -1;
 const double kDefaultYMin = -1;
 
 }  // namespace
 
 namespace webrtc {
 namespace plotting {
 
@@ skipping 38 matching lines @@
       uint64_t timestamp = parsed_log_.GetTimestamp(i);
       first_timestamp = std::min(first_timestamp, timestamp);
       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);
-        extension_maps[stream].Erase();
-        for (size_t j = 0; j < config.rtp.extensions.size(); ++j) {
-          const std::string& extension = config.rtp.extensions[j].uri;
-          int id = config.rtp.extensions[j].id;
-          extension_maps[stream].Register(StringToRtpExtensionType(extension),
-                                          id);
+        RegisterHeaderExtensions(config.rtp.extensions,
+                                 &extension_maps[stream]);
+        for (auto kv : config.rtp.rtx) {
+          StreamId rtx_stream(kv.second.ssrc, kIncomingPacket);
+          RegisterHeaderExtensions(config.rtp.extensions,
+                                   &extension_maps[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);
-          extension_maps[stream].Erase();
-          for (size_t j = 0; j < config.rtp.extensions.size(); ++j) {
-            const std::string& extension = config.rtp.extensions[j].uri;
-            int id = config.rtp.extensions[j].id;
-            extension_maps[stream].Register(StringToRtpExtensionType(extension),
-                                            id);
-          }
+          RegisterHeaderExtensions(config.rtp.extensions,
+                                   &extension_maps[stream]);
+        }
+        for (auto ssrc : config.rtp.rtx.ssrcs) {
+          StreamId stream(ssrc, kOutgoingPacket);
+          RegisterHeaderExtensions(config.rtp.extensions,
+                                   &extension_maps[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 665 matching lines @@
   plot->xaxis_max = (end_time_ - begin_time_) / 1000000 * kXMargin;
   plot->xaxis_label = "Time (s)";
   plot->yaxis_min = min_y - (kYMargin - 1) / 2 * (max_y - min_y);
   plot->yaxis_max = max_y + (kYMargin - 1) / 2 * (max_y - min_y);
   plot->yaxis_label = "Bitrate (kbps)";
   plot->title = "BWE";
 }
 
 }  // namespace plotting
 }  // namespace webrtc