// 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.

#include "services/audio/input_controller.h"

#include <inttypes.h>

#include <algorithm>
#include <limits>
#include <utility>

#include "base/bind.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/metrics/histogram_macros.h"
#include "base/numerics/ranges.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/threading/thread_restrictions.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "media/audio/audio_io.h"
#include "media/audio/audio_manager.h"
#include "media/base/audio_bus.h"
#include "media/base/user_input_monitor.h"
#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
#include "media/webrtc/audio_processor.h"
#include "media/webrtc/webrtc_switches.h"
#endif

namespace audio {
namespace {

const int kMaxInputChannels = 3;
constexpr base::TimeDelta kCheckMutedStateInterval =
    base::TimeDelta::FromSeconds(1);

#if defined(AUDIO_POWER_MONITORING)
// Time in seconds between two successive measurements of audio power levels.
constexpr base::TimeDelta kPowerMonitorLogInterval =
    base::TimeDelta::FromSeconds(15);

// A warning will be logged when the microphone audio volume is below this
// threshold.
const int kLowLevelMicrophoneLevelPercent = 10;

// Logs if the user has enabled the microphone mute or not. This is normally
// done by marking a checkbox in an audio-settings UI which is unique for each
// platform. Elements in this enum should not be added, deleted or rearranged.
enum MicrophoneMuteResult {
  MICROPHONE_IS_MUTED = 0,
  MICROPHONE_IS_NOT_MUTED = 1,
  MICROPHONE_MUTE_MAX = MICROPHONE_IS_NOT_MUTED
};

void LogMicrophoneMuteResult(MicrophoneMuteResult result) {
  UMA_HISTOGRAM_ENUMERATION("Media.MicrophoneMuted", result,
                            MICROPHONE_MUTE_MAX + 1);
}

const char* SilenceStateToString(InputController::SilenceState state) {
  switch (state) {
    case InputController::SILENCE_STATE_NO_MEASUREMENT:
      return "SILENCE_STATE_NO_MEASUREMENT";
    case InputController::SILENCE_STATE_ONLY_AUDIO:
      return "SILENCE_STATE_ONLY_AUDIO";
    case InputController::SILENCE_STATE_ONLY_SILENCE:
      return "SILENCE_STATE_ONLY_SILENCE";
    case InputController::SILENCE_STATE_AUDIO_AND_SILENCE:
      return "SILENCE_STATE_AUDIO_AND_SILENCE";
    default:
      NOTREACHED();
  }
  return "INVALID";
}

// Helper method which calculates the average power of an audio bus. Unit is in
// dBFS, where 0 dBFS corresponds to all channels and samples equal to 1.0.
float AveragePower(const media::AudioBus& buffer) {
  const int frames = buffer.frames();
  const int channels = buffer.channels();
  if (frames <= 0 || channels <= 0)
    return 0.0f;

  // Scan all channels and accumulate the sum of squares for all samples.
  float sum_power = 0.0f;
  for (int ch = 0; ch < channels; ++ch) {
    const float* channel_data = buffer.channel(ch);
    for (int i = 0; i < frames; i++) {
      const float sample = channel_data[i];
      sum_power += sample * sample;
    }
  }

  // Update accumulated average results, with clamping for sanity.
  const float average_power =
      base::ClampToRange(sum_power / (frames * channels), 0.0f, 1.0f);

  // Convert average power level to dBFS units, and pin it down to zero if it
  // is insignificantly small.
  const float kInsignificantPower = 1.0e-10f;  // -100 dBFS
  const float power_dbfs = average_power < kInsignificantPower
                               ? -std::numeric_limits<float>::infinity()
                               : 10.0f * log10f(average_power);

  return power_dbfs;
}
#endif  // AUDIO_POWER_MONITORING

#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)

bool SamplesNeedClamping(const media::AudioBus& bus) {
  const auto IsOutOfRange = [](float sample) {
    // See comment in CopySamplesWithClamping() for why the conditional is
    // written this way.
    if (UNLIKELY(!(sample >= -1.f && sample <= 1.f))) {
      return true;
    }
    return false;
  };

  const int frames = bus.frames();
  for (int i = 0; i < bus.channels(); ++i) {
    auto* const channel = bus.channel(i);
    if (UNLIKELY(std::any_of(channel, channel + frames, IsOutOfRange))) {
      return true;
    }
  }
  return false;
}

void CopySamplesWithClamping(const media::AudioBus& src_bus,
                             media::AudioBus* dest_bus) {
  DCHECK_EQ(src_bus.channels(), dest_bus->channels());
  DCHECK_EQ(src_bus.frames(), dest_bus->frames());

  const auto ToClampedSample = [](float sample) {
    // First check for all the invalid cases with a single conditional to
    // optimize for the typical (data ok) case. Different cases are handled
    // inside of the conditional. The condition is written like this to catch
    // NaN. It cannot be simplified to "channel[j] < -1.f || channel[j] > 1.f",
    // which isn't equivalent.
    if (UNLIKELY(!(sample >= -1.f && sample <= 1.f))) {
      // Don't just set all bad values to 0. If a value like 1.0001 is produced
      // due to floating-point shenanigans, 1 will sound better than 0.
      if (sample < -1.f) {
        return -1.f;
      } else {
        // channel[j] > 1 or NaN.
        return 1.f;
      }
    }
    return sample;
  };

  const int frames = src_bus.frames();
  for (int i = 0; i < src_bus.channels(); ++i) {
    auto* const src = src_bus.channel(i);
    std::transform(src, src + frames, dest_bus->channel(i), ToClampedSample);
  }
}

#endif  // defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)

}  // namespace

#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
InputController::ProcessingHelper::ProcessingHelper(
    const media::AudioParameters& params,
    media::AudioProcessingSettings processing_settings,
    mojo::PendingReceiver<mojom::AudioProcessorControls> controls_receiver)
    : receiver_(this, std::move(controls_receiver)),
      params_(params),
      audio_processor_(
          std::make_unique<media::AudioProcessor>(params,
                                                  processing_settings)) {}

InputController::ProcessingHelper::~ProcessingHelper() {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
}

void InputController::ProcessingHelper::ChangeMonitoredStream(
    Snoopable* stream) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  TRACE_EVENT1("audio", "AIC ChangeMonitoredStream", "stream", stream);
  if (!audio_processor_)
    return;
  if (monitored_output_stream_ == stream)
    return;

