Video Capture: extract storage info from pixel format in VideoCaptureFormat.

media/base/video_capture_types.h

 // 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.
 
 #ifndef MEDIA_BASE_VIDEO_CAPTURE_TYPES_H_
 #define MEDIA_BASE_VIDEO_CAPTURE_TYPES_H_
 
 #include <vector>
 
 #include "build/build_config.h"
 #include "media/base/media_export.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace media {
 
 // TODO(wjia): this type should be defined in a common place and
 // shared with device manager.
 typedef int VideoCaptureSessionId;
 
 // Color formats from camera. This list is sorted in order of preference.
 enum VideoPixelFormat {

[hubbe, 2015/06/18 19:23:11]

Would it be possible to unify VideoPixelFormat and VideoFrame::Format?

[mcasas, 2015/06/19 02:58:36]

Added a TODO(). It would not be trivial because
they are not fully coincidental (e.g. YV12A is only 
in VideoFrame::Format, YUY2 is only here, etc).

   PIXEL_FORMAT_I420,
   PIXEL_FORMAT_YV12,
   PIXEL_FORMAT_NV12,
   PIXEL_FORMAT_NV21,
   PIXEL_FORMAT_UYVY,
   PIXEL_FORMAT_YUY2,
   PIXEL_FORMAT_RGB24,
   PIXEL_FORMAT_RGB32,
   PIXEL_FORMAT_ARGB,
   PIXEL_FORMAT_MJPEG,
-  PIXEL_FORMAT_TEXTURE,  // Capture format as a GL texture.
-  PIXEL_FORMAT_GPUMEMORYBUFFER,
   PIXEL_FORMAT_UNKNOWN,  // Color format not set.
   PIXEL_FORMAT_MAX,
 };
 
+// Storage type for the pixels. In principle, all combinations of Storage and
+// Format are possible, though some are very typical, such as texture + ARGB,

[hubbe, 2015/06/18 19:23:11]

I don't think this is clear enough / struct.
What does texture + MJPEG mean? Is it allowed? Is the format ignored for
textures?

[mcasas, 2015/06/19 02:58:36]

Same as with VideoFrame, the specification of 
storage and pixel format are independent, so all
combinations are meaningful although perhaps some
are just not implemented. A texture MJPEG means
exactly what is says: a formatless buffer allocated
in the GPU (==texture) with data representing a
video frame in MJPEG pixel format.
No it isn't. But the only one used so far is ARGB.

[hubbe, 2015/06/23 23:35:40]

A texture is not a formatless buffer.
OpenGL doesn't give you direct access to the bytes of a texture, so it's not
possible to store arbitrary data in it.

+// and others are only available if the platform allows it e.g. GpuMemoryBuffer.
+enum VideoPixelStorage {

[hubbe, 2015/06/18 19:23:11]

Shouldn't this really be media::VideoFrame::StorageType?

[mcasas, 2015/06/19 02:58:36]

Again is only partially coincidental with
media::VideoFrame::StorageType, so although
it would be good, this is more reduced.

+  PIXEL_STORAGE_CPU,
+  PIXEL_STORAGE_TEXTURE,
+  PIXEL_STORAGE_GPUMEMORYBUFFER,
+};
+
 // Policies for capture devices that have source content that varies in size.
 // It is up to the implementation how the captured content will be transformed
 // (e.g., scaling and/or letterboxing) in order to produce video frames that
 // strictly adheree to one of these policies.
 enum ResolutionChangePolicy {
   // Capture device outputs a fixed resolution all the time. The resolution of
   // the first frame is the resolution for all frames.
   RESOLUTION_POLICY_FIXED_RESOLUTION,
 
   // Capture device is allowed to output frames of varying resolutions. The
@@ skipping 15 matching lines @@
 
 // Video capture format specification.
 // This class is used by the video capture device to specify the format of every
 // frame captured and returned to a client. It is also used to specify a
 // supported capture format by a device.
 struct MEDIA_EXPORT VideoCaptureFormat {
   VideoCaptureFormat();
   VideoCaptureFormat(const gfx::Size& frame_size,
                      float frame_rate,
                      VideoPixelFormat pixel_format);
+  VideoCaptureFormat(const gfx::Size& frame_size,
+                     float frame_rate,
+                     VideoPixelFormat pixel_format,
+                     VideoPixelStorage pixel_storage);
 
+  // TODO(mcasas): Remove this method http://crbug.com/501134.
   std::string ToString() const;
   static std::string PixelFormatToString(VideoPixelFormat format);
+  static std::string PixelStorageToString(VideoPixelStorage storage);
 
   // Returns the required buffer size to hold an image of a given
   // VideoCaptureFormat with no padding and tightly packed.
   size_t ImageAllocationSize() const;
 
   // Checks that all values are in the expected range. All limits are specified
   // in media::Limits.
   bool IsValid() const;
 
   bool operator==(const VideoCaptureFormat& other) const {
     return frame_size == other.frame_size &&
         frame_rate == other.frame_rate &&
         pixel_format == other.pixel_format;
   }
 
   gfx::Size frame_size;
   float frame_rate;
   VideoPixelFormat pixel_format;
+  VideoPixelStorage pixel_storage;
 };
 
 typedef std::vector<VideoCaptureFormat> VideoCaptureFormats;
 
 // Parameters for starting video capture.
 // This class is used by the client of a video capture device to specify the
 // format of frames in which the client would like to have captured frames
 // returned.
 struct MEDIA_EXPORT VideoCaptureParams {
   VideoCaptureParams();
@@ skipping 14 matching lines @@
 
 #if defined(OS_LINUX)
   // Indication to the Driver to try to use native GpuMemoryBuffers.
   bool use_native_gpu_memory_buffers;
 #endif
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_CAPTURE_TYPES_H_