oml-audio 0.5.1

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102


use crate::FileLoader;

use objc::*;
use objc::runtime::*;

#[derive(Debug)]
pub struct MusicApple {
	player: Option< *mut Object >,
}

impl MusicApple {

	pub fn new() -> Self {
		Self {
			player: None,
		}
	}


	fn load_from_slice( &mut self, slice: &[u8] ) -> bool {

		unsafe {
			let cls_nsdata = class!(NSData);

//			let data: *mut Object = msg_send![cls_nsdata, dataWithContentsOfFile: resourcePath];
			let data: *mut Object = msg_send![ cls_nsdata, dataWithBytes:slice.as_ptr() length:slice.len() ];
			let data_len: u64 = msg_send![ data, length ];
			dbg!(&data_len);

			let cls_nserror = class!(NSError);
			let error: *mut Object = msg_send![ cls_nserror, alloc ];

			let cls_avaudioplayer = class!(AVAudioPlayer);
			let player: *mut Object = msg_send![ cls_avaudioplayer, alloc ];
			let player: *mut Object = msg_send![ player, initWithData: data error: &error ];

			let prep_result: bool = msg_send![ player, prepareToPlay ];
			if prep_result {
				self.player = Some( player );
				let _: () = msg_send![ player, setNumberOfLoops: -1 ];
				true
			} else {
				self.player = None;
				false
			}
//			let _: () = msg_send![ player, setVolume: 0.2 fadeDuration: 10.0 ];
		}
	}
	pub fn load( &mut self, fileloader: &mut impl FileLoader, filename: &str ) -> bool {

		let mut f = fileloader.open( &filename );
		if f.is_valid() {
			println!("Loading Music from {} ({}).", &filename, &f.name());
			let mut buf = Vec::new();
			while !f.eof() {
				let c = f.read_u8();
				buf.push( c );
			}

//			let buf: &[u8] = buf.as_slice();

			self.load_from_slice( buf.as_slice() )
		} else {
			println!("Couldn't read Music from {}!", &filename);

			false
		}
	}

	pub fn play( &mut self ) {
		if let Some( player ) = self.player {
			unsafe {
				let _: () = msg_send![ player, play ];
			}
		}
	}

	pub fn pause( &mut self ) {
		if let Some( player ) = self.player {
			unsafe {
				let _: () = msg_send![ player, pause ];
			}
		}		
	}

	pub fn stop( &mut self ) {
		if let Some( player ) = self.player {
			unsafe {
				let _: () = msg_send![ player, stop ];
			}
		}		
	}

	pub fn update( &mut self, _time_step: f64 ) {

	}



}