Class cf::array< cf_array_t, cf_basetype_t >

cf::array: templatize container type

factory functionality

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

evaluate clock::status replacement (exception?)

Member dx::coreaudio::device< desc_t >::device (decltype(super::driver)&driver, decltype(super::id)&id)

coreaudio::device: validate configuration for clock settings

Member dx::coreaudio::driver< device_t >::driver (const match &matching_ids, const char *product_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

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)

evaluate if setting of kAudioDevicePropertySafetyOffset should be supported

provide channel names

kAudioSelectorControlPropertyAvailableItems: calc clock # settings offset for multiple clock support

keep track and return running state of pin

Member dx::coreaudio::server::device< pin_t >::request (uint32_t samplerate)

coreaudio::server::request(): evaluate if sample rate has to asynchronously submitted at all

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

evaluate kAudioStreamPropertyIsActive: seems to never get requested

support sample rate range

Member dx::coreaudio::server::preference::operator::CFArrayRef () const noexcept override

: coreaudio::server::preference::operator CFArrayRef(): correctly fill key array

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

Class dx::io::port

io::port: consider seperation from runloop

Class dx::open< object_t >

check destructor exception declaration

Member dx::proxy::device::device (decltype(driver)&driver, ::io_service_t id)

proxy::device: find a way to set notification port only propratary DriverKit devices and except on failure to do so.

Member dx::registry::erase (const char *key=nullptr)

registry::erase(): investigate why it's not working

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::device< super_device_t, desc_t >::dx_catchall_rethrow (, "iosize: %d (current: %d)", iosize, hw.iosize) virtual int32_t iosize() const try

stream::device calculate default iosize from desc

Member dx::stream::device< super_device_t, desc_t >::samplerate () const

dedicated stream::device::clock class

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

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

Member dx::stream::engine< device_t, pin_t, driver_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, driver_t, io_t, circular_t >::initialize (uint32_t iosize, uint64_t channel_map[2][(max_channels+63)/64]) try

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

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

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

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

Member dx::stream::pin< _desc_t, _circular_t, _device_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::stream::stream< device_t, circular_t >::samplerate () try

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

Member dx::thread::prio::realtime::initialize (const std::chrono::high_resolution_clock::duration &resolution)

dx::thread::prio: replace experimental hardcoded preemption limit with real limit obtained from machine

Member dx::trace::pretty (std::string function) noexcept

trace::pretty fix: removal of template parameter resolution hint will remove anything between '[' and ']'.

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 >::dx_catchall_rethrow () virtual void configure()

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

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

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

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

evaluate non-transaction size transmit handling

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

evaluate transaction size vs. ring buffer write size

validate rx non-clock domain handling

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::usb::stream::pipe< desc_t, circular_t >::tick (cache.granularity? cache.granularity:size/cache.linesize)

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

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

find approprate place

Member dx::virtuel::driver< device_t >::launch () override

virtual::driver::launch(): fix preference[] and remove ":" test hack

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)

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

move into performFormatChange

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

enum class

Member dxd::usb_device::speed () const

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

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)

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

: check and refuse IRQL; handle completion

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

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