dx::service::client::_device< desc_t, preference_t, stream_t > Class Template Reference

service client streaming device interface class More...

#include <dx_service_client_device.h>

Inheritance diagram for dx::service::client::_device< desc_t, preference_t, stream_t >:

Collaboration diagram for dx::service::client::_device< desc_t, preference_t, stream_t >:

Public Types
typedef desc_t	desc_t
typedef shared::event	event_t

Public Member Functions
void	attach (channel_t **io[dx::stream::direction::directions][2], const std::vector< bool >(&channel_map)[2])
void	conclude () noexcept override
	dx_catchall_handler (this,) void conclude() noexcept override
	dx_catchall_rethrow () bool start(uint64_t frame
	dx_catchall_rethrow () virtual uint64_t frame() const
void	hw_clock (abstract::event *event, uint32_t iosize) override try
virtual bool	hw_clock () const noexcept
void	info (std::ostream &os) noexcept override try
void	launch () override
virtual bool	start (uint64_t=0, unsigned int starting=1)
virtual unsigned int	stop (bool force=false) noexcept
std::string	string (uint32_t idx) try
void	wake () override
	~_device () override

Public Attributes
dx::promoted< typename super::client_map >	clients
shared::guard< std::map< abstract::event *, std::pair< uint32_t, size_t > > >	clock
	event -> {iosize, sample counter}
promoted< uint32_t >::preference< decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)>	clocksource
dx::promoted< desc_t >	desc
chain< desc_t, request >	desc_server {pipe, desc, request::id::desc}
struct {
shared::guard< std::map< abstract::event *, std::pair< uint32_t, size_t > > >   clock
	event -> {iosize, sample counter} More...
uint32_t   iosize
	staging value for registration paths without their own iosize argument (macOS CF property bridge) More...
}	hw
promoted< std::string >::preference< decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)>	icon
promoted< uint32_t >::preference< decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)>	iosize
uint32_t	iosize
	staging value for registration paths without their own iosize argument (macOS CF property bridge)
dx::stream::device::monitor	monitor
std::deque< std::function< void(control &)> >	notify
dx::shared::reference	reference
	this process' crash-safe hold on the puuid's client-local preference store
promoted< uint32_t >::preference< decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)>	safety_offset [direction::directions]
promoted< uint32_t >::preference< decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)>	samplerate
std::atomic< unsigned int >	started {}
std::map< decltype(desc_t::stream::target.idx()), std::weak_ptr< stream_t > >	streams
promoted< uint32_t >::preference< decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)>	sync_cycle_ticks
promoted< structdesc_t::stream * >::template preference< decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference), uint32_t >	sync_reference
dx::stream::device::monitor	version

Protected Types
typedef service::request< service::stream::data< desc_t > >	request

Protected Member Functions
virtual void	flush ()
virtual void	halt ()

Protected Attributes
chain< uint32_t, request >	clocksource_server {pipe, super::clocksource, request::id::clocksource}
chain< uint32_t, request >	iosize_server {pipe, super::iosize, request::id::iosize}
pipe< request >	pipe {std::string{this->driver.product_id}+ "/"+ this->id}
chain< uint32_t, request >	safety_offset_server [2]
chain< uint32_t, request >	samplerate_server {pipe, super::samplerate, request::id::samplerate}
std::recursive_mutex	start_stop_in_progress
	start/stop operation in progress

Detailed Description

template<typename desc_t, typename preference_t, typename stream_t>
class dx::service::client::_device< desc_t, preference_t, stream_t >

service client streaming device interface class

Exceptions

In	case of an error returned by the underlaying API the device class throws a dx::exception.

Member Typedef Documentation

desc_t

typedef desc_t dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::desc_t

inherited

event_t

template<typename desc_t, typename preference_t, typename stream_t>

typedef shared::event dx::service::client::_device< desc_t, preference_t, stream_t >::event_t

request

