a USB device that streams: the stream device's settings wired to the class requests of the device (the rate to the endpoints stating the sampling frequency control, the clock source and the channel source to their units), its streams the pipes below More...

#include <dx_usb_stream_device.h>

Inheritance diagram for dx::usb::stream::_device< desc_t, preference_t, stream_t, group_t >:

Collaboration diagram for dx::usb::stream::_device< desc_t, preference_t, stream_t, group_t >:

Classes
struct	[struct].adc

Public Types
typedef desc_t	desc_t
typedef event	event_t
typedef std::set<std::string>	keys
typedef promoted<uint32_t>::template preference<decltype(super_device_t::preference)>	source_t
typedef stream_t	stream_t
typedef usb::device<preference_t>	super_device_t
	the device this streaming device sits on: its own operations of a name this class takes for itself (a USB device's configuration()) are reached through it
enum	type
	the value types this store keeps - a scalar rides as REG_DWORD/REG_QWORD rather than as a byte copy, so a value written here reads like any other in the registry editor More...

Public Member Functions
	_device(decltype(super::driver)& driver, decltype(super::id)& id, const std::pair<std::string, std::string>& identity= {})
desc_t::configuration	align(const typename desc_t::configuration& value, const typename desc_t::configuration& current) override
	the configuration the device's bus carries: its USB configuration, per stream what the rate and the periodic budget leave (usb::align) - the rate as it stands, never asked from inside its own server
usb::interface&	at(const usb::endpoint& endpoint)
	the interface one of whose settings carries the endpoint: an endpoint address belongs to one interface of a configuration
usb::interface&	at(uint8_t number)
void	attach(void** io[dx::stream::direction::directions][2], const std::vector<bool>(& channel_map)[2], const dx::stream::format(& format)[2])
	the consumer's planar channel buffers in the format each direction's buffers carry
uint64_t	budget() const
	the periodic bus time a (micro) frame offers the device's isochronous endpoints, in ns: 90% of a full speed frame, 80% of a high speed micro frame, no bound above
uint64_t	budget(const typename desc_t::configuration& value) override
	the periodic bus time the configuration takes, in ns: to hold against budget(), what the bus offers
	catch(...)
	catch(...)
device&	clear()
device&	close(bool force= false) noexcept
void	conclude() noexcept override
	ends every group's session before the device's resources go; the start counts stay with their holders
uint8_t	configuration() const
uint8_t	configuration(uint8_t configuration) override
uint8_t	configurations() const
virtual void	configure()
	a desc without streams takes them from the configuration's audio class descriptors
auto	count() const noexcept
auto	count() const noexcept
void	ctl(uint32_t ioctl) const
class	end()
registry&	erase(const char* subkey= nullptr) noexcept
void	exception(const dx::exception& exception, bool filtered= false) const noexcept override
	notification exception handler
uint64_t	frame(int64_t* timestamp= nullptr) const
	current bus frame number; timestamp: dx::timestamp() of the readout
virtual void	free() noexcept
value_t	get() const
value_t	get(::CFStringRef key) const
::CFTypeRef	get(::CFStringRef key) const
::CFTypeRef	get(::CFStringRef key) const
value_t	get(::CFStringRef key, ::CFTypeRef dflt) const noexcept
::CFTypeRef	get(::CFStringRef key, ::CFTypeRef dflt) const noexcept
::CFTypeRef	get(::CFStringRef key, ::CFTypeRef dflt) const noexcept
value_t	get(::CFStringRef key, value_t dflt) const noexcept
value_t	get(::CFStringRef key, value_t dflt) const noexcept
value_t	get(key_t key) const
::CFTypeRef	get(key_t key) const
::CFTypeRef	get(key_t key) const
bool	get(value_t& value) const
virtual bool	hw_clock() const noexcept
virtual void	hw_clock(abstract::event* hw_clock, uint32_t iosize)
	registers a consumer with the device's clock: it is signalled every iosize samples of the clock's own advance. A bus whose driver owns the clock hands the registration on instead
hide_if_scalar_or_ptr<rx_t>	ictl(uint32_t ioctl) const
	member ioctl
size_t	ictl(unsigned int ioctl, rx_t& rx) const
registry&	initialize(::HKEY root, ::REGSAM rights= KEY_ALL_ACCESS)
registry&	initialize(::REGSAM rights= KEY_ALL_ACCESS, ::HKEY root= HKEY_CURRENT_USER)
void	initialize(const char* name, ::DWORD access= GENERIC_READ\|GENERIC_WRITE, ::DWORD share= FILE_SHARE_READ\|FILE_SHARE_WRITE)
	(re-)initialization the underlaying windows API is CreateFile(). for detailed information see http://msdn.microsoft.com/en-us/library/aa363858(VS.85).aspx
registry&	initialize(const std::string& key, ::HKEY root= HKEY_CURRENT_USER, ::REGSAM rights= KEY_ALL_ACCESS)
size_t	ioctl(uint32_t ioctl, const tx_t& tx, rx_t& rx) const
rx_t	ioctl(unsigned int ioctl, const tx_t& tx) const
void	launch() override
	launch notification: object mounted and ready to use. Called only through try_launch() - never call this directly from outside the class hierarchy.
rx_t*	map(uint32_t typetype) const
	maps the memory the given type names into this client
device&	octl(uint32_t ioctl, const tx_t& tx)
void	octl(unsigned int ioctl, const tx_t& tx) const
std::shared_ptr<stream_t>	open(const typename desc_t::stream::desc& desc, bool client= false)
	the desc's stream: the registered one, else created, registered and launched - a host's client takes a data driven stream alone, its ring has one writer and one reader
device&	open()
	opens the USB device for exclusice access
	operator const ::io_registry_entry_t&() const noexcept
	auto converter into const io_object
	operator const ::io_registry_entry_t&() const noexcept
	auto converter into const io_object
	operator const ::io_registry_entry_t&() const noexcept
	auto converter into const io_object
	operator const os_event() const noexcept
	operator const std::string&() const noexcept
	identifying device string, mirroring macOS' io::registry conversion
	operator os_event() noexcept
	operator uint64_t() const
	operator uint64_t() const
const struct desc_t::stream::config&	operator ()(const struct desc_t::stream& stream)
	the stream configuration the device runs the stream in: the stream is one of the desc's
::IOUSBDeviceInterface650*	operator ->() const
	operator ::CFMutableDictionaryRef() const
	operator ::CFMutableDictionaryRef() const
	operator ::CFStringRef() const
	operator ::CFStringRef() const
	operator ::HANDLE() const noexcept
	operator ::HKEY() const noexcept
	operator ::io_registry_entry_t&() noexcept
	auto converter into io_object
	operator ::io_registry_entry_t&() noexcept
	auto converter into io_object
	operator ::io_registry_entry_t&() noexcept
	auto converter into io_object
	operator ::io_registry_entry_t*() noexcept
	auto converter into io_object pointer
	operator ::io_registry_entry_t*() noexcept
	auto converter into io_object pointer
	operator ::io_registry_entry_t*() noexcept
	auto converter into io_object pointer
	operator ::IOUSBDeviceInterface650**() const
bool	operator ==(::io_registry_entry_t io_object) const noexcept
bool	operator ==(::io_registry_entry_t io_object) const noexcept
virtual device&	operator >>(std::ostream &) const
	the device's own diagnostics, beyond its operator <<
virtual device&	operator >>(std::ostream &) const
	the device's own diagnostics, beyond its operator <<
virtual device&	operator >>(std::ostream &) const
	the device's own diagnostics, beyond its operator <<
group_t&	operator [](const typename desc_t::stream::desc& stream)
	the stream's group, created on first use
usb::interface*	operator [](const usb::endpoint& endpoint)
	the interface one of whose settings carries the endpoint, nullptr where none of this device node does
::CFTypeRef	operator [](::CFStringRef key) const
::CFTypeRef	operator [](key_t key) const
registry	parent() const
registry	parent() const
os_result	rate(const struct desc_t::stream& stream, uint32_t& rate, bool set) noexcept
device&	reenumerate()
device&	reset()
reference&	retain()
reference&	retain()
registry&	run()
registry&	set(::CFStringRef key, ::CFTypeRef value)
registry&	set(::CFStringRef key, ::CFTypeRef value)
registry&	set(::CFStringRef key, value_t value)
registry&	set(::CFStringRef key, value_t value)
registry&	set(::CFTypeRef properties)
	Setting properties in a registry entry is not generally supported, it is more common to support setting of properties of the connection based property setting of dx::device.
device&	set(::CFTypeRef properties)
	Setting properties in a registry entry is not generally supported, it is more common to support setting of properties of the connection based property setting of dx::device.
registry&	set(::DWORD typetype, const void* value, size_t size)
registry&	set(key_t key, ::CFTypeRef value)
registry&	set(key_t key, ::CFTypeRef value)
registry&	set(key_t key, value_t value)
registry&	set(key_t key, value_t value)
void	setting(dx::stream::setting setting, uint32_t index, f_t&& f)
	the setting a host keeps for its clients handed to f as its promoted: the transport settings the sync reference's group's, the source the one of the stream whose target index is index
size_t	size() const noexcept
virtual void	sleep()
	notify system will sleep stub
virtual void	sleep()
	notify system will sleep stub
virtual void	sleep()
	notify system will sleep stub
std::pair<typename super::source_t &, bool>	source(const struct desc_t::stream& stream) override
	a stream's source selector is the selector unit's input pin, read/written/read back; its class request wraps the preference's own server
os_result	status() const noexcept
template<size_t size>
void	string(uint8_t idx, char(& string)[size], enum language language=language::standard)
	the string descriptor of the index as UTF-8 into string, as the kernel reads it
std::string	string(uint8_t idx, enum language language=language::standard)
std::string	string(uint8_t) const
device&	submit(const request<data_t>& request)
	standard device request
bool	try_conclude() noexcept
	atomically conclude()s if currently launched; returns whether this call did it
bool	try_conclude() noexcept
	atomically conclude()s if currently launched; returns whether this call did it
bool	try_conclude() noexcept
	atomically conclude()s if currently launched; returns whether this call did it
bool	try_launch()
	atomically launch()es if not already launched; returns whether this call did it. A launch() that throws is concluded before the exception leaves: the object never claims a launch it did not finish
bool	try_launch()
	atomically launch()es if not already launched; returns whether this call did it. A launch() that throws is concluded before the exception leaves: the object never claims a launch it did not finish
bool	try_launch()
	atomically launch()es if not already launched; returns whether this call did it. A launch() that throws is concluded before the exception leaves: the object never claims a launch it did not finish
type	type() const noexcept
const device&	unmap(uint32_t typetype, rx_t* rx) const
void	wake() override

Static Public Member Functions
static void	assign(const self_t& self, const value_t& value)
static registry	at(const self_t& self)
static container_t	children(const self_t& self) noexcept
static void	create(const char* product_id, const ::GUID& guid, const std::string& id, const desc_t& desc)
	persisted software device: PnP keeps it enumerated after the creating handle closes
static void	destroy(const char* product_id, const ::GUID& guid, const std::string& id)
	re-acquires the persisted device and binds it to the closing handle; PnP keeps the removed device's node as a phantom, uninstalled here
static bool	fetch(const self_t& self, value_t& value)
static std::pair<std::string, std::string>	identity(::io_service_t id)
	the device class constructor
static bool	nested(const self_t& self) noexcept
static void	purge(const self_t& self) noexcept
static size_t	size(const self_t& self) noexcept

Public Attributes
struct	adc
uint16_t	bcdADC{}
dx::listen<std::function<void()>>	broadcast
	the driver's values mirrored here that listen: each reads itself back where it stands initialized
std::atomic<int64_t>	clock_locked{}
	dx::timestamp() from which the device's clock is locked to the sample rate last set (desc::clock::lock_delay): the transport charges its pipes no earlier, a session live across the change is re-charged then
promoted<uint32_t>::preference<decltype(super::preference)>	clocksource
promoted<typenamedesc_t::configuration>::template preference<decltype(super::preference)>	configuration
	the device's configuration: per stream the stream configuration it runs, the richest by default - a bus device narrows it to what its bus carries (align()), and it stands while a group is started
dx::driver<decltype(id), dx::preference>&	driver
dx::driver<decltype(id), dx::preference>&	driver
dx::driver<decltype(id), dx::preference>&	driver
std::map<decltype(desc_t::stream::group), group_t>	group
struct dx::stream::device:: { ... }	hw
promoted<std::string>::preference<decltype(super::preference)>	icon
const ::io_service_t	id
const ::io_service_t	id
const std::string	id
	interface
return	interface == end()? nullptr:& static_cast<const usb::interface&>(* interface)
class const dx::usb::interface&	interface{return interface.bInterfaceNumber== index
promoted<uint32_t>::preference<decltype(super::preference)>	iosize
std::string	key
std::atomic<bool>	launched
std::atomic<bool>	launched
std::atomic<bool>	launched
std::deque<std::function<void()>>	listen
event	listener
	this client's listener on the driver's values: every change it signals reads them back
dx::stream::device::monitor	monitor
dx::preference	preference
dx::preference	preference
dx::preference	preference
std::string	puid
	persistent UID - system unique - could change with location
std::string	puid
	persistent UID - system unique - could change with location
std::string	puid
	persistent UID - system unique - could change with location
std::string	puuid
	persistent universal UID - universally unique ID (i.e. serial number)
std::string	puuid
	persistent universal UID - universally unique ID (i.e. serial number)
std::string	puuid
	persistent universal UID - universally unique ID (i.e. serial number)
uint32_t	rated{}
promoted<uint32_t>::preference<decltype(super::preference)>	samplerate
bool	schedule_erase
std::map<decltype(desc_t::stream::target.idx()), source_t>	sources
enum speed	speed
promoted<structdesc_t::stream *>::template preference<decltype(super::preference), uint32_t>	sync_reference
dx::stream::device::monitor	version

Static Public Attributes
static constexpr auto	device_class
	the IOProviderClass a USB bus enumerates
static constexpr bool	hosted
	the transport's settings belong to another process' device: a hosted device mirrors them through its chains, it keeps no store of them

Protected Member Functions
std::string	canonical(const std::string& name) const
virtual void	grouped(group_t &)
	operator[](): a group just came into existence, a host wires its per-group transports here
void	initialize(::IOCFPlugInInterface** cf_interface, ::CFUUIDRef uuid)
registry&	initialize(const std::string& key, ::REGSAM rights, ::HKEY root, const char* path= nullptr)

Protected Attributes
bool	connected
std::unique_ptr<uint8_t[]>	descriptors
	the selected configuration's complete descriptor, wTotalLength bytes
::HANDLE	handle
struct dx::registry::device:: { ... }	kernel
std::atomic<int>	opened
io::port	port
::HANDLE	process
decltype(super::samplerate) ::chain	samplerate_server
struct dx::usb::platform::device:: { ... }	winusb

Detailed Description

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>
class dx::usb::stream::_device< desc_t, preference_t, stream_t, group_t >

a USB device that streams: the stream device's settings wired to the class requests of the device (the rate to the endpoints stating the sampling frequency control, the clock source and the channel source to their units), its streams the pipes below

Member Typedef Documentation

◆ desc_t

typedef desc_t dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::desc_t

inherited

◆ event_t

typedef event dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::event_t

inherited

◆ keys

typedef std::set<std::string> dx::registry::keys

inherited

◆ source_t

typedef promoted<uint32_t>::template preference<decltype(super_device_t::preference)> dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::source_t

inherited

◆ stream_t

typedef stream_t dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::stream_t

inherited

◆ super_device_t

typedef usb::device<preference_t> dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::super_device_t

inherited

the device this streaming device sits on: its own operations of a name this class takes for itself (a USB device's configuration()) are reached through it

Member Enumeration Documentation

◆ type

enum dx::registry::type : ::DWORD

stronginherited

the value types this store keeps - a scalar rides as REG_DWORD/REG_QWORD rather than as a byte copy, so a value written here reads like any other in the registry editor

Constructor & Destructor Documentation

◆ _device()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::_device(decltype(super::driver)& driver, decltype(super::id)& id, const std::pair<std::string, std::string>& identity= {})

inline

Member Function Documentation

◆ align()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

desc_t::configuration dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::align(const typename desc_t::configuration& value, const typename desc_t::configuration& current)

inlineoverridevirtual

the configuration the device's bus carries: its USB configuration, per stream what the rate and the periodic budget leave (usb::align) - the rate as it stands, never asked from inside its own server

Reimplemented from dx::stream::device< usb::device< preference_t >, desc_t, stream_t, group_t >.

◆ assign()

void dx::registry::assign(const self_t& self, const value_t& value)

inlinestaticinherited

◆ at() [1/3]

template<typename preference_t= dx::preference>

usb::interface& dx::usb::device<preference_t>::at(const usb::endpoint& endpoint)

inlineinherited

the interface one of whose settings carries the endpoint: an endpoint address belongs to one interface of a configuration

◆ at() [2/3]

template<typename preference_t= dx::preference>

usb::interface& dx::usb::device<preference_t>::at(uint8_t number)

inlineinherited

the interface of that number - a list position is no interface number: a device may number them sparsely, and one whose exclusive owner refused it never entered the list

Here is the call graph for this function:

◆ at() [3/3]

registry dx::registry::at(const self_t& self)

inlinestaticinherited

dx::key_value_tree<registry> contract: resolves self's parent chain into one real key/value position, then delegates below - the only place a registry[k1][k2]..[kN] chain becomes real subkeys/values.

◆ attach()

void dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::attach(void** io[dx::stream::direction::directions][2], const std::vector<bool>(&) channel_map[2], const dx::stream::format(&) format[2])

inlineinherited

the consumer's planar channel buffers in the format each direction's buffers carry

◆ budget() [1/2]

template<typename preference_t= dx::preference>

uint64_t dx::usb::device<preference_t>::budget() const

inlineinherited

the periodic bus time a (micro) frame offers the device's isochronous endpoints, in ns: 90% of a full speed frame, 80% of a high speed micro frame, no bound above

◆ budget() [2/2]

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

uint64_t dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::budget(const typename desc_t::configuration& value)

inlineoverridevirtual

the periodic bus time the configuration takes, in ns: to hold against budget(), what the bus offers

Reimplemented from dx::stream::device< usb::device< preference_t >, desc_t, stream_t, group_t >.

◆ canonical()

std::string dx::registry::canonical(const std::string& name) const

inlineprotectedinherited

◆ catch() [1/2]

dx::registry::catch(...)

inlineinherited

◆ catch() [2/2]

dx::registry::catch(...)

inlineinherited

◆ children()

container_t dx::registry::children(const self_t& self)

inlinestaticnoexceptinherited

self's own child names as any string container, yielding an empty one when the key is absent or inaccessible. Stays a static, not a dx::key_value_tree-style operator container_t(): registry is a dependent base of key_value_tree<registry> (inherited via the tree_t template parameter), and key_value_tree's own operator value_t() becomes entirely unreachable once a dependent base declares a same-shaped operator container_t() template of its own.

◆ clear()

device& dx::usb::platform::device<dx::preference>::clear()

inlineinherited

◆ close()

device& dx::usb::platform::device<dx::preference>::close(bool force= false)

inlinenoexceptinherited

◆ conclude()

void dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::conclude()

inlineoverridevirtualnoexceptinherited

ends every group's session before the device's resources go; the start counts stay with their holders

Reimplemented from dx::object.

◆ configuration() [1/2]

template<typename preference_t= dx::preference>

uint8_t dx::usb::platform::device<preference_t>::configuration() const

inlineinherited

◆ configuration() [2/2]

template<typename preference_t= dx::preference>

uint8_t dx::usb::device<preference_t>::configuration(uint8_t configuration)

inlineoverridevirtualinherited

the interface tree across a configuration change: dropped ahead of it, enumerated again once the device carries the new configuration

Reimplemented from dx::usb::platform::device< dx::preference >.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ configurations()

uint8_t dx::usb::platform::device<dx::preference>::configurations() const

inlineinherited

◆ configure()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

virtual void dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::configure()

inlinevirtual

a desc without streams takes them from the configuration's audio class descriptors

◆ count() [1/2]

auto io::reference<::io_registry_entry_t>::count() const

inlinenoexceptinherited

◆ count() [2/2]

auto io::reference<::io_registry_entry_t>::count() const

inlinenoexceptinherited

◆ create()

void dx::proxy::device<dx::preference>::create(const char* product_id, const ::GUID& guid, const std::string& id, const desc_t& desc)

inlinestaticinherited

persisted software device: PnP keeps it enumerated after the creating handle closes

◆ ctl()

void dx::proxy::device<dx::preference>::ctl(uint32_t ioctl) const

inlineinherited

◆ destroy()

void dx::proxy::device<dx::preference>::destroy(const char* product_id, const ::GUID& guid, const std::string& id)

inlinestaticinherited

re-acquires the persisted device and binds it to the closing handle; PnP keeps the removed device's node as a phantom, uninstalled here

◆ end()

template<typename preference_t= dx::preference>

class dx::usb::device<preference_t>::end()

inherited

Here is the caller graph for this function:

◆ erase()

registry& dx::registry::erase(const char* subkey= nullptr)

inlinenoexceptinherited

◆ exception()

template<typename preference_t= dx::preference>

void dx::usb::device<preference_t>::exception(const dx::exception& exception, bool filtered= false) const

inlineoverridevirtualnoexceptinherited

notification exception handler

Reimplemented from dx::device<::io_service_t, dx::preference >.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fetch()

bool dx::registry::fetch(const self_t& self, value_t& value)

inlinestaticinherited

a value that serializes itself into a tree node recurses through its own named children; only what has no such serialization reaches the flat position below, where a struct would become one opaque REG_BINARY of its layout

◆ frame()

uint64_t dx::usb::platform::device<dx::preference>::frame(int64_t* timestamp= nullptr) const

inlineinherited

current bus frame number; timestamp: dx::timestamp() of the readout

◆ free()

virtual void dx::resource<invalid_t>::free()

inlinevirtualnoexceptinherited

◆ get() [1/13]

value_t dx::registry::get() const

inlineinherited

stays a named method: base and derived conversion function templates are simultaneous overload candidates, so an operator value_t() here would compete with dx::key_value_tree's own.

◆ get() [2/13]

value_t io::registry::get(::CFStringRef key) const

inlineinherited

◆ get() [3/13]

::CFTypeRef io::registry::get(::CFStringRef key) const

inlineinherited

◆ get() [4/13]

::CFTypeRef io::registry::get(::CFStringRef key) const

inlineinherited

◆ get() [5/13]

value_t io::registry::get(::CFStringRef key, ::CFTypeRef dflt) const

inlinenoexceptinherited

◆ get() [6/13]

::CFTypeRef io::registry::get(::CFStringRef key, ::CFTypeRef dflt) const

inlinenoexceptinherited

◆ get() [7/13]

::CFTypeRef io::registry::get(::CFStringRef key, ::CFTypeRef dflt) const

inlinenoexceptinherited

◆ get() [8/13]

value_t io::registry::get(::CFStringRef key, value_t dflt) const

inlinenoexceptinherited

◆ get() [9/13]

value_t io::registry::get(::CFStringRef key, value_t dflt) const

inlinenoexceptinherited

◆ get() [10/13]

value_t io::registry::get(key_t key) const

inlineinherited

◆ get() [11/13]

::CFTypeRef io::registry::get(key_t key) const

inlineinherited

◆ get() [12/13]

::CFTypeRef io::registry::get(key_t key) const

inlineinherited

◆ get() [13/13]

bool dx::registry::get(value_t& value) const

inlineinherited

like get<value_t>() but returns false for ERROR_FILE_NOT_FOUND, from either RegQueryValueExA or value_of() itself; any other failure throws.

◆ grouped()

virtual void dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::grouped(group_t&)

inlineprotectedvirtualinherited

operator[](): a group just came into existence, a host wires its per-group transports here

◆ hw_clock() [1/2]

virtual bool dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::hw_clock() const

inlinevirtualnoexceptinherited

◆ hw_clock() [2/2]

virtual void dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::hw_clock(abstract::event* hw_clock, uint32_t iosize)

inlinevirtualinherited

registers a consumer with the device's clock: it is signalled every iosize samples of the clock's own advance. A bus whose driver owns the clock hands the registration on instead

◆ ictl() [1/2]

hide_if_scalar_or_ptr<rx_t> dx::proxy::device<dx::preference>::ictl(uint32_t ioctl) const

inlineinherited

member ioctl

this member retreives data from the device by providing an IOCTL code. the template argument defines the type of data to be retreived. this member is intended as a convinient way to retreive only small amounts of data since there is an intermediate stack copy involved in returning the data.

◆ ictl() [2/2]

size_t dx::file::ictl(unsigned int ioctl, rx_t& rx) const

inlineinherited

◆ identity()

std::pair<std::string, std::string> dx::usb::platform::device<dx::preference>::identity(::io_service_t id)

inlinestaticinherited

the device class constructor

Exceptions

kIOReturn NoMemory means that the system couldn't allocate the class defined in the drivers plist, or nub which ever its trying connecting to

the registry holds the device's string descriptors before anyone opens it: vendor, product and serial name the device, the path locates it; without a serial the path stands for both

Here is the caller graph for this function:

◆ initialize() [1/6]

registry& dx::registry::initialize(::HKEY root, ::REGSAM rights= KEY_ALL_ACCESS)

inlineinherited

◆ initialize() [2/6]

void cf::interface<::IOUSBDeviceInterface650>::initialize(::IOCFPlugInInterface** cf_interface, ::CFUUIDRef uuid)

inlineprotectedinherited

◆ initialize() [3/6]

registry& dx::registry::initialize(::REGSAM rights= KEY_ALL_ACCESS, ::HKEY root= HKEY_CURRENT_USER)

inlineinherited

◆ initialize() [4/6]

void dx::file::initialize(const char* name, ::DWORD access= GENERIC_READ| GENERIC_WRITE, ::DWORD share= FILE_SHARE_READ| FILE_SHARE_WRITE)

inlineinherited

(re-)initialization the underlaying windows API is CreateFile(). for detailed information see http://msdn.microsoft.com/en-us/library/aa363858(VS.85).aspx

Exceptions

n/a	microsoft does not give information about what possible errors values are provided by its OS

◆ initialize() [5/6]

registry& dx::registry::initialize(const std::string& key, ::HKEY root= HKEY_CURRENT_USER, ::REGSAM rights= KEY_ALL_ACCESS)

inlineinherited

◆ initialize() [6/6]

registry& dx::registry::initialize(const std::string& key, ::REGSAM rights, ::HKEY root, const char* path= nullptr)

inlineprotectedinherited

◆ ioctl() [1/2]

size_t dx::proxy::device<dx::preference>::ioctl(uint32_t ioctl, const tx_t& tx, rx_t& rx) const

inlineinherited

◆ ioctl() [2/2]

rx_t dx::file::ioctl(unsigned int ioctl, const tx_t& tx) const

inlineinherited

◆ launch()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

void dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::launch()

inlineoverridevirtual

launch notification: object mounted and ready to use. Called only through try_launch() - never call this directly from outside the class hierarchy.

Reimplemented from dx::object.

◆ map()

rx_t* dx::proxy::device<dx::preference>::map(uint32_t type) const

inlineinherited

maps the memory the given type names into this client

DriverKit maps into the dext, never into its client: what a WDM driver hands back as a pointer is fetched here, with the type the driver answers in IOUserClient::CopyClientMemoryForType().

◆ nested()

bool dx::registry::nested(const self_t& self)

inlinestaticnoexceptinherited

◆ octl() [1/2]

device& dx::proxy::device<dx::preference>::octl(uint32_t ioctl, const tx_t& tx)

inlineinherited

◆ octl() [2/2]

void dx::file::octl(unsigned int ioctl, const tx_t& tx) const

inlineinherited

◆ open() [1/2]

std::shared_ptr<stream_t> dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::open(const typename desc_t::stream::desc& desc, bool client= false)

inlineinherited

the desc's stream: the registered one, else created, registered and launched - a host's client takes a data driven stream alone, its ring has one writer and one reader

◆ open() [2/2]

device& dx::usb::platform::device<dx::preference>::open()

inlineinherited

opens the USB device for exclusice access

Here is the caller graph for this function:

◆ operator const ::io_registry_entry_t &() [1/3]

io::reference<::io_registry_entry_t>::operator const ::io_registry_entry_t&() const

inlinenoexceptinherited

auto converter into const io_object

◆ operator const ::io_registry_entry_t &() [2/3]

io::reference<::io_registry_entry_t>::operator const ::io_registry_entry_t&() const

inlinenoexceptinherited

auto converter into const io_object

◆ operator const ::io_registry_entry_t &() [3/3]

io::reference<::io_registry_entry_t>::operator const ::io_registry_entry_t&() const

inlinenoexceptinherited

auto converter into const io_object

◆ operator const os_event()

dx::resource<invalid_t>::operator const os_event() const

inlinenoexceptinherited

◆ operator const std::string &()

dx::proxy::device<dx::preference>::operator const std::string&() const

inlinenoexceptinherited

identifying device string, mirroring macOS' io::registry conversion

◆ operator os_event()

dx::resource<invalid_t>::operator os_event()

inlinenoexceptinherited

◆ operator uint64_t() [1/2]

io::registry::operator uint64_t() const

inlineexplicitinherited

◆ operator uint64_t() [2/2]

io::registry::operator uint64_t() const

inlineexplicitinherited

◆ operator ()()

const struct desc_t::stream::config& dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::operator ()(const struct desc_t::stream& stream)

inlineinherited

the stream configuration the device runs the stream in: the stream is one of the desc's

◆ operator ->()

::IOUSBDeviceInterface650* cf::interface<::IOUSBDeviceInterface650>::operator ->() const

inlineinherited

◆ operator ::CFMutableDictionaryRef() [1/2]

io::registry::operator ::CFMutableDictionaryRef() const

inlineexplicitinherited

◆ operator ::CFMutableDictionaryRef() [2/2]

io::registry::operator ::CFMutableDictionaryRef() const

inlineexplicitinherited

◆ operator ::CFStringRef() [1/2]

io::registry::operator ::CFStringRef() const

inlineexplicitinherited

◆ operator ::CFStringRef() [2/2]

io::registry::operator ::CFStringRef() const

inlineexplicitinherited

◆ operator ::HANDLE()

dx::resource<invalid_t>::operator ::HANDLE() const

inlinenoexceptinherited

◆ operator ::HKEY()

dx::registry::operator ::HKEY() const

inlinenoexceptinherited

◆ operator ::io_registry_entry_t &() [1/3]

io::reference<::io_registry_entry_t>::operator ::io_registry_entry_t&()

inlinenoexceptinherited

auto converter into io_object

◆ operator ::io_registry_entry_t &() [2/3]

io::reference<::io_registry_entry_t>::operator ::io_registry_entry_t&()

inlinenoexceptinherited

auto converter into io_object

◆ operator ::io_registry_entry_t &() [3/3]

io::reference<::io_registry_entry_t>::operator ::io_registry_entry_t&()

inlinenoexceptinherited

auto converter into io_object

◆ operator ::io_registry_entry_t *() [1/3]

io::reference<::io_registry_entry_t>::operator ::io_registry_entry_t*()

inlinenoexceptinherited

auto converter into io_object pointer

◆ operator ::io_registry_entry_t *() [2/3]

io::reference<::io_registry_entry_t>::operator ::io_registry_entry_t*()

inlinenoexceptinherited

auto converter into io_object pointer

◆ operator ::io_registry_entry_t *() [3/3]

io::reference<::io_registry_entry_t>::operator ::io_registry_entry_t*()

inlinenoexceptinherited

auto converter into io_object pointer

◆ operator ::IOUSBDeviceInterface650 **()

cf::interface<::IOUSBDeviceInterface650>::operator ::IOUSBDeviceInterface650**() const

inlineinherited

◆ operator ==() [1/2]

bool io::reference<::io_registry_entry_t>::operator ==(::io_registry_entry_t io_object) const

inlinenoexceptinherited

◆ operator ==() [2/2]

bool io::reference<::io_registry_entry_t>::operator ==(::io_registry_entry_t io_object) const

inlinenoexceptinherited

◆ operator >>() [1/3]

virtual device& dx::device<::io_service_t, dx::preference>::operator >>(std::ostream&) const

inlinevirtualinherited

the device's own diagnostics, beyond its operator <<

◆ operator >>() [2/3]

virtual device& dx::device<::io_service_t, dx::preference>::operator >>(std::ostream&) const

inlinevirtualinherited

the device's own diagnostics, beyond its operator <<

◆ operator >>() [3/3]

virtual device& dx::device<std::string, dx::preference>::operator >>(std::ostream&) const

inlinevirtualinherited

the device's own diagnostics, beyond its operator <<

◆ operator []() [1/4]

group_t& dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::operator [](const typename desc_t::stream::desc& stream)

inlineinherited

the stream's group, created on first use

◆ operator []() [2/4]

template<typename preference_t= dx::preference>

usb::interface* dx::usb::device<preference_t>::operator [](const usb::endpoint& endpoint)

inlineinherited

the interface one of whose settings carries the endpoint, nullptr where none of this device node does

Here is the call graph for this function:

◆ operator []() [3/4]

::CFTypeRef io::registry::operator [](::CFStringRef key) const

inlineinherited

◆ operator []() [4/4]

::CFTypeRef io::registry::operator [](key_t key) const

inlineinherited

◆ parent() [1/2]

registry io::registry::parent() const

inlineinherited

◆ parent() [2/2]

registry io::registry::parent() const

inlineinherited

◆ purge()

void dx::registry::purge(const self_t& self)

inlinestaticnoexceptinherited

◆ rate()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

os_result dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::rate(const struct desc_t::stream& stream, uint32_t& rate, bool set)

inlinenoexcept

the sampling frequency request to a stream's endpoint over the interface owning it, in the alternate setting its session's charge selected - the endpoint exists there alone: sets the rate, or reads it

◆ reenumerate()

device& dx::usb::platform::device<dx::preference>::reenumerate()

inlineinherited

◆ reset()

device& dx::usb::platform::device<dx::preference>::reset()

inlineinherited

◆ retain() [1/2]

reference& io::reference<::io_registry_entry_t>::retain()

inlineinherited

◆ retain() [2/2]

reference& io::reference<::io_registry_entry_t>::retain()

inlineinherited

◆ run()

registry& dx::registry::run()

inlineinherited

◆ set() [1/11]

registry& io::registry::set(::CFStringRef key, ::CFTypeRef value)

inlineinherited

◆ set() [2/11]

registry& io::registry::set(::CFStringRef key, ::CFTypeRef value)

inlineinherited

◆ set() [3/11]

registry& io::registry::set(::CFStringRef key, value_t value)

inlineinherited

◆ set() [4/11]

registry& io::registry::set(::CFStringRef key, value_t value)

inlineinherited

◆ set() [5/11]

registry& io::registry::set(::CFTypeRef properties)

inlineinherited

Setting properties in a registry entry is not generally supported, it is more common to support setting of properties of the connection based property setting of dx::device.

◆ set() [6/11]

device& dx::proxy::device<dx::preference>::set(::CFTypeRef properties)

inlineinherited

Setting properties in a registry entry is not generally supported, it is more common to support setting of properties of the connection based property setting of dx::device.

◆ set() [7/11]

registry& dx::registry::set(::DWORD type, const void* value, size_t size)

inlineinherited

a sibling thread/process may delete the containing key between value_of()'s create and the set - retry recreates the whole chain in that case

◆ set() [8/11]

registry& io::registry::set(key_t key, ::CFTypeRef value)

inlineinherited

◆ set() [9/11]

registry& io::registry::set(key_t key, ::CFTypeRef value)

inlineinherited

◆ set() [10/11]

registry& io::registry::set(key_t key, value_t value)

inlineinherited

◆ set() [11/11]

registry& io::registry::set(key_t key, value_t value)

inlineinherited

◆ setting()

void dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::setting(dx::stream::setting setting, uint32_t index, f_t&& f)

inlineinherited

the setting a host keeps for its clients handed to f as its promoted: the transport settings the sync reference's group's, the source the one of the stream whose target index is index

◆ size() [1/2]

size_t dx::registry::size() const

inlinenoexceptinherited

subkey+value count, 0 if the key doesn't exist (key_of()'s non-throwing overload - an ordinary, expected outcome here, not a genuine error).

Here is the caller graph for this function:

◆ size() [2/2]

size_t dx::registry::size(const self_t& self)

inlinestaticnoexceptinherited

◆ sleep() [1/3]

virtual void dx::device<::io_service_t, dx::preference>::sleep()

inlinevirtualinherited

notify system will sleep stub

◆ sleep() [2/3]

virtual void dx::device<::io_service_t, dx::preference>::sleep()

inlinevirtualinherited

notify system will sleep stub

◆ sleep() [3/3]

virtual void dx::device<std::string, dx::preference>::sleep()

inlinevirtualinherited

notify system will sleep stub

◆ source()

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

std::pair<typename super::source_t &, bool> dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::source(const struct desc_t::stream& stream)

inlineoverridevirtual

a stream's source selector is the selector unit's input pin, read/written/read back; its class request wraps the preference's own server

Reimplemented from dx::stream::device< usb::device< preference_t >, desc_t, stream_t, group_t >.

◆ status()

os_result dx::usb::platform::device<dx::preference>::status() const

inlinenoexceptinherited

◆ string() [1/3]

template<typename preference_t= dx::preference>

template<size_t size>

void dx::usb::device<preference_t>::string(uint8_t idx, char(&) string[size], enum language language= language::standard)

inlineinherited

the string descriptor of the index as UTF-8 into string, as the kernel reads it

Here is the call graph for this function:

Here is the caller graph for this function:

◆ string() [2/3]

template<typename preference_t= dx::preference>

std::string dx::usb::device<preference_t>::string(uint8_t idx, enum language language= language::standard)

inlineinherited

Here is the call graph for this function:

◆ string() [3/3]

std::string dx::proxy::device<dx::preference>::string(uint8_t) const

inlineinherited

◆ submit()

device& dx::usb::platform::device<dx::preference>::submit(const request<data_t>& request)

inlineinherited

standard device request

Here is the caller graph for this function:

◆ try_conclude() [1/3]

bool dx::object::try_conclude()

inlinenoexceptinherited

atomically conclude()s if currently launched; returns whether this call did it

◆ try_conclude() [2/3]

bool dx::object::try_conclude()

inlinenoexceptinherited

atomically conclude()s if currently launched; returns whether this call did it

◆ try_conclude() [3/3]

bool dx::object::try_conclude()

inlinenoexceptinherited

atomically conclude()s if currently launched; returns whether this call did it

◆ try_launch() [1/3]

bool dx::object::try_launch()

inlineinherited

atomically launch()es if not already launched; returns whether this call did it. A launch() that throws is concluded before the exception leaves: the object never claims a launch it did not finish

◆ try_launch() [2/3]

bool dx::object::try_launch()

inlineinherited

atomically launch()es if not already launched; returns whether this call did it. A launch() that throws is concluded before the exception leaves: the object never claims a launch it did not finish

◆ try_launch() [3/3]

bool dx::object::try_launch()

inlineinherited

atomically launch()es if not already launched; returns whether this call did it. A launch() that throws is concluded before the exception leaves: the object never claims a launch it did not finish

◆ type()

type dx::registry::type() const

inlinenoexceptinherited

◆ unmap()

const device& dx::proxy::device<dx::preference>::unmap(uint32_t type, rx_t* rx) const

inlineinherited

◆ wake()

void dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::wake()

inlineoverridevirtualinherited

Reimplemented from dx::device<::io_service_t, dx::preference >.

Member Data Documentation

◆ adc

struct dx::usb::stream::_device::[struct].adc dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::adc

◆ bcdADC

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

uint16_t dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::bcdADC{}

◆ broadcast

dx::listen<std::function<void()>> dx::proxy::device<dx::preference>::broadcast

inherited

the driver's values mirrored here that listen: each reads itself back where it stands initialized

◆ clock_locked

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

std::atomic<int64_t> dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::clock_locked{}

dx::timestamp() from which the device's clock is locked to the sample rate last set (desc::clock::lock_delay): the transport charges its pipes no earlier, a session live across the change is re-charged then

◆ clocksource

promoted<uint32_t>::preference<decltype(super::preference)> dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::clocksource

inherited

◆ configuration

promoted<typenamedesc_t::configuration>::template preference<decltype(super::preference)> dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::configuration

inherited

the device's configuration: per stream the stream configuration it runs, the richest by default - a bus device narrows it to what its bus carries (align()), and it stands while a group is started

◆ connected

bool dx::proxy::device<dx::preference>::connected

protectedinherited

◆ descriptors

template<typename preference_t= dx::preference>

std::unique_ptr<uint8_t[]> dx::usb::device<preference_t>::descriptors

protectedinherited

the selected configuration's complete descriptor, wTotalLength bytes

◆ device_class

auto dx::usb::platform::device<dx::preference>::device_class

staticconstexprinherited

the IOProviderClass a USB bus enumerates

◆ driver [1/3]

dx::driver<decltype(id), dx::preference>& dx::device<::io_service_t, dx::preference>::driver

inherited

◆ driver [2/3]

dx::driver<decltype(id), dx::preference>& dx::device<::io_service_t, dx::preference>::driver

inherited

◆ driver [3/3]

dx::driver<decltype(id), dx::preference>& dx::device<std::string, dx::preference>::driver

inherited

◆ group

std::map<decltype(desc_t::stream::group), group_t> dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::group

inherited

streaming groups by desc::stream::group id: every stream of this device is registered with its group - behind the settings its groups listen to, so they go first

◆ handle

::HANDLE dx::resource<invalid_t>::handle

protectedinherited

◆ hosted

bool dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::hosted

staticconstexprinherited

the transport's settings belong to another process' device: a hosted device mirrors them through its chains, it keeps no store of them

◆ hw

struct { ... } dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::hw

◆ icon

promoted<std::string>::preference<decltype(super::preference)> dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::icon

inherited

◆ id [1/3]

const ::io_service_t dx::device<::io_service_t, dx::preference>::id

inherited

◆ id [2/3]

const ::io_service_t dx::device<::io_service_t, dx::preference>::id

inherited

◆ id [3/3]

const std::string dx::device<std::string, dx::preference>::id

inherited

◆ interface [1/3]

template<typename preference_t= dx::preference>

dx::usb::device<preference_t>::interface

inherited

◆ interface [2/3]

template<typename preference_t= dx::preference>

return dx::usb::device<preference_t>::interface == end()? nullptr: &static_cast<const usb::interface&>(*interface)

inherited

◆ interface [3/3]

template<typename preference_t= dx::preference>

class const dx::usb::interface& dx::usb::device<preference_t>::interface{return interface.bInterfaceNumber== index

inherited

◆ iosize

promoted<uint32_t>::preference<decltype(super::preference)> dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::iosize

inherited

◆ kernel

struct { ... } dx::registry::device<dx::preference>::kernel

◆ key

std::string dx::registry::key

inherited

◆ launched [1/3]

std::atomic<bool> dx::object::launched

inherited

◆ launched [2/3]

std::atomic<bool> dx::object::launched

inherited

◆ launched [3/3]

std::atomic<bool> dx::object::launched

inherited

◆ listen

std::deque<std::function<void()>> dx::registry::listen

inherited

◆ listener

event dx::proxy::device<dx::preference>::listener

inherited

this client's listener on the driver's values: every change it signals reads them back

◆ monitor

dx::stream::device::monitor dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::monitor

inherited

◆ opened

std::atomic<int> dx::usb::platform::device<dx::preference>::opened

protectedinherited

Todo: add runloop ////////////////////////////////////////////////////////////////////////////

◆ port

io::port dx::proxy::device<dx::preference>::port

protectedinherited

◆ preference [1/3]

dx::preference dx::device<::io_service_t, dx::preference>::preference

inherited

◆ preference [2/3]

dx::preference dx::device<::io_service_t, dx::preference>::preference

inherited

◆ preference [3/3]

dx::preference dx::device<std::string, dx::preference>::preference

inherited

◆ process

::HANDLE dx::resource<invalid_t>::process

protectedinherited

◆ puid [1/3]

std::string dx::device<::io_service_t, dx::preference>::puid

inherited

persistent UID - system unique - could change with location

◆ puid [2/3]

std::string dx::device<::io_service_t, dx::preference>::puid

inherited

persistent UID - system unique - could change with location

◆ puid [3/3]

std::string dx::device<std::string, dx::preference>::puid

inherited

persistent UID - system unique - could change with location

◆ puuid [1/3]

std::string dx::device<::io_service_t, dx::preference>::puuid

inherited

persistent universal UID - universally unique ID (i.e. serial number)

◆ puuid [2/3]

std::string dx::device<::io_service_t, dx::preference>::puuid

inherited

persistent universal UID - universally unique ID (i.e. serial number)

◆ puuid [3/3]

std::string dx::device<std::string, dx::preference>::puuid

inherited

persistent universal UID - universally unique ID (i.e. serial number)

◆ rated

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

uint32_t dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::rated{}

the streams whose endpoints take the sampling frequency control, a bit each (usb::audio::rated)

◆ samplerate

promoted<uint32_t>::preference<decltype(super::preference)> dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::samplerate

inherited

◆ samplerate_server

template<typename desc_t, typename preference_t, typename stream_t, typename group_t>

decltype(super::samplerate) ::chain dx::usb::stream::_device<desc_t, preference_t, stream_t, group_t>::samplerate_server

protected

◆ schedule_erase

bool dx::registry::schedule_erase

inherited

◆ sources

std::map<decltype(desc_t::stream::target.idx()), source_t> dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::sources

inherited

source selectors by stream target: a stream with sources gets its own on first use

◆ speed

enum speed dx::usb::platform::device<dx::preference>::speed

inherited

◆ sync_reference

promoted<structdesc_t::stream*>::template preference<decltype(super::preference), uint32_t> dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::sync_reference

inherited

◆ version

dx::stream::device::monitor dx::stream::device<usb::device<preference_t>, desc_t, stream_t, group_t>::version

inherited

◆ winusb

struct { ... } dx::usb::platform::device<dx::preference>::winusb

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

dx_usb_stream_device.h

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ desc_t

◆ event_t

◆ keys

◆ source_t

◆ stream_t

◆ super_device_t

Member Enumeration Documentation

◆ type

Constructor & Destructor Documentation

◆ _device()

Member Function Documentation

◆ align()

◆ assign()

◆ at() [1/3]

◆ at() [2/3]

◆ at() [3/3]

◆ attach()

◆ budget() [1/2]

◆ budget() [2/2]

◆ canonical()

◆ catch() [1/2]

◆ catch() [2/2]

◆ children()

◆ clear()

◆ close()

◆ conclude()

◆ configuration() [1/2]

◆ configuration() [2/2]

◆ configurations()

◆ configure()

◆ count() [1/2]

◆ count() [2/2]

◆ create()

◆ ctl()

◆ destroy()

◆ end()

◆ erase()

◆ exception()

◆ fetch()

◆ frame()

◆ free()

◆ get() [1/13]

◆ get() [2/13]

◆ get() [3/13]

◆ get() [4/13]

◆ get() [5/13]

◆ get() [6/13]

◆ get() [7/13]

◆ get() [8/13]

◆ get() [9/13]

◆ get() [10/13]

◆ get() [11/13]

◆ get() [12/13]

◆ get() [13/13]

◆ grouped()

◆ hw_clock() [1/2]

◆ hw_clock() [2/2]

◆ ictl() [1/2]

◆ ictl() [2/2]

◆ identity()

◆ initialize() [1/6]

◆ initialize() [2/6]

◆ initialize() [3/6]

◆ initialize() [4/6]

◆ initialize() [5/6]

◆ initialize() [6/6]

◆ ioctl() [1/2]

◆ ioctl() [2/2]

◆ launch()

◆ map()