Added logging for audio send/receive stream configs.

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 86 matching lines @@
     }
     RTC_DCHECK(0 <= byte && byte <= 255);
     varint |= static_cast<uint64_t>(byte & 0x7F) << (7 * bytes_read);
     if ((byte & 0x80) == 0) {
       return std::make_pair(varint, true);
     }
   }
   return std::make_pair(varint, false);
 }
 
+void GetHeaderExtensions(
+    std::vector<RtpExtension>* header_extensions,
+    const google::protobuf::RepeatedPtrField<rtclog::RtpHeaderExtension>&
+        proto_header_extensions) {
+  header_extensions->clear();
+  for (auto& p : proto_header_extensions) {
+    RTC_CHECK(p.has_name());
+    RTC_CHECK(p.has_id());
+    const std::string& name = p.name();
+    int id = p.id();
+    header_extensions->push_back(RtpExtension(name, id));
+  }
+}
+
 }  // namespace
 
 bool ParsedRtcEventLog::ParseFile(const std::string& filename) {
   std::ifstream file(filename, std::ios_base::in | std::ios_base::binary);
   if (!file.good() || !file.is_open()) {
     LOG(LS_WARNING) << "Could not open file for reading.";
     return false;
   }
 
   return ParseStream(file);
@@ skipping 187 matching lines @@
     RTC_CHECK(map.has_payload_type());
     RTC_CHECK(map.has_config());
     RTC_CHECK(map.config().has_rtx_ssrc());
     RTC_CHECK(map.config().has_rtx_payload_type());
     webrtc::VideoReceiveStream::Config::Rtp::Rtx rtx_pair;
     rtx_pair.ssrc = map.config().rtx_ssrc();
     rtx_pair.payload_type = map.config().rtx_payload_type();
     config->rtp.rtx.insert(std::make_pair(map.payload_type(), rtx_pair));
   }
   // Get header extensions.
-  config->rtp.extensions.clear();
-  for (int i = 0; i < receiver_config.header_extensions_size(); i++) {
-    RTC_CHECK(receiver_config.header_extensions(i).has_name());
-    RTC_CHECK(receiver_config.header_extensions(i).has_id());
-    const std::string& name = receiver_config.header_extensions(i).name();
-    int id = receiver_config.header_extensions(i).id();
-    config->rtp.extensions.push_back(RtpExtension(name, id));
-  }
+  GetHeaderExtensions(&config->rtp.extensions,
+                      receiver_config.header_extensions());
   // Get decoders.
   config->decoders.clear();
   for (int i = 0; i < receiver_config.decoders_size(); i++) {
     RTC_CHECK(receiver_config.decoders(i).has_name());
     RTC_CHECK(receiver_config.decoders(i).has_payload_type());
     VideoReceiveStream::Decoder decoder;
     decoder.payload_name = receiver_config.decoders(i).name();
     decoder.payload_type = receiver_config.decoders(i).payload_type();
     config->decoders.push_back(decoder);
   }
 }
 
 void ParsedRtcEventLog::GetVideoSendConfig(
     size_t index,
     VideoSendStream::Config* config) const {
   RTC_CHECK_LT(index, GetNumberOfEvents());
   const rtclog::Event& event = events_[index];
   RTC_CHECK(config != nullptr);
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::VIDEO_SENDER_CONFIG_EVENT);
   RTC_CHECK(event.has_video_sender_config());
   const rtclog::VideoSendConfig& sender_config = event.video_sender_config();
   // Get SSRCs.
   config->rtp.ssrcs.clear();
   for (int i = 0; i < sender_config.ssrcs_size(); i++) {
     config->rtp.ssrcs.push_back(sender_config.ssrcs(i));
   }
   // Get header extensions.
