Make rtc_event_log2text output header extensions

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 281 matching lines @@
   }
 }
 
 }  // namespace
 
 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;
   uint8_t header[IP_PACKET_SIZE];
   size_t header_length;
   size_t total_length;
 
   uint8_t last_incoming_rtcp_packet[IP_PACKET_SIZE];
   uint8_t last_incoming_rtcp_packet_length = 0;
 
   // Make a default extension map for streams without configuration information.
   // TODO(ivoc): Once configuration of audio streams is stored in the event log,
@@ skipping 10 matching lines @@
         event_type != ParsedRtcEventLog::LOG_END) {
       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: {
         rtclog::StreamConfig config = parsed_log_.GetVideoReceiveConfig(i);
         StreamId stream(config.remote_ssrc, kIncomingPacket);
-        extension_maps[stream] = RtpHeaderExtensionMap(config.rtp_extensions);
         video_ssrcs_.insert(stream);
         StreamId rtx_stream(config.rtx_ssrc, kIncomingPacket);
-        extension_maps[rtx_stream] =
-            RtpHeaderExtensionMap(config.rtp_extensions);
         video_ssrcs_.insert(rtx_stream);
         rtx_ssrcs_.insert(rtx_stream);
         break;
       }
       case ParsedRtcEventLog::VIDEO_SENDER_CONFIG_EVENT: {
         std::vector<rtclog::StreamConfig> configs =
             parsed_log_.GetVideoSendConfig(i);
         for (const auto& config : configs) {
           StreamId stream(config.local_ssrc, kOutgoingPacket);
-          extension_maps[stream] =
-              RtpHeaderExtensionMap(config.rtp_extensions);
           video_ssrcs_.insert(stream);
           StreamId rtx_stream(config.rtx_ssrc, kOutgoingPacket);
-          extension_maps[rtx_stream] =
-              RtpHeaderExtensionMap(config.rtp_extensions);
           video_ssrcs_.insert(rtx_stream);
           rtx_ssrcs_.insert(rtx_stream);
         }
         break;
       }
       case ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT: {
         rtclog::StreamConfig config = parsed_log_.GetAudioReceiveConfig(i);
         StreamId stream(config.remote_ssrc, kIncomingPacket);
-        extension_maps[stream] = RtpHeaderExtensionMap(config.rtp_extensions);
         audio_ssrcs_.insert(stream);
         break;
       }
       case ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT: {
         rtclog::StreamConfig config = parsed_log_.GetAudioSendConfig(i);
         StreamId stream(config.local_ssrc, kOutgoingPacket);
-        extension_maps[stream] = RtpHeaderExtensionMap(config.rtp_extensions);
         audio_ssrcs_.insert(stream);
         break;
       }
       case ParsedRtcEventLog::RTP_EVENT: {
-        parsed_log_.GetRtpHeader(i, &direction, header, &header_length,
-                                 &total_length);
-        // Parse header to get SSRC.
+        RtpHeaderExtensionMap* extension_map = parsed_log_.GetRtpHeader(
+            i, &direction, header, &header_length, &total_length);
         RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
         RTPHeader parsed_header;
-        rtp_parser.Parse(&parsed_header);
-        StreamId stream(parsed_header.ssrc, direction);
-        // Look up the extension_map and parse it again to get the extensions.
-        if (extension_maps.count(stream) == 1) {
-          RtpHeaderExtensionMap* extension_map = &extension_maps[stream];
+        if (extension_map != nullptr) {
           rtp_parser.Parse(&parsed_header, extension_map);
         } else {
           // Use the default extension map.
           // TODO(ivoc): Once configuration of audio streams is stored in the
           //             event log, this can be removed.
           //             Tracking bug: webrtc:6399
           rtp_parser.Parse(&parsed_header, &default_extension_map);
         }
         uint64_t timestamp = parsed_log_.GetTimestamp(i);
+        StreamId stream(parsed_header.ssrc, direction);
         rtp_packets_[stream].push_back(
             LoggedRtpPacket(timestamp, parsed_header, total_length));
         break;
       }
       case ParsedRtcEventLog::RTCP_EVENT: {
         uint8_t packet[IP_PACKET_SIZE];
         parsed_log_.GetRtcpPacket(i, &direction, packet, &total_length);
         // Currently incoming RTCP packets are logged twice, both for audio and
         // video. Only act on one of them. Compare against the previous parsed
         // incoming RTCP packet.
@@ skipping 986 matching lines @@
       },
       audio_network_adaptation_events_, begin_time_, &time_series);
   plot->AppendTimeSeries(std::move(time_series));
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Number of channels (1 (mono)/2 (stereo))",
                           kBottomMargin, kTopMargin);
   plot->SetTitle("Reported audio encoder number of channels");
 }
 }  // namespace plotting
 }  // namespace webrtc