Make rtc_event_log2text output header extensions

webrtc/logging/rtc_event_log/rtc_event_log2text.cc

 /*
  *  Copyright (c) 2017 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 <iostream>
+#include <map>
 #include <sstream>
 #include <string>
+#include <utility>  // pair
 
 #include "gflags/gflags.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/common_types.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
@@ skipping 408 matching lines @@
                   << ", rtx_payload_type: " << codec.rtx_payload_type << "}";
       }
       std::cout << "}" << std::endl;
     }
     if (!FLAGS_nortp &&
         parsed_stream.GetEventType(i) == webrtc::ParsedRtcEventLog::RTP_EVENT) {
       size_t header_length;
       size_t total_length;
       uint8_t header[IP_PACKET_SIZE];
       webrtc::PacketDirection direction;
-
-      parsed_stream.GetRtpHeader(i, &direction, header, &header_length,
-                                 &total_length);
+      webrtc::RtpHeaderExtensionMap* extension_map = parsed_stream.GetRtpHeader(

[perkj_webrtc, 2017/06/07 16:49:57]

Why can't this return a webrtc::RtpHeader directly? 

[ilnik, 2017/06/08 08:43:43]

I don't know why it was done like that. Maybe designers of  ParsedRtcEventLog
thought to make it more flexible like that. What if some user would want to
print the bytes of a header itself to check a corrupted header?

[terelius, 2017/06/08 09:40:28]

RTPHeader doesn't contain direction, media_type or length fields. And, as Ilya
pointed out, it can't parse corrupt headers. In retrospect, we almost never care
about corrupt headers, so it would indeed be more convenient to get a fully
parsed header.

Eventually I think that the parser should contain std::vector<LoggedRtpPacket>
incoming_packets_;
std::vector<LoggedRtpPacket> outgoing_packets_;
std::map<StreamId, std::vector<LoggedRtpPacket*>> incoming_packets_by_stream_;
std::map<StreamId, std::vector<LoggedRtpPacket*>> outgoing_packets_by_stream_;
These would be populated as soon as the file is read. The analysis tools can
then access the packets via getters
const std::vector<LoggedRtpPacket>& incoming_packets();
All other event types (RTCP, BWE, Audio playouts, etc) would be handled in the
same manner. This is slightly less flexible, but it matches the way we actually
use the events in the analysis tools.

[ilnik, 2017/06/08 09:44:16]

Looks like there'll be a massive overhaul of rtp_log_parser in the future. But
it should be in a separate CL.

Perkj@, do you approve of this CL? May I land it? 

+          i, &direction, header, &header_length, &total_length);
 
       // Parse header to get SSRC and RTP time.
       webrtc::RtpUtility::RtpHeaderParser rtp_parser(header, header_length);
       webrtc::RTPHeader parsed_header;
-      rtp_parser.Parse(&parsed_header);
+      rtp_parser.Parse(&parsed_header, extension_map);
       MediaType media_type =
           parsed_stream.GetMediaType(parsed_header.ssrc, direction);
 
       if (ExcludePacket(direction, media_type, parsed_header.ssrc))
         continue;
 
       std::cout << parsed_stream.GetTimestamp(i) << "\tRTP"
                 << StreamInfo(direction, media_type)
                 << "\tssrc=" << parsed_header.ssrc
-                << "\ttimestamp=" << parsed_header.timestamp << std::endl;
+                << "\ttimestamp=" << parsed_header.timestamp;
+      if (parsed_header.extension.hasAbsoluteSendTime) {
+        std::cout << "\tAbsSendTime="
+                  << parsed_header.extension.absoluteSendTime;
+      }
+      if (parsed_header.extension.hasVideoContentType) {
+        std::cout << "\tContentType="
+                  << static_cast<int>(parsed_header.extension.videoContentType);
+      }
+      if (parsed_header.extension.hasVideoRotation) {
+        std::cout << "\tRotation="
+                  << static_cast<int>(parsed_header.extension.videoRotation);
+      }
+      if (parsed_header.extension.hasTransportSequenceNumber) {
+        std::cout << "\tTransportSeq="
+                  << parsed_header.extension.transportSequenceNumber;
+      }
+      if (parsed_header.extension.hasTransmissionTimeOffset) {
+        std::cout << "\tTransmTimeOffset="
+                  << parsed_header.extension.transmissionTimeOffset;
+      }
+      if (parsed_header.extension.hasAudioLevel) {
+        std::cout << "\tAudioLevel=" << parsed_header.extension.audioLevel;
+      }
+      std::cout << std::endl;
     }
     if (!FLAGS_nortcp &&
         parsed_stream.GetEventType(i) ==
             webrtc::ParsedRtcEventLog::RTCP_EVENT) {
       size_t length;
       uint8_t packet[IP_PACKET_SIZE];
       webrtc::PacketDirection direction;
       parsed_stream.GetRtcpPacket(i, &direction, packet, &length);
 
       webrtc::rtcp::CommonHeader rtcp_block;
@@ skipping 34 matching lines @@
                             direction);
             break;
           default:
             break;
         }
       }
     }
   }
   return 0;
 }