dx::test::driver< super_device_t, audio_pin_t, midi_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, midi_pin_t, io_t, device_t, driver_t, engine_t >:

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

Classes
class	clog
struct	dispatch

Public Types
typedef std::deque< std::string >	args
typedef device_t::desc	desc

Public Member Functions
	catch (...)
	catch (const dx::exception &__dx_exception)
	catch (const std::exception &__std_exception)
virtual void	conclude () noexcept
void	conclude () noexcept override
::CFStringRef	copy () const
virtual void	detach () noexcept
	driver (const typename super::match &match, const char *id)
	dx_catchall () static void idle(int64_t nsec)
	dx_catchall () static void idle(uint64_t timeout) noexcept
virtual void	exception (const exception &exception, bool filtered=false) const noexcept try
	notification exception handler
virtual void	exception (const exception &exception, bool filtered=false) const noexcept try
	notification exception handler
device_t *	find (std::string uid) const noexcept
	Finds the device by guid. The user is responsible for making sure the device list cannot be modified during find().
virtual void	free () noexcept
void	halt () noexcept override
	stop streaming engine
reference &	initialize (cf_object_t cf_object, bool retain=true)
template<unsigned int max_channels>
void	initialize (uint32_t iosize, uint64_t channel_map[2][(max_channels+63)/64]) try
virtual void	launch ()
virtual void	launch ()
	operator bool () const noexcept
	operator cf_object_t () const noexcept
	operator const char * () const
	operator double () const noexcept
	Skips whitespace; returns 0.0 on error.
	operator int32_t () const noexcept
	Skips whitespace; returns 0 on error, MAX or -MAX on overflow.
	operator std::string () const
template<typename petty_t = cf_object_t, typename = typename std::enable_if_t <!std::is_same_v<petty_t, ::CFTypeRef>>>
	operator type<> () const noexcept
bool	operator!= (::CFStringRef value) const noexcept
bool	operator!= (cf_object_t cf_object) const noexcept
bool	operator!= (value_t value)
::CFMutableStringRef	operator+ (::CFStringRef value) const noexcept
::CFMutableStringRef	operator+ (const char *value) const noexcept
	operator::CFDataRef () const noexcept
	operator::CFTypeID () const noexcept
template<typename petty_t = cf_object_t, typename = typename std::enable_if_t <!std::is_same_v<petty_t, ::CFTypeRef>>>
	operator::CFTypeRef () const noexcept
bool	operator< (::CFStringRef value) const noexcept
bool	operator< (value_t value)
void	operator<< (args args) try
bool	operator<= (::CFStringRef value) const noexcept
bool	operator<= (value_t value)
bool	operator== (::CFStringRef value) const noexcept
bool	operator== (cf_object_t cf_object) const noexcept
bool	operator== (value_t value)
bool	operator> (::CFStringRef value) const noexcept
bool	operator> (value_t value)
bool	operator>= (::CFStringRef value) const noexcept
bool	operator>= (value_t value)
reference &	release () noexcept
reference &	retain () noexcept
void	run () override try
	start streaming engine
uint32_t	samplerate () const try
void	samplerate (uint32_t samplerate) try

Public Attributes
class redirect::indent::streambuf dx::test::driver::clog	cerr
::CFStringRef	cf_type_desc = nullptr
::CFStringRef	cf_type_id = nullptr
class redirect::indent::streambuf dx::test::driver::clog	cout
T	elements
	STL member.
bool	launched = false
log	log {}
dx::log	log {}
cf::preference	preference
dx::registry	preference
dx::generic::driver::setup	setup

Protected Types
typedef driver< device_t >	driver

Protected Member Functions
dx_catchall_handler(this,) using driver_t 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
	replaces std::deque::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	device_arrival_removal (const args &={}) try
void	device_config (const args &args={}) try
void	device_reset (const args &={}) try
void	enumerate_os_audio (const args &args={}) try
void	generator (const args &args={}) try
void	help (const args &args={})
void	info (const args &={})
realtime &	initialize (const std::chrono::high_resolution_clock::duration &resolution)
void	initialize (const typename clock_t::duration &duration)
void	iosize (const args &args) try
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	midi_test (const args &args={}) try
void	notify () noexcept override
	notify change from device requiring streaming reset
