blob: b06af1eecdd0dbec415e6cac10e66d80d019a267 [file] [log] [blame]
/*
* Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "call/call.h"
#include <list>
#include <map>
#include <memory>
#include <utility>
#include "absl/memory/memory.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/rtc_event_log/rtc_event_log.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/test/mock_audio_mixer.h"
#include "api/test/video/function_video_encoder_factory.h"
#include "api/transport/field_trial_based_config.h"
#include "api/video/builtin_video_bitrate_allocator_factory.h"
#include "audio/audio_receive_stream.h"
#include "audio/audio_send_stream.h"
#include "call/adaptation/test/fake_resource.h"
#include "call/adaptation/test/mock_resource_listener.h"
#include "call/audio_state.h"
#include "modules/audio_device/include/mock_audio_device.h"
#include "modules/audio_processing/include/mock_audio_processing.h"
#include "modules/include/module.h"
#include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
#include "test/fake_encoder.h"
#include "test/gtest.h"
#include "test/mock_audio_decoder_factory.h"
#include "test/mock_transport.h"
#include "test/run_loop.h"
namespace {
using ::testing::_;
using ::testing::Contains;
using ::testing::NiceMock;
using ::testing::StrictMock;
struct CallHelper {
explicit CallHelper(bool use_null_audio_processing) {
task_queue_factory_ = webrtc::CreateDefaultTaskQueueFactory();
webrtc::AudioState::Config audio_state_config;
audio_state_config.audio_mixer =
rtc::make_ref_counted<webrtc::test::MockAudioMixer>();
audio_state_config.audio_processing =
use_null_audio_processing
? nullptr
: rtc::make_ref_counted<
NiceMock<webrtc::test::MockAudioProcessing>>();
audio_state_config.audio_device_module =
rtc::make_ref_counted<webrtc::test::MockAudioDeviceModule>();
webrtc::Call::Config config(&event_log_);
config.audio_state = webrtc::AudioState::Create(audio_state_config);
config.task_queue_factory = task_queue_factory_.get();
config.trials = &field_trials_;
call_.reset(webrtc::Call::Create(config));
}
webrtc::Call* operator->() { return call_.get(); }
private:
webrtc::test::RunLoop loop_;
webrtc::RtcEventLogNull event_log_;
webrtc::FieldTrialBasedConfig field_trials_;
std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
std::unique_ptr<webrtc::Call> call_;
};
} // namespace
namespace webrtc {
namespace {
rtc::scoped_refptr<Resource> FindResourceWhoseNameContains(
const std::vector<rtc::scoped_refptr<Resource>>& resources,
const std::string& name_contains) {
for (const auto& resource : resources) {
if (resource->Name().find(name_contains) != std::string::npos)
return resource;
}
return nullptr;
}
} // namespace
TEST(CallTest, ConstructDestruct) {
for (bool use_null_audio_processing : {false, true}) {
CallHelper call(use_null_audio_processing);
}
}
TEST(CallTest, CreateDestroy_AudioSendStream) {
for (bool use_null_audio_processing : {false, true}) {
CallHelper call(use_null_audio_processing);
MockTransport send_transport;
AudioSendStream::Config config(&send_transport);
config.rtp.ssrc = 42;
AudioSendStream* stream = call->CreateAudioSendStream(config);
EXPECT_NE(stream, nullptr);
call->DestroyAudioSendStream(stream);
}
}
TEST(CallTest, CreateDestroy_AudioReceiveStream) {
for (bool use_null_audio_processing : {false, true}) {
CallHelper call(use_null_audio_processing);
AudioReceiveStream::Config config;
MockTransport rtcp_send_transport;
config.rtp.remote_ssrc = 42;
config.rtcp_send_transport = &rtcp_send_transport;
config.decoder_factory =
rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>();
AudioReceiveStream* stream = call->CreateAudioReceiveStream(config);
EXPECT_NE(stream, nullptr);
call->DestroyAudioReceiveStream(stream);
}
}
TEST(CallTest, CreateDestroy_AudioSendStreams) {
for (bool use_null_audio_processing : {false, true}) {
CallHelper call(use_null_audio_processing);
MockTransport send_transport;
AudioSendStream::Config config(&send_transport);
std::list<AudioSendStream*> streams;
for (int i = 0; i < 2; ++i) {
for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) {
config.rtp.ssrc = ssrc;
AudioSendStream* stream = call->CreateAudioSendStream(config);
EXPECT_NE(stream, nullptr);
if (ssrc & 1) {
streams.push_back(stream);
} else {
streams.push_front(stream);
}
}
for (auto s : streams) {
call->DestroyAudioSendStream(s);
}
streams.clear();
}
}
}
TEST(CallTest, CreateDestroy_AudioReceiveStreams) {
for (bool use_null_audio_processing : {false, true}) {
CallHelper call(use_null_audio_processing);
AudioReceiveStream::Config config;
MockTransport rtcp_send_transport;
config.rtcp_send_transport = &rtcp_send_transport;
config.decoder_factory =
rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>();
std::list<AudioReceiveStream*> streams;
for (int i = 0; i < 2; ++i) {
for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) {
config.rtp.remote_ssrc = ssrc;
AudioReceiveStream* stream = call->CreateAudioReceiveStream(config);
EXPECT_NE(stream, nullptr);
if (ssrc & 1) {
streams.push_back(stream);
} else {
streams.push_front(stream);
}
}
for (auto s : streams) {
call->DestroyAudioReceiveStream(s);
}
streams.clear();
}
}
}
TEST(CallTest, CreateDestroy_AssociateAudioSendReceiveStreams_RecvFirst) {
for (bool use_null_audio_processing : {false, true}) {
CallHelper call(use_null_audio_processing);
AudioReceiveStream::Config recv_config;
MockTransport rtcp_send_transport;
recv_config.rtp.remote_ssrc = 42;
recv_config.rtp.local_ssrc = 777;
recv_config.rtcp_send_transport = &rtcp_send_transport;
recv_config.decoder_factory =
rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>();
AudioReceiveStream* recv_stream =
call->CreateAudioReceiveStream(recv_config);
EXPECT_NE(recv_stream, nullptr);
MockTransport send_transport;
AudioSendStream::Config send_config(&send_transport);
send_config.rtp.ssrc = 777;
AudioSendStream* send_stream = call->CreateAudioSendStream(send_config);
EXPECT_NE(send_stream, nullptr);
internal::AudioReceiveStream* internal_recv_stream =
static_cast<internal::AudioReceiveStream*>(recv_stream);
EXPECT_EQ(send_stream,
internal_recv_stream->GetAssociatedSendStreamForTesting());
call->DestroyAudioSendStream(send_stream);
EXPECT_EQ(nullptr,
internal_recv_stream->GetAssociatedSendStreamForTesting());
call->DestroyAudioReceiveStream(recv_stream);
}
}
TEST(CallTest, CreateDestroy_AssociateAudioSendReceiveStreams_SendFirst) {
for (bool use_null_audio_processing : {false, true}) {
CallHelper call(use_null_audio_processing);
MockTransport send_transport;
AudioSendStream::Config send_config(&send_transport);
send_config.rtp.ssrc = 777;
AudioSendStream* send_stream = call->CreateAudioSendStream(send_config);
EXPECT_NE(send_stream, nullptr);
AudioReceiveStream::Config recv_config;
MockTransport rtcp_send_transport;
recv_config.rtp.remote_ssrc = 42;
recv_config.rtp.local_ssrc = 777;
recv_config.rtcp_send_transport = &rtcp_send_transport;
recv_config.decoder_factory =
rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>();
AudioReceiveStream* recv_stream =
call->CreateAudioReceiveStream(recv_config);
EXPECT_NE(recv_stream, nullptr);
internal::AudioReceiveStream* internal_recv_stream =
static_cast<internal::AudioReceiveStream*>(recv_stream);
EXPECT_EQ(send_stream,
internal_recv_stream->GetAssociatedSendStreamForTesting());
call->DestroyAudioReceiveStream(recv_stream);
call->DestroyAudioSendStream(send_stream);
}
}
TEST(CallTest, CreateDestroy_FlexfecReceiveStream) {
for (bool use_null_audio_processing : {false, true}) {
CallHelper call(use_null_audio_processing);
MockTransport rtcp_send_transport;
FlexfecReceiveStream::Config config(&rtcp_send_transport);
config.payload_type = 118;
config.remote_ssrc = 38837212;
config.protected_media_ssrcs = {27273};
FlexfecReceiveStream* stream = call->CreateFlexfecReceiveStream(config);
EXPECT_NE(stream, nullptr);
call->DestroyFlexfecReceiveStream(stream);
}
}
TEST(CallTest, CreateDestroy_FlexfecReceiveStreams) {
for (bool use_null_audio_processing : {false, true}) {
CallHelper call(use_null_audio_processing);
MockTransport rtcp_send_transport;
FlexfecReceiveStream::Config config(&rtcp_send_transport);
config.payload_type = 118;
std::list<FlexfecReceiveStream*> streams;
for (int i = 0; i < 2; ++i) {
for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) {
config.remote_ssrc = ssrc;
config.protected_media_ssrcs = {ssrc + 1};
FlexfecReceiveStream* stream = call->CreateFlexfecReceiveStream(config);
EXPECT_NE(stream, nullptr);
if (ssrc & 1) {
streams.push_back(stream);
} else {
streams.push_front(stream);
}
}
for (auto s : streams) {
call->DestroyFlexfecReceiveStream(s);
}
streams.clear();
}
}
}
TEST(CallTest, MultipleFlexfecReceiveStreamsProtectingSingleVideoStream) {
for (bool use_null_audio_processing : {false, true}) {
CallHelper call(use_null_audio_processing);
MockTransport rtcp_send_transport;
FlexfecReceiveStream::Config config(&rtcp_send_transport);
config.payload_type = 118;
config.protected_media_ssrcs = {1324234};
FlexfecReceiveStream* stream;
std::list<FlexfecReceiveStream*> streams;
config.remote_ssrc = 838383;
stream = call->CreateFlexfecReceiveStream(config);
EXPECT_NE(stream, nullptr);
streams.push_back(stream);
config.remote_ssrc = 424993;
stream = call->CreateFlexfecReceiveStream(config);
EXPECT_NE(stream, nullptr);
streams.push_back(stream);
config.remote_ssrc = 99383;
stream = call->CreateFlexfecReceiveStream(config);
EXPECT_NE(stream, nullptr);
streams.push_back(stream);
config.remote_ssrc = 5548;
stream = call->CreateFlexfecReceiveStream(config);
EXPECT_NE(stream, nullptr);
streams.push_back(stream);
for (auto s : streams) {
call->DestroyFlexfecReceiveStream(s);
}
}
}
TEST(CallTest, RecreatingAudioStreamWithSameSsrcReusesRtpState) {
constexpr uint32_t kSSRC = 12345;
for (bool use_null_audio_processing : {false, true}) {
CallHelper call(use_null_audio_processing);
auto create_stream_and_get_rtp_state = [&](uint32_t ssrc) {
MockTransport send_transport;
AudioSendStream::Config config(&send_transport);
config.rtp.ssrc = ssrc;
AudioSendStream* stream = call->CreateAudioSendStream(config);
const RtpState rtp_state =
static_cast<internal::AudioSendStream*>(stream)->GetRtpState();
call->DestroyAudioSendStream(stream);
return rtp_state;
};
const RtpState rtp_state1 = create_stream_and_get_rtp_state(kSSRC);
const RtpState rtp_state2 = create_stream_and_get_rtp_state(kSSRC);
EXPECT_EQ(rtp_state1.sequence_number, rtp_state2.sequence_number);
EXPECT_EQ(rtp_state1.start_timestamp, rtp_state2.start_timestamp);
EXPECT_EQ(rtp_state1.timestamp, rtp_state2.timestamp);
EXPECT_EQ(rtp_state1.capture_time_ms, rtp_state2.capture_time_ms);
EXPECT_EQ(rtp_state1.last_timestamp_time_ms,
rtp_state2.last_timestamp_time_ms);
}
}
TEST(CallTest, AddAdaptationResourceAfterCreatingVideoSendStream) {
CallHelper call(true);
// Create a VideoSendStream.
test::FunctionVideoEncoderFactory fake_encoder_factory([]() {
return std::make_unique<test::FakeEncoder>(Clock::GetRealTimeClock());
});
auto bitrate_allocator_factory = CreateBuiltinVideoBitrateAllocatorFactory();
MockTransport send_transport;
VideoSendStream::Config config(&send_transport);
config.rtp.payload_type = 110;
config.rtp.ssrcs = {42};
config.encoder_settings.encoder_factory = &fake_encoder_factory;
config.encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory.get();
VideoEncoderConfig encoder_config;
encoder_config.max_bitrate_bps = 1337;
VideoSendStream* stream1 =
call->CreateVideoSendStream(config.Copy(), encoder_config.Copy());
EXPECT_NE(stream1, nullptr);
config.rtp.ssrcs = {43};
VideoSendStream* stream2 =
call->CreateVideoSendStream(config.Copy(), encoder_config.Copy());
EXPECT_NE(stream2, nullptr);
// Add a fake resource.
auto fake_resource = FakeResource::Create("FakeResource");
call->AddAdaptationResource(fake_resource);
// An adapter resource mirroring the |fake_resource| should now be present on
// both streams.
auto injected_resource1 = FindResourceWhoseNameContains(
stream1->GetAdaptationResources(), fake_resource->Name());
EXPECT_TRUE(injected_resource1);
auto injected_resource2 = FindResourceWhoseNameContains(
stream2->GetAdaptationResources(), fake_resource->Name());
EXPECT_TRUE(injected_resource2);
// Overwrite the real resource listeners with mock ones to verify the signal
// gets through.
injected_resource1->SetResourceListener(nullptr);
StrictMock<MockResourceListener> resource_listener1;
EXPECT_CALL(resource_listener1, OnResourceUsageStateMeasured(_, _))
.Times(1)
.WillOnce([injected_resource1](rtc::scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(injected_resource1, resource);
EXPECT_EQ(ResourceUsageState::kOveruse, usage_state);
});
injected_resource1->SetResourceListener(&resource_listener1);
injected_resource2->SetResourceListener(nullptr);
StrictMock<MockResourceListener> resource_listener2;
EXPECT_CALL(resource_listener2, OnResourceUsageStateMeasured(_, _))
.Times(1)
.WillOnce([injected_resource2](rtc::scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(injected_resource2, resource);
EXPECT_EQ(ResourceUsageState::kOveruse, usage_state);
});
injected_resource2->SetResourceListener(&resource_listener2);
// The kOveruse signal should get to our resource listeners.
fake_resource->SetUsageState(ResourceUsageState::kOveruse);
call->DestroyVideoSendStream(stream1);
call->DestroyVideoSendStream(stream2);
}
TEST(CallTest, AddAdaptationResourceBeforeCreatingVideoSendStream) {
CallHelper call(true);
// Add a fake resource.
auto fake_resource = FakeResource::Create("FakeResource");
call->AddAdaptationResource(fake_resource);
// Create a VideoSendStream.
test::FunctionVideoEncoderFactory fake_encoder_factory([]() {
return std::make_unique<test::FakeEncoder>(Clock::GetRealTimeClock());
});
auto bitrate_allocator_factory = CreateBuiltinVideoBitrateAllocatorFactory();
MockTransport send_transport;
VideoSendStream::Config config(&send_transport);
config.rtp.payload_type = 110;
config.rtp.ssrcs = {42};
config.encoder_settings.encoder_factory = &fake_encoder_factory;
config.encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory.get();
VideoEncoderConfig encoder_config;
encoder_config.max_bitrate_bps = 1337;
VideoSendStream* stream1 =
call->CreateVideoSendStream(config.Copy(), encoder_config.Copy());
EXPECT_NE(stream1, nullptr);
config.rtp.ssrcs = {43};
VideoSendStream* stream2 =
call->CreateVideoSendStream(config.Copy(), encoder_config.Copy());
EXPECT_NE(stream2, nullptr);
// An adapter resource mirroring the |fake_resource| should be present on both
// streams.
auto injected_resource1 = FindResourceWhoseNameContains(
stream1->GetAdaptationResources(), fake_resource->Name());
EXPECT_TRUE(injected_resource1);
auto injected_resource2 = FindResourceWhoseNameContains(
stream2->GetAdaptationResources(), fake_resource->Name());
EXPECT_TRUE(injected_resource2);
// Overwrite the real resource listeners with mock ones to verify the signal
// gets through.
injected_resource1->SetResourceListener(nullptr);
StrictMock<MockResourceListener> resource_listener1;
EXPECT_CALL(resource_listener1, OnResourceUsageStateMeasured(_, _))
.Times(1)
.WillOnce([injected_resource1](rtc::scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(injected_resource1, resource);
EXPECT_EQ(ResourceUsageState::kUnderuse, usage_state);
});
injected_resource1->SetResourceListener(&resource_listener1);
injected_resource2->SetResourceListener(nullptr);
StrictMock<MockResourceListener> resource_listener2;
EXPECT_CALL(resource_listener2, OnResourceUsageStateMeasured(_, _))
.Times(1)
.WillOnce([injected_resource2](rtc::scoped_refptr<Resource> resource,
ResourceUsageState usage_state) {
EXPECT_EQ(injected_resource2, resource);
EXPECT_EQ(ResourceUsageState::kUnderuse, usage_state);
});
injected_resource2->SetResourceListener(&resource_listener2);
// The kUnderuse signal should get to our resource listeners.
fake_resource->SetUsageState(ResourceUsageState::kUnderuse);
call->DestroyVideoSendStream(stream1);
call->DestroyVideoSendStream(stream2);
}
TEST(CallTest, SharedModuleThread) {
class SharedModuleThreadUser : public Module {
public:
SharedModuleThreadUser(ProcessThread* expected_thread,
rtc::scoped_refptr<SharedModuleThread> thread)
: expected_thread_(expected_thread), thread_(std::move(thread)) {
thread_->EnsureStarted();
thread_->process_thread()->RegisterModule(this, RTC_FROM_HERE);
}
~SharedModuleThreadUser() override {
thread_->process_thread()->DeRegisterModule(this);
EXPECT_TRUE(thread_was_checked_);
}
private:
int64_t TimeUntilNextProcess() override { return 1000; }
void Process() override {}
void ProcessThreadAttached(ProcessThread* process_thread) override {
if (!process_thread) {
// Being detached.
return;
}
EXPECT_EQ(process_thread, expected_thread_);
thread_was_checked_ = true;
}
bool thread_was_checked_ = false;
ProcessThread* const expected_thread_;
rtc::scoped_refptr<SharedModuleThread> thread_;
};
// Create our test instance and pass a lambda to it that gets executed when
// the reference count goes back to 1 - meaning |shared| again is the only
// reference, which means we can free the variable and deallocate the thread.
rtc::scoped_refptr<SharedModuleThread> shared;
shared =
SharedModuleThread::Create(ProcessThread::Create("MySharedProcessThread"),
[&shared]() { shared = nullptr; });
ProcessThread* process_thread = shared->process_thread();
ASSERT_TRUE(shared.get());
{
// Create a couple of users of the thread.
// These instances are in a separate scope to trigger the callback to our
// lambda, which will run when these go out of scope.
SharedModuleThreadUser user1(process_thread, shared);
SharedModuleThreadUser user2(process_thread, shared);
}
// The thread should now have been stopped and freed.
EXPECT_FALSE(shared);
}
} // namespace webrtc