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

Replace AudioReceiveStream::Config with rtclog::StreamConfig.

Browse Source 
BUG=webrtc:7538

Review-Url: https://codereview.webrtc.org/2851303007
Cr-Commit-Position: refs/heads/master@{#18223}
This commit is contained in:
perkj
2017-05-22 09:36:28 -07:00
committed by Commit bot
parent 3ec96df907
commit ac8f52de70
12 changed files with 54 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
webrtc/call/call.cc
View File

@ -124,6 +124,15 @@ rtclog::StreamConfig CreateRtcLogStreamConfig(
return rtclog_config;
}
rtclog::StreamConfig CreateRtcLogStreamConfig(
const AudioReceiveStream::Config& config) {
rtclog::StreamConfig rtclog_config;
rtclog_config.remote_ssrc = config.rtp.remote_ssrc;
rtclog_config.local_ssrc = config.rtp.local_ssrc;
rtclog_config.rtp_extensions = config.rtp.extensions;
return rtclog_config;
}
} // namespace
namespace internal {
@ -594,7 +603,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);
event_log_->LogAudioReceiveStreamConfig(CreateRtcLogStreamConfig(config));
AudioReceiveStream* receive_stream =
new AudioReceiveStream(transport_send_->packet_router(), config,
config_.audio_state, event_log_);

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

@ -36,7 +36,7 @@ class MockRtcEventLog : public RtcEventLog {
void(const rtclog::StreamConfig& config));
MOCK_METHOD1(LogAudioReceiveStreamConfig,
void(const webrtc::AudioReceiveStream::Config& config));
void(const rtclog::StreamConfig& config));
MOCK_METHOD1(LogAudioSendStreamConfig,
void(const webrtc::AudioSendStream::Config& config));

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

