dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t > Class Template Reference

a streaming device: its desc, the settings the desc defaults, the streams of that desc grouped by dx::stream::group and the clock those groups run on. Every bus device derives from this one and supplies what its transport does differently - the settings' servers (a rate written to the hardware), the group's tick, the streams' rings. The settings themselves are promoted preferences here, so a wish survives the device and is asked of the transport once the device is there. More...

#include <dx_stream_device.h>

Inheritance diagram for dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >:

Collaboration diagram for dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >:

Classes
struct	[struct].hw
class	monitor
	the device's performance counters in shared memory, so a second process (the test app's clock monitor) reads what the streaming session measures; every fetch initializes an unused buffer More...
class	pause
	RAII: pauses every one of this device's groups (remembered count, force-stopped) across a streams structure mutation, restarts all on destruction. More...
struct	property
	the preference keys of this device's settings, named once - the store's layout is these words, and a host's own property names never reach the store More...

Public Types
typedef _desc_t	desc_t
typedef event	event_t
typedef std::conditional_t< std::is_void_v< _group_t >, dx::stream::group< device >, _group_t >	group_t
	bus devices driving their groups' tick pass their own group type
typedef promoted< uint32_t >::template preference< decltype(super_device_t::preference)>	source_t
typedef _stream_t	stream_t

Public Member Functions
template<typename channel_t>
void	attach (channel_t **io[dx::stream::direction::directions][2], const std::vector< bool >(&channel_map)[2])
void	conclude () noexcept override
	ends every group's session before the device's resources go; the start counts stay with their holders
	device (decltype(super::driver)&driver, const decltype(super::id)&id, const desc_t &desc, const std::pair< std::string, std::string > &identity={})
	device (decltype(super::driver)&driver, const decltype(super::id)&id, decltype(super::preference)&&preferencepreference, const desc_t &desc, const std::pair< std::string, std::string > &identity={})
	device (decltype(super::driver)&driver, const decltype(super::id)&id, desc_t &&desc, const std::pair< std::string, std::string > &identity={})
	a desc temporary moves into the desc base, and wins over control's forwarding constructor, which binds an rvalue just as well
virtual bool	hw_clock () const noexcept
virtual void	hw_clock (abstract::event *hw_clock, uint32_t iosize)
	registers a consumer with the device's clock: it is signalled every iosize samples of the clock's own advance. A bus whose driver owns the clock hands the registration on instead
void	info (std::ostream &os) noexcept override
std::shared_ptr< stream_t >	open (const typename _desc_t::stream::desc &desc)
	the desc's stream: the registered one, else created, registered and launched
group_t &	operator[] (const typename _desc_t::stream::desc &stream)
	the stream's group, created on first use
virtual std::pair< source_t &, bool >	source (const struct _desc_t::stream &stream)
	the stream's source selector, created on first use: the preference by stream target, the value an index into the stream's sources
void	wake () override

Public Attributes
promoted< uint32_t >::preference< decltype(super::preference)>	clocksource
std::map< decltype(_desc_t::stream::group), group_t >	group
	streaming groups by desc::stream::group id: every stream of this device is registered with its group - behind the settings its groups listen to, so they go first
struct	hw
promoted< std::string >::preference< decltype(super::preference)>	icon {this->preference}
promoted< uint32_t >::preference< decltype(super::preference)>	iosize
dx::stream::device::monitor	monitor
promoted< uint32_t >::preference< decltype(super::preference)>	samplerate
std::map< decltype(_desc_t::stream::target.idx()), source_t >	sources
promoted< structdesc_t::stream * >::template preference< decltype(super::preference), uint32_t >	sync_reference
dx::stream::device::monitor	version

Static Public Attributes
static constexpr bool	hosted {}
	the transport's settings belong to another process' device: a hosted device mirrors them through its chains, it keeps no store of them

Protected Member Functions
virtual void	grouped (group_t &)
	operator[](): a group just came into existence, a host wires its per-group transports here

Detailed Description

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>
class dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >

a streaming device: its desc, the settings the desc defaults, the streams of that desc grouped by dx::stream::group and the clock those groups run on. Every bus device derives from this one and supplies what its transport does differently - the settings' servers (a rate written to the hardware), the group's tick, the streams' rings. The settings themselves are promoted preferences here, so a wish survives the device and is asked of the transport once the device is there.

Member Typedef Documentation

