dxd - dynax driver framework 2.1.0d48
cross platform open source driver development framework
Loading...
Searching...
No Matches
Todo List
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::error,.operation=log::level::error,},.interface={ .setup=log::level::error,.operation=log::level::error}}})
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)

kAudioSelectorControlPropertyAvailableItems: calc clock # settings offset for multiple clock support

provide channel names

evaluate if setting of kAudioDevicePropertySafetyOffset should be supported

keep track and return running state of pin

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])

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, 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 >::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 (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

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::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!

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

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)

: check and refuse IRQL; handle completion

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


(c) copyright 2009 dynamic acoustics e.U. generated on Fri Feb 23 2024

a closed source license may be obtained by requesting a written permission from dynamic acoustics e.U.
however - governmental use generally and military use especially is strictly prohibited though.