Introduce SelectSettings algorithm for MediaStream video tracks.

content/renderer/media/video_track_adapter.cc

 // 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.
 
 #include "content/renderer/media/video_track_adapter.h"
 
 #include <algorithm>
 #include <limits>
+#include <memory>
+#include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 34 matching lines @@
 // VideoFrameResolutionAdapter is created on and lives on the IO-thread. It does
 // the resolution adaptation and delivers frames to all registered tracks on the
 // IO-thread. All method calls must be on the IO-thread.
 class VideoTrackAdapter::VideoFrameResolutionAdapter
     : public base::RefCountedThreadSafe<VideoFrameResolutionAdapter> {
  public:
   // Setting |max_frame_rate| to 0.0, means that no frame rate limitation
   // will be done.
   VideoFrameResolutionAdapter(
       scoped_refptr<base::SingleThreadTaskRunner> render_message_loop,
-      const gfx::Size& max_size,
-      double min_aspect_ratio,
-      double max_aspect_ratio,
-      double max_frame_rate);
+      const VideoTrackAdapterSettings& settings);
 
   // Add |callback| to receive video frames on the IO-thread.
   // |callback| will however be released on the main render thread.
   void AddCallback(const MediaStreamVideoTrack* track,
                    const VideoCaptureDeliverFrameCB& callback);
 
   // Removes |callback| associated with |track| from receiving video frames if
   // |track| has been added. It is ok to call RemoveCallback even if the |track|
   // has not been added. The |callback| is released on the main render thread.
   void RemoveCallback(const MediaStreamVideoTrack* track);
 
   void DeliverFrame(const scoped_refptr<media::VideoFrame>& frame,
                     const base::TimeTicks& estimated_capture_time);
 
   // Returns true if all arguments match with the output of this adapter.
-  bool ConstraintsMatch(const gfx::Size& max_size,
-                        double min_aspect_ratio,
-                        double max_aspect_ratio,
-                        double max_frame_rate) const;
+  bool SettingsMatch(const VideoTrackAdapterSettings& settings) const;
 
   bool IsEmpty() const;
 
  private:
   virtual ~VideoFrameResolutionAdapter();
   friend class base::RefCountedThreadSafe<VideoFrameResolutionAdapter>;
 
   void DoDeliverFrame(const scoped_refptr<media::VideoFrame>& frame,
                       const base::TimeTicks& estimated_capture_time);
 
@@ skipping 18 matching lines @@
   double max_frame_rate_;
   double keep_frame_counter_;
 
   typedef std::pair<const MediaStreamVideoTrack*, VideoCaptureDeliverFrameCB>
       VideoIdCallbackPair;
   std::vector<VideoIdCallbackPair> callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameResolutionAdapter);
 };
 
-VideoTrackAdapter::
-VideoFrameResolutionAdapter::VideoFrameResolutionAdapter(
+VideoTrackAdapter::VideoFrameResolutionAdapter::VideoFrameResolutionAdapter(
     scoped_refptr<base::SingleThreadTaskRunner> render_message_loop,
-    const gfx::Size& max_size,
-    double min_aspect_ratio,
-    double max_aspect_ratio,
-    double max_frame_rate)
+    const VideoTrackAdapterSettings& settings)
     : renderer_task_runner_(render_message_loop),
-      max_frame_size_(max_size),
-      min_aspect_ratio_(min_aspect_ratio),
-      max_aspect_ratio_(max_aspect_ratio),
+      max_frame_size_(settings.max_width, settings.max_height),
+      min_aspect_ratio_(settings.min_aspect_ratio),
+      max_aspect_ratio_(settings.max_aspect_ratio),
       frame_rate_(MediaStreamVideoSource::kDefaultFrameRate),
       last_time_stamp_(base::TimeDelta::Max()),