  if (monitored_output_stream_) {
    monitored_output_stream_->StopSnooping(this);
    if (!stream) {
      audio_processor_->set_has_reverse_stream(false);
    }
  }
  monitored_output_stream_ = stream;
  if (!monitored_output_stream_) {
    output_params_ = media::AudioParameters();
    clamped_bus_.reset();
    return;
  }
  output_params_ = monitored_output_stream_->GetAudioParameters();
  audio_processor_->set_has_reverse_stream(true);
  monitored_output_stream_->StartSnooping(this);
}

void InputController::ProcessingHelper::OnData(const media::AudioBus& audio_bus,
                                               base::TimeTicks reference_time,
                                               double volume) {
  TRACE_EVENT0("audio", "APM AnalyzePlayout");

  // OnData gets called when the InputController is snooping on an output stream
  // for audio processing purposes. |audio_bus| contains the data from the
  // snooped-upon output stream, not the input stream's data.
  // |volume| is applied in the WebRTC mixer in the renderer, so we don't have
  // to inform the |audio_processor_| of the new volume.

  // If there are out-of-range samples, clamp them.
  const media::AudioBus* bus_to_analyze = &audio_bus;
  if (SamplesNeedClamping(audio_bus)) {
    if (!clamped_bus_ || clamped_bus_->channels() != audio_bus.channels() ||
        clamped_bus_->frames() != audio_bus.frames()) {
      clamped_bus_ =
          media::AudioBus::Create(audio_bus.channels(), audio_bus.frames());
    }
    CopySamplesWithClamping(audio_bus, clamped_bus_.get());
    bus_to_analyze = clamped_bus_.get();
  }

  audio_processor_->AnalyzePlayout(*bus_to_analyze, output_params_,
                                   reference_time);
}

