From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../libwebrtc/pc/track_media_info_map_unittest.cc | 332 +++++++++++++++++++++ 1 file changed, 332 insertions(+) create mode 100644 third_party/libwebrtc/pc/track_media_info_map_unittest.cc (limited to 'third_party/libwebrtc/pc/track_media_info_map_unittest.cc') diff --git a/third_party/libwebrtc/pc/track_media_info_map_unittest.cc b/third_party/libwebrtc/pc/track_media_info_map_unittest.cc new file mode 100644 index 0000000000..bffa3eb866 --- /dev/null +++ b/third_party/libwebrtc/pc/track_media_info_map_unittest.cc @@ -0,0 +1,332 @@ +/* + * Copyright 2016 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 "pc/track_media_info_map.h" + +#include + +#include +#include +#include +#include +#include +#include + +#include "api/media_types.h" +#include "api/rtp_parameters.h" +#include "api/test/mock_video_track.h" +#include "media/base/media_channel.h" +#include "pc/audio_track.h" +#include "pc/test/fake_video_track_source.h" +#include "pc/test/mock_rtp_receiver_internal.h" +#include "pc/test/mock_rtp_sender_internal.h" +#include "pc/video_track.h" +#include "rtc_base/checks.h" +#include "rtc_base/thread.h" +#include "test/gmock.h" +#include "test/gtest.h" + +using ::testing::ElementsAre; + +namespace webrtc { + +namespace { + +RtpParameters CreateRtpParametersWithSsrcs( + std::initializer_list ssrcs) { + RtpParameters params; + for (uint32_t ssrc : ssrcs) { + RtpEncodingParameters encoding_params; + encoding_params.ssrc = ssrc; + params.encodings.push_back(encoding_params); + } + return params; +} + +rtc::scoped_refptr CreateMockRtpSender( + cricket::MediaType media_type, + std::initializer_list ssrcs, + rtc::scoped_refptr track) { + uint32_t first_ssrc; + if (ssrcs.size()) { + first_ssrc = *ssrcs.begin(); + } else { + first_ssrc = 0; + } + auto sender = rtc::make_ref_counted(); + EXPECT_CALL(*sender, track()) + .WillRepeatedly(::testing::Return(std::move(track))); + EXPECT_CALL(*sender, ssrc()).WillRepeatedly(::testing::Return(first_ssrc)); + EXPECT_CALL(*sender, media_type()) + .WillRepeatedly(::testing::Return(media_type)); + EXPECT_CALL(*sender, GetParameters()) + .WillRepeatedly(::testing::Return(CreateRtpParametersWithSsrcs(ssrcs))); + EXPECT_CALL(*sender, AttachmentId()).WillRepeatedly(::testing::Return(1)); + return sender; +} + +rtc::scoped_refptr CreateMockRtpReceiver( + cricket::MediaType media_type, + std::initializer_list ssrcs, + rtc::scoped_refptr track) { + auto receiver = rtc::make_ref_counted(); + EXPECT_CALL(*receiver, track()) + .WillRepeatedly(::testing::Return(std::move(track))); + EXPECT_CALL(*receiver, media_type()) + .WillRepeatedly(::testing::Return(media_type)); + EXPECT_CALL(*receiver, GetParameters()) + .WillRepeatedly(::testing::Return(CreateRtpParametersWithSsrcs(ssrcs))); + EXPECT_CALL(*receiver, AttachmentId()).WillRepeatedly(::testing::Return(1)); + return receiver; +} + +rtc::scoped_refptr CreateVideoTrack( + const std::string& id) { + return VideoTrack::Create(id, FakeVideoTrackSource::Create(false), + rtc::Thread::Current()); +} + +rtc::scoped_refptr CreateMockVideoTrack( + const std::string& id) { + auto track = MockVideoTrack::Create(); + EXPECT_CALL(*track, kind()) + .WillRepeatedly(::testing::Return(VideoTrack::kVideoKind)); + return track; +} + +class TrackMediaInfoMapTest : public ::testing::Test { + public: + TrackMediaInfoMapTest() : TrackMediaInfoMapTest(true) {} + + explicit TrackMediaInfoMapTest(bool use_real_video_track) + : local_audio_track_(AudioTrack::Create("LocalAudioTrack", nullptr)), + remote_audio_track_(AudioTrack::Create("RemoteAudioTrack", nullptr)), + local_video_track_(use_real_video_track + ? CreateVideoTrack("LocalVideoTrack") + : CreateMockVideoTrack("LocalVideoTrack")), + remote_video_track_(use_real_video_track + ? CreateVideoTrack("RemoteVideoTrack") + : CreateMockVideoTrack("LocalVideoTrack")) {} + + void AddRtpSenderWithSsrcs(std::initializer_list ssrcs, + MediaStreamTrackInterface* local_track) { + rtc::scoped_refptr rtp_sender = CreateMockRtpSender( + local_track->kind() == MediaStreamTrackInterface::kAudioKind + ? cricket::MEDIA_TYPE_AUDIO + : cricket::MEDIA_TYPE_VIDEO, + ssrcs, rtc::scoped_refptr(local_track)); + rtp_senders_.push_back(rtp_sender); + + if (local_track->kind() == MediaStreamTrackInterface::kAudioKind) { + cricket::VoiceSenderInfo voice_sender_info; + size_t i = 0; + for (uint32_t ssrc : ssrcs) { + voice_sender_info.local_stats.push_back(cricket::SsrcSenderInfo()); + voice_sender_info.local_stats[i++].ssrc = ssrc; + } + voice_media_info_.senders.push_back(voice_sender_info); + } else { + cricket::VideoSenderInfo video_sender_info; + size_t i = 0; + for (uint32_t ssrc : ssrcs) { + video_sender_info.local_stats.push_back(cricket::SsrcSenderInfo()); + video_sender_info.local_stats[i++].ssrc = ssrc; + } + video_media_info_.senders.push_back(video_sender_info); + video_media_info_.aggregated_senders.push_back(video_sender_info); + } + } + + void AddRtpReceiverWithSsrcs(std::initializer_list ssrcs, + MediaStreamTrackInterface* remote_track) { + auto rtp_receiver = CreateMockRtpReceiver( + remote_track->kind() == MediaStreamTrackInterface::kAudioKind + ? cricket::MEDIA_TYPE_AUDIO + : cricket::MEDIA_TYPE_VIDEO, + ssrcs, rtc::scoped_refptr(remote_track)); + rtp_receivers_.push_back(rtp_receiver); + + if (remote_track->kind() == MediaStreamTrackInterface::kAudioKind) { + cricket::VoiceReceiverInfo voice_receiver_info; + size_t i = 0; + for (uint32_t ssrc : ssrcs) { + voice_receiver_info.local_stats.push_back(cricket::SsrcReceiverInfo()); + voice_receiver_info.local_stats[i++].ssrc = ssrc; + } + voice_media_info_.receivers.push_back(voice_receiver_info); + } else { + cricket::VideoReceiverInfo video_receiver_info; + size_t i = 0; + for (uint32_t ssrc : ssrcs) { + video_receiver_info.local_stats.push_back(cricket::SsrcReceiverInfo()); + video_receiver_info.local_stats[i++].ssrc = ssrc; + } + video_media_info_.receivers.push_back(video_receiver_info); + } + } + + // Copies the current state of `voice_media_info_` and `video_media_info_` + // into the map. + void InitializeMap() { + map_.Initialize(voice_media_info_, video_media_info_, rtp_senders_, + rtp_receivers_); + } + + private: + rtc::AutoThread main_thread_; + cricket::VoiceMediaInfo voice_media_info_; + cricket::VideoMediaInfo video_media_info_; + + protected: + std::vector> rtp_senders_; + std::vector> rtp_receivers_; + TrackMediaInfoMap map_; + rtc::scoped_refptr local_audio_track_; + rtc::scoped_refptr remote_audio_track_; + rtc::scoped_refptr local_video_track_; + rtc::scoped_refptr remote_video_track_; +}; + +} // namespace + +TEST_F(TrackMediaInfoMapTest, SingleSenderReceiverPerTrackWithOneSsrc) { + AddRtpSenderWithSsrcs({1}, local_audio_track_.get()); + AddRtpReceiverWithSsrcs({2}, remote_audio_track_.get()); + AddRtpSenderWithSsrcs({3}, local_video_track_.get()); + AddRtpReceiverWithSsrcs({4}, remote_video_track_.get()); + InitializeMap(); + // RTP audio sender -> local audio track + EXPECT_EQ(map_.GetAudioTrack(map_.voice_media_info()->senders[0]), + local_audio_track_.get()); + // RTP audio receiver -> remote audio track + EXPECT_EQ(map_.GetAudioTrack(map_.voice_media_info()->receivers[0]), + remote_audio_track_.get()); + // RTP video sender -> local video track + EXPECT_EQ(map_.GetVideoTrack(map_.video_media_info()->senders[0]), + local_video_track_.get()); + // RTP video receiver -> remote video track + EXPECT_EQ(map_.GetVideoTrack(map_.video_media_info()->receivers[0]), + remote_video_track_.get()); +} + +TEST_F(TrackMediaInfoMapTest, + SingleSenderReceiverPerTrackWithAudioAndVideoUseSameSsrc) { + AddRtpSenderWithSsrcs({1}, local_audio_track_.get()); + AddRtpReceiverWithSsrcs({2}, remote_audio_track_.get()); + AddRtpSenderWithSsrcs({1}, local_video_track_.get()); + AddRtpReceiverWithSsrcs({2}, remote_video_track_.get()); + InitializeMap(); + // RTP audio sender -> local audio track + EXPECT_EQ(map_.GetAudioTrack(map_.voice_media_info()->senders[0]), + local_audio_track_.get()); + // RTP audio receiver -> remote audio track + EXPECT_EQ(map_.GetAudioTrack(map_.voice_media_info()->receivers[0]), + remote_audio_track_.get()); + // RTP video sender -> local video track + EXPECT_EQ(map_.GetVideoTrack(map_.video_media_info()->senders[0]), + local_video_track_.get()); + // RTP video receiver -> remote video track + EXPECT_EQ(map_.GetVideoTrack(map_.video_media_info()->receivers[0]), + remote_video_track_.get()); +} + +TEST_F(TrackMediaInfoMapTest, SingleMultiSsrcSenderPerTrack) { + AddRtpSenderWithSsrcs({1, 2}, local_audio_track_.get()); + AddRtpSenderWithSsrcs({3, 4}, local_video_track_.get()); + InitializeMap(); + // RTP audio senders -> local audio track + EXPECT_EQ(map_.GetAudioTrack(map_.voice_media_info()->senders[0]), + local_audio_track_.get()); + // RTP video senders -> local video track + EXPECT_EQ(map_.GetVideoTrack(map_.video_media_info()->senders[0]), + local_video_track_.get()); +} + +TEST_F(TrackMediaInfoMapTest, MultipleOneSsrcSendersPerTrack) { + AddRtpSenderWithSsrcs({1}, local_audio_track_.get()); + AddRtpSenderWithSsrcs({2}, local_audio_track_.get()); + AddRtpSenderWithSsrcs({3}, local_video_track_.get()); + AddRtpSenderWithSsrcs({4}, local_video_track_.get()); + InitializeMap(); + // RTP audio senders -> local audio track + EXPECT_EQ(map_.GetAudioTrack(map_.voice_media_info()->senders[0]), + local_audio_track_.get()); + EXPECT_EQ(map_.GetAudioTrack(map_.voice_media_info()->senders[1]), + local_audio_track_.get()); + // RTP video senders -> local video track + EXPECT_EQ(map_.GetVideoTrack(map_.video_media_info()->senders[0]), + local_video_track_.get()); + EXPECT_EQ(map_.GetVideoTrack(map_.video_media_info()->senders[1]), + local_video_track_.get()); +} + +TEST_F(TrackMediaInfoMapTest, MultipleMultiSsrcSendersPerTrack) { + AddRtpSenderWithSsrcs({1, 2}, local_audio_track_.get()); + AddRtpSenderWithSsrcs({3, 4}, local_audio_track_.get()); + AddRtpSenderWithSsrcs({5, 6}, local_video_track_.get()); + AddRtpSenderWithSsrcs({7, 8}, local_video_track_.get()); + InitializeMap(); + // RTP audio senders -> local audio track + EXPECT_EQ(map_.GetAudioTrack(map_.voice_media_info()->senders[0]), + local_audio_track_.get()); + EXPECT_EQ(map_.GetAudioTrack(map_.voice_media_info()->senders[1]), + local_audio_track_.get()); + // RTP video senders -> local video track + EXPECT_EQ(map_.GetVideoTrack(map_.video_media_info()->senders[0]), + local_video_track_.get()); + EXPECT_EQ(map_.GetVideoTrack(map_.video_media_info()->senders[1]), + local_video_track_.get()); +} + +// SSRCs can be reused for send and receive in loopback. +TEST_F(TrackMediaInfoMapTest, SingleSenderReceiverPerTrackWithSsrcNotUnique) { + AddRtpSenderWithSsrcs({1}, local_audio_track_.get()); + AddRtpReceiverWithSsrcs({1}, remote_audio_track_.get()); + AddRtpSenderWithSsrcs({2}, local_video_track_.get()); + AddRtpReceiverWithSsrcs({2}, remote_video_track_.get()); + InitializeMap(); + // RTP audio senders -> local audio track + EXPECT_EQ(map_.GetAudioTrack(map_.voice_media_info()->senders[0]), + local_audio_track_.get()); + // RTP audio receiver -> remote audio track + EXPECT_EQ(map_.GetAudioTrack(map_.voice_media_info()->receivers[0]), + remote_audio_track_.get()); + // RTP video senders -> local video track + EXPECT_EQ(map_.GetVideoTrack(map_.video_media_info()->senders[0]), + local_video_track_.get()); + // RTP video receiver -> remote video track + EXPECT_EQ(map_.GetVideoTrack(map_.video_media_info()->receivers[0]), + remote_video_track_.get()); +} + +TEST_F(TrackMediaInfoMapTest, SsrcLookupFunction) { + AddRtpSenderWithSsrcs({1}, local_audio_track_.get()); + AddRtpReceiverWithSsrcs({2}, remote_audio_track_.get()); + AddRtpSenderWithSsrcs({3}, local_video_track_.get()); + AddRtpReceiverWithSsrcs({4}, remote_video_track_.get()); + InitializeMap(); + EXPECT_TRUE(map_.GetVoiceSenderInfoBySsrc(1)); + EXPECT_TRUE(map_.GetVoiceReceiverInfoBySsrc(2)); + EXPECT_TRUE(map_.GetVideoSenderInfoBySsrc(3)); + EXPECT_TRUE(map_.GetVideoReceiverInfoBySsrc(4)); + EXPECT_FALSE(map_.GetVoiceSenderInfoBySsrc(2)); + EXPECT_FALSE(map_.GetVoiceSenderInfoBySsrc(1024)); +} + +TEST_F(TrackMediaInfoMapTest, GetAttachmentIdByTrack) { + AddRtpSenderWithSsrcs({1}, local_audio_track_.get()); + InitializeMap(); + EXPECT_EQ(rtp_senders_[0]->AttachmentId(), + map_.GetAttachmentIdByTrack(local_audio_track_.get())); + EXPECT_EQ(absl::nullopt, + map_.GetAttachmentIdByTrack(local_video_track_.get())); +} + +} // namespace webrtc -- cgit v1.2.3