dx::stream::stream< device_t, circular_t, super_stream_t, _event_t > Class Template Reference

one stream of the device's desc while it is in use: the ring its clients share, the format they agreed on, and the session its dx::stream::control counts. The ring is allocated once (alloc()/free(), never across a start/stop cycle) and reset by its host alone at a session start - a participant mapping another's ring replaces the run hook and anchors a cursor instead. Bus streams derive from this one: a pipe, a shared memory ring, the kernel's mapping. More...

#include <dx_stream_stream.h>

Inheritance diagram for dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >:

Collaboration diagram for dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >:

Classes
struct	[struct].cache

Public Types
typedef struct device_t::desc::stream	desc
typedef _event_t	event_t

Public Member Functions
template<typename channel_t>
stream &	attach (channel_t **[2], const std::vector< bool > &, direction::direction)
	the pin passes its own direction: a stream shared by two pins carries none of its own
virtual float	encoder (dx::stream::encoder::index::type, unsigned int) const
virtual bool	encoder (dx::stream::encoder::index::type, unsigned int, float)
void	exception (const class exception &exception, bool filtered=false) const noexcept override
void	flush ()
void	info (std::ostream &os) noexcept override
virtual void	initialize ()
void	launch () override
	operator circular_t * () const noexcept
circular_t *	operator-> () const noexcept
virtual os_result	status () noexcept
	stream (device_t &device, const decltype(id)&id, const descdesc &descdesc)
	creates circular streaming backing store and frame buffers
