hinawa-sys: regenerate FFI crate

This commit regenerates FFI crate.

Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>

10 files changed, 878 insertions, 362 deletions

diff --git a/README.rst b/README.rst
index 6ae2c7d..4bad9a8 100644
--- a/README.rst
+++ b/README.rst
@@ -24,6 +24,11 @@ Dependencies
 
 * Rust version 1.57 or later (edition 2021)
 * `libhinawa <https://github.com/alsa-project/libhinawa>`_
+* FFI crate (``hinawa-sys``)
+
+  * ``libc`` >= 0.2
+  * ``glib-sys`` >= 0.15
+  * ``gobject-sys`` >= 0.15
 
 Sample code
 ===========
diff --git a/hinawa-sys/Cargo.toml b/hinawa-sys/Cargo.toml
index 9f30cf6..b9259f2 100644
--- a/hinawa-sys/Cargo.toml
+++ b/hinawa-sys/Cargo.toml
@@ -1,35 +1,37 @@
 [package]
-name = "hinawa-sys"
-version = "0.5.0"
-description = "FFI bindings for libhinawa2 library"
 authors = ["Takashi Sakamoto <o-takashi@sakamocchi.jp>"]
-links = "hinawa"
 build = "build.rs"
+description = "FFI bindings for libhinawa2 library"
+edition = "2021"
 license = "MIT"
+links = "hinawa"
+name = "hinawa-sys"
 repository = "https://github.com/alsa-project/hinawa-rs/"
+rust-version = "1.57"
+version = "0.5.0"
 [package.metadata.docs.rs]
 features = ["dox"]
 [package.metadata.system-deps.hinawa]
 name = "hinawa"
 version = "2.4"
 
-[package.metadata.system-deps.hinawa.feature-versions]
-v2_1 = "2.1"
-v2_2 = "2.2"
-v2_3 = "2.3"
-v2_4 = "2.4"
-
 [lib]
 name = "hinawa_sys"
 
+[build-dependencies]
+pkg-config = "0.3.7"
+system-deps = "6"
+
 [dependencies]
 libc = "0.2"
-glib-sys = "0.10"
-gobject-sys = "0.10"
 
-[build-dependencies]
-pkg-config = "0.3.7"
-system-deps = "1.3"
+[dependencies.glib]
+package = "glib-sys"
+version = "0.15"
+
+[dependencies.gobject]
+package = "gobject-sys"
+version = "0.15"
 
 [dev-dependencies]
 shell-words = "1.0.0"
diff --git a/hinawa-sys/Gir.toml b/hinawa-sys/Gir.toml
index 8364af6..d8b08fa 100644
--- a/hinawa-sys/Gir.toml
+++ b/hinawa-sys/Gir.toml
@@ -1,4 +1,5 @@
 [options]
+girs_directories = ["../gir-files", ".."]
 work_mode = "sys"
 library = "Hinawa"
 version = "3.0"
diff --git a/hinawa-sys/build.rs b/hinawa-sys/build.rs
index f4c4e7c..2737436 100644
--- a/hinawa-sys/build.rs
+++ b/hinawa-sys/build.rs
@@ -1,11 +1,9 @@
 // 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
 
 #[cfg(not(feature = "dox"))]
-extern crate system_deps;
-
-#[cfg(not(feature = "dox"))]
 use std::process;
 
 #[cfg(feature = "dox")]
@@ -14,7 +12,7 @@ fn main() {} // prevent linking libraries to avoid documentation failure
 #[cfg(not(feature = "dox"))]
 fn main() {
     if let Err(s) = system_deps::Config::new().probe() {
-        let _ = eprintln!("{}", s);
+        println!("cargo:warning={}", s);
         process::exit(1);
     }
 }
diff --git a/hinawa-sys/src/lib.rs b/hinawa-sys/src/lib.rs
index 04a2a9f..32e4d0e 100644
--- a/hinawa-sys/src/lib.rs
+++ b/hinawa-sys/src/lib.rs
@@ -1,18 +1,22 @@
 // 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
 
 #![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
-#![allow(clippy::approx_constant, clippy::type_complexity, clippy::unreadable_literal)]
-
-extern crate libc;
-extern crate glib_sys as glib;
-extern crate gobject_sys as gobject;
+#![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_int, c_char, c_uchar, c_float, c_uint, c_double,
-    c_short, c_ushort, c_long, c_ulong,
-    c_void, size_t, ssize_t, intptr_t, uintptr_t, time_t, FILE};
+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};
@@ -109,8 +113,8 @@ pub const HINAWA_SND_UNIT_TYPE_MOTU: HinawaSndUnitType = 7;
 pub const HINAWA_SND_UNIT_TYPE_FIREFACE: HinawaSndUnitType = 8;
 
 // Records
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaFwFcpClass {
     pub parent_class: HinawaFwRespClass,
     pub responded: Option<unsafe extern "C" fn(*mut HinawaFwFcp, *const u8, c_uint)>,
@@ -118,20 +122,23 @@ pub struct HinawaFwFcpClass {
 
 impl ::std::fmt::Debug for HinawaFwFcpClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaFwFcpClass @ {:?}", self as *const _))
-         .field("parent_class", &self.parent_class)
-         .field("responded", &self.responded)
-         .finish()
+        f.debug_struct(&format!("HinawaFwFcpClass @ {:p}", self))
+            .field("parent_class", &self.parent_class)
+            .field("responded", &self.responded)
+            .finish()
     }
 }
 
 #[repr(C)]
-pub struct _HinawaFwFcpPrivate(c_void);
+pub struct _HinawaFwFcpPrivate {
+    _data: [u8; 0],
+    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+}
 
 pub type HinawaFwFcpPrivate = *mut _HinawaFwFcpPrivate;
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaFwNodeClass {
     pub parent_class: gobject::GObjectClass,
     pub bus_update: Option<unsafe extern "C" fn(*mut HinawaFwNode)>,
@@ -140,21 +147,24 @@ pub struct HinawaFwNodeClass {
 
 impl ::std::fmt::Debug for HinawaFwNodeClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaFwNodeClass @ {:?}", self as *const _))
-         .field("parent_class", &self.parent_class)
-         .field("bus_update", &self.bus_update)
-         .field("disconnected", &self.disconnected)
-         .finish()
+        f.debug_struct(&format!("HinawaFwNodeClass @ {:p}", self))
+            .field("parent_class", &self.parent_class)
+            .field("bus_update", &self.bus_update)
+            .field("disconnected", &self.disconnected)
+            .finish()
     }
 }
 
 #[repr(C)]
-pub struct _HinawaFwNodePrivate(c_void);
+pub struct _HinawaFwNodePrivate {
+    _data: [u8; 0],
+    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+}
 
 pub type HinawaFwNodePrivate = *mut _HinawaFwNodePrivate;
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaFwReqClass {
     pub parent_class: gobject::GObjectClass,
     pub responded: Option<unsafe extern "C" fn(*mut HinawaFwReq, HinawaFwRcode, *const u8, c_uint)>,
@@ -162,43 +172,61 @@ pub struct HinawaFwReqClass {
 
 impl ::std::fmt::Debug for HinawaFwReqClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaFwReqClass @ {:?}", self as *const _))
-         .field("parent_class", &self.parent_class)
-         .field("responded", &self.responded)
-         .finish()
+        f.debug_struct(&format!("HinawaFwReqClass @ {:p}", self))
+            .field("parent_class", &self.parent_class)
+            .field("responded", &self.responded)
+            .finish()
     }
 }
 
 #[repr(C)]
-pub struct _HinawaFwReqPrivate(c_void);
+pub struct _HinawaFwReqPrivate {
+    _data: [u8; 0],
+    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+}
 
 pub type HinawaFwReqPrivate = *mut _HinawaFwReqPrivate;
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaFwRespClass {
     pub parent_class: gobject::GObjectClass,
     pub requested: Option<unsafe extern "C" fn(*mut HinawaFwResp, HinawaFwTcode) -> HinawaFwRcode>,
-    pub requested2: Option<unsafe extern "C" fn(*mut HinawaFwResp, HinawaFwTcode, u64, u32, u32, u32, u32, *const u8, c_uint) -> HinawaFwRcode>,
+    pub requested2: Option<
+        unsafe extern "C" fn(
+            *mut HinawaFwResp,
+            HinawaFwTcode,
+            u64,
+            u32,
+            u32,
+            u32,
+            u32,
+            *const u8,
+            c_uint,
+        ) -> HinawaFwRcode,
+    >,
 }
 
 impl ::std::fmt::Debug for HinawaFwRespClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaFwRespClass @ {:?}", self as *const _))
-         .field("parent_class", &self.parent_class)
-         .field("requested", &self.requested)
-         .field("requested2", &self.requested2)
-         .finish()
+        f.debug_struct(&format!("HinawaFwRespClass @ {:p}", self))
+            .field("parent_class", &self.parent_class)
+            .field("requested", &self.requested)
+            .field("requested2", &self.requested2)
+            .finish()
     }
 }
 
 #[repr(C)]
