path: root/chromium/content/renderer/media/stream/media_stream_constraints_util_audio.cc

// Copyright 2017 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/stream/media_stream_constraints_util_audio.h"

#include <algorithm>
#include <cmath>
#include <utility>
#include <vector>

#include "base/strings/string_number_conversions.h"
#include "content/common/media/media_stream_controls.h"
#include "content/renderer/media/stream/media_stream_audio_source.h"
#include "content/renderer/media/stream/media_stream_constraints_util_sets.h"
#include "content/renderer/media/stream/media_stream_video_source.h"
#include "content/renderer/media/stream/processed_local_audio_source.h"
#include "media/base/limits.h"
#include "third_party/blink/public/platform/web_media_constraints.h"
#include "third_party/blink/public/platform/web_string.h"

namespace content {

namespace {

enum BoolConstraint {
  // Constraints not related to audio processing.
  HOTWORD_ENABLED,
  DISABLE_LOCAL_ECHO,
  RENDER_TO_ASSOCIATED_SINK,

  // Constraints that enable/disable audio processing.
  ECHO_CANCELLATION,
  GOOG_ECHO_CANCELLATION,

  // Constraints that control audio-processing behavior.
  GOOG_AUDIO_MIRRORING,
  GOOG_AUTO_GAIN_CONTROL,
  GOOG_EXPERIMENTAL_ECHO_CANCELLATION,
  GOOG_TYPING_NOISE_DETECTION,
  GOOG_NOISE_SUPPRESSION,
  GOOG_EXPERIMENTAL_NOISE_SUPPRESSION,
  GOOG_BEAMFORMING,
  GOOG_HIGHPASS_FILTER,
  GOOG_EXPERIMENTAL_AUTO_GAIN_CONTROL,
  NUM_BOOL_CONSTRAINTS
};

// This struct groups related fields or entries from AudioProcessingProperties,
// SingleDeviceCandidateSet::bool_sets_ and blink::WebMediaTrackConstraintSet.
struct AudioPropertyConstraintPair {
  bool AudioProcessingProperties::* audio_property;
  BoolConstraint bool_set_index;
};

// Boolean audio properties that are mapped directly to a boolean constraint
// and which are subject to the same processing.
const AudioPropertyConstraintPair kAudioPropertyConstraintMap[] = {
    {&AudioProcessingProperties::goog_auto_gain_control,
     GOOG_AUTO_GAIN_CONTROL},
    {&AudioProcessingProperties::goog_experimental_echo_cancellation,
     GOOG_EXPERIMENTAL_ECHO_CANCELLATION},
    {&AudioProcessingProperties::goog_typing_noise_detection,
     GOOG_TYPING_NOISE_DETECTION},
    {&AudioProcessingProperties::goog_noise_suppression,
     GOOG_NOISE_SUPPRESSION},
    {&AudioProcessingProperties::goog_experimental_noise_suppression,
     GOOG_EXPERIMENTAL_NOISE_SUPPRESSION},
    {&AudioProcessingProperties::goog_beamforming, GOOG_BEAMFORMING},
    {&AudioProcessingProperties::goog_highpass_filter, GOOG_HIGHPASS_FILTER},
    {&AudioProcessingProperties::goog_experimental_auto_gain_control,
     GOOG_EXPERIMENTAL_AUTO_GAIN_CONTROL}};

// TODO(guidou): Remove this function. http://crbug.com/796955
std::string MediaPointToString(const media::Point& point) {
  std::string point_string;
  point_string.append(base::NumberToString(point.x()));
  point_string.append(" ");
  point_string.append(base::NumberToString(point.y()));
  point_string.append(" ");
  point_string.append(base::NumberToString(point.z()));

  return point_string;
}

// TODO(guidou): Remove this function. http://crbug.com/796955
std::string MediaPointsToString(const std::vector<media::Point>& points) {
  std::string points_string;
  if (!points.empty()) {
    for (size_t i = 0; i < points.size() - 1; ++i) {
      points_string.append(MediaPointToString(points[i]));
      points_string.append("  ");
    }
    points_string.append(MediaPointToString(points.back()));
  }

  return points_string;
}

// Selects the best value from the nonempty |set|, subject to |constraint|. The
// first selection criteria is equality to |constraint.Ideal()|, followed by
// equality to |default_value|. There is always a single best value.
bool SelectBool(const DiscreteSet<bool>& set,
                const blink::BooleanConstraint& constraint,
                bool default_value) {
  DCHECK(!set.IsEmpty());
  if (constraint.HasIdeal() && set.Contains(constraint.Ideal()))
    return constraint.Ideal();

  if (set.is_universal())
    return default_value;

  DCHECK_EQ(set.elements().size(), 1U);
  return set.FirstElement();
}

// Selects the best value from the nonempty |set|, subject to |constraint|. The
// only decision criteria is equality to |constraint.Ideal()|. If there is no
// single best value in |set|, returns nullopt.
base::Optional<bool> SelectOptionalBool(
    const DiscreteSet<bool>& set,
    const blink::BooleanConstraint& constraint) {
  DCHECK(!set.IsEmpty());
  if (constraint.HasIdeal() && set.Contains(constraint.Ideal()))
    return constraint.Ideal();

  if (set.is_universal())
    return base::Optional<bool>();

  DCHECK_EQ(set.elements().size(), 1U);
  return set.FirstElement();
}

// Selects the best value from the nonempty |set|, subject to |constraint|. The
// first selection criteria is inclusion in |constraint.Ideal()|, followed by
// equality to |default_value|. There is always a single best value.
std::string SelectString(const DiscreteSet<std::string>& set,
                         const blink::StringConstraint& constraint,
                         const std::string& default_value) {
  DCHECK(!set.IsEmpty());
  if (constraint.HasIdeal()) {
    for (const blink::WebString& ideal_candidate : constraint.Ideal()) {
      std::string candidate = ideal_candidate.Utf8();
      if (set.Contains(candidate))
        return candidate;
    }
  }

  if (set.Contains(default_value))
    return default_value;

  return set.FirstElement();
}

// Selects the best value from the nonempty |set|, subject to |constraint|. The
// only decision criteria is inclusion in |constraint.Ideal()|. If there is no
// single best value in |set|, returns nullopt.
base::Optional<std::string> SelectOptionalString(
    const DiscreteSet<std::string>& set,
    const blink::StringConstraint& constraint) {
  DCHECK(!set.IsEmpty());
  if (constraint.HasIdeal()) {
    for (const auto& ideal_candidate : constraint.Ideal()) {
      std::string candidate = ideal_candidate.Utf8();
      if (set.Contains(candidate))
        return candidate;
    }
  }

  if (set.is_universal())
    return base::Optional<std::string>();

  return set.FirstElement();
}

bool SelectEnableSwEchoCancellation(
    base::Optional<bool> echo_cancellation,
    base::Optional<bool> goog_echo_cancellation,
    const media::AudioParameters& audio_parameters,
    bool default_audio_processing_value,
    bool should_enable_experimental_hw_echo_cancellation) {
  // If there is hardware echo cancellation, return false.
  const bool has_hw_echo_canceller =
      (audio_parameters.effects() & media::AudioParameters::ECHO_CANCELLER);
  const bool has_experimental_hw_echo_canceller =
      (audio_parameters.effects() &
       media::AudioParameters::EXPERIMENTAL_ECHO_CANCELLER);
  if (audio_parameters.IsValid() &&
      (has_hw_echo_canceller ||
       (has_experimental_hw_echo_canceller &&
        should_enable_experimental_hw_echo_cancellation)))
    return false;
  DCHECK(echo_cancellation && goog_echo_cancellation
             ? *echo_cancellation == *goog_echo_cancellation
             : true);
  if (echo_cancellation)
    return *echo_cancellation;
  if (goog_echo_cancellation)
    return *goog_echo_cancellation;

  return default_audio_processing_value;
}

// This class represents all the candidates settings for a single audio device.
class SingleDeviceCandidateSet {
 public:
  explicit SingleDeviceCandidateSet(
      const AudioDeviceCaptureCapability& capability)
      : parameters_(capability.Parameters()) {
    // If empty, all values for the deviceId constraint are allowed and
    // |device_id_set_| is the universal set. Otherwise, limit |device_id_set_|
    // to the known device ID.
    if (!capability.DeviceID().empty())
      device_id_set_ = DiscreteSet<std::string>({capability.DeviceID()});

    MediaStreamAudioSource* source = capability.source();
    if (!source)
      return;

    // Properties not related to audio processing.
    bool_sets_[HOTWORD_ENABLED] =
        DiscreteSet<bool>({source->hotword_enabled()});
    bool_sets_[DISABLE_LOCAL_ECHO] =
        DiscreteSet<bool>({source->disable_local_echo()});
    bool_sets_[RENDER_TO_ASSOCIATED_SINK] =
        DiscreteSet<bool>({source->RenderToAssociatedSinkEnabled()});

    // Properties related with audio processing.
    AudioProcessingProperties properties;
    if (ProcessedLocalAudioSource* processed_source =
            ProcessedLocalAudioSource::From(source)) {
      properties = processed_source->audio_processing_properties();
    } else {
      properties.DisableDefaultProperties();
    }

    bool echo_cancellation_enabled = false;
    if (properties.enable_sw_echo_cancellation) {
      echo_cancellation_enabled = true;
    } else if (properties.disable_hw_echo_cancellation) {
      // Software and hardware echo cancellation disabled.
      echo_cancellation_enabled = false;
    } else {
      // Software echo cancellation disabled, but hardware echo cancellation
      // allowed. In this case, look at device parameters.
      echo_cancellation_enabled = source->device().input.effects() &
                                  media::AudioParameters::ECHO_CANCELLER;
    }
    bool_sets_[ECHO_CANCELLATION] =
        DiscreteSet<bool>({echo_cancellation_enabled});
    bool_sets_[GOOG_ECHO_CANCELLATION] = bool_sets_[ECHO_CANCELLATION];

    bool_sets_[GOOG_AUDIO_MIRRORING] =
        DiscreteSet<bool>({properties.goog_audio_mirroring});

    for (auto& entry : kAudioPropertyConstraintMap) {
      bool_sets_[entry.bool_set_index] =
          DiscreteSet<bool>({properties.*entry.audio_property});
    }

#if DCHECK_IS_ON()
    for (const auto& bool_set : bool_sets_) {
      DCHECK(!bool_set.is_universal());
      DCHECK(!bool_set.IsEmpty());
    }
#endif

    // This fails with input strings that are equivalent to
    // |properties.goog_array_geometry|, but not exactly equal to the string
    // returned by MediaPointsToString().
    // TODO(guidou): Change |goog_array_geometry_set_| to be a set of vectors of
    // points instead of a set of strings. http://crbug.com/796955
    std::string mic_positions =
        MediaPointsToString(properties.goog_array_geometry);
    goog_array_geometry_set_ = DiscreteSet<std::string>({mic_positions});
  }

