Forward Encode failure codes from sub encoders.

webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 103 matching lines @@
   int32_t InitEncode(const VideoCodec* codecSettings,
                      int32_t numberOfCores,
                      size_t maxPayloadSize) /* override */ {
     codec_ = *codecSettings;
     return 0;
   }
 
   int32_t Encode(const VideoFrame& inputImage,
                  const CodecSpecificInfo* codecSpecificInfo,
                  const std::vector<FrameType>* frame_types) /* override */ {
-    return 0;
+    return encode_return_value_;
   }
 
   int32_t RegisterEncodeCompleteCallback(
       EncodedImageCallback* callback) /* override */ {
     callback_ = callback;
     return 0;
   }
 
   int32_t Release() /* override */ { return 0; }
 
@@ skipping 18 matching lines @@
     image._encodedHeight = height;
     CodecSpecificInfo codecSpecificInfo;
     memset(&codecSpecificInfo, 0, sizeof(codecSpecificInfo));
     callback_->Encoded(image, &codecSpecificInfo, NULL);
   }
 
   void set_supports_native_handle(bool enabled) {
     supports_native_handle_ = enabled;
   }
 
+  void set_encode_return_value(int value) {
+    encode_return_value_ = value;
+  }
+
   MOCK_CONST_METHOD0(ImplementationName, const char*());
 
  private:
   bool supports_native_handle_ = false;
+  int encode_return_value_ = WEBRTC_VIDEO_CODEC_OK;
   VideoCodec codec_;
   EncodedImageCallback* callback_;
 };
 
 class MockVideoEncoderFactory : public VideoEncoderFactory {
  public:
   VideoEncoder* Create() override {
-    MockVideoEncoder* encoder = new MockVideoEncoder();
+    MockVideoEncoder* encoder = new
+        ::testing::NiceMock<MockVideoEncoder>();
     const char* encoder_name = encoder_names_.empty()
                                    ? "codec_implementation_name"
                                    : encoder_names_[encoders_.size()];
     ON_CALL(*encoder, ImplementationName()).WillByDefault(Return(encoder_name));
     encoders_.push_back(encoder);
     return encoder;
   }
 
   void Destroy(VideoEncoder* encoder) override {
     for (size_t i = 0; i < encoders_.size(); ++i) {
@@ skipping 268 matching lines @@
       &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
   codec_.numberOfSimulcastStreams = 3;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
   adapter_->RegisterEncodeCompleteCallback(this);
   ASSERT_EQ(3u, helper_->factory()->encoders().size());
   for (MockVideoEncoder* encoder : helper_->factory()->encoders())
     encoder->set_supports_native_handle(true);
   EXPECT_FALSE(adapter_->SupportsNativeHandle());
 }
 
+TEST_F(TestSimulcastEncoderAdapterFake, TestFailureReturnCodesFromEncodeCalls) {
+  TestVp8Simulcast::DefaultSettings(
+      &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
+  codec_.numberOfSimulcastStreams = 3;
+  EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
+  adapter_->RegisterEncodeCompleteCallback(this);
+  ASSERT_EQ(3u, helper_->factory()->encoders().size());
+  for (MockVideoEncoder* encoder : helper_->factory()->encoders())
+    encoder->set_encode_return_value(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE);

[pbos-webrtc, 2016/05/24 13:26:33]

Set only one of them (like encoders()[1]) to make sure that one failing is
enough.

[noahric, 2016/05/24 18:31:09]

Done.

+
+  // Send a fake frame and assert the return is software fallback.
+  VideoFrame input_frame;
+  int half_width = (kDefaultWidth + 1) / 2;
+  input_frame.CreateEmptyFrame(kDefaultWidth, kDefaultHeight, kDefaultWidth,
+                                half_width, half_width);
+  memset(input_frame.video_frame_buffer()->MutableDataY(), 0,
+         input_frame.allocated_size(kYPlane));
+  memset(input_frame.video_frame_buffer()->MutableDataU(), 0,
+         input_frame.allocated_size(kUPlane));
+  memset(input_frame.video_frame_buffer()->MutableDataV(), 0,
+         input_frame.allocated_size(kVPlane));
+
+  std::vector<FrameType> frame_types(3, kVideoFrameKey);
+  EXPECT_EQ(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE,
+            adapter_->Encode(input_frame, nullptr, &frame_types));
+}
+
 }  // namespace testing
 }  // namespace webrtc