Struct StreamingSource

pub struct StreamingSource { /* private fields */ }

A source that plays a queue of owned buffers.

Implementations

impl StreamingSource

pub fn buffers_queued(&self) -> ALint

alGetSourcei(AL_BUFFERS_QUEUED)

pub fn buffers_processed(&self) -> ALint

alGetSourcei(AL_BUFFERS_PROCESSED)

Examples found in repository

examples/sine.rs (line 73)

fn main() {
	let alto = if let Ok(alto) = Alto::load_default() {
		alto
	} else {
		println!("No OpenAL implementation present!");
		return;
	};

	println!("Using output: {:?}", alto.default_output().unwrap());
	let dev = alto.open(None).unwrap();
	let ctx = dev.new_context(None).unwrap();

	let mut slot = if dev.is_extension_present(alto::ext::Alc::Efx) {
		println!("Using EFX reverb");
		if let Ok(slot) = (|| -> AltoResult<_> {
			let mut slot = ctx.new_aux_effect_slot()?;
			let mut reverb: efx::EaxReverbEffect = ctx.new_effect()?;
			reverb.set_preset(&efx::REVERB_PRESET_GENERIC)?;
			slot.set_effect(&reverb)?;
			Ok(slot)
		})() {
			Some(slot)
		} else {
			println!("Broken router detected; disabling EFX");
			None
		}
	} else {
		println!("EFX not present");
		None
	};

	{
		let buf = ctx.new_buffer(SinWave::new(44_000 / 440, 0.25).render().take(44_000 / 440).collect::<Vec<_>>(), 44_000).unwrap();
		let buf = Arc::new(buf);

		let mut src = ctx.new_static_source().unwrap();
		src.set_buffer(buf).unwrap();
		src.set_looping(true);
		if let Some(ref mut slot) = slot {
			src.set_aux_send(0, slot).unwrap();
		}

		println!("Playing static 440hz sine wave...");
		src.play();

		std::thread::sleep(std::time::Duration::new(2, 0));
	}

	std::thread::sleep(std::time::Duration::new(1, 0));

	{
		let mut wave = SinWave::new(44_000 / 220, 0.25);

		let mut src = ctx.new_streaming_source().unwrap();
		if let Some(ref mut slot) = slot {
			src.set_aux_send(0, slot).unwrap();
		}
		for _ in 0 .. 5 {
			let buf = ctx.new_buffer(wave.render().take(44_000 / 10).collect::<Vec<_>>(), 44_000).unwrap();
			src.queue_buffer(buf).unwrap();
		}

		println!("Playing streaming 220hz sine wave...");
		src.play();

		for _ in 0 .. 15 {
			while src.buffers_processed() == 0 { }

			let mut buf = src.unqueue_buffer().unwrap();
			buf.set_data(wave.render().take(44_000 / 10).collect::<Vec<_>>(), 44_000).unwrap();
			src.queue_buffer(buf).unwrap();
		}

		while src.buffers_processed() < 5 { }
	}

	std::thread::sleep(std::time::Duration::new(1, 0));
}

pub fn queue_buffer(&mut self, buf: Buffer) -> AltoResult<()>

alSourceQueueBuffers()

Examples found in repository

examples/sine.rs (line 66)

