hitaki-sys 0.2.0

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

#![doc = include_str!("../README.md")]
#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
    clippy::approx_constant,
    clippy::type_complexity,
    clippy::unreadable_literal,
    clippy::upper_case_acronyms
)]
#![cfg_attr(feature = "dox", feature(doc_cfg))]

#[allow(unused_imports)]
use libc::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
    intptr_t, size_t, ssize_t, uintptr_t, FILE,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Enums
pub type HitakiAlsaFirewireError = c_int;
pub const HITAKI_ALSA_FIREWIRE_ERROR_FAILED: HitakiAlsaFirewireError = 0;
pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_OPENED: HitakiAlsaFirewireError = 1;
pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_NOT_OPENED: HitakiAlsaFirewireError = 2;
pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_USED: HitakiAlsaFirewireError = 3;
pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_LOCKED: HitakiAlsaFirewireError = 4;
pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_UNLOCKED: HitakiAlsaFirewireError = 5;
pub const HITAKI_ALSA_FIREWIRE_ERROR_IS_DISCONNECTED: HitakiAlsaFirewireError = 6;
pub const HITAKI_ALSA_FIREWIRE_ERROR_WRONG_CLASS: HitakiAlsaFirewireError = 7;

pub type HitakiAlsaFirewireType = c_int;
pub const HITAKI_ALSA_FIREWIRE_TYPE_DICE: HitakiAlsaFirewireType = 1;
pub const HITAKI_ALSA_FIREWIRE_TYPE_FIREWORKS: HitakiAlsaFirewireType = 2;
pub const HITAKI_ALSA_FIREWIRE_TYPE_BEBOB: HitakiAlsaFirewireType = 3;
pub const HITAKI_ALSA_FIREWIRE_TYPE_OXFW: HitakiAlsaFirewireType = 4;
pub const HITAKI_ALSA_FIREWIRE_TYPE_DIGI00X: HitakiAlsaFirewireType = 5;
pub const HITAKI_ALSA_FIREWIRE_TYPE_TASCAM: HitakiAlsaFirewireType = 6;
pub const HITAKI_ALSA_FIREWIRE_TYPE_MOTU: HitakiAlsaFirewireType = 7;
pub const HITAKI_ALSA_FIREWIRE_TYPE_FIREFACE: HitakiAlsaFirewireType = 8;

pub type HitakiEfwProtocolError = c_int;
pub const HITAKI_EFW_PROTOCOL_ERROR_OK: HitakiEfwProtocolError = 0;
pub const HITAKI_EFW_PROTOCOL_ERROR_BAD: HitakiEfwProtocolError = 1;
pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_COMMAND: HitakiEfwProtocolError = 2;
pub const HITAKI_EFW_PROTOCOL_ERROR_COMM_ERR: HitakiEfwProtocolError = 3;
pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_QUAD_COUNT: HitakiEfwProtocolError = 4;
pub const HITAKI_EFW_PROTOCOL_ERROR_UNSUPPORTED: HitakiEfwProtocolError = 5;
pub const HITAKI_EFW_PROTOCOL_ERROR_TIMEOUT: HitakiEfwProtocolError = 6;
pub const HITAKI_EFW_PROTOCOL_ERROR_DSP_TIMEOUT: HitakiEfwProtocolError = 7;
pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_RATE: HitakiEfwProtocolError = 8;
pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_CLOCK: HitakiEfwProtocolError = 9;
pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_CHANNEL: HitakiEfwProtocolError = 10;
pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_PAN: HitakiEfwProtocolError = 11;
pub const HITAKI_EFW_PROTOCOL_ERROR_FLASH_BUSY: HitakiEfwProtocolError = 12;
pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_MIRROR: HitakiEfwProtocolError = 13;
pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_LED: HitakiEfwProtocolError = 14;
pub const HITAKI_EFW_PROTOCOL_ERROR_BAD_PARAMETER: HitakiEfwProtocolError = 15;
pub const HITAKI_EFW_PROTOCOL_ERROR_INCOMPLETE: HitakiEfwProtocolError = -2147483648;
pub const HITAKI_EFW_PROTOCOL_ERROR_INVALID: HitakiEfwProtocolError = -1;