void InputController::ProcessingHelper::GetStats(GetStatsCallback callback) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(audio_processor_);
  TRACE_EVENT0("audio", "APM GetStats");
  audio_processor_->GetStats(std::move(callback));
}

void InputController::ProcessingHelper::StartEchoCancellationDump(
    base::File file) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(audio_processor_);
  audio_processor_->StartEchoCancellationDump(std::move(file));
}

void InputController::ProcessingHelper::StopEchoCancellationDump() {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(audio_processor_);
  audio_processor_->StopEchoCancellationDump();
}

media::AudioProcessor* InputController::ProcessingHelper::GetAudioProcessor() {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(audio_processor_);
  return audio_processor_.get();
}

void InputController::ProcessingHelper::StartMonitoringStream(
    Snoopable* output_stream) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(audio_processor_);
  ChangeMonitoredStream(output_stream);
}

void InputController::ProcessingHelper::StopMonitoringStream(
    Snoopable* output_stream) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(audio_processor_);
  if (output_stream == monitored_output_stream_)
    ChangeMonitoredStream(nullptr);
}

void InputController::ProcessingHelper::StopAllStreamMonitoring() {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(audio_processor_);
  ChangeMonitoredStream(nullptr);
}

#endif  // defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)

// Private subclass of AIC that covers the state while capturing audio.
// This class implements the callback interface from the lower level audio
// layer and gets called back on the audio hw thread.
// We implement this in a sub class instead of directly in the AIC so that
// - The AIC itself is not an AudioInputCallback.
// - The lifetime of the AudioCallback is shorter than the AIC
// - How tasks are posted to the AIC from the hw callback thread, is different
//   than how tasks are posted from the AIC to itself from the main thread.
//   So, this difference is isolated to the subclass (see below).
// - The callback class can gather information on what happened during capture
//   and store it in a state that can be fetched after stopping capture
//   (received_callback, error_during_callback).
// The AIC itself must not be AddRef-ed on the hw callback thread so that we
// can be guaranteed to not receive callbacks generated by the hw callback
// thread after Close() has been called on the audio manager thread and
// the callback object deleted. To avoid AddRef-ing the AIC and to cancel
// potentially pending tasks, we use a weak pointer to the AIC instance
// when posting.
class InputController::AudioCallback
    : public media::AudioInputStream::AudioInputCallback {
 public:
  AudioCallback(
#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
      media::AudioProcessor* audio_processor,
#endif  // defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
      InputController* controller)
      : task_runner_(base::ThreadTaskRunnerHandle::Get()),
#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
        audio_processor_(audio_processor),
#endif  // defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
        controller_(controller),
        weak_controller_(controller->weak_ptr_factory_.GetWeakPtr()) {
  }
  ~AudioCallback() override = default;

  // These should not be called when the stream is live.
  bool received_callback() const { return received_callback_; }
  bool error_during_callback() const { return error_during_callback_; }

 private:
  void OnData(const media::AudioBus* source,
              base::TimeTicks capture_time,
              double volume) override {
    TRACE_EVENT1("audio", "InputController::OnData", "capture time (ms)",
                 (capture_time - base::TimeTicks()).InMillisecondsF());

    if (!received_callback_) {
      // Mark the stream as alive at first audio callback. Currently only used
      // for logging purposes.
      task_runner_->PostTask(
          FROM_HERE,
          base::BindOnce(&InputController::ReportIsAlive, weak_controller_));
    }
    received_callback_ = true;

    DeliverDataToSyncWriter(source, capture_time, volume);
  }

  void OnError() override {
    error_during_callback_ = true;
    task_runner_->PostTask(
        FROM_HERE,
        base::BindOnce(&InputController::DoReportError, weak_controller_));
  }

  void DeliverDataToSyncWriter(const media::AudioBus* source,
                               base::TimeTicks capture_time,
                               double volume) {
    const bool key_pressed = controller_->CheckForKeyboardInput();

#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
    base::Optional<double> new_volume;
    if (audio_processor_) {
      TRACE_EVENT0("audio", "APM ProcessCapture");
      auto result = audio_processor_->ProcessCapture(*source, capture_time,
                                                     volume, key_pressed);
      source = &result.audio;
      new_volume = result.new_volume;
    }
#endif  // defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)

    controller_->sync_writer_->Write(source, volume, key_pressed, capture_time);

    // The way the two classes interact here, could be done in a nicer way.
    // As is, we call the AIC here to check the audio power, return and then
    // post a task to the AIC based on what the AIC said.
    // The reason for this is to keep all PostTask calls from the hw callback
    // thread to the AIC, that use a weak pointer, in the same class.
    float average_power_dbfs;
    int mic_volume_percent;
    if (controller_->CheckAudioPower(source, volume, &average_power_dbfs,
                                     &mic_volume_percent)) {
      // Use event handler on the audio thread to relay a message to the ARIH
      // in content which does the actual logging on the IO thread.
      task_runner_->PostTask(
          FROM_HERE,
          base::BindOnce(&InputController::DoLogAudioLevels, weak_controller_,
                         average_power_dbfs, mic_volume_percent));
    }

#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
    // Updates APM stats and stream volume (if needed). Post through
    // weak_controller, in case we're just shutting down.
    if (audio_processor_) {
      task_runner_->PostTask(
          FROM_HERE, base::BindOnce(&InputController::UpdateVolumeAndAPMStats,
                                    weak_controller_, new_volume));
    }
#endif  // defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
  }

  const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
  media::AudioProcessor* const audio_processor_;
#endif
  InputController* const controller_;
  // We do not want any pending posted tasks generated from the callback class
  // to keep the controller object alive longer than it should. So we use
  // a weak ptr whenever we post, we use this weak pointer.
  base::WeakPtr<InputController> weak_controller_;
  bool received_callback_ = false;
  bool error_during_callback_ = false;
};

