azo 0.0.8

Re-implementation of ASIO (Audio Stream Input/Output)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use std::ffi::{c_long, c_void};
use std::sync::Mutex;
use std::sync::atomic::{AtomicU8, AtomicUsize, Ordering};
use std::{ptr, slice, thread};
use azo::dto::ChannelId;
use azo::sys::*;

fn main() {
	let driver =
		azo::get_drivers()
		.unwrap()
		.into_iter()
		.find(|meta| meta.description.to_string_lossy().starts_with("TOPPING"))
		.unwrap()
		.create_instance()
		.unwrap();
	
	assert!(driver.init(None));

	let pref = driver.buffer_size().unwrap().preferred;
	println!("pref: {pref}\n-----");
	
	let buf_ptrs = unsafe { driver.create_buffers([ChannelId { index: 0, input: false }], pref, &raw const CALLBACKS) }
    	.unwrap()
		.next()
		.unwrap();
	
	unsafe { BUF_PTRS = buf_ptrs; }
	
	println!(">> {buf_ptrs:?}");
	println!(">> {}", buf_ptrs[1].addr() - buf_ptrs[0].addr() - BUFFER_LEN_BYTES);
	
	driver.start().unwrap();
	
	thread::park();
}

const SUPPORTED_SELECTORS: &[MessageSelector] = &[
	MessageSelector::SELECTOR_SUPPORTED,
	MessageSelector::ENGINE_VERSION,
	// MessageSelector::RESET_REQUEST,
	// MessageSelector::BUFFER_SIZE_CHANGE,
	// MessageSelector::RESYNC_REQUEST,
	// MessageSelector::LATENCIES_CHANGED,
	MessageSelector::SUPPORTS_TIME_INFO,
	MessageSelector::SUPPORTS_TIME_CODE
];

const SAMPLE_SIZE: usize = 4;
const BUFFER_SIZE: usize = 8;
const BUFFER_LEN_BYTES: usize = SAMPLE_SIZE * BUFFER_SIZE;

const ALLOC_LEN_BYTES: usize = BUFFER_LEN_BYTES * ALLOC_MULT;

const BUFFER_COUNT: usize = 2;
const TOTAL_LEN_BYTES: usize = ALLOC_LEN_BYTES * BUFFER_COUNT;


static N: AtomicU8 = AtomicU8::new(1);
static mut BUF_PTRS: [*mut c_void; 2] = [ptr::null_mut(); 2];

static CALLBACKS: Callbacks = Callbacks {
    buffer_switch,
    sample_rate_did_change,
    asio_message,
    buffer_switch_time_info
};

unsafe extern "system" fn buffer_switch(buffer_index: c_long, _direct_process: Bool) {
	let n = N.fetch_add(1, Ordering::SeqCst);
	println!("n={n}:");
	
	let ptr0 = unsafe { BUF_PTRS[0] }.cast::<[u8; BUFFER_LEN_BYTES]>();
	
	for i_half in 0..BUFFER_COUNT {
		for i_row in 0..ALLOC_MULT {
			let ptr_row = ptr0.add(i_row + i_half * ALLOC_MULT);
			let row = unsafe { *ptr_row };
			println!("{row:x?}");
		}
	}
	
	
	let ptr_target = unsafe { BUF_PTRS[buffer_index as usize] }.cast::<[u8; BUFFER_LEN_BYTES]>();
	
	ptr_target.write_bytes(n, 1);
	
	if n == 10 { panic!() };
}

unsafe extern "system" fn sample_rate_did_change(_rate: SampleRate) {
	unimplemented!()
}

unsafe extern "system" fn asio_message(
	selector: MessageSelector,
	value   : c_long,
	message : *const c_void,
	opt     : *const f64
) -> c_long {
	print!("{:<20}", selector_name(selector));
	if selector == MessageSelector::SELECTOR_SUPPORTED {
		print!("value = {}", selector_name(MessageSelector(value)));
	} else if value != 0 {
		print!("value = {value}");
	} else {
		// skip
	}
	
	if !message.is_null() {
		print!("message = {message:?}");
	}
	
	if !opt.is_null() {
		print!("{}", unsafe { *opt });
	}
	println!();
	

	match selector {
		MessageSelector::SELECTOR_SUPPORTED => {
			Bool::from(SUPPORTED_SELECTORS.contains(&MessageSelector(value))).0
		}
		MessageSelector::ENGINE_VERSION => 2,
		MessageSelector::RESET_REQUEST => Bool::TRUE.0,
		MessageSelector::BUFFER_SIZE_CHANGE => Bool::TRUE.0,
		MessageSelector::RESYNC_REQUEST => Bool::TRUE.0,
		MessageSelector::LATENCIES_CHANGED => Bool::TRUE.0,
		MessageSelector::SUPPORTS_TIME_INFO => Bool::FALSE.0,
    	MessageSelector::SUPPORTS_TIME_CODE => Bool::FALSE.0,
		_ => Bool::FALSE.0
	}
}

unsafe extern "system" fn buffer_switch_time_info(
	_params             : *const Time,
	_double_buffer_index: c_long,
	_direct_process     : Bool
) -> Time {
	unimplemented!()
}

fn selector_name(selector: MessageSelector) -> &'static str {
	match selector {
		MessageSelector::SELECTOR_SUPPORTED => "SELECTOR_SUPPORTED",
		MessageSelector::ENGINE_VERSION     => "ENGINE_VERSION",
		MessageSelector::RESET_REQUEST      => "RESET_REQUEST",
		MessageSelector::BUFFER_SIZE_CHANGE => "BUFFER_SIZE_CHANGE",
		MessageSelector::RESYNC_REQUEST     => "RESYNC_REQUEST",
		MessageSelector::LATENCIES_CHANGED  => "LATENCIES_CHANGED",
		MessageSelector::SUPPORTS_TIME_INFO => "SUPPORTS_TIME_INFO",
		MessageSelector::SUPPORTS_TIME_CODE => "SUPPORTS_TIME_CODE",
		_ => "unknown"
	}
}