desc_t

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

typedef _desc_t dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::desc_t

event_t

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

typedef event dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::event_t

group_t

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

typedef std::conditional_t<std::is_void_v<_group_t>, dx::stream::group<device>, _group_t> dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::group_t

bus devices driving their groups' tick pass their own group type

source_t

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

typedef promoted<uint32_t>::template preference<decltype(super_device_t::preference)> dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::source_t

stream_t

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

typedef _stream_t dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::stream_t

Constructor & Destructor Documentation

device() [1/3]

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::device ( decltype(super::driver)& driver, const decltype(super::id)& id, const desc_t & desc, const std::pair< std::string, std::string > & identity = {} )

inline

Here is the caller graph for this function:

device() [2/3]

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::device ( decltype(super::driver)& driver, const decltype(super::id)& id, desc_t && desc, const std::pair< std::string, std::string > & identity = {} )

inline

a desc temporary moves into the desc base, and wins over control's forwarding constructor, which binds an rvalue just as well

device() [3/3]

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::device ( decltype(super::driver)& driver, const decltype(super::id)& id, decltype(super::preference)&& preference, const desc_t & desc, const std::pair< std::string, std::string > & identity = {} )

inline

Member Function Documentation

attach()

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

template<typename channel_t>

void dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::attach ( channel_t ** io[dx::stream::direction::directions][2], const std::vector< bool >(&) channel_map[2] )

inline

Here is the caller graph for this function:

conclude()

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

void dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::conclude ( )

inlineoverridenoexcept

ends every group's session before the device's resources go; the start counts stay with their holders

Reimplemented in dx::virtuel::stream::_device< desc_t, preference_t, stream_t, group_t >, dx::virtuel::stream::_device< desc, dx::preference, dx::stream::shared::stream< device< desc, dx::preference, dx::stream::shared::stream, group > >, group< device< desc, dx::preference, dx::stream::shared::stream, group > > >, and dx::virtuel::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t, group_t > >, group_t< device< desc_t, preference_t, stream_t, group_t > > >.

grouped()

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

virtual void dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::grouped ( group_t & )

inlineprotectedvirtual

operator[](): a group just came into existence, a host wires its per-group transports here

hw_clock() [1/2]

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

virtual bool dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::hw_clock ( ) const

inlinevirtualnoexcept

hw_clock() [2/2]

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

virtual void dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::hw_clock ( abstract::event * hw_clock, uint32_t iosize )

inlinevirtual

registers a consumer with the device's clock: it is signalled every iosize samples of the clock's own advance. A bus whose driver owns the clock hands the registration on instead

Reimplemented in dx::coreaudio::pod::device< desc_t, preference_t, stream_t, group_t >, dx::proxy::stream::_device< desc_t, preference_t, stream_t, group_t >, dx::proxy::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t, group_t > >, group_t< device< desc_t, preference_t, stream_t, group_t > > >, dx::proxy::stream::_device< dx::stream::desc<>, dx::preference, stream< device< dx::stream::desc<>, dx::preference, stream, group > >, group< device< dx::stream::desc<>, dx::preference, stream, group > > >, dx::service::client::_device< desc_t, preference_t, stream_t, group_t >, dx::service::client::_device< desc, preference, stream< device< desc, preference, stream, group > >, group< device< desc, preference, stream, group > > >, and dx::service::client::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t, group_t > >, group_t< device< desc_t, preference_t, stream_t, group_t > > >.

Here is the caller graph for this function:

info()

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

void dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::info ( std::ostream & os )

inlineoverridenoexcept

Reimplemented in dx::usb::stream::_device< desc_t, preference_t, stream_t, group_t >, dx::usb::stream::_device< desc_t, dx::preference, pipe< device< desc_t, dx::preference, pipe, group > >, group< device< desc_t, dx::preference, pipe, group > > >, dx::usb::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t, group_t > >, group_t< device< desc_t, preference_t, stream_t, group_t > > >, dx::virtuel::stream::_device< desc_t, preference_t, stream_t, group_t >, dx::virtuel::stream::_device< desc, dx::preference, dx::stream::shared::stream< device< desc, dx::preference, dx::stream::shared::stream, group > >, group< device< desc, dx::preference, dx::stream::shared::stream, group > > >, dx::virtuel::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t, group_t > >, group_t< device< desc_t, preference_t, stream_t, group_t > > >, and dx::wasapi::client::_device< desc, preference, stream< device< desc, preference, stream, group > >, group< device< desc, preference, stream, group > > >.