// Records
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiAlsaFirewireInterface {
    pub iface: gobject::GTypeInterface,
    pub open: Option<
        unsafe extern "C" fn(
            *mut HitakiAlsaFirewire,
            *const c_char,
            c_int,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
    pub lock:
        Option<unsafe extern "C" fn(*mut HitakiAlsaFirewire, *mut *mut glib::GError) -> gboolean>,
    pub unlock:
        Option<unsafe extern "C" fn(*mut HitakiAlsaFirewire, *mut *mut glib::GError) -> gboolean>,
    pub create_source: Option<
        unsafe extern "C" fn(
            *mut HitakiAlsaFirewire,
            *mut *mut glib::GSource,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
}

impl ::std::fmt::Debug for HitakiAlsaFirewireInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiAlsaFirewireInterface @ {:p}", self))
            .field("iface", &self.iface)
            .field("open", &self.open)
            .field("lock", &self.lock)
            .field("unlock", &self.unlock)
            .field("create_source", &self.create_source)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiEfwProtocolInterface {
    pub iface: gobject::GTypeInterface,
    pub transmit_request: Option<
        unsafe extern "C" fn(
            *mut HitakiEfwProtocol,
            *const u8,
            size_t,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
    pub get_seqnum: Option<unsafe extern "C" fn(*mut HitakiEfwProtocol, *mut u32)>,
    pub responded: Option<
        unsafe extern "C" fn(
            *mut HitakiEfwProtocol,
            c_uint,
            c_uint,
            c_uint,
            c_uint,
            HitakiEfwProtocolError,
            *const u32,
            c_uint,
        ),
    >,
}

impl ::std::fmt::Debug for HitakiEfwProtocolInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiEfwProtocolInterface @ {:p}", self))
            .field("iface", &self.iface)
            .field("transmit_request", &self.transmit_request)
            .field("get_seqnum", &self.get_seqnum)
            .field("responded", &self.responded)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiMotuCommandDspInterface {
    pub iface: gobject::GTypeInterface,
    pub read_float_meter: Option<
        unsafe extern "C" fn(
            *mut HitakiMotuCommandDsp,
            *const *mut [c_float; 400],
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
}

impl ::std::fmt::Debug for HitakiMotuCommandDspInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiMotuCommandDspInterface @ {:p}", self))
            .field("iface", &self.iface)
            .field("read_float_meter", &self.read_float_meter)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiMotuRegisterDspInterface {
    pub iface: gobject::GTypeInterface,
    pub read_parameter: Option<
        unsafe extern "C" fn(
            *mut HitakiMotuRegisterDsp,
            *const *mut HitakiSndMotuRegisterDspParameter,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
    pub read_byte_meter: Option<
        unsafe extern "C" fn(
            *mut HitakiMotuRegisterDsp,
            *const *mut [u8; 48],
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
    pub changed: Option<unsafe extern "C" fn(*mut HitakiMotuRegisterDsp, *const u32, c_uint)>,
}

impl ::std::fmt::Debug for HitakiMotuRegisterDspInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiMotuRegisterDspInterface @ {:p}", self))
            .field("iface", &self.iface)
            .field("read_parameter", &self.read_parameter)
            .field("read_byte_meter", &self.read_byte_meter)
            .field("changed", &self.changed)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiQuadletNotificationInterface {
    pub iface: gobject::GTypeInterface,
    pub notified: Option<unsafe extern "C" fn(*mut HitakiQuadletNotification, u32)>,
}

impl ::std::fmt::Debug for HitakiQuadletNotificationInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiQuadletNotificationInterface @ {:p}", self))
            .field("iface", &self.iface)
            .field("notified", &self.notified)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndDiceClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for HitakiSndDiceClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndDiceClass @ {:p}", self))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndDigi00xClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for HitakiSndDigi00xClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndDigi00xClass @ {:p}", self))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndEfwClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for HitakiSndEfwClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndEfwClass @ {:p}", self))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndMotuClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for HitakiSndMotuClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndMotuClass @ {:p}", self))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndMotuRegisterDspParameter {
    pub reserved: [u8; 512],
}

impl ::std::fmt::Debug for HitakiSndMotuRegisterDspParameter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndMotuRegisterDspParameter @ {:p}", self))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndTascamClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for HitakiSndTascamClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndTascamClass @ {:p}", self))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndUnitClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for HitakiSndUnitClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndUnitClass @ {:p}", self))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiTascamProtocolInterface {
    pub iface: gobject::GTypeInterface,
    pub read_state: Option<
        unsafe extern "C" fn(
            *mut HitakiTascamProtocol,
            *const *mut u32,
            *mut size_t,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
    pub changed: Option<unsafe extern "C" fn(*mut HitakiTascamProtocol, c_uint, c_uint, c_uint)>,
}

impl ::std::fmt::Debug for HitakiTascamProtocolInterface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiTascamProtocolInterface @ {:p}", self))
            .field("iface", &self.iface)
            .field("read_state", &self.read_state)
            .field("changed", &self.changed)
            .finish()
    }
}

