zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added logging for audio send/receive stream configs.

Browse Source 
BUG=webrtc:4741,webrtc:6399

Review-Url: https://codereview.webrtc.org/2353543003
Cr-Commit-Position: refs/heads/master@{#14585}
This commit is contained in:
ivoc
2016-10-10 05:12:51 -07:00
committed by Commit bot
parent fc9414ab51
commit e0928d8002
11 changed files with 415 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
webrtc/call/call.cc
View File

@ -370,6 +370,7 @@ webrtc::AudioSendStream* Call::CreateAudioSendStream(
const webrtc::AudioSendStream::Config& config) {
TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream");
RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
event_log_->LogAudioSendStreamConfig(config);
AudioSendStream* send_stream = new AudioSendStream(
config, config_.audio_state, &worker_queue_, congestion_controller_.get(),
bitrate_allocator_.get(), event_log_);
@ -407,6 +408,7 @@ webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream(
const webrtc::AudioReceiveStream::Config& config) {
TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
event_log_->LogAudioReceiveStreamConfig(config);
AudioReceiveStream* receive_stream = new AudioReceiveStream(
congestion_controller_.get(), config, config_.audio_state, event_log_);
{

6
webrtc/call/mock/mock_rtc_event_log.h
View File

@ -34,6 +34,12 @@ class MockRtcEventLog : public RtcEventLog {
MOCK_METHOD1(LogVideoSendStreamConfig,
void(const webrtc::VideoSendStream::Config& config));
MOCK_METHOD1(LogAudioReceiveStreamConfig,
void(const webrtc::AudioReceiveStream::Config& config));
MOCK_METHOD1(LogAudioSendStreamConfig,
void(const webrtc::AudioSendStream::Config& config));
MOCK_METHOD4(LogRtpHeader,
void(PacketDirection direction,
MediaType media_type,

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

@ -62,6 +62,9 @@ class RtcEventLogImpl final : public RtcEventLog {
void LogVideoReceiveStreamConfig(
const VideoReceiveStream::Config& config) override;
void LogVideoSendStreamConfig(const VideoSendStream::Config& config) override;
void LogAudioReceiveStreamConfig(
const AudioReceiveStream::Config& config) override;
void LogAudioSendStreamConfig(const AudioSendStream::Config& config) override;
void LogRtpHeader(PacketDirection direction,
MediaType media_type,
const uint8_t* header,
@ -292,6 +295,46 @@ void RtcEventLogImpl::LogVideoSendStreamConfig(
StoreEvent(&event);
}
void RtcEventLogImpl::LogAudioReceiveStreamConfig(
const AudioReceiveStream::Config& config) {
std::unique_ptr<rtclog::Event> event(new rtclog::Event());
event->set_timestamp_us(clock_->TimeInMicroseconds());
event->set_type(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT);
rtclog::AudioReceiveConfig* receiver_config =
event->mutable_audio_receiver_config();
receiver_config->set_remote_ssrc(config.rtp.remote_ssrc);
receiver_config->set_local_ssrc(config.rtp.local_ssrc);
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);
}
StoreEvent(&event);
}
void RtcEventLogImpl::LogAudioSendStreamConfig(
const AudioSendStream::Config& config) {
std::unique_ptr<rtclog::Event> event(new rtclog::Event());
event->set_timestamp_us(clock_->TimeInMicroseconds());
event->set_type(rtclog::Event::AUDIO_SENDER_CONFIG_EVENT);
rtclog::AudioSendConfig* sender_config = event->mutable_audio_sender_config();
sender_config->set_ssrc(config.rtp.ssrc);
for (const auto& e : config.rtp.extensions) {
rtclog::RtpHeaderExtension* extension =
sender_config->add_header_extensions();
extension->set_name(e.uri);
extension->set_id(e.id);
}
StoreEvent(&event);
}
void RtcEventLogImpl::LogRtpHeader(PacketDirection direction,
MediaType media_type,
const uint8_t* header,

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

@ -14,6 +14,8 @@
#include <memory>
#include <string>
#include "webrtc/api/call/audio_receive_stream.h"
#include "webrtc/api/call/audio_send_stream.h"
#include "webrtc/base/platform_file.h"
#include "webrtc/video_receive_stream.h"
#include "webrtc/video_send_stream.h"
@ -77,6 +79,14 @@ class RtcEventLog {
virtual void LogVideoSendStreamConfig(
const webrtc::VideoSendStream::Config& config) = 0;
// Logs configuration information for webrtc::AudioReceiveStream.
virtual void LogAudioReceiveStreamConfig(
const webrtc::AudioReceiveStream::Config& config) = 0;
// Logs configuration information for webrtc::AudioSendStream.
virtual void LogAudioSendStreamConfig(
const webrtc::AudioSendStream::Config& config) = 0;
// Logs the header of an incoming or outgoing RTP packet. packet_length
// is the total length of the packet, including both header and payload.
virtual void LogRtpHeader(PacketDirection direction,
@ -123,6 +133,10 @@ class RtcEventLogNullImpl final : public RtcEventLog {
const VideoReceiveStream::Config& config) override {}
void LogVideoSendStreamConfig(
const VideoSendStream::Config& config) override {}
void LogAudioReceiveStreamConfig(
const AudioReceiveStream::Config& config) override {}
void LogAudioSendStreamConfig(
const AudioSendStream::Config& config) override {}
void LogRtpHeader(PacketDirection direction,
MediaType media_type,
const uint8_t* header,

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

@ -104,6 +104,20 @@ std::pair<uint64_t, bool> ParseVarInt(std::istream& stream) {
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) {
@ -311,14 +325,8 @@ void ParsedRtcEventLog::GetVideoReceiveConfig(
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++) {
@ -347,14 +355,8 @@ void ParsedRtcEventLog::GetVideoSendConfig(
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++) {
@ -376,6 +378,45 @@ void ParsedRtcEventLog::GetVideoSendConfig(
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];

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

@ -99,6 +99,15 @@ class ParsedRtcEventLog {
// Only the fields that are stored in the protobuf will be written.
void GetVideoSendConfig(size_t index, VideoSendStream::Config* config) const;
// Reads a config event to a (non-NULL) AudioReceiveStream::Config struct.
// Only the fields that are stored in the protobuf will be written.
void GetAudioReceiveConfig(size_t index,
AudioReceiveStream::Config* config) const;
// Reads a config event to a (non-NULL) AudioSendStream::Config struct.
// Only the fields that are stored in the protobuf will be written.
void GetAudioSendConfig(size_t index, AudioSendStream::Config* config) const;
// Reads the SSRC from the audio playout event at |index|. The SSRC is stored
// in the output parameter ssrc. The output parameter can be set to nullptr
// and in that case the function only asserts that the event is well formed.

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

@ -200,6 +200,35 @@ void GenerateVideoSendConfig(uint32_t extensions_bitvector,
}
}
void GenerateAudioReceiveConfig(uint32_t extensions_bitvector,
AudioReceiveStream::Config* config,
Random* prng) {
// Add SSRCs for the stream.
config->rtp.remote_ssrc = prng->Rand<uint32_t>();
config->rtp.local_ssrc = prng->Rand<uint32_t>();
// 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>()));
}
}
}
void GenerateAudioSendConfig(uint32_t extensions_bitvector,
AudioSendStream::Config* config,
Random* prng) {
// Add SSRC to the stream.
config->rtp.ssrc = prng->Rand<uint32_t>();
// 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>()));
}
}
}
// Test for the RtcEventLog class. Dumps some RTP packets and other events
// to disk, then reads them back to see if they match.
void LogSessionAndReadBack(size_t rtp_count,
@ -324,9 +353,10 @@ void LogSessionAndReadBack(size_t rtp_count,
PrintExpectedEvents(rtp_count, rtcp_count, playout_count, bwe_loss_count);
}
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
RtcEventLogTestHelper::VerifyReceiveStreamConfig(parsed_log, 1,
receiver_config);
RtcEventLogTestHelper::VerifySendStreamConfig(parsed_log, 2, sender_config);
RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, 1,
receiver_config);
RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, 2,
sender_config);
size_t event_index = config_count + 1;
size_t rtcp_index = 1;
size_t playout_index = 1;
@ -457,4 +487,138 @@ TEST(RtcEventLogTest, LogEventAndReadBack) {
remove(temp_filename.c_str());
}
class ConfigReadWriteTest {
public:
ConfigReadWriteTest() : prng(987654321) {}
virtual ~ConfigReadWriteTest() {}
virtual void GenerateConfig(uint32_t extensions_bitvector) = 0;
virtual void VerifyConfig(const ParsedRtcEventLog& parsed_log,
size_t index) = 0;
virtual void LogConfig(RtcEventLog* event_log) = 0;
void DoTest() {
// Find the name of the current test, in order to use it as a temporary
// filename.
auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
const std::string temp_filename =
test::OutputPath() + test_info->test_case_name() + test_info->name();
// Use all extensions.
uint32_t extensions_bitvector = (1u << kNumExtensions) - 1;
GenerateConfig(extensions_bitvector);
// Log a single config event and stop logging.
SimulatedClock fake_clock(prng.Rand<uint32_t>());
std::unique_ptr<RtcEventLog> log_dumper(RtcEventLog::Create(&fake_clock));
log_dumper->StartLogging(temp_filename, 10000000);
LogConfig(log_dumper.get());
log_dumper->StopLogging();
// Read the generated file from disk.
ParsedRtcEventLog parsed_log;
ASSERT_TRUE(parsed_log.ParseFile(temp_filename));
// Check the generated number of events.
EXPECT_EQ(3u, parsed_log.GetNumberOfEvents());
RtcEventLogTestHelper::VerifyLogStartEvent(parsed_log, 0);
// Verify that the parsed config struct matches the one that was logged.
VerifyConfig(parsed_log, 1);
RtcEventLogTestHelper::VerifyLogEndEvent(parsed_log, 2);
// Clean up temporary file - can be pretty slow.
remove(temp_filename.c_str());
}
Random prng;
};
class AudioReceiveConfigReadWriteTest : public ConfigReadWriteTest {
public:
void GenerateConfig(uint32_t extensions_bitvector) override {
GenerateAudioReceiveConfig(extensions_bitvector, &config, &prng);
}
void LogConfig(RtcEventLog* event_log) override {
event_log->LogAudioReceiveStreamConfig(config);
}
void VerifyConfig(const ParsedRtcEventLog& parsed_log,
size_t index) override {
RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(parsed_log, index,
config);
}
AudioReceiveStream::Config config;
};
class AudioSendConfigReadWriteTest : public ConfigReadWriteTest {
public:
AudioSendConfigReadWriteTest() : config(nullptr) {}
void GenerateConfig(uint32_t extensions_bitvector) override {
GenerateAudioSendConfig(extensions_bitvector, &config, &prng);
}
void LogConfig(RtcEventLog* event_log) override {
event_log->LogAudioSendStreamConfig(config);
}
void VerifyConfig(const ParsedRtcEventLog& parsed_log,
size_t index) override {
RtcEventLogTestHelper::VerifyAudioSendStreamConfig(parsed_log, index,
config);
}
AudioSendStream::Config config;
};
class VideoReceiveConfigReadWriteTest : public ConfigReadWriteTest {
public:
VideoReceiveConfigReadWriteTest() : config(nullptr) {}
void GenerateConfig(uint32_t extensions_bitvector) override {
GenerateVideoReceiveConfig(extensions_bitvector, &config, &prng);
}
void LogConfig(RtcEventLog* event_log) override {
event_log->LogVideoReceiveStreamConfig(config);
}
void VerifyConfig(const ParsedRtcEventLog& parsed_log,
size_t index) override {
RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(parsed_log, index,
config);
}
VideoReceiveStream::Config config;
};
class VideoSendConfigReadWriteTest : public ConfigReadWriteTest {
public:
VideoSendConfigReadWriteTest() : config(nullptr) {}
void GenerateConfig(uint32_t extensions_bitvector) override {
GenerateVideoSendConfig(extensions_bitvector, &config, &prng);
}
void LogConfig(RtcEventLog* event_log) override {
event_log->LogVideoSendStreamConfig(config);
}
void VerifyConfig(const ParsedRtcEventLog& parsed_log,
size_t index) override {
RtcEventLogTestHelper::VerifyVideoSendStreamConfig(parsed_log, index,
config);
}
VideoSendStream::Config config;
};
TEST(RtcEventLogTest, LogAudioReceiveConfig) {
AudioReceiveConfigReadWriteTest test;
test.DoTest();
}
TEST(RtcEventLogTest, LogAudioSendConfig) {
AudioSendConfigReadWriteTest test;
test.DoTest();
}
TEST(RtcEventLogTest, LogVideoReceiveConfig) {
VideoReceiveConfigReadWriteTest test;
test.DoTest();
}
TEST(RtcEventLogTest, LogVideoSendConfig) {
VideoSendConfigReadWriteTest test;
test.DoTest();
}
} // namespace webrtc

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

@ -102,7 +102,7 @@ MediaType GetRuntimeMediaType(rtclog::MediaType media_type) {
return ::testing::AssertionSuccess();
}
void RtcEventLogTestHelper::VerifyReceiveStreamConfig(
void RtcEventLogTestHelper::VerifyVideoReceiveStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
const VideoReceiveStream::Config& config) {
@ -198,7 +198,7 @@ void RtcEventLogTestHelper::VerifyReceiveStreamConfig(
}
}
void RtcEventLogTestHelper::VerifySendStreamConfig(
void RtcEventLogTestHelper::VerifyVideoSendStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
const VideoSendStream::Config& config) {
@ -270,6 +270,82 @@ void RtcEventLogTestHelper::VerifySendStreamConfig(
parsed_config.encoder_settings.payload_type);
}
void RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
const AudioReceiveStream::Config& config) {
const rtclog::Event& event = parsed_log.events_[index];
ASSERT_TRUE(IsValidBasicEvent(event));
ASSERT_EQ(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT, event.type());
const rtclog::AudioReceiveConfig& receiver_config =
event.audio_receiver_config();
// Check SSRCs.
ASSERT_TRUE(receiver_config.has_remote_ssrc());
EXPECT_EQ(config.rtp.remote_ssrc, receiver_config.remote_ssrc());
ASSERT_TRUE(receiver_config.has_local_ssrc());
EXPECT_EQ(config.rtp.local_ssrc, receiver_config.local_ssrc());
// Check header extensions.
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);
}
// Check consistency of the parser.
AudioReceiveStream::Config parsed_config;
parsed_log.GetAudioReceiveConfig(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 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);
}
}
void RtcEventLogTestHelper::VerifyAudioSendStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
const AudioSendStream::Config& config) {
const rtclog::Event& event = parsed_log.events_[index];
ASSERT_TRUE(IsValidBasicEvent(event));
ASSERT_EQ(rtclog::Event::AUDIO_SENDER_CONFIG_EVENT, event.type());
const rtclog::AudioSendConfig& sender_config = event.audio_sender_config();
// Check SSRCs.
EXPECT_EQ(config.rtp.ssrc, sender_config.ssrc());
// Check header extensions.
ASSERT_EQ(static_cast<int>(config.rtp.extensions.size()),
sender_config.header_extensions_size());
for (int i = 0; i < sender_config.header_extensions_size(); i++) {
ASSERT_TRUE(sender_config.header_extensions(i).has_name());
ASSERT_TRUE(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();
EXPECT_EQ(config.rtp.extensions[i].id, id);
EXPECT_EQ(config.rtp.extensions[i].uri, name);
}
// Check consistency of the parser.
AudioSendStream::Config parsed_config(nullptr);
parsed_log.GetAudioSendConfig(index, &parsed_config);
// Check SSRCs
EXPECT_EQ(config.rtp.ssrc, parsed_config.rtp.ssrc);
// 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);
}
}
void RtcEventLogTestHelper::VerifyRtpEvent(const ParsedRtcEventLog& parsed_log,
size_t index,
PacketDirection direction,

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

@ -18,13 +18,22 @@ namespace webrtc {
class RtcEventLogTestHelper {
public:
static void VerifyReceiveStreamConfig(
static void VerifyVideoReceiveStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
const VideoReceiveStream::Config& config);
static void VerifySendStreamConfig(const ParsedRtcEventLog& parsed_log,
size_t index,
const VideoSendStream::Config& config);
static void VerifyVideoSendStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
const VideoSendStream::Config& config);
static void VerifyAudioReceiveStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
const AudioReceiveStream::Config& config);
static void VerifyAudioSendStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
const AudioSendStream::Config& config);
static void VerifyRtpEvent(const ParsedRtcEventLog& parsed_log,
size_t index,
PacketDirection direction,

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

@ -353,12 +353,20 @@ EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log)
}
case ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT: {
AudioReceiveStream::Config config;
// TODO(terelius): Parse the audio configs once we have them.
parsed_log_.GetAudioReceiveConfig(i, &config);
StreamId stream(config.rtp.remote_ssrc, kIncomingPacket);
RegisterHeaderExtensions(config.rtp.extensions,
&extension_maps[stream]);
audio_ssrcs_.insert(stream);
break;
}
case ParsedRtcEventLog::AUDIO_SENDER_CONFIG_EVENT: {
AudioSendStream::Config config(nullptr);
// TODO(terelius): Parse the audio configs once we have them.
parsed_log_.GetAudioSendConfig(i, &config);
StreamId stream(config.rtp.ssrc, kOutgoingPacket);
RegisterHeaderExtensions(config.rtp.extensions,
&extension_maps[stream]);
audio_ssrcs_.insert(stream);
break;
}
case ParsedRtcEventLog::RTP_EVENT: {

16
webrtc/voice_engine/channel.cc
View File

@ -94,6 +94,22 @@ class RtcEventLogProxy final : public webrtc::RtcEventLog {
}
}
void LogAudioReceiveStreamConfig(
const webrtc::AudioReceiveStream::Config& config) override {
rtc::CritScope lock(&crit_);
if (event_log_) {
event_log_->LogAudioReceiveStreamConfig(config);
}
}
void LogAudioSendStreamConfig(
const webrtc::AudioSendStream::Config& config) override {
rtc::CritScope lock(&crit_);
if (event_log_) {
event_log_->LogAudioSendStreamConfig(config);
}
}
void LogRtpHeader(webrtc::PacketDirection direction,
webrtc::MediaType media_type,
const uint8_t* header,