template<typename desc_t, typename preference_t, typename stream_t>

typedef service::request<service::stream::data<desc_t> > dx::service::client::_device< desc_t, preference_t, stream_t >::request

protected

Constructor & Destructor Documentation

~_device()

template<typename desc_t, typename preference_t, typename stream_t>

dx::service::client::_device< desc_t, preference_t, stream_t >::~_device ( )

inlineoverride

Member Function Documentation

attach()

void dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::attach ( channel_t ** io[dx::stream::direction::directions][2], const std::vector< bool >(&) channel_map[2] )

inlineinherited

conclude()

template<typename desc_t, typename preference_t, typename stream_t>

void dx::service::client::_device< desc_t, preference_t, stream_t >::conclude ( )

inlineoverridenoexcept

Here is the caller graph for this function:

dx_catchall_handler()

template<typename object_t>

dx::stream::control< object_t >::dx_catchall_handler ( this )

inlineoverridenoexceptinherited

dx_catchall_rethrow() [1/2]

template<typename desc_t, typename preference_t, typename stream_t>

dx::service::client::_device< desc_t, preference_t, stream_t >::dx_catchall_rethrow

(

)

dx_catchall_rethrow() [2/2]

template<typename desc_t, typename preference_t, typename stream_t>

dx::service::client::_device< desc_t, preference_t, stream_t >::dx_catchall_rethrow ( ) const

inline

flush()

template<typename object_t>

virtual void dx::stream::control< object_t >::flush ( )

inlineprotectedvirtualinherited

Reimplemented in dx::stream::stream< device_t, dx::circular, usb::pipe< device_t > >.

halt()

template<typename object_t>

virtual void dx::stream::control< object_t >::halt ( )

inlineprotectedvirtualinherited

Reimplemented in dx::coreaudio::_device< desc_t, preference_t, stream_t >, dx::coreaudio::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > >, dx::coreaudio::_device< dx::virtuel::stream::desc, cf::preference, dx::stream::stream< device< dx::virtuel::stream::desc, cf::preference, dx::stream::stream > > >, dx::coreaudio::_device< dx::virtuel::stream::desc, cf::preference, stream< device< dx::virtuel::stream::desc, cf::preference, stream > > >, dx::coreaudio::pod::device< desc_t, preference_t, stream_t >, dx::proxy::stream::_device< desc_t, preference_t, stream_t >, dx::proxy::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > >, dx::proxy::stream::_device< dx::stream::desc<>, dx::preference, stream< device< dx::stream::desc<>, dx::preference, stream > > >, dx::stream::pin< device_t, _circular_t >, dx::stream::stream< device_t, dx::circular, usb::pipe< device_t > >, dx::usb::platform::pipe< device_t, interface_t >, dx::usb::platform::pipe< device_t, interface_t >, dx::usb::platform::pipe< device<>, interface >, dx::usb::platform::pipe< device_t, interface >, dx::usb::platform::pipe< device_t, usb::interface >, dx::usb::platform::pipe< device_t, usb::interface >, dx::usb::stream::_device< desc_t, preference_t, stream_t >, dx::usb::stream::_device< desc_t, dx::preference, pipe< device< desc_t, dx::preference, pipe > > >, dx::usb::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > >, and dx::usb::stream::pipe< device_t, circular_t, stream_t >.

Here is the caller graph for this function:

hw_clock() [1/2]

template<typename desc_t, typename preference_t, typename stream_t>

void dx::service::client::_device< desc_t, preference_t, stream_t >::hw_clock ( abstract::event * event, uint32_t iosize )

inlineoverridevirtual

Reimplemented from dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >.

hw_clock() [2/2]

virtual bool dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::hw_clock ( ) const

inlinevirtualnoexceptinherited

Reimplemented in dx::virtuel::stream::_device< desc_t, preference_t, stream_t >, and dx::virtuel::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > >.

Here is the caller graph for this function:

