[nihav.git] / nihav-llaudio / src / demuxers / flac.rs

use nihav_core::frame::*;
use nihav_core::demuxers::*;

#[derive(Clone,Copy,Default)]
struct FrameSeekInfo {
    off:            u64,
    size:           u64,
    samplepos:      u64,
    sampleend:      u64,
}

struct FLACDemuxer<'a> {
    src:            &'a mut ByteReader<'a>,
    data_start:     u64,
    tot_samples:    u64,
    cur_samples:    u64,
    blk_samples:    u16,
    min_samples:    u16,
    min_size:       usize,
    max_size:       usize,
    srate:          u32,
    known_frames:   Vec<FrameSeekInfo>,
    build_index:    bool,
}

impl<'a> FLACDemuxer<'a> {
    fn new(io: &'a mut ByteReader<'a>) -> Self {
        Self {
            src:            io,
            data_start:     0,
            tot_samples:    0,
            cur_samples:    0,
            blk_samples:    0,
            min_samples:    0,
            min_size:       0,
            max_size:       0,
            srate:          0,
            known_frames:   Vec::new(),
            build_index:    false,
        }
    }
    fn read_frame(&mut self) -> DemuxerResult<(Vec<u8>, u64, u64)> {
        if self.src.is_eof() || (self.tot_samples != 0 && self.cur_samples == self.tot_samples) { return Err(DemuxerError::EOF); }
        let mut buf = Vec::with_capacity(self.min_size);
        let mut crc = 0;
        let frame_start = self.src.tell();
        for _ in 0..5 {
            let byte                    = self.src.read_byte()?;
            buf.push(byte);
            crc = update_crc16(crc, byte);
        }
        let mut ref_crc                 = self.src.read_u16be()?;
        loop {
            let byte                    = self.src.read_byte()?;
            let old_byte = (ref_crc >> 8) as u8;
            buf.push(old_byte);
            ref_crc = (ref_crc << 8) | u16::from(byte);
            crc = update_crc16(crc, old_byte);
            if buf.len() + 2 >= self.min_size && crc == ref_crc {
                let ret                 = self.src.peek_u16be();
                if ret.is_err() || ((ret.unwrap_or(0) & 0xFFFE) == 0xFFF8) {
                    buf.push((ref_crc >> 8) as u8);
                    buf.push(ref_crc as u8);
                    break;
                }
            }
            if (self.max_size > 0) && (buf.len() > self.max_size) {
                return Err(DemuxerError::InvalidData);
            }
            if buf.len() > (1 << 23) {
                return Err(DemuxerError::InvalidData);
            }
        }

        let (duration, pts) = if self.blk_samples != 0 {
                validate!((buf[1] & 1) == 0);
                let blkno = u64::from(read_utf8(&buf[4..])?);
                self.cur_samples = blkno * u64::from(self.blk_samples);
                (u64::from(self.blk_samples), blkno)
            } else {
                let mut idx = 5;
                while idx < buf.len() && (buf[idx] & 0x80) != 0 {
                    idx += 1;
                }

                let bsz_id = buf[2] >> 4;
                let blksamps = match bsz_id {
                        0 => return Err(DemuxerError::InvalidData),
                        1 => 192,
                        2..=5 => 576 << (bsz_id - 2),
                        6 => {
                            validate!(idx < buf.len());
                            u64::from(buf[idx]) + 1
                        },
                        7 => {
                            validate!(idx + 2 <= buf.len());
                            u64::from(buf[idx]) * 256 + u64::from(buf[idx + 1]) + 1
                        },
                        _ => 256 << (bsz_id - 8),
                    };
                let pts = u64::from(read_utf8(&buf[4..])?);

                validate!(idx < buf.len());

                (blksamps, pts)
            };

        let spos = if self.blk_samples != 0 { pts * u64::from(self.blk_samples) } else { pts };
        if self.build_index && (self.known_frames.is_empty() || self.known_frames.last().unwrap_or(&FrameSeekInfo::default()).samplepos < spos) {
            let sampleend = spos + duration;
            self.known_frames.push(FrameSeekInfo{off: frame_start, size: buf.len() as u64, samplepos: spos, sampleend });
        }

        self.cur_samples += duration;

        Ok((buf, pts, duration))
    }
}

