admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add send transports to individual webrtc::Call streams.

Browse Source 
BUG=webrtc:4690

Review URL: https://codereview.webrtc.org/1273363005

Cr-Commit-Position: refs/heads/master@{#9807}
This commit is contained in:
solenberg 2015-08-28 04:07:10 -07:00 committed by Commit bot
parent 6480d03f17
commit 4fbae2b791
27 changed files with 178 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
talk/media/webrtc/webrtcvideoengine2.cc
View File

@ -788,7 +788,7 @@ WebRtcVideoChannel2::WebRtcVideoChannel2(
SetDefaultOptions();
options_.SetAll(options);
options_.cpu_overuse_detection.Get(&signal_cpu_adaptation_);
webrtc::Call::Config config(this);
webrtc::Call::Config config;
config.overuse_callback = this;
if (voice_engine != NULL) {
config.voice_engine = voice_engine->voe()->engine();
@ -1119,11 +1119,12 @@ bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) {
WebRtcVideoSendStream* stream =
new WebRtcVideoSendStream(call_.get(),
sp,
webrtc::VideoSendStream::Config(this),
external_encoder_factory_,
options_,
bitrate_config_.max_bitrate_bps,
send_codec_,
sp,
send_rtp_extensions_);
uint32 ssrc = sp.first_ssrc();
@ -1227,7 +1228,7 @@ bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp,
for (uint32 used_ssrc : sp.ssrcs)
receive_ssrcs_.insert(used_ssrc);
webrtc::VideoReceiveStream::Config config;
webrtc::VideoReceiveStream::Config config(this);
ConfigureReceiverRtp(&config, sp);
// Set up A/V sync group based on sync label.
@ -1240,7 +1241,7 @@ bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp,
}
receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
call_.get(), sp, external_decoder_factory_, default_stream, config,
call_.get(), sp, config, external_decoder_factory_, default_stream,
recv_codecs_);
return true;
@ -1732,21 +1733,19 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder(
WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
webrtc::Call* call,
const StreamParams& sp,
const webrtc::VideoSendStream::Config& config,
WebRtcVideoEncoderFactory* external_encoder_factory,
const VideoOptions& options,
int max_bitrate_bps,
const Settable<VideoCodecSettings>& codec_settings,
const StreamParams& sp,
const std::vector<webrtc::RtpExtension>& rtp_extensions)
: ssrcs_(sp.ssrcs),
ssrc_groups_(sp.ssrc_groups),
call_(call),
external_encoder_factory_(external_encoder_factory),
stream_(NULL),
parameters_(webrtc::VideoSendStream::Config(),
options,
max_bitrate_bps,
codec_settings),
parameters_(config, options, max_bitrate_bps, codec_settings),
allocated_encoder_(NULL, webrtc::kVideoCodecUnknown, false),
capturer_(NULL),
sending_(false),
@ -2335,9 +2334,9 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
webrtc::Call* call,
const StreamParams& sp,
const webrtc::VideoReceiveStream::Config& config,
WebRtcVideoDecoderFactory* external_decoder_factory,
bool default_stream,
const webrtc::VideoReceiveStream::Config& config,
const std::vector<VideoCodecSettings>& recv_codecs)
: call_(call),
ssrcs_(sp.ssrcs),

5
talk/media/webrtc/webrtcvideoengine2.h
View File

@ -268,11 +268,12 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler,
public:
WebRtcVideoSendStream(
webrtc::Call* call,
const StreamParams& sp,
const webrtc::VideoSendStream::Config& config,
WebRtcVideoEncoderFactory* external_encoder_factory,
const VideoOptions& options,
int max_bitrate_bps,
const Settable<VideoCodecSettings>& codec_settings,
const StreamParams& sp,
const std::vector<webrtc::RtpExtension>& rtp_extensions);
~WebRtcVideoSendStream();
@ -414,9 +415,9 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler,
WebRtcVideoReceiveStream(
webrtc::Call* call,
const StreamParams& sp,
const webrtc::VideoReceiveStream::Config& config,
WebRtcVideoDecoderFactory* external_decoder_factory,
bool default_stream,
const webrtc::VideoReceiveStream::Config& config,
const std::vector<VideoCodecSettings>& recv_codecs);
~WebRtcVideoReceiveStream();

14
talk/media/webrtc/webrtcvoiceengine_unittest.cc
View File

