Add VideoCaptureDevice::GetDeviceSupportedFormats to interface + implementation for Linux and Fake

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 78 matching lines @@
   GetListOfUsableFourCCs(false, &usable_fourccs);
 
   memset(&fmtdesc, 0, sizeof(v4l2_fmtdesc));
   fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
   while (ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
     if (std::find(usable_fourccs.begin(), usable_fourccs.end(),
                   fmtdesc.pixelformat) != usable_fourccs.end())
       return true;
 
-    fmtdesc.index++;
+    ++fmtdesc.index;
   }
   return false;
 }
 
 void VideoCaptureDevice::GetDeviceNames(Names* device_names) {
   int fd = -1;
 
   // Empty the name list.
   device_names->clear();
 
@@ skipping 135 matching lines @@
   // Make sure no buffers are still allocated.
   // This can happen (theoretically) if an error occurs when trying to stop
   // the camera.
   DeAllocateVideoBuffers();
 }
 
 const VideoCaptureDevice::Name& VideoCaptureDeviceLinux::device_name() {
   return device_name_;
 }
 
+void VideoCaptureDeviceLinux::GetDeviceSupportedFormats(
+    const std::string& device_name,
+    VideoCaptureFormats* capture_formats) {
+
+  int fd = open(device_name.c_str(), O_RDONLY);
+  if (fd < 0)
+    return;
+
+  media::VideoCaptureCapability capture_format;
+
+  v4l2_capability device;
+  // Test if this is a V4L2 capture device.
+  if ((ioctl(fd, VIDIOC_QUERYCAP, &device) == 0) &&
+      (device.capabilities & V4L2_CAP_VIDEO_CAPTURE) &&
+      !(device.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
+    // 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 = media::V4l2ColorToVideoCaptureColorFormat(
+          static_cast<int32>(pixel_format.pixelformat));
+
+      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;
+        } else if (frame_size.type == V4L2_FRMSIZE_TYPE_STEPWISE) {
+          // What to do here? We get a min-max pair for width and height, and a
+          // step for each dimensions. Is not a crazy format, ViVi uses it.
+          // TODO(mcasas) see crbug.com/249953
+          NOTIMPLEMENTED();
+        } else if (frame_size.type == V4L2_FRMSIZE_TYPE_CONTINUOUS) {
+          // Same here as the case before: TODO(mcasas) see crbug.com/249953
+          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) {
+            capture_format.frame_rate =
+                (frame_interval.discrete.numerator != 0)
+                    ? (static_cast<float>(frame_interval.discrete.denominator) /
+                       static_cast<float>(frame_interval.discrete.numerator))
+                    : 0;
+
+          } else if (frame_interval.type == V4L2_FRMIVAL_TYPE_CONTINUOUS) {
+            // Same here as the case above: TODO(mcasas) see crbug.com/249953
+            NOTIMPLEMENTED();
+            break;
+          } else if (frame_interval.type == V4L2_FRMIVAL_TYPE_STEPWISE) {
+            // Same here as the case before: TODO(mcasas) see crbug.com/249953
+            NOTIMPLEMENTED();
+            break;
+          }
+          capture_formats->insert(capture_formats->end(), capture_format);
+          ++frame_interval.index;
+        }
+        ++frame_size.index;
+      }
+      ++pixel_format.index;
+    }
+  } else {
+    // The selected device is not video capture as we like it.
+    capture_formats->clear();
+  }
+  close(fd);
+}
+
 void VideoCaptureDeviceLinux::OnAllocate(int width,
                                          int height,
                                          int frame_rate,
                                          EventHandler* observer) {
   DCHECK_EQ(v4l2_thread_.message_loop(), base::MessageLoop::current());
 
   observer_ = observer;
 
   // Need to open camera with O_RDWR after Linux kernel 3.3.
   if ((device_fd_ = open(device_name_.id().c_str(), O_RDWR)) < 0) {
@@ skipping 20 matching lines @@
                          &v4l2_formats);
 
   v4l2_fmtdesc fmtdesc;
   memset(&fmtdesc, 0, sizeof(v4l2_fmtdesc));
   fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
   // Enumerate image formats.
   std::list<int>::iterator best = v4l2_formats.end();
   while (ioctl(device_fd_, VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
     best = std::find(v4l2_formats.begin(), best, fmtdesc.pixelformat);
-    fmtdesc.index++;
+    ++fmtdesc.index;
   }
 
   if (best == v4l2_formats.end()) {
     SetErrorState("Failed to find a supported camera format.");
     return;
   }
 
   // Set format and frame size now.
   v4l2_format video_fmt;
   memset(&video_fmt, 0, sizeof(video_fmt));
@@ skipping 136 matching lines @@
     }
     v4l2_thread_.message_loop()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&VideoCaptureDeviceLinux::OnCaptureTask,
                    base::Unretained(this)),
         base::TimeDelta::FromMilliseconds(kCaptureSelectWaitMs));
   }
 
   // Check if select timeout.
   if (result == 0) {
-    timeout_count_++;
+    ++timeout_count_;
     if (timeout_count_ >= kContinuousTimeoutLimit) {
       SetErrorState(base::StringPrintf(
           "Continuous timeout %d times", timeout_count_));
       timeout_count_ = 0;
       return;
     }
   } else {
     timeout_count_ = 0;
   }
 
@@ skipping 40 matching lines @@
   }
 
   if (r_buffer.count > kMaxVideoBuffers) {
     r_buffer.count = kMaxVideoBuffers;
   }
 
   buffer_pool_size_ = r_buffer.count;
 
   // Map the buffers.
   buffer_pool_ = new Buffer[r_buffer.count];
-  for (unsigned int i = 0; i < r_buffer.count; i++) {
+  for (unsigned int i = 0; i < r_buffer.count; ++i) {
     v4l2_buffer buffer;
     memset(&buffer, 0, sizeof(buffer));
     buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     buffer.memory = V4L2_MEMORY_MMAP;
     buffer.index = i;
 
     if (ioctl(device_fd_, VIDIOC_QUERYBUF, &buffer) < 0) {
       return false;
     }
 
@@ skipping 11 matching lines @@
     }
   }
   return true;
 }
 
 void VideoCaptureDeviceLinux::DeAllocateVideoBuffers() {
   if (!buffer_pool_)
     return;
 
   // Unmaps buffers.
-  for (int i = 0; i < buffer_pool_size_; i++) {
+  for (int i = 0; i < buffer_pool_size_; ++i) {
     munmap(buffer_pool_[i].start, buffer_pool_[i].length);
   }
   v4l2_requestbuffers r_buffer;
   memset(&r_buffer, 0, sizeof(r_buffer));
   r_buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   r_buffer.memory = V4L2_MEMORY_MMAP;
   r_buffer.count = 0;
 
   if (ioctl(device_fd_, VIDIOC_REQBUFS, &r_buffer) < 0) {
     SetErrorState("Failed to reset buf.");
   }
 
   delete [] buffer_pool_;
   buffer_pool_ = NULL;
   buffer_pool_size_ = 0;
 }
 
 void VideoCaptureDeviceLinux::SetErrorState(const std::string& reason) {
   DVLOG(1) << reason;
   state_ = kError;
   observer_->OnError();
 }
 
 }  // namespace media