input_controller.cc | Explore in Territory

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

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "services/audio/input_controller.h"

#include <inttypes.h>

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

#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/histogram_macros.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/task/bind_post_task.h"
#include "base/task/single_thread_task_runner.h"
#include "base/threading/thread_restrictions.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/audio_parameters.h"
#include "media/base/audio_processing.h"
#include "media/base/media_switches.h"
#include "media/base/user_input_monitor.h"
#include "services/audio/audio_manager_power_user.h"
#include "services/audio/device_output_listener.h"
#include "services/audio/output_tapper.h"
#include "services/audio/processing_audio_fifo.h"
#include "services/audio/reference_output.h"

#if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
#include "services/audio/audio_processor_handler.h"
#endif

namespace audio {
namespace {

OpenOutcome;

const int kMaxInputChannels = …;
constexpr base::TimeDelta kCheckMutedStateInterval = …;

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

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

// 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 { … };

void LogMicrophoneMuteResult(MicrophoneMuteResult result) { … }

const char* SilenceStateToString(InputController::SilenceState state) { … }

// 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) { … }
#endif  // AUDIO_POWER_MONITORING

}  // namespace

// This class implements the AudioInputCallback interface in place of the
// InputController (AIC), so that
// - The AIC itself does not publicly inherit AudioInputCallback.
// - The lifetime of the AudioCallback (shorter than the AIC) matches the
//   interval during which hardware callbacks come.
// - 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()).
class AudioCallback : public media::AudioInputStream::AudioInputCallback { … };

InputController::InputController(
    EventHandler* event_handler,
    SyncWriter* sync_writer,
    media::UserInputMonitor* user_input_monitor,
    DeviceOutputListener* device_output_listener,
    media::AecdumpRecordingManager* aecdump_recording_manager,
    media::mojom::AudioProcessingConfigPtr processing_config,
    const media::AudioParameters& output_params,
    const media::AudioParameters& device_params,
    StreamType type)
    : … { … }

#if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
void InputController::MaybeSetUpAudioProcessing(
    media::mojom::AudioProcessingConfigPtr processing_config,
    const media::AudioParameters& processing_output_params,
    const media::AudioParameters& device_params,
    DeviceOutputListener* device_output_listener,
    media::AecdumpRecordingManager* aecdump_recording_manager) { … }
#endif

InputController::~InputController() { … }

// static
std::unique_ptr<InputController> InputController::Create(
    media::AudioManager* audio_manager,
    EventHandler* event_handler,
    SyncWriter* sync_writer,
    media::UserInputMonitor* user_input_monitor,
    DeviceOutputListener* device_output_listener,
    media::AecdumpRecordingManager* aecdump_recording_manager,
    media::mojom::AudioProcessingConfigPtr processing_config,
    const media::AudioParameters& params,
    const std::string& device_id,
    bool enable_agc) { … }

void InputController::Record() { … }

void InputController::Close() { … }

void InputController::SetVolume(double volume) { … }

void InputController::SetOutputDeviceForAec(
    const std::string& output_device_id) { … }

void InputController::OnStreamActive(Snoopable* output_stream) { … }

void InputController::OnStreamInactive(Snoopable* output_stream) { … }

InputController::ErrorCode MapOpenOutcomeToErrorCode(OpenOutcome outcome) { … }

void InputController::DoCreate(media::AudioManager* audio_manager,
                               const media::AudioParameters& params,
                               const std::string& device_id,
                               bool enable_agc) { … }

void InputController::DoReportError() { … }

void InputController::DoLogAudioLevels(float level_dbfs,
                                       int microphone_volume_percent) { … }

#if defined(AUDIO_POWER_MONITORING)
void InputController::UpdateSilenceState(bool silence) { … }

#endif

void InputController::LogCaptureStartupResult(CaptureStartupResult result) { … }

void InputController::LogCallbackError() { … }

void InputController::LogMessage(const std::string& message) { … }

bool InputController::CheckForKeyboardInput() { … }

bool InputController::CheckAudioPower(const media::AudioBus* source,
                                      double volume,
                                      float* average_power_dbfs,
                                      int* mic_volume_percent) { … }

void InputController::CheckMutedState() { … }

void InputController::ReportIsAlive() { … }

void InputController::OnData(const media::AudioBus* source,
                             base::TimeTicks capture_time,
                             double volume,
                             const media::AudioGlitchInfo& glitch_info) { … }

#if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
void InputController::DeliverProcessedAudio(
    const media::AudioBus& audio_bus,
    base::TimeTicks audio_capture_time,
    std::optional<double> new_volume,
    const media::AudioGlitchInfo& glitch_info) { … }
#endif

// static
InputController::StreamType InputController::ParamsToStreamType(
    const media::AudioParameters& params) { … }

}  // namespace audio
chromium/services/audio/input_controller.cc
