use std::cell::RefCell; use std::cmp; use std::convert::TryInto; use std::vec::IntoIter as VecIntoIter; extern crate oboe; use crate::traits::{DeviceTrait, HostTrait, StreamTrait}; use crate::{ BackendSpecificError, BufferSize, BuildStreamError, Data, DefaultStreamConfigError, DeviceNameError, DevicesError, InputCallbackInfo, OutputCallbackInfo, PauseStreamError, PlayStreamError, Sample, SampleFormat, SampleRate, StreamConfig, StreamError, SupportedBufferSize, SupportedStreamConfig, SupportedStreamConfigRange, SupportedStreamConfigsError, }; mod android_media; mod convert; mod input_callback; mod output_callback; use self::android_media::{get_audio_record_min_buffer_size, get_audio_track_min_buffer_size}; use self::input_callback::CpalInputCallback; use self::oboe::{AudioInputStream, AudioOutputStream}; use self::output_callback::CpalOutputCallback; // Android Java API supports up to 8 channels, but oboe API // only exposes mono and stereo. const CHANNEL_MASKS: [i32; 2] = [ android_media::CHANNEL_OUT_MONO, android_media::CHANNEL_OUT_STEREO, ]; const SAMPLE_RATES: [i32; 13] = [ 5512, 8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000, 88200, 96000, 176_400, 192_000, ]; pub struct Host; pub struct Device(Option); pub enum Stream { Input(Box>), Output(Box>), } pub type SupportedInputConfigs = VecIntoIter; pub type SupportedOutputConfigs = VecIntoIter; pub type Devices = VecIntoIter; impl Host { pub fn new() -> Result { Ok(Host) } } impl HostTrait for Host { type Devices = Devices; type Device = Device; fn is_available() -> bool { true } fn devices(&self) -> Result { if let Ok(devices) = oboe::AudioDeviceInfo::request(oboe::AudioDeviceDirection::InputOutput) { Ok(devices .into_iter() .map(|d| Device(Some(d))) .collect::>() .into_iter()) } else { Ok(vec![Device(None)].into_iter()) } } fn default_input_device(&self) -> Option { Some(Device(None)) } fn default_output_device(&self) -> Option { Some(Device(None)) } } fn buffer_size_range_for_params( is_output: bool, sample_rate: i32, channel_mask: i32, android_format: i32, ) -> SupportedBufferSize { let min_buffer_size = if is_output { get_audio_track_min_buffer_size(sample_rate, channel_mask, android_format) } else { get_audio_record_min_buffer_size(sample_rate, channel_mask, android_format) }; if min_buffer_size > 0 { SupportedBufferSize::Range { min: min_buffer_size as u32, max: i32::MAX as u32, } } else { SupportedBufferSize::Unknown } } fn default_supported_configs(is_output: bool) -> VecIntoIter { // Have to "brute force" the parameter combinations with getMinBufferSize const FORMATS: [SampleFormat; 2] = [SampleFormat::I16, SampleFormat::F32]; let mut output = Vec::with_capacity(SAMPLE_RATES.len() * CHANNEL_MASKS.len() * FORMATS.len()); for sample_format in &FORMATS { let android_format = if *sample_format == SampleFormat::I16 { android_media::ENCODING_PCM_16BIT } else { android_media::ENCODING_PCM_FLOAT }; for (mask_idx, channel_mask) in CHANNEL_MASKS.iter().enumerate() { let channel_count = mask_idx + 1; for sample_rate in &SAMPLE_RATES { if let SupportedBufferSize::Range { min, max } = buffer_size_range_for_params( is_output, *sample_rate, *channel_mask, android_format, ) { output.push(SupportedStreamConfigRange { channels: channel_count as u16, min_sample_rate: SampleRate(*sample_rate as u32), max_sample_rate: SampleRate(*sample_rate as u32), buffer_size: SupportedBufferSize::Range { min, max }, sample_format: *sample_format, }); } } } } output.into_iter() } fn device_supported_configs( device: &oboe::AudioDeviceInfo, is_output: bool, ) -> VecIntoIter { let sample_rates = if !device.sample_rates.is_empty() { device.sample_rates.as_slice() } else { &SAMPLE_RATES }; const ALL_CHANNELS: [i32; 2] = [1, 2]; let channel_counts = if !device.channel_counts.is_empty() { device.channel_counts.as_slice() } else { &ALL_CHANNELS }; const ALL_FORMATS: [oboe::AudioFormat; 2] = [oboe::AudioFormat::I16, oboe::AudioFormat::F32]; let formats = if !device.formats.is_empty() { device.formats.as_slice() } else { &ALL_FORMATS }; let mut output = Vec::with_capacity(sample_rates.len() * channel_counts.len() * formats.len()); for sample_rate in sample_rates { for channel_count in channel_counts { assert!(*channel_count > 0); if *channel_count > 2 { // could be supported by the device, but oboe does not support more than 2 channels continue; } let channel_mask = CHANNEL_MASKS[*channel_count as usize - 1]; for format in formats { let (android_format, sample_format) = match format { oboe::AudioFormat::I16 => { (android_media::ENCODING_PCM_16BIT, SampleFormat::I16) } oboe::AudioFormat::F32 => { (android_media::ENCODING_PCM_FLOAT, SampleFormat::F32) } _ => panic!("Unexpected format"), }; let buffer_size = buffer_size_range_for_params( is_output, *sample_rate, channel_mask, android_format, ); output.push(SupportedStreamConfigRange { channels: cmp::min(*channel_count as u16, 2u16), min_sample_rate: SampleRate(*sample_rate as u32), max_sample_rate: SampleRate(*sample_rate as u32), buffer_size, sample_format, }); } } } output.into_iter() } fn configure_for_device( builder: oboe::AudioStreamBuilder, device: &Device, config: &StreamConfig, ) -> oboe::AudioStreamBuilder { let mut builder = if let Some(info) = &device.0 { builder.set_device_id(info.id) } else { builder }; builder = builder.set_sample_rate(config.sample_rate.0.try_into().unwrap()); match &config.buffer_size { BufferSize::Default => builder, BufferSize::Fixed(size) => builder.set_buffer_capacity_in_frames(*size as i32), } } fn build_input_stream( device: &Device, config: &StreamConfig, data_callback: D, error_callback: E, builder: oboe::AudioStreamBuilder, ) -> Result where T: Sample + oboe::IsFormat + Send + 'static, C: oboe::IsChannelCount + Send + 'static, (T, C): oboe::IsFrameType, D: FnMut(&Data, &InputCallbackInfo) + Send + 'static, E: FnMut(StreamError) + Send + 'static, { let builder = configure_for_device(builder, device, config); let stream = builder .set_callback(CpalInputCallback::::new( data_callback, error_callback, )) .open_stream()?; Ok(Stream::Input(Box::new(RefCell::new(stream)))) } fn build_output_stream( device: &Device, config: &StreamConfig, data_callback: D, error_callback: E, builder: oboe::AudioStreamBuilder, ) -> Result where T: Sample + oboe::IsFormat + Send + 'static, C: oboe::IsChannelCount + Send + 'static, (T, C): oboe::IsFrameType, D: FnMut(&mut Data, &OutputCallbackInfo) + Send + 'static, E: FnMut(StreamError) + Send + 'static, { let builder = configure_for_device(builder, device, config); let stream = builder .set_callback(CpalOutputCallback::::new( data_callback, error_callback, )) .open_stream()?; Ok(Stream::Output(Box::new(RefCell::new(stream)))) } impl DeviceTrait for Device { type SupportedInputConfigs = SupportedInputConfigs; type SupportedOutputConfigs = SupportedOutputConfigs; type Stream = Stream; fn name(&self) -> Result { match &self.0 { None => Ok("default".to_owned()), Some(info) => Ok(info.product_name.clone()), } } fn supported_input_configs( &self, ) -> Result { if let Some(info) = &self.0 { Ok(device_supported_configs(info, false)) } else { Ok(default_supported_configs(false)) } } fn supported_output_configs( &self, ) -> Result { if let Some(info) = &self.0 { Ok(device_supported_configs(info, true)) } else { Ok(default_supported_configs(true)) } } fn default_input_config(&self) -> Result { let mut configs: Vec<_> = self.supported_input_configs().unwrap().collect(); configs.sort_by(|a, b| b.cmp_default_heuristics(a)); let config = configs .into_iter() .next() .ok_or(DefaultStreamConfigError::StreamTypeNotSupported)? .with_max_sample_rate(); Ok(config) } fn default_output_config(&self) -> Result { let mut configs: Vec<_> = self.supported_output_configs().unwrap().collect(); configs.sort_by(|a, b| b.cmp_default_heuristics(a)); let config = configs .into_iter() .next() .ok_or(DefaultStreamConfigError::StreamTypeNotSupported)? .with_max_sample_rate(); Ok(config) } fn build_input_stream_raw( &self, config: &StreamConfig, sample_format: SampleFormat, data_callback: D, error_callback: E, ) -> Result where D: FnMut(&Data, &InputCallbackInfo) + Send + 'static, E: FnMut(StreamError) + Send + 'static, { match sample_format { SampleFormat::I16 => { let builder = oboe::AudioStreamBuilder::default() .set_input() .set_format::(); if config.channels == 1 { build_input_stream( self, config, data_callback, error_callback, builder.set_mono(), ) } else if config.channels == 2 { build_input_stream( self, config, data_callback, error_callback, builder.set_stereo(), ) } else { Err(BackendSpecificError { description: "More than 2 channels are not supported by Oboe.".to_owned(), } .into()) } } SampleFormat::F32 => { let builder = oboe::AudioStreamBuilder::default() .set_input() .set_format::(); if config.channels == 1 { build_input_stream( self, config, data_callback, error_callback, builder.set_mono(), ) } else if config.channels == 2 { build_input_stream( self, config, data_callback, error_callback, builder.set_stereo(), ) } else { Err(BackendSpecificError { description: "More than 2 channels are not supported by Oboe.".to_owned(), } .into()) } } SampleFormat::U16 => Err(BackendSpecificError { description: "U16 format is not supported on Android.".to_owned(), } .into()), } } fn build_output_stream_raw( &self, config: &StreamConfig, sample_format: SampleFormat, data_callback: D, error_callback: E, ) -> Result where D: FnMut(&mut Data, &OutputCallbackInfo) + Send + 'static, E: FnMut(StreamError) + Send + 'static, { match sample_format { SampleFormat::I16 => { let builder = oboe::AudioStreamBuilder::default() .set_output() .set_format::(); if config.channels == 1 { build_output_stream( self, config, data_callback, error_callback, builder.set_mono(), ) } else if config.channels == 2 { build_output_stream( self, config, data_callback, error_callback, builder.set_stereo(), ) } else { Err(BackendSpecificError { description: "More than 2 channels are not supported by Oboe.".to_owned(), } .into()) } } SampleFormat::F32 => { let builder = oboe::AudioStreamBuilder::default() .set_output() .set_format::(); if config.channels == 1 { build_output_stream( self, config, data_callback, error_callback, builder.set_mono(), ) } else if config.channels == 2 { build_output_stream( self, config, data_callback, error_callback, builder.set_stereo(), ) } else { Err(BackendSpecificError { description: "More than 2 channels are not supported by Oboe.".to_owned(), } .into()) } } SampleFormat::U16 => Err(BackendSpecificError { description: "U16 format is not supported on Android.".to_owned(), } .into()), } } } impl StreamTrait for Stream { fn play(&self) -> Result<(), PlayStreamError> { match self { Self::Input(stream) => stream .borrow_mut() .request_start() .map_err(PlayStreamError::from), Self::Output(stream) => stream .borrow_mut() .request_start() .map_err(PlayStreamError::from), } } fn pause(&self) -> Result<(), PauseStreamError> { match self { Self::Input(_) => Err(BackendSpecificError { description: "Pause called on the input stream.".to_owned(), } .into()), Self::Output(stream) => stream .borrow_mut() .request_pause() .map_err(PauseStreamError::from), } } }