Use PacketReceiver::DeliverRtpPaket in scenario tests

Change-Id: I36db102d023e4b716ce33a0afcff38b79b59b622

Bug: webrtc:7135
Change-Id: I36db102d023e4b716ce33a0afcff38b79b59b622
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/290883
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Per Kjellander <perkj@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39090}

test/scenario/BUILD.gn

@@ -74,6 +74,7 @@ if (rtc_include_tests && !build_with_chromium) {
       "../:test_common",
       "../:test_support",
       "../:video_test_common",
+      "../../api:array_view",
       "../../api:create_frame_generator",
       "../../api:fec_controller_api",
       "../../api:frame_generator_api",

test/scenario/audio_stream.cc

@@ -67,6 +67,20 @@ absl::optional<std::string> CreateAdaptationString(
 }
 }  // namespace
 
+std::vector<RtpExtension> GetAudioRtpExtensions(
+    const AudioStreamConfig& config) {
+  std::vector<RtpExtension> extensions;
+  if (config.stream.in_bandwidth_estimation) {
+    extensions.push_back({RtpExtension::kTransportSequenceNumberUri,
+                          kTransportSequenceNumberExtensionId});
+  }
+  if (config.stream.abs_send_time) {
+    extensions.push_back(
+        {RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId});
+  }
+  return extensions;
+}
+
 SendAudioStream::SendAudioStream(
     CallClient* sender,
     AudioStreamConfig config,
@@ -120,13 +134,8 @@ SendAudioStream::SendAudioStream(
 
   if (config.stream.in_bandwidth_estimation) {
     send_config.send_codec_spec->transport_cc_enabled = true;
-    send_config.rtp.extensions = {{RtpExtension::kTransportSequenceNumberUri,
-                                   kTransportSequenceNumberExtensionId}};
-  }
-  if (config.stream.abs_send_time) {
-    send_config.rtp.extensions.push_back(
-        {RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId});
   }
+  send_config.rtp.extensions = GetAudioRtpExtensions(config);
 
   sender_->SendTask([&] {
     send_stream_ = sender_->call_->CreateAudioSendStream(send_config);
@@ -179,10 +188,7 @@ ReceiveAudioStream::ReceiveAudioStream(
   recv_config.rtcp_send_transport = feedback_transport;
   recv_config.rtp.remote_ssrc = send_stream->ssrc_;
   receiver->ssrc_media_types_[recv_config.rtp.remote_ssrc] = MediaType::AUDIO;
-  if (config.stream.in_bandwidth_estimation) {
-    recv_config.rtp.extensions = {{RtpExtension::kTransportSequenceNumberUri,
-                                   kTransportSequenceNumberExtensionId}};
-  }
+  recv_config.rtp.extensions = GetAudioRtpExtensions(config);
   recv_config.decoder_factory = decoder_factory;
   recv_config.decoder_map = {
       {CallTest::kAudioSendPayloadType, {"opus", 48000, 2}}};

test/scenario/audio_stream.h

@@ -100,6 +100,10 @@ class AudioStreamPair {
   SendAudioStream send_stream_;
   ReceiveAudioStream receive_stream_;
 };
+
+std::vector<RtpExtension> GetAudioRtpExtensions(
+    const AudioStreamConfig& config);
+
 }  // namespace test
 }  // namespace webrtc
 

test/scenario/call_client.cc

@@ -13,12 +13,15 @@
 #include <memory>
 #include <utility>
 
+#include "api/media_types.h"
 #include "api/rtc_event_log/rtc_event_log.h"
 #include "api/rtc_event_log/rtc_event_log_factory.h"
 #include "api/transport/network_types.h"
 #include "call/call.h"
 #include "call/rtp_transport_controller_send_factory.h"
 #include "modules/audio_mixer/audio_mixer_impl.h"
+#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
+#include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "modules/rtp_rtcp/source/rtp_util.h"
 
 namespace webrtc {
@@ -289,16 +292,44 @@ void CallClient::UpdateBitrateConstraints(
   });
 }
 
+void CallClient::SetAudioReceiveRtpHeaderExtensions(
+    rtc::ArrayView<RtpExtension> extensions) {
+  SendTask([this, &extensions]() {
+    audio_extensions_ = RtpHeaderExtensionMap(extensions);
+  });
+}
+
+void CallClient::SetVideoReceiveRtpHeaderExtensions(
+    rtc::ArrayView<RtpExtension> extensions) {
+  SendTask([this, &extensions]() {
+    video_extensions_ = RtpHeaderExtensionMap(extensions);
+  });
+}
+
 void CallClient::OnPacketReceived(EmulatedIpPacket packet) {
   MediaType media_type = MediaType::ANY;
   if (IsRtpPacket(packet.data)) {
     media_type = ssrc_media_types_[ParseRtpSsrc(packet.data)];
-  }
-  task_queue_.PostTask(
-      [call = call_.get(), media_type, packet = std::move(packet)]() mutable {
-        call->Receiver()->DeliverPacket(media_type, packet.data,
-                                        packet.arrival_time.us());
+    task_queue_.PostTask([this, media_type,
+                          packet = std::move(packet)]() mutable {
+      RtpHeaderExtensionMap& extension_map = media_type == MediaType::AUDIO
+                                                 ? audio_extensions_
+                                                 : video_extensions_;
+      RtpPacketReceived received_packet(&extension_map, packet.arrival_time);
+      RTC_CHECK(received_packet.Parse(packet.data));
+      call_->Receiver()->DeliverRtpPacket(media_type, received_packet,
+                                          /*undemuxable_packet_handler=*/
+                                          [](const RtpPacketReceived& packet) {
+                                            RTC_CHECK_NOTREACHED();
+                                            return false;
                                           });
+    });
+  } else {
+    task_queue_.PostTask(
+        [call = call_.get(), packet = std::move(packet)]() mutable {
+          call->Receiver()->DeliverRtcpPacket(packet.data);
+        });
+  }
 }
 
 std::unique_ptr<RtcEventLogOutput> CallClient::GetLogWriter(std::string name) {

test/scenario/call_client.h

@@ -16,12 +16,15 @@
 #include <utility>
 #include <vector>
 
+#include "api/array_view.h"
 #include "api/rtc_event_log/rtc_event_log.h"
+#include "api/rtp_parameters.h"
 #include "api/test/time_controller.h"
 #include "api/units/data_rate.h"
 #include "call/call.h"
 #include "modules/audio_device/include/test_audio_device.h"
 #include "modules/congestion_controller/goog_cc/test/goog_cc_printer.h"
+#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "test/logging/log_writer.h"
 #include "test/network/network_emulation.h"
@@ -121,6 +124,11 @@ class CallClient : public EmulatedNetworkReceiverInterface {
   void UpdateBitrateConstraints(const BitrateConstraints& constraints);
   void SetRemoteBitrate(DataRate bitrate);
 
+  void SetAudioReceiveRtpHeaderExtensions(
+      rtc::ArrayView<RtpExtension> extensions);
+  void SetVideoReceiveRtpHeaderExtensions(
+      rtc::ArrayView<RtpExtension> extensions);
+
   void OnPacketReceived(EmulatedIpPacket packet) override;
   std::unique_ptr<RtcEventLogOutput> GetLogWriter(std::string name);
 
@@ -156,6 +164,8 @@ class CallClient : public EmulatedNetworkReceiverInterface {
   std::unique_ptr<Call> call_;
   std::unique_ptr<NetworkNodeTransport> transport_;
   std::vector<std::pair<EmulatedEndpoint*, uint16_t>> endpoints_;
+  RtpHeaderExtensionMap audio_extensions_;
+  RtpHeaderExtensionMap video_extensions_;
 
   int next_video_ssrc_index_ = 0;
   int next_video_local_ssrc_index_ = 0;

test/scenario/scenario.cc

@@ -20,6 +20,7 @@
 #include "rtc_base/socket_address.h"
 #include "test/logging/file_log_writer.h"
 #include "test/network/network_emulation.h"
+#include "test/scenario/video_stream.h"
 #include "test/testsupport/file_utils.h"
 
 ABSL_FLAG(bool, scenario_logs, false, "Save logs from scenario framework.");
@@ -224,6 +225,9 @@ VideoStreamPair* Scenario::CreateVideoStream(
 VideoStreamPair* Scenario::CreateVideoStream(
     std::pair<CallClient*, CallClient*> clients,
     VideoStreamConfig config) {
+  std::vector<RtpExtension> extensions = GetVideoRtpExtensions(config);
+  clients.first->SetVideoReceiveRtpHeaderExtensions(extensions);
+  clients.second->SetVideoReceiveRtpHeaderExtensions(extensions);
   video_streams_.emplace_back(
       new VideoStreamPair(clients.first, clients.second, config));
   return video_streams_.back().get();
@@ -240,6 +244,9 @@ AudioStreamPair* Scenario::CreateAudioStream(
 AudioStreamPair* Scenario::CreateAudioStream(
     std::pair<CallClient*, CallClient*> clients,
     AudioStreamConfig config) {
+  std::vector<RtpExtension> extensions = GetAudioRtpExtensions(config);
+  clients.first->SetAudioReceiveRtpHeaderExtensions(extensions);
+  clients.second->SetAudioReceiveRtpHeaderExtensions(extensions);
   audio_streams_.emplace_back(
       new AudioStreamPair(clients.first, audio_encoder_factory_, clients.second,
                           audio_decoder_factory_, config));

test/scenario/video_stream.cc

@@ -80,24 +80,6 @@ VideoEncoderConfig::ContentType ConvertContentType(
   }
 }
 
-std::vector<RtpExtension> GetVideoRtpExtensions(
-    const VideoStreamConfig config) {
-  std::vector<RtpExtension> res = {
-      RtpExtension(RtpExtension::kVideoContentTypeUri,
-                   kVideoContentTypeExtensionId),
-      RtpExtension(RtpExtension::kVideoRotationUri,
-                   kVideoRotationRtpExtensionId)};
-  if (config.stream.packet_feedback) {
-    res.push_back(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
-                               kTransportSequenceNumberExtensionId));
-  }
-  if (config.stream.abs_send_time) {
-    res.push_back(
-        RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
-  }
-  return res;
-}
-
 std::string TransformFilePath(std::string path) {
   static const std::string resource_prefix = "res://";
   int ext_pos = path.rfind('.');
@@ -356,6 +338,24 @@ VideoReceiveStreamInterface::Config CreateVideoReceiveStreamConfig(
 }
 }  // namespace
 
+std::vector<RtpExtension> GetVideoRtpExtensions(
+    const VideoStreamConfig config) {
+  std::vector<RtpExtension> res = {
+      RtpExtension(RtpExtension::kVideoContentTypeUri,
+                   kVideoContentTypeExtensionId),
+      RtpExtension(RtpExtension::kVideoRotationUri,
+                   kVideoRotationRtpExtensionId)};
+  if (config.stream.packet_feedback) {
+    res.push_back(RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+                               kTransportSequenceNumberExtensionId));
+  }
+  if (config.stream.abs_send_time) {
+    res.push_back(
+        RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
+  }
+  return res;
+}
+
 SendVideoStream::SendVideoStream(CallClient* sender,
                                  VideoStreamConfig config,
                                  Transport* send_transport,

test/scenario/video_stream.h

@@ -129,6 +129,9 @@ class VideoStreamPair {
   SendVideoStream send_stream_;
   ReceiveVideoStream receive_stream_;
 };
+
+std::vector<RtpExtension> GetVideoRtpExtensions(const VideoStreamConfig config);
+
 }  // namespace test
 }  // namespace webrtc