fn main() {
	let alto = if let Ok(alto) = Alto::load_default() {
		alto
	} else {
		println!("No OpenAL implementation present!");
		return;
	};

	println!("Using output: {:?}", alto.default_output().unwrap());
	let dev = alto.open(None).unwrap();
	let ctx = dev.new_context(None).unwrap();

	let mut slot = if dev.is_extension_present(alto::ext::Alc::Efx) {
		println!("Using EFX reverb");
		if let Ok(slot) = (|| -> AltoResult<_> {
			let mut slot = ctx.new_aux_effect_slot()?;
			let mut reverb: efx::EaxReverbEffect = ctx.new_effect()?;
			reverb.set_preset(&efx::REVERB_PRESET_GENERIC)?;
			slot.set_effect(&reverb)?;
			Ok(slot)
		})() {
			Some(slot)
		} else {
			println!("Broken router detected; disabling EFX");
			None
		}
	} else {
		println!("EFX not present");
		None
	};

	{
		let buf = ctx.new_buffer(SinWave::new(44_000 / 440, 0.25).render().take(44_000 / 440).collect::<Vec<_>>(), 44_000).unwrap();
		let buf = Arc::new(buf);

		let mut src = ctx.new_static_source().unwrap();
		src.set_buffer(buf).unwrap();
		src.set_looping(true);
		if let Some(ref mut slot) = slot {
			src.set_aux_send(0, slot).unwrap();
		}

		println!("Playing static 440hz sine wave...");
		src.play();

		std::thread::sleep(std::time::Duration::new(2, 0));
	}

	std::thread::sleep(std::time::Duration::new(1, 0));

	{
		let mut wave = SinWave::new(44_000 / 220, 0.25);

		let mut src = ctx.new_streaming_source().unwrap();
		if let Some(ref mut slot) = slot {
			src.set_aux_send(0, slot).unwrap();
		}
		for _ in 0 .. 5 {
			let buf = ctx.new_buffer(wave.render().take(44_000 / 10).collect::<Vec<_>>(), 44_000).unwrap();
			src.queue_buffer(buf).unwrap();
		}

		println!("Playing streaming 220hz sine wave...");
		src.play();

		for _ in 0 .. 15 {
			while src.buffers_processed() == 0 { }

			let mut buf = src.unqueue_buffer().unwrap();
			buf.set_data(wave.render().take(44_000 / 10).collect::<Vec<_>>(), 44_000).unwrap();
			src.queue_buffer(buf).unwrap();
		}

		while src.buffers_processed() < 5 { }
	}

	std::thread::sleep(std::time::Duration::new(1, 0));
}

pub fn unqueue_buffer(&mut self) -> AltoResult<Buffer>

alSourceUnqueueBuffers()

Examples found in repository

examples/sine.rs (line 75)

fn main() {
	let alto = if let Ok(alto) = Alto::load_default() {
		alto
	} else {
		println!("No OpenAL implementation present!");
		return;
	};

	println!("Using output: {:?}", alto.default_output().unwrap());
	let dev = alto.open(None).unwrap();
	let ctx = dev.new_context(None).unwrap();

	let mut slot = if dev.is_extension_present(alto::ext::Alc::Efx) {
		println!("Using EFX reverb");
		if let Ok(slot) = (|| -> AltoResult<_> {
			let mut slot = ctx.new_aux_effect_slot()?;
			let mut reverb: efx::EaxReverbEffect = ctx.new_effect()?;
			reverb.set_preset(&efx::REVERB_PRESET_GENERIC)?;
			slot.set_effect(&reverb)?;
			Ok(slot)
		})() {
			Some(slot)
		} else {
			println!("Broken router detected; disabling EFX");
			None
		}
	} else {
		println!("EFX not present");
		None
	};

	{
		let buf = ctx.new_buffer(SinWave::new(44_000 / 440, 0.25).render().take(44_000 / 440).collect::<Vec<_>>(), 44_000).unwrap();
		let buf = Arc::new(buf);

		let mut src = ctx.new_static_source().unwrap();
		src.set_buffer(buf).unwrap();
		src.set_looping(true);
		if let Some(ref mut slot) = slot {
			src.set_aux_send(0, slot).unwrap();
		}

		println!("Playing static 440hz sine wave...");
		src.play();

		std::thread::sleep(std::time::Duration::new(2, 0));
	}

	std::thread::sleep(std::time::Duration::new(1, 0));

	{
		let mut wave = SinWave::new(44_000 / 220, 0.25);

		let mut src = ctx.new_streaming_source().unwrap();
		if let Some(ref mut slot) = slot {
			src.set_aux_send(0, slot).unwrap();
		}
		for _ in 0 .. 5 {
			let buf = ctx.new_buffer(wave.render().take(44_000 / 10).collect::<Vec<_>>(), 44_000).unwrap();
			src.queue_buffer(buf).unwrap();
		}

		println!("Playing streaming 220hz sine wave...");
		src.play();

		for _ in 0 .. 15 {
			while src.buffers_processed() == 0 { }

			let mut buf = src.unqueue_buffer().unwrap();
			buf.set_data(wave.render().take(44_000 / 10).collect::<Vec<_>>(), 44_000).unwrap();
			src.queue_buffer(buf).unwrap();
		}

		while src.buffers_processed() < 5 { }
	}

	std::thread::sleep(std::time::Duration::new(1, 0));
}

Trait Implementations

impl PartialEq for StreamingSource

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Source for StreamingSource

fn context(&self) -> &Context

The context from which this source was created.

fn as_raw(&self) -> ALuint

Raw handle as provided by OpenAL.

fn state(&self) -> SourceState

alGetSourcei(AL_SOURCE_STATE)

