123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831 |
- // 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 <memory>
- #include <utility>
- #include "base/bind.h"
- #include "base/cxx17_backports.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/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/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/concurrent_stream_metric_reporter.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 {
- using OpenOutcome = media::AudioInputStream::OpenOutcome;
- const int kMaxInputChannels = 3;
- constexpr base::TimeDelta kCheckMutedStateInterval = base::Seconds(1);
- #if defined(AUDIO_POWER_MONITORING)
- // Time in seconds between two successive measurements of audio power levels.
- constexpr base::TimeDelta kPowerMonitorLogInterval = base::Seconds(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::clamp(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
- } // 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 {
- public:
- using OnDataCallback = base::RepeatingCallback<
- void(const media::AudioBus*, base::TimeTicks, double volume)>;
- using OnFirstDataCallback = base::OnceCallback<void()>;
- using OnErrorCallback = base::RepeatingCallback<void()>;
- // All callbacks are called on the hw callback thread.
- AudioCallback(OnDataCallback on_data_callback,
- OnFirstDataCallback on_first_data_callback,
- OnErrorCallback on_error_callback)
- : on_data_callback_(std::move(on_data_callback)),
- on_first_data_callback_(std::move(on_first_data_callback)),
- on_error_callback_(std::move(on_error_callback)) {
- DCHECK(on_data_callback_);
- DCHECK(on_first_data_callback_);
- DCHECK(on_error_callback_);
- }
- ~AudioCallback() override = default;
- // These should not be called when the stream is live.
- bool received_callback() const { return !on_first_data_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 (on_first_data_callback_) {
- // Mark the stream as alive at first audio callback. Currently only used
- // for logging purposes.
- std::move(on_first_data_callback_).Run();
- }
- on_data_callback_.Run(source, capture_time, volume);
- }
- void OnError() override {
- error_during_callback_ = true;
- on_error_callback_.Run();
- }
- const OnDataCallback on_data_callback_;
- OnFirstDataCallback on_first_data_callback_;
- const OnErrorCallback on_error_callback_;
- bool error_during_callback_ = false;
- };
- InputController::InputController(
- EventHandler* event_handler,
- SyncWriter* sync_writer,
- media::UserInputMonitor* user_input_monitor,
- InputStreamActivityMonitor* activity_monitor,
- DeviceOutputListener* device_output_listener,
- AecdumpRecordingManager* aecdump_recording_manager,
- media::mojom::AudioProcessingConfigPtr processing_config,
- const media::AudioParameters& output_params,
- const media::AudioParameters& device_params,
- StreamType type)
- : task_runner_(base::ThreadTaskRunnerHandle::Get()),
- event_handler_(event_handler),
- stream_(nullptr),
- sync_writer_(sync_writer),
- type_(type),
- user_input_monitor_(user_input_monitor),
- activity_monitor_(activity_monitor) {
- DCHECK(task_runner_->BelongsToCurrentThread());
- DCHECK(event_handler_);
- DCHECK(sync_writer_);
- DCHECK(activity_monitor_);
- weak_this_ = weak_ptr_factory_.GetWeakPtr();
- #if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
- MaybeSetUpAudioProcessing(std::move(processing_config), output_params,
- device_params, device_output_listener,
- aecdump_recording_manager);
- #endif
- if (!user_input_monitor_) {
- event_handler_->OnLog(
- "AIC::InputController() => (WARNING: keypress monitoring is disabled)");
- }
- }
- #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,
- AecdumpRecordingManager* aecdump_recording_manager) {
- if (!device_output_listener)
- return;
- if (!(processing_config &&
- processing_config->settings.NeedAudioModification())) {
- return;
- }
- absl::optional<media::AudioParameters> processing_input_params =
- media::AudioProcessor::ComputeInputFormat(device_params,
- processing_config->settings);
- if (!processing_input_params) {
- event_handler_->OnLog(base::StringPrintf(
- "AIC::MaybeSetupAudioProcessing() => (Unsupported device_params=%s, "
- "cannot do audio processing)",
- device_params.AsHumanReadableString().c_str()));
- return;
- }
- // In case fake audio input is requested.
- processing_input_params->set_format(processing_output_params.format());
- // Unretained() is safe, since |this| and |event_handler_| outlive
- // |audio_processor_handler_|.
- audio_processor_handler_ = std::make_unique<AudioProcessorHandler>(
- processing_config->settings, *processing_input_params,
- processing_output_params,
- base::BindRepeating(&EventHandler::OnLog,
- base::Unretained(event_handler_)),
- base::BindRepeating(&InputController::DeliverProcessedAudio,
- base::Unretained(this)),
- std::move(processing_config->controls_receiver),
- aecdump_recording_manager);
- // If the required processing is lightweight, there is no need to offload work
- // to a new thread.
- if (!processing_config->settings.NeedPlayoutReference())
- return;
- int fifo_size = media::kChromeWideEchoCancellationProcessingFifoSize.Get();
- // Only use the FIFO/new thread if its size is explicitly set.
- if (fifo_size) {
- // base::Unretained() is safe since both |audio_processor_handler_| and
- // |event_handler_| outlive |processing_fifo_|.
- processing_fifo_ = std::make_unique<ProcessingAudioFifo>(
- *processing_input_params, fifo_size,
- base::BindRepeating(&AudioProcessorHandler::ProcessCapturedAudio,
- base::Unretained(audio_processor_handler_.get())),
- base::BindRepeating(&EventHandler::OnLog,
- base::Unretained(event_handler_.get())));
- }
- // Unretained() is safe, since |event_handler_| outlives |output_tapper_|.
- output_tapper_ = std::make_unique<OutputTapper>(
- device_output_listener, audio_processor_handler_.get(),
- base::BindRepeating(&EventHandler::OnLog,
- base::Unretained(event_handler_)));
- }
- #endif
- InputController::~InputController() {
- DCHECK(task_runner_->BelongsToCurrentThread());
- 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,
- InputStreamActivityMonitor* activity_monitor,
- DeviceOutputListener* device_output_listener,
- AecdumpRecordingManager* aecdump_recording_manager,
- media::mojom::AudioProcessingConfigPtr processing_config,
- const media::AudioParameters& params,
- const std::string& device_id,
- bool enable_agc) {
- DCHECK(audio_manager);
- DCHECK(audio_manager->GetTaskRunner()->BelongsToCurrentThread());
- DCHECK(activity_monitor);
- DCHECK(sync_writer);
- DCHECK(event_handler);
- DCHECK(params.IsValid());
- if (params.channels() > kMaxInputChannels)
- return nullptr;
- const media::AudioParameters device_params =
- AudioManagerPowerUser(audio_manager).GetInputStreamParameters(device_id);
- // Create the InputController object and ensure that it runs on
- // the audio-manager thread.
- // Using `new` to access a non-public constructor.
- std::unique_ptr<InputController> controller =
- base::WrapUnique(new InputController(
- event_handler, sync_writer, user_input_monitor, activity_monitor,
- device_output_listener, aecdump_recording_manager,
- std::move(processing_config), params, device_params,
- ParamsToStreamType(params)));
- controller->DoCreate(audio_manager, params, device_id, enable_agc);
- return controller;
- }
- void InputController::Record() {
- DCHECK(task_runner_->BelongsToCurrentThread());
- SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.RecordTime");
- if (!stream_ || audio_callback_)
- return;
- event_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();
- // Unretained() is safe, since |this| outlives |audio_callback_|.
- // |on_first_data_callback| and |on_error_callback| calls are posted on the
- // audio thread, since all AudioCallback callbacks run on the hw callback
- // thread.
- audio_callback_ = std::make_unique<AudioCallback>(
- /*on_data_callback=*/base::BindRepeating(&InputController::OnData,
- base::Unretained(this)),
- /*on_first_data_callback=*/
- base::BindPostTask(
- task_runner_,
- base::BindOnce(&InputController::ReportIsAlive, weak_this_)),
- /*on_error_callback=*/
- base::BindPostTask(
- task_runner_,
- base::BindRepeating(&InputController::DoReportError, weak_this_)));
- #if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
- if (processing_fifo_)
- processing_fifo_->Start();
- if (output_tapper_)
- output_tapper_->Start();
- #endif
- stream_->Start(audio_callback_.get());
- activity_monitor_->OnInputStreamActive();
- return;
- }
- void InputController::Close() {
- DCHECK(task_runner_->BelongsToCurrentThread());
- SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CloseTime");
- if (!stream_)
- return;
- check_muted_state_timer_.AbandonAndStop();
- 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_) {
- // Calls to OnData() should stop beyond this point.
- stream_->Stop();
- #if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
- if (output_tapper_)
- output_tapper_->Stop();
- if (processing_fifo_) {
- // Stop the FIFO after |stream_| is stopped, to guarantee there are no
- // more calls to OnData().
- // Note: destroying the FIFO will synchronously wait for the processing
- // thread to stop.
- processing_fifo_.reset();
- }
- #endif
- activity_monitor_->OnInputStreamInactive();
- // 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);
- }
- event_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_));
- event_handler_->OnLog(log_string);
- }
- #endif
- max_volume_ = 0.0;
- weak_ptr_factory_.InvalidateWeakPtrs();
- }
- void InputController::SetVolume(double volume) {
- DCHECK(task_runner_->BelongsToCurrentThread());
- DCHECK_GE(volume, 0);
- DCHECK_LE(volume, 1.0);
- if (!stream_)
- return;
- event_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(task_runner_->BelongsToCurrentThread());
- if (stream_)
- stream_->SetOutputDeviceForAec(output_device_id);
- #if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
- if (output_tapper_)
- output_tapper_->SetOutputDeviceForAec(output_device_id);
- #endif
- }
- void InputController::OnStreamActive(Snoopable* output_stream) {
- DCHECK(task_runner_->BelongsToCurrentThread());
- }
- void InputController::OnStreamInactive(Snoopable* output_stream) {
- DCHECK(task_runner_->BelongsToCurrentThread());
- }
- InputController::ErrorCode MapOpenOutcomeToErrorCode(OpenOutcome outcome) {
- switch (outcome) {
- case OpenOutcome::kFailedSystemPermissions:
- return InputController::STREAM_OPEN_SYSTEM_PERMISSIONS_ERROR;
- case OpenOutcome::kFailedInUse:
- return InputController::STREAM_OPEN_DEVICE_IN_USE_ERROR;
- default:
- return InputController::STREAM_OPEN_ERROR;
- }
- }
- void InputController::DoCreate(media::AudioManager* audio_manager,
- const media::AudioParameters& params,
- const std::string& device_id,
- bool enable_agc) {
- DCHECK(task_runner_->BelongsToCurrentThread());
- DCHECK(!stream_);
- SCOPED_UMA_HISTOGRAM_TIMER("Media.AudioInputController.CreateTime");
- event_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
- const media::AudioParameters audio_input_stream_params =
- #if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
- audio_processor_handler_ ? audio_processor_handler_->input_format() :
- #endif
- params;
- // Unretained is safe since |this| owns |stream|.
- auto* stream = audio_manager->MakeAudioInputStream(
- audio_input_stream_params, device_id,
- base::BindRepeating(&InputController::LogMessage,
- base::Unretained(this)));
- if (!stream) {
- LogCaptureStartupResult(CAPTURE_STARTUP_CREATE_STREAM_FAILED);
- event_handler_->OnError(STREAM_CREATE_ERROR);
- return;
- }
- auto open_outcome = stream->Open();
- if (open_outcome != OpenOutcome::kSuccess) {
- stream->Close();
- LogCaptureStartupResult(CAPTURE_STARTUP_OPEN_STREAM_FAILED);
- event_handler_->OnError(MapOpenOutcomeToErrorCode(open_outcome));
- 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;
- event_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();
- event_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(task_runner_->BelongsToCurrentThread());
- event_handler_->OnError(STREAM_ERROR);
- }
- void InputController::DoLogAudioLevels(float level_dbfs,
- int microphone_volume_percent) {
- #if defined(AUDIO_POWER_MONITORING)
- DCHECK(task_runner_->BelongsToCurrentThread());
- 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);
- event_handler_->OnLog("AIC::OnData => (microphone is muted)");
- } else {
- 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";
- event_handler_->OnLog(log_string + ")");
- if (!microphone_is_muted) {
- 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";
- event_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(task_runner_->BelongsToCurrentThread());
- event_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(task_runner_->BelongsToCurrentThread());
- DCHECK(stream_);
- const bool new_state = stream_->IsMuted();
- if (new_state != is_muted_) {
- is_muted_ = new_state;
- event_handler_->OnMuted(is_muted_);
- std::string log_string =
- base::StringPrintf("AIC::OnMuted({is_muted=%d})", is_muted_);
- event_handler_->OnLog(log_string);
- }
- }
- void InputController::ReportIsAlive() {
- DCHECK(task_runner_->BelongsToCurrentThread());
- DCHECK(stream_);
- // Don't store any state, just log the event for now.
- event_handler_->OnLog("AIC::OnData => (stream is alive)");
- }
- void InputController::OnData(const media::AudioBus* source,
- base::TimeTicks capture_time,
- double volume) {
- const bool key_pressed = CheckForKeyboardInput();
- #if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
- if (processing_fifo_) {
- DCHECK(audio_processor_handler_);
- processing_fifo_->PushData(source, capture_time, volume, key_pressed);
- } else if (audio_processor_handler_) {
- audio_processor_handler_->ProcessCapturedAudio(*source, capture_time,
- volume, key_pressed);
- } else
- #endif
- {
- sync_writer_->Write(source, volume, key_pressed, capture_time);
- }
- float average_power_dbfs;
- int mic_volume_percent;
- if (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_this_,
- average_power_dbfs, mic_volume_percent));
- }
- }
- #if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
- void InputController::DeliverProcessedAudio(const media::AudioBus& audio_bus,
- base::TimeTicks audio_capture_time,
- absl::optional<double> new_volume) {
- // When processing is performed in the audio service, the consumer is not
- // expected to use the input volume and keypress information.
- sync_writer_->Write(&audio_bus, /*volume=*/1.0,
- /*key_pressed=*/false, audio_capture_time);
- if (new_volume) {
- task_runner_->PostTask(
- FROM_HERE,
- base::BindOnce(&InputController::SetVolume, weak_this_, *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
|