InputController::InputController(
    EventHandler* handler,
    SyncWriter* sync_writer,
    media::UserInputMonitor* user_input_monitor,
    const media::AudioParameters& params,
    StreamType type,
    StreamMonitorCoordinator* stream_monitor_coordinator,
    mojom::AudioProcessingConfigPtr processing_config)
    : handler_(handler),
      stream_(nullptr),
      sync_writer_(sync_writer),
      type_(type),
      user_input_monitor_(user_input_monitor),
      stream_monitor_coordinator_(stream_monitor_coordinator),
      processing_config_(std::move(processing_config)) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(handler_);
  DCHECK(sync_writer_);
  DCHECK(stream_monitor_coordinator);

#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
  if (processing_config_) {
    if (processing_config_->settings.requires_apm() &&
        media::IsWebRtcApmInAudioServiceEnabled()) {
      processing_helper_.emplace(
          params, processing_config_->settings,
          std::move(processing_config_->controls_receiver));
    } else {
      processing_config_->controls_receiver.reset();
    }
  }
#endif  // defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
}

InputController::~InputController() {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(!audio_callback_);
  DCHECK(!stream_);
  DCHECK(!check_muted_state_timer_.IsRunning());
}

// static
std::unique_ptr<InputController> InputController::Create(
    media::AudioManager* audio_manager,
    EventHandler* event_handler,
    SyncWriter* sync_writer,
    media::UserInputMonitor* user_input_monitor,
    const media::AudioParameters& params,
    const std::string& device_id,
    bool enable_agc,
    StreamMonitorCoordinator* stream_monitor_coordinator,
    mojom::AudioProcessingConfigPtr processing_config) {
  DCHECK(audio_manager);
  DCHECK(audio_manager->GetTaskRunner()->BelongsToCurrentThread());
  DCHECK(sync_writer);
  DCHECK(event_handler);
  DCHECK(params.IsValid());

  if (params.channels() > kMaxInputChannels)
    return nullptr;

  // Create the InputController object and ensure that it runs on
  // the audio-manager thread.
  std::unique_ptr<InputController> controller(new InputController(
      event_handler, sync_writer, user_input_monitor, params,
      ParamsToStreamType(params), stream_monitor_coordinator,
      std::move(processing_config)));

  controller->DoCreate(audio_manager, params, device_id, enable_agc);
  return controller;
}

