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>
 #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"
+#include "ui/gfx/screen.h"
 
 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
@@ skipping 229 matching lines @@
 
   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),
+      display_rotation_(gfx::Display::ROTATE_0) {
+  gfx::Screen* screen =

[perkj_chrome, 2014/05/09 10:11:28]

This will be called on a special thread used only for media devices? Is it ok to
run the display observer from any thread? 

+      gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);
+  if (screen) {
+    SetDisplayRotation(screen->GetPrimaryDisplay());
+    screen->AddObserver(this);
+  }
+}
 
 VideoCaptureDeviceLinux::~VideoCaptureDeviceLinux() {
+  gfx::Screen* screen =
+      gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_ALTERNATE);

[perkj_chrome, 2014/05/09 10:11:28]

Can there be a race here? ie, is it ok to not call RemoveObserver even if it was
added? 

+  if (screen)
+    screen->RemoveObserver(this);
+
   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(
     const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
@@ skipping 19 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::OnDisplayBoundsChanged(
+    const gfx::Display& display) {
+  v4l2_thread_.message_loop()->PostTask(

[perkj_chrome, 2014/05/09 10:11:28]

This thread is started in AllocateAndStart. So you must verify that you are in
the correct state before posting. How about moving registration to
AllocateAndStart to ensure that this is safe. And deregister in the stop method.

[perkj_chrome, 2014/05/09 10:28:44]

oh- btw - this need a thread check to make sure its called on the same thread as
we do AllocateAndStart and Stop.... -- ie it must be called on the same thread
as we register and deregister the observer.

+      FROM_HERE,
+      base::Bind(&VideoCaptureDeviceLinux::SetDisplayRotation,
+                 base::Unretained(this), display));
+}
+
+void VideoCaptureDeviceLinux::OnDisplayAdded(
+    const gfx::Display& /*new_display*/) {}
+
+void VideoCaptureDeviceLinux::OnDisplayRemoved(
+    const gfx::Display& /*old_display*/) {}
+
+void VideoCaptureDeviceLinux::SetDisplayRotation(const gfx::Display& display) {
+  DCHECK(!v4l2_thread_.IsRunning() ||
+         v4l2_thread_.message_loop() == base::MessageLoop::current());
+  if (display.IsInternal())
+    display_rotation_ = display.rotation();

[perkj_chrome, 2014/05/09 10:18:52]

Add a todo and a comment that this will in fact rotate all cameras and why this
is done.

+}
+
 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,
+          display_rotation_ * 90,
           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