@ -3354,7 +3354,7 @@ TEST(WebRtcVoiceEngineTest, CoInitialize) {
#endif
TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) {
cricket::FakeCall call(webrtc::Call::Config(nullptr));
cricket::FakeCall call((webrtc::Call::Config()));
const uint32 kAudioSsrc = 123;
const std::string kSyncLabel = "AvSyncLabel";
@ -3384,7 +3384,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) {
TEST_F(WebRtcVoiceEngineTestFake, CanChangeCombinedBweOption) {
// Test that changing the combined_audio_video_bwe option results in the
// expected state changes on an associated Call.
cricket::FakeCall call(webrtc::Call::Config(nullptr));
cricket::FakeCall call((webrtc::Call::Config()));
const uint32 kAudioSsrc1 = 223;
const uint32 kAudioSsrc2 = 224;
@ -3437,8 +3437,8 @@ TEST_F(WebRtcVoiceEngineTestFake, CanChangeCombinedBweOption) {
TEST_F(WebRtcVoiceEngineTestFake, SetCallConfiguresAudioReceiveChannels) {
// Test that calling SetCall() on the voice media channel results in the
// expected state changes in Call.
cricket::FakeCall call(webrtc::Call::Config(nullptr));
cricket::FakeCall call2(webrtc::Call::Config(nullptr));
cricket::FakeCall call((webrtc::Call::Config()));
cricket::FakeCall call2((webrtc::Call::Config()));
const uint32 kAudioSsrc1 = 223;
const uint32 kAudioSsrc2 = 224;
@ -3474,7 +3474,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetCallConfiguresAudioReceiveChannels) {
TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) {
// Test that adding receive streams after enabling combined bandwidth
// estimation will correctly configure each channel.
cricket::FakeCall call(webrtc::Call::Config(nullptr));
cricket::FakeCall call((webrtc::Call::Config()));
EXPECT_TRUE(SetupEngine());
cricket::WebRtcVoiceMediaChannel* media_channel =
@ -3502,7 +3502,7 @@ TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) {
TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
// Test that setting the header extensions results in the expected state
// changes on an associated Call.
cricket::FakeCall call(webrtc::Call::Config(nullptr));
cricket::FakeCall call((webrtc::Call::Config()));
std::vector<uint32> ssrcs;
ssrcs.push_back(223);
ssrcs.push_back(224);
@ -3556,7 +3556,7 @@ TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) {
// Test that packets are forwarded to the Call when configured accordingly.
cricket::FakeCall call(webrtc::Call::Config(nullptr));
cricket::FakeCall call((webrtc::Call::Config()));
const uint32 kAudioSsrc = 1;
rtc::Buffer kPcmuPacket(kPcmuFrame, sizeof(kPcmuFrame));
static const unsigned char kRtcp[] = {

8
webrtc/audio_send_stream.h
View File

@ -18,6 +18,7 @@
#include "webrtc/config.h"
#include "webrtc/modules/audio_coding/codecs/audio_encoder.h"
#include "webrtc/stream.h"
#include "webrtc/transport.h"
#include "webrtc/typedefs.h"
namespace webrtc {
@ -27,6 +28,10 @@ class AudioSendStream : public SendStream {
struct Stats {};
struct Config {
Config() = delete;
explicit Config(newapi::Transport* send_transport)
: send_transport(send_transport) {}
std::string ToString() const;
// Receive-stream specific RTP settings.
@ -40,6 +45,9 @@ class AudioSendStream : public SendStream {
std::vector<RtpExtension> extensions;
} rtp;
// Transport for outgoing packets.
newapi::Transport* send_transport = nullptr;
rtc::scoped_ptr<AudioEncoder> encoder;
int cng_payload_type = -1; // pt, or -1 to disable Comfort Noise Generator.
int red_payload_type = -1; // pt, or -1 to disable REDundant coding.

8
webrtc/call.h
View File

@ -69,16 +69,8 @@ class LoadObserver {
class Call {
public:
struct Config {
Config() = delete;
explicit Config(newapi::Transport* send_transport)
: send_transport(send_transport) {}
static const int kDefaultStartBitrateBps;
// TODO(solenberg): Need to add media type to the interface for outgoing
// packets too.
newapi::Transport* send_transport = nullptr;
// VoiceEngine used for audio/video synchronization for this Call.
VoiceEngine* voice_engine = nullptr;

19
webrtc/test/call_test.cc
View File

@ -19,6 +19,7 @@ const int kVideoRotationRtpExtensionId = 4;
CallTest::CallTest()
: clock_(Clock::GetRealTimeClock()),
send_config_(nullptr),
send_stream_(NULL),
fake_encoder_(clock_) {
}
@ -39,9 +40,9 @@ void CallTest::RunBaseTest(BaseTest* test) {
test->SetReceivers(sender_call_->Receiver(), NULL);
}
CreateSendConfig(test->GetNumStreams());
CreateSendConfig(test->GetNumStreams(), test->SendTransport());
if (test->ShouldCreateReceivers()) {
CreateMatchingReceiveConfigs();
CreateMatchingReceiveConfigs(test->ReceiveTransport());
}
test->ModifyConfigs(&send_config_, &receive_configs_, &encoder_config_);
CreateStreams();
@ -88,9 +89,10 @@ void CallTest::CreateReceiverCall(const Call::Config& config) {
receiver_call_.reset(Call::Create(config));
}
void CallTest::CreateSendConfig(size_t num_streams) {
void CallTest::CreateSendConfig(size_t num_streams,
newapi::Transport* send_transport) {
assert(num_streams <= kNumSsrcs);
send_config_ = VideoSendStream::Config();
send_config_ = VideoSendStream::Config(send_transport);
send_config_.encoder_settings.encoder = &fake_encoder_;
send_config_.encoder_settings.payload_name = "FAKE";
send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
@ -103,11 +105,12 @@ void CallTest::CreateSendConfig(size_t num_streams) {
RtpExtension(RtpExtension::kVideoRotation, kVideoRotationRtpExtensionId));
}
void CallTest::CreateMatchingReceiveConfigs() {
void CallTest::CreateMatchingReceiveConfigs(
newapi::Transport* rtcp_send_transport) {
assert(!send_config_.rtp.ssrcs.empty());
assert(receive_configs_.empty());
assert(allocated_decoders_.empty());
VideoReceiveStream::Config config;
VideoReceiveStream::Config config(rtcp_send_transport);
config.rtp.remb = true;
config.rtp.local_ssrc = kReceiverLocalSsrc;
for (const RtpExtension& extension : send_config_.rtp.extensions)
@ -183,11 +186,11 @@ BaseTest::~BaseTest() {
}
Call::Config BaseTest::GetSenderCallConfig() {
return Call::Config(SendTransport());
return Call::Config();
}
Call::Config BaseTest::GetReceiverCallConfig() {
return Call::Config(ReceiveTransport());
return Call::Config();
}
void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {

4
webrtc/test/call_test.h
View File

@ -53,8 +53,8 @@ class CallTest : public ::testing::Test {
void CreateSenderCall(const Call::Config& config);
void CreateReceiverCall(const Call::Config& config);
void CreateSendConfig(size_t num_streams);
void CreateMatchingReceiveConfigs();
void CreateSendConfig(size_t num_streams, newapi::Transport* send_transport);
void CreateMatchingReceiveConfigs(newapi::Transport* rtcp_send_transport);
void CreateFrameGeneratorCapturer();

13
webrtc/video/bitrate_estimator_tests.cc
View File

@ -121,7 +121,7 @@ class BitrateEstimatorTest : public test::CallTest {
receive_transport_(),
sender_call_(),
receiver_call_(),
receive_config_(),
receive_config_(nullptr),
streams_() {
}
@ -130,16 +130,13 @@ class BitrateEstimatorTest : public test::CallTest {
}
virtual void SetUp() {
Call::Config receiver_call_config(&receive_transport_);
receiver_call_.reset(Call::Create(receiver_call_config));
Call::Config sender_call_config(&send_transport_);
sender_call_.reset(Call::Create(sender_call_config));
receiver_call_.reset(Call::Create(Call::Config()));
sender_call_.reset(Call::Create(Call::Config()));
send_transport_.SetReceiver(receiver_call_->Receiver());
receive_transport_.SetReceiver(sender_call_->Receiver());
send_config_ = VideoSendStream::Config();
send_config_ = VideoSendStream::Config(&send_transport_);
send_config_.rtp.ssrcs.push_back(kSendSsrcs[0]);
// Encoders will be set separately per stream.
send_config_.encoder_settings.encoder = nullptr;
@ -147,7 +144,7 @@ class BitrateEstimatorTest : public test::CallTest {
send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
encoder_config_.streams = test::CreateVideoStreams(1);
receive_config_ = VideoReceiveStream::Config();
receive_config_ = VideoReceiveStream::Config(&receive_transport_);
// receive_config_.decoders will be set by every stream separately.
receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
receive_config_.rtp.local_ssrc = kReceiverLocalSsrc;

8
webrtc/video/call.cc
View File

@ -123,7 +123,6 @@ class Call : public webrtc::Call, public PacketReceiver {
// and receivers.
rtc::CriticalSection network_enabled_crit_;
bool network_enabled_ GUARDED_BY(network_enabled_crit_);
TransportAdapter transport_adapter_;
rtc::scoped_ptr<RWLockWrapper> receive_crit_;
std::map<uint32_t, AudioReceiveStream*> audio_receive_ssrcs_
@ -160,11 +159,8 @@ Call::Call(const Call::Config& config)
next_channel_id_(0),
config_(config),
network_enabled_(true),
transport_adapter_(nullptr),
receive_crit_(RWLockWrapper::CreateRWLock()),
send_crit_(RWLockWrapper::CreateRWLock()) {
DCHECK(config.send_transport != nullptr);
DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0);
DCHECK_GE(config.bitrate_config.start_bitrate_bps,
config.bitrate_config.min_bitrate_bps);
@ -253,7 +249,7 @@ webrtc::VideoSendStream* Call::CreateVideoSendStream(
// TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
// the call has already started.
VideoSendStream* send_stream = new VideoSendStream(
config_.send_transport, overuse_observer_proxy_.get(), num_cpu_cores_,
overuse_observer_proxy_.get(), num_cpu_cores_,
module_process_thread_.get(), channel_group_.get(),
rtc::AtomicOps::Increment(&next_channel_id_), config, encoder_config,
suspended_video_send_ssrcs_);
@ -313,7 +309,7 @@ webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
VideoReceiveStream* receive_stream = new VideoReceiveStream(
num_cpu_cores_, channel_group_.get(),
rtc::AtomicOps::Increment(&next_channel_id_), config,
config_.send_transport, config_.voice_engine);
config_.voice_engine);
// This needs to be taken before receive_crit_ as both locks need to be held
// while changing network state.

10
webrtc/video/call_perf_tests.cc
View File

@ -239,9 +239,9 @@ void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
voe_sync,
&audio_observer);
Call::Config receiver_config(observer.ReceiveTransport());
Call::Config receiver_config;
receiver_config.voice_engine = voice_engine;
CreateCalls(Call::Config(observer.SendTransport()), receiver_config);
CreateCalls(Call::Config(), receiver_config);
CodecInst isac = {103, "ISAC", 16000, 480, 1, 32000};
EXPECT_EQ(0, voe_codec->SetSendCodec(channel, isac));
@ -258,8 +258,8 @@ void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
test::FakeDecoder fake_decoder;
CreateSendConfig(1);
CreateMatchingReceiveConfigs();
CreateSendConfig(1, observer.SendTransport());
CreateMatchingReceiveConfigs(observer.ReceiveTransport());
send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
if (fec) {
@ -489,7 +489,7 @@ void CallPerfTest::TestCpuOveruse(LoadObserver::Load tested_load,
}
Call::Config GetSenderCallConfig() override {
Call::Config config(SendTransport());
Call::Config config;
config.overuse_callback = this;
return config;
}

124
webrtc/video/end_to_end_tests.cc
View File

@ -82,11 +82,11 @@ class EndToEndTest : public test::CallTest {
};
TEST_F(EndToEndTest, ReceiverCanBeStartedTwice) {
test::NullTransport transport;
CreateCalls(Call::Config(&transport), Call::Config(&transport));
CreateCalls(Call::Config(), Call::Config());
CreateSendConfig(1);
CreateMatchingReceiveConfigs();
test::NullTransport transport;
CreateSendConfig(1, &transport);
CreateMatchingReceiveConfigs(&transport);
CreateStreams();
@ -97,11 +97,11 @@ TEST_F(EndToEndTest, ReceiverCanBeStartedTwice) {
}
TEST_F(EndToEndTest, ReceiverCanBeStoppedTwice) {
test::NullTransport transport;
CreateCalls(Call::Config(&transport), Call::Config(&transport));
CreateCalls(Call::Config(), Call::Config());
CreateSendConfig(1);
CreateMatchingReceiveConfigs();
test::NullTransport transport;
CreateSendConfig(1, &transport);
CreateMatchingReceiveConfigs(&transport);
CreateStreams();
@ -150,16 +150,14 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
rtc::scoped_ptr<EventWrapper> event_;
};
CreateCalls(Call::Config(), Call::Config());
test::DirectTransport sender_transport, receiver_transport;
CreateCalls(Call::Config(&sender_transport),
Call::Config(&receiver_transport));
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
CreateSendConfig(1);
CreateMatchingReceiveConfigs();
CreateSendConfig(1, &sender_transport);
CreateMatchingReceiveConfigs(&receiver_transport);
TestFrameCallback pre_render_callback;
receive_configs_[0].pre_render_callback = &pre_render_callback;
@ -202,16 +200,14 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) {
rtc::scoped_ptr<EventWrapper> event_;
} renderer;
CreateCalls(Call::Config(), Call::Config());
test::DirectTransport sender_transport, receiver_transport;
CreateCalls(Call::Config(&sender_transport),
Call::Config(&receiver_transport));
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
CreateSendConfig(1);
CreateMatchingReceiveConfigs();
CreateSendConfig(1, &sender_transport);
CreateMatchingReceiveConfigs(&receiver_transport);
receive_configs_[0].renderer = &renderer;
CreateStreams();
@ -641,7 +637,7 @@ void EndToEndTest::TestReceivedFecPacketsNotNacked(
// TODO(holmer): Investigate why we don't send FEC packets when the bitrate
// is 10 kbps.
Call::Config GetSenderCallConfig() override {
Call::Config config(SendTransport());
Call::Config config;
const int kMinBitrateBps = 30000;
config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
return config;
@ -847,15 +843,13 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
TestFrameCallback pre_encode_callback(-1, 255); // Changes luma to 255.
TestFrameCallback pre_render_callback(255, 0); // Changes luma from 255 to 0.
CreateCalls(Call::Config(), Call::Config());
test::DirectTransport sender_transport, receiver_transport;
CreateCalls(Call::Config(&sender_transport),
Call::Config(&receiver_transport));
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
CreateSendConfig(1);
CreateSendConfig(1, &sender_transport);
rtc::scoped_ptr<VideoEncoder> encoder(
VideoEncoder::Create(VideoEncoder::kVp8));
send_config_.encoder_settings.encoder = encoder.get();
@ -865,7 +859,7 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
encoder_config_.streams[0].height = kHeight;
send_config_.pre_encode_callback = &pre_encode_callback;
CreateMatchingReceiveConfigs();
CreateMatchingReceiveConfigs(&receiver_transport);
receive_configs_[0].pre_render_callback = &pre_render_callback;
receive_configs_[0].renderer = &renderer;
@ -1016,16 +1010,15 @@ TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
rtc::scoped_ptr<EventWrapper> delivered_packet_;
};
CreateCalls(Call::Config(), Call::Config());
test::DirectTransport send_transport, receive_transport;
CreateCalls(Call::Config(&send_transport), Call::Config(&receive_transport));
PacketInputObserver input_observer(receiver_call_->Receiver());
send_transport.SetReceiver(&input_observer);
receive_transport.SetReceiver(sender_call_->Receiver());
CreateSendConfig(1);
CreateMatchingReceiveConfigs();
CreateSendConfig(1, &send_transport);
CreateMatchingReceiveConfigs(&receive_transport);
CreateStreams();
CreateFrameGeneratorCapturer();
@ -1157,10 +1150,8 @@ class MultiStreamTest {
rtc::scoped_ptr<test::DirectTransport> receiver_transport(
CreateReceiveTransport());
rtc::scoped_ptr<Call> sender_call(
Call::Create(Call::Config(sender_transport.get())));
rtc::scoped_ptr<Call> receiver_call(
Call::Create(Call::Config(receiver_transport.get())));
rtc::scoped_ptr<Call> sender_call(Call::Create(Call::Config()));
rtc::scoped_ptr<Call> receiver_call(Call::Create(Call::Config()));
sender_transport->SetReceiver(receiver_call->Receiver());
receiver_transport->SetReceiver(sender_call->Receiver());
@ -1178,7 +1169,7 @@ class MultiStreamTest {
int width = codec_settings[i].width;
int height = codec_settings[i].height;
VideoSendStream::Config send_config;
VideoSendStream::Config send_config(sender_transport.get());
send_config.rtp.ssrcs.push_back(ssrc);
send_config.encoder_settings.encoder = encoders[i].get();
send_config.encoder_settings.payload_name = "VP8";
@ -1198,7 +1189,7 @@ class MultiStreamTest {
sender_call->CreateVideoSendStream(send_config, encoder_config);
send_streams[i]->Start();
VideoReceiveStream::Config receive_config;
VideoReceiveStream::Config receive_config(receiver_transport.get());
receive_config.rtp.remote_ssrc = ssrc;
receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalSsrc;
VideoReceiveStream::Decoder decoder =
@ -1477,16 +1468,14 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
EncodedFrameTestObserver post_encode_observer;
EncodedFrameTestObserver pre_decode_observer;
CreateCalls(Call::Config(), Call::Config());
test::DirectTransport sender_transport, receiver_transport;
CreateCalls(Call::Config(&sender_transport),
Call::Config(&receiver_transport));
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
CreateSendConfig(1);
CreateMatchingReceiveConfigs();
CreateSendConfig(1, &sender_transport);
CreateMatchingReceiveConfigs(&receiver_transport);
send_config_.post_encode_callback = &post_encode_observer;
receive_configs_[0].pre_decode_callback = &pre_decode_observer;
@ -2618,11 +2607,10 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_);
} observer(use_rtx);
CreateCalls(Call::Config(observer.SendTransport()),
Call::Config(observer.ReceiveTransport()));
CreateCalls(Call::Config(), Call::Config());
observer.SetReceivers(sender_call_->Receiver(), nullptr);
CreateSendConfig(kNumSsrcs);
CreateSendConfig(kNumSsrcs, observer.SendTransport());
if (use_rtx) {
for (size_t i = 0; i < kNumSsrcs; ++i) {
@ -2651,7 +2639,7 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
encoder_config_.streams[i].max_bitrate_bps;
}
CreateMatchingReceiveConfigs();
CreateMatchingReceiveConfigs(observer.ReceiveTransport());
CreateStreams();
CreateFrameGeneratorCapturer();
@ -2889,20 +2877,18 @@ TEST_F(EndToEndTest, CallReportsRttForSender) {
static const int kSendDelayMs = 30;
static const int kReceiveDelayMs = 70;
CreateCalls(Call::Config(), Call::Config());
FakeNetworkPipe::Config config;
config.queue_delay_ms = kSendDelayMs;
test::DirectTransport sender_transport(config);
config.queue_delay_ms = kReceiveDelayMs;
test::DirectTransport receiver_transport(config);
CreateCalls(Call::Config(&sender_transport),
Call::Config(&receiver_transport));
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
CreateSendConfig(1);
CreateMatchingReceiveConfigs();
CreateSendConfig(1, &sender_transport);
CreateMatchingReceiveConfigs(&receiver_transport);
CreateStreams();
CreateFrameGeneratorCapturer();
@ -2938,11 +2924,11 @@ TEST_F(EndToEndTest, NewSendStreamsRespectNetworkDown) {
}
};
UnusedTransport transport;
CreateSenderCall(Call::Config(&transport));
CreateSenderCall(Call::Config());
sender_call_->SignalNetworkState(kNetworkDown);
CreateSendConfig(1);
UnusedTransport transport;
CreateSendConfig(1, &transport);
UnusedEncoder unused_encoder;
send_config_.encoder_settings.encoder = &unused_encoder;
CreateStreams();
@ -2956,16 +2942,14 @@ TEST_F(EndToEndTest, NewSendStreamsRespectNetworkDown) {
}
TEST_F(EndToEndTest, NewReceiveStreamsRespectNetworkDown) {
test::DirectTransport sender_transport;
CreateSenderCall(Call::Config(&sender_transport));
UnusedTransport transport;
CreateReceiverCall(Call::Config(&transport));
sender_transport.SetReceiver(receiver_call_->Receiver());
CreateCalls(Call::Config(), Call::Config());
receiver_call_->SignalNetworkState(kNetworkDown);
CreateSendConfig(1);
CreateMatchingReceiveConfigs();
test::DirectTransport sender_transport;
sender_transport.SetReceiver(receiver_call_->Receiver());
CreateSendConfig(1, &sender_transport);
UnusedTransport transport;
CreateMatchingReceiveConfigs(&transport);
CreateStreams();
CreateFrameGeneratorCapturer();
@ -2982,11 +2966,11 @@ TEST_F(EndToEndTest, NewReceiveStreamsRespectNetworkDown) {
// a backend. This is to test that we hand channels back properly.
TEST_F(EndToEndTest, CanCreateAndDestroyManyVideoStreams) {
test::NullTransport transport;
rtc::scoped_ptr<Call> call(Call::Create(Call::Config(&transport)));
rtc::scoped_ptr<Call> call(Call::Create(Call::Config()));
test::FakeDecoder fake_decoder;
test::FakeEncoder fake_encoder(Clock::GetRealTimeClock());
for (size_t i = 0; i < 100; ++i) {
VideoSendStream::Config send_config;
VideoSendStream::Config send_config(&transport);
send_config.encoder_settings.encoder = &fake_encoder;
send_config.encoder_settings.payload_name = "FAKE";
send_config.encoder_settings.payload_type = 123;
@ -2998,7 +2982,7 @@ TEST_F(EndToEndTest, CanCreateAndDestroyManyVideoStreams) {
call->CreateVideoSendStream(send_config, encoder_config);
call->DestroyVideoSendStream(send_stream);
VideoReceiveStream::Config receive_config;
VideoReceiveStream::Config receive_config(&transport);
receive_config.rtp.remote_ssrc = 1;
receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
VideoReceiveStream::Decoder decoder;
@ -3027,7 +3011,7 @@ void VerifyEmptyFecConfig(const FecConfig& config) {
}
TEST_F(EndToEndTest, VerifyDefaultSendConfigParameters) {
VideoSendStream::Config default_send_config;
VideoSendStream::Config default_send_config(nullptr);
EXPECT_EQ(0, default_send_config.rtp.nack.rtp_history_ms)
<< "Enabling NACK require rtcp-fb: nack negotiation.";
EXPECT_TRUE(default_send_config.rtp.rtx.ssrcs.empty())
@ -3040,7 +3024,7 @@ TEST_F(EndToEndTest, VerifyDefaultSendConfigParameters) {
}
TEST_F(EndToEndTest, VerifyDefaultReceiveConfigParameters) {
VideoReceiveStream::Config default_receive_config;
VideoReceiveStream::Config default_receive_config(nullptr);
EXPECT_EQ(newapi::kRtcpCompound, default_receive_config.rtp.rtcp_mode)
<< "Reduced-size RTCP require rtcp-rsize to be negotiated.";
EXPECT_FALSE(default_receive_config.rtp.remb)

6
webrtc/video/full_stack.cc
View File

@ -492,13 +492,13 @@ void FullStackTest::RunTest(const FullStackTestParams& params) {
params.avg_psnr_threshold, params.avg_ssim_threshold,
params.test_durations_secs * params.clip.fps);
CreateCalls(Call::Config(&analyzer), Call::Config(&recv_transport));
CreateCalls(Call::Config(), Call::Config());
analyzer.SetReceiver(receiver_call_->Receiver());
send_transport.SetReceiver(&analyzer);
recv_transport.SetReceiver(sender_call_->Receiver());
CreateSendConfig(1);
CreateSendConfig(1, &analyzer);
rtc::scoped_ptr<VideoEncoder> encoder;
if (params.codec == "VP8") {
@ -552,7 +552,7 @@ void FullStackTest::RunTest(const FullStackTestParams& params) {
stream->temporal_layer_thresholds_bps.push_back(stream->target_bitrate_bps);
}
CreateMatchingReceiveConfigs();
CreateMatchingReceiveConfigs(&recv_transport);
receive_configs_[0].renderer = &analyzer;
receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
receive_configs_[0].rtp.rtx[kSendRtxPayloadType].ssrc = kSendRtxSsrcs[0];

25
webrtc/video/loopback.cc
View File

@ -61,15 +61,7 @@ void Loopback::Run() {
test::VideoRenderer::Create("Loopback Video", config_.width,
config_.height));
FakeNetworkPipe::Config pipe_config;
pipe_config.loss_percent = config_.loss_percent;
pipe_config.link_capacity_kbps = config_.link_capacity_kbps;
pipe_config.queue_length_packets = config_.queue_size;
pipe_config.queue_delay_ms = config_.avg_propagation_delay_ms;
pipe_config.delay_standard_deviation_ms = config_.std_propagation_delay_ms;
test::DirectTransport transport(pipe_config);
Call::Config call_config(&transport);
Call::Config call_config;
call_config.bitrate_config.min_bitrate_bps =
static_cast<int>(config_.min_bitrate_kbps) * 1000;
call_config.bitrate_config.start_bitrate_bps =
@ -78,10 +70,17 @@ void Loopback::Run() {
static_cast<int>(config_.max_bitrate_kbps) * 1000;
rtc::scoped_ptr<Call> call(Call::Create(call_config));
FakeNetworkPipe::Config pipe_config;
pipe_config.loss_percent = config_.loss_percent;
pipe_config.link_capacity_kbps = config_.link_capacity_kbps;
pipe_config.queue_length_packets = config_.queue_size;
pipe_config.queue_delay_ms = config_.avg_propagation_delay_ms;
pipe_config.delay_standard_deviation_ms = config_.std_propagation_delay_ms;
test::DirectTransport send_transport(pipe_config);
// Loopback, call sends to itself.
transport.SetReceiver(call->Receiver());
send_transport.SetReceiver(call->Receiver());
VideoSendStream::Config send_config;
VideoSendStream::Config send_config(&send_transport);
send_config.rtp.ssrcs.push_back(kSendSsrc);
send_config.rtp.rtx.ssrcs.push_back(kSendRtxSsrc);
send_config.rtp.rtx.payload_type = kRtxVideoPayloadType;
@ -111,7 +110,7 @@ void Loopback::Run() {
rtc::scoped_ptr<test::VideoCapturer> capturer(CreateCapturer(send_stream));
VideoReceiveStream::Config receive_config;
VideoReceiveStream::Config receive_config(&send_transport);
receive_config.rtp.remote_ssrc = send_config.rtp.ssrcs[0];
receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
receive_config.rtp.nack.rtp_history_ms = 1000;
@ -143,7 +142,7 @@ void Loopback::Run() {
delete decoder.decoder;
transport.StopSending();
send_transport.StopSending();
}
VideoEncoderConfig Loopback::CreateEncoderConfig() {

10
webrtc/video/packet_injection_tests.cc
View File

@ -36,12 +36,12 @@ void PacketInjectionTest::InjectIncorrectPacket(CodecType codec_type,
uint8_t payload_type,
const uint8_t* packet,
size_t length) {
test::NullTransport transport;
CreateSenderCall(Call::Config(&transport));
CreateReceiverCall(Call::Config(&transport));
CreateSenderCall(Call::Config());
CreateReceiverCall(Call::Config());
CreateSendConfig(1);
CreateMatchingReceiveConfigs();
test::NullTransport null_transport;
CreateSendConfig(1, &null_transport);
CreateMatchingReceiveConfigs(&null_transport);
receive_configs_[0].decoders[0].payload_type = payload_type;
switch (codec_type) {
case CodecType::kVp8:

13
webrtc/video/rampup_tests.cc
View File

@ -381,13 +381,13 @@ void RampUpTest::RunRampUpTest(size_t num_streams,
rtx_ssrc_map[rtx_ssrcs[i]] = ssrcs[i];
}
CreateSendConfig(num_streams);
send_config_.rtp.extensions.clear();
test::DirectTransport receiver_transport;
StreamObserver stream_observer(rtx_ssrc_map, &receiver_transport,
Clock::GetRealTimeClock());
CreateSendConfig(num_streams, &stream_observer);
send_config_.rtp.extensions.clear();
if (extension_type == RtpExtension::kAbsSendTime) {
stream_observer.SetRemoteBitrateEstimator(
new RemoteBitrateEstimatorAbsSendTime(
@ -404,12 +404,11 @@ void RampUpTest::RunRampUpTest(size_t num_streams,
extension_type.c_str(), kTransmissionTimeOffsetExtensionId));
}
Call::Config call_config(&stream_observer);
Call::Config call_config;
if (start_bitrate_bps != 0) {
call_config.bitrate_config.start_bitrate_bps = start_bitrate_bps;
stream_observer.set_start_bitrate_bps(start_bitrate_bps);
}
CreateSenderCall(call_config);
receiver_transport.SetReceiver(sender_call_->Receiver());
@ -462,12 +461,12 @@ void RampUpTest::RunRampUpDownUpTest(size_t number_of_streams,
LowRateStreamObserver stream_observer(
&receiver_transport, Clock::GetRealTimeClock(), number_of_streams, rtx);
Call::Config call_config(&stream_observer);
Call::Config call_config;
call_config.bitrate_config.start_bitrate_bps = 60000;
CreateSenderCall(call_config);
receiver_transport.SetReceiver(sender_call_->Receiver());
CreateSendConfig(number_of_streams);
CreateSendConfig(number_of_streams, &stream_observer);
send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
send_config_.rtp.extensions.push_back(RtpExtension(

9
webrtc/video/replay.cc
View File

@ -214,13 +214,10 @@ void RtpReplay() {
FileRenderPassthrough file_passthrough(flags::OutBase(),
playback_video.get());
// TODO(pbos): Might be good to have a transport that prints keyframe requests
// etc.
test::NullTransport transport;
Call::Config call_config(&transport);
rtc::scoped_ptr<Call> call(Call::Create(call_config));
rtc::scoped_ptr<Call> call(Call::Create(Call::Config()));
VideoReceiveStream::Config receive_config;
test::NullTransport transport;
VideoReceiveStream::Config receive_config(&transport);
receive_config.rtp.remote_ssrc = flags::Ssrc();
receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
receive_config.rtp.fec.ulpfec_payload_type = flags::FecPayloadType();

4
webrtc/video/rtc_event_log_unittest.cc
View File

@ -310,8 +310,8 @@ void LogSessionAndReadBack(size_t rtp_count, unsigned random_seed) {
std::vector<uint8_t> incoming_rtcp_packet;
std::vector<uint8_t> outgoing_rtcp_packet;
VideoReceiveStream::Config receiver_config;
VideoSendStream::Config sender_config;
VideoReceiveStream::Config receiver_config(nullptr);
VideoSendStream::Config sender_config(nullptr);
srand(random_seed);

6
webrtc/video/send_statistics_proxy_unittest.cc
View File

@ -22,19 +22,19 @@ namespace webrtc {
class SendStatisticsProxyTest : public ::testing::Test {
public:
SendStatisticsProxyTest()
: fake_clock_(1234), avg_delay_ms_(0), max_delay_ms_(0) {}
: fake_clock_(1234), config_(GetTestConfig()), avg_delay_ms_(0),
max_delay_ms_(0) {}
virtual ~SendStatisticsProxyTest() {}
protected:
virtual void SetUp() {
statistics_proxy_.reset(
new SendStatisticsProxy(&fake_clock_, GetTestConfig()));
config_ = GetTestConfig();
expected_ = VideoSendStream::Stats();
}
VideoSendStream::Config GetTestConfig() {
VideoSendStream::Config config;
VideoSendStream::Config config(nullptr);
config.rtp.ssrcs.push_back(17);
config.rtp.ssrcs.push_back(42);
config.rtp.rtx.ssrcs.push_back(18);

6
webrtc/video/transport_adapter.cc
View File

@ -10,11 +10,15 @@
#include "webrtc/video/transport_adapter.h"
#include "webrtc/base/checks.h"
namespace webrtc {
namespace internal {
TransportAdapter::TransportAdapter(newapi::Transport* transport)
: transport_(transport), enabled_(0) {}
: transport_(transport), enabled_(0) {
DCHECK(nullptr != transport);
}
int TransportAdapter::SendPacket(int /*channel*/,
const void* packet,

2
webrtc/video/video_capture_input_unittest.cc
View File

@ -54,7 +54,7 @@ class VideoCaptureInputTest : public ::testing::Test {
mock_frame_callback_(new NiceMock<MockVideoCaptureCallback>),
output_frame_event_(EventWrapper::Create()),
stats_proxy_(Clock::GetRealTimeClock(),
webrtc::VideoSendStream::Config()) {}
webrtc::VideoSendStream::Config(nullptr)) {}
virtual void SetUp() {
EXPECT_CALL(*mock_frame_callback_, DeliverFrame(_))

3
webrtc/video/video_receive_stream.cc
View File

@ -128,9 +128,8 @@ VideoReceiveStream::VideoReceiveStream(int num_cpu_cores,
ChannelGroup* channel_group,
int channel_id,
const VideoReceiveStream::Config& config,
newapi::Transport* transport,
webrtc::VoiceEngine* voice_engine)
: transport_adapter_(transport),
: transport_adapter_(config.rtcp_send_transport),
encoded_frame_proxy_(config.pre_decode_callback),
config_(config),
clock_(Clock::GetRealTimeClock()),

1
webrtc/video/video_receive_stream.h
View File

@ -41,7 +41,6 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
ChannelGroup* channel_group,
int channel_id,
const VideoReceiveStream::Config& config,
newapi::Transport* transport,
webrtc::VoiceEngine* voice_engine);
~VideoReceiveStream() override;

3
webrtc/video/video_send_stream.cc
View File

@ -101,7 +101,6 @@ std::string VideoSendStream::Config::ToString() const {
namespace internal {
VideoSendStream::VideoSendStream(
newapi::Transport* transport,
CpuOveruseObserver* overuse_observer,
int num_cpu_cores,
ProcessThread* module_process_thread,
@ -110,7 +109,7 @@ VideoSendStream::VideoSendStream(
const VideoSendStream::Config& config,
const VideoEncoderConfig& encoder_config,
const std::map<uint32_t, RtpState>& suspended_ssrcs)
: transport_adapter_(transport),
: transport_adapter_(config.send_transport),
encoded_frame_proxy_(config.post_encode_callback),
config_(config),
suspended_ssrcs_(suspended_ssrcs),

3
webrtc/video/video_send_stream.h
View File

@ -37,8 +37,7 @@ namespace internal {
class VideoSendStream : public webrtc::VideoSendStream {
public:
VideoSendStream(newapi::Transport* transport,
CpuOveruseObserver* overuse_observer,
VideoSendStream(CpuOveruseObserver* overuse_observer,
int num_cpu_cores,
ProcessThread* module_process_thread,
ChannelGroup* channel_group,

28
webrtc/video/video_send_stream_tests.cc
View File

@ -59,11 +59,11 @@ class VideoSendStreamTest : public test::CallTest {
};
TEST_F(VideoSendStreamTest, CanStartStartedStream) {
test::NullTransport transport;
Call::Config call_config(&transport);
Call::Config call_config;
CreateSenderCall(call_config);
CreateSendConfig(1);
test::NullTransport transport;
CreateSendConfig(1, &transport);
CreateStreams();
send_stream_->Start();
send_stream_->Start();
@ -71,11 +71,11 @@ TEST_F(VideoSendStreamTest, CanStartStartedStream) {
}
TEST_F(VideoSendStreamTest, CanStopStoppedStream) {
test::NullTransport transport;
Call::Config call_config(&transport);
Call::Config call_config;
CreateSenderCall(call_config);
CreateSendConfig(1);
test::NullTransport transport;
CreateSendConfig(1, &transport);
CreateStreams();
send_stream_->Stop();
send_stream_->Stop();
@ -614,7 +614,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
}
Call::Config GetSenderCallConfig() override {
Call::Config config(SendTransport());
Call::Config config;
const int kMinBitrateBps = 30000;
config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
return config;
@ -1044,10 +1044,10 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
int start_bitrate_kbps_ GUARDED_BY(crit_);
};
test::NullTransport transport;
CreateSenderCall(Call::Config(&transport));
CreateSenderCall(Call::Config());
CreateSendConfig(1);
test::NullTransport transport;
CreateSendConfig(1, &transport);
Call::Config::BitrateConfig bitrate_config;
bitrate_config.start_bitrate_bps =
@ -1104,10 +1104,10 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {
};
// Initialize send stream.
test::NullTransport transport;
CreateSenderCall(Call::Config(&transport));
CreateSenderCall(Call::Config());
CreateSendConfig(1);
test::NullTransport transport;
CreateSendConfig(1, &transport);
FrameObserver observer;
send_config_.pre_encode_callback = &observer;
CreateStreams();
@ -1659,7 +1659,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
}
Call::Config GetSenderCallConfig() override {
Call::Config config(SendTransport());
Call::Config config;
config.bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000;
config.bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000;
config.bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000;

7
webrtc/video_receive_stream.h
View File

@ -86,6 +86,10 @@ class VideoReceiveStream : public ReceiveStream {
};
struct Config {
Config() = delete;
explicit Config(newapi::Transport* rtcp_send_transport)
: rtcp_send_transport(rtcp_send_transport) {}
std::string ToString() const;
// Decoders for every payload that we can receive.
@ -137,6 +141,9 @@ class VideoReceiveStream : public ReceiveStream {
std::vector<RtpExtension> extensions;
} rtp;
// Transport for outgoing packets (RTCP).
newapi::Transport* rtcp_send_transport = nullptr;
// VideoRenderer will be called for each decoded frame. 'nullptr' disables
// rendering of this stream.
VideoRenderer* renderer = nullptr;

8
webrtc/video_send_stream.h
View File

@ -18,6 +18,7 @@
#include "webrtc/config.h"
#include "webrtc/frame_callback.h"
#include "webrtc/stream.h"
#include "webrtc/transport.h"
#include "webrtc/video_renderer.h"
namespace webrtc {
@ -64,6 +65,10 @@ class VideoSendStream : public SendStream {
};
struct Config {
Config() = delete;
explicit Config(newapi::Transport* send_transport)
: send_transport(send_transport) {}
std::string ToString() const;
struct EncoderSettings {
@ -110,6 +115,9 @@ class VideoSendStream : public SendStream {
std::string c_name;
} rtp;
// Transport for outgoing packets.
newapi::Transport* send_transport = nullptr;
// Called for each I420 frame before encoding the frame. Can be used for
// effects, snapshots etc. 'nullptr' disables the callback.
I420FrameCallback* pre_encode_callback = nullptr;