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; |