1 /*
2 * Copyright (c) 2012 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
11 #include "modules/video_coding/codecs/test/videoprocessor.h"
12
13 #include <memory>
14
15 #include "api/scoped_refptr.h"
16 #include "api/test/mock_video_decoder.h"
17 #include "api/test/mock_video_encoder.h"
18 #include "api/test/videocodec_test_fixture.h"
19 #include "api/video/i420_buffer.h"
20 #include "media/base/media_constants.h"
21 #include "modules/video_coding/codecs/test/videocodec_test_stats_impl.h"
22 #include "rtc_base/task_queue_for_test.h"
23 #include "test/gmock.h"
24 #include "test/gtest.h"
25 #include "test/testsupport/mock/mock_frame_reader.h"
26
27 using ::testing::_;
28 using ::testing::AllOf;
29 using ::testing::Field;
30 using ::testing::Property;
31 using ::testing::ResultOf;
32 using ::testing::Return;
33
34 namespace webrtc {
35 namespace test {
36
37 namespace {
38
39 const int kWidth = 352;
40 const int kHeight = 288;
41 const int kFrameSize = kWidth * kHeight * 3 / 2; // I420.
42
43 } // namespace
44
45 class VideoProcessorTest : public ::testing::Test {
46 protected:
VideoProcessorTest()47 VideoProcessorTest() : q_("VP queue") {
48 config_.SetCodecSettings(cricket::kVp8CodecName, 1, 1, 1, false, false,
49 false, kWidth, kHeight);
50
51 decoder_mock_ = new MockVideoDecoder();
52 decoders_.push_back(std::unique_ptr<VideoDecoder>(decoder_mock_));
53
54 ExpectInit();
55 EXPECT_CALL(frame_reader_mock_, FrameLength())
56 .WillRepeatedly(Return(kFrameSize));
57 q_.SendTask(
58 [this] {
59 video_processor_ = std::make_unique<VideoProcessor>(
60 &encoder_mock_, &decoders_, &frame_reader_mock_, config_, &stats_,
61 &encoded_frame_writers_, /*decoded_frame_writers=*/nullptr);
62 });
63 }
64
~VideoProcessorTest()65 ~VideoProcessorTest() {
66 q_.SendTask([this] { video_processor_.reset(); });
67 }
68
ExpectInit()69 void ExpectInit() {
70 EXPECT_CALL(encoder_mock_, InitEncode(_, _));
71 EXPECT_CALL(encoder_mock_, RegisterEncodeCompleteCallback);
72 EXPECT_CALL(*decoder_mock_, Configure);
73 EXPECT_CALL(*decoder_mock_, RegisterDecodeCompleteCallback);
74 }
75
ExpectRelease()76 void ExpectRelease() {
77 EXPECT_CALL(encoder_mock_, Release()).Times(1);
78 EXPECT_CALL(encoder_mock_, RegisterEncodeCompleteCallback(_)).Times(1);
79 EXPECT_CALL(*decoder_mock_, Release()).Times(1);
80 EXPECT_CALL(*decoder_mock_, RegisterDecodeCompleteCallback(_)).Times(1);
81 }
82
83 TaskQueueForTest q_;
84
85 VideoCodecTestFixture::Config config_;
86
87 MockVideoEncoder encoder_mock_;
88 MockVideoDecoder* decoder_mock_;
89 std::vector<std::unique_ptr<VideoDecoder>> decoders_;
90 MockFrameReader frame_reader_mock_;
91 VideoCodecTestStatsImpl stats_;
92 VideoProcessor::IvfFileWriterMap encoded_frame_writers_;
93 std::unique_ptr<VideoProcessor> video_processor_;
94 };
95
TEST_F(VideoProcessorTest,InitRelease)96 TEST_F(VideoProcessorTest, InitRelease) {
97 ExpectRelease();
98 }
99
TEST_F(VideoProcessorTest,ProcessFrames_FixedFramerate)100 TEST_F(VideoProcessorTest, ProcessFrames_FixedFramerate) {
101 const int kBitrateKbps = 456;
102 const int kFramerateFps = 31;
103 EXPECT_CALL(
104 encoder_mock_,
105 SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
106 static_cast<double>(kFramerateFps))))
107 .Times(1);
108 q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
109
110 EXPECT_CALL(frame_reader_mock_, ReadFrame())
111 .WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
112 EXPECT_CALL(
113 encoder_mock_,
114 Encode(Property(&VideoFrame::timestamp, 1 * 90000 / kFramerateFps), _))
115 .Times(1);
116 q_.SendTask([this] { video_processor_->ProcessFrame(); });
117
118 EXPECT_CALL(
119 encoder_mock_,
120 Encode(Property(&VideoFrame::timestamp, 2 * 90000 / kFramerateFps), _))
121 .Times(1);
122 q_.SendTask([this] { video_processor_->ProcessFrame(); });
123
124 ExpectRelease();
125 }
126
TEST_F(VideoProcessorTest,ProcessFrames_VariableFramerate)127 TEST_F(VideoProcessorTest, ProcessFrames_VariableFramerate) {
128 const int kBitrateKbps = 456;
129 const int kStartFramerateFps = 27;
130 const int kStartTimestamp = 90000 / kStartFramerateFps;
131 EXPECT_CALL(
132 encoder_mock_,
133 SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
134 static_cast<double>(kStartFramerateFps))))
135 .Times(1);
136 q_.SendTask(
137 [=] { video_processor_->SetRates(kBitrateKbps, kStartFramerateFps); });
138
139 EXPECT_CALL(frame_reader_mock_, ReadFrame())
140 .WillRepeatedly(Return(I420Buffer::Create(kWidth, kHeight)));
141 EXPECT_CALL(encoder_mock_,
142 Encode(Property(&VideoFrame::timestamp, kStartTimestamp), _))
143 .Times(1);
144 q_.SendTask([this] { video_processor_->ProcessFrame(); });
145
146 const int kNewFramerateFps = 13;
147 EXPECT_CALL(
148 encoder_mock_,
149 SetRates(Field(&VideoEncoder::RateControlParameters::framerate_fps,
150 static_cast<double>(kNewFramerateFps))))
151 .Times(1);
152 q_.SendTask(
153 [=] { video_processor_->SetRates(kBitrateKbps, kNewFramerateFps); });
154
155 EXPECT_CALL(encoder_mock_,
156 Encode(Property(&VideoFrame::timestamp,
157 kStartTimestamp + 90000 / kNewFramerateFps),
158 _))
159 .Times(1);
160 q_.SendTask([this] { video_processor_->ProcessFrame(); });
161
162 ExpectRelease();
163 }
164
TEST_F(VideoProcessorTest,SetRates)165 TEST_F(VideoProcessorTest, SetRates) {
166 const uint32_t kBitrateKbps = 123;
167 const int kFramerateFps = 17;
168
169 EXPECT_CALL(
170 encoder_mock_,
171 SetRates(AllOf(ResultOf(
172 [](const VideoEncoder::RateControlParameters& params) {
173 return params.bitrate.get_sum_kbps();
174 },
175 kBitrateKbps),
176 Field(&VideoEncoder::RateControlParameters::framerate_fps,
177 static_cast<double>(kFramerateFps)))))
178 .Times(1);
179 q_.SendTask([=] { video_processor_->SetRates(kBitrateKbps, kFramerateFps); });
180
181 const uint32_t kNewBitrateKbps = 456;
182 const int kNewFramerateFps = 34;
183 EXPECT_CALL(
184 encoder_mock_,
185 SetRates(AllOf(ResultOf(
186 [](const VideoEncoder::RateControlParameters& params) {
187 return params.bitrate.get_sum_kbps();
188 },
189 kNewBitrateKbps),
190 Field(&VideoEncoder::RateControlParameters::framerate_fps,
191 static_cast<double>(kNewFramerateFps)))))
192 .Times(1);
193 q_.SendTask(
194 [=] { video_processor_->SetRates(kNewBitrateKbps, kNewFramerateFps); });
195
196 ExpectRelease();
197 }
198
199 } // namespace test
200 } // namespace webrtc
201