]> git.nihav.org Git - nihav.git/blob - nihav-llaudio/src/demuxers/flac.rs
h264: introduce inline assembly for CABAC get_bit() and bump compiler version
[nihav.git] / nihav-llaudio / src / demuxers / flac.rs
1 use nihav_core::frame::*;
2 use nihav_core::demuxers::*;
3
4 #[derive(Clone,Copy,Default)]
5 struct FrameSeekInfo {
6 off: u64,
7 size: u64,
8 samplepos: u64,
9 sampleend: u64,
10 }
11
12 struct FLACDemuxer<'a> {
13 src: &'a mut ByteReader<'a>,
14 data_start: u64,
15 tot_samples: u64,
16 cur_samples: u64,
17 blk_samples: u16,
18 min_samples: u16,
19 min_size: usize,
20 max_size: usize,
21 srate: u32,
22 known_frames: Vec<FrameSeekInfo>,
23 build_index: bool,
24 frame_hdr: u32,
25 }
26
27 fn common_header_word(mut val: u32) -> u32 {
28 val &= !0x1F000; // blocking strategy and block size
29 let ch_map = (val >> 4) & 0xF;
30 if matches!(ch_map, 0x1 | 0x8 | 0x9 | 0xA) { // stereo coding modes
31 val &= !0xF0;
32 val |= 0x10;
33 }
34 val
35 }
36
37 impl<'a> FLACDemuxer<'a> {
38 fn new(io: &'a mut ByteReader<'a>) -> Self {
39 Self {
40 src: io,
41 data_start: 0,
42 tot_samples: 0,
43 cur_samples: 0,
44 blk_samples: 0,
45 min_samples: 0,
46 min_size: 0,
47 max_size: 0,
48 srate: 0,
49 known_frames: Vec::new(),
50 build_index: false,
51 frame_hdr: 0,
52 }
53 }
54 fn read_frame(&mut self) -> DemuxerResult<(Vec<u8>, u64, u64)> {
55 if self.src.is_eof() || (self.tot_samples != 0 && self.cur_samples == self.tot_samples) { return Err(DemuxerError::EOF); }
56 let mut buf = Vec::with_capacity(self.min_size);
57 let mut crc = 0;
58 let frame_start = self.src.tell();
59 for _ in 0..5 {
60 let byte = self.src.read_byte()?;
61 buf.push(byte);
62 crc = update_crc16(crc, byte);
63 }
64 if self.frame_hdr == 0 {
65 self.frame_hdr = read_u32be(&buf).unwrap_or(0);
66 }
67 let mut ref_crc = self.src.read_u16be()?;
68 loop {
69 let byte = self.src.read_byte()?;
70 let old_byte = (ref_crc >> 8) as u8;
71 buf.push(old_byte);
72 ref_crc = (ref_crc << 8) | u16::from(byte);
73 crc = update_crc16(crc, old_byte);
74 if buf.len() + 4 >= self.min_size && crc == ref_crc {
75 let ret = self.src.peek_u32be();
76 if ret.is_err() || (common_header_word(ret.unwrap_or(0)) == common_header_word(self.frame_hdr)) {
77 buf.push((ref_crc >> 8) as u8);
78 buf.push(ref_crc as u8);
79 break;
80 }
81 }
82 if (self.max_size > 0) && (buf.len() > self.max_size) {
83 return Err(DemuxerError::InvalidData);
84 }
85 if buf.len() > (1 << 23) {
86 return Err(DemuxerError::InvalidData);
87 }
88 }
89
90 let (duration, pts) = if self.blk_samples != 0 {
91 validate!((buf[1] & 1) == 0);
92 let blkno = u64::from(read_utf8(&buf[4..])?);
93 self.cur_samples = blkno * u64::from(self.blk_samples);
94 (u64::from(self.blk_samples), blkno)
95 } else {
96 let mut idx = 5;
97 while idx < buf.len() && (buf[idx] & 0x80) != 0 {
98 idx += 1;
99 }
100
101 let bsz_id = buf[2] >> 4;
102 let blksamps = match bsz_id {
103 0 => return Err(DemuxerError::InvalidData),
104 1 => 192,
105 2..=5 => 576 << (bsz_id - 2),
106 6 => {
107 validate!(idx < buf.len());
108 u64::from(buf[idx]) + 1
109 },
110 7 => {
111 validate!(idx + 2 <= buf.len());
112 u64::from(buf[idx]) * 256 + u64::from(buf[idx + 1]) + 1
113 },
114 _ => 256 << (bsz_id - 8),
115 };
116 let pts = u64::from(read_utf8(&buf[4..])?);
117
118 validate!(idx < buf.len());
119
120 (blksamps, pts)
121 };
122
123 let spos = if self.blk_samples != 0 { pts * u64::from(self.blk_samples) } else { pts };
124 if self.build_index && (self.known_frames.is_empty() || self.known_frames.last().unwrap_or(&FrameSeekInfo::default()).samplepos < spos) {
125 let sampleend = spos + duration;
126 self.known_frames.push(FrameSeekInfo{off: frame_start, size: buf.len() as u64, samplepos: spos, sampleend });
127 }
128
129 self.cur_samples += duration;
130
131 Ok((buf, pts, duration))
132 }
133 }
134
135 fn update_crc16(crc: u16, byte: u8) -> u16 {
136 (crc << 8) ^ CRC16_TABLE[(((crc >> 8) as u8) ^ byte) as usize]
137 }
138
139 fn read_utf8(src: &[u8]) -> DemuxerResult<u32> {
140 if (src[0] & 0x80) == 0 {
141 return Ok(u32::from(src[0]));
142 }
143 let len = (!src[0]).leading_zeros() as usize;
144 validate!(len != 1 && len <= 5 && src.len() >= len);
145 let mut val = u32::from(src[0] & 0x1F);
146 for byte in src.iter().take(len).skip(1) {
147 validate!((*byte & 0xC0) == 0x80);
148 val = (val << 6) | u32::from(*byte & 0x3F);
149 }
150 Ok(val)
151 }
152
153 impl<'a> DemuxCore<'a> for FLACDemuxer<'a> {
154 fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
155 let tag = self.src.read_tag()?;
156 validate!(&tag == b"fLaC");
157 let mut streaminfo: Vec<u8> = Vec::new();
158 let mut srate = 0u32;
159 let mut channels = 0u8;
160 loop {
161 let id1 = self.src.read_byte()?;
162 let len = self.src.read_u24be()? as usize;
163 let id = id1 & 0x7F;
164
165 match id {
166 0x00 => {
167 validate!(len >= 34);
168 streaminfo = vec![0u8; len];
169 self.src.read_buf(&mut streaminfo)?;
170 let min_bs = read_u16be(&streaminfo[0..])?;
171 let max_bs = read_u16be(&streaminfo[2..])?;
172 if min_bs == max_bs {
173 self.blk_samples = max_bs;
174 }
175 self.min_samples = min_bs;
176 self.min_size = read_u24be(&streaminfo[4..])? as usize;
177 self.max_size = read_u24be(&streaminfo[7..])? as usize;
178 let word = read_u24be(&streaminfo[10..])?;
179 srate = word >> 4;
180 channels = (((word >> 1) & 7) + 1) as u8;
181 self.tot_samples = (u64::from(streaminfo[13] & 0xF) << 32) | u64::from(read_u32be(&streaminfo[14..])?);
182 },
183 0x03 => {
184 validate!((len % 18) == 0);
185 seek_index.mode = SeekIndexMode::Present;
186 for _ in 0..len / 18 {
187 let sample = self.src.read_u64be()?;
188 let offset = self.src.read_u64be()?;
189 let _nsamps = self.src.read_u16be()?;
190 let time = sample * 1000 / u64::from(srate.max(1000));
191 seek_index.add_entry(0, SeekEntry { time, pts: sample, pos: offset });
192 }
193 },
194 _ => self.src.read_skip(len)?,
195 };
196
197 if (id1 & 0x80) != 0 {
198 break;
199 }
200 }
201 if seek_index.mode != SeekIndexMode::Present {
202 let min_size = if self.min_samples != 0 { self.min_samples } else { 2048 };
203 let nframes = self.tot_samples as usize / (min_size as usize);
204 self.known_frames = Vec::with_capacity(nframes.max(1));
205 seek_index.mode = SeekIndexMode::Automatic;
206 self.build_index = true;
207 } else {
208 self.build_index = false;
209 }
210 self.data_start = self.src.tell();
211 validate!(srate != 0);
212 self.srate = srate;
213
214 let base = if self.blk_samples != 0 { u32::from(self.blk_samples) } else { 1 };
215 let ahdr = NAAudioInfo::new(srate, channels as u8, SND_S16P_FORMAT, base as usize);
216 let ainfo = NACodecInfo::new("flac", NACodecTypeInfo::Audio(ahdr), Some(streaminfo));
217 strmgr.add_stream(NAStream::new(StreamType::Audio, 0, ainfo, base, srate, 0)).unwrap();
218
219 Ok(())
220 }
221 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
222 let (buf, pts, duration) = self.read_frame()?;
223
224 let stream = strmgr.get_stream(0).unwrap();
225 let ts = stream.make_ts(Some(pts), None, Some(duration));
226 let pkt = NAPacket::new(stream, ts, true, buf);
227
228 Ok(pkt)
229 }
230 fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> {
231 if seek_index.mode == SeekIndexMode::Present {
232 let ret = seek_index.find_pos(time);
233 if ret.is_none() {
234 return Err(DemuxerError::SeekError);
235 }
236 let seek_info = ret.unwrap();
237 self.cur_samples = seek_info.pts;
238 self.src.seek(SeekFrom::Start(self.data_start + seek_info.pos))?;
239 Ok(())
240 } else if let NATimePoint::Milliseconds(ms) = time {
241 let samppos = NATimeInfo::time_to_ts(ms, 1000, 1, self.srate);
242 if self.known_frames.last().unwrap_or(&FrameSeekInfo::default()).sampleend >= samppos {
243 for point in self.known_frames.iter().rev() {
244 if point.samplepos <= samppos {
245 self.src.seek(SeekFrom::Start(point.off))?;
246 self.cur_samples = point.samplepos;
247 return Ok(());
248 }
249 }
250 } else {
251 let startinfo = FrameSeekInfo { off: self.data_start, size: 0, samplepos: 0, sampleend: 0 };
252 let lentry = self.known_frames.last().unwrap_or(&startinfo);
253
254 self.src.seek(SeekFrom::Start(lentry.off + lentry.size))?;
255 self.cur_samples = lentry.sampleend;
256 loop {
257 let frame_start = self.src.tell();
258 let ret = self.read_frame();
259 if ret.is_err() {
260 return Err(DemuxerError::SeekError);
261 }
262 let (_, pts, duration) = ret.unwrap();
263 self.cur_samples = pts;
264 if self.blk_samples != 0 {
265 self.cur_samples *= u64::from(self.blk_samples);
266 }
267 if self.cur_samples <= samppos && self.cur_samples + duration >= samppos {
268 self.src.seek(SeekFrom::Start(frame_start))?;
269 return Ok(());
270 }
271 }
272 }
273 Err(DemuxerError::SeekError)
274 } else {
275 Err(DemuxerError::NotPossible)
276 }
277 }
278 fn get_duration(&self) -> u64 { self.tot_samples * 1000 / u64::from(self.srate) }
279 }
280
281 impl<'a> NAOptionHandler for FLACDemuxer<'a> {
282 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
283 fn set_options(&mut self, _options: &[NAOption]) { }
284 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
285 }
286
287 pub struct FLACDemuxerCreator { }
288
289 impl DemuxerCreator for FLACDemuxerCreator {
290 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
291 Box::new(FLACDemuxer::new(br))
292 }
293 fn get_name(&self) -> &'static str { "flac" }
294 }
295
296 #[cfg(test)]
297 mod test {
298 use super::*;
299 use std::fs::File;
300
301 #[test]
302 fn test_flac_demux() {
303 // sample: https://samples.mplayerhq.hu/A-codecs/lossless/luckynight.flac
304 let mut file = File::open("assets/LLaudio/luckynight.flac").unwrap();
305 let mut fr = FileReader::new_read(&mut file);
306 let mut br = ByteReader::new(&mut fr);
307 let mut dmx = FLACDemuxer::new(&mut br);
308 let mut sm = StreamManager::new();
309 let mut si = SeekIndex::new();
310 dmx.open(&mut sm, &mut si).unwrap();
311 loop {
312 let pktres = dmx.get_frame(&mut sm);
313 if let Err(e) = pktres {
314 if (e as i32) == (DemuxerError::EOF as i32) { break; }
315 panic!("error");
316 }
317 let pkt = pktres.unwrap();
318 println!("Got {}", pkt);
319 }
320 }
321 }
322
323 const CRC16_TABLE: [u16; 256] = [
324 0x0000, 0x8005, 0x800F, 0x000A, 0x801B, 0x001E, 0x0014, 0x8011,
325 0x8033, 0x0036, 0x003C, 0x8039, 0x0028, 0x802D, 0x8027, 0x0022,
326 0x8063, 0x0066, 0x006C, 0x8069, 0x0078, 0x807D, 0x8077, 0x0072,
327 0x0050, 0x8055, 0x805F, 0x005A, 0x804B, 0x004E, 0x0044, 0x8041,
328 0x80C3, 0x00C6, 0x00CC, 0x80C9, 0x00D8, 0x80DD, 0x80D7, 0x00D2,
329 0x00F0, 0x80F5, 0x80FF, 0x00FA, 0x80EB, 0x00EE, 0x00E4, 0x80E1,
330 0x00A0, 0x80A5, 0x80AF, 0x00AA, 0x80BB, 0x00BE, 0x00B4, 0x80B1,
331 0x8093, 0x0096, 0x009C, 0x8099, 0x0088, 0x808D, 0x8087, 0x0082,
332 0x8183, 0x0186, 0x018C, 0x8189, 0x0198, 0x819D, 0x8197, 0x0192,
333 0x01B0, 0x81B5, 0x81BF, 0x01BA, 0x81AB, 0x01AE, 0x01A4, 0x81A1,
334 0x01E0, 0x81E5, 0x81EF, 0x01EA, 0x81FB, 0x01FE, 0x01F4, 0x81F1,
335 0x81D3, 0x01D6, 0x01DC, 0x81D9, 0x01C8, 0x81CD, 0x81C7, 0x01C2,
336 0x0140, 0x8145, 0x814F, 0x014A, 0x815B, 0x015E, 0x0154, 0x8151,
337 0x8173, 0x0176, 0x017C, 0x8179, 0x0168, 0x816D, 0x8167, 0x0162,
338 0x8123, 0x0126, 0x012C, 0x8129, 0x0138, 0x813D, 0x8137, 0x0132,
339 0x0110, 0x8115, 0x811F, 0x011A, 0x810B, 0x010E, 0x0104, 0x8101,
340 0x8303, 0x0306, 0x030C, 0x8309, 0x0318, 0x831D, 0x8317, 0x0312,
341 0x0330, 0x8335, 0x833F, 0x033A, 0x832B, 0x032E, 0x0324, 0x8321,
342 0x0360, 0x8365, 0x836F, 0x036A, 0x837B, 0x037E, 0x0374, 0x8371,
343 0x8353, 0x0356, 0x035C, 0x8359, 0x0348, 0x834D, 0x8347, 0x0342,
344 0x03C0, 0x83C5, 0x83CF, 0x03CA, 0x83DB, 0x03DE, 0x03D4, 0x83D1,
345 0x83F3, 0x03F6, 0x03FC, 0x83F9, 0x03E8, 0x83ED, 0x83E7, 0x03E2,
346 0x83A3, 0x03A6, 0x03AC, 0x83A9, 0x03B8, 0x83BD, 0x83B7, 0x03B2,
347 0x0390, 0x8395, 0x839F, 0x039A, 0x838B, 0x038E, 0x0384, 0x8381,
348 0x0280, 0x8285, 0x828F, 0x028A, 0x829B, 0x029E, 0x0294, 0x8291,
349 0x82B3, 0x02B6, 0x02BC, 0x82B9, 0x02A8, 0x82AD, 0x82A7, 0x02A2,
350 0x82E3, 0x02E6, 0x02EC, 0x82E9, 0x02F8, 0x82FD, 0x82F7, 0x02F2,
351 0x02D0, 0x82D5, 0x82DF, 0x02DA, 0x82CB, 0x02CE, 0x02C4, 0x82C1,
352 0x8243, 0x0246, 0x024C, 0x8249, 0x0258, 0x825D, 0x8257, 0x0252,
353 0x0270, 0x8275, 0x827F, 0x027A, 0x826B, 0x026E, 0x0264, 0x8261,
354 0x0220, 0x8225, 0x822F, 0x022A, 0x823B, 0x023E, 0x0234, 0x8231,
355 0x8213, 0x0216, 0x021C, 0x8219, 0x0208, 0x820D, 0x8207, 0x0202
356 ];