fn update_crc16(crc: u16, byte: u8) -> u16 {
    (crc << 8) ^ CRC16_TABLE[(((crc >> 8) as u8) ^ byte) as usize]
}

fn read_utf8(src: &[u8]) -> DemuxerResult<u32> {
    if (src[0] & 0x80) == 0 {
        return Ok(u32::from(src[0]));
    }
    let len = (!src[0]).leading_zeros() as usize;
    validate!(len != 1 && len <= 5 && src.len() >= len);
    let mut val = u32::from(src[0] & 0x1F);
    for byte in src.iter().take(len).skip(1) {
        validate!((*byte & 0xC0) == 0x80);
        val = (val << 6) | u32::from(*byte & 0x3F);
    }
    Ok(val)
}

impl<'a> DemuxCore<'a> for FLACDemuxer<'a> {
    fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
        let tag                         = self.src.read_tag()?;
        validate!(&tag == b"fLaC");
        let mut streaminfo: Vec<u8> = Vec::new();
        let mut srate = 0u32;
        let mut channels = 0u8;
        loop {
            let id1                     = self.src.read_byte()?;
            let len                     = self.src.read_u24be()? as usize;
            let id = id1 & 0x7F;

            match id {
                0x00 => {
                    validate!(len >= 34);
                    streaminfo = vec![0u8; len];
                                          self.src.read_buf(&mut streaminfo)?;
                    let min_bs          = read_u16be(&streaminfo[0..])?;
                    let max_bs          = read_u16be(&streaminfo[2..])?;
                    if min_bs == max_bs {
                        self.blk_samples = max_bs;
                    }
                    self.min_samples = min_bs;
                    self.min_size       = read_u24be(&streaminfo[4..])? as usize;
                    self.max_size       = read_u24be(&streaminfo[7..])? as usize;
                    let word            = read_u24be(&streaminfo[10..])?;
                    srate = word >> 4;
                    channels = (((word >> 1) & 7) + 1) as u8;
                    self.tot_samples    = (u64::from(streaminfo[13] & 0xF) << 32) | u64::from(read_u32be(&streaminfo[14..])?);
                },
                0x03 => {
                    validate!((len % 18) == 0);
                    seek_index.mode = SeekIndexMode::Present;
                    for _ in 0..len / 18 {
                        let sample      = self.src.read_u64be()?;
                        let offset      = self.src.read_u64be()?;
                        let _nsamps     = self.src.read_u16be()?;
                        let time = sample * 1000 / u64::from(srate.max(1000));
                        seek_index.add_entry(0, SeekEntry { time, pts: sample, pos: offset });
                    }
                },
                _ =>                      self.src.read_skip(len)?,
            };

            if (id1 & 0x80) != 0 {
                break;
            }
        }
        if seek_index.mode != SeekIndexMode::Present {
            let min_size = if self.min_samples != 0 { self.min_samples } else { 2048 };
            let nframes = self.tot_samples as usize / (min_size as usize);
            self.known_frames = Vec::with_capacity(nframes.max(1));
            seek_index.mode = SeekIndexMode::Automatic;
            self.build_index = true;
        } else {
            self.build_index = false;
        }
        self.data_start = self.src.tell();
        validate!(srate != 0);
        self.srate = srate;

        let base = if self.blk_samples != 0 { u32::from(self.blk_samples) } else { 1 };
        let ahdr = NAAudioInfo::new(srate, channels as u8, SND_S16P_FORMAT, base as usize);
        let ainfo = NACodecInfo::new("flac", NACodecTypeInfo::Audio(ahdr), Some(streaminfo));
        strmgr.add_stream(NAStream::new(StreamType::Audio, 0, ainfo, base, srate, 0)).unwrap();

        Ok(())
    }
    fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
        let (buf, pts, duration) = self.read_frame()?;

        let stream = strmgr.get_stream(0).unwrap();
        let (tb_num, tb_den) = stream.get_timebase();
        let ts = NATimeInfo::new(Some(pts), None, Some(duration), tb_num, tb_den);
        let pkt = NAPacket::new(stream, ts, true, buf);

        Ok(pkt)
    }
    fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> {
        if seek_index.mode == SeekIndexMode::Present {
            let ret = seek_index.find_pos(time);
            if ret.is_none() {
                return Err(DemuxerError::SeekError);
            }
            let seek_info = ret.unwrap();
            self.cur_samples = seek_info.pts;
            self.src.seek(SeekFrom::Start(self.data_start + seek_info.pos))?;
            Ok(())
        } else if let NATimePoint::Milliseconds(ms) = time {
            let samppos = NATimeInfo::time_to_ts(ms, 1000, 1, self.srate);
            if self.known_frames.last().unwrap_or(&FrameSeekInfo::default()).sampleend >= samppos {
                for point in self.known_frames.iter().rev() {
                    if point.samplepos <= samppos {
                        self.src.seek(SeekFrom::Start(point.off))?;
                        self.cur_samples = point.samplepos;
                        return Ok(());
                    }
                }
            } else {
                let startinfo = FrameSeekInfo { off: self.data_start, size: 0, samplepos: 0, sampleend: 0 };
                let lentry = self.known_frames.last().unwrap_or(&startinfo);

                self.src.seek(SeekFrom::Start(lentry.off + lentry.size))?;
                self.cur_samples = lentry.sampleend;
                loop {
                    let frame_start = self.src.tell();
                    let ret = self.read_frame();
                    if ret.is_err() {
                        return Err(DemuxerError::SeekError);
                    }
                    let (_, pts, duration) = ret.unwrap();
                    self.cur_samples = pts;
                    if self.blk_samples != 0 {
                        self.cur_samples *= u64::from(self.blk_samples);
                    }
                    if self.cur_samples <= samppos && self.cur_samples + duration >= samppos {
                        self.src.seek(SeekFrom::Start(frame_start))?;
                        return Ok(());
                    }
                }
            }
            Err(DemuxerError::SeekError)
        } else {
            Err(DemuxerError::NotPossible)
        }
    }
    fn get_duration(&self) -> u64 { self.tot_samples * 1000 / u64::from(self.srate) }
}

impl<'a> NAOptionHandler for FLACDemuxer<'a> {
    fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
    fn set_options(&mut self, _options: &[NAOption]) { }
    fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
}

pub struct FLACDemuxerCreator { }

impl DemuxerCreator for FLACDemuxerCreator {
    fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
        Box::new(FLACDemuxer::new(br))
    }
    fn get_name(&self) -> &'static str { "flac" }
}

#[cfg(test)]
mod test {
    use super::*;
    use std::fs::File;

    #[test]
    fn test_flac_demux() {
        let mut file = File::open("assets/LLaudio/luckynight.flac").unwrap();
        let mut fr = FileReader::new_read(&mut file);
        let mut br = ByteReader::new(&mut fr);
        let mut dmx = FLACDemuxer::new(&mut br);
        let mut sm = StreamManager::new();
        let mut si = SeekIndex::new();
        dmx.open(&mut sm, &mut si).unwrap();
        loop {
            let pktres = dmx.get_frame(&mut sm);
            if let Err(e) = pktres {
                if (e as i32) == (DemuxerError::EOF as i32) { break; }
                panic!("error");
            }
            let pkt = pktres.unwrap();
            println!("Got {}", pkt);
        }
    }
}

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