  // Accessors
  const char* failed_constraint_name() const { return failed_constraint_name_; }
  const DiscreteSet<std::string>& device_id_set() const {
    return device_id_set_;
  }

  bool IsEmpty() const { return failed_constraint_name_ != nullptr; }

  void ApplyConstraintSet(
      const blink::WebMediaTrackConstraintSet& constraint_set) {
    device_id_set_ = device_id_set_.Intersection(
        StringSetFromConstraint(constraint_set.device_id));
    if (device_id_set_.IsEmpty()) {
      failed_constraint_name_ = constraint_set.device_id.GetName();
      return;
    }

    goog_array_geometry_set_ = goog_array_geometry_set_.Intersection(
        StringSetFromConstraint(constraint_set.goog_array_geometry));
    if (goog_array_geometry_set_.IsEmpty()) {
      failed_constraint_name_ = constraint_set.goog_array_geometry.GetName();
      return;
    }

    for (size_t i = 0; i < NUM_BOOL_CONSTRAINTS; ++i) {
      bool_sets_[i] = bool_sets_[i].Intersection(
          BoolSetFromConstraint(constraint_set.*kBlinkBoolConstraintFields[i]));
      if (bool_sets_[i].IsEmpty()) {
        failed_constraint_name_ =
            (constraint_set.*kBlinkBoolConstraintFields[i]).GetName();
        return;
      }
    }

    // echoCancellation and googEchoCancellation constraints should not
    // contradict each other. Mark the set as empty if they do.
    DiscreteSet<bool> echo_cancellation_intersection =
        bool_sets_[ECHO_CANCELLATION].Intersection(
            bool_sets_[GOOG_ECHO_CANCELLATION]);
    if (echo_cancellation_intersection.IsEmpty()) {
      failed_constraint_name_ =
          blink::WebMediaTrackConstraintSet().echo_cancellation.GetName();
      return;
    }
  }

