Windows MIDI Services client device. More...

#include <dx_midi_services_device.h>

Inheritance diagram for dx::midi::services::device< desc_t, preference_t, stream_t >:

Collaboration diagram for dx::midi::services::device< desc_t, preference_t, stream_t >:

Public Types
typedef desc	desc_t
typedef event	event_t
typedef std::conditional_t<std::is_void_v<void>, dx::stream::group<device>, void>	group_t
	bus devices driving their groups' tick pass their own group type
typedef promoted<uint32_t>::template preference<decltype(super_device_t::preference)>	source_t
typedef dx::stream::control<dx::device<std::string, preference>>	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

Public Member Functions
virtual desc::configuration	align(const typename desc::configuration& value, const typename desc::configuration &)
	a configuration the device can run: every stream's index within its configurations, one past them the stream off - a bus device narrows it to what its bus carries, the streams value leaves as current has them standing
struct stream*	align(struct stream* sync_reference)
	the given stream where it may be the sync reference, else the first one that may - what a stored reference is aligned to when the desc changed under it
uint32_t	align(uint32_t sync_reference) const
virtual desc_t::configuration	align(const typename desc_t::configuration& value, const typename desc_t::configuration &)
	a configuration the device can run: every stream's index within its configurations, one past them the stream off - a bus device narrows it to what its bus carries, the streams value leaves as current has them standing
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
template<typename align_t, typename bind_t>
configuration	bound(configuration value, const configuration& current, align_t&& align, bind_t&& bind) const
virtual uint64_t	budget(const typename desc::configuration &)
	the periodic bus time the configuration takes, in ns - a bus device with a periodic budget states it
virtual uint64_t	budget(const typename desc_t::configuration &)
	the periodic bus time the configuration takes, in ns - a bus device with a periodic budget states it
void	conclude() noexcept override
	ends every group's session before the device's resources go; the start counts stay with their holders
	device(decltype(super::driver)& driver, decltype(super::id)& id)
	the desc is the driver's template: the driver that makes a device is this bus's
uint32_t	enumerate(const format& format= any) const
	enumerate typified pins
void	exception(const dx::exception& exception, bool filtered= false) const noexcept override
	notification exception handler
template<typename stream_t= struct stream>
stream_t*	find(const decltype(stream_t::target.idx())& target)
	by the target's index, where the target has one
struct stream*	find(const format& format= any, enum direction::direction direction= direction::any)
struct stream*	find(const target_t& target)
struct stream*	find(uint32_t& pin, const format& format= any, enum direction::direction direction= direction::any)
	finds and returns the stream description and pin idx into this stream
