dxd - dynax driver framework 2.1.0d49
cross platform open source driver development framework
Loading...
Searching...
No Matches
dx::stream::engine< device_t, pin_t, io_t, circular_t > Class Template Referenceabstract

generic streaming engine More...

#include <dx_stream_engine.h>

+ Inheritance diagram for dx::stream::engine< device_t, pin_t, io_t, circular_t >:
+ Collaboration diagram for dx::stream::engine< device_t, pin_t, io_t, circular_t >:

Public Types

typedef device_t::desc desc
 
typedef decltype(matching_dictionaries) match
 
typedef ::GUID match
 

Public Member Functions

 __dx_cf_string_comparator (!=)
 
 __dx_cf_string_comparator (<)
 
 __dx_cf_string_comparator (<=)
 
 __dx_cf_string_comparator (==)
 
 __dx_cf_string_comparator (>)
 
 __dx_cf_string_comparator (>=)
 
virtual void conclude () noexcept
 
void conclude () noexcept override
 
::CFStringRef copy () const
 
virtual void detach () noexcept
 
 dx_catchall () static void idle(int64_t nsec)
 
virtual void exception (const exception &exception, bool=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
 
CFTypeID id () noexcept
 
CFTypeID id () noexcept
 
CFTypeID id () noexcept
 
CFTypeID id () noexcept
 
CFTypeID id () noexcept
 
CFTypeID id () noexcept
 
CFTypeID id () noexcept
 
CFTypeID id () noexcept
 
CFTypeID id () noexcept
 
CFTypeID id () noexcept
 
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])
 
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
 
bool operator!= (::CFStringRef value) const noexcept
 
bool operator!= (cf_object_t cf_object) const noexcept
 
::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<= (::CFStringRef value) const noexcept
 
bool operator== (::CFStringRef value) const noexcept
 
bool operator== (cf_object_t cf_object) const noexcept
 
bool operator> (::CFStringRef value) const noexcept
 
bool operator>= (::CFStringRef value) const noexcept
 
reference & release () noexcept
 
reference & retain () noexcept
 
void run () override
 
uint32_t samplerate () const
 
void samplerate (uint32_t samplerate)
 

Static Public Member Functions

::CFTypeID id () noexcept
 
static void idle (uint64_t timeout) noexcept
 

Public Attributes

::CFStringRef cf_type_desc = nullptr
 
::CFStringRef cf_type_id = nullptr
 
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< device_t > void arrived () override
 notify device arrivals completed stub
 
virtual void arrived (device_t &)
 notify specific device arrival stub
 
void clear () noexcept
 replaces std::deque::clear to call virtual notification methods
 
 dx_catchall_rethrow () virtual ~clock() noexcept
 
 engine (const typename driver::match &match, const char *id)
 
virtual void exception (const exception &) const noexcept
 notification exception handler
 
realtime & initialize (const std::chrono::high_resolution_clock::duration &resolution)
 
void initialize (const typename clock_t::duration &duration)
 
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
 
virtual void process (int64_t timestamp) noexcept=0
 
virtual void removed () noexcept
 notify device removals completed stub
 
void removed (device_t &device) noexcept override
 notify specific device removal stub
 
void sync (const std::chrono::high_resolution_clock::time_point &now) override
 
virtual void sync (const typename clock_t::time_point &now)
 
void tick () override
 
void update () noexcept try
 
void wait () try
 
virtual ~engine () 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
 
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
 
std::shared_ptr< pin_t > pin [directions]
 
volatile bool running = false
 
os_result status = not_initialized
 

Detailed Description

template<typename device_t, typename pin_t, typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
class dx::stream::engine< device_t, pin_t, io_t, circular_t >

generic streaming engine

Exceptions
incase of an error returned by the underlaying API the device class throws a dx::exception.

Member Typedef Documentation

◆ desc

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
typedef device_t::desc dx::stream::engine< device_t, pin_t, io_t, circular_t >::desc

◆ driver

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
typedef driver<device_t> dx::stream::engine< device_t, pin_t, io_t, circular_t >::driver
protected

◆ match [1/2]

typedef decltype(matching_dictionaries) dx::generic::driver::match
inherited

◆ match [2/2]