@ -64,8 +64,7 @@ class RtcEventLogImpl final : public RtcEventLog {
void StopLogging() override;
void LogVideoReceiveStreamConfig(const rtclog::StreamConfig& config) override;
void LogVideoSendStreamConfig(const rtclog::StreamConfig& config) override;
void LogAudioReceiveStreamConfig(
const AudioReceiveStream::Config& config) override;
void LogAudioReceiveStreamConfig(const rtclog::StreamConfig& config) override;
void LogAudioSendStreamConfig(const AudioSendStream::Config& config) override;
void LogRtpHeader(PacketDirection direction,
MediaType media_type,
@ -351,17 +350,17 @@ void RtcEventLogImpl::LogVideoSendStreamConfig(
}
void RtcEventLogImpl::LogAudioReceiveStreamConfig(
const AudioReceiveStream::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::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);
receiver_config->set_remote_ssrc(config.remote_ssrc);
receiver_config->set_local_ssrc(config.local_ssrc);
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);

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

@ -119,9 +119,9 @@ class RtcEventLog {
// Logs configuration information for a video send stream.
virtual void LogVideoSendStreamConfig(const rtclog::StreamConfig& config) = 0;
// Logs configuration information for webrtc::AudioReceiveStream.
// Logs configuration information for an audio receive stream.
virtual void LogAudioReceiveStreamConfig(
const webrtc::AudioReceiveStream::Config& config) = 0;
const rtclog::StreamConfig& config) = 0;
// Logs configuration information for webrtc::AudioSendStream.
virtual void LogAudioSendStreamConfig(
@ -202,7 +202,7 @@ class RtcEventLogNullImpl final : public RtcEventLog {
const rtclog::StreamConfig& config) override {}
void LogVideoSendStreamConfig(const rtclog::StreamConfig& config) override {}
void LogAudioReceiveStreamConfig(
const AudioReceiveStream::Config& config) override {}
const rtclog::StreamConfig& config) override {}
void LogAudioSendStreamConfig(
const AudioSendStream::Config& config) override {}
void LogRtpHeader(PacketDirection direction,

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

@ -399,18 +399,18 @@ int main(int argc, char* argv[]) {
}
if (parsed_stream.GetEventType(i) ==
webrtc::ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT) {
webrtc::AudioReceiveStream::Config config;
webrtc::rtclog::StreamConfig config;
parsed_stream.GetAudioReceiveConfig(i, &config);
global_streams.emplace_back(config.rtp.remote_ssrc,
global_streams.emplace_back(config.remote_ssrc,
webrtc::MediaType::AUDIO,
webrtc::kIncomingPacket);
global_streams.emplace_back(config.rtp.local_ssrc,
global_streams.emplace_back(config.local_ssrc,
webrtc::MediaType::AUDIO,
webrtc::kOutgoingPacket);
if (!FLAGS_noconfig && !FLAGS_noaudio && !FLAGS_noincoming) {
std::cout << parsed_stream.GetTimestamp(i) << "\tAUDIO_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) ==

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

@ -417,7 +417,7 @@ void ParsedRtcEventLog::GetVideoSendConfig(size_t index,
void ParsedRtcEventLog::GetAudioReceiveConfig(
size_t index,
AudioReceiveStream::Config* config) const {
rtclog::StreamConfig* config) const {
RTC_CHECK_LT(index, GetNumberOfEvents());
const rtclog::Event& event = events_[index];
RTC_CHECK(config != nullptr);
@ -428,11 +428,11 @@ void ParsedRtcEventLog::GetAudioReceiveConfig(
event.audio_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();
// Get header extensions.
GetHeaderExtensions(&config->rtp.extensions,
GetHeaderExtensions(&config->rtp_extensions,
receiver_config.header_extensions());
}

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

@ -122,10 +122,9 @@ class ParsedRtcEventLog {
// Only the fields that are stored in the protobuf will be written.
void GetVideoSendConfig(size_t index, rtclog::StreamConfig* config) const;
// Reads a config event to a (non-NULL) AudioReceiveStream::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 GetAudioReceiveConfig(size_t index,
AudioReceiveStream::Config* config) const;
void GetAudioReceiveConfig(size_t index, rtclog::StreamConfig* 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.

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

@ -191,15 +191,15 @@ void GenerateVideoSendConfig(uint32_t extensions_bitvector,
}
void GenerateAudioReceiveConfig(uint32_t extensions_bitvector,
AudioReceiveStream::Config* config,
rtclog::StreamConfig* config,
Random* prng) {
// 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 header extensions.
for (unsigned i = 0; i < kNumExtensions; i++) {
if (extensions_bitvector & (1u << i)) {
config->rtp.extensions.push_back(
config->rtp_extensions.push_back(
RtpExtension(kExtensionNames[i], prng->Rand<int>()));
}
}
@ -783,7 +783,7 @@ class AudioReceiveConfigReadWriteTest : public ConfigReadWriteTest {
RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(parsed_log, index,
config);
}
AudioReceiveStream::Config config;
rtclog::StreamConfig config;
};
class AudioSendConfigReadWriteTest : public ConfigReadWriteTest {

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

@ -299,7 +299,7 @@ void RtcEventLogTestHelper::VerifyVideoSendStreamConfig(
void RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
const AudioReceiveStream::Config& config) {
const rtclog::StreamConfig& config) {
const rtclog::Event& event = parsed_log.events_[index];
ASSERT_TRUE(IsValidBasicEvent(event));
ASSERT_EQ(rtclog::Event::AUDIO_RECEIVER_CONFIG_EVENT, event.type());
@ -307,32 +307,32 @@ void RtcEventLogTestHelper::VerifyAudioReceiveStreamConfig(
event.audio_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 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 consistency of the parser.
AudioReceiveStream::Config parsed_config;
rtclog::StreamConfig 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);
EXPECT_EQ(config.remote_ssrc, parsed_config.remote_ssrc);
EXPECT_EQ(config.local_ssrc, parsed_config.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);
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);
}
}

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

@ -28,7 +28,7 @@ class RtcEventLogTestHelper {
static void VerifyAudioReceiveStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,
const AudioReceiveStream::Config& config);
const rtclog::StreamConfig& config);
static void VerifyAudioSendStreamConfig(
const ParsedRtcEventLog& parsed_log,
size_t index,

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

@ -357,10 +357,10 @@ EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log)
break;
}
case ParsedRtcEventLog::AUDIO_RECEIVER_CONFIG_EVENT: {
AudioReceiveStream::Config config;
rtclog::StreamConfig config;
parsed_log_.GetAudioReceiveConfig(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);
audio_ssrcs_.insert(stream);
break;
}

2
webrtc/voice_engine/channel.cc
View File

@ -85,7 +85,7 @@ class RtcEventLogProxy final : public webrtc::RtcEventLog {
}
void LogAudioReceiveStreamConfig(
const webrtc::AudioReceiveStream::Config& config) override {
const webrtc::rtclog::StreamConfig& config) override {
rtc::CritScope lock(&crit_);
if (event_log_) {
event_log_->LogAudioReceiveStreamConfig(config);