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
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
C[struct].cache
C[struct].cache.linesize
C[struct].cache.sync
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	Setting the device's host keeps (dx::stream::setting) mirrored: a promoted property of the plugin's device, addressed by the setting and its stream's index - as service::client::device::mirror over its connection
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
Csetting
Clisten	Coreaudio::property::listen
Cplugin
Cpod
Cstream
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 product's 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)
Nfirewire	IEEE 1394: what user mode and the kernel share
Cnode	Node as its self-ID packets state it (IEEE 1394a-2000 4.3.4.1)
Csegment	Run of 48 bit bus addresses another node reaches host memory at - a physical address space's part
Ctopology	Bus as a reset's self-ID phase states it: its nodes in phy id order, the root last
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
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
Cchanged	Change without a promoted of its own, told to the refreshes keyed: an outline's edits
Ccheckbox	Check box for one boolean of the desc
Ccontrol	One control of an outline row: what it shows and, where it may change something, how - a toolkit renders it, nothing else
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
Cdescribe	Outline of a struct that names its members (dx_serialize.h: visit): a line per member, as its kind says - a power of two, a bitmap of named bits, a choice among the options its struct allows as it stands -, a nested struct a branch of its own or, where all its members are switches, one line of toggles; an array a branch whose count is chosen, its elements beneath it. Every edit commits and tells changed, so every control asks its value and its options anew: what one member allows follows another. extend() adds a caller's lines to an array's element
Cdevice	Dx::gui::device A device_t with its outline (dx::gui::model) as its own line of the tree, built by attach() as the driver adds it; its icon the image the tree paints behind it
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
Cline	Line of the outline in the tree: its row made while the line shows, the lines beneath it its sub items
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
Cmodel	Device's outline: its line with icon and name, its identity, its desc (dx::gui::describe) - the clock's rate, source and sync reference and a stream's source among its lines -, its I/O size, its transport and its clients
Cnode	One line of the outline: its controls and the lines beneath it, those refilled as watch tells
Crow	Line of the outline's controls, left to right, each at the width its content needs; one watching its value refreshes on the message thread while it lives
Ctext	Dx::gui::text An editable single line text field, committing on Enter or on losing focus
Ninstall	Driver package installation namespace
Cparser	Driver extension installer: a product's <Product>Install.app - a dext is activated by the app carrying it in Contents/Library/SystemExtensions alone - 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
Cparser	MIDI 1.0 byte stream into its messages, the state between two bytes: write(const uint8_t* bytes, uint8_t size) takes each as it completes - a channel voice or system common message whole, its status resolved by running status, a real time byte alone wherever it falls, a system exclusive in pieces of up to three bytes with its F0 and F7 among them, which a status byte other than real time ends with an F7; a data byte without status and an F7 outside a system exclusive are dropped. A byte completes two pieces at most
Npci	Verbs of a PCI device as its system names them
Cdma	Physical DMA stream descriptor
Csegment	Run of device addresses, as a DMA engine takes it
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
Cshared	Process's holders share one: the first turns the deep idle states off, the last restores them
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
Npresent
Cbitmap	Bits each named: names() the (name, bit) pairs
Cchoice	One of options(): the (name, value) pairs the struct allows as it stands
Cpower2	Power of two, and the half-way values, from min to max
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
Cmirror	Transport settings' mirror (dx::stream::settings, a hosted device's): born with the IOCTL, the setting mapped to the kernel's
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
Ccircular	Circular of the driver's, mapped into this client: opened by its target, its participant event the broadcast the driver signals
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
Cpromoted	Value its driver serves as an IOCTL, mirrored: asked on its first access, a wish sent and the driver's answer committed - the driver is the authority -, and read back on every change the driver signals (the device's broadcast) - a kernel driver's through its proxy device, a service's through its connection (dx::service::connection)
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)
Nplatform
Cnotification	User's notifications on UNUserNotificationCenter: an app's alone - a bundle stating its identifier, which LaunchServices validates where it lies (/Applications, ~/Applications; not a temporary directory) - any other process posts nothing. The first one asks the user's permission once, without waiting for it; refused, nothing shows. The lines of a burst - an exception's report - are one notification titled with the app's name, posted once the stream stood still for half a second; the end posts what is pending and waits for every post to arrive, at most two seconds
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 line to each sink whole, its start prefixed by the writing thread's indent. A writer never waits: it gathers its line and puts it into the distributor's dx::log::circular at the line end (at sync() too, where the stream does not flush every insertion); whoever finds the sinks free (io_mutex) takes the ring into them. 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 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
Cnotification	Stream's lines as the user's notifications, beside its other sinks: the app's, grouped by the stream
Cpipe	Sinks a dx::log::pipe names, joined to std::cerr, std::clog and std::cout for the object's life
Cscreen	Terminal's live block below its scrolling text: a row per writer whose line stands open, as its own terminal would show it - a carriage return returns to the row's start, the text after it overwrites the row in place, a line end closes the row into the text above. Without an open row a line passes as it is. Every distributor on the terminal draws through the one screen, under io_mutex
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
Nregistry	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
Cdevice	Registry entry behind a device: its class, the bundle that provides it and every property it publishes
Cproperty
Nservice	Service interface namespace
Nclient
C_device	Service client streaming device interface class: the device the service hosts under <product id>/<puuid>, its settings the service's - mirrored as a kernel driver's values are (dx::proxy::promoted) over the connection
Cmirror	Transport settings' mirror (dx::stream::settings, a hosted device's): the setting mapped to the service's IOCTL
Cdevice	< the app's consumer group (dx::stream::engine::group) wraps this bus's own
Cdriver	Service's device tree as a client sees it: its devices the service's (dx::ioctl::service::devices), taken anew on every broadcast - a device the service no longer lists removed, one it lists anew added -, every device gone while the service does not answer
Cproperty
Cgroup	Service client's own streaming group: its transport side is the service's
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
Ctarget	Service client stream's whole hardware identity: its direction - the device behind the service names its own
Nplatform
Cconnection	MacOS: a client's connection to a service - a launchd mach service, or a listener below it - over XPC
Cpipe	Windows: one end of a service's named pipe - a message pipe, read and written overlapped: Windows serializes the synchronous operations on a process' pipes
Nstream
Cdevice	Streaming device the service hosts: its rings the service's, in shared memory, a client a participant in them
Cpeer
Caccept
Cto
Capp	MacOS: the service a launchd daemon - its mach service the plist's (dxd_daemon), launchd starting it at a client's first message: it runs until launchd or the console ends it (SIGTERM, SIGINT)
Cclock	Dx::ioctl::service::clock's data: the client's clock event by its name, and the client's iosize
Cconnection	Client's connection to a service: its IOCTLs in the forms a kernel driver's client takes them, so a mirror of a kernel's value (dx::proxy::promoted) mirrors the service's alike - asked on its first access, told a wish and read back on every broadcast
Ccreate	Dx::ioctl::service::create's data: the device's id and its desc
Cdevice	Device the service hosts, served under <product id>/<puuid> as a kernel driver serves its device: a peer per client connection, its IOCTLs landing in ioctl()
Cpeer	Client's connection to the device: what it asks the device answers, while the client stands the device stands
Cdriver	Device tree hosted by the service: the driver served under its product id as a kernel driver serves its client - a client's IOCTL lands in ioctl(), every arrival and removal is the broadcast
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
Cpeer	Client's connection to the driver: what it asks the driver answers
Cproperty	This bus's name in the device tree and the preference store
Cendpoints	MacOS: the endpoints of this process' listeners by their ids - launchd registers a daemon's plist's mach services alone, so a listener whose id names a part below the service (<service>/<device>) is anonymous, and the service's listener hands its endpoint to a client asking with that id under endpoint
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
Cmessage	Head of every message on a service connection, its data behind it: a request, its reply or the service's broadcast
Cparser	MacOS: the service's command line - launchd installs and starts it (the product's package), so it runs in the console alone
Cpeer	Client's connection as the service sees it - the service's counterpart of a kernel driver's client: what the client asks lands in ioctl(), its connection's end destroys it
Cserver	MacOS: a service's listener - a launchd mach service, or an anonymous one below it (dx::service::endpoints) - a peer per client connection
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
C[struct].shared
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
Cdevice	Bus device plus the streaming engine its app session runs on - attached in launch(), released in conclude(), so the engine's lifetime is the device's own and a call holding the device holds the engine
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
C[struct].cache
C[struct].cache.sync
C[struct].cache.sync.io
C[struct].cache.sync.io.pin
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
C[struct].performance
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
Cconfiguration	Device's configuration, the value the promoted configuration holds: the bus entity selecting it and, per stream, the index of its active stream configuration - one past the stream's configurations: the stream is off
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
Cclock
Csync
Cconfig	Dx::desc::stream::config interface descriptor
Cclock
Coptions
Cquirk	Where the device departs from its class: what it does is the opposite of what its class descriptors state
Cspdif
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
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
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
C[struct].hw
C[struct]registration.hw.__unnamed0__	Consumer's registration: its event, its own iosize and sample counter - the counter the tick's alone, a reset asked of it
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
C[struct].__unnamed0__
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
Crow	Conversions of one participant's sample type against every ring format: sample picks the ring's column
Centry
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
C[struct].cache
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 commands of the test app: the connection's state, and an echo round trip test - against the service, or a server of the test's own
Nstream	Streaming tests over a bus's command set
Cdevice	Test harness's device with 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
C[struct].phase
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
Cunit_test	Unit test's rows and timing: the device's own, or the ones a driver's unit test hands every device it runs
Cdriver	Bus's command set with the streaming tests: a device with a streaming engine is testable
Nsurprise	Device tree arrival and removal under load: what a replug does to a running session, without a hand at the cable
Casynchronous	Surprise removals of the devices under test in turn, one every interval, on a thread of its own
Nusb
Cdriver	Raw USB commands beside the generic ones: every hub's periodic bus time
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 - a derived device adds its commands to the parser's
Cdriver	One bus's command set: the driver of that bus plus the commands the CLI dispatches on it
Cload	Load scenario the streaming monitor runs its session under: threads of the named kind for the object's lifetime
Ctable	Command's results as a table: its head once, a row per run beneath the one before - the run's seconds and its share of the duration ahead of the command's columns
Ccolumn
Crow	One run's row: true until stopped or the duration is over - asked, it rewrites itself in place every 20 ms, the cursor hidden; its end writes the last state, where it ran, and shows the cursor again
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	Verbs of a USB device as its system names them
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
Nto
C[struct].analog_connector	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].communication_speaker	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].da_stream	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].desktop_microphone	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].desktop_speaker	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].digital	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].digital_interface	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].down_line_phone	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].dv_stream	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].echo_canceling	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].echo_suppressing	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].handset	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].head_mounted	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].headphones	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].headset	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].legacy_connector	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].lfe	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].lfe_speaker	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].line	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].line_connector	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].microphone	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].microphone_array	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].omni_microphone	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].personal_microphone	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].phone_line	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].processing_microphone	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].room_speaker	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].spdif	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].speaker	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].speakerphone	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].synth	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].synthesizer	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].telephone	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].tty	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
C[struct].usb_streaming	What such a terminal is as a plug of a pin: what the two vocabularies share - a terminal the list leaves out keeps its number, since no word of dx::stream::plug names it
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
C[struct].delivered
C[struct].detected
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
C[struct].correlated
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 clock domain endpoint's request pipeline and data move over the slots of a round, the same in every environment
C[struct].cache
C[struct].sync
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 - a group pipe's and an isochronous one's queue their 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
C[struct].adc
C[union].adc.__unnamed0__
C[struct].adc.__unnamed0__.v2
C[struct].adc.__unnamed0__.v2.clock
C[struct].adc.__unnamed0__.v2.clock.selector
C[struct].adc.__unnamed0__.v2.clock.source
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
C[struct].transaction_size
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
Cstring	String descriptor at its largest, the same on every platform: UTF-16LE, its length device supplied and untrusted; inside it head is its base's injected class name, so the union's member is named qualified
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
Chub
Cport	Port's connection: the device's descriptor, speed and open pipes
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
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
C[struct].cycle
Cchannel	Copy/mix channel converters
Cchannel<dst_t, src_t>	Same width, or floating point on both sides: the sample moves as it stands
Cconversion	What one pair of sample types moves with: the loops of channel, and the widths the transfers step by
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: signalled when the kernel triggers it, or its callback called instead - on the thread of the kernel's async notifications
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
Chwid	Model's hardware id as its bus enumerates it, off its desc at compile time: USB\VID_xxxx&PID_xxxx, PCI\VEN_xxxx&DEV_xxxx - PCI\CC_xxxxxx for a PCI model without vendor id, its model id the class code -, a software device's the product's urid; empty on a bus without one - the models of a product's inf (kernel/dxd_models.cpp) and the installer's devices alike
Cint24	Packed 24 bit integer, little endian: its low 16 bits and its high byte accessed as such - the two accesses clang makes of a packed 24 bit field -, sign extended
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
Cint32be	32 bit integer stored big endian: converts from and to the native int on every access, so the circular's converters take it like int32_t
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 named by the subject given that the root signed, that covers the device's vendor and model, 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 two 32 bit words: the level - a dx::log::level per dx::log::scope per dx::log::module, four bits each - and the pipes (dx::log::pipe), where the lines go. The words are what a driver, a kernel, a host and a firmware 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 macro hands the member list to the tree sink of dx_serialize.h, so a store - the plugin property's dictionary as a cf::store among them - holds the log resolved rather than the words
C[union].__unnamed0__
C[struct].__unnamed0__.__unnamed0__
Ccircular	Log's lines from any number of writers, lock free: a writer reserves its entry at tx - a length word and the line, padded to the word - and writes the length word last; the one reader takes the entries whose length word stands and clears them behind it, so a zero length is a line not written yet The ring's size is a multiple of the word, so a length word never wraps
Cfrom
Cmodule	Parts of a driver a message is attributed to, each with its own dx::log::scope
Cfrom
Cto
Cpipe	Where the std streams' lines go: the dx::log::pipe::sinks of each - a stream naming no sink of the process drops its lines
C[struct].__unnamed0__
Csinks	Stream's sinks, a bit each in the order of name
C[struct].__unnamed0__
Cscope	Phases a module is logged apart in - a device's setup may be traced while its operation stays quiet
Cfrom
Cto
Cto
Cmatch	Which devices a bus takes: any of its dictionaries whose every verb the device states alike, an empty dictionary every device
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
C[struct].flags
Cpci	Physical PCI stream descriptor
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
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)
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
Cuint24	Packed 24 bit unsigned integer, little endian: its low 16 bits and its high byte accessed as such
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
Ndxd	Dynax driver framework kernel namespace
Nabstract
Cevent	Abstract::event: base clase to event<dx::user> and event<dx::kernel> to allow mixed user/kernel broadcast signalization
Naudio	AudioDriverKit binding - the DriverKit counterpart of portcls/wavert
Cdevice	AudioDriverKit binding of a clocked streaming device: one IOUserAudioDevice per desc, one IOUserAudioStream per audio pin
Cendpoint
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
Nfirewire	IEEE 1394
Nplatform	Dynax driver framework kernel namespace
Cdevice	Windows FireWire unit transport: the 1394 bus driver's request blocks, on plain WDM and KMDF alike
Caddress	Address range this driver publishes on the bus: a node writing into it hands its data over through the FIFO entries, write() takes them
Cphy	Physical address space: host memory another node reaches by its own DMA, as runs of bus addresses (segment)
Cform	Windows form's reach to the 1394 bus driver below, the layer between the form's device and the transport: send() hands the bus driver a request block - specialized per form beside its device (plain WDM: dxd_firewire_platform_device.h, KMDF: dxd_kmdf_firewire_platform_device.h)
Cform<dxd::platform::device>	Plain WDM: a request block an internal device control to the device object below, which completes it within the bus's own timeouts
Cform<kmdf::device>	KMDF: a request block the framework's I/O target's, which bounds it by the caller's timeout
Cirb	One 1394 request block per request kind: each specialization fills the union member its request uses, so a caller states the request's own arguments and never the SDK's union
Cirb<REQUEST_ALLOCATE_ADDRESS_RANGE>
Cirb<REQUEST_ASYNC_LOCK>
Cirb<REQUEST_ASYNC_READ>
Cirb<REQUEST_ASYNC_WRITE>
Cirb<REQUEST_BUS_RESET_NOTIFICATION>
Cirb<REQUEST_FREE_ADDRESS_RANGE>	Address range's removal - the DeviceExtension as at the allocation
Cirb<REQUEST_GET_GENERATION_COUNT>
Cirb<REQUEST_GET_LOCAL_HOST_INFO>
Ccontroller	IEEE 1394 OHCI host controller: the link the OS matched by its PCI class, its GUID the device's puid
Cdevice	IEEE 1394 unit: the asynchronous transactions a unit's driver issues to its node, on every platform
Nkmdf	KMDF bound device framework: the WDF driver model beside plain WDM (dxd::platform), on the same contract (dxd::driver/device/client)
Npci	PCI devices on KMDF
Cdevice	KMDF PCI device: the PCI half's interface (PCI devices) on the framework
Cscatter_gather
Cdevice	KMDF device: the contract's hooks on the framework's callbacks, its clients created per file object
Cdriver	WDF driver, one per driver object: the framework device objects with their queue and interface, its devices made by the product's create()
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
Nmodels	Product's models as the lines of its inf and plist templates
Chex	Value as 0x and its digits
Cline
Clines
Nmultichannel
Cstream	Generic kernel multichannel stream
C[struct].control
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
C[struct].cache
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
Npci	PCI devices
Cbars	Windows PCI device's BARs, each by its index: what the WDM and the KMDF half (PCI devices) share
Cdevice	DriverKit PCI device: its nub opened with bus mastering and memory space, its memory and interrupts
Cscatter_gather	Memory's device addresses below 1<< limit_t, from initialize() to free(): mapped by the device's IOMMU (DART), in at most the 32 runs one preparation hands
Cscatter_gather	Buffer's device addresses below 1<< limit_t, from initialize() to free()
Nplatform	Platform branch: DriverKit
Cdevice	DriverKit device: the plain C++ object its IOService shell (dxd_device) holds
Cclient	Open of the device: one per dxd_user_client the device's shell opens
Cdriver	DriverKit driver: the plain C++ object its shell holds, making the devices the host asks for
Cclient	Open of the driver itself: one per dxd_user_client of the type dx::ioctl::driver::client the driver's shell opens - the one way to create and destroy devices
Cform	Form's construction: it registers with the OS, then installs dispatch()
Csession	What the user client shell (dxd_user_client) serves: a device's client or the driver's
Nportcls	PortCls: the driver form owning the WDM dispatch, audio subdevices on WaveRT and DMus miniports
Cadapter	PortCls adapter driver
Cdevice	Per-FDO adapter device: miniport subdevices are created in start()
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 conversions those rings are moved with - everything a client's tick needs, none of it shared
C[struct].control	Buffer switch bookkeeping every pin the client attached follows: both directions switch together
Cconfiguration_server	Device's configuration: the device's alignment of the wish - a bus device narrows it to what its bus carries - and the value it stands at while a stream is started; every ring whose stream configuration changes binds to its new one ahead of the commit, a ring that cannot stands and the wish is aligned around it (desc::bound())
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
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
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
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
Ctransport_server	Transport's settings in the dx::stream::setting order - its wait strategy, its lead out and in - the desc's defaults until a client sets them, committed and handed to the bus running the transport
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
Nvirtuel
Nstream	Virtual streaming device, the kernel's counterpart of user mode's dx::virtuel::stream::device
Cclock_server	Runs the device clock while streams are started, from within started's promoted server
Cdevice	Virtual streaming device: an autonomous tick source drives its single clock domain, the endpoints above it move on the lines it advanced
Cclock	Autonomous software tick source for this device's single clock domain
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	Atomic scalar on the compiler's builtins - a dext has no interlocked KPI and needs none
C__atomic_scalar<4, type_t>	32bit atomic operations
C__atomic_scalar<8, type_t>	64bit atomic operations
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
Clistener	Client's listener: the user event of the IOCTL that registered it, woken by every signal() until another registration replaces it or the client goes
Cbuffer	DriverKit memory buffer: whole pages
Cbus	WDM BUS class
Cdesc	Device description for bus class
C[struct].matching
C[struct].node
Cclock	DriverKit periodic software clock, mirroring dx::clock's tick()/run()/halt() shape
Ccompletion	IOCTL call in flight on a client, which a user event registered by that call binds to
Cdecay	No array/function decay - not needed here
Cdevice	Device the OS publishes and user mode finds and opens
Cclient	Open of a device, created by device::client_create(): what it does not answer itself goes to its device
Cdriver	Driver: one per driver binary, holding and answering what is driver-wide
Cclient	Open of the driver itself, created by driver::client_create(): what it does not answer itself goes to the driver
Cevent	Kernel representation of a user space event
Cevent<dx::kernel>	Kernel event: auto reset, as a WDM synchronization event
Cevent<dx::user>	Kernel representation of user space event
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
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>	Buffer as its client sees it: a dext cannot map into its client, so the address stays empty
Cmemory	Virtual DriverKit memory description
Cmutex	Mutex
Copen
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
Cpower	OS's power management bound to a driver form's devices (Driver architecture (future): one shape on every platform): one specialization per form
Cpower<kmdf::driver>	KMDF power policy: the framework owns it, each device's D0 entry and exit tell the device (kmdf::device)
Cpower<platform::driver>	DriverKit power policy: the device shell's SetPowerState tells its device
Cpower<portcls::adapter>	PortCls power policy: PortCls owns the IRPs and tells each adapter device its device state
Cprocess	Process: launch() on a queue of its own, the event signalled on its way out
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	Dext runs at no interrupt level: what the kernel platforms take a spinlock for is a mutex here
Cstream	Generic kernel stream
Cmappings	Client's mappings of the rings it opened, each by the id its memory type carries
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