Replace VideoReceiveStream::Config with new rtclog::StreamConfig in RtcEventLog.
BUG=webrtc:7538
Review-Url: https://codereview.webrtc.org/2850793002
Cr-Original-Commit-Position: refs/heads/master@{#18220}
Cr-Mirrored-From: https://chromium.googlesource.com/external/webrtc
Cr-Mirrored-Commit: 09e71daec503f9983938fd7e621657fc4cff2440
diff --git a/call/call.cc b/call/call.cc
index 802778e..f9f1fb5 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -88,6 +88,25 @@
return UseSendSideBwe(config.rtp_header_extensions, config.transport_cc);
}
+rtclog::StreamConfig CreateRtcLogStreamConfig(
+ const VideoReceiveStream::Config& config) {
+ rtclog::StreamConfig rtclog_config;
+ rtclog_config.remote_ssrc = config.rtp.remote_ssrc;
+ rtclog_config.local_ssrc = config.rtp.local_ssrc;
+ rtclog_config.rtx_ssrc = config.rtp.rtx_ssrc;
+ rtclog_config.rtcp_mode = config.rtp.rtcp_mode;
+ rtclog_config.remb = config.rtp.remb;
+ rtclog_config.rtp_extensions = config.rtp.extensions;
+
+ for (const auto& d : config.decoders) {
+ auto search = config.rtp.rtx_payload_types.find(d.payload_type);
+ rtclog_config.codecs.emplace_back(
+ d.payload_name, d.payload_type,
+ search != config.rtp.rtx_payload_types.end() ? search->second : 0);
+ }
+ return rtclog_config;
+}
+
} // namespace
namespace internal {
@@ -710,7 +729,7 @@
}
receive_stream->SignalNetworkState(video_network_state_);
UpdateAggregateNetworkState();
- event_log_->LogVideoReceiveStreamConfig(config);
+ event_log_->LogVideoReceiveStreamConfig(CreateRtcLogStreamConfig(config));
return receive_stream;
}
diff --git a/logging/rtc_event_log/mock/mock_rtc_event_log.h b/logging/rtc_event_log/mock/mock_rtc_event_log.h
index 154882f..e6dd9d6 100644
--- a/logging/rtc_event_log/mock/mock_rtc_event_log.h
+++ b/logging/rtc_event_log/mock/mock_rtc_event_log.h
@@ -30,7 +30,7 @@
MOCK_METHOD0(StopLogging, void());
MOCK_METHOD1(LogVideoReceiveStreamConfig,
- void(const webrtc::VideoReceiveStream::Config& config));
+ void(const rtclog::StreamConfig& config));
MOCK_METHOD1(LogVideoSendStreamConfig,
void(const webrtc::VideoSendStream::Config& config));
diff --git a/logging/rtc_event_log/rtc_event_log.cc b/logging/rtc_event_log/rtc_event_log.cc
index 7d5b606..d7e6067 100644
--- a/logging/rtc_event_log/rtc_event_log.cc
+++ b/logging/rtc_event_log/rtc_event_log.cc
@@ -62,8 +62,7 @@
bool StartLogging(rtc::PlatformFile platform_file,
int64_t max_size_bytes) override;
void StopLogging() override;
- void LogVideoReceiveStreamConfig(
- const VideoReceiveStream::Config& config) override;
+ void LogVideoReceiveStreamConfig(const rtclog::StreamConfig& config) override;
void LogVideoSendStreamConfig(const VideoSendStream::Config& config) override;
void LogAudioReceiveStreamConfig(
const AudioReceiveStream::Config& config) override;
@@ -277,37 +276,37 @@
}
void RtcEventLogImpl::LogVideoReceiveStreamConfig(
- const VideoReceiveStream::Config& config) {
+ const rtclog::StreamConfig& config) {
std::unique_ptr<rtclog::Event> event(new rtclog::Event());
event->set_timestamp_us(rtc::TimeMicros());
event->set_type(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT);
rtclog::VideoReceiveConfig* receiver_config =
event->mutable_video_receiver_config();
- receiver_config->set_remote_ssrc(config.rtp.remote_ssrc);
- receiver_config->set_local_ssrc(config.rtp.local_ssrc);
+ receiver_config->set_remote_ssrc(config.remote_ssrc);
+ receiver_config->set_local_ssrc(config.local_ssrc);
- receiver_config->set_rtcp_mode(ConvertRtcpMode(config.rtp.rtcp_mode));
- receiver_config->set_remb(config.rtp.remb);
+ // TODO(perkj): Add field for rsid.
+ receiver_config->set_rtcp_mode(ConvertRtcpMode(config.rtcp_mode));
+ receiver_config->set_remb(config.remb);
- for (const auto& kv : config.rtp.rtx_payload_types) {
- rtclog::RtxMap* rtx = receiver_config->add_rtx_map();
- rtx->set_payload_type(kv.first);
- rtx->mutable_config()->set_rtx_ssrc(config.rtp.rtx_ssrc);
- rtx->mutable_config()->set_rtx_payload_type(kv.second);
- }
-
- for (const auto& e : config.rtp.extensions) {
+ for (const auto& e : config.rtp_extensions) {
rtclog::RtpHeaderExtension* extension =
receiver_config->add_header_extensions();
extension->set_name(e.uri);
extension->set_id(e.id);
}
- for (const auto& d : config.decoders) {
+ for (const auto& d : config.codecs) {
rtclog::DecoderConfig* decoder = receiver_config->add_decoders();
decoder->set_name(d.payload_name);
decoder->set_payload_type(d.payload_type);
+ if (d.rtx_payload_type != 0) {
+ rtclog::RtxMap* rtx = receiver_config->add_rtx_map();
+ rtx->set_payload_type(d.payload_type);
+ rtx->mutable_config()->set_rtx_ssrc(config.rtx_ssrc);
+ rtx->mutable_config()->set_rtx_payload_type(d.rtx_payload_type);
+ }
}
StoreEvent(&event);
}
diff --git a/logging/rtc_event_log/rtc_event_log.h b/logging/rtc_event_log/rtc_event_log.h
index a98c71b..d3e6213 100644
--- a/logging/rtc_event_log/rtc_event_log.h
+++ b/logging/rtc_event_log/rtc_event_log.h
@@ -13,6 +13,7 @@
#include <memory>
#include <string>
+#include <vector>
#include "webrtc/base/platform_file.h"
#include "webrtc/call/audio_receive_stream.h"
@@ -26,6 +27,33 @@
// the protobuf file.
namespace rtclog {
class EventStream;
+
+struct StreamConfig {
+ uint32_t local_ssrc = 0;
+ uint32_t remote_ssrc = 0;
+ uint32_t rtx_ssrc = 0;
+ std::string rsid;
+
+ bool remb = false;
+ std::vector<RtpExtension> rtp_extensions;
+
+ RtcpMode rtcp_mode = RtcpMode::kReducedSize;
+
+ struct Codec {
+ Codec(const std::string& payload_name,
+ int payload_type,
+ int rtx_payload_type)
+ : payload_name(payload_name),
+ payload_type(payload_type),
+ rtx_payload_type(rtx_payload_type) {}
+
+ std::string payload_name;
+ int payload_type;
+ int rtx_payload_type;
+ };
+ std::vector<Codec> codecs;
+};
+
} // namespace rtclog
class Clock;
@@ -84,9 +112,9 @@
// Stops logging to file and waits until the thread has finished.
virtual void StopLogging() = 0;
- // Logs configuration information for webrtc::VideoReceiveStream.
+ // Logs configuration information for video receive stream.
virtual void LogVideoReceiveStreamConfig(
- const webrtc::VideoReceiveStream::Config& config) = 0;
+ const rtclog::StreamConfig& config) = 0;
// Logs configuration information for webrtc::VideoSendStream.
virtual void LogVideoSendStreamConfig(
@@ -172,7 +200,7 @@
int64_t max_size_bytes) override;
void StopLogging() override {}
void LogVideoReceiveStreamConfig(
- const VideoReceiveStream::Config& config) override {}
+ const rtclog::StreamConfig& config) override {}
void LogVideoSendStreamConfig(
const VideoSendStream::Config& config) override {}
void LogAudioReceiveStreamConfig(
diff --git a/logging/rtc_event_log/rtc_event_log2text.cc b/logging/rtc_event_log/rtc_event_log2text.cc
index 1fa694d..76fc95e 100644
--- a/logging/rtc_event_log/rtc_event_log2text.cc
+++ b/logging/rtc_event_log/rtc_event_log2text.cc
@@ -364,20 +364,20 @@
for (size_t i = 0; i < parsed_stream.GetNumberOfEvents(); i++) {
if (parsed_stream.GetEventType(i) ==
webrtc::ParsedRtcEventLog::VIDEO_RECEIVER_CONFIG_EVENT) {
- webrtc::VideoReceiveStream::Config config(nullptr);
+ webrtc::rtclog::StreamConfig config;
parsed_stream.GetVideoReceiveConfig(i, &config);
- global_streams.emplace_back(config.rtp.remote_ssrc,
+ global_streams.emplace_back(config.remote_ssrc,
webrtc::MediaType::VIDEO,
webrtc::kIncomingPacket);
- global_streams.emplace_back(config.rtp.local_ssrc,
+ global_streams.emplace_back(config.local_ssrc,
webrtc::MediaType::VIDEO,
webrtc::kOutgoingPacket);
if (!FLAGS_noconfig && !FLAGS_novideo && !FLAGS_noincoming) {
std::cout << parsed_stream.GetTimestamp(i) << "\tVIDEO_RECV_CONFIG"
- << "\tssrc=" << config.rtp.remote_ssrc
- << "\tfeedback_ssrc=" << config.rtp.local_ssrc << std::endl;
+ << "\tssrc=" << config.remote_ssrc
+ << "\tfeedback_ssrc=" << config.local_ssrc << std::endl;
}
}
if (parsed_stream.GetEventType(i) ==
diff --git a/logging/rtc_event_log/rtc_event_log_parser.cc b/logging/rtc_event_log/rtc_event_log_parser.cc
index 79f077d..2816158 100644
--- a/logging/rtc_event_log/rtc_event_log_parser.cc
+++ b/logging/rtc_event_log/rtc_event_log_parser.cc
@@ -16,6 +16,7 @@
#include <algorithm>
#include <fstream>
#include <istream>
+#include <map>
#include <utility>
#include "webrtc/base/checks.h"
@@ -316,7 +317,7 @@
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);
@@ -327,52 +328,53 @@
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);
}
}
diff --git a/logging/rtc_event_log/rtc_event_log_parser.h b/logging/rtc_event_log/rtc_event_log_parser.h
index c682c63..147ff1b 100644
--- a/logging/rtc_event_log/rtc_event_log_parser.h
+++ b/logging/rtc_event_log/rtc_event_log_parser.h
@@ -114,10 +114,9 @@
uint8_t* packet,
size_t* length) const;
- // Reads a config event to a (non-NULL) VideoReceiveStream::Config struct.
+ // Reads a config event to a (non-NULL) StreamConfig struct.
// Only the fields that are stored in the protobuf will be written.
- void GetVideoReceiveConfig(size_t index,
- VideoReceiveStream::Config* config) const;
+ void GetVideoReceiveConfig(size_t index, rtclog::StreamConfig* config) const;
// Reads a config event to a (non-NULL) VideoSendStream::Config struct.
// Only the fields that are stored in the protobuf will be written.
diff --git a/logging/rtc_event_log/rtc_event_log_unittest.cc b/logging/rtc_event_log/rtc_event_log_unittest.cc
index 8be739e..cb3bf0d 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest.cc
+++ b/logging/rtc_event_log/rtc_event_log_unittest.cc
@@ -153,29 +153,23 @@
}
void GenerateVideoReceiveConfig(uint32_t extensions_bitvector,
- VideoReceiveStream::Config* config,
+ rtclog::StreamConfig* config,
Random* prng) {
- // Create a map from a payload type to an encoder name.
- VideoReceiveStream::Decoder decoder;
- decoder.payload_type = prng->Rand(0, 127);
- decoder.payload_name = (prng->Rand<bool>() ? "VP8" : "H264");
- config->decoders.push_back(decoder);
// Add SSRCs for the stream.
- config->rtp.remote_ssrc = prng->Rand<uint32_t>();
- config->rtp.local_ssrc = prng->Rand<uint32_t>();
+ config->remote_ssrc = prng->Rand<uint32_t>();
+ config->local_ssrc = prng->Rand<uint32_t>();
// Add extensions and settings for RTCP.
- config->rtp.rtcp_mode =
+ config->rtcp_mode =
prng->Rand<bool>() ? RtcpMode::kCompound : RtcpMode::kReducedSize;
- config->rtp.remb = prng->Rand<bool>();
- config->rtp.rtx_ssrc = prng->Rand<uint32_t>();
- // Add a map from a payload type to a new payload type for RTX.
- config->rtp.rtx_payload_types.insert(
- std::make_pair(prng->Rand(0, 127), prng->Rand(0, 127)));
+ config->remb = prng->Rand<bool>();
+ config->rtx_ssrc = prng->Rand<uint32_t>();
+ config->codecs.emplace_back(prng->Rand<bool>() ? "VP8" : "H264",
+ prng->Rand(1, 127), prng->Rand(1, 127));
// Add header extensions.
for (unsigned i = 0; i < kNumExtensions; i++) {
if (extensions_bitvector & (1u << i)) {
- config->rtp.extensions.push_back(
- RtpExtension(kExtensionNames[i], prng->Rand<int>()));
+ config->rtp_extensions.emplace_back(kExtensionNames[i],
+ prng->Rand<int>());
}
}
}
@@ -258,7 +252,7 @@
std::vector<uint32_t> playout_ssrcs;
std::vector<std::pair<int32_t, uint8_t> > bwe_loss_updates;
- VideoReceiveStream::Config receiver_config(nullptr);
+ rtclog::StreamConfig receiver_config;
VideoSendStream::Config sender_config(nullptr);
Random prng(random_seed);
@@ -815,7 +809,7 @@
class VideoReceiveConfigReadWriteTest : public ConfigReadWriteTest {
public:
- VideoReceiveConfigReadWriteTest() : config(nullptr) {}
+ VideoReceiveConfigReadWriteTest() {}
void GenerateConfig(uint32_t extensions_bitvector) override {
GenerateVideoReceiveConfig(extensions_bitvector, &config, &prng);
}
@@ -827,7 +821,7 @@
RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, index,
config);
}
- VideoReceiveStream::Config config;
+ rtclog::StreamConfig config;
};
class VideoSendConfigReadWriteTest : public ConfigReadWriteTest {
diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
index e2fa4b1..b5d739e 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
+++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
@@ -163,10 +163,32 @@
return ::testing::AssertionSuccess();
}
+void VerifyStreamConfigsAreEqual(const rtclog::StreamConfig& config_1,
+ const rtclog::StreamConfig& config_2) {
+ EXPECT_EQ(config_1.remote_ssrc, config_2.remote_ssrc);
+ EXPECT_EQ(config_1.local_ssrc, config_2.local_ssrc);
+ EXPECT_EQ(config_1.rtx_ssrc, config_2.rtx_ssrc);
+ EXPECT_EQ(config_1.rtcp_mode, config_2.rtcp_mode);
+ EXPECT_EQ(config_1.remb, config_2.remb);
+
+ ASSERT_EQ(config_1.rtp_extensions.size(), config_2.rtp_extensions.size());
+ for (size_t i = 0; i < config_2.rtp_extensions.size(); i++) {
+ EXPECT_EQ(config_1.rtp_extensions[i].uri, config_2.rtp_extensions[i].uri);
+ EXPECT_EQ(config_1.rtp_extensions[i].id, config_2.rtp_extensions[i].id);
+ }
+ ASSERT_EQ(config_1.codecs.size(), config_2.codecs.size());
+ for (size_t i = 0; i < config_2.codecs.size(); i++) {
+ EXPECT_EQ(config_1.codecs[i].payload_name, config_2.codecs[i].payload_name);
+ EXPECT_EQ(config_1.codecs[i].payload_type, config_2.codecs[i].payload_type);
+ EXPECT_EQ(config_1.codecs[i].rtx_payload_type,
+ config_2.codecs[i].rtx_payload_type);
+ }
+}
+
void RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
- const VideoReceiveStream::Config& config) {
+ const rtclog::StreamConfig& config) {
const rtclog::Event& event = parsed_log.events_[index];
ASSERT_TRUE(IsValidBasicEvent(event));
ASSERT_EQ(rtclog::Event::VIDEO_RECEIVER_CONFIG_EVENT, event.type());
@@ -174,12 +196,12 @@
event.video_receiver_config();
// Check SSRCs.
ASSERT_TRUE(receiver_config.has_remote_ssrc());
- EXPECT_EQ(config.rtp.remote_ssrc, receiver_config.remote_ssrc());
+ EXPECT_EQ(config.remote_ssrc, receiver_config.remote_ssrc());
ASSERT_TRUE(receiver_config.has_local_ssrc());
- EXPECT_EQ(config.rtp.local_ssrc, receiver_config.local_ssrc());
+ EXPECT_EQ(config.local_ssrc, receiver_config.local_ssrc());
// Check RTCP settings.
ASSERT_TRUE(receiver_config.has_rtcp_mode());
- if (config.rtp.rtcp_mode == RtcpMode::kCompound) {
+ if (config.rtcp_mode == RtcpMode::kCompound) {
EXPECT_EQ(rtclog::VideoReceiveConfig::RTCP_COMPOUND,
receiver_config.rtcp_mode());
} else {
@@ -187,76 +209,51 @@
receiver_config.rtcp_mode());
}
ASSERT_TRUE(receiver_config.has_remb());
- EXPECT_EQ(config.rtp.remb, receiver_config.remb());
+ EXPECT_EQ(config.remb, receiver_config.remb());
// Check RTX map.
- ASSERT_EQ(static_cast<int>(config.rtp.rtx_payload_types.size()),
- receiver_config.rtx_map_size());
for (const rtclog::RtxMap& rtx_map : receiver_config.rtx_map()) {
ASSERT_TRUE(rtx_map.has_payload_type());
ASSERT_TRUE(rtx_map.has_config());
- EXPECT_EQ(1u, config.rtp.rtx_payload_types.count(rtx_map.payload_type()));
const rtclog::RtxConfig& rtx_config = rtx_map.config();
ASSERT_TRUE(rtx_config.has_rtx_ssrc());
ASSERT_TRUE(rtx_config.has_rtx_payload_type());
- EXPECT_EQ(config.rtp.rtx_ssrc, rtx_config.rtx_ssrc());
- EXPECT_EQ(config.rtp.rtx_payload_types.at(rtx_map.payload_type()),
- rtx_config.rtx_payload_type());
+
+ EXPECT_EQ(config.rtx_ssrc, rtx_config.rtx_ssrc());
+ auto codec_found =
+ std::find_if(config.codecs.begin(), config.codecs.end(),
+ [&rtx_map](const rtclog::StreamConfig::Codec& codec) {
+ return rtx_map.payload_type() == codec.payload_type;
+ });
+ ASSERT_TRUE(codec_found != config.codecs.end());
+ EXPECT_EQ(rtx_config.rtx_payload_type(), codec_found->rtx_payload_type);
}
// Check header extensions.
- ASSERT_EQ(static_cast<int>(config.rtp.extensions.size()),
+ ASSERT_EQ(static_cast<int>(config.rtp_extensions.size()),
receiver_config.header_extensions_size());
for (int i = 0; i < receiver_config.header_extensions_size(); i++) {
ASSERT_TRUE(receiver_config.header_extensions(i).has_name());
ASSERT_TRUE(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();
- EXPECT_EQ(config.rtp.extensions[i].id, id);
- EXPECT_EQ(config.rtp.extensions[i].uri, name);
+ EXPECT_EQ(config.rtp_extensions[i].id, id);
+ EXPECT_EQ(config.rtp_extensions[i].uri, name);
}
// Check decoders.
- ASSERT_EQ(static_cast<int>(config.decoders.size()),
+ ASSERT_EQ(static_cast<int>(config.codecs.size()),
receiver_config.decoders_size());
for (int i = 0; i < receiver_config.decoders_size(); i++) {
ASSERT_TRUE(receiver_config.decoders(i).has_name());
ASSERT_TRUE(receiver_config.decoders(i).has_payload_type());
const std::string& decoder_name = receiver_config.decoders(i).name();
int decoder_type = receiver_config.decoders(i).payload_type();
- EXPECT_EQ(config.decoders[i].payload_name, decoder_name);
- EXPECT_EQ(config.decoders[i].payload_type, decoder_type);
+ EXPECT_EQ(config.codecs[i].payload_name, decoder_name);
+ EXPECT_EQ(config.codecs[i].payload_type, decoder_type);
}
// Check consistency of the parser.
- VideoReceiveStream::Config parsed_config(nullptr);
+ rtclog::StreamConfig parsed_config;
parsed_log.GetVideoReceiveConfig(index, &parsed_config);
- EXPECT_EQ(config.rtp.remote_ssrc, parsed_config.rtp.remote_ssrc);
- EXPECT_EQ(config.rtp.local_ssrc, parsed_config.rtp.local_ssrc);
- // Check RTCP settings.
- EXPECT_EQ(config.rtp.rtcp_mode, parsed_config.rtp.rtcp_mode);
- EXPECT_EQ(config.rtp.remb, parsed_config.rtp.remb);
- // Check RTX map.
- EXPECT_EQ(config.rtp.rtx_ssrc, parsed_config.rtp.rtx_ssrc);
- EXPECT_EQ(config.rtp.rtx_payload_types.size(),
- parsed_config.rtp.rtx_payload_types.size());
- for (const auto& kv : config.rtp.rtx_payload_types) {
- auto parsed_kv = parsed_config.rtp.rtx_payload_types.find(kv.first);
- EXPECT_EQ(kv.first, parsed_kv->first);
- EXPECT_EQ(kv.second, parsed_kv->second);
- }
- // Check header extensions.
- EXPECT_EQ(config.rtp.extensions.size(), parsed_config.rtp.extensions.size());
- for (size_t i = 0; i < parsed_config.rtp.extensions.size(); i++) {
- EXPECT_EQ(config.rtp.extensions[i].uri,
- parsed_config.rtp.extensions[i].uri);
- EXPECT_EQ(config.rtp.extensions[i].id, parsed_config.rtp.extensions[i].id);
- }
- // Check decoders.
- EXPECT_EQ(config.decoders.size(), parsed_config.decoders.size());
- for (size_t i = 0; i < parsed_config.decoders.size(); i++) {
- EXPECT_EQ(config.decoders[i].payload_name,
- parsed_config.decoders[i].payload_name);
- EXPECT_EQ(config.decoders[i].payload_type,
- parsed_config.decoders[i].payload_type);
- }
+ VerifyStreamConfigsAreEqual(config, parsed_config);
}
void RtcEventLogTestHelper::VerifyVideoSendStreamConfig(
diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.h b/logging/rtc_event_log/rtc_event_log_unittest_helper.h
index 235d112..301d496 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest_helper.h
+++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.h
@@ -21,7 +21,7 @@
static void VerifyVideoReceiveStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
- const VideoReceiveStream::Config& config);
+ const rtclog::StreamConfig& config);
static void VerifyVideoSendStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
diff --git a/tools/event_log_visualizer/analyzer.cc b/tools/event_log_visualizer/analyzer.cc
index 5ff0e58..3bf9764 100644
--- a/tools/event_log_visualizer/analyzer.cc
+++ b/tools/event_log_visualizer/analyzer.cc
@@ -331,14 +331,14 @@
switch (parsed_log_.GetEventType(i)) {
case ParsedRtcEventLog::VIDEO_RECEIVER_CONFIG_EVENT: {
- VideoReceiveStream::Config config(nullptr);
+ rtclog::StreamConfig config;
parsed_log_.GetVideoReceiveConfig(i, &config);
- StreamId stream(config.rtp.remote_ssrc, kIncomingPacket);
- extension_maps[stream] = RtpHeaderExtensionMap(config.rtp.extensions);
+ StreamId stream(config.remote_ssrc, kIncomingPacket);
+ extension_maps[stream] = RtpHeaderExtensionMap(config.rtp_extensions);
video_ssrcs_.insert(stream);
- StreamId rtx_stream(config.rtp.rtx_ssrc, kIncomingPacket);
+ StreamId rtx_stream(config.rtx_ssrc, kIncomingPacket);
extension_maps[rtx_stream] =
- RtpHeaderExtensionMap(config.rtp.extensions);
+ RtpHeaderExtensionMap(config.rtp_extensions);
video_ssrcs_.insert(rtx_stream);
rtx_ssrcs_.insert(rtx_stream);
break;
diff --git a/voice_engine/channel.cc b/voice_engine/channel.cc
index 6f01725..3aeca5f 100644
--- a/voice_engine/channel.cc
+++ b/voice_engine/channel.cc
@@ -76,11 +76,8 @@
void StopLogging() override { RTC_NOTREACHED(); }
void LogVideoReceiveStreamConfig(
- const webrtc::VideoReceiveStream::Config& config) override {
- rtc::CritScope lock(&crit_);
- if (event_log_) {
- event_log_->LogVideoReceiveStreamConfig(config);
- }
+ const webrtc::rtclog::StreamConfig&) override {
+ RTC_NOTREACHED();
}
void LogVideoSendStreamConfig(