  // Fitness function to support device selection. Based on
  // https://w3c.github.io/mediacapture-main/#dfn-fitness-distance
  double Fitness(
      const blink::WebMediaTrackConstraintSet& constraint_set) const {
    double fitness = 0.0;

    if (constraint_set.device_id.HasIdeal()) {
      for (const blink::WebString& ideal_value :
           constraint_set.device_id.Ideal()) {
        if (device_id_set_.Contains(ideal_value.Utf8())) {
          fitness += 1.0;
          break;
        }
      }
    }

    for (size_t i = 0; i < NUM_BOOL_CONSTRAINTS; ++i) {
      if ((constraint_set.*kBlinkBoolConstraintFields[i]).HasIdeal() &&
          bool_sets_[i].Contains(
              (constraint_set.*kBlinkBoolConstraintFields[i]).Ideal())) {
        fitness += 1.0;
      }
    }

    if (constraint_set.goog_array_geometry.HasIdeal()) {
      for (const blink::WebString& ideal_value :
           constraint_set.goog_array_geometry.Ideal()) {
        if (goog_array_geometry_set_.Contains(ideal_value.Utf8())) {
          fitness += 1.0;
          break;
        }
      }
    }

    return fitness;
  }

  // Returns the settings supported by this SingleDeviceCandidateSet that best
  // satisfy the ideal values in |basic_constraint_set|.
  AudioCaptureSettings SelectBestSettings(
      const blink::WebMediaTrackConstraintSet& basic_constraint_set,
      const std::string& default_device_id,
      const std::string& media_stream_source,
      bool should_disable_hardware_noise_suppression,
      bool should_enable_experimental_hw_echo_cancellation) const {
    std::string device_id = SelectString(
        device_id_set_, basic_constraint_set.device_id, default_device_id);
    bool hotword_enabled =
        SelectBool(bool_sets_[HOTWORD_ENABLED],
                   basic_constraint_set.hotword_enabled, false);
    bool disable_local_echo_default =
        media_stream_source != kMediaStreamSourceDesktop;
    bool disable_local_echo = SelectBool(
        bool_sets_[DISABLE_LOCAL_ECHO], basic_constraint_set.disable_local_echo,
        disable_local_echo_default);
    bool render_to_associated_sink =
        SelectBool(bool_sets_[RENDER_TO_ASSOCIATED_SINK],
                   basic_constraint_set.render_to_associated_sink, false);

    bool is_device_capture = media_stream_source.empty();
    AudioProcessingProperties audio_processing_properties =
        SelectAudioProcessingProperties(
            basic_constraint_set, is_device_capture,
            should_disable_hardware_noise_suppression,
            should_enable_experimental_hw_echo_cancellation);

    return AudioCaptureSettings(
        std::move(device_id), parameters_, hotword_enabled, disable_local_echo,
        render_to_associated_sink, audio_processing_properties);
  }

