blob: d1c771409d08dca02f9e57f80281350654f900ef [file] [log] [blame]
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +00001/*
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
kwiberg27f982b2016-03-01 11:52:33 -080011#include <memory>
Åsa Persson4bece9a2017-10-06 10:04:04 +020012#include <string>
kwiberg27f982b2016-03-01 11:52:33 -080013
Steve Anton40d55332019-01-07 10:21:47 -080014#include "absl/memory/memory.h"
Sebastian Janssoned50e6c2019-03-01 14:45:21 +010015#include "api/task_queue/global_task_queue_factory.h"
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020016#include "call/rtp_transport_controller_send.h"
Stefan Holmer9416ef82018-07-19 10:34:38 +020017#include "call/rtp_video_sender.h"
Stefan Holmer64be7fa2018-10-04 15:21:55 +020018#include "modules/video_coding/fec_controller_default.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020019#include "modules/video_coding/include/video_codec_interface.h"
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020020#include "rtc_base/rate_limiter.h"
Åsa Persson4bece9a2017-10-06 10:04:04 +020021#include "test/field_trial.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020022#include "test/gmock.h"
23#include "test/gtest.h"
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020024#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.org02270cd2015-02-06 13:10:19 +000028
29using ::testing::_;
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +000030using ::testing::NiceMock;
Niels Möller949f0fd2019-01-29 09:44:24 +010031using ::testing::SaveArg;
Åsa Persson4bece9a2017-10-06 10:04:04 +020032using ::testing::Unused;
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +000033
34namespace webrtc {
Åsa Persson4bece9a2017-10-06 10:04:04 +020035namespace {
36const int8_t kPayloadType = 96;
37const uint32_t kSsrc1 = 12345;
38const uint32_t kSsrc2 = 23456;
Åsa Persson4bece9a2017-10-06 10:04:04 +020039const int16_t kInitialPictureId1 = 222;
40const int16_t kInitialPictureId2 = 44;
Niels Möllerbb894ff2018-03-15 12:28:53 +010041const int16_t kInitialTl0PicIdx1 = 99;
42const int16_t kInitialTl0PicIdx2 = 199;
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020043const int64_t kRetransmitWindowSizeMs = 500;
44
45class MockRtcpIntraFrameObserver : public RtcpIntraFrameObserver {
46 public:
47 MOCK_METHOD1(OnReceivedIntraFrameRequest, void(uint32_t));
48};
49
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020050RtpSenderObservers 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 Holmer64be7fa2018-10-04 15:21:55 +020059 SendPacketObserver* send_packet_observer) {
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020060 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 Holmerdbdb3a02018-07-17 16:03:46 +020070 return observers;
71}
72
Stefan Holmer9416ef82018-07-19 10:34:38 +020073class RtpVideoSenderTestFixture {
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020074 public:
Stefan Holmer9416ef82018-07-19 10:34:38 +020075 RtpVideoSenderTestFixture(
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020076 const std::vector<uint32_t>& ssrcs,
77 int payload_type,
Niels Möller949f0fd2019-01-29 09:44:24 +010078 const std::map<uint32_t, RtpPayloadState>& suspended_payload_states,
79 FrameCountObserver* frame_count_observer)
Sebastian Jansson572c60f2019-03-04 18:30:41 +010080 : clock_(1000000),
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020081 config_(&transport_),
82 send_delay_stats_(&clock_),
Sebastian Janssoned50e6c2019-03-01 14:45:21 +010083 transport_controller_(&clock_,
84 &event_log_,
85 nullptr,
86 bitrate_config_,
87 ProcessThread::Create("PacerThread"),
88 &GlobalTaskQueueFactory()),
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020089 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 Holmer9416ef82018-07-19 10:34:38 +0200100 router_ = absl::make_unique<RtpVideoSender>(
Sebastian Jansson572c60f2019-03-04 18:30:41 +0100101 &clock_, suspended_ssrcs, suspended_payload_states, config_.rtp,
Oleh Prypine8964902019-03-29 15:33:01 +0000102 config_.rtcp_report_interval_ms, &transport_,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200103 CreateObservers(&call_stats_, &encoder_feedback_, &stats_proxy_,
Niels Möller949f0fd2019-01-29 09:44:24 +0100104 &stats_proxy_, &stats_proxy_, frame_count_observer,
Stefan Holmer64be7fa2018-10-04 15:21:55 +0200105 &stats_proxy_, &stats_proxy_, &send_delay_stats_),
106 &transport_controller_, &event_log_, &retransmission_rate_limiter_,
Benjamin Wright192eeec2018-10-17 17:27:25 -0700107 absl::make_unique<FecControllerDefault>(&clock_), nullptr,
108 CryptoOptions{});
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200109 }
Niels Möller949f0fd2019-01-29 09:44:24 +0100110 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 Holmerdbdb3a02018-07-17 16:03:46 +0200118
Stefan Holmer9416ef82018-07-19 10:34:38 +0200119 RtpVideoSender* router() { return router_.get(); }
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200120
121 private:
122 NiceMock<MockTransport> transport_;
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200123 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 Holmer9416ef82018-07-19 10:34:38 +0200134 std::unique_ptr<RtpVideoSender> router_;
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200135};
Åsa Persson4bece9a2017-10-06 10:04:04 +0200136} // namespace
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000137
Sebastian Jansson63470292019-02-01 10:13:43 +0100138TEST(RtpVideoSenderTest, SendOnOneModule) {
Niels Möller663844d2019-02-14 16:15:54 +0100139 constexpr uint8_t kPayload = 'a';
kjellander02b3d272016-04-20 05:05:54 -0700140 EncodedImage encoded_image;
Niels Möller23775882018-08-16 10:24:12 +0200141 encoded_image.SetTimestamp(1);
kjellander02b3d272016-04-20 05:05:54 -0700142 encoded_image.capture_time_ms_ = 2;
Niels Möller8f7ce222019-03-21 15:43:58 +0100143 encoded_image._frameType = VideoFrameType::kVideoFrameKey;
Niels Möller663844d2019-02-14 16:15:54 +0100144 encoded_image.Allocate(1);
145 encoded_image.data()[0] = kPayload;
Niels Möller77536a22019-01-15 08:50:01 +0100146 encoded_image.set_size(1);
kjellander02b3d272016-04-20 05:05:54 -0700147
Stefan Holmer9416ef82018-07-19 10:34:38 +0200148 RtpVideoSenderTestFixture test({kSsrc1}, kPayloadType, {});
sergeyu2cb155a2016-11-04 11:39:29 -0700149 EXPECT_NE(
150 EncodedImageCallback::Result::OK,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200151 test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error);
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000152
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200153 test.router()->SetActive(true);
sergeyu2cb155a2016-11-04 11:39:29 -0700154 EXPECT_EQ(
155 EncodedImageCallback::Result::OK,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200156 test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error);
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000157
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200158 test.router()->SetActive(false);
sergeyu2cb155a2016-11-04 11:39:29 -0700159 EXPECT_NE(
160 EncodedImageCallback::Result::OK,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200161 test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error);
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000162
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200163 test.router()->SetActive(true);
sergeyu2cb155a2016-11-04 11:39:29 -0700164 EXPECT_EQ(
165 EncodedImageCallback::Result::OK,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200166 test.router()->OnEncodedImage(encoded_image, nullptr, nullptr).error);
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000167}
168
Sebastian Jansson63470292019-02-01 10:13:43 +0100169TEST(RtpVideoSenderTest, SendSimulcastSetActive) {
Niels Möller663844d2019-02-14 16:15:54 +0100170 constexpr uint8_t kPayload = 'a';
Niels Möllerd3b8c632018-08-27 15:33:42 +0200171 EncodedImage encoded_image_1;
172 encoded_image_1.SetTimestamp(1);
173 encoded_image_1.capture_time_ms_ = 2;
Niels Möller8f7ce222019-03-21 15:43:58 +0100174 encoded_image_1._frameType = VideoFrameType::kVideoFrameKey;
Niels Möller663844d2019-02-14 16:15:54 +0100175 encoded_image_1.Allocate(1);
176 encoded_image_1.data()[0] = kPayload;
Niels Möller77536a22019-01-15 08:50:01 +0100177 encoded_image_1.set_size(1);
kjellander02b3d272016-04-20 05:05:54 -0700178
Stefan Holmer9416ef82018-07-19 10:34:38 +0200179 RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000180
Niels Möllerd3b8c632018-08-27 15:33:42 +0200181 CodecSpecificInfo codec_info;
Niels Möllerd3b8c632018-08-27 15:33:42 +0200182 codec_info.codecType = kVideoCodecVP8;
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000183
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200184 test.router()->SetActive(true);
sergeyu2cb155a2016-11-04 11:39:29 -0700185 EXPECT_EQ(EncodedImageCallback::Result::OK,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200186 test.router()
Niels Möllerd3b8c632018-08-27 15:33:42 +0200187 ->OnEncodedImage(encoded_image_1, &codec_info, nullptr)
sergeyu2cb155a2016-11-04 11:39:29 -0700188 .error);
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000189
Niels Möllerd3b8c632018-08-27 15:33:42 +0200190 EncodedImage encoded_image_2(encoded_image_1);
191 encoded_image_2.SetSpatialIndex(1);
sergeyu2cb155a2016-11-04 11:39:29 -0700192 EXPECT_EQ(EncodedImageCallback::Result::OK,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200193 test.router()
Niels Möllerd3b8c632018-08-27 15:33:42 +0200194 ->OnEncodedImage(encoded_image_2, &codec_info, nullptr)
sergeyu2cb155a2016-11-04 11:39:29 -0700195 .error);
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000196
mflodman@webrtc.org50e28162015-02-23 07:45:11 +0000197 // Inactive.
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200198 test.router()->SetActive(false);
sergeyu2cb155a2016-11-04 11:39:29 -0700199 EXPECT_NE(EncodedImageCallback::Result::OK,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200200 test.router()
Niels Möllerd3b8c632018-08-27 15:33:42 +0200201 ->OnEncodedImage(encoded_image_1, &codec_info, nullptr)
sergeyu2cb155a2016-11-04 11:39:29 -0700202 .error);
203 EXPECT_NE(EncodedImageCallback::Result::OK,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200204 test.router()
Niels Möllerd3b8c632018-08-27 15:33:42 +0200205 ->OnEncodedImage(encoded_image_2, &codec_info, nullptr)
sergeyu2cb155a2016-11-04 11:39:29 -0700206 .error);
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000207}
208
Seth Hampsoncc7125f2018-02-02 08:46:16 -0800209// 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 Holmerdbdb3a02018-07-17 16:03:46 +0200211// that outgoing data can be sent on this module, and checks that no data can
212// be sent if both modules are inactive.
Sebastian Jansson63470292019-02-01 10:13:43 +0100213TEST(RtpVideoSenderTest, SendSimulcastSetActiveModules) {
Niels Möller663844d2019-02-14 16:15:54 +0100214 constexpr uint8_t kPayload = 'a';
Niels Möllerd3b8c632018-08-27 15:33:42 +0200215 EncodedImage encoded_image_1;
216 encoded_image_1.SetTimestamp(1);
217 encoded_image_1.capture_time_ms_ = 2;
Niels Möller8f7ce222019-03-21 15:43:58 +0100218 encoded_image_1._frameType = VideoFrameType::kVideoFrameKey;
Niels Möller663844d2019-02-14 16:15:54 +0100219 encoded_image_1.Allocate(1);
220 encoded_image_1.data()[0] = kPayload;
Niels Möller77536a22019-01-15 08:50:01 +0100221 encoded_image_1.set_size(1);
222
Niels Möllerd3b8c632018-08-27 15:33:42 +0200223 EncodedImage encoded_image_2(encoded_image_1);
224 encoded_image_2.SetSpatialIndex(1);
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200225
Stefan Holmer9416ef82018-07-19 10:34:38 +0200226 RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
Niels Möllerd3b8c632018-08-27 15:33:42 +0200227 CodecSpecificInfo codec_info;
Niels Möllerd3b8c632018-08-27 15:33:42 +0200228 codec_info.codecType = kVideoCodecVP8;
Seth Hampsoncc7125f2018-02-02 08:46:16 -0800229
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 Holmerdbdb3a02018-07-17 16:03:46 +0200233 test.router()->SetActiveModules(active_modules);
Seth Hampsoncc7125f2018-02-02 08:46:16 -0800234 EXPECT_EQ(EncodedImageCallback::Result::OK,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200235 test.router()
Niels Möllerd3b8c632018-08-27 15:33:42 +0200236 ->OnEncodedImage(encoded_image_1, &codec_info, nullptr)
Seth Hampsoncc7125f2018-02-02 08:46:16 -0800237 .error);
238
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200239 // Setting both streams to inactive will turn the payload router to
240 // inactive.
Seth Hampsoncc7125f2018-02-02 08:46:16 -0800241 active_modules = {false, false};
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200242 test.router()->SetActiveModules(active_modules);
Seth Hampsoncc7125f2018-02-02 08:46:16 -0800243 // An incoming encoded image will not ask the module to send outgoing data
244 // because the payload router is inactive.
Seth Hampsoncc7125f2018-02-02 08:46:16 -0800245 EXPECT_NE(EncodedImageCallback::Result::OK,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200246 test.router()
Niels Möllerd3b8c632018-08-27 15:33:42 +0200247 ->OnEncodedImage(encoded_image_1, &codec_info, nullptr)
Seth Hampsoncc7125f2018-02-02 08:46:16 -0800248 .error);
249 EXPECT_NE(EncodedImageCallback::Result::OK,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200250 test.router()
Niels Möllerd3b8c632018-08-27 15:33:42 +0200251 ->OnEncodedImage(encoded_image_1, &codec_info, nullptr)
Seth Hampsoncc7125f2018-02-02 08:46:16 -0800252 .error);
253}
254
Sebastian Jansson63470292019-02-01 10:13:43 +0100255TEST(RtpVideoSenderTest, CreateWithNoPreviousStates) {
Stefan Holmer9416ef82018-07-19 10:34:38 +0200256 RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, {});
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200257 test.router()->SetActive(true);
Åsa Persson4bece9a2017-10-06 10:04:04 +0200258
259 std::map<uint32_t, RtpPayloadState> initial_states =
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200260 test.router()->GetRtpPayloadStates();
Åsa Persson4bece9a2017-10-06 10:04:04 +0200261 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 Jansson63470292019-02-01 10:13:43 +0100266TEST(RtpVideoSenderTest, CreateWithPreviousStates) {
philipel25d31ec2018-08-08 16:33:01 +0200267 const int64_t kState1SharedFrameId = 123;
268 const int64_t kState2SharedFrameId = 234;
Åsa Persson4bece9a2017-10-06 10:04:04 +0200269 RtpPayloadState state1;
270 state1.picture_id = kInitialPictureId1;
Niels Möllerbb894ff2018-03-15 12:28:53 +0100271 state1.tl0_pic_idx = kInitialTl0PicIdx1;
philipel25d31ec2018-08-08 16:33:01 +0200272 state1.shared_frame_id = kState1SharedFrameId;
Åsa Persson4bece9a2017-10-06 10:04:04 +0200273 RtpPayloadState state2;
274 state2.picture_id = kInitialPictureId2;
Niels Möllerbb894ff2018-03-15 12:28:53 +0100275 state2.tl0_pic_idx = kInitialTl0PicIdx2;
philipel25d31ec2018-08-08 16:33:01 +0200276 state2.shared_frame_id = kState2SharedFrameId;
Åsa Persson4bece9a2017-10-06 10:04:04 +0200277 std::map<uint32_t, RtpPayloadState> states = {{kSsrc1, state1},
278 {kSsrc2, state2}};
279
Stefan Holmer9416ef82018-07-19 10:34:38 +0200280 RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, kPayloadType, states);
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200281 test.router()->SetActive(true);
Åsa Persson4bece9a2017-10-06 10:04:04 +0200282
283 std::map<uint32_t, RtpPayloadState> initial_states =
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200284 test.router()->GetRtpPayloadStates();
Åsa Persson4bece9a2017-10-06 10:04:04 +0200285 EXPECT_EQ(2u, initial_states.size());
286 EXPECT_EQ(kInitialPictureId1, initial_states[kSsrc1].picture_id);
Niels Möllerbb894ff2018-03-15 12:28:53 +0100287 EXPECT_EQ(kInitialTl0PicIdx1, initial_states[kSsrc1].tl0_pic_idx);
Åsa Persson4bece9a2017-10-06 10:04:04 +0200288 EXPECT_EQ(kInitialPictureId2, initial_states[kSsrc2].picture_id);
Niels Möllerbb894ff2018-03-15 12:28:53 +0100289 EXPECT_EQ(kInitialTl0PicIdx2, initial_states[kSsrc2].tl0_pic_idx);
philipel25d31ec2018-08-08 16:33:01 +0200290 EXPECT_EQ(kState2SharedFrameId, initial_states[kSsrc1].shared_frame_id);
291 EXPECT_EQ(kState2SharedFrameId, initial_states[kSsrc2].shared_frame_id);
Åsa Persson4bece9a2017-10-06 10:04:04 +0200292}
Niels Möller949f0fd2019-01-29 09:44:24 +0100293
Sebastian Jansson63470292019-02-01 10:13:43 +0100294TEST(RtpVideoSenderTest, FrameCountCallbacks) {
Niels Möller949f0fd2019-01-29 09:44:24 +0100295 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öller663844d2019-02-14 16:15:54 +0100303 constexpr uint8_t kPayload = 'a';
Niels Möller949f0fd2019-01-29 09:44:24 +0100304 EncodedImage encoded_image;
305 encoded_image.SetTimestamp(1);
306 encoded_image.capture_time_ms_ = 2;
Niels Möller8f7ce222019-03-21 15:43:58 +0100307 encoded_image._frameType = VideoFrameType::kVideoFrameKey;
Niels Möller663844d2019-02-14 16:15:54 +0100308 encoded_image.Allocate(1);
309 encoded_image.data()[0] = kPayload;
Niels Möller949f0fd2019-01-29 09:44:24 +0100310 encoded_image.set_size(1);
311
Niels Möller8f7ce222019-03-21 15:43:58 +0100312 encoded_image._frameType = VideoFrameType::kVideoFrameKey;
Niels Möller949f0fd2019-01-29 09:44:24 +0100313
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);
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200319 ::testing::Mock::VerifyAndClearExpectations(&callback);
Niels Möller949f0fd2019-01-29 09:44:24 +0100320
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
Mirko Bonadei6a489f22019-04-09 15:11:12 +0200333 ::testing::Mock::VerifyAndClearExpectations(&callback);
Niels Möller949f0fd2019-01-29 09:44:24 +0100334
Niels Möller8f7ce222019-03-21 15:43:58 +0100335 encoded_image._frameType = VideoFrameType::kVideoFrameDelta;
Niels Möller949f0fd2019-01-29 09:44:24 +0100336 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.org02270cd2015-02-06 13:10:19 +0000346} // namespace webrtc