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

#include <dx_test.h>

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

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

Classes
class	clog
struct	match_helper
struct	match_helper< std::vector< std::string > >

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

Public Member Functions
dx_catchall_rethrow() using super void	add (const std::string &id, const typename device_t::desc &desc)
virtual void	detach () noexcept
	driver (const typename super::match &match, const char *id, std::map< std::deque< std::string >, dispatch > dictionary={})
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 void	free () noexcept
void	halt () noexcept override
	stop streaming engine
virtual void	help (args &args)
void	info (std::ostream &os) noexcept override
	log object class information
template<unsigned int max_channels>
void	initialize (uint32_t iosize, 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
void	operator<< (args &args) try
void	operator<< (const args &args)
virtual void	quiet (const args &={}) noexcept
void	remove (const device_id_t &device_id) override try
	finds and removes a device from the device list
void	remove (const std::string &id)
void	run () override try
	start streaming engine
uint32_t	samplerate () const try
void	samplerate (uint32_t samplerate) try
virtual void	version (const args &={}) noexcept

Public Attributes
class redirect::indent::streambuf dx::test::driver::clog	cerr
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
const char *	product_id
io::registry	registry
std::deque< setup >	setup
uint32_t	version

Protected Member Functions
void	add (const device_id_t &device_id) override try
	adds a new device to the device list
dx_catchall_handler(this,) using super void	arrived () override try
	notify device arrivals completed stub
virtual void	arrived (device_t &)
	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
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const dx::exception &__dx_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
void	clear () noexcept try
	replaces std::map::clear to call virtual notification methods
void	clock (const args &args={}) try
void	clock_monitor (device_t &device, std::chrono::high_resolution_clock::duration duration) noexcept
void	conclude () noexcept override try
	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.
void	device_arrival_removal (const args &={}) try
void	device_reset (const args &={}) try
void	enumerate_os_audio (const args &args={}) try
void	filter (const args &cargs={}) try
void	generator (const args &args={}) try
bool	head () const noexcept override
void	info (const args &={})
void	iosize (const args &args) try
	set/get I/O streaming block size
void	loglevel (const args &args) try
void	loopback (const 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 void	overload () noexcept
void	process (int64_t) noexcept override
virtual void	removed () noexcept
	notify device removals completed stub
void	removed (device_t &device) noexcept override
	notify specific device removal stub
void	safety_offset (const args &args) try
	set/get streaming safety offset
void	streaming_monitor (const args &args) try
void	streaming_reset (const args &={}) try
void	sync (const std::chrono::high_resolution_clock::time_point &now) override try
void	sync_reference (const args &args) try
	set/get I/O streaming block size
void	unittest (const args &args) try
void	unittest_buffer (const args &args={}) try
void	unittest_duration (const args &args={}) try
void	unittest_format (const args &={}) try
void	unittest_mask (const args &args={}) try
void	update () noexcept try

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

Protected Attributes
struct {
circular_t *   circular [direction::directions]
force_read   force_read
force_write   force_write
struct {
volatile uint32_t *   samplerate
}   observer
struct {
bool   engine_driven
	pins do not provide any means of driving streaming More...
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
bool	hw_clock = false
io_t **	io [direction::directions][2] {}
uint32_t	iosize = 0
bool	kernel_streaming = false
std::vector<::GUID >	matching_ids
dx::stream::clock::monitor *	monitor = nullptr
	io[directions][double buffer][channel][sample]
struct dx::proxy::driver::notification	notification
struct {
struct {
double   denominator
uint32_t   periode = 0
}   generator
struct {
bool   audio = false
bool   midi = false
}   loopback
}	parameter
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 dx::stream::engine< device_t, pin_t, driver_t, io_t, circular_t >::desc

inherited

match [1/2]

template<class device_t = device>

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

inherited

match [2/2]

template<class device_t = device>

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

inherited

Constructor & Destructor Documentation

driver()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::driver ( const typename super::match & match, const char * id, std::map< std::deque< std::string >, dispatch > dictionary = {} )

inline

Member Function Documentation

abort()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 )

inlinestaticprotectednoexcept

Here is the caller graph for this function:

add() [1/2]

template<typename device_t >

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

inlineoverrideprotectedvirtualinherited

adds a new device to the device list

Exceptions

dx::exception

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

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

Here is the call graph for this function:

add() [2/2]

template<class device_t = device>

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

inlineinherited

Here is the caller graph for this function:

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 device_t >

virtual void dx::map::driver< device_t >::arrived ( device_t & )

inlineprotectedvirtualinherited

notify specific device arrival stub

Reimplemented in dx::coreaudio::server::plugin< pin_t, device_t, driver_t >.

buffer()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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

inlineprotected

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<typename audio_pin_t::circular_t, 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

inlineprotected

catch() [1/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [2/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [3/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [4/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [5/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [6/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [7/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [8/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [9/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [10/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [11/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [12/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [13/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [14/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [15/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [16/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [17/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [18/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [19/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [20/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [21/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [22/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [23/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [24/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [25/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [26/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [27/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [28/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [29/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [30/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [31/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [32/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [33/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [34/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [35/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [36/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [37/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [38/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [39/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [40/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [41/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [42/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [43/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [44/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [45/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [46/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [47/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [48/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [49/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [50/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [51/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [52/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [53/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [54/54]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

clear()

template<typename device_t >

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()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 ( const args & args = {} )

inlineprotected

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<typename audio_pin_t::circular_t, 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 )

inlineprotectednoexcept

Here is the call graph for this function:

Here is the caller graph for this function:

conclude()

template<typename device_t >

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

inlineoverrideprotectedvirtualnoexceptinherited

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::object.

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

Here is the call graph for this function:

Here is the caller graph for this function:

device_arrival_removal()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 & = {} )

inlineprotected

device_reset()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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_reset ( const args & = {} )

inlineprotected

enumerate_os_audio()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::enumerate_os_audio ( const args & args = {} )

inlineprotected

exception() [1/2]

void dx::driver< decltype(device_t::id) >::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< std::string >, dx::device<::AudioObjectID >, dx::device<::io_service_t >, dx::device< id_t >, dx::proxy::device, dx::usb::platform::device, and dx::proxy::device.

filter()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::filter ( const args & cargs = {} )

inlineprotected

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 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

Here is the caller graph for this function:

generator()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::generator ( const args & args = {} )

inlineprotected

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>

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:

Here is the caller graph for this function:

head()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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

inlineoverrideprotectedvirtualnoexcept

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

info() [1/2]

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 ( const args & = {} )

inlineprotected

info() [2/2]

template<class device_t = device>

void dx::proxy::driver< device_t >::info ( std::ostream & os )

inlineoverridevirtualnoexceptinherited

log object class information

Reimplemented from dx::object.

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, 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:

iosize()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::iosize ( const args & args )

inlineprotected

set/get I/O streaming block size

Here is the call graph for this function:

launch() [1/2]

template<class device_t = device>

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

inlineoverridevirtualinherited

launch notification: object mounted and ready to use

Reimplemented from dx::object.

Here is the call graph for this function:

Here is the caller graph for this function:

launch() [2/2]

template<class device_t = device>

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

inlinevirtualinherited

launch notification: object mounted and ready to use

Reimplemented from dx::object.

Here is the call graph for this function:

loglevel()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::loglevel ( const args & args )

inlineprotected

Here is the call graph for this function:

loopback()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::loopback ( const args & args = {} )

inlineprotected

meta_buffer()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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

inlineprotected

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<typename audio_pin_t::circular_t, 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 ( )

inlineoverrideprotectednoexcept

Here is the caller graph for this function:

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< device_t, pin_t, driver_t >.

Here is the caller graph for this function:

operator<<() [1/2]

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

inlineinherited

operator<<() [2/2]

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

inlineinherited

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< device_t, pin_t, driver_t >.

Here is the caller graph for this function:

process()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 )

inlineoverrideprotectedvirtualnoexcept

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

Here is the call graph for this function:

quiet()

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

inlinevirtualnoexceptinherited

remove() [1/2]

template<class device_t = device>

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

inlineoverridevirtualinherited

finds and removes a device from the device list

Exceptions

dx::exception

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

remove() [2/2]

template<class device_t = device>

void dx::proxy::driver< device_t >::remove ( const std::string & id )

inlineinherited

removed() [1/2]

template<typename device_t >

virtual void dx::driver< device_id_t >::removed ( )

inlineprotectedvirtualnoexceptinherited

notify device removals completed stub

Reimplemented from dx::driver< decltype(device_t::id)>.

Here is the caller graph for this function:

removed() [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 >::removed ( device_t & )

inlineoverrideprotectedvirtualnoexceptinherited

notify specific device removal stub

Reimplemented from dx::map::driver< device_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:

safety_offset()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::safety_offset ( const args & args )

inlineprotected

set/get streaming safety offset

Here is the call 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>

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

inlineinherited

Here is the call graph for this function:

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:

sig()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::sig ( int )

inlinestaticprotectednoexcept

Here is the call graph for this function:

Here is the caller graph for this function:

streaming_monitor()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::streaming_monitor ( const args & args )

inlineprotected

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<typename audio_pin_t::circular_t, 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 >::streaming_reset ( const args & = {} )

inlineprotected

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:

sync_reference()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::sync_reference ( const args & args )

inlineprotected

set/get I/O streaming block size

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<typename audio_pin_t::circular_t, 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 )

inlineprotected

Here is the call graph for this function:

unittest_buffer()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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_buffer ( const args & args = {} )

inlineprotected

unittest_duration()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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_duration ( const args & args = {} )

inlineprotected

unittest_format()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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_format ( const args & = {} )

inlineprotected

unittest_mask()

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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_mask ( const args & args = {} )

inlineprotected

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 call graph for this function:

Here is the caller graph for this function:

version()

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

inlinevirtualnoexceptinherited

Member Data Documentation

audio

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::audio = false

[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<typename audio_pin_t::circular_t, 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

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

cout

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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

denominator

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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>>

double dx::test::driver< super_device_t, audio_pin_t, io_t, device_t, driver_t, engine_t >::denominator

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", [](){std::cout<< "[argument ...]";}, 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<typename audio_pin_t::circular_t, 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

protected

elements

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

inherited

STL member.

engine_driven

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 >::engine_driven

inherited

pins do not provide any means of driving streaming

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

[struct]

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

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) >::log

inherited

[struct]

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

mask

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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

matching_ids

template<class device_t = device>

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

protectedinherited

midi

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::midi = false

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<class device_t = device>

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

protectedinherited

[struct]

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

[struct]

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

periode

template<typename super_device_t , typename audio_pin_t , typename io_t = int32_t, typename device_t = device<typename audio_pin_t::circular_t, 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 >::periode = 0

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>

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

protectedinherited

product_id

const char* dx::driver< decltype(device_t::id) >::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<class 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 [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>

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

inherited

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>

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

inherited

setup

template<class 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<typename audio_pin_t::circular_t, 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

[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<typename audio_pin_t::circular_t, 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

protected

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]

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) >::version

inherited

---

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

• dx_test.h