// Classes
#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndDice {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for HitakiSndDice {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndDice @ {:p}", self))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndDigi00x {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for HitakiSndDigi00x {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndDigi00x @ {:p}", self))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndEfw {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for HitakiSndEfw {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndEfw @ {:p}", self))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndMotu {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for HitakiSndMotu {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndMotu @ {:p}", self))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndTascam {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for HitakiSndTascam {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndTascam @ {:p}", self))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct HitakiSndUnit {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for HitakiSndUnit {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("HitakiSndUnit @ {:p}", self))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

// Interfaces
#[repr(C)]
pub struct HitakiAlsaFirewire {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for HitakiAlsaFirewire {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "HitakiAlsaFirewire @ {:p}", self)
    }
}

#[repr(C)]
pub struct HitakiEfwProtocol {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for HitakiEfwProtocol {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "HitakiEfwProtocol @ {:p}", self)
    }
}

#[repr(C)]
pub struct HitakiMotuCommandDsp {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for HitakiMotuCommandDsp {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "HitakiMotuCommandDsp @ {:p}", self)
    }
}

#[repr(C)]
pub struct HitakiMotuRegisterDsp {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for HitakiMotuRegisterDsp {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "HitakiMotuRegisterDsp @ {:p}", self)
    }
}

#[repr(C)]
pub struct HitakiQuadletNotification {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for HitakiQuadletNotification {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "HitakiQuadletNotification @ {:p}", self)
    }
}

#[repr(C)]
pub struct HitakiTascamProtocol {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for HitakiTascamProtocol {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "HitakiTascamProtocol @ {:p}", self)
    }
}

