pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2014 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 | |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 11 | #include <array> |
kwiberg | 3f55dea | 2016-02-29 05:51:59 -0800 | [diff] [blame] | 12 | #include <memory> |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 13 | #include <vector> |
| 14 | |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 15 | #include "api/video_codecs/sdp_video_format.h" |
| 16 | #include "api/video_codecs/video_encoder_factory.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 17 | #include "common_video/include/video_frame_buffer.h" |
Magnus Jedvert | 46a2765 | 2017-11-13 14:10:02 +0100 | [diff] [blame] | 18 | #include "media/engine/internalencoderfactory.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 19 | #include "media/engine/simulcast_encoder_adapter.h" |
| 20 | #include "modules/video_coding/codecs/vp8/simulcast_test_utility.h" |
| 21 | #include "modules/video_coding/include/video_codec_interface.h" |
Magnus Jedvert | 46a2765 | 2017-11-13 14:10:02 +0100 | [diff] [blame] | 22 | #include "rtc_base/ptr_util.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 23 | #include "test/gmock.h" |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 24 | |
| 25 | namespace webrtc { |
| 26 | namespace testing { |
| 27 | |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 28 | class TestSimulcastEncoderAdapter : public TestVp8Simulcast { |
| 29 | public: |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 30 | TestSimulcastEncoderAdapter() : factory_(new InternalEncoderFactory()) {} |
philipel | cce46fc | 2015-12-21 03:04:49 -0800 | [diff] [blame] | 31 | |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 32 | protected: |
Magnus Jedvert | 46a2765 | 2017-11-13 14:10:02 +0100 | [diff] [blame] | 33 | std::unique_ptr<VP8Encoder> CreateEncoder() override { |
| 34 | return rtc::MakeUnique<SimulcastEncoderAdapter>(factory_.get()); |
magjed | 6cc2561 | 2017-07-10 03:26:36 -0700 | [diff] [blame] | 35 | } |
Magnus Jedvert | 46a2765 | 2017-11-13 14:10:02 +0100 | [diff] [blame] | 36 | std::unique_ptr<VP8Decoder> CreateDecoder() override { |
| 37 | return VP8Decoder::Create(); |
| 38 | } |
magjed | 6cc2561 | 2017-07-10 03:26:36 -0700 | [diff] [blame] | 39 | |
| 40 | private: |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 41 | std::unique_ptr<VideoEncoderFactory> factory_; |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 42 | }; |
| 43 | |
| 44 | TEST_F(TestSimulcastEncoderAdapter, TestKeyFrameRequestsOnAllStreams) { |
| 45 | TestVp8Simulcast::TestKeyFrameRequestsOnAllStreams(); |
| 46 | } |
| 47 | |
| 48 | TEST_F(TestSimulcastEncoderAdapter, TestPaddingAllStreams) { |
| 49 | TestVp8Simulcast::TestPaddingAllStreams(); |
| 50 | } |
| 51 | |
| 52 | TEST_F(TestSimulcastEncoderAdapter, TestPaddingTwoStreams) { |
| 53 | TestVp8Simulcast::TestPaddingTwoStreams(); |
| 54 | } |
| 55 | |
| 56 | TEST_F(TestSimulcastEncoderAdapter, TestPaddingTwoStreamsOneMaxedOut) { |
| 57 | TestVp8Simulcast::TestPaddingTwoStreamsOneMaxedOut(); |
| 58 | } |
| 59 | |
| 60 | TEST_F(TestSimulcastEncoderAdapter, TestPaddingOneStream) { |
| 61 | TestVp8Simulcast::TestPaddingOneStream(); |
| 62 | } |
| 63 | |
| 64 | TEST_F(TestSimulcastEncoderAdapter, TestPaddingOneStreamTwoMaxedOut) { |
| 65 | TestVp8Simulcast::TestPaddingOneStreamTwoMaxedOut(); |
| 66 | } |
| 67 | |
| 68 | TEST_F(TestSimulcastEncoderAdapter, TestSendAllStreams) { |
| 69 | TestVp8Simulcast::TestSendAllStreams(); |
| 70 | } |
| 71 | |
| 72 | TEST_F(TestSimulcastEncoderAdapter, TestDisablingStreams) { |
| 73 | TestVp8Simulcast::TestDisablingStreams(); |
| 74 | } |
| 75 | |
Seth Hampson | 46e31ba | 2018-01-18 10:39:54 -0800 | [diff] [blame] | 76 | TEST_F(TestSimulcastEncoderAdapter, TestActiveStreams) { |
| 77 | TestVp8Simulcast::TestActiveStreams(); |
| 78 | } |
| 79 | |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 80 | TEST_F(TestSimulcastEncoderAdapter, TestSwitchingToOneStream) { |
| 81 | TestVp8Simulcast::TestSwitchingToOneStream(); |
| 82 | } |
| 83 | |
| 84 | TEST_F(TestSimulcastEncoderAdapter, TestSwitchingToOneOddStream) { |
| 85 | TestVp8Simulcast::TestSwitchingToOneOddStream(); |
| 86 | } |
| 87 | |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 88 | TEST_F(TestSimulcastEncoderAdapter, TestStrideEncodeDecode) { |
| 89 | TestVp8Simulcast::TestStrideEncodeDecode(); |
| 90 | } |
| 91 | |
| 92 | TEST_F(TestSimulcastEncoderAdapter, TestSaptioTemporalLayers333PatternEncoder) { |
| 93 | TestVp8Simulcast::TestSaptioTemporalLayers333PatternEncoder(); |
| 94 | } |
| 95 | |
| 96 | TEST_F(TestSimulcastEncoderAdapter, TestSpatioTemporalLayers321PatternEncoder) { |
| 97 | TestVp8Simulcast::TestSpatioTemporalLayers321PatternEncoder(); |
| 98 | } |
| 99 | |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 100 | class MockVideoEncoder; |
| 101 | |
| 102 | class MockVideoEncoderFactory : public VideoEncoderFactory { |
| 103 | public: |
| 104 | std::vector<SdpVideoFormat> GetSupportedFormats() const override; |
| 105 | |
| 106 | std::unique_ptr<VideoEncoder> CreateVideoEncoder( |
| 107 | const SdpVideoFormat& format) override; |
| 108 | |
| 109 | CodecInfo QueryVideoEncoder(const SdpVideoFormat& format) const override; |
| 110 | |
| 111 | const std::vector<MockVideoEncoder*>& encoders() const; |
| 112 | void SetEncoderNames(const std::vector<const char*>& encoder_names); |
| 113 | void set_init_encode_return_value(int32_t value); |
| 114 | |
| 115 | void DestroyVideoEncoder(VideoEncoder* encoder); |
| 116 | |
| 117 | private: |
| 118 | int32_t init_encode_return_value_ = 0; |
| 119 | std::vector<MockVideoEncoder*> encoders_; |
| 120 | std::vector<const char*> encoder_names_; |
| 121 | }; |
| 122 | |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 123 | class MockVideoEncoder : public VideoEncoder { |
| 124 | public: |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 125 | explicit MockVideoEncoder(MockVideoEncoderFactory* factory) |
Erik Språng | 82fad3d | 2018-03-21 09:57:23 +0100 | [diff] [blame] | 126 | : factory_(factory), callback_(nullptr) {} |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 127 | |
nisse | ef8b61e | 2016-04-29 06:09:15 -0700 | [diff] [blame] | 128 | // TODO(nisse): Valid overrides commented out, because the gmock |
| 129 | // methods don't use any override declarations, and we want to avoid |
| 130 | // warnings from -Winconsistent-missing-override. See |
| 131 | // http://crbug.com/428099. |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 132 | int32_t InitEncode(const VideoCodec* codecSettings, |
| 133 | int32_t numberOfCores, |
nisse | ef8b61e | 2016-04-29 06:09:15 -0700 | [diff] [blame] | 134 | size_t maxPayloadSize) /* override */ { |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 135 | codec_ = *codecSettings; |
noahric | e5ba75a | 2016-12-12 13:08:27 -0800 | [diff] [blame] | 136 | return init_encode_return_value_; |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 137 | } |
| 138 | |
noahric | fe3654d | 2016-07-01 09:05:54 -0700 | [diff] [blame] | 139 | MOCK_METHOD3( |
| 140 | Encode, |
| 141 | int32_t(const VideoFrame& inputImage, |
| 142 | const CodecSpecificInfo* codecSpecificInfo, |
| 143 | const std::vector<FrameType>* frame_types) /* override */); |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 144 | |
pbos | 65e15ba | 2015-10-15 10:52:15 -0700 | [diff] [blame] | 145 | int32_t RegisterEncodeCompleteCallback( |
nisse | ef8b61e | 2016-04-29 06:09:15 -0700 | [diff] [blame] | 146 | EncodedImageCallback* callback) /* override */ { |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 147 | callback_ = callback; |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 148 | return 0; |
| 149 | } |
| 150 | |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 151 | MOCK_METHOD0(Release, int32_t()); |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 152 | |
Erik Språng | 08127a9 | 2016-11-16 16:41:30 +0100 | [diff] [blame] | 153 | int32_t SetRateAllocation(const BitrateAllocation& bitrate_allocation, |
| 154 | uint32_t framerate) { |
| 155 | last_set_bitrate_ = bitrate_allocation; |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 156 | return 0; |
| 157 | } |
| 158 | |
philipel | cce46fc | 2015-12-21 03:04:49 -0800 | [diff] [blame] | 159 | MOCK_METHOD2(SetChannelParameters, int32_t(uint32_t packetLoss, int64_t rtt)); |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 160 | |
nisse | ef8b61e | 2016-04-29 06:09:15 -0700 | [diff] [blame] | 161 | bool SupportsNativeHandle() const /* override */ { |
| 162 | return supports_native_handle_; |
| 163 | } |
pbos | 65e15ba | 2015-10-15 10:52:15 -0700 | [diff] [blame] | 164 | |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 165 | virtual ~MockVideoEncoder() { factory_->DestroyVideoEncoder(this); } |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 166 | |
| 167 | const VideoCodec& codec() const { return codec_; } |
| 168 | |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 169 | void SendEncodedImage(int width, int height) { |
| 170 | // Sends a fake image of the given width/height. |
| 171 | EncodedImage image; |
| 172 | image._encodedWidth = width; |
| 173 | image._encodedHeight = height; |
sergeyu | 2cb155a | 2016-11-04 11:39:29 -0700 | [diff] [blame] | 174 | CodecSpecificInfo codec_specific_info; |
| 175 | memset(&codec_specific_info, 0, sizeof(codec_specific_info)); |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 176 | callback_->OnEncodedImage(image, &codec_specific_info, nullptr); |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 177 | } |
| 178 | |
pbos | 65e15ba | 2015-10-15 10:52:15 -0700 | [diff] [blame] | 179 | void set_supports_native_handle(bool enabled) { |
| 180 | supports_native_handle_ = enabled; |
| 181 | } |
noahric | e5ba75a | 2016-12-12 13:08:27 -0800 | [diff] [blame] | 182 | |
| 183 | void set_init_encode_return_value(int32_t value) { |
| 184 | init_encode_return_value_ = value; |
| 185 | } |
| 186 | |
Erik Språng | 08127a9 | 2016-11-16 16:41:30 +0100 | [diff] [blame] | 187 | BitrateAllocation last_set_bitrate() const { return last_set_bitrate_; } |
pbos | 65e15ba | 2015-10-15 10:52:15 -0700 | [diff] [blame] | 188 | |
Peter Boström | a5dec16 | 2016-01-20 15:53:55 +0100 | [diff] [blame] | 189 | MOCK_CONST_METHOD0(ImplementationName, const char*()); |
| 190 | |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 191 | private: |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 192 | MockVideoEncoderFactory* const factory_; |
pbos | 65e15ba | 2015-10-15 10:52:15 -0700 | [diff] [blame] | 193 | bool supports_native_handle_ = false; |
noahric | e5ba75a | 2016-12-12 13:08:27 -0800 | [diff] [blame] | 194 | int32_t init_encode_return_value_ = 0; |
Erik Språng | 08127a9 | 2016-11-16 16:41:30 +0100 | [diff] [blame] | 195 | BitrateAllocation last_set_bitrate_; |
noahric | fac0ff0 | 2016-09-09 10:27:15 -0700 | [diff] [blame] | 196 | |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 197 | VideoCodec codec_; |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 198 | EncodedImageCallback* callback_; |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 199 | }; |
| 200 | |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 201 | std::vector<SdpVideoFormat> MockVideoEncoderFactory::GetSupportedFormats() |
| 202 | const { |
| 203 | std::vector<SdpVideoFormat> formats = {SdpVideoFormat("VP8")}; |
| 204 | return formats; |
| 205 | } |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 206 | |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 207 | std::unique_ptr<VideoEncoder> MockVideoEncoderFactory::CreateVideoEncoder( |
| 208 | const SdpVideoFormat& format) { |
| 209 | std::unique_ptr<MockVideoEncoder> encoder( |
| 210 | new ::testing::NiceMock<MockVideoEncoder>(this)); |
| 211 | encoder->set_init_encode_return_value(init_encode_return_value_); |
| 212 | const char* encoder_name = encoder_names_.empty() |
| 213 | ? "codec_implementation_name" |
| 214 | : encoder_names_[encoders_.size()]; |
| 215 | ON_CALL(*encoder, ImplementationName()).WillByDefault(Return(encoder_name)); |
| 216 | encoders_.push_back(encoder.get()); |
| 217 | return encoder; |
| 218 | } |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 219 | |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 220 | void MockVideoEncoderFactory::DestroyVideoEncoder(VideoEncoder* encoder) { |
| 221 | for (size_t i = 0; i < encoders_.size(); ++i) { |
| 222 | if (encoders_[i] == encoder) { |
| 223 | encoders_.erase(encoders_.begin() + i); |
| 224 | break; |
Zhi Huang | aea84f5 | 2017-11-16 18:46:27 +0000 | [diff] [blame] | 225 | } |
Zhi Huang | aea84f5 | 2017-11-16 18:46:27 +0000 | [diff] [blame] | 226 | } |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 227 | } |
Zhi Huang | aea84f5 | 2017-11-16 18:46:27 +0000 | [diff] [blame] | 228 | |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 229 | VideoEncoderFactory::CodecInfo MockVideoEncoderFactory::QueryVideoEncoder( |
| 230 | const SdpVideoFormat& format) const { |
| 231 | return CodecInfo(); |
| 232 | } |
Zhi Huang | aea84f5 | 2017-11-16 18:46:27 +0000 | [diff] [blame] | 233 | |
Magnus Jedvert | df4883d | 2017-11-17 14:44:55 +0100 | [diff] [blame] | 234 | const std::vector<MockVideoEncoder*>& MockVideoEncoderFactory::encoders() |
| 235 | const { |
| 236 | return encoders_; |
| 237 | } |
| 238 | void MockVideoEncoderFactory::SetEncoderNames( |
| 239 | const std::vector<const char*>& encoder_names) { |
| 240 | encoder_names_ = encoder_names; |
| 241 | } |
| 242 | void MockVideoEncoderFactory::set_init_encode_return_value(int32_t value) { |
| 243 | init_encode_return_value_ = value; |
| 244 | } |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 245 | |
| 246 | class TestSimulcastEncoderAdapterFakeHelper { |
| 247 | public: |
| 248 | TestSimulcastEncoderAdapterFakeHelper() |
| 249 | : factory_(new MockVideoEncoderFactory()) {} |
| 250 | |
| 251 | // Can only be called once as the SimulcastEncoderAdapter will take the |
| 252 | // ownership of |factory_|. |
| 253 | VP8Encoder* CreateMockEncoderAdapter() { |
magjed | 6cc2561 | 2017-07-10 03:26:36 -0700 | [diff] [blame] | 254 | return new SimulcastEncoderAdapter(factory_.get()); |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 255 | } |
| 256 | |
pkasting@chromium.org | 16825b1 | 2015-01-12 21:51:21 +0000 | [diff] [blame] | 257 | void ExpectCallSetChannelParameters(uint32_t packetLoss, int64_t rtt) { |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 258 | EXPECT_TRUE(!factory_->encoders().empty()); |
| 259 | for (size_t i = 0; i < factory_->encoders().size(); ++i) { |
| 260 | EXPECT_CALL(*factory_->encoders()[i], |
philipel | cce46fc | 2015-12-21 03:04:49 -0800 | [diff] [blame] | 261 | SetChannelParameters(packetLoss, rtt)) |
| 262 | .Times(1); |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 263 | } |
| 264 | } |
| 265 | |
magjed | 6cc2561 | 2017-07-10 03:26:36 -0700 | [diff] [blame] | 266 | MockVideoEncoderFactory* factory() { return factory_.get(); } |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 267 | |
| 268 | private: |
magjed | 6cc2561 | 2017-07-10 03:26:36 -0700 | [diff] [blame] | 269 | std::unique_ptr<MockVideoEncoderFactory> factory_; |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 270 | }; |
| 271 | |
| 272 | static const int kTestTemporalLayerProfile[3] = {3, 2, 1}; |
| 273 | |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 274 | class TestSimulcastEncoderAdapterFake : public ::testing::Test, |
| 275 | public EncodedImageCallback { |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 276 | public: |
| 277 | TestSimulcastEncoderAdapterFake() |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 278 | : helper_(new TestSimulcastEncoderAdapterFakeHelper()), |
| 279 | adapter_(helper_->CreateMockEncoderAdapter()), |
| 280 | last_encoded_image_width_(-1), |
| 281 | last_encoded_image_height_(-1), |
| 282 | last_encoded_image_simulcast_index_(-1) {} |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 283 | virtual ~TestSimulcastEncoderAdapterFake() { |
| 284 | if (adapter_) { |
| 285 | adapter_->Release(); |
| 286 | } |
| 287 | } |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 288 | |
Sergey Ulanov | 525df3f | 2016-08-02 17:46:41 -0700 | [diff] [blame] | 289 | Result OnEncodedImage(const EncodedImage& encoded_image, |
| 290 | const CodecSpecificInfo* codec_specific_info, |
| 291 | const RTPFragmentationHeader* fragmentation) override { |
| 292 | last_encoded_image_width_ = encoded_image._encodedWidth; |
| 293 | last_encoded_image_height_ = encoded_image._encodedHeight; |
| 294 | if (codec_specific_info) { |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 295 | last_encoded_image_simulcast_index_ = |
Sergey Ulanov | 525df3f | 2016-08-02 17:46:41 -0700 | [diff] [blame] | 296 | codec_specific_info->codecSpecific.VP8.simulcastIdx; |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 297 | } |
Sergey Ulanov | 525df3f | 2016-08-02 17:46:41 -0700 | [diff] [blame] | 298 | return Result(Result::OK, encoded_image._timeStamp); |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 299 | } |
| 300 | |
| 301 | bool GetLastEncodedImageInfo(int* out_width, |
| 302 | int* out_height, |
| 303 | int* out_simulcast_index) { |
| 304 | if (last_encoded_image_width_ == -1) { |
| 305 | return false; |
| 306 | } |
| 307 | *out_width = last_encoded_image_width_; |
| 308 | *out_height = last_encoded_image_height_; |
| 309 | *out_simulcast_index = last_encoded_image_simulcast_index_; |
| 310 | return true; |
| 311 | } |
| 312 | |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 313 | void SetupCodec() { |
| 314 | TestVp8Simulcast::DefaultSettings( |
philipel | cce46fc | 2015-12-21 03:04:49 -0800 | [diff] [blame] | 315 | &codec_, static_cast<const int*>(kTestTemporalLayerProfile)); |
Erik Språng | 82fad3d | 2018-03-21 09:57:23 +0100 | [diff] [blame] | 316 | rate_allocator_.reset(new SimulcastRateAllocator(codec_)); |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 317 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 318 | adapter_->RegisterEncodeCompleteCallback(this); |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 319 | } |
| 320 | |
| 321 | void VerifyCodec(const VideoCodec& ref, int stream_index) { |
| 322 | const VideoCodec& target = |
| 323 | helper_->factory()->encoders()[stream_index]->codec(); |
| 324 | EXPECT_EQ(ref.codecType, target.codecType); |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 325 | EXPECT_EQ(ref.plType, target.plType); |
| 326 | EXPECT_EQ(ref.width, target.width); |
| 327 | EXPECT_EQ(ref.height, target.height); |
| 328 | EXPECT_EQ(ref.startBitrate, target.startBitrate); |
| 329 | EXPECT_EQ(ref.maxBitrate, target.maxBitrate); |
| 330 | EXPECT_EQ(ref.minBitrate, target.minBitrate); |
| 331 | EXPECT_EQ(ref.maxFramerate, target.maxFramerate); |
hta | 257dc39 | 2016-10-25 09:05:06 -0700 | [diff] [blame] | 332 | EXPECT_EQ(ref.VP8().complexity, target.VP8().complexity); |
| 333 | EXPECT_EQ(ref.VP8().resilience, target.VP8().resilience); |
| 334 | EXPECT_EQ(ref.VP8().numberOfTemporalLayers, |
| 335 | target.VP8().numberOfTemporalLayers); |
| 336 | EXPECT_EQ(ref.VP8().denoisingOn, target.VP8().denoisingOn); |
hta | 257dc39 | 2016-10-25 09:05:06 -0700 | [diff] [blame] | 337 | EXPECT_EQ(ref.VP8().automaticResizeOn, target.VP8().automaticResizeOn); |
| 338 | EXPECT_EQ(ref.VP8().frameDroppingOn, target.VP8().frameDroppingOn); |
| 339 | EXPECT_EQ(ref.VP8().keyFrameInterval, target.VP8().keyFrameInterval); |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 340 | EXPECT_EQ(ref.qpMax, target.qpMax); |
| 341 | EXPECT_EQ(0, target.numberOfSimulcastStreams); |
| 342 | EXPECT_EQ(ref.mode, target.mode); |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 343 | |
| 344 | // No need to compare simulcastStream as numberOfSimulcastStreams should |
| 345 | // always be 0. |
| 346 | } |
| 347 | |
| 348 | void InitRefCodec(int stream_index, VideoCodec* ref_codec) { |
| 349 | *ref_codec = codec_; |
hta | 257dc39 | 2016-10-25 09:05:06 -0700 | [diff] [blame] | 350 | ref_codec->VP8()->numberOfTemporalLayers = |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 351 | kTestTemporalLayerProfile[stream_index]; |
| 352 | ref_codec->width = codec_.simulcastStream[stream_index].width; |
| 353 | ref_codec->height = codec_.simulcastStream[stream_index].height; |
| 354 | ref_codec->maxBitrate = codec_.simulcastStream[stream_index].maxBitrate; |
| 355 | ref_codec->minBitrate = codec_.simulcastStream[stream_index].minBitrate; |
| 356 | ref_codec->qpMax = codec_.simulcastStream[stream_index].qpMax; |
| 357 | } |
| 358 | |
| 359 | void VerifyCodecSettings() { |
| 360 | EXPECT_EQ(3u, helper_->factory()->encoders().size()); |
| 361 | VideoCodec ref_codec; |
| 362 | |
| 363 | // stream 0, the lowest resolution stream. |
| 364 | InitRefCodec(0, &ref_codec); |
| 365 | ref_codec.qpMax = 45; |
hta | 257dc39 | 2016-10-25 09:05:06 -0700 | [diff] [blame] | 366 | ref_codec.VP8()->complexity = webrtc::kComplexityHigher; |
| 367 | ref_codec.VP8()->denoisingOn = false; |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 368 | ref_codec.startBitrate = 100; // Should equal to the target bitrate. |
| 369 | VerifyCodec(ref_codec, 0); |
| 370 | |
| 371 | // stream 1 |
| 372 | InitRefCodec(1, &ref_codec); |
hta | 257dc39 | 2016-10-25 09:05:06 -0700 | [diff] [blame] | 373 | ref_codec.VP8()->denoisingOn = false; |
Noah Richards | 67b635a | 2015-05-22 14:12:10 -0700 | [diff] [blame] | 374 | // The start bitrate (300kbit) minus what we have for the lower layers |
| 375 | // (100kbit). |
| 376 | ref_codec.startBitrate = 200; |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 377 | VerifyCodec(ref_codec, 1); |
| 378 | |
| 379 | // stream 2, the biggest resolution stream. |
| 380 | InitRefCodec(2, &ref_codec); |
Noah Richards | 67b635a | 2015-05-22 14:12:10 -0700 | [diff] [blame] | 381 | // We don't have enough bits to send this, so the adapter should have |
| 382 | // configured it to use the min bitrate for this layer (600kbit) but turn |
| 383 | // off sending. |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 384 | ref_codec.startBitrate = 600; |
| 385 | VerifyCodec(ref_codec, 2); |
| 386 | } |
| 387 | |
| 388 | protected: |
kwiberg | 3f55dea | 2016-02-29 05:51:59 -0800 | [diff] [blame] | 389 | std::unique_ptr<TestSimulcastEncoderAdapterFakeHelper> helper_; |
| 390 | std::unique_ptr<VP8Encoder> adapter_; |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 391 | VideoCodec codec_; |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 392 | int last_encoded_image_width_; |
| 393 | int last_encoded_image_height_; |
| 394 | int last_encoded_image_simulcast_index_; |
Erik Språng | 08127a9 | 2016-11-16 16:41:30 +0100 | [diff] [blame] | 395 | std::unique_ptr<SimulcastRateAllocator> rate_allocator_; |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 396 | }; |
| 397 | |
| 398 | TEST_F(TestSimulcastEncoderAdapterFake, InitEncode) { |
| 399 | SetupCodec(); |
| 400 | VerifyCodecSettings(); |
| 401 | } |
| 402 | |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 403 | TEST_F(TestSimulcastEncoderAdapterFake, ReleaseWithoutInitEncode) { |
| 404 | EXPECT_EQ(0, adapter_->Release()); |
| 405 | } |
| 406 | |
| 407 | TEST_F(TestSimulcastEncoderAdapterFake, Reinit) { |
| 408 | SetupCodec(); |
| 409 | EXPECT_EQ(0, adapter_->Release()); |
| 410 | |
| 411 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 412 | } |
| 413 | |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 414 | TEST_F(TestSimulcastEncoderAdapterFake, SetChannelParameters) { |
| 415 | SetupCodec(); |
| 416 | const uint32_t packetLoss = 5; |
pkasting@chromium.org | 16825b1 | 2015-01-12 21:51:21 +0000 | [diff] [blame] | 417 | const int64_t rtt = 30; |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 418 | helper_->ExpectCallSetChannelParameters(packetLoss, rtt); |
| 419 | adapter_->SetChannelParameters(packetLoss, rtt); |
| 420 | } |
| 421 | |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 422 | TEST_F(TestSimulcastEncoderAdapterFake, EncodedCallbackForDifferentEncoders) { |
| 423 | SetupCodec(); |
| 424 | |
Peter Boström | 5d0379d | 2015-10-06 14:04:51 +0200 | [diff] [blame] | 425 | // Set bitrates so that we send all layers. |
Erik Språng | 08127a9 | 2016-11-16 16:41:30 +0100 | [diff] [blame] | 426 | adapter_->SetRateAllocation(rate_allocator_->GetAllocation(1200, 30), 30); |
Peter Boström | 5d0379d | 2015-10-06 14:04:51 +0200 | [diff] [blame] | 427 | |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 428 | // At this point, the simulcast encoder adapter should have 3 streams: HD, |
| 429 | // quarter HD, and quarter quarter HD. We're going to mostly ignore the exact |
| 430 | // resolutions, to test that the adapter forwards on the correct resolution |
| 431 | // and simulcast index values, going only off the encoder that generates the |
| 432 | // image. |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 433 | std::vector<MockVideoEncoder*> encoders = helper_->factory()->encoders(); |
| 434 | ASSERT_EQ(3u, encoders.size()); |
| 435 | encoders[0]->SendEncodedImage(1152, 704); |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 436 | int width; |
| 437 | int height; |
| 438 | int simulcast_index; |
| 439 | EXPECT_TRUE(GetLastEncodedImageInfo(&width, &height, &simulcast_index)); |
| 440 | EXPECT_EQ(1152, width); |
| 441 | EXPECT_EQ(704, height); |
| 442 | EXPECT_EQ(0, simulcast_index); |
| 443 | |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 444 | encoders[1]->SendEncodedImage(300, 620); |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 445 | EXPECT_TRUE(GetLastEncodedImageInfo(&width, &height, &simulcast_index)); |
| 446 | EXPECT_EQ(300, width); |
| 447 | EXPECT_EQ(620, height); |
| 448 | EXPECT_EQ(1, simulcast_index); |
| 449 | |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 450 | encoders[2]->SendEncodedImage(120, 240); |
Noah Richards | 41ee1ea | 2015-04-15 09:24:26 -0700 | [diff] [blame] | 451 | EXPECT_TRUE(GetLastEncodedImageInfo(&width, &height, &simulcast_index)); |
| 452 | EXPECT_EQ(120, width); |
| 453 | EXPECT_EQ(240, height); |
| 454 | EXPECT_EQ(2, simulcast_index); |
| 455 | } |
| 456 | |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 457 | // This test verifies that the underlying encoders are reused, when the adapter |
| 458 | // is reinited with different number of simulcast streams. It further checks |
| 459 | // that the allocated encoders are reused in the same order as before, starting |
| 460 | // with the lowest stream. |
| 461 | TEST_F(TestSimulcastEncoderAdapterFake, ReusesEncodersInOrder) { |
| 462 | // Set up common settings for three streams. |
| 463 | TestVp8Simulcast::DefaultSettings( |
| 464 | &codec_, static_cast<const int*>(kTestTemporalLayerProfile)); |
Erik Språng | 82fad3d | 2018-03-21 09:57:23 +0100 | [diff] [blame] | 465 | rate_allocator_.reset(new SimulcastRateAllocator(codec_)); |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 466 | adapter_->RegisterEncodeCompleteCallback(this); |
| 467 | |
| 468 | // Input data. |
| 469 | rtc::scoped_refptr<VideoFrameBuffer> buffer(I420Buffer::Create(1280, 720)); |
| 470 | VideoFrame input_frame(buffer, 100, 1000, kVideoRotation_180); |
| 471 | std::vector<FrameType> frame_types; |
| 472 | |
| 473 | // Encode with three streams. |
| 474 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 475 | VerifyCodecSettings(); |
| 476 | std::vector<MockVideoEncoder*> original_encoders = |
| 477 | helper_->factory()->encoders(); |
| 478 | ASSERT_EQ(3u, original_encoders.size()); |
| 479 | EXPECT_CALL(*original_encoders[0], Encode(_, _, _)) |
| 480 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 481 | EXPECT_CALL(*original_encoders[1], Encode(_, _, _)) |
| 482 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 483 | EXPECT_CALL(*original_encoders[2], Encode(_, _, _)) |
| 484 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 485 | frame_types.resize(3, kVideoFrameKey); |
| 486 | EXPECT_EQ(0, adapter_->Encode(input_frame, nullptr, &frame_types)); |
| 487 | EXPECT_CALL(*original_encoders[0], Release()) |
| 488 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 489 | EXPECT_CALL(*original_encoders[1], Release()) |
| 490 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 491 | EXPECT_CALL(*original_encoders[2], Release()) |
| 492 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 493 | EXPECT_EQ(0, adapter_->Release()); |
| 494 | |
| 495 | // Encode with two streams. |
| 496 | codec_.width /= 2; |
| 497 | codec_.height /= 2; |
| 498 | codec_.numberOfSimulcastStreams = 2; |
| 499 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 500 | std::vector<MockVideoEncoder*> new_encoders = helper_->factory()->encoders(); |
| 501 | ASSERT_EQ(2u, new_encoders.size()); |
| 502 | ASSERT_EQ(original_encoders[0], new_encoders[0]); |
| 503 | EXPECT_CALL(*original_encoders[0], Encode(_, _, _)) |
| 504 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 505 | ASSERT_EQ(original_encoders[1], new_encoders[1]); |
| 506 | EXPECT_CALL(*original_encoders[1], Encode(_, _, _)) |
| 507 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 508 | frame_types.resize(2, kVideoFrameKey); |
| 509 | EXPECT_EQ(0, adapter_->Encode(input_frame, nullptr, &frame_types)); |
| 510 | EXPECT_CALL(*original_encoders[0], Release()) |
| 511 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 512 | EXPECT_CALL(*original_encoders[1], Release()) |
| 513 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 514 | EXPECT_EQ(0, adapter_->Release()); |
| 515 | |
| 516 | // Encode with single stream. |
| 517 | codec_.width /= 2; |
| 518 | codec_.height /= 2; |
| 519 | codec_.numberOfSimulcastStreams = 1; |
| 520 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 521 | new_encoders = helper_->factory()->encoders(); |
| 522 | ASSERT_EQ(1u, new_encoders.size()); |
| 523 | ASSERT_EQ(original_encoders[0], new_encoders[0]); |
| 524 | EXPECT_CALL(*original_encoders[0], Encode(_, _, _)) |
| 525 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 526 | frame_types.resize(1, kVideoFrameKey); |
| 527 | EXPECT_EQ(0, adapter_->Encode(input_frame, nullptr, &frame_types)); |
| 528 | EXPECT_CALL(*original_encoders[0], Release()) |
| 529 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 530 | EXPECT_EQ(0, adapter_->Release()); |
| 531 | |
| 532 | // Encode with three streams, again. |
| 533 | codec_.width *= 4; |
| 534 | codec_.height *= 4; |
| 535 | codec_.numberOfSimulcastStreams = 3; |
| 536 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 537 | new_encoders = helper_->factory()->encoders(); |
| 538 | ASSERT_EQ(3u, new_encoders.size()); |
| 539 | // The first encoder is reused. |
| 540 | ASSERT_EQ(original_encoders[0], new_encoders[0]); |
| 541 | EXPECT_CALL(*original_encoders[0], Encode(_, _, _)) |
| 542 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 543 | // The second and third encoders are new. |
| 544 | EXPECT_CALL(*new_encoders[1], Encode(_, _, _)) |
| 545 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 546 | EXPECT_CALL(*new_encoders[2], Encode(_, _, _)) |
| 547 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 548 | frame_types.resize(3, kVideoFrameKey); |
| 549 | EXPECT_EQ(0, adapter_->Encode(input_frame, nullptr, &frame_types)); |
| 550 | EXPECT_CALL(*original_encoders[0], Release()) |
| 551 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 552 | EXPECT_CALL(*new_encoders[1], Release()) |
| 553 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 554 | EXPECT_CALL(*new_encoders[2], Release()) |
| 555 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_OK)); |
| 556 | EXPECT_EQ(0, adapter_->Release()); |
| 557 | } |
| 558 | |
| 559 | TEST_F(TestSimulcastEncoderAdapterFake, DoesNotLeakEncoders) { |
| 560 | SetupCodec(); |
| 561 | VerifyCodecSettings(); |
| 562 | |
| 563 | EXPECT_EQ(3u, helper_->factory()->encoders().size()); |
| 564 | |
| 565 | // The adapter should destroy all encoders it has allocated. Since |
| 566 | // |helper_->factory()| is owned by |adapter_|, however, we need to rely on |
| 567 | // lsan to find leaks here. |
| 568 | EXPECT_EQ(0, adapter_->Release()); |
| 569 | adapter_.reset(); |
| 570 | } |
| 571 | |
| 572 | // This test verifies that an adapter reinit with the same codec settings as |
| 573 | // before does not change the underlying encoder codec settings. |
| 574 | TEST_F(TestSimulcastEncoderAdapterFake, ReinitDoesNotReorderEncoderSettings) { |
| 575 | SetupCodec(); |
| 576 | VerifyCodecSettings(); |
| 577 | |
| 578 | // Capture current codec settings. |
| 579 | std::vector<MockVideoEncoder*> encoders = helper_->factory()->encoders(); |
| 580 | ASSERT_EQ(3u, encoders.size()); |
| 581 | std::array<VideoCodec, 3> codecs_before; |
| 582 | for (int i = 0; i < 3; ++i) { |
| 583 | codecs_before[i] = encoders[i]->codec(); |
| 584 | } |
| 585 | |
| 586 | // Reinitialize and verify that the new codec settings are the same. |
| 587 | EXPECT_EQ(0, adapter_->Release()); |
| 588 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 589 | for (int i = 0; i < 3; ++i) { |
| 590 | const VideoCodec& codec_before = codecs_before[i]; |
| 591 | const VideoCodec& codec_after = encoders[i]->codec(); |
| 592 | |
| 593 | // webrtc::VideoCodec does not implement operator==. |
| 594 | EXPECT_EQ(codec_before.codecType, codec_after.codecType); |
| 595 | EXPECT_EQ(codec_before.plType, codec_after.plType); |
| 596 | EXPECT_EQ(codec_before.width, codec_after.width); |
| 597 | EXPECT_EQ(codec_before.height, codec_after.height); |
| 598 | EXPECT_EQ(codec_before.startBitrate, codec_after.startBitrate); |
| 599 | EXPECT_EQ(codec_before.maxBitrate, codec_after.maxBitrate); |
| 600 | EXPECT_EQ(codec_before.minBitrate, codec_after.minBitrate); |
| 601 | EXPECT_EQ(codec_before.targetBitrate, codec_after.targetBitrate); |
| 602 | EXPECT_EQ(codec_before.maxFramerate, codec_after.maxFramerate); |
| 603 | EXPECT_EQ(codec_before.qpMax, codec_after.qpMax); |
| 604 | EXPECT_EQ(codec_before.numberOfSimulcastStreams, |
| 605 | codec_after.numberOfSimulcastStreams); |
| 606 | EXPECT_EQ(codec_before.mode, codec_after.mode); |
| 607 | EXPECT_EQ(codec_before.expect_encode_from_texture, |
| 608 | codec_after.expect_encode_from_texture); |
| 609 | } |
| 610 | } |
| 611 | |
| 612 | // This test is similar to the one above, except that it tests the simulcastIdx |
| 613 | // from the CodecSpecificInfo that is connected to an encoded frame. The |
| 614 | // PayloadRouter demuxes the incoming encoded frames on different RTP modules |
| 615 | // using the simulcastIdx, so it's important that there is no corresponding |
| 616 | // encoder reordering in between adapter reinits as this would lead to PictureID |
| 617 | // discontinuities. |
| 618 | TEST_F(TestSimulcastEncoderAdapterFake, ReinitDoesNotReorderFrameSimulcastIdx) { |
| 619 | SetupCodec(); |
| 620 | adapter_->SetRateAllocation(rate_allocator_->GetAllocation(1200, 30), 30); |
| 621 | VerifyCodecSettings(); |
| 622 | |
| 623 | // Send frames on all streams. |
| 624 | std::vector<MockVideoEncoder*> encoders = helper_->factory()->encoders(); |
| 625 | ASSERT_EQ(3u, encoders.size()); |
| 626 | encoders[0]->SendEncodedImage(1152, 704); |
| 627 | int width; |
| 628 | int height; |
| 629 | int simulcast_index; |
| 630 | EXPECT_TRUE(GetLastEncodedImageInfo(&width, &height, &simulcast_index)); |
| 631 | EXPECT_EQ(0, simulcast_index); |
| 632 | |
| 633 | encoders[1]->SendEncodedImage(300, 620); |
| 634 | EXPECT_TRUE(GetLastEncodedImageInfo(&width, &height, &simulcast_index)); |
| 635 | EXPECT_EQ(1, simulcast_index); |
| 636 | |
| 637 | encoders[2]->SendEncodedImage(120, 240); |
| 638 | EXPECT_TRUE(GetLastEncodedImageInfo(&width, &height, &simulcast_index)); |
| 639 | EXPECT_EQ(2, simulcast_index); |
| 640 | |
| 641 | // Reinitialize. |
| 642 | EXPECT_EQ(0, adapter_->Release()); |
| 643 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 644 | adapter_->SetRateAllocation(rate_allocator_->GetAllocation(1200, 30), 30); |
| 645 | |
| 646 | // Verify that the same encoder sends out frames on the same simulcast index. |
| 647 | encoders[0]->SendEncodedImage(1152, 704); |
| 648 | EXPECT_TRUE(GetLastEncodedImageInfo(&width, &height, &simulcast_index)); |
| 649 | EXPECT_EQ(0, simulcast_index); |
| 650 | |
| 651 | encoders[1]->SendEncodedImage(300, 620); |
| 652 | EXPECT_TRUE(GetLastEncodedImageInfo(&width, &height, &simulcast_index)); |
| 653 | EXPECT_EQ(1, simulcast_index); |
| 654 | |
| 655 | encoders[2]->SendEncodedImage(120, 240); |
| 656 | EXPECT_TRUE(GetLastEncodedImageInfo(&width, &height, &simulcast_index)); |
| 657 | EXPECT_EQ(2, simulcast_index); |
| 658 | } |
| 659 | |
pbos | 65e15ba | 2015-10-15 10:52:15 -0700 | [diff] [blame] | 660 | TEST_F(TestSimulcastEncoderAdapterFake, SupportsNativeHandleForSingleStreams) { |
| 661 | TestVp8Simulcast::DefaultSettings( |
| 662 | &codec_, static_cast<const int*>(kTestTemporalLayerProfile)); |
| 663 | codec_.numberOfSimulcastStreams = 1; |
| 664 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 665 | adapter_->RegisterEncodeCompleteCallback(this); |
| 666 | ASSERT_EQ(1u, helper_->factory()->encoders().size()); |
| 667 | helper_->factory()->encoders()[0]->set_supports_native_handle(true); |
| 668 | EXPECT_TRUE(adapter_->SupportsNativeHandle()); |
| 669 | helper_->factory()->encoders()[0]->set_supports_native_handle(false); |
| 670 | EXPECT_FALSE(adapter_->SupportsNativeHandle()); |
| 671 | } |
| 672 | |
noahric | fac0ff0 | 2016-09-09 10:27:15 -0700 | [diff] [blame] | 673 | TEST_F(TestSimulcastEncoderAdapterFake, SetRatesUnderMinBitrate) { |
| 674 | TestVp8Simulcast::DefaultSettings( |
| 675 | &codec_, static_cast<const int*>(kTestTemporalLayerProfile)); |
| 676 | codec_.minBitrate = 50; |
| 677 | codec_.numberOfSimulcastStreams = 1; |
| 678 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
Erik Språng | 82fad3d | 2018-03-21 09:57:23 +0100 | [diff] [blame] | 679 | rate_allocator_.reset(new SimulcastRateAllocator(codec_)); |
noahric | fac0ff0 | 2016-09-09 10:27:15 -0700 | [diff] [blame] | 680 | |
| 681 | // Above min should be respected. |
Erik Språng | 08127a9 | 2016-11-16 16:41:30 +0100 | [diff] [blame] | 682 | BitrateAllocation target_bitrate = |
| 683 | rate_allocator_->GetAllocation(codec_.minBitrate * 1000, 30); |
| 684 | adapter_->SetRateAllocation(target_bitrate, 30); |
| 685 | EXPECT_EQ(target_bitrate, |
| 686 | helper_->factory()->encoders()[0]->last_set_bitrate()); |
noahric | fac0ff0 | 2016-09-09 10:27:15 -0700 | [diff] [blame] | 687 | |
| 688 | // Below min but non-zero should be replaced with the min bitrate. |
Erik Språng | 08127a9 | 2016-11-16 16:41:30 +0100 | [diff] [blame] | 689 | BitrateAllocation too_low_bitrate = |
| 690 | rate_allocator_->GetAllocation((codec_.minBitrate - 1) * 1000, 30); |
| 691 | adapter_->SetRateAllocation(too_low_bitrate, 30); |
| 692 | EXPECT_EQ(target_bitrate, |
| 693 | helper_->factory()->encoders()[0]->last_set_bitrate()); |
noahric | fac0ff0 | 2016-09-09 10:27:15 -0700 | [diff] [blame] | 694 | |
| 695 | // Zero should be passed on as is, since it means "pause". |
Erik Språng | 08127a9 | 2016-11-16 16:41:30 +0100 | [diff] [blame] | 696 | adapter_->SetRateAllocation(BitrateAllocation(), 30); |
| 697 | EXPECT_EQ(BitrateAllocation(), |
| 698 | helper_->factory()->encoders()[0]->last_set_bitrate()); |
noahric | fac0ff0 | 2016-09-09 10:27:15 -0700 | [diff] [blame] | 699 | } |
| 700 | |
Peter Boström | a5dec16 | 2016-01-20 15:53:55 +0100 | [diff] [blame] | 701 | TEST_F(TestSimulcastEncoderAdapterFake, SupportsImplementationName) { |
| 702 | EXPECT_STREQ("SimulcastEncoderAdapter", adapter_->ImplementationName()); |
| 703 | TestVp8Simulcast::DefaultSettings( |
| 704 | &codec_, static_cast<const int*>(kTestTemporalLayerProfile)); |
| 705 | std::vector<const char*> encoder_names; |
| 706 | encoder_names.push_back("codec1"); |
| 707 | encoder_names.push_back("codec2"); |
| 708 | encoder_names.push_back("codec3"); |
| 709 | helper_->factory()->SetEncoderNames(encoder_names); |
| 710 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 711 | EXPECT_STREQ("SimulcastEncoderAdapter (codec1, codec2, codec3)", |
| 712 | adapter_->ImplementationName()); |
Peter Boström | d53c389 | 2016-03-30 17:03:52 +0200 | [diff] [blame] | 713 | |
| 714 | // Single streams should not expose "SimulcastEncoderAdapter" in name. |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 715 | EXPECT_EQ(0, adapter_->Release()); |
Peter Boström | d53c389 | 2016-03-30 17:03:52 +0200 | [diff] [blame] | 716 | codec_.numberOfSimulcastStreams = 1; |
| 717 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 718 | adapter_->RegisterEncodeCompleteCallback(this); |
| 719 | ASSERT_EQ(1u, helper_->factory()->encoders().size()); |
| 720 | EXPECT_STREQ("codec1", adapter_->ImplementationName()); |
Peter Boström | a5dec16 | 2016-01-20 15:53:55 +0100 | [diff] [blame] | 721 | } |
| 722 | |
pbos | 65e15ba | 2015-10-15 10:52:15 -0700 | [diff] [blame] | 723 | TEST_F(TestSimulcastEncoderAdapterFake, |
noahric | fe3654d | 2016-07-01 09:05:54 -0700 | [diff] [blame] | 724 | SupportsNativeHandleForMultipleStreams) { |
pbos | 65e15ba | 2015-10-15 10:52:15 -0700 | [diff] [blame] | 725 | TestVp8Simulcast::DefaultSettings( |
| 726 | &codec_, static_cast<const int*>(kTestTemporalLayerProfile)); |
| 727 | codec_.numberOfSimulcastStreams = 3; |
| 728 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 729 | adapter_->RegisterEncodeCompleteCallback(this); |
| 730 | ASSERT_EQ(3u, helper_->factory()->encoders().size()); |
| 731 | for (MockVideoEncoder* encoder : helper_->factory()->encoders()) |
| 732 | encoder->set_supports_native_handle(true); |
noahric | fe3654d | 2016-07-01 09:05:54 -0700 | [diff] [blame] | 733 | // If one encoder doesn't support it, then overall support is disabled. |
| 734 | helper_->factory()->encoders()[0]->set_supports_native_handle(false); |
pbos | 65e15ba | 2015-10-15 10:52:15 -0700 | [diff] [blame] | 735 | EXPECT_FALSE(adapter_->SupportsNativeHandle()); |
noahric | fe3654d | 2016-07-01 09:05:54 -0700 | [diff] [blame] | 736 | // Once all do, then the adapter claims support. |
| 737 | helper_->factory()->encoders()[0]->set_supports_native_handle(true); |
| 738 | EXPECT_TRUE(adapter_->SupportsNativeHandle()); |
| 739 | } |
| 740 | |
nisse | af91689 | 2017-01-10 07:44:26 -0800 | [diff] [blame] | 741 | // TODO(nisse): Reuse definition in webrtc/test/fake_texture_handle.h. |
Magnus Jedvert | 72dbe2a | 2017-06-10 17:03:37 +0000 | [diff] [blame] | 742 | class FakeNativeBuffer : public VideoFrameBuffer { |
noahric | fe3654d | 2016-07-01 09:05:54 -0700 | [diff] [blame] | 743 | public: |
Magnus Jedvert | 72dbe2a | 2017-06-10 17:03:37 +0000 | [diff] [blame] | 744 | FakeNativeBuffer(int width, int height) : width_(width), height_(height) {} |
| 745 | |
| 746 | Type type() const override { return Type::kNative; } |
| 747 | int width() const override { return width_; } |
| 748 | int height() const override { return height_; } |
| 749 | |
| 750 | rtc::scoped_refptr<I420BufferInterface> ToI420() override { |
noahric | fe3654d | 2016-07-01 09:05:54 -0700 | [diff] [blame] | 751 | RTC_NOTREACHED(); |
| 752 | return nullptr; |
| 753 | } |
Magnus Jedvert | 72dbe2a | 2017-06-10 17:03:37 +0000 | [diff] [blame] | 754 | |
| 755 | private: |
| 756 | const int width_; |
| 757 | const int height_; |
noahric | fe3654d | 2016-07-01 09:05:54 -0700 | [diff] [blame] | 758 | }; |
| 759 | |
| 760 | TEST_F(TestSimulcastEncoderAdapterFake, |
| 761 | NativeHandleForwardingForMultipleStreams) { |
| 762 | TestVp8Simulcast::DefaultSettings( |
| 763 | &codec_, static_cast<const int*>(kTestTemporalLayerProfile)); |
| 764 | codec_.numberOfSimulcastStreams = 3; |
| 765 | // High start bitrate, so all streams are enabled. |
| 766 | codec_.startBitrate = 3000; |
| 767 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 768 | adapter_->RegisterEncodeCompleteCallback(this); |
| 769 | ASSERT_EQ(3u, helper_->factory()->encoders().size()); |
| 770 | for (MockVideoEncoder* encoder : helper_->factory()->encoders()) |
| 771 | encoder->set_supports_native_handle(true); |
| 772 | EXPECT_TRUE(adapter_->SupportsNativeHandle()); |
| 773 | |
| 774 | rtc::scoped_refptr<VideoFrameBuffer> buffer( |
Magnus Jedvert | 72dbe2a | 2017-06-10 17:03:37 +0000 | [diff] [blame] | 775 | new rtc::RefCountedObject<FakeNativeBuffer>(1280, 720)); |
noahric | fe3654d | 2016-07-01 09:05:54 -0700 | [diff] [blame] | 776 | VideoFrame input_frame(buffer, 100, 1000, kVideoRotation_180); |
| 777 | // Expect calls with the given video frame verbatim, since it's a texture |
| 778 | // frame and can't otherwise be modified/resized. |
| 779 | for (MockVideoEncoder* encoder : helper_->factory()->encoders()) |
| 780 | EXPECT_CALL(*encoder, Encode(::testing::Ref(input_frame), _, _)).Times(1); |
| 781 | std::vector<FrameType> frame_types(3, kVideoFrameKey); |
brandtr | 5e17175 | 2017-05-23 03:32:16 -0700 | [diff] [blame] | 782 | EXPECT_EQ(0, adapter_->Encode(input_frame, nullptr, &frame_types)); |
pbos | 65e15ba | 2015-10-15 10:52:15 -0700 | [diff] [blame] | 783 | } |
| 784 | |
noahric | 5777910 | 2016-05-25 06:48:46 -0700 | [diff] [blame] | 785 | TEST_F(TestSimulcastEncoderAdapterFake, TestFailureReturnCodesFromEncodeCalls) { |
| 786 | TestVp8Simulcast::DefaultSettings( |
| 787 | &codec_, static_cast<const int*>(kTestTemporalLayerProfile)); |
| 788 | codec_.numberOfSimulcastStreams = 3; |
| 789 | EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200)); |
| 790 | adapter_->RegisterEncodeCompleteCallback(this); |
| 791 | ASSERT_EQ(3u, helper_->factory()->encoders().size()); |
| 792 | // Tell the 2nd encoder to request software fallback. |
noahric | fe3654d | 2016-07-01 09:05:54 -0700 | [diff] [blame] | 793 | EXPECT_CALL(*helper_->factory()->encoders()[1], Encode(_, _, _)) |
| 794 | .WillOnce(Return(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE)); |
noahric | 5777910 | 2016-05-25 06:48:46 -0700 | [diff] [blame] | 795 | |
| 796 | // Send a fake frame and assert the return is software fallback. |
Magnus Jedvert | 72dbe2a | 2017-06-10 17:03:37 +0000 | [diff] [blame] | 797 | rtc::scoped_refptr<I420Buffer> input_buffer = |
| 798 | I420Buffer::Create(kDefaultWidth, kDefaultHeight); |
nisse | 64ec8f8 | 2016-09-27 00:17:25 -0700 | [diff] [blame] | 799 | input_buffer->InitializeData(); |
| 800 | VideoFrame input_frame(input_buffer, 0, 0, webrtc::kVideoRotation_0); |
noahric | 5777910 | 2016-05-25 06:48:46 -0700 | [diff] [blame] | 801 | std::vector<FrameType> frame_types(3, kVideoFrameKey); |
| 802 | EXPECT_EQ(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE, |
| 803 | adapter_->Encode(input_frame, nullptr, &frame_types)); |
| 804 | } |
| 805 | |
noahric | e5ba75a | 2016-12-12 13:08:27 -0800 | [diff] [blame] | 806 | TEST_F(TestSimulcastEncoderAdapterFake, TestInitFailureCleansUpEncoders) { |
| 807 | TestVp8Simulcast::DefaultSettings( |
| 808 | &codec_, static_cast<const int*>(kTestTemporalLayerProfile)); |
noahric | e5ba75a | 2016-12-12 13:08:27 -0800 | [diff] [blame] | 809 | codec_.numberOfSimulcastStreams = 3; |
| 810 | helper_->factory()->set_init_encode_return_value( |
| 811 | WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE); |
| 812 | EXPECT_EQ(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE, |
| 813 | adapter_->InitEncode(&codec_, 1, 1200)); |
| 814 | EXPECT_TRUE(helper_->factory()->encoders().empty()); |
| 815 | } |
| 816 | |
pbos@webrtc.org | 9115cde | 2014-12-09 10:36:40 +0000 | [diff] [blame] | 817 | } // namespace testing |
| 818 | } // namespace webrtc |