From fcc75f4566c91a7293f4f6dfd67e09aa92d93bea Mon Sep 17 00:00:00 2001 From: mitchmindtree Date: Sun, 4 Feb 2018 23:02:16 +1100 Subject: [PATCH] Rename `SamplesRate` to `SampleRate` and `ChannelsCount` to `ChannelCount` (#199) * Rename SamplesRate to SampleRate and samples_rate to sample_rate * Rename ChannelsCount to ChannelCount * Update CHANGELOG for SamplesRate and ChannelsCount renaming --- CHANGELOG.md | 2 ++ examples/beep.rs | 8 ++++---- src/alsa/mod.rs | 20 ++++++++++---------- src/coreaudio/mod.rs | 12 ++++++------ src/emscripten/mod.rs | 4 ++-- src/lib.rs | 26 +++++++++++++------------- src/wasapi/endpoint.rs | 10 +++++----- src/wasapi/voice.rs | 4 ++-- 8 files changed, 44 insertions(+), 42 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9052bff..32a303b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,7 @@ # Unreleased +- Rename ChannelsCount to ChannelCount. +- Rename SamplesRate to SampleRate. - Remove unused ChannelPosition API. - Implement Endpoint and Format Enumeration for macos. - Implement format handling for macos `build_voice` method. diff --git a/examples/beep.rs b/examples/beep.rs index 37b04cf..59dc908 100644 --- a/examples/beep.rs +++ b/examples/beep.rs @@ -7,19 +7,19 @@ fn main() { .unwrap() .next() .expect("Failed to get endpoint format") - .with_max_samples_rate(); + .with_max_sample_rate(); let event_loop = cpal::EventLoop::new(); let voice_id = event_loop.build_voice(&endpoint, &format).unwrap(); event_loop.play(voice_id); - let samples_rate = format.samples_rate.0 as f32; + let sample_rate = format.sample_rate.0 as f32; let mut sample_clock = 0f32; // Produce a sinusoid of maximum amplitude. let mut next_value = || { - sample_clock = (sample_clock + 1.0) % samples_rate; - (sample_clock * 440.0 * 2.0 * 3.141592 / samples_rate).sin() + sample_clock = (sample_clock + 1.0) % sample_rate; + (sample_clock * 440.0 * 2.0 * 3.141592 / sample_rate).sin() }; event_loop.run(move |_, buffer| { diff --git a/src/alsa/mod.rs b/src/alsa/mod.rs index 6c852d0..f8cd46d 100644 --- a/src/alsa/mod.rs +++ b/src/alsa/mod.rs @@ -3,12 +3,12 @@ extern crate libc; pub use self::enumerate::{EndpointsIterator, default_endpoint}; -use ChannelsCount; +use ChannelCount; use CreationError; use Format; use FormatsEnumerationError; use SampleFormat; -use SamplesRate; +use SampleRate; use SupportedFormat; use UnknownTypeBuffer; @@ -149,7 +149,7 @@ impl Endpoint { ptr::null_mut())) .expect("unable to get maximum supported rate"); - let samples_rates = if min_rate == max_rate { + let sample_rates = if min_rate == max_rate { vec![(min_rate, max_rate)] } else if alsa::snd_pcm_hw_params_test_rate(playback_handle, hw_params.0, @@ -206,21 +206,21 @@ impl Endpoint { num, ) == 0 { - Some(num as ChannelsCount) + Some(num as ChannelCount) } else { None }) .collect::>(); let mut output = Vec::with_capacity(supported_formats.len() * supported_channels.len() * - samples_rates.len()); + sample_rates.len()); for &data_type in supported_formats.iter() { for channels in supported_channels.iter() { - for &(min_rate, max_rate) in samples_rates.iter() { + for &(min_rate, max_rate) in sample_rates.iter() { output.push(SupportedFormat { channels: channels.clone(), - min_samples_rate: SamplesRate(min_rate as u32), - max_samples_rate: SamplesRate(max_rate as u32), + min_sample_rate: SampleRate(min_rate as u32), + max_sample_rate: SampleRate(max_rate as u32), data_type: data_type, }); } @@ -552,7 +552,7 @@ impl EventLoop { .expect("format could not be set"); check_errors(alsa::snd_pcm_hw_params_set_rate(playback_handle, hw_params.0, - format.samples_rate.0 as libc::c_uint, + format.sample_rate.0 as libc::c_uint, 0)) .expect("sample rate could not be set"); check_errors(alsa::snd_pcm_hw_params_set_channels(playback_handle, @@ -560,7 +560,7 @@ impl EventLoop { format.channels as libc::c_uint)) .expect("channel count could not be set"); - let mut max_buffer_size = format.samples_rate.0 as alsa::snd_pcm_uframes_t / + let mut max_buffer_size = format.sample_rate.0 as alsa::snd_pcm_uframes_t / format.channels as alsa::snd_pcm_uframes_t / 5; // 200ms of buffer check_errors(alsa::snd_pcm_hw_params_set_buffer_size_max(playback_handle, diff --git a/src/coreaudio/mod.rs b/src/coreaudio/mod.rs index a4e8819..87150e8 100644 --- a/src/coreaudio/mod.rs +++ b/src/coreaudio/mod.rs @@ -1,13 +1,13 @@ extern crate coreaudio; extern crate core_foundation_sys; -use ChannelsCount; +use ChannelCount; use CreationError; use Format; use FormatsEnumerationError; use Sample; use SampleFormat; -use SamplesRate; +use SampleRate; use SupportedFormat; use UnknownTypeBuffer; @@ -151,9 +151,9 @@ impl Endpoint { let mut fmts = vec![]; for range in ranges { let fmt = SupportedFormat { - channels: n_channels as ChannelsCount, - min_samples_rate: SamplesRate(range.mMinimum as _), - max_samples_rate: SamplesRate(range.mMaximum as _), + channels: n_channels as ChannelCount, + min_sample_rate: SampleRate(range.mMinimum as _), + max_sample_rate: SampleRate(range.mMaximum as _), data_type: sample_format, }; fmts.push(fmt); @@ -282,7 +282,7 @@ impl EventLoop { // Set the stream in interleaved mode. let n_channels = format.channels as usize; - let sample_rate = format.samples_rate.0; + let sample_rate = format.sample_rate.0; let bytes_per_channel = format.data_type.sample_size(); let bits_per_channel = bytes_per_channel * 8; let bytes_per_frame = n_channels * bytes_per_channel; diff --git a/src/emscripten/mod.rs b/src/emscripten/mod.rs index 26bd5ff..8914e9e 100644 --- a/src/emscripten/mod.rs +++ b/src/emscripten/mod.rs @@ -184,8 +184,8 @@ impl Endpoint { vec![ SupportedFormat { channels: 2, - min_samples_rate: ::SamplesRate(44100), - max_samples_rate: ::SamplesRate(44100), + min_sample_rate: ::SampleRate(44100), + max_sample_rate: ::SampleRate(44100), data_type: ::SampleFormat::F32, }, ].into_iter(), diff --git a/src/lib.rs b/src/lib.rs index 59a103d..4693cd1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -40,14 +40,14 @@ //! let mut supported_formats_range = endpoint.supported_formats() //! .expect("error while querying formats"); //! let format = supported_formats_range.next().expect("no supported format?!") -//! .with_max_samples_rate(); +//! .with_max_sample_rate(); //! ``` //! //! Now that we have everything, we can create a voice from that event loop: //! //! ```no_run //! # let endpoint = cpal::default_endpoint().unwrap(); -//! # let format = endpoint.supported_formats().unwrap().next().unwrap().with_max_samples_rate(); +//! # let format = endpoint.supported_formats().unwrap().next().unwrap().with_max_sample_rate(); //! # let event_loop = cpal::EventLoop::new(); //! let voice_id = event_loop.build_voice(&endpoint, &format).unwrap(); //! ``` @@ -238,17 +238,17 @@ impl Endpoint { } /// Number of channels. -pub type ChannelsCount = u16; +pub type ChannelCount = u16; /// #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] -pub struct SamplesRate(pub u32); +pub struct SampleRate(pub u32); /// Describes a format. #[derive(Debug, Clone, PartialEq, Eq)] pub struct Format { - pub channels: ChannelsCount, - pub samples_rate: SamplesRate, + pub channels: ChannelCount, + pub sample_rate: SampleRate, pub data_type: SampleFormat, } @@ -274,11 +274,11 @@ impl Iterator for SupportedFormatsIterator { /// Describes a range of supported formats. #[derive(Debug, Clone, PartialEq, Eq)] pub struct SupportedFormat { - pub channels: ChannelsCount, + pub channels: ChannelCount, /// Minimum value for the samples rate of the supported formats. - pub min_samples_rate: SamplesRate, + pub min_sample_rate: SampleRate, /// Maximum value for the samples rate of the supported formats. - pub max_samples_rate: SamplesRate, + pub max_sample_rate: SampleRate, /// Type of data expected by the endpoint. pub data_type: SampleFormat, } @@ -286,10 +286,10 @@ pub struct SupportedFormat { impl SupportedFormat { /// Turns this `SupportedFormat` into a `Format` corresponding to the maximum samples rate. #[inline] - pub fn with_max_samples_rate(self) -> Format { + pub fn with_max_sample_rate(self) -> Format { Format { channels: self.channels, - samples_rate: self.max_samples_rate, + sample_rate: self.max_sample_rate, data_type: self.data_type, } } @@ -300,8 +300,8 @@ impl From for SupportedFormat { fn from(format: Format) -> SupportedFormat { SupportedFormat { channels: format.channels, - min_samples_rate: format.samples_rate, - max_samples_rate: format.samples_rate, + min_sample_rate: format.sample_rate, + max_sample_rate: format.sample_rate, data_type: format.data_type, } } diff --git a/src/wasapi/endpoint.rs b/src/wasapi/endpoint.rs index 5d11b5c..fb8e878 100644 --- a/src/wasapi/endpoint.rs +++ b/src/wasapi/endpoint.rs @@ -7,10 +7,10 @@ use std::ptr; use std::slice; use std::sync::{Arc, Mutex, MutexGuard}; -use ChannelsCount; +use ChannelCount; use FormatsEnumerationError; use SampleFormat; -use SamplesRate; +use SampleRate; use SupportedFormat; use super::check_result; @@ -144,7 +144,7 @@ impl Endpoint { }, winapi::WAVE_FORMAT_EXTENSIBLE => { let format_ptr = format_ptr as *const winapi::WAVEFORMATEXTENSIBLE; - let channels = (*format_ptr).Format.nChannels as ChannelsCount; + let channels = (*format_ptr).Format.nChannels as ChannelCount; let format = { fn cmp_guid(a: &winapi::GUID, b: &winapi::GUID) -> bool { a.Data1 == b.Data1 && a.Data2 == b.Data2 && a.Data3 == b.Data3 && @@ -172,8 +172,8 @@ impl Endpoint { SupportedFormat { channels: channels, - min_samples_rate: SamplesRate((*format_ptr).nSamplesPerSec), - max_samples_rate: SamplesRate((*format_ptr).nSamplesPerSec), + min_sample_rate: SampleRate((*format_ptr).nSamplesPerSec), + max_sample_rate: SampleRate((*format_ptr).nSamplesPerSec), data_type: data_type, } }; diff --git a/src/wasapi/voice.rs b/src/wasapi/voice.rs index 0ebb0a3..57d82a4 100644 --- a/src/wasapi/voice.rs +++ b/src/wasapi/voice.rs @@ -472,9 +472,9 @@ fn format_to_waveformatextensible(format: &Format) SampleFormat::U16 => return Err(CreationError::FormatNotSupported), }, nChannels: format.channels as winapi::WORD, - nSamplesPerSec: format.samples_rate.0 as winapi::DWORD, + nSamplesPerSec: format.sample_rate.0 as winapi::DWORD, nAvgBytesPerSec: format.channels as winapi::DWORD * - format.samples_rate.0 as winapi::DWORD * + format.sample_rate.0 as winapi::DWORD * format.data_type.sample_size() as winapi::DWORD, nBlockAlign: format.channels as winapi::WORD * format.data_type.sample_size() as winapi::WORD,