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

Reland of Don't hardcode MediaType::ANY in FakeNetworkPipe. (patchset #1 id:1 of https://codereview.webrtc.org/2784543002/ )

Browse Source 
Reason for revert:
Intend to fix perf failures and reland.

Original issue's description:
> Revert of Don't hardcode MediaType::ANY in FakeNetworkPipe. (patchset #4 id:60001 of https://codereview.webrtc.org/2774463003/ )
>
> Reason for revert:
> Reverting since this seems to break multiple WebRTC Perf buildbots
>
> Original issue's description:
> > Don't hardcode MediaType::ANY in FakeNetworkPipe.
> >
> > 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}
> > Committed: 9c47b00e24
>
> TBR=stefan@webrtc.org,deadbeef@webrtc.org,solenberg@webrtc.org,pbos@webrtc.org,sprang@webrtc.org,nisse@webrtc.org
> # Skipping CQ checks because original CL landed less than 1 days ago.
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
> BUG=webrtc:7135
>
> Review-Url: https://codereview.webrtc.org/2784543002
> Cr-Commit-Position: refs/heads/master@{#17427}
> Committed: 3a3bd50610

TBR=stefan@webrtc.org,deadbeef@webrtc.org,solenberg@webrtc.org,pbos@webrtc.org,sprang@webrtc.org,lliuu@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=webrtc:7135

Review-Url: https://codereview.webrtc.org/2783853002
Cr-Commit-Position: refs/heads/master@{#17459}
This commit is contained in:
nisse
2017-03-29 23:57:43 -07:00
committed by Commit bot
parent 1dcb16409a
commit e5ad5ca06a
20 changed files with 208 additions and 81 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());

13
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));
@ -1320,10 +1322,7 @@ void Call::NotifyBweOfReceivedPacket(const RtpPacketReceived& packet,
return;
}
// For audio, we only support send side BWE.
// TODO(nisse): Tests passes MediaType::ANY, see
// FakeNetworkPipe::Process. We need to treat that as video. Tests
// should be fixed to use the same MediaType as the production code.
if (media_type != MediaType::AUDIO ||
if (media_type == MediaType::VIDEO ||
(use_send_side_bwe && header.extension.hasTransportSequenceNumber)) {
receive_side_cc_.OnReceivedPacket(
packet.arrival_time_ms(), packet.payload_size() + packet.padding_size(),

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 {

21
webrtc/call/rampup_tests.cc
View File

@ -89,13 +89,34 @@ void RampUpTester::OnVideoStreamsCreated(
send_stream_ = send_stream;
}
MediaType RampUpTester::SelectMediaType() {
if (num_video_streams_ > 0) {
if (num_audio_streams_ > 0) {
// Rely on call to set media type from payload type.
return MediaType::ANY;
} else {
return MediaType::VIDEO;
}
} else {
return MediaType::AUDIO;
}
}
test::PacketTransport* RampUpTester::CreateSendTransport(Call* sender_call) {
send_transport_ = new test::PacketTransport(sender_call, this,
test::PacketTransport::kSender,
SelectMediaType(),
forward_transport_config_);
return send_transport_;
}
test::PacketTransport* RampUpTester::CreateReceiveTransport() {
return new test::PacketTransport(nullptr, this,
test::PacketTransport::kReceiver,
SelectMediaType(),
FakeNetworkPipe::Config());
}
size_t RampUpTester::GetNumVideoStreams() const {
return num_video_streams_;
}

2
webrtc/call/rampup_tests.h
View File

@ -84,7 +84,9 @@ class RampUpTester : public test::EndToEndTest {
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override;
MediaType SelectMediaType();
test::PacketTransport* CreateSendTransport(Call* sender_call) override;
test::PacketTransport* CreateReceiveTransport() override;
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,

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

41
webrtc/test/call_test.cc
View File

@ -26,6 +26,29 @@ namespace {
const int kVideoRotationRtpExtensionId = 4;
}
void CallTest::PayloadDemuxer::SetReceiver(PacketReceiver* receiver) {
receiver_ = receiver;
}
PacketReceiver::DeliveryStatus CallTest::PayloadDemuxer::DeliverPacket(
MediaType media_type,
const uint8_t* packet,
size_t length,
const PacketTime& packet_time) {
if (media_type == MediaType::ANY) {
// This simplistic demux logic will not make much sense for RTCP
// packets, but it seems that doesn't matter.
RTC_CHECK_GE(length, 2);
uint8_t pt = packet[1] & 0x7f;
if (pt == kFakeVideoSendPayloadType || pt == kFlexfecPayloadType) {
media_type = MediaType::VIDEO;
} else {
media_type = MediaType::AUDIO;
}
}
return receiver_->DeliverPacket(media_type, packet, length, packet_time);
}
CallTest::CallTest()
: clock_(Clock::GetRealTimeClock()),
video_send_config_(nullptr),
@ -75,8 +98,20 @@ void CallTest::RunBaseTest(BaseTest* test) {
send_transport_.reset(test->CreateSendTransport(sender_call_.get()));
if (test->ShouldCreateReceivers()) {
send_transport_->SetReceiver(receiver_call_->Receiver());
receive_transport_->SetReceiver(sender_call_->Receiver());
// For tests using only video or only audio, we rely on each test
// configuring the underlying FakeNetworkPipe with the right media
// type. But for tests sending both video and audio over the same
// FakeNetworkPipe, we need to "demux", i.e., setting the
// MediaType based on RTP payload type.
if (num_video_streams_ > 0 && num_audio_streams_ > 0) {
receive_demuxer_.SetReceiver(receiver_call_->Receiver());
send_transport_->SetReceiver(&receive_demuxer_);
send_demuxer_.SetReceiver(sender_call_->Receiver());
receive_transport_->SetReceiver(&send_demuxer_);
} else {
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)
@ -459,11 +494,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());
}

21
webrtc/test/call_test.h
View File

@ -59,6 +59,23 @@ class CallTest : public ::testing::Test {
static const int kNackRtpHistoryMs;
protected:
// Needed for tests sending both audio and video on the same
// FakeNetworkPipe. We then need to set correct MediaType based on
// packet payload type, before passing the packet on to Call.
class PayloadDemuxer : public PacketReceiver {
public:
PayloadDemuxer() = default;
void SetReceiver(PacketReceiver* receiver);
DeliveryStatus DeliverPacket(MediaType media_type,
const uint8_t* packet,
size_t length,
const PacketTime& packet_time) override;
private:
PacketReceiver* receiver_ = nullptr;
};
// RunBaseTest overwrites the audio_state and the voice_engine of the send and
// receive Call configs to simplify test code and avoid having old VoiceEngine
// APIs in the tests.
@ -124,6 +141,9 @@ class CallTest : public ::testing::Test {
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
test::FakeVideoRenderer fake_renderer_;
PayloadDemuxer receive_demuxer_;
PayloadDemuxer send_demuxer_;
private:
// TODO(holmer): Remove once VoiceEngine is fully refactored to the new API.
// These methods are used to set up legacy voice engines and channels which is
@ -172,6 +192,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

@ -210,8 +210,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());
@ -257,8 +259,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());
@ -529,6 +533,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;
@ -790,7 +795,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 {
@ -969,7 +975,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
@ -1311,8 +1318,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());
@ -1539,10 +1548,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);
}
};
@ -1621,7 +1630,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),
@ -1937,8 +1946,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());
@ -2102,6 +2113,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_;
}
@ -3065,7 +3077,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 {
@ -3619,9 +3632,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());
@ -3914,9 +3929,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());
@ -3978,7 +3995,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(