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

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

const SAMPLE_RATES: [u32; 15] = [
     6000,  8000,  9600, 11025, 12000, 16000,  22050, 24000,
    32000, 44100, 48000, 64000, 88200, 96000, 192000
];
const WV_FLAG_MONO: u32         = 1 <<  2;
//const WV_FLAG_HYBRID: u32       = 1 <<  3;
//const WV_FLAG_JSTEREO: u32      = 1 <<  4;
//const WV_FLAG_CH_DECORR: u32    = 1 <<  5;
//const WV_FLAG_HYB_NOISE_SHAPING: u32 = 1 <<  6;
const WV_FLAG_FLOATS: u32       = 1 <<  7;
//const WV_FLAG_EXT_INTEGERS: u32 = 1 <<  8;
//const WV_FLAG_HYB_BITRATE: u32  = 1 <<  9;
//const WV_FLAG_HYB_BALANCED_NOISE: u32 = 1 << 10;
const WV_FLAG_START_BLOCK: u32  = 1 << 11;
const WV_FLAG_END_BLOCK: u32    = 1 << 12;
//const WV_FLAG_HAS_CRC: u32      = 1 << 28;
const WV_FLAG_FALSE_STEREO: u32 = 1 << 30;
//const WV_FLAG_DSD_AUDIO: u32    = 1 << 31;

const WV_STREAM_FLAGS: u32 = 0x8000008B;

#[derive(Clone,Copy,Default)]
struct WVHeader {
    size:           usize,
    ver:            u16,
    tot_samples:    u64,
    block_index:    u64,
    block_samples:  u32,
    flags:          u32,
    crc:            u32,
}

const WV_HEADER_SIZE: usize = 32;

impl WVHeader {
    #[allow(clippy::field_reassign_with_default)]
    fn parse(src: &[u8]) -> DemuxerResult<Self> {
        let mut mr = MemoryReader::new_read(src);
        let mut br = ByteReader::new(&mut mr);
        let tag                         = br.read_tag()?;
        validate!(&tag == b"wvpk");
        let mut hdr = Self::default();
        hdr.size                        = br.read_u32le()? as usize;
        validate!(hdr.size >= 24);
        hdr.ver                         = br.read_u16le()?;
        validate!(hdr.ver >= 0x402 || hdr.ver <= 0x410);
        let top_idx                     = br.read_byte()?;
        let top_samps                   = br.read_byte()?;
        hdr.tot_samples                 = u64::from(br.read_u32le()?) | (u64::from(top_samps) << 32);
        hdr.block_index                 = u64::from(br.read_u32le()?) | (u64::from(top_idx) << 32);
        hdr.block_samples               = br.read_u32le()?;
        hdr.flags                       = br.read_u32le()?;
        hdr.crc                         = br.read_u32le()?;
        Ok(hdr)
    }
    fn stream_eq(&self, rval: &Self) -> bool {
        self.ver == rval.ver &&
        (self.flags & WV_STREAM_FLAGS) == (rval.flags & WV_STREAM_FLAGS)
    }
    fn block_eq(&self, rval: &Self) -> bool {
        self.stream_eq(rval) && self.tot_samples == rval.tot_samples &&
        self.block_index == rval.block_index &&
        self.block_samples == rval.block_samples
    }
    fn is_start_block(&self) -> bool {
        (self.flags & WV_FLAG_START_BLOCK) != 0
    }
    fn is_end_block(&self) -> bool {
        (self.flags & WV_FLAG_END_BLOCK) != 0
    }
    fn get_num_channels(&self) -> u8 {
        if (self.flags & WV_FLAG_MONO) != 0 && (self.flags & WV_FLAG_FALSE_STEREO) == 0 { 1 } else { 2 }
    }
    fn get_sample_rate(&self) -> u32 {
        let idx = ((self.flags >> 23) & 0xF) as usize;
        if idx != 15 {
            SAMPLE_RATES[idx]
        } else {
            0
        }
    }
    fn get_size(&self) -> usize {
        self.size - (WV_HEADER_SIZE - 8)
    }
}

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