#[link(name = "hitaki")]
extern "C" {

    //=========================================================================
    // HitakiAlsaFirewireError
    //=========================================================================
    pub fn hitaki_alsa_firewire_error_get_type() -> GType;
    pub fn hitaki_alsa_firewire_error_quark() -> glib::GQuark;
    pub fn hitaki_alsa_firewire_error_to_label(
        code: HitakiAlsaFirewireError,
        label: *mut *const c_char,
    );

    //=========================================================================
    // HitakiAlsaFirewireType
    //=========================================================================
    pub fn hitaki_alsa_firewire_type_get_type() -> GType;

    //=========================================================================
    // HitakiEfwProtocolError
    //=========================================================================
    pub fn hitaki_efw_protocol_error_get_type() -> GType;
    pub fn hitaki_efw_protocol_error_quark() -> glib::GQuark;
    pub fn hitaki_efw_protocol_error_to_label(
        code: HitakiEfwProtocolError,
        label: *mut *const c_char,
    );

    //=========================================================================
    // HitakiSndMotuRegisterDspParameter
    //=========================================================================
    pub fn hitaki_snd_motu_register_dsp_parameter_get_type() -> GType;
    pub fn hitaki_snd_motu_register_dsp_parameter_new() -> *mut HitakiSndMotuRegisterDspParameter;
    pub fn hitaki_snd_motu_register_dsp_parameter_get_headphone_output_paired_assignment(
        self_: *const HitakiSndMotuRegisterDspParameter,
        assignment: *mut u8,
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_headphone_output_paired_volume(
        self_: *const HitakiSndMotuRegisterDspParameter,
        volume: *mut u8,
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_input_flag(
        self_: *const HitakiSndMotuRegisterDspParameter,
        flag: *mut *const [u8; 10],
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_input_gain_and_invert(
        self_: *const HitakiSndMotuRegisterDspParameter,
        gain_and_invert: *mut *const [u8; 10],
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_line_input_boost_flag(
        self_: *const HitakiSndMotuRegisterDspParameter,
        boost_flag: *mut u8,
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_line_input_nominal_level_flag(
        self_: *const HitakiSndMotuRegisterDspParameter,
        nominal_level_flag: *mut u8,
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_main_output_paired_volume(
        self_: *const HitakiSndMotuRegisterDspParameter,
        volume: *mut u8,
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_output_paired_flag(
        self_: *const HitakiSndMotuRegisterDspParameter,
        flag: *mut *const [u8; 4],
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_output_paired_volume(
        self_: *const HitakiSndMotuRegisterDspParameter,
        volume: *mut *const [u8; 4],
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_source_flag(
        self_: *const HitakiSndMotuRegisterDspParameter,
        mixer: size_t,
        flag: *mut *const [u8; 20],
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_source_gain(
        self_: *const HitakiSndMotuRegisterDspParameter,
        mixer: size_t,
        gain: *mut *const [u8; 20],
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_source_paired_balance(
        self_: *const HitakiSndMotuRegisterDspParameter,
        mixer: size_t,
        balance: *mut *const [u8; 20],
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_source_paired_width(
        self_: *const HitakiSndMotuRegisterDspParameter,
        mixer: size_t,
        width: *mut *const [u8; 20],
    );
    pub fn hitaki_snd_motu_register_dsp_parameter_get_mixer_source_pan(
        self_: *const HitakiSndMotuRegisterDspParameter,
        mixer: size_t,
        pan: *mut *const [u8; 20],
    );

    //=========================================================================
    // HitakiSndDice
    //=========================================================================
    pub fn hitaki_snd_dice_get_type() -> GType;
    pub fn hitaki_snd_dice_new() -> *mut HitakiSndDice;

    //=========================================================================
    // HitakiSndDigi00x
    //=========================================================================
    pub fn hitaki_snd_digi00x_get_type() -> GType;
    pub fn hitaki_snd_digi00x_new() -> *mut HitakiSndDigi00x;

    //=========================================================================
    // HitakiSndEfw
    //=========================================================================
    pub fn hitaki_snd_efw_get_type() -> GType;
    pub fn hitaki_snd_efw_new() -> *mut HitakiSndEfw;

    //=========================================================================
    // HitakiSndMotu
    //=========================================================================
    pub fn hitaki_snd_motu_get_type() -> GType;
    pub fn hitaki_snd_motu_new() -> *mut HitakiSndMotu;

    //=========================================================================
    // HitakiSndTascam
    //=========================================================================
    pub fn hitaki_snd_tascam_get_type() -> GType;
    pub fn hitaki_snd_tascam_new() -> *mut HitakiSndTascam;

    //=========================================================================
    // HitakiSndUnit
    //=========================================================================
    pub fn hitaki_snd_unit_get_type() -> GType;
    pub fn hitaki_snd_unit_new() -> *mut HitakiSndUnit;

    //=========================================================================
    // HitakiAlsaFirewire
    //=========================================================================
    pub fn hitaki_alsa_firewire_get_type() -> GType;
    pub fn hitaki_alsa_firewire_create_source(
        self_: *mut HitakiAlsaFirewire,
        source: *mut *mut glib::GSource,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn hitaki_alsa_firewire_lock(
        self_: *mut HitakiAlsaFirewire,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn hitaki_alsa_firewire_open(
        self_: *mut HitakiAlsaFirewire,
        path: *const c_char,
        open_flag: c_int,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn hitaki_alsa_firewire_unlock(
        self_: *mut HitakiAlsaFirewire,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // HitakiEfwProtocol
    //=========================================================================
    pub fn hitaki_efw_protocol_get_type() -> GType;
    pub fn hitaki_efw_protocol_receive_response(
        self_: *mut HitakiEfwProtocol,
        buffer: *const u8,
        length: size_t,
    );
    pub fn hitaki_efw_protocol_transaction(
        self_: *mut HitakiEfwProtocol,
        category: c_uint,
        command: c_uint,
        args: *const u32,
        arg_count: size_t,
        params: *const *mut u32,
        param_count: *mut size_t,
        timeout_ms: c_uint,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn hitaki_efw_protocol_transmit_request(
        self_: *mut HitakiEfwProtocol,
        category: c_uint,
        command: c_uint,
        args: *const u32,
        arg_count: size_t,
        resp_seqnum: *mut u32,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // HitakiMotuCommandDsp
    //=========================================================================
    pub fn hitaki_motu_command_dsp_get_type() -> GType;
    pub fn hitaki_motu_command_dsp_read_float_meter(
        self_: *mut HitakiMotuCommandDsp,
        meter: *const *mut [c_float; 400],
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // HitakiMotuRegisterDsp
    //=========================================================================
    pub fn hitaki_motu_register_dsp_get_type() -> GType;
    pub fn hitaki_motu_register_dsp_read_byte_meter(
        self_: *mut HitakiMotuRegisterDsp,
        meter: *const *mut [u8; 48],
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn hitaki_motu_register_dsp_read_parameter(
        self_: *mut HitakiMotuRegisterDsp,
        param: *const *mut HitakiSndMotuRegisterDspParameter,
        error: *mut *mut glib::GError,
    ) -> gboolean;

    //=========================================================================
    // HitakiQuadletNotification
    //=========================================================================
    pub fn hitaki_quadlet_notification_get_type() -> GType;

    //=========================================================================
    // HitakiTascamProtocol
    //=========================================================================
    pub fn hitaki_tascam_protocol_get_type() -> GType;
    pub fn hitaki_tascam_protocol_read_state(
        self_: *mut HitakiTascamProtocol,
        state: *const *mut u32,
        count: *mut size_t,
        error: *mut *mut glib::GError,
    ) -> gboolean;

}