fn play(&mut self)

alSourcePlay()

fn pause(&mut self)

alSourcePause()

fn stop(&mut self)

alSourceStop()

fn rewind(&mut self)

alSourceRewind()

fn relative(&self) -> bool

alGetSourcei(AL_SOURCE_RELATIVE)

fn set_relative(&mut self, value: bool)

alSourcei(AL_SOURCE_RELATIVE)

fn gain(&self) -> f32

alGetSourcef(AL_GAIN)

fn set_gain(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_GAIN)

fn min_gain(&self) -> f32

alGetSourcef(AL_MIN_GAIN)

fn set_min_gain(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_MIN_GAIN)

fn max_gain(&self) -> f32

alGetSourcef(AL_MAX_GAIN)

fn set_max_gain(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_MAX_GAIN)

fn reference_distance(&self) -> f32

alGetSourcef(AL_REFERENCE_DISTANCE)

fn set_reference_distance(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_REFERENCE_DISTANCE)

fn rolloff_factor(&self) -> f32

alGetSourcef(AL_ROLLOFF_FACTOR)

fn set_rolloff_factor(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_ROLLOFF_FACTOR)

fn max_distance(&self) -> f32

alGetSourcef(AL_MAX_DISTANCE)

fn set_max_distance(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_MAX_DISTANCE)

fn pitch(&self) -> f32

alGetSourcef(AL_PITCH)

fn set_pitch(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_PITCH)

fn position<V: From<[f32; 3]>>(&self) -> V

alGetSourcefv(AL_POSITION)

fn set_position<V: Into<[f32; 3]>>(&mut self, value: V) -> AltoResult<()>

alSourcefv(AL_POSITION)

fn velocity<V: From<[f32; 3]>>(&self) -> V

alGetSourcefv(AL_VELOCITY)

fn set_velocity<V: Into<[f32; 3]>>(&mut self, value: V) -> AltoResult<()>

alSourcefv(AL_VELOCITY)

fn direction<V: From<[f32; 3]>>(&self) -> V

alGetSourcefv(AL_DIRECTION)

fn set_direction<V: Into<[f32; 3]>>(&mut self, value: V) -> AltoResult<()>

alSourcefv(AL_DIRECTION)

fn cone_inner_angle(&self) -> f32

alGetSourcef(AL_CONE_INNER_ANGLE)

fn set_cone_inner_angle(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_CONE_INNER_ANGLE)

fn cone_outer_angle(&self) -> f32

alGetSourcef(AL_CONE_OUTER_ANGLE)

fn set_cone_outer_angle(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_CONE_OUTER_ANGLE)

fn cone_outer_gain(&self) -> f32

alGetSourcef(AL_CONE_OUTER_GAIN)

fn set_cone_outer_gain(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_CONE_OUTER_GAIN)

fn sec_offset(&self) -> f32

alGetSourcef(AL_SEC_OFFSET)

fn set_sec_offset(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_SEC_OFFSET)

fn sample_offset(&self) -> ALint

alGetSourcei(AL_SAMPLE_OFFSET)

fn set_sample_offset(&mut self, value: ALint) -> AltoResult<()>

alSourcei(AL_SAMPLE_OFFSET)

fn byte_offset(&self) -> ALint

alGetSourcei(AL_BYTE_OFFSET)

fn set_byte_offset(&mut self, value: ALint) -> AltoResult<()>

alSourcei(AL_BYTE_OFFSET)

fn soft_sec_offset_latency(&self) -> AltoResult<(f64, f64)>

alGetSourcedvSOFT(AL_SEC_OFFSET_LATENCY_SOFT) Requires AL_SOFT_source_latency

fn soft_sample_frac_offset_latency(&self) -> AltoResult<(i32, i32, i64)>

alGetSourcei16vSOFT(AL_SAMPLE_OFFSET_LATENCY_SOFT) Requires AL_SOFT_source_latency

fn soft_sec_length(&self) -> AltoResult<f32>

alGetSourcef(AL_SEC_LENGTH_SOFT) Requires AL_SOFT_source_length

fn soft_sample_length(&self) -> AltoResult<ALint>

alGetSourcei(AL_SAMPLE_LENGTH_SOFT) Requires AL_SOFT_source_length

fn soft_byte_length(&self) -> AltoResult<ALint>

alGetSourcei(AL_BYTE_LENGTH_SOFT) Requires AL_SOFT_source_length

fn soft_direct_channels(&self) -> bool

