From d575adf63b7e87196b636ee91061692a685b605f Mon Sep 17 00:00:00 2001 From: Minijackson Date: Sun, 2 Sep 2018 16:04:22 +0200 Subject: First working version --- src/dbus_api/equalizing_manager.rs | 291 +++++++++ src/dbus_api/mod.rs | 3 + src/dbus_api/server_lookup.rs | 188 ++++++ src/dbus_api/sink.rs | 1128 ++++++++++++++++++++++++++++++++++ src/main.rs | 132 ++++ src/parsing/equalizer_apo.lalrpop | 42 ++ src/parsing/equalizer_apo.rs | 1164 ++++++++++++++++++++++++++++++++++++ src/parsing/mod.rs | 3 + src/utils.rs | 71 +++ 9 files changed, 3022 insertions(+) create mode 100644 src/dbus_api/equalizing_manager.rs create mode 100644 src/dbus_api/mod.rs create mode 100644 src/dbus_api/server_lookup.rs create mode 100644 src/dbus_api/sink.rs create mode 100644 src/main.rs create mode 100644 src/parsing/equalizer_apo.lalrpop create mode 100644 src/parsing/equalizer_apo.rs create mode 100644 src/parsing/mod.rs create mode 100644 src/utils.rs (limited to 'src') 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; + fn get_equalized_sinks(&self) -> Result>, Self::Err>; + fn get_profiles(&self) -> Result, Self::Err>; +} + +impl<'a, C: ::std::ops::Deref> 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 { + ::get(&self, "org.PulseAudio.Ext.Equalizing1.Manager", "InterfaceRevision") + } + + fn get_equalized_sinks(&self) -> Result>, Self::Err> { + ::get(&self, "org.PulseAudio.Ext.Equalizing1.Manager", "EqualizedSinks") + } + + fn get_profiles(&self) -> Result, Self::Err> { + ::get(&self, "org.PulseAudio.Ext.Equalizing1.Manager", "Profiles") + } +} + +pub fn org_pulse_audio_ext_equalizing1_manager_server(factory: &tree::Factory, D>, data: D::Interface, f: F) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: OrgPulseAudioExtEqualizing1Manager, + F: 'static + for <'z> Fn(& 'z tree::MethodInfo, 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, 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::("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::, _>("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::, _>("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; +} + +impl<'a, C: ::std::ops::Deref> OrgFreedesktopDBusIntrospectable for dbus::ConnPath<'a, C> { + type Err = dbus::Error; + + fn introspect(&self) -> Result { + 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(factory: &tree::Factory, D>, data: D::Interface, f: F) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: OrgFreedesktopDBusIntrospectable, + F: 'static + for <'z> Fn(& 'z tree::MethodInfo, 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, 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>, Self::Err>; + fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant>) -> Result<(), Self::Err>; + fn get_all(&self, interface_name: &str) -> Result<::std::collections::HashMap>>, Self::Err>; +} + +impl<'a, C: ::std::ops::Deref> OrgFreedesktopDBusProperties for dbus::ConnPath<'a, C> { + type Err = dbus::Error; + + fn get(&self, interface_name: &str, property_name: &str) -> Result>, 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> = try!(i.read()); + Ok(value) + } + + fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant>) -> 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>>, 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>> = try!(i.read()); + Ok(props) + } +} + +pub fn org_freedesktop_dbus_properties_server(factory: &tree::Factory, D>, data: D::Interface, f: F) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: OrgFreedesktopDBusProperties, + F: 'static + for <'z> Fn(& 'z tree::MethodInfo, 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, 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, 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> = 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, 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; +} + +impl<'a, C: ::std::ops::Deref> OrgPulseAudioServerLookup1 for dbus::ConnPath<'a, C> { + type Err = dbus::Error; + + fn get_address(&self) -> Result { + ::get(&self, "org.PulseAudio.ServerLookup1", "Address") + } +} + +pub fn org_pulse_audio_server_lookup1_server(factory: &tree::Factory, D>, data: D::Interface, f: F) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: OrgPulseAudioServerLookup1, + F: 'static + for <'z> Fn(& 'z tree::MethodInfo, 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; +} + +impl<'a, C: ::std::ops::Deref> OrgFreedesktopDBusIntrospectable for dbus::ConnPath<'a, C> { + type Err = dbus::Error; + + fn introspect(&self) -> Result { + 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(factory: &tree::Factory, D>, data: D::Interface, f: F) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: OrgFreedesktopDBusIntrospectable, + F: 'static + for <'z> Fn(& 'z tree::MethodInfo, 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, 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>, Self::Err>; + fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant>) -> Result<(), Self::Err>; + fn get_all(&self, interface_name: &str) -> Result<::std::collections::HashMap>>, Self::Err>; +} + +impl<'a, C: ::std::ops::Deref> OrgFreedesktopDBusProperties for dbus::ConnPath<'a, C> { + type Err = dbus::Error; + + fn get(&self, interface_name: &str, property_name: &str) -> Result>, 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> = try!(i.read()); + Ok(value) + } + + fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant>) -> 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>>, 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>> = try!(i.read()); + Ok(props) + } +} + +pub fn org_freedesktop_dbus_properties_server(factory: &tree::Factory, D>, data: D::Interface, f: F) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: OrgFreedesktopDBusProperties, + F: 'static + for <'z> Fn(& 'z tree::MethodInfo, 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, 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, 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> = 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, 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) -> Result<(Vec, f64), Self::Err>; + fn seed_filter(&self, channel: u32, xs: Vec, ys: Vec, 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, preamp: f64) -> Result<(), Self::Err>; + fn get_filter(&self, channel: u32) -> Result<(Vec, f64), Self::Err>; + fn save_state(&self) -> Result<(), Self::Err>; + fn base_profile(&self, channel: u32) -> Result; + fn get_interface_revision(&self) -> Result; + fn get_sample_rate(&self) -> Result; + fn get_filter_sample_rate(&self) -> Result; + fn get_nfilter_coefficients(&self) -> Result; + fn get_nchannels(&self) -> Result; +} + +impl<'a, C: ::std::ops::Deref> OrgPulseAudioExtEqualizing1Equalizer for dbus::ConnPath<'a, C> { + type Err = dbus::Error; + + fn filter_at_points(&self, channel: u32, xs: Vec) -> Result<(Vec, 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 = try!(i.read()); + let preamp: f64 = try!(i.read()); + Ok((ys, preamp)) + } + + fn seed_filter(&self, channel: u32, xs: Vec, ys: Vec, 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, 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), 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 = 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 { + 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 { + ::get(&self, "org.PulseAudio.Ext.Equalizing1.Equalizer", "InterfaceRevision") + } + + fn get_sample_rate(&self) -> Result { + ::get(&self, "org.PulseAudio.Ext.Equalizing1.Equalizer", "SampleRate") + } + + fn get_filter_sample_rate(&self) -> Result { + ::get(&self, "org.PulseAudio.Ext.Equalizing1.Equalizer", "FilterSampleRate") + } + + fn get_nfilter_coefficients(&self) -> Result { + ::get(&self, "org.PulseAudio.Ext.Equalizing1.Equalizer", "NFilterCoefficients") + } + + fn get_nchannels(&self) -> Result { + ::get(&self, "org.PulseAudio.Ext.Equalizing1.Equalizer", "NChannels") + } +} + +pub fn org_pulse_audio_ext_equalizing1_equalizer_server(factory: &tree::Factory, D>, data: D::Interface, f: F) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: OrgPulseAudioExtEqualizing1Equalizer, + F: 'static + for <'z> Fn(& 'z tree::MethodInfo, 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, D>| { + let mut i = minfo.msg.iter_init(); + let channel: u32 = try!(i.read()); + let xs: Vec = 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, D>| { + let mut i = minfo.msg.iter_init(); + let channel: u32 = try!(i.read()); + let xs: Vec = try!(i.read()); + let ys: Vec = 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, 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, 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, D>| { + let mut i = minfo.msg.iter_init(); + let channel: u32 = try!(i.read()); + let ys: Vec = 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, 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, 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, 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::("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::("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::("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::("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::("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, Self::Err>; + fn get_index(&self) -> Result; + fn get_name(&self) -> Result; + fn get_driver(&self) -> Result; + fn get_owner_module(&self) -> Result, Self::Err>; + fn get_card(&self) -> Result, Self::Err>; + fn get_sample_format(&self) -> Result; + fn get_sample_rate(&self) -> Result; + fn get_channels(&self) -> Result, Self::Err>; + fn get_volume(&self) -> Result, Self::Err>; + fn set_volume(&self, value: Vec) -> Result<(), Self::Err>; + fn get_has_flat_volume(&self) -> Result; + fn get_has_convertible_to_decibel_volume(&self) -> Result; + fn get_base_volume(&self) -> Result; + fn get_volume_steps(&self) -> Result; + fn get_mute(&self) -> Result; + fn set_mute(&self, value: bool) -> Result<(), Self::Err>; + fn get_has_hardware_volume(&self) -> Result; + fn get_has_hardware_mute(&self) -> Result; + fn get_configured_latency(&self) -> Result; + fn get_has_dynamic_latency(&self) -> Result; + fn get_latency(&self) -> Result; + fn get_is_hardware_device(&self) -> Result; + fn get_is_network_device(&self) -> Result; + fn get_state(&self) -> Result; + fn get_ports(&self) -> Result>, Self::Err>; + fn get_active_port(&self) -> Result, Self::Err>; + fn set_active_port(&self, value: dbus::Path<'static>) -> Result<(), Self::Err>; + fn get_property_list(&self) -> Result<::std::collections::HashMap>, Self::Err>; +} + +impl<'a, C: ::std::ops::Deref> 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, 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 { + ::get(&self, "org.PulseAudio.Core1.Device", "Index") + } + + fn get_name(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "Name") + } + + fn get_driver(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "Driver") + } + + fn get_owner_module(&self) -> Result, Self::Err> { + ::get(&self, "org.PulseAudio.Core1.Device", "OwnerModule") + } + + fn get_card(&self) -> Result, Self::Err> { + ::get(&self, "org.PulseAudio.Core1.Device", "Card") + } + + fn get_sample_format(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "SampleFormat") + } + + fn get_sample_rate(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "SampleRate") + } + + fn get_channels(&self) -> Result, Self::Err> { + ::get(&self, "org.PulseAudio.Core1.Device", "Channels") + } + + fn get_volume(&self) -> Result, Self::Err> { + ::get(&self, "org.PulseAudio.Core1.Device", "Volume") + } + + fn get_has_flat_volume(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "HasFlatVolume") + } + + fn get_has_convertible_to_decibel_volume(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "HasConvertibleToDecibelVolume") + } + + fn get_base_volume(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "BaseVolume") + } + + fn get_volume_steps(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "VolumeSteps") + } + + fn get_mute(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "Mute") + } + + fn get_has_hardware_volume(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "HasHardwareVolume") + } + + fn get_has_hardware_mute(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "HasHardwareMute") + } + + fn get_configured_latency(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "ConfiguredLatency") + } + + fn get_has_dynamic_latency(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "HasDynamicLatency") + } + + fn get_latency(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "Latency") + } + + fn get_is_hardware_device(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "IsHardwareDevice") + } + + fn get_is_network_device(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "IsNetworkDevice") + } + + fn get_state(&self) -> Result { + ::get(&self, "org.PulseAudio.Core1.Device", "State") + } + + fn get_ports(&self) -> Result>, Self::Err> { + ::get(&self, "org.PulseAudio.Core1.Device", "Ports") + } + + fn get_active_port(&self) -> Result, Self::Err> { + ::get(&self, "org.PulseAudio.Core1.Device", "ActivePort") + } + + fn get_property_list(&self) -> Result<::std::collections::HashMap>, Self::Err> { + ::get(&self, "org.PulseAudio.Core1.Device", "PropertyList") + } + + fn set_volume(&self, value: Vec) -> Result<(), Self::Err> { + ::set(&self, "org.PulseAudio.Core1.Device", "Volume", value) + } + + fn set_mute(&self, value: bool) -> Result<(), Self::Err> { + ::set(&self, "org.PulseAudio.Core1.Device", "Mute", value) + } + + fn set_active_port(&self, value: dbus::Path<'static>) -> Result<(), Self::Err> { + ::set(&self, "org.PulseAudio.Core1.Device", "ActivePort", value) + } +} + +pub fn org_pulse_audio_core1_device_server(factory: &tree::Factory, D>, data: D::Interface, f: F) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: OrgPulseAudioCore1Device, + F: 'static + for <'z> Fn(& 'z tree::MethodInfo, 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, 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, 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::("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::("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::("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::("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::("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::, _>("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::, _>("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::("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::("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::("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::("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::("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::("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::("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::("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::("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::("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::("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::("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::("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::, _>("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::("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>, _>("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, +} + +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>, +} + +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, Self::Err>; +} + +impl<'a, C: ::std::ops::Deref> OrgPulseAudioCore1Sink for dbus::ConnPath<'a, C> { + type Err = dbus::Error; + + fn get_monitor_source(&self) -> Result, Self::Err> { + ::get(&self, "org.PulseAudio.Core1.Sink", "MonitorSource") + } +} + +pub fn org_pulse_audio_core1_sink_server(factory: &tree::Factory, D>, data: D::Interface, f: F) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + D::Property: Default, + T: OrgPulseAudioCore1Sink, + F: 'static + for <'z> Fn(& 'z tree::MethodInfo, D>) -> & 'z T, +{ + let i = factory.interface("org.PulseAudio.Core1.Sink", data); + let f = ::std::sync::Arc::new(f); + let p = factory.property::("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; +} + +impl<'a, C: ::std::ops::Deref> OrgFreedesktopDBusIntrospectable for dbus::ConnPath<'a, C> { + type Err = dbus::Error; + + fn introspect(&self) -> Result { + 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(factory: &tree::Factory, D>, data: D::Interface, f: F) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: OrgFreedesktopDBusIntrospectable, + F: 'static + for <'z> Fn(& 'z tree::MethodInfo, 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, 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>, Self::Err>; + fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant>) -> Result<(), Self::Err>; + fn get_all(&self, interface_name: &str) -> Result<::std::collections::HashMap>>, Self::Err>; +} + +impl<'a, C: ::std::ops::Deref> OrgFreedesktopDBusProperties for dbus::ConnPath<'a, C> { + type Err = dbus::Error; + + fn get(&self, interface_name: &str, property_name: &str) -> Result>, 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> = try!(i.read()); + Ok(value) + } + + fn set(&self, interface_name: &str, property_name: &str, value: arg::Variant>) -> 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>>, 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>> = try!(i.read()); + Ok(props) + } +} + +pub fn org_freedesktop_dbus_properties_server(factory: &tree::Factory, D>, data: D::Interface, f: F) -> tree::Interface, D> +where + D: tree::DataType, + D::Method: Default, + T: OrgFreedesktopDBusProperties, + F: 'static + for <'z> Fn(& 'z tree::MethodInfo, 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, 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, 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> = 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, 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, + coefficients: Vec, +} + +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::().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 = { + => { + 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:" +} + +Eq: (Vec, Vec) = { + "GraphicEQ:" ";")+> => { + let mut values = values; + values.push(end); + values.into_iter().unzip() + } +} + +Decibel: f64 = { + "dB" +} + +Float: f64 = { + , + => <> as f64, + => <> 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, Vec)), + 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, &'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 = 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 = 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, + __symbols: &mut ::std::vec::Vec<(usize,__Symbol<'input>,usize)>, + _: ::std::marker::PhantomData<()>, + ) -> Option, &'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, Vec), 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, + __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, + __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, + __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, + __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, + __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, + __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, + __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, + __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, + __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, + __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, + __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, + __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, + __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, + __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,&'static str>>; + + fn next(&mut self) -> Option { + 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, Vec), 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, Vec) +{ + { + 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, Vec) +{ + 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 { + 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, 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 { + 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 { + 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()?) +} -- cgit v1.2.3