[READ-ONLY] Mirror of https://github.com/probablykasper/redlux. AAC decoder for MPEG-4 and AAC files, with rodio support
aac
audio
decoder
mp4
package
Add aac file decoder support
+105
-38
+21
examples/aac_playback.rs
+21
examples/aac_playback.rs
···
1
+
use redlux::Decoder;
2
+
use rodio::{OutputStream, Sink};
3
+
use std::fs::File;
4
+
use std::io::BufReader;
5
+
6
+
fn main() {
7
+
let path = "tests/samples/Simbai & Elke Bay - Energy.aac";
8
+
let file = File::open(path).expect("Error opening file");
9
+
let buf = BufReader::new(file);
10
+
11
+
let decoder = Decoder::new_aac(buf).expect("Error creating Decoder");
12
+
13
+
let output_stream = OutputStream::try_default();
14
+
let (_stream, handle) = output_stream.expect("Error creating output stream");
15
+
let sink = Sink::try_new(&handle).expect("Error creating sink");
16
+
17
+
sink.append(decoder);
18
+
sink.play();
19
+
sink.set_volume(0.25);
20
+
sink.sleep_until_end();
21
+
}
+2
-2
examples/m4a_playback.rs
+2
-2
examples/m4a_playback.rs
···
11
11
let size = metadata.len();
12
12
let buf = BufReader::new(file);
13
13
14
-
let decoder = Decoder::new(buf, size).expect("Error creating M4aDecoder");
14
+
let decoder = Decoder::new_mpeg4(buf, size).expect("Error creating M4aDecoder");
15
15
16
16
let output_stream = OutputStream::try_default();
17
17
let (_stream, handle) = output_stream.expect("Error creating output stream");
···
19
19
20
20
sink.append(decoder);
21
21
sink.play();
22
-
sink.set_volume(0.5);
22
+
sink.set_volume(0.25);
23
23
sink.sleep_until_end();
24
24
}
+81
-35
src/lib.rs
+81
-35
src/lib.rs
···
4
4
5
5
pub mod adts;
6
6
7
+
pub enum Format {
8
+
Mp4,
9
+
Aac,
10
+
}
11
+
12
+
pub enum Reader<R> {
13
+
Mp4Reader(mp4::Mp4Reader<R>),
14
+
AacReader(R),
15
+
}
16
+
7
17
pub struct Decoder<R>
8
18
where
9
19
R: Read + Seek,
10
20
{
11
-
mp4_reader: mp4::Mp4Reader<R>,
21
+
pub format: Format,
22
+
reader: Reader<R>,
12
23
aac_decoder: AacDecoder,
24
+
bytes: Vec<u8>,
13
25
current_pcm_index: usize,
14
26
current_pcm: Vec<i16>,
15
27
track_id: u32,
···
20
32
where
21
33
R: Read + Seek,
22
34
{
23
-
pub fn new(reader: R, size: u64) -> Result<Decoder<R>, &'static str> {
24
-
let decoder = AacDecoder::new(Transport::Adts);
35
+
pub fn new_aac(reader: R) -> Result<Decoder<R>, &'static str> {
36
+
let aac_decoder = AacDecoder::new(Transport::Adts);
37
+
let aac_decoder = Decoder {
38
+
format: Format::Aac,
39
+
reader: Reader::AacReader(reader),
40
+
aac_decoder: aac_decoder,
41
+
bytes: Vec::new(),
42
+
current_pcm_index: 0,
43
+
current_pcm: Vec::new(),
44
+
track_id: 0,
45
+
position: 1,
46
+
};
47
+
// aac_decoder.next();
48
+
Ok(aac_decoder)
49
+
}
50
+
pub fn new_mpeg4(reader: R, size: u64) -> Result<Decoder<R>, &'static str> {
51
+
let aac_decoder = AacDecoder::new(Transport::Adts);
25
52
let mp4 = mp4::Mp4Reader::read_header(reader, size).or(Err("Error reading MPEG header"))?;
26
53
let mut track_id: Option<u32> = None;
27
54
{
···
39
66
match track_id {
40
67
Some(track_id) => {
41
68
return Ok(Decoder {
42
-
mp4_reader: mp4,
43
-
aac_decoder: decoder,
69
+
format: Format::Mp4,
70
+
reader: Reader::Mp4Reader(mp4),
71
+
aac_decoder: aac_decoder,
72
+
bytes: Vec::new(),
44
73
current_pcm_index: 0,
45
74
current_pcm: Vec::new(),
46
75
track_id: track_id,
···
77
106
fn next(&mut self) -> Option<i16> {
78
107
if self.current_pcm_index == self.current_pcm.len() {
79
108
let mut pcm = vec![0; 8192];
80
-
let result = match self.aac_decoder.decode_frame(&mut self.current_pcm) {
109
+
let result = match self.aac_decoder.decode_frame(&mut pcm) {
81
110
Err(DecoderError::NOT_ENOUGH_BITS) => {
82
-
let sample_result = self.mp4_reader.read_sample(self.track_id, self.position);
83
-
let sample = match sample_result {
84
-
Ok(sample) => sample?, // None if EOF
85
-
Err(_) => {
86
-
println!("Error reading sample");
87
-
return None;
88
-
}
89
-
};
90
-
let tracks = self.mp4_reader.tracks();
91
-
let track = match tracks.get(self.track_id as usize - 1) {
92
-
Some(track) => track,
93
-
None => {
94
-
println!("No track ID there");
95
-
return None;
111
+
match &mut self.reader {
112
+
// mp4
113
+
Reader::Mp4Reader(mp4_reader) => {
114
+
let sample_result = mp4_reader.read_sample(self.track_id, self.position);
115
+
let sample = match sample_result {
116
+
Ok(sample) => sample?, // None if EOF
117
+
Err(_) => {
118
+
println!("Error reading sample");
119
+
return None;
120
+
}
121
+
};
122
+
let tracks = mp4_reader.tracks();
123
+
let track = match tracks.get(self.track_id as usize - 1) {
124
+
Some(track) => track,
125
+
None => {
126
+
println!("No track ID there");
127
+
return None;
128
+
}
129
+
};
130
+
let adts_header = match adts::construct_adts_header(track, &sample) {
131
+
Some(bytes) => bytes,
132
+
None => {
133
+
println!("Error getting adts header bytes");
134
+
return None;
135
+
}
136
+
};
137
+
let adts_bytes = mp4::Bytes::copy_from_slice(&adts_header);
138
+
self.bytes = [adts_bytes, sample.bytes].concat();
139
+
self.position += 1;
96
140
}
97
-
};
98
-
let adts_header = match adts::construct_adts_header(track, &sample) {
99
-
Some(bytes) => bytes,
100
-
None => {
101
-
println!("Error getting adts header bytes");
102
-
return None;
141
+
// aac
142
+
Reader::AacReader(aac_reader) => {
143
+
let old_bytes_len = self.bytes.len();
144
+
let mut new_bytes = vec![0; 8192 - old_bytes_len];
145
+
let bytes_read = match aac_reader.read(&mut new_bytes) {
146
+
Ok(bytes_read) => bytes_read,
147
+
Err(_) => return None,
148
+
};
149
+
// aac files already have adts headers
150
+
self.bytes.extend(new_bytes);
103
151
}
104
-
};
105
-
let adts_bytes = mp4::Bytes::copy_from_slice(&adts_header);
106
-
let bytes = [adts_bytes, sample.bytes].concat();
107
-
self.position += 1;
108
-
let _bytes_read = match self.aac_decoder.fill(&bytes) {
109
-
Ok(bytes_read) => bytes_read,
152
+
}
153
+
let bytes_filled = match self.aac_decoder.fill(&self.bytes) {
154
+
Ok(bytes_filled) => bytes_filled,
110
155
Err(_) => return None,
111
156
};
157
+
self.bytes = self.bytes[bytes_filled..].to_vec();
112
158
self.aac_decoder.decode_frame(&mut pcm)
113
159
}
114
160
val => val,
···
120
166
return None;
121
167
}
122
168
}
123
-
let decoded_fram_size = self.aac_decoder.decoded_frame_size();
124
-
if decoded_fram_size < pcm.len() {
125
-
let _ = pcm.split_off(decoded_fram_size);
169
+
let decoded_frame_size = self.aac_decoder.decoded_frame_size();
170
+
if decoded_frame_size < pcm.len() {
171
+
let _ = pcm.split_off(decoded_frame_size);
126
172
}
127
173
self.current_pcm = pcm;
128
174
self.current_pcm_index = 0;
tests/samples/Simbai & Elke Bay - Energy.aac
tests/samples/Simbai & Elke Bay - Energy.aac
This is a binary file and will not be displayed.
+1
-1
tests/test.rs
+1
-1
tests/test.rs
···
14
14
let size = metadata.len();
15
15
let buf = BufReader::new(file);
16
16
17
-
let decoder = Decoder::new(buf, size).expect("Error creating M4aDecoder");
17
+
let decoder = Decoder::new_mpeg4(buf, size).expect("Error creating M4aDecoder");
18
18
19
19
let output_stream = OutputStream::try_default();
20
20
let (_stream, handle) = output_stream.expect("Error creating output stream");