-      max_frame_rate_(max_frame_rate),
+      max_frame_rate_(settings.max_frame_rate),
       keep_frame_counter_(0.0) {
   DCHECK(renderer_task_runner_.get());
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK_GE(max_aspect_ratio_, min_aspect_ratio_);
   CHECK_NE(0, max_aspect_ratio_);
 
   const std::string max_fps_str =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kWebRtcMaxCaptureFramerate);
   if (!max_fps_str.empty()) {
     double value;
     if (base::StringToDouble(max_fps_str, &value) && value >= 0.0) {
-      DVLOG(1) << "Overriding max frame rate.  Was=" << max_frame_rate
-              << ", Now=" << value;
+      DVLOG(1) << "Overriding max frame rate.  Was=" << max_frame_rate_
+               << ", Now=" << value;
       max_frame_rate_ = value;
     } else {
       DLOG(ERROR) << "Unable to set max fps to " << max_fps_str;
     }
   }
 
   DVLOG(3) << "VideoFrameResolutionAdapter("
-          << "{ max_width =" << max_frame_size_.width() << "}, "
-          << "{ max_height =" << max_frame_size_.height() << "}, "
-          << "{ min_aspect_ratio =" << min_aspect_ratio << "}, "
-          << "{ max_aspect_ratio_ =" << max_aspect_ratio_ << "}"
-          << "{ max_frame_rate_ =" << max_frame_rate_ << "}) ";
+           << "{ max_width =" << max_frame_size_.width() << "}, "
+           << "{ max_height =" << max_frame_size_.height() << "}, "
+           << "{ min_aspect_ratio =" << min_aspect_ratio_ << "}, "
+           << "{ max_aspect_ratio_ =" << max_aspect_ratio_ << "}"
+           << "{ max_frame_rate_ =" << max_frame_rate_ << "}) ";
 }
 
 VideoTrackAdapter::
 VideoFrameResolutionAdapter::~VideoFrameResolutionAdapter() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(callbacks_.empty());
 }
 
 void VideoTrackAdapter::VideoFrameResolutionAdapter::AddCallback(
     const MediaStreamVideoTrack* track,
@@ skipping 70 matching lines @@
 
     DVLOG(3) << "desired size  " << desired_size.ToString()
              << " output natural size "
              << video_frame->natural_size().ToString()
              << " output visible rect  "
              << video_frame->visible_rect().ToString();
   }
   DoDeliverFrame(video_frame, estimated_capture_time);
 }
 