 private:
  // Returns the audio-processing properties supported by this
  // SingleDeviceCandidateSet that best satisfy the ideal values in
  // |basic_constraint_set|.
  AudioProcessingProperties SelectAudioProcessingProperties(
      const blink::WebMediaTrackConstraintSet& basic_constraint_set,
      bool is_device_capture,
      bool should_disable_hardware_noise_suppression,
      bool should_enable_experimental_hw_echo_cancellation) const {
    DCHECK(!IsEmpty());
    base::Optional<bool> echo_cancellation = SelectOptionalBool(
        bool_sets_[ECHO_CANCELLATION], basic_constraint_set.echo_cancellation);
    // Audio-processing properties are disabled by default for content capture,
    // or if the |echo_cancellation| constraint is false.
    bool default_audio_processing_value = true;
    if (!is_device_capture || (echo_cancellation && !*echo_cancellation))
      default_audio_processing_value = false;

    base::Optional<bool> goog_echo_cancellation =
        SelectOptionalBool(bool_sets_[GOOG_ECHO_CANCELLATION],
                           basic_constraint_set.goog_echo_cancellation);

    AudioProcessingProperties properties;
    properties.disable_hw_echo_cancellation =
        (echo_cancellation && !*echo_cancellation) ||
        (goog_echo_cancellation && !*goog_echo_cancellation);
    properties.enable_experimental_hw_echo_cancellation =
        should_enable_experimental_hw_echo_cancellation &&
        !properties.disable_hw_echo_cancellation;
    properties.enable_sw_echo_cancellation = SelectEnableSwEchoCancellation(
        echo_cancellation, goog_echo_cancellation, parameters_,
        default_audio_processing_value,
        properties.enable_experimental_hw_echo_cancellation);
    properties.disable_hw_noise_suppression =
        should_disable_hardware_noise_suppression &&
        !properties.disable_hw_echo_cancellation;

    properties.goog_audio_mirroring =
        SelectBool(bool_sets_[GOOG_AUDIO_MIRRORING],
                   basic_constraint_set.goog_audio_mirroring,
                   properties.goog_audio_mirroring);

    for (auto& entry : kAudioPropertyConstraintMap) {
      properties.*entry.audio_property = SelectBool(
          bool_sets_[entry.bool_set_index],
          basic_constraint_set.*
              kBlinkBoolConstraintFields[entry.bool_set_index],
          default_audio_processing_value && properties.*entry.audio_property);
    }

    base::Optional<std::string> array_geometry = SelectOptionalString(
        goog_array_geometry_set_, basic_constraint_set.goog_array_geometry);
    std::vector<media::Point> parsed_positions;
    if (array_geometry)
      parsed_positions = media::ParsePointsFromString(*array_geometry);
    bool are_valid_parsed_positions =
        !parsed_positions.empty() ||
        (array_geometry && array_geometry->empty());
    properties.goog_array_geometry = are_valid_parsed_positions
                                         ? std::move(parsed_positions)
                                         : parameters_.mic_positions();

    return properties;
  }