info()

void dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::info ( std::ostream & os )

inlineoverridenoexceptinherited

Here is the caller graph for this function:

launch()

template<typename desc_t, typename preference_t, typename stream_t>

void dx::service::client::_device< desc_t, preference_t, stream_t >::launch ( )

inlineoverride

start()

template<typename object_t>

virtual bool dx::stream::control< object_t >::start ( uint64_t = 0, unsigned int starting = 1 )

inlinevirtualinherited

result indicates if start changed the state.

Reimplemented in dx::asio::client::_device< desc_t, preference_t, stream_t >, dx::asio::client::_device< desc, preference, stream< device< desc, preference, stream > > >, dx::asio::client::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > >, dx::coreaudio::_device< desc_t, preference_t, stream_t >, dx::coreaudio::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t > > >, dx::coreaudio::_device< dx::virtuel::stream::desc, cf::preference, dx::stream::stream< device< dx::virtuel::stream::desc, cf::preference, dx::stream::stream > > >, dx::coreaudio::_device< dx::virtuel::stream::desc, cf::preference, stream< device< dx::virtuel::stream::desc, cf::preference, stream > > >, dx::coreaudio::pod::device< desc_t, preference_t, stream_t >, dx::stream::pin< device_t, _circular_t >, dx::stream::stream< device_t, dx::circular, usb::pipe< device_t > >, and dx::usb::stream::pipe< device_t, circular_t, stream_t >.

Here is the caller graph for this function:

stop()

template<typename object_t>

virtual unsigned int dx::stream::control< object_t >::stop ( bool force = false )

inlinevirtualnoexceptinherited

result indicates the amount of stopped start references

string()

template<typename desc_t, typename preference_t, typename stream_t>

std::string dx::service::client::_device< desc_t, preference_t, stream_t >::string ( uint32_t idx )

inline

wake()

void dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::wake ( )

inlineoverrideinherited

Member Data Documentation

clients

template<typename desc_t, typename preference_t, typename stream_t>

dx::promoted<typename super::client_map> dx::service::client::_device< desc_t, preference_t, stream_t >::clients

Initial value:

{
        [this](dx::promoted<typename super::client_map>::lock_t&& lock, const typename super::client_map& value, const typename super::client_map&){
            dx::promoted<uint32_t>::lock_t tmp(std::move(lock));
            if(clients.transient)
                clients.commit(std::move(tmp), value);
            else if(!clients.initialized)
                clients.initialized= true; 
        }}

clock

shared::guard<std::map<abstract::event*, std::pair<uint32_t, size_t> > > dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::clock

inherited

event -> {iosize, sample counter}

clocksource

promoted<uint32_t>::preference<decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)> dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::clocksource

inherited

clocksource_server

template<typename desc_t, typename preference_t, typename stream_t>

chain<uint32_t, request> dx::service::client::_device< desc_t, preference_t, stream_t >::clocksource_server {pipe, super::clocksource, request::id::clocksource}

protected

desc

template<typename desc_t, typename preference_t, typename stream_t>

dx::promoted<desc_t> dx::service::client::_device< desc_t, preference_t, stream_t >::desc

desc_server

template<typename desc_t, typename preference_t, typename stream_t>

chain<desc_t, request> dx::service::client::_device< desc_t, preference_t, stream_t >::desc_server {pipe, desc, request::id::desc}

[struct]

struct { ... } dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::hw

Todo

migrate hw clock generation/distribution into a dedicated clock class

icon

promoted<std::string>::preference<decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)> dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::icon

inherited

iosize [1/2]

promoted<uint32_t>::preference<decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)> dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::iosize

inherited

iosize [2/2]

uint32_t dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::iosize

inherited

staging value for registration paths without their own iosize argument (macOS CF property bridge)

iosize_server

template<typename desc_t, typename preference_t, typename stream_t>