typedef ::GUID dx::generic::driver::match
inherited

Constructor & Destructor Documentation

◆ engine()

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
dx::stream::engine< device_t, pin_t, io_t, circular_t >::engine ( const typename driver::match & match,
const char * id )
inlineprotected
+ Here is the call graph for this function:

◆ ~engine()

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
virtual dx::stream::engine< device_t, pin_t, io_t, circular_t >::~engine ( )
inlineprotectedvirtualnoexcept
+ Here is the call graph for this function:

Member Function Documentation

◆ __dx_cf_string_comparator() [1/6]

template<typename cf_object_t >
dx::cf::__string< cf_object_t >::__dx_cf_string_comparator ( ! )
inherited

◆ __dx_cf_string_comparator() [2/6]

template<typename cf_object_t >
dx::cf::__string< cf_object_t >::__dx_cf_string_comparator ( )
inherited

◆ __dx_cf_string_comparator() [3/6]

template<typename cf_object_t >
dx::cf::__string< cf_object_t >::__dx_cf_string_comparator ( <= )
inherited

◆ __dx_cf_string_comparator() [4/6]

template<typename cf_object_t >
dx::cf::__string< cf_object_t >::__dx_cf_string_comparator ( )
inherited

◆ __dx_cf_string_comparator() [5/6]

template<typename cf_object_t >
dx::cf::__string< cf_object_t >::__dx_cf_string_comparator ( )
inherited

◆ __dx_cf_string_comparator() [6/6]

template<typename cf_object_t >
dx::cf::__string< cf_object_t >::__dx_cf_string_comparator ( >= )
inherited

◆ arrived() [1/2]

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
dx_catchall_handler(this,) using driver< device_t > void dx::stream::engine< device_t, pin_t, io_t, circular_t >::arrived ( )
inlineoverrideprotectedvirtual

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

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

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

◆ copy()

template<typename cf_object_t >
::CFStringRef dx::cf::__string< cf_object_t >::copy ( ) const
inlineinherited

◆ detach()

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
virtual void dx::stream::engine< device_t, pin_t, io_t, circular_t >::detach ( )
inlinevirtualnoexcept
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ dx_catchall()

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

◆ dx_catchall_rethrow()

template<enum scope scope_t = user, typename clock_t = std::chrono::high_resolution_clock>
dx::clock< scope_t, clock_t >::dx_catchall_rethrow ( )
inlinenoexceptinherited

◆ exception() [1/2]

virtual void dx::generic::driver::exception ( const exception & ) const
inlineprotectedvirtualnoexceptinherited

notification exception handler

◆ exception() [2/2]

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

notification exception handler

+ Here is the caller graph for this function:

◆ 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>
virtual void dx::stream::engine< device_t, pin_t, io_t, circular_t >::free ( )
inlinevirtualnoexcept
Todo
replace test for valid pin by overwise keeping track of allocated channels
+ Here is the caller graph for this function:

◆ halt()

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
void dx::stream::engine< device_t, pin_t, io_t, circular_t >::halt ( )
inlineoverridevirtualnoexcept

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

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ id() [1/11]

template<typename cf_object_t >
::CFTypeID dx::cf::reference< cf_object_t >::id ( )
staticnoexceptinherited
+ Here is the caller graph for this function:

◆ id() [2/11]

CFTypeID dx::cf::reference<::CFDictionaryRef >::id ( )
inlinenoexceptinherited

◆ id() [3/11]

CFTypeID dx::cf::reference<::CFMutableDictionaryRef >::id ( )
inlinenoexceptinherited

◆ id() [4/11]

CFTypeID dx::cf::reference<::CFNumberRef >::id ( )
inlinenoexceptinherited

◆ id() [5/11]

CFTypeID dx::cf::reference<::CFStringRef >::id ( )
inlinenoexceptinherited

◆ id() [6/11]

CFTypeID dx::cf::reference<::CFArrayRef >::id ( )
inlinenoexceptinherited

◆ id() [7/11]

CFTypeID dx::cf::reference<::CFURLRef >::id ( )
inlinenoexceptinherited

◆ id() [8/11]

CFTypeID dx::cf::reference<::CFBundleRef >::id ( )
inlinenoexceptinherited

◆ id() [9/11]