open()

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

std::shared_ptr< stream_t > dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::open ( const typename _desc_t::stream::desc & desc )

inline

the desc's stream: the registered one, else created, registered and launched

operator[]()

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

group_t & dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::operator[] ( const typename _desc_t::stream::desc & stream )

inline

the stream's group, created on first use

source()

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

virtual std::pair< source_t &, bool > dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::source ( const struct _desc_t::stream & stream )

inlinevirtual

the stream's source selector, created on first use: the preference by stream target, the value an index into the stream's sources

Reimplemented in dx::usb::stream::_device< desc_t, preference_t, stream_t, group_t >, dx::usb::stream::_device< desc_t, dx::preference, pipe< device< desc_t, dx::preference, pipe, group > >, group< device< desc_t, dx::preference, pipe, group > > >, and dx::usb::stream::_device< desc_t, preference_t, stream_t< device< desc_t, preference_t, stream_t, group_t > >, group_t< device< desc_t, preference_t, stream_t, group_t > > >.

wake()

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

void dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::wake ( )

inlineoverride

Member Data Documentation

clocksource

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

promoted<uint32_t>::preference<decltype(super::preference)> dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::clocksource

Initial value:

{this->preference[property::clocksource],
        [this]() {return this->clock[0].defaults.clocksource;},
        [this](uint32_t value, uint32_t) {return std::min(value, this->clock[0].settings);}}

group

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

std::map<decltype(_desc_t::stream::group), group_t> dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::group

streaming groups by desc::stream::group id: every stream of this device is registered with its group - behind the settings its groups listen to, so they go first

hosted

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

bool dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::hosted {}

staticconstexpr

the transport's settings belong to another process' device: a hosted device mirrors them through its chains, it keeps no store of them

hw

struct dx::stream::device::[struct].hw dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::hw

icon

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

promoted<std::string>::preference<decltype(super::preference)> dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::icon {this->preference}

iosize

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

promoted<uint32_t>::preference<decltype(super::preference)> dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::iosize

Initial value:

{this->preference[property::iosize],
        {[this](uint32_t value) {hw.iosize= value;}},
        [this](){
            const struct desc_t::stream* sync_reference{this->sync_reference};
            return this->clock[0].defaults.iosize.hw_ticks* this->clock[0].interval(samplerate,
                sync_reference? sync_reference->config[0].transaction.granularity: 0);},
        [this](uint32_t value, uint32_t){
            const struct desc_t::stream* sync_reference{this->sync_reference};
            return this->clock[0].defaults.iosize.align(value, this->clock[0].interval(samplerate,
                sync_reference? sync_reference->config[0].transaction.granularity: 0));}}

monitor

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

dx::stream::device::monitor dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::monitor

samplerate

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

promoted<uint32_t>::preference<decltype(super::preference)> dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::samplerate

Initial value:

{this->preference[property::samplerate],
        [this]() {return this->clock[0].defaults.samplerate;},
        [this](uint32_t value, uint32_t current) {return
            (samplerate.transient && !(this->clock[0].settings && this->clock[0].setting[clocksource].external.locked))?
                this->clock[0].align(value):
            samplerate.initialized?
                current:
                this->clock[0].align(this->samplerate.value(this->samplerate.backing_store(this->samplerate.preference_value(this->samplerate.dflt()))));}}

sources

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

std::map<decltype(_desc_t::stream::target.idx()), source_t> dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::sources

source selectors by stream target: a stream with sources gets its own on first use

sync_reference

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

promoted<structdesc_t::stream*>::template preference<decltype(super::preference), uint32_t> dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::sync_reference

Initial value:

{this->preference[property::sync::reference],
        [this]() {return this->desc_t::sync_reference(this->clock[0].defaults.sync.reference);},
        [this](struct desc_t::stream* value, struct desc_t::stream*) {return desc_t::align(value);},
        [this](struct desc_t::stream* value)->uint32_t {return desc_t::sync_reference(value);},
        [this](uint32_t preference_value) {return desc_t::sync_reference(preference_value);}}

version

template<typename super_device_t, typename _desc_t, typename _stream_t, typename _group_t = void>

dx::stream::device::monitor dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::version

---

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

• dx_stream_device.h