oml-audio 0.6.5-alpha

Very basic, and thin abstraction of audio handling meant for games.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


use crate::FileLoader;
use crate::Music;
use crate::SoundBank;
//use crate::SoundPool;

use std::time::Instant;	// temporary, we get higher precision by calculating from the audio callbacks

#[derive(Debug)]
pub struct AudioStub {
	last_now:		Instant,
	capture_buffer: Vec< f32 >,
	sound_bank:		SoundBank,
}

impl AudioStub {
	pub fn new() -> Self {
		eprintln!("Warning: Using STUB for all oml-audio!\nSelect a backend via a feature.");
		Self {
	        last_now:		Instant::now(),
	        capture_buffer:	Vec::new(),
	        sound_bank:		SoundBank::new(),
		}
	}

	pub fn start( &mut self ) {
	}	

	pub fn get_sound_bank_mut( &mut self ) -> &mut SoundBank {
		&mut self.sound_bank
	}

	pub fn fill_buffer( _sound_bank: &mut SoundBank, _producer: &mut ringbuf::Producer< f32 > ) -> usize {
		0
	}

	pub fn drain_buffer( _consumer: &mut ringbuf::Consumer< f32 > ) -> usize {
		0
	}

	pub fn update( &mut self ) -> f64 {
        let timestep = self.last_now.elapsed().as_secs_f64();
        self.last_now = Instant::now();

		timestep
	}

	pub fn load_music( &mut self, fileloader: &mut impl FileLoader, filename: &str ) -> bool {
//		self.music.load( fileloader, filename )
		true
	}

	pub fn load_music_native( &mut self, fileloader: &mut impl FileLoader, filename: &str ) -> bool {
//		self.music.load( fileloader, filename )
		true
	}

	pub fn play_music( &mut self ) {
//		self.music.play();
	}
	pub fn pause_music( &mut self ) {
//		self.music.pause();
	}

	pub fn load_sound_bank( &mut self, fileloader: &mut impl FileLoader, filename: &str ) {
//		self.sound_bank.load( fileloader, filename )
	}

	pub fn play_sound( &mut self, name: &str ) {
//		self.sound_bank.play( name );
	}

	pub fn is_any_sound_playing( &self ) -> bool {
		false
	}

	pub fn capture( &mut self, size: usize ) {
	}

	pub fn capture_buffer_slice( &self ) -> &[f32] {
		self.capture_buffer.as_slice()
	}

}