Struct HardwareParametersMut 

pub struct HardwareParametersMut<'a> { /* private fields */ }

Available on crate feature alsa only.

Collection of harward parameters being configured for a Pcm handle.

Must be refined before they are applied to a Pcm device through HardwareParametersMut::install.

See Pcm::hardware_parameters_any.

Implementations

impl<'a> HardwareParametersMut<'a>

pub fn install(self) -> Result<()>

Install one PCM hardware configuration chosen from a configuration space and prepare it.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

hw.set_channels_near(2)?;
hw.install()?;

pub fn rate_resample(&mut self) -> Result<bool>

Extract resample state from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let result = hw.rate_resample()?;
dbg!(result);

pub fn set_rate_resample(&mut self, resample: bool) -> Result<()>

Restrict a configuration space to contain only real hardware rates.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_rate_resample(true)?;
dbg!(actual);

pub fn set_channels_near(&mut self, channels: c_uint) -> Result<c_uint>

Restrict a configuration space to have channels count nearest to a target.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_channels_near(2)?;
dbg!(actual);

pub fn set_channels(&mut self, channels: c_uint) -> Result<()>

Restrict a configuration space to contain only one channels count.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_channels(2)?;
dbg!(actual);

pub fn test_channels(&mut self, channels: c_uint) -> Result<bool>

Extract minimum channels count from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let result = hw.test_channels(4)?;
dbg!(result);

pub fn set_channels_min(&mut self, channels: c_uint) -> Result<c_uint>

Restrict a configuration space with a minimum channels count.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_channels_min(2)?;
dbg!(actual);

pub fn set_channels_max(&mut self, channels: c_uint) -> Result<c_uint>

Restrict a configuration space with a maximum channels count.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_channels_max(2)?;
dbg!(actual);

pub fn set_channels_minmax( &mut self, channels_min: c_uint, channels_max: c_uint, ) -> Result<(c_uint, c_uint)>

Restrict a configuration space to have channels counts in a given range.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_channels_minmax(2, 4)?;
dbg!(actual);

pub fn set_channels_first(&mut self) -> Result<c_uint>

Restrict a configuration space to contain only its minimum channels count.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_channels_first()?;
dbg!(actual);

pub fn set_channels_last(&mut self) -> Result<c_uint>

Restrict a configuration space to contain only its maximum channels count.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_channels_last()?;
dbg!(actual);

pub fn set_rate_near( &mut self, rate: c_uint, dir: Direction, ) -> Result<(u32, Direction)>

Restrict a configuration space to have rate nearest to a target.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_rate_near(44100, alsa::Direction::Nearest)?;
dbg!(actual);
dbg!(actual);

pub fn set_rate(&mut self, rate: c_uint, dir: Direction) -> Result<()>