struct WavPackDemuxer<'a> {
    src:            &'a mut ByteReader<'a>,
    samplepos:      u64,
    nsamples:       u64,
    first_blocks:   Option<(WVHeader, Vec<u8>)>,
    srate:          u32,
    known_frames:   Vec<FrameSeekInfo>,
}

impl<'a> WavPackDemuxer<'a> {
    fn new(io: &'a mut ByteReader<'a>) -> Self {
        Self {
            src:            io,
            samplepos:      0,
            nsamples:       0,
            first_blocks:   None,
            srate:          0,
            known_frames:   Vec::new(),
        }
    }
    fn read_blocks(&mut self) -> DemuxerResult<(WVHeader, Vec<u8>)> {
        let mut hdrbuf = [0u8; WV_HEADER_SIZE];
        let mut buf: Vec<u8> = Vec::new();
        let mut first = true;
        let mut refhdr = WVHeader::default();
        loop {
                                        self.src.read_buf(&mut hdrbuf)?;
            let hdr = WVHeader::parse(&hdrbuf)?;
            if first {
                validate!(hdr.is_start_block());
                refhdr = hdr;
                first = false;
            } else {
                validate!(refhdr.block_eq(&hdr));
            }
            buf.extend_from_slice(&hdrbuf);
            let pos = buf.len();
            buf.resize(pos + hdr.get_size(), 0);
                                        self.src.read_buf(&mut buf[pos..])?;

            if hdr.is_end_block() {
                break;
            }
        }
        Ok((refhdr, buf))
    }
}

impl<'a> DemuxCore<'a> for WavPackDemuxer<'a> {
    fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {

        let (hdr, buf) = self.read_blocks()?;

        let srate = hdr.get_sample_rate();
        validate!(srate != 0);
        let channels = if !hdr.is_end_block() {
                let mut ch_count = 0;
                let mut off = 0;
                loop {
                    let hdr = WVHeader::parse(&buf[off..]).unwrap();
                    off += WV_HEADER_SIZE + hdr.get_size();
                    ch_count += hdr.get_num_channels();
                    if hdr.is_end_block() {
                        break;
                    }
                }
                ch_count
            } else {
                hdr.get_num_channels()
            };

        self.nsamples = hdr.tot_samples;

        let mut fmt = SND_S16P_FORMAT;
        if (hdr.flags & WV_FLAG_FLOATS) != 0 {
            fmt.float = true;
        } else {
            fmt.bits = (((hdr.flags & 3) + 1) * 8) as u8;
        }

        let ahdr = NAAudioInfo::new(srate, channels, SND_S16P_FORMAT, 1);
        let ainfo = NACodecInfo::new("wavpack", NACodecTypeInfo::Audio(ahdr), Some(buf.clone()));
        strmgr.add_stream(NAStream::new(StreamType::Audio, 0, ainfo, 1, srate, hdr.tot_samples)).unwrap();
        seek_index.mode = SeekIndexMode::Automatic;
        self.srate = srate;
        self.known_frames = Vec::with_capacity(((self.nsamples + u64::from(srate) - 1) / u64::from(srate)) as usize);
        self.known_frames.push(FrameSeekInfo { off: 0, samplepos: hdr.block_index });

        self.first_blocks = Some((hdr, buf));
        Ok(())
    }
    fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
        if self.first_blocks.is_some() {
            let mut fb = None;
            std::mem::swap(&mut fb, &mut self.first_blocks);
            let (refhdr, buf) = fb.unwrap();
            let stream = strmgr.get_stream(0).unwrap();
            let ts = stream.make_ts(Some(self.samplepos), None, None);
            let pkt = NAPacket::new(stream, ts, true, buf);

            self.samplepos += u64::from(refhdr.block_samples);

            return Ok(pkt);
        }
        if self.samplepos == self.nsamples {
            return Err(DemuxerError::EOF);
        }
        let cur_off = self.src.tell();
        let cur_spos = self.samplepos;
        let (refhdr, buf) = self.read_blocks()?;

        let stream = strmgr.get_stream(0).unwrap();
        let ts = stream.make_ts(Some(self.samplepos), None, None);
        let pkt = NAPacket::new(stream, ts, true, buf);

        self.samplepos += u64::from(refhdr.block_samples);
        if self.known_frames.last().unwrap_or(&FrameSeekInfo::default()).samplepos < cur_spos {
            self.known_frames.push(FrameSeekInfo{off: cur_off, samplepos: cur_spos });
        }

        Ok(pkt)
    }
    fn seek(&mut self, time: NATimePoint, _seek_index: &SeekIndex) -> DemuxerResult<()> {
        self.first_blocks = None;
        if let NATimePoint::Milliseconds(ms) = time {
            let samppos = ms * u64::from(self.srate) / 1000;
            if self.known_frames.last().unwrap_or(&FrameSeekInfo::default()).samplepos >= samppos {
                for point in self.known_frames.iter().rev() {
                    if point.samplepos <= samppos {
                        self.src.seek(SeekFrom::Start(point.off))?;
                        self.samplepos = point.samplepos;
                        return Ok(());
                    }
                }
            } else {
                let mut hdrbuf = [0u8; WV_HEADER_SIZE];
                let lastoff = self.known_frames.last().unwrap_or(&FrameSeekInfo::default()).off;
                self.src.seek(SeekFrom::Start(lastoff))?;
                loop {
                                          self.src.peek_buf(&mut hdrbuf)?;
                    let hdr = WVHeader::parse(&hdrbuf)?;
                    if hdr.is_start_block() {
                        self.known_frames.push(FrameSeekInfo{off: self.src.tell(), samplepos: hdr.block_index });
                        if hdr.block_index <= samppos && hdr.block_index + u64::from(hdr.block_samples) > samppos {
                            self.samplepos = hdr.block_index;
                            return Ok(());
                        }
                        if hdr.block_index > samppos {
                            break;
                        }
                    }
                                          self.src.read_skip(WV_HEADER_SIZE + hdr.get_size())?
                }
            }
            Err(DemuxerError::SeekError)
        } else {
            Err(DemuxerError::NotPossible)
        }
    }
    fn get_duration(&self) -> u64 { 0 }
}