virtual uint8_t	submit (dx::stream::encoder::index::type, unsigned int) const
virtual bool	submit (dx::stream::encoder::index::type, unsigned int, uint8_t)
	submit encoder stage to device return true if successfully submitted; if false is returned the encode state machine will not update the stage value (i.e. if the stage can't be submitted during streaming pause), given the chance to submit the stage at start().
	~stream () override

Public Attributes
struct	cache
dx::stream::channel::control *	control {}
	kernel streaming: the driver's buffer switch bookkeeping, set by attach()
event_t	data [direction::directions]
	event signalising data arrival(in) or draining(out)
dx::promoted< dx::stream::format >	format
	the container this stream's ring runs: class and width its participants agreed on
const decltype(desc::target.idx())	id
uint32_t	latency {}
decltype(device_t::samplerate) &	samplerate
bool	ticking {}
	the tick's own view of this stream's session: set by the run hook once the ring stands, cleared by the halt hook before the session ends - a plain flag, the tick must never block on a promoted's transition

Protected Member Functions
virtual void	alloc (size_t size, bool free=true)
virtual void	free () noexcept
	overrides may release further alloc()-acquired resources (request buffers, isoc pools, shared-memory attachments) alongside circular; called only from alloc()'s own self-cleanup or the destructor - never from halt()/stop(), so everything alloc() acquires stays live for the object's full lifetime

Protected Attributes
circular_t *	circular {}
	allocated once by initialize()/alloc(); released only by free()

Detailed Description

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>
class dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >

one stream of the device's desc while it is in use: the ring its clients share, the format they agreed on, and the session its dx::stream::control counts. The ring is allocated once (alloc()/free(), never across a start/stop cycle) and reset by its host alone at a session start - a participant mapping another's ring replaces the run hook and anchors a cursor instead. Bus streams derive from this one: a pipe, a shared memory ring, the kernel's mapping.

Member Typedef Documentation

desc

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

typedef struct device_t::desc::stream dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::desc

event_t

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

typedef _event_t dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::event_t

Constructor & Destructor Documentation

stream()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::stream ( device_t & device, const decltype(id)& id, const desc & desc )

inline

creates circular streaming backing store and frame buffers

< the device's group_t is a bus's own ticking group, not the plain generic container (whose tick() is a stub): only then does a clock-domain stream cascade its share into it

the ring reset and the group share, composed with whatever a more-specific super_stream_t (e.g. usb::pipe) already wired - a no-op for the generic default

~stream()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::~stream ( )

inlineoverride

Member Function Documentation

alloc()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

virtual void dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::alloc ( size_t size, bool free = true )

inlineprotectedvirtual

Reimplemented in dx::stream::shared::stream< device_t, circular_t, super_stream_t, event_t >, and dx::usb::stream::pipe< device_t, circular_t, stream_t >.

attach()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

template<typename channel_t>

stream & dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::attach ( channel_t ** [2], const std::vector< bool > & , direction::direction  )

inline

the pin passes its own direction: a stream shared by two pins carries none of its own

encoder() [1/2]

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

virtual float dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::encoder ( dx::stream< device_t, circular_t, super_stream_t, _event_t >::encoder::index::type , unsigned int  ) const

inlinevirtual

encoder() [2/2]

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

virtual bool dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::encoder ( dx::stream< device_t, circular_t, super_stream_t, _event_t >::encoder::index::type , unsigned int , float  )

inlinevirtual

Reimplemented in dx::usb::stream::pipe< device_t, circular_t, stream_t >.

exception()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

void dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::exception ( const class exception & exception, bool filtered = false ) const

inlineoverridenoexcept

flush()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

void dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::flush ( )

inline

free()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

virtual void dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::free ( )

inlineprotectedvirtualnoexcept

overrides may release further alloc()-acquired resources (request buffers, isoc pools, shared-memory attachments) alongside circular; called only from alloc()'s own self-cleanup or the destructor - never from halt()/stop(), so everything alloc() acquires stays live for the object's full lifetime

Reimplemented in dx::stream::shared::stream< device_t, circular_t, super_stream_t, event_t >, and dx::usb::stream::pipe< device_t, circular_t, stream_t >.

info()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

void dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::info ( std::ostream< device_t, circular_t, super_stream_t, _event_t > & os )

inlineoverridenoexcept

Reimplemented in dx::usb::stream::pipe< device_t, circular_t, stream_t >.

initialize()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

virtual void dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::initialize ( )

inlinevirtual

< a shared ring takes the wider of its two directions

< this stream's own contribution: the frames its transport keeps ahead of/behind the ring

< a hosted device's ring is its host's (kernel, service, plugin) and attached as it stands - sizing it here would write the ring into a mapping of the host's making

< a fresh ring, zeroed by alloc(), takes its size here

Reimplemented in dx::usb::stream::pipe< device_t, circular_t, stream_t >.

launch()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

void dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::launch ( )

inlineoverride

operator circular_t *()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::operator circular_t * ( ) const

inlinenoexcept

operator->()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

circular_t * dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::operator-> ( ) const

inlinenoexcept

status()

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

virtual os_result dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::status ( )

inlinevirtualnoexcept

submit() [1/2]

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

virtual uint8_t dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::submit ( dx::stream< device_t, circular_t, super_stream_t, _event_t >::encoder::index::type , unsigned int  ) const

inlinevirtual

submit() [2/2]

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

virtual bool dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::submit ( dx::stream< device_t, circular_t, super_stream_t, _event_t >::encoder::index::type , unsigned int , uint8_t  )

inlinevirtual

submit encoder stage to device return true if successfully submitted; if false is returned the encode state machine will not update the stage value (i.e. if the stage can't be submitted during streaming pause), given the chance to submit the stage at start().

Member Data Documentation

cache

struct dx::stream::stream::[struct].cache dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::cache

circular

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

circular_t* dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::circular {}

protected

allocated once by initialize()/alloc(); released only by free()

control

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

dx::stream::channel::control* dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::control {}

kernel streaming: the driver's buffer switch bookkeeping, set by attach()

data

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

event_t dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::data[direction::directions]

event signalising data arrival(in) or draining(out)

format

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

dx::promoted<dx::stream::format> dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::format

Initial value:

{{[this](dx::promoted<dx::stream::format>::lock_t&& lock, const dx::stream::format& value, const dx::stream::format&){
        format.commit(std::move(lock), value);
    }}}

the container this stream's ring runs: class and width its participants agreed on

A bus that negotiates it installs its own server; without one the request stands. The seed is the desc's own pin format, so a stream that nobody contradicts runs what it was declared with.

id

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

const decltype(desc::target.idx()) dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::id

latency

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

uint32_t dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::latency {}

samplerate

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

decltype(device_t::samplerate) & dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::samplerate

ticking

template<typename device_t, typename circular_t = circular, typename super_stream_t = control<object<device_t>>, typename _event_t = event<user>>

bool dx::stream::stream< device_t, circular_t, super_stream_t, _event_t >::ticking {}

the tick's own view of this stream's session: set by the run hook once the ring stands, cleared by the halt hook before the session ends - a plain flag, the tick must never block on a promoted's transition

---

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

• dx_stream_stream.h