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

Don't hardcode MediaType::ANY in FakeNetworkPipe.

Browse Source 
Instead let each test set the appropriate media type. This simplifies
demuxing in Call and later in RtpTransportController.

BUG=webrtc:7135

Review-Url: https://codereview.webrtc.org/2774463003
Cr-Commit-Position: refs/heads/master@{#17418}
This commit is contained in:
nisse
2017-03-28 04:59:41 -07:00
committed by Commit bot
parent 0238ba8327
commit 9c47b00e24
19 changed files with 128 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
webrtc/audio/test/low_bandwidth_audio_test.cc
View File

@ -80,12 +80,14 @@ test::PacketTransport* AudioQualityTest::CreateSendTransport(
Call* sender_call) {
return new test::PacketTransport(
sender_call, this, test::PacketTransport::kSender,
MediaType::AUDIO,
GetNetworkPipeConfig());
}
test::PacketTransport* AudioQualityTest::CreateReceiveTransport() {
return new test::PacketTransport(nullptr, this,
test::PacketTransport::kReceiver, GetNetworkPipeConfig());
test::PacketTransport::kReceiver, MediaType::AUDIO,
GetNetworkPipeConfig());
}
void AudioQualityTest::ModifyAudioConfigs(

6
webrtc/call/bitrate_estimator_tests.cc
View File

@ -108,9 +108,11 @@ class BitrateEstimatorTest : public test::CallTest {
receiver_call_.reset(Call::Create(config));
sender_call_.reset(Call::Create(config));
send_transport_.reset(new test::DirectTransport(sender_call_.get()));
send_transport_.reset(
new test::DirectTransport(sender_call_.get(), MediaType::VIDEO));
send_transport_->SetReceiver(receiver_call_->Receiver());
receive_transport_.reset(new test::DirectTransport(receiver_call_.get()));
receive_transport_.reset(
new test::DirectTransport(receiver_call_.get(), MediaType::VIDEO));
receive_transport_->SetReceiver(sender_call_->Receiver());
video_send_config_ = VideoSendStream::Config(send_transport_.get());

8
webrtc/call/call.cc
View File

@ -1221,6 +1221,8 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
const PacketTime& packet_time) {
TRACE_EVENT0("webrtc", "Call::DeliverRtp");
RTC_DCHECK(media_type == MediaType::AUDIO || media_type == MediaType::VIDEO);
ReadLockScoped read_lock(*receive_crit_);
// TODO(nisse): We should parse the RTP header only here, and pass
// on parsed_packet to the receive streams.
@ -1234,7 +1236,7 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
uint32_t ssrc = parsed_packet->Ssrc();
if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
if (media_type == MediaType::AUDIO) {
auto it = audio_receive_ssrcs_.find(ssrc);
if (it != audio_receive_ssrcs_.end()) {
received_bytes_per_second_counter_.Add(static_cast<int>(length));
@ -1244,7 +1246,7 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
return DELIVERY_OK;
}
}
if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
if (media_type == MediaType::VIDEO) {
auto it = video_receive_ssrcs_.find(ssrc);
if (it != video_receive_ssrcs_.end()) {
received_bytes_per_second_counter_.Add(static_cast<int>(length));
@ -1260,7 +1262,7 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
return DELIVERY_OK;
}
}
if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
if (media_type == MediaType::VIDEO) {
received_bytes_per_second_counter_.Add(static_cast<int>(length));
// TODO(brandtr): Update here when FlexFEC supports protecting audio.
received_video_bytes_per_second_counter_.Add(static_cast<int>(length));

9
webrtc/call/call_perf_tests.cc
View File

@ -193,6 +193,7 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
audio_net_config.loss_percent = 5;
test::PacketTransport audio_send_transport(sender_call_.get(), &observer,
test::PacketTransport::kSender,
MediaType::AUDIO,
audio_net_config);
MediaTypePacketReceiver audio_receiver(receiver_call_->Receiver(),
MediaType::AUDIO);
@ -200,6 +201,7 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
test::PacketTransport video_send_transport(sender_call_.get(), &observer,
test::PacketTransport::kSender,
MediaType::VIDEO,
FakeNetworkPipe::Config());
MediaTypePacketReceiver video_receiver(receiver_call_->Receiver(),
MediaType::VIDEO);
@ -207,6 +209,7 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
test::PacketTransport receive_transport(
receiver_call_.get(), &observer, test::PacketTransport::kReceiver,
MediaType::VIDEO,
FakeNetworkPipe::Config());
receive_transport.SetReceiver(sender_call_->Receiver());
@ -343,12 +346,14 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
private:
test::PacketTransport* CreateSendTransport(Call* sender_call) override {
return new test::PacketTransport(
sender_call, this, test::PacketTransport::kSender, net_config_);
sender_call, this, test::PacketTransport::kSender, MediaType::VIDEO,
net_config_);
}
test::PacketTransport* CreateReceiveTransport() override {
return new test::PacketTransport(
nullptr, this, test::PacketTransport::kReceiver, net_config_);
nullptr, this, test::PacketTransport::kReceiver, MediaType::VIDEO,
net_config_);
}
void OnFrame(const VideoFrame& video_frame) override {

1
webrtc/call/rampup_tests.cc
View File

@ -92,6 +92,7 @@ void RampUpTester::OnVideoStreamsCreated(
test::PacketTransport* RampUpTester::CreateSendTransport(Call* sender_call) {
send_transport_ = new test::PacketTransport(sender_call, this,
test::PacketTransport::kSender,
MediaType::AUDIO,
forward_transport_config_);
return send_transport_;
}

9
webrtc/media/engine/fakewebrtccall.cc
View File

@ -520,19 +520,20 @@ FakeCall::DeliveryStatus FakeCall::DeliverPacket(
size_t length,
const webrtc::PacketTime& packet_time) {
EXPECT_GE(length, 12u);
RTC_DCHECK(media_type == webrtc::MediaType::AUDIO ||
media_type == webrtc::MediaType::VIDEO);
uint32_t ssrc;
if (!GetRtpSsrc(packet, length, &ssrc))
return DELIVERY_PACKET_ERROR;
if (media_type == webrtc::MediaType::ANY ||
media_type == webrtc::MediaType::VIDEO) {
if (media_type == webrtc::MediaType::VIDEO) {
for (auto receiver : video_receive_streams_) {
if (receiver->GetConfig().rtp.remote_ssrc == ssrc)
return DELIVERY_OK;
}
}
if (media_type == webrtc::MediaType::ANY ||
media_type == webrtc::MediaType::AUDIO) {
if (media_type == webrtc::MediaType::AUDIO) {
for (auto receiver : audio_receive_streams_) {
if (receiver->GetConfig().rtp.remote_ssrc == ssrc) {
receiver->DeliverRtp(packet, length, packet_time);

2
webrtc/test/call_test.cc
View File

@ -458,11 +458,13 @@ void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {
test::PacketTransport* BaseTest::CreateSendTransport(Call* sender_call) {
return new PacketTransport(sender_call, this, test::PacketTransport::kSender,
MediaType::VIDEO,
FakeNetworkPipe::Config());
}
test::PacketTransport* BaseTest::CreateReceiveTransport() {
return new PacketTransport(nullptr, this, test::PacketTransport::kReceiver,
MediaType::VIDEO,
FakeNetworkPipe::Config());
}

1
webrtc/test/call_test.h
View File

@ -172,6 +172,7 @@ class BaseTest : public RtpRtcpObserver {
virtual Call::Config GetReceiverCallConfig();
virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
// The default implementation creates MediaType::VIDEO transports.
virtual test::PacketTransport* CreateSendTransport(Call* sender_call);
virtual test::PacketTransport* CreateReceiveTransport();

8
webrtc/test/direct_transport.cc
View File

@ -15,17 +15,17 @@
namespace webrtc {
namespace test {
DirectTransport::DirectTransport(Call* send_call)
: DirectTransport(FakeNetworkPipe::Config(), send_call) {}
DirectTransport::DirectTransport(Call* send_call, MediaType media_type)
: DirectTransport(FakeNetworkPipe::Config(), send_call, media_type) {}
DirectTransport::DirectTransport(const FakeNetworkPipe::Config& config,
Call* send_call)
Call* send_call, MediaType media_type)
: send_call_(send_call),
packet_event_(false, false),
thread_(NetworkProcess, this, "NetworkProcess"),
clock_(Clock::GetRealTimeClock()),
shutting_down_(false),
fake_network_(clock_, config) {
fake_network_(clock_, config, media_type) {
thread_.Start();
if (send_call_) {
send_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp);

15
webrtc/test/direct_transport.h
View File

@ -18,11 +18,11 @@
#include "webrtc/base/criticalsection.h"
#include "webrtc/base/event.h"
#include "webrtc/base/platform_thread.h"
#include "webrtc/call/call.h"
#include "webrtc/test/fake_network_pipe.h"
namespace webrtc {
class Call;
class Clock;
class PacketReceiver;
@ -30,8 +30,17 @@ namespace test {
class DirectTransport : public Transport {
public:
explicit DirectTransport(Call* send_call);
DirectTransport(const FakeNetworkPipe::Config& config, Call* send_call);
DirectTransport(Call* send_call, MediaType media_type);
DirectTransport(const FakeNetworkPipe::Config& config, Call* send_call,
MediaType media_type);
// These deprecated variants always use MediaType::VIDEO.
RTC_DEPRECATED explicit DirectTransport(Call* send_call)
: DirectTransport(send_call, MediaType::VIDEO) {}
RTC_DEPRECATED DirectTransport(const FakeNetworkPipe::Config& config,
Call* send_call)
: DirectTransport(config, send_call, MediaType::VIDEO) {}
~DirectTransport();
void SetConfig(const FakeNetworkPipe::Config& config);

9
webrtc/test/fake_network_pipe.cc
View File

@ -28,13 +28,16 @@ constexpr int64_t kDefaultProcessIntervalMs = 5;
}
FakeNetworkPipe::FakeNetworkPipe(Clock* clock,
const FakeNetworkPipe::Config& config)
: FakeNetworkPipe(clock, config, 1) {}
const FakeNetworkPipe::Config& config,
MediaType media_type)
: FakeNetworkPipe(clock, config, media_type, 1) {}
FakeNetworkPipe::FakeNetworkPipe(Clock* clock,
const FakeNetworkPipe::Config& config,
MediaType media_type,
uint64_t seed)
: clock_(clock),
media_type_(media_type),
packet_receiver_(NULL),
random_(seed),
config_(),
@ -199,7 +202,7 @@ void FakeNetworkPipe::Process() {
while (!packets_to_deliver.empty()) {
NetworkPacket* packet = packets_to_deliver.front();
packets_to_deliver.pop();
packet_receiver_->DeliverPacket(MediaType::ANY, packet->data(),
packet_receiver_->DeliverPacket(media_type_, packet->data(),
packet->data_length(), PacketTime());
delete packet;
}

7
webrtc/test/fake_network_pipe.h
View File

@ -25,6 +25,7 @@ namespace webrtc {
class Clock;
class PacketReceiver;
enum class MediaType;
class NetworkPacket {
public:
@ -82,9 +83,10 @@ class FakeNetworkPipe {
int avg_burst_loss_length = -1;
};
FakeNetworkPipe(Clock* clock, const FakeNetworkPipe::Config& config);
FakeNetworkPipe(Clock* clock, const FakeNetworkPipe::Config& config,
MediaType media_type);
FakeNetworkPipe(Clock* clock,
const FakeNetworkPipe::Config& config,
const FakeNetworkPipe::Config& config, MediaType media_type,
uint64_t seed);
~FakeNetworkPipe();
@ -110,6 +112,7 @@ class FakeNetworkPipe {
private:
Clock* const clock_;
const MediaType media_type_;
rtc::CriticalSection lock_;
PacketReceiver* packet_receiver_;
std::queue<NetworkPacket*> capacity_link_;

52
webrtc/test/fake_network_pipe_unittest.cc
View File

@ -96,7 +96,7 @@ TEST_F(FakeNetworkPipeTest, CapacityTest) {
config.queue_length_packets = 20;
config.link_capacity_kbps = 80;
std::unique_ptr<FakeNetworkPipe> pipe(
new FakeNetworkPipe(&fake_clock_, config));
new FakeNetworkPipe(&fake_clock_, config, MediaType::VIDEO));
pipe->SetReceiver(receiver_.get());
// Add 10 packets of 1000 bytes, = 80 kb, and verify it takes one second to
@ -110,22 +110,22 @@ TEST_F(FakeNetworkPipeTest, CapacityTest) {
kPacketSize);
// Time haven't increased yet, so we souldn't get any packets.
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::VIDEO, _, _, _)).Times(0);
pipe->Process();
// Advance enough time to release one packet.
fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::VIDEO, _, _, _)).Times(1);
pipe->Process();
// Release all but one packet
fake_clock_.AdvanceTimeMilliseconds(9 * kPacketTimeMs - 1);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(8);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::VIDEO, _, _, _)).Times(8);
pipe->Process();
// And the last one.
fake_clock_.AdvanceTimeMilliseconds(1);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::VIDEO, _, _, _)).Times(1);
pipe->Process();
}
@ -136,7 +136,7 @@ TEST_F(FakeNetworkPipeTest, ExtraDelayTest) {
config.queue_delay_ms = 100;
config.link_capacity_kbps = 80;
std::unique_ptr<FakeNetworkPipe> pipe(
new FakeNetworkPipe(&fake_clock_, config));
new FakeNetworkPipe(&fake_clock_, config, MediaType::AUDIO));
pipe->SetReceiver(receiver_.get());
const int kNumPackets = 2;
@ -149,17 +149,17 @@ TEST_F(FakeNetworkPipeTest, ExtraDelayTest) {
// Increase more than kPacketTimeMs, but not more than the extra delay.
fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::AUDIO, _, _, _)).Times(0);
pipe->Process();
// Advance the network delay to get the first packet.
fake_clock_.AdvanceTimeMilliseconds(config.queue_delay_ms);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::AUDIO, _, _, _)).Times(1);
pipe->Process();
// Advance one more kPacketTimeMs to get the last packet.
fake_clock_.AdvanceTimeMilliseconds(kPacketTimeMs);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::AUDIO, _, _, _)).Times(1);
pipe->Process();
}
@ -170,7 +170,7 @@ TEST_F(FakeNetworkPipeTest, QueueLengthTest) {
config.queue_length_packets = 2;
config.link_capacity_kbps = 80;
std::unique_ptr<FakeNetworkPipe> pipe(
new FakeNetworkPipe(&fake_clock_, config));
new FakeNetworkPipe(&fake_clock_, config, MediaType::VIDEO));
pipe->SetReceiver(receiver_.get());
const int kPacketSize = 1000;
@ -183,7 +183,7 @@ TEST_F(FakeNetworkPipeTest, QueueLengthTest) {
// Increase time enough to deliver all three packets, verify only two are
// delivered.
fake_clock_.AdvanceTimeMilliseconds(3 * kPacketTimeMs);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(2);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::VIDEO, _, _, _)).Times(2);
pipe->Process();
}
@ -194,7 +194,7 @@ TEST_F(FakeNetworkPipeTest, StatisticsTest) {
config.queue_delay_ms = 20;
config.link_capacity_kbps = 80;
std::unique_ptr<FakeNetworkPipe> pipe(
new FakeNetworkPipe(&fake_clock_, config));
new FakeNetworkPipe(&fake_clock_, config, MediaType::VIDEO));
pipe->SetReceiver(receiver_.get());
const int kPacketSize = 1000;
@ -206,7 +206,7 @@ TEST_F(FakeNetworkPipeTest, StatisticsTest) {
fake_clock_.AdvanceTimeMilliseconds(3 * kPacketTimeMs +
config.queue_delay_ms);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(2);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::VIDEO, _, _, _)).Times(2);
pipe->Process();
// Packet 1: kPacketTimeMs + config.queue_delay_ms,
@ -224,7 +224,7 @@ TEST_F(FakeNetworkPipeTest, ChangingCapacityWithEmptyPipeTest) {
config.queue_length_packets = 20;
config.link_capacity_kbps = 80;
std::unique_ptr<FakeNetworkPipe> pipe(
new FakeNetworkPipe(&fake_clock_, config));
new FakeNetworkPipe(&fake_clock_, config, MediaType::VIDEO));
pipe->SetReceiver(receiver_.get());
// Add 10 packets of 1000 bytes, = 80 kb, and verify it takes one second to
@ -237,13 +237,13 @@ TEST_F(FakeNetworkPipeTest, ChangingCapacityWithEmptyPipeTest) {
int packet_time_ms = PacketTimeMs(config.link_capacity_kbps, kPacketSize);
// Time hasn't increased yet, so we souldn't get any packets.
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::VIDEO, _, _, _)).Times(0);
pipe->Process();
// Advance time in steps to release one packet at a time.
for (int i = 0; i < kNumPackets; ++i) {
fake_clock_.AdvanceTimeMilliseconds(packet_time_ms);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::VIDEO, _, _, _)).Times(1);
pipe->Process();
}
@ -259,20 +259,20 @@ TEST_F(FakeNetworkPipeTest, ChangingCapacityWithEmptyPipeTest) {
packet_time_ms = PacketTimeMs(config.link_capacity_kbps, kPacketSize);
// Time hasn't increased yet, so we souldn't get any packets.
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::VIDEO, _, _, _)).Times(0);
pipe->Process();
// Advance time in steps to release one packet at a time.
for (int i = 0; i < kNumPackets; ++i) {
fake_clock_.AdvanceTimeMilliseconds(packet_time_ms);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::VIDEO, _, _, _)).Times(1);
pipe->Process();
}
// Check that all the packets were sent.
EXPECT_EQ(static_cast<size_t>(2 * kNumPackets), pipe->sent_packets());
fake_clock_.AdvanceTimeMilliseconds(pipe->TimeUntilNextProcess());
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::VIDEO, _, _, _)).Times(0);
pipe->Process();
}
@ -283,7 +283,7 @@ TEST_F(FakeNetworkPipeTest, ChangingCapacityWithPacketsInPipeTest) {
config.queue_length_packets = 20;
config.link_capacity_kbps = 80;
std::unique_ptr<FakeNetworkPipe> pipe(
new FakeNetworkPipe(&fake_clock_, config));
new FakeNetworkPipe(&fake_clock_, config, MediaType::AUDIO));
pipe->SetReceiver(receiver_.get());
// Add 10 packets of 1000 bytes, = 80 kb.
@ -306,27 +306,27 @@ TEST_F(FakeNetworkPipeTest, ChangingCapacityWithPacketsInPipeTest) {
int packet_time_2_ms = PacketTimeMs(config.link_capacity_kbps, kPacketSize);
// Time hasn't increased yet, so we souldn't get any packets.
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::AUDIO, _, _, _)).Times(0);
pipe->Process();
// Advance time in steps to release one packet at a time.
for (int i = 0; i < kNumPackets; ++i) {
fake_clock_.AdvanceTimeMilliseconds(packet_time_1_ms);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::AUDIO, _, _, _)).Times(1);
pipe->Process();
}
// Advance time in steps to release one packet at a time.
for (int i = 0; i < kNumPackets; ++i) {
fake_clock_.AdvanceTimeMilliseconds(packet_time_2_ms);
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::AUDIO, _, _, _)).Times(1);
pipe->Process();
}
// Check that all the packets were sent.
EXPECT_EQ(static_cast<size_t>(2 * kNumPackets), pipe->sent_packets());
fake_clock_.AdvanceTimeMilliseconds(pipe->TimeUntilNextProcess());
EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0);
EXPECT_CALL(*receiver_, DeliverPacket(MediaType::AUDIO, _, _, _)).Times(0);
pipe->Process();
}
@ -338,7 +338,7 @@ TEST_F(FakeNetworkPipeTest, DisallowReorderingThenAllowReordering) {
config.queue_delay_ms = 100;
config.delay_standard_deviation_ms = 10;
std::unique_ptr<FakeNetworkPipe> pipe(
new FakeNetworkPipe(&fake_clock_, config));
new FakeNetworkPipe(&fake_clock_, config, MediaType::VIDEO));
ReorderTestReceiver* receiver = new ReorderTestReceiver();
receiver_.reset(receiver);
pipe->SetReceiver(receiver_.get());
@ -390,7 +390,7 @@ TEST_F(FakeNetworkPipeTest, BurstLoss) {
config.loss_percent = kLossPercent;
config.avg_burst_loss_length = kAvgBurstLength;
std::unique_ptr<FakeNetworkPipe> pipe(
new FakeNetworkPipe(&fake_clock_, config));
new FakeNetworkPipe(&fake_clock_, config, MediaType::VIDEO));
ReorderTestReceiver* receiver = new ReorderTestReceiver();
receiver_.reset(receiver);
pipe->SetReceiver(receiver_.get());

