1#![doc = include_str!("../README.md")]
7#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
8#![allow(
9 clippy::approx_constant,
10 clippy::type_complexity,
11 clippy::unreadable_literal,
12 clippy::upper_case_acronyms
13)]
14#![cfg_attr(docsrs, feature(doc_cfg))]
15
16use glib_sys as glib;
17use gobject_sys as gobject;
18
19#[cfg(unix)]
20#[allow(unused_imports)]
21use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
22#[allow(unused_imports)]
23use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
24#[allow(unused_imports)]
25use std::ffi::{
26 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
27};
28
29#[allow(unused_imports)]
30use glib::{gboolean, gconstpointer, gpointer, GType};
31
32pub type HitakiAlsaFirewireError = c_int;
34pub const HITAKI_ALSA_FIREWIRE_ERROR_FAILED: HitakiAlsaFirewireError = 0;
35pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_OPENED: HitakiAlsaFirewireError = 1;
36pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_NOT_OPENED: HitakiAlsaFirewireError = 2;
37pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_USED: HitakiAlsaFirewireError = 3;
38pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_LOCKED: HitakiAlsaFirewireError = 4;
39pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_UNLOCKED: HitakiAlsaFirewireError = 5;
40pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_DISCONNECTED: HitakiAlsaFirewireError = 6;
41pub const HITAKI_ALSA_FIREWIRE_ERROR_WRONG_CLASS: HitakiAlsaFirewireError = 7;
42
43pub type HitakiAlsaFirewireType = c_int;
44pub const HITAKI_ALSA_FIREWIRE_TYPE_DICE: HitakiAlsaFirewireType = 1;
45pub const HITAKI_ALSA_FIREWIRE_TYPE_FIREWORKS: HitakiAlsaFirewireType = 2;
46pub const HITAKI_ALSA_FIREWIRE_TYPE_BEBOB: HitakiAlsaFirewireType = 3;
47pub const HITAKI_ALSA_FIREWIRE_TYPE_OXFW: HitakiAlsaFirewireType = 4;
48pub const HITAKI_ALSA_FIREWIRE_TYPE_DIGI00X: HitakiAlsaFirewireType = 5;
49pub const HITAKI_ALSA_FIREWIRE_TYPE_TASCAM: HitakiAlsaFirewireType = 6;
50pub const HITAKI_ALSA_FIREWIRE_TYPE_MOTU: HitakiAlsaFirewireType = 7;
51pub const HITAKI_ALSA_FIREWIRE_TYPE_FIREFACE: HitakiAlsaFirewireType = 8;
52
53pub type HitakiEfwProtocolError = c_int;
54pub const HITAKI_EFW_PROTOCOL_ERROR_OK: HitakiEfwProtocolError = 0;
55pub const HITAKI_EFW_PROTOCOL_ERROR_BAD: HitakiEfwProtocolError = 1;
56pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_COMMAND: HitakiEfwProtocolError = 2;
57pub const HITAKI_EFW_PROTOCOL_ERROR_COMM_ERR: HitakiEfwProtocolError = 3;
58pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_QUAD_COUNT: HitakiEfwProtocolError = 4;
59pub const HITAKI_EFW_PROTOCOL_ERROR_UNSUPPORTED: HitakiEfwProtocolError = 5;
60pub const HITAKI_EFW_PROTOCOL_ERROR_TIMEOUT: HitakiEfwProtocolError = 6;
61pub const HITAKI_EFW_PROTOCOL_ERROR_DSP_TIMEOUT: HitakiEfwProtocolError = 7;
62pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_RATE: HitakiEfwProtocolError = 8;
63pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_CLOCK: HitakiEfwProtocolError = 9;
64pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_CHANNEL: HitakiEfwProtocolError = 10;
65pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_PAN: HitakiEfwProtocolError = 11;
66pub const HITAKI_EFW_PROTOCOL_ERROR_FLASH_BUSY: HitakiEfwProtocolError = 12;
67pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_MIRROR: HitakiEfwProtocolError = 13;
68pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_LED: HitakiEfwProtocolError = 14;
69pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_PARAMETER: HitakiEfwProtocolError = 15;
70pub const HITAKI_EFW_PROTOCOL_ERROR_INCOMPLETE: HitakiEfwProtocolError = -2147483648;
71pub const HITAKI_EFW_PROTOCOL_ERROR_INVALID: HitakiEfwProtocolError = -1;
72
73#[derive(Copy, Clone)]
75#[repr(C)]
76pub struct HitakiAlsaFirewireInterface {
77 pub iface: gobject::GTypeInterface,
78 pub open: Option<
79 unsafe extern "C" fn(
80 *mut HitakiAlsaFirewire,
81 *const c_char,
82 c_int,
83 *mut *mut glib::GError,
84 ) -> gboolean,
85 >,
86 pub lock:
87 Option<unsafe extern "C" fn(*mut HitakiAlsaFirewire, *mut *mut glib::GError) -> gboolean>,
88 pub unlock:
89 Option<unsafe extern "C" fn(*mut HitakiAlsaFirewire, *mut *mut glib::GError) -> gboolean>,
90 pub create_source: Option<
91 unsafe extern "C" fn(
92 *mut HitakiAlsaFirewire,
93 *mut *mut glib::GSource,
94 *mut *mut glib::GError,
95 ) -> gboolean,
96 >,
97}
98
99impl ::std::fmt::Debug for HitakiAlsaFirewireInterface {
100 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
101 f.debug_struct(&format!("HitakiAlsaFirewireInterface @ {self:p}"))
102 .field("iface", &self.iface)
103 .field("open", &self.open)
104 .field("lock", &self.lock)
105 .field("unlock", &self.unlock)
106 .field("create_source", &self.create_source)
107 .finish()
108 }
109}
110
111#[derive(Copy, Clone)]
112#[repr(C)]
113pub struct HitakiEfwProtocolInterface {
114 pub iface: gobject::GTypeInterface,
115 pub transmit_request: Option<
116 unsafe extern "C" fn(
117 *mut HitakiEfwProtocol,
118 *const u8,
119 size_t,
120 *mut *mut glib::GError,
121 ) -> gboolean,
122 >,
123 pub get_seqnum: Option<unsafe extern "C" fn(*mut HitakiEfwProtocol, *mut u32)>,
124 pub responded: Option<
125 unsafe extern "C" fn(
126 *mut HitakiEfwProtocol,
127 c_uint,
128 c_uint,
129 c_uint,
130 c_uint,
131 HitakiEfwProtocolError,
132 *const u32,
133 c_uint,
134 ),
135 >,
136}
137
138impl ::std::fmt::Debug for HitakiEfwProtocolInterface {
139 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
140 f.debug_struct(&format!("HitakiEfwProtocolInterface @ {self:p}"))
141 .field("iface", &self.iface)
142 .field("transmit_request", &self.transmit_request)
143 .field("get_seqnum", &self.get_seqnum)
144 .field("responded", &self.responded)
145 .finish()
146 }
147}
148
149#[derive(Copy, Clone)]
150#[repr(C)]
151pub struct HitakiMotuCommandDspInterface {
152 pub iface: gobject::GTypeInterface,
153 pub read_float_meter: Option<
154 unsafe extern "C" fn(
155 *mut HitakiMotuCommandDsp,
156 *const *mut [c_float; 400],
157 *mut *mut glib::GError,
158 ) -> gboolean,
159 >,
160}
161
162impl ::std::fmt::Debug for HitakiMotuCommandDspInterface {
163 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
164 f.debug_struct(&format!("HitakiMotuCommandDspInterface @ {self:p}"))
165 .field("iface", &self.iface)
166 .field("read_float_meter", &self.read_float_meter)
167 .finish()
168 }
169}
170
171#[derive(Copy, Clone)]
172#[repr(C)]
173pub struct HitakiMotuRegisterDspInterface {
174 pub iface: gobject::GTypeInterface,
175 pub read_parameter: Option<
176 unsafe extern "C" fn(
177 *mut HitakiMotuRegisterDsp,
178 *const *mut HitakiSndMotuRegisterDspParameter,
179 *mut *mut glib::GError,
180 ) -> gboolean,
181 >,
182 pub read_byte_meter: Option<
183 unsafe extern "C" fn(
184 *mut HitakiMotuRegisterDsp,
185 *const *mut [u8; 48],
186 *mut *mut glib::GError,
187 ) -> gboolean,
188 >,
189 pub changed: Option<unsafe extern "C" fn(*mut HitakiMotuRegisterDsp, *const u32, c_uint)>,
190}
191
192impl ::std::fmt::Debug for HitakiMotuRegisterDspInterface {
193 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
194 f.debug_struct(&format!("HitakiMotuRegisterDspInterface @ {self:p}"))
195 .field("iface", &self.iface)
196 .field("read_parameter", &self.read_parameter)
197 .field("read_byte_meter", &self.read_byte_meter)
198 .field("changed", &self.changed)
199 .finish()
200 }
201}
202
203#[derive(Copy, Clone)]
204#[repr(C)]
205pub struct HitakiQuadletNotificationInterface {
206 pub iface: gobject::GTypeInterface,
207 pub notified: Option<unsafe extern "C" fn(*mut HitakiQuadletNotification, u32)>,
208}
209
210impl ::std::fmt::Debug for HitakiQuadletNotificationInterface {
211 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
212 f.debug_struct(&format!("HitakiQuadletNotificationInterface @ {self:p}"))
213 .field("iface", &self.iface)
214 .field("notified", &self.notified)
215 .finish()
216 }
217}
218
219#[derive(Copy, Clone)]
220#[repr(C)]
221pub struct HitakiSndDiceClass {
222 pub parent_class: gobject::GObjectClass,
223}
224
225impl ::std::fmt::Debug for HitakiSndDiceClass {
226 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
227 f.debug_struct(&format!("HitakiSndDiceClass @ {self:p}"))
228 .field("parent_class", &self.parent_class)
229 .finish()
230 }
231}
232
233#[derive(Copy, Clone)]
234#[repr(C)]
235pub struct HitakiSndDigi00xClass {
236 pub parent_class: gobject::GObjectClass,
237}
238
239impl ::std::fmt::Debug for HitakiSndDigi00xClass {
240 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
241 f.debug_struct(&format!("HitakiSndDigi00xClass @ {self:p}"))
242 .field("parent_class", &self.parent_class)
243 .finish()
244 }
245}
246
247#[derive(Copy, Clone)]
248#[repr(C)]
249pub struct HitakiSndEfwClass {
250 pub parent_class: gobject::GObjectClass,
251}
252
253impl ::std::fmt::Debug for HitakiSndEfwClass {
254 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
255 f.debug_struct(&format!("HitakiSndEfwClass @ {self:p}"))
256 .field("parent_class", &self.parent_class)
257 .finish()
258 }
259}
260
261#[derive(Copy, Clone)]
262#[repr(C)]
263pub struct HitakiSndFirefaceClass {
264 pub parent_class: gobject::GObjectClass,
265}
266
267impl ::std::fmt::Debug for HitakiSndFirefaceClass {
268 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
269 f.debug_struct(&format!("HitakiSndFirefaceClass @ {self:p}"))
270 .field("parent_class", &self.parent_class)
271 .finish()
272 }
273}
274
275#[derive(Copy, Clone)]
276#[repr(C)]
277pub struct HitakiSndMotuClass {
278 pub parent_class: gobject::GObjectClass,
279}
280
281impl ::std::fmt::Debug for HitakiSndMotuClass {
282 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
283 f.debug_struct(&format!("HitakiSndMotuClass @ {self:p}"))
284 .field("parent_class", &self.parent_class)
285 .finish()
286 }
287}
288
289#[derive(Copy, Clone)]
290#[repr(C)]
291pub struct HitakiSndMotuRegisterDspParameter {
292 pub reserved: [u8; 512],
293}
294
295impl ::std::fmt::Debug for HitakiSndMotuRegisterDspParameter {
296 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
297 f.debug_struct(&format!("HitakiSndMotuRegisterDspParameter @ {self:p}"))
298 .finish()
299 }
300}
301
302#[derive(Copy, Clone)]
303#[repr(C)]
304pub struct HitakiSndTascamClass {
305 pub parent_class: gobject::GObjectClass,
306}
307
308impl ::std::fmt::Debug for HitakiSndTascamClass {
309 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
310 f.debug_struct(&format!("HitakiSndTascamClass @ {self:p}"))
311 .field("parent_class", &self.parent_class)
312 .finish()
313 }
314}
315
316#[derive(Copy, Clone)]
317#[repr(C)]
318pub struct HitakiSndUnitClass {
319 pub parent_class: gobject::GObjectClass,
320}
321
322impl ::std::fmt::Debug for HitakiSndUnitClass {
323 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
324 f.debug_struct(&format!("HitakiSndUnitClass @ {self:p}"))
325 .field("parent_class", &self.parent_class)
326 .finish()
327 }
328}
329
330#[derive(Copy, Clone)]
331#[repr(C)]
332pub struct HitakiTascamProtocolInterface {
333 pub iface: gobject::GTypeInterface,
334 pub read_state: Option<
335 unsafe extern "C" fn(
336 *mut HitakiTascamProtocol,
337 *const *mut u32,
338 *mut size_t,
339 *mut *mut glib::GError,
340 ) -> gboolean,
341 >,
342 pub changed: Option<unsafe extern "C" fn(*mut HitakiTascamProtocol, c_uint, c_uint, c_uint)>,
343}
344
345impl ::std::fmt::Debug for HitakiTascamProtocolInterface {
346 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
347 f.debug_struct(&format!("HitakiTascamProtocolInterface @ {self:p}"))
348 .field("iface", &self.iface)
349 .field("read_state", &self.read_state)
350 .field("changed", &self.changed)
351 .finish()
352 }
353}
354
355#[derive(Copy, Clone)]
356#[repr(C)]
357pub struct HitakiTimestampedQuadletNotificationInterface {
358 pub iface: gobject::GTypeInterface,
359 pub notified_at:
360 Option<unsafe extern "C" fn(*mut HitakiTimestampedQuadletNotification, c_uint, c_uint)>,
361}
362
363impl ::std::fmt::Debug for HitakiTimestampedQuadletNotificationInterface {
364 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
365 f.debug_struct(&format!(
366 "HitakiTimestampedQuadletNotificationInterface @ {self:p}"
367 ))
368 .field("iface", &self.iface)
369 .field("notified_at", &self.notified_at)
370 .finish()
371 }
372}
373
374#[derive(Copy, Clone)]
376#[repr(C)]
377pub struct HitakiSndDice {
378 pub parent_instance: gobject::GObject,
379}
380
381impl ::std::fmt::Debug for HitakiSndDice {
382 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
383 f.debug_struct(&format!("HitakiSndDice @ {self:p}"))
384 .field("parent_instance", &self.parent_instance)
385 .finish()
386 }
387}
388
389#[derive(Copy, Clone)]
390#[repr(C)]
391pub struct HitakiSndDigi00x {
392 pub parent_instance: gobject::GObject,
393}
394
395impl ::std::fmt::Debug for HitakiSndDigi00x {
396 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
397 f.debug_struct(&format!("HitakiSndDigi00x @ {self:p}"))
398 .field("parent_instance", &self.parent_instance)
399 .finish()
400 }
401}
402
403#[derive(Copy, Clone)]
404#[repr(C)]
405pub struct HitakiSndEfw {
406 pub parent_instance: gobject::GObject,
407}
408
409impl ::std::fmt::Debug for HitakiSndEfw {
410 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
411 f.debug_struct(&format!("HitakiSndEfw @ {self:p}"))
412 .field("parent_instance", &self.parent_instance)
413 .finish()
414 }
415}
416
417#[derive(Copy, Clone)]
418#[repr(C)]
419pub struct HitakiSndFireface {
420 pub parent_instance: gobject::GObject,
421}
422
423impl ::std::fmt::Debug for HitakiSndFireface {
424 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
425 f.debug_struct(&format!("HitakiSndFireface @ {self:p}"))
426 .field("parent_instance", &self.parent_instance)
427 .finish()
428 }
429}
430
431#[derive(Copy, Clone)]
432#[repr(C)]
433pub struct HitakiSndMotu {
434 pub parent_instance: gobject::GObject,
435}
436
437impl ::std::fmt::Debug for HitakiSndMotu {
438 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
439 f.debug_struct(&format!("HitakiSndMotu @ {self:p}"))
440 .field("parent_instance", &self.parent_instance)
441 .finish()
442 }
443}
444
445#[derive(Copy, Clone)]
446#[repr(C)]
447pub struct HitakiSndTascam {
448 pub parent_instance: gobject::GObject,
449}
450
451impl ::std::fmt::Debug for HitakiSndTascam {
452 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
453 f.debug_struct(&format!("HitakiSndTascam @ {self:p}"))
454 .field("parent_instance", &self.parent_instance)
455 .finish()
456 }
457}
458
459#[derive(Copy, Clone)]
460#[repr(C)]
461pub struct HitakiSndUnit {
462 pub parent_instance: gobject::GObject,
463}
464
465impl ::std::fmt::Debug for HitakiSndUnit {
466 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
467 f.debug_struct(&format!("HitakiSndUnit @ {self:p}"))
468 .field("parent_instance", &self.parent_instance)
469 .finish()
470 }
471}
472
473#[repr(C)]
475#[allow(dead_code)]
476pub struct HitakiAlsaFirewire {
477 _data: [u8; 0],
478 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
479}
480
481impl ::std::fmt::Debug for HitakiAlsaFirewire {
482 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
483 write!(f, "HitakiAlsaFirewire @ {self:p}")
484 }
485}
486
487#[repr(C)]
488#[allow(dead_code)]
489pub struct HitakiEfwProtocol {
490 _data: [u8; 0],
491 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
492}
493
494impl ::std::fmt::Debug for HitakiEfwProtocol {
495 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
496 write!(f, "HitakiEfwProtocol @ {self:p}")
497 }
498}
499
500#[repr(C)]
501#[allow(dead_code)]
502pub struct HitakiMotuCommandDsp {
503 _data: [u8; 0],
504 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
505}
506
507impl ::std::fmt::Debug for HitakiMotuCommandDsp {
508 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
509 write!(f, "HitakiMotuCommandDsp @ {self:p}")
510 }
511}
512
513#[repr(C)]
514#[allow(dead_code)]
515pub struct HitakiMotuRegisterDsp {
516 _data: [u8; 0],
517 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
518}
519
520impl ::std::fmt::Debug for HitakiMotuRegisterDsp {
521 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
522 write!(f, "HitakiMotuRegisterDsp @ {self:p}")
523 }
524}
525
526#[repr(C)]
527#[allow(dead_code)]
528pub struct HitakiQuadletNotification {
529 _data: [u8; 0],
530 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
531}
532
533impl ::std::fmt::Debug for HitakiQuadletNotification {
534 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
535 write!(f, "HitakiQuadletNotification @ {self:p}")
536 }
537}
538
539#[repr(C)]
540#[allow(dead_code)]
541pub struct HitakiTascamProtocol {
542 _data: [u8; 0],
543 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
544}
545
546impl ::std::fmt::Debug for HitakiTascamProtocol {
547 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
548 write!(f, "HitakiTascamProtocol @ {self:p}")
549 }
550}
551
552#[repr(C)]
553#[allow(dead_code)]
554pub struct HitakiTimestampedQuadletNotification {
555 _data: [u8; 0],
556 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
557}
558
559impl ::std::fmt::Debug for HitakiTimestampedQuadletNotification {
560 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
561 write!(f, "HitakiTimestampedQuadletNotification @ {self:p}")
562 }
563}
564
565extern "C" {
566
567 pub fn hitaki_alsa_firewire_error_get_type() -> GType;
571 pub fn hitaki_alsa_firewire_error_quark() -> glib::GQuark;
572 pub fn hitaki_alsa_firewire_error_to_label(
573 code: HitakiAlsaFirewireError,
574 label: *mut *const c_char,
575 );
576
577 pub fn hitaki_alsa_firewire_type_get_type() -> GType;
581
582 pub fn hitaki_efw_protocol_error_get_type() -> GType;
586 pub fn hitaki_efw_protocol_error_quark() -> glib::GQuark;
587 pub fn hitaki_efw_protocol_error_to_label(
588 code: HitakiEfwProtocolError,
589 label: *mut *const c_char,
590 );
591
592 pub fn hitaki_snd_motu_register_dsp_parameter_get_type() -> GType;
596 pub fn hitaki_snd_motu_register_dsp_parameter_new() -> *mut HitakiSndMotuRegisterDspParameter;
597 pub fn hitaki_snd_motu_register_dsp_parameter_get_headphone_output_paired_assignment(
598 self_: *const HitakiSndMotuRegisterDspParameter,
599 assignment: *mut u8,
600 );
601 pub fn hitaki_snd_motu_register_dsp_parameter_get_headphone_output_paired_volume(
602 self_: *const HitakiSndMotuRegisterDspParameter,
603 volume: *mut u8,
604 );
605 pub fn hitaki_snd_motu_register_dsp_parameter_get_input_flag(
606 self_: *const HitakiSndMotuRegisterDspParameter,
607 flag: *mut *const [u8; 10],
608 );
609 pub fn hitaki_snd_motu_register_dsp_parameter_get_input_gain_and_invert(
610 self_: *const HitakiSndMotuRegisterDspParameter,
611 gain_and_invert: *mut *const [u8; 10],
612 );
613 pub fn hitaki_snd_motu_register_dsp_parameter_get_line_input_boost_flag(
614 self_: *const HitakiSndMotuRegisterDspParameter,
615 boost_flag: *mut u8,
616 );
617 pub fn hitaki_snd_motu_register_dsp_parameter_get_line_input_nominal_level_flag(
618 self_: *const HitakiSndMotuRegisterDspParameter,
619 nominal_level_flag: *mut u8,
620 );
621 pub fn hitaki_snd_motu_register_dsp_parameter_get_main_output_paired_volume(
622 self_: *const HitakiSndMotuRegisterDspParameter,
623 volume: *mut u8,
624 );
625 pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_output_paired_flag(
626 self_: *const HitakiSndMotuRegisterDspParameter,
627 flag: *mut *const [u8; 4],
628 );
629 pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_output_paired_volume(
630 self_: *const HitakiSndMotuRegisterDspParameter,
631 volume: *mut *const [u8; 4],
632 );
633 pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_source_flag(
634 self_: *const HitakiSndMotuRegisterDspParameter,
635 mixer: size_t,
636 flag: *mut *const [u8; 20],
637 );
638 pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_source_gain(
639 self_: *const HitakiSndMotuRegisterDspParameter,
640 mixer: size_t,
641 gain: *mut *const [u8; 20],
642 );
643 pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_source_paired_balance(
644 self_: *const HitakiSndMotuRegisterDspParameter,
645 mixer: size_t,
646 balance: *mut *const [u8; 20],
647 );
648 pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_source_paired_width(
649 self_: *const HitakiSndMotuRegisterDspParameter,
650 mixer: size_t,
651 width: *mut *const [u8; 20],
652 );
653 pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_source_pan(
654 self_: *const HitakiSndMotuRegisterDspParameter,
655 mixer: size_t,
656 pan: *mut *const [u8; 20],
657 );
658
659 pub fn hitaki_snd_dice_get_type() -> GType;
663 pub fn hitaki_snd_dice_new() -> *mut HitakiSndDice;
664
665 pub fn hitaki_snd_digi00x_get_type() -> GType;
669 pub fn hitaki_snd_digi00x_new() -> *mut HitakiSndDigi00x;
670
671 pub fn hitaki_snd_efw_get_type() -> GType;
675 pub fn hitaki_snd_efw_new() -> *mut HitakiSndEfw;
676
677 pub fn hitaki_snd_fireface_get_type() -> GType;
681 pub fn hitaki_snd_fireface_new() -> *mut HitakiSndFireface;
682
683 pub fn hitaki_snd_motu_get_type() -> GType;
687 pub fn hitaki_snd_motu_new() -> *mut HitakiSndMotu;
688
689 pub fn hitaki_snd_tascam_get_type() -> GType;
693 pub fn hitaki_snd_tascam_new() -> *mut HitakiSndTascam;
694
695 pub fn hitaki_snd_unit_get_type() -> GType;
699 pub fn hitaki_snd_unit_new() -> *mut HitakiSndUnit;
700
701 pub fn hitaki_alsa_firewire_get_type() -> GType;
705 pub fn hitaki_alsa_firewire_create_source(
706 self_: *mut HitakiAlsaFirewire,
707 source: *mut *mut glib::GSource,
708 error: *mut *mut glib::GError,
709 ) -> gboolean;
710 pub fn hitaki_alsa_firewire_lock(
711 self_: *mut HitakiAlsaFirewire,
712 error: *mut *mut glib::GError,
713 ) -> gboolean;
714 pub fn hitaki_alsa_firewire_open(
715 self_: *mut HitakiAlsaFirewire,
716 path: *const c_char,
717 open_flag: c_int,
718 error: *mut *mut glib::GError,
719 ) -> gboolean;
720 pub fn hitaki_alsa_firewire_unlock(
721 self_: *mut HitakiAlsaFirewire,
722 error: *mut *mut glib::GError,
723 ) -> gboolean;
724
725 pub fn hitaki_efw_protocol_get_type() -> GType;
729 pub fn hitaki_efw_protocol_receive_response(
730 self_: *mut HitakiEfwProtocol,
731 buffer: *const u8,
732 length: size_t,
733 );
734 pub fn hitaki_efw_protocol_transaction(
735 self_: *mut HitakiEfwProtocol,
736 category: c_uint,
737 command: c_uint,
738 args: *const u32,
739 arg_count: size_t,
740 params: *const *mut u32,
741 param_count: *mut size_t,
742 timeout_ms: c_uint,
743 error: *mut *mut glib::GError,
744 ) -> gboolean;
745 pub fn hitaki_efw_protocol_transmit_request(
746 self_: *mut HitakiEfwProtocol,
747 category: c_uint,
748 command: c_uint,
749 args: *const u32,
750 arg_count: size_t,
751 resp_seqnum: *mut u32,
752 error: *mut *mut glib::GError,
753 ) -> gboolean;
754
755 pub fn hitaki_motu_command_dsp_get_type() -> GType;
759 pub fn hitaki_motu_command_dsp_read_float_meter(
760 self_: *mut HitakiMotuCommandDsp,
761 meter: *const *mut [c_float; 400],
762 error: *mut *mut glib::GError,
763 ) -> gboolean;
764
765 pub fn hitaki_motu_register_dsp_get_type() -> GType;
769 pub fn hitaki_motu_register_dsp_read_byte_meter(
770 self_: *mut HitakiMotuRegisterDsp,
771 meter: *const *mut [u8; 48],
772 error: *mut *mut glib::GError,
773 ) -> gboolean;
774 pub fn hitaki_motu_register_dsp_read_parameter(
775 self_: *mut HitakiMotuRegisterDsp,
776 param: *const *mut HitakiSndMotuRegisterDspParameter,
777 error: *mut *mut glib::GError,
778 ) -> gboolean;
779
780 pub fn hitaki_quadlet_notification_get_type() -> GType;
784
785 pub fn hitaki_tascam_protocol_get_type() -> GType;
789 pub fn hitaki_tascam_protocol_read_state(
790 self_: *mut HitakiTascamProtocol,
791 state: *const *mut u32,
792 count: *mut size_t,
793 error: *mut *mut glib::GError,
794 ) -> gboolean;
795
796 pub fn hitaki_timestamped_quadlet_notification_get_type() -> GType;
800
801}