impl<'a> NAOptionHandler for WavPackDemuxer<'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 WavPackDemuxerCreator { }

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

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

    #[test]
    fn test_wavpack_demux() {
        // sample from the official WavPack test samples set
        let mut file = File::open("assets/LLaudio/wv/false_stereo.wv").unwrap();
        let mut fr = FileReader::new_read(&mut file);
        let mut br = ByteReader::new(&mut fr);
        let mut dmx = WavPackDemuxer::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);
        }
    }
}
Commit	Line	Data
87927c57 KS	1	use nihav_core::frame::*;
	2	use nihav_core::demuxers::*;
	3
	4	const SAMPLE_RATES: [u32; 15] = [
	5	6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000,
	6	32000, 44100, 48000, 64000, 88200, 96000, 192000
	7	];
	8	const WV_FLAG_MONO: u32 = 1 << 2;
	9	//const WV_FLAG_HYBRID: u32 = 1 << 3;
	10	//const WV_FLAG_JSTEREO: u32 = 1 << 4;
	11	//const WV_FLAG_CH_DECORR: u32 = 1 << 5;
	12	//const WV_FLAG_HYB_NOISE_SHAPING: u32 = 1 << 6;
	13	const WV_FLAG_FLOATS: u32 = 1 << 7;
	14	//const WV_FLAG_EXT_INTEGERS: u32 = 1 << 8;
	15	//const WV_FLAG_HYB_BITRATE: u32 = 1 << 9;
	16	//const WV_FLAG_HYB_BALANCED_NOISE: u32 = 1 << 10;
	17	const WV_FLAG_START_BLOCK: u32 = 1 << 11;
	18	const WV_FLAG_END_BLOCK: u32 = 1 << 12;
	19	//const WV_FLAG_HAS_CRC: u32 = 1 << 28;
	20	const WV_FLAG_FALSE_STEREO: u32 = 1 << 30;
	21	//const WV_FLAG_DSD_AUDIO: u32 = 1 << 31;
	22
