the ring of stamped Universal MIDI Packets: an entry is the stamp in two words, low first, and the words of one packet; a read cuts on whole entries, so a reader never sees a torn one The ring's size is a multiple of the word, so a word never wraps. More...

#include <dx_midi.h>

Inheritance diagram for dx::midi::ump::circular:

Collaboration diagram for dx::midi::ump::circular:

Public Types
typedef dx::circular	super

Public Member Functions
void	clear(uint64_t position, uint64_t bytes)
	zero a just-consumed region, wrapping around - only safe for a single reader's own rx, never a shared/multi-reader position
size_t	decode(volatile uint64_t& position, uint8_t* dst, uint8_t port)
	the next packet of the port's group that carries MIDI 1.0: its bytes into dst, which holds 8, their count returned - 0: none
uint64_t	empty() const
uint64_t	empty(uint64_t position) const
size_t	encode(midi::parser& parser, const uint8_t* src, size_t size, uint8_t port)
	MIDI 1.0 bytes into packets on the port's group, due at once, as the parser completes them: the bytes taken returned - a byte while the ring holds the two packets it completes at most.
template<typename ext_t>
bool	force_read(const conversion& conversion, volatile uint64_t& position, ext_t* const* dst, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_dst= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
	multi channel interleaved bulk read from circular buffer with format conversion if applicable
template<non_pointer ext_t, typename circular_t= ext_t>
bool	force_read(ext_t* const* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_dst= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<non_pointer ext_t, typename circular_t= ext_t>
bool	force_read(ext_t* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<typename ext_t, typename circular_t= ext_t>
bool	force_read(volatile uint64_t& position, ext_t* const* dst, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_dst= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<non_pointer ext_t, typename circular_t= ext_t>
bool	force_read(volatile uint64_t& position, ext_t* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<typename ext_t>
bool	force_write(const conversion& conversion, volatile uint64_t& position, const ext_t* const* src, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
	multi channel interleaved bulk write into circular buffer with format conversion if applicable
template<typename ext_t, typename circular_t= ext_t>
bool	force_write(const ext_t* const* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<non_pointer ext_t, typename circular_t= ext_t>
bool	force_write(const ext_t* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<typename data_t>
bool	force_write(data_t* const* const* src, uint64_t clients, uint64_t channels, uint64_t bulk)
template<typename circular_t, typename src_t>
bool	force_write(src_t* const* const* src, uint32_t clients, uint32_t channels= 1, uint64_t bulk= 1)
	multi channel multi client bulk mix into circular buffer with format conversion if applicable src[client][channel][sample]
template<typename ext_t, typename circular_t= ext_t>
bool	force_write(volatile uint64_t& position, const ext_t* const* src, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<non_pointer ext_t, typename circular_t= ext_t>
bool	force_write(volatile uint64_t& position, const ext_t* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
	single channel convenience access templates
void	initialize()
void	initialize(uint64_t backingstore_size)
uint64_t	loop() const
template<typename ext_t>
bool	mix_write(const conversion& conversion, volatile uint64_t& position, const ext_t* const* src, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
	multi channel interleaved bulk mix into circular buffer at position with format conversion if applicable
template<typename ext_t, typename circular_t= ext_t>
bool	mix_write(volatile uint64_t& position, const ext_t* const* src, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<typename callback_t>
bool	move(callback_t& callback, uint64_t packet)
template<non_pointer data_t>
bool	operator <<(const data_t& src)
template<non_pointer data_t>
bool	operator >>(data_t& dst)
template<typename ext_t>
void	put(conversion::loop op, const conversion& conversion, uint64_t position, const ext_t* const* src, uint64_t bulk, uint32_t channels_circular, uint32_t channels_src, uint32_t circular_offset, uint32_t interleaved)
	multi channel interleaved bulk placement into circular space at position with wrap-around; channel operation (copy/add) the conversion's
template<non_pointer ext_t, typename circular_t= ext_t>
bool	read(ext_t* const* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_dst= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<non_pointer ext_t, typename circular_t= ext_t>
bool	read(ext_t* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<non_pointer ext_t, typename circular_t= ext_t>
bool	read(volatile uint64_t& position, ext_t* const* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_dst= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<non_pointer ext_t, typename circular_t= ext_t>
bool	read(volatile uint64_t& position, ext_t* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
uint64_t	read(packet* dst, uint64_t bulk)
uint64_t	read(volatile uint64_t& position, packet* dst, uint64_t bulk)
	reads whole packets: as many as fit bulk and stand complete in the ring; the packets read returned
void	reset(int64_t timestamp)
	a session start: the indices at the ring's size, the content silence, the time the transport's
template<typename dst_t= uint8_t>
dst_t*	simulate_read(uint64_t bulk= 1)
template<typename dst_t= uint8_t>
dst_t*	simulate_read(volatile uint64_t& position, uint64_t bulk)
uint8_t*	simulate_write(uint64_t bulk)
	simulate write by advancing write idx and take care of wrap write optimization
void	stamp(uint64_t position, int64_t timestamp, uint64_t bytes= 0, int64_t period= 0)
	the transport moved its index to position at timestamp: the ring's time, and a crossed cycle boundary's - placed within the move's period by its share of the move's bytes, at timestamp without them
uint64_t	used() const
uint64_t	used(uint64_t position) const
template<typename ext_t, typename circular_t= ext_t>
bool	write(const ext_t* const* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<non_pointer ext_t, typename circular_t= ext_t>
bool	write(const ext_t* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
template<typename ext_t, typename circular_t= ext_t>
bool	write(volatile uint64_t& position, const ext_t* const* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
	bulk write into circular buffer with format conversion if applicable
template<non_pointer ext_t, typename circular_t= ext_t>
bool	write(volatile uint64_t& position, const ext_t* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)
bool	write(const packet& packet)
bool	write(int64_t timestamp, const uint32_t* src, uint64_t words)
	writes a run of whole packets, every one at the same moment: all or nothing

Static Public Member Functions
template<typename position_t>
static position_t	advance(volatile position_t& position, position_t value)
	lock-free max-publish; returns the position advanced from (>= value when nothing was advanced), so the winning caller alone owns the span [returned, value)
template<typename dst_t>
static void	atomic_add(dst_t* dst, int64_t added)
	atomic clip-add of one sample: concurrent writers into the same mix target must never plain read-modify-write
template<typename position_t>
static position_t	exchange(volatile position_t& position, position_t comperator, position_t value)
	lock-free monotonic publish: advance position to value unless already beyond
template<typename dst_t, typename src_t>
static constexpr conversion::loop	mixed()
	a sample that adds mixes; a record moved through a ring (a MIDI message, a log line) has none
template<auto op, typename dst_t, typename src_t>
static void	untyped(void* dst, const void* src, uint64_t bulk, uint32_t dst_gap, uint32_t src_gap, uint32_t interleaved)

Public Attributes
struct	cycle
uint8_t	data [1]
volatile uint64_t	dropout
	dropout counter
volatile uint64_t	rx
	the reader side's index: a transport reader's own; every client reads at its own cursor (dx::stream::cursor)
uint64_t	size
	size of buffer in bytes
volatile int64_t	timestamp
	current rx/tx timestamp
volatile uint64_t	tx
	producers current write index

Static Public Attributes
template<typename ext_t, typename circular_t= ext_t>
static constexpr conversion	of
	the conversion of the participant's sample type ext_t against the ring's circular_t
static constexpr uint64_t	stamp{sizeof(int64_t)/ sizeof(uint32_t)}

Detailed Description

the ring of stamped Universal MIDI Packets: an entry is the stamp in two words, low first, and the words of one packet; a read cuts on whole entries, so a reader never sees a torn one The ring's size is a multiple of the word, so a word never wraps.

Member Typedef Documentation

◆ super

typedef dx::circular dx::midi::ump::circular::super

Member Function Documentation

◆ advance()

template<typename position_t>

position_t dx::circular::advance(volatile position_t& position, position_t value)

inlinestaticinherited

lock-free max-publish; returns the position advanced from (>= value when nothing was advanced), so the winning caller alone owns the span [returned, value)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ atomic_add()

template<typename dst_t>

void dx::circular::atomic_add(dst_t* dst, int64_t added)

inlinestaticinherited

atomic clip-add of one sample: concurrent writers into the same mix target must never plain read-modify-write

Todo: packed 24bit: no lock-free CAS on a 3-byte element - plain clip-add, not yet atomic (like the floating-point formats)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear()

void dx::circular::clear(uint64_t position, uint64_t bytes)

inlineinherited

zero a just-consumed region, wrapping around - only safe for a single reader's own rx, never a shared/multi-reader position

Here is the caller graph for this function:

◆ decode()

size_t dx::midi::ump::circular::decode(volatile uint64_t& position, uint8_t* dst, uint8_t port)

inline

the next packet of the port's group that carries MIDI 1.0: its bytes into dst, which holds 8, their count returned - 0: none

Here is the call graph for this function:

◆ empty() [1/2]

uint64_t dx::circular::empty() const

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

◆ empty() [2/2]

uint64_t dx::circular::empty(uint64_t position) const

inlineinherited

Here is the call graph for this function:

◆ encode()

size_t dx::midi::ump::circular::encode(midi::parser& parser, const uint8_t* src, size_t size, uint8_t port)

inline

MIDI 1.0 bytes into packets on the port's group, due at once, as the parser completes them: the bytes taken returned - a byte while the ring holds the two packets it completes at most.

Here is the call graph for this function:

◆ exchange()

template<typename position_t>

position_t dx::circular::exchange(volatile position_t& position, position_t comperator, position_t value)

inlinestaticinherited

lock-free monotonic publish: advance position to value unless already beyond

compare and swap: position takes value where it held comperator; returns what it held

Here is the caller graph for this function:

◆ force_read() [1/5]

template<typename ext_t>

bool dx::circular::force_read(const conversion& conversion, volatile uint64_t& position, ext_t* const* dst, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_dst= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

multi channel interleaved bulk read from circular buffer with format conversion if applicable

return true if enough data is available in circular space

Here is the call graph for this function:

Here is the caller graph for this function:

◆ force_read() [2/5]

template<non_pointer ext_t, typename circular_t= ext_t>

bool dx::circular::force_read(ext_t* const* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_dst= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ force_read() [3/5]

template<non_pointer ext_t, typename circular_t= ext_t>

bool dx::circular::force_read(ext_t* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ force_read() [4/5]

template<typename ext_t, typename circular_t= ext_t>

bool dx::circular::force_read(volatile uint64_t& position, ext_t* const* dst, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_dst= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ force_read() [5/5]

template<non_pointer ext_t, typename circular_t= ext_t>

bool dx::circular::force_read(volatile uint64_t& position, ext_t* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ force_write() [1/7]

template<typename ext_t>

bool dx::circular::force_write(const conversion& conversion, volatile uint64_t& position, const ext_t* const* src, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

multi channel interleaved bulk write into circular buffer with format conversion if applicable

return true if data fit into circular space false if data fit not or older data had to be overwritten

Here is the call graph for this function:

Here is the caller graph for this function:

◆ force_write() [2/7]

template<typename ext_t, typename circular_t= ext_t>

bool dx::circular::force_write(const ext_t* const* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ force_write() [3/7]

template<non_pointer ext_t, typename circular_t= ext_t>

bool dx::circular::force_write(const ext_t* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ force_write() [4/7]

template<typename data_t>

bool dx::circular::force_write(data_t* const* const* src, uint64_t clients, uint64_t channels, uint64_t bulk)

inlineinherited

Here is the call graph for this function:

◆ force_write() [5/7]

template<typename circular_t, typename src_t>

bool dx::circular::force_write(src_t* const* const* src, uint32_t clients, uint32_t channels= 1, uint64_t bulk= 1)

inlineinherited

multi channel multi client bulk mix into circular buffer with format conversion if applicable src[client][channel][sample]

return true if data fit into empty space

◆ force_write() [6/7]

template<typename ext_t, typename circular_t= ext_t>

bool dx::circular::force_write(volatile uint64_t& position, const ext_t* const* src, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ force_write() [7/7]

template<non_pointer ext_t, typename circular_t= ext_t>

bool dx::circular::force_write(volatile uint64_t& position, const ext_t* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

single channel convenience access templates

Here is the call graph for this function:

◆ initialize() [1/2]

void dx::circular::initialize()

inlineinherited

◆ initialize() [2/2]

void dx::circular::initialize(uint64_t backingstore_size)

inlineinherited

Here is the caller graph for this function:

◆ loop()

uint64_t dx::circular::loop() const

inlineinherited

◆ mix_write() [1/2]

template<typename ext_t>

bool dx::circular::mix_write(const conversion& conversion, volatile uint64_t& position, const ext_t* const* src, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

multi channel interleaved bulk mix into circular buffer at position with format conversion if applicable

concurrent writers each holding their own position share one circular and always atomically add (never overwrite) into it - the single reader (its own rx, see above) is responsible for zeroing a region once consumed, so every writer finds a clean slate regardless of write order

return true if data fit into circular space false if data fit not or older data had to be overwritten

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mix_write() [2/2]

template<typename ext_t, typename circular_t= ext_t>

bool dx::circular::mix_write(volatile uint64_t& position, const ext_t* const* src, uint64_t bulk, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ mixed()

template<typename dst_t, typename src_t>

constexpr conversion::loop dx::circular::mixed()

inlinestaticconstexprinherited

a sample that adds mixes; a record moved through a ring (a MIDI message, a log line) has none

Here is the call graph for this function:

◆ move()

template<typename callback_t>

bool dx::circular::move(callback_t& callback, uint64_t packet)

inlineinherited

Here is the call graph for this function:

◆ operator <<()

template<non_pointer data_t>

bool dx::circular::operator <<(const data_t& src)

inlineinherited

Here is the call graph for this function:

◆ operator >>()

template<non_pointer data_t>

bool dx::circular::operator >>(data_t& dst)

inlineinherited

Here is the call graph for this function:

◆ put()

template<typename ext_t>

void dx::circular::put(conversion::loop op, const conversion& conversion, uint64_t position, const ext_t* const* src, uint64_t bulk, uint32_t channels_circular, uint32_t channels_src, uint32_t circular_offset, uint32_t interleaved)

inlineinherited

multi channel interleaved bulk placement into circular space at position with wrap-around; channel operation (copy/add) the conversion's

Here is the caller graph for this function:

◆ read() [1/6]

template<non_pointer ext_t, typename circular_t= ext_t>

bool dx::circular::read(ext_t* const* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_dst= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ read() [2/6]

template<non_pointer ext_t, typename circular_t= ext_t>

bool dx::circular::read(ext_t* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ read() [3/6]

template<non_pointer ext_t, typename circular_t= ext_t>

bool dx::circular::read(volatile uint64_t& position, ext_t* const* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_dst= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read() [4/6]

template<non_pointer ext_t, typename circular_t= ext_t>

bool dx::circular::read(volatile uint64_t& position, ext_t* dst, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ read() [5/6]

uint64_t dx::midi::ump::circular::read(packet* dst, uint64_t bulk)

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read() [6/6]

uint64_t dx::midi::ump::circular::read(volatile uint64_t& position, packet* dst, uint64_t bulk)

inline

reads whole packets: as many as fit bulk and stand complete in the ring; the packets read returned

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reset()

void dx::circular::reset(int64_t timestamp)

inlineinherited

a session start: the indices at the ring's size, the content silence, the time the transport's

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simulate_read() [1/2]

template<typename dst_t= uint8_t>

dst_t* dx::circular::simulate_read(uint64_t bulk= 1)

inlineinherited

Here is the call graph for this function:

◆ simulate_read() [2/2]

template<typename dst_t= uint8_t>

dst_t* dx::circular::simulate_read(volatile uint64_t& position, uint64_t bulk)

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

◆ simulate_write()

uint8_t* dx::circular::simulate_write(uint64_t bulk)

inlineinherited

simulate write by advancing write idx and take care of wrap write optimization

◆ stamp()

void dx::circular::stamp(uint64_t position, int64_t timestamp, uint64_t bytes= 0, int64_t period= 0)

inlineinherited

the transport moved its index to position at timestamp: the ring's time, and a crossed cycle boundary's - placed within the move's period by its share of the move's bytes, at timestamp without them

Here is the caller graph for this function:

◆ untyped()

template<auto op, typename dst_t, typename src_t>

void dx::circular::untyped(void* dst, const void* src, uint64_t bulk, uint32_t dst_gap, uint32_t src_gap, uint32_t interleaved)

inlinestaticinherited

Here is the caller graph for this function:

◆ used() [1/2]

uint64_t dx::circular::used() const

inlineinherited

Here is the call graph for this function:

Here is the caller graph for this function:

◆ used() [2/2]

uint64_t dx::circular::used(uint64_t position) const

inlineinherited

Here is the call graph for this function:

◆ write() [1/6]

template<typename ext_t, typename circular_t= ext_t>

bool dx::circular::write(const ext_t* const* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ write() [2/6]

template<non_pointer ext_t, typename circular_t= ext_t>

bool dx::circular::write(const ext_t* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ write() [3/6]

template<typename ext_t, typename circular_t= ext_t>

bool dx::circular::write(volatile uint64_t& position, const ext_t* const* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t channels_src= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

bulk write into circular buffer with format conversion if applicable

return true if data fit into empty space

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write() [4/6]

template<non_pointer ext_t, typename circular_t= ext_t>

bool dx::circular::write(volatile uint64_t& position, const ext_t* src, uint64_t bulk= 1, uint32_t channels_circular= 1, uint32_t circular_offset= 0, uint32_t interleaved= 1)

inlineinherited

Here is the call graph for this function:

◆ write() [5/6]

bool dx::midi::ump::circular::write(const packet& packet)

inline

Here is the call graph for this function:

Here is the caller graph for this function:

◆ write() [6/6]

bool dx::midi::ump::circular::write(int64_t timestamp, const uint32_t* src, uint64_t words)

inline

writes a run of whole packets, every one at the same moment: all or nothing

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ cycle

struct dx::circular::[struct].cycle dx::circular::cycle

◆ data

uint8_t dx::circular::data[1]

inherited

◆ dropout

volatile uint64_t dx::circular::dropout

inherited

dropout counter

◆ of

template<typename ext_t, typename circular_t= ext_t>

conversion dx::circular::of

staticconstexprinherited

Initial value:

{
        .write= &untyped<&channel<circular_t, ext_t>::copy, circular_t, ext_t>,
        .mix= mixed<circular_t, ext_t>(),
        .read= &untyped<&channel<ext_t, circular_t>::copy, ext_t, circular_t>,
        .ext= sizeof(ext_t),
        .ring= sizeof(circular_t)}

the conversion of the participant's sample type ext_t against the ring's circular_t

◆ rx

volatile uint64_t dx::circular::rx

inherited

the reader side's index: a transport reader's own; every client reads at its own cursor (dx::stream::cursor)

◆ size

uint64_t dx::circular::size

inherited

size of buffer in bytes

◆ stamp

uint64_t dx::midi::ump::circular::stamp{sizeof(int64_t)/ sizeof(uint32_t)}

staticconstexpr

◆ timestamp

volatile int64_t dx::circular::timestamp

inherited

current rx/tx timestamp

◆ tx

volatile uint64_t dx::circular::tx

inherited

producers current write index

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

dx_midi.h

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Member Typedef Documentation

◆ super

Member Function Documentation

◆ advance()

◆ atomic_add()

◆ clear()

◆ decode()

◆ empty() [1/2]

◆ empty() [2/2]

◆ encode()

◆ exchange()

◆ force_read() [1/5]

◆ force_read() [2/5]

◆ force_read() [3/5]

◆ force_read() [4/5]

◆ force_read() [5/5]

◆ force_write() [1/7]

◆ force_write() [2/7]

◆ force_write() [3/7]

◆ force_write() [4/7]

◆ force_write() [5/7]

◆ force_write() [6/7]

◆ force_write() [7/7]

◆ initialize() [1/2]

◆ initialize() [2/2]

◆ loop()

◆ mix_write() [1/2]

◆ mix_write() [2/2]

◆ mixed()

◆ move()

◆ operator <<()

◆ operator >>()

◆ put()

◆ read() [1/6]

◆ read() [2/6]

◆ read() [3/6]

◆ read() [4/6]

◆ read() [5/6]

◆ read() [6/6]

◆ reset()

◆ simulate_read() [1/2]

◆ simulate_read() [2/2]

◆ simulate_write()

◆ stamp()

◆ untyped()

◆ used() [1/2]

◆ used() [2/2]

◆ write() [1/6]

◆ write() [2/6]

◆ write() [3/6]

◆ write() [4/6]

◆ write() [5/6]

◆ write() [6/6]

Member Data Documentation

◆ cycle

◆ data

◆ dropout

◆ of

◆ rx

◆ size

◆ stamp

◆ timestamp

◆ tx