Make rtc_event_log2text output header extensions

webrtc/logging/rtc_event_log/rtc_event_log_parser.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 140 matching lines @@
   uint64_t tag;
   uint64_t message_length;
   bool success;
 
   RTC_DCHECK(stream.good());
 
   while (1) {
     // Check whether we have reached end of file.
     stream.peek();
     if (stream.eof()) {
+      // Process all extensions maps for faster look-up later.
+      for (auto& event_stream : streams_) {
+        rtp_extensions_maps_[StreamId(event_stream.ssrc,
+                                      event_stream.direction)] =
+            &event_stream.rtp_extensions_map;
+      }
       return true;
     }
 
     // Read the next message tag. The tag number is defined as
     // (fieldnumber << 3) | wire_type. In our case, the field number is
     // supposed to be 1 and the wire type for an
     // length-delimited field is 2.
     const uint64_t kExpectedTag = (1 << 3) | 2;
     std::tie(tag, success) = ParseVarInt(stream);
     if (!success) {
@@ skipping 26 matching lines @@
     if (!event.ParseFromArray(tmp_buffer.data(), message_length)) {
       LOG(LS_WARNING) << "Failed to parse protobuf message.";
       return false;
     }
 
     EventType type = GetRuntimeEventType(event.type());
     switch (type) {
       case VIDEO_RECEIVER_CONFIG_EVENT: {
         rtclog::StreamConfig config = GetVideoReceiveConfig(event);
         streams_.emplace_back(config.remote_ssrc, MediaType::VIDEO,
-                              kIncomingPacket);
+                              kIncomingPacket,
+                              RtpHeaderExtensionMap(config.rtp_extensions));
         streams_.emplace_back(config.local_ssrc, MediaType::VIDEO,
-                              kOutgoingPacket);
+                              kOutgoingPacket,
+                              RtpHeaderExtensionMap(config.rtp_extensions));
         break;
       }
       case VIDEO_SENDER_CONFIG_EVENT: {
         std::vector<rtclog::StreamConfig> configs = GetVideoSendConfig(event);
         for (size_t i = 0; i < configs.size(); i++) {
-          streams_.emplace_back(configs[i].local_ssrc, MediaType::VIDEO,
-                                kOutgoingPacket);
+          streams_.emplace_back(
+              configs[i].local_ssrc, MediaType::VIDEO, kOutgoingPacket,
+              RtpHeaderExtensionMap(configs[i].rtp_extensions));
 
-          streams_.emplace_back(configs[i].rtx_ssrc, MediaType::VIDEO,
-                                kOutgoingPacket);
+          streams_.emplace_back(
+              configs[i].rtx_ssrc, MediaType::VIDEO, kOutgoingPacket,
+              RtpHeaderExtensionMap(configs[i].rtp_extensions));
         }
         break;
       }
       case AUDIO_RECEIVER_CONFIG_EVENT: {
         rtclog::StreamConfig config = GetAudioReceiveConfig(event);
         streams_.emplace_back(config.remote_ssrc, MediaType::AUDIO,
-                              kIncomingPacket);
+                              kIncomingPacket,
+                              RtpHeaderExtensionMap(config.rtp_extensions));
         streams_.emplace_back(config.local_ssrc, MediaType::AUDIO,
-                              kOutgoingPacket);
+                              kOutgoingPacket,
+                              RtpHeaderExtensionMap(config.rtp_extensions));
         break;
       }
       case AUDIO_SENDER_CONFIG_EVENT: {
         rtclog::StreamConfig config = GetAudioSendConfig(event);
         streams_.emplace_back(config.local_ssrc, MediaType::AUDIO,
-                              kOutgoingPacket);
+                              kOutgoingPacket,
+                              RtpHeaderExtensionMap(config.rtp_extensions));
         break;
       }
       default:
         break;
     }
 
     events_.push_back(event);
   }
 }
 
@@ skipping 10 matching lines @@
 
 ParsedRtcEventLog::EventType ParsedRtcEventLog::GetEventType(
     size_t index) const {
   RTC_CHECK_LT(index, GetNumberOfEvents());
   const rtclog::Event& event = events_[index];
   RTC_CHECK(event.has_type());
   return GetRuntimeEventType(event.type());
 }
 
 // The header must have space for at least IP_PACKET_SIZE bytes.
-void ParsedRtcEventLog::GetRtpHeader(size_t index,
-                                     PacketDirection* incoming,
-                                     uint8_t* header,
-                                     size_t* header_length,
-                                     size_t* total_length) const {
+webrtc::RtpHeaderExtensionMap* ParsedRtcEventLog::GetRtpHeader(
+    size_t index,
+    PacketDirection* incoming,
+    uint8_t* header,
+    size_t* header_length,
+    size_t* total_length) const {
   RTC_CHECK_LT(index, GetNumberOfEvents());
   const rtclog::Event& event = events_[index];
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::RTP_EVENT);
   RTC_CHECK(event.has_rtp_packet());
   const rtclog::RtpPacket& rtp_packet = event.rtp_packet();
   // Get direction of packet.
   RTC_CHECK(rtp_packet.has_incoming());
   if (incoming != nullptr) {
     *incoming = rtp_packet.incoming() ? kIncomingPacket : kOutgoingPacket;
   }
   // Get packet length.
   RTC_CHECK(rtp_packet.has_packet_length());
   if (total_length != nullptr) {
     *total_length = rtp_packet.packet_length();
   }
   // Get header length.
   RTC_CHECK(rtp_packet.has_header());
   if (header_length != nullptr) {
     *header_length = rtp_packet.header().size();
   }
   // Get header contents.
   if (header != nullptr) {
     const size_t kMinRtpHeaderSize = 12;
     RTC_CHECK_GE(rtp_packet.header().size(), kMinRtpHeaderSize);
     RTC_CHECK_LE(rtp_packet.header().size(),
                  static_cast<size_t>(IP_PACKET_SIZE));
     memcpy(header, rtp_packet.header().data(), rtp_packet.header().size());
+    uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(header + 8);
+    StreamId stream_id(
+        ssrc, rtp_packet.incoming() ? kIncomingPacket : kOutgoingPacket);
+    auto it = rtp_extensions_maps_.find(stream_id);
+    if (it != rtp_extensions_maps_.end()) {
+      return it->second;
+    }
   }
+  return nullptr;
 }
 
 // The packet must have space for at least IP_PACKET_SIZE bytes.
 void ParsedRtcEventLog::GetRtcpPacket(size_t index,
                                       PacketDirection* incoming,
                                       uint8_t* packet,
                                       size_t* length) const {
   RTC_CHECK_LT(index, GetNumberOfEvents());
   const rtclog::Event& event = events_[index];
   RTC_CHECK(event.has_type());
@@ skipping 316 matching lines @@
 ParsedRtcEventLog::MediaType ParsedRtcEventLog::GetMediaType(
     uint32_t ssrc,
     PacketDirection direction) const {
   for (auto rit = streams_.rbegin(); rit != streams_.rend(); ++rit) {
     if (rit->ssrc == ssrc && rit->direction == direction)
       return rit->media_type;
   }
   return MediaType::ANY;
 }
 }  // namespace webrtc