Reland: Reorganize media::VideoCapture* types

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 141 matching lines @@
     return;
   int fd;
   VideoCaptureCapabilities capture_formats;
   if ((fd = open(device.id().c_str(), O_RDONLY)) < 0) {
     // Failed to open this device.
     return;
   }
 
   formats->clear();
 
-  VideoCaptureCapability capture_format;
+  VideoCaptureCapability capture_capability;
   // Retrieve the caps one by one, first get colorspace, then sizes, then
   // framerates. See http://linuxtv.org/downloads/v4l-dvb-apis for reference.
   v4l2_fmtdesc pixel_format = {};
   pixel_format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   while (ioctl(fd, VIDIOC_ENUM_FMT, &pixel_format) == 0) {
-    capture_format.color =
+    capture_capability.supported_format.pixel_format =
         V4l2ColorToVideoCaptureColorFormat((int32)pixel_format.pixelformat);
-    if (capture_format.color == PIXEL_FORMAT_UNKNOWN) continue;
+    if (capture_capability.supported_format.pixel_format ==
+        PIXEL_FORMAT_UNKNOWN) {
+      continue;
+    }
 
     v4l2_frmsizeenum frame_size = {};
     frame_size.pixel_format = pixel_format.pixelformat;
     while (ioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frame_size) == 0) {
       if (frame_size.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
-        capture_format.width = frame_size.discrete.width;
-        capture_format.height = frame_size.discrete.height;
+        capture_capability.supported_format.frame_size.SetSize(
+            frame_size.discrete.width, frame_size.discrete.height);
       } else if (frame_size.type == V4L2_FRMSIZE_TYPE_STEPWISE) {
         // TODO(mcasas): see http://crbug.com/249953, support these devices.
         NOTIMPLEMENTED();
       } else if (frame_size.type == V4L2_FRMSIZE_TYPE_CONTINUOUS) {
         // TODO(mcasas): see http://crbug.com/249953, support these devices.
         NOTIMPLEMENTED();
       }
       v4l2_frmivalenum frame_interval = {};
       frame_interval.pixel_format = pixel_format.pixelformat;
       frame_interval.width = frame_size.discrete.width;
       frame_interval.height = frame_size.discrete.height;
       while (ioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frame_interval) == 0) {
         if (frame_interval.type == V4L2_FRMIVAL_TYPE_DISCRETE) {
           if (frame_interval.discrete.numerator != 0) {
-            capture_format.frame_rate =
+            capture_capability.supported_format.frame_rate =
                 static_cast<float>(frame_interval.discrete.denominator) /
                 static_cast<float>(frame_interval.discrete.numerator);
           } else {
-            capture_format.frame_rate = 0;
+            capture_capability.supported_format.frame_rate = 0;
           }
         } else if (frame_interval.type == V4L2_FRMIVAL_TYPE_CONTINUOUS) {
           // TODO(mcasas): see http://crbug.com/249953, support these devices.
           NOTIMPLEMENTED();
           break;
         } else if (frame_interval.type == V4L2_FRMIVAL_TYPE_STEPWISE) {
           // TODO(mcasas): see http://crbug.com/249953, support these devices.
           NOTIMPLEMENTED();
           break;
         }
-        formats->push_back(capture_format);
+        formats->push_back(capture_capability);
         ++frame_interval.index;
       }
       ++frame_size.index;
     }
     ++pixel_format.index;
   }
 
   close(fd);
   return;
 }
@@ skipping 66 matching lines @@
   // This means that the device have not been DeAllocated properly.
   DCHECK(!v4l2_thread_.IsRunning());
 
   v4l2_thread_.Stop();
   if (device_fd_ >= 0) {
     close(device_fd_);
   }
 }
 
 void VideoCaptureDeviceLinux::AllocateAndStart(
-    const VideoCaptureCapability& capture_format,
+    const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   if (v4l2_thread_.IsRunning()) {
     return;  // Wrong state.
   }
   v4l2_thread_.Start();
   v4l2_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureDeviceLinux::OnAllocateAndStart,
                  base::Unretained(this),
-                 capture_format.width,
-                 capture_format.height,
-                 capture_format.frame_rate,
+                 params.requested_format.frame_size.width(),
+                 params.requested_format.frame_size.height(),
+                 params.requested_format.frame_rate,
                  base::Passed(&client)));
 }
 
 void VideoCaptureDeviceLinux::StopAndDeAllocate() {
   if (!v4l2_thread_.IsRunning()) {
     return;  // Wrong state.
   }
   v4l2_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureDeviceLinux::OnStopAndDeAllocate,
@@ skipping 85 matching lines @@
       }
       DVLOG(2) << "Actual camera driverframerate: "
                << streamparm.parm.capture.timeperframe.denominator << "/"
                << streamparm.parm.capture.timeperframe.numerator;
     }
   }
   // TODO(mcasas): what should be done if the camera driver does not allow
   // framerate configuration, or the actual one is different from the desired?
 
   // Store our current width and height.
-  frame_info_.color =
+  capture_format_.frame_size.SetSize(video_fmt.fmt.pix.width,
+                                     video_fmt.fmt.pix.height);
+  capture_format_.frame_rate = frame_rate;
+  capture_format_.pixel_format =
       V4l2ColorToVideoCaptureColorFormat(video_fmt.fmt.pix.pixelformat);
-  frame_info_.width = video_fmt.fmt.pix.width;
-  frame_info_.height = video_fmt.fmt.pix.height;
-  frame_info_.frame_rate = frame_rate;
-  frame_info_.frame_size_type = VariableResolutionVideoCaptureDevice;
 
   // Start capturing.
   if (!AllocateVideoBuffers()) {
     // Error, We can not recover.
     SetErrorState("Allocate buffer failed");
     return;
   }
 
   // Start UVC camera.
   v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
@@ skipping 84 matching lines @@
     buffer.memory = V4L2_MEMORY_MMAP;
     // Dequeue a buffer.
     if (ioctl(device_fd_, VIDIOC_DQBUF, &buffer) == 0) {
       client_->OnIncomingCapturedFrame(
           static_cast<uint8*>(buffer_pool_[buffer.index].start),
           buffer.bytesused,
           base::Time::Now(),
           0,
           false,
           false,
-          frame_info_);
+          capture_format_);
 
       // Enqueue the buffer again.
       if (ioctl(device_fd_, 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));
       return;
@@ skipping 78 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();
 }
 
 }  // namespace media