void InputController::Record() {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.RecordTime");

  if (!stream_ || audio_callback_)
    return;

  handler_->OnLog("AIC::Record()");

  if (user_input_monitor_) {
    user_input_monitor_->EnableKeyPressMonitoring();
    prev_key_down_count_ = user_input_monitor_->GetKeyPressCount();
  }

  stream_create_time_ = base::TimeTicks::Now();

  audio_callback_.reset(new AudioCallback(
#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
      processing_helper_ ? processing_helper_->GetAudioProcessor() : nullptr,
#endif
      this));
  if (ShouldRegisterWithStreamMonitorCoordinator()) {
    stream_monitor_coordinator_->RegisterMember(
        processing_config_->processing_id, this);
    registered_to_coordinator_ = true;
  }
  stream_->Start(audio_callback_.get());
  return;
}

void InputController::Close() {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CloseTime");

  if (!stream_)
    return;

  check_muted_state_timer_.AbandonAndStop();

  if (registered_to_coordinator_) {
    // We should only unregister ourselves from the coordinator if we previously
    // registered.
    stream_monitor_coordinator_->UnregisterMember(
        processing_config_->processing_id, this);
    registered_to_coordinator_ = false;
  }

#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
  // Disconnect from any output stream, so we don't get called when we're gone.
  if (processing_helper_)
    processing_helper_->StopAllStreamMonitoring();
#endif

  std::string log_string;
  static const char kLogStringPrefix[] = "AIC::Close => ";

  // Allow calling unconditionally and bail if we don't have a stream to close.
  if (audio_callback_) {
    stream_->Stop();

    // Sometimes a stream (and accompanying audio track) is created and
    // immediately closed or discarded. In this case they are registered as
    // 'stopped early' rather than 'never got data'.
    const base::TimeDelta duration =
        base::TimeTicks::Now() - stream_create_time_;
    CaptureStartupResult capture_startup_result =
        audio_callback_->received_callback()
            ? CAPTURE_STARTUP_OK
            : (duration.InMilliseconds() < 500
                   ? CAPTURE_STARTUP_STOPPED_EARLY
                   : CAPTURE_STARTUP_NEVER_GOT_DATA);
    LogCaptureStartupResult(capture_startup_result);
    LogCallbackError();

    log_string = base::StringPrintf("%s(stream duration=%" PRId64 " seconds%s",
                                    kLogStringPrefix, duration.InSeconds(),
                                    audio_callback_->received_callback()
                                        ? ")"
                                        : " - no callbacks received)");

    if (type_ == LOW_LATENCY) {
      if (audio_callback_->received_callback()) {
        UMA_HISTOGRAM_LONG_TIMES("Media.InputStreamDuration", duration);
      } else {
        UMA_HISTOGRAM_LONG_TIMES("Media.InputStreamDurationWithoutCallback",
                                 duration);
      }
    }

    if (user_input_monitor_)
      user_input_monitor_->DisableKeyPressMonitoring();

    audio_callback_.reset();
  } else {
    log_string = base::StringPrintf("%s(WARNING: recording never started)",
                                    kLogStringPrefix);
  }

  handler_->OnLog(log_string);

  stream_->Close();
  stream_ = nullptr;

  sync_writer_->Close();

#if defined(AUDIO_POWER_MONITORING)
  // Send UMA stats if enabled.
  if (power_measurement_is_enabled_) {
    LogSilenceState(silence_state_);
    log_string = base::StringPrintf("%s(silence_state=%s)", kLogStringPrefix,
                                    SilenceStateToString(silence_state_));
    handler_->OnLog(log_string);
  }
#endif

  max_volume_ = 0.0;
  weak_ptr_factory_.InvalidateWeakPtrs();
}

