Making FakeNetworkPipe demux audio and video packets.

webrtc/test/call_test.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/test/call_test.h"
 
 #include <algorithm>
 
 #include "webrtc/api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/config.h"
 #include "webrtc/modules/audio_mixer/audio_mixer_impl.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/voice_engine/include/voe_base.h"
 
 namespace webrtc {
 namespace test {
 
 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),
       video_send_stream_(nullptr),
       audio_send_config_(nullptr),
       audio_send_stream_(nullptr),
       fake_encoder_(clock_),
       num_video_streams_(1),
       num_audio_streams_(0),
       num_flexfec_streams_(0),
@@ skipping 29 matching lines @@
       audio_state_config.audio_mixer = AudioMixerImpl::Create();
       recv_config.audio_state = AudioState::Create(audio_state_config);
     }
     CreateReceiverCall(recv_config);
   }
   test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
   receive_transport_.reset(test->CreateReceiveTransport());
   send_transport_.reset(test->CreateSendTransport(sender_call_.get()));
 
   if (test->ShouldCreateReceivers()) {
-    // 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());
-    }
+    send_transport_->SetReceiver(receiver_call_->Receiver());
+    receive_transport_->SetReceiver(sender_call_->Receiver());
     if (num_video_streams_ > 0)
       receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
     if (num_audio_streams_ > 0)
       receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp);
   } else {
     // Sender-only call delivers to itself.
     send_transport_->SetReceiver(sender_call_->Receiver());
     receive_transport_->SetReceiver(nullptr);
   }
 
@@ skipping 167 matching lines @@
 
   RTC_DCHECK_GE(1, num_audio_streams_);
   if (num_audio_streams_ == 1) {
     RTC_DCHECK_LE(0, voe_send_.channel_id);
     AudioReceiveStream::Config audio_config;
     audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
     audio_config.rtcp_send_transport = rtcp_send_transport;
     audio_config.voe_channel_id = voe_recv_.channel_id;
     audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc;
     audio_config.decoder_factory = decoder_factory_;
-    audio_config.decoder_map = {{120, {"opus", 48000, 2}}};
+    audio_config.decoder_map = {{kAudioSendPayloadType, {"opus", 48000, 2}}};
     audio_receive_configs_.push_back(audio_config);
   }
 
   // TODO(brandtr): Update this when we support multistream protection.
   RTC_DCHECK(num_flexfec_streams_ <= 1);
   if (num_flexfec_streams_ == 1) {
     FlexfecReceiveStream::Config config(rtcp_send_transport);
     config.payload_type = kFlexfecPayloadType;
     config.remote_ssrc = kFlexfecSendSsrc;
     config.protected_media_ssrcs = {kVideoSendSsrcs[0]};
@@ skipping 141 matching lines @@
 const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {0xBADCAFD, 0xBADCAFE,
                                                      0xBADCAFF};
 const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = {0xC0FFED, 0xC0FFEE,
                                                        0xC0FFEF};
 const uint32_t CallTest::kAudioSendSsrc = 0xDEADBEEF;
 const uint32_t CallTest::kFlexfecSendSsrc = 0xBADBEEF;
 const uint32_t CallTest::kReceiverLocalVideoSsrc = 0x123456;
 const uint32_t CallTest::kReceiverLocalAudioSsrc = 0x1234567;
 const int CallTest::kNackRtpHistoryMs = 1000;
 
+const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = {
+    {CallTest::kVideoSendPayloadType, MediaType::VIDEO},
+    {CallTest::kFakeVideoSendPayloadType, MediaType::VIDEO},
+    {CallTest::kSendRtxPayloadType, MediaType::VIDEO},
+    {CallTest::kRedPayloadType, MediaType::VIDEO},
+    {CallTest::kRtxRedPayloadType, MediaType::VIDEO},
+    {CallTest::kUlpfecPayloadType, MediaType::VIDEO},
+    {CallTest::kFlexfecPayloadType, MediaType::VIDEO},
+    {CallTest::kAudioSendPayloadType, MediaType::AUDIO}};
+
 BaseTest::BaseTest() {}
 
 BaseTest::BaseTest(unsigned int timeout_ms) : RtpRtcpObserver(timeout_ms) {
 }
 
 BaseTest::~BaseTest() {
 }
 
 std::unique_ptr<FakeAudioDevice::Capturer> BaseTest::CreateCapturer() {
   return FakeAudioDevice::CreatePulsedNoiseCapturer(256, 48000);
@@ skipping 11 matching lines @@
   return Call::Config(&event_log_);
 }
 
 Call::Config BaseTest::GetReceiverCallConfig() {
   return Call::Config(&event_log_);
 }
 
 void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {
 }
 
-MediaType BaseTest::SelectMediaType() {
-  if (GetNumVideoStreams() > 0) {
-    if (GetNumAudioStreams() > 0) {
-      // Relies on PayloadDemuxer to set media type from payload type.
-      return MediaType::ANY;
-    } else {
-      return MediaType::VIDEO;
-    }
-  } else {
-    return MediaType::AUDIO;
-  }
-}
-
 test::PacketTransport* BaseTest::CreateSendTransport(Call* sender_call) {
   return new PacketTransport(sender_call, this, test::PacketTransport::kSender,
-                             SelectMediaType(),
+                             CallTest::payload_type_map_,

[stefan-webrtc, 2017/04/10 07:45:26]

Wouldn't it be cleaner to pass the payload_type_map into CreateSendTransport
than to rely on a static const?

[minyue-webrtc, 2017/04/10 07:58:46]

I also thought about it. I think it would be an improvement. Can I do it in a
follow up CL, to avoid possible inconvenience it may bring.

[stefan-webrtc, 2017/04/10 12:04:15]

SG

                              FakeNetworkPipe::Config());
 }
 
 test::PacketTransport* BaseTest::CreateReceiveTransport() {
   return new PacketTransport(nullptr, this, test::PacketTransport::kReceiver,
-                             SelectMediaType(),
+                             CallTest::payload_type_map_,
                              FakeNetworkPipe::Config());
 }
 
 size_t BaseTest::GetNumVideoStreams() const {
   return 1;
 }
 
 size_t BaseTest::GetNumAudioStreams() const {
   return 0;
 }
@@ skipping 47 matching lines @@
 
 EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
 }
 
 bool EndToEndTest::ShouldCreateReceivers() const {
   return true;
 }
 
 }  // namespace test
 }  // namespace webrtc