-  config->rtp.extensions.clear();
-  for (int i = 0; i < sender_config.header_extensions_size(); i++) {
-    RTC_CHECK(sender_config.header_extensions(i).has_name());
-    RTC_CHECK(sender_config.header_extensions(i).has_id());
-    const std::string& name = sender_config.header_extensions(i).name();
-    int id = sender_config.header_extensions(i).id();
-    config->rtp.extensions.push_back(RtpExtension(name, id));
-  }
+  GetHeaderExtensions(&config->rtp.extensions,
+                      sender_config.header_extensions());
   // Get RTX settings.
   config->rtp.rtx.ssrcs.clear();
   for (int i = 0; i < sender_config.rtx_ssrcs_size(); i++) {
     config->rtp.rtx.ssrcs.push_back(sender_config.rtx_ssrcs(i));
   }
   if (sender_config.rtx_ssrcs_size() > 0) {
     RTC_CHECK(sender_config.has_rtx_payload_type());
     config->rtp.rtx.payload_type = sender_config.rtx_payload_type();
   } else {
     // Reset RTX payload type default value if no RTX SSRCs are used.
     config->rtp.rtx.payload_type = -1;
   }
   // Get encoder.
   RTC_CHECK(sender_config.has_encoder());
   RTC_CHECK(sender_config.encoder().has_name());
   RTC_CHECK(sender_config.encoder().has_payload_type());
   config->encoder_settings.payload_name = sender_config.encoder().name();
   config->encoder_settings.payload_type =
       sender_config.encoder().payload_type();
 }
 
+void ParsedRtcEventLog::GetAudioReceiveConfig(
+    size_t index,
+    AudioReceiveStream::Config* config) const {
+  RTC_CHECK_LT(index, GetNumberOfEvents());
+  const rtclog::Event& event = events_[index];
+  RTC_CHECK(config != nullptr);
+  RTC_CHECK(event.has_type());
+  RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT);
+  RTC_CHECK(event.has_audio_receiver_config());
+  const rtclog::AudioReceiveConfig& receiver_config =
+      event.audio_receiver_config();
+  // Get SSRCs.
+  RTC_CHECK(receiver_config.has_remote_ssrc());
+  config->rtp.remote_ssrc = receiver_config.remote_ssrc();
+  RTC_CHECK(receiver_config.has_local_ssrc());
+  config->rtp.local_ssrc = receiver_config.local_ssrc();
+  // Get header extensions.
+  GetHeaderExtensions(&config->rtp.extensions,
+                      receiver_config.header_extensions());
+}
+
+void ParsedRtcEventLog::GetAudioSendConfig(
+    size_t index,
+    AudioSendStream::Config* config) const {
+  RTC_CHECK_LT(index, GetNumberOfEvents());
+  const rtclog::Event& event = events_[index];
+  RTC_CHECK(config != nullptr);
+  RTC_CHECK(event.has_type());
+  RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_SENDER_CONFIG_EVENT);
+  RTC_CHECK(event.has_audio_sender_config());
+  const rtclog::AudioSendConfig& sender_config = event.audio_sender_config();
+  // Get SSRCs.
+  RTC_CHECK(sender_config.has_ssrc());
+  config->rtp.ssrc = sender_config.ssrc();
+  // Get header extensions.
+  GetHeaderExtensions(&config->rtp.extensions,
+                      sender_config.header_extensions());
+}
+
 void ParsedRtcEventLog::GetAudioPlayout(size_t index, uint32_t* ssrc) const {
   RTC_CHECK_LT(index, GetNumberOfEvents());
   const rtclog::Event& event = events_[index];
   RTC_CHECK(event.has_type());
   RTC_CHECK_EQ(event.type(), rtclog::Event::AUDIO_PLAYOUT_EVENT);
   RTC_CHECK(event.has_audio_playout_event());
   const rtclog::AudioPlayoutEvent& loss_event = event.audio_playout_event();
   RTC_CHECK(loss_event.has_local_ssrc());
   if (ssrc != nullptr) {
     *ssrc = loss_event.local_ssrc();
@@ skipping 18 matching lines @@
   if (fraction_loss != nullptr) {
     *fraction_loss = loss_event.fraction_loss();
   }
   RTC_CHECK(loss_event.has_total_packets());
   if (total_packets != nullptr) {
     *total_packets = loss_event.total_packets();
   }
 }
 
 }  // namespace webrtc