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 <stdio.h>
12
13 #include "testing/gtest/include/gtest/gtest.h"
14 #include "webrtc/base/checks.h"
15 #include "webrtc/base/scoped_ptr.h"
16 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
17 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
18 #include "webrtc/system_wrappers/include/tick_util.h"
19 #include "webrtc/test/testsupport/fileutils.h"
20
21 namespace webrtc {
22
23 enum { kMaxWaitEncTimeMs = 100 };
24 enum { kMaxWaitDecTimeMs = 25 };
25
26 static const uint32_t kTestTimestamp = 123;
27 static const int64_t kTestNtpTimeMs = 456;
28
29 // TODO(mikhal): Replace these with mocks.
30 class Vp8UnitTestEncodeCompleteCallback : public webrtc::EncodedImageCallback {
31 public:
Vp8UnitTestEncodeCompleteCallback(EncodedImage * frame,unsigned int decoderSpecificSize,void * decoderSpecificInfo)32 Vp8UnitTestEncodeCompleteCallback(EncodedImage* frame,
33 unsigned int decoderSpecificSize,
34 void* decoderSpecificInfo)
35 : encoded_frame_(frame), encode_complete_(false) {}
36
37 virtual int Encoded(const EncodedImage& encoded_frame_,
38 const CodecSpecificInfo* codecSpecificInfo,
39 const RTPFragmentationHeader*);
40 bool EncodeComplete();
41
42 private:
43 EncodedImage* const encoded_frame_;
44 rtc::scoped_ptr<uint8_t[]> frame_buffer_;
45 bool encode_complete_;
46 };
47
Encoded(const EncodedImage & encoded_frame,const CodecSpecificInfo * codecSpecificInfo,const RTPFragmentationHeader * fragmentation)48 int Vp8UnitTestEncodeCompleteCallback::Encoded(
49 const EncodedImage& encoded_frame,
50 const CodecSpecificInfo* codecSpecificInfo,
51 const RTPFragmentationHeader* fragmentation) {
52 if (encoded_frame_->_size < encoded_frame._length) {
53 delete[] encoded_frame_->_buffer;
54 frame_buffer_.reset(new uint8_t[encoded_frame._length]);
55 encoded_frame_->_buffer = frame_buffer_.get();
56 encoded_frame_->_size = encoded_frame._length;
57 }
58 memcpy(encoded_frame_->_buffer, encoded_frame._buffer, encoded_frame._length);
59 encoded_frame_->_length = encoded_frame._length;
60 encoded_frame_->_encodedWidth = encoded_frame._encodedWidth;
61 encoded_frame_->_encodedHeight = encoded_frame._encodedHeight;
62 encoded_frame_->_timeStamp = encoded_frame._timeStamp;
63 encoded_frame_->_frameType = encoded_frame._frameType;
64 encoded_frame_->_completeFrame = encoded_frame._completeFrame;
65 encode_complete_ = true;
66 return 0;
67 }
68
EncodeComplete()69 bool Vp8UnitTestEncodeCompleteCallback::EncodeComplete() {
70 if (encode_complete_) {
71 encode_complete_ = false;
72 return true;
73 }
74 return false;
75 }
76
77 class Vp8UnitTestDecodeCompleteCallback : public webrtc::DecodedImageCallback {
78 public:
Vp8UnitTestDecodeCompleteCallback(VideoFrame * frame)79 explicit Vp8UnitTestDecodeCompleteCallback(VideoFrame* frame)
80 : decoded_frame_(frame), decode_complete(false) {}
81 int32_t Decoded(VideoFrame& frame) override;
Decoded(VideoFrame & frame,int64_t decode_time_ms)82 int32_t Decoded(VideoFrame& frame, int64_t decode_time_ms) override {
83 RTC_NOTREACHED();
84 return -1;
85 }
86 bool DecodeComplete();
87
88 private:
89 VideoFrame* decoded_frame_;
90 bool decode_complete;
91 };
92
DecodeComplete()93 bool Vp8UnitTestDecodeCompleteCallback::DecodeComplete() {
94 if (decode_complete) {
95 decode_complete = false;
96 return true;
97 }
98 return false;
99 }
100
Decoded(VideoFrame & image)101 int Vp8UnitTestDecodeCompleteCallback::Decoded(VideoFrame& image) {
102 decoded_frame_->CopyFrame(image);
103 decode_complete = true;
104 return 0;
105 }
106
107 class TestVp8Impl : public ::testing::Test {
108 protected:
SetUp()109 virtual void SetUp() {
110 encoder_.reset(VP8Encoder::Create());
111 decoder_.reset(VP8Decoder::Create());
112 memset(&codec_inst_, 0, sizeof(codec_inst_));
113 encode_complete_callback_.reset(
114 new Vp8UnitTestEncodeCompleteCallback(&encoded_frame_, 0, NULL));
115 decode_complete_callback_.reset(
116 new Vp8UnitTestDecodeCompleteCallback(&decoded_frame_));
117 encoder_->RegisterEncodeCompleteCallback(encode_complete_callback_.get());
118 decoder_->RegisterDecodeCompleteCallback(decode_complete_callback_.get());
119 // Using a QCIF image (aligned stride (u,v planes) > width).
120 // Processing only one frame.
121 length_source_frame_ = CalcBufferSize(kI420, kWidth, kHeight);
122 source_buffer_.reset(new uint8_t[length_source_frame_]);
123 source_file_ = fopen(test::ResourcePath("paris_qcif", "yuv").c_str(), "rb");
124 ASSERT_TRUE(source_file_ != NULL);
125 // Set input frame.
126 ASSERT_EQ(
127 fread(source_buffer_.get(), 1, length_source_frame_, source_file_),
128 length_source_frame_);
129 codec_inst_.width = kWidth;
130 codec_inst_.height = kHeight;
131 const int kFramerate = 30;
132 codec_inst_.maxFramerate = kFramerate;
133 // Setting aligned stride values.
134 int stride_uv = 0;
135 int stride_y = 0;
136 Calc16ByteAlignedStride(codec_inst_.width, &stride_y, &stride_uv);
137 EXPECT_EQ(stride_y, 176);
138 EXPECT_EQ(stride_uv, 96);
139
140 input_frame_.CreateEmptyFrame(codec_inst_.width, codec_inst_.height,
141 stride_y, stride_uv, stride_uv);
142 input_frame_.set_timestamp(kTestTimestamp);
143 // Using ConvertToI420 to add stride to the image.
144 EXPECT_EQ(0, ConvertToI420(kI420, source_buffer_.get(), 0, 0,
145 codec_inst_.width, codec_inst_.height, 0,
146 kVideoRotation_0, &input_frame_));
147 }
148
SetUpEncodeDecode()149 void SetUpEncodeDecode() {
150 codec_inst_.startBitrate = 300;
151 codec_inst_.maxBitrate = 4000;
152 codec_inst_.qpMax = 56;
153 codec_inst_.codecSpecific.VP8.denoisingOn = true;
154
155 EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
156 encoder_->InitEncode(&codec_inst_, 1, 1440));
157 EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->InitDecode(&codec_inst_, 1));
158 }
159
WaitForEncodedFrame() const160 size_t WaitForEncodedFrame() const {
161 int64_t startTime = TickTime::MillisecondTimestamp();
162 while (TickTime::MillisecondTimestamp() - startTime < kMaxWaitEncTimeMs) {
163 if (encode_complete_callback_->EncodeComplete()) {
164 return encoded_frame_._length;
165 }
166 }
167 return 0;
168 }
169
WaitForDecodedFrame() const170 size_t WaitForDecodedFrame() const {
171 int64_t startTime = TickTime::MillisecondTimestamp();
172 while (TickTime::MillisecondTimestamp() - startTime < kMaxWaitDecTimeMs) {
173 if (decode_complete_callback_->DecodeComplete()) {
174 return CalcBufferSize(kI420, decoded_frame_.width(),
175 decoded_frame_.height());
176 }
177 }
178 return 0;
179 }
180
181 const int kWidth = 172;
182 const int kHeight = 144;
183
184 rtc::scoped_ptr<Vp8UnitTestEncodeCompleteCallback> encode_complete_callback_;
185 rtc::scoped_ptr<Vp8UnitTestDecodeCompleteCallback> decode_complete_callback_;
186 rtc::scoped_ptr<uint8_t[]> source_buffer_;
187 FILE* source_file_;
188 VideoFrame input_frame_;
189 rtc::scoped_ptr<VideoEncoder> encoder_;
190 rtc::scoped_ptr<VideoDecoder> decoder_;
191 EncodedImage encoded_frame_;
192 VideoFrame decoded_frame_;
193 size_t length_source_frame_;
194 VideoCodec codec_inst_;
195 };
196
TEST_F(TestVp8Impl,EncoderParameterTest)197 TEST_F(TestVp8Impl, EncoderParameterTest) {
198 strncpy(codec_inst_.plName, "VP8", 31);
199 codec_inst_.plType = 126;
200 codec_inst_.maxBitrate = 0;
201 codec_inst_.minBitrate = 0;
202 codec_inst_.width = 1440;
203 codec_inst_.height = 1080;
204 codec_inst_.maxFramerate = 30;
205 codec_inst_.startBitrate = 300;
206 codec_inst_.qpMax = 56;
207 codec_inst_.codecSpecific.VP8.complexity = kComplexityNormal;
208 codec_inst_.codecSpecific.VP8.numberOfTemporalLayers = 1;
209 // Calls before InitEncode().
210 EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->Release());
211 int bit_rate = 300;
212 EXPECT_EQ(WEBRTC_VIDEO_CODEC_UNINITIALIZED,
213 encoder_->SetRates(bit_rate, codec_inst_.maxFramerate));
214
215 EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, encoder_->InitEncode(&codec_inst_, 1, 1440));
216
217 // Decoder parameter tests.
218 // Calls before InitDecode().
219 EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->Release());
220 EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, decoder_->InitDecode(&codec_inst_, 1));
221 }
222
223 #if defined(WEBRTC_ANDROID)
224 #define MAYBE_AlignedStrideEncodeDecode DISABLED_AlignedStrideEncodeDecode
225 #else
226 #define MAYBE_AlignedStrideEncodeDecode AlignedStrideEncodeDecode
227 #endif
TEST_F(TestVp8Impl,MAYBE_AlignedStrideEncodeDecode)228 TEST_F(TestVp8Impl, MAYBE_AlignedStrideEncodeDecode) {
229 SetUpEncodeDecode();
230 encoder_->Encode(input_frame_, NULL, NULL);
231 EXPECT_GT(WaitForEncodedFrame(), 0u);
232 // First frame should be a key frame.
233 encoded_frame_._frameType = kVideoFrameKey;
234 encoded_frame_.ntp_time_ms_ = kTestNtpTimeMs;
235 EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
236 decoder_->Decode(encoded_frame_, false, NULL));
237 EXPECT_GT(WaitForDecodedFrame(), 0u);
238 // Compute PSNR on all planes (faster than SSIM).
239 EXPECT_GT(I420PSNR(&input_frame_, &decoded_frame_), 36);
240 EXPECT_EQ(kTestTimestamp, decoded_frame_.timestamp());
241 EXPECT_EQ(kTestNtpTimeMs, decoded_frame_.ntp_time_ms());
242 }
243
244 #if defined(WEBRTC_ANDROID)
245 #define MAYBE_DecodeWithACompleteKeyFrame DISABLED_DecodeWithACompleteKeyFrame
246 #else
247 #define MAYBE_DecodeWithACompleteKeyFrame DecodeWithACompleteKeyFrame
248 #endif
TEST_F(TestVp8Impl,MAYBE_DecodeWithACompleteKeyFrame)249 TEST_F(TestVp8Impl, MAYBE_DecodeWithACompleteKeyFrame) {
250 SetUpEncodeDecode();
251 encoder_->Encode(input_frame_, NULL, NULL);
252 EXPECT_GT(WaitForEncodedFrame(), 0u);
253 // Setting complete to false -> should return an error.
254 encoded_frame_._completeFrame = false;
255 EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR,
256 decoder_->Decode(encoded_frame_, false, NULL));
257 // Setting complete back to true. Forcing a delta frame.
258 encoded_frame_._frameType = kVideoFrameDelta;
259 encoded_frame_._completeFrame = true;
260 EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR,
261 decoder_->Decode(encoded_frame_, false, NULL));
262 // Now setting a key frame.
263 encoded_frame_._frameType = kVideoFrameKey;
264 EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
265 decoder_->Decode(encoded_frame_, false, NULL));
266 EXPECT_GT(I420PSNR(&input_frame_, &decoded_frame_), 36);
267 }
268
TEST_F(TestVp8Impl,TestReset)269 TEST_F(TestVp8Impl, TestReset) {
270 SetUpEncodeDecode();
271 EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
272 EXPECT_EQ(0, decoder_->Decode(encoded_frame_, false, NULL));
273 size_t length = CalcBufferSize(kI420, kWidth, kHeight);
274 rtc::scoped_ptr<uint8_t[]> first_frame_buffer(new uint8_t[length]);
275 ExtractBuffer(decoded_frame_, length, first_frame_buffer.get());
276
277 EXPECT_EQ(0, decoder_->Reset());
278
279 EXPECT_EQ(0, decoder_->Decode(encoded_frame_, false, NULL));
280 rtc::scoped_ptr<uint8_t[]> second_frame_buffer(new uint8_t[length]);
281 ExtractBuffer(decoded_frame_, length, second_frame_buffer.get());
282
283 EXPECT_EQ(
284 0, memcmp(second_frame_buffer.get(), first_frame_buffer.get(), length));
285 }
286
287 } // namespace webrtc
288