1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103


media / capture / content / capture_resolution_chooser.h [blame]

// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef MEDIA_CAPTURE_CONTENT_CAPTURE_RESOLUTION_CHOOSER_H_
#define MEDIA_CAPTURE_CONTENT_CAPTURE_RESOLUTION_CHOOSER_H_

#include <vector>

#include "media/capture/capture_export.h"
#include "ui/gfx/geometry/size.h"

namespace media {

// Encapsulates the logic that determines the capture frame resolution based on:
//   1. The configured minimum/maximum frame resolution.
//   2. Whether the capture frame resolution must be of a fixed aspect ratio.
//   3. Changes to resolution of the source content.
//   4. Changes to the (externally-computed) target data volume, provided in
//      terms of the number of pixels in the frame.
//
// In variable-resolution use cases, the capture sizes are "snapped" to a small
// (i.e., usually less than a dozen) set of possibilities.  This is to prevent
// the end-to-end system from having to deal with rapidly-changing video frame
// resolutions that results from providing a fine-grained range of values.  The
// possible snapped frame sizes are computed relative to the resolution of the
// source content: They are the same or smaller in size, and are of the same
// aspect ratio.
class CAPTURE_EXPORT CaptureResolutionChooser {
 public:
  // Default constructor. Capture size is fixed at kDefaultCaptureSize until
  // SetConstraints() is called.
  CaptureResolutionChooser();

  ~CaptureResolutionChooser();

  // Returns the current capture frame resolution to use.
  const gfx::Size& capture_size() const { return capture_size_; }

  // Specifies a new range of acceptable capture resolutions and whether a fixed
  // aspect ratio is required. When |min_frame_size| is equal to
  // |max_frame_size|, capture resolution will be held constant. If a fixed
  // aspect ratio is required, the aspect ratio of |max_frame_size| is used.
  void SetConstraints(const gfx::Size& min_frame_size,
                      const gfx::Size& max_frame_size,
                      bool use_fixed_aspect_ratio);

  // Returns the currently-set source size.
  const gfx::Size& source_size() const { return source_size_; }

  // Updates the capture size based on a change in the resolution of the source
  // content.
  void SetSourceSize(const gfx::Size& source_size);

  // Updates the capture size to target the given frame area, in terms of
  // gfx::Size::GetArea().  The initial target frame area is the maximum int
  // (i.e., always target the source size).
  void SetTargetFrameArea(int area);

  // Search functions to, given a frame |area|, return the nearest snapped frame
  // size, or N size steps up/down.  Snapped frame sizes are based on the
  // current source size.
  gfx::Size FindNearestFrameSize(int area) const;
  gfx::Size FindLargerFrameSize(int area, int num_steps_up) const;
  gfx::Size FindSmallerFrameSize(int area, int num_steps_down) const;

  // The default capture size, if SetConstraints() is never called.
  static constexpr gfx::Size kDefaultCaptureSize = gfx::Size(640, 360);

 private:
  // Called after any update that requires |capture_size_| be re-computed.
  void RecomputeCaptureSize();

  // Recomputes the |snapped_sizes_| cache.
  void UpdateSnappedFrameSizes();

  // Hard constraints.
  gfx::Size min_frame_size_;
  gfx::Size max_frame_size_;

  // If true, adjust the |source_size_| to match the aspect ratio of
  // |max_frame_size_| before computing the snapped frame sizes.
  bool apply_aspect_ratio_adjustment_;

  // Current source size.
  gfx::Size source_size_;

  // |capture_size_| will be computed such that its area is as close to this
  // value as possible.
  int target_area_;

  // The current computed capture frame resolution.
  gfx::Size capture_size_;

  // Cache of the set of possible values |capture_size_| can have, in order from
  // smallest to largest.  This is recomputed whenever UpdateSnappedFrameSizes()
  // is called.
  std::vector<gfx::Size> snapped_sizes_;
};

}  // namespace media

#endif  // MEDIA_CAPTURE_CONTENT_CAPTURE_RESOLUTION_CHOOSER_H_