dx::test::virtuel::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t > Class Template Reference

#include <dx_test_virtual.h>

Inheritance diagram for dx::test::virtuel::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >:

Collaboration diagram for dx::test::virtuel::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >:

Public Types
typedef std::deque< std::string >	args
typedef device_t::desc_t	desc
typedef decltype(matching_ids)	match
typedef decltype(matching_ids)	match

Public Member Functions
void	add (const device_id_t &device_id) override try
template<typename desc_t >
dx_catchall_rethrow() using super void	add (const std::string &, const desc_t &)
void	add (const std::string &, const typename device_t::desc_t &)
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END bool	boot () try
void	conclude () noexcept override
	conclude notification: object will be removed. If you overwrite conclude() you also need to overwrite destructor and check if its needed to be called from there.
virtual void	detach () noexcept
	driver (const typename super::match &match, const char *product_id, const typename super::desc &desc, const decltype(parser::dictionary)&dictionary={})
	dx_catchall_rethrow () virtual operator bool() const noexcept
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	exception (const class exception &exception, bool filtered=false) const noexcept override try
	notification exception handler
virtual void	exception (const exception &exception, bool filtered=false) const noexcept=0
	notification exception handler
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	free () noexcept
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	halt () noexcept override
	stop streaming engine
virtual void	help (args &args) try
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	help_head ()
virtual void	help_listparameter (const decltype(dictionary)&dictionary) const try
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	help_subparameter (const decltype(dictionary)&dictionary) const try
void	info (std::ostream &os) noexcept override try
	log object class information
template<unsigned int max_channels>
void	initialize (uint32_t iosize, const uint64_t(&channel_map)[2][(max_channels+63)/64]) try
void	launch () override try
	launch notification: object mounted and ready to use
virtual void	launch () try
	launch notification: object mounted and ready to use
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	operator<< (args &args) try
virtual void	operator<< (const args &args)
virtual void	parse_subparameter (const decltype(dictionary)&dictionary, args &args) const
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	quiet (const args &={}) noexcept
dx_catchall_rethrow() using super void	remove (const std::string &, bool=false)
void	run () override try
	start streaming engine
DX_PRAGMA_IGNORE_RETURN_VALUE_END uint32_t	samplerate () const try
void	samplerate (uint32_t samplerate) try
const auto	select (const std::string &id) const try
virtual bool	shutdown () try
	client driver::shutdown/boot(): override to shutdown/boot host driver
virtual void	version (const args &={}) noexcept

Public Attributes
class redirect::indent::streambuf dx::test::driver::clog	cerr
cf::string	connection_id = ::IOObjectCopyBundleIdentifierForClass(cf::string{this->product_id}.retain())
class redirect::indent::streambuf dx::test::driver::clog	cout
std::map< std::deque< std::string >, dispatch >	dictionary
T	elements
	STL member.
K	keys
	STL member.
bool	launched {}
log	log
decltype(device_t::preference)	preference
const char *	product_id
io::registry	registry
std::deque< setup >	setup
uint32_t	version

Static Public Attributes
static constexpr auto	connection_id = class_name

Protected Types
typedef decltype(device_t::id)	device_id_t

Protected Member Functions
dx_catchall_handler(this,) using super void	arrived () override try
	notify device arrivals completed stub
void	arrived (device_t &device) override
	notify specific device arrival stub
template<typename data_t >
void	buffer (size_t size=0x1000, uint32_t rx=1, uint32_t tx=1, const std::chrono::high_resolution_clock::duration &duration=3s) const
void	buffer_header () const
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	clear () noexcept try
	replaces std::map::clear to call virtual notification methods