void InputController::SetVolume(double volume) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK_GE(volume, 0);
  DCHECK_LE(volume, 1.0);

  if (!stream_)
    return;

  handler_->OnLog(base::StringPrintf("AIC::SetVolume({volume=%.2f})", volume));

  // Only ask for the maximum volume at first call and use cached value
  // for remaining function calls.
  if (!max_volume_) {
    max_volume_ = stream_->GetMaxVolume();
  }

  if (max_volume_ == 0.0) {
    DLOG(WARNING) << "Failed to access input volume control";
    return;
  }

  // Set the stream volume and scale to a range matched to the platform.
  stream_->SetVolume(max_volume_ * volume);
}

void InputController::SetOutputDeviceForAec(
    const std::string& output_device_id) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  if (stream_)
    stream_->SetOutputDeviceForAec(output_device_id);
}

bool InputController::ShouldRegisterWithStreamMonitorCoordinator() const {
  // We register with the coordinator if we need it for AEC and we have a
  // processing_id to monitor.
  return processing_config_ && !processing_config_->processing_id.is_empty() &&
         processing_config_->settings.echo_cancellation !=
             media::EchoCancellationType::kDisabled;
}

void InputController::OnStreamActive(Snoopable* output_stream) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  // Always pick the last stream that becomes active. There should be just one
  // active at a time, but in-case the creation of and old stream overlaps with
  // the destruction of a new stream, we still want to be ok.
  switch (processing_config_->settings.echo_cancellation) {
    case media::EchoCancellationType::kSystemAec:
      if (output_stream)
        stream_->SetOutputDeviceForAec(output_stream->GetDeviceId());
      break;
    case media::EchoCancellationType::kAec3:
#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
      if (processing_helper_)
        processing_helper_->StartMonitoringStream(output_stream);
#endif
      break;
    case media::EchoCancellationType::kDisabled:
      // Do nothing.
      break;
  }
}

void InputController::OnStreamInactive(Snoopable* output_stream) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
  if (processing_helper_)
    processing_helper_->StopMonitoringStream(output_stream);
#endif
}

void InputController::DoCreate(media::AudioManager* audio_manager,
                               const media::AudioParameters& params,
                               const std::string& device_id,
                               bool enable_agc) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(!stream_);
  SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CreateTime");
  handler_->OnLog("AIC::DoCreate({device_id=" + device_id + "})");

#if defined(AUDIO_POWER_MONITORING)
  // We only do power measurements for UMA stats for low latency streams, and
  // only if agc is requested, to avoid adding logs and UMA for non-WebRTC
  // clients.
  power_measurement_is_enabled_ = (type_ == LOW_LATENCY && enable_agc);
  last_audio_level_log_time_ = base::TimeTicks::Now();
#endif

  // Unretained is safe since |this| owns |stream|.
  auto* stream = audio_manager->MakeAudioInputStream(
      params, device_id,
      base::BindRepeating(&InputController::LogMessage,
                          base::Unretained(this)));

  if (!stream) {
    LogCaptureStartupResult(CAPTURE_STARTUP_CREATE_STREAM_FAILED);
    handler_->OnError(STREAM_CREATE_ERROR);
    return;
  }

  if (!stream->Open()) {
    stream->Close();
    LogCaptureStartupResult(CAPTURE_STARTUP_OPEN_STREAM_FAILED);
    handler_->OnError(STREAM_OPEN_ERROR);
    return;
  }

#if defined(AUDIO_POWER_MONITORING)
  bool agc_is_supported = stream->SetAutomaticGainControl(enable_agc);
  // Disable power measurements on platforms that does not support AGC at a
  // lower level. AGC can fail on platforms where we don't support the
  // functionality to modify the input volume slider. One such example is
  // Windows XP.
  power_measurement_is_enabled_ &= agc_is_supported;
  handler_->OnLog(
      base::StringPrintf("AIC::DoCreate => (power_measurement_is_enabled=%d)",
                         power_measurement_is_enabled_));