alGetSourcei(AL_DIRECT_CHANNELS_SOFT) Requires AL_SOFT_direct_channels

fn set_soft_direct_channels(&mut self, value: bool) -> AltoResult<()>

alSourcei(AL_DIRECT_CHANNELS_SOFT) Requires AL_SOFT_direct_channels

fn distance_model(&self) -> DistanceModel

alGetSourcei(AL_DISTANCE_MODEL) Requires AL_EXT_source_distance_model

fn set_distance_model(&mut self, value: DistanceModel) -> AltoResult<()>

alSourcei(AL_DISTANCE_MODEL) Requires AL_EXT_source_distance_model

fn soft_spatialization(&self) -> SoftSourceSpatialization

alGetSourcei(AL_SOURCE_SPATIALIZATION_SOFT) Requires AL_SOFT_source_spatialization

fn set_soft_spatialization( &mut self, value: SoftSourceSpatialization, ) -> AltoResult<()>

alSourcei(AL_SOURCE_SPATIALIZATION_SOFT) Requires AL_SOFT_source_spatialization

fn soft_resampler(&self) -> AltoResult<ALint>

alGetSourcei(AL_SOURCE_RESAMPLER_SOFT) Requires AL_SOFT_source_resampler

fn set_soft_resampler(&mut self, value: ALint) -> AltoResult<()>

alSourcei(AL_SOURCE_RESAMPLER_SOFT) Requires AL_SOFT_source_resampler

fn stereo_angles<V: From<[f32; 2]>>(&self) -> AltoResult<V>

alGetSourcefv(AL_STEREO_ANGLES) Requires AL_EXT_STEREO_ANGLES

fn set_stereo_angles<V: Into<[f32; 2]>>(&mut self, value: V) -> AltoResult<()>

alSourcefv(AL_STEREO_ANGLES) Requires AL_EXT_STEREO_ANGLES

fn radius(&self) -> f32

alGetSourcef(AL_SOURCE_RADIUS) Requires AL_EXT_SOURCE_RADIUS

fn set_radius(&self, value: f32) -> AltoResult<()>

alSourcef(AL_SOURCE_RADIUS) Requires AL_EXT_SOURCE_RADIUS

fn set_direct_filter<F: Filter>(&mut self, value: &F) -> AltoResult<()>

alSourcei(AL_DIRECT_FILTER) Requires ALC_EXT_EFX

fn clear_direct_filter(&mut self)

alSourcei(AL_DIRECT_FILTER) Requires ALC_EXT_EFX

fn set_aux_send( &mut self, send: ALint, slot: &mut AuxEffectSlot, ) -> AltoResult<()>

alSourceiv(AL_AUXILIARY_SEND_FILTER) Requires ALC_EXT_EFX

fn set_aux_send_filter<F: Filter>( &mut self, send: ALint, slot: &mut AuxEffectSlot, filter: &F, ) -> AltoResult<()>

alSourceiv(AL_AUXILIARY_SEND_FILTER) Requires ALC_EXT_EFX

fn clear_aux_send(&mut self, send: ALint)

alSourceiv(AL_AUXILIARY_SEND_FILTER) Requires ALC_EXT_EFX

fn air_absorption_factor(&self) -> f32

alGetSourcef(AL_AIR_ABSORPTION_FACTOR) Requires ALC_EXT_EFX

fn set_air_absorption_factor(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_AIR_ABSORPTION_FACTOR) Requires ALC_EXT_EFX

fn room_rolloff_factor(&self) -> f32

alGetSourcef(AL_ROOM_ROLLOFF_FACTOR) Requires ALC_EXT_EFX

fn set_room_rolloff_factor(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_ROOM_ROLLOFF_FACTOR) Requires ALC_EXT_EFX

fn cone_outer_gainhf(&self) -> f32

alGetSourcef(AL_CONE_OUTER_GAINHF) Requires ALC_EXT_EFX

fn set_cone_outer_gainhf(&mut self, value: f32) -> AltoResult<()>

alSourcef(AL_CONE_OUTER_GAINHF) Requires ALC_EXT_EFX

fn direct_filter_gainhf_auto(&self) -> bool

alGetSourcei(AL_DIRECT_FILTER_GAINHF_AUTO) Requires ALC_EXT_EFX

fn set_direct_filter_gainhf_auto(&mut self, value: bool) -> AltoResult<()>

alSourcei(AL_DIRECT_FILTER_GAINHF_AUTO) Requires ALC_EXT_EFX

impl Eq for StreamingSource