  static constexpr blink::BooleanConstraint
      blink::WebMediaTrackConstraintSet::* const
          kBlinkBoolConstraintFields[NUM_BOOL_CONSTRAINTS] = {
              &blink::WebMediaTrackConstraintSet::hotword_enabled,
              &blink::WebMediaTrackConstraintSet::disable_local_echo,
              &blink::WebMediaTrackConstraintSet::render_to_associated_sink,
              &blink::WebMediaTrackConstraintSet::echo_cancellation,
              &blink::WebMediaTrackConstraintSet::goog_echo_cancellation,
              &blink::WebMediaTrackConstraintSet::goog_audio_mirroring,
              &blink::WebMediaTrackConstraintSet::goog_auto_gain_control,
              &blink::WebMediaTrackConstraintSet::
                  goog_experimental_echo_cancellation,
              &blink::WebMediaTrackConstraintSet::goog_typing_noise_detection,
              &blink::WebMediaTrackConstraintSet::goog_noise_suppression,
              &blink::WebMediaTrackConstraintSet::
                  goog_experimental_noise_suppression,
              &blink::WebMediaTrackConstraintSet::goog_beamforming,
              &blink::WebMediaTrackConstraintSet::goog_highpass_filter,
              &blink::WebMediaTrackConstraintSet::
                  goog_experimental_auto_gain_control};