#else
  stream->SetAutomaticGainControl(enable_agc);
#endif

  // Finally, keep the stream pointer around, update the state and notify.
  stream_ = stream;

  // Send initial muted state along with OnCreated, to avoid races.
  is_muted_ = stream_->IsMuted();
  handler_->OnCreated(is_muted_);
  check_muted_state_timer_.Start(FROM_HERE, kCheckMutedStateInterval, this,
                                 &InputController::CheckMutedState);
  DCHECK(check_muted_state_timer_.IsRunning());
}

void InputController::DoReportError() {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  handler_->OnError(STREAM_ERROR);
}

void InputController::DoLogAudioLevels(float level_dbfs,
                                       int microphone_volume_percent) {
#if defined(AUDIO_POWER_MONITORING)
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  if (!stream_)
    return;

  // Detect if the user has enabled hardware mute by pressing the mute
  // button in audio settings for the selected microphone.
  const bool microphone_is_muted = stream_->IsMuted();
  if (microphone_is_muted) {
    LogMicrophoneMuteResult(MICROPHONE_IS_MUTED);
    handler_->OnLog("AIC::OnData => (microphone is muted)");
    // Return early if microphone is muted. No need to adding logs and UMA stats
    // of audio levels if we know that the microphone is muted.
    return;
  }

  LogMicrophoneMuteResult(MICROPHONE_IS_NOT_MUTED);

  std::string log_string = base::StringPrintf(
      "AIC::OnData => (average audio level=%.2f dBFS", level_dbfs);
  static const float kSilenceThresholdDBFS = -72.24719896f;
  if (level_dbfs < kSilenceThresholdDBFS)
    log_string += " <=> low audio input level";
  handler_->OnLog(log_string + ")");

  UpdateSilenceState(level_dbfs < kSilenceThresholdDBFS);

  log_string = base::StringPrintf("AIC::OnData => (microphone volume=%d%%",
                                  microphone_volume_percent);
  if (microphone_volume_percent < kLowLevelMicrophoneLevelPercent)
    log_string += " <=> low microphone level";
  handler_->OnLog(log_string + ")");
#endif
}

#if defined(AUDIO_POWER_MONITORING)
void InputController::UpdateSilenceState(bool silence) {
  if (silence) {
    if (silence_state_ == SILENCE_STATE_NO_MEASUREMENT) {
      silence_state_ = SILENCE_STATE_ONLY_SILENCE;
    } else if (silence_state_ == SILENCE_STATE_ONLY_AUDIO) {
      silence_state_ = SILENCE_STATE_AUDIO_AND_SILENCE;
    } else {
      DCHECK(silence_state_ == SILENCE_STATE_ONLY_SILENCE ||
             silence_state_ == SILENCE_STATE_AUDIO_AND_SILENCE);
    }
  } else {
    if (silence_state_ == SILENCE_STATE_NO_MEASUREMENT) {
      silence_state_ = SILENCE_STATE_ONLY_AUDIO;
    } else if (silence_state_ == SILENCE_STATE_ONLY_SILENCE) {
      silence_state_ = SILENCE_STATE_AUDIO_AND_SILENCE;
    } else {
      DCHECK(silence_state_ == SILENCE_STATE_ONLY_AUDIO ||
             silence_state_ == SILENCE_STATE_AUDIO_AND_SILENCE);
    }
  }
}

void InputController::LogSilenceState(SilenceState value) {
  UMA_HISTOGRAM_ENUMERATION("Media.AudioInputControllerSessionSilenceReport",
                            value, SILENCE_STATE_MAX + 1);
}
#endif

