Add a ChromeOS implementation of VideoCaptureDevice

media/video/capture/linux/video_capture_device_linux.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.
 
 #include "media/video/capture/linux/video_capture_device_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #if defined(OS_OPENBSD)
 #include <sys/videoio.h>
@@ skipping 95 matching lines @@
   // Put it as the least preferred format.
   fourccs->push_back(V4L2_PIX_FMT_JPEG);
 }
 
 // TODO(mcasas): Remove the following static methods when they are no longer
 // referenced from VideoCaptureDeviceFactory, i.e. when all OS platforms have
 // splitted the VideoCaptureDevice into VideoCaptureDevice and
 // VideoCaptureDeviceFactory.
 
 // static
-VideoCaptureDevice* VideoCaptureDevice::Create(const Name& device_name) {
+VideoCaptureDevice* VideoCaptureDevice::Create(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    const Name& device_name) {
   NOTREACHED();
   return NULL;
 }
 // static
 void VideoCaptureDevice::GetDeviceNames(Names* device_names) {
   NOTREACHED();
 }
 
 // static
 void VideoCaptureDevice::GetDeviceSupportedFormats(
@@ skipping 23 matching lines @@
 
   return usb_id;
 }
 
 VideoCaptureDeviceLinux::VideoCaptureDeviceLinux(const Name& device_name)
     : state_(kIdle),
       device_name_(device_name),
       v4l2_thread_("V4L2Thread"),
       buffer_pool_(NULL),
       buffer_pool_size_(0),
-      timeout_count_(0) {}
+      timeout_count_(0),
+      rotation_(0) {
+}
 
 VideoCaptureDeviceLinux::~VideoCaptureDeviceLinux() {
   state_ = kIdle;
   // Check if the thread is running.
   // This means that the device have not been DeAllocated properly.
   DCHECK(!v4l2_thread_.IsRunning());
   v4l2_thread_.Stop();
 }
 
 void VideoCaptureDeviceLinux::AllocateAndStart(
@@ skipping 21 matching lines @@
       FROM_HERE,
       base::Bind(&VideoCaptureDeviceLinux::OnStopAndDeAllocate,
                  base::Unretained(this)));
   v4l2_thread_.Stop();
   // Make sure no buffers are still allocated.
   // This can happen (theoretically) if an error occurs when trying to stop
   // the camera.
   DeAllocateVideoBuffers();
 }
 
+void VideoCaptureDeviceLinux::SetRotation(int rotation) {
+  if (v4l2_thread_.IsRunning()) {
+    v4l2_thread_.message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&VideoCaptureDeviceLinux::SetRotationOnV4L2Thread,
+                   base::Unretained(this), rotation));
+  } else {
+    // If the |v4l2_thread_| is not running, there's no race condition and
+    // |rotation_| can be set directly.
+    rotation_ = rotation;
+  }
+}
+
+void VideoCaptureDeviceLinux::SetRotationOnV4L2Thread(int rotation) {
+  DCHECK_EQ(v4l2_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(rotation >= 0 && rotation < 360 && rotation % 90 == 0);
+  rotation_ = rotation;
+}
+
 void VideoCaptureDeviceLinux::OnAllocateAndStart(int width,
                                                  int height,
                                                  int frame_rate,
                                                  scoped_ptr<Client> client) {
   DCHECK_EQ(v4l2_thread_.message_loop(), base::MessageLoop::current());
 
   client_ = client.Pass();
 
   // Need to open camera with O_RDWR after Linux kernel 3.3.
   device_fd_.reset(HANDLE_EINTR(open(device_name_.id().c_str(), O_RDWR)));
@@ skipping 188 matching lines @@
     v4l2_buffer buffer;
     memset(&buffer, 0, sizeof(buffer));
     buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     buffer.memory = V4L2_MEMORY_MMAP;
     // Dequeue a buffer.
     if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_DQBUF, &buffer)) == 0) {
       client_->OnIncomingCapturedData(
           static_cast<uint8*>(buffer_pool_[buffer.index].start),
           buffer.bytesused,
           capture_format_,
-          0,
+          rotation_,
           base::TimeTicks::Now());
 
       // Enqueue the buffer again.
       if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_QBUF, &buffer)) == -1) {
         SetErrorState(base::StringPrintf(
             "Failed to enqueue capture buffer errno %d", errno));
       }
     } else {
       SetErrorState(base::StringPrintf(
           "Failed to dequeue capture buffer errno %d", errno));
@@ skipping 79 matching lines @@
 
 void VideoCaptureDeviceLinux::SetErrorState(const std::string& reason) {
   DCHECK(!v4l2_thread_.IsRunning() ||
          v4l2_thread_.message_loop() == base::MessageLoop::current());
   DVLOG(1) << reason;
   state_ = kError;
   client_->OnError(reason);
 }
 
 }  // namespace media