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	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 *product_id, const typename super::desc &desc)
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
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 = dx::test::device<typename audio_pin_t::circular_t, 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 )

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 )

inlinestaticprotectednoexceptinherited

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

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

inlineprotectedinherited

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 = {} )

inlineprotectedinherited

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 )

inlineprotectednoexceptinherited

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 & = {} )

inlineprotectedinherited

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 & = {} )

inlineprotectedinherited

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 = {} )

inlineprotectedinherited

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 = {} )

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 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 = {} )

inlineprotectedinherited

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

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

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 & = {} )

inlineprotectedinherited

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 )

inlineprotectedinherited

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 )

inlineprotectedinherited

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 = {} )

inlineprotectedinherited

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

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

inlineoverrideprotectednoexceptinherited

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 )

inlineoverrideprotectedvirtualnoexceptinherited

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 )

inlineprotectedinherited

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 )

inlinestaticprotectednoexceptinherited

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 )

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<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 & = {} )

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:

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 )

inlineprotectedinherited

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 )

inlineprotectedinherited

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 = {} )

inlineprotectedinherited

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 = {} )

inlineprotectedinherited

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 & = {} )

inlineprotectedinherited

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 = {} )

inlineprotectedinherited

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

inherited

[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

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

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

inherited

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

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", [](){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

protectedinherited

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

inherited

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

inherited

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

inherited

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

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

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]

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_virtual.h