| // Copyright 2016 The Fuchsia 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 "src/media/audio/audio_core/audio_device_manager.h" |
| |
| #include <lib/fit/promise.h> |
| #include <lib/fit/single_threaded_executor.h> |
| #include <lib/trace/event.h> |
| |
| #include <string> |
| |
| #include "src/media/audio/audio_core/audio_core_impl.h" |
| #include "src/media/audio/audio_core/base_capturer.h" |
| #include "src/media/audio/audio_core/base_renderer.h" |
| #include "src/media/audio/audio_core/driver_output.h" |
| #include "src/media/audio/audio_core/plug_detector.h" |
| #include "src/media/audio/audio_core/reporter.h" |
| #include "src/media/audio/lib/logging/logging.h" |
| |
| namespace media::audio { |
| |
| AudioDeviceManager::AudioDeviceManager(ThreadingModel& threading_model, |
| std::unique_ptr<PlugDetector> plug_detector, |
| RouteGraph& route_graph, LinkMatrix& link_matrix, |
| ProcessConfig& process_config) |
| : threading_model_(threading_model), |
| route_graph_(route_graph), |
| plug_detector_(std::move(plug_detector)), |
| link_matrix_(link_matrix), |
| process_config_(process_config) {} |
| |
| AudioDeviceManager::~AudioDeviceManager() { |
| Shutdown(); |
| FX_DCHECK(devices_.empty()); |
| } |
| |
| // Configure this admin singleton object to manage audio device instances. |
| zx_status_t AudioDeviceManager::Init() { |
| TRACE_DURATION("audio", "AudioDeviceManager::Init"); |
| |
| // Start monitoring for plug/unplug events of pluggable audio output devices. |
| zx_status_t res = |
| plug_detector_->Start(fit::bind_member(this, &AudioDeviceManager::AddDeviceByVersion)); |
| if (res != ZX_OK) { |
| FX_PLOGS(ERROR, res) << "AudioDeviceManager failed to start plug detector"; |
| return res; |
| } |
| |
| return ZX_OK; |
| } |
| |
| // We are no longer managing audio devices, unwind everything. |
| void AudioDeviceManager::Shutdown() { |
| TRACE_DURATION("audio", "AudioDeviceManager::Shutdown"); |
| plug_detector_->Stop(); |
| |
| std::vector<fit::promise<void>> device_promises; |
| for (auto& [_, device] : devices_pending_init_) { |
| device_promises.push_back(device->Shutdown()); |
| } |
| devices_pending_init_.clear(); |
| |
| for (auto& [_, device] : devices_) { |
| device_promises.push_back(device->Shutdown()); |
| } |
| devices_.clear(); |
| |
| fit::run_single_threaded(fit::join_promise_vector(std::move(device_promises))); |
| } |
| |
| fit::promise<void, fuchsia::media::audio::UpdateEffectError> AudioDeviceManager::UpdateEffect( |
| const std::string& instance_name, const std::string& config, bool persist) { |
| if (persist) { |
| persisted_effects_updates_[instance_name] = config; |
| } |
| std::vector<fit::promise<void, fuchsia::media::audio::UpdateEffectError>> promises; |
| for (auto& [_, device] : devices_) { |
| promises.push_back(device->UpdateEffect(instance_name, config)); |
| } |
| return fit::join_promise_vector(std::move(promises)) |
| .then( |
| [](fit::result<std::vector<fit::result<void, fuchsia::media::audio::UpdateEffectError>>>& |
| results) -> fit::result<void, fuchsia::media::audio::UpdateEffectError> { |
| FX_DCHECK(results.is_ok()) << "fit::join_promise_vector returns an error"; |
| bool found = false; |
| for (const auto& result : results.value()) { |
| if (result.is_error() && |
| result.error() == fuchsia::media::audio::UpdateEffectError::INVALID_CONFIG) { |
| return result; |
| } |
| if (result.is_ok()) { |
| found = true; |
| } |
| } |
| if (found) { |
| return fit::ok(); |
| } else { |
| return fit::error(fuchsia::media::audio::UpdateEffectError::NOT_FOUND); |
| } |
| }); |
| } |
| |
| fit::promise<void, fuchsia::media::audio::UpdateEffectError> AudioDeviceManager::UpdateDeviceEffect( |
| const std::string device_id, const std::string& instance_name, const std::string& message) { |
| auto devices = GetDeviceInfos(); |
| const auto dev = std::find_if(devices.begin(), devices.end(), [&device_id](auto candidate) { |
| return candidate.unique_id == device_id; |
| }); |
| if (dev == devices.end()) { |
| return fit::make_error_promise(fuchsia::media::audio::UpdateEffectError::NOT_FOUND); |
| } |
| auto device = devices_[dev->token_id]; |
| FX_DCHECK(device); |
| |
| return device->UpdateEffect(instance_name, message) |
| .then([](fit::result<void, fuchsia::media::audio::UpdateEffectError>& result) |
| -> fit::result<void, fuchsia::media::audio::UpdateEffectError> { |
| if (result.is_ok()) { |
| return fit::ok(); |
| } |
| if (result.error() == fuchsia::media::audio::UpdateEffectError::INVALID_CONFIG) { |
| return result; |
| } else { |
| return fit::error(fuchsia::media::audio::UpdateEffectError::NOT_FOUND); |
| } |
| }); |
| } |
| |
| fit::promise<void, zx_status_t> AudioDeviceManager::UpdatePipelineConfig( |
| const std::string device_id, const PipelineConfig& pipeline_config, |
| const VolumeCurve& volume_curve) { |
| auto devices = GetDeviceInfos(); |
| const auto dev = std::find_if(devices.begin(), devices.end(), [&device_id](auto candidate) { |
| return candidate.unique_id == device_id; |
| }); |
| if (dev == devices.end()) { |
| return fit::make_error_promise(ZX_ERR_NOT_FOUND); |
| } |
| auto device = devices_[dev->token_id]; |
| FX_DCHECK(device); |
| |
| // UpdatePipelineConfig is only valid on a device that is currently routable; the routable state |
| // protects from devices being plugged or unplugged during update of the PipelineConfig, |
| // as well as ensures only one update to the PipelineConfig will be processed at a time. |
| if (!device->routable()) { |
| return fit::make_error_promise(ZX_ERR_BAD_STATE); |
| } |
| |
| // UpdatePipelineConfig is only valid on a device without links (for the purpose of effects |
| // tuning). As such, the device is removed from route_graph to ensure all links are removed. |
| if (device->plugged()) { |
| route_graph_.RemoveDevice(device.get()); |
| } |
| FX_DCHECK(link_matrix_.DestLinkCount(*device) == 0); |
| FX_DCHECK(link_matrix_.SourceLinkCount(*device) == 0); |
| |
| device->UpdateRoutableState(false); |
| auto profile_params = DeviceConfig::OutputDeviceProfile::Parameters{ |
| .pipeline_config = pipeline_config, .volume_curve = volume_curve}; |
| return device->UpdateDeviceProfile(profile_params).and_then([this, device]() { |
| device->UpdateRoutableState(true); |
| if (device->plugged()) { |
| route_graph_.AddDevice(device.get()); |
| } |
| }); |
| } |
| |
| void AudioDeviceManager::AddDevice(const std::shared_ptr<AudioDevice>& device) { |
| TRACE_DURATION("audio", "AudioDeviceManager::AddDevice"); |
| FX_DCHECK(device != nullptr); |
| |
| threading_model_.FidlDomain().executor()->schedule_task( |
| device->Startup() |
| .and_then([this, device]() mutable { |
| devices_pending_init_.insert({device->token(), std::move(device)}); |
| }) |
| .or_else([device](zx_status_t& error) { |
| FX_PLOGS(ERROR, error) << "AddDevice failed"; |
| Reporter::Singleton().FailedToStartDevice(device->name()); |
| device->Shutdown(); |
| })); |
| } |
| |
| void AudioDeviceManager::ActivateDevice(const std::shared_ptr<AudioDevice>& device) { |
| TRACE_DURATION("audio", "AudioDeviceManager::ActivateDevice"); |
| FX_DCHECK(device != nullptr); |
| |
| // Have we already been removed from the pending list? If so, the device is |
| // already shutting down and there is nothing to be done. |
| if (devices_pending_init_.find(device->token()) == devices_pending_init_.end()) { |
| return; |
| } |
| |
| // If this device is still waiting for initialization, move it over to the set of active devices. |
| // Otherwise (if not waiting for initialization), we've been removed. |
| auto dev = devices_pending_init_.extract(device->token()); |
| if (!dev) { |
| return; |
| } |
| |
| devices_.insert(std::move(dev)); |
| device->SetActivated(); |
| |
| // Apply persisted effects updates. |
| std::vector<fit::promise<void, void>> promises; |
| for (auto it : persisted_effects_updates_) { |
| std::string instance_name = it.first; |
| std::string config = it.second; |
| promises.push_back( |
| device->UpdateEffect(instance_name, config) |
| .then([instance_name, |
| config](fit::result<void, fuchsia::media::audio::UpdateEffectError>& result) { |
| if (result.is_error()) { |
| FX_LOGS_FIRST_N(ERROR, 10) << "Unable to update effect " << instance_name |
| << ", error code " << static_cast<int>(result.error()); |
| } |
| })); |
| } |
| threading_model_.FidlDomain().executor()->schedule_task( |
| fit::join_promise_vector(std::move(promises))); |
| |
| // Notify interested users of the new device. |
| auto info = device->GetDeviceInfo(); |
| |
| // We always report is_default as false in the OnDeviceAdded event. There will be a following |
| // DefaultDeviceChange event that will signal if this device is now the default. |
| info.is_default = false; |
| |
| for (auto& client : bindings_.bindings()) { |
| client->events().OnDeviceAdded(info); |
| } |
| |
| if (device->plugged()) { |
| OnDevicePlugged(device, device->plug_time()); |
| } |
| } |
| |
| void AudioDeviceManager::RemoveDevice(const std::shared_ptr<AudioDevice>& device) { |
| TRACE_DURATION("audio", "AudioDeviceManager::RemoveDevice"); |
| FX_DCHECK(device != nullptr); |
| |
| FX_LOGS(INFO) << "Removing " << (device->is_input() ? "input" : "output") << " '" |
| << device->name() << "'"; |
| |
| // If device was active: reset the default (based on most-recently-plugged). |
| OnPlugStateChanged(device, false, device->plug_time()); |
| device->Shutdown(); |
| |
| auto& device_set = device->activated() ? devices_ : devices_pending_init_; |
| device_set.erase(device->token()); |
| |
| // If device was active: notify clients of the removal. |
| if (device->activated()) { |
| for (auto& client : bindings_.bindings()) { |
| client->events().OnDeviceRemoved(device->token()); |
| } |
| } |
| } |
| |
| void AudioDeviceManager::OnPlugStateChanged(const std::shared_ptr<AudioDevice>& device, |
| bool plugged, zx::time plug_time) { |
| TRACE_DURATION("audio", "AudioDeviceManager::OnPlugStateChanged"); |
| FX_DCHECK(device != nullptr); |
| |
| // Update our bookkeeping for device's plug state. If no change, we're done. |
| if (!device->UpdatePlugState(plugged, plug_time)) { |
| return; |
| } |
| |
| // If the device is not yet activated, we should not be changing routes. |
| bool activated = devices_.find(device->token()) != devices_.end(); |
| if (!activated) { |
| return; |
| } |
| |
| if (plugged) { |
| OnDevicePlugged(device, plug_time); |
| } else { |
| OnDeviceUnplugged(device, plug_time); |
| } |
| } |
| |
| std::vector<fuchsia::media::AudioDeviceInfo> AudioDeviceManager::GetDeviceInfos() { |
| TRACE_DURATION("audio", "AudioDeviceManager::GetDevices"); |
| std::vector<fuchsia::media::AudioDeviceInfo> ret; |
| |
| for (const auto& [_, dev] : devices_) { |
| if (dev->token() != ZX_KOID_INVALID) { |
| auto info = dev->GetDeviceInfo(); |
| info.is_default = |
| (dev->token() == (dev->is_input() ? default_input_token_ : default_output_token_)); |
| ret.push_back(std::move(info)); |
| } |
| } |
| |
| return ret; |
| } |
| |
| void AudioDeviceManager::GetDevices(GetDevicesCallback cbk) { cbk(GetDeviceInfos()); } |
| |
| void AudioDeviceManager::GetDeviceGain(uint64_t device_token, GetDeviceGainCallback cbk) { |
| TRACE_DURATION("audio", "AudioDeviceManager::GetDeviceGain"); |
| |
| auto it = devices_.find(device_token); |
| if (it == devices_.end()) { |
| cbk(ZX_KOID_INVALID, {}); |
| return; |
| } |
| |
| auto [_, dev] = *it; |
| FX_DCHECK(dev->device_settings() != nullptr); |
| auto info = dev->device_settings()->GetGainInfo(); |
| cbk(device_token, info); |
| } |
| |
| void AudioDeviceManager::SetDeviceGain(uint64_t device_token, |
| fuchsia::media::AudioGainInfo gain_info, |
| fuchsia::media::AudioGainValidFlags set_flags) { |
| TRACE_DURATION("audio", "AudioDeviceManager::SetDeviceGain"); |
| auto it = devices_.find(device_token); |
| if (it == devices_.end()) { |
| return; |
| } |
| auto [_, dev] = *it; |
| |
| // SetGainInfo clamps out-of-range values (e.g. +infinity) into the device- |
| // allowed gain range. NAN is undefined (signless); handle it here and exit. |
| if (((set_flags & fuchsia::media::AudioGainValidFlags::GAIN_VALID) == |
| fuchsia::media::AudioGainValidFlags::GAIN_VALID) && |
| isnan(gain_info.gain_db)) { |
| FX_LOGS(WARNING) << "Invalid device gain " << gain_info.gain_db << " dB -- making no change"; |
| return; |
| } |
| |
| dev->system_gain_dirty = true; |
| |
| // Change the gain and then report the new settings to our clients. |
| dev->SetGainInfo(gain_info, set_flags); |
| NotifyDeviceGainChanged(*dev); |
| } |
| |
| void AudioDeviceManager::GetDefaultInputDevice(GetDefaultInputDeviceCallback cbk) { |
| cbk(default_input_token_); |
| } |
| |
| void AudioDeviceManager::GetDefaultOutputDevice(GetDefaultOutputDeviceCallback cbk) { |
| cbk(default_output_token_); |
| } |
| |
| std::shared_ptr<AudioDevice> AudioDeviceManager::FindLastPlugged(AudioObject::Type type, |
| bool allow_unplugged) { |
| TRACE_DURATION("audio", "AudioDeviceManager::FindLastPlugged"); |
| FX_DCHECK((type == AudioObject::Type::Output) || (type == AudioObject::Type::Input)); |
| std::shared_ptr<AudioDevice> best = nullptr; |
| |
| // TODO(johngro): Consider tracking last-plugged times in a fbl::WAVLTree, so |
| // this operation becomes O(1). N is pretty low right now, so the benefits do |
| // not currently outweigh the complexity of maintaining this index. |
| for (auto& [_, device] : devices_) { |
| if (device->type() != type) { |
| continue; |
| } |
| |
| if ((best == nullptr) || (!best->plugged() && device->plugged()) || |
| ((best->plugged() == device->plugged()) && (best->plug_time() < device->plug_time()))) { |
| best = device; |
| } |
| } |
| |
| FX_DCHECK((best == nullptr) || (best->type() == type)); |
| if (!allow_unplugged && best && !best->plugged()) { |
| return nullptr; |
| } |
| |
| return best; |
| } |
| |
| void AudioDeviceManager::OnDeviceUnplugged(const std::shared_ptr<AudioDevice>& device, |
| zx::time plug_time) { |
| TRACE_DURATION("audio", "AudioDeviceManager::OnDeviceUnplugged"); |
| FX_DCHECK(device); |
| FX_LOGS(INFO) << "Unplugged " << (device->is_input() ? "input" : "output") << " '" |
| << device->name() << "'"; |
| |
| device->UpdatePlugState(/*plugged=*/false, plug_time); |
| |
| if (device->routable()) { |
| route_graph_.RemoveDevice(device.get()); |
| } |
| UpdateDefaultDevice(device->is_input()); |
| } |
| |
| void AudioDeviceManager::OnDevicePlugged(const std::shared_ptr<AudioDevice>& device, |
| zx::time plug_time) { |
| TRACE_DURATION("audio", "AudioDeviceManager::OnDevicePlugged"); |
| FX_DCHECK(device); |
| FX_LOGS(INFO) << "Plugged " << (device->is_input() ? "input" : "output") << " '" << device->name() |
| << "'"; |
| |
| device->UpdatePlugState(/*plugged=*/true, plug_time); |
| |
| if (device->routable()) { |
| route_graph_.AddDevice(device.get()); |
| } |
| UpdateDefaultDevice(device->is_input()); |
| } |
| |
| void AudioDeviceManager::NotifyDeviceGainChanged(const AudioDevice& device) { |
| TRACE_DURATION("audio", "AudioDeviceManager::NotifyDeviceGainChanged"); |
| FX_DCHECK(device.device_settings() != nullptr); |
| auto info = device.device_settings()->GetGainInfo(); |
| |
| for (auto& client : bindings_.bindings()) { |
| client->events().OnDeviceGainChanged(device.token(), info); |
| } |
| } |
| |
| void AudioDeviceManager::UpdateDefaultDevice(bool input) { |
| TRACE_DURATION("audio", "AudioDeviceManager::UpdateDefaultDevice"); |
| const auto new_dev = |
| FindLastPlugged(input ? AudioObject::Type::Input : AudioObject::Type::Output); |
| uint64_t new_id = new_dev ? new_dev->token() : ZX_KOID_INVALID; |
| uint64_t& old_id = input ? default_input_token_ : default_output_token_; |
| |
| if (old_id != new_id) { |
| FX_LOGS(INFO) << "Default " << (input ? "input" : "output") << " '" |
| << (new_dev ? new_dev->name() : "none") << "'"; |
| |
| for (auto& client : bindings_.bindings()) { |
| client->events().OnDefaultDeviceChanged(old_id, new_id); |
| } |
| old_id = new_id; |
| } |
| } |
| |
| void AudioDeviceManager::AddDeviceByVersion(zx::channel device_channel, std::string device_name, |
| bool is_input, AudioDriverVersion version) { |
| FX_LOGS(DEBUG) << "AddingByVersion (" << (version == AudioDriverVersion::V1 ? "V1" : "V2") << ")" |
| << (is_input ? "input" : "output") << " '" << device_name << "'"; |
| switch (version) { |
| case AudioDriverVersion::V1: |
| AddDeviceByChannel(std::move(device_channel), std::move(device_name), is_input); |
| break; |
| case AudioDriverVersion::V2: |
| fidl::InterfaceHandle<fuchsia::hardware::audio::StreamConfig> stream_config = {}; |
| stream_config.set_channel(std::move(device_channel)); |
| AddDeviceByChannel2(std::move(device_name), is_input, std::move(stream_config)); |
| break; |
| } |
| } |
| |
| void AudioDeviceManager::AddDeviceByChannel(zx::channel device_channel, std::string device_name, |
| bool is_input) { |
| TRACE_DURATION("audio", "AudioDeviceManager::AddDeviceByChannel"); |
| FX_LOGS(INFO) << "Adding " << (is_input ? "input" : "output") << " '" << device_name << "'"; |
| |
| // Hand the stream off to the proper type of class to manage. |
| std::shared_ptr<AudioDevice> new_device; |
| if (is_input) { |
| new_device = AudioInput::Create(device_name, std::move(device_channel), &threading_model(), |
| this, &link_matrix_); |
| } else { |
| new_device = std::make_shared<DriverOutput>(device_name, &threading_model(), this, |
| std::move(device_channel), &link_matrix_, |
| process_config_.default_volume_curve()); |
| } |
| |
| if (new_device == nullptr) { |
| FX_LOGS(ERROR) << "Failed to instantiate audio " << (is_input ? "input" : "output") << " for '" |
| << device_name << "'"; |
| } |
| |
| AddDevice(std::move(new_device)); |
| } |
| |
| void AudioDeviceManager::AddDeviceByChannel2( |
| std::string device_name, bool is_input, |
| fidl::InterfaceHandle<fuchsia::hardware::audio::StreamConfig> stream_config) { |
| TRACE_DURATION("audio", "AudioDeviceManager::AddDeviceByChannel2"); |
| FX_LOGS(INFO) << "Adding " << (is_input ? "input" : "output") << " '" << device_name << "'"; |
| |
| // Hand the stream off to the proper type of class to manage. |
| std::shared_ptr<AudioDevice> new_device; |
| if (is_input) { |
| new_device = AudioInput::Create(device_name, std::move(stream_config), &threading_model(), this, |
| &link_matrix_); |
| } else { |
| new_device = std::make_shared<DriverOutput>(device_name, &threading_model(), this, |
| std::move(stream_config), &link_matrix_, |
| process_config_.default_volume_curve()); |
| } |
| |
| if (new_device == nullptr) { |
| FX_LOGS(ERROR) << "Failed to instantiate audio " << (is_input ? "input" : "output") << " for '" |
| << device_name << "'"; |
| } |
| |
| AddDevice(std::move(new_device)); |
| } |
| |
| } // namespace media::audio |
