Todo List

Class cf::array< cf_array_t, cf_basetype_t >

cf::array: templatize container type

Class cf::type<::CFTypeRef >

factory functionality

Class dx::asio::driver< device_t, driver_t >

strongly consider getting rid of Bills COM macro orgy https://github.com/AlexBAV/moderncom

Member dx::canonical (const std::string &name, size_t length=DX_FILENAME_LENGTH)

should move into platform as requirements are too different between macOS and Windows

Member dx::circular::atomic_add (dst_t *dst, int64_t added)

packed 24bit: no lock-free CAS on a 3-byte element - plain clip-add, not yet atomic (like the floating-point formats)

Member dx::circular::channel< dst_t, src_t >::add (dst_t *dst, const src_t *src, uint64_t bulk, uint32_t dst_gap=0, uint32_t src_gap=0, uint32_t interleaved=1)

floating-point circular formats: not yet made atomic, no concurrent writer needs it today

Struct dx::circular::interlocked< dst_t >

platform-dependent, provisionally placed here same as fence above - belongs as a shared dxd primitive once interface/'s no-dependency-on-kernel/ direction is rethought (see fence's own todo)

Member dx::coreaudio::driver< device_t >::driver (const match &matching_ids, const char *product_id, decltype(super::preference)&&preference, dx::log log={})

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

Member dx::coreaudio::driver< device_t >::notify (::AudioObjectID id, const coreaudio::property::addresses &addresses)

coreaudio::driver::notify(): evaluate other synchronization options

Member dx::coreaudio::server::device< pin_t >::configure (target target, ::UInt64 action, void *info)

coreaudio::server::device::configure(): kAudioDevicePropertyNominalSampleRate does not yet select the pin whose alternate setting matches the requested rate for devices with multiple alternate settings per stream

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

coreaudio::server::device::create_pins(): not yet filtered by negotiated sample rate for devices with multiple alternate settings per stream

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

coreaudio::server::device::io_start(): starts every pin unconditionally; not yet rate-aware for devices with multiple alternate settings per stream

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

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

coreaudio::server::device::launch():

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

provide channel names

coreaudio::server::device::property(): property::device::clients: replace cf::array by cf::dictionary with PIDs as keys

kAudioSelectorControlPropertyAvailableItems: calc clock # settings offset for multiple clock support

Member dx::coreaudio::server::pin< stream_pin_t >::io (::UInt32 operation, ::UInt32 frames, const ::AudioServerPlugInIOCycleInfo *info, void *main)

RT-unsafe: this branch logs (std::clog: heap alloc + os_log) on the coreaudiod IO thread

whenever a dropout/discontinuity occurs at the default log level. Needs a lock-free

counter/flag incremented here and drained + logged by a non-RT thread instead, so the

diagnostic survives at production log levels without doing unsafe work on this thread.

RT-unsafe: same as the ReadInput branch above (std::clog on the IO thread on dropout).

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::coreaudio::stream::device< desc_t, preference_t, stream_t, group_t >::device (decltype(super::driver)&driver, decltype(super::id)&id)

coreaudio::device: validate configuration for clock settings

Member dx::coreaudio::stream::device< desc_t, preference_t, stream_t, group_t >::process (const ::AudioTimeStamp *now, const ::AudioBufferList *input, const ::AudioTimeStamp *, ::AudioBufferList *output, const ::AudioTimeStamp *) override

evaluate this->circular->cycle.reference redudancy

Member dx::coremidi::driver< device_t >::driver (const match &matching_ids, const char *product_id, dx::log log={})

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

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 >::receive (const ::MIDIPacketList *pktlist)

coremidi::server::pin::send(): support fractional MIDI package commit

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

dx::coremidi::server::pin::receive: make MIDI flow control threshold accessible

Class dx::open< object_t >

check destructor exception declaration

Member dx::platform::license::serial (visit_t visit)

DX_SEC_ENFORCEMENT on Windows

Struct dx::promoting< preference_t, typename >

promoted::preference: consider moving default and alignment into key_value_pair<preference>

Class dx::proxy::device< preference_t >

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

Member dx::proxy::device< preference_t >::device (decltype(super::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::proxy::driver< device_t >::create (const std::string &id, const typename super::device_t::desc_t &desc) override

proxy::driver::operator bool() check if driver is installed

Member dx::proxy::driver< device_t >::match

proxy::driver::connection_id: reflect driver presence

Class dx::reference< object_t >

check destructor exception declaration

Member dx::service::device< preference_t >::user_client::device

remove service::device::user_client::device_t when VS understand to distinguish between type and member even inside lambda

Member dx::shared::memory< buffer_t >::initialize (size_t size=0)

shared::memory: buffer initialization @ version mismatch!

Member dx::source< _event_t, _clock_t >::event

evaluate clock::status replacement (exception?)

Struct dx::stream::desc< target_t, max_streams, max_pins, max_clock_settings, max_clocks, max_configurations, max_sources >::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, max_sources >::stream::pin::name [0x40]

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

Member dx::stream::device< super_device_t, _desc_t, _stream_t, _group_t >::hw

migrate hw clock generation/distribution into a dedicated clock class

Member dx::stream::engine::group< group_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::group< group_t, _pin_t, _io_t, circular_t >::initialize (uint32_t iosize, const std::vector< bool >(&channel_map)[dx::stream::direction::directions])

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

Member dx::stream::engine::group< group_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::stream< device_t, circular_t, super_stream_t, _event_t >::cache

: stream::stream::cache needs to be made protected (coreaudio::device requires cache access)

Member dx::test::driver< super_device_t, device_t, driver_t >::list (const args &={})

: remove obscure cast preventing desc::version and driver::version ambiguity due to single device streaming engine design

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< preference_t >::opened

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

Member dx::usb::stream::pipe< device_t, circular_t, stream_t >::alloc (size_t=0, bool free=true) override

reset max frame size when pipe is closed

Member dx::usb::stream::pipe< device_t, circular_t, stream_t >::isoc_buffer_create ()

dx::usb::stream::pipe: the non-buffered isoc case (see alloc() below) still only creates once, at construction, since c77a0974's this->circular null-pointer fix depends on that staying true; unexercised by any currently shipping device

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

evaluate non-transaction size transmit handling

log async write callback

Member dx::usb::stream::pipe< device_t, circular_t, stream_t >::transmitted (os_result status, size_t size) override

evaluate non-transaction size transmit handling

log async write callback

evaluate transaction size vs. ring buffer read size

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 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_t >

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::kmdf::property::fw_device_desc

Should map to kernel variant of "DEVPKEY_Device_BusReportedDeviceDesc"

Member dxd::pci::pci (::WDFDEVICE_INIT *wdf_device_init, const::GUID &guid)

find cross-platform way of selecting DMA configuration: 32/64 bit physical buffers

Class dxd::pci::scatter_gather< limit_t, alignment_t, page_size_t >

templatize endianism!

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

iterate GetScatterGatherList over mdl size until map_registers*PAGE_SIZE: http://www.osronline.com/article.cfm?id=55

Member dxd::usb::device< base_t >::speed () const

implement WDK low/super speed check for dxd::usb::device::speed() the device's own operating speed: a full speed device behind a high speed hub is full speed

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

implement WDK USB max_frame_size() bandwidth adjustment

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

return number of written bytes

return number of written bytes

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!

Class io::port

io::port: consider seperation from runloop

Member sc::_preference::commit ()

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