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 | |
kwiberg | 27f982b | 2016-03-01 11:52:33 -0800 | [diff] [blame] | 11 | #include <memory> |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 12 | #include <string> |
kwiberg | 27f982b | 2016-03-01 11:52:33 -0800 | [diff] [blame] | 13 | |
Steve Anton | 40d5533 | 2019-01-07 10:21:47 -0800 | [diff] [blame] | 14 | #include "absl/memory/memory.h" |
Sebastian Jansson | ed50e6c | 2019-03-01 14:45:21 +0100 | [diff] [blame] | 15 | #include "api/task_queue/global_task_queue_factory.h" |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 16 | #include "call/rtp_transport_controller_send.h" |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 17 | #include "call/rtp_video_sender.h" |
Stefan Holmer | 64be7fa | 2018-10-04 15:21:55 +0200 | [diff] [blame] | 18 | #include "modules/video_coding/fec_controller_default.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 19 | #include "modules/video_coding/include/video_codec_interface.h" |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 20 | #include "rtc_base/rate_limiter.h" |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 21 | #include "test/field_trial.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 22 | #include "test/gmock.h" |
| 23 | #include "test/gtest.h" |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 24 | #include "test/mock_transport.h" |
| 25 | #include "video/call_stats.h" |
| 26 | #include "video/send_delay_stats.h" |
| 27 | #include "video/send_statistics_proxy.h" |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 28 | |
| 29 | using ::testing::_; |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 30 | using ::testing::NiceMock; |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 31 | using ::testing::SaveArg; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 32 | using ::testing::Unused; |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 33 | |
| 34 | namespace webrtc { |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 35 | namespace { |
| 36 | const int8_t kPayloadType = 96; |
| 37 | const uint32_t kSsrc1 = 12345; |
| 38 | const uint32_t kSsrc2 = 23456; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 39 | const int16_t kInitialPictureId1 = 222; |
| 40 | const int16_t kInitialPictureId2 = 44; |
Niels Möller | bb894ff | 2018-03-15 12:28:53 +0100 | [diff] [blame] | 41 | const int16_t kInitialTl0PicIdx1 = 99; |
| 42 | const int16_t kInitialTl0PicIdx2 = 199; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 43 | const int64_t kRetransmitWindowSizeMs = 500; |
| 44 | |
| 45 | class MockRtcpIntraFrameObserver : public RtcpIntraFrameObserver { |
| 46 | public: |
| 47 | MOCK_METHOD1(OnReceivedIntraFrameRequest, void(uint32_t)); |
| 48 | }; |
| 49 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 50 | RtpSenderObservers CreateObservers( |
| 51 | RtcpRttStats* rtcp_rtt_stats, |
| 52 | RtcpIntraFrameObserver* intra_frame_callback, |
| 53 | RtcpStatisticsCallback* rtcp_stats, |
| 54 | StreamDataCountersCallback* rtp_stats, |
| 55 | BitrateStatisticsObserver* bitrate_observer, |
| 56 | FrameCountObserver* frame_count_observer, |
| 57 | RtcpPacketTypeCounterObserver* rtcp_type_observer, |
| 58 | SendSideDelayObserver* send_delay_observer, |
Stefan Holmer | 64be7fa | 2018-10-04 15:21:55 +0200 | [diff] [blame] | 59 | SendPacketObserver* send_packet_observer) { |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 60 | RtpSenderObservers observers; |
| 61 | observers.rtcp_rtt_stats = rtcp_rtt_stats; |
| 62 | observers.intra_frame_callback = intra_frame_callback; |
| 63 | observers.rtcp_stats = rtcp_stats; |
| 64 | observers.rtp_stats = rtp_stats; |
| 65 | observers.bitrate_observer = bitrate_observer; |
| 66 | observers.frame_count_observer = frame_count_observer; |
| 67 | observers.rtcp_type_observer = rtcp_type_observer; |
| 68 | observers.send_delay_observer = send_delay_observer; |
| 69 | observers.send_packet_observer = send_packet_observer; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 70 | return observers; |
| 71 | } |
| 72 | |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 73 | class RtpVideoSenderTestFixture { |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 74 | public: |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 75 | RtpVideoSenderTestFixture( |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 76 | const std::vector<uint32_t>& ssrcs, |
| 77 | int payload_type, |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 78 | const std::map<uint32_t, RtpPayloadState>& suspended_payload_states, |
| 79 | FrameCountObserver* frame_count_observer) |
Sebastian Jansson | 572c60f | 2019-03-04 18:30:41 +0100 | [diff] [blame] | 80 | : clock_(1000000), |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 81 | config_(&transport_), |
| 82 | send_delay_stats_(&clock_), |
Sebastian Jansson | ed50e6c | 2019-03-01 14:45:21 +0100 | [diff] [blame] | 83 | transport_controller_(&clock_, |
| 84 | &event_log_, |
| 85 | nullptr, |
| 86 | bitrate_config_, |
| 87 | ProcessThread::Create("PacerThread"), |
| 88 | &GlobalTaskQueueFactory()), |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 89 | process_thread_(ProcessThread::Create("test_thread")), |
| 90 | call_stats_(&clock_, process_thread_.get()), |
| 91 | stats_proxy_(&clock_, |
| 92 | config_, |
| 93 | VideoEncoderConfig::ContentType::kRealtimeVideo), |
| 94 | retransmission_rate_limiter_(&clock_, kRetransmitWindowSizeMs) { |
| 95 | for (uint32_t ssrc : ssrcs) { |
| 96 | config_.rtp.ssrcs.push_back(ssrc); |
| 97 | } |
| 98 | config_.rtp.payload_type = payload_type; |
| 99 | std::map<uint32_t, RtpState> suspended_ssrcs; |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 100 | router_ = absl::make_unique<RtpVideoSender>( |
Sebastian Jansson | 572c60f | 2019-03-04 18:30:41 +0100 | [diff] [blame] | 101 | &clock_, suspended_ssrcs, suspended_payload_states, config_.rtp, |
Amit Hilbuch | 0fc2843 | 2018-12-18 13:01:47 -0800 | [diff] [blame] | 102 | config_.rtcp_report_interval_ms, &transport_, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 103 | CreateObservers(&call_stats_, &encoder_feedback_, &stats_proxy_, |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 104 | &stats_proxy_, &stats_proxy_, frame_count_observer, |
Stefan Holmer | 64be7fa | 2018-10-04 15:21:55 +0200 | [diff] [blame] | 105 | &stats_proxy_, &stats_proxy_, &send_delay_stats_), |
| 106 | &transport_controller_, &event_log_, &retransmission_rate_limiter_, |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 107 | absl::make_unique<FecControllerDefault>(&clock_), nullptr, |
| 108 | CryptoOptions{}); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 109 | } |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 110 | RtpVideoSenderTestFixture( |
| 111 | const std::vector<uint32_t>& ssrcs, |
| 112 | int payload_type, |
| 113 | const std::map<uint32_t, RtpPayloadState>& suspended_payload_states) |
| 114 | : RtpVideoSenderTestFixture(ssrcs, |
| 115 | payload_type, |
| 116 | suspended_payload_states, |
| 117 | /*frame_count_observer=*/nullptr) {} |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 118 | |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 119 | RtpVideoSender* router() { return router_.get(); } |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 120 | |
| 121 | private: |
| 122 | NiceMock<MockTransport> transport_; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 123 | NiceMock<MockRtcpIntraFrameObserver> encoder_feedback_; |
| 124 | SimulatedClock clock_; |
| 125 | RtcEventLogNullImpl event_log_; |
| 126 | VideoSendStream::Config config_; |
| 127 | SendDelayStats send_delay_stats_; |
| 128 | BitrateConstraints bitrate_config_; |
| 129 | RtpTransportControllerSend transport_controller_; |
| 130 | std::unique_ptr<ProcessThread> process_thread_; |
| 131 | CallStats call_stats_; |
| 132 | SendStatisticsProxy stats_proxy_; |
| 133 | RateLimiter retransmission_rate_limiter_; |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 134 | std::unique_ptr<RtpVideoSender> router_; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 135 | }; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 136 | } // namespace |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 137 | |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 138 | TEST(RtpVideoSenderTest, SendOnOneModule) { |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 139 | constexpr uint8_t kPayload = 'a'; |
kjellander | 02b3d27 | 2016-04-20 05:05:54 -0700 | [diff] [blame] | 140 | EncodedImage encoded_image; |
Niels Möller | 2377588 | 2018-08-16 10:24:12 +0200 | [diff] [blame] | 141 | encoded_image.SetTimestamp(1); |
kjellander | 02b3d27 | 2016-04-20 05:05:54 -0700 | [diff] [blame] | 142 | encoded_image.capture_time_ms_ = 2; |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame^] | 143 | encoded_image._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 144 | encoded_image.Allocate(1); |
| 145 | encoded_image.data()[0] = kPayload; |
Niels Möller | 77536a2 | 2019-01-15 08:50:01 +0100 | [diff] [blame] | 146 | encoded_image.set_size(1); |
kjellander | 02b3d27 | 2016-04-20 05:05:54 -0700 | [diff] [blame] | 147 | |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 148 | RtpVideoSenderTestFixture test({kSsrc1}, kPayloadType, {}); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 149 | EXPECT_NE( |
| 150 | EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 151 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 152 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 153 | test.router()->SetActive(true); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 154 | EXPECT_EQ( |
| 155 | EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 156 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 157 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 158 | test.router()->SetActive(false); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 159 | EXPECT_NE( |
| 160 | EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 161 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 162 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 163 | test.router()->SetActive(true); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 164 | EXPECT_EQ( |
| 165 | EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 166 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 167 | } |
| 168 | |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 169 | TEST(RtpVideoSenderTest, SendSimulcastSetActive) { |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 170 | constexpr uint8_t kPayload = 'a'; |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 171 | EncodedImage encoded_image_1; |
| 172 | encoded_image_1.SetTimestamp(1); |
| 173 | encoded_image_1.capture_time_ms_ = 2; |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame^] | 174 | encoded_image_1._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 175 | encoded_image_1.Allocate(1); |
| 176 | encoded_image_1.data()[0] = kPayload; |
Niels Möller | 77536a2 | 2019-01-15 08:50:01 +0100 | [diff] [blame] | 177 | encoded_image_1.set_size(1); |
kjellander | 02b3d27 | 2016-04-20 05:05:54 -0700 | [diff] [blame] | 178 | |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 179 | RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {}); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 180 | |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 181 | CodecSpecificInfo codec_info; |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 182 | codec_info.codecType = kVideoCodecVP8; |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 183 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 184 | test.router()->SetActive(true); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 185 | EXPECT_EQ(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 186 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 187 | ->OnEncodedImage(encoded_image_1, &codec_info, nullptr) |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 188 | .error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 189 | |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 190 | EncodedImage encoded_image_2(encoded_image_1); |
| 191 | encoded_image_2.SetSpatialIndex(1); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 192 | EXPECT_EQ(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 193 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 194 | ->OnEncodedImage(encoded_image_2, &codec_info, nullptr) |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 195 | .error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 196 | |
mflodman@webrtc.org | 50e2816 | 2015-02-23 07:45:11 +0000 | [diff] [blame] | 197 | // Inactive. |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 198 | test.router()->SetActive(false); |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 199 | EXPECT_NE(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 200 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 201 | ->OnEncodedImage(encoded_image_1, &codec_info, nullptr) |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 202 | .error); |
| 203 | EXPECT_NE(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 204 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 205 | ->OnEncodedImage(encoded_image_2, &codec_info, nullptr) |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 206 | .error); |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 207 | } |
| 208 | |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 209 | // Tests how setting individual rtp modules to active affects the overall |
| 210 | // 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] | 211 | // that outgoing data can be sent on this module, and checks that no data can |
| 212 | // be sent if both modules are inactive. |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 213 | TEST(RtpVideoSenderTest, SendSimulcastSetActiveModules) { |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 214 | constexpr uint8_t kPayload = 'a'; |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 215 | EncodedImage encoded_image_1; |
| 216 | encoded_image_1.SetTimestamp(1); |
| 217 | encoded_image_1.capture_time_ms_ = 2; |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame^] | 218 | encoded_image_1._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 219 | encoded_image_1.Allocate(1); |
| 220 | encoded_image_1.data()[0] = kPayload; |
Niels Möller | 77536a2 | 2019-01-15 08:50:01 +0100 | [diff] [blame] | 221 | encoded_image_1.set_size(1); |
| 222 | |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 223 | EncodedImage encoded_image_2(encoded_image_1); |
| 224 | encoded_image_2.SetSpatialIndex(1); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 225 | |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 226 | RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {}); |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 227 | CodecSpecificInfo codec_info; |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 228 | codec_info.codecType = kVideoCodecVP8; |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 229 | |
| 230 | // Only setting one stream to active will still set the payload router to |
| 231 | // active and allow sending data on the active stream. |
| 232 | std::vector<bool> active_modules({true, false}); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 233 | test.router()->SetActiveModules(active_modules); |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 234 | EXPECT_EQ(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 235 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 236 | ->OnEncodedImage(encoded_image_1, &codec_info, nullptr) |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 237 | .error); |
| 238 | |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 239 | // Setting both streams to inactive will turn the payload router to |
| 240 | // inactive. |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 241 | active_modules = {false, false}; |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 242 | test.router()->SetActiveModules(active_modules); |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 243 | // An incoming encoded image will not ask the module to send outgoing data |
| 244 | // because the payload router is inactive. |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 245 | EXPECT_NE(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 246 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 247 | ->OnEncodedImage(encoded_image_1, &codec_info, nullptr) |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 248 | .error); |
| 249 | EXPECT_NE(EncodedImageCallback::Result::OK, |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 250 | test.router() |
Niels Möller | d3b8c63 | 2018-08-27 15:33:42 +0200 | [diff] [blame] | 251 | ->OnEncodedImage(encoded_image_1, &codec_info, nullptr) |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 252 | .error); |
| 253 | } |
| 254 | |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 255 | TEST(RtpVideoSenderTest, CreateWithNoPreviousStates) { |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 256 | RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {}); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 257 | test.router()->SetActive(true); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 258 | |
| 259 | std::map<uint32_t, RtpPayloadState> initial_states = |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 260 | test.router()->GetRtpPayloadStates(); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 261 | EXPECT_EQ(2u, initial_states.size()); |
| 262 | EXPECT_NE(initial_states.find(kSsrc1), initial_states.end()); |
| 263 | EXPECT_NE(initial_states.find(kSsrc2), initial_states.end()); |
| 264 | } |
| 265 | |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 266 | TEST(RtpVideoSenderTest, CreateWithPreviousStates) { |
philipel | 25d31ec | 2018-08-08 16:33:01 +0200 | [diff] [blame] | 267 | const int64_t kState1SharedFrameId = 123; |
| 268 | const int64_t kState2SharedFrameId = 234; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 269 | RtpPayloadState state1; |
| 270 | state1.picture_id = kInitialPictureId1; |
Niels Möller | bb894ff | 2018-03-15 12:28:53 +0100 | [diff] [blame] | 271 | state1.tl0_pic_idx = kInitialTl0PicIdx1; |
philipel | 25d31ec | 2018-08-08 16:33:01 +0200 | [diff] [blame] | 272 | state1.shared_frame_id = kState1SharedFrameId; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 273 | RtpPayloadState state2; |
| 274 | state2.picture_id = kInitialPictureId2; |
Niels Möller | bb894ff | 2018-03-15 12:28:53 +0100 | [diff] [blame] | 275 | state2.tl0_pic_idx = kInitialTl0PicIdx2; |
philipel | 25d31ec | 2018-08-08 16:33:01 +0200 | [diff] [blame] | 276 | state2.shared_frame_id = kState2SharedFrameId; |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 277 | std::map<uint32_t, RtpPayloadState> states = {{kSsrc1, state1}, |
| 278 | {kSsrc2, state2}}; |
| 279 | |
Stefan Holmer | 9416ef8 | 2018-07-19 10:34:38 +0200 | [diff] [blame] | 280 | RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, states); |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 281 | test.router()->SetActive(true); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 282 | |
| 283 | std::map<uint32_t, RtpPayloadState> initial_states = |
Stefan Holmer | dbdb3a0 | 2018-07-17 16:03:46 +0200 | [diff] [blame] | 284 | test.router()->GetRtpPayloadStates(); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 285 | EXPECT_EQ(2u, initial_states.size()); |
| 286 | EXPECT_EQ(kInitialPictureId1, initial_states[kSsrc1].picture_id); |
Niels Möller | bb894ff | 2018-03-15 12:28:53 +0100 | [diff] [blame] | 287 | EXPECT_EQ(kInitialTl0PicIdx1, initial_states[kSsrc1].tl0_pic_idx); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 288 | EXPECT_EQ(kInitialPictureId2, initial_states[kSsrc2].picture_id); |
Niels Möller | bb894ff | 2018-03-15 12:28:53 +0100 | [diff] [blame] | 289 | EXPECT_EQ(kInitialTl0PicIdx2, initial_states[kSsrc2].tl0_pic_idx); |
philipel | 25d31ec | 2018-08-08 16:33:01 +0200 | [diff] [blame] | 290 | EXPECT_EQ(kState2SharedFrameId, initial_states[kSsrc1].shared_frame_id); |
| 291 | EXPECT_EQ(kState2SharedFrameId, initial_states[kSsrc2].shared_frame_id); |
Åsa Persson | 4bece9a | 2017-10-06 10:04:04 +0200 | [diff] [blame] | 292 | } |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 293 | |
Sebastian Jansson | 6347029 | 2019-02-01 10:13:43 +0100 | [diff] [blame] | 294 | TEST(RtpVideoSenderTest, FrameCountCallbacks) { |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 295 | class MockFrameCountObserver : public FrameCountObserver { |
| 296 | public: |
| 297 | MOCK_METHOD2(FrameCountUpdated, |
| 298 | void(const FrameCounts& frame_counts, uint32_t ssrc)); |
| 299 | } callback; |
| 300 | |
| 301 | RtpVideoSenderTestFixture test({kSsrc1}, kPayloadType, {}, &callback); |
| 302 | |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 303 | constexpr uint8_t kPayload = 'a'; |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 304 | EncodedImage encoded_image; |
| 305 | encoded_image.SetTimestamp(1); |
| 306 | encoded_image.capture_time_ms_ = 2; |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame^] | 307 | encoded_image._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | 663844d | 2019-02-14 16:15:54 +0100 | [diff] [blame] | 308 | encoded_image.Allocate(1); |
| 309 | encoded_image.data()[0] = kPayload; |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 310 | encoded_image.set_size(1); |
| 311 | |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame^] | 312 | encoded_image._frameType = VideoFrameType::kVideoFrameKey; |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 313 | |
| 314 | // No callbacks when not active. |
| 315 | EXPECT_CALL(callback, FrameCountUpdated).Times(0); |
| 316 | EXPECT_NE( |
| 317 | EncodedImageCallback::Result::OK, |
| 318 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
| 319 | testing::Mock::VerifyAndClearExpectations(&callback); |
| 320 | |
| 321 | test.router()->SetActive(true); |
| 322 | |
| 323 | FrameCounts frame_counts; |
| 324 | EXPECT_CALL(callback, FrameCountUpdated(_, kSsrc1)) |
| 325 | .WillOnce(SaveArg<0>(&frame_counts)); |
| 326 | EXPECT_EQ( |
| 327 | EncodedImageCallback::Result::OK, |
| 328 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
| 329 | |
| 330 | EXPECT_EQ(1, frame_counts.key_frames); |
| 331 | EXPECT_EQ(0, frame_counts.delta_frames); |
| 332 | |
| 333 | testing::Mock::VerifyAndClearExpectations(&callback); |
| 334 | |
Niels Möller | 8f7ce22 | 2019-03-21 15:43:58 +0100 | [diff] [blame^] | 335 | encoded_image._frameType = VideoFrameType::kVideoFrameDelta; |
Niels Möller | 949f0fd | 2019-01-29 09:44:24 +0100 | [diff] [blame] | 336 | EXPECT_CALL(callback, FrameCountUpdated(_, kSsrc1)) |
| 337 | .WillOnce(SaveArg<0>(&frame_counts)); |
| 338 | EXPECT_EQ( |
| 339 | EncodedImageCallback::Result::OK, |
| 340 | test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error); |
| 341 | |
| 342 | EXPECT_EQ(1, frame_counts.key_frames); |
| 343 | EXPECT_EQ(1, frame_counts.delta_frames); |
| 344 | } |
| 345 | |
mflodman@webrtc.org | 02270cd | 2015-02-06 13:10:19 +0000 | [diff] [blame] | 346 | } // namespace webrtc |