Member dx::clock< scope_t, clock_t >::duration

evaluate clock::status replacement (exception?)

Member dx::coreaudio::driver< device_t >::driver (const match &matching_dictionaries, const char *id, dx::log log=dx::log{{ .bus={ .setup=log::level::dflt,.operation=log::level::dflt,},.interface={ .setup=log::level::dflt,.operation=log::level::dflt}}})

handle kext blocking https://developer.apple.com/library/content/technotes/tn2459/_index.html

Member dx::coreaudio::pin::pin (device_t &device, const typename desc_t::stream::desc &stream_desc, const typename desc_t::stream::pin::desc &pin_desc)

pin::control: find descriptive, scoping name; evaluate presence in non-kernel interface

Class dx::coreaudio::server::device< pin_t >

static OSStatus deviceSampleRateChanged(AudioObjectID inObjectID, UInt32 inNumberAddresses, const AudioObjectPropertyAddress* inAddresses, void* __nullable inClientData) { cout << "callback" << endl; return noErr; }

Member dx::coreaudio::server::device< pin_t >::io_start ()

coreaudio::device::io_start(): check stream state while waiting for cycle switch

Member dx::coreaudio::server::device< pin_t >::launch () override

make sync ref stream selectable from stream::desc

Member dx::coreaudio::server::device< pin_t >::property (target target, const ::AudioObjectPropertyAddress &address, void *property, ::UInt32 &size, bool set=false)

provide channel names

evaluate if setting of kAudioDevicePropertySafetyOffset should be supported

keep track and return running state of pin

kAudioSelectorControlPropertyAvailableItems: calc clock # settings offset for multiple clock support

Member dx::coreaudio::server::pin< stream_pin_t >::property (target target, const ::AudioObjectPropertyAddress &address, void *property, ::UInt32 &size, bool set=false)

support sample rate range

evaluate kAudioStreamPropertyIsActive: seems to never get requested

Member dx::coremidi::server::device< stream_pin_t >::launch () override

remove operator=(::MIDIDriverRef)

test if CoreMIDI device image resource exists

Member dx::coremidi::server::device< stream_pin_t >::operator= (::MIDIDriverRef plugin) noexcept

make coremidi_device private

