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#[allow(unused_imports)]
20use libc::{
21 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
22 intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE,
23};
24#[cfg(unix)]
25#[allow(unused_imports)]
26use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
27
28#[allow(unused_imports)]
29use glib::{gboolean, gconstpointer, gpointer, GType};
30
31pub type HitakiAlsaFirewireError = c_int;
33pub const HITAKI_ALSA_FIREWIRE_ERROR_FAILED: HitakiAlsaFirewireError = 0;
34pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_OPENED: HitakiAlsaFirewireError = 1;
35pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_NOT_OPENED: HitakiAlsaFirewireError = 2;
36pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_USED: HitakiAlsaFirewireError = 3;
37pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_LOCKED: HitakiAlsaFirewireError = 4;
38pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_UNLOCKED: HitakiAlsaFirewireError = 5;
39pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_DISCONNECTED: HitakiAlsaFirewireError = 6;
40pub const HITAKI_ALSA_FIREWIRE_ERROR_WRONG_CLASS: HitakiAlsaFirewireError = 7;
41
42pub type HitakiAlsaFirewireType = c_int;
43pub const HITAKI_ALSA_FIREWIRE_TYPE_DICE: HitakiAlsaFirewireType = 1;
44pub const HITAKI_ALSA_FIREWIRE_TYPE_FIREWORKS: HitakiAlsaFirewireType = 2;
45pub const HITAKI_ALSA_FIREWIRE_TYPE_BEBOB: HitakiAlsaFirewireType = 3;
46pub const HITAKI_ALSA_FIREWIRE_TYPE_OXFW: HitakiAlsaFirewireType = 4;
47pub const HITAKI_ALSA_FIREWIRE_TYPE_DIGI00X: HitakiAlsaFirewireType = 5;
48pub const HITAKI_ALSA_FIREWIRE_TYPE_TASCAM: HitakiAlsaFirewireType = 6;
49pub const HITAKI_ALSA_FIREWIRE_TYPE_MOTU: HitakiAlsaFirewireType = 7;
50pub const HITAKI_ALSA_FIREWIRE_TYPE_FIREFACE: HitakiAlsaFirewireType = 8;
51
52pub type HitakiEfwProtocolError = c_int;
53pub const HITAKI_EFW_PROTOCOL_ERROR_OK: HitakiEfwProtocolError = 0;
54pub const HITAKI_EFW_PROTOCOL_ERROR_BAD: HitakiEfwProtocolError = 1;
55pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_COMMAND: HitakiEfwProtocolError = 2;
56pub const HITAKI_EFW_PROTOCOL_ERROR_COMM_ERR: HitakiEfwProtocolError = 3;
57pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_QUAD_COUNT: HitakiEfwProtocolError = 4;
58pub const HITAKI_EFW_PROTOCOL_ERROR_UNSUPPORTED: HitakiEfwProtocolError = 5;
59pub const HITAKI_EFW_PROTOCOL_ERROR_TIMEOUT: HitakiEfwProtocolError = 6;
60pub const HITAKI_EFW_PROTOCOL_ERROR_DSP_TIMEOUT: HitakiEfwProtocolError = 7;
61pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_RATE: HitakiEfwProtocolError = 8;
62pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_CLOCK: HitakiEfwProtocolError = 9;
63pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_CHANNEL: HitakiEfwProtocolError = 10;
64pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_PAN: HitakiEfwProtocolError = 11;
65pub const HITAKI_EFW_PROTOCOL_ERROR_FLASH_BUSY: HitakiEfwProtocolError = 12;
66pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_MIRROR: HitakiEfwProtocolError = 13;
67pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_LED: HitakiEfwProtocolError = 14;
68pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_PARAMETER: HitakiEfwProtocolError = 15;
69pub const HITAKI_EFW_PROTOCOL_ERROR_INCOMPLETE: HitakiEfwProtocolError = -2147483648;
70pub const HITAKI_EFW_PROTOCOL_ERROR_INVALID: HitakiEfwProtocolError = -1;
71
72#[derive(Copy, Clone)]
74#[repr(C)]
75pub struct HitakiAlsaFirewireInterface {
76 pub iface: gobject::GTypeInterface,
77 pub open: Option<
78 unsafe extern "C" fn(
79 *mut HitakiAlsaFirewire,
80 *const c_char,
81 c_int,
82 *mut *mut glib::GError,
83 ) -> gboolean,
84 >,
85 pub lock:
86 Option<unsafe extern "C" fn(*mut HitakiAlsaFirewire, *mut *mut glib::GError) -> gboolean>,
87 pub unlock:
88 Option<unsafe extern "C" fn(*mut HitakiAlsaFirewire, *mut *mut glib::GError) -> gboolean>,
89 pub create_source: Option<
90 unsafe extern "C" fn(
91 *mut HitakiAlsaFirewire,
92 *mut *mut glib::GSource,
93 *mut *mut glib::GError,
94 ) -> gboolean,
95 >,
96}
97
98impl ::std::fmt::Debug for HitakiAlsaFirewireInterface {
99 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
100 f.debug_struct(&format!("HitakiAlsaFirewireInterface @ {self:p}"))
101 .field("iface", &self.iface)
102 .field("open", &self.open)
103 .field("lock", &self.lock)
104 .field("unlock", &self.unlock)
105 .field("create_source", &self.create_source)
106 .finish()
107 }
108}
109
110#[derive(Copy, Clone)]
111#[repr(C)]
112pub struct HitakiEfwProtocolInterface {
113 pub iface: gobject::GTypeInterface,
114 pub transmit_request: Option<
115 unsafe extern "C" fn(
116 *mut HitakiEfwProtocol,
117 *const u8,
118 size_t,
119 *mut *mut glib::GError,
120 ) -> gboolean,
121 >,
122 pub get_seqnum: Option<unsafe extern "C" fn(*mut HitakiEfwProtocol, *mut u32)>,
123 pub responded: Option<
124 unsafe extern "C" fn(
125 *mut HitakiEfwProtocol,
126 c_uint,
127 c_uint,
128 c_uint,
129 c_uint,
130 HitakiEfwProtocolError,
131 *const u32,
132 c_uint,
133 ),
134 >,
135}
136
137impl ::std::fmt::Debug for HitakiEfwProtocolInterface {
138 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
139 f.debug_struct(&format!("HitakiEfwProtocolInterface @ {self:p}"))
140 .field("iface", &self.iface)
141 .field("transmit_request", &self.transmit_request)
142 .field("get_seqnum", &self.get_seqnum)
143 .field("responded", &self.responded)
144 .finish()
145 }
146}
147
148#[derive(Copy, Clone)]
149#[repr(C)]
150pub struct HitakiMotuCommandDspInterface {
151 pub iface: gobject::GTypeInterface,
152 pub read_float_meter: Option<
153 unsafe extern "C" fn(
154 *mut HitakiMotuCommandDsp,
155 *const *mut [c_float; 400],
156 *mut *mut glib::GError,
157 ) -> gboolean,
158 >,
159}
160
161impl ::std::fmt::Debug for HitakiMotuCommandDspInterface {
162 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
163 f.debug_struct(&format!("HitakiMotuCommandDspInterface @ {self:p}"))
164 .field("iface", &self.iface)
165 .field("read_float_meter", &self.read_float_meter)
166 .finish()
167 }
168}
169
170#[derive(Copy, Clone)]
171#[repr(C)]
172pub struct HitakiMotuRegisterDspInterface {
173 pub iface: gobject::GTypeInterface,
174 pub read_parameter: Option<
175 unsafe extern "C" fn(
176 *mut HitakiMotuRegisterDsp,
177 *const *mut HitakiSndMotuRegisterDspParameter,
178 *mut *mut glib::GError,
179 ) -> gboolean,
180 >,
181 pub read_byte_meter: Option<
182 unsafe extern "C" fn(
183 *mut HitakiMotuRegisterDsp,
184 *const *mut [u8; 48],
185 *mut *mut glib::GError,
186 ) -> gboolean,
187 >,
188 pub changed: Option<unsafe extern "C" fn(*mut HitakiMotuRegisterDsp, *const u32, c_uint)>,
189}
190
191impl ::std::fmt::Debug for HitakiMotuRegisterDspInterface {
192 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
193 f.debug_struct(&format!("HitakiMotuRegisterDspInterface @ {self:p}"))
194 .field("iface", &self.iface)
195 .field("read_parameter", &self.read_parameter)
196 .field("read_byte_meter", &self.read_byte_meter)
197 .field("changed", &self.changed)
198 .finish()
199 }
200}
201
202#[derive(Copy, Clone)]
203#[repr(C)]
204pub struct HitakiQuadletNotificationInterface {
205 pub iface: gobject::GTypeInterface,
206 pub notified: Option<unsafe extern "C" fn(*mut HitakiQuadletNotification, u32)>,
207}
208
209impl ::std::fmt::Debug for HitakiQuadletNotificationInterface {
210 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
211 f.debug_struct(&format!("HitakiQuadletNotificationInterface @ {self:p}"))
212 .field("iface", &self.iface)
213 .field("notified", &self.notified)
214 .finish()
215 }
216}
217
218#[derive(Copy, Clone)]
219#[repr(C)]
220pub struct HitakiSndDiceClass {
221 pub parent_class: gobject::GObjectClass,
222}
223
224impl ::std::fmt::Debug for HitakiSndDiceClass {
225 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
226 f.debug_struct(&format!("HitakiSndDiceClass @ {self:p}"))
227 .field("parent_class", &self.parent_class)
228 .finish()
229 }
230}
231
232#[derive(Copy, Clone)]
233#[repr(C)]
234pub struct HitakiSndDigi00xClass {
235 pub parent_class: gobject::GObjectClass,
236}
237
238impl ::std::fmt::Debug for HitakiSndDigi00xClass {
239 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
240 f.debug_struct(&format!("HitakiSndDigi00xClass @ {self:p}"))
241 .field("parent_class", &self.parent_class)
242 .finish()
243 }
244}
245
246#[derive(Copy, Clone)]
247#[repr(C)]
248pub struct HitakiSndEfwClass {
249 pub parent_class: gobject::GObjectClass,
250}
251
252impl ::std::fmt::Debug for HitakiSndEfwClass {
253 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
254 f.debug_struct(&format!("HitakiSndEfwClass @ {self:p}"))
255 .field("parent_class", &self.parent_class)
256 .finish()
257 }
258}
259
260#[derive(Copy, Clone)]
261#[repr(C)]
262pub struct HitakiSndFirefaceClass {
263 pub parent_class: gobject::GObjectClass,
264}
265
266impl ::std::fmt::Debug for HitakiSndFirefaceClass {
267 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
268 f.debug_struct(&format!("HitakiSndFirefaceClass @ {self:p}"))
269 .field("parent_class", &self.parent_class)
270 .finish()
271 }
272}
273
274#[derive(Copy, Clone)]
275#[repr(C)]
276pub struct HitakiSndMotuClass {
277 pub parent_class: gobject::GObjectClass,
278}
279
280impl ::std::fmt::Debug for HitakiSndMotuClass {
281 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
282 f.debug_struct(&format!("HitakiSndMotuClass @ {self:p}"))
283 .field("parent_class", &self.parent_class)
284 .finish()
285 }
286}
287
288#[derive(Copy, Clone)]
289#[repr(C)]
290pub struct HitakiSndMotuRegisterDspParameter {
291 pub reserved: [u8; 512],
292}
293
294impl ::std::fmt::Debug for HitakiSndMotuRegisterDspParameter {
295 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
296 f.debug_struct(&format!("HitakiSndMotuRegisterDspParameter @ {self:p}"))
297 .finish()
298 }
299}
300
301#[derive(Copy, Clone)]
302#[repr(C)]
303pub struct HitakiSndTascamClass {
304 pub parent_class: gobject::GObjectClass,
305}
306
307impl ::std::fmt::Debug for HitakiSndTascamClass {
308 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
309 f.debug_struct(&format!("HitakiSndTascamClass @ {self:p}"))
310 .field("parent_class", &self.parent_class)
311 .finish()
312 }
313}
314
315#[derive(Copy, Clone)]
316#[repr(C)]
317pub struct HitakiSndUnitClass {
318 pub parent_class: gobject::GObjectClass,
319}
320
321impl ::std::fmt::Debug for HitakiSndUnitClass {
322 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
323 f.debug_struct(&format!("HitakiSndUnitClass @ {self:p}"))
324 .field("parent_class", &self.parent_class)
325 .finish()
326 }
327}
328
329#[derive(Copy, Clone)]
330#[repr(C)]
331pub struct HitakiTascamProtocolInterface {
332 pub iface: gobject::GTypeInterface,
333 pub read_state: Option<
334 unsafe extern "C" fn(
335 *mut HitakiTascamProtocol,
336 *const *mut u32,
337 *mut size_t,
338 *mut *mut glib::GError,
339 ) -> gboolean,
340 >,
341 pub changed: Option<unsafe extern "C" fn(*mut HitakiTascamProtocol, c_uint, c_uint, c_uint)>,
342}
343
344impl ::std::fmt::Debug for HitakiTascamProtocolInterface {
345 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
346 f.debug_struct(&format!("HitakiTascamProtocolInterface @ {self:p}"))
347 .field("iface", &self.iface)
348 .field("read_state", &self.read_state)
349 .field("changed", &self.changed)
350 .finish()
351 }
352}
353
354#[derive(Copy, Clone)]
355#[repr(C)]
356pub struct HitakiTimestampedQuadletNotificationInterface {
357 pub iface: gobject::GTypeInterface,
358 pub notified_at:
359 Option<unsafe extern "C" fn(*mut HitakiTimestampedQuadletNotification, c_uint, c_uint)>,
360}
361
362impl ::std::fmt::Debug for HitakiTimestampedQuadletNotificationInterface {
363 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
364 f.debug_struct(&format!(
365 "HitakiTimestampedQuadletNotificationInterface @ {self:p}"
366 ))
367 .field("iface", &self.iface)
368 .field("notified_at", &self.notified_at)
369 .finish()
370 }
371}
372
373#[derive(Copy, Clone)]
375#[repr(C)]
376pub struct HitakiSndDice {
377 pub parent_instance: gobject::GObject,
378}
379
380impl ::std::fmt::Debug for HitakiSndDice {
381 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
382 f.debug_struct(&format!("HitakiSndDice @ {self:p}"))
383 .field("parent_instance", &self.parent_instance)
384 .finish()
385 }
386}
387
388#[derive(Copy, Clone)]
389#[repr(C)]
390pub struct HitakiSndDigi00x {
391 pub parent_instance: gobject::GObject,
392}
393
394impl ::std::fmt::Debug for HitakiSndDigi00x {
395 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
396 f.debug_struct(&format!("HitakiSndDigi00x @ {self:p}"))
397 .field("parent_instance", &self.parent_instance)
398 .finish()
399 }
400}
401
402#[derive(Copy, Clone)]
403#[repr(C)]
404pub struct HitakiSndEfw {
405 pub parent_instance: gobject::GObject,
406}
407
408impl ::std::fmt::Debug for HitakiSndEfw {
409 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
410 f.debug_struct(&format!("HitakiSndEfw @ {self:p}"))
411 .field("parent_instance", &self.parent_instance)
412 .finish()
413 }
414}
415
416#[derive(Copy, Clone)]
417#[repr(C)]
418pub struct HitakiSndFireface {
419 pub parent_instance: gobject::GObject,
420}
421
422impl ::std::fmt::Debug for HitakiSndFireface {
423 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
424 f.debug_struct(&format!("HitakiSndFireface @ {self:p}"))
425 .field("parent_instance", &self.parent_instance)
426 .finish()
427 }
428}
429
430#[derive(Copy, Clone)]
431#[repr(C)]
432pub struct HitakiSndMotu {
433 pub parent_instance: gobject::GObject,
434}
435
436impl ::std::fmt::Debug for HitakiSndMotu {
437 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
438 f.debug_struct(&format!("HitakiSndMotu @ {self:p}"))
439 .field("parent_instance", &self.parent_instance)
440 .finish()
441 }
442}
443
444#[derive(Copy, Clone)]
445#[repr(C)]
446pub struct HitakiSndTascam {
447 pub parent_instance: gobject::GObject,
448}
449
450impl ::std::fmt::Debug for HitakiSndTascam {
451 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
452 f.debug_struct(&format!("HitakiSndTascam @ {self:p}"))
453 .field("parent_instance", &self.parent_instance)
454 .finish()
455 }
456}
457
458#[derive(Copy, Clone)]
459#[repr(C)]
460pub struct HitakiSndUnit {
461 pub parent_instance: gobject::GObject,
462}
463
464impl ::std::fmt::Debug for HitakiSndUnit {
465 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
466 f.debug_struct(&format!("HitakiSndUnit @ {self:p}"))
467 .field("parent_instance", &self.parent_instance)
468 .finish()
469 }
470}
471
472#[repr(C)]
474#[allow(dead_code)]
475pub struct HitakiAlsaFirewire {
476 _data: [u8; 0],
477 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
478}
479
480impl ::std::fmt::Debug for HitakiAlsaFirewire {
481 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
482 write!(f, "HitakiAlsaFirewire @ {self:p}")
483 }
484}
485
486#[repr(C)]
487#[allow(dead_code)]
488pub struct HitakiEfwProtocol {
489 _data: [u8; 0],
490 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
491}
492
493impl ::std::fmt::Debug for HitakiEfwProtocol {
494 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
495 write!(f, "HitakiEfwProtocol @ {self:p}")
496 }
497}
498
499#[repr(C)]
500#[allow(dead_code)]
501pub struct HitakiMotuCommandDsp {
502 _data: [u8; 0],
503 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
504}
505
506impl ::std::fmt::Debug for HitakiMotuCommandDsp {
507 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
508 write!(f, "HitakiMotuCommandDsp @ {self:p}")
509 }
510}
511
512#[repr(C)]
513#[allow(dead_code)]
514pub struct HitakiMotuRegisterDsp {
515 _data: [u8; 0],
516 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
517}
518
519impl ::std::fmt::Debug for HitakiMotuRegisterDsp {
520 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
521 write!(f, "HitakiMotuRegisterDsp @ {self:p}")
522 }
523}
524
525#[repr(C)]
526#[allow(dead_code)]
527pub struct HitakiQuadletNotification {
528 _data: [u8; 0],
529 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
530}
531
532impl ::std::fmt::Debug for HitakiQuadletNotification {
533 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
534 write!(f, "HitakiQuadletNotification @ {self:p}")
535 }
536}
537
538#[repr(C)]
539#[allow(dead_code)]
540pub struct HitakiTascamProtocol {
541 _data: [u8; 0],
542 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
543}
544
545impl ::std::fmt::Debug for HitakiTascamProtocol {
546 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
547 write!(f, "HitakiTascamProtocol @ {self:p}")
548 }
549}
550
551#[repr(C)]
552#[allow(dead_code)]
553pub struct HitakiTimestampedQuadletNotification {
554 _data: [u8; 0],
555 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
556}
557
558impl ::std::fmt::Debug for HitakiTimestampedQuadletNotification {
559 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
560 write!(f, "HitakiTimestampedQuadletNotification @ {self:p}")
561 }
562}
563
564#[link(name = "hitaki")]
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}