OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include "webrtc/media/engine/videodecodersoftwarefallbackwrapper.h" | 11 #include "webrtc/media/engine/videodecodersoftwarefallbackwrapper.h" |
12 #include "webrtc/api/video_codecs/video_decoder.h" | 12 #include "webrtc/api/video_codecs/video_decoder.h" |
13 #include "webrtc/modules/video_coding/include/video_error_codes.h" | 13 #include "webrtc/modules/video_coding/include/video_error_codes.h" |
14 #include "webrtc/rtc_base/checks.h" | 14 #include "webrtc/rtc_base/checks.h" |
15 #include "webrtc/test/gtest.h" | 15 #include "webrtc/test/gtest.h" |
16 | 16 |
17 namespace webrtc { | 17 namespace webrtc { |
18 | 18 |
19 class VideoDecoderSoftwareFallbackWrapperTest : public ::testing::Test { | 19 class VideoDecoderSoftwareFallbackWrapperTest : public ::testing::Test { |
20 protected: | 20 protected: |
21 VideoDecoderSoftwareFallbackWrapperTest() | 21 VideoDecoderSoftwareFallbackWrapperTest() |
22 : fake_decoder_(new CountingFakeDecoder()), | 22 : fallback_wrapper_(kVideoCodecVP8, &fake_decoder_) {} |
23 fallback_wrapper_(kVideoCodecVP8, | |
24 std::unique_ptr<VideoDecoder>(fake_decoder_)) {} | |
25 | 23 |
26 class CountingFakeDecoder : public VideoDecoder { | 24 class CountingFakeDecoder : public VideoDecoder { |
27 public: | 25 public: |
28 int32_t InitDecode(const VideoCodec* codec_settings, | 26 int32_t InitDecode(const VideoCodec* codec_settings, |
29 int32_t number_of_cores) override { | 27 int32_t number_of_cores) override { |
30 ++init_decode_count_; | 28 ++init_decode_count_; |
31 return init_decode_return_code_; | 29 return init_decode_return_code_; |
32 } | 30 } |
33 | 31 |
34 int32_t Decode(const EncodedImage& input_image, | 32 int32_t Decode(const EncodedImage& input_image, |
(...skipping 21 matching lines...) Expand all Loading... |
56 } | 54 } |
57 | 55 |
58 int init_decode_count_ = 0; | 56 int init_decode_count_ = 0; |
59 int decode_count_ = 0; | 57 int decode_count_ = 0; |
60 int32_t init_decode_return_code_ = WEBRTC_VIDEO_CODEC_OK; | 58 int32_t init_decode_return_code_ = WEBRTC_VIDEO_CODEC_OK; |
61 int32_t decode_return_code_ = WEBRTC_VIDEO_CODEC_OK; | 59 int32_t decode_return_code_ = WEBRTC_VIDEO_CODEC_OK; |
62 DecodedImageCallback* decode_complete_callback_ = nullptr; | 60 DecodedImageCallback* decode_complete_callback_ = nullptr; |
63 int release_count_ = 0; | 61 int release_count_ = 0; |
64 int reset_count_ = 0; | 62 int reset_count_ = 0; |
65 }; | 63 }; |
66 // |fake_decoder_| is owned and released by |fallback_wrapper_|. | 64 CountingFakeDecoder fake_decoder_; |
67 CountingFakeDecoder* fake_decoder_; | |
68 VideoDecoderSoftwareFallbackWrapper fallback_wrapper_; | 65 VideoDecoderSoftwareFallbackWrapper fallback_wrapper_; |
69 }; | 66 }; |
70 | 67 |
71 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, InitializesDecoder) { | 68 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, InitializesDecoder) { |
72 VideoCodec codec = {}; | 69 VideoCodec codec = {}; |
73 fallback_wrapper_.InitDecode(&codec, 2); | 70 fallback_wrapper_.InitDecode(&codec, 2); |
74 EXPECT_EQ(1, fake_decoder_->init_decode_count_); | 71 EXPECT_EQ(1, fake_decoder_.init_decode_count_); |
75 | 72 |
76 EncodedImage encoded_image; | 73 EncodedImage encoded_image; |
77 encoded_image._frameType = kVideoFrameKey; | 74 encoded_image._frameType = kVideoFrameKey; |
78 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); | 75 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); |
79 EXPECT_EQ(1, fake_decoder_->init_decode_count_) | 76 EXPECT_EQ(1, fake_decoder_.init_decode_count_) |
80 << "Initialized decoder should not be reinitialized."; | 77 << "Initialized decoder should not be reinitialized."; |
81 EXPECT_EQ(1, fake_decoder_->decode_count_); | 78 EXPECT_EQ(1, fake_decoder_.decode_count_); |
82 } | 79 } |
83 | 80 |
84 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, | 81 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, |
85 UsesFallbackDecoderAfterOnInitDecodeFailure) { | 82 UsesFallbackDecoderAfterOnInitDecodeFailure) { |
86 VideoCodec codec = {}; | 83 VideoCodec codec = {}; |
87 fake_decoder_->init_decode_return_code_ = | 84 fake_decoder_.init_decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; |
88 WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; | |
89 fallback_wrapper_.InitDecode(&codec, 2); | 85 fallback_wrapper_.InitDecode(&codec, 2); |
90 EXPECT_EQ(1, fake_decoder_->init_decode_count_); | 86 EXPECT_EQ(1, fake_decoder_.init_decode_count_); |
91 | 87 |
92 EncodedImage encoded_image; | 88 EncodedImage encoded_image; |
93 encoded_image._frameType = kVideoFrameKey; | 89 encoded_image._frameType = kVideoFrameKey; |
94 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); | 90 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); |
95 EXPECT_EQ(2, fake_decoder_->init_decode_count_) | 91 EXPECT_EQ(2, fake_decoder_.init_decode_count_) |
96 << "Should have attempted reinitializing the fallback decoder on " | 92 << "Should have attempted reinitializing the fallback decoder on " |
97 "keyframe."; | 93 "keyframe."; |
98 // Unfortunately faking a VP8 frame is hard. Rely on no Decode -> using SW | 94 // Unfortunately faking a VP8 frame is hard. Rely on no Decode -> using SW |
99 // decoder. | 95 // decoder. |
100 EXPECT_EQ(0, fake_decoder_->decode_count_) | 96 EXPECT_EQ(0, fake_decoder_.decode_count_) |
101 << "Decoder used even though no InitDecode had succeeded."; | 97 << "Decoder used even though no InitDecode had succeeded."; |
102 } | 98 } |
103 | 99 |
104 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, | 100 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, |
105 CanRecoverFromSoftwareFallback) { | 101 CanRecoverFromSoftwareFallback) { |
106 VideoCodec codec = {}; | 102 VideoCodec codec = {}; |
107 fallback_wrapper_.InitDecode(&codec, 2); | 103 fallback_wrapper_.InitDecode(&codec, 2); |
108 // Unfortunately faking a VP8 frame is hard. Rely on no Decode -> using SW | 104 // Unfortunately faking a VP8 frame is hard. Rely on no Decode -> using SW |
109 // decoder. | 105 // decoder. |
110 fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; | 106 fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; |
111 EncodedImage encoded_image; | 107 EncodedImage encoded_image; |
112 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); | 108 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); |
113 EXPECT_EQ(1, fake_decoder_->decode_count_); | 109 EXPECT_EQ(1, fake_decoder_.decode_count_); |
114 | 110 |
115 // Fail -> fake_decoder shouldn't be used anymore. | 111 // Fail -> fake_decoder shouldn't be used anymore. |
116 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); | 112 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); |
117 EXPECT_EQ(1, fake_decoder_->decode_count_) | 113 EXPECT_EQ(1, fake_decoder_.decode_count_) |
118 << "Decoder used even though fallback should be active."; | 114 << "Decoder used even though fallback should be active."; |
119 | 115 |
120 // Should be able to recover on a keyframe. | 116 // Should be able to recover on a keyframe. |
121 encoded_image._frameType = kVideoFrameKey; | 117 encoded_image._frameType = kVideoFrameKey; |
122 fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_OK; | 118 fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_OK; |
123 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); | 119 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); |
124 EXPECT_EQ(2, fake_decoder_->decode_count_) | 120 EXPECT_EQ(2, fake_decoder_.decode_count_) |
125 << "Wrapper did not try to decode a keyframe using registered decoder."; | 121 << "Wrapper did not try to decode a keyframe using registered decoder."; |
126 | 122 |
127 encoded_image._frameType = kVideoFrameDelta; | 123 encoded_image._frameType = kVideoFrameDelta; |
128 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); | 124 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); |
129 EXPECT_EQ(3, fake_decoder_->decode_count_) | 125 EXPECT_EQ(3, fake_decoder_.decode_count_) |
130 << "Decoder not used on future delta frames."; | 126 << "Decoder not used on future delta frames."; |
131 } | 127 } |
132 | 128 |
133 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, DoesNotFallbackOnEveryError) { | 129 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, DoesNotFallbackOnEveryError) { |
134 VideoCodec codec = {}; | 130 VideoCodec codec = {}; |
135 fallback_wrapper_.InitDecode(&codec, 2); | 131 fallback_wrapper_.InitDecode(&codec, 2); |
136 fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_ERROR; | 132 fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_ERROR; |
137 EncodedImage encoded_image; | 133 EncodedImage encoded_image; |
138 EXPECT_EQ( | 134 EXPECT_EQ( |
139 fake_decoder_->decode_return_code_, | 135 fake_decoder_.decode_return_code_, |
140 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1)); | 136 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1)); |
141 EXPECT_EQ(1, fake_decoder_->decode_count_); | 137 EXPECT_EQ(1, fake_decoder_.decode_count_); |
142 | 138 |
143 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); | 139 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); |
144 EXPECT_EQ(2, fake_decoder_->decode_count_) | 140 EXPECT_EQ(2, fake_decoder_.decode_count_) |
145 << "Decoder should be active even though previous decode failed."; | 141 << "Decoder should be active even though previous decode failed."; |
146 } | 142 } |
147 | 143 |
148 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, ForwardsReleaseCall) { | 144 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, ForwardsReleaseCall) { |
149 VideoCodec codec = {}; | 145 VideoCodec codec = {}; |
150 fallback_wrapper_.InitDecode(&codec, 2); | 146 fallback_wrapper_.InitDecode(&codec, 2); |
151 fallback_wrapper_.Release(); | 147 fallback_wrapper_.Release(); |
152 EXPECT_EQ(1, fake_decoder_->release_count_); | 148 EXPECT_EQ(1, fake_decoder_.release_count_); |
153 | 149 |
154 fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; | 150 fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; |
155 EncodedImage encoded_image; | 151 EncodedImage encoded_image; |
156 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); | 152 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); |
157 EXPECT_EQ(1, fake_decoder_->release_count_) | 153 EXPECT_EQ(1, fake_decoder_.release_count_) |
158 << "Decoder should not be released during fallback."; | 154 << "Decoder should not be released during fallback."; |
159 fallback_wrapper_.Release(); | 155 fallback_wrapper_.Release(); |
160 EXPECT_EQ(2, fake_decoder_->release_count_); | 156 EXPECT_EQ(2, fake_decoder_.release_count_); |
161 } | 157 } |
162 | 158 |
163 // TODO(pbos): Fake a VP8 frame well enough to actually receive a callback from | 159 // TODO(pbos): Fake a VP8 frame well enough to actually receive a callback from |
164 // the software decoder. | 160 // the software decoder. |
165 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, | 161 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, |
166 ForwardsRegisterDecodeCompleteCallback) { | 162 ForwardsRegisterDecodeCompleteCallback) { |
167 class FakeDecodedImageCallback : public DecodedImageCallback { | 163 class FakeDecodedImageCallback : public DecodedImageCallback { |
168 int32_t Decoded(VideoFrame& decodedImage) override { return 0; } | 164 int32_t Decoded(VideoFrame& decodedImage) override { return 0; } |
169 int32_t Decoded( | 165 int32_t Decoded( |
170 webrtc::VideoFrame& decodedImage, int64_t decode_time_ms) override { | 166 webrtc::VideoFrame& decodedImage, int64_t decode_time_ms) override { |
171 RTC_NOTREACHED(); | 167 RTC_NOTREACHED(); |
172 return -1; | 168 return -1; |
173 } | 169 } |
174 void Decoded(webrtc::VideoFrame& decodedImage, | 170 void Decoded(webrtc::VideoFrame& decodedImage, |
175 rtc::Optional<int32_t> decode_time_ms, | 171 rtc::Optional<int32_t> decode_time_ms, |
176 rtc::Optional<uint8_t> qp) override { | 172 rtc::Optional<uint8_t> qp) override { |
177 RTC_NOTREACHED(); | 173 RTC_NOTREACHED(); |
178 } | 174 } |
179 } callback, callback2; | 175 } callback, callback2; |
180 | 176 |
181 VideoCodec codec = {}; | 177 VideoCodec codec = {}; |
182 fallback_wrapper_.InitDecode(&codec, 2); | 178 fallback_wrapper_.InitDecode(&codec, 2); |
183 fallback_wrapper_.RegisterDecodeCompleteCallback(&callback); | 179 fallback_wrapper_.RegisterDecodeCompleteCallback(&callback); |
184 EXPECT_EQ(&callback, fake_decoder_->decode_complete_callback_); | 180 EXPECT_EQ(&callback, fake_decoder_.decode_complete_callback_); |
185 | 181 |
186 fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; | 182 fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; |
187 EncodedImage encoded_image; | 183 EncodedImage encoded_image; |
188 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); | 184 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); |
189 fallback_wrapper_.RegisterDecodeCompleteCallback(&callback2); | 185 fallback_wrapper_.RegisterDecodeCompleteCallback(&callback2); |
190 EXPECT_EQ(&callback2, fake_decoder_->decode_complete_callback_); | 186 EXPECT_EQ(&callback2, fake_decoder_.decode_complete_callback_); |
191 } | 187 } |
192 | 188 |
193 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, | 189 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, |
194 ReportsFallbackImplementationName) { | 190 ReportsFallbackImplementationName) { |
195 VideoCodec codec = {}; | 191 VideoCodec codec = {}; |
196 fallback_wrapper_.InitDecode(&codec, 2); | 192 fallback_wrapper_.InitDecode(&codec, 2); |
197 | 193 |
198 fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; | 194 fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; |
199 EncodedImage encoded_image; | 195 EncodedImage encoded_image; |
200 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); | 196 fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1); |
201 // Hard coded expected value since libvpx is the software implementation name | 197 // Hard coded expected value since libvpx is the software implementation name |
202 // for VP8. Change accordingly if the underlying implementation does. | 198 // for VP8. Change accordingly if the underlying implementation does. |
203 EXPECT_STREQ("libvpx (fallback from: fake-decoder)", | 199 EXPECT_STREQ("libvpx (fallback from: fake-decoder)", |
204 fallback_wrapper_.ImplementationName()); | 200 fallback_wrapper_.ImplementationName()); |
205 fallback_wrapper_.Release(); | 201 fallback_wrapper_.Release(); |
206 } | 202 } |
207 | 203 |
208 } // namespace webrtc | 204 } // namespace webrtc |
OLD | NEW |