  const char* failed_constraint_name_ = nullptr;
  DiscreteSet<std::string> device_id_set_;
  std::array<DiscreteSet<bool>, NUM_BOOL_CONSTRAINTS> bool_sets_;
  DiscreteSet<std::string> goog_array_geometry_set_;
  media::AudioParameters parameters_;
};

constexpr blink::BooleanConstraint blink::WebMediaTrackConstraintSet::* const
    SingleDeviceCandidateSet::kBlinkBoolConstraintFields[NUM_BOOL_CONSTRAINTS];

// This class represents a set of possible candidate settings.
// The SelectSettings algorithm starts with a set containing all possible
// candidates based on hardware capabilities and/or allowed values for supported
// properties. The set is then reduced progressively as the basic and advanced
// constraint sets are applied.
// In the end, if the set of candidates is empty, SelectSettings fails.
// If not, the ideal values (if any) or tie breaker rules are used to select
// the final settings based on the candidates that survived the application
// of the constraint sets.
// This class is implemented as a collection of more specific sets for the
// various supported properties. If any of the specific sets is empty, the
// whole AudioCaptureCandidates set is considered empty as well.
class AudioCaptureCandidates {
 public:
  AudioCaptureCandidates(
      const blink::WebMediaTrackConstraintSet& constraint_set,
      const AudioDeviceCaptureCapabilities& capabilities) {
    for (const auto& capability : capabilities)
      candidate_sets_.emplace_back(capability);

    ApplyConstraintSet(constraint_set);
  }

  const char* failed_constraint_name() const { return failed_constraint_name_; }
  bool IsEmpty() const { return failed_constraint_name_ != nullptr; }

  void ApplyConstraintSet(
      const blink::WebMediaTrackConstraintSet& constraint_set) {
    for (auto& candidate_set : candidate_sets_)
      candidate_set.ApplyConstraintSet(constraint_set);

    const char* failed_constraint_name = nullptr;
    for (auto it = candidate_sets_.begin(); it != candidate_sets_.end();) {
      if (it->IsEmpty()) {
        DCHECK(it->failed_constraint_name());
        failed_constraint_name = it->failed_constraint_name();
        it = candidate_sets_.erase(it);
      } else {
        ++it;
      }
    }

    if (candidate_sets_.empty())
      failed_constraint_name_ = failed_constraint_name;
  }

  // Returns the settings that best satisfy the ideal values in
  // |basic_constraint_set| subject to the limitations of this
  // AudioCaptureCandidates object.
  AudioCaptureSettings SelectBestSettings(
      const blink::WebMediaTrackConstraintSet& basic_constraint_set,
      const std::string& default_device_id,
      const std::string& media_stream_source,
      bool should_disable_hardware_noise_suppression,
      bool should_enable_experimental_hw_echo_cancellation) const {
    const SingleDeviceCandidateSet* device_candidate_set =
        SelectBestDevice(basic_constraint_set, default_device_id);
    DCHECK(!device_candidate_set->IsEmpty());
    return device_candidate_set->SelectBestSettings(
        basic_constraint_set, default_device_id, media_stream_source,
        should_disable_hardware_noise_suppression,
        should_enable_experimental_hw_echo_cancellation);
  }

 private:
  // Selects the best device based on the fitness function.
  // The returned pointer is valid as long as |candidate_sets_| is not mutated.
  const SingleDeviceCandidateSet* SelectBestDevice(
      const blink::WebMediaTrackConstraintSet& constraint_set,
      const std::string& default_device_id) const {
    DCHECK(!candidate_sets_.empty());

    auto best_candidate = candidate_sets_.end();
    std::vector<double> best_fitness({-1, -1});

    for (auto it = candidate_sets_.begin(); it != candidate_sets_.end(); ++it) {
      DCHECK(!it->IsEmpty());
      std::vector<double> fitness;
      fitness.push_back(it->Fitness(constraint_set));
      // Second selection criterion is being the default device.
      fitness.push_back(it->device_id_set().Contains(default_device_id) ? 1.0
                                                                        : 0.0);
      if (fitness > best_fitness) {
        best_fitness = fitness;
        best_candidate = it;
      }
    }

    return &(*best_candidate);
  }