void	clock_monitor (device_t &device, std::chrono::high_resolution_clock::duration duration) try
void	device_arrival_removal (const args &={}) try
	dx_catchall_handler (this,) virtual driver &operator<<(std
	restores device settings
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	enumerate_os_audio (const args &args={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	filter (const args &cargs={}) try
bool	head () const noexcept override
void	help_scope () override
void	list (const args &={})
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	loglevel (args &args) try
void	meta_buffer (size_t size, uint32_t rx, uint32_t tx, const std::chrono::high_resolution_clock::duration &duration) const
void	notify () noexcept override
virtual void	notify (uint32_t) noexcept
	notify sample rate change from device
virtual driver &	operator<< (const char *file)
virtual driver &	operator>> (const char *file) const
virtual driver &	operator>> (std::ostream &ostream) const
	saves device tree
virtual void	overload () noexcept
void	parse (args &args) override
void	process (int64_t) noexcept override
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	remove (const device_id_t &device_id) override try
	finds and removes a device from the device list
void	removed (device_t &device) noexcept override
	notify specific device removal stub
void	sleep () override
	< notify system will sleep
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	streaming_generator (args &args) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	streaming_monitor (const args &args) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	streaming_reset (const args &={}) try
void	sync (const std::chrono::high_resolution_clock::time_point &now) override try
void	unittest (const args &args) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	unittest_align (const args &={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	unittest_buffer (const args &args={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	unittest_format (const args &={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	unittest_mask (args &args) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	unittest_preference (const args &={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	unittest_preference_erase (const decltype(device_t::preference)&preferences, uint32_t &leaves) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	unittest_preference_write (const decltype(device_t::preference)&preference, const std::chrono::high_resolution_clock::time_point &timeout, uint32_t &leaves) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	unittest_stream_duration (args &args) try
void	update () noexcept try
void	wake () override

Static Protected Member Functions
static void	abort (int) noexcept
static DX_PRAGMA_IGNORE_RETURN_VALUE_END void	sig (int) noexcept

Protected Attributes
struct {
circular_t *   circular [direction::directions]
force_read   force_read
force_write   force_write
struct {
struct {
uint32_t   interval
	clock resolution: HW stream frame size in samples More...
uint32_t   linesize
uint32_t   safety_offset
}   io [direction::directions]
direction::direction   reference
uint32_t   samplerate
int64_t   trigger
	resync condition More...
}   sync
}	cache
std::shared_ptr< device_t >	device
uint32_t	dropout = 0
uint64_t	frame = 0
std::deque< typename parameter::generator >	generator
bool	hw_clock = false
io_t **	io [direction::directions][2] {}
uint32_t	iosize = 0
bool	kernel_streaming = false
std::deque< typename parameter::mask >	loopback
std::vector<::GUID >	matching_ids
dx::stream::clock::monitor *	monitor = nullptr
	io[directions][double buffer][channel][sample]
struct dx::proxy::driver::notification	notification
std::deque< typename parameter::mask >	pattern
DX_PRAGMA_IGNORE_RETURN_VALUE_END std::shared_ptr< pin_t >	pin [direction::directions]
uint64_t	tick = 0
struct {
uint64_t   mask = ULLONG_MAX
std::chrono::high_resolution_clock::duration   stream_duration = 0s
}	unit_test

Member Typedef Documentation

args

typedef std::deque<std::string> dx::test::parser::args

inherited

desc

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

typedef device_t::desc_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::desc

inherited

device_id_t

template<typename device_t >

typedef decltype(device_t::id) dx::map::driver< device_t >::device_id_t

protectedinherited

match [1/2]

template<typename device_t = device<>>

typedef decltype(matching_ids) dx::proxy::driver< device_t >::match

inherited

match [2/2]

template<typename device_t = device<>>

typedef decltype(matching_ids) dx::proxy::driver< device_t >::match

inherited

Todo

proxy::driver::connection_id: reflect driver presence

Constructor & Destructor Documentation

driver()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = dx::test::device<super_device_t>, typename driver_t = dx::virtuel::driver<device_t>, typename engine_t = dx::stream::engine<device_t, audio_pin_t, driver_t, io_t>>

dx::test::virtuel::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::driver ( const typename super::match & match, const char * product_id, const typename super::desc & desc, const decltype(parser::dictionary)& dictionary = {} )

inline

Member Function Documentation

abort()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

static void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::abort ( int )

inlinestaticprotectednoexceptinherited

Here is the caller graph for this function:

add() [1/3]

template<typename device_t = device<>>

void dx::map::driver< device_t >::add ( const device_id_t & device_id )

inlineoverridevirtualinherited

Todo

proxy::driver::operator bool() check if driver is installed

Reimplemented from dx::map::driver< device_t >.

add() [2/3]

template<typename device_t = device<>>

template<typename desc_t >

dx_catchall_rethrow() using super void dx::proxy::driver< device_t >::add ( const std::string & , const desc_t &  )

inlineinherited

Here is the caller graph for this function:

add() [3/3]

template<typename device_t = device<>>

void dx::proxy::driver< device_t >::add ( const std::string & , const typename device_t::desc_t &  )

inlineinherited

arrived() [1/2]

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx_catchall_handler(this,) using super void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::arrived ( )

inlineoverrideprotectedvirtualinherited

notify device arrivals completed stub

pin creation exception caught here to allow device inspection even if streaming is not possible - most likely due to exclusive access.

Todo

forward pin creation exception to be thrown at engine::start()

Reimplemented from dx::map::driver< device_t >.

Here is the call graph for this function:

arrived() [2/2]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::arrived ( device_t & )

inlineoverrideprotectedvirtualinherited

notify specific device arrival stub

Reimplemented from dx::map::driver< device_t >.

Here is the call graph for this function:

boot()

virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END bool dx::driver< decltype(device_t::id) , decltype(device_t::preference) >::boot ( )

inlinevirtualinherited

buffer()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

template<typename data_t >

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::buffer ( size_t size = 0x1000, uint32_t rx = 1, uint32_t tx = 1, const std::chrono::high_resolution_clock::duration & duration = 3s ) const

inlineprotectedinherited

Here is the call graph for this function:

buffer_header()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::buffer_header ( ) const

inlineprotectedinherited

clear()

template<typename device_t >

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::map::driver< device_t >::clear ( )

inlineprotectednoexceptinherited

replaces std::map::clear to call virtual notification methods

Here is the call graph for this function:

Here is the caller graph for this function:

clock_monitor()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::clock_monitor ( device_t & device, std::chrono::high_resolution_clock::duration duration )

inlineprotectedinherited

Here is the call graph for this function:

Here is the caller graph for this function:

conclude()

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::conclude ( )

inlineoverridevirtualnoexceptinherited

conclude notification: object will be removed. If you overwrite conclude() you also need to overwrite destructor and check if its needed to be called from there.

Reimplemented from dx::map::driver< device_t >.

Here is the call graph for this function:

Here is the caller graph for this function:

detach()

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

virtual void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::detach ( )

inlinevirtualnoexceptinherited

device_arrival_removal()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::device_arrival_removal ( const args & = {} )

inlineprotectedinherited

dx_catchall_handler()

template<typename device_t >

dx::map::driver< device_t >::dx_catchall_handler ( this ) &

inlineprotectedinherited

restores device settings

dx_catchall_rethrow()

template<typename device_t = device<>>

dx::proxy::driver< device_t >::dx_catchall_rethrow ( ) const

inlinenoexceptinherited

Here is the caller graph for this function:

enumerate_os_audio()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::enumerate_os_audio ( const args & args = {} )

inlineprotectedinherited

exception() [1/2]

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::driver< decltype(device_t::id) , decltype(device_t::preference) >::exception ( const class exception & exception, bool filtered = false ) const

inlineoverridenoexceptinherited

notification exception handler

exception() [2/2]

virtual void dx::object::exception ( const exception & exception, bool filtered = false ) const

pure virtualnoexceptinherited

notification exception handler

Implemented in dx::device< dx::guid, dx::preference >, dx::device< dx::guid, preference_t >, dx::device< std::string, dx::preference >, dx::device< std::string, preference_t >, dx::device<::AudioObjectID, cf::preference >, dx::device<::AudioObjectID, preference_t >, dx::device<::io_service_t, dx::preference >, dx::device<::io_service_t, preference_t >, dx::device<::MIDIDeviceRef, cf::preference >, dx::device<::MIDIDeviceRef, preference_t >, dx::device< id_t, preference_t >, dx::stream::pin< device_t, _circular_t >, dx::virtuel::stream::_device< desc_t, preference_t, stream_t >, dx::usb::platform::device< preference_t >, dx::asio::client::_device< desc_t, preference_t, stream_t >, dx::proxy::device< dx::preference >, dx::proxy::device<>, and dx::proxy::device< preference_t >.

Here is the caller graph for this function:

filter()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::filter ( const args & cargs = {} )

inlineprotectedinherited

free()

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::free ( )

inlinevirtualnoexceptinherited

Todo

replace test for valid pin by overwise keeping track of allocated channels

halt()

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::halt ( )

inlineoverridenoexceptinherited

stop streaming engine

Here is the call graph for this function:

head()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

bool dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::head ( ) const

inlineoverrideprotectedvirtualnoexceptinherited

Reimplemented from dx::test::parser.

Here is the call graph for this function:

Here is the caller graph for this function:

help()

virtual void dx::test::parser::help ( args & args )

inlinevirtualinherited

help_head()

virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::parser::help_head ( )

inlinevirtualinherited

help_listparameter()

virtual void dx::test::parser::help_listparameter ( const decltype(dictionary)& dictionary ) const

inlinevirtualinherited

help_scope()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::help_scope ( )

inlineoverrideprotectedvirtualinherited

Reimplemented from dx::test::parser.

help_subparameter()

virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::parser::help_subparameter ( const decltype(dictionary)& dictionary ) const

inlinevirtualinherited

info()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::info ( std::ostream & os )

inlineoverridevirtualnoexceptinherited

log object class information

Reimplemented from dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >.

Reimplemented in dx::test::usb::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >.

Here is the call graph for this function:

initialize()

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

template<unsigned int max_channels>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::initialize ( uint32_t iosize, const uint64_t(&) channel_map[2][(max_channels+63)/64] )

inlineinherited

Todo

clock already runnning with different iosize: check if engine should be initialized with current iosize

Todo

stream::engine::initialize(): define sync reference pin

Here is the call graph for this function:

launch() [1/2]

template<typename device_t = device<>>

void dx::proxy::driver< device_t >::launch ( )

inlineoverridevirtualinherited

launch notification: object mounted and ready to use

Reimplemented from dx::map::driver< device_t >.

Here is the caller graph for this function:

launch() [2/2]

template<typename device_t = device<>>

virtual void dx::proxy::driver< device_t >::launch ( )

inlinevirtualinherited

launch notification: object mounted and ready to use

Reimplemented from dx::map::driver< device_t >.

Reimplemented in dx::coremidi::server::plugin< stream_pin_t, device_t, driver_t >.

Here is the call graph for this function:

list()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::list ( const args & = {} )

inlineprotectedinherited

Todo

: remove obscure cast preventing desc::version and driver::version ambiguity due to single device streaming engine design

loglevel()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::loglevel ( args & args )

inlineprotectedinherited

Here is the call graph for this function:

meta_buffer()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::meta_buffer ( size_t size, uint32_t rx, uint32_t tx, const std::chrono::high_resolution_clock::duration & duration ) const

inlineprotectedinherited

Here is the call graph for this function:

notify() [1/2]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::notify ( )

inlineoverrideprotectednoexceptinherited

notify() [2/2]

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

virtual void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::notify ( uint32_t )

inlineprotectedvirtualnoexceptinherited

notify sample rate change from device

Reimplemented in dx::asio::driver< device_t, pin_t, driver_t >.

operator<<() [1/3]

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::parser::operator<< ( args & args )

inlinevirtualinherited

Reimplemented in dx::test::select< drivers_t >.

operator<<() [2/3]

virtual void dx::test::parser::operator<< ( const args & args )

inlinevirtualinherited

Here is the caller graph for this function:

operator<<() [3/3]

template<typename device_t >

virtual driver & dx::map::driver< device_t >::operator<< ( const char * file )

inlineprotectedvirtualinherited

Here is the call graph for this function:

Here is the caller graph for this function:

operator>>() [1/2]

template<typename device_t >

virtual driver & dx::map::driver< device_t >::operator>> ( const char * file ) const

inlineprotectedvirtualinherited

Here is the call graph for this function:

operator>>() [2/2]

template<typename device_t >

virtual driver & dx::map::driver< device_t >::operator>> ( std::ostream & ostream ) const

inlineprotectedvirtualinherited

saves device tree

Reimplemented in dx::coreaudio::driver< device_t >.

Here is the caller graph for this function:

overload()

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

virtual void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::overload ( )

inlineprotectedvirtualnoexceptinherited

Reimplemented in dx::asio::driver< device_t, pin_t, driver_t >.

parse()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::parse ( args & args )

inlineoverrideprotectedvirtualinherited

Reimplemented from dx::test::parser.

Here is the call graph for this function:

parse_subparameter()

virtual void dx::test::parser::parse_subparameter ( const decltype(dictionary)& dictionary, args & args ) const

inlinevirtualinherited

process()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::process ( int64_t )

inlineoverrideprotectedvirtualnoexceptinherited

Implements dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >.

quiet()

virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::parser::quiet ( const args & = {} )

inlinevirtualnoexceptinherited

remove() [1/2]

template<typename device_t >

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::map::driver< device_t >::remove ( const device_id_t & device_id )

inlineoverrideprotectedvirtualinherited

finds and removes a device from the device list

Exceptions

dx::exception

Implements dx::driver< decltype(device_t::id), decltype(device_t::preference)>.

Here is the call graph for this function:

Here is the caller graph for this function:

remove() [2/2]

template<typename device_t = device<>>

dx_catchall_rethrow() using super void dx::proxy::driver< device_t >::remove ( const std::string & , bool = false )

inlineinherited

removed()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::removed ( device_t & )

inlineoverrideprotectedvirtualnoexceptinherited

notify specific device removal stub

Reimplemented from dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >.

Here is the call graph for this function:

run()

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::run ( )

inlineoverrideinherited

start streaming engine

Here is the call graph for this function:

Here is the caller graph for this function:

samplerate() [1/2]

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END uint32_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::samplerate ( ) const

inlineinherited

samplerate() [2/2]

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::samplerate ( uint32_t samplerate )

inlineinherited

Here is the call graph for this function:

select()

const auto dx::test::parser::select ( const std::string & id ) const

inlineinherited

Here is the caller graph for this function:

shutdown()

virtual bool dx::driver< decltype(device_t::id) , decltype(device_t::preference) >::shutdown ( )

inlinevirtualinherited

client driver::shutdown/boot(): override to shutdown/boot host driver

Reimplemented in dx::coreaudio::driver< device_t >.

sig()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

static DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::sig ( int )

inlinestaticprotectednoexceptinherited

Here is the call graph for this function:

Here is the caller graph for this function:

sleep()

template<typename device_t >

void dx::map::driver< device_t >::sleep ( )

inlineoverrideprotectedinherited

< notify system will sleep

notify system wake completed stub

Here is the call graph for this function:

streaming_generator()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::streaming_generator ( args & args )

inlineprotectedinherited

Here is the call graph for this function:

streaming_monitor()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::streaming_monitor ( const args & args )

inlineprotectedinherited

Here is the call graph for this function:

streaming_reset()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::streaming_reset ( const args & = {} )

inlineprotectedinherited

sync()

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::sync ( const std::chrono::high_resolution_clock::time_point & now )

inlineoverrideprotectedinherited

Here is the call graph for this function:

unittest()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::unittest ( const args & args )

inlineprotectedinherited

Here is the call graph for this function:

unittest_align()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::unittest_align ( const args & = {} )

inlineprotectedinherited

unittest_buffer()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::unittest_buffer ( const args & args = {} )

inlineprotectedinherited

unittest_format()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::unittest_format ( const args & = {} )

inlineprotectedinherited

unittest_mask()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::unittest_mask ( args & args )

inlineprotectedinherited

Here is the call graph for this function:

unittest_preference()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::unittest_preference ( const args & = {} )

inlineprotectedinherited

unittest_preference_erase()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::unittest_preference_erase ( const decltype(device_t::preference)& preferences, uint32_t & leaves )

inlineprotectedinherited

Here is the call graph for this function:

Here is the caller graph for this function:

unittest_preference_write()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::unittest_preference_write ( const decltype(device_t::preference)& preference, const std::chrono::high_resolution_clock::time_point & timeout, uint32_t & leaves )

inlineprotectedinherited

Here is the call graph for this function:

Here is the caller graph for this function:

unittest_stream_duration()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::unittest_stream_duration ( args & args )

inlineprotectedinherited

Here is the call graph for this function:

update()

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

void dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::update ( )

inlineprotectednoexceptinherited

Here is the caller graph for this function:

version()

virtual void dx::test::parser::version ( const args & = {} )

inlinevirtualnoexceptinherited

wake()

template<typename device_t >

void dx::map::driver< device_t >::wake ( )

inlineoverrideprotectedinherited

Here is the call graph for this function:

Member Data Documentation

[struct]

struct { ... } dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::cache

cerr

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

class redirect::indent::streambuf dx::test::driver::clog dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::cerr

inherited

circular

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

circular_t* dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::circular[direction::directions]

inherited

connection_id [1/2]

template<typename device_t = device<>>

cf::string dx::proxy::driver< device_t >::connection_id = ::IOObjectCopyBundleIdentifierForClass(cf::string{this->product_id}.retain())

inherited

connection_id [2/2]

template<typename device_t = device<>>

constexpr auto dx::proxy::driver< device_t >::connection_id = class_name

staticconstexprinherited

cout

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

class redirect::indent::streambuf dx::test::driver::clog dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::cout

inherited

device

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

std::shared_ptr<device_t> dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::device

protectedinherited

dictionary

std::map<std::deque<std::string>, dispatch> dx::test::parser::dictionary

inherited

Initial value:

{
        {{"--help", "-h", "-?"},{std::bind(&parser::help, this, std::placeholders::_1), "help or detailed help on specific arguments", [this](){for(const auto& verb: dictionary) std::cout<< "["<< verb.first.front()<< "] ";}, true}},
        {{"--quiet", "-q"},     {std::bind(&parser::quiet, this, std::placeholders::_1), "quiet!"}},
 
 
 
        {{"--version", "-v"},   {std::bind(&parser::version, this, std::placeholders::_1), "display the cmd line test application version"}},
    }

dropout

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

uint32_t dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::dropout = 0

protectedinherited

elements

T std::map< K, T >::elements

inherited

STL member.

filename

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = dx::test::device<super_device_t>, typename driver_t = dx::virtuel::driver<device_t>, typename engine_t = dx::stream::engine<device_t, audio_pin_t, driver_t, io_t>>

std::string dx::test::virtuel::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::filename

force_read

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

force_read dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::force_read

inherited

force_write

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

force_write dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::force_write

inherited

frame

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

uint64_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::frame = 0

protectedinherited

generator

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

std::deque<typename parameter::generator> dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::generator

protectedinherited

hw_clock

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

bool dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::hw_clock = false

protectedinherited

interval

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

uint32_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::interval

inherited

clock resolution: HW stream frame size in samples

[struct] [1/2]

struct { ... } dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::io[direction::directions]

io [2/2]

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

io_t** dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::io[direction::directions][2] {}

protectedinherited

iosize

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

uint32_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::iosize = 0

protectedinherited

kernel_streaming

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

bool dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::kernel_streaming = false

protectedinherited

keys

K std::map< K, T >::keys

inherited

STL member.

launched

bool dx::object::launched {}

inherited

linesize

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

uint32_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::linesize

inherited

log

log dx::driver< decltype(device_t::id) , decltype(device_t::preference) >::log

inherited

loopback

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

std::deque<typename parameter::mask> dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::loopback

protectedinherited

mask

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

uint64_t dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::mask = ULLONG_MAX

inherited

matching_ids

template<typename device_t = device<>>

std::vector<::GUID> dx::proxy::driver< device_t >::matching_ids

protectedinherited

monitor

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

dx::stream::clock::monitor* dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::monitor = nullptr

protectedinherited

io[directions][double buffer][channel][sample]

notification

template<typename device_t = device<>>

struct dx::proxy::driver::notification dx::proxy::driver< device_t >::notification

protectedinherited

pattern

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

std::deque<typename parameter::mask> dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::pattern

protectedinherited

pin

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END std::shared_ptr<pin_t> dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::pin[direction::directions]

protectedinherited

preference

decltype(device_t::preference) dx::driver< decltype(device_t::id) , decltype(device_t::preference) >::preference

inherited

product_id

const char* dx::driver< decltype(device_t::id) , decltype(device_t::preference) >::product_id

inherited

quiet

bool dx::test::parser::quiet = false

inherited

reference

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

direction::direction dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::reference

inherited

registry

template<typename device_t = device<>>

io::registry dx::proxy::driver< device_t >::registry

inherited

safety_offset

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

uint32_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::safety_offset {}

inherited

samplerate

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

uint32_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::samplerate

inherited

setup

template<typename device_t = device<>>

std::deque<setup> dx::proxy::driver< device_t >::setup

inherited

stream_duration

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

std::chrono::high_resolution_clock::duration dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::stream_duration = 0s

inherited

[struct]

struct { ... } dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::sync

tick

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<super_device_t>, typename driver_t = dx::proxy::driver<device_t>, typename engine_t = stream::engine<device_t, audio_pin_t, driver_t, io_t>>

uint64_t dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::tick = 0

protectedinherited

trigger

template<typename device_t , typename pin_t , typename driver_t = proxy::driver<device_t>, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>

int64_t dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::trigger

inherited

resync condition

[struct]

DX_PRAGMA_IGNORE_RETURN_VALUE_END struct { ... } dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::unit_test

version

uint32_t dx::driver< decltype(device_t::id) , decltype(device_t::preference) >::version

inherited

---

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

• dx_test_virtual.h