Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456789]

Ncf	Corefoundation namespace
C__string	RAII CFString class
Cless	Ordering a ::CFStringRef key needs in an std::map - comparing the strings, not the pointers
C_preference	Persistant storarage base class - do not use directly! use cf::preference
Cproperty
Carray
Carray<::CFArrayRef, cf_object_t >	::CFArray read: its elements as a plain vector (container, unretained) or as cf::type values (dx_container), and a range-for over them
Citerator
Carray<::CFMutableArrayRef >	Array being built: add() appends, and the result converts to what an API asks for
Cbundle	Bundle by identifier, or the running one: its URL, its resources and its Info.plist as a dictionary
Cdata	Byte blob: made from a string, a buffer or a file, compared and copied back out - what a certificate's DER, a descriptor or a property's raw bytes travel in
Citerator
Cdictionary	Key value pair store
Cdictionary<::CFDictionaryRef, cf_object_t >	::CFDictionary read: operator [] names an entry, which converts to what the caller asks for, and a range-for walks key and value pairs. An entry hands out a retained value (cf::reference's ownership rule)
Citerator
Cdictionary<::CFMutableDictionaryRef >	Dictionary being built: set() chains one entry after another, which is what the desc's CF serialization expands into
Cerror	::CFError, in both directions: made from an OSStatus to name it, or taken from an API that hands one out (operator ::CFErrorRef*() is the out parameter). cf::describe is what dx::exception prints for a macOS result
Cinterface	COM style IOKit plugin interface: QueryInterface on the plugin (or on an io_object_t, which is opened as a plugin first) and the release at the end of the object's life - every IOUSBLib and IOCFPlugIn interface is reached through one
Cinterface<::IOCFPlugInInterface >
Creference
Crunloop	Run loop on a thread of its own: sources are added with += and removed with -=, and the object's construction waits until that loop is up, so a source may be attached right away. Every dxd entity that takes IOKit or CF notifications owns one
Cpause	Scope that holds the run loop's thread still: it is made to perform nothing until the scope ends, so another thread may touch what the loop's callbacks reach
Csource
Cstream	File open for reading, closed with the object; its offset is what a parse error is reported at
Ctree	Dx::key_value_tree<derived_t> contract (dxd/interface/dx_key_value_tree.h), implemented once for every CF-backed preference store (cf::_preference, sc::_preference, dx::coreaudio::server::_preference) - inherit from this (CRTP: class _preference: public cf::tree<_preference>) instead of reimplementing it
Ctype
Ctype< bool >	Boolean is no ::CFNumber but one of the two ::kCFBoolean singletons, so this one carries no reference of its own
Ctype< char * >
Ctype< const char * >
Ctype< double >
Ctype< float >
Ctype< std::string >
Ctype< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==1 > >
Ctype< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==2 > >
Ctype< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==4 > >
Ctype< type_t, typename std::enable_if_t<(std::is_enum_v< type_t >||std::is_integral_v< type_t >) &&sizeof(type_t)==8 > >
Ctype<::CFTypeRef >	Opaque type serves as type::factory
Curl	File system path or a bundle resource as a ::CFURL, converting back to a path, a string and a read stream
Cuuid	UUID, generated or read from its string or bytes - dx::guid on macOS
Ncrypt	Crypt - the CryptoAPI namespace (Security's counterpart on Windows)
Ccertificate	CryptoAPI certificate context, reference counted
Cstore	System certificate store by name and location, read only
Ndx	Dynax driver framework interface namespace
Nabstract
Cevent	Counting event every scope implements: a signal raises the count, a wait takes one (or resets the count where the waiter serves them all at once)
Nasio	ASIO namespace
Nclient
C_device	ASIO client streaming device interface class
Casio	SDK driver this device is, opened off a list of its own: its id holds however the registry moves
Ccallbacks	What an ASIO driver calls back into its host: the buffer switch and the driver's own notifications. The comments are the SDK's own description of the contract
Cdevice	Bus's device as a product composes it: an ASIO driver of the machine, driven as any ASIO host drives one
Cdriver	ASIO client driver interface class
Cproperty
Cgroup	ASIO client's own streaming group: the underlying SDK driver runs its session, ticked by the driver's own bufferSwitch callback
Cstream	One side of the ASIO driver as a stream: the buffer infos name this side's channels, which the host driver fills and empties at every buffer switch
Ctarget	ASIO stream's whole hardware identity: its direction - an ASIO driver offers one input and one output side, whatever the device behind it has
Nservice	Service interface namespace
Cdevice	Device the service hosts for ASIO clients: on arrival it registers the ASIO driver itself - HKLM\SOFTWARE\ASIO and the CLSID, the DLL path derived from the running service's own - and erases both at removal. No installer and no regsvr32 ever writes those keys
Cdriver	Service's ASIO side: it hands every arriving device the registration above
Cdevice	ASIO driver's device: the bus device plus the streaming engine the host session runs on - attached in launch(), released in conclude(), so the engine's lifetime is the device's own and a host call holding the device holds the engine
Cdriver
Cpause	Session stopped for the scope and started again at its end, where a host's request needs the driver still
Cproperty
Ncoreaudio	CoreAudio, both sides of it: dx::coreaudio is the HAL client - a device the system published, whoever drives it - and dx::coreaudio::server is the plugin that publishes one. Settings are HAL properties here, promoted over dx::coreaudio::promoted::property
Npod	Puppet device: an empty endpoint, given life by the existence and the streaming of its counterpart at the other end of the stream
Cdevice	Puppet endpoint's client device: it announces its own session to the counterpart, whose streaming is what animates it
Cgroup	Pod client's own streaming group: the HAL I/O proc's session like any client's - it is what keeps the counterpart's process scheduled tightly, the pod's own I/O proc moves nothing - on the counterpart's hw clock, a shared event the device's hw_clock() opens by name
Cstream	Pod's stream: the ring is the counterpart's, mapped by name, and open, close, start and stop are told to it as properties - nothing here touches hardware
Npromoted
Cproperty	Coreaudio::promoted::property
Nserver	Driver side of CoreAudio: the plugin the HAL loads, its devices, pins and controls. dx::coreaudio itself is the client side - the two never meet in one object
C_preference	Persistant CoreAudio storarage base class - do not use directly! use coreaudio::server::preference
Ccontrol	Controls a pin publishes beyond the encoders: clock source and its settings, the S/PDIF flag and the stream's source selector - numbered past dx::stream::encoder::index so one target field carries both
Cproperty
Cclock
Cspdif
Cdevice	CoreAudio server streaming device
Cclient	One process the HAL opened this device for: its bundle identifier, the HAL's client ids and the streams it holds - what a client leaves behind is released with it
Chost
Cpin	Pin as the HAL sees it: the stream object, its format list and every control of this pin, each answering the HAL's property calls from the desc and the device's promoted settings
Centry
Cplugin	CoreAudio server plugin
Nstream
Cdevice	CoreAudio stream client device
Cstream	Stream of a HAL device: the ring is the client's own, the latency the HAL's property of that direction
C__target	Same layout with named members, so a target can be written with designated initializers
C_device	CoreAudio client device
Cclocksource	Clock source as the HAL models it: a selector control object beside the device, its current item an ::AudioObjectID. The promoted carries the index into the available items instead, which is what a desc's clock settings are numbered by
Cicon	Device's icon as a file system path; the HAL states it as a URL
Cdevice	CoreAudio client device
Cmirror	Hosted device's transport settings' mirror (dx::stream::settings): a promoted property of the pod, born with the counterpart's property, the setting mapped to its selector - as service::client::device::mirror over the pipe
Cdriver	Coreaudio driver interface class
Cproperty	This bus's name in the device tree and the preference store
Cgroup	CoreAudio client's own streaming group: the HAL I/O proc runs its session
Cproperty	Coreaudio::property
Cdevice
Clisten	Coreaudio::property::listen
Cplugin
Cpod
Cstream
Ctransport
Cqualifier	Qualifier a HAL property takes beside its address, where the selector asks for one
Cvirtuel	Dxd's own selectors on a plugin: what neither the HAL nor a device knows - creating and removing a virtual device, the pod's stream and session notifications, and the plugin's own settings. A four character code each, as every HAL selector is
Cdevice
Ctarget	What an ::AudioObjectID of this plugin addresses: the device, its pin and, inside that pin, the control - the plugin derives the object from the id alone, so no lookup table stands between the HAL and the device tree
Cdx_packed
Cdx_packed
Cdx_packed
Ncoremidi	MIDI client over CoreMIDI, which speaks Universal MIDI Packets since macOS 11 - so this bus's rings carry UMP, and a MIDITimeStamp is dx::timestamp itself, converted nowhere
Npromoted
Cproperty	Coremidi::promoted::property
Nserver	Server - dynax coremidi::server interface namespace
Cdevice	CoreMIDI device
Cpin
Cplugin	CoreMIDI plugin
C_device	CoreMIDI client device
Cdevice	CoreMIDI client device
Cdriver	CoreMIDI client driver interface class
Cproperty	What this driver calls its framework, as every dxd driver states it
Cproperty	Coremidi::property
Clisten	Coremidi::property::listen
Cstream	One source or destination: the in side writes what the endpoint's callback delivers into the ring at the moment each packet carries and never stalls - a full ring drops and counts - while the out side's own thread reads whole packets and hands them to CoreMIDI at their own timestamps, which schedules what is still due
Ctarget	CoreMIDI stream's hardware identity: the entity it belongs to and its direction - a source or a destination of that entity
Ncrypto	Cryptographic primitives a signature check takes, kernel and user mode alike: no allocation, no exception, no platform
Crsa	RSA public key of up to 4096 bits: the signature verification of RSASSA-PKCS1-v1_5 (RFC 8017 8.2.2)
Csha256_digestinfo	SHA-256's DigestInfo for verify(): the DER prefix and the digest
Csha256	SHA-256 (FIPS 180-4): update() over any run of bytes, digest() ends the message
Ndaemon
Capp	Launchd daemon capturing the listed USB devices for its peers: a request names a registry entry, the capture holds while any requesting peer's connection stands
Ccapture	Peer's request for the daemon's capture of a registry entry, held while the connection stands: a refused or absent daemon means no capture
Ccaptures	Captures of every registry entry the matching dictionaries name, held for the scope - ahead of a host driver releasing its devices, whose own capture then is not the last
Nder	ASN.1 DER, walked in place: what a certificate's fields and a license's private extensions take
Ctlv	One element: its tag, content, the element behind it and its own start (begin..next is the whole element, what a signature covers)
Ngui	Control panel's widgets over JUCE: each one takes the value it edits and a listener, writes the device's desc back on a change and follows the desc when something else changes it - so a panel is composed of these, never of event handling of its own
Caggregate	Several widgets in one row, each at its own width - what a tree item's line is built from
Cbar	Row of buttons laid out left to right, each sized to its text, with one listener for all of them
Cbox	Drop down whose items are either ids or their text, depending on what the edited value is
Clabel	Box::label Corrects JUCE awkward positioning and size of the juce::ComboBox editor. This is attached by the cpl::looknfeel class
Cbutton	Button, toggling where a listener is given
Ccheckbox	Check box for one boolean of the desc
Ccomponent_size_pair	Widget with the width its content needs: negative takes it from the right, zero takes what is left
Ccpl	Control panel application: one window holding the driver's device tree, every device a branch of it. The driver itself is a base of the tree view below, so a device arriving on the bus adds its line - marshalled onto the message thread
Cdevice	Device as a branch of the panel's tree: its name and icon on the line, its streams, clock, buffer size and clients below - every widget bound to the desc, which the device writes back when one of them changes
Cclients	Who has the device open, one line per client, following the device's promoted client map
Cclock	Clock domain's branch: the sample rate to choose from what the desc offers, and the rates themselves editable where the device allows it
Ciosize	Buffer size in samples, offered between the desc's limits and aligned to the clock's interval
Cstream	One stream's line: its name, its direction and its channel count, with a line per pin below
Cpin	Dx::gui::device::stream::pin Detail row of a single stream pin: name, direction/channels/index, sample format (audio/MIDI, resolution, scalar/float, byte size, endian, alignment), latency and encoder role - grouped into the same dense rows juce uses
Cdirection	Stream's direction: every direction to choose from where the device has an editable desc, the current one alone where it has not
Cexception_dialog	Dx::gui::exception_dialog wxWidgets counterpart of the juce interface's exception hierarchy dialog: shows a dx::exception and its chain of causes (frame, comment, what()+error code, file:line, function) as a navigable tree, instead of collapsing it into a single message string
Cfile	Given vendor/product-relative path, in the platform's standard app data location
Cimage	Image from a file or a resource, scaled into its place
Citem	One line of the device tree: its widget is created when the line becomes visible and dropped with it
Clabel	Text field, editable where a listener is given
Clooknfeel	Dx::gui::looknfeel Approximates the juce interface's dark/light colour scheme on the containers wx lets us recolour (frame/panel/splitter backgrounds, the tree, and - via colour inheritance - future field labels) without fighting native control rendering. Buttons, combo boxes, checkboxes and text fields are deliberately left to render as the platform normally would: recolouring native controls fights macOS's own dark-mode appearance, whereas juce draws every control itself and so can commit to one look on every platform
Cpower2	Drop down of powers of two within a range - a buffer size or a channel count, with the values between the powers offered as well where asked for
Ctext	Dx::gui::text An editable single line text field, committing on Enter or on losing focus
Ninstall	Driver package installation namespace
Cparser	Driver package installer: a product's <Product>Install.exe, the installer's custom action (dxd_installer.wxs) and a command line alike
Nmap
Cdriver	Device mapping driver interface class
Nmidi
Nservices	Windows MIDI Services: the MIDI service of Windows 11 (midisrv), its endpoints spoken to in Universal MIDI Packets through the App SDK (Windows.Devices.Midi2)
C_device	Windows MIDI Services client device: one UMP endpoint
Cdevice	Windows MIDI Services client device
Cdriver	Windows MIDI Services client driver interface class
Cproperty	This bus's name in the device tree and the preference store
Cstream	Stream of a Windows MIDI Services endpoint: Universal MIDI Packets through the device's connection, an ump::circular ring on this side
Ctarget	Stream of an endpoint: the direction, the index in the device
Nump	Universal MIDI Packet: whole 32 bit words, one to four a packet, the message type in the top nibble of the first word saying how many, the group in the nibble below it
Ccircular	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
Cpacket	One packet with its moment: the dx::timestamp() it arrived at or is due at, the words of the packet, words() how many of them the message takes
Ccircular	Byte ring of a MIDI 1.0 stream: the reader takes whole messages alone, running status resolved against the status byte it keeps between calls, and a message the ring does not hold completely stays for the next round
Nplatform	Machine's identity a license may be bound to (dx_common.cpp)
Clicense	Dx::license's platform part in the WDK kernel: the machine store's candidates, the machine's identity
Npower
Cac	One processor power setting while on mains, set for the object's life and restored at its end - unless something else changed it meanwhile, which keeps that change
Cacdc	Both at once - what a setting that must hold whatever the machine runs on takes
Cdc	Same setting while on battery
Cdisable_c3	Deep idle states off for the object's life: a core entering one leaves a realtime thread's wakeup late, which a streaming tick pays for in glitches
Cscheme	Machine's active power scheme, whose settings the classes above write
Cthrottling	Process power throttling opt-out: Windows 11 ignores timer resolution requests of windowless (service/background) processes unless the process excludes itself from that throttling policy
Nprocess	Process
Cmmcss	Mmcss | thread priority/process priority class
Nproxy	OS proxy interface class
Nstream	Stream interface
C_device
Cchain	Drives one of the device's own promoted values through an IOCTL
Cmonitor	Driver's clock monitor, mapped on demand and handed back at the end of the scope; a driver that does not keep one answers not_implemented and the monitor stays empty
Cheader
Cpromoted	Dx::proxy::stream::device::promoted with device::preference
Cdevice	Bus's device as a product composes it: the _device above with this bus's own stream and group, the group's clock being the driver's
Cgroup	OS proxy's own streaming group: the kernel driver owns its clock, started and stopped with this group's session
Cstream	Pin's stream on the kernel driver: the ring is the driver's, mapped into this process, and this client is a participant in it - it anchors a cursor where the indices stand and never resets them (dx::stream::cursor)
Cdevice	OS proxy device driver interface class
Csoftware	Software Device API instance
Cdriver
Cnotification	Device notifications this driver's window is subscribed to: one per interface class it matches, and one per open handle whose removal it must hear about
Cdevice
Cproperty	This bus's name in the device tree and the preference store
Csetup	Device information set of one interface class: what enumerates the devices present and names their paths
Cdevices	Devices of a hardware id and the set's class - its own or its parent's, a composite device's function - the present ones unless all are asked for, what a range-for over setup(hwid) walks
Citerator
Nredirect	Redirect std IO: a stream's distributor (dx::redirect::indent::streambuf) hands every write to the sinks joined to it - any std::streambuf: the stream's own, a file's, a line sink's (dx::redirect::line) - which join and leave in any order, each for its object's life (dx::redirect::join)
Ccerr
Cclog
Ccout	Event log entry kind each standard stream is written as - the three below are what dx::redirect::eventlog is instantiated with
Cdebug	Stream's lines to the debugger (OutputDebugString), beside its other sinks
Ceventlog	Standard stream redirected into the Windows event log, one entry per line: what a service or any process without a console logs through, since nobody reads its stdout
Cfile	Stream into a file, beside its other sinks: instances naming one path share its buffer - one per ASIO client, left in any order - and each line is written once
Cindent	One nesting level on a stream carrying an dx::redirect::indent::streambuf, taken for the object's scope: every line written inside it is prefixed. Levels nest LIFO per thread
Cdflt
Cstreambuf	Stream's distributor: over the stream's own buffer while a sink is joined, the stream's own restored once the last one left - every write to each sink, a line's start prefixed by the writing thread's indent, a line sink given each line whole. Every distributor joins the stream's own buffer: the stream stays where it was, indented - a sink wanting the stream for itself leaves it (leave(*origin)). std::cout, std::clog and std::cerr get theirs at their first indent level or sink. A buffer joined twice is written once. Joining and leaving take the lock the writes take (io_mutex)
Cjoin	Buffer as a sink of a stream for the object's life - a sink's last member, so it leaves before the sink's own members go
Cline	Sink taking a stream's lines, each whole in one call, without its line end: what a system log, the debugger or an installation log keeps as an entry
Clog	Stream's lines into unified logging, beside its other sinks
Csetup	Stream's lines into the application installation log at an event level, beside its other sinks: what a driver package installer reports reaches the log Windows keeps of installations, a custom action without a session included
Csyslog	Redirect stdout to syslog
Nservice	Device that is an IOService of the registry, without a driver connection of its own - what a proxy device derives its identity and its properties from
Nclient
C_device	Service client streaming device interface class
Cmirror	Transport settings' mirror (dx::stream::settings, a hosted device's): born with the pipe, the setting mapped to the service's request
Cdevice	< the app's consumer group (dx::stream::engine::group) wraps this bus's own
Cdriver	Service client driver interface class
Cproperty
Cgroup	Service client's own streaming group: its transport side is the service's, chain-forwarded
Cpromoted	Host's promoted mirrored, born with the pipe as its server (dx_value.h: no promoted is born empty): a wish (assignment) or a question (first access) goes to the host as data, the promoted commits the host's answer under its own lock; a message outside a request is the host's broadcast, committed on the pipe's thread under the promoted's lock
Cstream	Stream of a device the service hosts: the ring is the service's, in shared memory, and this client is a participant in it
Csync	One request made synchronous: it waits for the answer carrying its own id, and a connection that drops meanwhile ends the wait rather than hanging it
Ctarget	Service client stream's whole hardware identity: its direction - the device behind the service names its own
Caccept
Cto
Capp	Service::app - Windows Service Windows services are essentially just a type of container for which startup conditions can be defined. The service interface does not support any additional communication. Communication between client and service are usually be implemented using Windows named pipes
Cdevice	Registry entry behind a device: its class, the bundle that provides it and every property it publishes
Cpromoted	Service::device::chain handle request to/from device::promoted and pipe
Cuser_client	User client connection The each user_client holds a shared device reference
Cdriver	Service driver interface class
Capp	Service's own entry point: it launches the driver, so a device arriving on the machine is served whether a client is connected or not
Cproperty	This bus's name in the device tree and the preference store
Cmanager	Service as the control manager sees it: installed, started, stopped and removed from here, its state followed by the promoted below
Cenumerate	Machine's services, re-read whenever one of them changes state
Cpromoted	Value the control manager notifies about, on a thread of its own: the notification is an alertable wait, so the callback runs on that thread and commits what it read. A service marked for deletion ends the watch
Cstatus	Service's current state; a delete pending answer closes the handle
Cparser	Service control command line: install, start, stop, remove and run in the console, on a dx::service::manager of its own. Its settings live under HKLM\SOFTWARE\<id>, writable where the process is elevated
Crequest	One message on the service's pipe: what is asked, what came back and the value it carries. Every setting a hosted device mirrors has its own id here, so a client's promoted reaches the service's device with one round trip
Cstart_type
Cfrom
Cto
Cstate	Service states, start types and accepted controls by their SDK names - what a status is printed and a command line argument read as
Cto
Nshared
Nlockfree
Clist	Entries a real time walk visits without a lock, in user mode and the kernel alike
Cevent	MacOS user space shared event
Cguard	Synchronize write/shared read access/destruction
Cmemory	MacOS user space shared memory
Cheader	What every shared segment carries ahead of its payload: the version the host wrote it with and its size, so an attaching process refuses a segment of another build
Creference	Cross-process, crash-safe named reference count
Nstream	Generic stream interface
Nchannel	Generic stream::channel interface
Ccontrol	Kernel streaming client's own header beside its channel buffers: the frame counter and the last two buffer switch timestamps, from which a client derives where the hardware stands
Copen	Generic stream open request
Copened	Generic streaming channel buffer description
Nengine
Cconsumer	App's consumer group for a bus device's group_t slot: engine::group over the bus's own group and the device's audio pin
Cgroup	Consumer twin of a bus's producing group: it owns this group's pins, its io buffers and ring positions, and runs the consumer data path on the group's own clock - one thread per group, so every group of every device streams in parallel
Cconverter
Centry
Nshared	Shared stream namespace
Cstream	Stream whose ring and events live in named shared memory, so another process attaches to them by name - the host sizes and resets the ring, a hosted device takes what it finds (device_t::hosted)
Cclock	Select/get stream sample rate/iosize
Cconsumer	One clock consumer's share of the domain: its buffer switch is due every iosize samples
Cmonitor	Performance monitor shared memory
Cclock_value	Value asked of, or answered by, one clock domain (sample rate, clock source)
Ccontrol	Promoted-counter refcount: start counts, started derives (start!= 0); run_hook fires on the 0->nonzero edge, halt_hook on the nonzero->0 edge, flush_hook before every effective decrement (including one that doesn't reach zero). One central mechanism, reused by inheritance wherever a level still needs its own share-count (pin's per-client attribution; stream, which also owns the ring reset in its own run_hook; group, whose hooks are its own dx::clock run()/halt()) - hooks are set by the derived class's own constructor body, exactly how dx::stream::group already wired its hand-rolled start/streaming pair
Cpause	Session held open across a change that needs it stopped: the counted shares are taken out for the scope and handed back at its end, so clients starting or stopping meanwhile keep their own
Ccursor	Client's own place in a ring and the margin it keeps to the transport
Cdesc	Device streaming interface descriptor
Cclock	Clock domain of the device: its sources, the rates it serves and everything the streams of that domain are timed by
Cdefaults	What the device asks for where nothing was stored yet - every one of them a preference's default
Ciosize	Buffer sizes offered to applications, in clock ticks: what a host may ask for and what the ring is sized from
Csync
Csetting	One clock source of this domain: internal, or an external one the device locks to
Cexternal
Cfirmware	Device's own: what the bus reports (USB: bcdDevice, iSerialNumber) unless a product knows a vendor way; the serial number is what a license binds to (DSN)
Cname_id	Name with the bus entity's own id behind it - what a vendor, a model or a selectable source is called and how the bus addresses it
Cstream	Dx::desc::stream interface descriptor
Cconfig	Dx::desc::stream::config interface descriptor
Cclock
Csync
Coptions
Cspdif
Ctransaction	What one transfer on the bus carries where it is not simply a run of sample frames: a granularity the bus enforces, or a vendor's own payload size
Cpin	Pin of the stream: the channels a host attaches to as one entity, their format and what they are wired to. A stream's channels may be split into several pins, and a hidden one is not offered to the host
Cdevice	Streaming device: its desc, the settings the desc defaults, the streams of that desc grouped by dx::stream::group and the clock those groups run on. Every bus device derives from this one and supplies what its transport does differently - the settings' servers (a rate written to the hardware), the group's tick, the streams' rings. The settings themselves are promoted preferences here, so a wish survives the device and is asked of the transport once the device is there
Cmonitor	Device's performance counters in shared memory, so a second process (the test app's clock monitor) reads what the streaming session measures; every fetch initializes an unused buffer
Cpause	RAII: pauses every one of this device's groups (remembered count, force-stopped) across a streams structure mutation, restarts all on destruction
Cproperty	Preference keys of this device's settings, named once - the store's layout is these words, and a host's own property names never reach the store
Csync
Ccycle
Cstrategy
Cdriver	Stream driver interface class
Cencoder	Per channel controls a stream carries; what a device does not have is emulated where it has the gain, and the host publishes one control per bit
Cindex
Cformat	What one sample frame looks like, container and content apart: the resolution inside the container's size, its alignment there and its endianness. operator == is a match against a wish, not an identity: a member left at zero in the asked format matches anything, which is how a pin states audio alone and a ring adopts the one format its participants agree on (dx::stream::format::align). The named constants below are the formats the converters of dx_circular.h move - dx::stream::sample keys them
Cformat_value	Stream's negotiated sample format, addressed by the bus's own stream target
Cgroup	Streaming group: the streams of one device sharing a desc::stream::group id, streamed together by one realtime thread
Ciosize	Client's share of a clock domain: the samples between its buffer switches and the event the clock signals it on
Cobject	Everything that belongs to one device: it keeps the reference and hands its diagnostics to the device, so a stream, a pin or a group reports as the device does
Copen	Generic stream open request
Copened	Generic shared streaming buffer description
Cpin	One client's attachment to a stream: the pin desc it was made from, the channels it takes of that stream's ring, and its own share of the stream's start count. Several pins - several clients - share one dx::stream::stream, which the device keeps by weak reference: the first pin of a stream creates it, the last one to go releases it, and neither stops a transport the others still run
Csettings	Group's settings per side of its ring: the side's wait strategy on the clock and its lead per direction. The owner keeps them in its store, keyed and defaulted by role; a hosted device (device_t::hosted) mirrors the transport's through its mirror type, each born with the transport that asks the host
Cclient	Client side: the group's clients (app engine, service client, ASIO/CoreAudio/WASAPI host) and the ring margin they keep to the transport - the client's own, in its store
Ctransport	Transport side: the tick and the frames it moves data ahead of/behind the device, kept per wait strategy - a strategy switch rebinds the leads to the new strategy's store and reloads them. A bus's own group runs its tick by them; a hosted device's group mirrors its host's, without a store
Csettings_promoted
Csettings_promoted< device_t, false >	Hosted device's, born with the transport to its host (dx_value.h: no promoted is born empty)
Cstart	RAII object start/stop balancer
Cstream	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
Ntest	Manual exerciser: one dx::test::driver per client bus, each a dx::parser of its own, handed to dx::select. It prints rather than asserts - the output is the verdict
Nmidi
Cdevice	Generic test device, unchanged: a MIDI device's commands are its driver's
Cdriver	MIDI exerciser: it sends over one port and counts what comes back on another - the round trip's losses, its slips and its latency, no audio ring involved
Nservice
Cdriver	Service control commands of the test app: install, start, stop and remove, plus the timing a client's connect and disconnect are exercised with
Nsurprise	Device tree arrival and removal under load: what a replug does to a running session, without a hand at the cable
Casynchronous	Concurrently drives synchronous conclude()/launch() cycles (device tree arrival/removal) against whatever else is using the driver, on its own thread
Csynchronous	Single, synchronous mid-operation conclude()/launch() cycle, resuming streaming (if it was active) at its prior sample rate once the device is back
Nusb
Cdriver	Raw USB commands beside the generic ones: the device's configuration and what a configuration change does to a running session
Nvirtuel
Cdriver	Device tree commands of the in-process bus: a device is added to and removed from the preference store here, its desc taken from a file or the default
Nwasapi
Cdevice	WASAPI client test device: the generic test device plus the endpoint share mode
Cdevice	Test harness's device: the bus device plus its command line parser, and the streaming engine its tests run under - its own group_t slot, or the app's consumer group on its clock divider
Chas_license
Chas_license< type_t, decltype((void) type_t::license, void())>
Cimpulse	One impulse test: what an analog loop keeps is its timing alone
Cmask	Channels a monitor's callback works on: one word per direction, plus the mix target
Csine	One generator tone: the channels it feeds and its phase, carried between callbacks
Cdriver	One bus's command set: the driver of that bus plus the commands the CLI dispatches on it. It keeps the device under test alone - a bus's tree must hold exactly that one device while a test runs
Cmatch_helper
Cmatch_helper< std::set< std::string > >
Cload	Load scenario the streaming monitor runs its session under: threads of the named kind for the object's lifetime
Nthread	Thread
Cprio	Thread::prio
Crealtime	Thread::prio::realtime
Cworkgroup	Apple audio workgroup: a realtime thread of a driver's own joins the workgroup of the device it serves, so the scheduler treats them as one deadline group (macOS 11)
Cinterval	One work interval of the group: started with its deadline and moved on by update() at every tick
Cjoin	This thread's membership, held for the scope
Ntrace
Nindent
Creceipt	dx::trace::receipt indenting everything logged inside its scope by one level - what $ expands to
Creceipt	$ trace's entry and exit lines for one scope, the exit carrying the time spent - debug builds alone
Nusb	USB user mode interface namespace
N__	Standard descriptors with what the class descriptors add to them: an endpoint and an interface as the enumeration read them, class descriptors and, for an interface, its endpoints in tow
Cendpoint
Cinterface
Naudio	Generic USB audio 1.0
Cdescriptor	USB audio class descriptors
Cendpoint
Cmidi
Cgeneral
Cstreaming
Cgeneral
Csubtype
Chead
Cinterface	USB audio class interface descriptors
Ccontrol	USB audio class control interface descriptors
Cclock_multiplier
Cclock_selector
Cclock_source
Ceffect_unit
Cextension_unit
Cfeature_unit
Chead
Cheader
Cinput_terminal
Chead
Cv1
Cv2
Cmixer_unit
Chead
Cv1
Cv2
Coutput_terminal
Chead
Cv1
Cv2
Cprocessing_unit
Csamplerate_converter
Cselector_unit
Csubtype
Cv1	Every control entity as Audio Device Class 1.0 lays it out; v2 below is the same set in 2.0 - the header's bcdADC says which a device speaks, and dxd configures ADC1 devices
Cclock_selector
Cclock_selector1
Ceffect_unit
Ceffect_unit1
Cextension_unit
Cextension_unit1
Cfeature_unit
Cfeature_unit1
Cmixer_unit
Cmixer_unit1
Cprocessing_unit
Cprocessing_unit1
Cselector_unit
Cselector_unit1
Cv2
Cclock_selector
Cclock_selector1
Ceffect_unit
Ceffect_unit1
Cextension_unit
Cextension_unit1
Cfeature_unit
Cfeature_unit1
Cmixer_unit
Cmixer_unit1
Cprocessing_unit
Cprocessing_unit1
Cselector_unit
Cselector_unit1
Chead
Cmidi
Celement
Chead
Cheader
Cjack
Chead
Cin
Cout
Csubtype
Cstreaming	USB audio class streaming interface descriptors
Cencoder
Cformat
Cex
Ctype1
Ctype2
Ctype3
Chead
Ctype1
Cv1
Cv2
Ctype2
Cv1
Cv2
Ctype4
Cv1
Cv2
Cex
Cgeneral
Cv1
Cv2
Chead
Csubtype
Cv1
Cv2
Ctype
Cisoc	Isochronous cycle of one pipe: the slots a session rotates through, each carrying the bus frame it is scheduled for, its request size and the lines its micro frames hold
Ccycle
Ctick
Crange	ADC2 control's answer: subranges of minimum, maximum and resolution
Csubclass
Nclock	USB clock source interface namespace
Cframe	Chrono conforming bus frame clock: frames since bus start; now() maps the OS timestamp onto the frame counter via the tick thread's correlation
Csource	USB bus frame clock source: one tick per bus frame - a high resolution OS timer wait toward the frame objective, optionally handing over to yield/spin polling covering user mode jitter for low latency sessions
Nezusb	Cypress EZ-USB firmware download, shared with the kernel
Can21	Chip's CPU control register (bit 0: reset) and where its internal RAM ends
Cfx2
Nisoc	Isochronous transfer as both platforms describe it, frame by frame
Ccorrelation	Bus frame clock's correlation with the timestamp clock, the same in every environment: which frame the tick serves, where the wire is now, when a frame starts
Cframe	One frame of a request: what was asked for, what the controller delivered and its status - laid over the platform's own frame structure, so a request is filled once and submitted as it stands
Cpipeline	One isochronous endpoint's request pipeline and data move over the slots of a round, the same in every environment
Cresult	Completed asynchronous isoc request, as pulled by a platform pipe's poll()
Csession	Streaming session's tick over a group's pipelines, the same in every environment
Nplatform
Cdevice	Platform half of a USB device: the IOKit registry entry, the IOUSBLib device interface and the open count over it - what dx::usb::device puts its descriptors and interfaces on
Cvoid_struct
Cinterface	Platform half of an interface: the IOUSBLib interface plugin, its exclusive open and the run loop its asynchronous completions arrive on
Crunloop	Interface's own realtime run loop: every asynchronous completion of its pipes runs here, at a 125 µs timing policy
Cpipe	Platform half of a pipe: the transfers over the interface's endpoint and their completions - an isochronous one queues its result for the group's poll, since a completion counts and never schedules
Cisoc	What an isochronous pipe needs beside its requests: the micro frames a packet is spread over and the registered buffer they are served from
Cbuffer
Nstream	USB user mode streaming interface namespace
C_device	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
Cdevice	Bus's device as a product composes it: the _device above with this bus's pipes and its own ticking group
Cgroup	USB isoc streaming group: one bus frame aligned tick per USB frame, the one thread running the pipes' request pipelines and moving their data
Cpipe	One isochronous endpoint as a stream: the ring, the cycle of slots the session rotates through and the thread that ticks them. The data path itself is dx::usb::isoc::pipeline, shared with the kernel driver; this class supplies its platform part - a slot's request over its buffer, the completions in submission order, the direction's data event and the timestamp clock. An asynchronous sink keeps its sync endpoint's requests here too (isoc.sync), an implicit feedback source reads its rate off its own delivered lines
Ccache	What the tick reads instead of asking a promoted: the derived transaction sizes, the encoder stages and the in slot's sentinel - none of them may block or lock
Cencoder
Cisoc	What this pipe's session needs beside its own requests: the feedback ring of lines per frame, and an explicit feedback endpoint's own slots
C__request_type	Standard USB control request definitions
Ccapture	IOUSBHost framework's device capture, its class reached through the Objective-C runtime: the class driver's clients are terminated, the device stays configured and open to other processes' interface clients, the drivers match again with the release
Ccontrol	Setup packet: the request and its wValue/wIndex/wLength. length is the data stage's size - a request carrying data with length 0 is stalled by the device
Cdescriptor	Standard descriptors over the platform's own declarations: one spelling for the walkers of dx_usb_audio.h, whatever SDK the build takes them from
Ctype
Cdevice	USB device in user mode: its device, configuration and association descriptors, the platform's handle and this tree's interfaces. It is the base every bus device derives its streams from - the class descriptors it enumerates are what dx::usb::audio::configure builds a desc from
Cendpoint	USB specific errors
Cattributes	Endpoint's bmAttributes: the transfer type, how an isochronous endpoint synchronizes, and whether it carries data or the feedback for another endpoint
Cinterface	Interface of the device: the platform's handle to it and the descriptors of its current alternate setting, which update() re-reads whenever the setting is selected
Cmidi	USB MIDI packetizer
Cmsg	USB MIDI endpoint element types: defining the element size for a single USB MIDI pipe request
Cpipe
Crequest
Crequest< data_t >
Nvirtuel	In-process bus: devices exist in the preference store alone, no OS registration of any kind. It exercises the shared stream machinery - device, pins, groups, engine - without a plugin, a service or a kernel driver, and its desc types are the generic default other buses fall back to
Nstream
C_device	Virtual streaming device interface class
Cdevice	Bus's device as a product composes it: shared memory streams, so another process attaches to this device's rings by name
Cgroup	Virtual device's own transport: a device without hardware, so the tick moves silence - a transport reader takes and clears at rx, a transport writer clears and publishes at tx, the clients anchor to it - and runs the device's clock at the desc's tick
Ctarget	Virtual stream's whole hardware identity: its direction, since there is no bus to address
Cdriver	Virtual driver interface class
Cproperty	This bus's own preference keys: the store's subtree the device tree lives in
Nwasapi	WASAPI namespace
Nclient
C_device	WASAPI client streaming device interface class
Cproperty	Beside the generic settings: the share mode this device's endpoints are opened in, which decides whether a rate other than the engine's mix format is reachable at all
Cdevice	Bus's device as a product composes it: the endpoints of one Windows audio device, driven as any WASAPI application drives them
Cdriver	WASAPI client driver interface class
Cproperty	This bus's name in the device tree and the preference store
Cgroup	WASAPI client streaming group: one endpoint's engine period thread, signalled by the audio engine through the stream's client
Cstream	WASAPI client stream: one endpoint's audio client, moved by its group one engine period per tick between the engine's buffer and the circular buffer
Ctarget	WASAPI stream's hardware identity: the endpoint it belongs to, by the MMDevice id, and its index within the device - one endpoint per direction and channel pair, several of them making up one device
Creference	COM interface reference
Ctask_memory	CoTaskMemAlloc'd out parameter
Nx509	Fields of an X.509 certificate a license check reads, off its DER: kernel and user mode alike
Ccertificate
Nxpc
Cconnection	Client's connection to a launchd mach service: a request is one number under the request's name, answered with a status
Clistener	Launchd mach service: every peer's requests run the handler on the queue, a peer's end runs the closure there
C__scalar	Integer of a width the language has none for - dx::int24/dx::uint24, packed into its own bytes because a bit field of a packed struct still costs four bytes here
Ccast
Caggregate	Forwards a braced argument list into a type with no matching constructor - the conversion builds it from the stored tuple, so an aggregate can be returned or passed where its own members would not deduce
Cansi	SGR/OSC control sequence, written only where it is read: every sink below drops it unless stderr is a terminal
Capartment	COM apartment of one object - a device or a whole driver: its thread creates the object, runs its steps and releases it
Ccircular	Kernel/user space shared circular buffer
Cchannel	Copy/mix channel converters
Cchannel< dst_t, src_t >	Same width, or floating point on both sides: the sample moves as it stands
Cinterlocked	Compare-exchange returning the prior value regardless of outcome (WIN32 Interlocked* semantics)
Cclock	Realtime tick mechanism: one thread per clock - run/halt lifecycle and tick dispatch; the source_t base owns objective and wait
Cdevice	Abstract commom base device interface class
Cclient_map	Who has the device open: process id to bundle identifier and whether that client is running it - the HAL hands it over as a CF dictionary, every other platform keeps the map itself
Cdriver
Cdisconnect	Exclusive access to a device a host driver already holds: the scope shuts that driver down and boots it again at its end (dx::coreaudio::driver asks its installed plugin to release the device)
Cdriver_settings	Abstract base driver interface class This is the abstract base interface to a driver
Cevent
Cevent< kernel >	Kernel triggerable user space event
Cevent< user >	Process local event over a condition variable; dx::event<kernel> is the platform's own, waitable together with an OS handle
Cexception	Throw's whole diagnostic: the OS result, where it was raised (frame, file, line), the thread and the moment, a formatted comment and the exception it grew out of. Each frame on the way out wraps the one below into a new exception of its own - dx_catchall and friends do nothing else - so previous is the chain down to the origin, deep copied and owned by the wrapper; dx::trace::unfold prints it. The constructor overloads below are one signature per combination of the optional leading arguments (previous, function, error, what) ahead of the mandatory frame/file/line, with and without the printf-style comment
Cfence	Memory ordering plain shared state needs on weakly ordered CPUs, in user mode and the kernel alike
Cfile	Open handle to a device interface - what every ioctl of a proxy device goes through
Cfree_run	Free running timer source: condition variable timer at system timer resolution; duration zero degenerates to the event driven base
Cguid	::GUID with the arithmetic Windows leaves out: constructed from its parts or its string, ordered so it can be a map key, printed as its string
Cint24be	Packed 24 bit integer stored big endian: converts from and to the native int on every access, so the ring converters take it like int24
Ciobridge	Ioctl bridge for 32/64bit user mode/kernel space big/little endian interface
Cis_dx_iterator
Cis_dx_iterator< type_t, std::void_t< typename type_t::dx_iterator_tag > >
Cis_initializer_list
Cis_initializer_list< std::initializer_list< type_t > >
Cis_smart_pointer
Cis_smart_pointer< std::shared_ptr< type_t > >
Cis_smart_pointer< std::unique_ptr< type_t, deleter_t > >
Cis_smart_pointer< std::weak_ptr< type_t > >
Cis_string_container
Cis_string_container< type_t, false >
Cprobe
Cprobe< t, std::void_t< typename t::value_type, decltype(t(std::declval< std::set< std::string >::iterator >(), std::declval< std::set< std::string >::iterator >()))> >
Citerator	Range-for support shared by every dxd type whose elements aren't already kept in an STL container of their own (dx::key_value_tree, cf::data, cf::dictionary, cf::array): a derived_t populates container_t however it needs to - a single existing conversion, or an explicit per-element loop - in its own constructor, then calls seed() once population is complete; operator++()/operator!=() forward to container_t's own iterator from then on. operator*() stays derived_t's own: what it should return (a plain element, const or not) differs per user, from cf::data's read-only bytes to dx::key_value_tree's mutable, further-navigable child node
Ckey_value_tree	Hierarchical key/value navigation over a flat persistent store
Citerator	Node's immediate children as nodes of their own, named by tree_t::children() - what a range-for over a node walks
Ckey_value_tree_enabled
Ckey_value_tree_enabled< tree_t, value_t, std::void_t< decltype(tree_t::template enabled< value_t >())> >
Claunch	RAII object launcher
Clicense	First certificate of the platform's store naming the product that the root signed, whose constraints this machine and device satisfy and that, unless perpetual, has not expired; kernel and user mode alike over the platform part (dx_platform_license.h: the store's candidates and their DER, the time, the machine's serial number and ethernet addresses, what to keep and the missing/forged hooks)
Clisten	Guarded listerners map used from the server side to manage listeners
Clistener	Balanced listener client into servers listeners map used from the client side to manage its subscription into the server listeners map
Clisteners	Internal helper to map single listener into listerners map
Clog	Whole log setting in one 32 bit word: a dx::log::level per dx::log::scope per dx::log::module, four bits each. The word is what a driver, a kernel and a host exchange and compare; the named members are the same bits, and to/from name them for a preference, a command line or a property. The serialization macros hand the member list to the tree and CF sinks of dx_serialize.h, so the store holds the log resolved rather than the word
Cfrom
Cmodule	Parts of a driver a message is attributed to, each with its own dx::log::scope
Cfrom
Cto
Cscope	Phases a module is logged apart in - a device's setup may be traced while its operation stays quiet
Cfrom
Cto
Cto
Cobject	Framework's object lifecycle: launch() once mounted, conclude() before removal, both reached through the try_ pair alone, which elects the single caller that runs them. Neither is a constructor's or destructor's job: an object is constructed long before its resources exist (a device ahead of its bus arrival) and outlives their release. The destructor's try_conclude() is the backstop for an object never concluded by its owner
Copen	RAII manage balanced object open/(close)
Cos_event	Kernel/user space shared event representation
Coverlapped	Overlapped operation with the event it completes on, and the wait for its result
Cparser	Cmd line parser
Cdispatch	One command: what it runs, how it reads in the help, and the commands nested under it. A word of parameter consumes the arguments that follow it before this one's own function runs, which is what makes the CLI hierarchical
Cpci	Physical PCI stream descriptor
Cdma	Physical DMA stream descriptor
Cpipe	Pipe - Windows named pipes A dx::pipe is a bidirection, multi-client, multi-threaded communication channel between a pipe client and a pipe server. Both pipe sides feature a dedicated read thread to receive data from the opposite side notifiying installable listener std::functions. On the service side, a pipe server is instantiated for each pipe client connection. Until a new client connects, the pipe::server::instance remains waiting in pipe::server::instance::connect within its dedicated pipe read thread. If a client disconnects the pipe::server::instance terminates its read thread and is joined and released by the next pipe::server::run() or pipe::server::stop(). The pipe::server::instance super class can be template-parameterized to allow mimicking user client behaviour. Windows arbitrarily serializes operations on synchronous pipe handles, limiting it's named pipe concurrent synchronous operation capabilities to exactly one synchronous pipe per process (i.e. exactly one per process), effectively forcing both the pipe::server and the pipe client to be implemented using asynchronous OVERLAPPED I/O — introducing a whole host of unnecessary pitfalls and awkward behaviors. However, the MSDN documentation here apparently describes a different piece of software. Though dx::pipes can be used for any communication between user space software its purpose is to allow Windows service communication. A service itself runs with elevated privileges, whereas the clients typically run in the normal user context. Therefore, the pipe servers have defined their default ACLs for non-privileged access
Caccess	How a client opens the pipe where the caller names nothing: read and write, overlapped
Cconnection	Whether this pipe stands: an event to wait on and a promoted to follow - dx::pipe::status derives it from what the last operation answered
Cserver	Server - accepts multiple concurrent pipe client connections Each accepted connection is served by its own pipe::server::instance, running on a dedicated read thread. run() keeps exactly one instance listening for the next client at all times: once ConnectNamedPipe() accepts a connection, that instance's own thread calls server::run() again - reaping already-concluded instances and spawning the next listener - before servicing its own connection. A concluded instance (client disconnected) therefore joins only at the start of the next run(), on a different thread: a std::jthread cannot join itself, so reaping cannot happen from within the concluding instance's own read thread. An otherwise idle server thus keeps its most recently used instance around until either the next connection or stop(), which unconditionally joins every instance - connected or not - synchronously before returning
Caccess	How the pipe is created where the caller names nothing: a duplex message pipe, overlapped
Cinstance	One accepted client connection, on a read thread of its own
Cstatus	Every pipe operation's result assigned here: the states that mean the peer is gone end the read thread, ok marks the connection up, the pending ones pass, and anything else is a fault
Cprocess	Child process with its handles, started and waited for; mmcss inside it is what a streaming thread of this process registers with the multimedia scheduler as
Cpromoted	Promoted value
Cchain	Server that keeps the one it replaces: a derived class prepends its own step (the device's request to the hardware) and hands the rest to the server its base installed
Cpreference
Cpromoting	Promoted::preference with default and optional alignment function
Cpromoting< preference_t, std::void_t< decltype(preference_t::listen)> >
Creference	RAII manage balanced object open/(close)
Cregistry	Flat, non-hierarchical Windows registry access to one real key
Cproperty
Cresource	Windows handle class bill wasn't sure wether an invalid handle is a nullptr or -1. Hence the invalid_t template parameter. (Usually its -1, but i.e. for file mappings its nullptr, etc.)
Csecurity	Windows security descriptor: allows non-privileged access
Cselect	Select from aggregated drivers
Cserial	Serial interface
Csource	Clock source base: the only thing that may signal a tick - itself the event driven source (hw clock fan-out)
Cspin
Cstring	Fixed size name that crosses a process or kernel boundary by value, where a std::string cannot: the platform's file name length, always terminated, converting to and from std::string
Cthemed
Ctimer	High resolution timer source: an OS timer wait toward the objective, optionally handing over to yield/spin polling covering the last lead; self pacing by duration like free_run, or paced by an override's sync()
Ctty	Terminal behind a file descriptor: its presence, its raw mode and its background colour
Cvoid_struct	Empty stand-in where a template needs a type but nothing is carried - it streams nothing
Cwindow	Message only window on a thread of its own: WM_DEVICECHANGE and WM_POWERBROADCAST are what Windows delivers device arrival, removal and sleep through, and there is no window less way to take them
Cyield	Stateless polling wait strategies: trade a core for the last microseconds toward an objective
Ndxd	Dynax driver framework DriverKit namespace
Nabstract
Cevent	Abstract::event: base clase to event<dx::user> and event<dx::kernel> to allow mixed user/kernel broadcast signalization
Ndmus	Dmus namespace
Cminiport	Dmus::miniport: one DirectMusic port per MIDI pin, its streams over the backend's ring
Cstream	Dmus::stream: a DirectMusic pin stream over its device's MIDI ring
Ndoubly	Semi lock free doubly linked list: an item knows its list and leaves it in its own destructor, which the singly linked one cannot - what a registration of unknown lifetime hangs in
Nlinked
Nabstract
Cevent	Semi lock free doubly linked event list
Cevent	Semi lock free doubly linked event item
Citem	Semi lock free doubly linked list item
Clist	Partially lock free doubly linked list
Nkmdf	KMDF bound device framework: the plain WDM counterparts of device/client/driver live in dxd itself
Cclient	User client
Cdevice	KMDF device: the framework's own PnP and power callbacks routed to this class's virtuals, its clients created per file object. The WDM counterpart, which the PortCls path takes, lives in dxd itself
Cdriver_creator	Dummy WDF interface class
Nlinked	Lock free singly linked list: a push and a pop with no lock at all, which makes it a stack - what is pushed last comes off first, so nothing that needs its order kept walks it (dxd/CLAUDE.md, the isoc completions)
Nabstract
Cevent	Lock free linked event list item
Cevent	Lock free linked event
Citem	Singly linked list item
Clink
Clist	Lock free singly linked list
Nmultichannel
Cstream	Generic kernel multichannel stream
Cclock	Clock domain in the kernel: its sample rate in a buffer the clients map, and the broadcast every registered client is signalled through. references counts the starts, so the domain runs while any client holds it
Cmonitor	Clock::monitor buffer to be shared with user client mappings to measure jitter and latencies at various levels(IRQ, DPC, ASIO)
Cin	Kernel stream mapped client reference counted in channel buffers
Cumap	Stream user mapping
Cchannel	One channel's double buffer, mapped into the kernel and into the client - the planar buffers a kernel streaming client exchanges instead of the ring
Nportcls	Portcls namespace
Cdevice	Adapter device's WaveRT endpoints over its streaming device's rings
Cstream	WaveRT pin stream: exchanges the frames its device's tick hands it with its stream's ring
Cminiport	Portcls::miniport
Cpin	One pin of a WaveRT miniport as PortCls wants it: its data ranges, its category and flow, and the instance counts the system may open of it
Cwave	Wave filter description shared by the wave port models
Nrange	Range namespace
Caudio	KSDATARANGE_AUDIO constructor
Nstreaming	Generic streaming device layer, shared by every bus and both device frameworks
Cchannels	One client's planar channel double buffers for one pin
Cclient	Streaming state of one control client
Cclock	One client's registration with a clock domain: its buffer switch bookkeeping, its planar channel buffers per direction, its own cursors in the device's rings and the converters those rings are moved with - everything a client's tick needs, none of it shared
Cconverter
Cdevice	Generic streaming device: the control interface every bus's clients share
Cclient	Control client: the platform's client with this device's streaming state
Cring	Ring one stream streams through, sized by the opening client
Cdomain	Clock domain every client rides on: the DAW clock
Centry
Ciosize_server	Buffer size a client asks for: aligned to the clock's granularity and the desc's limits, and left where it stands while the device streams or a stream is open
Coffset_server	Client side safety offset in clock ticks: it is committed and then handed to the domain's registered clients as a margin in bytes, which their cursors take at the next seat
Copened_server	Count of open streams, committed as it stands - the flag every setting below refuses a change against
Csamplerate_server	Server functors of device's promoted values
Cswitching	One client's share of a clock domain: its buffer switch event and iosize, and the channel buffers that switch
Nusb	Dynax driver framework kernel namespace
Nstream	Dynax driver framework kernel namespace
Cclock_server	Runs the group while streams are started, from within started's promoted server
Cdevice	USB streaming device: the streaming device over the platform's USB device, its streams the endpoints' rings, its clock the bus frame tick
Cgroup	USB isoc streaming group: one bus frame aligned tick per USB frame, the one thread running the pipes' request pipelines and moving their data
Cpipe	One endpoint's ring and request pipeline
Cdevice
Cpipe
Nwavert	WaveRT namespace
Cminiport	Wavert::miniport
Cstream	Wavert::stream: cyclic WaveRT buffer with client notifications
Nwdm	WDM++ - windows helper classes
Cdevice_interface	Enabled device interface: registered and enabled by initialize(), disabled by conclude() - or on destruction, when no remove came
Cfile	File class
Cirp	IRP class
Cregistry	Registry key in the kernel: the driver's parameters and, for the license, the machine's certificate store - read at PASSIVE_LEVEL alone
Cunicode	WDM unicode string helper
Cworkitem	WDM workitem helper
C__atomic_pointer	Atomic pointer operations
C__atomic_pointer< type_t * >
C__atomic_scalar
C__atomic_scalar< 4, type_t >	32bit atomic operations
C__atomic_scalar< 8, type_t >	64bit atomic operations
Cadapter	PortCls adapter driver
Cdevice	Per-FDO adapter device: miniport subdevices are created in start()
Cadjust
Cadjust< host >
Cadjust< swap >
Carray	Array owned the same way, sized once and freed with the object
Catomic	Atomic operations
Catomic< type_t * >	Explicitely specify pointer template argument:
Cbroadcast	Broadcast signalization of participating linked event items
Cbuffer	DriverKit memory buffer w/o alignment and boundary requirements
Cbus	WDM BUS class
Cdesc	Device description for bus class
Cclient	User client: one per control open, created by device::client_create()
Cclock	Kernel-mode periodic software clock, mirroring dx::clock's tick()/run()/halt() shape
Cdecay	No array/function decay - not needed here
Cdevice	Plain WDM device, one per FDO
Cevent	WDK event
Cevent< dx::kernel >
Cevent< dx::user >
Cfourchar_string	Four character code as a string on the stack: the kernel has no allocation free formatting, so the code is unpacked into this and printed as s
Cfw	WDK: FireWire device
Caddress	Address range this driver publishes on the bus: a peer writing into it hands its data over through the FIFO entries below
Cphy
Cguid
Clock
Cmap	One mapping of a buffer, into the driver itself or into the client that asked for it - the scope says which address space the address belongs to
Cmap< dx::kernel, vm_t >	WDK: kernel space memory mapping
Cmap< dx::user, vm_t >	WDK: user space memory mapping
Cmemory	Virtual DriverKit memory description
Cmutex	Mutex
Copen
Cpci	PCI device
Cdbg
Cresources	PCI windows this device was assigned, mapped for the driver's life: each one its virtual and physical address, its length and its mask
Cmemory
Cscatter_gather
Cport	Miniport creation helper
Creference	COM reference held for the object's life - the PortCls interfaces are reference counted and a miniport that keeps one raw outlives it
Cppc	PPC device
Cprocess	WDK process
Cpromoted	Kernel-mode promoted value, mirroring dx::promoted's server/commit/notify shape
Creference	Reference holder for object based reference counter
Creferenced	Reference counting base class
Cremove_reference
Cremove_reference< type_t & >
Cremove_reference< type_t && >
Cscoped	Object owned for the scope, freed at its end and at every assignment - the kernel's own unique_ptr, with the conversions an OS call's out parameter needs
Cscoped<::URB >
Cspinlock	WDK spinlock
Cstream	Generic kernel stream
Copened	Generic streaming interface description
Cumap	Stream user mapping
Cstring	Formatted string of a fixed length on the stack: the kernel has no std::string, and a driver's names and log lines need no allocation
Cwmi	WMI data block's instances, read as a consumer (IoWMIOpenBlock, IoWMIQueryAllData) at PASSIVE_LEVEL
Nio	Io - IOKit namespace
Citerator	Internally used service iterator providing RAII for io_service references - returned when iterating
Cservice	Iteration state of a range-for over an IOKit iterator: the service in hand and the iterator handing out the next
Cport	Notification port
Cpower	System power notification receiver to get notifications: inherit and connect to runloop
Creference	IOKit object's retain and release, the counterpart of cf::reference for the io_object_t family
Cregistry	MacOS IORegistry access
Nsc	Sc - system configuration namespace
C_preference	Persistant system configuration storarage base class - do not use directly! use sc::preference
Clock	System configuration store's write lock, held for the scope - a store several processes write needs it around a change
Nsec	Sec - security namespace
C__code	Code with a signature - a running process or a file on disk: its signing information as a dictionary, which is what a signature requirement is checked against
Ccertificate	Persistant system configuration storarage base class - do not use directly! use sc::preference
Ccode
Ccode<::SecCodeRef >
Ccode<::SecStaticCodeRef >
Citem
Crequirement	Code signing requirement compiled from its text form
Ctrust	Evaluation of a certificate chain; sec::trust::anchors restricts it to a given root - a license is checked against the embedded one, never against the keychain's trust settings