solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 11 | #include "call/call.h" |
| 12 | |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 13 | #include <list> |
kwiberg | 1c07c70 | 2017-03-27 14:15:49 | [diff] [blame] | 14 | #include <map> |
kwiberg | b25345e | 2016-03-12 14:10:44 | [diff] [blame] | 15 | #include <memory> |
zstein | 7cb69d5 | 2017-05-08 18:52:38 | [diff] [blame] | 16 | #include <utility> |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 17 | |
Ali Tofigh | 641a1b1 | 2022-05-17 09:48:46 | [diff] [blame] | 18 | #include "absl/strings/string_view.h" |
Karl Wiberg | f3850f6 | 2017-11-02 12:04:41 | [diff] [blame] | 19 | #include "api/audio_codecs/builtin_audio_decoder_factory.h" |
Danil Chapovalov | 3c58501 | 2023-11-27 16:57:44 | [diff] [blame] | 20 | #include "api/environment/environment.h" |
| 21 | #include "api/environment/environment_factory.h" |
Per K | f6ce1d3 | 2023-03-28 15:27:47 | [diff] [blame] | 22 | #include "api/media_types.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 23 | #include "api/test/mock_audio_mixer.h" |
Henrik Boström | f4a9991 | 2020-06-11 10:07:14 | [diff] [blame] | 24 | #include "api/test/video/function_video_encoder_factory.h" |
Per K | f6ce1d3 | 2023-03-28 15:27:47 | [diff] [blame] | 25 | #include "api/units/timestamp.h" |
Henrik Boström | f4a9991 | 2020-06-11 10:07:14 | [diff] [blame] | 26 | #include "api/video/builtin_video_bitrate_allocator_factory.h" |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 27 | #include "audio/audio_receive_stream.h" |
Yves Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 28 | #include "audio/audio_send_stream.h" |
Henrik Boström | f4a9991 | 2020-06-11 10:07:14 | [diff] [blame] | 29 | #include "call/adaptation/test/fake_resource.h" |
Henrik Boström | 29444c6 | 2020-07-01 13:48:46 | [diff] [blame] | 30 | #include "call/adaptation/test/mock_resource_listener.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 31 | #include "call/audio_state.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 32 | #include "modules/audio_device/include/mock_audio_device.h" |
Fredrik Solenberg | 2a87797 | 2017-12-15 15:42:15 | [diff] [blame] | 33 | #include "modules/audio_processing/include/mock_audio_processing.h" |
Tomas Gunnarsson | f25761d | 2020-06-03 20:55:33 | [diff] [blame] | 34 | #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 35 | #include "test/fake_encoder.h" |
| 36 | #include "test/gtest.h" |
| 37 | #include "test/mock_audio_decoder_factory.h" |
| 38 | #include "test/mock_transport.h" |
Tommi | 553c869 | 2020-05-05 13:35:45 | [diff] [blame] | 39 | #include "test/run_loop.h" |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 40 | |
Danil Chapovalov | a3ce407 | 2023-10-13 11:53:00 | [diff] [blame] | 41 | namespace webrtc { |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 42 | namespace { |
| 43 | |
Henrik Boström | 29444c6 | 2020-07-01 13:48:46 | [diff] [blame] | 44 | using ::testing::_; |
Henrik Boström | f4a9991 | 2020-06-11 10:07:14 | [diff] [blame] | 45 | using ::testing::Contains; |
Per K | f6ce1d3 | 2023-03-28 15:27:47 | [diff] [blame] | 46 | using ::testing::MockFunction; |
Alex Konradi | c20baf6 | 2020-12-03 16:30:34 | [diff] [blame] | 47 | using ::testing::NiceMock; |
Henrik Boström | 29444c6 | 2020-07-01 13:48:46 | [diff] [blame] | 48 | using ::testing::StrictMock; |
Danil Chapovalov | a3ce407 | 2023-10-13 11:53:00 | [diff] [blame] | 49 | using ::webrtc::test::MockAudioDeviceModule; |
| 50 | using ::webrtc::test::MockAudioMixer; |
| 51 | using ::webrtc::test::MockAudioProcessing; |
| 52 | using ::webrtc::test::RunLoop; |
Henrik Boström | f4a9991 | 2020-06-11 10:07:14 | [diff] [blame] | 53 | |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 54 | struct CallHelper { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 55 | explicit CallHelper(bool use_null_audio_processing) { |
Danil Chapovalov | a3ce407 | 2023-10-13 11:53:00 | [diff] [blame] | 56 | AudioState::Config audio_state_config; |
| 57 | audio_state_config.audio_mixer = rtc::make_ref_counted<MockAudioMixer>(); |
Fredrik Solenberg | 2a87797 | 2017-12-15 15:42:15 | [diff] [blame] | 58 | audio_state_config.audio_processing = |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 59 | use_null_audio_processing |
| 60 | ? nullptr |
Danil Chapovalov | a3ce407 | 2023-10-13 11:53:00 | [diff] [blame] | 61 | : rtc::make_ref_counted<NiceMock<MockAudioProcessing>>(); |
Fredrik Solenberg | 2a87797 | 2017-12-15 15:42:15 | [diff] [blame] | 62 | audio_state_config.audio_device_module = |
Danil Chapovalov | a3ce407 | 2023-10-13 11:53:00 | [diff] [blame] | 63 | rtc::make_ref_counted<MockAudioDeviceModule>(); |
Danil Chapovalov | 3c58501 | 2023-11-27 16:57:44 | [diff] [blame] | 64 | CallConfig config(CreateEnvironment()); |
Danil Chapovalov | a3ce407 | 2023-10-13 11:53:00 | [diff] [blame] | 65 | config.audio_state = AudioState::Create(audio_state_config); |
Danil Chapovalov | a3ce407 | 2023-10-13 11:53:00 | [diff] [blame] | 66 | call_ = Call::Create(config); |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 67 | } |
| 68 | |
Danil Chapovalov | a3ce407 | 2023-10-13 11:53:00 | [diff] [blame] | 69 | Call* operator->() { return call_.get(); } |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 70 | |
| 71 | private: |
Danil Chapovalov | a3ce407 | 2023-10-13 11:53:00 | [diff] [blame] | 72 | RunLoop loop_; |
Danil Chapovalov | a3ce407 | 2023-10-13 11:53:00 | [diff] [blame] | 73 | std::unique_ptr<Call> call_; |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 74 | }; |
Henrik Boström | 29444c6 | 2020-07-01 13:48:46 | [diff] [blame] | 75 | |
| 76 | rtc::scoped_refptr<Resource> FindResourceWhoseNameContains( |
| 77 | const std::vector<rtc::scoped_refptr<Resource>>& resources, |
Ali Tofigh | 641a1b1 | 2022-05-17 09:48:46 | [diff] [blame] | 78 | absl::string_view name_contains) { |
Henrik Boström | 29444c6 | 2020-07-01 13:48:46 | [diff] [blame] | 79 | for (const auto& resource : resources) { |
Ali Tofigh | 641a1b1 | 2022-05-17 09:48:46 | [diff] [blame] | 80 | if (resource->Name().find(std::string(name_contains)) != std::string::npos) |
Henrik Boström | 29444c6 | 2020-07-01 13:48:46 | [diff] [blame] | 81 | return resource; |
| 82 | } |
| 83 | return nullptr; |
| 84 | } |
| 85 | |
| 86 | } // namespace |
| 87 | |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 88 | TEST(CallTest, ConstructDestruct) { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 89 | for (bool use_null_audio_processing : {false, true}) { |
| 90 | CallHelper call(use_null_audio_processing); |
| 91 | } |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 92 | } |
| 93 | |
| 94 | TEST(CallTest, CreateDestroy_AudioSendStream) { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 95 | for (bool use_null_audio_processing : {false, true}) { |
| 96 | CallHelper call(use_null_audio_processing); |
| 97 | MockTransport send_transport; |
| 98 | AudioSendStream::Config config(&send_transport); |
| 99 | config.rtp.ssrc = 42; |
| 100 | AudioSendStream* stream = call->CreateAudioSendStream(config); |
| 101 | EXPECT_NE(stream, nullptr); |
| 102 | call->DestroyAudioSendStream(stream); |
| 103 | } |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 104 | } |
| 105 | |
| 106 | TEST(CallTest, CreateDestroy_AudioReceiveStream) { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 107 | for (bool use_null_audio_processing : {false, true}) { |
| 108 | CallHelper call(use_null_audio_processing); |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 109 | AudioReceiveStreamInterface::Config config; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 110 | MockTransport rtcp_send_transport; |
| 111 | config.rtp.remote_ssrc = 42; |
| 112 | config.rtcp_send_transport = &rtcp_send_transport; |
| 113 | config.decoder_factory = |
Tomas Gunnarsson | c1d5891 | 2021-04-22 17:21:43 | [diff] [blame] | 114 | rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>(); |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 115 | AudioReceiveStreamInterface* stream = |
| 116 | call->CreateAudioReceiveStream(config); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 117 | EXPECT_NE(stream, nullptr); |
| 118 | call->DestroyAudioReceiveStream(stream); |
| 119 | } |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 120 | } |
| 121 | |
| 122 | TEST(CallTest, CreateDestroy_AudioSendStreams) { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 123 | for (bool use_null_audio_processing : {false, true}) { |
| 124 | CallHelper call(use_null_audio_processing); |
| 125 | MockTransport send_transport; |
| 126 | AudioSendStream::Config config(&send_transport); |
| 127 | std::list<AudioSendStream*> streams; |
| 128 | for (int i = 0; i < 2; ++i) { |
| 129 | for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { |
| 130 | config.rtp.ssrc = ssrc; |
| 131 | AudioSendStream* stream = call->CreateAudioSendStream(config); |
| 132 | EXPECT_NE(stream, nullptr); |
| 133 | if (ssrc & 1) { |
| 134 | streams.push_back(stream); |
| 135 | } else { |
| 136 | streams.push_front(stream); |
| 137 | } |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 138 | } |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 139 | for (auto s : streams) { |
| 140 | call->DestroyAudioSendStream(s); |
| 141 | } |
| 142 | streams.clear(); |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 143 | } |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 144 | } |
| 145 | } |
| 146 | |
| 147 | TEST(CallTest, CreateDestroy_AudioReceiveStreams) { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 148 | for (bool use_null_audio_processing : {false, true}) { |
| 149 | CallHelper call(use_null_audio_processing); |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 150 | AudioReceiveStreamInterface::Config config; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 151 | MockTransport rtcp_send_transport; |
| 152 | config.rtcp_send_transport = &rtcp_send_transport; |
| 153 | config.decoder_factory = |
Tomas Gunnarsson | c1d5891 | 2021-04-22 17:21:43 | [diff] [blame] | 154 | rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>(); |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 155 | std::list<AudioReceiveStreamInterface*> streams; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 156 | for (int i = 0; i < 2; ++i) { |
| 157 | for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { |
| 158 | config.rtp.remote_ssrc = ssrc; |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 159 | AudioReceiveStreamInterface* stream = |
| 160 | call->CreateAudioReceiveStream(config); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 161 | EXPECT_NE(stream, nullptr); |
| 162 | if (ssrc & 1) { |
| 163 | streams.push_back(stream); |
| 164 | } else { |
| 165 | streams.push_front(stream); |
| 166 | } |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 167 | } |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 168 | for (auto s : streams) { |
| 169 | call->DestroyAudioReceiveStream(s); |
| 170 | } |
| 171 | streams.clear(); |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 172 | } |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 173 | } |
| 174 | } |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 175 | |
solenberg | 7602aab | 2016-11-14 19:30:07 | [diff] [blame] | 176 | TEST(CallTest, CreateDestroy_AssociateAudioSendReceiveStreams_RecvFirst) { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 177 | for (bool use_null_audio_processing : {false, true}) { |
| 178 | CallHelper call(use_null_audio_processing); |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 179 | AudioReceiveStreamInterface::Config recv_config; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 180 | MockTransport rtcp_send_transport; |
| 181 | recv_config.rtp.remote_ssrc = 42; |
| 182 | recv_config.rtp.local_ssrc = 777; |
| 183 | recv_config.rtcp_send_transport = &rtcp_send_transport; |
| 184 | recv_config.decoder_factory = |
Tomas Gunnarsson | c1d5891 | 2021-04-22 17:21:43 | [diff] [blame] | 185 | rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>(); |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 186 | AudioReceiveStreamInterface* recv_stream = |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 187 | call->CreateAudioReceiveStream(recv_config); |
| 188 | EXPECT_NE(recv_stream, nullptr); |
solenberg | 7602aab | 2016-11-14 19:30:07 | [diff] [blame] | 189 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 190 | MockTransport send_transport; |
| 191 | AudioSendStream::Config send_config(&send_transport); |
| 192 | send_config.rtp.ssrc = 777; |
| 193 | AudioSendStream* send_stream = call->CreateAudioSendStream(send_config); |
| 194 | EXPECT_NE(send_stream, nullptr); |
solenberg | 7602aab | 2016-11-14 19:30:07 | [diff] [blame] | 195 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 196 | AudioReceiveStreamImpl* internal_recv_stream = |
| 197 | static_cast<AudioReceiveStreamImpl*>(recv_stream); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 198 | EXPECT_EQ(send_stream, |
| 199 | internal_recv_stream->GetAssociatedSendStreamForTesting()); |
solenberg | 7602aab | 2016-11-14 19:30:07 | [diff] [blame] | 200 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 201 | call->DestroyAudioSendStream(send_stream); |
| 202 | EXPECT_EQ(nullptr, |
| 203 | internal_recv_stream->GetAssociatedSendStreamForTesting()); |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 204 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 205 | call->DestroyAudioReceiveStream(recv_stream); |
| 206 | } |
solenberg | 7602aab | 2016-11-14 19:30:07 | [diff] [blame] | 207 | } |
| 208 | |
| 209 | TEST(CallTest, CreateDestroy_AssociateAudioSendReceiveStreams_SendFirst) { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 210 | for (bool use_null_audio_processing : {false, true}) { |
| 211 | CallHelper call(use_null_audio_processing); |
| 212 | MockTransport send_transport; |
| 213 | AudioSendStream::Config send_config(&send_transport); |
| 214 | send_config.rtp.ssrc = 777; |
| 215 | AudioSendStream* send_stream = call->CreateAudioSendStream(send_config); |
| 216 | EXPECT_NE(send_stream, nullptr); |
solenberg | 7602aab | 2016-11-14 19:30:07 | [diff] [blame] | 217 | |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 218 | AudioReceiveStreamInterface::Config recv_config; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 219 | MockTransport rtcp_send_transport; |
| 220 | recv_config.rtp.remote_ssrc = 42; |
| 221 | recv_config.rtp.local_ssrc = 777; |
| 222 | recv_config.rtcp_send_transport = &rtcp_send_transport; |
| 223 | recv_config.decoder_factory = |
Tomas Gunnarsson | c1d5891 | 2021-04-22 17:21:43 | [diff] [blame] | 224 | rtc::make_ref_counted<webrtc::MockAudioDecoderFactory>(); |
Tommi | 3176ef7 | 2022-05-22 18:47:28 | [diff] [blame] | 225 | AudioReceiveStreamInterface* recv_stream = |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 226 | call->CreateAudioReceiveStream(recv_config); |
| 227 | EXPECT_NE(recv_stream, nullptr); |
solenberg | 7602aab | 2016-11-14 19:30:07 | [diff] [blame] | 228 | |
Tommi | dddbbeb | 2022-05-20 13:21:33 | [diff] [blame] | 229 | AudioReceiveStreamImpl* internal_recv_stream = |
| 230 | static_cast<AudioReceiveStreamImpl*>(recv_stream); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 231 | EXPECT_EQ(send_stream, |
| 232 | internal_recv_stream->GetAssociatedSendStreamForTesting()); |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 233 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 234 | call->DestroyAudioReceiveStream(recv_stream); |
solenberg | 7602aab | 2016-11-14 19:30:07 | [diff] [blame] | 235 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 236 | call->DestroyAudioSendStream(send_stream); |
| 237 | } |
solenberg | 7602aab | 2016-11-14 19:30:07 | [diff] [blame] | 238 | } |
| 239 | |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 240 | TEST(CallTest, CreateDestroy_FlexfecReceiveStream) { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 241 | for (bool use_null_audio_processing : {false, true}) { |
| 242 | CallHelper call(use_null_audio_processing); |
| 243 | MockTransport rtcp_send_transport; |
| 244 | FlexfecReceiveStream::Config config(&rtcp_send_transport); |
| 245 | config.payload_type = 118; |
Tommi | 1c1f540 | 2021-06-14 08:54:20 | [diff] [blame] | 246 | config.rtp.remote_ssrc = 38837212; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 247 | config.protected_media_ssrcs = {27273}; |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 248 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 249 | FlexfecReceiveStream* stream = call->CreateFlexfecReceiveStream(config); |
| 250 | EXPECT_NE(stream, nullptr); |
| 251 | call->DestroyFlexfecReceiveStream(stream); |
| 252 | } |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | TEST(CallTest, CreateDestroy_FlexfecReceiveStreams) { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 256 | for (bool use_null_audio_processing : {false, true}) { |
| 257 | CallHelper call(use_null_audio_processing); |
| 258 | MockTransport rtcp_send_transport; |
| 259 | FlexfecReceiveStream::Config config(&rtcp_send_transport); |
| 260 | config.payload_type = 118; |
| 261 | std::list<FlexfecReceiveStream*> streams; |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 262 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 263 | for (int i = 0; i < 2; ++i) { |
| 264 | for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { |
Tommi | 1c1f540 | 2021-06-14 08:54:20 | [diff] [blame] | 265 | config.rtp.remote_ssrc = ssrc; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 266 | config.protected_media_ssrcs = {ssrc + 1}; |
| 267 | FlexfecReceiveStream* stream = call->CreateFlexfecReceiveStream(config); |
| 268 | EXPECT_NE(stream, nullptr); |
| 269 | if (ssrc & 1) { |
| 270 | streams.push_back(stream); |
| 271 | } else { |
| 272 | streams.push_front(stream); |
| 273 | } |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 274 | } |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 275 | for (auto s : streams) { |
| 276 | call->DestroyFlexfecReceiveStream(s); |
| 277 | } |
| 278 | streams.clear(); |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 279 | } |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 280 | } |
| 281 | } |
| 282 | |
| 283 | TEST(CallTest, MultipleFlexfecReceiveStreamsProtectingSingleVideoStream) { |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 284 | for (bool use_null_audio_processing : {false, true}) { |
| 285 | CallHelper call(use_null_audio_processing); |
| 286 | MockTransport rtcp_send_transport; |
| 287 | FlexfecReceiveStream::Config config(&rtcp_send_transport); |
| 288 | config.payload_type = 118; |
| 289 | config.protected_media_ssrcs = {1324234}; |
| 290 | FlexfecReceiveStream* stream; |
| 291 | std::list<FlexfecReceiveStream*> streams; |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 292 | |
Tommi | 1c1f540 | 2021-06-14 08:54:20 | [diff] [blame] | 293 | config.rtp.remote_ssrc = 838383; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 294 | stream = call->CreateFlexfecReceiveStream(config); |
| 295 | EXPECT_NE(stream, nullptr); |
| 296 | streams.push_back(stream); |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 297 | |
Tommi | 1c1f540 | 2021-06-14 08:54:20 | [diff] [blame] | 298 | config.rtp.remote_ssrc = 424993; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 299 | stream = call->CreateFlexfecReceiveStream(config); |
| 300 | EXPECT_NE(stream, nullptr); |
| 301 | streams.push_back(stream); |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 302 | |
Tommi | 1c1f540 | 2021-06-14 08:54:20 | [diff] [blame] | 303 | config.rtp.remote_ssrc = 99383; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 304 | stream = call->CreateFlexfecReceiveStream(config); |
| 305 | EXPECT_NE(stream, nullptr); |
| 306 | streams.push_back(stream); |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 307 | |
Tommi | 1c1f540 | 2021-06-14 08:54:20 | [diff] [blame] | 308 | config.rtp.remote_ssrc = 5548; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 309 | stream = call->CreateFlexfecReceiveStream(config); |
| 310 | EXPECT_NE(stream, nullptr); |
| 311 | streams.push_back(stream); |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 312 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 313 | for (auto s : streams) { |
| 314 | call->DestroyFlexfecReceiveStream(s); |
| 315 | } |
brandtr | 25445d3 | 2016-10-24 06:37:14 | [diff] [blame] | 316 | } |
| 317 | } |
| 318 | |
Per K | f6ce1d3 | 2023-03-28 15:27:47 | [diff] [blame] | 319 | TEST(CallTest, |
| 320 | DeliverRtpPacketOfTypeAudioTriggerOnUndemuxablePacketHandlerIfNotDemuxed) { |
| 321 | CallHelper call(/*use_null_audio_processing=*/false); |
| 322 | MockFunction<bool(const RtpPacketReceived& parsed_packet)> |
| 323 | un_demuxable_packet_handler; |
| 324 | |
| 325 | RtpPacketReceived packet; |
| 326 | packet.set_arrival_time(Timestamp::Millis(1)); |
| 327 | EXPECT_CALL(un_demuxable_packet_handler, Call); |
| 328 | call->Receiver()->DeliverRtpPacket( |
| 329 | MediaType::AUDIO, packet, un_demuxable_packet_handler.AsStdFunction()); |
| 330 | } |
| 331 | |
| 332 | TEST(CallTest, |
| 333 | DeliverRtpPacketOfTypeVideoTriggerOnUndemuxablePacketHandlerIfNotDemuxed) { |
| 334 | CallHelper call(/*use_null_audio_processing=*/false); |
| 335 | MockFunction<bool(const RtpPacketReceived& parsed_packet)> |
| 336 | un_demuxable_packet_handler; |
| 337 | |
| 338 | RtpPacketReceived packet; |
| 339 | packet.set_arrival_time(Timestamp::Millis(1)); |
| 340 | EXPECT_CALL(un_demuxable_packet_handler, Call); |
| 341 | call->Receiver()->DeliverRtpPacket( |
| 342 | MediaType::VIDEO, packet, un_demuxable_packet_handler.AsStdFunction()); |
| 343 | } |
| 344 | |
| 345 | TEST(CallTest, |
| 346 | DeliverRtpPacketOfTypeAnyDoesNotTriggerOnUndemuxablePacketHandler) { |
| 347 | CallHelper call(/*use_null_audio_processing=*/false); |
| 348 | MockFunction<bool(const RtpPacketReceived& parsed_packet)> |
| 349 | un_demuxable_packet_handler; |
| 350 | |
| 351 | RtpPacketReceived packet; |
| 352 | packet.set_arrival_time(Timestamp::Millis(1)); |
| 353 | EXPECT_CALL(un_demuxable_packet_handler, Call).Times(0); |
| 354 | call->Receiver()->DeliverRtpPacket( |
| 355 | MediaType::ANY, packet, un_demuxable_packet_handler.AsStdFunction()); |
| 356 | } |
| 357 | |
ossu | c3d4b48 | 2017-05-23 13:07:11 | [diff] [blame] | 358 | TEST(CallTest, RecreatingAudioStreamWithSameSsrcReusesRtpState) { |
| 359 | constexpr uint32_t kSSRC = 12345; |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 360 | for (bool use_null_audio_processing : {false, true}) { |
| 361 | CallHelper call(use_null_audio_processing); |
ossu | c3d4b48 | 2017-05-23 13:07:11 | [diff] [blame] | 362 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 363 | auto create_stream_and_get_rtp_state = [&](uint32_t ssrc) { |
| 364 | MockTransport send_transport; |
| 365 | AudioSendStream::Config config(&send_transport); |
| 366 | config.rtp.ssrc = ssrc; |
| 367 | AudioSendStream* stream = call->CreateAudioSendStream(config); |
| 368 | const RtpState rtp_state = |
| 369 | static_cast<internal::AudioSendStream*>(stream)->GetRtpState(); |
| 370 | call->DestroyAudioSendStream(stream); |
| 371 | return rtp_state; |
| 372 | }; |
ossu | c3d4b48 | 2017-05-23 13:07:11 | [diff] [blame] | 373 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 374 | const RtpState rtp_state1 = create_stream_and_get_rtp_state(kSSRC); |
| 375 | const RtpState rtp_state2 = create_stream_and_get_rtp_state(kSSRC); |
ossu | c3d4b48 | 2017-05-23 13:07:11 | [diff] [blame] | 376 | |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 377 | EXPECT_EQ(rtp_state1.sequence_number, rtp_state2.sequence_number); |
| 378 | EXPECT_EQ(rtp_state1.start_timestamp, rtp_state2.start_timestamp); |
| 379 | EXPECT_EQ(rtp_state1.timestamp, rtp_state2.timestamp); |
Danil Chapovalov | 9ecc76e | 2023-04-26 08:46:10 | [diff] [blame] | 380 | EXPECT_EQ(rtp_state1.capture_time, rtp_state2.capture_time); |
| 381 | EXPECT_EQ(rtp_state1.last_timestamp_time, rtp_state2.last_timestamp_time); |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 382 | } |
ossu | c3d4b48 | 2017-05-23 13:07:11 | [diff] [blame] | 383 | } |
Fredrik Solenberg | 8f5787a | 2018-01-11 12:52:30 | [diff] [blame] | 384 | |
Henrik Boström | f4a9991 | 2020-06-11 10:07:14 | [diff] [blame] | 385 | TEST(CallTest, AddAdaptationResourceAfterCreatingVideoSendStream) { |
| 386 | CallHelper call(true); |
| 387 | // Create a VideoSendStream. |
| 388 | test::FunctionVideoEncoderFactory fake_encoder_factory([]() { |
| 389 | return std::make_unique<test::FakeEncoder>(Clock::GetRealTimeClock()); |
| 390 | }); |
| 391 | auto bitrate_allocator_factory = CreateBuiltinVideoBitrateAllocatorFactory(); |
| 392 | MockTransport send_transport; |
| 393 | VideoSendStream::Config config(&send_transport); |
| 394 | config.rtp.payload_type = 110; |
| 395 | config.rtp.ssrcs = {42}; |
| 396 | config.encoder_settings.encoder_factory = &fake_encoder_factory; |
| 397 | config.encoder_settings.bitrate_allocator_factory = |
| 398 | bitrate_allocator_factory.get(); |
| 399 | VideoEncoderConfig encoder_config; |
| 400 | encoder_config.max_bitrate_bps = 1337; |
Henrik Boström | 29444c6 | 2020-07-01 13:48:46 | [diff] [blame] | 401 | VideoSendStream* stream1 = |
| 402 | call->CreateVideoSendStream(config.Copy(), encoder_config.Copy()); |
| 403 | EXPECT_NE(stream1, nullptr); |
| 404 | config.rtp.ssrcs = {43}; |
| 405 | VideoSendStream* stream2 = |
| 406 | call->CreateVideoSendStream(config.Copy(), encoder_config.Copy()); |
| 407 | EXPECT_NE(stream2, nullptr); |
| 408 | // Add a fake resource. |
Henrik Boström | f4a9991 | 2020-06-11 10:07:14 | [diff] [blame] | 409 | auto fake_resource = FakeResource::Create("FakeResource"); |
| 410 | call->AddAdaptationResource(fake_resource); |
Artem Titov | ea24027 | 2021-07-26 10:40:21 | [diff] [blame] | 411 | // An adapter resource mirroring the `fake_resource` should now be present on |
Henrik Boström | 29444c6 | 2020-07-01 13:48:46 | [diff] [blame] | 412 | // both streams. |
| 413 | auto injected_resource1 = FindResourceWhoseNameContains( |
| 414 | stream1->GetAdaptationResources(), fake_resource->Name()); |
| 415 | EXPECT_TRUE(injected_resource1); |
| 416 | auto injected_resource2 = FindResourceWhoseNameContains( |
| 417 | stream2->GetAdaptationResources(), fake_resource->Name()); |
| 418 | EXPECT_TRUE(injected_resource2); |
| 419 | // Overwrite the real resource listeners with mock ones to verify the signal |
| 420 | // gets through. |
| 421 | injected_resource1->SetResourceListener(nullptr); |
| 422 | StrictMock<MockResourceListener> resource_listener1; |
| 423 | EXPECT_CALL(resource_listener1, OnResourceUsageStateMeasured(_, _)) |
| 424 | .Times(1) |
| 425 | .WillOnce([injected_resource1](rtc::scoped_refptr<Resource> resource, |
| 426 | ResourceUsageState usage_state) { |
| 427 | EXPECT_EQ(injected_resource1, resource); |
| 428 | EXPECT_EQ(ResourceUsageState::kOveruse, usage_state); |
| 429 | }); |
| 430 | injected_resource1->SetResourceListener(&resource_listener1); |
| 431 | injected_resource2->SetResourceListener(nullptr); |
| 432 | StrictMock<MockResourceListener> resource_listener2; |
| 433 | EXPECT_CALL(resource_listener2, OnResourceUsageStateMeasured(_, _)) |
| 434 | .Times(1) |
| 435 | .WillOnce([injected_resource2](rtc::scoped_refptr<Resource> resource, |
| 436 | ResourceUsageState usage_state) { |
| 437 | EXPECT_EQ(injected_resource2, resource); |
| 438 | EXPECT_EQ(ResourceUsageState::kOveruse, usage_state); |
| 439 | }); |
| 440 | injected_resource2->SetResourceListener(&resource_listener2); |
| 441 | // The kOveruse signal should get to our resource listeners. |
| 442 | fake_resource->SetUsageState(ResourceUsageState::kOveruse); |
| 443 | call->DestroyVideoSendStream(stream1); |
| 444 | call->DestroyVideoSendStream(stream2); |
Henrik Boström | f4a9991 | 2020-06-11 10:07:14 | [diff] [blame] | 445 | } |
| 446 | |
| 447 | TEST(CallTest, AddAdaptationResourceBeforeCreatingVideoSendStream) { |
| 448 | CallHelper call(true); |
| 449 | // Add a fake resource. |
| 450 | auto fake_resource = FakeResource::Create("FakeResource"); |
| 451 | call->AddAdaptationResource(fake_resource); |
| 452 | // Create a VideoSendStream. |
| 453 | test::FunctionVideoEncoderFactory fake_encoder_factory([]() { |
| 454 | return std::make_unique<test::FakeEncoder>(Clock::GetRealTimeClock()); |
| 455 | }); |
| 456 | auto bitrate_allocator_factory = CreateBuiltinVideoBitrateAllocatorFactory(); |
| 457 | MockTransport send_transport; |
| 458 | VideoSendStream::Config config(&send_transport); |
| 459 | config.rtp.payload_type = 110; |
| 460 | config.rtp.ssrcs = {42}; |
| 461 | config.encoder_settings.encoder_factory = &fake_encoder_factory; |
| 462 | config.encoder_settings.bitrate_allocator_factory = |
| 463 | bitrate_allocator_factory.get(); |
| 464 | VideoEncoderConfig encoder_config; |
| 465 | encoder_config.max_bitrate_bps = 1337; |
Henrik Boström | 29444c6 | 2020-07-01 13:48:46 | [diff] [blame] | 466 | VideoSendStream* stream1 = |
| 467 | call->CreateVideoSendStream(config.Copy(), encoder_config.Copy()); |
| 468 | EXPECT_NE(stream1, nullptr); |
| 469 | config.rtp.ssrcs = {43}; |
| 470 | VideoSendStream* stream2 = |
| 471 | call->CreateVideoSendStream(config.Copy(), encoder_config.Copy()); |
| 472 | EXPECT_NE(stream2, nullptr); |
Artem Titov | ea24027 | 2021-07-26 10:40:21 | [diff] [blame] | 473 | // An adapter resource mirroring the `fake_resource` should be present on both |
Henrik Boström | 29444c6 | 2020-07-01 13:48:46 | [diff] [blame] | 474 | // streams. |
| 475 | auto injected_resource1 = FindResourceWhoseNameContains( |
| 476 | stream1->GetAdaptationResources(), fake_resource->Name()); |
| 477 | EXPECT_TRUE(injected_resource1); |
| 478 | auto injected_resource2 = FindResourceWhoseNameContains( |
| 479 | stream2->GetAdaptationResources(), fake_resource->Name()); |
| 480 | EXPECT_TRUE(injected_resource2); |
| 481 | // Overwrite the real resource listeners with mock ones to verify the signal |
| 482 | // gets through. |
| 483 | injected_resource1->SetResourceListener(nullptr); |
| 484 | StrictMock<MockResourceListener> resource_listener1; |
| 485 | EXPECT_CALL(resource_listener1, OnResourceUsageStateMeasured(_, _)) |
| 486 | .Times(1) |
| 487 | .WillOnce([injected_resource1](rtc::scoped_refptr<Resource> resource, |
| 488 | ResourceUsageState usage_state) { |
| 489 | EXPECT_EQ(injected_resource1, resource); |
| 490 | EXPECT_EQ(ResourceUsageState::kUnderuse, usage_state); |
| 491 | }); |
| 492 | injected_resource1->SetResourceListener(&resource_listener1); |
| 493 | injected_resource2->SetResourceListener(nullptr); |
| 494 | StrictMock<MockResourceListener> resource_listener2; |
| 495 | EXPECT_CALL(resource_listener2, OnResourceUsageStateMeasured(_, _)) |
| 496 | .Times(1) |
| 497 | .WillOnce([injected_resource2](rtc::scoped_refptr<Resource> resource, |
| 498 | ResourceUsageState usage_state) { |
| 499 | EXPECT_EQ(injected_resource2, resource); |
| 500 | EXPECT_EQ(ResourceUsageState::kUnderuse, usage_state); |
| 501 | }); |
| 502 | injected_resource2->SetResourceListener(&resource_listener2); |
| 503 | // The kUnderuse signal should get to our resource listeners. |
| 504 | fake_resource->SetUsageState(ResourceUsageState::kUnderuse); |
| 505 | call->DestroyVideoSendStream(stream1); |
| 506 | call->DestroyVideoSendStream(stream2); |
Henrik Boström | f4a9991 | 2020-06-11 10:07:14 | [diff] [blame] | 507 | } |
| 508 | |
solenberg | c7a8b08 | 2015-10-16 21:35:07 | [diff] [blame] | 509 | } // namespace webrtc |