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 80 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);
   }
+  // Add default values for audio header extensions, since these are not stored
+  // in the eventlog.
+  // TODO(ivoc): Remove this once this is stored in the event log.

[hlundin-webrtc, 2016/09/21 08:51:13]

Do we have a tracking bug for this work? If not, please, create one, and
reference it in this TODO.

[ivoc, 2016/09/21 11:50:04]

I have a CL up to include this information in the event log:
https://codereview.webrtc.org/2353543003/
However, we will probably want to wait for a while after that lands before we
remove these default mappings, since there are currently a lot of event logs in
the wild that don't have the configs in them. I made a tracking bug here:
https://bugs.chromium.org/p/webrtc/issues/detail?id=6399

+  extension_map->Register(

[terelius, 2016/09/21 09:44:32]

Could you do this for audio streams only please.

[ivoc, 2016/09/21 11:50:04]

I moved this to a seperate function, which returns a default
RtpHeaderExtensionMap, which is only used for streams without other header
extensions (so presumably audio streams).

+      webrtc::StringToRtpExtensionType(webrtc::RtpExtension::kAudioLevelUri),
+      webrtc::RtpExtension::kAudioLevelDefaultId);
+  extension_map->Register(
+      webrtc::StringToRtpExtensionType(webrtc::RtpExtension::kAbsSendTimeUri),
+      webrtc::RtpExtension::kAbsSendTimeDefaultId);
 }
 
 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;
@@ skipping 234 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 {
+          // Make a default extension map.
+          RtpHeaderExtensionMap extension_map;
+          std::vector<webrtc::RtpExtension> extensions;
+          RegisterHeaderExtensions(extensions, &extension_map);

[terelius, 2016/09/21 09:44:32]

Mark this with a TODO. We don't want to reregister extensions for each packet.

[ivoc, 2016/09/21 11:50:04]

Good point, I moved the creation of the extension map outside of the packet
loop, so it can be reused for all packets without config, and I sprinkled some
TODOs around.

+          rtp_parser.Parse(&parsed_header, &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;

[terelius, 2016/09/21 10:00:14]

In the future, you should only search the packets if the stream has been
configured for audio. Please add a TODO.

[ivoc, 2016/09/21 11:50:04]

Good point, added.

+    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