Linux Video Capture: Add V4L2VideoCaptureDelegate{Single,Multi}Plane.

content/browser/renderer_host/media/video_capture_controller_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Unit test for VideoCaptureController.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 11 matching lines @@
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if !defined(OS_ANDROID)
 #include "content/browser/compositor/test/no_transport_image_transport_factory.h"
 #endif
 
+using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Mock;
+using ::testing::SaveArg;
 
 namespace content {
 
 class MockVideoCaptureControllerEventHandler
     : public VideoCaptureControllerEventHandler {
  public:
   explicit MockVideoCaptureControllerEventHandler(
       VideoCaptureController* controller)
       : controller_(controller) {}
   virtual ~MockVideoCaptureControllerEventHandler() {}
 
   // These mock methods are delegated to by our fake implementation of
   // VideoCaptureControllerEventHandler, to be used in EXPECT_CALL().
   MOCK_METHOD1(DoBufferCreated, void(const VideoCaptureControllerID&));
   MOCK_METHOD1(DoBufferDestroyed, void(const VideoCaptureControllerID&));
-  MOCK_METHOD1(DoBufferReady, void(const VideoCaptureControllerID&));
+  MOCK_METHOD2(DoBufferReady, void(const VideoCaptureControllerID&,
+                                   const gfx::Size&));
   MOCK_METHOD1(DoMailboxBufferReady, void(const VideoCaptureControllerID&));
   MOCK_METHOD1(DoEnded, void(const VideoCaptureControllerID&));
   MOCK_METHOD1(DoError, void(const VideoCaptureControllerID&));
 
   virtual void OnError(const VideoCaptureControllerID& id) override {
     DoError(id);
   }
   virtual void OnBufferCreated(const VideoCaptureControllerID& id,
                                base::SharedMemoryHandle handle,
                                int length, int buffer_id) override {
     DoBufferCreated(id);
   }
   virtual void OnBufferDestroyed(const VideoCaptureControllerID& id,
                                  int buffer_id) override {
     DoBufferDestroyed(id);
   }
   virtual void OnBufferReady(
       const VideoCaptureControllerID& id,
       int buffer_id,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       base::TimeTicks timestamp,
       scoped_ptr<base::DictionaryValue> metadata) override {
-    DoBufferReady(id);
+    DoBufferReady(id, coded_size);
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&VideoCaptureController::ReturnBuffer,
                    base::Unretained(controller_),
                    id,
                    this,
                    buffer_id,
                    0));
   }
   virtual void OnMailboxBufferReady(
@@ skipping 238 matching lines @@
   // side effect this will cause the first buffer to be shared with clients.
   uint8 buffer_no = 1;
   scoped_refptr<media::VideoCaptureDevice::Client::Buffer> buffer;
   buffer =
       device_->ReserveOutputBuffer(media::VideoFrame::I420, capture_resolution);
   ASSERT_TRUE(buffer.get());
   memset(buffer->data(), buffer_no++, buffer->size());
   {
     InSequence s;
     EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_1)).Times(1);
-    EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_1)).Times(1);
+    EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_1,_)).Times(1);
   }
   {
     InSequence s;
     EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_1)).Times(1);
-    EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1)).Times(1);
+    EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1,_)).Times(1);
   }
   {
     InSequence s;
     EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_2)).Times(1);
-    EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2)).Times(1);
+    EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2,_)).Times(1);
   }
   device_->OnIncomingCapturedVideoFrame(
       buffer,
       WrapI420Buffer(buffer, capture_resolution),
       base::TimeTicks());
   buffer = NULL;
 
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
 
   // Second buffer which ought to use the same shared memory buffer. In this
   // case pretend that the Buffer pointer is held by the device for a long
   // delay. This shouldn't affect anything.
   buffer =
       device_->ReserveOutputBuffer(media::VideoFrame::I420, capture_resolution);
   ASSERT_TRUE(buffer.get());
   memset(buffer->data(), buffer_no++, buffer->size());
   device_->OnIncomingCapturedVideoFrame(
       buffer,
       WrapI420Buffer(buffer, capture_resolution),
       base::TimeTicks());
   buffer = NULL;
 
   // The buffer should be delivered to the clients in any order.
-  EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_1)).Times(1);
-  EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1)).Times(1);
-  EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2)).Times(1);
+  EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_1,_)).Times(1);
+  EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1,_)).Times(1);
+  EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2,_)).Times(1);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
 
   // Add a fourth client now that some buffers have come through.
   controller_->AddClient(client_b_route_2,
                          client_b_.get(),
                          base::kNullProcessHandle,
                          1,
                          session_1);
