Add support for multiple V4L2 video devices of the same type.

media/gpu/v4l2_image_processor.h

 // Copyright 2014 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.
 
 #ifndef MEDIA_GPU_V4L2_IMAGE_PROCESSOR_H_
 #define MEDIA_GPU_V4L2_IMAGE_PROCESSOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 37 matching lines @@
                   gfx::Size output_allocated_size,
                   int num_buffers,
                   const base::Closure& error_cb);
 
   // Returns a vector of dmabuf file descriptors, exported for V4L2 output
   // buffer with |index|. The size of vector will be the number of planes of the
   // buffer. Return an empty vector on failure.
   std::vector<base::ScopedFD> GetDmabufsForOutputBuffer(
       int output_buffer_index);
 
-  // Returns a vector of supported input formats in fourcc. This can be called
-  // before Initialize.
-  std::vector<uint32_t> GetSupportedInputFormats();
+  // Return true if image processing is supported on this platform.

[kcwu, 2016/10/07 11:19:05]

s/Return/Returns/

[Pawel Osciak, 2016/10/11 06:13:46]

Done.

+  static bool IsSupported();
 
-  // Returns a vector of supported output formats in fourcc. This can be called
-  // before Initialize.
-  std::vector<uint32_t> GetSupportedOutputFormats();
+  // Returns a vector of supported input formats in fourcc.
+  static std::vector<uint32_t> GetSupportedInputFormats();
 
-  // Gets the output allocated size and number of planes given |pixelformat|
-  // fourcc and visible size |size|. Return true if success. The adjusted coded
-  // size will be stored in |size| and the number of planes will be stored in
-  // |num_planes|. This can be called before Initialize.
-  bool TryOutputFormat(uint32_t pixelformat,
-                       gfx::Size* size,
-                       size_t* num_planes);
+  // Returns a vector of supported output formats in fourcc.
+  static std::vector<uint32_t> GetSupportedOutputFormats();
+
+  // Gets output allocated size and number of planes required by the device
+  // for conversion from |input_pixelformat| to |output_pixelformat|, for
+  // visible size |size|. Returns true on success. Adjusted coded size will be
+  // stored in |size| and the number of planes will be stored in |num_planes|.
+  static bool TryOutputFormat(uint32_t input_pixelformat,
+                              uint32_t output_pixelformat,
+                              gfx::Size* size,
+                              size_t* num_planes);
 
   // Returns input allocated size required by the processor to be fed with.
   gfx::Size input_allocated_size() const { return input_allocated_size_; }
 
   // Returns output allocated size required by the processor.
   gfx::Size output_allocated_size() const { return output_allocated_size_; }
 
   // Callback to be used to return the index of a processed image to the
   // client. After the client is done with the frame, call Process with the
   // index to return the output buffer to the image processor.
@@ skipping 147 matching lines @@
 
   // Weak factory for producing weak pointers on the child thread.
   base::WeakPtrFactory<V4L2ImageProcessor> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2ImageProcessor);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_V4L2_IMAGE_PROCESSOR_H_