Member dx::coremidi::server::pin< stream_pin_t >::dx_catchall () void send(const

coremidi::server::pin::send(): multi port support utilizing split stream this->index mask

Member dx::driver< device_t >::clear () noexcept

check if exception catching needed for device::conclude()

Class dx::generic::driver

distinguish between "driver not installed" and "no device"

Member dx::generic::driver::driver (const match &matching_dictionaries, const char *id, dx::log log)

handle kext blocking https://developer.apple.com/library/content/technotes/tn2459/_index.html

Class dx::io::port

io::port: consider seperation from runloop

Class dx::open< object_t >

check destructor exception declaration

Member dx::sc::preference::dx_catchall_rethrow () preference &commit()

cs::preference: hack commit/apply: exchange dx_assert with dx_pass again

Member dx::shared::memory< buffer_t >::initialize (const std::string &name, size_t size=sizeof(buffer_t)) try

shared::memory: buffer initialization @ version mismatch!

Struct dx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::stream::config

move target from stream to stream::config to relate USB alternate interface settings to the configuration

Member dx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::stream::pin::line

use USB terminal ids and DEFINE_USB_TERMINAL_GUID

Member dx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations >::stream::pin::name [0x40]

remove redundant pin_desc typedef once the llvm understands templates (coremidi)

Member dx::stream::engine< device_t, pin_t, io_t, circular_t >::arrived () override

forward pin creation exception to be thrown at engine::start()

Member dx::stream::engine< device_t, pin_t, io_t, circular_t >::free () noexcept

replace test for valid pin by overwise keeping track of allocated channels

Member dx::stream::engine< device_t, pin_t, io_t, circular_t >::initialize (uint32_t iosize, uint64_t channel_map[2][(max_channels+63)/64])

clock already runnning with different iosize: check if engine should be initialized with current iosize

stream::engine::initialize(): define sync reference pin

Member dx::stream::engine< device_t, pin_t, io_t, circular_t >::tick () override

enable re-sync with correct rx/tx position dependent clock event time point

Member dx::stream::pin< _desc_t, _circular_t, _device_t >::stop (bool force=false) try

connect flush

Member dx::usb::audio::isoc::cycle::tick::initialize (uint32_t micro_frames, uint32_t lines, uint32_t line_size)

usb::isoc::cyclce::tick::initialize(): evaluate a more equal aux line distribution across all cycle ticks

Member dx::usb::midi< buffer_t >::encode (const uint8_t *os_midi_package, size_t length, uint8_t cable)

cleanup issue with stl not available in kernel:

Member dx::usb::platform::device::opened

add runloop ////////////////////////////////////////////////////////////////////////////

Member dx::usb::stream::device< desc_t >::configure ()

usb::stream::device::configure(): support odd sample rate ranges

Member dx::usb::stream::device< desc_t >::samplerate (uint32_t samplerate) try

dedicated usb::stream::device::clock class

Member dx::usb::stream::pin< _desc_t, _circular_t, _device_t, pipe_t >::pin (device_t &device, const typename desc_t::stream::desc &stream_desc, const typename desc_t::stream::pin::desc &pin_desc)

pin::control: find descriptive, scoping name; evaluate presence in non-kernel interface

Member dx::usb::stream::pipe< desc_t, circular_t >::if (!cache.buffered||config.transaction.vendor)

evaluate non-transaction size transmit handling

Member dx::usb::stream::pipe< desc_t, circular_t >::if (started)

USB HW clock support: hardcoded to USB/out - needs to be handled by clock class

usb::stream::pipe::received(): evaluate checking for valid sizes

Member dx::usb::stream::pipe< desc_t, circular_t >::if (started &&config.clock.domain) if(cache.buffered)

evaluate transaction size vs. ring buffer read size

Member dx::usb::stream::pipe< desc_t, circular_t >::if (!cache.buffered||config.transaction.vendor)

log async write callback

Member dx::usb::stream::pipe< desc_t, circular_t >::pipe (usb::stream::device< desc_t > &device, const desc &desc)

reset max frame size when pipe is closed

Member dx::usb::stream::pipe< desc_t, circular_t >::received (os_result status, size_t size) override try

validate rx non-clock domain handling

evaluate transaction size vs. ring buffer write size

log async write callback

evaluate non-transaction size transmit handling

Member dx::usb::stream::pipe< desc_t, circular_t >::samplerate () try

reference dedicated usb::stream::device::clock class

Member dx::version (const std::string &package)

find approprate place

Member dxd::device::query (const char *key, type_t &value)

move into property class

Member dxd::dmus::miniport< stream_t >::GetDescription (::PCFILTER_DESCRIPTOR **out_filter) override

in(): compile only: statics can't be conditionally initialized. move to be a member!

Member dxd::each (::OSIterator *iterator, exec_arg_t exec_arg, exec_t exec)

deduct exec_t return type

Member dxd::engine::initHardware (::IOService *provider)

release audiostream

compute latencies and CoreAudio safty offsets

Member dxd::event< dx::kernel >::wait_any (os_event wdm_event, int64_t time=0)

check if event index really needs to be returned in os_result.

Class dxd::event< scope >

auto-reset variant

Member dxd::fw::lock_compare_swap (unsigned int src, unsigned int compare, uint64_t space, int64_t timeout=msec)

swap template

Class dxd::fw::phy

templatize endianism!

Member dxd::fw::phy::initialize (const dxd::fw &fw, ::MDL *mdl, unsigned int &segments, sgl_t &sgl)

remove workaround using pseudo address space if physical memory is located above 4GB (Bill cannot handle this bidirectionally: content will not be flushed back from bounce buffers)

Class dxd::guid

guid: find appropriate place

Member dxd::iostream::initWithAudioEngine (::IOAudioEngine *engine,::IOAudioStreamDirection direction, unsigned int channel_id, const char *description=0,::OSDictionary *properties=0)

move into performFormatChange

check if every physical USB bit resolution leads to own CoreAudio IOAudioStreamFormat

Member dxd::pci::scatter_gather< limit_t, alignment_t, page_size_t >::initialize (device &, ::IOMemoryDescriptor *iokit_memory_descriptor, unsigned int &pages, sgl_t &sgl, unsigned int limit=limit_t, unsigned int alignment=alignment_t, unsigned int page_size=page_size_t)

templatize endianism!

Member dxd::usb_device::conclude () override

investigate if reset() is still needed here

Member dxd::usb_device::pipe::max_frame_size (unsigned int frame_size)

implement WDK USB max_frame_size() bandwidth adjustment

Member dxd::usb_device::pipe::pipe (::IOUSBHostDevice *, ::IOUSBHostInterface *iokit_usb_interface, unsigned char address)

evaluate to get isoc.line_size from generic USB descriptor

Member dxd::usb_device::pipe::state () const

find out if isInactive() is equivalent to getState()

Member dxd::usb_device::pipe::write (const::MDL *mdl) const

return number of written bytes

Member dxd::usb_device::request (const dx::usb::control &control, data_t &data)

USB device control request timeout

Member dxd::usb_device::speed () const

implement WDK low/super speed check for dxd::usb_device.speed()

Member dxd::usb_device::speed

enum class

Member dxd::usb_device::state () const

find out if isInactive() is equivalent to getState()

Member dxd::usb_stream_client::ioctl (unsigned int ioctl, const void *in, size_t size_in, void *out, size_t size_out, size_t &size) override

clean way of switching SR of device or endpoint, /when streams are opened or closed

Member dxd::usb_stream_client::map

make readonly: MdlMappingNoWrite

Member dxd::usb_stream_device::ioctl (unsigned int ioctl, const void *in, size_t size_in, void *out, size_t size_out, size_t &size) override

clean way of switching SR of device or endpoint, /when streams are opened or closed

Member dxd::usb_stream_device::stream::initialize (unsigned int line_size, unsigned int cycles, unsigned int samplerate)

initialize also RX isoc when no extralines are required

reset max frame size when pipe is closed

Member dxd::usb_stream_device::stream::start (bool force=false) override

compute timestamp in ticks (not nsec)!

Member dxd::usb_stream_device::stream::stream (class usb_stream_device &usb_stream_device, const dx::stream::open< dx::usb::endpoint > &open)

default sample rate from clock description

dxd::usb::stream: follow dxd stream changes

Member dxd::wdm::irp< synchrony_t >::ioctl (const void *post, size_t post_size, unsigned int ioctl, void *receipt, size_t receipt_size, bool internal=false)

: check and refuse IRQL; handle completion

:for asynchronous IRP request: move buffered copy into completion!