CFTypeID dx::cf::reference<::CFDataRef >::id ( )
inlinenoexceptinherited

◆ id() [10/11]

CFTypeID dx::cf::reference<::CFUUIDRef >::id ( )
inlinenoexceptinherited

◆ id() [11/11]

CFTypeID dx::cf::reference<::SCPreferencesRef >::id ( )
inlinenoexceptinherited

◆ idle()

static void dx::generic::driver::idle ( uint64_t timeout)
inlinestaticnoexceptinherited
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ 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
+ 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>
template<unsigned int max_channels>
void dx::stream::engine< device_t, pin_t, io_t, circular_t >::initialize ( uint32_t iosize,
uint64_t channel_map[2][(max_channels+63)/64] )
inline
Todo
clock already runnning with different iosize: check if engine should be initialized with current iosize
Todo
stream::engine::initialize(): define sync reference pin
+ Here is the call graph for this function:

◆ launch() [1/2]

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

◆ launch() [2/2]

virtual void dx::generic::driver::launch ( )
inlinevirtualinherited
+ Here is the call graph for this function:

◆ notify() [1/2]

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
void dx::stream::engine< device_t, pin_t, io_t, circular_t >::notify ( )
inlineoverrideprotectedvirtualnoexcept

notify change from device requiring streaming reset

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

Reimplemented in dx::test::driver< super_device_t, audio_pin_t, midi_pin_t, io_t, device_t >.

◆ notify() [2/2]

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
virtual void dx::stream::engine< device_t, pin_t, io_t, circular_t >::notify ( uint32_t )
inlineprotectedvirtualnoexcept

notify sample rate change from device

+ Here is the caller graph for this function:

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

template<typename cf_object_t >
dx::cf::__string< cf_object_t >::operator const char * ( ) const
inlineinherited

◆ operator double()

template<typename cf_object_t >
dx::cf::__string< cf_object_t >::operator double ( ) const
inlinenoexceptinherited

Skips whitespace; returns 0.0 on error.

◆ operator int32_t()

template<typename cf_object_t >
dx::cf::__string< cf_object_t >::operator int32_t ( ) const
inlinenoexceptinherited

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

◆ operator std::string()

template<typename cf_object_t >
dx::cf::__string< cf_object_t >::operator std::string ( ) const
inlineinherited

◆ operator!=() [1/2]

template<typename cf_object_t >
bool dx::cf::__string< cf_object_t >::operator!= ( ::CFStringRef value) const
inlinenoexceptinherited

◆ operator!=() [2/2]

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

◆ operator+() [1/2]

template<typename cf_object_t >
::CFMutableStringRef dx::cf::__string< cf_object_t >::operator+ ( ::CFStringRef value) const
inlinenoexceptinherited

◆ operator+() [2/2]

template<typename cf_object_t >
::CFMutableStringRef dx::cf::__string< cf_object_t >::operator+ ( const char * value) const
inlinenoexceptinherited

◆ operator::CFDataRef()

template<typename cf_object_t >
dx::cf::__string< cf_object_t >::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<()

template<typename cf_object_t >
bool dx::cf::__string< cf_object_t >::operator< ( ::CFStringRef value) const
inlinenoexceptinherited

◆ operator<=()

template<typename cf_object_t >
bool dx::cf::__string< cf_object_t >::operator<= ( ::CFStringRef value) const
inlinenoexceptinherited

◆ operator==() [1/2]

template<typename cf_object_t >
bool dx::cf::__string< cf_object_t >::operator== ( ::CFStringRef value) const
inlinenoexceptinherited

◆ operator==() [2/2]

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

◆ operator>()

template<typename cf_object_t >
bool dx::cf::__string< cf_object_t >::operator> ( ::CFStringRef value) const
inlinenoexceptinherited

◆ operator>=()

template<typename cf_object_t >
bool dx::cf::__string< cf_object_t >::operator>= ( ::CFStringRef value) const
inlinenoexceptinherited

◆ overload()

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
virtual void dx::stream::engine< device_t, pin_t, io_t, circular_t >::overload ( )
inlineprotectedvirtualnoexcept
+ Here is the caller graph for this function:

◆ process()

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
virtual void dx::stream::engine< device_t, pin_t, io_t, circular_t >::process ( int64_t timestamp)
protectedpure virtualnoexcept