95221ccc	23	const WV_STREAM_FLAGS: u32 = 0x8000008B;
87927c57 KS	24
	25	#[derive(Clone,Copy,Default)]
	26	struct WVHeader {
	27	size: usize,
	28	ver: u16,
	29	tot_samples: u64,
	30	block_index: u64,
	31	block_samples: u32,
	32	flags: u32,
	33	crc: u32,
	34	}
	35
	36	const WV_HEADER_SIZE: usize = 32;
	37
	38	impl WVHeader {
e6aaad5c	39	#[allow(clippy::field_reassign_with_default)]
87927c57 KS	40	fn parse(src: &[u8]) -> DemuxerResult<Self> {
	41	let mut mr = MemoryReader::new_read(src);
	42	let mut br = ByteReader::new(&mut mr);
	43	let tag = br.read_tag()?;
	44	validate!(&tag == b"wvpk");
	45	let mut hdr = Self::default();
	46	hdr.size = br.read_u32le()? as usize;
	47	validate!(hdr.size >= 24);
	48	hdr.ver = br.read_u16le()?;
	49	validate!(hdr.ver >= 0x402 \|\| hdr.ver <= 0x410);
	50	let top_idx = br.read_byte()?;
	51	let top_samps = br.read_byte()?;
	52	hdr.tot_samples = u64::from(br.read_u32le()?) \| (u64::from(top_samps) << 32);
	53	hdr.block_index = u64::from(br.read_u32le()?) \| (u64::from(top_idx) << 32);
	54	hdr.block_samples = br.read_u32le()?;
	55	hdr.flags = br.read_u32le()?;
	56	hdr.crc = br.read_u32le()?;
	57	Ok(hdr)
	58	}
	59	fn stream_eq(&self, rval: &Self) -> bool {
	60	self.ver == rval.ver &&
	61	(self.flags & WV_STREAM_FLAGS) == (rval.flags & WV_STREAM_FLAGS)
	62	}
	63	fn block_eq(&self, rval: &Self) -> bool {
	64	self.stream_eq(rval) && self.tot_samples == rval.tot_samples &&
	65	self.block_index == rval.block_index &&
	66	self.block_samples == rval.block_samples
	67	}
	68	fn is_start_block(&self) -> bool {
	69	(self.flags & WV_FLAG_START_BLOCK) != 0
	70	}
	71	fn is_end_block(&self) -> bool {
	72	(self.flags & WV_FLAG_END_BLOCK) != 0
	73	}
	74	fn get_num_channels(&self) -> u8 {
	75	if (self.flags & WV_FLAG_MONO) != 0 && (self.flags & WV_FLAG_FALSE_STEREO) == 0 { 1 } else { 2 }
	76	}
	77	fn get_sample_rate(&self) -> u32 {
	78	let idx = ((self.flags >> 23) & 0xF) as usize;
	79	if idx != 15 {
	80	SAMPLE_RATES[idx]
	81	} else {
	82	0
	83	}
	84	}
	85	fn get_size(&self) -> usize {
	86	self.size - (WV_HEADER_SIZE - 8)
	87	}
	88	}
	89
	90	#[derive(Clone,Copy,Default)]
	91	struct FrameSeekInfo {
	92	off: u64,
	93	samplepos: u64,
	94	}
	95
	96	struct WavPackDemuxer<'a> {
	97	src: &'a mut ByteReader<'a>,
	98	samplepos: u64,
	99	nsamples: u64,
	100	first_blocks: Option<(WVHeader, Vec<u8>)>,
	101	srate: u32,
	102	known_frames: Vec<FrameSeekInfo>,
	103	}