void InputController::LogCaptureStartupResult(CaptureStartupResult result) {
  switch (type_) {
    case LOW_LATENCY:
      UMA_HISTOGRAM_ENUMERATION("Media.LowLatencyAudioCaptureStartupSuccess",
                                result, CAPTURE_STARTUP_RESULT_MAX + 1);
      break;
    case HIGH_LATENCY:
      UMA_HISTOGRAM_ENUMERATION("Media.HighLatencyAudioCaptureStartupSuccess",
                                result, CAPTURE_STARTUP_RESULT_MAX + 1);
      break;
    case VIRTUAL:
      UMA_HISTOGRAM_ENUMERATION("Media.VirtualAudioCaptureStartupSuccess",
                                result, CAPTURE_STARTUP_RESULT_MAX + 1);
      break;
    default:
      break;
  }
}

void InputController::LogCallbackError() {
  bool error_during_callback = audio_callback_->error_during_callback();
  switch (type_) {
    case LOW_LATENCY:
      UMA_HISTOGRAM_BOOLEAN("Media.Audio.Capture.LowLatencyCallbackError",
                            error_during_callback);
      break;
    case HIGH_LATENCY:
      UMA_HISTOGRAM_BOOLEAN("Media.Audio.Capture.HighLatencyCallbackError",
                            error_during_callback);
      break;
    case VIRTUAL:
      UMA_HISTOGRAM_BOOLEAN("Media.Audio.Capture.VirtualCallbackError",
                            error_during_callback);
      break;
    default:
      break;
  }
}

void InputController::LogMessage(const std::string& message) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  handler_->OnLog(message);
}

bool InputController::CheckForKeyboardInput() {
  if (!user_input_monitor_)
    return false;

  const size_t current_count = user_input_monitor_->GetKeyPressCount();
  const bool key_pressed = current_count != prev_key_down_count_;
  prev_key_down_count_ = current_count;
  DVLOG_IF(6, key_pressed) << "Detected keypress.";

  return key_pressed;
}

bool InputController::CheckAudioPower(const media::AudioBus* source,
                                      double volume,
                                      float* average_power_dbfs,
                                      int* mic_volume_percent) {
#if defined(AUDIO_POWER_MONITORING)
  // Only do power-level measurements if DoCreate() has been called. It will
  // ensure that logging will mainly be done for WebRTC and WebSpeech
  // clients.
  if (!power_measurement_is_enabled_)
    return false;

  // Perform periodic audio (power) level measurements.
  const auto now = base::TimeTicks::Now();
  if (now - last_audio_level_log_time_ <= kPowerMonitorLogInterval) {
    return false;
  }

  *average_power_dbfs = AveragePower(*source);
  *mic_volume_percent = static_cast<int>(100.0 * volume);

  last_audio_level_log_time_ = now;

  return true;
#else
  return false;
#endif
}

void InputController::CheckMutedState() {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(stream_);
  const bool new_state = stream_->IsMuted();
  if (new_state != is_muted_) {
    is_muted_ = new_state;
    handler_->OnMuted(is_muted_);
    std::string log_string =
        base::StringPrintf("AIC::OnMuted({is_muted=%d})", is_muted_);
    handler_->OnLog(log_string);
  }
}

void InputController::ReportIsAlive() {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  DCHECK(stream_);
  // Don't store any state, just log the event for now.
  handler_->OnLog("AIC::OnData => (stream is alive)");
}

#if defined(AUDIO_PROCESSING_IN_AUDIO_SERVICE)
void InputController::UpdateVolumeAndAPMStats(
    base::Optional<double> new_volume) {
  DCHECK_CALLED_ON_VALID_THREAD(owning_thread_);
  if (new_volume)
    SetVolume(*new_volume);
}
#endif

// static
InputController::StreamType InputController::ParamsToStreamType(
    const media::AudioParameters& params) {
  switch (params.format()) {
    case media::AudioParameters::Format::AUDIO_PCM_LINEAR:
      return InputController::StreamType::HIGH_LATENCY;
    case media::AudioParameters::Format::AUDIO_PCM_LOW_LATENCY:
      return InputController::StreamType::LOW_LATENCY;
    default:
      // Currently, the remaining supported type is fake. Reconsider if other
      // formats become supported.
      return InputController::StreamType::FAKE;
  }
}

}  // namespace audio