use jack_sys::jack_nframes_t;
use libc::c_void;
use std::ffi::CString;
use std::{mem, slice};
mod wrappers;
use self::wrappers::*;
use crate::errors::*;
use crate::{Ignore, MidiMessage};
const OUTPUT_RINGBUFFER_SIZE: usize = 16384;
type CallbackFn<T> = dyn FnMut(u64, &[u8], &mut T) + Send;
struct InputHandlerData<T> {
port: Option<MidiPort>,
ignore_flags: Ignore,
callback: Box<CallbackFn<T>>,
user_data: Option<T>,
}
pub struct MidiInput {
ignore_flags: Ignore,
client: Option<Client>,
}
#[derive(Clone, PartialEq)]
pub struct MidiInputPort {
name: CString,
}
impl MidiInputPort {
pub fn id(&self) -> String {
self.name.to_string_lossy().to_string()
}
}
pub struct MidiInputConnection<T> {
handler_data: Box<InputHandlerData<T>>,
client: Option<Client>,
}
impl MidiInput {
pub fn new(client_name: &str) -> Result<Self, InitError> {
let client = match Client::open(client_name, JackOpenOptions::NoStartServer) {
Ok(c) => c,
Err(_) => {
return Err(InitError);
} };
Ok(MidiInput {
ignore_flags: Ignore::None,
client: Some(client),
})
}
pub fn ignore(&mut self, flags: Ignore) {
self.ignore_flags = flags;
}
pub(crate) fn ports_internal(&self) -> Vec<crate::common::MidiInputPort> {
let ports = self
.client
.as_ref()
.unwrap()
.get_midi_ports(PortFlags::PortIsOutput);
let mut result = Vec::with_capacity(ports.count());
for i in 0..ports.count() {
result.push(crate::common::MidiInputPort {
imp: MidiInputPort {
name: ports.get_c_name(i).into(),
},
})
}
result
}
pub fn port_count(&self) -> usize {
self.client
.as_ref()
.unwrap()
.get_midi_ports(PortFlags::PortIsOutput)
.count()
}
pub fn port_name(&self, port: &MidiInputPort) -> Result<String, PortInfoError> {
Ok(port.name.to_string_lossy().into())
}
fn activate_callback<F, T: Send>(&mut self, callback: F, data: T) -> Box<InputHandlerData<T>>
where
F: FnMut(u64, &[u8], &mut T) + Send + 'static,
{
let handler_data = Box::new(InputHandlerData {
port: None,
ignore_flags: self.ignore_flags,
callback: Box::new(callback),
user_data: Some(data),
});
let data_ptr = unsafe { mem::transmute_copy::<_, *mut InputHandlerData<T>>(&handler_data) };
self.client
.as_mut()
.unwrap()
.set_process_callback(handle_input::<T>, data_ptr as *mut c_void);
self.client.as_mut().unwrap().activate();
handler_data
}
pub fn connect<F, T: Send>(
mut self,
port: &MidiInputPort,
port_name: &str,
callback: F,
data: T,
) -> Result<MidiInputConnection<T>, ConnectError<MidiInput>>
where
F: FnMut(u64, &[u8], &mut T) + Send + 'static,
{
let mut handler_data = self.activate_callback(callback, data);
let dest_port = match self
.client
.as_mut()
.unwrap()
.register_midi_port(port_name, PortFlags::PortIsInput)
{
Ok(p) => p,
Err(()) => {
return Err(ConnectError::other("could not register JACK port", self));
}
};
if self
.client
.as_mut()
.unwrap()
.connect(&port.name, dest_port.get_name())
.is_err()
{
return Err(ConnectError::new(ConnectErrorKind::InvalidPort, self));
}
handler_data.port = Some(dest_port);
Ok(MidiInputConnection {
handler_data,
client: self.client.take(),
})
}
pub fn create_virtual<F, T: Send>(
mut self,
port_name: &str,
callback: F,
data: T,
) -> Result<MidiInputConnection<T>, ConnectError<Self>>
where
F: FnMut(u64, &[u8], &mut T) + Send + 'static,
{
let mut handler_data = self.activate_callback(callback, data);
let port = match self
.client
.as_mut()
.unwrap()
.register_midi_port(port_name, PortFlags::PortIsInput)
{
Ok(p) => p,
Err(()) => {
return Err(ConnectError::other("could not register JACK port", self));
}
};
handler_data.port = Some(port);
Ok(MidiInputConnection {
handler_data,
client: self.client.take(),
})
}
}
impl<T> MidiInputConnection<T> {
pub fn close(mut self) -> (MidiInput, T) {
self.close_internal();
(
MidiInput {
client: self.client.take(),
ignore_flags: self.handler_data.ignore_flags,
},
self.handler_data.user_data.take().unwrap(),
)
}
fn close_internal(&mut self) {
let port = self.handler_data.port.take().unwrap();
self.client.as_mut().unwrap().unregister_midi_port(port);
self.client.as_mut().unwrap().deactivate();
}
}
impl<T> Drop for MidiInputConnection<T> {
fn drop(&mut self) {
if self.client.is_some() {
self.close_internal();
}
}
}
extern "C" fn handle_input<T>(nframes: jack_nframes_t, arg: *mut c_void) -> i32 {
let data: &mut InputHandlerData<T> = unsafe { &mut *(arg as *mut InputHandlerData<T>) };
if let Some(ref port) = data.port {
let buff = port.get_midi_buffer(nframes);
let mut message = MidiMessage::new();
let evcount = buff.get_event_count();
let mut event = mem::MaybeUninit::uninit();
for j in 0..evcount {
message.bytes.clear();
unsafe { buff.get_event(event.as_mut_ptr(), j) };
let event = unsafe { event.assume_init() };
for i in 0..event.size {
message.bytes.push(unsafe { *event.buffer.add(i) });
}
message.timestamp = Client::get_time(); (data.callback)(
message.timestamp,
&message.bytes,
data.user_data.as_mut().unwrap(),
);
}
}
0
}
struct OutputHandlerData {
port: Option<MidiPort>,
buff_size: Ringbuffer,
buff_message: Ringbuffer,
}
pub struct MidiOutput {
client: Option<Client>,
}
#[derive(Clone, PartialEq)]
pub struct MidiOutputPort {
name: CString,
}
impl MidiOutputPort {
pub fn id(&self) -> String {
self.name.to_string_lossy().to_string()
}
}
pub struct MidiOutputConnection {
handler_data: Box<OutputHandlerData>,
client: Option<Client>,
}
impl MidiOutput {
pub fn new(client_name: &str) -> Result<Self, InitError> {
let client = match Client::open(client_name, JackOpenOptions::NoStartServer) {
Ok(c) => c,
Err(_) => {
return Err(InitError);
} };
Ok(MidiOutput {
client: Some(client),
})
}
pub(crate) fn ports_internal(&self) -> Vec<crate::common::MidiOutputPort> {
let ports = self
.client
.as_ref()
.unwrap()
.get_midi_ports(PortFlags::PortIsInput);
let mut result = Vec::with_capacity(ports.count());
for i in 0..ports.count() {
result.push(crate::common::MidiOutputPort {
imp: MidiOutputPort {
name: ports.get_c_name(i).into(),
},
})
}
result
}
pub fn port_count(&self) -> usize {
self.client
.as_ref()
.unwrap()
.get_midi_ports(PortFlags::PortIsInput)
.count()
}
pub fn port_name(&self, port: &MidiOutputPort) -> Result<String, PortInfoError> {
Ok(port.name.to_string_lossy().into())
}
fn activate_callback(&mut self) -> Box<OutputHandlerData> {
let handler_data = Box::new(OutputHandlerData {
port: None,
buff_size: Ringbuffer::new(OUTPUT_RINGBUFFER_SIZE),
buff_message: Ringbuffer::new(OUTPUT_RINGBUFFER_SIZE),
});
let data_ptr = unsafe { mem::transmute_copy::<_, *mut OutputHandlerData>(&handler_data) };
self.client
.as_mut()
.unwrap()
.set_process_callback(handle_output, data_ptr as *mut c_void);
self.client.as_mut().unwrap().activate();
handler_data
}
pub fn connect(
mut self,
port: &MidiOutputPort,
port_name: &str,
) -> Result<MidiOutputConnection, ConnectError<MidiOutput>> {
let mut handler_data = self.activate_callback();
let source_port = match self
.client
.as_mut()
.unwrap()
.register_midi_port(port_name, PortFlags::PortIsOutput)
{
Ok(p) => p,
Err(()) => {
return Err(ConnectError::other("could not register JACK port", self));
}
};
if self
.client
.as_mut()
.unwrap()
.connect(source_port.get_name(), &port.name)
.is_err()
{
return Err(ConnectError::new(ConnectErrorKind::InvalidPort, self));
}
handler_data.port = Some(source_port);
Ok(MidiOutputConnection {
handler_data,
client: self.client.take(),
})
}
pub fn create_virtual(
mut self,
port_name: &str,
) -> Result<MidiOutputConnection, ConnectError<Self>> {
let mut handler_data = self.activate_callback();
let port = match self
.client
.as_mut()
.unwrap()
.register_midi_port(port_name, PortFlags::PortIsOutput)
{
Ok(p) => p,
Err(()) => {
return Err(ConnectError::other("could not register JACK port", self));
}
};
handler_data.port = Some(port);
Ok(MidiOutputConnection {
handler_data,
client: self.client.take(),
})
}
}
impl MidiOutputConnection {
pub fn send(&mut self, message: &[u8]) -> Result<(), SendError> {
let nbytes = message.len();
let written = self.handler_data.buff_message.write(message);
debug_assert!(
written == nbytes,
"not enough bytes written to ALSA ringbuffer `message`"
);
let nbytes_slice = unsafe {
slice::from_raw_parts(
&nbytes as *const usize as *const u8,
mem::size_of_val(&nbytes),
)
};
let written = self.handler_data.buff_size.write(nbytes_slice);
debug_assert!(
written == mem::size_of_val(&nbytes),
"not enough bytes written to ALSA ringbuffer `size`"
);
Ok(())
}
pub fn close(mut self) -> MidiOutput {
self.close_internal();
MidiOutput {
client: self.client.take(),
}
}
fn close_internal(&mut self) {
let port = self.handler_data.port.take().unwrap();
self.client.as_mut().unwrap().unregister_midi_port(port);
self.client.as_mut().unwrap().deactivate();
}
}
impl Drop for MidiOutputConnection {
fn drop(&mut self) {
if self.client.is_some() {
self.close_internal();
}
}
}
extern "C" fn handle_output(nframes: jack_nframes_t, arg: *mut c_void) -> i32 {
let data: &mut OutputHandlerData = unsafe { &mut *(arg as *mut OutputHandlerData) };
if let Some(ref port) = data.port {
let mut space: usize = 0;
let mut buff = port.get_midi_buffer(nframes);
buff.clear();
while data.buff_size.get_read_space() > 0 {
let read = data
.buff_size
.read(&mut space as *mut usize as *mut u8, mem::size_of::<usize>());
debug_assert!(
read == mem::size_of::<usize>(),
"not enough bytes read from `size` ringbuffer"
);
let midi_data = buff.event_reserve(0, space);
let read = data.buff_message.read(midi_data, space);
debug_assert!(
read == space,
"not enough bytes read from `message` ringbuffer"
);
}
}
0
}