admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
BUG=webrtc:7538

Review-Url: https://codereview.webrtc.org/2850793002
Cr-Commit-Position: refs/heads/master@{#18220}
This commit is contained in:
perkj 2017-05-22 03:26:49 -07:00 committed by Commit bot
parent d4aebb0d1f
commit 09e71daec5
12 changed files with 169 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
webrtc/call/call.cc
View File

@ -88,6 +88,25 @@ bool UseSendSideBwe(const FlexfecReceiveStream::Config& config) {
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 @@ webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
}
receive_stream->SignalNetworkState(video_network_state_);
UpdateAggregateNetworkState();
event_log_->LogVideoReceiveStreamConfig(config);
event_log_->LogVideoReceiveStreamConfig(CreateRtcLogStreamConfig(config));
return receive_stream;
}

2
webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h
View File

@ -30,7 +30,7 @@ class MockRtcEventLog : public RtcEventLog {
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));

31
webrtc/logging/rtc_event_log/rtc_event_log.cc
View File

@ -62,8 +62,7 @@ class RtcEventLogImpl final : public RtcEventLog {
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::StopLogging() {
}
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);
}

34
webrtc/logging/rtc_event_log/rtc_event_log.h
View File

@ -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 @@ namespace webrtc {
// 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 @@ class RtcEventLog {
// 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 @@ class RtcEventLogNullImpl final : public RtcEventLog {
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(

10
webrtc/logging/rtc_event_log/rtc_event_log2text.cc
View File

@ -364,20 +364,20 @@ int main(int argc, char* argv[]) {
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) ==

58
webrtc/logging/rtc_event_log/rtc_event_log_parser.cc
View File

@ -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::GetRtcpPacket(size_t index,
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 @@ void ParsedRtcEventLog::GetVideoReceiveConfig(
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);
}
}

5
webrtc/logging/rtc_event_log/rtc_event_log_parser.h
View File

@ -114,10 +114,9 @@ class ParsedRtcEventLog {
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.

32
webrtc/logging/rtc_event_log/rtc_event_log_unittest.cc
View File

@ -153,29 +153,23 @@ rtc::Buffer GenerateRtcpPacket(Random* prng) {
}
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 @@ void LogSessionAndReadBack(size_t rtp_count,
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 AudioSendConfigReadWriteTest : public ConfigReadWriteTest {
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 @@ class VideoReceiveConfigReadWriteTest : public ConfigReadWriteTest {
RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, index,
config);
}
VideoReceiveStream::Config config;
rtclog::StreamConfig config;
};
class VideoSendConfigReadWriteTest : public ConfigReadWriteTest {

91
webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
View File

@ -163,10 +163,32 @@ rtclog::BweProbeResult::ResultType GetProbeResultType(
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 @@ void RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(
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 @@ void RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(
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(

2
webrtc/logging/rtc_event_log/rtc_event_log_unittest_helper.h
View File

@ -21,7 +21,7 @@ class RtcEventLogTestHelper {
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,

10
webrtc/tools/event_log_visualizer/analyzer.cc
View File

@ -331,14 +331,14 @@ EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log)
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;

7
webrtc/voice_engine/channel.cc
View File

@ -76,11 +76,8 @@ class RtcEventLogProxy final : public webrtc::RtcEventLog {
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(