Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(249)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: webrtc/test/call_test.cc

Issue 2997883002: Video/Screenshare loopback tool.
Patch Set: Rebase Created 3 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/test/call_test.h ('k') | webrtc/test/fake_network_pipe.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/test/call_test.cc
diff --git a/webrtc/test/call_test.cc b/webrtc/test/call_test.cc
index 3efc022cee7fd75407b6b2a9f0a688e5dd738212..d6f25378c811d0b02f3fa3630f319a428649c13b 100644
--- a/webrtc/test/call_test.cc
+++ b/webrtc/test/call_test.cc
@@ -32,7 +32,7 @@ const int kVideoRotationRtpExtensionId = 4;
CallTest::CallTest()
: clock_(Clock::GetRealTimeClock()),
- event_log_(RtcEventLog::CreateNull()),
+ event_log_(RtcEventLog::Create()),
sender_call_transport_controller_(nullptr),
video_send_config_(nullptr),
video_send_stream_(nullptr),
@@ -46,7 +46,13 @@ CallTest::CallTest()
encoder_factory_(CreateBuiltinAudioEncoderFactory()),
task_queue_("CallTestTaskQueue"),
fake_send_audio_device_(nullptr),
- fake_recv_audio_device_(nullptr) {}
+ fake_recv_audio_device_(nullptr) {
+ int64_t now_ms = clock_->TimeInMilliseconds();
+ std::stringstream ss;
+ ss << "/usr/local/google/home/philipel/temp/vs_stuff/event_logs/" << now_ms
+ << ".log";
+ event_log_->StartLogging(ss.str(), 1000000000);
+}
CallTest::~CallTest() {
task_queue_.SendTask([this]() {
@@ -57,113 +63,117 @@ CallTest::~CallTest() {
}
void CallTest::RunBaseTest(BaseTest* test) {
- task_queue_.SendTask([this, test]() {
- num_video_streams_ = test->GetNumVideoStreams();
- num_audio_streams_ = test->GetNumAudioStreams();
- num_flexfec_streams_ = test->GetNumFlexfecStreams();
- RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0);
- Call::Config send_config(test->GetSenderCallConfig());
- if (num_audio_streams_ > 0) {
- CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer());
- test->OnFakeAudioDevicesCreated(fake_send_audio_device_.get(),
- fake_recv_audio_device_.get());
- apm_send_ = AudioProcessing::Create();
- apm_recv_ = AudioProcessing::Create();
- CreateVoiceEngines();
- AudioState::Config audio_state_config;
- audio_state_config.voice_engine = voe_send_.voice_engine;
- audio_state_config.audio_mixer = AudioMixerImpl::Create();
- audio_state_config.audio_processing = apm_send_;
- send_config.audio_state = AudioState::Create(audio_state_config);
- }
- CreateSenderCall(send_config);
- if (sender_call_transport_controller_ != nullptr) {
- test->OnRtpTransportControllerSendCreated(
- sender_call_transport_controller_);
- }
- if (test->ShouldCreateReceivers()) {
- Call::Config recv_config(test->GetReceiverCallConfig());
- if (num_audio_streams_ > 0) {
- AudioState::Config audio_state_config;
- audio_state_config.voice_engine = voe_recv_.voice_engine;
- audio_state_config.audio_mixer = AudioMixerImpl::Create();
- audio_state_config.audio_processing = apm_recv_;
- recv_config.audio_state = AudioState::Create(audio_state_config);
- }
- CreateReceiverCall(recv_config);
- }
- test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
- receive_transport_.reset(test->CreateReceiveTransport(&task_queue_));
- send_transport_.reset(
- test->CreateSendTransport(&task_queue_, sender_call_.get()));
-
- if (test->ShouldCreateReceivers()) {
- send_transport_->SetReceiver(receiver_call_->Receiver());
- receive_transport_->SetReceiver(sender_call_->Receiver());
- if (num_video_streams_ > 0)
- receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
- if (num_audio_streams_ > 0)
- receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp);
- } else {
- // Sender-only call delivers to itself.
- send_transport_->SetReceiver(sender_call_->Receiver());
- receive_transport_->SetReceiver(nullptr);
- }
-
- CreateSendConfig(num_video_streams_, num_audio_streams_,
- num_flexfec_streams_, send_transport_.get());
- if (test->ShouldCreateReceivers()) {
- CreateMatchingReceiveConfigs(receive_transport_.get());
- }
- if (num_video_streams_ > 0) {
- test->ModifyVideoConfigs(&video_send_config_, &video_receive_configs_,
- &video_encoder_config_);
- }
- if (num_audio_streams_ > 0) {
- test->ModifyAudioConfigs(&audio_send_config_, &audio_receive_configs_);
- }
- if (num_flexfec_streams_ > 0) {
- test->ModifyFlexfecConfigs(&flexfec_receive_configs_);
- }
-
- if (num_flexfec_streams_ > 0) {
- CreateFlexfecStreams();
- test->OnFlexfecStreamsCreated(flexfec_receive_streams_);
- }
- if (num_video_streams_ > 0) {
- CreateVideoStreams();
- test->OnVideoStreamsCreated(video_send_stream_, video_receive_streams_);
- }
- if (num_audio_streams_ > 0) {
- CreateAudioStreams();
- test->OnAudioStreamsCreated(audio_send_stream_, audio_receive_streams_);
- }
-
- if (num_video_streams_ > 0) {
- int width = kDefaultWidth;
- int height = kDefaultHeight;
- int frame_rate = kDefaultFramerate;
- test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate);
- CreateFrameGeneratorCapturer(frame_rate, width, height);
- test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get());
- }
-
- Start();
- });
-
- test->PerformTest();
-
- task_queue_.SendTask([this]() {
- Stop();
- DestroyStreams();
- send_transport_.reset();
- receive_transport_.reset();
- DestroyCalls();
- if (num_audio_streams_ > 0)
- DestroyVoiceEngines();
- });
-
- test->OnTestFinished();
+ // num_video_streams_ = test->GetNumVideoStreams();
+ // num_audio_streams_ = test->GetNumAudioStreams();
+ // num_flexfec_streams_ = test->GetNumFlexfecStreams();
+ // RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0);
+ // Call::Config send_config(test->GetSenderCallConfig());
+ // if (num_audio_streams_ > 0) {
+ // CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer());
+ // test->OnFakeAudioDevicesCreated(fake_send_audio_device_.get(),
+ // fake_recv_audio_device_.get());
+ // apm_send_ = AudioProcessing::Create();
+ // apm_recv_ = AudioProcessing::Create();
+ // CreateVoiceEngines();
+ // AudioState::Config audio_state_config;
+ // audio_state_config.voice_engine = voe_send_.voice_engine;
+ // audio_state_config.audio_mixer = AudioMixerImpl::Create();
+ // audio_state_config.audio_processing = apm_send_;
+ // send_config.audio_state = AudioState::Create(audio_state_config);
+ // }
+ // CreateSenderCall(send_config);
+ // if (sender_call_transport_controller_ != nullptr) {
+ // test->OnRtpTransportControllerSendCreated(
+ // sender_call_transport_controller_);
+ // }
+ // if (test->ShouldCreateReceivers()) {
+ // Call::Config recv_config(test->GetReceiverCallConfig());
+ // if (num_audio_streams_ > 0) {
+ // AudioState::Config audio_state_config;
+ // audio_state_config.voice_engine = voe_recv_.voice_engine;
+ // audio_state_config.audio_mixer = AudioMixerImpl::Create();
+ // audio_state_config.audio_processing = apm_recv_;
+ // recv_config.audio_state = AudioState::Create(audio_state_config);
+ // }
+ // CreateReceiverCall(recv_config);
+ // }
+ // test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
+ // receive_transport_.reset(test->CreateReceiveTransport());
+ // send_transport_.reset(test->CreateSendTransport(sender_call_.get()));
+
+ // if (test->ShouldCreateReceivers()) {
+ // send_transport_->SetReceiver(receiver_call_->Receiver());
+ // receive_transport_->SetReceiver(sender_call_->Receiver());
+ // if (num_video_streams_ > 0)
+ // receiver_call_->SignalChannelNetworkState(MediaType::VIDEO,
+ // kNetworkUp);
+ // if (num_audio_streams_ > 0)
+ // receiver_call_->SignalChannelNetworkState(MediaType::AUDIO,
+ // kNetworkUp);
+ // } else {
+ // // Sender-only call delivers to itself.
+ // send_transport_->SetReceiver(sender_call_->Receiver());
+ // receive_transport_->SetReceiver(nullptr);
+ // }
+
+ // CreateSendConfig();
+ // if (test->ShouldCreateReceivers()) {
+ // CreateMatchingReceiveConfigs(
+ // receive_transport_.get(),
+ // &video_receive_configs_,
+ // &allocated_decoders_,
+ // &video_send_config_);
+ // }
+ // if (num_video_streams_ > 0) {
+ // test->ModifyVideoConfigs(&video_send_config_, &video_receive_configs_,
+ // &video_encoder_config_);
+ // }
+ // if (num_audio_streams_ > 0) {
+ // test->ModifyAudioConfigs(&audio_send_config_, &audio_receive_configs_);
+ // }
+ // if (num_flexfec_streams_ > 0) {
+ // test->ModifyFlexfecConfigs(&flexfec_receive_configs_);
+ // }
+
+ // if (num_flexfec_streams_ > 0) {
+ // CreateFlexfecStreams();
+ // test->OnFlexfecStreamsCreated(flexfec_receive_streams_);
+ // }
+ // if (num_video_streams_ > 0) {
+ // video_send_stream_ = CreateVideoStreams(sender_call_.get(),
+ // receiver_call_.get(),
+ // &video_send_config_,
+ // &video_receive_configs_,
+ // &video_receive_streams_,
+ // &video_encoder_config_);
+ // test->OnVideoStreamsCreated(video_send_stream_, video_receive_streams_);
+ // }
+ // if (num_audio_streams_ > 0) {
+ // CreateAudioStreams();
+ // test->OnAudioStreamsCreated(audio_send_stream_, audio_receive_streams_);
+ // }
+
+ // if (num_video_streams_ > 0) {
+ // int width = kDefaultWidth;
+ // int height = kDefaultHeight;
+ // int frame_rate = kDefaultFramerate;
+ // test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate);
+ // CreateFrameGeneratorCapturer(frame_rate, width, height);
+ // test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get());
+ // }
+
+ // Start();
+ // test->PerformTest();
+ // send_transport_->StopSending();
+ // receive_transport_->StopSending();
+ // Stop();
+
+ // DestroyStreams();
+ // DestroyCalls();
+ // if (num_audio_streams_ > 0)
+ // DestroyVoiceEngines();
+
+ // test->OnTestFinished();
}
void CallTest::CreateCalls(const Call::Config& sender_config,
@@ -179,6 +189,7 @@ void CallTest::CreateSenderCall(const Call::Config& config) {
sender_call_.reset(
Call::Create(config, std::unique_ptr<RtpTransportControllerSend>(
sender_call_transport_controller_)));
+ sender_call_->PrintDebugStuff();
}
void CallTest::CreateReceiverCall(const Call::Config& config) {
@@ -193,97 +204,73 @@ void CallTest::DestroyCalls() {
void CallTest::CreateSendConfig(size_t num_video_streams,
size_t num_audio_streams,
size_t num_flexfec_streams,
- Transport* send_transport) {
+ Transport* send_transport,
+ VideoSendStream::Config* video_send_config,
+ VideoEncoderConfig* video_encoder_config,
+ std::vector<uint32_t>* send_ssrcs) {
RTC_DCHECK(num_video_streams <= kNumSsrcs);
RTC_DCHECK_LE(num_audio_streams, 1);
RTC_DCHECK_LE(num_flexfec_streams, 1);
- RTC_DCHECK(num_audio_streams == 0 || voe_send_.channel_id >= 0);
+ RTC_DCHECK(num_audio_streams == 0);
if (num_video_streams > 0) {
- video_send_config_ = VideoSendStream::Config(send_transport);
- video_send_config_.encoder_settings.encoder = &fake_encoder_;
- video_send_config_.encoder_settings.payload_name = "FAKE";
- video_send_config_.encoder_settings.payload_type =
+ *video_send_config = VideoSendStream::Config(send_transport);
+ video_send_config->encoder_settings.encoder = &fake_encoder_;
+ video_send_config->encoder_settings.payload_name = "FAKE";
+ video_send_config->encoder_settings.payload_type =
kFakeVideoSendPayloadType;
- video_send_config_.rtp.extensions.push_back(
+ video_send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumberUri,
kTransportSequenceNumberExtensionId));
- video_send_config_.rtp.extensions.push_back(RtpExtension(
+ video_send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kVideoContentTypeUri, kVideoContentTypeExtensionId));
- FillEncoderConfiguration(num_video_streams, &video_encoder_config_);
+ FillEncoderConfiguration(num_video_streams, video_encoder_config);
for (size_t i = 0; i < num_video_streams; ++i)
- video_send_config_.rtp.ssrcs.push_back(kVideoSendSsrcs[i]);
- video_send_config_.rtp.extensions.push_back(RtpExtension(
+ video_send_config->rtp.ssrcs.push_back(send_ssrcs->at(i));
+ video_send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kVideoRotationUri, kVideoRotationRtpExtensionId));
}
- if (num_audio_streams > 0) {
- audio_send_config_ = AudioSendStream::Config(send_transport);
- audio_send_config_.voe_channel_id = voe_send_.channel_id;
- audio_send_config_.rtp.ssrc = kAudioSendSsrc;
- audio_send_config_.send_codec_spec =
- rtc::Optional<AudioSendStream::Config::SendCodecSpec>(
- {kAudioSendPayloadType, {"OPUS", 48000, 2, {{"stereo", "1"}}}});
- audio_send_config_.encoder_factory = encoder_factory_;
- }
-
// TODO(brandtr): Update this when we support multistream protection.
- if (num_flexfec_streams > 0) {
- video_send_config_.rtp.flexfec.payload_type = kFlexfecPayloadType;
- video_send_config_.rtp.flexfec.ssrc = kFlexfecSendSsrc;
- video_send_config_.rtp.flexfec.protected_media_ssrcs = {kVideoSendSsrcs[0]};
- }
-}
-
-void CallTest::CreateMatchingReceiveConfigs(Transport* rtcp_send_transport) {
- video_receive_configs_.clear();
- allocated_decoders_.clear();
+ RTC_DCHECK(num_flexfec_streams == 0);
+ // if (num_flexfec_streams > 0) {
+ // video_send_config->rtp.flexfec.payload_type = kFlexfecPayloadType;
+ // video_send_config->rtp.flexfec.ssrc = kFlexfecSendSsrc;
+ // video_send_config->rtp.flexfec.protected_media_ssrcs =
+ // {kVideoSendSsrcs[0]};
+ // }
+}
+
+void CallTest::CreateMatchingReceiveConfigs(
+ Transport* rtcp_send_transport,
+ std::vector<VideoReceiveStream::Config>* video_receive_configs,
+ std::vector<std::unique_ptr<VideoDecoder>>* allocated_decoders,
+ VideoSendStream::Config* video_send_config) {
+ video_receive_configs->clear();
+ allocated_decoders->clear();
if (num_video_streams_ > 0) {
- RTC_DCHECK(!video_send_config_.rtp.ssrcs.empty());
+ RTC_DCHECK(!video_send_config->rtp.ssrcs.empty());
VideoReceiveStream::Config video_config(rtcp_send_transport);
video_config.rtp.remb = false;
video_config.rtp.transport_cc = true;
video_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
- for (const RtpExtension& extension : video_send_config_.rtp.extensions)
+ for (const RtpExtension& extension : video_send_config->rtp.extensions)
video_config.rtp.extensions.push_back(extension);
video_config.renderer = &fake_renderer_;
- for (size_t i = 0; i < video_send_config_.rtp.ssrcs.size(); ++i) {
+ for (size_t i = 0; i < video_send_config->rtp.ssrcs.size(); ++i) {
VideoReceiveStream::Decoder decoder =
- test::CreateMatchingDecoder(video_send_config_.encoder_settings);
- allocated_decoders_.push_back(
+ test::CreateMatchingDecoder(video_send_config->encoder_settings);
+ allocated_decoders->push_back(
std::unique_ptr<VideoDecoder>(decoder.decoder));
video_config.decoders.clear();
video_config.decoders.push_back(decoder);
- video_config.rtp.remote_ssrc = video_send_config_.rtp.ssrcs[i];
- video_receive_configs_.push_back(video_config.Copy());
+ video_config.rtp.remote_ssrc = video_send_config->rtp.ssrcs[i];
+ video_receive_configs->push_back(video_config.Copy());
}
}
- RTC_DCHECK_GE(1, num_audio_streams_);
- if (num_audio_streams_ == 1) {
- RTC_DCHECK_LE(0, voe_send_.channel_id);
- AudioReceiveStream::Config audio_config;
- audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
- audio_config.rtcp_send_transport = rtcp_send_transport;
- audio_config.voe_channel_id = voe_recv_.channel_id;
- audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc;
- audio_config.decoder_factory = decoder_factory_;
- audio_config.decoder_map = {{kAudioSendPayloadType, {"opus", 48000, 2}}};
- audio_receive_configs_.push_back(audio_config);
- }
-
- // TODO(brandtr): Update this when we support multistream protection.
- RTC_DCHECK(num_flexfec_streams_ <= 1);
- if (num_flexfec_streams_ == 1) {
- FlexfecReceiveStream::Config config(rtcp_send_transport);
- config.payload_type = kFlexfecPayloadType;
- config.remote_ssrc = kFlexfecSendSsrc;
- config.protected_media_ssrcs = {kVideoSendSsrcs[0]};
- config.local_ssrc = kReceiverLocalVideoSsrc;
- for (const RtpExtension& extension : video_send_config_.rtp.extensions)
- config.rtp_header_extensions.push_back(extension);
- flexfec_receive_configs_.push_back(config);
- }
+ RTC_DCHECK_EQ(0, num_audio_streams_);
+ RTC_DCHECK(num_flexfec_streams_ <= 0);
}
void CallTest::CreateFrameGeneratorCapturerWithDrift(Clock* clock,
@@ -317,20 +304,20 @@ void CallTest::CreateFakeAudioDevices(
nullptr, std::move(renderer), 1.f));
}
-void CallTest::CreateVideoStreams() {
- RTC_DCHECK(video_send_stream_ == nullptr);
- RTC_DCHECK(video_receive_streams_.empty());
- RTC_DCHECK(audio_send_stream_ == nullptr);
- RTC_DCHECK(audio_receive_streams_.empty());
-
- video_send_stream_ = sender_call_->CreateVideoSendStream(
- video_send_config_.Copy(), video_encoder_config_.Copy());
- for (size_t i = 0; i < video_receive_configs_.size(); ++i) {
- video_receive_streams_.push_back(receiver_call_->CreateVideoReceiveStream(
- video_receive_configs_[i].Copy()));
+VideoSendStream* CallTest::CreateVideoStreams(
+ Call* sender_call,
+ Call* receiver_call,
+ VideoSendStream::Config* video_send_config,
+ std::vector<VideoReceiveStream::Config>* video_receive_configs,
+ std::vector<VideoReceiveStream*>* video_receive_streams,
+ VideoEncoderConfig* video_encoder_config) {
+ for (size_t i = 0; i < video_receive_configs->size(); ++i) {
+ video_receive_streams->push_back(receiver_call->CreateVideoReceiveStream(
+ video_receive_configs->at(i).Copy()));
}
- AssociateFlexfecStreamsWithVideoStreams();
+ return sender_call->CreateVideoSendStream(video_send_config->Copy(),
+ video_encoder_config->Copy());
}
void CallTest::CreateAudioStreams() {
@@ -474,10 +461,10 @@ const uint8_t CallTest::kAudioSendPayloadType = 103;
const uint8_t CallTest::kPayloadTypeH264 = 122;
const uint8_t CallTest::kPayloadTypeVP8 = 123;
const uint8_t CallTest::kPayloadTypeVP9 = 124;
-const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {0xBADCAFD, 0xBADCAFE,
- 0xBADCAFF};
-const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE,
- 0xC0FFEF};
+// const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {0xBADCAFD, 0xBADCAFE,
+// 0xBADCAFF};
+// const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE,
+// 0xC0FFEF};
const uint32_t CallTest::kAudioSendSsrc = 0xDEADBEEF;
const uint32_t CallTest::kFlexfecSendSsrc = 0xBADBEEF;
const uint32_t CallTest::kReceiverLocalVideoSsrc = 0x123456;
« no previous file with comments | « webrtc/test/call_test.h ('k') | webrtc/test/fake_network_pipe.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698