mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [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/rtp_video_sender.h" |
| 12 | |
Sebastian Jansson | 3d4d94a | 2020-01-14 14:25:41 +0100 | [diff] [blame] | 13 | #include <atomic> |
kwiberg | 27f982b | 2016-03-01 11:52:33 -0800 | [diff] [blame] | 14 | #include <memory> |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 15 | #include <string> |
Sebastian Jansson | 3d4d94a | 2020-01-14 14:25:41 +0100 | [diff] [blame] | 16 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 17 | #include "call/rtp_transport_controller_send.h" |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 18 | #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
| 19 | #include "modules/rtp_rtcp/source/byte_io.h" |
| 20 | #include "modules/rtp_rtcp/source/rtcp_packet/nack.h" |
| 21 | #include "modules/rtp_rtcp/source/rtp_packet.h" |
Stefan Holmer | 64be7fa | 2018-10-04 15:21:55 +0200 | [diff] [blame] | 22 | #include "modules/video_coding/fec_controller_default.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 23 | #include "modules/video_coding/include/video_codec_interface.h" |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 24 | #include "rtc_base/event.h" |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 25 | #include "rtc_base/rate_limiter.h" |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 26 | #include "test/field_trial.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 27 | #include "test/gmock.h" |
| 28 | #include "test/gtest.h" |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 29 | #include "test/mock_transport.h" |
Sebastian Jansson | 3d4d94a | 2020-01-14 14:25:41 +0100 | [diff] [blame] | 30 | #include "test/scenario/scenario.h" |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 31 | #include "test/time_controller/simulated_time_controller.h" |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 32 | #include "video/call_stats.h" |
| 33 | #include "video/send_delay_stats.h" |
| 34 | #include "video/send_statistics_proxy.h" |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 35 | |
| 36 | using ::testing::_; |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 37 | using ::testing::Invoke; |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 38 | using ::testing::NiceMock; |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 39 | using ::testing::SaveArg; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 40 | using ::testing::Unused; |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 41 | |
| 42 | namespace webrtc { |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 43 | namespace { |
| 44 | const int8_t kPayloadType = 96; |
| 45 | const uint32_t kSsrc1 = 12345; |
| 46 | const uint32_t kSsrc2 = 23456; |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 47 | const uint32_t kRtxSsrc1 = 34567; |
| 48 | const uint32_t kRtxSsrc2 = 45678; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 49 | const int16_t kInitialPictureId1 = 222; |
| 50 | const int16_t kInitialPictureId2 = 44; |
Niels Möller | bb894ff | 2018-03-15 12:28:53 +0100 | [diff] [blame] | 51 | const int16_t kInitialTl0PicIdx1 = 99; |
| 52 | const int16_t kInitialTl0PicIdx2 = 199; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 53 | const int64_t kRetransmitWindowSizeMs = 500; |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 54 | const int kTransportsSequenceExtensionId = 7; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 55 | |
| 56 | class MockRtcpIntraFrameObserver : public RtcpIntraFrameObserver { |
| 57 | public: |
| 58 | MOCK_METHOD1(OnReceivedIntraFrameRequest, void(uint32_t)); |
| 59 | }; |
| 60 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 61 | RtpSenderObservers CreateObservers( |
| 62 | RtcpRttStats* rtcp_rtt_stats, |
| 63 | RtcpIntraFrameObserver* intra_frame_callback, |
| 64 | RtcpStatisticsCallback* rtcp_stats, |
Henrik Boström | 87e3f9d | 2019-05-27 10:44:24 +0200 | [diff] [blame] | 65 | ReportBlockDataObserver* report_block_data_observer, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 66 | StreamDataCountersCallback* rtp_stats, |
| 67 | BitrateStatisticsObserver* bitrate_observer, |
| 68 | FrameCountObserver* frame_count_observer, |
| 69 | RtcpPacketTypeCounterObserver* rtcp_type_observer, |
| 70 | SendSideDelayObserver* send_delay_observer, |
Stefan Holmer | 64be7fa | 2018-10-04 15:21:55 +0200 | [diff] [blame] | 71 | SendPacketObserver* send_packet_observer) { |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 72 | RtpSenderObservers observers; |
| 73 | observers.rtcp_rtt_stats = rtcp_rtt_stats; |
| 74 | observers.intra_frame_callback = intra_frame_callback; |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 75 | observers.rtcp_loss_notification_observer = nullptr; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 76 | observers.rtcp_stats = rtcp_stats; |
Henrik Boström | 87e3f9d | 2019-05-27 10:44:24 +0200 | [diff] [blame] | 77 | observers.report_block_data_observer = report_block_data_observer; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 78 | observers.rtp_stats = rtp_stats; |
| 79 | observers.bitrate_observer = bitrate_observer; |
| 80 | observers.frame_count_observer = frame_count_observer; |
| 81 | observers.rtcp_type_observer = rtcp_type_observer; |
| 82 | observers.send_delay_observer = send_delay_observer; |
| 83 | observers.send_packet_observer = send_packet_observer; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 84 | return observers; |
| 85 | } |
| 86 | |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 87 | BitrateConstraints GetBitrateConfig() { |
| 88 | BitrateConstraints bitrate_config; |
| 89 | bitrate_config.min_bitrate_bps = 30000; |
| 90 | bitrate_config.start_bitrate_bps = 300000; |
| 91 | bitrate_config.max_bitrate_bps = 3000000; |
| 92 | return bitrate_config; |
| 93 | } |
| 94 | |
| 95 | VideoSendStream::Config CreateVideoSendStreamConfig( |
| 96 | Transport* transport, |
| 97 | const std::vector<uint32_t>& ssrcs, |
| 98 | const std::vector<uint32_t>& rtx_ssrcs, |
| 99 | int payload_type) { |
| 100 | VideoSendStream::Config config(transport); |
| 101 | config.rtp.ssrcs = ssrcs; |
| 102 | config.rtp.rtx.ssrcs = rtx_ssrcs; |
| 103 | config.rtp.payload_type = payload_type; |
| 104 | config.rtp.rtx.payload_type = payload_type + 1; |
| 105 | config.rtp.nack.rtp_history_ms = 1000; |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 106 | config.rtp.extensions.emplace_back(RtpExtension::kTransportSequenceNumberUri, |
| 107 | kTransportsSequenceExtensionId); |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 108 | return config; |
| 109 | } |
| 110 | |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 111 | class RtpVideoSenderTestFixture { |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 112 | public: |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 113 | RtpVideoSenderTestFixture( |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 114 | const std::vector<uint32_t>& ssrcs, |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 115 | const std::vector<uint32_t>& rtx_ssrcs, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 116 | int payload_type, |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 117 | const std::map<uint32_t, RtpPayloadState>& suspended_payload_states, |
| 118 | FrameCountObserver* frame_count_observer) |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 119 | : time_controller_(Timestamp::ms(1000000)), |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 120 | config_(CreateVideoSendStreamConfig(&transport_, |
| 121 | ssrcs, |
| 122 | rtx_ssrcs, |
| 123 | payload_type)), |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 124 | send_delay_stats_(time_controller_.GetClock()), |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 125 | bitrate_config_(GetBitrateConfig()), |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 126 | transport_controller_(time_controller_.GetClock(), |
Sebastian Jansson | ed50e6c | 2019-03-01 14:45:21 +0100 | [diff] [blame] | 127 | &event_log_, |
| 128 | nullptr, |
Ying Wang | 0810a7c | 2019-04-10 13:48:24 +0200 | [diff] [blame] | 129 | nullptr, |
Sebastian Jansson | ed50e6c | 2019-03-01 14:45:21 +0100 | [diff] [blame] | 130 | bitrate_config_, |
| 131 | ProcessThread::Create("PacerThread"), |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 132 | time_controller_.GetTaskQueueFactory(), |
Erik Språng | 662678d | 2019-11-15 17:18:52 +0100 | [diff] [blame] | 133 | &field_trials_), |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 134 | process_thread_(ProcessThread::Create("test_thread")), |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 135 | call_stats_(time_controller_.GetClock(), process_thread_.get()), |
| 136 | stats_proxy_(time_controller_.GetClock(), |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 137 | config_, |
| 138 | VideoEncoderConfig::ContentType::kRealtimeVideo), |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 139 | retransmission_rate_limiter_(time_controller_.GetClock(), |
| 140 | kRetransmitWindowSizeMs) { |
Mirko Bonadei | f18f920 | 2019-12-10 13:24:56 +0000 | [diff] [blame] | 141 | std::map<uint32_t, RtpState> suspended_ssrcs; |
| 142 | router_ = std::make_unique<RtpVideoSender>( |
| 143 | time_controller_.GetClock(), suspended_ssrcs, suspended_payload_states, |
| 144 | config_.rtp, config_.rtcp_report_interval_ms, &transport_, |
| 145 | CreateObservers(&call_stats_, &encoder_feedback_, &stats_proxy_, |
| 146 | &stats_proxy_, &stats_proxy_, &stats_proxy_, |
| 147 | frame_count_observer, &stats_proxy_, &stats_proxy_, |
| 148 | &send_delay_stats_), |
| 149 | &transport_controller_, &event_log_, &retransmission_rate_limiter_, |
| 150 | std::make_unique<FecControllerDefault>(time_controller_.GetClock()), |
| 151 | nullptr, CryptoOptions{}); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 152 | } |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 153 | RtpVideoSenderTestFixture( |
| 154 | const std::vector<uint32_t>& ssrcs, |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 155 | const std::vector<uint32_t>& rtx_ssrcs, |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 156 | int payload_type, |
| 157 | const std::map<uint32_t, RtpPayloadState>& suspended_payload_states) |
| 158 | : RtpVideoSenderTestFixture(ssrcs, |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 159 | rtx_ssrcs, |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 160 | payload_type, |
| 161 | suspended_payload_states, |
| 162 | /*frame_count_observer=*/nullptr) {} |
Mirko Bonadei | f18f920 | 2019-12-10 13:24:56 +0000 | [diff] [blame] | 163 | |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 164 | RtpVideoSender* router() { return router_.get(); } |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 165 | MockTransport& transport() { return transport_; } |
Markus Handell | 486cc55 | 2019-12-03 14:37:28 +0100 | [diff] [blame] | 166 | void AdvanceTime(TimeDelta delta) { time_controller_.AdvanceTime(delta); } |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 167 | |
| 168 | private: |
| 169 | NiceMock<MockTransport> transport_; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 170 | NiceMock<MockRtcpIntraFrameObserver> encoder_feedback_; |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 171 | GlobalSimulatedTimeController time_controller_; |
Danil Chapovalov | 83bbe91 | 2019-08-07 12:24:53 +0200 | [diff] [blame] | 172 | RtcEventLogNull event_log_; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 173 | VideoSendStream::Config config_; |
| 174 | SendDelayStats send_delay_stats_; |
| 175 | BitrateConstraints bitrate_config_; |
Erik Språng | 662678d | 2019-11-15 17:18:52 +0100 | [diff] [blame] | 176 | const FieldTrialBasedConfig field_trials_; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 177 | RtpTransportControllerSend transport_controller_; |
| 178 | std::unique_ptr<ProcessThread> process_thread_; |
| 179 | CallStats call_stats_; |
| 180 | SendStatisticsProxy stats_proxy_; |
| 181 | RateLimiter retransmission_rate_limiter_; |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 182 | std::unique_ptr<RtpVideoSender> router_; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 183 | }; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 184 | } // namespace |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 185 | |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 186 | TEST(RtpVideoSenderTest, SendOnOneModule) { |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 187 | constexpr uint8_t kPayload = 'a'; |
kjellander | 02b3d27 | 2016-04-20 05:05:54 -0700 | [diff] [blame] | 188 | EncodedImage encoded_image; |
Niels Möller | 2377588 | 2018-08-16 10:24:12 +0200 | [diff] [blame] | 189 | encoded_image.SetTimestamp(1); |
kjellander | 02b3d27 | 2016-04-20 05:05:54 -0700 | [diff] [blame] | 190 | encoded_image.capture_time_ms_ = 2; |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame] | 191 | encoded_image._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | 4d504c7 | 2019-06-18 15:56:56 +0200 | [diff] [blame] | 192 | encoded_image.SetEncodedData(EncodedImageBuffer::Create(&kPayload, 1)); |
kjellander | 02b3d27 | 2016-04-20 05:05:54 -0700 | [diff] [blame] | 193 | |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 194 | RtpVideoSenderTestFixture test({kSsrc1}, {kRtxSsrc1}, kPayloadType, {}); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 195 | EXPECT_NE( |
| 196 | EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 197 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 198 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 199 | test.router()->SetActive(true); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 200 | EXPECT_EQ( |
| 201 | EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 202 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 203 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 204 | test.router()->SetActive(false); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 205 | EXPECT_NE( |
| 206 | EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 207 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 208 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 209 | test.router()->SetActive(true); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 210 | EXPECT_EQ( |
| 211 | EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 212 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 213 | } |
| 214 | |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 215 | TEST(RtpVideoSenderTest, SendSimulcastSetActive) { |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 216 | constexpr uint8_t kPayload = 'a'; |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 217 | EncodedImage encoded_image_1; |
| 218 | encoded_image_1.SetTimestamp(1); |
| 219 | encoded_image_1.capture_time_ms_ = 2; |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame] | 220 | encoded_image_1._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | 4d504c7 | 2019-06-18 15:56:56 +0200 | [diff] [blame] | 221 | encoded_image_1.SetEncodedData(EncodedImageBuffer::Create(&kPayload, 1)); |
kjellander | 02b3d27 | 2016-04-20 05:05:54 -0700 | [diff] [blame] | 222 | |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 223 | RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, |
| 224 | kPayloadType, {}); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 225 | |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 226 | CodecSpecificInfo codec_info; |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 227 | codec_info.codecType = kVideoCodecVP8; |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 228 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 229 | test.router()->SetActive(true); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 230 | EXPECT_EQ(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 231 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 232 | ->OnEncodedImage(encoded_image_1, &codec_info, nullptr) |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 233 | .error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 234 | |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 235 | EncodedImage encoded_image_2(encoded_image_1); |
| 236 | encoded_image_2.SetSpatialIndex(1); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 237 | EXPECT_EQ(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 238 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 239 | ->OnEncodedImage(encoded_image_2, &codec_info, nullptr) |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 240 | .error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 241 | |
mflodman@webrtc.org | 50e2816 | 2015-02-23 07:45:11 +0000 | [diff] [blame] | 242 | // Inactive. |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 243 | test.router()->SetActive(false); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 244 | EXPECT_NE(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 245 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 246 | ->OnEncodedImage(encoded_image_1, &codec_info, nullptr) |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 247 | .error); |
| 248 | EXPECT_NE(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 249 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 250 | ->OnEncodedImage(encoded_image_2, &codec_info, nullptr) |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 251 | .error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 252 | } |
| 253 | |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 254 | // Tests how setting individual rtp modules to active affects the overall |
| 255 | // behavior of the payload router. First sets one module to active and checks |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 256 | // that outgoing data can be sent on this module, and checks that no data can |
| 257 | // be sent if both modules are inactive. |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 258 | TEST(RtpVideoSenderTest, SendSimulcastSetActiveModules) { |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 259 | constexpr uint8_t kPayload = 'a'; |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 260 | EncodedImage encoded_image_1; |
| 261 | encoded_image_1.SetTimestamp(1); |
| 262 | encoded_image_1.capture_time_ms_ = 2; |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame] | 263 | encoded_image_1._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | 4d504c7 | 2019-06-18 15:56:56 +0200 | [diff] [blame] | 264 | encoded_image_1.SetEncodedData(EncodedImageBuffer::Create(&kPayload, 1)); |
Niels Möller | 77536a2 | 2019-01-15 08:50:01 +0100 | [diff] [blame] | 265 | |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 266 | EncodedImage encoded_image_2(encoded_image_1); |
| 267 | encoded_image_2.SetSpatialIndex(1); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 268 | |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 269 | RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, |
| 270 | kPayloadType, {}); |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 271 | CodecSpecificInfo codec_info; |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 272 | codec_info.codecType = kVideoCodecVP8; |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 273 | |
| 274 | // Only setting one stream to active will still set the payload router to |
| 275 | // active and allow sending data on the active stream. |
| 276 | std::vector<bool> active_modules({true, false}); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 277 | test.router()->SetActiveModules(active_modules); |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 278 | EXPECT_EQ(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 279 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 280 | ->OnEncodedImage(encoded_image_1, &codec_info, nullptr) |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 281 | .error); |
| 282 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 283 | // Setting both streams to inactive will turn the payload router to |
| 284 | // inactive. |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 285 | active_modules = {false, false}; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 286 | test.router()->SetActiveModules(active_modules); |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 287 | // An incoming encoded image will not ask the module to send outgoing data |
| 288 | // because the payload router is inactive. |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 289 | EXPECT_NE(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 290 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 291 | ->OnEncodedImage(encoded_image_1, &codec_info, nullptr) |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 292 | .error); |
| 293 | EXPECT_NE(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 294 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 295 | ->OnEncodedImage(encoded_image_1, &codec_info, nullptr) |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 296 | .error); |
| 297 | } |
| 298 | |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 299 | TEST(RtpVideoSenderTest, CreateWithNoPreviousStates) { |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 300 | RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, |
| 301 | kPayloadType, {}); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 302 | test.router()->SetActive(true); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 303 | |
| 304 | std::map<uint32_t, RtpPayloadState> initial_states = |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 305 | test.router()->GetRtpPayloadStates(); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 306 | EXPECT_EQ(2u, initial_states.size()); |
| 307 | EXPECT_NE(initial_states.find(kSsrc1), initial_states.end()); |
| 308 | EXPECT_NE(initial_states.find(kSsrc2), initial_states.end()); |
| 309 | } |
| 310 | |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 311 | TEST(RtpVideoSenderTest, CreateWithPreviousStates) { |
philipel | 25d31ec | 2018-08-08 16:33:01 +0200 | [diff] [blame] | 312 | const int64_t kState1SharedFrameId = 123; |
| 313 | const int64_t kState2SharedFrameId = 234; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 314 | RtpPayloadState state1; |
| 315 | state1.picture_id = kInitialPictureId1; |
Niels Möller | bb894ff | 2018-03-15 12:28:53 +0100 | [diff] [blame] | 316 | state1.tl0_pic_idx = kInitialTl0PicIdx1; |
philipel | 25d31ec | 2018-08-08 16:33:01 +0200 | [diff] [blame] | 317 | state1.shared_frame_id = kState1SharedFrameId; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 318 | RtpPayloadState state2; |
| 319 | state2.picture_id = kInitialPictureId2; |
Niels Möller | bb894ff | 2018-03-15 12:28:53 +0100 | [diff] [blame] | 320 | state2.tl0_pic_idx = kInitialTl0PicIdx2; |
philipel | 25d31ec | 2018-08-08 16:33:01 +0200 | [diff] [blame] | 321 | state2.shared_frame_id = kState2SharedFrameId; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 322 | std::map<uint32_t, RtpPayloadState> states = {{kSsrc1, state1}, |
| 323 | {kSsrc2, state2}}; |
| 324 | |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 325 | RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, |
| 326 | kPayloadType, states); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 327 | test.router()->SetActive(true); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 328 | |
| 329 | std::map<uint32_t, RtpPayloadState> initial_states = |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 330 | test.router()->GetRtpPayloadStates(); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 331 | EXPECT_EQ(2u, initial_states.size()); |
| 332 | EXPECT_EQ(kInitialPictureId1, initial_states[kSsrc1].picture_id); |
Niels Möller | bb894ff | 2018-03-15 12:28:53 +0100 | [diff] [blame] | 333 | EXPECT_EQ(kInitialTl0PicIdx1, initial_states[kSsrc1].tl0_pic_idx); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 334 | EXPECT_EQ(kInitialPictureId2, initial_states[kSsrc2].picture_id); |
Niels Möller | bb894ff | 2018-03-15 12:28:53 +0100 | [diff] [blame] | 335 | EXPECT_EQ(kInitialTl0PicIdx2, initial_states[kSsrc2].tl0_pic_idx); |
philipel | 25d31ec | 2018-08-08 16:33:01 +0200 | [diff] [blame] | 336 | EXPECT_EQ(kState2SharedFrameId, initial_states[kSsrc1].shared_frame_id); |
| 337 | EXPECT_EQ(kState2SharedFrameId, initial_states[kSsrc2].shared_frame_id); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 338 | } |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 339 | |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 340 | TEST(RtpVideoSenderTest, FrameCountCallbacks) { |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 341 | class MockFrameCountObserver : public FrameCountObserver { |
| 342 | public: |
| 343 | MOCK_METHOD2(FrameCountUpdated, |
| 344 | void(const FrameCounts& frame_counts, uint32_t ssrc)); |
| 345 | } callback; |
| 346 | |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 347 | RtpVideoSenderTestFixture test({kSsrc1}, {kRtxSsrc1}, kPayloadType, {}, |
| 348 | &callback); |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 349 | |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 350 | constexpr uint8_t kPayload = 'a'; |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 351 | EncodedImage encoded_image; |
| 352 | encoded_image.SetTimestamp(1); |
| 353 | encoded_image.capture_time_ms_ = 2; |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame] | 354 | encoded_image._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | 4d504c7 | 2019-06-18 15:56:56 +0200 | [diff] [blame] | 355 | encoded_image.SetEncodedData(EncodedImageBuffer::Create(&kPayload, 1)); |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 356 | |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame] | 357 | encoded_image._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 358 | |
| 359 | // No callbacks when not active. |
| 360 | EXPECT_CALL(callback, FrameCountUpdated).Times(0); |
| 361 | EXPECT_NE( |
| 362 | EncodedImageCallback::Result::OK, |
| 363 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
Mirko Bonadei | 6a489f2 | 2019-04-09 15:11:12 +0200 | [diff] [blame] | 364 | ::testing::Mock::VerifyAndClearExpectations(&callback); |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 365 | |
| 366 | test.router()->SetActive(true); |
| 367 | |
| 368 | FrameCounts frame_counts; |
| 369 | EXPECT_CALL(callback, FrameCountUpdated(_, kSsrc1)) |
| 370 | .WillOnce(SaveArg<0>(&frame_counts)); |
| 371 | EXPECT_EQ( |
| 372 | EncodedImageCallback::Result::OK, |
| 373 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
| 374 | |
| 375 | EXPECT_EQ(1, frame_counts.key_frames); |
| 376 | EXPECT_EQ(0, frame_counts.delta_frames); |
| 377 | |
Mirko Bonadei | 6a489f2 | 2019-04-09 15:11:12 +0200 | [diff] [blame] | 378 | ::testing::Mock::VerifyAndClearExpectations(&callback); |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 379 | |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame] | 380 | encoded_image._frameType = VideoFrameType::kVideoFrameDelta; |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 381 | EXPECT_CALL(callback, FrameCountUpdated(_, kSsrc1)) |
| 382 | .WillOnce(SaveArg<0>(&frame_counts)); |
| 383 | EXPECT_EQ( |
| 384 | EncodedImageCallback::Result::OK, |
| 385 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
| 386 | |
| 387 | EXPECT_EQ(1, frame_counts.key_frames); |
| 388 | EXPECT_EQ(1, frame_counts.delta_frames); |
| 389 | } |
| 390 | |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 391 | // Integration test verifying that ack of packet via TransportFeedback means |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 392 | // that the packet is removed from RtpPacketHistory and won't be retransmitted |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 393 | // again. |
| 394 | TEST(RtpVideoSenderTest, DoesNotRetrasmitAckedPackets) { |
| 395 | const int64_t kTimeoutMs = 500; |
| 396 | |
| 397 | RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, |
| 398 | kPayloadType, {}); |
| 399 | test.router()->SetActive(true); |
| 400 | |
| 401 | constexpr uint8_t kPayload = 'a'; |
| 402 | EncodedImage encoded_image; |
| 403 | encoded_image.SetTimestamp(1); |
| 404 | encoded_image.capture_time_ms_ = 2; |
| 405 | encoded_image._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | 4d504c7 | 2019-06-18 15:56:56 +0200 | [diff] [blame] | 406 | encoded_image.SetEncodedData(EncodedImageBuffer::Create(&kPayload, 1)); |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 407 | |
| 408 | // Send two tiny images, mapping to two RTP packets. Capture sequence numbers. |
| 409 | rtc::Event event; |
| 410 | std::vector<uint16_t> rtp_sequence_numbers; |
| 411 | std::vector<uint16_t> transport_sequence_numbers; |
| 412 | EXPECT_CALL(test.transport(), SendRtp) |
| 413 | .Times(2) |
| 414 | .WillRepeatedly( |
| 415 | [&event, &rtp_sequence_numbers, &transport_sequence_numbers]( |
| 416 | const uint8_t* packet, size_t length, |
| 417 | const PacketOptions& options) { |
| 418 | RtpPacket rtp_packet; |
| 419 | EXPECT_TRUE(rtp_packet.Parse(packet, length)); |
| 420 | rtp_sequence_numbers.push_back(rtp_packet.SequenceNumber()); |
| 421 | transport_sequence_numbers.push_back(options.packet_id); |
| 422 | if (transport_sequence_numbers.size() == 2) { |
| 423 | event.Set(); |
| 424 | } |
| 425 | return true; |
| 426 | }); |
| 427 | EXPECT_EQ( |
| 428 | EncodedImageCallback::Result::OK, |
| 429 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
| 430 | encoded_image.SetTimestamp(2); |
| 431 | encoded_image.capture_time_ms_ = 3; |
| 432 | EXPECT_EQ( |
| 433 | EncodedImageCallback::Result::OK, |
| 434 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
Erik Språng | bd7046c | 2019-05-07 14:54:29 -0700 | [diff] [blame] | 435 | |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 436 | test.AdvanceTime(TimeDelta::ms(33)); |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 437 | |
| 438 | ASSERT_TRUE(event.Wait(kTimeoutMs)); |
| 439 | |
| 440 | // Construct a NACK message for requesting retransmission of both packet. |
| 441 | rtcp::Nack nack; |
| 442 | nack.SetMediaSsrc(kSsrc1); |
| 443 | nack.SetPacketIds(rtp_sequence_numbers); |
| 444 | rtc::Buffer nack_buffer = nack.Build(); |
| 445 | |
| 446 | std::vector<uint16_t> retransmitted_rtp_sequence_numbers; |
| 447 | EXPECT_CALL(test.transport(), SendRtp) |
| 448 | .Times(2) |
| 449 | .WillRepeatedly([&event, &retransmitted_rtp_sequence_numbers]( |
| 450 | const uint8_t* packet, size_t length, |
| 451 | const PacketOptions& options) { |
| 452 | RtpPacket rtp_packet; |
| 453 | EXPECT_TRUE(rtp_packet.Parse(packet, length)); |
| 454 | EXPECT_EQ(rtp_packet.Ssrc(), kRtxSsrc1); |
| 455 | // Capture the retransmitted sequence number from the RTX header. |
| 456 | rtc::ArrayView<const uint8_t> payload = rtp_packet.payload(); |
| 457 | retransmitted_rtp_sequence_numbers.push_back( |
| 458 | ByteReader<uint16_t>::ReadBigEndian(payload.data())); |
| 459 | if (retransmitted_rtp_sequence_numbers.size() == 2) { |
| 460 | event.Set(); |
| 461 | } |
| 462 | return true; |
| 463 | }); |
| 464 | test.router()->DeliverRtcp(nack_buffer.data(), nack_buffer.size()); |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 465 | test.AdvanceTime(TimeDelta::ms(33)); |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 466 | ASSERT_TRUE(event.Wait(kTimeoutMs)); |
| 467 | |
| 468 | // Verify that both packets were retransmitted. |
| 469 | EXPECT_EQ(retransmitted_rtp_sequence_numbers, rtp_sequence_numbers); |
| 470 | |
| 471 | // Simulate transport feedback indicating fist packet received, next packet |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 472 | // lost (not other way around as that would trigger early retransmit). |
Sebastian Jansson | f298855 | 2019-10-29 17:18:51 +0100 | [diff] [blame] | 473 | StreamFeedbackObserver::StreamPacketInfo lost_packet_feedback; |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 474 | lost_packet_feedback.rtp_sequence_number = rtp_sequence_numbers[0]; |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 475 | lost_packet_feedback.ssrc = kSsrc1; |
Sebastian Jansson | f298855 | 2019-10-29 17:18:51 +0100 | [diff] [blame] | 476 | lost_packet_feedback.received = false; |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 477 | |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 478 | StreamFeedbackObserver::StreamPacketInfo received_packet_feedback; |
| 479 | received_packet_feedback.rtp_sequence_number = rtp_sequence_numbers[1]; |
| 480 | received_packet_feedback.ssrc = kSsrc1; |
| 481 | received_packet_feedback.received = true; |
| 482 | |
Sebastian Jansson | f298855 | 2019-10-29 17:18:51 +0100 | [diff] [blame] | 483 | test.router()->OnPacketFeedbackVector( |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 484 | {lost_packet_feedback, received_packet_feedback}); |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 485 | |
| 486 | // Advance time to make sure retransmission would be allowed and try again. |
| 487 | // This time the retransmission should not happen for the first packet since |
| 488 | // the history has been notified of the ack and removed the packet. The |
| 489 | // second packet, included in the feedback but not marked as received, should |
| 490 | // still be retransmitted. |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 491 | test.AdvanceTime(TimeDelta::ms(33)); |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 492 | EXPECT_CALL(test.transport(), SendRtp) |
| 493 | .WillOnce([&event, &lost_packet_feedback](const uint8_t* packet, |
| 494 | size_t length, |
| 495 | const PacketOptions& options) { |
| 496 | RtpPacket rtp_packet; |
| 497 | EXPECT_TRUE(rtp_packet.Parse(packet, length)); |
| 498 | EXPECT_EQ(rtp_packet.Ssrc(), kRtxSsrc1); |
| 499 | // Capture the retransmitted sequence number from the RTX header. |
| 500 | rtc::ArrayView<const uint8_t> payload = rtp_packet.payload(); |
| 501 | EXPECT_EQ(lost_packet_feedback.rtp_sequence_number, |
| 502 | ByteReader<uint16_t>::ReadBigEndian(payload.data())); |
| 503 | event.Set(); |
| 504 | return true; |
| 505 | }); |
| 506 | test.router()->DeliverRtcp(nack_buffer.data(), nack_buffer.size()); |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 507 | test.AdvanceTime(TimeDelta::ms(33)); |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 508 | ASSERT_TRUE(event.Wait(kTimeoutMs)); |
| 509 | } |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 510 | |
Sebastian Jansson | 3d4d94a | 2020-01-14 14:25:41 +0100 | [diff] [blame] | 511 | // This tests that we utilize transport wide feedback to retransmit lost |
| 512 | // packets. This is tested by dropping all ordirary packets from a "lossy" |
| 513 | // stream send along with an secondary untouched stream. The transport wide |
| 514 | // feedback packets from the secondary stream allows the sending side to |
| 515 | // detect and retreansmit the lost packets from the lossy stream. |
| 516 | TEST(RtpVideoSenderTest, RetransmitsOnTransportWideLossInfo) { |
| 517 | int rtx_packets; |
| 518 | test::Scenario s(test_info_); |
| 519 | test::CallClientConfig call_conf; |
| 520 | // Keeping the bitrate fixed to avoid RTX due to probing. |
| 521 | call_conf.transport.rates.max_rate = DataRate::kbps(300); |
| 522 | call_conf.transport.rates.start_rate = DataRate::kbps(300); |
| 523 | test::NetworkSimulationConfig net_conf; |
| 524 | net_conf.bandwidth = DataRate::kbps(300); |
| 525 | auto send_node = s.CreateSimulationNode(net_conf); |
| 526 | auto* route = s.CreateRoutes(s.CreateClient("send", call_conf), {send_node}, |
| 527 | s.CreateClient("return", call_conf), |
| 528 | {s.CreateSimulationNode(net_conf)}); |
| 529 | |
| 530 | test::VideoStreamConfig lossy_config; |
| 531 | lossy_config.source.framerate = 5; |
| 532 | auto* lossy = s.CreateVideoStream(route->forward(), lossy_config); |
| 533 | // The secondary stream acts a driver for transport feedback messages, |
| 534 | // ensuring that lost packets on the lossy stream are retransmitted. |
| 535 | s.CreateVideoStream(route->forward(), test::VideoStreamConfig()); |
| 536 | |
| 537 | send_node->router()->SetFilter([&](const EmulatedIpPacket& packet) { |
| 538 | RtpPacket rtp; |
| 539 | if (rtp.Parse(packet.data)) { |
| 540 | // Drops all regular packets for the lossy stream and counts all RTX |
| 541 | // packets. Since no packets are let trough, NACKs can't be triggered |
| 542 | // by the receiving side. |
| 543 | if (lossy->send()->UsingSsrc(rtp.Ssrc())) { |
| 544 | return false; |
| 545 | } else if (lossy->send()->UsingRtxSsrc(rtp.Ssrc())) { |
| 546 | ++rtx_packets; |
| 547 | } |
| 548 | } |
| 549 | return true; |
| 550 | }); |
| 551 | |
| 552 | // Run for a short duration and reset counters to avoid counting RTX packets |
| 553 | // from initial probing. |
| 554 | s.RunFor(TimeDelta::seconds(1)); |
| 555 | rtx_packets = 0; |
| 556 | int decoded_baseline = lossy->receive()->GetStats().frames_decoded; |
| 557 | s.RunFor(TimeDelta::seconds(1)); |
| 558 | // We expect both that RTX packets were sent and that an appropriate number of |
| 559 | // frames were received. This is somewhat redundant but reduces the risk of |
| 560 | // false positives in future regressions (e.g. RTX is send due to probing). |
| 561 | EXPECT_GE(rtx_packets, 1); |
| 562 | int frames_decoded = |
| 563 | lossy->receive()->GetStats().frames_decoded - decoded_baseline; |
| 564 | EXPECT_EQ(frames_decoded, 5); |
| 565 | } |
| 566 | |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 567 | // Integration test verifying that retransmissions are sent for packets which |
| 568 | // can be detected as lost early, using transport wide feedback. |
| 569 | TEST(RtpVideoSenderTest, EarlyRetransmits) { |
| 570 | const int64_t kTimeoutMs = 500; |
| 571 | |
| 572 | RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, |
| 573 | kPayloadType, {}); |
| 574 | test.router()->SetActive(true); |
| 575 | |
Niels Möller | b9bfe65 | 2019-10-03 08:43:53 +0200 | [diff] [blame] | 576 | const uint8_t kPayload[1] = {'a'}; |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 577 | EncodedImage encoded_image; |
| 578 | encoded_image.SetTimestamp(1); |
| 579 | encoded_image.capture_time_ms_ = 2; |
| 580 | encoded_image._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | b9bfe65 | 2019-10-03 08:43:53 +0200 | [diff] [blame] | 581 | encoded_image.SetEncodedData( |
| 582 | EncodedImageBuffer::Create(kPayload, sizeof(kPayload))); |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 583 | encoded_image.SetSpatialIndex(0); |
| 584 | |
| 585 | CodecSpecificInfo codec_specific; |
| 586 | codec_specific.codecType = VideoCodecType::kVideoCodecGeneric; |
| 587 | |
| 588 | // Send two tiny images, mapping to single RTP packets. Capture sequence |
| 589 | // numbers. |
| 590 | rtc::Event event; |
| 591 | uint16_t frame1_rtp_sequence_number = 0; |
| 592 | uint16_t frame1_transport_sequence_number = 0; |
| 593 | EXPECT_CALL(test.transport(), SendRtp) |
| 594 | .WillOnce([&event, &frame1_rtp_sequence_number, |
| 595 | &frame1_transport_sequence_number]( |
| 596 | const uint8_t* packet, size_t length, |
| 597 | const PacketOptions& options) { |
| 598 | RtpPacket rtp_packet; |
| 599 | EXPECT_TRUE(rtp_packet.Parse(packet, length)); |
| 600 | frame1_rtp_sequence_number = rtp_packet.SequenceNumber(); |
| 601 | frame1_transport_sequence_number = options.packet_id; |
| 602 | EXPECT_EQ(rtp_packet.Ssrc(), kSsrc1); |
| 603 | event.Set(); |
| 604 | return true; |
| 605 | }); |
| 606 | EXPECT_EQ(test.router() |
| 607 | ->OnEncodedImage(encoded_image, &codec_specific, nullptr) |
| 608 | .error, |
| 609 | EncodedImageCallback::Result::OK); |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 610 | |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 611 | test.AdvanceTime(TimeDelta::ms(33)); |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 612 | ASSERT_TRUE(event.Wait(kTimeoutMs)); |
| 613 | |
| 614 | uint16_t frame2_rtp_sequence_number = 0; |
| 615 | uint16_t frame2_transport_sequence_number = 0; |
| 616 | encoded_image.SetSpatialIndex(1); |
| 617 | EXPECT_CALL(test.transport(), SendRtp) |
| 618 | .WillOnce([&event, &frame2_rtp_sequence_number, |
| 619 | &frame2_transport_sequence_number]( |
| 620 | const uint8_t* packet, size_t length, |
| 621 | const PacketOptions& options) { |
| 622 | RtpPacket rtp_packet; |
| 623 | EXPECT_TRUE(rtp_packet.Parse(packet, length)); |
| 624 | frame2_rtp_sequence_number = rtp_packet.SequenceNumber(); |
| 625 | frame2_transport_sequence_number = options.packet_id; |
| 626 | EXPECT_EQ(rtp_packet.Ssrc(), kSsrc2); |
| 627 | event.Set(); |
| 628 | return true; |
| 629 | }); |
| 630 | EXPECT_EQ(test.router() |
| 631 | ->OnEncodedImage(encoded_image, &codec_specific, nullptr) |
| 632 | .error, |
| 633 | EncodedImageCallback::Result::OK); |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 634 | test.AdvanceTime(TimeDelta::ms(33)); |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 635 | ASSERT_TRUE(event.Wait(kTimeoutMs)); |
| 636 | |
| 637 | EXPECT_NE(frame1_transport_sequence_number, frame2_transport_sequence_number); |
| 638 | |
| 639 | // Inject a transport feedback where the packet for the first frame is lost, |
| 640 | // expect a retransmission for it. |
| 641 | EXPECT_CALL(test.transport(), SendRtp) |
| 642 | .WillOnce([&event, &frame1_rtp_sequence_number]( |
| 643 | const uint8_t* packet, size_t length, |
| 644 | const PacketOptions& options) { |
| 645 | RtpPacket rtp_packet; |
| 646 | EXPECT_TRUE(rtp_packet.Parse(packet, length)); |
Sebastian Jansson | f298855 | 2019-10-29 17:18:51 +0100 | [diff] [blame] | 647 | EXPECT_EQ(rtp_packet.Ssrc(), kRtxSsrc1); |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 648 | |
| 649 | // Retransmitted sequence number from the RTX header should match |
| 650 | // the lost packet. |
| 651 | rtc::ArrayView<const uint8_t> payload = rtp_packet.payload(); |
| 652 | EXPECT_EQ(ByteReader<uint16_t>::ReadBigEndian(payload.data()), |
| 653 | frame1_rtp_sequence_number); |
| 654 | event.Set(); |
| 655 | return true; |
| 656 | }); |
| 657 | |
Sebastian Jansson | f298855 | 2019-10-29 17:18:51 +0100 | [diff] [blame] | 658 | StreamFeedbackObserver::StreamPacketInfo first_packet_feedback; |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 659 | first_packet_feedback.rtp_sequence_number = frame1_rtp_sequence_number; |
| 660 | first_packet_feedback.ssrc = kSsrc1; |
Sebastian Jansson | f298855 | 2019-10-29 17:18:51 +0100 | [diff] [blame] | 661 | first_packet_feedback.received = false; |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 662 | |
Sebastian Jansson | f298855 | 2019-10-29 17:18:51 +0100 | [diff] [blame] | 663 | StreamFeedbackObserver::StreamPacketInfo second_packet_feedback; |
| 664 | second_packet_feedback.rtp_sequence_number = frame2_rtp_sequence_number; |
| 665 | second_packet_feedback.ssrc = kSsrc2; |
| 666 | second_packet_feedback.received = true; |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 667 | |
Sebastian Jansson | f298855 | 2019-10-29 17:18:51 +0100 | [diff] [blame] | 668 | test.router()->OnPacketFeedbackVector( |
| 669 | {first_packet_feedback, second_packet_feedback}); |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 670 | |
| 671 | // Wait for pacer to run and send the RTX packet. |
Erik Språng | 00cc836 | 2019-11-25 12:21:46 +0100 | [diff] [blame] | 672 | test.AdvanceTime(TimeDelta::ms(33)); |
Erik Språng | 845c6aa | 2019-05-29 13:02:24 +0200 | [diff] [blame] | 673 | ASSERT_TRUE(event.Wait(kTimeoutMs)); |
| 674 | } |
Sebastian Jansson | cf41eb1 | 2019-06-10 11:30:59 +0200 | [diff] [blame] | 675 | |
| 676 | TEST(RtpVideoSenderTest, CanSetZeroBitrateWithOverhead) { |
| 677 | test::ScopedFieldTrials trials("WebRTC-SendSideBwe-WithOverhead/Enabled/"); |
| 678 | RtpVideoSenderTestFixture test({kSsrc1}, {kRtxSsrc1}, kPayloadType, {}); |
Sebastian Jansson | 82ed2e8 | 2019-10-15 15:58:37 +0200 | [diff] [blame] | 679 | BitrateAllocationUpdate update; |
| 680 | update.target_bitrate = DataRate::Zero(); |
| 681 | update.packet_loss_ratio = 0; |
| 682 | update.round_trip_time = TimeDelta::Zero(); |
Sebastian Jansson | cf41eb1 | 2019-06-10 11:30:59 +0200 | [diff] [blame] | 683 | |
Sebastian Jansson | 82ed2e8 | 2019-10-15 15:58:37 +0200 | [diff] [blame] | 684 | test.router()->OnBitrateUpdated(update, /*framerate*/ 0); |
Sebastian Jansson | cf41eb1 | 2019-06-10 11:30:59 +0200 | [diff] [blame] | 685 | } |
| 686 | |
| 687 | TEST(RtpVideoSenderTest, CanSetZeroBitrateWithoutOverhead) { |
| 688 | RtpVideoSenderTestFixture test({kSsrc1}, {kRtxSsrc1}, kPayloadType, {}); |
| 689 | |
Sebastian Jansson | 82ed2e8 | 2019-10-15 15:58:37 +0200 | [diff] [blame] | 690 | BitrateAllocationUpdate update; |
| 691 | update.target_bitrate = DataRate::Zero(); |
| 692 | update.packet_loss_ratio = 0; |
| 693 | update.round_trip_time = TimeDelta::Zero(); |
| 694 | |
| 695 | test.router()->OnBitrateUpdated(update, /*framerate*/ 0); |
Sebastian Jansson | cf41eb1 | 2019-06-10 11:30:59 +0200 | [diff] [blame] | 696 | } |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 697 | } // namespace webrtc |