  const char* failed_constraint_name_ = nullptr;
  std::vector<SingleDeviceCandidateSet> candidate_sets_;
};

}  // namespace

AudioDeviceCaptureCapability::AudioDeviceCaptureCapability()
    : parameters_(media::AudioParameters::UnavailableDeviceParams()) {}

AudioDeviceCaptureCapability::AudioDeviceCaptureCapability(
    MediaStreamAudioSource* source)
    : source_(source) {}

AudioDeviceCaptureCapability::AudioDeviceCaptureCapability(
    std::string device_id,
    const media::AudioParameters& parameters)
    : device_id_(std::move(device_id)), parameters_(parameters) {
  DCHECK(!device_id_.empty());
}

const std::string& AudioDeviceCaptureCapability::DeviceID() const {
  return source_ ? source_->device().id : device_id_;
}

const media::AudioParameters& AudioDeviceCaptureCapability::Parameters() const {
  return source_ ? source_->device().input : parameters_;
}

AudioCaptureSettings SelectSettingsAudioCapture(
    const AudioDeviceCaptureCapabilities& capabilities,
    const blink::WebMediaConstraints& constraints,
    bool should_disable_hardware_noise_suppression,
    bool should_enable_experimental_hw_echo_cancellation) {
  std::string media_stream_source = GetMediaStreamSource(constraints);
  bool is_device_capture = media_stream_source.empty();
  if (capabilities.empty())
    return AudioCaptureSettings();

  AudioCaptureCandidates candidates(constraints.Basic(), capabilities);
  if (candidates.IsEmpty())
    return AudioCaptureSettings(candidates.failed_constraint_name());

  for (const auto& advanced_set : constraints.Advanced()) {
    AudioCaptureCandidates copy = candidates;
    candidates.ApplyConstraintSet(advanced_set);
    if (candidates.IsEmpty())
      candidates = std::move(copy);
  }
  DCHECK(!candidates.IsEmpty());

  std::string default_device_id;
  if (is_device_capture)
    default_device_id = capabilities.begin()->DeviceID();

  return candidates.SelectBestSettings(
      constraints.Basic(), default_device_id, media_stream_source,
      should_disable_hardware_noise_suppression,
      should_enable_experimental_hw_echo_cancellation);
}

AudioCaptureSettings CONTENT_EXPORT
SelectSettingsAudioCapture(MediaStreamAudioSource* source,
                           const blink::WebMediaConstraints& constraints) {
  DCHECK(source);
  if (source->device().type != MEDIA_DEVICE_AUDIO_CAPTURE &&
      source->device().type != MEDIA_TAB_AUDIO_CAPTURE &&
      source->device().type != MEDIA_DESKTOP_AUDIO_CAPTURE) {
    return AudioCaptureSettings();
  }

  std::string media_stream_source = GetMediaStreamSource(constraints);
  if (source->device().type == MEDIA_DEVICE_AUDIO_CAPTURE &&
      !media_stream_source.empty()) {
    return AudioCaptureSettings(
        constraints.Basic().media_stream_source.GetName());
  }

  if (source->device().type == MEDIA_TAB_AUDIO_CAPTURE &&
      !media_stream_source.empty() &&
      media_stream_source != kMediaStreamSourceTab) {
    return AudioCaptureSettings(
        constraints.Basic().media_stream_source.GetName());
  }
  if (source->device().type == MEDIA_DESKTOP_AUDIO_CAPTURE &&
      !media_stream_source.empty() &&
      media_stream_source != kMediaStreamSourceSystem &&
      media_stream_source != kMediaStreamSourceDesktop) {
    return AudioCaptureSettings(
        constraints.Basic().media_stream_source.GetName());
  }

  AudioDeviceCaptureCapabilities capabilities = {
      AudioDeviceCaptureCapability(source)};
  bool should_disable_hardware_noise_suppression =
      !(source->device().input.effects() &
        media::AudioParameters::NOISE_SUPPRESSION);

  return SelectSettingsAudioCapture(
      capabilities, constraints, should_disable_hardware_noise_suppression,
      /* should_enable_experimental_hw_echo_cancellation */ false);
}

}  // namespace content