2
webrtc/test/layer_filtering_transport.cc
View File

@ -27,7 +27,7 @@ LayerFilteringTransport::LayerFilteringTransport(
uint8_t vp9_video_payload_type,
int selected_tl,
int selected_sl)
: test::DirectTransport(config, send_call),
: test::DirectTransport(config, send_call, MediaType::VIDEO),
vp8_video_payload_type_(vp8_video_payload_type),
vp9_video_payload_type_(vp9_video_payload_type),
selected_tl_(selected_tl),

3
webrtc/test/rtp_rtcp_observer.h
View File

@ -94,8 +94,9 @@ class PacketTransport : public test::DirectTransport {
PacketTransport(Call* send_call,
RtpRtcpObserver* observer,
TransportType transport_type,
MediaType media_type,
const FakeNetworkPipe::Config& configuration)
: test::DirectTransport(configuration, send_call),
: test::DirectTransport(configuration, send_call, media_type),
observer_(observer),
transport_type_(transport_type) {}

51
webrtc/video/end_to_end_tests.cc
View File

@ -202,8 +202,10 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
test::DirectTransport sender_transport(sender_call_.get());
test::DirectTransport receiver_transport(receiver_call_.get());
test::DirectTransport sender_transport(
sender_call_.get(), MediaType::VIDEO);
test::DirectTransport receiver_transport(
receiver_call_.get(), MediaType::VIDEO);
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
@ -249,8 +251,10 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) {
CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
test::DirectTransport sender_transport(sender_call_.get());
test::DirectTransport receiver_transport(receiver_call_.get());
test::DirectTransport sender_transport(
sender_call_.get(), MediaType::VIDEO);
test::DirectTransport receiver_transport(
receiver_call_.get(), MediaType::VIDEO);
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
@ -521,6 +525,7 @@ TEST_F(EndToEndTest, ReceivesNackAndRetransmitsAudio) {
test::PacketTransport* CreateReceiveTransport() override {
test::PacketTransport* receive_transport = new test::PacketTransport(
nullptr, this, test::PacketTransport::kReceiver,
MediaType::AUDIO,
FakeNetworkPipe::Config());
receive_transport_ = receive_transport;
return receive_transport;
@ -782,7 +787,8 @@ class FlexfecRenderObserver : public test::EndToEndTest,
FakeNetworkPipe::Config config;
config.queue_delay_ms = kNetworkDelayMs;
return new test::PacketTransport(sender_call, this,
test::PacketTransport::kSender, config);
test::PacketTransport::kSender,
MediaType::VIDEO, config);
}
void OnFrame(const VideoFrame& video_frame) override {
@ -961,7 +967,8 @@ TEST_F(EndToEndTest, ReceivedUlpfecPacketsNotNacked) {
FakeNetworkPipe::Config config;
config.queue_delay_ms = kNetworkDelayMs;
return new test::PacketTransport(sender_call, this,
test::PacketTransport::kSender, config);
test::PacketTransport::kSender,
MediaType::VIDEO, config);
}
// TODO(holmer): Investigate why we don't send FEC packets when the bitrate
@ -1303,8 +1310,10 @@ TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
test::DirectTransport send_transport(sender_call_.get());
test::DirectTransport receive_transport(receiver_call_.get());
test::DirectTransport send_transport(
sender_call_.get(), MediaType::VIDEO);
test::DirectTransport receive_transport(
receiver_call_.get(), MediaType::VIDEO);
PacketInputObserver input_observer(receiver_call_->Receiver());
send_transport.SetReceiver(&input_observer);
receive_transport.SetReceiver(sender_call_->Receiver());
@ -1531,10 +1540,10 @@ class MultiStreamTest {
VideoReceiveStream::Config* receive_config) {
}
virtual test::DirectTransport* CreateSendTransport(Call* sender_call) {
return new test::DirectTransport(sender_call);
return new test::DirectTransport(sender_call, MediaType::VIDEO);
}
virtual test::DirectTransport* CreateReceiveTransport(Call* receiver_call) {
return new test::DirectTransport(receiver_call);
return new test::DirectTransport(receiver_call, MediaType::VIDEO);
}
};
@ -1613,7 +1622,7 @@ TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
RtpExtensionHeaderObserver(Call* sender_call,
const uint32_t& first_media_ssrc,
const std::map<uint32_t, uint32_t>& ssrc_map)
: DirectTransport(sender_call),
: DirectTransport(sender_call, MediaType::VIDEO),
done_(false, false),
parser_(RtpHeaderParser::Create()),
first_media_ssrc_(first_media_ssrc),
@ -1929,8 +1938,10 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
CreateCalls(Call::Config(&event_log_), Call::Config(&event_log_));
test::DirectTransport sender_transport(sender_call_.get());
test::DirectTransport receiver_transport(receiver_call_.get());
test::DirectTransport sender_transport(
sender_call_.get(), MediaType::VIDEO);
test::DirectTransport receiver_transport(
receiver_call_.get(), MediaType::VIDEO);
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
@ -2094,6 +2105,7 @@ TEST_F(EndToEndTest, RembWithSendSideBwe) {
test::PacketTransport* CreateReceiveTransport() override {
receive_transport_ = new test::PacketTransport(
nullptr, this, test::PacketTransport::kReceiver,
MediaType::VIDEO,
FakeNetworkPipe::Config());
return receive_transport_;
}
@ -3057,7 +3069,8 @@ TEST_F(EndToEndTest, GetStats) {
FakeNetworkPipe::Config network_config;
network_config.loss_percent = 5;
return new test::PacketTransport(
sender_call, this, test::PacketTransport::kSender, network_config);
sender_call, this, test::PacketTransport::kSender, MediaType::VIDEO,
network_config);
}
Call::Config GetSenderCallConfig() override {
@ -3611,9 +3624,11 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx,
test::PacketTransport send_transport(sender_call_.get(), &observer,
test::PacketTransport::kSender,
MediaType::VIDEO,
FakeNetworkPipe::Config());
test::PacketTransport receive_transport(nullptr, &observer,
test::PacketTransport::kReceiver,
MediaType::VIDEO,
FakeNetworkPipe::Config());
send_transport.SetReceiver(receiver_call_->Receiver());
receive_transport.SetReceiver(sender_call_->Receiver());
@ -3906,9 +3921,11 @@ TEST_F(EndToEndTest, CallReportsRttForSender) {
FakeNetworkPipe::Config config;
config.queue_delay_ms = kSendDelayMs;
test::DirectTransport sender_transport(config, sender_call_.get());
test::DirectTransport sender_transport(
config, sender_call_.get(), MediaType::VIDEO);
config.queue_delay_ms = kReceiveDelayMs;
test::DirectTransport receiver_transport(config, receiver_call_.get());
test::DirectTransport receiver_transport(
config, receiver_call_.get(), MediaType::VIDEO);
sender_transport.SetReceiver(receiver_call_->Receiver());
receiver_transport.SetReceiver(sender_call_->Receiver());
@ -3970,7 +3987,7 @@ void EndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
CreateCalls(config, config);
receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
test::DirectTransport sender_transport(sender_call_.get());
test::DirectTransport sender_transport(sender_call_.get(), MediaType::VIDEO);
sender_transport.SetReceiver(receiver_call_->Receiver());
CreateSendConfig(1, 0, 0, &sender_transport);
CreateMatchingReceiveConfigs(transport);

4
webrtc/video/replay.cc
View File

@ -283,8 +283,8 @@ void RtpReplay() {
if (!rtp_reader->NextPacket(&packet))
break;
++num_packets;
switch (call->Receiver()->DeliverPacket(webrtc::MediaType::ANY, packet.data,
packet.length, PacketTime())) {
switch (call->Receiver()->DeliverPacket(
webrtc::MediaType::VIDEO, packet.data, packet.length, PacketTime())) {
case PacketReceiver::DELIVERY_OK:
break;
case PacketReceiver::DELIVERY_UNKNOWN_SSRC: {

3
webrtc/video/video_quality_test.cc
View File

@ -1590,7 +1590,8 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
test::LayerFilteringTransport send_transport(
params_.pipe, sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
params_.video.selected_tl, params_.ss.selected_sl);
test::DirectTransport recv_transport(params_.pipe, receiver_call_.get());
test::DirectTransport recv_transport(
params_.pipe, receiver_call_.get(), MediaType::VIDEO);
std::string graph_title = params_.analyzer.graph_title;
if (graph_title.empty())

9
webrtc/video/video_send_stream_tests.cc
View File

@ -439,7 +439,8 @@ class UlpfecObserver : public test::EndToEndTest {
config.loss_percent = 5;
config.queue_delay_ms = kNetworkDelayMs;
return new test::PacketTransport(sender_call, this,
test::PacketTransport::kSender, config);
test::PacketTransport::kSender,
MediaType::VIDEO, config);
}
void ModifyVideoConfigs(
@ -594,7 +595,8 @@ class FlexfecObserver : public test::EndToEndTest {
config.loss_percent = 5;
config.queue_delay_ms = kNetworkDelayMs;
return new test::PacketTransport(sender_call, this,
test::PacketTransport::kSender, config);
test::PacketTransport::kSender,
MediaType::VIDEO, config);
}
void ModifyVideoConfigs(
@ -1263,7 +1265,8 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
config.link_capacity_kbps = kCapacityKbps;
config.queue_delay_ms = kNetworkDelayMs;
return new test::PacketTransport(sender_call, this,
test::PacketTransport::kSender, config);
test::PacketTransport::kSender,
MediaType::VIDEO, config);
}
void ModifyVideoConfigs(