chain<uint32_t, request> dx::service::client::_device< desc_t, preference_t, stream_t >::iosize_server {pipe, super::iosize, request::id::iosize}

protected

monitor

dx::stream::device::monitor dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::monitor

inherited

notify

template<typename object_t>

std::deque<std::function<void(control&)> > dx::stream::control< object_t >::notify

inherited

pipe

template<typename desc_t, typename preference_t, typename stream_t>

pipe<request> dx::service::client::_device< desc_t, preference_t, stream_t >::pipe {std::string{this->driver.product_id}+ "/"+ this->id}

protected

reference

template<typename desc_t, typename preference_t, typename stream_t>

dx::shared::reference dx::service::client::_device< desc_t, preference_t, stream_t >::reference

Initial value:

{
        std::string{this->driver.product_id}+ "/"+ driver<super>::property::bus+ "/"+ dx::process().name()+ "/"+ this->puuid}

this process' crash-safe hold on the puuid's client-local preference store

dx::device::preference (driver.preference[puuid]) is this client process' own settings cache for the device - distinct from the service's own copy (a different registry hive: the service runs as LocalSystem, clients as the interactive user). Live values (samplerate, iosize, ...) already reach this object independently via the chain<> pipe broadcast below; what preference persists here is only what should survive this process disconnecting and reconnecting later.

The preference path is namespaced per connecting application (see the driver constructor in dx_service_client_driver.h, via process::name()), not just per device: two different applications must not share one settings key, but several instances of the same application legitimately should - and can therefore hold that identical key open at the same time. conclude() must not simply erase it on every single instance's own disconnect (schedule_erase only ever fires for non-persistent devices to begin with) - that would delete settings a sibling instance still actively uses, racing its concurrent registry access.

reference is this instance's hold on that shared identity: holding it signals "I am interested" to every other process under the same name, with no protocol beyond its own construction/release() - the OS releases the underlying named mutex (Windows) / advisory lock (macOS) on process exit even on a crash, so this can never desync the way a value manually incremented/decremented in memory would (dx_shared_reference.h). release() reports whether this was the last holder; only then may conclude() erase.

safety_offset

promoted<uint32_t>::preference<decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)> dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::safety_offset[direction::directions]

inherited

safety_offset_server

template<typename desc_t, typename preference_t, typename stream_t>

chain<uint32_t, request> dx::service::client::_device< desc_t, preference_t, stream_t >::safety_offset_server[2]

protected

Initial value:

{
            {pipe, super::safety_offset[dx::stream::direction::out], request::id::safety_offset_out},
            {pipe, super::safety_offset[dx::stream::direction::in], request::id::safety_offset_in}}

samplerate

promoted<uint32_t>::preference<decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)> dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::samplerate

inherited

samplerate_server

template<typename desc_t, typename preference_t, typename stream_t>

chain<uint32_t, request> dx::service::client::_device< desc_t, preference_t, stream_t >::samplerate_server {pipe, super::samplerate, request::id::samplerate}

protected

start_stop_in_progress

template<typename object_t>

std::recursive_mutex dx::stream::control< object_t >::start_stop_in_progress

protectedinherited

start/stop operation in progress

started

template<typename object_t>

std::atomic<unsigned int> dx::stream::control< object_t >::started {}

inherited

streams

std::map<decltype(desc_t::stream::target.idx()), std::weak_ptr<stream_t> > dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::streams

inherited

sync_cycle_ticks

promoted<uint32_t>::preference<decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference)> dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::sync_cycle_ticks

inherited

sync_reference

promoted<structdesc_t::stream*>::template preference<decltype(dx::stream::control< dx::device< std::string, preference_t > >::preference), uint32_t> dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::sync_reference

inherited

version

dx::stream::device::monitor dx::stream::device< dx::stream::control< dx::device< std::string, preference_t > >, desc_t, stream_t >::version

inherited

---

The documentation for this class was generated from the following file:

• dx_service_client_device.h