src/media/audio/drivers/virtual_audio/virtual_audio_device_impl.cc - fuchsia - Git at Google

 // Copyright 2019 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/drivers/virtual_audio/virtual_audio_device_impl.h"

 #include <lib/zx/clock.h>

 #include <memory>

 #include <ddk/debug.h>

 #include "src/media/audio/drivers/virtual_audio/virtual_audio_stream.h"

 namespace virtual_audio {

 class VirtualAudioStreamIn;
 class VirtualAudioStreamOut;

 // static methods
 std::unique_ptr<VirtualAudioDeviceImpl> VirtualAudioDeviceImpl::Create(
     VirtualAudioControlImpl* owner, bool is_input) {
   return std::unique_ptr<VirtualAudioDeviceImpl>(new VirtualAudioDeviceImpl(owner, is_input));
 }

 // Don't initialize here or in ctor; do it all in Init() so ResetConfiguration has same effect.
 VirtualAudioDeviceImpl::VirtualAudioDeviceImpl(VirtualAudioControlImpl* owner, bool is_input)
     : owner_(owner), is_input_(is_input) {
   ZX_DEBUG_ASSERT(owner_);

   Init();
 }

 // If we have not already destroyed our child stream, do so now.
 VirtualAudioDeviceImpl::~VirtualAudioDeviceImpl() { RemoveStream(); }

 // Initialize (or reset) a device's static configuration.
 void VirtualAudioDeviceImpl::Init() {
   device_name_ = kDefaultDeviceName;
   mfr_name_ = kDefaultManufacturerName;
   prod_name_ = kDefaultProductName;
   memcpy(unique_id_, kDefaultUniqueId, sizeof(unique_id_));

   clock_domain_ = kDefaultClockDomain;
   clock_rate_adjustment_ = kDefaultClockRateAdjustment;

   // By default, we support one basic format range (stereo 16-bit 48kHz)
   supported_formats_.clear();
   supported_formats_.push_back(kDefaultFormatRange);

   fifo_depth_ = kDefaultFifoDepthBytes;
   external_delay_nsec_ = kDefaultExternalDelayNsec;

   min_buffer_frames_ = kDefaultMinBufferFrames;
   max_buffer_frames_ = kDefaultMaxBufferFrames;
   modulo_buffer_frames_ = kDefaultModuloBufferFrames;

   cur_gain_state_ = kDefaultGainState;

   hardwired_ = kDefaultHardwired;
   async_plug_notify_ = kDefaultPlugCanNotify;
   plugged_ = kDefaultPlugged;

   // The time this Configuration was created / reset.
   plug_time_ = zx::clock::get_monotonic().get();

   override_notification_frequency_ = false;
   notifications_per_ring_ = 0;
 }

 // Receive and cache a virtualaudio::Input binding, forwarded from the virtual_audio_service.
 // ControlImpl has already associated us with the binding: when it closes we will auto-destruct.
 void VirtualAudioDeviceImpl::SetBinding(
     fidl::Binding<fuchsia::virtualaudio::Input,
                   std::unique_ptr<virtual_audio::VirtualAudioDeviceImpl>>* binding) {
   ZX_ASSERT(is_input_);
   ZX_DEBUG_ASSERT(output_binding_ == nullptr);

   input_binding_ = binding;
   ZX_DEBUG_ASSERT(input_binding_->is_bound());
 }

 // Receive and cache a virtualaudio::Output binding, forwarded from the virtual_audio_service.
 // ControlImpl has already associated us with the binding: when it closes we will auto-destruct.
 void VirtualAudioDeviceImpl::SetBinding(
     fidl::Binding<fuchsia::virtualaudio::Output,
                   std::unique_ptr<virtual_audio::VirtualAudioDeviceImpl>>* binding) {
   ZX_ASSERT(!is_input_);
   ZX_DEBUG_ASSERT(input_binding_ == nullptr);

   output_binding_ = binding;
   ZX_DEBUG_ASSERT(output_binding_->is_bound());
 }

 // In response to an Input::Add or Output::Add call, create the stream (activate the device).
 bool VirtualAudioDeviceImpl::CreateStream(zx_device_t* devnode) {
   stream_ = VirtualAudioStream::CreateStream(this, devnode, is_input_);
   return (stream_ != nullptr);
 }

 // Remove our child stream by calling its DdkUnbind. This may already have occurred; check for null.
 //
 // TODO(mpuryear): This may not safely unwind in all cases: it makes some threading assumptions that
 // cannot necessarily be enforced. But until fxbug.dev/33258 is addressed, the current VAD code
 // appears to be safe -- all RemoveStream callers are on the devhost primary thread:
 //   ~VirtualAudioDeviceImpl from DevHost removing parent,
 //   ~VirtualAudioDeviceImpl from Input|Output FIDL channel disconnecting
 //   fuchsia.virtualaudio.Control.Disable
 //   fuchsia.virtualaudio.Input|Output.Remove
 void VirtualAudioDeviceImpl::RemoveStream() {
   if (stream_ != nullptr) {
     // Clear any queued dispatcher tasks, and no longer accept new tasks.
     task_queue_->StopAndClear();

     // This bool tells the stream that Unbind originates from us (parent), so don't call us back.
     stream_->shutdown_by_parent_ = true;

     // Shutdown won't return until any in-flight calls to PostToDispatcher are quiesced.
     // Shutdown deactivates its execution domain, and all PostToDispatcher calls are
     // made from this execution domain). This guarantee is critical, because Add changes what
     // task_queue_ points to. If calls to PostToDispatcher WERE still outstanding, then it would be
     // possible that Add could be called before task_queue_->Enqueue runs, causing us to erroneously
     // run a task associated with the older stream, in the context of the new stream.
     stream_->Shutdown();
     // Request the device be unbound.
     stream_->DdkAsyncRemove();

     // Now that the stream has done its shutdown, we release our reference.
     stream_ = nullptr;
   }
   // bindings are reset in the VirtualAudioDeviceImpl dtor
 }

 // In most cases, stream DdkUnbind is called by us (the parent DeviceImpl), above in RemoveStream.
 // In the other cases, this RemoveStream is eventually called, but we should not RE-call DdkUnbind
 // at that point. To cover those other cases, this ClearStream method allows the child stream to
 // signal to its parent that it has gone away. Conversely, the flag shutdown_by_parent_ provides the
 // device->stream signal in the other cases (such as when RemoveStream is called during the device
 // dtor), to let the stream know that it need not and should not call us.
 void VirtualAudioDeviceImpl::ClearStream() {
   // Clear any queued dispatcher tasks, and no longer accept new tasks.
   task_queue_->StopAndClear();

   // Forget about this stream, but don't do more right now -- our RemoveStream will be called later.
   stream_ = nullptr;
 }

 // Use closure_queue to post a dispatcher task -- cancellable if stream or device is destroyed.
 void VirtualAudioDeviceImpl::PostToDispatcher(fit::closure task_to_post) {
   // We know task_queue_ isn't changing which ClosureQueue it's holding as this line is running,
   // because RemoveStream always runs on the same thread as Add (the main devhost thread, the FIDL
   // dispatch thread, the ClosureQueue's destination thread), and RemoveStream quiesces all calls to
   // PostToDispatcher before it returns (and thus before Add changes what task_queue_ points to).
   task_queue_->Enqueue(std::move(task_to_post));
 }

 //
 // virtualaudio::Configuration implementation
 //
 void VirtualAudioDeviceImpl::SetDeviceName(std::string device_name) {
   device_name_ = device_name;

   WarnActiveStreamNotAffected(__func__);
 }

 void VirtualAudioDeviceImpl::SetManufacturer(std::string manufacturer_name) {
   mfr_name_ = manufacturer_name;

   WarnActiveStreamNotAffected(__func__);
 }

 void VirtualAudioDeviceImpl::SetProduct(std::string product_name) {
   prod_name_ = product_name;

   WarnActiveStreamNotAffected(__func__);
 }

 void VirtualAudioDeviceImpl::SetUniqueId(std::array<uint8_t, 16> unique_id) {
   memcpy(unique_id_, unique_id.data(), sizeof(unique_id_));

   WarnActiveStreamNotAffected(__func__);
 }

 // After creation or reset, one default format range is always available.
 void VirtualAudioDeviceImpl::AddFormatRange(uint32_t format_flags, uint32_t min_rate,
                                             uint32_t max_rate, uint8_t min_chans, uint8_t max_chans,
                                             uint16_t rate_family_flags) {
   audio_stream_format_range_t range = {.sample_formats = format_flags,
                                        .min_frames_per_second = min_rate,
                                        .max_frames_per_second = max_rate,
                                        .min_channels = min_chans,
                                        .max_channels = max_chans,
                                        .flags = rate_family_flags};

   supported_formats_.push_back(range);

   WarnActiveStreamNotAffected(__func__);
 }

 void VirtualAudioDeviceImpl::ClearFormatRanges() {
   supported_formats_.clear();
   WarnActiveStreamNotAffected(__func__);
 }

 void VirtualAudioDeviceImpl::WarnActiveStreamNotAffected(const char* func_name) {
   if (stream_ != nullptr) {
     zxlogf(WARNING, "%s updates the static config, but has no effect on existing streams",
            func_name);
   }
 }

 void VirtualAudioDeviceImpl::SetClockProperties(int32_t clock_domain,
                                                 int32_t initial_rate_adjustment_ppm) {
   clock_domain_ = clock_domain;
   clock_rate_adjustment_ = initial_rate_adjustment_ppm;

   WarnActiveStreamNotAffected(__func__);
 }

 void VirtualAudioDeviceImpl::SetFifoDepth(uint32_t fifo_depth_bytes) {
   fifo_depth_ = fifo_depth_bytes;

   WarnActiveStreamNotAffected(__func__);
 }

 void VirtualAudioDeviceImpl::SetExternalDelay(zx_duration_t external_delay) {
   external_delay_nsec_ = external_delay;

   WarnActiveStreamNotAffected(__func__);
 }

 void VirtualAudioDeviceImpl::SetRingBufferRestrictions(uint32_t min_frames, uint32_t max_frames,
                                                        uint32_t modulo_frames) {
   ZX_DEBUG_ASSERT(min_frames <= max_frames);
   ZX_DEBUG_ASSERT(min_frames % modulo_frames == 0);
   ZX_DEBUG_ASSERT(max_frames % modulo_frames == 0);

   min_buffer_frames_ = min_frames;
   max_buffer_frames_ = max_frames;
   modulo_buffer_frames_ = modulo_frames;

   WarnActiveStreamNotAffected(__func__);
 }

 void VirtualAudioDeviceImpl::SetGainProperties(float min_gain_db, float max_gain_db,
                                                float gain_step_db, float current_gain_db,
                                                bool can_mute, bool current_mute, bool can_agc,
                                                bool current_agc) {
   cur_gain_state_ = {.cur_mute = current_mute,
                      .cur_agc = current_agc,
                      .cur_gain = current_gain_db,

                      .can_mute = can_mute,
                      .can_agc = can_agc,

                      .min_gain = min_gain_db,
                      .max_gain = max_gain_db,
                      .gain_step = gain_step_db};

   WarnActiveStreamNotAffected(__func__);
 }

 void VirtualAudioDeviceImpl::SetPlugProperties(zx_time_t plug_change_time, bool plugged,
                                                bool hardwired, bool can_notify) {
   plug_time_ = plug_change_time;

   plugged_ = plugged;
   hardwired_ = hardwired;
   async_plug_notify_ = can_notify;

   WarnActiveStreamNotAffected(__func__);
 }

 void VirtualAudioDeviceImpl::ResetConfiguration() {
   Init();

   WarnActiveStreamNotAffected(__func__);
 }

 //
 // virtualaudio::Device implementation
 //
 // Create a virtual audio device using the currently-specified configuration.
 void VirtualAudioDeviceImpl::Add() {
   if (!owner_->enabled()) {
     zxlogf(WARNING, "%s: Disabled, cannot add stream", __func__);
     return;
   }

   if (stream_ != nullptr) {
     zxlogf(WARNING, "%s: %p already has stream %p", __func__, this, stream_.get());
     return;
   }

   // This ClosureQueue is created when stream is created), deactivated (via StopAndClear) when
   // stream is removed, and synchronized by being on devhost dispatcher thread (our FIDL thread).
   // DeviceImpl and Stream both call PostToDispatcher, and all are quiesced before we get here.
   // DeviceImpl makes those calls on the FIDL thread (task_queue_'s destination thread); all are
   // enqueued and subsequently discarded (via StopAndClear) upon RemoveStream. Stream makes those
   // calls in its execution domain, which is synchronously deactivated during its DdkUnbind.
   task_queue_.emplace(owner_->dispatcher(), thrd_current());
   if (!CreateStream(owner_->dev_node())) {
     zxlogf(ERROR, "CreateStream failed");
     task_queue_->StopAndClear();
     return;
   }
 }

 // Remove the associated virtual audio device.
 void VirtualAudioDeviceImpl::Remove() {
   if (!owner_->enabled()) {
     zxlogf(WARNING, "%s: Disabled, no streams for removal", __func__);
     ZX_DEBUG_ASSERT(stream_ == nullptr);
     return;
   }

   if (stream_ == nullptr) {
     zxlogf(WARNING, "%s: %p has no stream to remove", __func__, this);
     return;
   }

   // If stream_ exists, null our copy and call SimpleAudioStream::DdkUnbind (which eventually calls
   // ShutdownHook and re-nulls). We need this because stream terminations come either from "device"
   // (direct DdkUnbind call), or from "parent" (Control::Disable, Device::Remove, ~DeviceImpl).
   RemoveStream();
 }

 void VirtualAudioDeviceImpl::GetFormat(
     fuchsia::virtualaudio::Device::GetFormatCallback format_callback) {
   if (stream_ == nullptr) {
     zxlogf(WARNING, "%s: %p has no stream for this request", __func__, this);
     return;
   }

   stream_->EnqueueFormatRequest(std::move(format_callback));
 }

 // Deliver SetFormat notification on binding's thread, if binding is valid.
 void VirtualAudioDeviceImpl::NotifySetFormat(uint32_t frames_per_second, uint32_t sample_format,
                                              uint32_t num_channels, zx_duration_t external_delay) {
   PostToDispatcher([this, frames_per_second, sample_format, num_channels, external_delay]() {
     if (input_binding_ && input_binding_->is_bound()) {
       input_binding_->events().OnSetFormat(frames_per_second, sample_format, num_channels,
                                            external_delay);
     } else if (output_binding_ && output_binding_->is_bound()) {
       output_binding_->events().OnSetFormat(frames_per_second, sample_format, num_channels,
                                             external_delay);
     }
   });
 }

 void VirtualAudioDeviceImpl::GetGain(fuchsia::virtualaudio::Device::GetGainCallback gain_callback) {
   if (stream_ == nullptr) {
     zxlogf(WARNING, "%s: %p has no stream for this request", __func__, this);
     return;
   }

   stream_->EnqueueGainRequest(std::move(gain_callback));
 }

 // Deliver SetGain notification on binding's thread, if binding is valid.
 void VirtualAudioDeviceImpl::NotifySetGain(bool current_mute, bool current_agc,
                                            float current_gain_db) {
   PostToDispatcher([this, current_mute, current_agc, current_gain_db]() {
     if (input_binding_ && input_binding_->is_bound()) {
       input_binding_->events().OnSetGain(current_mute, current_agc, current_gain_db);
     } else if (output_binding_ && output_binding_->is_bound()) {
       output_binding_->events().OnSetGain(current_mute, current_agc, current_gain_db);
     }
   });
 }

 void VirtualAudioDeviceImpl::GetBuffer(
     fuchsia::virtualaudio::Device::GetBufferCallback buffer_callback) {
   if (stream_ == nullptr) {
     zxlogf(WARNING, "%s: %p has no stream for this request", __func__, this);
     return;
   }

   stream_->EnqueueBufferRequest(std::move(buffer_callback));
 }

 // Deliver SetBuffer notification on binding's thread, if binding is valid.
 void VirtualAudioDeviceImpl::NotifyBufferCreated(zx::vmo ring_buffer_vmo,
                                                  uint32_t num_ring_buffer_frames,
                                                  uint32_t notifications_per_ring) {
   PostToDispatcher([this, ring_buffer_vmo = std::move(ring_buffer_vmo), num_ring_buffer_frames,
                     notifications_per_ring]() mutable {
     if (input_binding_ && input_binding_->is_bound()) {
       input_binding_->events().OnBufferCreated(std::move(ring_buffer_vmo), num_ring_buffer_frames,
                                                notifications_per_ring);
     } else if (output_binding_ && output_binding_->is_bound()) {
       output_binding_->events().OnBufferCreated(std::move(ring_buffer_vmo), num_ring_buffer_frames,
                                                 notifications_per_ring);
     }
   });
 }

 // Override AudioCore's systemwide position notification cadence, in favor of a per-stream
 // notification cadence. Update the static config, and if active, tell device to dynamically change.
 void VirtualAudioDeviceImpl::SetNotificationFrequency(uint32_t notifications_per_ring) {
   // This is a DeviceImpl property (stream has a property with same name)
   override_notification_frequency_ = true;
   notifications_per_ring_ = notifications_per_ring;

   if (stream_ != nullptr) {
     stream_->EnqueueNotificationOverride(notifications_per_ring);
   }
 }

 // Deliver Start notification on binding's thread, if binding is valid.
 void VirtualAudioDeviceImpl::NotifyStart(zx_time_t start_time) {
   PostToDispatcher([this, start_time]() {
     if (is_input_) {
       ZX_ASSERT(input_binding_ && input_binding_->is_bound());
       input_binding_->events().OnStart(start_time);
     } else {
       ZX_ASSERT(output_binding_ && output_binding_->is_bound());
       output_binding_->events().OnStart(start_time);
     }
   });
 }

 // Deliver Stop notification on binding's thread, if binding is valid.
 void VirtualAudioDeviceImpl::NotifyStop(zx_time_t stop_time, uint32_t ring_buffer_position) {
   PostToDispatcher([this, stop_time, ring_buffer_position]() {
     if (is_input_) {
       ZX_ASSERT(input_binding_ && input_binding_->is_bound());
       input_binding_->events().OnStop(stop_time, ring_buffer_position);
     } else {
       ZX_ASSERT(output_binding_ && output_binding_->is_bound());
       output_binding_->events().OnStop(stop_time, ring_buffer_position);
     }
   });
 }

 void VirtualAudioDeviceImpl::GetPosition(
     fuchsia::virtualaudio::Device::GetPositionCallback position_callback) {
   if (stream_ == nullptr) {
     zxlogf(WARNING, "%s: %p has no stream for this request", __func__, this);
     return;
   }

   stream_->EnqueuePositionRequest(std::move(position_callback));
 }

 // Deliver Position notification on binding's thread, if binding is valid.
 void VirtualAudioDeviceImpl::NotifyPosition(zx_time_t monotonic_time,
                                             uint32_t ring_buffer_position) {
   PostToDispatcher([this, monotonic_time, ring_buffer_position]() {
     if (is_input_) {
       ZX_ASSERT(input_binding_ && input_binding_->is_bound());
       input_binding_->events().OnPositionNotify(monotonic_time, ring_buffer_position);
     } else {
       ZX_ASSERT(output_binding_ && output_binding_->is_bound());
       output_binding_->events().OnPositionNotify(monotonic_time, ring_buffer_position);
     }
   });
 }

 // Change the plug state on-the-fly for this active virtual audio device.
 void VirtualAudioDeviceImpl::ChangePlugState(zx_time_t plug_change_time, bool plugged) {
   // Update static config, and tell (if present) stream to dynamically change.
   plug_time_ = plug_change_time;
   plugged_ = plugged;

   if (!owner_->enabled()) {
     zxlogf(WARNING, "%s: Disabled, cannot change plug state; changing only the static config",
            __func__);
     return;
   }

   if (stream_ == nullptr) {
     zxlogf(WARNING, "%s: %p has no stream; cannot change dynamic plug state", __func__, this);
     return;
   }

   stream_->EnqueuePlugChange(plugged);
 }

 // Change the plug state on-the-fly for this active virtual audio device.
 void VirtualAudioDeviceImpl::AdjustClockRate(int32_t ppm_from_monotonic) {
   // Update static config, and tell (if present) stream to dynamically change.
   clock_rate_adjustment_ = ppm_from_monotonic;

   if (!owner_->enabled()) {
     zxlogf(WARNING, "%s: Disabled, cannot adjust clock rate; changing only the static config",
            __func__);
     return;
   }

   if (stream_ == nullptr) {
     zxlogf(WARNING, "%s: %p has no stream; cannot change clock rate", __func__, this);
     return;
   }

   stream_->EnqueueClockRateAdjustment(ppm_from_monotonic);
 }

 }  // namespace virtual_audio
	// Copyright 2019 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/drivers/virtual_audio/virtual_audio_device_impl.h"

	#include <lib/zx/clock.h>

	#include <memory>

	#include <ddk/debug.h>

	#include "src/media/audio/drivers/virtual_audio/virtual_audio_stream.h"

	namespace virtual_audio {

	class VirtualAudioStreamIn;
	class VirtualAudioStreamOut;

	// static methods
	std::unique_ptr<VirtualAudioDeviceImpl> VirtualAudioDeviceImpl::Create(
	VirtualAudioControlImpl* owner, bool is_input) {
	return std::unique_ptr<VirtualAudioDeviceImpl>(new VirtualAudioDeviceImpl(owner, is_input));
	}

	// Don't initialize here or in ctor; do it all in Init() so ResetConfiguration has same effect.
	VirtualAudioDeviceImpl::VirtualAudioDeviceImpl(VirtualAudioControlImpl* owner, bool is_input)
	: owner_(owner), is_input_(is_input) {
	ZX_DEBUG_ASSERT(owner_);

	Init();
	}

	// If we have not already destroyed our child stream, do so now.
	VirtualAudioDeviceImpl::~VirtualAudioDeviceImpl() { RemoveStream(); }

	// Initialize (or reset) a device's static configuration.
	void VirtualAudioDeviceImpl::Init() {
	device_name_ = kDefaultDeviceName;
	mfr_name_ = kDefaultManufacturerName;
	prod_name_ = kDefaultProductName;
	memcpy(unique_id_, kDefaultUniqueId, sizeof(unique_id_));

	clock_domain_ = kDefaultClockDomain;
	clock_rate_adjustment_ = kDefaultClockRateAdjustment;

	// By default, we support one basic format range (stereo 16-bit 48kHz)
	supported_formats_.clear();
	supported_formats_.push_back(kDefaultFormatRange);

	fifo_depth_ = kDefaultFifoDepthBytes;
	external_delay_nsec_ = kDefaultExternalDelayNsec;

	min_buffer_frames_ = kDefaultMinBufferFrames;
	max_buffer_frames_ = kDefaultMaxBufferFrames;
	modulo_buffer_frames_ = kDefaultModuloBufferFrames;

	cur_gain_state_ = kDefaultGainState;

	hardwired_ = kDefaultHardwired;
	async_plug_notify_ = kDefaultPlugCanNotify;
	plugged_ = kDefaultPlugged;

	// The time this Configuration was created / reset.
	plug_time_ = zx::clock::get_monotonic().get();

	override_notification_frequency_ = false;
	notifications_per_ring_ = 0;
	}

	// Receive and cache a virtualaudio::Input binding, forwarded from the virtual_audio_service.
	// ControlImpl has already associated us with the binding: when it closes we will auto-destruct.
	void VirtualAudioDeviceImpl::SetBinding(
	fidl::Binding<fuchsia::virtualaudio::Input,
	std::unique_ptr<virtual_audio::VirtualAudioDeviceImpl>>* binding) {
	ZX_ASSERT(is_input_);
	ZX_DEBUG_ASSERT(output_binding_ == nullptr);

	input_binding_ = binding;
	ZX_DEBUG_ASSERT(input_binding_->is_bound());
	}

	// Receive and cache a virtualaudio::Output binding, forwarded from the virtual_audio_service.
	// ControlImpl has already associated us with the binding: when it closes we will auto-destruct.
	void VirtualAudioDeviceImpl::SetBinding(
	fidl::Binding<fuchsia::virtualaudio::Output,
	std::unique_ptr<virtual_audio::VirtualAudioDeviceImpl>>* binding) {
	ZX_ASSERT(!is_input_);
	ZX_DEBUG_ASSERT(input_binding_ == nullptr);

	output_binding_ = binding;
	ZX_DEBUG_ASSERT(output_binding_->is_bound());
	}

	// In response to an Input::Add or Output::Add call, create the stream (activate the device).
	bool VirtualAudioDeviceImpl::CreateStream(zx_device_t* devnode) {
	stream_ = VirtualAudioStream::CreateStream(this, devnode, is_input_);
	return (stream_ != nullptr);
	}

	// Remove our child stream by calling its DdkUnbind. This may already have occurred; check for null.
	//
	// TODO(mpuryear): This may not safely unwind in all cases: it makes some threading assumptions that
	// cannot necessarily be enforced. But until fxbug.dev/33258 is addressed, the current VAD code
	// appears to be safe -- all RemoveStream callers are on the devhost primary thread:
	// ~VirtualAudioDeviceImpl from DevHost removing parent,
	// ~VirtualAudioDeviceImpl from Input\|Output FIDL channel disconnecting
	// fuchsia.virtualaudio.Control.Disable
	// fuchsia.virtualaudio.Input\|Output.Remove
	void VirtualAudioDeviceImpl::RemoveStream() {
	if (stream_ != nullptr) {
	// Clear any queued dispatcher tasks, and no longer accept new tasks.
	task_queue_->StopAndClear();

	// This bool tells the stream that Unbind originates from us (parent), so don't call us back.
	stream_->shutdown_by_parent_ = true;

	// Shutdown won't return until any in-flight calls to PostToDispatcher are quiesced.
	// Shutdown deactivates its execution domain, and all PostToDispatcher calls are
	// made from this execution domain). This guarantee is critical, because Add changes what
	// task_queue_ points to. If calls to PostToDispatcher WERE still outstanding, then it would be
	// possible that Add could be called before task_queue_->Enqueue runs, causing us to erroneously
	// run a task associated with the older stream, in the context of the new stream.
	stream_->Shutdown();
	// Request the device be unbound.
	stream_->DdkAsyncRemove();

	// Now that the stream has done its shutdown, we release our reference.
	stream_ = nullptr;
	}
	// bindings are reset in the VirtualAudioDeviceImpl dtor
	}

	// In most cases, stream DdkUnbind is called by us (the parent DeviceImpl), above in RemoveStream.
	// In the other cases, this RemoveStream is eventually called, but we should not RE-call DdkUnbind
	// at that point. To cover those other cases, this ClearStream method allows the child stream to
	// signal to its parent that it has gone away. Conversely, the flag shutdown_by_parent_ provides the
	// device->stream signal in the other cases (such as when RemoveStream is called during the device
	// dtor), to let the stream know that it need not and should not call us.
	void VirtualAudioDeviceImpl::ClearStream() {
	// Clear any queued dispatcher tasks, and no longer accept new tasks.
	task_queue_->StopAndClear();

	// Forget about this stream, but don't do more right now -- our RemoveStream will be called later.
	stream_ = nullptr;
	}

	// Use closure_queue to post a dispatcher task -- cancellable if stream or device is destroyed.
	void VirtualAudioDeviceImpl::PostToDispatcher(fit::closure task_to_post) {
	// We know task_queue_ isn't changing which ClosureQueue it's holding as this line is running,
	// because RemoveStream always runs on the same thread as Add (the main devhost thread, the FIDL
	// dispatch thread, the ClosureQueue's destination thread), and RemoveStream quiesces all calls to
	// PostToDispatcher before it returns (and thus before Add changes what task_queue_ points to).
	task_queue_->Enqueue(std::move(task_to_post));
	}

	//
	// virtualaudio::Configuration implementation
	//
	void VirtualAudioDeviceImpl::SetDeviceName(std::string device_name) {
	device_name_ = device_name;

	WarnActiveStreamNotAffected(__func__);
	}

	void VirtualAudioDeviceImpl::SetManufacturer(std::string manufacturer_name) {
	mfr_name_ = manufacturer_name;

	WarnActiveStreamNotAffected(__func__);
	}

	void VirtualAudioDeviceImpl::SetProduct(std::string product_name) {
	prod_name_ = product_name;

	WarnActiveStreamNotAffected(__func__);
	}

	void VirtualAudioDeviceImpl::SetUniqueId(std::array<uint8_t, 16> unique_id) {
	memcpy(unique_id_, unique_id.data(), sizeof(unique_id_));

	WarnActiveStreamNotAffected(__func__);
	}

	// After creation or reset, one default format range is always available.
	void VirtualAudioDeviceImpl::AddFormatRange(uint32_t format_flags, uint32_t min_rate,
	uint32_t max_rate, uint8_t min_chans, uint8_t max_chans,
	uint16_t rate_family_flags) {
	audio_stream_format_range_t range = {.sample_formats = format_flags,
	.min_frames_per_second = min_rate,
	.max_frames_per_second = max_rate,
	.min_channels = min_chans,
	.max_channels = max_chans,
	.flags = rate_family_flags};

	supported_formats_.push_back(range);

	WarnActiveStreamNotAffected(__func__);
	}

	void VirtualAudioDeviceImpl::ClearFormatRanges() {
	supported_formats_.clear();
	WarnActiveStreamNotAffected(__func__);
	}

	void VirtualAudioDeviceImpl::WarnActiveStreamNotAffected(const char* func_name) {
	if (stream_ != nullptr) {
	zxlogf(WARNING, "%s updates the static config, but has no effect on existing streams",
	func_name);
	}
	}

	void VirtualAudioDeviceImpl::SetClockProperties(int32_t clock_domain,
	int32_t initial_rate_adjustment_ppm) {
	clock_domain_ = clock_domain;
	clock_rate_adjustment_ = initial_rate_adjustment_ppm;

	WarnActiveStreamNotAffected(__func__);
	}

	void VirtualAudioDeviceImpl::SetFifoDepth(uint32_t fifo_depth_bytes) {
	fifo_depth_ = fifo_depth_bytes;

	WarnActiveStreamNotAffected(__func__);
	}

	void VirtualAudioDeviceImpl::SetExternalDelay(zx_duration_t external_delay) {
	external_delay_nsec_ = external_delay;

	WarnActiveStreamNotAffected(__func__);
	}

	void VirtualAudioDeviceImpl::SetRingBufferRestrictions(uint32_t min_frames, uint32_t max_frames,
	uint32_t modulo_frames) {
	ZX_DEBUG_ASSERT(min_frames <= max_frames);
	ZX_DEBUG_ASSERT(min_frames % modulo_frames == 0);
	ZX_DEBUG_ASSERT(max_frames % modulo_frames == 0);

	min_buffer_frames_ = min_frames;
	max_buffer_frames_ = max_frames;
	modulo_buffer_frames_ = modulo_frames;

	WarnActiveStreamNotAffected(__func__);
	}

	void VirtualAudioDeviceImpl::SetGainProperties(float min_gain_db, float max_gain_db,
	float gain_step_db, float current_gain_db,
	bool can_mute, bool current_mute, bool can_agc,
	bool current_agc) {
	cur_gain_state_ = {.cur_mute = current_mute,
	.cur_agc = current_agc,
	.cur_gain = current_gain_db,

	.can_mute = can_mute,
	.can_agc = can_agc,

	.min_gain = min_gain_db,
	.max_gain = max_gain_db,
	.gain_step = gain_step_db};

	WarnActiveStreamNotAffected(__func__);
	}

	void VirtualAudioDeviceImpl::SetPlugProperties(zx_time_t plug_change_time, bool plugged,
	bool hardwired, bool can_notify) {
	plug_time_ = plug_change_time;

	plugged_ = plugged;
	hardwired_ = hardwired;
	async_plug_notify_ = can_notify;

	WarnActiveStreamNotAffected(__func__);
	}

	void VirtualAudioDeviceImpl::ResetConfiguration() {
	Init();

	WarnActiveStreamNotAffected(__func__);
	}

	//
	// virtualaudio::Device implementation
	//
	// Create a virtual audio device using the currently-specified configuration.
	void VirtualAudioDeviceImpl::Add() {
	if (!owner_->enabled()) {
	zxlogf(WARNING, "%s: Disabled, cannot add stream", __func__);
	return;
	}

	if (stream_ != nullptr) {
	zxlogf(WARNING, "%s: %p already has stream %p", __func__, this, stream_.get());
	return;
	}

	// This ClosureQueue is created when stream is created), deactivated (via StopAndClear) when
	// stream is removed, and synchronized by being on devhost dispatcher thread (our FIDL thread).
	// DeviceImpl and Stream both call PostToDispatcher, and all are quiesced before we get here.
	// DeviceImpl makes those calls on the FIDL thread (task_queue_'s destination thread); all are
	// enqueued and subsequently discarded (via StopAndClear) upon RemoveStream. Stream makes those
	// calls in its execution domain, which is synchronously deactivated during its DdkUnbind.
	task_queue_.emplace(owner_->dispatcher(), thrd_current());
	if (!CreateStream(owner_->dev_node())) {
	zxlogf(ERROR, "CreateStream failed");
	task_queue_->StopAndClear();
	return;
	}
	}

	// Remove the associated virtual audio device.
	void VirtualAudioDeviceImpl::Remove() {
	if (!owner_->enabled()) {
	zxlogf(WARNING, "%s: Disabled, no streams for removal", __func__);
	ZX_DEBUG_ASSERT(stream_ == nullptr);
	return;
	}

	if (stream_ == nullptr) {
	zxlogf(WARNING, "%s: %p has no stream to remove", __func__, this);
	return;
	}

	// If stream_ exists, null our copy and call SimpleAudioStream::DdkUnbind (which eventually calls
	// ShutdownHook and re-nulls). We need this because stream terminations come either from "device"
	// (direct DdkUnbind call), or from "parent" (Control::Disable, Device::Remove, ~DeviceImpl).
	RemoveStream();
	}

	void VirtualAudioDeviceImpl::GetFormat(
	fuchsia::virtualaudio::Device::GetFormatCallback format_callback) {
	if (stream_ == nullptr) {
	zxlogf(WARNING, "%s: %p has no stream for this request", __func__, this);
	return;
	}

	stream_->EnqueueFormatRequest(std::move(format_callback));
	}

	// Deliver SetFormat notification on binding's thread, if binding is valid.
	void VirtualAudioDeviceImpl::NotifySetFormat(uint32_t frames_per_second, uint32_t sample_format,
	uint32_t num_channels, zx_duration_t external_delay) {
	PostToDispatcher([this, frames_per_second, sample_format, num_channels, external_delay]() {
	if (input_binding_ && input_binding_->is_bound()) {
	input_binding_->events().OnSetFormat(frames_per_second, sample_format, num_channels,
	external_delay);
	} else if (output_binding_ && output_binding_->is_bound()) {
	output_binding_->events().OnSetFormat(frames_per_second, sample_format, num_channels,
	external_delay);
	}
	});
	}

	void VirtualAudioDeviceImpl::GetGain(fuchsia::virtualaudio::Device::GetGainCallback gain_callback) {
	if (stream_ == nullptr) {
	zxlogf(WARNING, "%s: %p has no stream for this request", __func__, this);
	return;
	}

	stream_->EnqueueGainRequest(std::move(gain_callback));
	}

	// Deliver SetGain notification on binding's thread, if binding is valid.
	void VirtualAudioDeviceImpl::NotifySetGain(bool current_mute, bool current_agc,
	float current_gain_db) {
	PostToDispatcher([this, current_mute, current_agc, current_gain_db]() {
	if (input_binding_ && input_binding_->is_bound()) {
	input_binding_->events().OnSetGain(current_mute, current_agc, current_gain_db);
	} else if (output_binding_ && output_binding_->is_bound()) {
	output_binding_->events().OnSetGain(current_mute, current_agc, current_gain_db);
	}
	});
	}

	void VirtualAudioDeviceImpl::GetBuffer(
	fuchsia::virtualaudio::Device::GetBufferCallback buffer_callback) {
	if (stream_ == nullptr) {
	zxlogf(WARNING, "%s: %p has no stream for this request", __func__, this);
	return;
	}

	stream_->EnqueueBufferRequest(std::move(buffer_callback));
	}

	// Deliver SetBuffer notification on binding's thread, if binding is valid.
	void VirtualAudioDeviceImpl::NotifyBufferCreated(zx::vmo ring_buffer_vmo,
	uint32_t num_ring_buffer_frames,
	uint32_t notifications_per_ring) {
	PostToDispatcher([this, ring_buffer_vmo = std::move(ring_buffer_vmo), num_ring_buffer_frames,
	notifications_per_ring]() mutable {
	if (input_binding_ && input_binding_->is_bound()) {
	input_binding_->events().OnBufferCreated(std::move(ring_buffer_vmo), num_ring_buffer_frames,
	notifications_per_ring);
	} else if (output_binding_ && output_binding_->is_bound()) {
	output_binding_->events().OnBufferCreated(std::move(ring_buffer_vmo), num_ring_buffer_frames,
	notifications_per_ring);
	}
	});
	}

	// Override AudioCore's systemwide position notification cadence, in favor of a per-stream
	// notification cadence. Update the static config, and if active, tell device to dynamically change.
	void VirtualAudioDeviceImpl::SetNotificationFrequency(uint32_t notifications_per_ring) {
	// This is a DeviceImpl property (stream has a property with same name)
	override_notification_frequency_ = true;
	notifications_per_ring_ = notifications_per_ring;

	if (stream_ != nullptr) {
	stream_->EnqueueNotificationOverride(notifications_per_ring);
	}
	}

	// Deliver Start notification on binding's thread, if binding is valid.
	void VirtualAudioDeviceImpl::NotifyStart(zx_time_t start_time) {
	PostToDispatcher([this, start_time]() {
	if (is_input_) {
	ZX_ASSERT(input_binding_ && input_binding_->is_bound());
	input_binding_->events().OnStart(start_time);
	} else {
	ZX_ASSERT(output_binding_ && output_binding_->is_bound());
	output_binding_->events().OnStart(start_time);
	}
	});
	}

	// Deliver Stop notification on binding's thread, if binding is valid.
	void VirtualAudioDeviceImpl::NotifyStop(zx_time_t stop_time, uint32_t ring_buffer_position) {
	PostToDispatcher([this, stop_time, ring_buffer_position]() {
	if (is_input_) {
	ZX_ASSERT(input_binding_ && input_binding_->is_bound());
	input_binding_->events().OnStop(stop_time, ring_buffer_position);
	} else {
	ZX_ASSERT(output_binding_ && output_binding_->is_bound());
	output_binding_->events().OnStop(stop_time, ring_buffer_position);
	}
	});
	}

	void VirtualAudioDeviceImpl::GetPosition(
	fuchsia::virtualaudio::Device::GetPositionCallback position_callback) {
	if (stream_ == nullptr) {
	zxlogf(WARNING, "%s: %p has no stream for this request", __func__, this);
	return;
	}

	stream_->EnqueuePositionRequest(std::move(position_callback));
	}

	// Deliver Position notification on binding's thread, if binding is valid.
	void VirtualAudioDeviceImpl::NotifyPosition(zx_time_t monotonic_time,
	uint32_t ring_buffer_position) {
	PostToDispatcher([this, monotonic_time, ring_buffer_position]() {
	if (is_input_) {
	ZX_ASSERT(input_binding_ && input_binding_->is_bound());
	input_binding_->events().OnPositionNotify(monotonic_time, ring_buffer_position);
	} else {
	ZX_ASSERT(output_binding_ && output_binding_->is_bound());
	output_binding_->events().OnPositionNotify(monotonic_time, ring_buffer_position);
	}
	});
	}

	// Change the plug state on-the-fly for this active virtual audio device.
	void VirtualAudioDeviceImpl::ChangePlugState(zx_time_t plug_change_time, bool plugged) {
	// Update static config, and tell (if present) stream to dynamically change.
	plug_time_ = plug_change_time;
	plugged_ = plugged;

	if (!owner_->enabled()) {
	zxlogf(WARNING, "%s: Disabled, cannot change plug state; changing only the static config",
	__func__);
	return;
	}

	if (stream_ == nullptr) {
	zxlogf(WARNING, "%s: %p has no stream; cannot change dynamic plug state", __func__, this);
	return;
	}

	stream_->EnqueuePlugChange(plugged);
	}

	// Change the plug state on-the-fly for this active virtual audio device.
	void VirtualAudioDeviceImpl::AdjustClockRate(int32_t ppm_from_monotonic) {
	// Update static config, and tell (if present) stream to dynamically change.
	clock_rate_adjustment_ = ppm_from_monotonic;

	if (!owner_->enabled()) {
	zxlogf(WARNING, "%s: Disabled, cannot adjust clock rate; changing only the static config",
	__func__);
	return;
	}

	if (stream_ == nullptr) {
	zxlogf(WARNING, "%s: %p has no stream; cannot change clock rate", __func__, this);
	return;
	}

	stream_->EnqueueClockRateAdjustment(ppm_from_monotonic);
	}

	} // namespace virtual_audio