104
105	impl<'a> WavPackDemuxer<'a> {
106	fn new(io: &'a mut ByteReader<'a>) -> Self {
107	Self {
108	src: io,
109	samplepos: 0,
110	nsamples: 0,
111	first_blocks: None,
112	srate: 0,
113	known_frames: Vec::new(),
114	}
115	}
116	fn read_blocks(&mut self) -> DemuxerResult<(WVHeader, Vec<u8>)> {
117	let mut hdrbuf = [0u8; WV_HEADER_SIZE];
118	let mut buf: Vec<u8> = Vec::new();
119	let mut first = true;
120	let mut refhdr = WVHeader::default();
121	loop {
122	self.src.read_buf(&mut hdrbuf)?;
123	let hdr = WVHeader::parse(&hdrbuf)?;
124	if first {
125	validate!(hdr.is_start_block());
126	refhdr = hdr;
127	first = false;
128	} else {
129	validate!(refhdr.block_eq(&hdr));
130	}
131	buf.extend_from_slice(&hdrbuf);
132	let pos = buf.len();
133	buf.resize(pos + hdr.get_size(), 0);
134	self.src.read_buf(&mut buf[pos..])?;
135
136	if hdr.is_end_block() {
137	break;
138	}
139	}
140	Ok((refhdr, buf))
141	}
142	}
143
144	impl<'a> DemuxCore<'a> for WavPackDemuxer<'a> {
145	fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
146
147	let (hdr, buf) = self.read_blocks()?;
148
149	let srate = hdr.get_sample_rate();
150	validate!(srate != 0);
151	let channels = if !hdr.is_end_block() {
152	let mut ch_count = 0;
153	let mut off = 0;
154	loop {
155	let hdr = WVHeader::parse(&buf[off..]).unwrap();
156	off += WV_HEADER_SIZE + hdr.get_size();
157	ch_count += hdr.get_num_channels();
158	if hdr.is_end_block() {
159	break;
160	}
161	}
162	ch_count
163	} else {
164	hdr.get_num_channels()
165	};
166
167	self.nsamples = hdr.tot_samples;
168
169	let mut fmt = SND_S16P_FORMAT;
170	if (hdr.flags & WV_FLAG_FLOATS) != 0 {
171	fmt.float = true;
172	} else {
173	fmt.bits = (((hdr.flags & 3) + 1) * 8) as u8;
174	}
175
176	let ahdr = NAAudioInfo::new(srate, channels, SND_S16P_FORMAT, 1);
177	let ainfo = NACodecInfo::new("wavpack", NACodecTypeInfo::Audio(ahdr), Some(buf.clone()));
a480a0de	178	strmgr.add_stream(NAStream::new(StreamType::Audio, 0, ainfo, 1, srate, hdr.tot_samples)).unwrap();
87927c57 KS	179	seek_index.mode = SeekIndexMode::Automatic;
	180	self.srate = srate;
	181	self.known_frames = Vec::with_capacity(((self.nsamples + u64::from(srate) - 1) / u64::from(srate)) as usize);
	182	self.known_frames.push(FrameSeekInfo { off: 0, samplepos: hdr.block_index });
	183
	184	self.first_blocks = Some((hdr, buf));
	185	Ok(())
	186	}
	187	fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
	188	if self.first_blocks.is_some() {
	189	let mut fb = None;
	190	std::mem::swap(&mut fb, &mut self.first_blocks);
	191	let (refhdr, buf) = fb.unwrap();
	192	let stream = strmgr.get_stream(0).unwrap();
8e14efb0	193	let ts = stream.make_ts(Some(self.samplepos), None, None);
87927c57 KS	194	let pkt = NAPacket::new(stream, ts, true, buf);
	195
	196	self.samplepos += u64::from(refhdr.block_samples);
	197
	198	return Ok(pkt);
	199	}
	200	if self.samplepos == self.nsamples {
	201	return Err(DemuxerError::EOF);
	202	}
	203	let cur_off = self.src.tell();
	204	let cur_spos = self.samplepos;
	205	let (refhdr, buf) = self.read_blocks()?;
	206
	207	let stream = strmgr.get_stream(0).unwrap();