◆ 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>
void dx::stream::engine< device_t, pin_t, io_t, circular_t >::removed ( device_t & )
inlineoverrideprotectedvirtualnoexcept

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>
void dx::stream::engine< device_t, pin_t, io_t, circular_t >::run ( )
inlineoverridevirtual

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

+ 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>
uint32_t dx::stream::engine< device_t, pin_t, io_t, circular_t >::samplerate ( ) const
inline

◆ samplerate() [2/2]

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
void dx::stream::engine< device_t, pin_t, io_t, circular_t >::samplerate ( uint32_t samplerate)
inline
+ Here is the call graph for this function:

◆ sync() [1/2]

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
void dx::stream::engine< device_t, pin_t, io_t, circular_t >::sync ( const std::chrono::high_resolution_clock::time_point & now)
inlineoverrideprotected
+ 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

◆ tick()

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
void dx::stream::engine< device_t, pin_t, io_t, circular_t >::tick ( )
inlineoverrideprotectedvirtual
Todo
enable re-sync with correct rx/tx position dependent clock event time point

Implements dx::clock< scope_t, clock_t >.

+ Here is the call graph for this function:

◆ update()

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
void dx::stream::engine< device_t, pin_t, io_t, circular_t >::update ( )
inlineprotectednoexcept
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ 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

◆ [struct]

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

◆ 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>
circular_t* dx::stream::engine< device_t, pin_t, io_t, circular_t >::circular[directions]

◆ device

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
std::shared_ptr<device_t> dx::stream::engine< device_t, pin_t, io_t, circular_t >::device
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>
force_read dx::stream::engine< device_t, pin_t, io_t, circular_t >::force_read

◆ force_write

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
force_write dx::stream::engine< device_t, pin_t, io_t, circular_t >::force_write

◆ frame

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
uint64_t dx::stream::engine< device_t, pin_t, io_t, circular_t >::frame = 0
protected

◆ hw_clock

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
bool dx::stream::engine< device_t, pin_t, io_t, circular_t >::hw_clock = false
protected

◆ interval

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
uint32_t dx::stream::engine< device_t, pin_t, io_t, circular_t >::interval

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>
io_t** dx::stream::engine< device_t, pin_t, io_t, circular_t >::io[directions][2] {}
protected

◆ iosize

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
uint32_t dx::stream::engine< device_t, pin_t, io_t, circular_t >::iosize = 0
protected

◆ kernel_streaming

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
bool dx::stream::engine< device_t, pin_t, io_t, circular_t >::kernel_streaming = false
protected

◆ 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>
uint32_t dx::stream::engine< device_t, pin_t, io_t, circular_t >::linesize

◆ log [1/2]

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

◆ log [2/2]

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

◆ monitor

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
dx::stream::clock::monitor* dx::stream::engine< device_t, pin_t, io_t, circular_t >::monitor = nullptr
protected

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

◆ pin

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
std::shared_ptr<pin_t> dx::stream::engine< device_t, pin_t, io_t, circular_t >::pin[directions]
protected

◆ preference [1/2]

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

◆ preference [2/2]

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

◆ reference

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
circular* dx::stream::engine< device_t, pin_t, io_t, circular_t >::reference

◆ running

template<enum scope scope_t = user, typename clock_t = std::chrono::high_resolution_clock>
volatile bool dx::clock< scope_t, clock_t >::running = false
protectedinherited

◆ safety_offset

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
uint32_t dx::stream::engine< device_t, pin_t, io_t, circular_t >::safety_offset {}

◆ samplerate [1/2]

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
volatile uint32_t* dx::stream::engine< device_t, pin_t, io_t, circular_t >::samplerate

◆ samplerate [2/2]

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
uint32_t dx::stream::engine< device_t, pin_t, io_t, circular_t >::samplerate

◆ 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

◆ [struct]

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

◆ trigger

template<typename device_t , typename pin_t , typename io_t = int32_t, typename circular_t = typename pin_t::circular_t>
int64_t dx::stream::engine< device_t, pin_t, io_t, circular_t >::trigger

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

(c) copyright 2009 dynamic acoustics e.U. generated on Wed Feb 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.