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