8e14efb0	208	let ts = stream.make_ts(Some(self.samplepos), None, None);
87927c57 KS	209	let pkt = NAPacket::new(stream, ts, true, buf);
	210
	211	self.samplepos += u64::from(refhdr.block_samples);
	212	if self.known_frames.last().unwrap_or(&FrameSeekInfo::default()).samplepos < cur_spos {
	213	self.known_frames.push(FrameSeekInfo{off: cur_off, samplepos: cur_spos });
	214	}
	215
	216	Ok(pkt)
	217	}
	218	fn seek(&mut self, time: NATimePoint, _seek_index: &SeekIndex) -> DemuxerResult<()> {
	219	self.first_blocks = None;
	220	if let NATimePoint::Milliseconds(ms) = time {
	221	let samppos = ms * u64::from(self.srate) / 1000;
	222	if self.known_frames.last().unwrap_or(&FrameSeekInfo::default()).samplepos >= samppos {
	223	for point in self.known_frames.iter().rev() {
	224	if point.samplepos <= samppos {
	225	self.src.seek(SeekFrom::Start(point.off))?;
	226	self.samplepos = point.samplepos;
	227	return Ok(());
	228	}
	229	}
	230	} else {
	231	let mut hdrbuf = [0u8; WV_HEADER_SIZE];
7d6bb2e8 KS	232	let lastoff = self.known_frames.last().unwrap_or(&FrameSeekInfo::default()).off;
7d6bb2e8 KS	233	self.src.seek(SeekFrom::Start(lastoff))?;
87927c57 KS	234	loop {
	235	self.src.peek_buf(&mut hdrbuf)?;
	236	let hdr = WVHeader::parse(&hdrbuf)?;
	237	if hdr.is_start_block() {
	238	self.known_frames.push(FrameSeekInfo{off: self.src.tell(), samplepos: hdr.block_index });
	239	if hdr.block_index <= samppos && hdr.block_index + u64::from(hdr.block_samples) > samppos {
	240	self.samplepos = hdr.block_index;
	241	return Ok(());
	242	}
	243	if hdr.block_index > samppos {
	244	break;
	245	}
	246	}
	247	self.src.read_skip(WV_HEADER_SIZE + hdr.get_size())?
	248	}
	249	}
	250	Err(DemuxerError::SeekError)
	251	} else {
	252	Err(DemuxerError::NotPossible)
	253	}
	254	}
a480a0de	255	fn get_duration(&self) -> u64 { 0 }
87927c57 KS	256	}
	257
	258	impl<'a> NAOptionHandler for WavPackDemuxer<'a> {
	259	fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
	260	fn set_options(&mut self, _options: &[NAOption]) { }
	261	fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
	262	}
	263
	264
	265	pub struct WavPackDemuxerCreator { }
	266
	267	impl DemuxerCreator for WavPackDemuxerCreator {
	268	fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
	269	Box::new(WavPackDemuxer::new(br))
	270	}
	271	fn get_name(&self) -> &'static str { "wavpack" }
	272	}
	273
	274	#[cfg(test)]
	275	mod test {
	276	use super::*;
	277	use std::fs::File;
	278
	279	#[test]
	280	fn test_wavpack_demux() {
886cde48	281	// sample from the official WavPack test samples set
87927c57 KS	282	let mut file = File::open("assets/LLaudio/wv/false_stereo.wv").unwrap();
	283	let mut fr = FileReader::new_read(&mut file);
	284	let mut br = ByteReader::new(&mut fr);
	285	let mut dmx = WavPackDemuxer::new(&mut br);
	286	let mut sm = StreamManager::new();
	287	let mut si = SeekIndex::new();
	288	dmx.open(&mut sm, &mut si).unwrap();
	289	loop {
	290	let pktres = dmx.get_frame(&mut sm);
	291	if let Err(e) = pktres {
	292	if (e as i32) == (DemuxerError::EOF as i32) { break; }
	293	panic!("error");
	294	}
	295	let pkt = pktres.unwrap();
	296	println!("Got {}", pkt);
	297	}
	298	}
	299	}