New resolution change policies for desktop and tab capture.

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 "media/base/media_export.h"
@@ skipping 20 matching lines @@
   PIXEL_FORMAT_TEXTURE,  // Capture format as a GL texture.
   PIXEL_FORMAT_GPUMEMORYBUFFER,
   PIXEL_FORMAT_UNKNOWN,  // Color format not set.
   PIXEL_FORMAT_MAX,
 };
 
 // Policies for capture devices that has source content with dynamic resolution.
 enum ResolutionChangePolicy {
   // Capture device outputs a fixed resolution all the time. The resolution of
   // the first frame is the resolution for all frames.
-  // It is implementation specific for the capture device to scale, letter-box
+  // It is implementation-specific for the capture device to scale, letter-box
   // and pillar-box. The only guarantee is that resolution will never change.
-  RESOLUTION_POLICY_FIXED,
+  RESOLUTION_POLICY_FIXED_RESOLUTION,
 
-  // Capture device outputs frames with dynamic resolution. The width and height
-  // will not exceed the maximum dimensions specified. The typical scenario is
-  // the frames will have the same aspect ratio as the original content and
-  // scaled down to fit inside the limit.
-  RESOLUTION_POLICY_DYNAMIC_WITHIN_LIMIT,
+  // Capture device is allowed to output frames of varying resolutions. The
+  // width and height will not exceed the maximum dimensions specified. The
+  // aspect ratio of the frames will be fixed to the aspect ratio of the maximum
+  // dimensions.
+  // It is implementation-specific for the capture device to scale, letter-box

[mcasas, 2015/05/07 22:10:00]

nit: I'd refactor this comment out, somehow saying that it applies to
both _FIXED_ polcies, otherwise is repeated verbatim.

[miu, 2015/05/08 06:43:34]

Done.

+  // and pillar-box. The only guarantee is that the aspect ratio will never
+  // change.
+  RESOLUTION_POLICY_FIXED_ASPECT_RATIO,
+
+  // Capture device is allowed to output frames of varying resolutions not
+  // exceeding the maximum dimensions specified.
+  RESOLUTION_POLICY_ANY_WITHIN_LIMIT,

[mcasas, 2015/05/07 22:10:00]

IIUC, only Desktop and Tab capture really care about these
division, i.e. the split of ...DYNAMIC_WITHIN_LIMIT into 
...FIXED_ASPECT_RATIO and ...ANY_WITHIN_LIMIT, however, 
I only see ThreadSafeCaptureOracle::UpdateCaptureSize()
and DesktopCaptureDevice::Core::RefreshCaptureFormat()
reacting to RESOLUTION_POLICY_ANY_WITHIN_LIMIT
and not to RESOLUTION_POLICY_FIXED_ASPECT_RATIO,
is this correct?

[miu, 2015/05/08 06:43:34]

Yes, that is correct.  The current implementations will still do the right
thing.  For example, if FIXED_ASPECT_RATIO is specified, they will actually
provide the FIXED_RESOLUTION behavior.  That is acceptable since
FIXED_RESOLUTION frames are all the same aspect ratio.

The whole reason for this change is to support my next CL (probably up for
review tomorrow or Monday).  That's where all three resolution change policies
will be implemented for desktop and tab capture.  See linked bug for details of
what this is all about.

 
   RESOLUTION_POLICY_LAST,
 };
 
 // Some drivers use rational time per frame instead of float frame rate, this
 // constant k is used to convert between both: A fps -> [k/k*A] seconds/frame.
 const int kFrameRatePrecision = 10000;
 
 // Video capture format specification.
 // This class is used by the video capture device to specify the format of every
@@ skipping 10 matching lines @@
   static std::string PixelFormatToString(VideoPixelFormat format);
 
   // 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;
 };
 
 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.
 class MEDIA_EXPORT VideoCaptureParams {
  public:
   VideoCaptureParams();
 
+  bool operator==(const VideoCaptureParams& other) const {
+    return requested_format == other.requested_format &&
+        resolution_change_policy == other.resolution_change_policy;
+  }
+
   // Requests a resolution and format at which the capture will occur.
   VideoCaptureFormat requested_format;
 
   // Policy for resolution change.
   ResolutionChangePolicy resolution_change_policy;
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_CAPTURE_TYPES_H_