-pub struct _HinawaFwRespPrivate(c_void);
+pub struct _HinawaFwRespPrivate {
+    _data: [u8; 0],
+    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+}
 
 pub type HinawaFwRespPrivate = *mut _HinawaFwRespPrivate;
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndDg00xClass {
     pub parent_class: HinawaSndUnitClass,
     pub message: Option<unsafe extern "C" fn(*mut HinawaSndDg00x, u32)>,
@@ -206,15 +234,15 @@ pub struct HinawaSndDg00xClass {
 
 impl ::std::fmt::Debug for HinawaSndDg00xClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndDg00xClass @ {:?}", self as *const _))
-         .field("parent_class", &self.parent_class)
-         .field("message", &self.message)
-         .finish()
+        f.debug_struct(&format!("HinawaSndDg00xClass @ {:p}", self))
+            .field("parent_class", &self.parent_class)
+            .field("message", &self.message)
+            .finish()
     }
 }
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndDiceClass {
     pub parent_class: HinawaSndUnitClass,
     pub notified: Option<unsafe extern "C" fn(*mut HinawaSndDice, c_uint)>,
@@ -222,41 +250,57 @@ pub struct HinawaSndDiceClass {
 
 impl ::std::fmt::Debug for HinawaSndDiceClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndDiceClass @ {:?}", self as *const _))
-         .field("parent_class", &self.parent_class)
-         .field("notified", &self.notified)
-         .finish()
+        f.debug_struct(&format!("HinawaSndDiceClass @ {:p}", self))
+            .field("parent_class", &self.parent_class)
+            .field("notified", &self.notified)
+            .finish()
     }
 }
 
 #[repr(C)]
-pub struct _HinawaSndDicePrivate(c_void);
+pub struct _HinawaSndDicePrivate {
+    _data: [u8; 0],
+    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+}
 
 pub type HinawaSndDicePrivate = *mut _HinawaSndDicePrivate;
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndEfwClass {
     pub parent_class: HinawaSndUnitClass,
-    pub responded: Option<unsafe extern "C" fn(*mut HinawaSndEfw, HinawaSndEfwStatus, c_uint, c_uint, c_uint, *const u32, c_uint)>,
+    pub responded: Option<
+        unsafe extern "C" fn(
+            *mut HinawaSndEfw,
+            HinawaSndEfwStatus,
+            c_uint,
+            c_uint,
+            c_uint,
+            *const u32,
+            c_uint,
+        ),
+    >,
 }
 
 impl ::std::fmt::Debug for HinawaSndEfwClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndEfwClass @ {:?}", self as *const _))
-         .field("parent_class", &self.parent_class)
-         .field("responded", &self.responded)
-         .finish()
+        f.debug_struct(&format!("HinawaSndEfwClass @ {:p}", self))
+            .field("parent_class", &self.parent_class)
+            .field("responded", &self.responded)
+            .finish()
     }
 }
 
 #[repr(C)]
-pub struct _HinawaSndEfwPrivate(c_void);
+pub struct _HinawaSndEfwPrivate {
+    _data: [u8; 0],
+    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+}
 
 pub type HinawaSndEfwPrivate = *mut _HinawaSndEfwPrivate;
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndMotuClass {
     pub parent_class: HinawaSndUnitClass,
     pub notified: Option<unsafe extern "C" fn(*mut HinawaSndMotu, c_uint)>,
@@ -265,34 +309,37 @@ pub struct HinawaSndMotuClass {
 
 impl ::std::fmt::Debug for HinawaSndMotuClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndMotuClass @ {:?}", self as *const _))
-         .field("parent_class", &self.parent_class)
-         .field("notified", &self.notified)
-         .field("register_dsp_changed", &self.register_dsp_changed)
-         .finish()
+        f.debug_struct(&format!("HinawaSndMotuClass @ {:p}", self))
+            .field("parent_class", &self.parent_class)
+            .field("notified", &self.notified)
+            .field("register_dsp_changed", &self.register_dsp_changed)
+            .finish()
     }
 }
 
 #[repr(C)]
-pub struct _HinawaSndMotuPrivate(c_void);
+pub struct _HinawaSndMotuPrivate {
+    _data: [u8; 0],
+    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+}
 
 pub type HinawaSndMotuPrivate = *mut _HinawaSndMotuPrivate;
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndMotuRegisterDspParameter {
     pub parameter: [u8; 512],
 }
 
 impl ::std::fmt::Debug for HinawaSndMotuRegisterDspParameter {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndMotuRegisterDspParameter @ {:?}", self as *const _))
-         .finish()
+        f.debug_struct(&format!("HinawaSndMotuRegisterDspParameter @ {:p}", self))
+            .finish()
     }
 }
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndTscmClass {
     pub parent_class: HinawaSndUnitClass,
     pub control: Option<unsafe extern "C" fn(*mut HinawaSndTscm, c_uint, c_uint, c_uint)>,
@@ -300,20 +347,23 @@ pub struct HinawaSndTscmClass {
 
 impl ::std::fmt::Debug for HinawaSndTscmClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndTscmClass @ {:?}", self as *const _))
-         .field("parent_class", &self.parent_class)
-         .field("control", &self.control)
-         .finish()
+        f.debug_struct(&format!("HinawaSndTscmClass @ {:p}", self))
+            .field("parent_class", &self.parent_class)
+            .field("control", &self.control)
+            .finish()
     }
 }
 
 #[repr(C)]
