media/capture/capture_resolution_chooser.h

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_CAPTURE_CAPTURE_RESOLUTION_CHOOSER_H_
   6 #define MEDIA_CAPTURE_CAPTURE_RESOLUTION_CHOOSER_H_
   7
   8 #include <vector>
   9
  10 #include "media/base/media_export.h"
  11 #include "media/base/video_capture_types.h"
  12 #include "ui/gfx/geometry/size.h"
  13
  14 namespace media {
  15
  16 // Encapsulates the logic that determines the capture frame resolution based on:
  17 //   1. The configured maximum frame resolution and resolution change policy.
  18 //   2. Changes to resolution of the source content.
  19 //   3. Changes to the (externally-computed) target data volume, provided in
  20 //      terms of the number of pixels in the frame.
  21 //
  22 // CaptureResolutionChooser always computes capture sizes less than the maximum
  23 // frame size, and adheres to the configured resolution change policy.  Within
  24 // those hard limits, the capture size is computed to be as close to the
  25 // targeted frame area as possible.
  26 //
  27 // In variable-resolution use cases, the capture sizes are "snapped" to a small
  28 // (i.e., usually less than a dozen) set of possibilities.  This is to prevent
  29 // the end-to-end system from having to deal with rapidly-changing video frame
  30 // resolutions that results from providing a fine-grained range of values.  The
  31 // possibile snapped frame sizes are computed relative to the resolution of the
  32 // source content: They are the same or smaller in size, and are of the same
  33 // aspect ratio.
  34 class MEDIA_EXPORT CaptureResolutionChooser {
  35  public:
  36   // media::ResolutionChangePolicy determines whether the variable frame
  37   // resolutions being computed must adhere to a fixed aspect ratio or not, or
  38   // that there must only be a single fixed resolution.
  39   CaptureResolutionChooser(
  40       const gfx::Size& max_frame_size,
  41       ResolutionChangePolicy resolution_change_policy);
  42   ~CaptureResolutionChooser();
  43
  44   // Returns the current capture frame resolution to use.
  45   gfx::Size capture_size() const {
  46     return capture_size_;
  47   }
  48
  49   // Updates the capture size based on a change in the resolution of the source
  50   // content.
  51   void SetSourceSize(const gfx::Size& source_size);
  52
  53   // Updates the capture size to target the given frame area, in terms of
  54   // gfx::Size::GetArea().  The initial target frame area is the maximum int
  55   // (i.e., always target the source size).
  56   void SetTargetFrameArea(int area);
  57
  58   // Search functions to, given a frame |area|, return the nearest snapped frame
  59   // size, or N size steps up/down.  Snapped frame sizes are based on the
  60   // current source size.
  61   gfx::Size FindNearestFrameSize(int area) const;
  62   gfx::Size FindLargerFrameSize(int area, int num_steps_up) const;
  63   gfx::Size FindSmallerFrameSize(int area, int num_steps_down) const;
  64
  65  private:
  66   // Called after any update that requires |capture_size_| be re-computed.
  67   void RecomputeCaptureSize();
  68
  69   // Recomputes the |snapped_sizes_| cache.
  70   void UpdateSnappedFrameSizes(const gfx::Size& constrained_size);
  71
  72   // Hard constraints.
  73   const gfx::Size max_frame_size_;
  74   const gfx::Size min_frame_size_;  // Computed from the ctor arguments.
  75
  76   // Specifies the set of heuristics to use.
  77   const ResolutionChangePolicy resolution_change_policy_;
  78
  79   // |capture_size_| will be computed such that its area is as close to this
  80   // value as possible.
  81   int target_area_;
  82
  83   // The current computed capture frame resolution.
  84   gfx::Size capture_size_;
  85
  86   // Cache of the set of possible values |capture_size_| can have, in order from
  87   // smallest to largest.  This is recomputed whenever UpdateSnappedFrameSizes()
  88   // is called.
  89   std::vector<gfx::Size> snapped_sizes_;
  90 };
  91
  92 }  // namespace media
  93
  94 #endif  // MEDIA_CAPTURE_RESOLUTION_CHOOSER_H_