-bool VideoTrackAdapter::VideoFrameResolutionAdapter::ConstraintsMatch(
-    const gfx::Size& max_size,
-    double min_aspect_ratio,
-    double max_aspect_ratio,
-    double max_frame_rate) const {
+bool VideoTrackAdapter::VideoFrameResolutionAdapter::SettingsMatch(
+    const VideoTrackAdapterSettings& settings) const {
   DCHECK(io_thread_checker_.CalledOnValidThread());
-  return max_frame_size_ == max_size &&
-      min_aspect_ratio_ == min_aspect_ratio &&
-      max_aspect_ratio_ == max_aspect_ratio &&
-      max_frame_rate_ == max_frame_rate;
+  return max_frame_size_.width() == settings.max_width &&
+         max_frame_size_.height() == settings.max_height &&
+         min_aspect_ratio_ == settings.min_aspect_ratio &&
+         max_aspect_ratio_ == settings.max_aspect_ratio &&
+         max_frame_rate_ == settings.max_frame_rate;
 }
 
 bool VideoTrackAdapter::VideoFrameResolutionAdapter::IsEmpty() const {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   return callbacks_.empty();
 }
 
 void VideoTrackAdapter::VideoFrameResolutionAdapter::DoDeliverFrame(
     const scoped_refptr<media::VideoFrame>& frame,
     const base::TimeTicks& estimated_capture_time) {
@@ skipping 53 matching lines @@
   keep_frame_counter_ += max_frame_rate_ / frame_rate_;
   if (keep_frame_counter_ >= 1) {
     keep_frame_counter_ -= 1;
     // Keep the frame.
     return false;
   }
   DVLOG(3) << "Drop frame. Input frame_rate_ " << frame_rate_ << ".";
   return true;
 }
 
+VideoTrackAdapterSettings::VideoTrackAdapterSettings(int max_width,
+                                                     int max_height,
+                                                     double min_aspect_ratio,
+                                                     double max_aspect_ratio,
+                                                     double max_frame_rate)
+    : max_width(max_width),
+      max_height(max_height),
+      min_aspect_ratio(min_aspect_ratio),
+      max_aspect_ratio(max_aspect_ratio),
+      max_frame_rate(max_frame_rate) {
+  DCHECK_GE(max_width, 1);
+  DCHECK_GE(max_height, 1);
+  DCHECK_GE(min_aspect_ratio, 0.0);
+  DCHECK_GE(max_aspect_ratio, min_aspect_ratio);
+  DCHECK_GE(max_frame_rate, 0.0);
+}
+
 VideoTrackAdapter::VideoTrackAdapter(
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
     : io_task_runner_(io_task_runner),
       renderer_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       monitoring_frame_rate_(false),
       muted_state_(false),
       frame_counter_(0),
       source_frame_rate_(0.0f) {
   DCHECK(io_task_runner);
 }
 
 VideoTrackAdapter::~VideoTrackAdapter() {
   DCHECK(adapters_.empty());
 }
 
 void VideoTrackAdapter::AddTrack(const MediaStreamVideoTrack* track,
                                  VideoCaptureDeliverFrameCB frame_callback,
-                                 int max_width,
-                                 int max_height,
-                                 double min_aspect_ratio,
-                                 double max_aspect_ratio,
-                                 double max_frame_rate) {
+                                 const VideoTrackAdapterSettings& settings) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   io_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&VideoTrackAdapter::AddTrackOnIO, this, track, frame_callback,
-                 gfx::Size(max_width, max_height), min_aspect_ratio,
-                 max_aspect_ratio, max_frame_rate));
+      FROM_HERE, base::Bind(&VideoTrackAdapter::AddTrackOnIO, this, track,
+                            frame_callback, settings));
 }
 
-void VideoTrackAdapter::AddTrackOnIO(const MediaStreamVideoTrack* track,
-                                     VideoCaptureDeliverFrameCB frame_callback,
-                                     const gfx::Size& max_frame_size,
-                                     double min_aspect_ratio,
-                                     double max_aspect_ratio,
-                                     double max_frame_rate) {
+void VideoTrackAdapter::AddTrackOnIO(
+    const MediaStreamVideoTrack* track,
+    VideoCaptureDeliverFrameCB frame_callback,
+    const VideoTrackAdapterSettings& settings) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   scoped_refptr<VideoFrameResolutionAdapter> adapter;
   for (const auto& frame_adapter : adapters_) {
-    if (frame_adapter->ConstraintsMatch(max_frame_size, min_aspect_ratio,
-                                        max_aspect_ratio, max_frame_rate)) {
+    if (frame_adapter->SettingsMatch(settings)) {
       adapter = frame_adapter.get();
       break;
     }
   }
   if (!adapter.get()) {
-    adapter = new VideoFrameResolutionAdapter(renderer_task_runner_,
-                                              max_frame_size,
-                                              min_aspect_ratio,
-                                              max_aspect_ratio,
-                                              max_frame_rate);
+    adapter = new VideoFrameResolutionAdapter(renderer_task_runner_, settings);
     adapters_.push_back(adapter);
   }
 
   adapter->AddCallback(track, frame_callback);
 }
 
 void VideoTrackAdapter::RemoveTrack(const MediaStreamVideoTrack* track) {
   DCHECK(thread_checker_.CalledOnValidThread());
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoTrackAdapter::RemoveTrackOnIO, this, track));
@@ skipping 126 matching lines @@
   }
 
   io_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&VideoTrackAdapter::CheckFramesReceivedOnIO, this,
                             set_muted_state_callback, frame_counter_),
       base::TimeDelta::FromSecondsD(kNormalFrameTimeoutInFrameIntervals /
                                     source_frame_rate_));
 }
 
 }  // namespace content