Replace VideoReceiveStream::Config with new rtclog::StreamConfig in RtcEventLog.

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.
  */
 
 #include "webrtc/logging/rtc_event_log/rtc_event_log_parser.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <algorithm>
 #include <fstream>
 #include <istream>
+#include <map>
 #include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/protobuf_utils.h"
 #include "webrtc/call/call.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@@ skipping 280 matching lines @@
   if (packet != nullptr) {
     RTC_CHECK_LE(rtcp_packet.packet_data().size(),
                  static_cast<unsigned>(IP_PACKET_SIZE));
     memcpy(packet, rtcp_packet.packet_data().data(),
            rtcp_packet.packet_data().size());
   }
 }
 
 void ParsedRtcEventLog::GetVideoReceiveConfig(
     size_t index,
-    VideoReceiveStream::Config* config) const {
+    rtclog::StreamConfig* 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_RECEIVER_CONFIG_EVENT);
   RTC_CHECK(event.has_video_receiver_config());
   const rtclog::VideoReceiveConfig& receiver_config =
       event.video_receiver_config();
   // Get SSRCs.
   RTC_CHECK(receiver_config.has_remote_ssrc());
-  config->rtp.remote_ssrc = receiver_config.remote_ssrc();
+  config->remote_ssrc = receiver_config.remote_ssrc();
   RTC_CHECK(receiver_config.has_local_ssrc());
-  config->rtp.local_ssrc = receiver_config.local_ssrc();
+  config->local_ssrc = receiver_config.local_ssrc();
+  config->rtx_ssrc = 0;
   // Get RTCP settings.
   RTC_CHECK(receiver_config.has_rtcp_mode());
-  config->rtp.rtcp_mode = GetRuntimeRtcpMode(receiver_config.rtcp_mode());
+  config->rtcp_mode = GetRuntimeRtcpMode(receiver_config.rtcp_mode());
   RTC_CHECK(receiver_config.has_remb());
-  config->rtp.remb = receiver_config.remb();
+  config->remb = receiver_config.remb();
+
   // Get RTX map.
-  std::vector<uint32_t> rtx_ssrcs(receiver_config.rtx_map_size());
-  config->rtp.rtx_payload_types.clear();
+  std::map<uint32_t, const rtclog::RtxConfig> rtx_map;
   for (int i = 0; i < receiver_config.rtx_map_size(); i++) {
     const rtclog::RtxMap& map = receiver_config.rtx_map(i);
     RTC_CHECK(map.has_payload_type());
     RTC_CHECK(map.has_config());
     RTC_CHECK(map.config().has_rtx_ssrc());
-    rtx_ssrcs[i] = map.config().rtx_ssrc();
     RTC_CHECK(map.config().has_rtx_payload_type());
-    config->rtp.rtx_payload_types.insert(
-        std::make_pair(map.payload_type(), map.config().rtx_payload_type()));
+    rtx_map.insert(std::make_pair(map.payload_type(), map.config()));
   }
-  if (!rtx_ssrcs.empty()) {
-    config->rtp.rtx_ssrc = rtx_ssrcs[0];
 
-    auto pred = [&config](uint32_t ssrc) {
-      return ssrc == config->rtp.rtx_ssrc;
-    };
-    if (!std::all_of(rtx_ssrcs.cbegin(), rtx_ssrcs.cend(), pred)) {
-      LOG(LS_WARNING) << "RtcEventLog protobuf contained different SSRCs for "
-                         "different received RTX payload types. Will only use "
-                         "rtx_ssrc = "
-                      << config->rtp.rtx_ssrc << ".";
-    }
-  }
   // Get header extensions.
-  GetHeaderExtensions(&config->rtp.extensions,
+  GetHeaderExtensions(&config->rtp_extensions,
                       receiver_config.header_extensions());
   // Get decoders.
-  config->decoders.clear();
+  config->codecs.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);
+    int rtx_payload_type = 0;
+    auto rtx_it = rtx_map.find(receiver_config.decoders(i).payload_type());
+    if (rtx_it != rtx_map.end()) {
+      rtx_payload_type = rtx_it->second.rtx_payload_type();
+      if (config->rtx_ssrc != 0 &&
+          config->rtx_ssrc != rtx_it->second.rtx_ssrc()) {
+        LOG(LS_WARNING)
+            << "RtcEventLog protobuf contained different SSRCs for "
+               "different received RTX payload types. Will only use "
+               "rtx_ssrc = "
+            << config->rtx_ssrc << ".";
+      } else {
+        config->rtx_ssrc = rtx_it->second.rtx_ssrc();
+      }
+    }
+    config->codecs.emplace_back(receiver_config.decoders(i).name(),
+                                receiver_config.decoders(i).payload_type(),
+                                rtx_payload_type);
   }
 }
 
 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());
@@ skipping 197 matching lines @@
         rtc::Optional<ProbeFailureReason>(kInvalidSendReceiveRatio);
   } else if (pr_event.result() == rtclog::BweProbeResult::TIMEOUT) {
     res.failure_reason = rtc::Optional<ProbeFailureReason>(kTimeout);
   } else {
     RTC_NOTREACHED();
   }
 
   return res;
 }
 }  // namespace webrtc