Struct bones_framework::audio::StaticSoundData

pub struct StaticSoundData {
    pub sample_rate: u32,
    pub frames: Arc<[Frame]>,
    pub settings: StaticSoundSettings,
    pub slice: Option<(usize, usize)>,
}

A piece of audio loaded into memory all at once.

These can be cheaply cloned, as the audio data is shared among all clones.

Fields

sample_rate: u32

The sample rate of the audio (in Hz).

frames: Arc<[Frame]>

The raw samples that make up the audio.

settings: StaticSoundSettings

Settings for the sound.

slice: Option<(usize, usize)>

The portion of the sound this StaticSoundData represents.

Note that the StaticSoundData holds the entire piece of audio it was originally given regardless of the value of slice, but StaticSoundData::num_frames, StaticSoundData::duration, and StaticSoundData::frame_at_index will all behave as if this StaticSoundData only contained the specified portion of audio.

Implementations

impl StaticSoundData

pub fn from_file( path: impl AsRef<Path>, ) -> Result<StaticSoundData, FromFileError>

Loads an audio file into a StaticSoundData.

pub fn from_cursor<T>( cursor: Cursor<T>, ) -> Result<StaticSoundData, FromFileError>

where T: AsRef<[u8]> + Send + Sync + 'static,

Loads a cursor wrapping audio file data into a StaticSoundData.

pub fn from_media_source( media_source: impl MediaSource + 'static, ) -> Result<StaticSoundData, FromFileError>

Loads an audio file from a type that implements Symphonia’s [MediaSource] trait.

impl StaticSoundData

pub fn start_time(&self, start_time: impl Into<StartTime>) -> StaticSoundData

Sets when the sound should start playing.

This returns a cheap clone of the StaticSoundData with the modified start time.

Examples

Configuring a sound to start 4 ticks after a clock’s current time:

use kira::{
	manager::{AudioManager, AudioManagerSettings, backend::DefaultBackend},
	sound::static_sound::{StaticSoundData, StaticSoundSettings},
	clock::ClockSpeed,
};

let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default())?;
let clock_handle = manager.add_clock(ClockSpeed::TicksPerMinute(120.0))?;
let sound = StaticSoundData::from_file("sound.ogg")?
	.start_time(clock_handle.time() + 4);

pub fn start_position( &self, start_position: impl Into<PlaybackPosition>, ) -> StaticSoundData

Sets where in the sound playback should start.

This returns a cheap clone of the StaticSoundData with the modified start position.

pub fn reverse(&self, reverse: bool) -> StaticSoundData

Sets whether the sound should be played in reverse.

This returns a cheap clone of the StaticSoundData with the modified setting.

pub fn loop_region( &self, loop_region: impl IntoOptionalRegion, ) -> StaticSoundData

Sets the portion of the sound that should be looped.

This returns a cheap clone of the StaticSoundData with the modified loop region.

Examples

Configure a sound to loop the portion from 3 seconds in to the end:

let settings = StaticSoundSettings::new().loop_region(3.0..);

Configure a sound to loop the portion from 2 to 4 seconds:

let settings = StaticSoundSettings::new().loop_region(2.0..4.0);

pub fn volume(&self, volume: impl Into<Value<Volume>>) -> StaticSoundData

Sets the volume of the sound.

This returns a cheap clone of the StaticSoundData with the modified volume.

Examples

Set the volume as a factor:

let settings = StaticSoundSettings::new().volume(0.5);

Set the volume as a gain in decibels:

let settings = StaticSoundSettings::new().volume(kira::Volume::Decibels(-6.0));

Link the volume to a modulator:

use kira::{
	manager::{AudioManager, AudioManagerSettings, backend::DefaultBackend},
	modulator::tweener::TweenerBuilder,
	sound::static_sound::{StaticSoundSettings},
};

let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default())?;
let tweener = manager.add_modulator(TweenerBuilder {
	initial_value: 0.5,
})?;
let settings = StaticSoundSettings::new().volume(&tweener);

pub fn playback_rate( &self, playback_rate: impl Into<Value<PlaybackRate>>, ) -> StaticSoundData

Sets the playback rate of the sound.

Changing the playback rate will change both the speed and the pitch of the sound.

This returns a cheap clone of the StaticSoundData with the modified playback rate.

Examples

Set the playback rate as a factor:

let settings = StaticSoundSettings::new().playback_rate(0.5);

Set the playback rate as a change in semitones:

use kira::sound::PlaybackRate;
let settings = StaticSoundSettings::new().playback_rate(PlaybackRate::Semitones(-2.0));

Link the playback rate to a modulator:

use kira::{
	manager::{AudioManager, AudioManagerSettings, backend::DefaultBackend},
	modulator::tweener::TweenerBuilder,
	sound::static_sound::{StaticSoundSettings},
};

