[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() {
        // sample: https://samples.mplayerhq.hu/A-codecs/lossless/luckynight.flac
        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
	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	}
	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,
	34	min_samples: 0,
	35	min_size: 0,
	36	max_size: 0,
	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 {
	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 => {
	92	validate!(idx < buf.len());
	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..])?);
	102
	103	validate!(idx < buf.len());
	104
	105	(blksamps, pts)
	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 });
	112	}
	113
	114	self.cur_samples += duration;
	115
	116	Ok((buf, pts, duration))
	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	}
	160	self.min_samples = min_bs;
	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	}
	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	}
	195	self.data_start = self.src.tell();
	196	validate!(srate != 0);
	197	self.srate = srate;
	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));
	202	strmgr.add_stream(NAStream::new(StreamType::Audio, 0, ainfo, base, srate, 0)).unwrap();
	203
	204	Ok(())
	205	}
	206	fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
	207	let (buf, pts, duration) = self.read_frame()?;
	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
	214	Ok(pkt)
	215	}
	216	fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> {
	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 {
	227	let samppos = NATimeInfo::time_to_ts(ms, 1000, 1, self.srate);
	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)
	262	}
	263	}
	264	fn get_duration(&self) -> u64 { self.tot_samples * 1000 / u64::from(self.srate) }
	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	// sample: https://samples.mplayerhq.hu/A-codecs/lossless/luckynight.flac
	290	let mut file = File::open("assets/LLaudio/luckynight.flac").unwrap();
	291	let mut fr = FileReader::new_read(&mut file);
	292	let mut br = ByteReader::new(&mut fr);
	293	let mut dmx = FLACDemuxer::new(&mut br);
	294	let mut sm = StreamManager::new();
	295	let mut si = SeekIndex::new();
	296	dmx.open(&mut sm, &mut si).unwrap();
	297	loop {
	298	let pktres = dmx.get_frame(&mut sm);
	299	if let Err(e) = pktres {
	300	if (e as i32) == (DemuxerError::EOF as i32) { break; }
	301	panic!("error");
	302	}
	303	let pkt = pktres.unwrap();
	304	println!("Got {}", pkt);
	305	}
	306	}
	307	}
	308
	309	const CRC16_TABLE: [u16; 256] = [
	310	0x0000, 0x8005, 0x800F, 0x000A, 0x801B, 0x001E, 0x0014, 0x8011,
	311	0x8033, 0x0036, 0x003C, 0x8039, 0x0028, 0x802D, 0x8027, 0x0022,
	312	0x8063, 0x0066, 0x006C, 0x8069, 0x0078, 0x807D, 0x8077, 0x0072,
	313	0x0050, 0x8055, 0x805F, 0x005A, 0x804B, 0x004E, 0x0044, 0x8041,
	314	0x80C3, 0x00C6, 0x00CC, 0x80C9, 0x00D8, 0x80DD, 0x80D7, 0x00D2,
	315	0x00F0, 0x80F5, 0x80FF, 0x00FA, 0x80EB, 0x00EE, 0x00E4, 0x80E1,
	316	0x00A0, 0x80A5, 0x80AF, 0x00AA, 0x80BB, 0x00BE, 0x00B4, 0x80B1,
	317	0x8093, 0x0096, 0x009C, 0x8099, 0x0088, 0x808D, 0x8087, 0x0082,
	318	0x8183, 0x0186, 0x018C, 0x8189, 0x0198, 0x819D, 0x8197, 0x0192,
	319	0x01B0, 0x81B5, 0x81BF, 0x01BA, 0x81AB, 0x01AE, 0x01A4, 0x81A1,
	320	0x01E0, 0x81E5, 0x81EF, 0x01EA, 0x81FB, 0x01FE, 0x01F4, 0x81F1,
	321	0x81D3, 0x01D6, 0x01DC, 0x81D9, 0x01C8, 0x81CD, 0x81C7, 0x01C2,
	322	0x0140, 0x8145, 0x814F, 0x014A, 0x815B, 0x015E, 0x0154, 0x8151,
	323	0x8173, 0x0176, 0x017C, 0x8179, 0x0168, 0x816D, 0x8167, 0x0162,
	324	0x8123, 0x0126, 0x012C, 0x8129, 0x0138, 0x813D, 0x8137, 0x0132,
	325	0x0110, 0x8115, 0x811F, 0x011A, 0x810B, 0x010E, 0x0104, 0x8101,
	326	0x8303, 0x0306, 0x030C, 0x8309, 0x0318, 0x831D, 0x8317, 0x0312,
	327	0x0330, 0x8335, 0x833F, 0x033A, 0x832B, 0x032E, 0x0324, 0x8321,
	328	0x0360, 0x8365, 0x836F, 0x036A, 0x837B, 0x037E, 0x0374, 0x8371,
	329	0x8353, 0x0356, 0x035C, 0x8359, 0x0348, 0x834D, 0x8347, 0x0342,
	330	0x03C0, 0x83C5, 0x83CF, 0x03CA, 0x83DB, 0x03DE, 0x03D4, 0x83D1,
	331	0x83F3, 0x03F6, 0x03FC, 0x83F9, 0x03E8, 0x83ED, 0x83E7, 0x03E2,
	332	0x83A3, 0x03A6, 0x03AC, 0x83A9, 0x03B8, 0x83BD, 0x83B7, 0x03B2,
	333	0x0390, 0x8395, 0x839F, 0x039A, 0x838B, 0x038E, 0x0384, 0x8381,
	334	0x0280, 0x8285, 0x828F, 0x028A, 0x829B, 0x029E, 0x0294, 0x8291,
	335	0x82B3, 0x02B6, 0x02BC, 0x82B9, 0x02A8, 0x82AD, 0x82A7, 0x02A2,
	336	0x82E3, 0x02E6, 0x02EC, 0x82E9, 0x02F8, 0x82FD, 0x82F7, 0x02F2,
	337	0x02D0, 0x82D5, 0x82DF, 0x02DA, 0x82CB, 0x02CE, 0x02C4, 0x82C1,
	338	0x8243, 0x0246, 0x024C, 0x8249, 0x0258, 0x825D, 0x8257, 0x0252,
	339	0x0270, 0x8275, 0x827F, 0x027A, 0x826B, 0x026E, 0x0264, 0x8261,
	340	0x0220, 0x8225, 0x822F, 0x022A, 0x823B, 0x023E, 0x0234, 0x8231,
	341	0x8213, 0x0216, 0x021C, 0x8219, 0x0208, 0x820D, 0x8207, 0x0202
	342	];