virtual uint64_t	frame() 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
std::shared_ptr<stream<device<desc, preference, stream>>>	open(const typename desc::stream::desc& descdesc, 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
std::shared_ptr<stream_t>	open(const typename desc::stream::desc& descdesc, 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
const struct desc::stream::config&	operator ()(const struct desc::stream& stream)
	the stream configuration the device runs the stream in: the stream is one of the desc's
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
virtual device&	operator >>(std::ostream &) const
	the device's own diagnostics, beyond its operator <<
group_t&	operator [](const typename desc::stream::desc& stream)
	the stream's group, created on first use
group_t&	operator [](const typename desc::stream::desc& stream)
	the stream's group, created on first use
template<typename align_t>
configuration	preferred(align_t&& align) const
_device&	reset()
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
virtual void	sleep()
	notify system will sleep stub
virtual std::pair<source_t &, bool>	source(const struct desc::stream& stream)
	the stream's source selector, created on first use: the preference by stream target, the value an index into the stream's sources
virtual std::pair<source_t &, bool>	source(const struct desc::stream& stream)
	the stream's source selector, created on first use: the preference by stream target, the value an index into the stream's sources
std::string	string(uint8_t)
uint32_t	sync_reference(struct stream* sync_reference)
struct stream*	sync_reference(uint32_t sync_reference)
	the n-th stream qualifying as sync reference, and the twin below the index of a given one - the two directions of the preference's value
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
void	updated(const enumeration::MidiEndpointDeviceInformationUpdatedEventArgs& args)
	what the watcher says changed at the endpoint: logged
void	wake() override

Public Attributes
dx::stream::bus::bus	bus{}
	the bus this device hangs on
struct dx::stream::desc::clock	clock [max_clocks]
uint32_t	clocks{}
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
bool	dflt{}
	can be selected as default (OS audio) device
dx::driver<decltype(id), preference>&	driver
bool	editable{}
	can be edited
struct dx::stream::desc::firmware	firmware
std::map<decltype(desc::stream::group), group_t>	group
bool	hidden{}
	hide device
struct dx::stream::device:: { ... }	hw
promoted<std::string>::preference<decltype(super::preference)>	icon
const std::string	id
enumeration::MidiEndpointDeviceInformation	information
promoted<uint32_t>::preference<decltype(super::preference)>	iosize
std::atomic<bool>	launched
struct dx::stream::desc::name_id	model
dx::stream::device::monitor	monitor
bool	persistence{}
	device has capability to store persistent settings (i.e. sample rate; clock source; etc.)
preference	preference
std::string	puid
	persistent UID - system unique - could change with location
std::string	puuid
	persistent universal UID - universally unique ID (i.e. serial number)
promoted<uint32_t>::preference<decltype(super::preference)>	samplerate
std::map<decltype(desc::stream::target.idx()), source_t>	sources
promoted<uint32_t>	start
direction::direction	start_stop_order{direction::any}
promoted<bool>	started
struct dx::stream::desc::stream	stream [max_streams]
uint32_t	streams{}
	number of streams
promoted<structdesc_t::stream *>::template preference<decltype(super::preference), uint32_t>	sync_reference
struct dx::stream::desc::name_id	vendor
dx::stream::device::monitor	version

Static Public Attributes
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
void	connect(stream<device<desc, preference, stream>>& stream)
	the session and the connection made by the first stream to run, the callback set ahead of Open()
void	disconnect(stream<device<desc, preference, stream>>& stream) noexcept
	the last stream to halt closes the connection
virtual void	grouped(group_t &)
	operator[](): a group just came into existence, a host wires its per-group transports here
virtual void	launch()
	launch notification: object mounted and ready to use. Called only through try_launch() - never call this directly from outside the class hierarchy.
void	release() noexcept
void	send(int64_t timestamp, uint32_t count, const uint32_t* words)
	whole packets to the endpoint, at the moment given - the service schedules them - or at once for 0

Protected Attributes
std::function<void()>	flush_hook
std::function<void()>	halt_hook
uint32_t	maximum
	words a transmission takes, read when the connection opens
std::function<void()>	run_hook

Detailed Description

template<typename desc_t = desc, typename preference_t = preference, template< typename ... > typename stream_t = stream>
class dx::midi::services::device< desc_t, preference_t, stream_t >

Windows MIDI Services client device.

Member Typedef Documentation

◆ desc_t

typedef desc dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::desc

inherited

◆ event_t

typedef event dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::event_t

inherited

◆ group_t

typedef std::conditional_t<std::is_void_v<void>, dx::stream::group<device>, void> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::group_t

inherited

bus devices driving their groups' tick pass their own group type

◆ source_t

typedef promoted<uint32_t>::template preference<decltype(super_device_t::preference)> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::source_t

inherited

◆ super_device_t

typedef dx::stream::control<dx::device<std::string, preference>> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::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

Constructor & Destructor Documentation

◆ device()

template<typename desc_t= desc, typename preference_t= preference, template<typename ...> typename stream_t= stream>

dx::midi::services::device<desc_t, preference_t, stream_t>::device(decltype(super::driver)& driver, decltype(super::id)& id)

inline

the desc is the driver's template: the driver that makes a device is this bus's

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

◆ align() [1/4]

virtual desc::configuration dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::align(const typename desc::configuration& value, const typename desc::configuration&)

inlinevirtualinherited

a configuration the device can run: every stream's index within its configurations, one past them the stream off - a bus device narrows it to what its bus carries, the streams value leaves as current has them standing

◆ align() [2/4]

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

struct stream* dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::align(struct stream* sync_reference)

inlineinherited

the given stream where it may be the sync reference, else the first one that may - what a stored reference is aligned to when the desc changed under it

◆ align() [3/4]

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

uint32_t dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::align(uint32_t sync_reference) const

inlineinherited

Here is the caller graph for this function:

◆ align() [4/4]

virtual desc_t::configuration dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::align(const typename desc_t::configuration& value, const typename desc_t::configuration&)

inlinevirtualinherited

a configuration the device can run: every stream's index within its configurations, one past them the stream off - a bus device narrows it to what its bus carries, the streams value leaves as current has them standing

◆ attach()

void dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::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

◆ bound()

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

template<typename align_t, typename bind_t>

configuration dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::bound(configuration value, const configuration& current, align_t&& align, bind_t&& bind) const

inlineinherited

the configuration align(value, current) answers for the wish that the streams carry: bind(idx, config) moves a stream to its aligned stream configuration, one it refuses stands as current has it and the wish is aligned around it again - the result is an answer of align

◆ budget() [1/2]

virtual uint64_t dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::budget(const typename desc::configuration&)

inlinevirtualinherited

the periodic bus time the configuration takes, in ns - a bus device with a periodic budget states it

◆ budget() [2/2]

virtual uint64_t dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::budget(const typename desc_t::configuration&)

inlinevirtualinherited

the periodic bus time the configuration takes, in ns - a bus device with a periodic budget states it

◆ conclude()

void dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::conclude()

inlineoverridenoexceptinherited

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

◆ connect()

void dx::midi::services::_device<desc, preference, stream<device<desc, preference, stream>>>::connect(stream<device<desc, preference, stream>>& stream)

inlineprotectedinherited

the session and the connection made by the first stream to run, the callback set ahead of Open()

◆ disconnect()

void dx::midi::services::_device<desc, preference, stream<device<desc, preference, stream>>>::disconnect(stream<device<desc, preference, stream>>& stream)

inlineprotectednoexceptinherited

the last stream to halt closes the connection

◆ enumerate()

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

uint32_t dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::enumerate(const format& format= any) const

inlineinherited

enumerate typified pins

◆ exception()

void dx::device<std::string, preference>::exception(const dx::exception& exception, bool filtered= false) const

inlineoverridevirtualnoexceptinherited

notification exception handler

Implements dx::object.

Reimplemented in dx::service::client::_device< desc, preference, stream< device< desc, preference, stream, group > >, group< device< desc, preference, stream, group > > >, and dx::wasapi::client::_device< desc, preference, stream< device< desc, preference, stream, group > >, group< device< desc, preference, stream, group > > >.

◆ find() [1/4]

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

template<typename stream_t= struct stream>

stream_t* dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::find(const decltype(stream_t::target.idx())& target)

inlineinherited

by the target's index, where the target has one

◆ find() [2/4]

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

struct stream* dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::find(const format& format= any, enum direction::direction direction= direction::any)

inlineinherited

Parameters

format	search stream format filter
direction	search stream direction filter

◆ find() [3/4]

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

struct stream* dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::find(const target_t& target)

inlineinherited

◆ find() [4/4]

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

struct stream* dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::find(uint32_t& pin, const format& format= any, enum direction::direction direction= direction::any)

inlineinherited

finds and returns the stream description and pin idx into this stream

Returns: stream description of indexed pin, pin idx will be altered on return!

Parameters

pin	in: global pin index, out: pin index into returned stream description
format	search stream format filter
direction	search stream direction filter

Here is the caller graph for this function:

◆ frame()

virtual uint64_t dx::midi::services::_device<desc, preference, stream<device<desc, preference, stream>>>::frame() const

inlinevirtualinherited

◆ grouped()

virtual void dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::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<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::hw_clock() const

inlinevirtualnoexceptinherited

◆ hw_clock() [2/2]

virtual void dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::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

◆ launch()

virtual void dx::object::launch()

inlineprotectedvirtualinherited

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

◆ open() [1/2]

std::shared_ptr<stream<device<desc, preference, stream>>> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::open(const typename desc::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]

std::shared_ptr<stream_t> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::open(const typename desc::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

◆ operator ()() [1/2]

const struct desc::stream::config& dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::operator ()(const struct desc::stream& stream)

inlineinherited

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

◆ operator ()() [2/2]

const struct desc_t::stream::config& dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::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 >>()

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

inlinevirtualinherited

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

◆ operator []() [1/2]

group_t& dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::operator [](const typename desc::stream::desc& stream)

inlineinherited

the stream's group, created on first use

◆ operator []() [2/2]

group_t& dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::operator [](const typename desc::stream::desc& stream)

inlineinherited

the stream's group, created on first use

◆ preferred()

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

template<typename align_t>

configuration dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::preferred(align_t&& align) const

inlineinherited

the richest configuration align admits (it returns the candidate as it stands): the largest sum of channels times bits over the streams that run, on a tie the richer stream configuration to the smaller stream index, then the more streams running - streams without channels (MIDI, raw) score nothing - every combination is tried

◆ release()

void dx::midi::services::_device<desc, preference, stream<device<desc, preference, stream>>>::release()

inlineprotectednoexceptinherited

◆ reset()

_device& dx::midi::services::_device<desc, preference, stream<device<desc, preference, stream>>>::reset()

inlineinherited

◆ send()

void dx::midi::services::_device<desc, preference, stream<device<desc, preference, stream>>>::send(int64_t timestamp, uint32_t count, const uint32_t* words)

inlineprotectedinherited

whole packets to the endpoint, at the moment given - the service schedules them - or at once for 0

◆ setting()

void dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::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

◆ sleep()

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

inlinevirtualinherited

notify system will sleep stub

◆ source() [1/2]

virtual std::pair<source_t &, bool> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::source(const struct desc::stream& stream)

inlinevirtualinherited

the stream's source selector, created on first use: the preference by stream target, the value an index into the stream's sources

◆ source() [2/2]

virtual std::pair<source_t &, bool> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::source(const struct desc::stream& stream)

inlinevirtualinherited

the stream's source selector, created on first use: the preference by stream target, the value an index into the stream's sources

◆ string()

std::string dx::midi::services::_device<desc, preference, stream<device<desc, preference, stream>>>::string(uint8_t)

inlineinherited

◆ sync_reference() [1/2]

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

uint32_t dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::sync_reference(struct stream* sync_reference)

inlineinherited

◆ sync_reference() [2/2]

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

struct stream* dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::sync_reference(uint32_t sync_reference)

inlineinherited

the n-th stream qualifying as sync reference, and the twin below the index of a given one - the two directions of the preference's value

Here is the caller graph for this function:

◆ try_conclude()

bool dx::object::try_conclude()

inlinenoexceptinherited

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

◆ try_launch()

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

◆ updated()

void dx::midi::services::_device<desc, preference, stream<device<desc, preference, stream>>>::updated(const enumeration::MidiEndpointDeviceInformationUpdatedEventArgs& args)

inlineinherited

what the watcher says changed at the endpoint: logged

◆ wake()

void dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::wake()

inlineoverrideinherited

Member Data Documentation

◆ bus

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

dx::stream::bus::bus dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::bus{}

inherited

the bus this device hangs on

◆ clock

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

struct dx::stream::desc::clock dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::clock[max_clocks]

inherited

◆ clocks

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

uint32_t dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::clocks{}

inherited

number of independent clocks [currenlty only single clock support]

◆ clocksource

promoted<uint32_t>::preference<decltype(super::preference)> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::clocksource

inherited

◆ configuration

promoted<typenamedesc_t::configuration>::template preference<decltype(super::preference)> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::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

◆ dflt

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

bool dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::dflt{}

inherited

can be selected as default (OS audio) device

◆ driver

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

inherited

◆ editable

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

bool dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::editable{}

inherited

can be edited

◆ firmware

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

struct dx::stream::desc::firmware dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::firmware

inherited

◆ flush_hook

std::function<void()> dx::stream::control<object_t>::flush_hook

protectedinherited

◆ group

std::map<decltype(desc::stream::group), group_t> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::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

◆ halt_hook

std::function<void()> dx::stream::control<object_t>::halt_hook

protectedinherited

◆ hidden

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

bool dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::hidden{}

inherited

hide device

◆ hosted

bool dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::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<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::hw

◆ icon

promoted<std::string>::preference<decltype(super::preference)> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::icon

inherited

◆ id

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

inherited

◆ information

enumeration::MidiEndpointDeviceInformation dx::midi::services::_device<desc, preference, stream<device<desc, preference, stream>>>::information

inherited

◆ iosize

promoted<uint32_t>::preference<decltype(super::preference)> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::iosize

inherited

◆ launched

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

inherited

◆ maximum

uint32_t dx::midi::services::_device<desc, preference, stream<device<desc, preference, stream>>>::maximum

protectedinherited

words a transmission takes, read when the connection opens

◆ model

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

struct dx::stream::desc::name_id dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::model

inherited

◆ monitor

dx::stream::device::monitor dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::monitor

inherited

◆ persistence

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

bool dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::persistence{}

inherited

device has capability to store persistent settings (i.e. sample rate; clock source; etc.)

◆ preference

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

inherited

◆ puid

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

inherited

persistent UID - system unique - could change with location

◆ puuid

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

inherited

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

◆ run_hook

std::function<void()> dx::stream::control<object_t>::run_hook

protectedinherited

◆ samplerate

promoted<uint32_t>::preference<decltype(super::preference)> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::samplerate

inherited

◆ sources

std::map<decltype(desc::stream::target.idx()), source_t> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::sources

inherited

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

◆ start

promoted<uint32_t> dx::stream::control<object_t>::start

inherited

◆ start_stop_order

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

direction::direction dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::start_stop_order{direction::any}

inherited

◆ started

promoted<bool> dx::stream::control<object_t>::started

inherited

◆ stream

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

struct dx::stream::desc::stream dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::stream[max_streams]

inherited

◆ streams

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

uint32_t dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::streams{}

inherited

number of streams

◆ sync_reference

promoted<structdesc_t::stream*>::template preference<decltype(super::preference), uint32_t> dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::sync_reference

inherited

◆ vendor

template<typename target_t= void_struct, int max_streams= 2, int max_pins= 1, int max_clock_settings= 1, int max_clocks= 1, int max_configurations= 1, int max_sources= 1>

struct dx::stream::desc::name_id dx::stream::desc<target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources>::vendor

inherited

◆ version

dx::stream::device::monitor dx::stream::device<dx::stream::control<dx::device<std::string, preference>>, desc, stream<device<desc, preference, stream>>, void>::version

inherited

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

dx_midi_services_device.h

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ desc_t

◆ event_t

◆ group_t

◆ source_t

◆ super_device_t

Constructor & Destructor Documentation

◆ device()

Member Function Documentation

◆ align() [1/4]

◆ align() [2/4]

◆ align() [3/4]

◆ align() [4/4]

◆ attach()

◆ bound()

◆ budget() [1/2]

◆ budget() [2/2]

◆ conclude()

◆ connect()

◆ disconnect()

◆ enumerate()

◆ exception()

◆ find() [1/4]

◆ find() [2/4]

◆ find() [3/4]

◆ find() [4/4]

◆ frame()

◆ grouped()

◆ hw_clock() [1/2]

◆ hw_clock() [2/2]

◆ launch()

◆ open() [1/2]

◆ open() [2/2]

◆ operator ()() [1/2]

◆ operator ()() [2/2]

◆ operator >>()

◆ operator []() [1/2]

◆ operator []() [2/2]

◆ preferred()

◆ release()

◆ reset()

◆ send()

◆ setting()

◆ sleep()

◆ source() [1/2]

◆ source() [2/2]

◆ string()

◆ sync_reference() [1/2]

◆ sync_reference() [2/2]

◆ try_conclude()

◆ try_launch()

◆ updated()

◆ wake()

Member Data Documentation

◆ bus

◆ clock

◆ clocks

◆ clocksource

◆ configuration

◆ dflt

◆ driver

◆ editable

◆ firmware

◆ flush_hook

◆ group

◆ halt_hook

◆ hidden

◆ hosted

◆ hw

◆ icon

◆ id

◆ information

◆ iosize