virtual void	notify (uint32_t) noexcept
	notify sample rate change from device
	operator::CFRunLoopSourceRef () const noexcept
	operator::IONotificationPortRef () const noexcept
	operator::mach_port_t () const noexcept
virtual void	overload () noexcept
void	process (int64_t) noexcept override
void	quiet (const args &={}) noexcept
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
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
virtual void	sync (const typename clock_t::time_point &now)
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
void	version (const args &={}) noexcept
void	wait () try

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

Protected Attributes
struct {
circular_t *   circular [directions]
force_read   force_read
force_write   force_write
struct {
volatile uint32_t *   samplerate
}   observer
struct {
uint32_t   interval
	clock resolution: HW stream frame size in samples More...
uint32_t   linesize
circular *   reference
uint32_t   safety_offset [directions]
uint32_t   samplerate
int64_t   trigger
}   sync
}	cache
cf_object_t	cf_object = nullptr
std::shared_ptr< device_t >	device
uint32_t	dropout = 0
clock_t::duration	duration = clock_t::duration::zero()
uint64_t	frame = 0
bool	hw_clock = false
io_t **	io [directions][2] {}
uint32_t	iosize = 0
bool	kernel_streaming = false
dx::stream::clock::monitor *	monitor = nullptr
	io[directions][double buffer][channel][sample]
std::mutex	mutex
clock_t::time_point	objective
struct {
struct {
double   denominator
uint32_t   periode = 0
}   generator
struct {
bool   audio = false
bool   midi = false
}   loopback
bool   quiet = false
}	parameter
const std::map< std::deque< std::string >, dispatch >	parse
std::shared_ptr< pin_t >	pin [directions]
std::atomic< bool >	running
os_result	status = not_initialized
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

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

typedef std::deque<std::string> dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::args

desc

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

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

inherited

driver

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

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

protectedinherited

Constructor & Destructor Documentation

driver()

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::driver ( const typename super::match & match, const char * id )

inline

Here is the call graph for this function:

Member Function Documentation

abort()

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

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

inlinestaticprotectednoexcept

Here is the caller graph for this function:

arrived() [1/2]

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

dx_catchall_handler(this,) using driver_t void dx::stream::engine< device_t, pin_t, io_t, circular_t, driver_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::driver< device_t >.

Here is the call graph for this function:

arrived() [2/2]

template<class device_t = device>

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

inlineprotectedvirtualinherited

notify specific device arrival stub

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

buffer()

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

template<typename data_t >

void dx::test::driver< super_device_t, audio_pin_t, midi_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

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

inlineprotected

