First working version

9 files changed, 3022 insertions, 0 deletions

diff --git a/src/dbus_api/equalizing_manager.rs b/src/dbus_api/equalizing_manager.rs
new file mode 100644
index 0000000..5f6574f
--- /dev/null
+++ b/src/dbus_api/equalizing_manager.rs
@@ -0,0 +1,291 @@
+// This code was autogenerated with dbus-codegen-rust, see https://github.com/diwic/dbus-rs
+
+#![allow(dead_code)]
+use dbus as dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait OrgPulseAudioExtEqualizing1Manager {
+    type Err;
+    fn remove_profile(&self, name: &str) -> Result<(), Self::Err>;
+    fn get_interface_revision(&self) -> Result<u32, Self::Err>;
+    fn get_equalized_sinks(&self) -> Result<Vec<dbus::Path<'static>>, Self::Err>;
+    fn get_profiles(&self) -> Result<Vec<String>, Self::Err>;
+}
+
+impl<'a, C: ::std::ops::Deref<Target=dbus::Connection>> OrgPulseAudioExtEqualizing1Manager for dbus::ConnPath<'a, C> {
+    type Err = dbus::Error;
+
+    fn remove_profile(&self, name: &str) -> Result<(), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.PulseAudio.Ext.Equalizing1.Manager".into(), &"RemoveProfile".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(name);
+        }));
+        try!(m.as_result());
+        Ok(())
+    }
+
+    fn get_interface_revision(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Ext.Equalizing1.Manager", "InterfaceRevision")
+    }
+
+    fn get_equalized_sinks(&self) -> Result<Vec<dbus::Path<'static>>, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Ext.Equalizing1.Manager", "EqualizedSinks")
+    }
+
+    fn get_profiles(&self) -> Result<Vec<String>, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Ext.Equalizing1.Manager", "Profiles")
+    }
+}
+
+pub fn org_pulse_audio_ext_equalizing1_manager_server<F, T, D>(factory: &tree::Factory<tree::MTFn<D>, D>, data: D::Interface, f: F) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: OrgPulseAudioExtEqualizing1Manager<Err=tree::MethodErr>,
+    F: 'static + for <'z> Fn(& 'z tree::MethodInfo<tree::MTFn<D>, D>) -> & 'z T,
+{
+    let i = factory.interface("org.PulseAudio.Ext.Equalizing1.Manager", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let name: &str = try!(i.read());
+        let d = fclone(minfo);
+        try!(d.remove_profile(name));
+        let rm = minfo.msg.method_return();
+        Ok(vec!(rm))
+    };
+    let m = factory.method("RemoveProfile", Default::default(), h);
+    let m = m.in_arg(("name", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("InterfaceRevision", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_interface_revision()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("EqualizedSinks", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_equalized_sinks()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<&str>, _>("Profiles", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_profiles()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
+
+#[derive(Debug, Default)]
+pub struct OrgPulseAudioExtEqualizing1ManagerSinkAdded {
+    pub sink: dbus::Path<'static>,
+}
+
+impl dbus::SignalArgs for OrgPulseAudioExtEqualizing1ManagerSinkAdded {
+    const NAME: &'static str = "SinkAdded";
+    const INTERFACE: &'static str = "org.PulseAudio.Ext.Equalizing1.Manager";
+    fn append(&self, i: &mut arg::IterAppend) {
+        (&self.sink as &arg::RefArg).append(i);
+    }
+    fn get(&mut self, i: &mut arg::Iter) -> Result<(), arg::TypeMismatchError> {
+        self.sink = try!(i.read());
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct OrgPulseAudioExtEqualizing1ManagerSinkRemoved {
+    pub sink: dbus::Path<'static>,
+}
+
+impl dbus::SignalArgs for OrgPulseAudioExtEqualizing1ManagerSinkRemoved {
+    const NAME: &'static str = "SinkRemoved";
+    const INTERFACE: &'static str = "org.PulseAudio.Ext.Equalizing1.Manager";
+    fn append(&self, i: &mut arg::IterAppend) {
+        (&self.sink as &arg::RefArg).append(i);
+    }
+    fn get(&mut self, i: &mut arg::Iter) -> Result<(), arg::TypeMismatchError> {
+        self.sink = try!(i.read());
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct OrgPulseAudioExtEqualizing1ManagerProfilesChanged {
+}
+
+impl dbus::SignalArgs for OrgPulseAudioExtEqualizing1ManagerProfilesChanged {
+    const NAME: &'static str = "ProfilesChanged";
+    const INTERFACE: &'static str = "org.PulseAudio.Ext.Equalizing1.Manager";
+    fn append(&self, _: &mut arg::IterAppend) {
+    }
+    fn get(&mut self, _: &mut arg::Iter) -> Result<(), arg::TypeMismatchError> {
+        Ok(())
+    }
+}
+
+pub trait OrgFreedesktopDBusIntrospectable {
+    type Err;
+    fn introspect(&self) -> Result<String, Self::Err>;
+}
+
+impl<'a, C: ::std::ops::Deref<Target=dbus::Connection>> OrgFreedesktopDBusIntrospectable for dbus::ConnPath<'a, C> {
+    type Err = dbus::Error;
+
+    fn introspect(&self) -> Result<String, Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Introspectable".into(), &"Introspect".into(), |_| {
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let data: String = try!(i.read());
+        Ok(data)
+    }
+}
+
+pub fn org_freedesktop_dbus_introspectable_server<F, T, D>(factory: &tree::Factory<tree::MTFn<D>, D>, data: D::Interface, f: F) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: OrgFreedesktopDBusIntrospectable<Err=tree::MethodErr>,
+    F: 'static + for <'z> Fn(& 'z tree::MethodInfo<tree::MTFn<D>, D>) -> & 'z T,
+{
+    let i = factory.interface("org.freedesktop.DBus.Introspectable", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let data = try!(d.introspect());
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(data);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("Introspect", Default::default(), h);
+    let m = m.out_arg(("data", "s"));
+    let i = i.add_m(m);
+    i
+}
+
+pub trait OrgFreedesktopDBusProperties {
+    type Err;
+    fn get(&self, interface_name: &str, property_name: &str) -> Result<arg::Variant<Box<arg::RefArg>>, Self::Err>;
+    fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant<Box<arg::RefArg>>) -> Result<(), Self::Err>;
+    fn get_all(&self, interface_name: &str) -> Result<::std::collections::HashMap<String, arg::Variant<Box<arg::RefArg>>>, Self::Err>;
+}
+
+impl<'a, C: ::std::ops::Deref<Target=dbus::Connection>> OrgFreedesktopDBusProperties for dbus::ConnPath<'a, C> {
+    type Err = dbus::Error;
+
+    fn get(&self, interface_name: &str, property_name: &str) -> Result<arg::Variant<Box<arg::RefArg>>, Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Properties".into(), &"Get".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(interface_name);
+            i.append(property_name);
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let value: arg::Variant<Box<arg::RefArg>> = try!(i.read());
+        Ok(value)
+    }
+
+    fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant<Box<arg::RefArg>>) -> Result<(), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Properties".into(), &"Set".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(interface_name);
+            i.append(property_name);
+            i.append(value);
+        }));
+        try!(m.as_result());
+        Ok(())
+    }
+
+    fn get_all(&self, interface_name: &str) -> Result<::std::collections::HashMap<String, arg::Variant<Box<arg::RefArg>>>, Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Properties".into(), &"GetAll".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(interface_name);
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let props: ::std::collections::HashMap<String, arg::Variant<Box<arg::RefArg>>> = try!(i.read());
+        Ok(props)
+    }
+}
+
+pub fn org_freedesktop_dbus_properties_server<F, T, D>(factory: &tree::Factory<tree::MTFn<D>, D>, data: D::Interface, f: F) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: OrgFreedesktopDBusProperties<Err=tree::MethodErr>,
+    F: 'static + for <'z> Fn(& 'z tree::MethodInfo<tree::MTFn<D>, D>) -> & 'z T,
+{
+    let i = factory.interface("org.freedesktop.DBus.Properties", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let interface_name: &str = try!(i.read());
+        let property_name: &str = try!(i.read());
+        let d = fclone(minfo);
+        let value = try!(d.get(interface_name, property_name));
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(value);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("Get", Default::default(), h);
+    let m = m.in_arg(("interface_name", "s"));
+    let m = m.in_arg(("property_name", "s"));
+    let m = m.out_arg(("value", "v"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let interface_name: &str = try!(i.read());
+        let property_name: &str = try!(i.read());
+        let value: arg::Variant<Box<arg::RefArg>> = try!(i.read());
+        let d = fclone(minfo);
+        try!(d.set(interface_name, property_name, value));
+        let rm = minfo.msg.method_return();
+        Ok(vec!(rm))
+    };
+    let m = factory.method("Set", Default::default(), h);
+    let m = m.in_arg(("interface_name", "s"));
+    let m = m.in_arg(("property_name", "s"));
+    let m = m.in_arg(("value", "v"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let interface_name: &str = try!(i.read());
+        let d = fclone(minfo);
+        let props = try!(d.get_all(interface_name));
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(props);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("GetAll", Default::default(), h);
+    let m = m.in_arg(("interface_name", "s"));
+    let m = m.out_arg(("props", "a{sv}"));
+    let i = i.add_m(m);
+    i
+}
diff --git a/src/dbus_api/mod.rs b/src/dbus_api/mod.rs
new file mode 100644
index 0000000..a184c55
--- /dev/null
+++ b/src/dbus_api/mod.rs
@@ -0,0 +1,3 @@
+pub mod equalizing_manager;
+pub mod server_lookup;
+pub mod sink;
diff --git a/src/dbus_api/server_lookup.rs b/src/dbus_api/server_lookup.rs
new file mode 100644
index 0000000..78ad4bd
--- /dev/null
+++ b/src/dbus_api/server_lookup.rs
@@ -0,0 +1,188 @@
+// This code was autogenerated with dbus-codegen-rust, see https://github.com/diwic/dbus-rs
+
+#![allow(dead_code)]
+use dbus as dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait OrgPulseAudioServerLookup1 {
+    type Err;
+    fn get_address(&self) -> Result<String, Self::Err>;
+}
+
+impl<'a, C: ::std::ops::Deref<Target=dbus::Connection>> OrgPulseAudioServerLookup1 for dbus::ConnPath<'a, C> {
+    type Err = dbus::Error;
+
+    fn get_address(&self) -> Result<String, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.ServerLookup1", "Address")
+    }
+}
+
+pub fn org_pulse_audio_server_lookup1_server<F, T, D>(factory: &tree::Factory<tree::MTFn<D>, D>, data: D::Interface, f: F) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: OrgPulseAudioServerLookup1<Err=tree::MethodErr>,
+    F: 'static + for <'z> Fn(& 'z tree::MethodInfo<tree::MTFn<D>, D>) -> & 'z T,
+{
+    let i = factory.interface("org.PulseAudio.ServerLookup1", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<&str, _>("Address", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_address()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
+
+pub trait OrgFreedesktopDBusIntrospectable {
+    type Err;
+    fn introspect(&self) -> Result<String, Self::Err>;
+}
+
+impl<'a, C: ::std::ops::Deref<Target=dbus::Connection>> OrgFreedesktopDBusIntrospectable for dbus::ConnPath<'a, C> {
+    type Err = dbus::Error;
+
+    fn introspect(&self) -> Result<String, Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Introspectable".into(), &"Introspect".into(), |_| {
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let data: String = try!(i.read());
+        Ok(data)
+    }
+}
+
+pub fn org_freedesktop_dbus_introspectable_server<F, T, D>(factory: &tree::Factory<tree::MTFn<D>, D>, data: D::Interface, f: F) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: OrgFreedesktopDBusIntrospectable<Err=tree::MethodErr>,
+    F: 'static + for <'z> Fn(& 'z tree::MethodInfo<tree::MTFn<D>, D>) -> & 'z T,
+{
+    let i = factory.interface("org.freedesktop.DBus.Introspectable", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let data = try!(d.introspect());
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(data);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("Introspect", Default::default(), h);
+    let m = m.out_arg(("data", "s"));
+    let i = i.add_m(m);
+    i
+}
+
+pub trait OrgFreedesktopDBusProperties {
+    type Err;
+    fn get(&self, interface_name: &str, property_name: &str) -> Result<arg::Variant<Box<arg::RefArg>>, Self::Err>;
+    fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant<Box<arg::RefArg>>) -> Result<(), Self::Err>;
+    fn get_all(&self, interface_name: &str) -> Result<::std::collections::HashMap<String, arg::Variant<Box<arg::RefArg>>>, Self::Err>;
+}
+
+impl<'a, C: ::std::ops::Deref<Target=dbus::Connection>> OrgFreedesktopDBusProperties for dbus::ConnPath<'a, C> {
+    type Err = dbus::Error;
+
+    fn get(&self, interface_name: &str, property_name: &str) -> Result<arg::Variant<Box<arg::RefArg>>, Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Properties".into(), &"Get".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(interface_name);
+            i.append(property_name);
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let value: arg::Variant<Box<arg::RefArg>> = try!(i.read());
+        Ok(value)
+    }
+
+    fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant<Box<arg::RefArg>>) -> Result<(), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Properties".into(), &"Set".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(interface_name);
+            i.append(property_name);
+            i.append(value);
+        }));
+        try!(m.as_result());
+        Ok(())
+    }
+
+    fn get_all(&self, interface_name: &str) -> Result<::std::collections::HashMap<String, arg::Variant<Box<arg::RefArg>>>, Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Properties".into(), &"GetAll".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(interface_name);
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let props: ::std::collections::HashMap<String, arg::Variant<Box<arg::RefArg>>> = try!(i.read());
+        Ok(props)
+    }
+}
+
+pub fn org_freedesktop_dbus_properties_server<F, T, D>(factory: &tree::Factory<tree::MTFn<D>, D>, data: D::Interface, f: F) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: OrgFreedesktopDBusProperties<Err=tree::MethodErr>,
+    F: 'static + for <'z> Fn(& 'z tree::MethodInfo<tree::MTFn<D>, D>) -> & 'z T,
+{
+    let i = factory.interface("org.freedesktop.DBus.Properties", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let interface_name: &str = try!(i.read());
+        let property_name: &str = try!(i.read());
+        let d = fclone(minfo);
+        let value = try!(d.get(interface_name, property_name));
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(value);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("Get", Default::default(), h);
+    let m = m.in_arg(("interface_name", "s"));
+    let m = m.in_arg(("property_name", "s"));
+    let m = m.out_arg(("value", "v"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let interface_name: &str = try!(i.read());
+        let property_name: &str = try!(i.read());
+        let value: arg::Variant<Box<arg::RefArg>> = try!(i.read());
+        let d = fclone(minfo);
+        try!(d.set(interface_name, property_name, value));
+        let rm = minfo.msg.method_return();
+        Ok(vec!(rm))
+    };
+    let m = factory.method("Set", Default::default(), h);
+    let m = m.in_arg(("interface_name", "s"));
+    let m = m.in_arg(("property_name", "s"));
+    let m = m.in_arg(("value", "v"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let interface_name: &str = try!(i.read());
+        let d = fclone(minfo);
+        let props = try!(d.get_all(interface_name));
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(props);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("GetAll", Default::default(), h);
+    let m = m.in_arg(("interface_name", "s"));
+    let m = m.out_arg(("props", "a{sv}"));
+    let i = i.add_m(m);
+    i
+}
diff --git a/src/dbus_api/sink.rs b/src/dbus_api/sink.rs
new file mode 100644
index 0000000..6bd1756
--- /dev/null
+++ b/src/dbus_api/sink.rs
@@ -0,0 +1,1128 @@
+// This code was autogenerated with dbus-codegen-rust, see https://github.com/diwic/dbus-rs
+
+#![allow(dead_code)]
+use dbus as dbus;
+use dbus::arg;
+use dbus::tree;
+
+pub trait OrgPulseAudioExtEqualizing1Equalizer {
+    type Err;
+    fn filter_at_points(&self, channel: u32, xs: Vec<u32>) -> Result<(Vec<f64>, f64), Self::Err>;
+    fn seed_filter(&self, channel: u32, xs: Vec<u32>, ys: Vec<f64>, preamp: f64) -> Result<(), Self::Err>;
+    fn save_profile(&self, channel: u32, name: &str) -> Result<(), Self::Err>;
+    fn load_profile(&self, channel: u32, name: &str) -> Result<(), Self::Err>;
+    fn set_filter(&self, channel: u32, ys: Vec<f64>, preamp: f64) -> Result<(), Self::Err>;
+    fn get_filter(&self, channel: u32) -> Result<(Vec<f64>, f64), Self::Err>;
+    fn save_state(&self) -> Result<(), Self::Err>;
+    fn base_profile(&self, channel: u32) -> Result<String, Self::Err>;
+    fn get_interface_revision(&self) -> Result<u32, Self::Err>;
+    fn get_sample_rate(&self) -> Result<u32, Self::Err>;
+    fn get_filter_sample_rate(&self) -> Result<u32, Self::Err>;
+    fn get_nfilter_coefficients(&self) -> Result<u32, Self::Err>;
+    fn get_nchannels(&self) -> Result<u32, Self::Err>;
+}
+
+impl<'a, C: ::std::ops::Deref<Target=dbus::Connection>> OrgPulseAudioExtEqualizing1Equalizer for dbus::ConnPath<'a, C> {
+    type Err = dbus::Error;
+
+    fn filter_at_points(&self, channel: u32, xs: Vec<u32>) -> Result<(Vec<f64>, f64), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.PulseAudio.Ext.Equalizing1.Equalizer".into(), &"FilterAtPoints".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(channel);
+            i.append(xs);
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let ys: Vec<f64> = try!(i.read());
+        let preamp: f64 = try!(i.read());
+        Ok((ys, preamp))
+    }
+
+    fn seed_filter(&self, channel: u32, xs: Vec<u32>, ys: Vec<f64>, preamp: f64) -> Result<(), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.PulseAudio.Ext.Equalizing1.Equalizer".into(), &"SeedFilter".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(channel);
+            i.append(xs);
+            i.append(ys);
+            i.append(preamp);
+        }));
+        try!(m.as_result());
+        Ok(())
+    }
+
+    fn save_profile(&self, channel: u32, name: &str) -> Result<(), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.PulseAudio.Ext.Equalizing1.Equalizer".into(), &"SaveProfile".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(channel);
+            i.append(name);
+        }));
+        try!(m.as_result());
+        Ok(())
+    }
+
+    fn load_profile(&self, channel: u32, name: &str) -> Result<(), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.PulseAudio.Ext.Equalizing1.Equalizer".into(), &"LoadProfile".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(channel);
+            i.append(name);
+        }));
+        try!(m.as_result());
+        Ok(())
+    }
+
+    fn set_filter(&self, channel: u32, ys: Vec<f64>, preamp: f64) -> Result<(), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.PulseAudio.Ext.Equalizing1.Equalizer".into(), &"SetFilter".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(channel);
+            i.append(ys);
+            i.append(preamp);
+        }));
+        try!(m.as_result());
+        Ok(())
+    }
+
+    fn get_filter(&self, channel: u32) -> Result<(Vec<f64>, f64), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.PulseAudio.Ext.Equalizing1.Equalizer".into(), &"GetFilter".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(channel);
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let ys: Vec<f64> = try!(i.read());
+        let preamp: f64 = try!(i.read());
+        Ok((ys, preamp))
+    }
+
+    fn save_state(&self) -> Result<(), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.PulseAudio.Ext.Equalizing1.Equalizer".into(), &"SaveState".into(), |_| {
+        }));
+        try!(m.as_result());
+        Ok(())
+    }
+
+    fn base_profile(&self, channel: u32) -> Result<String, Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.PulseAudio.Ext.Equalizing1.Equalizer".into(), &"BaseProfile".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(channel);
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let name: String = try!(i.read());
+        Ok(name)
+    }
+
+    fn get_interface_revision(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Ext.Equalizing1.Equalizer", "InterfaceRevision")
+    }
+
+    fn get_sample_rate(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Ext.Equalizing1.Equalizer", "SampleRate")
+    }
+
+    fn get_filter_sample_rate(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Ext.Equalizing1.Equalizer", "FilterSampleRate")
+    }
+
+    fn get_nfilter_coefficients(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Ext.Equalizing1.Equalizer", "NFilterCoefficients")
+    }
+
+    fn get_nchannels(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Ext.Equalizing1.Equalizer", "NChannels")
+    }
+}
+
+pub fn org_pulse_audio_ext_equalizing1_equalizer_server<F, T, D>(factory: &tree::Factory<tree::MTFn<D>, D>, data: D::Interface, f: F) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: OrgPulseAudioExtEqualizing1Equalizer<Err=tree::MethodErr>,
+    F: 'static + for <'z> Fn(& 'z tree::MethodInfo<tree::MTFn<D>, D>) -> & 'z T,
+{
+    let i = factory.interface("org.PulseAudio.Ext.Equalizing1.Equalizer", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel: u32 = try!(i.read());
+        let xs: Vec<u32> = try!(i.read());
+        let d = fclone(minfo);
+        let (ys, preamp) = try!(d.filter_at_points(channel, xs));
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(ys);
+        let rm = rm.append1(preamp);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("FilterAtPoints", Default::default(), h);
+    let m = m.in_arg(("channel", "u"));
+    let m = m.in_arg(("xs", "au"));
+    let m = m.out_arg(("ys", "ad"));
+    let m = m.out_arg(("preamp", "d"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel: u32 = try!(i.read());
+        let xs: Vec<u32> = try!(i.read());
+        let ys: Vec<f64> = try!(i.read());
+        let preamp: f64 = try!(i.read());
+        let d = fclone(minfo);
+        try!(d.seed_filter(channel, xs, ys, preamp));
+        let rm = minfo.msg.method_return();
+        Ok(vec!(rm))
+    };
+    let m = factory.method("SeedFilter", Default::default(), h);
+    let m = m.in_arg(("channel", "u"));
+    let m = m.in_arg(("xs", "au"));
+    let m = m.in_arg(("ys", "ad"));
+    let m = m.in_arg(("preamp", "d"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel: u32 = try!(i.read());
+        let name: &str = try!(i.read());
+        let d = fclone(minfo);
+        try!(d.save_profile(channel, name));
+        let rm = minfo.msg.method_return();
+        Ok(vec!(rm))
+    };
+    let m = factory.method("SaveProfile", Default::default(), h);
+    let m = m.in_arg(("channel", "u"));
+    let m = m.in_arg(("name", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel: u32 = try!(i.read());
+        let name: &str = try!(i.read());
+        let d = fclone(minfo);
+        try!(d.load_profile(channel, name));
+        let rm = minfo.msg.method_return();
+        Ok(vec!(rm))
+    };
+    let m = factory.method("LoadProfile", Default::default(), h);
+    let m = m.in_arg(("channel", "u"));
+    let m = m.in_arg(("name", "s"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel: u32 = try!(i.read());
+        let ys: Vec<f64> = try!(i.read());
+        let preamp: f64 = try!(i.read());
+        let d = fclone(minfo);
+        try!(d.set_filter(channel, ys, preamp));
+        let rm = minfo.msg.method_return();
+        Ok(vec!(rm))
+    };
+    let m = factory.method("SetFilter", Default::default(), h);
+    let m = m.in_arg(("channel", "u"));
+    let m = m.in_arg(("ys", "ad"));
+    let m = m.in_arg(("preamp", "d"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel: u32 = try!(i.read());
+        let d = fclone(minfo);
+        let (ys, preamp) = try!(d.get_filter(channel));
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(ys);
+        let rm = rm.append1(preamp);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("GetFilter", Default::default(), h);
+    let m = m.in_arg(("channel", "u"));
+    let m = m.out_arg(("ys", "ad"));
+    let m = m.out_arg(("preamp", "d"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        try!(d.save_state());
+        let rm = minfo.msg.method_return();
+        Ok(vec!(rm))
+    };
+    let m = factory.method("SaveState", Default::default(), h);
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let channel: u32 = try!(i.read());
+        let d = fclone(minfo);
+        let name = try!(d.base_profile(channel));
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(name);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("BaseProfile", Default::default(), h);
+    let m = m.in_arg(("channel", "u"));
+    let m = m.out_arg(("name", "s"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("InterfaceRevision", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_interface_revision()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("SampleRate", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_sample_rate()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("FilterSampleRate", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_filter_sample_rate()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("NFilterCoefficients", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_nfilter_coefficients()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("NChannels", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_nchannels()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
+
+#[derive(Debug, Default)]
+pub struct OrgPulseAudioExtEqualizing1EqualizerFilterChanged {
+}
+
+impl dbus::SignalArgs for OrgPulseAudioExtEqualizing1EqualizerFilterChanged {
+    const NAME: &'static str = "FilterChanged";
+    const INTERFACE: &'static str = "org.PulseAudio.Ext.Equalizing1.Equalizer";
+    fn append(&self, _: &mut arg::IterAppend) {
+    }
+    fn get(&mut self, _: &mut arg::Iter) -> Result<(), arg::TypeMismatchError> {
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct OrgPulseAudioExtEqualizing1EqualizerSinkReconfigured {
+}
+
+impl dbus::SignalArgs for OrgPulseAudioExtEqualizing1EqualizerSinkReconfigured {
+    const NAME: &'static str = "SinkReconfigured";
+    const INTERFACE: &'static str = "org.PulseAudio.Ext.Equalizing1.Equalizer";
+    fn append(&self, _: &mut arg::IterAppend) {
+    }
+    fn get(&mut self, _: &mut arg::Iter) -> Result<(), arg::TypeMismatchError> {
+        Ok(())
+    }
+}
+
+pub trait OrgPulseAudioCore1Device {
+    type Err;
+    fn suspend(&self, suspend: bool) -> Result<(), Self::Err>;
+    fn get_port_by_name(&self, name: &str) -> Result<dbus::Path<'static>, Self::Err>;
+    fn get_index(&self) -> Result<u32, Self::Err>;
+    fn get_name(&self) -> Result<String, Self::Err>;
+    fn get_driver(&self) -> Result<String, Self::Err>;
+    fn get_owner_module(&self) -> Result<dbus::Path<'static>, Self::Err>;
+    fn get_card(&self) -> Result<dbus::Path<'static>, Self::Err>;
+    fn get_sample_format(&self) -> Result<u32, Self::Err>;
+    fn get_sample_rate(&self) -> Result<u32, Self::Err>;
+    fn get_channels(&self) -> Result<Vec<u32>, Self::Err>;
+    fn get_volume(&self) -> Result<Vec<u32>, Self::Err>;
+    fn set_volume(&self, value: Vec<u32>) -> Result<(), Self::Err>;
+    fn get_has_flat_volume(&self) -> Result<bool, Self::Err>;
+    fn get_has_convertible_to_decibel_volume(&self) -> Result<bool, Self::Err>;
+    fn get_base_volume(&self) -> Result<u32, Self::Err>;
+    fn get_volume_steps(&self) -> Result<u32, Self::Err>;
+    fn get_mute(&self) -> Result<bool, Self::Err>;
+    fn set_mute(&self, value: bool) -> Result<(), Self::Err>;
+    fn get_has_hardware_volume(&self) -> Result<bool, Self::Err>;
+    fn get_has_hardware_mute(&self) -> Result<bool, Self::Err>;
+    fn get_configured_latency(&self) -> Result<u64, Self::Err>;
+    fn get_has_dynamic_latency(&self) -> Result<bool, Self::Err>;
+    fn get_latency(&self) -> Result<u64, Self::Err>;
+    fn get_is_hardware_device(&self) -> Result<bool, Self::Err>;
+    fn get_is_network_device(&self) -> Result<bool, Self::Err>;
+    fn get_state(&self) -> Result<u32, Self::Err>;
+    fn get_ports(&self) -> Result<Vec<dbus::Path<'static>>, Self::Err>;
+    fn get_active_port(&self) -> Result<dbus::Path<'static>, Self::Err>;
+    fn set_active_port(&self, value: dbus::Path<'static>) -> Result<(), Self::Err>;
+    fn get_property_list(&self) -> Result<::std::collections::HashMap<String, Vec<u8>>, Self::Err>;
+}
+
+impl<'a, C: ::std::ops::Deref<Target=dbus::Connection>> OrgPulseAudioCore1Device for dbus::ConnPath<'a, C> {
+    type Err = dbus::Error;
+
+    fn suspend(&self, suspend: bool) -> Result<(), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.PulseAudio.Core1.Device".into(), &"Suspend".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(suspend);
+        }));
+        try!(m.as_result());
+        Ok(())
+    }
+
+    fn get_port_by_name(&self, name: &str) -> Result<dbus::Path<'static>, Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.PulseAudio.Core1.Device".into(), &"GetPortByName".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(name);
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let port: dbus::Path<'static> = try!(i.read());
+        Ok(port)
+    }
+
+    fn get_index(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "Index")
+    }
+
+    fn get_name(&self) -> Result<String, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "Name")
+    }
+
+    fn get_driver(&self) -> Result<String, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "Driver")
+    }
+
+    fn get_owner_module(&self) -> Result<dbus::Path<'static>, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "OwnerModule")
+    }
+
+    fn get_card(&self) -> Result<dbus::Path<'static>, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "Card")
+    }
+
+    fn get_sample_format(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "SampleFormat")
+    }
+
+    fn get_sample_rate(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "SampleRate")
+    }
+
+    fn get_channels(&self) -> Result<Vec<u32>, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "Channels")
+    }
+
+    fn get_volume(&self) -> Result<Vec<u32>, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "Volume")
+    }
+
+    fn get_has_flat_volume(&self) -> Result<bool, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "HasFlatVolume")
+    }
+
+    fn get_has_convertible_to_decibel_volume(&self) -> Result<bool, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "HasConvertibleToDecibelVolume")
+    }
+
+    fn get_base_volume(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "BaseVolume")
+    }
+
+    fn get_volume_steps(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "VolumeSteps")
+    }
+
+    fn get_mute(&self) -> Result<bool, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "Mute")
+    }
+
+    fn get_has_hardware_volume(&self) -> Result<bool, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "HasHardwareVolume")
+    }
+
+    fn get_has_hardware_mute(&self) -> Result<bool, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "HasHardwareMute")
+    }
+
+    fn get_configured_latency(&self) -> Result<u64, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "ConfiguredLatency")
+    }
+
+    fn get_has_dynamic_latency(&self) -> Result<bool, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "HasDynamicLatency")
+    }
+
+    fn get_latency(&self) -> Result<u64, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "Latency")
+    }
+
+    fn get_is_hardware_device(&self) -> Result<bool, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "IsHardwareDevice")
+    }
+
+    fn get_is_network_device(&self) -> Result<bool, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "IsNetworkDevice")
+    }
+
+    fn get_state(&self) -> Result<u32, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "State")
+    }
+
+    fn get_ports(&self) -> Result<Vec<dbus::Path<'static>>, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "Ports")
+    }
+
+    fn get_active_port(&self) -> Result<dbus::Path<'static>, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "ActivePort")
+    }
+
+    fn get_property_list(&self) -> Result<::std::collections::HashMap<String, Vec<u8>>, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Device", "PropertyList")
+    }
+
+    fn set_volume(&self, value: Vec<u32>) -> Result<(), Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::set(&self, "org.PulseAudio.Core1.Device", "Volume", value)
+    }
+
+    fn set_mute(&self, value: bool) -> Result<(), Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::set(&self, "org.PulseAudio.Core1.Device", "Mute", value)
+    }
+
+    fn set_active_port(&self, value: dbus::Path<'static>) -> Result<(), Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::set(&self, "org.PulseAudio.Core1.Device", "ActivePort", value)
+    }
+}
+
+pub fn org_pulse_audio_core1_device_server<F, T, D>(factory: &tree::Factory<tree::MTFn<D>, D>, data: D::Interface, f: F) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: OrgPulseAudioCore1Device<Err=tree::MethodErr>,
+    F: 'static + for <'z> Fn(& 'z tree::MethodInfo<tree::MTFn<D>, D>) -> & 'z T,
+{
+    let i = factory.interface("org.PulseAudio.Core1.Device", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let suspend: bool = try!(i.read());
+        let d = fclone(minfo);
+        try!(d.suspend(suspend));
+        let rm = minfo.msg.method_return();
+        Ok(vec!(rm))
+    };
+    let m = factory.method("Suspend", Default::default(), h);
+    let m = m.in_arg(("suspend", "b"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let name: &str = try!(i.read());
+        let d = fclone(minfo);
+        let port = try!(d.get_port_by_name(name));
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(port);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("GetPortByName", Default::default(), h);
+    let m = m.in_arg(("name", "s"));
+    let m = m.out_arg(("port", "o"));
+    let i = i.add_m(m);
+
+    let p = factory.property::<u32, _>("Index", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_index()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Name", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_name()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<&str, _>("Driver", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_driver()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<dbus::Path, _>("OwnerModule", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_owner_module()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<dbus::Path, _>("Card", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_card()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("SampleFormat", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_sample_format()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("SampleRate", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_sample_rate()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("Channels", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_channels()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<u32>, _>("Volume", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_volume()));
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        try!(d.set_volume(try!(iter.read())));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasFlatVolume", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_has_flat_volume()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasConvertibleToDecibelVolume", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_has_convertible_to_decibel_volume()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("BaseVolume", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_base_volume()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("VolumeSteps", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_volume_steps()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("Mute", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_mute()));
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        try!(d.set_mute(try!(iter.read())));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasHardwareVolume", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_has_hardware_volume()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasHardwareMute", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_has_hardware_mute()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u64, _>("ConfiguredLatency", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_configured_latency()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("HasDynamicLatency", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_has_dynamic_latency()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u64, _>("Latency", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_latency()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("IsHardwareDevice", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_is_hardware_device()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<bool, _>("IsNetworkDevice", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_is_network_device()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<u32, _>("State", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_state()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<Vec<dbus::Path>, _>("Ports", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_ports()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<dbus::Path, _>("ActivePort", Default::default());
+    let p = p.access(tree::Access::ReadWrite);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_active_port()));
+        Ok(())
+    });
+    let fclone = f.clone();
+    let p = p.on_set(move |iter, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        try!(d.set_active_port(try!(iter.read())));
+        Ok(())
+    });
+    let i = i.add_p(p);
+
+    let p = factory.property::<::std::collections::HashMap<&str, Vec<u8>>, _>("PropertyList", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_property_list()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
+
+#[derive(Debug, Default)]
+pub struct OrgPulseAudioCore1DeviceVolumeUpdated {
+    pub volume: Vec<u32>,
+}
+
+impl dbus::SignalArgs for OrgPulseAudioCore1DeviceVolumeUpdated {
+    const NAME: &'static str = "VolumeUpdated";
+    const INTERFACE: &'static str = "org.PulseAudio.Core1.Device";
+    fn append(&self, i: &mut arg::IterAppend) {
+        (&self.volume as &arg::RefArg).append(i);
+    }
+    fn get(&mut self, i: &mut arg::Iter) -> Result<(), arg::TypeMismatchError> {
+        self.volume = try!(i.read());
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct OrgPulseAudioCore1DeviceMuteUpdated {
+    pub muted: bool,
+}
+
+impl dbus::SignalArgs for OrgPulseAudioCore1DeviceMuteUpdated {
+    const NAME: &'static str = "MuteUpdated";
+    const INTERFACE: &'static str = "org.PulseAudio.Core1.Device";
+    fn append(&self, i: &mut arg::IterAppend) {
+        (&self.muted as &arg::RefArg).append(i);
+    }
+    fn get(&mut self, i: &mut arg::Iter) -> Result<(), arg::TypeMismatchError> {
+        self.muted = try!(i.read());
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct OrgPulseAudioCore1DeviceStateUpdated {
+    pub state: u32,
+}
+
+impl dbus::SignalArgs for OrgPulseAudioCore1DeviceStateUpdated {
+    const NAME: &'static str = "StateUpdated";
+    const INTERFACE: &'static str = "org.PulseAudio.Core1.Device";
+    fn append(&self, i: &mut arg::IterAppend) {
+        (&self.state as &arg::RefArg).append(i);
+    }
+    fn get(&mut self, i: &mut arg::Iter) -> Result<(), arg::TypeMismatchError> {
+        self.state = try!(i.read());
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct OrgPulseAudioCore1DeviceActivePortUpdated {
+    pub port: dbus::Path<'static>,
+}
+
+impl dbus::SignalArgs for OrgPulseAudioCore1DeviceActivePortUpdated {
+    const NAME: &'static str = "ActivePortUpdated";
+    const INTERFACE: &'static str = "org.PulseAudio.Core1.Device";
+    fn append(&self, i: &mut arg::IterAppend) {
+        (&self.port as &arg::RefArg).append(i);
+    }
+    fn get(&mut self, i: &mut arg::Iter) -> Result<(), arg::TypeMismatchError> {
+        self.port = try!(i.read());
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct OrgPulseAudioCore1DevicePropertyListUpdated {
+    pub property_list: ::std::collections::HashMap<String, Vec<u8>>,
+}
+
+impl dbus::SignalArgs for OrgPulseAudioCore1DevicePropertyListUpdated {
+    const NAME: &'static str = "PropertyListUpdated";
+    const INTERFACE: &'static str = "org.PulseAudio.Core1.Device";
+    fn append(&self, i: &mut arg::IterAppend) {
+        (&self.property_list as &arg::RefArg).append(i);
+    }
+    fn get(&mut self, i: &mut arg::Iter) -> Result<(), arg::TypeMismatchError> {
+        self.property_list = try!(i.read());
+        Ok(())
+    }
+}
+
+pub trait OrgPulseAudioCore1Sink {
+    type Err;
+    fn get_monitor_source(&self) -> Result<dbus::Path<'static>, Self::Err>;
+}
+
+impl<'a, C: ::std::ops::Deref<Target=dbus::Connection>> OrgPulseAudioCore1Sink for dbus::ConnPath<'a, C> {
+    type Err = dbus::Error;
+
+    fn get_monitor_source(&self) -> Result<dbus::Path<'static>, Self::Err> {
+        <Self as dbus::stdintf::org_freedesktop_dbus::Properties>::get(&self, "org.PulseAudio.Core1.Sink", "MonitorSource")
+    }
+}
+
+pub fn org_pulse_audio_core1_sink_server<F, T, D>(factory: &tree::Factory<tree::MTFn<D>, D>, data: D::Interface, f: F) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    D::Property: Default,
+    T: OrgPulseAudioCore1Sink<Err=tree::MethodErr>,
+    F: 'static + for <'z> Fn(& 'z tree::MethodInfo<tree::MTFn<D>, D>) -> & 'z T,
+{
+    let i = factory.interface("org.PulseAudio.Core1.Sink", data);
+    let f = ::std::sync::Arc::new(f);
+    let p = factory.property::<dbus::Path, _>("MonitorSource", Default::default());
+    let p = p.access(tree::Access::Read);
+    let fclone = f.clone();
+    let p = p.on_get(move |a, pinfo| {
+        let minfo = pinfo.to_method_info();
+        let d = fclone(&minfo);
+        a.append(try!(d.get_monitor_source()));
+        Ok(())
+    });
+    let i = i.add_p(p);
+    i
+}
+
+pub trait OrgFreedesktopDBusIntrospectable {
+    type Err;
+    fn introspect(&self) -> Result<String, Self::Err>;
+}
+
+impl<'a, C: ::std::ops::Deref<Target=dbus::Connection>> OrgFreedesktopDBusIntrospectable for dbus::ConnPath<'a, C> {
+    type Err = dbus::Error;
+
+    fn introspect(&self) -> Result<String, Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Introspectable".into(), &"Introspect".into(), |_| {
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let data: String = try!(i.read());
+        Ok(data)
+    }
+}
+
+pub fn org_freedesktop_dbus_introspectable_server<F, T, D>(factory: &tree::Factory<tree::MTFn<D>, D>, data: D::Interface, f: F) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: OrgFreedesktopDBusIntrospectable<Err=tree::MethodErr>,
+    F: 'static + for <'z> Fn(& 'z tree::MethodInfo<tree::MTFn<D>, D>) -> & 'z T,
+{
+    let i = factory.interface("org.freedesktop.DBus.Introspectable", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let d = fclone(minfo);
+        let data = try!(d.introspect());
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(data);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("Introspect", Default::default(), h);
+    let m = m.out_arg(("data", "s"));
+    let i = i.add_m(m);
+    i
+}
+
+pub trait OrgFreedesktopDBusProperties {
+    type Err;
+    fn get(&self, interface_name: &str, property_name: &str) -> Result<arg::Variant<Box<arg::RefArg>>, Self::Err>;
+    fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant<Box<arg::RefArg>>) -> Result<(), Self::Err>;
+    fn get_all(&self, interface_name: &str) -> Result<::std::collections::HashMap<String, arg::Variant<Box<arg::RefArg>>>, Self::Err>;
+}
+
+impl<'a, C: ::std::ops::Deref<Target=dbus::Connection>> OrgFreedesktopDBusProperties for dbus::ConnPath<'a, C> {
+    type Err = dbus::Error;
+
+    fn get(&self, interface_name: &str, property_name: &str) -> Result<arg::Variant<Box<arg::RefArg>>, Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Properties".into(), &"Get".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(interface_name);
+            i.append(property_name);
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let value: arg::Variant<Box<arg::RefArg>> = try!(i.read());
+        Ok(value)
+    }
+
+    fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant<Box<arg::RefArg>>) -> Result<(), Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Properties".into(), &"Set".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(interface_name);
+            i.append(property_name);
+            i.append(value);
+        }));
+        try!(m.as_result());
+        Ok(())
+    }
+
+    fn get_all(&self, interface_name: &str) -> Result<::std::collections::HashMap<String, arg::Variant<Box<arg::RefArg>>>, Self::Err> {
+        let mut m = try!(self.method_call_with_args(&"org.freedesktop.DBus.Properties".into(), &"GetAll".into(), |msg| {
+            let mut i = arg::IterAppend::new(msg);
+            i.append(interface_name);
+        }));
+        try!(m.as_result());
+        let mut i = m.iter_init();
+        let props: ::std::collections::HashMap<String, arg::Variant<Box<arg::RefArg>>> = try!(i.read());
+        Ok(props)
+    }
+}
+
+pub fn org_freedesktop_dbus_properties_server<F, T, D>(factory: &tree::Factory<tree::MTFn<D>, D>, data: D::Interface, f: F) -> tree::Interface<tree::MTFn<D>, D>
+where
+    D: tree::DataType,
+    D::Method: Default,
+    T: OrgFreedesktopDBusProperties<Err=tree::MethodErr>,
+    F: 'static + for <'z> Fn(& 'z tree::MethodInfo<tree::MTFn<D>, D>) -> & 'z T,
+{
+    let i = factory.interface("org.freedesktop.DBus.Properties", data);
+    let f = ::std::sync::Arc::new(f);
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let interface_name: &str = try!(i.read());
+        let property_name: &str = try!(i.read());
+        let d = fclone(minfo);
+        let value = try!(d.get(interface_name, property_name));
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(value);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("Get", Default::default(), h);
+    let m = m.in_arg(("interface_name", "s"));
+    let m = m.in_arg(("property_name", "s"));
+    let m = m.out_arg(("value", "v"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let interface_name: &str = try!(i.read());
+        let property_name: &str = try!(i.read());
+        let value: arg::Variant<Box<arg::RefArg>> = try!(i.read());
+        let d = fclone(minfo);
+        try!(d.set(interface_name, property_name, value));
+        let rm = minfo.msg.method_return();
+        Ok(vec!(rm))
+    };
+    let m = factory.method("Set", Default::default(), h);
+    let m = m.in_arg(("interface_name", "s"));
+    let m = m.in_arg(("property_name", "s"));
+    let m = m.in_arg(("value", "v"));
+    let i = i.add_m(m);
+
+    let fclone = f.clone();
+    let h = move |minfo: &tree::MethodInfo<tree::MTFn<D>, D>| {
+        let mut i = minfo.msg.iter_init();
+        let interface_name: &str = try!(i.read());
+        let d = fclone(minfo);
+        let props = try!(d.get_all(interface_name));
+        let rm = minfo.msg.method_return();
+        let rm = rm.append1(props);
+        Ok(vec!(rm))
+    };
+    let m = factory.method("GetAll", Default::default(), h);
+    let m = m.in_arg(("interface_name", "s"));
+    let m = m.out_arg(("props", "a{sv}"));
+    let i = i.add_m(m);
+    i
+}
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..10c9434
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,132 @@
+extern crate dbus;
+
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate failure;
+
+extern crate clap;
+extern crate clap_log_flag;
+extern crate clap_verbosity_flag;
+extern crate structopt;
+
+use structopt::StructOpt;
+
+use failure::Error;
+
+//use dbus::stdintf::org_freedesktop_dbus::Properties;
+use dbus::Connection;
+
+use dbus_api::sink::OrgPulseAudioExtEqualizing1Equalizer;
+
+mod dbus_api;
+mod parsing;
+mod utils;
+
+use utils::*;
+
+#[derive(StructOpt, Debug)]
+enum Command {
+    #[structopt(name = "load")]
+    Load(LoadCli),
+    #[structopt(name = "reset")]
+    Reset(ResetCli),
+}
+
+#[derive(StructOpt, Debug)]
+struct LoadCli {
+}
+
+#[derive(StructOpt, Debug)]
+struct ResetCli {
+}
+
+#[derive(StructOpt, Debug)]
+struct Cli {
+    #[structopt(flatten)]
+    verbose: clap_verbosity_flag::Verbosity,
+    #[structopt(flatten)]
+    log: clap_log_flag::Log,
+    #[structopt(subcommand)]
+    cmd: Command,
+}
+
+#[derive(Fail, Debug)]
+#[fail(display = "No equalized sink found")]
+struct NoEqualizedSink;
+
+#[derive(Debug)]
+pub struct Filter {
+    preamp: f64,
+    frequencies: Vec<u32>,
+    coefficients: Vec<f64>,
+}
+
+impl Filter {
+    fn pad(self, filter_rate: u32) -> Self {
+        Filter {
+            preamp: self.preamp,
+            frequencies: vec![0u32]
+                .into_iter()
+                .chain(self.frequencies.into_iter())
+                .chain(vec![filter_rate / 2u32])
+                .collect(),
+            coefficients: vec![1f64]
+                .into_iter()
+                .chain(self.coefficients.into_iter())
+                .chain(vec![1f64])
+                .collect(),
+        }
+    }
+}
+
+fn main() -> Result<(), Error> {
+    let args = Cli::from_args();
+    args.log.log_all(args.verbose.log_level())?;
+
+    use Command::*;
+
+    match args.cmd {
+        Load(args) => load(args),
+        Reset(args)=> reset(args),
+    }
+}
+
+fn reset(args: ResetCli) -> Result<(), Error> {
+    let conn = connect()?;
+    let conn_sink = get_equalized_sink(&conn)?;
+    let filter_rate = conn_sink.get_filter_sample_rate()?;
+    let filter = Filter {
+        preamp: 1f64,
+        frequencies: vec![],
+        coefficients: vec![],
+    }.pad(filter_rate);
+
+    send_filter(&conn_sink, filter)?;
+
+    Ok(())
+}
+
+fn load(args: LoadCli) -> Result<(), Error> {
+    let conn = connect()?;
+    let conn_sink = get_equalized_sink(&conn)?;
+    let filter = read_filter()?;
+    let filter_rate = conn_sink.get_filter_sample_rate()?;
+    send_filter(&conn_sink, filter.pad(filter_rate))?;
+
+    Ok(())
+}
+
+/*
+fn introspect(conn: &dbus::ConnPath<&Connection>) {
+    let mut thing = conn
+        .method_call_with_args(
+            &"org.freedesktop.DBus.Introspectable".into(),
+            &"Introspect".into(),
+            |_| {},
+        ).unwrap();
+    thing.as_result().unwrap();
+
+    println!("{}", thing.iter_init().read::<String>().unwrap());
+}
+*/
diff --git a/src/parsing/equalizer_apo.lalrpop b/src/parsing/equalizer_apo.lalrpop
new file mode 100644
index 0000000..b1faad9
--- /dev/null
+++ b/src/parsing/equalizer_apo.lalrpop
@@ -0,0 +1,42 @@
+use ::Filter;
+
+use std::str::FromStr;
+
+grammar;
+
+pub Main: Filter = {
+    <preamp: Preamp> <eq: Eq> => {
+        let coefficients: Vec<_> = eq.1.iter().map(|decibel| 10f64.powf(decibel / 10f64)).collect();
+        // TODO: add decibel_to_ratio conversion function
+        let preamp = 10f64.powf(preamp / 10f64);
+        Filter { preamp, frequencies: eq.0, coefficients }
+    }
+}
+
+Preamp: f64 = {
+    "Preamp:" <Decibel>
+}
+
+Eq: (Vec<u32>, Vec<f64>) = {
+    "GraphicEQ:" <values:(<(Integer Float)> ";")+> <end:(Integer Float)> => {
+        let mut values = values;
+        values.push(end);
+        values.into_iter().unzip()
+    }
+}
+
+Decibel: f64 = {
+    <Float> "dB"
+}
+
+Float: f64 = {
+    <RawFloat>,
+    <SignedInteger> => <> as f64,
+    <Integer> => <> as f64,
+}
+
+RawFloat: f64 = r"-?[0-9]*\.[0-9]+" => f64::from_str(<>).unwrap();
+SignedInteger: i32 = r"-[0-9]+" => i32::from_str(<>).unwrap();
+Integer: u32 = r"[0-9]+"=> u32::from_str(<>).unwrap();
+
+// vim: ft=rust
diff --git a/src/parsing/equalizer_apo.rs b/src/parsing/equalizer_apo.rs
new file mode 100644
index 0000000..3fab396
--- /dev/null
+++ b/src/parsing/equalizer_apo.rs
@@ -0,0 +1,1164 @@
+// auto-generated: "lalrpop 0.15.2"
+// sha256: 81b6fa5856d7887b20715c2c7f6137db1927ece087e2db9f4bf1fcd8943365c5
+use ::Filter;
+use std::str::FromStr;
+#[allow(unused_extern_crates)]
+extern crate lalrpop_util as __lalrpop_util;
+
+#[cfg_attr(rustfmt, rustfmt_skip)]
+mod __parse__Main {
+    #![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports, unused_parens)]
+
+    use ::Filter;
+    use std::str::FromStr;
+    #[allow(unused_extern_crates)]
+    extern crate lalrpop_util as __lalrpop_util;
+    use super::__intern_token::Token;
+    #[allow(dead_code)]
+    pub enum __Symbol<'input>
+     {
+        Variant0(&'input str),
+        Variant1((u32, f64)),
+        Variant2(::std::vec::Vec<(u32, f64)>),
+        Variant3(f64),
+        Variant4((Vec<u32>, Vec<f64>)),
+        Variant5(u32),
+        Variant6(Filter),
+        Variant7(i32),
+    }
+    const __ACTION: &'static [i8] = &[
+        // State 0
+        0, 0, 4, 0, 0, 0, 0,
+        // State 1
+        0, 0, 0, 0, 0, 0, 0,
+        // State 2
+        0, 6, 0, 0, 0, 0, 0,
+        // State 3
+        0, 0, 0, 0, 12, 13, 14,
+        // State 4
+        0, 0, 0, 0, 0, 0, 0,
+        // State 5
+        0, 0, 0, 0, 0, 0, 14,
+        // State 6
+        0, -12, 0, 0, 0, 0, 0,
+        // State 7
+        0, 0, 0, 17, 0, 0, 0,
+        // State 8
+        -9, 0, 0, -9, 0, 0, 0,
+        // State 9
+        -7, 0, 0, -7, 0, 0, 0,
+        // State 10
+        -8, 0, 0, -8, 0, 0, 0,
+        // State 11
+        -13, 0, 0, -13, 0, 0, 0,
+        // State 12
+        -14, 0, 0, -14, 0, 0, 0,
+        // State 13
+        -10, 0, 0, -10, -10, -10, -10,
+        // State 14
+        0, 0, 0, 0, 0, 0, 14,
+        // State 15
+        0, 0, 0, 0, 12, 13, 14,
+        // State 16
+        0, -5, 0, 0, 0, 0, 0,
+        // State 17
+        0, 0, 0, 0, 12, 13, 14,
+        // State 18
+        21, 0, 0, 0, 0, 0, 0,
+        // State 19
+        22, 0, 0, 0, 0, 0, 0,
+        // State 20
+        0, 0, 0, 0, 0, 0, -2,
+        // State 21
+        0, 0, 0, 0, 0, 0, -3,
+    ];
+    const __EOF_ACTION: &'static [i8] = &[
+        // State 0
+        0,
+        // State 1
+        -15,
+        // State 2
+        0,
+        // State 3
+        0,
+        // State 4
+        -11,
+        // State 5
+        0,
+        // State 6
+        0,
+        // State 7
+        0,
+        // State 8
+        -9,
+        // State 9
+        -7,
+        // State 10
+        -8,
+        // State 11
+        -13,
+        // State 12
+        -14,
+        // State 13
+        -10,
+        // State 14
+        0,
+        // State 15
+        0,
+        // State 16
+        0,
+        // State 17
+        0,
+        // State 18
+        0,
+        // State 19
+        -6,
+        // State 20
+        0,
+        // State 21
+        0,
+    ];
+    const __GOTO: &'static [i8] = &[
+        // State 0
+        0, 0, 0, 0, 0, 0, 0, 2, 3, 0, 0, 0,
+        // State 1
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 2
+        0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0,
+        // State 3
+        0, 0, 0, 7, 0, 8, 9, 0, 0, 10, 11, 0,
+        // State 4
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 5
+        0, 15, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0,
+        // State 6
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 7
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 8
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 9
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 10
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 11
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 12
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 13
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 14
+        0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0,
+        // State 15
+        0, 0, 0, 0, 0, 19, 9, 0, 0, 10, 11, 0,
+        // State 16
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 17
+        0, 0, 0, 0, 0, 20, 9, 0, 0, 10, 11, 0,
+        // State 18
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 19
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 20
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        // State 21
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ];
+    fn __expected_tokens(__state: usize) -> Vec<::std::string::String> {
+        const __TERMINAL: &'static [&'static str] = &[
+            r###"";""###,
+            r###""GraphicEQ:""###,
+            r###""Preamp:""###,
+            r###""dB""###,
+            r###"r#"-?[0-9]*\\.[0-9]+"#"###,
+            r###"r#"-[0-9]+"#"###,
+            r###"r#"[0-9]+"#"###,
+        ];
+        __ACTION[(__state * 7)..].iter().zip(__TERMINAL).filter_map(|(&state, terminal)| {
+            if state == 0 {
+                None
+            } else {
+                Some(terminal.to_string())
+            }
+        }).collect()
+    }
+    pub struct MainParser {
+        builder: super::__intern_token::__MatcherBuilder,
+        _priv: (),
+    }
+
+    impl MainParser {
+        pub fn new() -> MainParser {
+            let __builder = super::__intern_token::__MatcherBuilder::new();
+            MainParser {
+                builder: __builder,
+                _priv: (),
+            }
+        }
+
+        #[allow(dead_code)]
+        pub fn parse<
+            'input,
+        >(
+            &self,
+            input: &'input str,
+        ) -> Result<Filter, __lalrpop_util::ParseError<usize, Token<'input>, &'static str>>
+        {
+            let mut __tokens = self.builder.matcher(input);
+            let mut __states = vec![0_i8];
+            let mut __symbols = vec![];
+            let mut __integer;
+            let mut __lookahead;
+            let __last_location = &mut Default::default();
+            '__shift: loop {
+                __lookahead = match __tokens.next() {
+                    Some(Ok(v)) => v,
+                    None => break '__shift,
+                    Some(Err(e)) => return Err(e),
+                };
+                *__last_location = __lookahead.2.clone();
+                __integer = match __lookahead.1 {
+                    Token(3, _) if true => 0,
+                    Token(4, _) if true => 1,
+                    Token(5, _) if true => 2,
+                    Token(6, _) if true => 3,
+                    Token(0, _) if true => 4,
+                    Token(1, _) if true => 5,
+                    Token(2, _) if true => 6,
+                    _ => {
+                        let __state = *__states.last().unwrap() as usize;
+                        let __error = __lalrpop_util::ParseError::UnrecognizedToken {
+                            token: Some(__lookahead),
+                            expected: __expected_tokens(__state),
+                        };
+                        return Err(__error);
+                    }
+                };
+                '__inner: loop {
+                    let __state = *__states.last().unwrap() as usize;
+                    let __action = __ACTION[__state * 7 + __integer];
+                    if __action > 0 {
+                        let __symbol = match __integer {
+                            0 => match __lookahead.1 {
+                                Token(3, __tok0) => __Symbol::Variant0((__tok0)),
+                                _ => unreachable!(),
+                            },
+                            1 => match __lookahead.1 {
+                                Token(4, __tok0) => __Symbol::Variant0((__tok0)),
+                                _ => unreachable!(),
+                            },
+                            2 => match __lookahead.1 {
+                                Token(5, __tok0) => __Symbol::Variant0((__tok0)),
+                                _ => unreachable!(),
+                            },
+                            3 => match __lookahead.1 {
+                                Token(6, __tok0) => __Symbol::Variant0((__tok0)),
+                                _ => unreachable!(),
+                            },
+                            4 => match __lookahead.1 {
+                                Token(0, __tok0) => __Symbol::Variant0((__tok0)),
+                                _ => unreachable!(),
+                            },
+                            5 => match __lookahead.1 {
+                                Token(1, __tok0) => __Symbol::Variant0((__tok0)),
+                                _ => unreachable!(),
+                            },
+                            6 => match __lookahead.1 {
+                                Token(2, __tok0) => __Symbol::Variant0((__tok0)),
+                                _ => unreachable!(),
+                            },
+                            _ => unreachable!(),
+                        };
+                        __states.push(__action - 1);
+                        __symbols.push((__lookahead.0, __symbol, __lookahead.2));
+                        continue '__shift;
+                    } else if __action < 0 {
+                        if let Some(r) = __reduce(input, __action, Some(&__lookahead.0), &mut __states, &mut __symbols, ::std::marker::PhantomData::<()>) {
+                            if r.is_err() {
+                                return r;
+                            }
+                            return Err(__lalrpop_util::ParseError::ExtraToken { token: __lookahead });
+                        }
+                    } else {
+                        let mut __err_lookahead = Some(__lookahead);
+                        let mut __err_integer: Option<usize> = Some(__integer);
+                        let __state = *__states.last().unwrap() as usize;
+                        let __error = __lalrpop_util::ParseError::UnrecognizedToken {
+                            token: __err_lookahead,
+                            expected: __expected_tokens(__state),
+                        };
+                        return Err(__error)
+                    }
+                }
+            }
+            loop {
+                let __state = *__states.last().unwrap() as usize;
+                let __action = __EOF_ACTION[__state];
+                if __action < 0 {
+                    if let Some(r) = __reduce(input, __action, None, &mut __states, &mut __symbols, ::std::marker::PhantomData::<()>) {
+                        return r;
+                    }
+                } else {
+                    let mut __err_lookahead = None;
+                    let mut __err_integer: Option<usize> = None;
+                    let __state = *__states.last().unwrap() as usize;
+                    let __error = __lalrpop_util::ParseError::UnrecognizedToken {
+                        token: __err_lookahead,
+                        expected: __expected_tokens(__state),
+                    };
+                    return Err(__error)
+                }
+            }
+        }
+    }
+    pub(crate) fn __reduce<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> Option<Result<Filter,__lalrpop_util::ParseError<usize, Token<'input>, &'static str>>>
+    {
+        let (__pop_states, __symbol, __nonterminal) = match -__action {
+            1 => {
+                __reduce1(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            2 => {
+                __reduce2(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            3 => {
+                __reduce3(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            4 => {
+                __reduce4(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            5 => {
+                __reduce5(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            6 => {
+                __reduce6(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            7 => {
+                __reduce7(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            8 => {
+                __reduce8(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            9 => {
+                __reduce9(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            10 => {
+                __reduce10(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            11 => {
+                __reduce11(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            12 => {
+                __reduce12(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            13 => {
+                __reduce13(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            14 => {
+                __reduce14(input, __action, __lookahead_start, __states, __symbols, ::std::marker::PhantomData::<()>)
+            }
+            15 => {
+                // __Main = Main => ActionFn(0);
+                let __sym0 = __pop_Variant6(__symbols);
+                let __start = __sym0.0.clone();
+                let __end = __sym0.2.clone();
+                let __nt = super::__action0::<>(input, __sym0);
+                return Some(Ok(__nt));
+            }
+            _ => panic!("invalid action code {}", __action)
+        };
+        let __states_len = __states.len();
+        __states.truncate(__states_len - __pop_states);
+        __symbols.push(__symbol);
+        let __state = *__states.last().unwrap() as usize;
+        let __next_state = __GOTO[__state * 12 + __nonterminal] - 1;
+        __states.push(__next_state);
+        None
+    }
+    fn __pop_Variant4<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, (Vec<u32>, Vec<f64>), usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant4(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant1<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, (u32, f64), usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant1(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant6<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, Filter, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant6(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant3<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, f64, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant3(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant7<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, i32, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant7(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant5<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, u32, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant5(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant2<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, ::std::vec::Vec<(u32, f64)>, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant2(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    fn __pop_Variant0<
+      'input,
+    >(
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>
+    ) -> (usize, &'input str, usize)
+     {
+        match __symbols.pop().unwrap() {
+            (__l, __Symbol::Variant0(__v), __r) => (__l, __v, __r),
+            _ => panic!("symbol type mismatch")
+        }
+    }
+    pub(crate) fn __reduce1<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // (<(Integer Float)> ";") = Integer, Float, ";" => ActionFn(15);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant3(__symbols);
+        let __sym0 = __pop_Variant5(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym2.2.clone();
+        let __nt = super::__action15::<>(input, __sym0, __sym1, __sym2);
+        let __symbol = (__start, __Symbol::Variant1(__nt), __end);
+        (3, __symbol, 0)
+    }
+    pub(crate) fn __reduce2<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // (<(Integer Float)> ";")+ = Integer, Float, ";" => ActionFn(17);
+        let __sym2 = __pop_Variant0(__symbols);
+        let __sym1 = __pop_Variant3(__symbols);
+        let __sym0 = __pop_Variant5(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym2.2.clone();
+        let __nt = super::__action17::<>(input, __sym0, __sym1, __sym2);
+        let __symbol = (__start, __Symbol::Variant2(__nt), __end);
+        (3, __symbol, 1)
+    }
+    pub(crate) fn __reduce3<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // (<(Integer Float)> ";")+ = (<(Integer Float)> ";")+, Integer, Float, ";" => ActionFn(18);
+        let __sym3 = __pop_Variant0(__symbols);
+        let __sym2 = __pop_Variant3(__symbols);
+        let __sym1 = __pop_Variant5(__symbols);
+        let __sym0 = __pop_Variant2(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym3.2.clone();
+        let __nt = super::__action18::<>(input, __sym0, __sym1, __sym2, __sym3);
+        let __symbol = (__start, __Symbol::Variant2(__nt), __end);
+        (4, __symbol, 1)
+    }
+    pub(crate) fn __reduce4<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // (Integer Float) = Integer, Float => ActionFn(14);
+        let __sym1 = __pop_Variant3(__symbols);
+        let __sym0 = __pop_Variant5(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym1.2.clone();
+        let __nt = super::__action14::<>(input, __sym0, __sym1);
+        let __symbol = (__start, __Symbol::Variant1(__nt), __end);
+        (2, __symbol, 2)
+    }
+    pub(crate) fn __reduce5<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // Decibel = Float, "dB" => ActionFn(4);
+        let __sym1 = __pop_Variant0(__symbols);
+        let __sym0 = __pop_Variant3(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym1.2.clone();
+        let __nt = super::__action4::<>(input, __sym0, __sym1);
+        let __symbol = (__start, __Symbol::Variant3(__nt), __end);
+        (2, __symbol, 3)
+    }
+    pub(crate) fn __reduce6<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // Eq = "GraphicEQ:", (<(Integer Float)> ";")+, Integer, Float => ActionFn(16);
+        let __sym3 = __pop_Variant3(__symbols);
+        let __sym2 = __pop_Variant5(__symbols);
+        let __sym1 = __pop_Variant2(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym3.2.clone();
+        let __nt = super::__action16::<>(input, __sym0, __sym1, __sym2, __sym3);
+        let __symbol = (__start, __Symbol::Variant4(__nt), __end);
+        (4, __symbol, 4)
+    }
+    pub(crate) fn __reduce7<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // Float = RawFloat => ActionFn(5);
+        let __sym0 = __pop_Variant3(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action5::<>(input, __sym0);
+        let __symbol = (__start, __Symbol::Variant3(__nt), __end);
+        (1, __symbol, 5)
+    }
+    pub(crate) fn __reduce8<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // Float = SignedInteger => ActionFn(6);
+        let __sym0 = __pop_Variant7(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action6::<>(input, __sym0);
+        let __symbol = (__start, __Symbol::Variant3(__nt), __end);
+        (1, __symbol, 5)
+    }
+    pub(crate) fn __reduce9<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // Float = Integer => ActionFn(7);
+        let __sym0 = __pop_Variant5(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action7::<>(input, __sym0);
+        let __symbol = (__start, __Symbol::Variant3(__nt), __end);
+        (1, __symbol, 5)
+    }
+    pub(crate) fn __reduce10<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // Integer = r#"[0-9]+"# => ActionFn(10);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action10::<>(input, __sym0);
+        let __symbol = (__start, __Symbol::Variant5(__nt), __end);
+        (1, __symbol, 6)
+    }
+    pub(crate) fn __reduce11<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // Main = Preamp, Eq => ActionFn(1);
+        let __sym1 = __pop_Variant4(__symbols);
+        let __sym0 = __pop_Variant3(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym1.2.clone();
+        let __nt = super::__action1::<>(input, __sym0, __sym1);
+        let __symbol = (__start, __Symbol::Variant6(__nt), __end);
+        (2, __symbol, 7)
+    }
+    pub(crate) fn __reduce12<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // Preamp = "Preamp:", Decibel => ActionFn(2);
+        let __sym1 = __pop_Variant3(__symbols);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym1.2.clone();
+        let __nt = super::__action2::<>(input, __sym0, __sym1);
+        let __symbol = (__start, __Symbol::Variant3(__nt), __end);
+        (2, __symbol, 8)
+    }
+    pub(crate) fn __reduce13<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // RawFloat = r#"-?[0-9]*\\.[0-9]+"# => ActionFn(8);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action8::<>(input, __sym0);
+        let __symbol = (__start, __Symbol::Variant3(__nt), __end);
+        (1, __symbol, 9)
+    }
+    pub(crate) fn __reduce14<
+        'input,
+    >(
+        input: &'input str,
+        __action: i8,
+        __lookahead_start: Option<&usize>,
+        __states: &mut ::std::vec::Vec<i8>,
+        __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>,
+        _: ::std::marker::PhantomData<()>,
+    ) -> (usize, (usize,__Symbol<'input>,usize), usize)
+    {
+        // SignedInteger = r#"-[0-9]+"# => ActionFn(9);
+        let __sym0 = __pop_Variant0(__symbols);
+        let __start = __sym0.0.clone();
+        let __end = __sym0.2.clone();
+        let __nt = super::__action9::<>(input, __sym0);
+        let __symbol = (__start, __Symbol::Variant7(__nt), __end);
+        (1, __symbol, 10)
+    }
+}
+pub use self::__parse__Main::MainParser;
+#[cfg_attr(rustfmt, rustfmt_skip)]
+mod __intern_token {
+    #![allow(unused_imports)]
+    use ::Filter;
+    use std::str::FromStr;
+    #[allow(unused_extern_crates)]
+    extern crate lalrpop_util as __lalrpop_util;
+    extern crate regex as __regex;
+    use std::fmt as __fmt;
+
+    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+    pub struct Token<'input>(pub usize, pub &'input str);
+    impl<'a> __fmt::Display for Token<'a> {
+        fn fmt(&self, formatter: &mut __fmt::Formatter) -> Result<(), __fmt::Error> {
+            __fmt::Display::fmt(self.1, formatter)
+        }
+    }
+
+    pub struct __MatcherBuilder {
+        regex_set: __regex::RegexSet,
+        regex_vec: Vec<__regex::Regex>,
+    }
+
+    impl __MatcherBuilder {
+        pub fn new() -> __MatcherBuilder {
+            let __strs: &[&str] = &[
+                "^((?u:\\-)?(?u:[0-9])*(?u:\\.)(?u:[0-9])+)",
+                "^((?u:\\-)(?u:[0-9])+)",
+                "^((?u:[0-9])+)",
+                "^((?u:;))",
+                "^((?u:GraphicEQ:))",
+                "^((?u:Preamp:))",
+                "^((?u:dB))",
+            ];
+            let __regex_set = __regex::RegexSet::new(__strs).unwrap();
+            let __regex_vec = vec![
+                __regex::Regex::new("^((?u:\\-)?(?u:[0-9])*(?u:\\.)(?u:[0-9])+)").unwrap(),
+                __regex::Regex::new("^((?u:\\-)(?u:[0-9])+)").unwrap(),
+                __regex::Regex::new("^((?u:[0-9])+)").unwrap(),
+                __regex::Regex::new("^((?u:;))").unwrap(),
+                __regex::Regex::new("^((?u:GraphicEQ:))").unwrap(),
+                __regex::Regex::new("^((?u:Preamp:))").unwrap(),
+                __regex::Regex::new("^((?u:dB))").unwrap(),
+            ];
+            __MatcherBuilder { regex_set: __regex_set, regex_vec: __regex_vec }
+        }
+        pub fn matcher<'input, 'builder>(&'builder self, s: &'input str) -> __Matcher<'input, 'builder> {
+            __Matcher {
+                text: s,
+                consumed: 0,
+                regex_set: &self.regex_set,
+                regex_vec: &self.regex_vec,
+            }
+        }
+    }
+
+    pub struct __Matcher<'input, 'builder> {
+        text: &'input str,
+        consumed: usize,
+        regex_set: &'builder __regex::RegexSet,
+        regex_vec: &'builder Vec<__regex::Regex>,
+    }
+
+    impl<'input, 'builder> Iterator for __Matcher<'input, 'builder> {
+        type Item = Result<(usize, Token<'input>, usize), __lalrpop_util::ParseError<usize,Token<'input>,&'static str>>;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            let __text = self.text.trim_left();
+            let __whitespace = self.text.len() - __text.len();
+            let __start_offset = self.consumed + __whitespace;
+            if __text.is_empty() {
+                self.text = __text;
+                self.consumed = __start_offset;
+                None
+            } else {
+                let __matches = self.regex_set.matches(__text);
+                if !__matches.matched_any() {
+                    Some(Err(__lalrpop_util::ParseError::InvalidToken {
+                        location: __start_offset,
+                    }))
+                } else {
+                    let mut __longest_match = 0;
+                    let mut __index = 0;
+                    for __i in 0 .. 7 {
+                        if __matches.matched(__i) {
+                            let __match = self.regex_vec[__i].find(__text).unwrap();
+                            let __len = __match.end();
+                            if __len >= __longest_match {
+                                __longest_match = __len;
+                                __index = __i;
+                            }
+                        }
+                    }
+                    let __result = &__text[..__longest_match];
+                    let __remaining = &__text[__longest_match..];
+                    let __end_offset = __start_offset + __longest_match;
+                    self.text = __remaining;
+                    self.consumed = __end_offset;
+                    Some(Ok((__start_offset, Token(__index, __result), __end_offset)))
+                }
+            }
+        }
+    }
+}
+pub use self::__intern_token::Token;
+
+#[allow(unused_variables)]
+fn __action0<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, Filter, usize),
+) -> Filter
+{
+    (__0)
+}
+
+#[allow(unused_variables)]
+fn __action1<
+    'input,
+>(
+    input: &'input str,
+    (_, preamp, _): (usize, f64, usize),
+    (_, eq, _): (usize, (Vec<u32>, Vec<f64>), usize),
+) -> Filter
+{
+    {
+        let coefficients: Vec<_> = eq.1.iter().map(|decibel| 10f64.powf(decibel / 10f64)).collect();
+        // TODO: add decibel_to_ratio conversion function
+        let preamp = 10f64.powf(preamp / 10f64);
+        Filter { preamp, frequencies: eq.0, coefficients }
+    }
+}
+
+#[allow(unused_variables)]
+fn __action2<
+    'input,
+>(
+    input: &'input str,
+    (_, _, _): (usize, &'input str, usize),
+    (_, __0, _): (usize, f64, usize),
+) -> f64
+{
+    (__0)
+}
+
+#[allow(unused_variables)]
+fn __action3<
+    'input,
+>(
+    input: &'input str,
+    (_, _, _): (usize, &'input str, usize),
+    (_, values, _): (usize, ::std::vec::Vec<(u32, f64)>, usize),
+    (_, end, _): (usize, (u32, f64), usize),
+) -> (Vec<u32>, Vec<f64>)
+{
+    {
+        let mut values = values;
+        values.push(end);
+        values.into_iter().unzip()
+    }
+}
+
+#[allow(unused_variables)]
+fn __action4<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, f64, usize),
+    (_, _, _): (usize, &'input str, usize),
+) -> f64
+{
+    (__0)
+}
+
+#[allow(unused_variables)]
+fn __action5<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, f64, usize),
+) -> f64
+{
+    (__0)
+}
+
+#[allow(unused_variables)]
+fn __action6<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, i32, usize),
+) -> f64
+{
+    __0 as f64
+}
+
+#[allow(unused_variables)]
+fn __action7<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, u32, usize),
+) -> f64
+{
+    __0 as f64
+}
+
+#[allow(unused_variables)]
+fn __action8<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, &'input str, usize),
+) -> f64
+{
+    f64::from_str(__0).unwrap()
+}
+
+#[allow(unused_variables)]
+fn __action9<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, &'input str, usize),
+) -> i32
+{
+    i32::from_str(__0).unwrap()
+}
+
+#[allow(unused_variables)]
+fn __action10<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, &'input str, usize),
+) -> u32
+{
+    u32::from_str(__0).unwrap()
+}
+
+#[allow(unused_variables)]
+fn __action11<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, (u32, f64), usize),
+) -> ::std::vec::Vec<(u32, f64)>
+{
+    vec![__0]
+}
+
+#[allow(unused_variables)]
+fn __action12<
+    'input,
+>(
+    input: &'input str,
+    (_, v, _): (usize, ::std::vec::Vec<(u32, f64)>, usize),
+    (_, e, _): (usize, (u32, f64), usize),
+) -> ::std::vec::Vec<(u32, f64)>
+{
+    { let mut v = v; v.push(e); v }
+}
+
+#[allow(unused_variables)]
+fn __action13<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, (u32, f64), usize),
+    (_, _, _): (usize, &'input str, usize),
+) -> (u32, f64)
+{
+    (__0)
+}
+
+#[allow(unused_variables)]
+fn __action14<
+    'input,
+>(
+    input: &'input str,
+    (_, __0, _): (usize, u32, usize),
+    (_, __1, _): (usize, f64, usize),
+) -> (u32, f64)
+{
+    (__0, __1)
+}
+
+#[allow(unused_variables)]
+fn __action15<
+    'input,
+>(
+    input: &'input str,
+    __0: (usize, u32, usize),
+    __1: (usize, f64, usize),
+    __2: (usize, &'input str, usize),
+) -> (u32, f64)
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __1.2.clone();
+    let __temp0 = __action14(
+        input,
+        __0,
+        __1,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action13(
+        input,
+        __temp0,
+        __2,
+    )
+}
+
+#[allow(unused_variables)]
+fn __action16<
+    'input,
+>(
+    input: &'input str,
+    __0: (usize, &'input str, usize),
+    __1: (usize, ::std::vec::Vec<(u32, f64)>, usize),
+    __2: (usize, u32, usize),
+    __3: (usize, f64, usize),
+) -> (Vec<u32>, Vec<f64>)
+{
+    let __start0 = __2.0.clone();
+    let __end0 = __3.2.clone();
+    let __temp0 = __action14(
+        input,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action3(
+        input,
+        __0,
+        __1,
+        __temp0,
+    )
+}
+
+#[allow(unused_variables)]
+fn __action17<
+    'input,
+>(
+    input: &'input str,
+    __0: (usize, u32, usize),
+    __1: (usize, f64, usize),
+    __2: (usize, &'input str, usize),
+) -> ::std::vec::Vec<(u32, f64)>
+{
+    let __start0 = __0.0.clone();
+    let __end0 = __2.2.clone();
+    let __temp0 = __action15(
+        input,
+        __0,
+        __1,
+        __2,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action11(
+        input,
+        __temp0,
+    )
+}
+
+#[allow(unused_variables)]
+fn __action18<
+    'input,
+>(
+    input: &'input str,
+    __0: (usize, ::std::vec::Vec<(u32, f64)>, usize),
+    __1: (usize, u32, usize),
+    __2: (usize, f64, usize),
+    __3: (usize, &'input str, usize),
+) -> ::std::vec::Vec<(u32, f64)>
+{
+    let __start0 = __1.0.clone();
+    let __end0 = __3.2.clone();
+    let __temp0 = __action15(
+        input,
+        __1,
+        __2,
+        __3,
+    );
+    let __temp0 = (__start0, __temp0, __end0);
+    __action12(
+        input,
+        __0,
+        __temp0,
+    )
+}
+
+pub trait __ToTriple<'input, > {
+    type Error;
+    fn to_triple(value: Self) -> Result<(usize,Token<'input>,usize),Self::Error>;
+}
+
+impl<'input, > __ToTriple<'input, > for (usize, Token<'input>, usize) {
+    type Error = &'static str;
+    fn to_triple(value: Self) -> Result<(usize,Token<'input>,usize),&'static str> {
+        Ok(value)
+    }
+}
+impl<'input, > __ToTriple<'input, > for Result<(usize, Token<'input>, usize),&'static str> {
+    type Error = &'static str;
+    fn to_triple(value: Self) -> Result<(usize,Token<'input>,usize),&'static str> {
+        value
+    }
+}
diff --git a/src/parsing/mod.rs b/src/parsing/mod.rs
new file mode 100644
index 0000000..b613585
--- /dev/null
+++ b/src/parsing/mod.rs
@@ -0,0 +1,3 @@
+pub mod equalizer_apo;
+
+pub use self::equalizer_apo::MainParser as EqualizerApoParser;
diff --git a/src/utils.rs b/src/utils.rs
new file mode 100644
index 0000000..5aae29d
--- /dev/null
+++ b/src/utils.rs
@@ -0,0 +1,71 @@
+use ::{Filter, NoEqualizedSink};
+
+use parsing::EqualizerApoParser;
+
+use ::dbus_api::equalizing_manager::OrgPulseAudioExtEqualizing1Manager;
+use ::dbus_api::server_lookup::OrgPulseAudioServerLookup1;
+use ::dbus_api::sink::OrgPulseAudioExtEqualizing1Equalizer;
+
+use dbus::{BusType, Connection, ConnPath};
+use failure::{Error, ResultExt};
+
+use std::io::{self, Read};
+
+pub fn connect() -> Result<Connection, Error> {
+    let pulse_sock_path =
+        get_pulse_dbus_sock().context("While looking up PulseAudio's D-Bus socket path")?;
+    info!("PulseAudio's D-Bus socket path is: {}", pulse_sock_path);
+
+    trace!("Connecting to PulseAudio's D-Bus socket");
+    Ok(Connection::open_private(&pulse_sock_path)?)
+}
+
+pub fn get_equalized_sink<'a>(conn: &'a Connection) -> Result<ConnPath<'a, &'a Connection>, Error> {
+    let conn_manager = conn.with_path("org.PulseAudio.Core1", "/org/pulseaudio/equalizing1", 2000);
+
+    // TODO: make that a command-line option
+    trace!("Getting (one of) the equalized sink(s)");
+    let mut sinks = conn_manager.get_equalized_sinks()?;
+    let sink_path = sinks.pop().ok_or(NoEqualizedSink {})?;
+    info!("Using equalized sink: {:?}", sink_path.as_cstr());
+
+    trace!("Connecting to equalized sink");
+    Ok(conn.with_path("org.PulseAudio.Core1", sink_path, 2000))
+}
+
+pub fn send_filter(conn_sink: &ConnPath<&Connection>, filter: Filter) -> Result<(), Error> {
+    let channel = conn_sink.get_nchannels()?;
+    info!("Using channel: {}", channel);
+    trace!("Sending filter");
+    conn_sink.seed_filter(
+        channel,
+        filter.frequencies,
+        filter.coefficients,
+        filter.preamp,
+    )?;
+    Ok(())
+}
+
+pub fn read_filter() -> Result<Filter, Error> {
+    let mut buffer = String::new();
+    let stdin = io::stdin();
+    let mut handle = stdin.lock();
+
+    info!("Reading filter in GraphicEQ format from the command line");
+    handle.read_to_string(&mut buffer)?;
+
+    // TODO: lifetime issue when "throwing" parse error
+    let filter = EqualizerApoParser::new().parse(&buffer).unwrap();
+    info!("Parsed filter: {:?}", filter);
+
+    Ok(filter)
+}
+
+fn get_pulse_dbus_sock() -> Result<String, Error> {
+    trace!("Connecting to the D-Bus' session bus");
+    let conn = Connection::get_private(BusType::Session)?;
+    let conn = conn.with_path("org.PulseAudio1", "/org/pulseaudio/server_lookup1", 2000);
+
+    trace!("Checking PulseAudio's D-Bus socket path");
+    Ok(conn.get_address()?)
+}