Add native handle support to SimulcastEncoderAdapter.

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 100 matching lines @@
   // methods don't use any override declarations, and we want to avoid
   // warnings from -Winconsistent-missing-override. See
   // http://crbug.com/428099.
   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 encode_return_value_;
-  }
+  MOCK_METHOD3(
+      Encode,
+      int32_t(const VideoFrame& inputImage,
+              const CodecSpecificInfo* codecSpecificInfo,
+              const std::vector<FrameType>* frame_types) /* override */);
 
   int32_t RegisterEncodeCompleteCallback(
       EncodedImageCallback* callback) /* override */ {
     callback_ = callback;
     return 0;
   }
 
   int32_t Release() /* override */ { return 0; }
 
   int32_t SetRates(uint32_t newBitRate, uint32_t frameRate) /* override */ {
@@ skipping 17 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
         ::testing::NiceMock<MockVideoEncoder>();
     const char* encoder_name = encoder_names_.empty()
@@ skipping 263 matching lines @@
   // Single streams should not expose "SimulcastEncoderAdapter" in name.
   adapter_->Release();
   codec_.numberOfSimulcastStreams = 1;
   EXPECT_EQ(0, adapter_->InitEncode(&codec_, 1, 1200));
   adapter_->RegisterEncodeCompleteCallback(this);
   ASSERT_EQ(1u, helper_->factory()->encoders().size());
   EXPECT_STREQ("codec1", adapter_->ImplementationName());
 }
 
 TEST_F(TestSimulcastEncoderAdapterFake,
-       SupportsNativeHandleDisabledForMultipleStreams) {
-  // TODO(pbos): Implement actual test (verify that it works) when implemented
-  // for multiple streams.
+       SupportsNativeHandleForMultipleStreams) {
   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_supports_native_handle(true);
+  // If one encoder doesn't support it, then overall support is disabled.
+  helper_->factory()->encoders()[0]->set_supports_native_handle(false);
   EXPECT_FALSE(adapter_->SupportsNativeHandle());
+  // Once all do, then the adapter claims support.
+  helper_->factory()->encoders()[0]->set_supports_native_handle(true);
+  EXPECT_TRUE(adapter_->SupportsNativeHandle());
+}
+
+class FakeNativeHandleBuffer : public NativeHandleBuffer {
+ public:
+  FakeNativeHandleBuffer(void* native_handle, int width, int height)
+      : NativeHandleBuffer(native_handle, width, height) {}
+  rtc::scoped_refptr<VideoFrameBuffer> NativeToI420Buffer() override {
+    RTC_NOTREACHED();
+    return nullptr;
+  }
+};
+
+TEST_F(TestSimulcastEncoderAdapterFake,
+       NativeHandleForwardingForMultipleStreams) {
+  TestVp8Simulcast::DefaultSettings(
+      &codec_, static_cast<const int*>(kTestTemporalLayerProfile));
+  codec_.numberOfSimulcastStreams = 3;
+  // High start bitrate, so all streams are enabled.
+  codec_.startBitrate = 3000;
+  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_TRUE(adapter_->SupportsNativeHandle());
+
+  rtc::scoped_refptr<VideoFrameBuffer> buffer(
+      new rtc::RefCountedObject<FakeNativeHandleBuffer>(this, 1280, 720));
+  VideoFrame input_frame(buffer, 100, 1000, kVideoRotation_180);
+  // Expect calls with the given video frame verbatim, since it's a texture
+  // frame and can't otherwise be modified/resized.
+  for (MockVideoEncoder* encoder : helper_->factory()->encoders())
+    EXPECT_CALL(*encoder, Encode(::testing::Ref(input_frame), _, _)).Times(1);
+  std::vector<FrameType> frame_types(3, kVideoFrameKey);
+  EXPECT_EQ(0, adapter_->Encode(input_frame, NULL, &frame_types));
 }
 
 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());
   // Tell the 2nd encoder to request software fallback.
-  helper_->factory()->encoders()[1]->set_encode_return_value(
-      WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE);
+  EXPECT_CALL(*helper_->factory()->encoders()[1], Encode(_, _, _))
+      .WillOnce(Return(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE));
 
   // 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