Merge 271560 "Add a ChromeOS implementation of VideoCaptureDevic..."

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>
 #else
 #include <linux/videodev2.h>
 #endif
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include <list>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/scoped_file.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/stringprintf.h"
 
+#if defined(OS_CHROMEOS)
+#include "media/video/capture/linux/video_capture_device_chromeos.h"
+#endif
+
 namespace media {
 
 // Max number of video buffers VideoCaptureDeviceLinux can allocate.
 enum { kMaxVideoBuffers = 2 };
 // Timeout in microseconds v4l2_thread_ blocks waiting for a frame from the hw.
 enum { kCaptureTimeoutUs = 200000 };
 // The number of continuous timeouts tolerated before treated as error.
 enum { kContinuousTimeoutLimit = 10 };
 // Time to wait in milliseconds before v4l2_thread_ reschedules OnCaptureTask
 // if an event is triggered (select) but no video frame is read.
@@ skipping 205 matching lines @@
   std::string usb_id;
   if (!ReadIdFile(vidPath, &usb_id))
     return "";
   usb_id.append(":");
   if (!ReadIdFile(pidPath, &usb_id))
     return "";
 
   return usb_id;
 }
 
-VideoCaptureDevice* VideoCaptureDevice::Create(const Name& device_name) {
+VideoCaptureDevice* VideoCaptureDevice::Create(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    const Name& device_name) {
+#if defined(OS_CHROMEOS)
+  VideoCaptureDeviceChromeOS* self =
+      new VideoCaptureDeviceChromeOS(ui_task_runner, device_name);
+#else
   VideoCaptureDeviceLinux* self = new VideoCaptureDeviceLinux(device_name);
+#endif
   if (!self)
     return NULL;
   // Test opening the device driver. This is to make sure it is available.
   // We will reopen it again in our worker thread when someone
   // allocates the camera.
   base::ScopedFD fd(HANDLE_EINTR(open(device_name.id().c_str(), O_RDONLY)));
   if (!fd.is_valid()) {
     DVLOG(1) << "Cannot open device";
     delete self;
     return NULL;
   }
 
   return self;
 }
 
 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