Making FakeNetworkPipe demux audio and video packets.

webrtc/call/call_perf_tests.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
@@ skipping 173 matching lines @@
    private:
     PacketReceiver* packet_receiver_;
     const MediaType media_type_;
 
     RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(MediaTypePacketReceiver);
   };
 
   FakeNetworkPipe::Config audio_net_config;
   audio_net_config.queue_delay_ms = 500;
   audio_net_config.loss_percent = 5;
+
+  std::map<uint8_t, MediaType> audio_pt_map;
+  std::map<uint8_t, MediaType> video_pt_map;
+  std::copy_if(std::begin(payload_type_map_), std::end(payload_type_map_),
+               std::inserter(audio_pt_map, audio_pt_map.end()),
+               [](const std::pair<const uint8_t, MediaType>& pair) {
+                 return pair.second == MediaType::AUDIO;
+               });
+  std::copy_if(std::begin(payload_type_map_), std::end(payload_type_map_),
+               std::inserter(video_pt_map, video_pt_map.end()),
+               [](const std::pair<const uint8_t, MediaType>& pair) {
+                 return pair.second == MediaType::VIDEO;
+               });
+
   test::PacketTransport audio_send_transport(sender_call_.get(), &observer,
                                              test::PacketTransport::kSender,
-                                             MediaType::AUDIO,
-                                             audio_net_config);
+                                             audio_pt_map, audio_net_config);
   MediaTypePacketReceiver audio_receiver(receiver_call_->Receiver(),
                                          MediaType::AUDIO);
   audio_send_transport.SetReceiver(&audio_receiver);
 
-  test::PacketTransport video_send_transport(sender_call_.get(), &observer,
-                                             test::PacketTransport::kSender,
-                                             MediaType::VIDEO,
-                                             FakeNetworkPipe::Config());
+  test::PacketTransport video_send_transport(
+      sender_call_.get(), &observer, test::PacketTransport::kSender,
+      video_pt_map, FakeNetworkPipe::Config());
   MediaTypePacketReceiver video_receiver(receiver_call_->Receiver(),
                                          MediaType::VIDEO);
   video_send_transport.SetReceiver(&video_receiver);
 
   test::PacketTransport receive_transport(
       receiver_call_.get(), &observer, test::PacketTransport::kReceiver,
-      MediaType::VIDEO,
-      FakeNetworkPipe::Config());
+      payload_type_map_, FakeNetworkPipe::Config());
   receive_transport.SetReceiver(sender_call_->Receiver());
 
   test::FakeDecoder fake_decoder;
 
   CreateSendConfig(1, 0, 0, &video_send_transport);
   CreateMatchingReceiveConfigs(&receive_transport);
 
   AudioSendStream::Config audio_send_config(&audio_send_transport);
   audio_send_config.voe_channel_id = send_channel_id;
   audio_send_config.rtp.ssrc = kAudioSendSsrc;
   audio_send_config.send_codec_spec.codec_inst =
-      CodecInst{103, "ISAC", 16000, 480, 1, 32000};
+      CodecInst{kAudioSendPayloadType, "ISAC", 16000, 480, 1, 32000};
   AudioSendStream* audio_send_stream =
       sender_call_->CreateAudioSendStream(audio_send_config);
 
   video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
   if (fec == FecMode::kOn) {
     video_send_config_.rtp.ulpfec.red_payload_type = kRedPayloadType;
     video_send_config_.rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
     video_receive_configs_[0].rtp.ulpfec.red_payload_type = kRedPayloadType;
     video_receive_configs_[0].rtp.ulpfec.ulpfec_payload_type =
         kUlpfecPayloadType;
   }
   video_receive_configs_[0].rtp.nack.rtp_history_ms = 1000;
   video_receive_configs_[0].renderer = &observer;
   video_receive_configs_[0].sync_group = kSyncGroup;
 
   AudioReceiveStream::Config audio_recv_config;
   audio_recv_config.rtp.remote_ssrc = kAudioSendSsrc;
   audio_recv_config.rtp.local_ssrc = kAudioRecvSsrc;
   audio_recv_config.voe_channel_id = recv_channel_id;
   audio_recv_config.sync_group = kSyncGroup;
   audio_recv_config.decoder_factory = decoder_factory_;
-  audio_recv_config.decoder_map = {{103, {"ISAC", 16000, 1}}};
+  audio_recv_config.decoder_map = {{kAudioSendPayloadType, {"ISAC", 16000, 1}}};
 
   AudioReceiveStream* audio_receive_stream;
 
   if (create_first == CreateOrder::kAudioFirst) {
     audio_receive_stream =
         receiver_call_->CreateAudioReceiveStream(audio_recv_config);
     CreateVideoStreams();
   } else {
     CreateVideoStreams();
     audio_receive_stream =
@@ skipping 80 matching lines @@
           threshold_ms_(threshold_ms),
           start_time_ms_(start_time_ms),
           run_time_ms_(run_time_ms),
           creation_time_ms_(clock_->TimeInMilliseconds()),
           capturer_(nullptr),
           rtp_start_timestamp_set_(false),
           rtp_start_timestamp_(0) {}
 
    private:
     test::PacketTransport* CreateSendTransport(Call* sender_call) override {
-      return new test::PacketTransport(
-          sender_call, this, test::PacketTransport::kSender, MediaType::VIDEO,
-          net_config_);
+      return new test::PacketTransport(sender_call, this,
+                                       test::PacketTransport::kSender,
+                                       payload_type_map_, net_config_);
     }
 
     test::PacketTransport* CreateReceiveTransport() override {
-      return new test::PacketTransport(
-          nullptr, this, test::PacketTransport::kReceiver, MediaType::VIDEO,
-          net_config_);
+      return new test::PacketTransport(nullptr, this,
+                                       test::PacketTransport::kReceiver,
+                                       payload_type_map_, net_config_);
     }
 
     void OnFrame(const VideoFrame& video_frame) override {
       rtc::CritScope lock(&crit_);
       if (video_frame.ntp_time_ms() <= 0) {
         // Haven't got enough RTCP SR in order to calculate the capture ntp
         // time.
         return;
       }
 
@@ skipping 396 matching lines @@
     uint32_t last_set_bitrate_kbps_;
     VideoSendStream* send_stream_;
     test::FrameGeneratorCapturer* frame_generator_;
     VideoEncoderConfig encoder_config_;
   } test;
 
   RunBaseTest(&test);
 }
 
 }  // namespace webrtc