solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [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 19:08:33 +0200 | [diff] [blame] | 11 | #include "call/call.h" |
| 12 | |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 13 | #include <list> |
kwiberg | 1c07c70 | 2017-03-27 07:15:49 -0700 | [diff] [blame] | 14 | #include <map> |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 15 | #include <memory> |
zstein | 7cb69d5 | 2017-05-08 11:52:38 -0700 | [diff] [blame] | 16 | #include <utility> |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 17 | |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 18 | #include "absl/memory/memory.h" |
Karl Wiberg | f3850f6 | 2017-11-02 13:04:41 +0100 | [diff] [blame] | 19 | #include "api/audio_codecs/builtin_audio_decoder_factory.h" |
Danil Chapovalov | 83bbe91 | 2019-08-07 12:24:53 +0200 | [diff] [blame] | 20 | #include "api/rtc_event_log/rtc_event_log.h" |
Danil Chapovalov | 53d45ba | 2019-07-03 14:56:33 +0200 | [diff] [blame] | 21 | #include "api/task_queue/default_task_queue_factory.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 22 | #include "api/test/mock_audio_mixer.h" |
Erik Språng | 014dd3c | 2019-11-28 13:44:25 +0100 | [diff] [blame] | 23 | #include "api/transport/field_trial_based_config.h" |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 24 | #include "audio/audio_receive_stream.h" |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 25 | #include "audio/audio_send_stream.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 26 | #include "call/audio_state.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 27 | #include "modules/audio_device/include/mock_audio_device.h" |
Fredrik Solenberg | 2a87797 | 2017-12-15 16:42:15 +0100 | [diff] [blame] | 28 | #include "modules/audio_processing/include/mock_audio_processing.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 29 | #include "modules/rtp_rtcp/include/rtp_rtcp.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 30 | #include "test/fake_encoder.h" |
| 31 | #include "test/gtest.h" |
| 32 | #include "test/mock_audio_decoder_factory.h" |
| 33 | #include "test/mock_transport.h" |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 34 | |
| 35 | namespace { |
| 36 | |
| 37 | struct CallHelper { |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 38 | CallHelper() { |
Danil Chapovalov | 53d45ba | 2019-07-03 14:56:33 +0200 | [diff] [blame] | 39 | task_queue_factory_ = webrtc::CreateDefaultTaskQueueFactory(); |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 40 | webrtc::AudioState::Config audio_state_config; |
Fredrik Solenberg | 2a87797 | 2017-12-15 16:42:15 +0100 | [diff] [blame] | 41 | audio_state_config.audio_mixer = |
| 42 | new rtc::RefCountedObject<webrtc::test::MockAudioMixer>(); |
| 43 | audio_state_config.audio_processing = |
| 44 | new rtc::RefCountedObject<webrtc::test::MockAudioProcessing>(); |
| 45 | audio_state_config.audio_device_module = |
| 46 | new rtc::RefCountedObject<webrtc::test::MockAudioDeviceModule>(); |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame] | 47 | webrtc::Call::Config config(&event_log_); |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 48 | config.audio_state = webrtc::AudioState::Create(audio_state_config); |
Danil Chapovalov | 53d45ba | 2019-07-03 14:56:33 +0200 | [diff] [blame] | 49 | config.task_queue_factory = task_queue_factory_.get(); |
Erik Språng | 014dd3c | 2019-11-28 13:44:25 +0100 | [diff] [blame] | 50 | config.trials = &field_trials_; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 51 | call_.reset(webrtc::Call::Create(config)); |
| 52 | } |
| 53 | |
| 54 | webrtc::Call* operator->() { return call_.get(); } |
| 55 | |
| 56 | private: |
Danil Chapovalov | 83bbe91 | 2019-08-07 12:24:53 +0200 | [diff] [blame] | 57 | webrtc::RtcEventLogNull event_log_; |
Erik Språng | 014dd3c | 2019-11-28 13:44:25 +0100 | [diff] [blame] | 58 | webrtc::FieldTrialBasedConfig field_trials_; |
Danil Chapovalov | 53d45ba | 2019-07-03 14:56:33 +0200 | [diff] [blame] | 59 | std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_; |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 60 | std::unique_ptr<webrtc::Call> call_; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 61 | }; |
| 62 | } // namespace |
| 63 | |
| 64 | namespace webrtc { |
| 65 | |
| 66 | TEST(CallTest, ConstructDestruct) { |
| 67 | CallHelper call; |
| 68 | } |
| 69 | |
| 70 | TEST(CallTest, CreateDestroy_AudioSendStream) { |
| 71 | CallHelper call; |
Fredrik Solenberg | 3d2ed19 | 2018-12-18 09:18:33 +0100 | [diff] [blame] | 72 | MockTransport send_transport; |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 73 | AudioSendStream::Config config(&send_transport); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 74 | config.rtp.ssrc = 42; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 75 | AudioSendStream* stream = call->CreateAudioSendStream(config); |
| 76 | EXPECT_NE(stream, nullptr); |
| 77 | call->DestroyAudioSendStream(stream); |
| 78 | } |
| 79 | |
| 80 | TEST(CallTest, CreateDestroy_AudioReceiveStream) { |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 81 | CallHelper call; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 82 | AudioReceiveStream::Config config; |
Niels Möller | ae4237e | 2018-10-05 11:28:38 +0200 | [diff] [blame] | 83 | MockTransport rtcp_send_transport; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 84 | config.rtp.remote_ssrc = 42; |
Niels Möller | ae4237e | 2018-10-05 11:28:38 +0200 | [diff] [blame] | 85 | config.rtcp_send_transport = &rtcp_send_transport; |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 86 | config.decoder_factory = |
| 87 | new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>(); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 88 | AudioReceiveStream* stream = call->CreateAudioReceiveStream(config); |
| 89 | EXPECT_NE(stream, nullptr); |
| 90 | call->DestroyAudioReceiveStream(stream); |
| 91 | } |
| 92 | |
| 93 | TEST(CallTest, CreateDestroy_AudioSendStreams) { |
| 94 | CallHelper call; |
Fredrik Solenberg | 3d2ed19 | 2018-12-18 09:18:33 +0100 | [diff] [blame] | 95 | MockTransport send_transport; |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 96 | AudioSendStream::Config config(&send_transport); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 97 | std::list<AudioSendStream*> streams; |
| 98 | for (int i = 0; i < 2; ++i) { |
| 99 | for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { |
| 100 | config.rtp.ssrc = ssrc; |
| 101 | AudioSendStream* stream = call->CreateAudioSendStream(config); |
| 102 | EXPECT_NE(stream, nullptr); |
| 103 | if (ssrc & 1) { |
| 104 | streams.push_back(stream); |
| 105 | } else { |
| 106 | streams.push_front(stream); |
| 107 | } |
| 108 | } |
| 109 | for (auto s : streams) { |
| 110 | call->DestroyAudioSendStream(s); |
| 111 | } |
| 112 | streams.clear(); |
| 113 | } |
| 114 | } |
| 115 | |
| 116 | TEST(CallTest, CreateDestroy_AudioReceiveStreams) { |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 117 | CallHelper call; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 118 | AudioReceiveStream::Config config; |
Niels Möller | ae4237e | 2018-10-05 11:28:38 +0200 | [diff] [blame] | 119 | MockTransport rtcp_send_transport; |
| 120 | config.rtcp_send_transport = &rtcp_send_transport; |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 121 | config.decoder_factory = |
| 122 | new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>(); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 123 | std::list<AudioReceiveStream*> streams; |
| 124 | for (int i = 0; i < 2; ++i) { |
| 125 | for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { |
| 126 | config.rtp.remote_ssrc = ssrc; |
| 127 | AudioReceiveStream* stream = call->CreateAudioReceiveStream(config); |
| 128 | EXPECT_NE(stream, nullptr); |
| 129 | if (ssrc & 1) { |
| 130 | streams.push_back(stream); |
| 131 | } else { |
| 132 | streams.push_front(stream); |
| 133 | } |
| 134 | } |
| 135 | for (auto s : streams) { |
| 136 | call->DestroyAudioReceiveStream(s); |
| 137 | } |
| 138 | streams.clear(); |
| 139 | } |
| 140 | } |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 141 | |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 142 | TEST(CallTest, CreateDestroy_AssociateAudioSendReceiveStreams_RecvFirst) { |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 143 | CallHelper call; |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 144 | AudioReceiveStream::Config recv_config; |
Niels Möller | ae4237e | 2018-10-05 11:28:38 +0200 | [diff] [blame] | 145 | MockTransport rtcp_send_transport; |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 146 | recv_config.rtp.remote_ssrc = 42; |
| 147 | recv_config.rtp.local_ssrc = 777; |
Niels Möller | ae4237e | 2018-10-05 11:28:38 +0200 | [diff] [blame] | 148 | recv_config.rtcp_send_transport = &rtcp_send_transport; |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 149 | recv_config.decoder_factory = |
| 150 | new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>(); |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 151 | AudioReceiveStream* recv_stream = call->CreateAudioReceiveStream(recv_config); |
| 152 | EXPECT_NE(recv_stream, nullptr); |
| 153 | |
Fredrik Solenberg | 3d2ed19 | 2018-12-18 09:18:33 +0100 | [diff] [blame] | 154 | MockTransport send_transport; |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 155 | AudioSendStream::Config send_config(&send_transport); |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 156 | send_config.rtp.ssrc = 777; |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 157 | AudioSendStream* send_stream = call->CreateAudioSendStream(send_config); |
| 158 | EXPECT_NE(send_stream, nullptr); |
| 159 | |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 160 | internal::AudioReceiveStream* internal_recv_stream = |
| 161 | static_cast<internal::AudioReceiveStream*>(recv_stream); |
| 162 | EXPECT_EQ(send_stream, |
| 163 | internal_recv_stream->GetAssociatedSendStreamForTesting()); |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 164 | |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 165 | call->DestroyAudioSendStream(send_stream); |
| 166 | EXPECT_EQ(nullptr, internal_recv_stream->GetAssociatedSendStreamForTesting()); |
| 167 | |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 168 | call->DestroyAudioReceiveStream(recv_stream); |
| 169 | } |
| 170 | |
| 171 | TEST(CallTest, CreateDestroy_AssociateAudioSendReceiveStreams_SendFirst) { |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 172 | CallHelper call; |
Fredrik Solenberg | 3d2ed19 | 2018-12-18 09:18:33 +0100 | [diff] [blame] | 173 | MockTransport send_transport; |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 174 | AudioSendStream::Config send_config(&send_transport); |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 175 | send_config.rtp.ssrc = 777; |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 176 | AudioSendStream* send_stream = call->CreateAudioSendStream(send_config); |
| 177 | EXPECT_NE(send_stream, nullptr); |
| 178 | |
| 179 | AudioReceiveStream::Config recv_config; |
Niels Möller | ae4237e | 2018-10-05 11:28:38 +0200 | [diff] [blame] | 180 | MockTransport rtcp_send_transport; |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 181 | recv_config.rtp.remote_ssrc = 42; |
| 182 | recv_config.rtp.local_ssrc = 777; |
Niels Möller | ae4237e | 2018-10-05 11:28:38 +0200 | [diff] [blame] | 183 | recv_config.rtcp_send_transport = &rtcp_send_transport; |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 184 | recv_config.decoder_factory = |
| 185 | new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>(); |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 186 | AudioReceiveStream* recv_stream = call->CreateAudioReceiveStream(recv_config); |
| 187 | EXPECT_NE(recv_stream, nullptr); |
| 188 | |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 189 | internal::AudioReceiveStream* internal_recv_stream = |
| 190 | static_cast<internal::AudioReceiveStream*>(recv_stream); |
| 191 | EXPECT_EQ(send_stream, |
| 192 | internal_recv_stream->GetAssociatedSendStreamForTesting()); |
| 193 | |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 194 | call->DestroyAudioReceiveStream(recv_stream); |
| 195 | |
| 196 | call->DestroyAudioSendStream(send_stream); |
| 197 | } |
| 198 | |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 199 | TEST(CallTest, CreateDestroy_FlexfecReceiveStream) { |
| 200 | CallHelper call; |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 201 | MockTransport rtcp_send_transport; |
| 202 | FlexfecReceiveStream::Config config(&rtcp_send_transport); |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 203 | config.payload_type = 118; |
| 204 | config.remote_ssrc = 38837212; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 205 | config.protected_media_ssrcs = {27273}; |
| 206 | |
| 207 | FlexfecReceiveStream* stream = call->CreateFlexfecReceiveStream(config); |
| 208 | EXPECT_NE(stream, nullptr); |
| 209 | call->DestroyFlexfecReceiveStream(stream); |
| 210 | } |
| 211 | |
| 212 | TEST(CallTest, CreateDestroy_FlexfecReceiveStreams) { |
| 213 | CallHelper call; |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 214 | MockTransport rtcp_send_transport; |
| 215 | FlexfecReceiveStream::Config config(&rtcp_send_transport); |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 216 | config.payload_type = 118; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 217 | std::list<FlexfecReceiveStream*> streams; |
| 218 | |
| 219 | for (int i = 0; i < 2; ++i) { |
| 220 | for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 221 | config.remote_ssrc = ssrc; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 222 | config.protected_media_ssrcs = {ssrc + 1}; |
| 223 | FlexfecReceiveStream* stream = call->CreateFlexfecReceiveStream(config); |
| 224 | EXPECT_NE(stream, nullptr); |
| 225 | if (ssrc & 1) { |
| 226 | streams.push_back(stream); |
| 227 | } else { |
| 228 | streams.push_front(stream); |
| 229 | } |
| 230 | } |
| 231 | for (auto s : streams) { |
| 232 | call->DestroyFlexfecReceiveStream(s); |
| 233 | } |
| 234 | streams.clear(); |
| 235 | } |
| 236 | } |
| 237 | |
| 238 | TEST(CallTest, MultipleFlexfecReceiveStreamsProtectingSingleVideoStream) { |
| 239 | CallHelper call; |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 240 | MockTransport rtcp_send_transport; |
| 241 | FlexfecReceiveStream::Config config(&rtcp_send_transport); |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 242 | config.payload_type = 118; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 243 | config.protected_media_ssrcs = {1324234}; |
| 244 | FlexfecReceiveStream* stream; |
| 245 | std::list<FlexfecReceiveStream*> streams; |
| 246 | |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 247 | config.remote_ssrc = 838383; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 248 | stream = call->CreateFlexfecReceiveStream(config); |
| 249 | EXPECT_NE(stream, nullptr); |
| 250 | streams.push_back(stream); |
| 251 | |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 252 | config.remote_ssrc = 424993; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 253 | stream = call->CreateFlexfecReceiveStream(config); |
| 254 | EXPECT_NE(stream, nullptr); |
| 255 | streams.push_back(stream); |
| 256 | |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 257 | config.remote_ssrc = 99383; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 258 | stream = call->CreateFlexfecReceiveStream(config); |
| 259 | EXPECT_NE(stream, nullptr); |
| 260 | streams.push_back(stream); |
| 261 | |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 262 | config.remote_ssrc = 5548; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 263 | stream = call->CreateFlexfecReceiveStream(config); |
| 264 | EXPECT_NE(stream, nullptr); |
| 265 | streams.push_back(stream); |
| 266 | |
| 267 | for (auto s : streams) { |
| 268 | call->DestroyFlexfecReceiveStream(s); |
| 269 | } |
| 270 | } |
| 271 | |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 272 | TEST(CallTest, RecreatingAudioStreamWithSameSsrcReusesRtpState) { |
| 273 | constexpr uint32_t kSSRC = 12345; |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 274 | CallHelper call; |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 275 | |
| 276 | auto create_stream_and_get_rtp_state = [&](uint32_t ssrc) { |
Fredrik Solenberg | 3d2ed19 | 2018-12-18 09:18:33 +0100 | [diff] [blame] | 277 | MockTransport send_transport; |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 278 | AudioSendStream::Config config(&send_transport); |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 279 | config.rtp.ssrc = ssrc; |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 280 | AudioSendStream* stream = call->CreateAudioSendStream(config); |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 281 | const RtpState rtp_state = |
| 282 | static_cast<internal::AudioSendStream*>(stream)->GetRtpState(); |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 283 | call->DestroyAudioSendStream(stream); |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 284 | return rtp_state; |
| 285 | }; |
| 286 | |
| 287 | const RtpState rtp_state1 = create_stream_and_get_rtp_state(kSSRC); |
| 288 | const RtpState rtp_state2 = create_stream_and_get_rtp_state(kSSRC); |
| 289 | |
| 290 | EXPECT_EQ(rtp_state1.sequence_number, rtp_state2.sequence_number); |
| 291 | EXPECT_EQ(rtp_state1.start_timestamp, rtp_state2.start_timestamp); |
| 292 | EXPECT_EQ(rtp_state1.timestamp, rtp_state2.timestamp); |
| 293 | EXPECT_EQ(rtp_state1.capture_time_ms, rtp_state2.capture_time_ms); |
| 294 | EXPECT_EQ(rtp_state1.last_timestamp_time_ms, |
| 295 | rtp_state2.last_timestamp_time_ms); |
| 296 | EXPECT_EQ(rtp_state1.media_has_been_sent, rtp_state2.media_has_been_sent); |
| 297 | } |
Fredrik Solenberg | 8f5787a | 2018-01-11 13:52:30 +0100 | [diff] [blame] | 298 | |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 299 | } // namespace webrtc |