2017-06-29 12:25:40 +00:00
|
|
|
use alsa::card::Card;
|
2017-06-29 12:55:07 +00:00
|
|
|
use alsa::mixer::{Mixer, Selem, SelemId};
|
2017-06-29 12:25:40 +00:00
|
|
|
use alsa::poll::PollDescriptors;
|
|
|
|
use alsa_sys;
|
|
|
|
use errors::*;
|
2017-06-29 21:35:39 +00:00
|
|
|
use glib;
|
2017-06-29 12:25:40 +00:00
|
|
|
use glib_sys;
|
2017-06-28 15:53:19 +00:00
|
|
|
use libc::c_uint;
|
|
|
|
use libc::pollfd;
|
2017-06-29 12:25:40 +00:00
|
|
|
use libc::size_t;
|
|
|
|
use myalsa::*;
|
2017-06-28 23:35:30 +00:00
|
|
|
use std::mem;
|
2017-06-29 21:35:39 +00:00
|
|
|
use std::cell::RefCell;
|
2017-06-30 15:24:26 +00:00
|
|
|
use std::cell::Ref;
|
2017-06-28 23:35:30 +00:00
|
|
|
use std::ptr;
|
|
|
|
use std::u8;
|
2017-06-26 07:08:37 +00:00
|
|
|
|
|
|
|
|
2017-06-29 12:55:07 +00:00
|
|
|
|
2017-06-29 12:25:40 +00:00
|
|
|
// TODO: implement free/destructor
|
|
|
|
pub struct AlsaCard {
|
|
|
|
_cannot_construct: (),
|
|
|
|
pub card: Card,
|
|
|
|
pub mixer: Mixer,
|
|
|
|
pub selem_id: SelemId,
|
|
|
|
pub watch_ids: Vec<u32>,
|
2017-06-30 15:24:26 +00:00
|
|
|
pub last_action_timestamp: RefCell<i64>,
|
|
|
|
pub handlers: RefCell<Vec<Box<Fn(&AlsaCard, AudioSignal, AudioUser)>>>,
|
2017-06-29 12:25:40 +00:00
|
|
|
}
|
|
|
|
|
2017-06-29 12:55:07 +00:00
|
|
|
|
|
|
|
/* TODO: AlsaCard cleanup */
|
2017-06-29 12:25:40 +00:00
|
|
|
impl AlsaCard {
|
2017-06-30 15:24:26 +00:00
|
|
|
pub fn new(
|
|
|
|
card_name: Option<String>,
|
|
|
|
elem_name: Option<String>,
|
|
|
|
) -> Result<AlsaCard> {
|
2017-06-29 12:25:40 +00:00
|
|
|
let card = {
|
|
|
|
match card_name {
|
|
|
|
Some(name) => get_alsa_card_by_name(name)?,
|
|
|
|
None => get_default_alsa_card(),
|
|
|
|
}
|
|
|
|
};
|
|
|
|
let mixer = get_mixer(&card)?;
|
2017-06-30 15:24:26 +00:00
|
|
|
let selem_id = get_selem_by_name(
|
|
|
|
&mixer,
|
|
|
|
elem_name.unwrap_or(String::from("Master")),
|
|
|
|
).unwrap()
|
|
|
|
.get_id();
|
2017-06-29 12:25:40 +00:00
|
|
|
let vec_pollfd = PollDescriptors::get(&mixer)?;
|
|
|
|
|
2017-06-30 15:24:26 +00:00
|
|
|
let mut acard = AlsaCard {
|
|
|
|
_cannot_construct: (),
|
|
|
|
card: card,
|
|
|
|
mixer: mixer,
|
|
|
|
selem_id: selem_id,
|
|
|
|
watch_ids: vec![],
|
|
|
|
last_action_timestamp: RefCell::new(0),
|
|
|
|
handlers: RefCell::new(vec![]),
|
|
|
|
};
|
|
|
|
|
2017-06-29 12:25:40 +00:00
|
|
|
/* TODO: callback is registered here, which must be unregistered
|
2017-06-29 21:35:39 +00:00
|
|
|
* when the mixer is destroyed!!
|
|
|
|
* poll descriptors must be unwatched too */
|
2017-06-30 15:24:26 +00:00
|
|
|
let watch_ids = watch_poll_descriptors(vec_pollfd, &acard);
|
|
|
|
// acard.watch_ids = watch_ids;
|
|
|
|
|
|
|
|
// println!("Watch IDs: {:?}", acard.watch_ids);
|
|
|
|
println!("Last_Timestamp: {}", acard.last_action_timestamp.borrow());
|
|
|
|
|
|
|
|
|
|
|
|
return Ok(acard);
|
2017-06-28 12:55:38 +00:00
|
|
|
}
|
|
|
|
|
2017-06-29 12:55:07 +00:00
|
|
|
|
2017-06-29 12:25:40 +00:00
|
|
|
pub fn selem(&self) -> Selem {
|
|
|
|
return get_selems(&self.mixer)
|
2017-06-30 15:24:26 +00:00
|
|
|
.nth(self.selem_id.get_index() as usize)
|
|
|
|
.unwrap();
|
2017-06-29 12:25:40 +00:00
|
|
|
}
|
2017-06-26 07:08:37 +00:00
|
|
|
|
2017-06-29 12:55:07 +00:00
|
|
|
|
2017-06-29 12:25:40 +00:00
|
|
|
pub fn vol(&self) -> Result<f64> {
|
|
|
|
return get_vol(&self.selem());
|
|
|
|
}
|
2017-06-26 07:08:37 +00:00
|
|
|
|
2017-06-29 12:55:07 +00:00
|
|
|
|
2017-06-29 21:35:39 +00:00
|
|
|
pub fn set_vol(&self, new_vol: f64, user: AudioUser) -> Result<()> {
|
2017-06-30 15:24:26 +00:00
|
|
|
{
|
|
|
|
let mut rc = self.last_action_timestamp.borrow_mut();
|
|
|
|
*rc = glib::get_monotonic_time();
|
|
|
|
println!("glib::get_monotonic_time: {}", glib::get_real_time());
|
|
|
|
}
|
|
|
|
println!("Now timestamp: {}", self.last_action_timestamp.borrow());
|
2017-06-29 21:35:39 +00:00
|
|
|
// TODO invoke handlers, make use of user
|
2017-06-29 12:25:40 +00:00
|
|
|
return set_vol(&self.selem(), new_vol);
|
|
|
|
}
|
2017-06-26 07:08:37 +00:00
|
|
|
|
2017-06-29 12:55:07 +00:00
|
|
|
|
2017-06-29 12:25:40 +00:00
|
|
|
pub fn has_mute(&self) -> bool {
|
|
|
|
return has_mute(&self.selem());
|
|
|
|
}
|
2017-06-26 07:08:37 +00:00
|
|
|
|
2017-06-29 12:55:07 +00:00
|
|
|
|
2017-06-29 12:25:40 +00:00
|
|
|
pub fn get_mute(&self) -> Result<bool> {
|
|
|
|
return get_mute(&self.selem());
|
2017-06-26 07:08:37 +00:00
|
|
|
}
|
|
|
|
|
2017-06-29 12:55:07 +00:00
|
|
|
|
2017-06-29 21:35:39 +00:00
|
|
|
pub fn set_mute(&self, mute: bool, user: AudioUser) -> Result<()> {
|
|
|
|
let mut rc = self.last_action_timestamp.borrow_mut();
|
2017-06-30 15:24:26 +00:00
|
|
|
*rc = glib::get_monotonic_time();
|
2017-06-29 21:35:39 +00:00
|
|
|
// TODO invoke handlers, make use of user
|
2017-06-29 12:25:40 +00:00
|
|
|
return set_mute(&self.selem(), mute);
|
|
|
|
}
|
2017-06-29 21:35:39 +00:00
|
|
|
|
|
|
|
|
|
|
|
fn on_alsa_event(&self, alsa_event: AlsaEvent) {
|
2017-06-30 15:24:26 +00:00
|
|
|
// let last: i64 = *Ref::clone(&self.last_action_timestamp.borrow());
|
|
|
|
|
|
|
|
// if last != 0 {
|
|
|
|
// let now: i64 = glib::get_monotonic_time();
|
|
|
|
// let delay: i64 = now - last;
|
|
|
|
// if delay < 1000000 {
|
|
|
|
// println!("Too short: {} and {}", now, last);
|
|
|
|
// println!("Delay: {}", delay);
|
|
|
|
// return;
|
|
|
|
// }
|
|
|
|
// *self.last_action_timestamp.borrow_mut() = 0;
|
|
|
|
// }
|
|
|
|
|
2017-06-29 21:35:39 +00:00
|
|
|
|
|
|
|
/* external change */
|
|
|
|
match alsa_event {
|
|
|
|
// TODO: invoke handlers with AudioUserUnknown
|
|
|
|
AlsaEvent::AlsaCardError => println!("AlsaCardError"),
|
|
|
|
AlsaEvent::AlsaCardDiconnected => println!("AlsaCardDiconnected"),
|
2017-06-30 15:24:26 +00:00
|
|
|
AlsaEvent::AlsaCardValuesChanged => {
|
|
|
|
println!("AlsaCardValuesChanged");
|
|
|
|
self.invoke_handlers(
|
|
|
|
self::AudioSignal::AudioValuesChanged,
|
|
|
|
self::AudioUser::AudioUserUnknown,
|
|
|
|
);
|
|
|
|
}
|
2017-06-29 21:35:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2017-06-30 15:24:26 +00:00
|
|
|
|
|
|
|
|
|
|
|
fn invoke_handlers(&self, signal: AudioSignal, user: AudioUser) {
|
|
|
|
|
|
|
|
let mut vec = vec![1,2,3];
|
|
|
|
|
|
|
|
for v in &vec {
|
|
|
|
println!("Elem: {}", v);
|
|
|
|
}
|
|
|
|
|
|
|
|
let handlers = self.handlers.borrow();
|
|
|
|
let x: &Vec<Box<Fn(&AlsaCard, AudioSignal, AudioUser)>> = &*handlers;
|
|
|
|
println!("Vec size: {}", handlers.capacity());
|
|
|
|
// for handler in x {
|
|
|
|
// // let unboxed = handler.as_ref();
|
|
|
|
// // unboxed(&self, signal, user);
|
|
|
|
// println!("Gogo");
|
|
|
|
// }
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
pub fn connect_handler(
|
|
|
|
&self,
|
|
|
|
cb: Box<Fn(&AlsaCard, AudioSignal, AudioUser)>,
|
|
|
|
) {
|
|
|
|
println!("Vec size before: {}", self.handlers.borrow().capacity());
|
|
|
|
|
|
|
|
self.handlers.borrow_mut().push(cb);
|
|
|
|
println!("Vec size after: {}", self.handlers.borrow().capacity());
|
|
|
|
}
|
2017-06-26 15:56:09 +00:00
|
|
|
}
|
2017-06-27 22:23:12 +00:00
|
|
|
|
2017-06-29 12:55:07 +00:00
|
|
|
|
2017-06-30 15:24:26 +00:00
|
|
|
#[derive(Clone, Copy)]
|
2017-06-29 12:25:40 +00:00
|
|
|
pub enum AudioUser {
|
|
|
|
AudioUserUnknown,
|
|
|
|
AudioUserPopup,
|
|
|
|
AudioUserTrayIcon,
|
|
|
|
AudioUserHotkeys,
|
2017-06-28 15:53:19 +00:00
|
|
|
}
|
|
|
|
|
2017-06-29 12:55:07 +00:00
|
|
|
|
2017-06-30 15:24:26 +00:00
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
pub enum AudioSignal {
|
2017-06-29 12:25:40 +00:00
|
|
|
AudioNoCard,
|
|
|
|
AudioCardInitialized,
|
|
|
|
AudioCardCleanedUp,
|
|
|
|
AudioCardDisconnected,
|
|
|
|
AudioCardError,
|
|
|
|
AudioValuesChanged,
|
2017-06-27 22:23:12 +00:00
|
|
|
}
|
|
|
|
|
2017-06-30 15:24:26 +00:00
|
|
|
|
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
pub enum AlsaEvent {
|
2017-06-29 21:35:39 +00:00
|
|
|
AlsaCardError,
|
|
|
|
AlsaCardDiconnected,
|
|
|
|
AlsaCardValuesChanged,
|
|
|
|
}
|
|
|
|
|
2017-06-27 22:23:12 +00:00
|
|
|
|
2017-06-30 15:24:26 +00:00
|
|
|
fn watch_poll_descriptors(polls: Vec<pollfd>, acard: &AlsaCard) -> Vec<c_uint> {
|
2017-06-28 15:53:19 +00:00
|
|
|
let mut watch_ids: Vec<c_uint> = vec![];
|
2017-06-30 15:24:26 +00:00
|
|
|
let acard_ptr =
|
|
|
|
unsafe { mem::transmute::<&AlsaCard, &glib_sys::gpointer>(acard) };
|
2017-06-28 15:53:19 +00:00
|
|
|
for poll in polls {
|
|
|
|
unsafe {
|
2017-06-29 10:51:28 +00:00
|
|
|
let gioc: *mut glib_sys::GIOChannel =
|
|
|
|
glib_sys::g_io_channel_unix_new(poll.fd);
|
2017-06-28 15:53:19 +00:00
|
|
|
watch_ids.push(glib_sys::g_io_add_watch(
|
|
|
|
gioc,
|
2017-06-28 23:35:30 +00:00
|
|
|
glib_sys::GIOCondition::from_bits(
|
2017-06-28 15:53:19 +00:00
|
|
|
glib_sys::G_IO_IN.bits() | glib_sys::G_IO_ERR.bits(),
|
2017-06-28 23:35:30 +00:00
|
|
|
).unwrap(),
|
2017-06-28 15:53:19 +00:00
|
|
|
Some(watch_cb),
|
2017-06-30 15:24:26 +00:00
|
|
|
*acard_ptr,
|
2017-06-28 15:53:19 +00:00
|
|
|
));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-30 15:24:26 +00:00
|
|
|
println!("Handler size in watch_poll_descriptors: {}", acard.handlers.borrow().capacity());
|
2017-06-28 23:35:30 +00:00
|
|
|
return watch_ids;
|
2017-06-28 15:53:19 +00:00
|
|
|
}
|
|
|
|
|
2017-06-29 12:55:07 +00:00
|
|
|
|
2017-06-30 15:24:26 +00:00
|
|
|
extern "C" fn watch_cb(
|
|
|
|
chan: *mut glib_sys::GIOChannel,
|
|
|
|
cond: glib_sys::GIOCondition,
|
|
|
|
data: glib_sys::gpointer,
|
|
|
|
) -> glib_sys::gboolean {
|
2017-06-28 23:35:30 +00:00
|
|
|
|
2017-06-30 15:24:26 +00:00
|
|
|
let acard =
|
|
|
|
unsafe { mem::transmute::<&glib_sys::gpointer, &AlsaCard>(&data) };
|
|
|
|
println!("Handler size in watch_cb: {}", acard.handlers.borrow().capacity());
|
|
|
|
let mixer = unsafe {
|
|
|
|
mem::transmute::<&Mixer, &*mut alsa_sys::snd_mixer_t>(&acard.mixer)
|
|
|
|
};
|
2017-06-28 23:35:30 +00:00
|
|
|
|
|
|
|
unsafe {
|
2017-06-30 15:24:26 +00:00
|
|
|
alsa_sys::snd_mixer_handle_events(*mixer);
|
2017-06-28 23:35:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if cond == glib_sys::G_IO_ERR {
|
|
|
|
return false as glib_sys::gboolean;
|
|
|
|
}
|
|
|
|
|
2017-06-29 10:51:28 +00:00
|
|
|
let mut sread: size_t = 1;
|
2017-06-29 11:43:32 +00:00
|
|
|
let mut buf: Vec<u8> = vec![0; 256];
|
2017-06-28 23:35:30 +00:00
|
|
|
|
|
|
|
while sread > 0 {
|
2017-06-30 15:24:26 +00:00
|
|
|
let stat: glib_sys::GIOStatus = unsafe {
|
|
|
|
glib_sys::g_io_channel_read_chars(
|
|
|
|
chan,
|
|
|
|
buf.as_mut_ptr() as *mut u8,
|
|
|
|
256,
|
|
|
|
&mut sread as *mut size_t,
|
|
|
|
ptr::null_mut(),
|
|
|
|
)
|
|
|
|
};
|
2017-06-29 11:43:32 +00:00
|
|
|
|
2017-06-28 23:35:30 +00:00
|
|
|
match stat {
|
2017-06-29 11:43:32 +00:00
|
|
|
glib_sys::G_IO_STATUS_AGAIN => {
|
|
|
|
println!("G_IO_STATUS_AGAIN");
|
2017-06-29 21:35:39 +00:00
|
|
|
continue;
|
|
|
|
}
|
2017-06-29 10:51:28 +00:00
|
|
|
glib_sys::G_IO_STATUS_NORMAL => println!("G_IO_STATUS_NORMAL"),
|
|
|
|
glib_sys::G_IO_STATUS_ERROR => println!("G_IO_STATUS_ERROR"),
|
|
|
|
glib_sys::G_IO_STATUS_EOF => println!("G_IO_STATUS_EOF"),
|
2017-06-28 23:35:30 +00:00
|
|
|
}
|
|
|
|
return true as glib_sys::gboolean;
|
2017-06-29 10:51:28 +00:00
|
|
|
}
|
2017-06-28 23:35:30 +00:00
|
|
|
|
2017-06-29 13:50:24 +00:00
|
|
|
// TODO: handle alsa events, pass to 'on_alsa_event'
|
|
|
|
|
2017-06-30 15:24:26 +00:00
|
|
|
println!("on_alsa_event triggering");
|
|
|
|
acard.on_alsa_event(AlsaEvent::AlsaCardValuesChanged);
|
|
|
|
|
2017-06-28 15:53:19 +00:00
|
|
|
return true as glib_sys::gboolean;
|
|
|
|
}
|