-pub struct _HinawaSndTscmPrivate(c_void);
+pub struct _HinawaSndTscmPrivate {
+    _data: [u8; 0],
+    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+}
 
 pub type HinawaSndTscmPrivate = *mut _HinawaSndTscmPrivate;
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndUnitClass {
     pub parent_class: gobject::GObjectClass,
     pub lock_status: Option<unsafe extern "C" fn(*mut HinawaSndUnit, gboolean)>,
@@ -322,22 +372,25 @@ pub struct HinawaSndUnitClass {
 
 impl ::std::fmt::Debug for HinawaSndUnitClass {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndUnitClass @ {:?}", self as *const _))
-         .field("parent_class", &self.parent_class)
-         .field("lock_status", &self.lock_status)
-         .field("disconnected", &self.disconnected)
-         .finish()
+        f.debug_struct(&format!("HinawaSndUnitClass @ {:p}", self))
+            .field("parent_class", &self.parent_class)
+            .field("lock_status", &self.lock_status)
+            .field("disconnected", &self.disconnected)
+            .finish()
     }
 }
 
 #[repr(C)]
-pub struct _HinawaSndUnitPrivate(c_void);
+pub struct _HinawaSndUnitPrivate {
+    _data: [u8; 0],
+    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
+}
 
 pub type HinawaSndUnitPrivate = *mut _HinawaSndUnitPrivate;
 
 // Classes
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaFwFcp {
     pub parent_instance: HinawaFwResp,
     pub priv_: *mut HinawaFwFcpPrivate,
@@ -345,15 +398,15 @@ pub struct HinawaFwFcp {
 
 impl ::std::fmt::Debug for HinawaFwFcp {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaFwFcp @ {:?}", self as *const _))
-         .field("parent_instance", &self.parent_instance)
-         .field("priv_", &self.priv_)
-         .finish()
+        f.debug_struct(&format!("HinawaFwFcp @ {:p}", self))
+            .field("parent_instance", &self.parent_instance)
+            .field("priv_", &self.priv_)
+            .finish()
     }
 }
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaFwNode {
     pub parent_instance: gobject::GObject,
     pub priv_: *mut HinawaFwNodePrivate,
@@ -361,15 +414,15 @@ pub struct HinawaFwNode {
 
 impl ::std::fmt::Debug for HinawaFwNode {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaFwNode @ {:?}", self as *const _))
-         .field("parent_instance", &self.parent_instance)
-         .field("priv_", &self.priv_)
-         .finish()
+        f.debug_struct(&format!("HinawaFwNode @ {:p}", self))
+            .field("parent_instance", &self.parent_instance)
+            .field("priv_", &self.priv_)
+            .finish()
     }
 }
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaFwReq {
     pub parent_instance: gobject::GObject,
     pub priv_: *mut HinawaFwReqPrivate,
@@ -377,15 +430,15 @@ pub struct HinawaFwReq {
 
 impl ::std::fmt::Debug for HinawaFwReq {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaFwReq @ {:?}", self as *const _))
-         .field("parent_instance", &self.parent_instance)
-         .field("priv_", &self.priv_)
-         .finish()
+        f.debug_struct(&format!("HinawaFwReq @ {:p}", self))
+            .field("parent_instance", &self.parent_instance)
+            .field("priv_", &self.priv_)
+            .finish()
     }
 }
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaFwResp {
     pub parent_instance: gobject::GObject,
     pub priv_: *mut HinawaFwRespPrivate,
@@ -393,29 +446,29 @@ pub struct HinawaFwResp {
 
 impl ::std::fmt::Debug for HinawaFwResp {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaFwResp @ {:?}", self as *const _))
-         .field("parent_instance", &self.parent_instance)
-         .field("priv_", &self.priv_)
-         .finish()
+        f.debug_struct(&format!("HinawaFwResp @ {:p}", self))
+            .field("parent_instance", &self.parent_instance)
+            .field("priv_", &self.priv_)
+            .finish()
     }
 }
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndDg00x {
     pub parent_instance: HinawaSndUnit,
 }
 
 impl ::std::fmt::Debug for HinawaSndDg00x {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndDg00x @ {:?}", self as *const _))
-         .field("parent_instance", &self.parent_instance)
-         .finish()
+        f.debug_struct(&format!("HinawaSndDg00x @ {:p}", self))
+            .field("parent_instance", &self.parent_instance)
+            .finish()
     }
 }
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndDice {
     pub parent_instance: HinawaSndUnit,
     pub priv_: *mut HinawaSndDicePrivate,
@@ -423,15 +476,15 @@ pub struct HinawaSndDice {
 
 impl ::std::fmt::Debug for HinawaSndDice {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndDice @ {:?}", self as *const _))
-         .field("parent_instance", &self.parent_instance)
-         .field("priv_", &self.priv_)
-         .finish()
+        f.debug_struct(&format!("HinawaSndDice @ {:p}", self))
+            .field("parent_instance", &self.parent_instance)
+            .field("priv_", &self.priv_)
+            .finish()
     }
 }
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndEfw {
     pub parent_instance: HinawaSndUnit,
     pub priv_: *mut HinawaSndEfwPrivate,
@@ -439,15 +492,15 @@ pub struct HinawaSndEfw {
 
 impl ::std::fmt::Debug for HinawaSndEfw {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndEfw @ {:?}", self as *const _))
-         .field("parent_instance", &self.parent_instance)
-         .field("priv_", &self.priv_)
-         .finish()
+        f.debug_struct(&format!("HinawaSndEfw @ {:p}", self))
+            .field("parent_instance", &self.parent_instance)
+            .field("priv_", &self.priv_)
+            .finish()
     }
 }
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndMotu {
     pub parent_instance: HinawaSndUnit,
     pub priv_: *mut HinawaSndMotuPrivate,
@@ -455,15 +508,15 @@ pub struct HinawaSndMotu {
 
 impl ::std::fmt::Debug for HinawaSndMotu {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndMotu @ {:?}", self as *const _))
-         .field("parent_instance", &self.parent_instance)
-         .field("priv_", &self.priv_)
-         .finish()
+        f.debug_struct(&format!("HinawaSndMotu @ {:p}", self))
+            .field("parent_instance", &self.parent_instance)
+            .field("priv_", &self.priv_)
+            .finish()
     }
 }
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndTscm {
     pub parent_instance: HinawaSndUnit,
     pub priv_: *mut HinawaSndTscmPrivate,
@@ -471,15 +524,15 @@ pub struct HinawaSndTscm {
 
 impl ::std::fmt::Debug for HinawaSndTscm {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndTscm @ {:?}", self as *const _))
-         .field("parent_instance", &self.parent_instance)
-         .field("priv_", &self.priv_)
-         .finish()
+        f.debug_struct(&format!("HinawaSndTscm @ {:p}", self))
+            .field("parent_instance", &self.parent_instance)
+            .field("priv_", &self.priv_)
+            .finish()
     }
 }
 
-#[repr(C)]
 #[derive(Copy, Clone)]
+#[repr(C)]
 pub struct HinawaSndUnit {
     pub parent_instance: gobject::GObject,
     pub priv_: *mut HinawaSndUnitPrivate,
@@ -487,13 +540,14 @@ pub struct HinawaSndUnit {
 
 impl ::std::fmt::Debug for HinawaSndUnit {
     fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        f.debug_struct(&format!("HinawaSndUnit @ {:?}", self as *const _))
-         .field("parent_instance", &self.parent_instance)
-         .field("priv_", &self.priv_)
-         .finish()
+        f.debug_struct(&format!("HinawaSndUnit @ {:p}", self))
+            .field("parent_instance", &self.parent_instance)
+            .field("priv_", &self.priv_)
+            .finish()
     }
 }
 
+#[link(name = "hinawa")]
 extern "C" {
 
     //=========================================================================
@@ -551,30 +605,102 @@ extern "C" {
     //=========================================================================
     pub fn hinawa_snd_motu_register_dsp_parameter_get_type() -> GType;
     pub fn hinawa_snd_motu_register_dsp_parameter_new() -> *mut HinawaSndMotuRegisterDspParameter;
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_headphone_output_paired_assignment(self_: *const HinawaSndMotuRegisterDspParameter, assignment: *mut u8);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_headphone_output_paired_volume(self_: *const HinawaSndMotuRegisterDspParameter, volume: *mut u8);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_input_flag(self_: *const HinawaSndMotuRegisterDspParameter, flag: *mut *const [u8; 10]);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_input_gain_and_invert(self_: *const HinawaSndMotuRegisterDspParameter, gain_and_invert: *mut *const [u8; 10]);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_line_input_boost_flag(self_: *const HinawaSndMotuRegisterDspParameter, boost_flag: *mut u8);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_line_input_nominal_level_flag(self_: *const HinawaSndMotuRegisterDspParameter, nominal_level_flag: *mut u8);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_main_output_paired_volume(self_: *const HinawaSndMotuRegisterDspParameter, volume: *mut u8);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_output_paired_flag(self_: *const HinawaSndMotuRegisterDspParameter, flag: *mut *const [u8; 4]);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_output_paired_volume(self_: *const HinawaSndMotuRegisterDspParameter, volume: *mut *const [u8; 4]);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_source_flag(self_: *const HinawaSndMotuRegisterDspParameter, mixer: size_t, flag: *mut *const [u8; 20]);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_source_gain(self_: *const HinawaSndMotuRegisterDspParameter, mixer: size_t, gain: *mut *const [u8; 20]);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_source_paired_balance(self_: *const HinawaSndMotuRegisterDspParameter, mixer: size_t, balance: *mut *const [u8; 20]);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_source_paired_width(self_: *const HinawaSndMotuRegisterDspParameter, mixer: size_t, width: *mut *const [u8; 20]);
-    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_source_pan(self_: *const HinawaSndMotuRegisterDspParameter, mixer: size_t, pan: *mut *const [u8; 20]);
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_headphone_output_paired_assignment(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        assignment: *mut u8,
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_headphone_output_paired_volume(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        volume: *mut u8,
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_input_flag(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        flag: *mut *const [u8; 10],
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_input_gain_and_invert(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        gain_and_invert: *mut *const [u8; 10],
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_line_input_boost_flag(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        boost_flag: *mut u8,
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_line_input_nominal_level_flag(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        nominal_level_flag: *mut u8,
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_main_output_paired_volume(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        volume: *mut u8,
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_output_paired_flag(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        flag: *mut *const [u8; 4],
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_output_paired_volume(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        volume: *mut *const [u8; 4],
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_source_flag(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        mixer: size_t,
+        flag: *mut *const [u8; 20],
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_source_gain(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        mixer: size_t,
+        gain: *mut *const [u8; 20],
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_source_paired_balance(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        mixer: size_t,
+        balance: *mut *const [u8; 20],
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_source_paired_width(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        mixer: size_t,
+        width: *mut *const [u8; 20],
+    );
+    pub fn hinawa_snd_motu_register_dsp_parameter_get_mixer_source_pan(
+        self_: *const HinawaSndMotuRegisterDspParameter,
+        mixer: size_t,
+        pan: *mut *const [u8; 20],
+    );
 
     //=========================================================================
     // HinawaFwFcp
     //=========================================================================
     pub fn hinawa_fw_fcp_get_type() -> GType;
     pub fn hinawa_fw_fcp_new() -> *mut HinawaFwFcp;
-    pub fn hinawa_fw_fcp_avc_transaction(self_: *mut HinawaFwFcp, cmd: *const u8, cmd_size: size_t, resp: *const *mut u8, resp_size: *mut size_t, timeout_ms: c_uint, error: *mut *mut glib::GError);
-    pub fn hinawa_fw_fcp_bind(self_: *mut HinawaFwFcp, node: *mut HinawaFwNode, error: *mut *mut glib::GError);
-    pub fn hinawa_fw_fcp_command(self_: *mut HinawaFwFcp, cmd: *const u8, cmd_size: size_t, timeout_ms: c_uint, error: *mut *mut glib::GError);
-    pub fn hinawa_fw_fcp_transaction(self_: *mut HinawaFwFcp, req_frame: *const u8, req_frame_size: size_t, resp_frame: *const *mut u8, resp_frame_size: *mut size_t, error: *mut *mut glib::GError);
+    pub fn hinawa_fw_fcp_avc_transaction(
+        self_: *mut HinawaFwFcp,
+        cmd: *const u8,
+        cmd_size: size_t,
+        resp: *const *mut u8,
+        resp_size: *mut size_t,
+        timeout_ms: c_uint,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_fw_fcp_bind(
+        self_: *mut HinawaFwFcp,
+        node: *mut HinawaFwNode,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_fw_fcp_command(
+        self_: *mut HinawaFwFcp,
+        cmd: *const u8,
+        cmd_size: size_t,
+        timeout_ms: c_uint,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_fw_fcp_transaction(
+        self_: *mut HinawaFwFcp,
+        req_frame: *const u8,
+        req_frame_size: size_t,
+        resp_frame: *const *mut u8,
+        resp_frame_size: *mut size_t,
+        error: *mut *mut glib::GError,
+    );
     pub fn hinawa_fw_fcp_unbind(self_: *mut HinawaFwFcp);
 
     //=========================================================================
@@ -582,9 +708,22 @@ extern "C" {
     //=========================================================================
     pub fn hinawa_fw_node_get_type() -> GType;
     pub fn hinawa_fw_node_new() -> *mut HinawaFwNode;
-    pub fn hinawa_fw_node_create_source(self_: *mut HinawaFwNode, gsrc: *mut *mut glib::GSource, error: *mut *mut glib::GError);
-    pub fn hinawa_fw_node_get_config_rom(self_: *mut HinawaFwNode, image: *mut *const u8, length: *mut size_t, error: *mut *mut glib::GError);
-    pub fn hinawa_fw_node_open(self_: *mut HinawaFwNode, path: *const c_char, error: *mut *mut glib::GError);
+    pub fn hinawa_fw_node_create_source(
+        self_: *mut HinawaFwNode,
+        gsrc: *mut *mut glib::GSource,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_fw_node_get_config_rom(
+        self_: *mut HinawaFwNode,
+        image: *mut *const u8,
+        length: *mut size_t,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_fw_node_open(
+        self_: *mut HinawaFwNode,
+        path: *const c_char,
+        error: *mut *mut glib::GError,
+    );
 
     //=========================================================================
     // HinawaFwReq
@@ -592,19 +731,64 @@ extern "C" {
     pub fn hinawa_fw_req_get_type() -> GType;
     pub fn hinawa_fw_req_new() -> *mut HinawaFwReq;
     pub fn hinawa_fw_req_error_quark() -> glib::GQuark;
-    pub fn hinawa_fw_req_transaction(self_: *mut HinawaFwReq, node: *mut HinawaFwNode, tcode: HinawaFwTcode, addr: u64, length: size_t, frame: *const *mut u8, frame_size: *mut size_t, error: *mut *mut glib::GError);
-    pub fn hinawa_fw_req_transaction_async(self_: *mut HinawaFwReq, node: *mut HinawaFwNode, tcode: HinawaFwTcode, addr: u64, length: size_t, frame: *const *mut u8, frame_size: *mut size_t, error: *mut *mut glib::GError);
-    pub fn hinawa_fw_req_transaction_sync(self_: *mut HinawaFwReq, node: *mut HinawaFwNode, tcode: HinawaFwTcode, addr: u64, length: size_t, frame: *const *mut u8, frame_size: *mut size_t, timeout_ms: c_uint, error: *mut *mut glib::GError);
+    pub fn hinawa_fw_req_transaction(
+        self_: *mut HinawaFwReq,
+        node: *mut HinawaFwNode,
+        tcode: HinawaFwTcode,
+        addr: u64,
+        length: size_t,
+        frame: *const *mut u8,
+        frame_size: *mut size_t,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_fw_req_transaction_async(
+        self_: *mut HinawaFwReq,
+        node: *mut HinawaFwNode,
+        tcode: HinawaFwTcode,
+        addr: u64,
+        length: size_t,
+        frame: *const *mut u8,
+        frame_size: *mut size_t,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_fw_req_transaction_sync(
+        self_: *mut HinawaFwReq,
+        node: *mut HinawaFwNode,
+        tcode: HinawaFwTcode,
+        addr: u64,
+        length: size_t,
+        frame: *const *mut u8,
+        frame_size: *mut size_t,
+        timeout_ms: c_uint,
+        error: *mut *mut glib::GError,
+    );
 
     //=========================================================================
     // HinawaFwResp
     //=========================================================================
     pub fn hinawa_fw_resp_get_type() -> GType;
     pub fn hinawa_fw_resp_new() -> *mut HinawaFwResp;
-    pub fn hinawa_fw_resp_get_req_frame(self_: *mut HinawaFwResp, frame: *mut *const u8, length: *mut size_t);
+    pub fn hinawa_fw_resp_get_req_frame(
+        self_: *mut HinawaFwResp,
+        frame: *mut *const u8,
+        length: *mut size_t,
+    );
     pub fn hinawa_fw_resp_release(self_: *mut HinawaFwResp);
-    pub fn hinawa_fw_resp_reserve(self_: *mut HinawaFwResp, node: *mut HinawaFwNode, addr: u64, width: c_uint, error: *mut *mut glib::GError);
-    pub fn hinawa_fw_resp_reserve_within_region(self_: *mut HinawaFwResp, node: *mut HinawaFwNode, region_start: u64, region_end: u64, width: c_uint, error: *mut *mut glib::GError);
+    pub fn hinawa_fw_resp_reserve(
+        self_: *mut HinawaFwResp,
+        node: *mut HinawaFwNode,
+        addr: u64,
+        width: c_uint,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_fw_resp_reserve_within_region(
+        self_: *mut HinawaFwResp,
+        node: *mut HinawaFwNode,
+        region_start: u64,
+        region_end: u64,
+        width: c_uint,
+        error: *mut *mut glib::GError,
+    );
     pub fn hinawa_fw_resp_set_resp_frame(self_: *mut HinawaFwResp, frame: *mut u8, length: size_t);
 
     //=========================================================================
@@ -612,15 +796,30 @@ extern "C" {
     //=========================================================================
     pub fn hinawa_snd_dg00x_get_type() -> GType;
     pub fn hinawa_snd_dg00x_new() -> *mut HinawaSndDg00x;
-    pub fn hinawa_snd_dg00x_open(self_: *mut HinawaSndDg00x, path: *mut c_char, error: *mut *mut glib::GError);
+    pub fn hinawa_snd_dg00x_open(
+        self_: *mut HinawaSndDg00x,
+        path: *mut c_char,
+        error: *mut *mut glib::GError,
+    );
 
     //=========================================================================
     // HinawaSndDice
     //=========================================================================
     pub fn hinawa_snd_dice_get_type() -> GType;
     pub fn hinawa_snd_dice_new() -> *mut HinawaSndDice;
-    pub fn hinawa_snd_dice_open(self_: *mut HinawaSndDice, path: *mut c_char, error: *mut *mut glib::GError);
-    pub fn hinawa_snd_dice_transaction(self_: *mut HinawaSndDice, addr: u64, frame: *const u32, frame_count: size_t, bit_flag: u32, error: *mut *mut glib::GError);
+    pub fn hinawa_snd_dice_open(
+        self_: *mut HinawaSndDice,
+        path: *mut c_char,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_snd_dice_transaction(
+        self_: *mut HinawaSndDice,
+        addr: u64,
+        frame: *const u32,
+        frame_count: size_t,
+        bit_flag: u32,
+        error: *mut *mut glib::GError,
+    );
 
     //=========================================================================
     // HinawaSndEfw
@@ -628,48 +827,100 @@ extern "C" {
     pub fn hinawa_snd_efw_get_type() -> GType;
     pub fn hinawa_snd_efw_new() -> *mut HinawaSndEfw;
     pub fn hinawa_snd_efw_error_quark() -> glib::GQuark;
-    pub fn hinawa_snd_efw_open(self_: *mut HinawaSndEfw, path: *mut c_char, error: *mut *mut glib::GError);
-    pub fn hinawa_snd_efw_transaction(self_: *mut HinawaSndEfw, category: c_uint, command: c_uint, args: *const u32, arg_count: size_t, params: *const *mut u32, param_count: *mut size_t, error: *mut *mut glib::GError);
-    pub fn hinawa_snd_efw_transaction_async(self_: *mut HinawaSndEfw, category: c_uint, command: c_uint, args: *const u32, arg_count: size_t, resp_seqnum: *mut u32, error: *mut *mut glib::GError);
-    pub fn hinawa_snd_efw_transaction_sync(self_: *mut HinawaSndEfw, 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);
+    pub fn hinawa_snd_efw_open(
+        self_: *mut HinawaSndEfw,
+        path: *mut c_char,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_snd_efw_transaction(
+        self_: *mut HinawaSndEfw,
+        category: c_uint,
+        command: c_uint,
+        args: *const u32,
+        arg_count: size_t,
+        params: *const *mut u32,
+        param_count: *mut size_t,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_snd_efw_transaction_async(
+        self_: *mut HinawaSndEfw,
+        category: c_uint,
+        command: c_uint,
+        args: *const u32,
+        arg_count: size_t,
+        resp_seqnum: *mut u32,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_snd_efw_transaction_sync(
+        self_: *mut HinawaSndEfw,
+        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,
+    );
 
     //=========================================================================
     // HinawaSndMotu
     //=========================================================================
     pub fn hinawa_snd_motu_get_type() -> GType;
     pub fn hinawa_snd_motu_new() -> *mut HinawaSndMotu;
-    pub fn hinawa_snd_motu_open(self_: *mut HinawaSndMotu, path: *mut c_char, error: *mut *mut glib::GError);
-    pub fn hinawa_snd_motu_read_command_dsp_meter(self_: *mut HinawaSndMotu, meter: *const *mut [c_float; 400], error: *mut *mut glib::GError);
-    pub fn hinawa_snd_motu_read_register_dsp_meter(self_: *mut HinawaSndMotu, meter: *const *mut [u8; 48], error: *mut *mut glib::GError);
-    pub fn hinawa_snd_motu_read_register_dsp_parameter(self_: *mut HinawaSndMotu, param: *const *mut HinawaSndMotuRegisterDspParameter, error: *mut *mut glib::GError);
+    pub fn hinawa_snd_motu_open(
+        self_: *mut HinawaSndMotu,
+        path: *mut c_char,
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_snd_motu_read_command_dsp_meter(
+        self_: *mut HinawaSndMotu,
+        meter: *const *mut [c_float; 400],
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_snd_motu_read_register_dsp_meter(
+        self_: *mut HinawaSndMotu,
+        meter: *const *mut [u8; 48],
+        error: *mut *mut glib::GError,
+    );
+    pub fn hinawa_snd_motu_read_register_dsp_parameter(
+        self_: *mut HinawaSndMotu,
+        param: *const *mut HinawaSndMotuRegisterDspParameter,
+        error: *mut *mut glib::GError,
+    );
 
     //=========================================================================
     // HinawaSndTscm
     //=========================================================================
     pub fn hinawa_snd_tscm_get_type() -> GType;
     pub fn hinawa_snd_tscm_new() -> *mut HinawaSndTscm;
-    pub fn hinawa_snd_tscm_get_state(self_: *mut HinawaSndTscm, error: *mut *mut glib::GError) -> *const [u32; 64];
-    pub fn hinawa_snd_tscm_open(self_: *mut HinawaSndTscm, path: *mut c_char, error: *mut *mut glib::GError);
+    pub fn hinawa_snd_tscm_get_state(
+        self_: *mut HinawaSndTscm,
+        error: *mut *mut glib::GError,
+    ) -> *const [u32; 64];
+    pub fn hinawa_snd_tscm_open(
+        self_: *mut HinawaSndTscm,
+        path: *mut c_char,
+        error: *mut *mut glib::GError,
+    );
 
     //=========================================================================
     // HinawaSndUnit
     //=========================================================================
     pub fn hinawa_snd_unit_get_type() -> GType;
     pub fn hinawa_snd_unit_new() -> *mut HinawaSndUnit;
-    pub fn hinawa_snd_unit_create_source(self_: *mut HinawaSndUnit, gsrc: *mut *mut glib::GSource, error: *mut *mut glib::GError);
+    pub fn hinawa_snd_unit_create_source(
+        self_: *mut HinawaSndUnit,
+        gsrc: *mut *mut glib::GSource,
+        error: *mut *mut glib::GError,
+    );
     pub fn hinawa_snd_unit_get_node(self_: *mut HinawaSndUnit, node: *mut *mut HinawaFwNode);
     pub fn hinawa_snd_unit_lock(self_: *mut HinawaSndUnit, error: *mut *mut glib::GError);
-    pub fn hinawa_snd_unit_open(self_: *mut HinawaSndUnit, path: *mut c_char, error: *mut *mut glib::GError);
+    pub fn hinawa_snd_unit_open(
+        self_: *mut HinawaSndUnit,
+        path: *mut c_char,
+        error: *mut *mut glib::GError,
+    );
     pub fn hinawa_snd_unit_unlock(self_: *mut HinawaSndUnit, error: *mut *mut glib::GError);
 
-    //=========================================================================
-    // Other functions
-    //=========================================================================
-    pub fn hinawa_sigs_marshal_ENUM__ENUM(closure: *mut gobject::GClosure, return_value: *mut gobject::GValue, n_param_values: c_uint, param_values: *const gobject::GValue, invocation_hint: gpointer, marshal_data: gpointer);
-    pub fn hinawa_sigs_marshal_ENUM__ENUM_UINT64_UINT_UINT_UINT_UINT_POINTER_UINT(closure: *mut gobject::GClosure, return_value: *mut gobject::GValue, n_param_values: c_uint, param_values: *const gobject::GValue, invocation_hint: gpointer, marshal_data: gpointer);
-    pub fn hinawa_sigs_marshal_VOID__ENUM_POINTER_UINT(closure: *mut gobject::GClosure, return_value: *mut gobject::GValue, n_param_values: c_uint, param_values: *const gobject::GValue, invocation_hint: gpointer, marshal_data: gpointer);
-    pub fn hinawa_sigs_marshal_VOID__ENUM_UINT_UINT_UINT_POINTER_UINT(closure: *mut gobject::GClosure, return_value: *mut gobject::GValue, n_param_values: c_uint, param_values: *const gobject::GValue, invocation_hint: gpointer, marshal_data: gpointer);
-    pub fn hinawa_sigs_marshal_VOID__POINTER_UINT(closure: *mut gobject::GClosure, return_value: *mut gobject::GValue, n_param_values: c_uint, param_values: *const gobject::GValue, invocation_hint: gpointer, marshal_data: gpointer);
-    pub fn hinawa_sigs_marshal_VOID__UINT_UINT_UINT(closure: *mut gobject::GClosure, return_value: *mut gobject::GValue, n_param_values: c_uint, param_values: *const gobject::GValue, invocation_hint: gpointer, marshal_data: gpointer);
-
 }
diff --git a/hinawa-sys/tests/abi.rs b/hinawa-sys/tests/abi.rs
index bfaf29a..a13a804 100644
--- a/hinawa-sys/tests/abi.rs
+++ b/hinawa-sys/tests/abi.rs
@@ -1,18 +1,17 @@
 // 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
 
-extern crate hinawa_sys;
-extern crate shell_words;
-extern crate tempfile;
+use hinawa_sys::*;
 use std::env;
 use std::error::Error;
-use std::path::Path;
+use std::ffi::OsString;
 use std::mem::{align_of, size_of};
+use std::path::Path;
 use std::process::Command;
 use std::str;
 use tempfile::Builder;
-use hinawa_sys::*;
 
 static PACKAGES: &[&str] = &["hinawa"];
 
@@ -22,23 +21,17 @@ struct Compiler {
 }
 
 impl Compiler {
-    pub fn new() -> Result<Compiler, Box<dyn Error>> {
+    pub fn new() -> Result<Self, Box<dyn Error>> {
         let mut args = get_var("CC", "cc")?;
         args.push("-Wno-deprecated-declarations".to_owned());
+        // For _Generic
+        args.push("-std=c11".to_owned());
         // For %z support in printf when using MinGW.
         args.push("-D__USE_MINGW_ANSI_STDIO".to_owned());
         args.extend(get_var("CFLAGS", "")?);
         args.extend(get_var("CPPFLAGS", "")?);
         args.extend(pkg_config_cflags(PACKAGES)?);
-        Ok(Compiler { args })
-    }
-
-    pub fn define<'a, V: Into<Option<&'a str>>>(&mut self, var: &str, val: V) {
-        let arg = match val.into() {
-            None => format!("-D{}", var),
-            Some(val) => format!("-D{}={}", var, val),
-        };
-        self.args.push(arg);
+        Ok(Self { args })
     }
 
     pub fn compile(&self, src: &Path, out: &Path) -> Result<(), Box<dyn Error>> {
@@ -48,8 +41,7 @@ impl Compiler {
         cmd.arg(out);
         let status = cmd.spawn()?.wait()?;
         if !status.success() {
-            return Err(format!("compilation command {:?} failed, {}",
-                               &cmd, status).into());
+            return Err(format!("compilation command {:?} failed, {}", &cmd, status).into());
         }
         Ok(())
     }
@@ -73,19 +65,18 @@ fn pkg_config_cflags(packages: &[&str]) -> Result<Vec<String>, Box<dyn Error>> {
     if packages.is_empty() {
         return Ok(Vec::new());
     }
-    let mut cmd = Command::new("pkg-config");
+    let pkg_config = env::var_os("PKG_CONFIG").unwrap_or_else(|| OsString::from("pkg-config"));
+    let mut cmd = Command::new(pkg_config);
     cmd.arg("--cflags");
     cmd.args(packages);
     let out = cmd.output()?;
     if !out.status.success() {
-        return Err(format!("command {:?} returned {}",
-                           &cmd, out.status).into());
+        return Err(format!("command {:?} returned {}", &cmd, out.status).into());
     }
     let stdout = str::from_utf8(&out.stdout)?;
     Ok(shell_words::split(stdout.trim())?)
 }
 
-
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 struct Layout {
     size: usize,
@@ -98,8 +89,6 @@ struct Results {
     passed: usize,
     /// Total number of failed tests (including those that failed to compile).
     failed: usize,
-    /// Number of tests that failed to compile.
-    failed_to_compile: usize,
 }
 
 impl Results {
@@ -109,16 +98,8 @@ impl Results {
     fn record_failed(&mut self) {
         self.failed += 1;
     }
-    fn record_failed_to_compile(&mut self) {
-        self.failed += 1;
-        self.failed_to_compile += 1;
-    }
     fn summary(&self) -> String {
-        format!(
-            "{} passed; {} failed (compilation errors: {})",
-            self.passed,
-            self.failed,
-            self.failed_to_compile)
+        format!("{} passed; {} failed", self.passed, self.failed)
     }
     fn expect_total_success(&self) {
         if self.failed == 0 {
@@ -131,144 +112,315 @@ impl Results {
 
 #[test]
 fn cross_validate_constants_with_c() {
-    let tmpdir = Builder::new().prefix("abi").tempdir().expect("temporary directory");
-    let cc = Compiler::new().expect("configured compiler");
+    let mut c_constants: Vec<(String, String)> = Vec::new();
 
-    assert_eq!("1",
-               get_c_value(tmpdir.path(), &cc, "1").expect("C constant"),
-               "failed to obtain correct constant value for 1");
+    for l in get_c_output("constant").unwrap().lines() {
+        let mut words = l.trim().split(';');
+        let name = words.next().expect("Failed to parse name").to_owned();
+        let value = words
+            .next()
+            .and_then(|s| s.parse().ok())
+            .expect("Failed to parse value");
+        c_constants.push((name, value));
+    }
 
-    let mut results : Results = Default::default();
-    for (i, &(name, rust_value)) in RUST_CONSTANTS.iter().enumerate() {
-        match get_c_value(tmpdir.path(), &cc, name) {
-            Err(e) => {
-                results.record_failed_to_compile();
-                eprintln!("{}", e);
-            },
-            Ok(ref c_value) => {
-                if rust_value == c_value {
-                    results.record_passed();
-                } else {
-                    results.record_failed();
-                    eprintln!("Constant value mismatch for {}\nRust: {:?}\nC:    {:?}",
-                              name, rust_value, c_value);
-                }
-            }
-        };
-        if (i + 1) % 25 == 0 {
-            println!("constants ... {}", results.summary());
+    let mut results = Results::default();
+
+    for ((rust_name, rust_value), (c_name, c_value)) in
+        RUST_CONSTANTS.iter().zip(c_constants.iter())
+    {
+        if rust_name != c_name {
+            results.record_failed();
+            eprintln!("Name mismatch:\nRust: {:?}\nC:    {:?}", rust_name, c_name,);
+            continue;
         }
+
+        if rust_value != c_value {
+            results.record_failed();
+            eprintln!(
+                "Constant value mismatch for {}\nRust: {:?}\nC:    {:?}",
+                rust_name, rust_value, &c_value
+            );
+            continue;
+        }
+
+        results.record_passed();
     }
+
     results.expect_total_success();
 }
 
 #[test]
 fn cross_validate_layout_with_c() {
-    let tmpdir = Builder::new().prefix("abi").tempdir().expect("temporary directory");
-    let cc = Compiler::new().expect("configured compiler");
+    let mut c_layouts = Vec::new();
 
-    assert_eq!(Layout {size: 1, alignment: 1},
-               get_c_layout(tmpdir.path(), &cc, "char").expect("C layout"),
-               "failed to obtain correct layout for char type");
+    for l in get_c_output("layout").unwrap().lines() {
+        let mut words = l.trim().split(';');
+        let name = words.next().expect("Failed to parse name").to_owned();
+        let size = words
+            .next()
+            .and_then(|s| s.parse().ok())
+            .expect("Failed to parse size");
+        let alignment = words
+            .next()
+            .and_then(|s| s.parse().ok())
+            .expect("Failed to parse alignment");
+        c_layouts.push((name, Layout { size, alignment }));
+    }
 
-    let mut results : Results = Default::default();
-    for (i, &(name, rust_layout)) in RUST_LAYOUTS.iter().enumerate() {
-        match get_c_layout(tmpdir.path(), &cc, name) {
-            Err(e) => {
-                results.record_failed_to_compile();
-                eprintln!("{}", e);
-            },
-            Ok(c_layout) => {
-                if rust_layout == c_layout {
-                    results.record_passed();
-                } else {
-                    results.record_failed();
-                    eprintln!("Layout mismatch for {}\nRust: {:?}\nC:    {:?}",
-                              name, rust_layout, &c_layout);
-                }
-            }
-        };
-        if (i + 1) % 25 == 0 {
-            println!("layout    ... {}", results.summary());
+    let mut results = Results::default();
+
+    for ((rust_name, rust_layout), (c_name, c_layout)) in RUST_LAYOUTS.iter().zip(c_layouts.iter())
+    {
+        if rust_name != c_name {
+            results.record_failed();
+            eprintln!("Name mismatch:\nRust: {:?}\nC:    {:?}", rust_name, c_name,);
+            continue;
         }
-    }
-    results.expect_total_success();
-}
 
-fn get_c_layout(dir: &Path, cc: &Compiler, name: &str) -> Result<Layout, Box<dyn Error>> {
-    let exe = dir.join("layout");
-    let mut cc = cc.clone();
-    cc.define("ABI_TYPE_NAME", name);
-    cc.compile(Path::new("tests/layout.c"), &exe)?;
+        if rust_layout != c_layout {
+            results.record_failed();
+            eprintln!(
+                "Layout mismatch for {}\nRust: {:?}\nC:    {:?}",
+                rust_name, rust_layout, &c_layout
+            );
+            continue;
+        }
 
-    let mut abi_cmd = Command::new(exe);
-    let output = abi_cmd.output()?;
-    if !output.status.success() {
-        return Err(format!("command {:?} failed, {:?}",
-                           &abi_cmd, &output).into());
+        results.record_passed();
     }
 
-    let stdout = str::from_utf8(&output.stdout)?;
-    let mut words = stdout.trim().split_whitespace();
-    let size = words.next().unwrap().parse().unwrap();
-    let alignment = words.next().unwrap().parse().unwrap();
-    Ok(Layout {size, alignment})
+    results.expect_total_success();
 }
 
-fn get_c_value(dir: &Path, cc: &Compiler, name: &str) -> Result<String, Box<dyn Error>> {
-    let exe = dir.join("constant");
-    let mut cc = cc.clone();
-    cc.define("ABI_CONSTANT_NAME", name);
-    cc.compile(Path::new("tests/constant.c"), &exe)?;
+fn get_c_output(name: &str) -> Result<String, Box<dyn Error>> {
+    let tmpdir = Builder::new().prefix("abi").tempdir()?;
+    let exe = tmpdir.path().join(name);
+    let c_file = Path::new("tests").join(name).with_extension("c");
+
+    let cc = Compiler::new().expect("configured compiler");
+    cc.compile(&c_file, &exe)?;
 
     let mut abi_cmd = Command::new(exe);
     let output = abi_cmd.output()?;
     if !output.status.success() {
-        return Err(format!("command {:?} failed, {:?}",
-                           &abi_cmd, &output).into());
+        return Err(format!("command {:?} failed, {:?}", &abi_cmd, &output).into());
     }
 
-    let output = str::from_utf8(&output.stdout)?.trim();
-    if !output.starts_with("###gir test###") ||
-       !output.ends_with("###gir test###") {
-        return Err(format!("command {:?} return invalid output, {:?}",
-                           &abi_cmd, &output).into());
-    }
-
-    Ok(String::from(&output[14..(output.len() - 14)]))
+    Ok(String::from_utf8(output.stdout)?)
 }
 
 const RUST_LAYOUTS: &[(&str, Layout)] = &[
-    ("HinawaFwFcp", Layout {size: size_of::<HinawaFwFcp>(), alignment: align_of::<HinawaFwFcp>()}),
-    ("HinawaFwFcpClass", Layout {size: size_of::<HinawaFwFcpClass>(), alignment: align_of::<HinawaFwFcpClass>()}),
-    ("HinawaFwFcpError", Layout {size: size_of::<HinawaFwFcpError>(), alignment: align_of::<HinawaFwFcpError>()}),
-    ("HinawaFwNode", Layout {size: size_of::<HinawaFwNode>(), alignment: align_of::<HinawaFwNode>()}),
-    ("HinawaFwNodeClass", Layout {size: size_of::<HinawaFwNodeClass>(), alignment: align_of::<HinawaFwNodeClass>()}),
-    ("HinawaFwNodeError", Layout {size: size_of::<HinawaFwNodeError>(), alignment: align_of::<HinawaFwNodeError>()}),
-    ("HinawaFwRcode", Layout {size: size_of::<HinawaFwRcode>(), alignment: align_of::<HinawaFwRcode>()}),
-    ("HinawaFwReq", Layout {size: size_of::<HinawaFwReq>(), alignment: align_of::<HinawaFwReq>()}),
-    ("HinawaFwReqClass", Layout {size: size_of::<HinawaFwReqClass>(), alignment: align_of::<HinawaFwReqClass>()}),
-    ("HinawaFwResp", Layout {size: size_of::<HinawaFwResp>(), alignment: align_of::<HinawaFwResp>()}),
-    ("HinawaFwRespClass", Layout {size: size_of::<HinawaFwRespClass>(), alignment: align_of::<HinawaFwRespClass>()}),
-    ("HinawaFwRespError", Layout {size: size_of::<HinawaFwRespError>(), alignment: align_of::<HinawaFwRespError>()}),
-    ("HinawaFwTcode", Layout {size: size_of::<HinawaFwTcode>(), alignment: align_of::<HinawaFwTcode>()}),
-    ("HinawaSndDg00x", Layout {size: size_of::<HinawaSndDg00x>(), alignment: align_of::<HinawaSndDg00x>()}),
-    ("HinawaSndDg00xClass", Layout {size: size_of::<HinawaSndDg00xClass>(), alignment: align_of::<HinawaSndDg00xClass>()}),
-    ("HinawaSndDice", Layout {size: size_of::<HinawaSndDice>(), alignment: align_of::<HinawaSndDice>()}),
-    ("HinawaSndDiceClass", Layout {size: size_of::<HinawaSndDiceClass>(), alignment: align_of::<HinawaSndDiceClass>()}),
-    ("HinawaSndDiceError", Layout {size: size_of::<HinawaSndDiceError>(), alignment: align_of::<HinawaSndDiceError>()}),
-    ("HinawaSndEfw", Layout {size: size_of::<HinawaSndEfw>(), alignment: align_of::<HinawaSndEfw>()}),
-    ("HinawaSndEfwClass", Layout {size: size_of::<HinawaSndEfwClass>(), alignment: align_of::<HinawaSndEfwClass>()}),
-    ("HinawaSndEfwStatus", Layout {size: size_of::<HinawaSndEfwStatus>(), alignment: align_of::<HinawaSndEfwStatus>()}),
-    ("HinawaSndMotu", Layout {size: size_of::<HinawaSndMotu>(), alignment: align_of::<HinawaSndMotu>()}),
-    ("HinawaSndMotuClass", Layout {size: size_of::<HinawaSndMotuClass>(), alignment: align_of::<HinawaSndMotuClass>()}),
-    ("HinawaSndMotuRegisterDspParameter", Layout {size: size_of::<HinawaSndMotuRegisterDspParameter>(), alignment: align_of::<HinawaSndMotuRegisterDspParameter>()}),
-    ("HinawaSndTscm", Layout {size: size_of::<HinawaSndTscm>(), alignment: align_of::<HinawaSndTscm>()}),
-    ("HinawaSndTscmClass", Layout {size: size_of::<HinawaSndTscmClass>(), alignment: align_of::<HinawaSndTscmClass>()}),
-    ("HinawaSndUnit", Layout {size: size_of::<HinawaSndUnit>(), alignment: align_of::<HinawaSndUnit>()}),
-    ("HinawaSndUnitClass", Layout {size: size_of::<HinawaSndUnitClass>(), alignment: align_of::<HinawaSndUnitClass>()}),
-    ("HinawaSndUnitError", Layout {size: size_of::<HinawaSndUnitError>(), alignment: align_of::<HinawaSndUnitError>()}),
-    ("HinawaSndUnitType", Layout {size: size_of::<HinawaSndUnitType>(), alignment: align_of::<HinawaSndUnitType>()}),
+    (
+        "HinawaFwFcp",
+        Layout {
+            size: size_of::<HinawaFwFcp>(),
+            alignment: align_of::<HinawaFwFcp>(),
+        },
+    ),
+    (
+        "HinawaFwFcpClass",
+        Layout {
+            size: size_of::<HinawaFwFcpClass>(),
+            alignment: align_of::<HinawaFwFcpClass>(),
+        },
+    ),
+    (
+        "HinawaFwFcpError",
+        Layout {
+            size: size_of::<HinawaFwFcpError>(),
+            alignment: align_of::<HinawaFwFcpError>(),
+        },
+    ),
+    (
+        "HinawaFwNode",
+        Layout {
+            size: size_of::<HinawaFwNode>(),
+            alignment: align_of::<HinawaFwNode>(),
+        },
+    ),
+    (
+        "HinawaFwNodeClass",
+        Layout {
+            size: size_of::<HinawaFwNodeClass>(),
+            alignment: align_of::<HinawaFwNodeClass>(),
+        },
+    ),
+    (
+        "HinawaFwNodeError",
+        Layout {
+            size: size_of::<HinawaFwNodeError>(),
+            alignment: align_of::<HinawaFwNodeError>(),
+        },
+    ),
+    (
+        "HinawaFwRcode",
+        Layout {
+            size: size_of::<HinawaFwRcode>(),
+            alignment: align_of::<HinawaFwRcode>(),
+        },
+    ),
+    (
+        "HinawaFwReq",
+        Layout {
+            size: size_of::<HinawaFwReq>(),
+            alignment: align_of::<HinawaFwReq>(),
+        },
+    ),
+    (
+        "HinawaFwReqClass",
+        Layout {
+            size: size_of::<HinawaFwReqClass>(),
+            alignment: align_of::<HinawaFwReqClass>(),
+        },
+    ),
+    (
+        "HinawaFwResp",
+        Layout {
+            size: size_of::<HinawaFwResp>(),
+            alignment: align_of::<HinawaFwResp>(),
+        },
+    ),
+    (
+        "HinawaFwRespClass",
+        Layout {
+            size: size_of::<HinawaFwRespClass>(),
+            alignment: align_of::<HinawaFwRespClass>(),
+        },
+    ),
+    (
+        "HinawaFwRespError",
+        Layout {
+            size: size_of::<HinawaFwRespError>(),
+            alignment: align_of::<HinawaFwRespError>(),
+        },
+    ),
+    (
+        "HinawaFwTcode",
+        Layout {
+            size: size_of::<HinawaFwTcode>(),
+            alignment: align_of::<HinawaFwTcode>(),
+        },
+    ),
+    (
+        "HinawaSndDg00x",
+        Layout {
+            size: size_of::<HinawaSndDg00x>(),
+            alignment: align_of::<HinawaSndDg00x>(),
+        },
+    ),
+    (
+        "HinawaSndDg00xClass",
+        Layout {
+            size: size_of::<HinawaSndDg00xClass>(),
+            alignment: align_of::<HinawaSndDg00xClass>(),
+        },
+    ),
+    (
+        "HinawaSndDice",
+        Layout {
+            size: size_of::<HinawaSndDice>(),
+            alignment: align_of::<HinawaSndDice>(),
+        },
+    ),
+    (
+        "HinawaSndDiceClass",
+        Layout {
+            size: size_of::<HinawaSndDiceClass>(),
+            alignment: align_of::<HinawaSndDiceClass>(),
+        },
+    ),
+    (
+        "HinawaSndDiceError",
+        Layout {
+            size: size_of::<HinawaSndDiceError>(),
+            alignment: align_of::<HinawaSndDiceError>(),
+        },
+    ),
+    (
+        "HinawaSndEfw",
+        Layout {
+            size: size_of::<HinawaSndEfw>(),
+            alignment: align_of::<HinawaSndEfw>(),
+        },
+    ),
+    (
+        "HinawaSndEfwClass",
+        Layout {
+            size: size_of::<HinawaSndEfwClass>(),
+            alignment: align_of::<HinawaSndEfwClass>(),
+        },
+    ),
+    (
+        "HinawaSndEfwStatus",
+        Layout {
+            size: size_of::<HinawaSndEfwStatus>(),
+            alignment: align_of::<HinawaSndEfwStatus>(),
+        },
+    ),
+    (
+        "HinawaSndMotu",
+        Layout {
+            size: size_of::<HinawaSndMotu>(),
+            alignment: align_of::<HinawaSndMotu>(),
+        },
+    ),
+    (
+        "HinawaSndMotuClass",
+        Layout {
+            size: size_of::<HinawaSndMotuClass>(),
+            alignment: align_of::<HinawaSndMotuClass>(),
+        },
+    ),
+    (
+        "HinawaSndMotuRegisterDspParameter",
+        Layout {
+            size: size_of::<HinawaSndMotuRegisterDspParameter>(),
+            alignment: align_of::<HinawaSndMotuRegisterDspParameter>(),
+        },
+    ),
+    (
+        "HinawaSndTscm",
+        Layout {
+            size: size_of::<HinawaSndTscm>(),
+            alignment: align_of::<HinawaSndTscm>(),
+        },
+    ),
+    (
+        "HinawaSndTscmClass",
+        Layout {
+            size: size_of::<HinawaSndTscmClass>(),
+            alignment: align_of::<HinawaSndTscmClass>(),
+        },
+    ),
+    (
+        "HinawaSndUnit",
+        Layout {
+            size: size_of::<HinawaSndUnit>(),
+            alignment: align_of::<HinawaSndUnit>(),
+        },
+    ),
+    (
+        "HinawaSndUnitClass",
+        Layout {
+            size: size_of::<HinawaSndUnitClass>(),
+            alignment: align_of::<HinawaSndUnitClass>(),
+        },
+    ),
+    (
+        "HinawaSndUnitError",
+        Layout {
+            size: size_of::<HinawaSndUnitError>(),
+            alignment: align_of::<HinawaSndUnitError>(),
+        },
+    ),
+    (
+        "HinawaSndUnitType",
+        Layout {
+            size: size_of::<HinawaSndUnitType>(),
+            alignment: align_of::<HinawaSndUnitType>(),
+        },
+    ),
 ];
 
 const RUST_CONSTANTS: &[(&str, &str)] = &[
@@ -345,5 +497,3 @@ const RUST_CONSTANTS: &[(&str, &str)] = &[
     ("(gint) HINAWA_SND_UNIT_TYPE_OXFW", "4"),
     ("(gint) HINAWA_SND_UNIT_TYPE_TASCAM", "6"),
 ];
-
-
diff --git a/hinawa-sys/tests/constant.c b/hinawa-sys/tests/constant.c
index 9836428..3cc3e8e 100644
--- a/hinawa-sys/tests/constant.c
+++ b/hinawa-sys/tests/constant.c
@@ -1,27 +1,105 @@
 // 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
 
 #include "manual.h"
 #include <stdio.h>
 
+#define PRINT_CONSTANT(CONSTANT_NAME) \
+    printf("%s;", #CONSTANT_NAME); \
+    printf(_Generic((CONSTANT_NAME), \
+                    char *: "%s", \
+                    const char *: "%s", \
+                    char: "%c", \
+                    signed char: "%hhd", \
+                    unsigned char: "%hhu", \
+                    short int: "%hd", \
+                    unsigned short int: "%hu", \
+                    int: "%d", \
+                    unsigned int: "%u", \
+                    long: "%ld", \
+                    unsigned long: "%lu", \
+                    long long: "%lld", \
+                    unsigned long long: "%llu", \
+                    float: "%f", \
+                    double: "%f", \
+                    long double: "%ld"), \
+           CONSTANT_NAME); \
+    printf("\n");
+
 int main() {
-    printf(_Generic((ABI_CONSTANT_NAME),
-                    char *: "###gir test###%s###gir test###\n",
-                    const char *: "###gir test###%s###gir test###\n",
-                    char: "###gir test###%c###gir test###\n",
-                    signed char: "###gir test###%hhd###gir test###\n",
-                    unsigned char: "###gir test###%hhu###gir test###\n",
-                    short int: "###gir test###%hd###gir test###\n",
-                    unsigned short int: "###gir test###%hu###gir test###\n",
-                    int: "###gir test###%d###gir test###\n",
-                    unsigned int: "###gir test###%u###gir test###\n",
-                    long: "###gir test###%ld###gir test###\n",
-                    unsigned long: "###gir test###%lu###gir test###\n",
-                    long long: "###gir test###%lld###gir test###\n",
-                    unsigned long long: "###gir test###%llu###gir test###\n",
-                    double: "###gir test###%f###gir test###\n",
-                    long double: "###gir test###%ld###gir test###\n"),
-           ABI_CONSTANT_NAME);
+    PRINT_CONSTANT((gint) HINAWA_FW_FCP_ERROR_LARGE_RESP);
+    PRINT_CONSTANT((gint) HINAWA_FW_FCP_ERROR_TIMEOUT);
+    PRINT_CONSTANT((gint) HINAWA_FW_NODE_ERROR_DISCONNECTED);
+    PRINT_CONSTANT((gint) HINAWA_FW_NODE_ERROR_FAILED);
+    PRINT_CONSTANT((gint) HINAWA_FW_NODE_ERROR_NOT_OPENED);
+    PRINT_CONSTANT((gint) HINAWA_FW_NODE_ERROR_OPENED);
+    PRINT_CONSTANT((gint) HINAWA_FW_RCODE_ADDRESS_ERROR);
+    PRINT_CONSTANT((gint) HINAWA_FW_RCODE_BUSY);
+    PRINT_CONSTANT((gint) HINAWA_FW_RCODE_CANCELLED);
+    PRINT_CONSTANT((gint) HINAWA_FW_RCODE_COMPLETE);
+    PRINT_CONSTANT((gint) HINAWA_FW_RCODE_CONFLICT_ERROR);
+    PRINT_CONSTANT((gint) HINAWA_FW_RCODE_DATA_ERROR);
+    PRINT_CONSTANT((gint) HINAWA_FW_RCODE_GENERATION);
+    PRINT_CONSTANT((gint) HINAWA_FW_RCODE_INVALID);
+    PRINT_CONSTANT((gint) HINAWA_FW_RCODE_NO_ACK);
+    PRINT_CONSTANT((gint) HINAWA_FW_RCODE_SEND_ERROR);
+    PRINT_CONSTANT((gint) HINAWA_FW_RCODE_TYPE_ERROR);
+    PRINT_CONSTANT((gint) HINAWA_FW_RESP_ERROR_ADDR_SPACE_USED);
+    PRINT_CONSTANT((gint) HINAWA_FW_RESP_ERROR_FAILED);
+    PRINT_CONSTANT((gint) HINAWA_FW_RESP_ERROR_RESERVED);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_CYCLE_START);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_LOCK_BOUNDED_ADD);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_LOCK_COMPARE_SWAP);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_LOCK_FETCH_ADD);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_LOCK_LITTLE_ADD);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_LOCK_MASK_SWAP);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_LOCK_REQUEST);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_LOCK_RESPONSE);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_LOCK_VENDOR_DEPENDENT);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_LOCK_WRAP_ADD);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_READ_BLOCK_REQUEST);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_READ_BLOCK_RESPONSE);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_READ_QUADLET_REQUEST);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_READ_QUADLET_RESPONSE);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_STREAM_DATA);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_WRITE_BLOCK_REQUEST);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_WRITE_QUADLET_REQUEST);
+    PRINT_CONSTANT((gint) HINAWA_FW_TCODE_WRITE_RESPONSE);
+    PRINT_CONSTANT((gint) HINAWA_SND_DICE_ERROR_TIMEOUT);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_BAD);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_BAD_CHANNEL);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_BAD_CLOCK);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_BAD_COMMAND);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_BAD_LED);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_BAD_MIRROR);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_BAD_PAN);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_BAD_PARAMETER);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_BAD_QUAD_COUNT);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_BAD_RATE);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_COMM_ERR);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_DSP_TIMEOUT);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_FLASH_BUSY);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_LARGE_RESP);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_OK);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_TIMEOUT);
+    PRINT_CONSTANT((gint) HINAWA_SND_EFW_STATUS_UNSUPPORTED);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_ERROR_DISCONNECTED);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_ERROR_FAILED);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_ERROR_LOCKED);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_ERROR_NOT_OPENED);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_ERROR_OPENED);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_ERROR_UNLOCKED);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_ERROR_USED);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_ERROR_WRONG_CLASS);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_TYPE_BEBOB);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_TYPE_DICE);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_TYPE_DIGI00X);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_TYPE_FIREFACE);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_TYPE_FIREWORKS);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_TYPE_MOTU);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_TYPE_OXFW);
+    PRINT_CONSTANT((gint) HINAWA_SND_UNIT_TYPE_TASCAM);
     return 0;
 }
diff --git a/hinawa-sys/tests/layout.c b/hinawa-sys/tests/layout.c
index 45f2ef4..568b53c 100644
--- a/hinawa-sys/tests/layout.c
+++ b/hinawa-sys/tests/layout.c
@@ -1,4 +1,5 @@
 // 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
 
@@ -7,6 +8,35 @@
 #include <stdio.h>
 
 int main() {
-    printf("%zu\n%zu", sizeof(ABI_TYPE_NAME), alignof(ABI_TYPE_NAME));
+    printf("%s;%zu;%zu\n", "HinawaFwFcp", sizeof(HinawaFwFcp), alignof(HinawaFwFcp));
+    printf("%s;%zu;%zu\n", "HinawaFwFcpClass", sizeof(HinawaFwFcpClass), alignof(HinawaFwFcpClass));
+    printf("%s;%zu;%zu\n", "HinawaFwFcpError", sizeof(HinawaFwFcpError), alignof(HinawaFwFcpError));
+    printf("%s;%zu;%zu\n", "HinawaFwNode", sizeof(HinawaFwNode), alignof(HinawaFwNode));
+    printf("%s;%zu;%zu\n", "HinawaFwNodeClass", sizeof(HinawaFwNodeClass), alignof(HinawaFwNodeClass));
+    printf("%s;%zu;%zu\n", "HinawaFwNodeError", sizeof(HinawaFwNodeError), alignof(HinawaFwNodeError));
+    printf("%s;%zu;%zu\n", "HinawaFwRcode", sizeof(HinawaFwRcode), alignof(HinawaFwRcode));
+    printf("%s;%zu;%zu\n", "HinawaFwReq", sizeof(HinawaFwReq), alignof(HinawaFwReq));
+    printf("%s;%zu;%zu\n", "HinawaFwReqClass", sizeof(HinawaFwReqClass), alignof(HinawaFwReqClass));
+    printf("%s;%zu;%zu\n", "HinawaFwResp", sizeof(HinawaFwResp), alignof(HinawaFwResp));
+    printf("%s;%zu;%zu\n", "HinawaFwRespClass", sizeof(HinawaFwRespClass), alignof(HinawaFwRespClass));
+    printf("%s;%zu;%zu\n", "HinawaFwRespError", sizeof(HinawaFwRespError), alignof(HinawaFwRespError));
+    printf("%s;%zu;%zu\n", "HinawaFwTcode", sizeof(HinawaFwTcode), alignof(HinawaFwTcode));
+    printf("%s;%zu;%zu\n", "HinawaSndDg00x", sizeof(HinawaSndDg00x), alignof(HinawaSndDg00x));
+    printf("%s;%zu;%zu\n", "HinawaSndDg00xClass", sizeof(HinawaSndDg00xClass), alignof(HinawaSndDg00xClass));
+    printf("%s;%zu;%zu\n", "HinawaSndDice", sizeof(HinawaSndDice), alignof(HinawaSndDice));
+    printf("%s;%zu;%zu\n", "HinawaSndDiceClass", sizeof(HinawaSndDiceClass), alignof(HinawaSndDiceClass));
+    printf("%s;%zu;%zu\n", "HinawaSndDiceError", sizeof(HinawaSndDiceError), alignof(HinawaSndDiceError));
+    printf("%s;%zu;%zu\n", "HinawaSndEfw", sizeof(HinawaSndEfw), alignof(HinawaSndEfw));
+    printf("%s;%zu;%zu\n", "HinawaSndEfwClass", sizeof(HinawaSndEfwClass), alignof(HinawaSndEfwClass));
+    printf("%s;%zu;%zu\n", "HinawaSndEfwStatus", sizeof(HinawaSndEfwStatus), alignof(HinawaSndEfwStatus));
+    printf("%s;%zu;%zu\n", "HinawaSndMotu", sizeof(HinawaSndMotu), alignof(HinawaSndMotu));
+    printf("%s;%zu;%zu\n", "HinawaSndMotuClass", sizeof(HinawaSndMotuClass), alignof(HinawaSndMotuClass));
+    printf("%s;%zu;%zu\n", "HinawaSndMotuRegisterDspParameter", sizeof(HinawaSndMotuRegisterDspParameter), alignof(HinawaSndMotuRegisterDspParameter));
+    printf("%s;%zu;%zu\n", "HinawaSndTscm", sizeof(HinawaSndTscm), alignof(HinawaSndTscm));
+    printf("%s;%zu;%zu\n", "HinawaSndTscmClass", sizeof(HinawaSndTscmClass), alignof(HinawaSndTscmClass));
+    printf("%s;%zu;%zu\n", "HinawaSndUnit", sizeof(HinawaSndUnit), alignof(HinawaSndUnit));
+    printf("%s;%zu;%zu\n", "HinawaSndUnitClass", sizeof(HinawaSndUnitClass), alignof(HinawaSndUnitClass));
+    printf("%s;%zu;%zu\n", "HinawaSndUnitError", sizeof(HinawaSndUnitError), alignof(HinawaSndUnitError));
+    printf("%s;%zu;%zu\n", "HinawaSndUnitType", sizeof(HinawaSndUnitType), alignof(HinawaSndUnitType));
     return 0;
 }
diff --git a/hinawa-sys/tests/manual.h b/hinawa-sys/tests/manual.h
index 33968c2..199b2f2 100644
--- a/hinawa-sys/tests/manual.h
+++ b/hinawa-sys/tests/manual.h
@@ -1,2 +1,2 @@
 // Feel free to edit this file, it won't be regenerated by gir generator unless removed.
-
+#include <hinawa.h>
diff --git a/hinawa-sys/versions.txt b/hinawa-sys/versions.txt
index 60d5c74..00e8a32 100644
--- a/hinawa-sys/versions.txt
+++ b/hinawa-sys/versions.txt
@@ -1,2 +1,3 @@
-Generated by gir (https://github.com/gtk-rs/gir @ a6737c7)
-from gir-files (https://github.com/gtk-rs/gir-files @ c31e734)
+Generated by gir (https://github.com/gtk-rs/gir @ 78e3d3c22343)
+from 
+from gir-files (https://github.com/gtk-rs/gir-files @ 5ca60543e148)