let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default())?;
let tweener = manager.add_modulator(TweenerBuilder {
	initial_value: 0.5,
})?;
let settings = StaticSoundSettings::new().playback_rate(&tweener);

pub fn panning(&self, panning: impl Into<Value<f64>>) -> StaticSoundData

Sets the panning of the sound, where 0 is hard left and 1 is hard right.

This returns a cheap clone of the StaticSoundData with the modified panning.

Examples

Set the panning to a static value:

let settings = StaticSoundSettings::new().panning(0.25);

Link the panning to a modulator:

use kira::{
	manager::{AudioManager, AudioManagerSettings, backend::DefaultBackend},
	modulator::tweener::TweenerBuilder,
	sound::static_sound::{StaticSoundSettings},
};

let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default())?;
let tweener = manager.add_modulator(TweenerBuilder {
	initial_value: 0.25,
})?;
let settings = StaticSoundSettings::new().panning(&tweener);

pub fn output_destination( &self, output_destination: impl Into<OutputDestination>, ) -> StaticSoundData

Sets the destination that this sound should be routed to.

This returns a cheap clone of the StaticSoundData with the modified output destination.

Examples

Set the output destination of a sound to a mixer track:

use kira::{
	manager::{AudioManager, AudioManagerSettings, backend::DefaultBackend},
	track::TrackBuilder,
	sound::static_sound::{StaticSoundSettings},
};

let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default())?;
let sub_track = manager.add_sub_track(TrackBuilder::new())?;
let settings = StaticSoundSettings::new().output_destination(&sub_track);

Set the output destination of a sound to an emitter in a spatial scene:

use kira::{
	manager::{AudioManager, AudioManagerSettings, backend::DefaultBackend},
	spatial::{scene::SpatialSceneSettings, emitter::EmitterSettings},
	sound::static_sound::{StaticSoundSettings},
};

let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default())?;
let mut scene = manager.add_spatial_scene(SpatialSceneSettings::default())?;
let emitter = scene.add_emitter(mint::Vector3 {
	x: 0.0,
	y: 0.0,
	z: 0.0,
}, EmitterSettings::default())?;
let settings = StaticSoundSettings::new().output_destination(&emitter);

pub fn fade_in_tween( &self, fade_in_tween: impl Into<Option<Tween>>, ) -> StaticSoundData

Sets the tween used to fade in the sound from silence.

This returns a cheap clone of the StaticSoundData with the modified fade in tween.

pub fn with_settings(&self, settings: StaticSoundSettings) -> StaticSoundData

Returns a cheap clone of the StaticSoundData with the specified settings.

pub fn num_frames(&self) -> usize

Returns the number of frames in the StaticSoundData.

If StaticSoundData::slice is Some, this will be the number of frames in the slice.

pub fn duration(&self) -> Duration

Returns the duration of the audio.

If StaticSoundData::slice is Some, this will be the duration of the slice.

pub fn frame_at_index(&self, index: usize) -> Option<Frame>

Returns the nth [Frame] of audio in the StaticSoundData.

If StaticSoundData::slice is Some, this will behave as if the StaticSoundData only contained that portion of the audio.

pub fn slice(&self, region: impl IntoOptionalRegion) -> StaticSoundData

Sets the portion of the audio this StaticSoundData represents.

This returns a cheap clone of the StaticSoundData with the modified slice.

Note that the StaticSoundData holds the entire piece of audio it was originally given regardless of the value of slice, but StaticSoundData::num_frames, StaticSoundData::duration, and StaticSoundData::frame_at_index will all behave as if this StaticSoundData only contained the specified portion of audio.

Example

use kira::{
	sound::static_sound::{StaticSoundData, StaticSoundSettings},
	Frame,
};
let sound = StaticSoundData {
	sample_rate: 1,
	frames: (0..10).map(|i| Frame::from_mono(i as f32)).collect(),
	settings: StaticSoundSettings::default(),
	slice: None,
};
let sliced = sound.slice(3.0..6.0);
assert_eq!(sliced.num_frames(), 3);
assert_eq!(sliced.frame_at_index(0), Some(Frame::from_mono(3.0)));
assert_eq!(sliced.frame_at_index(1), Some(Frame::from_mono(4.0)));

Trait Implementations

impl Clone for StaticSoundData

fn clone(&self) -> StaticSoundData

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StaticSoundData

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for StaticSoundData

fn eq(&self, other: &StaticSoundData) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SoundData for StaticSoundData

type Error = ()

Errors that can occur when starting the sound.

type Handle = StaticSoundHandle

The type that can be used to control the sound once it has started.

fn into_sound( self, ) -> Result<(Box<dyn Sound>, <StaticSoundData as SoundData>::Handle), <StaticSoundData as SoundData>::Error>

Converts the loaded sound into a live, playing sound and a handle to control it.

impl StructuralPartialEq for StaticSoundData