Restrict a configuration space to have rate nearest to a target.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_rate(44100, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_rate_min( &mut self, rate: c_uint, dir: Direction, ) -> Result<(c_uint, Direction)>

Restrict a configuration space with a minimum rate.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_rate_min(44100, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_rate_max( &mut self, rate: c_uint, dir: Direction, ) -> Result<(c_uint, Direction)>

Restrict a configuration space with a maximum rate.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_rate_max(44100, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_rate_minmax( &mut self, rate_min: c_uint, dir_min: Direction, rate_max: c_uint, dir_max: Direction, ) -> Result<(c_uint, Direction, c_uint, Direction)>

Restrict a configuration space to have rates in a given range.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_rate_minmax(128, alsa::Direction::Nearest, 256, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_rate_first(&mut self) -> Result<(c_uint, Direction)>

Restrict a configuration space to contain only its minimum rate.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_rate_first()?;
dbg!(actual);

pub fn set_rate_last(&mut self) -> Result<(c_uint, Direction)>

Restrict a configuration space to contain only its maximum rate.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_rate_last()?;
dbg!(actual);

pub fn test_rate(&mut self, rate: c_uint) -> Result<bool>

Extract min rate from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let result = hw.test_rate(44100)?;
dbg!(result);

pub fn set_format(&mut self, format: Format) -> Result<()>

Restrict a configuration space to contain only one format.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_format(alsa::Format::S16LE)?;
dbg!(actual);

pub fn set_format_first(&mut self) -> Result<Format>

Restrict a configuration space to contain only its first format.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_format_first()?;
dbg!(actual);

pub fn set_format_last(&mut self) -> Result<Format>

Restrict a configuration space to contain only its last format.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_format_last()?;
dbg!(actual);

pub fn set_format_mask(&mut self, mask: &FormatMask) -> Result<()>

Restrict a configuration space to contain only a set of formats.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let mut mask = alsa::FormatMask::new()?;
mask.set(alsa::Format::S16LE);

let actual = hw.set_format_mask(&mask)?;
dbg!(actual);

pub fn test_format(&mut self, format: Format) -> Result<bool>

Verify if a format is available inside a configuration space for a PCM.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let result = hw.test_format(alsa::Format::S16LE)?;
dbg!(result);

pub fn set_access(&mut self, access: Access) -> Result<()>

Restrict a configuration space to contain only one access type.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_access(alsa::Access::MmapInterleaved)?;
dbg!(actual);

pub fn test_access(&mut self, access: Access) -> Result<bool>

Verify if an access type is available inside a configuration space for a PCM.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let result = hw.test_access(alsa::Access::MmapInterleaved)?;
dbg!(result);

pub fn set_access_first(&mut self) -> Result<Access>

Restrict a configuration space to contain only its first access type.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

println!("{}", hw.set_access_first()?);

pub fn set_access_last(&mut self) -> Result<Access>

Restrict a configuration space to contain only its last access type.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

println!("{}", hw.set_access_last()?);

pub fn set_access_mask(&mut self, mask: &AccessMask) -> Result<()>

Restrict a configuration space to contain only a set of access types.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let mut mask = alsa::AccessMask::new()?;
mask.set(alsa::Access::MmapInterleaved);

let actual = hw.set_access_mask(&mask)?;
dbg!(actual);

pub fn set_export_buffer(&mut self, export_buffer: c_uint) -> Result<()>

Restrict a configuration space to allow the buffer to be accessible from outside.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_export_buffer(1024)?;
dbg!(actual);

pub fn export_buffer(&mut self) -> Result<c_uint>

Extract buffer accessibility from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let result = hw.export_buffer()?;
dbg!(result);

pub fn set_period_wakeup(&mut self, period_wakeup: c_uint) -> Result<()>

Restrict a configuration space to settings without period wakeups.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_wakeup(10000)?;
dbg!(actual);

pub fn period_wakeup(&mut self) -> Result<c_uint>

Extract period wakeup flag from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

dbg!(hw.period_wakeup()?);

pub fn test_period_time( &mut self, period_time: c_uint, dir: Direction, ) -> Result<bool>

Verify if a period time is available inside a configuration space for a PCM.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

dbg!(hw.test_period_time(1000, alsa::Direction::Nearest)?);

pub fn set_period_time( &mut self, period_time: c_uint, dir: Direction, ) -> Result<()>

Restrict a configuration space to contain only one period time.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_time(1000, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_period_time_min( &mut self, period_time: c_uint, dir: Direction, ) -> Result<(c_uint, Direction)>

Restrict a configuration space with a minimum period time.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_time_min(1000, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_period_time_max( &mut self, period_time: c_uint, dir: Direction, ) -> Result<(c_uint, Direction)>

Restrict a configuration space with a maximum period time.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_time_max(1000, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_period_time_minmax( &mut self, period_time_max: c_uint, dir_max: Direction, period_time_min: c_uint, dir_min: Direction, ) -> Result<(c_uint, Direction, c_uint, Direction)>

Restrict a configuration space to have period times in a given range.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_time_minmax(1000, alsa::Direction::Nearest, 10000, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_period_time_near( &mut self, period_time: c_uint, dir: Direction, ) -> Result<(c_uint, Direction)>

Restrict a configuration space to have period time nearest to a target.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_time_near(1000, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_period_time_first(&mut self) -> Result<(c_uint, Direction)>

Restrict a configuration space to contain only its minimum period time.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_time_first()?;
dbg!(actual);

pub fn set_period_time_last(&mut self) -> Result<(c_uint, Direction)>

Restrict a configuration space to contain only its maximum period time.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_time_last()?;
dbg!(actual);

pub fn test_period_size( &mut self, frames: c_ulong, dir: Direction, ) -> Result<bool>

Verify if a period size is available inside a configuration space for a PCM.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

if hw.test_period_size(128, alsa::Direction::Nearest)? {
    println!("period size supported!");
}

pub fn set_period_size(&mut self, frames: c_ulong, dir: Direction) -> Result<()>

Restrict a configuration space to contain only one period size.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_size(128, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_period_size_min( &mut self, frames: c_ulong, dir: Direction, ) -> Result<(c_ulong, Direction)>

Restrict a configuration space with a minimum period size.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_size_min(128, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_period_size_max( &mut self, frames: c_ulong, dir: Direction, ) -> Result<(c_ulong, Direction)>

Restrict a configuration space with a maximum period size.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_size_max(128, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_period_size_minmax( &mut self, frames_min: c_ulong, dir_min: Direction, frames_max: c_ulong, dir_max: Direction, ) -> Result<(c_ulong, Direction, c_ulong, Direction)>

Restrict a configuration space to have period sizes in a given range.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_size_minmax(128, alsa::Direction::Nearest, 256, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_period_size_near( &mut self, frames: c_ulong, dir: Direction, ) -> Result<(c_ulong, Direction)>

Restrict a configuration space to have period size nearest to a target.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_size_near(1024, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_period_size_first(&mut self) -> Result<(c_ulong, Direction)>

Restrict a configuration space to contain only its minimum period size.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_size_first()?;
dbg!(actual);

pub fn set_period_size_last(&mut self) -> Result<(c_ulong, Direction)>

Restrict a configuration space to contain only its maximum period size.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_size_last()?;
dbg!(actual);

pub fn set_period_size_integer(&mut self) -> Result<()>

Restrict a configuration space to contain only integer period sizes.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_period_size_integer()?;
dbg!(actual);

pub fn test_periods(&mut self, periods: c_uint, dir: Direction) -> Result<bool>

Verify if a periods count is available inside a configuration space for a PCM.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

if hw.test_periods(128, alsa::Direction::Nearest)? {
    println!("period size supported!");
}

pub fn set_periods(&mut self, periods: c_uint, dir: Direction) -> Result<()>

Restrict a configuration space to contain only one periods count.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_periods(128, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_periods_min( &mut self, periods: c_uint, dir: Direction, ) -> Result<(c_uint, Direction)>

Restrict a configuration space with a minimum periods count.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_periods_min(128, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_periods_max( &mut self, periods: c_uint, dir: Direction, ) -> Result<(c_uint, Direction)>

Restrict a configuration space with a maximum periods count.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_periods_max(128, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_periods_minmax( &mut self, periods_min: c_uint, dir_min: Direction, periods_max: c_uint, dir_max: Direction, ) -> Result<(c_uint, Direction, c_uint, Direction)>

Restrict a configuration space to have periods counts in a given range.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_periods_minmax(128, alsa::Direction::Nearest, 256, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_periods_near( &mut self, periods: c_uint, dir: Direction, ) -> Result<(c_uint, Direction)>

Restrict a configuration space to have periods count nearest to a target.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_periods_near(1024, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_periods_first(&mut self) -> Result<(c_uint, Direction)>

Restrict a configuration space to contain only its minimum periods count.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_periods_first()?;
dbg!(actual);

pub fn set_periods_last(&mut self) -> Result<(c_uint, Direction)>

Restrict a configuration space to contain only its maximum periods count.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_periods_last()?;
dbg!(actual);

pub fn set_periods_integer(&mut self) -> Result<()>

Restrict a configuration space to contain only integer periods counts.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_periods_integer()?;
dbg!(actual);

pub fn test_buffer_time( &mut self, buffer_time: c_uint, dir: Direction, ) -> Result<bool>

Verify if a buffer time is available inside a configuration space for a PCM.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

dbg!(hw.test_buffer_time(10_000, alsa::Direction::Nearest)?);

pub fn set_buffer_time( &mut self, buffer_time: c_uint, dir: Direction, ) -> Result<()>

Restrict a configuration space to contain only one buffer time.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_time(10_000, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_buffer_time_min( &mut self, buffer_time: c_uint, dir: Direction, ) -> Result<(c_uint, Direction)>

Restrict a configuration space with a minimum buffer time.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_time_min(10_000, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_buffer_time_max( &mut self, buffer_time: c_uint, dir: Direction, ) -> Result<(c_uint, Direction)>

Restrict a configuration space with a maximum buffer time.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_time_max(10_000, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_buffer_time_minmax( &mut self, buffer_time_min: c_uint, dir_min: Direction, buffer_time_max: c_uint, dir_max: Direction, ) -> Result<(c_uint, Direction, c_uint, Direction)>

Restrict a configuration space to have buffer times in a given range.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_time_minmax(10_000, alsa::Direction::Nearest, 20_000, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_buffer_time_near( &mut self, buffer_time: c_uint, dir: Direction, ) -> Result<(c_uint, Direction)>

Restrict a configuration space to have buffer time nearest to a target.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_time_near(10_000, alsa::Direction::Nearest)?;
dbg!(actual);

pub fn set_buffer_time_first(&mut self) -> Result<(c_uint, Direction)>

Restrict a configuration space to contain only its minimum buffer time.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_time_first()?;
dbg!(actual);

pub fn set_buffer_time_last(&mut self) -> Result<(c_uint, Direction)>

Restrict a configuration space to contain only its maximum buffered time.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_time_last()?;
dbg!(actual);

pub fn test_buffer_size(&mut self, buffer_size: c_ulong) -> Result<bool>

Verify if a buffer size is available inside a configuration space for a PCM.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

dbg!(hw.test_buffer_size(1024)?);

pub fn set_buffer_size(&mut self, buffer_size: c_ulong) -> Result<()>

Restrict a configuration space to contain only one buffer size.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_size(1024)?;
dbg!(actual);

pub fn set_buffer_size_min(&mut self, buffer_size: c_ulong) -> Result<c_ulong>

Restrict a configuration space with a minimum buffer size.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_size_min(1024)?;
dbg!(actual);

pub fn set_buffer_size_max(&mut self, buffer_size: c_ulong) -> Result<c_ulong>

Restrict a configuration space with a maximum buffer size.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_size_max(1024)?;
dbg!(actual);

pub fn set_buffer_size_minmax( &mut self, buffer_size_min: c_ulong, buffer_size_max: c_ulong, ) -> Result<(c_ulong, c_ulong)>

Restrict a configuration space to have buffer sizes in a given range.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_size_minmax(1024, 4096)?;
dbg!(actual);

pub fn set_buffer_size_near(&mut self, buffer_size: c_ulong) -> Result<c_ulong>

Restrict a configuration space to have buffer size nearest to a target.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_size_near(1024)?;
dbg!(actual);

pub fn set_buffer_size_first(&mut self) -> Result<c_ulong>

Restrict a configuration space to contain only its minimum buffer size.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_size_first()?;
dbg!(actual);

pub fn set_buffer_size_last(&mut self) -> Result<c_ulong>

Restrict a configuration space to contain only its maximum buffer size.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

let actual = hw.set_buffer_size_last()?;
dbg!(actual);

Methods from Deref<Target = HardwareParameters>

pub fn channels(&self) -> Result<c_uint>

Restrict a configuration space to contain only one channels count.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

let result = hw.channels()?;
dbg!(result);

pub fn channels_max(&self) -> Result<c_uint>

Extract maximum channels count from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.channels_max()?);

pub fn channels_min(&self) -> Result<c_uint>

Extract minimum channels count from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.channels_min()?);

pub fn rate(&self) -> Result<c_uint>

Extract rate from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

println!("{}", hw.rate()?);

pub fn rate_numden(&self) -> Result<(c_uint, c_uint)>

Get rate exact info from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

dbg!(hw.rate_numden()?);

pub fn rate_max(&self) -> Result<c_uint>

Extract max rate from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

println!("{}", hw.rate_max()?);

pub fn rate_min(&self) -> Result<c_uint>

Extract min rate from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

println!("{}", hw.rate_min()?);

pub fn format(&self) -> Result<Format>

Extract format from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

println!("{}", hw.format()?);

pub fn format_mask(&self) -> Result<FormatMask>

Get format mask from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

let _mask = hw.format_mask()?;

pub fn access(&self) -> Result<Access>

Extract access type from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

println!("{}", hw.access()?);

pub fn get_access_mask(&self) -> Result<AccessMask>

Get access mask from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

let _mask = hw.get_access_mask()?;

pub fn can_pause(&self) -> bool

Check if hardware supports pause.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

println!("{}", hw.can_pause());

pub fn can_resume(&self) -> bool

Check if hardware supports resume.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters_any()?;

println!("{}", hw.can_resume());

pub fn can_mmap_sample_resolution(&self) -> bool

Check if hardware supports sample-resolution mmap for given configuration.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.can_mmap_sample_resolution());

pub fn is_double(&self) -> bool

Check if hardware does double buffering for start/stop for given configuration.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.is_double());

pub fn is_batch(&self) -> bool

Check if hardware does double buffering for data transfers for given configuration.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.is_batch());

pub fn is_block_transfer(&self) -> bool

Check if hardware does block transfers for samples for given configuration.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.is_block_transfer());

pub fn is_monotonic(&self) -> bool

Check if timestamps are monotonic for given configuration.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.is_monotonic());

pub fn can_overrange(&self) -> bool

Check if hardware supports overrange detection.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.can_overrange());

pub fn is_half_duplex(&self) -> bool

Check if hardware does half-duplex only.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.is_half_duplex());

pub fn is_joint_duplex(&self) -> bool

Check if hardware does joint-duplex (playback and capture are somewhat correlated)

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.is_joint_duplex());

pub fn can_sync_start(&self) -> bool

Check if hardware supports synchronized start with sample resolution.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.can_sync_start());

pub fn can_disable_period_wakeup(&self) -> bool

Check if hardware can disable period wakeups.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.can_disable_period_wakeup());

pub fn supports_audio_wallclock_ts(&self) -> bool

Check if hardware supports audio wallclock timestamps.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.supports_audio_wallclock_ts());

pub fn supports_audio_ts_type(&self, ty: c_int) -> bool

Check if hardware supports type of audio timestamps.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.supports_audio_ts_type(2));

pub fn sbits(&self) -> Result<c_int>

Get sample resolution info from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.sbits()?);

pub fn fifo_size(&self) -> Result<c_int>

Get hardware FIFO size info from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

println!("{}", hw.fifo_size()?);

pub fn period_time(&self) -> Result<(c_uint, Direction)>

Extract period time from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.period_time());

pub fn period_time_min(&self) -> Result<(c_uint, Direction)>

Extract minimum period time from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.period_time_min());

pub fn period_time_max(&self) -> Result<(c_uint, Direction)>

Extract maximum period time from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.period_time_max());

pub fn period_size(&self) -> Result<(c_ulong, Direction)>

Extract period size from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.period_size());

pub fn period_size_min(&self) -> Result<(c_ulong, Direction)>

Extract minimum period size from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.period_size_min());

pub fn period_size_max(&self) -> Result<(c_ulong, Direction)>

Extract maximum period size from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.period_size_max()?);

pub fn periods(&self) -> Result<(c_uint, Direction)>

Extract periods from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.periods()?);

pub fn periods_min(&self) -> Result<(c_uint, Direction)>

Extract minimum periods count from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.periods_min()?);

