dxd - dynax driver framework 2.1.0d73
cross platform open source driver development framework
Loading...
Searching...
No Matches
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
 
referenceinitialize (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)
 
referencerelease () noexcept
 
referenceretain () 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
 
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 &={})
 
realtimeinitialize (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::monitormonitor = 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 >, dispatchparse
 
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

◆ 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/athis 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::clock< scope_t, clock_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

◆ 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"}},
}
clock()=default
uint32_t safety_offset[directions]
Definition dx_stream_engine.h:381
uint32_t iosize
Definition dx_stream_engine.h:368
void streaming_reset(const args &={}) try
Definition dx_test.h:833
struct dx::test::driver::@33::@39 loopback
void help(const args &args={})
Definition dx_test.h:1546
void unittest_format(const args &={}) try
Definition dx_test.h:1452
void midi_test(const args &args={}) try
Definition dx_test.h:862
struct dx::test::driver::@33::@40 generator
bool quiet
Definition dx_test.h:204
void device_config(const args &args={}) try
Definition dx_test.h:490
void unittest_mask(const args &args={}) try
Definition dx_test.h:1445
void info(const args &={})
Definition dx_test.h:216
void version(const args &={}) noexcept
Definition dx_test.h:1490
void device_reset(const args &={}) try
Definition dx_test.h:509
void unittest_duration(const args &args={}) try
Definition dx_test.h:1438
void unittest(const args &args) try
Definition dx_test.h:1085
void unittest_buffer(const args &args={}) try
Definition dx_test.h:1419
void loglevel(const args &args) try
Definition dx_test.h:558
void streaming_monitor(const args &args) try
Definition dx_test.h:810
void device_arrival_removal(const args &={}) try
Definition dx_test.h:467

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

(c) copyright 2009 dynamic acoustics e.U. generated on Thu Nov 28 2024

a closed source license may be obtained by requesting a written permission from dynamic acoustics e.U.
however - governmental use generally and military use especially is strictly prohibited though.