@@ skipping 10 matching lines @@
         WrapI420Buffer(buffer, capture_resolution),
         base::TimeTicks());
     buffer = NULL;
   }
   // ReserveOutputBuffer ought to fail now, because the pool is depleted.
   ASSERT_FALSE(device_->ReserveOutputBuffer(media::VideoFrame::I420,
                                             capture_resolution).get());
 
   // The new client needs to be told of 3 buffers; the old clients only 2.
   EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_2)).Times(kPoolSize);
-  EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_2)).Times(kPoolSize);
+  EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_2,_)).Times(kPoolSize);
   EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_1))
       .Times(kPoolSize - 1);
-  EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_1)).Times(kPoolSize);
+  EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_1,_)).Times(kPoolSize);
   EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_2))
       .Times(kPoolSize - 1);
-  EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2)).Times(kPoolSize);
+  EXPECT_CALL(*client_a_, DoBufferReady(client_a_route_2,_)).Times(kPoolSize);
   EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_1))
       .Times(kPoolSize - 1);
-  EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1)).Times(kPoolSize);
+  EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_1,_)).Times(kPoolSize);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
 
   // Now test the interaction of client shutdown and buffer delivery.
   // Kill A1 via renderer disconnect (synchronous).
   controller_->RemoveClient(client_a_route_1, client_a_.get());
   // Kill B1 via session close (posts a task to disconnect).
   EXPECT_CALL(*client_b_, DoEnded(client_b_route_1)).Times(1);
   controller_->StopSession(300);
@@ skipping 17 matching lines @@
   }
   ASSERT_TRUE(buffer.get());
   memset(buffer->data(), buffer_no++, buffer->size());
   device_->OnIncomingCapturedVideoFrame(
       buffer,
       WrapI420Buffer(buffer, capture_resolution),
       base::TimeTicks());
   buffer = NULL;
   // B2 is the only client left, and is the only one that should
   // get the buffer.
-  EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_2)).Times(2);
+  EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_2,_)).Times(2);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
 
   // Allocate all buffers from the buffer pool, half as SHM buffer and half as
   // mailbox buffers.  Make sure of different counts though.
 #if defined(OS_ANDROID)
   int mailbox_buffers = 0;
 #else
   int mailbox_buffers = kPoolSize / 2;
@@ skipping 32 matching lines @@
                           capture_resolution),
         base::TimeTicks());
     buffer = NULL;
   }
   // ReserveOutputBuffers ought to fail now regardless of buffer format, because
   // the pool is depleted.
   ASSERT_FALSE(device_->ReserveOutputBuffer(media::VideoFrame::I420,
                                             capture_resolution).get());
   ASSERT_FALSE(device_->ReserveOutputBuffer(media::VideoFrame::NATIVE_TEXTURE,
                                             gfx::Size(0, 0)).get());
-  EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_2)).Times(shm_buffers);
+  EXPECT_CALL(*client_b_, DoBufferReady(client_b_route_2,_)).Times(shm_buffers);
   EXPECT_CALL(*client_b_, DoMailboxBufferReady(client_b_route_2))
       .Times(mailbox_buffers);
   base::RunLoop().RunUntilIdle();
   for (size_t i = 0; i < mailbox_syncpoints.size(); ++i) {
     // A new release sync point must be inserted when the video frame is
     // returned to the Browser process.
     // See: MockVideoCaptureControllerEventHandler::OnMailboxBufferReady() and
     // VideoCaptureController::ReturnBuffer()
     ASSERT_NE(mailbox_syncpoints[i], release_syncpoints[i]);
   }