catch() [1/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [2/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [3/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [4/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [5/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [6/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [7/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [8/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [9/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [10/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [11/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [12/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [13/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [14/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [15/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [16/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [17/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [18/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inlineprotected

catch() [19/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( ... )

inline

catch() [20/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [21/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [22/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [23/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [24/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [25/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [26/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [27/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [28/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [29/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [30/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [31/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [32/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [33/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [34/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [35/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [36/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [37/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

catch() [38/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const dx::exception & __dx_exception )

inline

catch() [39/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [40/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [41/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [42/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [43/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [44/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [45/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [46/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [47/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [48/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [49/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [50/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [51/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [52/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [53/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [54/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [55/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [56/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

catch() [57/57]

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

dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::catch ( const std::exception & __std_exception )

inline

clear()

template<class device_t = device>

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

inlineprotectednoexceptinherited

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

Todo

check if exception catching needed for device::conclude()

Here is the call graph for this function:

clock()

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

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

inlineprotected

clock_monitor()

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

void dx::test::driver< super_device_t, audio_pin_t, midi_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() [1/2]

template<class device_t = device>

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

inlinevirtualnoexceptinherited

Reimplemented from dx::generic::driver.

conclude() [2/2]

template<class device_t = device>

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

inlineoverridevirtualnoexceptinherited

Reimplemented from dx::generic::driver.

Here is the call graph for this function:

Here is the caller graph for this function:

copy()

::CFStringRef dx::cf::__string< ::CFStringRef >::copy ( ) const

inlineinherited

detach()

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

virtual void dx::stream::engine< device_t, pin_t, io_t, circular_t, driver_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

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

inlineprotected

device_config()

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

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

inlineprotected

device_reset()

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

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

inlineprotected

dx_catchall() [1/2]

dx::generic::driver::dx_catchall ( )

inlineinherited

Here is the caller graph for this function:

dx_catchall() [2/2]

dx::generic::driver::dx_catchall ( )

inlinenoexceptinherited

enumerate_os_audio()

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

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

inlineprotected

exception() [1/2]

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

inlinevirtualnoexceptinherited

notification exception handler

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

Here is the caller graph for this function:

exception() [2/2]

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

inlinevirtualnoexceptinherited

notification exception handler

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

find()

template<class device_t = device>

device_t * dx::driver< device_t >::find ( std::string uid ) const

inlinenoexceptinherited

Finds the device by guid.
The user is responsible for making sure the device list cannot be modified during find().

Exceptions

n/a	this method does not throw exceptions

free()

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

virtual void dx::stream::engine< device_t, pin_t, io_t, circular_t, driver_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

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

inlineprotected

halt()

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

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

inlineoverridevirtualnoexceptinherited

stop streaming engine

Reimplemented from dx::clock< scope_t, clock_t >.

Here is the call graph for this function:

Here is the caller graph for this function:

help()

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

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

inlineprotected

Here is the caller graph for this function:

info()

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

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

inlineprotected

initialize() [1/4]

template<typename cf_object_t >

reference & dx::cf::reference< cf_object_t >::initialize ( cf_object_t cf_object, bool retain = true )

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

initialize() [2/4]

realtime & dx::thread::prio::realtime::initialize ( const std::chrono::high_resolution_clock::duration & resolution )

inlineinherited

Todo

dx::thread::prio: replace experimental hardcoded preemption limit with real limit obtained from machine

Here is the caller graph for this function:

initialize() [3/4]

template<enum scope scope_t = user, typename clock_t = std::chrono::high_resolution_clock>

void dx::clock< scope_t, clock_t >::initialize ( const typename clock_t::duration & duration )

inlineinherited

Here is the caller graph for this function:

initialize() [4/4]

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

template<unsigned int max_channels>

void dx::stream::engine< device_t, pin_t, io_t, circular_t, driver_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

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

inlineprotected

Here is the call graph for this function:

launch() [1/2]

virtual void dx::generic::driver::launch ( )

inlinevirtualinherited

Here is the caller graph for this function:

launch() [2/2]

virtual void dx::generic::driver::launch ( )

inlinevirtualinherited

Here is the call graph for this function:

loglevel()

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

void dx::test::driver< super_device_t, audio_pin_t, midi_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

void dx::test::driver< super_device_t, audio_pin_t, midi_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

void dx::test::driver< super_device_t, audio_pin_t, midi_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

midi_test()

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

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

inlineprotected

notify() [1/2]

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

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

inlineoverrideprotectedvirtualnoexcept

notify change from device requiring streaming reset

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

Here is the caller graph for this function:

notify() [2/2]

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

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

inlineprotectedvirtualnoexceptinherited

notify sample rate change from device

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

operator bool()

template<typename cf_object_t >

dx::cf::reference< cf_object_t >::operator bool ( ) const

inlinenoexceptinherited

operator cf_object_t()

template<typename cf_object_t >

dx::cf::reference< cf_object_t >::operator cf_object_t ( ) const

inlinenoexceptinherited

operator const char *()

dx::cf::__string< ::CFStringRef >::operator const char * ( ) const

inlineinherited

operator double()

dx::cf::__string< ::CFStringRef >::operator double ( ) const

inlinenoexceptinherited

Skips whitespace; returns 0.0 on error.

operator int32_t()

dx::cf::__string< ::CFStringRef >::operator int32_t ( ) const

inlinenoexceptinherited

Skips whitespace; returns 0 on error, MAX or -MAX on overflow.

operator std::string()

dx::cf::__string< ::CFStringRef >::operator std::string ( ) const

inlineinherited

operator type<>()

template<typename cf_object_t >

template<typename petty_t = cf_object_t, typename = typename std::enable_if_t <!std::is_same_v<petty_t, ::CFTypeRef>>>

dx::cf::reference< cf_object_t >::operator type<> ( ) const

noexceptinherited

operator!=() [1/3]

bool dx::cf::__string< ::CFStringRef >::operator!= ( ::CFStringRef value ) const

inlinenoexceptinherited

operator!=() [2/3]

template<typename cf_object_t >

bool dx::cf::reference< cf_object_t >::operator!= ( cf_object_t cf_object ) const

inlinenoexceptinherited

operator!=() [3/3]

bool dx::cf::__string< ::CFStringRef >::operator!= ( value_t value )

inlineinherited

operator+() [1/2]

::CFMutableStringRef dx::cf::__string< ::CFStringRef >::operator+ ( ::CFStringRef value ) const

inlinenoexceptinherited

operator+() [2/2]

::CFMutableStringRef dx::cf::__string< ::CFStringRef >::operator+ ( const char * value ) const

inlinenoexceptinherited

operator::CFDataRef()

dx::cf::__string< ::CFStringRef >::operator::CFDataRef ( ) const

inlinenoexceptinherited

operator::CFRunLoopSourceRef()

dx::io::power::operator::CFRunLoopSourceRef ( ) const

inlinenoexceptinherited

operator::CFTypeID()

template<typename cf_object_t >

dx::cf::reference< cf_object_t >::operator::CFTypeID ( ) const

inlinenoexceptinherited

operator::CFTypeRef()

template<typename cf_object_t >

template<typename petty_t = cf_object_t, typename = typename std::enable_if_t <!std::is_same_v<petty_t, ::CFTypeRef>>>

dx::cf::reference< cf_object_t >::operator::CFTypeRef ( ) const

inlinenoexceptinherited

operator::IONotificationPortRef()

dx::io::power::operator::IONotificationPortRef ( ) const

inlinenoexceptinherited

operator::mach_port_t()

dx::io::power::operator::mach_port_t ( ) const

inlinenoexceptinherited

operator<() [1/2]

bool dx::cf::__string< ::CFStringRef >::operator< ( ::CFStringRef value ) const

inlinenoexceptinherited

operator<() [2/2]

bool dx::cf::__string< ::CFStringRef >::operator< ( value_t value )

inlineinherited

operator<<()

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

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

inline

Here is the call graph for this function:

operator<=() [1/2]

bool dx::cf::__string< ::CFStringRef >::operator<= ( ::CFStringRef value ) const

inlinenoexceptinherited

operator<=() [2/2]

bool dx::cf::__string< ::CFStringRef >::operator<= ( value_t value )

inlineinherited

operator==() [1/3]

bool dx::cf::__string< ::CFStringRef >::operator== ( ::CFStringRef value ) const

inlinenoexceptinherited

operator==() [2/3]

template<typename cf_object_t >

bool dx::cf::reference< cf_object_t >::operator== ( cf_object_t cf_object ) const

inlinenoexceptinherited

operator==() [3/3]

bool dx::cf::__string< ::CFStringRef >::operator== ( value_t value )

inlineinherited

operator>() [1/2]

bool dx::cf::__string< ::CFStringRef >::operator> ( ::CFStringRef value ) const

inlinenoexceptinherited

operator>() [2/2]

bool dx::cf::__string< ::CFStringRef >::operator> ( value_t value )

inlineinherited

operator>=() [1/2]

bool dx::cf::__string< ::CFStringRef >::operator>= ( ::CFStringRef value ) const

inlinenoexceptinherited

operator>=() [2/2]

bool dx::cf::__string< ::CFStringRef >::operator>= ( value_t value )

inlineinherited

overload()

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

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

inlineprotectedvirtualnoexceptinherited

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

Here is the caller graph for this function:

process()

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

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

inlineoverrideprotectedvirtualnoexcept

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

Here is the call graph for this function:

quiet()

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

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

inlineprotectednoexcept

release()

template<typename cf_object_t >

reference & dx::cf::reference< cf_object_t >::release ( )

inlinenoexceptinherited

Here is the caller graph for this function:

removed() [1/2]

template<class device_t = device>

virtual void dx::generic::driver::removed ( )

inlineprotectedvirtualnoexceptinherited

notify device removals completed stub

Reimplemented from dx::generic::driver.

removed() [2/2]

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

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

inlineoverrideprotectedvirtualnoexceptinherited

notify specific device removal stub

Reimplemented from dx::driver< device_t >.

Here is the call graph for this function:

retain()

template<typename cf_object_t >

reference & dx::cf::reference< cf_object_t >::retain ( )

inlinenoexceptinherited

Here is the caller graph for this function:

run()

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

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

inlineoverridevirtualinherited

start streaming engine

Reimplemented from dx::clock< scope_t, clock_t >.

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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

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

inlineprotected

Here is the call graph for this function:

samplerate() [1/2]

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

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

inlineinherited

samplerate() [2/2]

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

void dx::stream::engine< device_t, pin_t, io_t, circular_t, driver_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

static void dx::test::driver< super_device_t, audio_pin_t, midi_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

void dx::test::driver< super_device_t, audio_pin_t, midi_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

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

inlineprotected

sync() [1/2]

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

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

inlineoverrideprotectedinherited

Here is the call graph for this function:

sync() [2/2]

template<enum scope scope_t = user, typename clock_t = std::chrono::high_resolution_clock>

virtual void dx::clock< scope_t, clock_t >::sync ( const typename clock_t::time_point & now )

inlineprotectedvirtualinherited

Here is the caller graph for this function:

unittest()

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

void dx::test::driver< super_device_t, audio_pin_t, midi_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

void dx::test::driver< super_device_t, audio_pin_t, midi_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

void dx::test::driver< super_device_t, audio_pin_t, midi_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

void dx::test::driver< super_device_t, audio_pin_t, midi_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 midi_pin_t , typename io_t = int32_t, typename device_t = device< typename audio_pin_t::circular_t, super_device_t, typename midi_pin_t::circular_t>, typename driver_t = dx::driver<device_t>, typename engine_t = stream::engine< device_t, audio_pin_t, io_t, typename audio_pin_t::circular_t, driver_t>>

void dx::test::driver< super_device_t, audio_pin_t, midi_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 io_t = int32_t, typename circular_t = typename pin_t::circular_t, typename driver_t = driver<device_t>>

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

inlineprotectednoexceptinherited

Here is the call graph for this function:

Here is the caller graph for this function:

version()

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

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

inlineprotectednoexcept

wait()

template<enum scope scope_t = user, typename clock_t = std::chrono::high_resolution_clock>

void dx::clock< scope_t, clock_t >::wait ( )

inlineinherited

Member Data Documentation

audio

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

bool dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::audio = false

[struct]

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

cerr

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

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

cf_object

template<typename cf_object_t >

cf_object_t dx::cf::reference< cf_object_t >::cf_object = nullptr

protectedinherited

cf_type_desc

template<typename cf_object_t >

::CFStringRef dx::cf::reference< cf_object_t >::cf_type_desc = nullptr

inherited

cf_type_id

template<typename cf_object_t >

::CFStringRef dx::cf::reference< cf_object_t >::cf_type_id = nullptr

inherited

circular

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

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

inherited

cout

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

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

denominator

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

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

device

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

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

protectedinherited

dropout

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

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

protected

duration

template<enum scope scope_t = user, typename clock_t = std::chrono::high_resolution_clock>

clock_t::duration dx::clock< scope_t, clock_t >::duration = clock_t::duration::zero()

protectedinherited

Todo

evaluate clock::status replacement (exception?)

elements

T std::deque< T >::elements

inherited

STL member.

force_read

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

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

inherited

force_write

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

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

inherited

frame

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

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

protectedinherited

[struct]

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

hw_clock

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

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

protectedinherited

interval

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

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

inherited

clock resolution: HW stream frame size in samples

io

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

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

protectedinherited

iosize

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

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

protectedinherited

kernel_streaming

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

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

protectedinherited

launched

template<class device_t = device>

bool dx::driver< device_t >::launched = false

inherited

linesize

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

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

inherited

log [1/2]

log dx::generic::driver::log {}

inherited

log [2/2]

dx::log dx::generic::driver::log {}

inherited

[struct]

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

mask

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

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

midi

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

bool dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::midi = false

monitor

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

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

protectedinherited

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

mutex

template<enum scope scope_t = user, typename clock_t = std::chrono::high_resolution_clock>

std::mutex dx::clock< scope_t, clock_t >::mutex

protectedinherited

objective

template<enum scope scope_t = user, typename clock_t = std::chrono::high_resolution_clock>

clock_t::time_point dx::clock< scope_t, clock_t >::objective

protectedinherited

[struct]

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

[struct]

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

parse

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

const std::map<std::deque<std::string>, dispatch> dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::parse

protected

Initial value:

{
        {{"--device-arrival-removal", "-a"},            {&driver::device_arrival_removal, "device arrival/removal loop"}},
        {{"--device-configuration", "--config", "-g"},  {&driver::device_config, "set and/or get current configuration", "[CFG]"}},
        {{"--device-reset", "-0"},                      {&driver::device_reset, "reset device"}},
        {{"--help", "-h", "-?"},                        {&driver::help, "help"}},
        {{"--info", "-i"},                              {&driver::info, "info: enumerate all devices; display driver, device and streaming pin informations"}},
        {{"--log-level", "-@"},                         {&driver::loglevel, "(re)set/get log mask", "[MASK|!]"}},
        {{"--midi-test", "--midi", "-m"},               {&driver::midi_test, "MIDI test", "[sec]"}},
 
 
 
 
 
 
        {{"--quiet", "-q"},                             {&driver::quiet, "quiet!"}},
        {{"--samplerate", "--clock", "--clk", "-c"},    {&driver::clock, "set and/or get device sample rate", "[CLK]"}},
        {{"--streaming-monitor", "--clock-monitor", "--monitor", "-s"},
                                                        {&driver::streaming_monitor, "streaming/clock monitor", "[sec]"}},
        {{"--streaming-generator", "-y"},               {&driver::generator, "sine generator (for streaming test)", "[Hz]"}},
        {{"--streaming-iosize", "--iosize", "-o"},      {&driver::iosize, "set/get I/O streaming block size", "[samples]"}},
        {{"--streaming-loopback", "--loopback", "-l"},  {&driver::loopback, "enable audio/MIDI loopback test (for streaming test)", "[audio|MIDI] [..]"}},
        {{"--streaming-reset", "-!"},                   {&driver::streaming_reset, "reset streaming monitor performance counters"}},
        {{"--streaming-safety-offset"},                 {&driver::safety_offset, "set/get streaming safety RX/TX offset in clock ticks", "<RX|TX> [ticks]"}},
        {{"--unit-test", "-u"},                         {&driver::unittest, "driver interface unit testing [defaulting to 3 sec per single test]", "[sec]"}},
        {{"--unit-test-buffer", "-b"},                  {&driver::unittest_buffer, "unit circular buffer streaming test", "[sec]"}},
        {{"--unit-test-duration", "-d"},                {&driver::unittest_duration, "set/get driver interface unit streaming test duration", "[msec]"}},
        {{"--unit-test-mask", "-m"},                    {&driver::unittest_mask, "set/get driver interface unit testing mask", "[MASK]"}},
        {{"--unit-test-format", "-f"},                  {&driver::unittest_format, "unit test: streaming format engine test"}},
        {{"--version", "-v"},                           {&driver::version, "display the cmd line test application version"}},
    }

periode

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

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

pin

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

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

protectedinherited

preference [1/2]

cf::preference dx::generic::driver::preference

inherited

preference [2/2]

dx::registry dx::generic::driver::preference

inherited

quiet

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

bool dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t, driver_t, engine_t >::quiet = false

reference

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

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

inherited

running

template<enum scope scope_t = user, typename clock_t = std::chrono::high_resolution_clock>

std::atomic<bool> dx::clock< scope_t, clock_t >::running

protectedinherited

safety_offset

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

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

inherited

samplerate [1/2]

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

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

inherited

samplerate [2/2]

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

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

inherited

setup

dx::generic::driver::setup dx::generic::driver::setup

inherited

status

template<enum scope scope_t = user, typename clock_t = std::chrono::high_resolution_clock>

os_result dx::clock< scope_t, clock_t >::status = not_initialized

protectedinherited

stream_duration

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

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

[struct]

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

tick

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

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

protected

trigger

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

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

inherited

[struct]

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

---

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

• dx_test.h