mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Use PacketReceiver::DeliverRtpPaket in scenario tests

Browse source 
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}
This commit is contained in:
Per K 2023-01-12 17:00:22 +01:00 committed by WebRTC LUCI CQ
parent 5b7896be29
commit b3046c25aa
8 changed files with 95 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
test/scenario/BUILD.gn
View file

@ -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",

26
test/scenario/audio_stream.cc
View file

@ -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}}};

4
test/scenario/audio_stream.h
View file

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

41
test/scenario/call_client.cc
View file

@ -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([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);
});
}
task_queue_.PostTask(
[call = call_.get(), media_type, packet = std::move(packet)]() mutable {
call->Receiver()->DeliverPacket(media_type, packet.data,
packet.arrival_time.us());
});
}
std::unique_ptr<RtcEventLogOutput> CallClient::GetLogWriter(std::string name) {

10
test/scenario/call_client.h
View file

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

7
test/scenario/scenario.cc
View file

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

36
test/scenario/video_stream.cc
View file

@ -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,

3
test/scenario/video_stream.h
View file

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