@@ skipping 97 matching lines @@
 TEST_F(VideoCaptureControllerTest, DataCaptureInEachVideoFormatInSequence) {
   // The usual ReserveOutputBuffer() -> OnIncomingCapturedVideoFrame() cannot
   // be used since it does not accept all pixel formats. The memory backed
   // buffer OnIncomingCapturedData() is used instead, with a dummy scratchpad
   // buffer.
   const size_t kScratchpadSizeInBytes = 400;
   unsigned char data[kScratchpadSizeInBytes];
   const gfx::Size capture_resolution(10, 10);
   ASSERT_GE(kScratchpadSizeInBytes, capture_resolution.GetArea() * 4u)
       << "Scratchpad is too small to hold the largest pixel format (ARGB).";
+
+  const int kSessionId = 100;
   // This Test skips PIXEL_FORMAT_TEXTURE and PIXEL_FORMAT_UNKNOWN.
   for (int format = 0; format < media::PIXEL_FORMAT_TEXTURE; ++format) {
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         capture_resolution, 30, media::VideoPixelFormat(format));
 
-    const gfx::Size capture_resolution(320, 240);
-
-    const VideoCaptureControllerID route(0x99);
-
     // Start with one client.
-    controller_->AddClient(route,
+    const VideoCaptureControllerID route_id(0x99);
+    controller_->AddClient(route_id,
                            client_a_.get(),
                            base::kNullProcessHandle,
-                           100,
+                           kSessionId,
                            params);
     ASSERT_EQ(1, controller_->GetClientCount());
     device_->OnIncomingCapturedData(
-      data,
-      params.requested_format.ImageAllocationSize(),
-      params.requested_format,
-      0 /* rotation */,
-      base::TimeTicks());
-    EXPECT_EQ(100, controller_->RemoveClient(route, client_a_.get()));
+        data,
+        params.requested_format.ImageAllocationSize(),
+        params.requested_format,
+        0 /* clockwise_rotation */,
+        base::TimeTicks());
+    EXPECT_EQ(kSessionId, controller_->RemoveClient(route_id, client_a_.get()));
     Mock::VerifyAndClearExpectations(client_a_.get());
   }
 }
+
+// Test that we receive the expected resolution for a given captured frame
+// resolution and rotation. Odd resolutions are also cropped.
+TEST_F(VideoCaptureControllerTest, CheckRotationsAndCrops) {
+  const int kSessionId = 100;
+  const struct SizeAndRotation {
+    gfx::Size input_resolution;
+    int rotation;
+    gfx::Size output_resolution;
+  } kSizeAndRotations[] = {{{6, 4}, 0, {6, 4}},
+                           {{6, 4}, 90, {4, 6}},
+                           {{6, 4}, 180, {6, 4}},
+                           {{6, 4}, 270, {4, 6}},
+                           {{7, 4}, 0, {6, 4}},
+                           {{7, 4}, 90, {4, 6}},
+                           {{7, 4}, 180, {6, 4}},
+                           {{7, 4}, 270, {4, 6}}};
+  // The usual ReserveOutputBuffer() -> OnIncomingCapturedVideoFrame() cannot
+  // be used since it does not resolve rotations or crops. The memory backed
+  // buffer OnIncomingCapturedData() is used instead, with a dummy scratchpad
+  // buffer.
+  const size_t kScratchpadSizeInBytes = 400;
+  unsigned char data[kScratchpadSizeInBytes];
+
+  media::VideoCaptureParams params;
+  for (const auto& size_and_rotation : kSizeAndRotations) {
+    ASSERT_GE(kScratchpadSizeInBytes,
+              size_and_rotation.input_resolution.GetArea() * 4u)
+        << "Scratchpad is too small to hold the largest pixel format (ARGB).";
+
+    params.requested_format = media::VideoCaptureFormat(
+        size_and_rotation.input_resolution, 30, media::PIXEL_FORMAT_ARGB);
+
+    const VideoCaptureControllerID route_id(0x99);
+    controller_->AddClient(route_id, client_a_.get(), base::kNullProcessHandle,
+                           kSessionId, params);
+    ASSERT_EQ(1, controller_->GetClientCount());
+
+    device_->OnIncomingCapturedData(
+        data,
+        params.requested_format.ImageAllocationSize(),
+        params.requested_format,
+        size_and_rotation.rotation,
+        base::TimeTicks());
+    gfx::Size coded_size;
+    {
+      InSequence s;
+      EXPECT_CALL(*client_a_, DoBufferCreated(route_id)).Times(1);
+      EXPECT_CALL(*client_a_, DoBufferReady(route_id, _))
+          .Times(1)
+          .WillOnce(SaveArg<1>(&coded_size));
+    }
+    base::RunLoop().RunUntilIdle();
+
+    EXPECT_EQ(coded_size.width(), size_and_rotation.output_resolution.width());
+    EXPECT_EQ(coded_size.height(),
+              size_and_rotation.output_resolution.height());
+
+    EXPECT_EQ(kSessionId, controller_->RemoveClient(route_id, client_a_.get()));
+    Mock::VerifyAndClearExpectations(client_a_.get());
+  }
+}
 
 }  // namespace content