Added graph for plotting the audio level from an Rtc event log.

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 82 matching lines @@
 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);
   }
 }
 
+// Return default values for header extensions, to use on streams without stored
+// mapping data. Currently this only applies to audio streams, since the mapping
+// is not stored in the event log.
+// TODO(ivoc): Remove this once this mapping is stored in the event log for
+//             audio streams. Tracking bug: webrtc:6399
+webrtc::RtpHeaderExtensionMap GetDefaultHeaderExtensionMap() {
+  webrtc::RtpHeaderExtensionMap default_map;
+  default_map.Register(
+      webrtc::StringToRtpExtensionType(webrtc::RtpExtension::kAudioLevelUri),
+      webrtc::RtpExtension::kAudioLevelDefaultId);
+  default_map.Register(
+      webrtc::StringToRtpExtensionType(webrtc::RtpExtension::kAbsSendTimeUri),
+      webrtc::RtpExtension::kAbsSendTimeDefaultId);
+  return default_map;
+}
+
 constexpr float kLeftMargin = 0.01f;
 constexpr float kRightMargin = 0.02f;
 constexpr float kBottomMargin = 0.02f;
 constexpr float kTopMargin = 0.05f;
 
 class PacketSizeBytes {
  public:
   using DataType = LoggedRtpPacket;
   using ResultType = size_t;
   size_t operator()(const LoggedRtpPacket& packet) {
@@ skipping 161 matching lines @@
 
   // 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;
 
+  // Make a default extension map for streams without configuration information.
+  // TODO(ivoc): Once configuration of audio streams is stored in the event log,
+  //             this can be removed. Tracking bug: webrtc:6399
+  RtpHeaderExtensionMap default_extension_map = GetDefaultHeaderExtensionMap();
+
   for (size_t i = 0; i < parsed_log_.GetNumberOfEvents(); i++) {
     ParsedRtcEventLog::EventType event_type = parsed_log_.GetEventType(i);
     if (event_type != ParsedRtcEventLog::VIDEO_RECEIVER_CONFIG_EVENT &&
         event_type != ParsedRtcEventLog::VIDEO_SENDER_CONFIG_EVENT &&
         event_type != ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT &&
         event_type != ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT &&
         event_type != ParsedRtcEventLog::LOG_START &&
         event_type != ParsedRtcEventLog::LOG_END) {
       uint64_t timestamp = parsed_log_.GetTimestamp(i);
       first_timestamp = std::min(first_timestamp, timestamp);
@@ skipping 51 matching lines @@
                                  &header_length, &total_length);
         // Parse header to get SSRC.
         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];
           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);
         rtp_packets_[stream].push_back(
             LoggedRtpPacket(timestamp, parsed_header, total_length));
         break;
       }
       case ParsedRtcEventLog::RTCP_EVENT: {
         uint8_t packet[IP_PACKET_SIZE];
         MediaType media_type;
         parsed_log_.GetRtcpPacket(i, &direction, &media_type, packet,
@@ skipping 110 matching lines @@
   std::stringstream name;
   if (IsAudioSsrc(stream_id)) {
     name << "Audio ";
   } else if (IsVideoSsrc(stream_id)) {
     name << "Video ";
   } else {
     name << "Unknown ";
   }
   if (IsRtxSsrc(stream_id))
     name << "RTX ";
+  if (stream_id.GetDirection() == kIncomingPacket) {
+    name << "(In) ";
+  } else {
+    name << "(Out) ";
+  }
   name << SsrcToString(stream_id.GetSsrc());
   return name.str();
 }
 
 void EventLogAnalyzer::CreatePacketGraph(PacketDirection desired_direction,
                                          Plot* plot) {
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
     // Filter on direction and SSRC.
@@ skipping 98 matching lines @@
     kv.second.style = BAR_GRAPH;
     plot->series_list_.push_back(std::move(kv.second));
   }
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 1, "Time since last playout (ms)", kBottomMargin,
                           kTopMargin);
   plot->SetTitle("Audio playout");
 }
 
+// For audio SSRCs, plot the audio level.
+void EventLogAnalyzer::CreateAudioLevelGraph(Plot* plot) {
+  std::map<StreamId, TimeSeries> time_series;
+
+  for (auto& kv : rtp_packets_) {
+    StreamId stream_id = kv.first;
+    const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
+    // TODO(ivoc): When audio send/receive configs are stored in the event
+    //             log, a check should be added here to only process audio
+    //             streams. Tracking bug: webrtc:6399
+    for (auto& packet : packet_stream) {
+      if (packet.header.extension.hasAudioLevel) {
+        float x = static_cast<float>(packet.timestamp - begin_time_) / 1000000;
+        // The audio level is stored in -dBov (so e.g. -10 dBov is stored as 10)
+        // Here we convert it to dBov.
+        float y = static_cast<float>(-packet.header.extension.audioLevel);
+        time_series[stream_id].points.emplace_back(TimeSeriesPoint(x, y));
+      }
+    }
+  }
+
+  for (auto& series : time_series) {
+    series.second.label = GetStreamName(series.first);
+    series.second.style = LINE_GRAPH;
+    plot->series_list_.push_back(std::move(series.second));
+  }
+
+  plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
+  plot->SetYAxis(-127, 0, "Audio playout level (dBov)", kBottomMargin,
+                 kTopMargin);
+  plot->SetTitle("Audio level");
+}
+
 // For each SSRC, plot the time between the consecutive playouts.
 void EventLogAnalyzer::CreateSequenceNumberGraph(Plot* plot) {
   for (auto& kv : rtp_packets_) {
     StreamId stream_id = kv.first;
     const std::vector<LoggedRtpPacket>& packet_stream = kv.second;
     // Filter on direction and SSRC.
     if (stream_id.GetDirection() != kIncomingPacket ||
         !MatchingSsrc(stream_id.GetSsrc(), desired_ssrc_)) {
       continue;
     }
@@ skipping 459 matching lines @@
     point.y -= estimated_base_delay_ms;
   // Add the data set to the plot.
   plot->series_list_.push_back(std::move(time_series));
 
   plot->SetXAxis(0, call_duration_s_, "Time (s)", kLeftMargin, kRightMargin);
   plot->SetSuggestedYAxis(0, 10, "Delay (ms)", kBottomMargin, kTopMargin);
   plot->SetTitle("Network Delay Change.");
 }
 }  // namespace plotting
 }  // namespace webrtc