pub fn periods_max(&self) -> Result<(c_uint, Direction)>

Extract maximum periods count from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.periods_max()?);

pub fn buffer_time(&self) -> Result<(c_uint, Direction)>

Extract buffer time from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.buffer_time()?);

pub fn buffer_time_min(&self) -> Result<(c_uint, Direction)>

Extract minimum buffer time from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.buffer_time_min()?);

pub fn buffer_time_max(&self) -> Result<(c_uint, Direction)>

Extract maximum buffer time from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let hw = pcm.hardware_parameters()?;

dbg!(hw.buffer_time_max()?);

pub fn buffer_size(&self) -> Result<c_ulong>

Extract buffer size from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters()?;

dbg!(hw.buffer_size()?);

pub fn buffer_size_min(&self) -> Result<c_ulong>

Extract minimum buffer size from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters()?;

dbg!(hw.buffer_size_min()?);

pub fn buffer_size_max(&self) -> Result<c_ulong>

Extract maximum buffer size from a configuration space.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters()?;

dbg!(hw.buffer_size_max()?);

pub fn min_align(&self) -> Result<c_ulong>

Get the minimum transfer align value in samples.

Examples

use audio_device::alsa;

let mut pcm = alsa::Pcm::open_default(alsa::Stream::Playback)?;
let mut hw = pcm.hardware_parameters()?;

dbg!(hw.min_align()?);

Trait Implementations

impl Deref for HardwareParametersMut<'_>

type Target = HardwareParameters

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.