3 use super::DemuxerError::*;
9 ($a:expr, $b:expr, $c:expr, $d:expr) => ({
10 (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
13 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
20 strm_type: Option<StreamType>,
25 StreamState { strm_no: 0, got_strf: true, strm_type: None }
28 self.strm_type = None;
32 fn valid_state(&self) -> bool {
33 match self.strm_type {
34 None => self.got_strf,
41 struct AVIDemuxer<'a> {
43 src: &'a mut ByteReader<'a>,
54 #[derive(Debug,Clone,Copy,PartialEq)]
62 parse: fn(&mut AVIDemuxer, size: usize) -> DemuxerResult<usize>,
65 impl<'a> Demux<'a> for AVIDemuxer<'a> {
66 #[allow(unused_variables)]
67 fn open(&mut self) -> DemuxerResult<()> {
73 fn get_num_streams(&self) -> usize { self.dmx.get_num_streams() }
74 fn get_stream(&self, idx: usize) -> Option<Rc<NAStream>> { self.dmx.get_stream(idx) }
76 fn get_frame(&mut self) -> DemuxerResult<NAPacket> {
77 if !self.opened { return Err(NoSuchInput); }
78 if self.movi_size == 0 { return Err(EOF); }
79 let mut tag: [u8; 4] = [0; 4];
81 if (self.src.tell() & 1) == 1 {
82 self.src.read_skip(1)?;
84 if self.movi_size == 0 { return Err(EOF); }
86 self.src.read_buf(&mut tag)?;
87 let size = self.src.read_u32le()? as usize;
88 if mktag!(tag) == mktag!(b"JUNK") {
89 self.movi_size -= size + 8;
90 self.src.read_skip(size)?;
91 if self.movi_size == 0 { return Err(EOF); }
94 if mktag!(tag) == mktag!(b"LIST") {
96 self.src.read_skip(4)?;
97 if self.movi_size == 0 { return Err(EOF); }
100 if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
101 return Err(InvalidData);
103 let stream_no = (tag[0] - b'0') * 10 + (tag[1] - b'0');
104 let str = self.dmx.get_stream(stream_no as usize);
105 if let None = str { return Err(InvalidData); }
106 let stream = str.unwrap();
109 if self.movi_size == 0 { return Err(EOF); }
112 let (tb_num, tb_den) = stream.get_timebase();
113 let ts = NATimeInfo::new(Some(self.cur_frame[stream_no as usize]), None, None, tb_num, tb_den);
114 let pkt = self.src.read_packet(stream, ts, false, size)?;
115 self.cur_frame[stream_no as usize] += 1;
116 self.movi_size -= size + 8;
122 #[allow(unused_variables)]
123 fn seek(&mut self, time: u64) -> DemuxerResult<()> {
124 if !self.opened { return Err(NoSuchInput); }
129 impl<'a> AVIDemuxer<'a> {
130 fn new(io: &'a mut ByteReader<'a>) -> Self {
132 cur_frame: Vec::new(),
138 sstate: StreamState::new(),
145 fn parse_chunk(&mut self, end_tag: RIFFTag, csize: usize, depth: u16) -> DemuxerResult<(usize, bool)> {
146 if csize < 8 { return Err(InvalidData); }
147 if depth > 42 { return Err(InvalidData); }
149 let tag = self.src.read_u32be()?;
150 let size = self.src.read_u32le()? as usize;
151 if size > csize { return Err(InvalidData); }
152 if RIFFTag::Chunk(tag) == end_tag {
153 return Ok((size, true));
155 let is_list = is_list_tag(tag);
156 let ltag = if is_list { self.src.read_u32be()? } else { 0 };
157 if RIFFTag::List(tag, ltag) == end_tag {
158 return Ok((size, true));
161 for i in 0..CHUNKS.len() {
162 if RIFFTag::Chunk(tag) == CHUNKS[i].tag {
163 let psize = (CHUNKS[i].parse)(self, size)?;
164 if psize != size { return Err(InvalidData); }
165 if (psize & 1) == 1 { self.src.read_skip(1)?; }
166 return Ok((size + 8, false));
168 if RIFFTag::List(tag, ltag) == CHUNKS[i].tag {
169 let mut rest_size = size - 4;
170 let psize = (CHUNKS[i].parse)(self, rest_size)?;
171 if psize > rest_size { return Err(InvalidData); }
173 while rest_size > 0 {
174 let (psize, _) = self.parse_chunk(end_tag, rest_size, depth+1)?;
175 if psize > rest_size { return Err(InvalidData); }
177 if (psize & 1) == 1 {
184 return Ok((size + 8, false));
188 self.src.read_skip(size)?;
190 if size < 4 { return Err(InvalidData); }
191 self.src.read_skip(size - 4)?;
193 if (size & 1) == 1 { self.src.read_skip(1)?; }
194 return Ok((size + 8, false));
197 fn read_header(&mut self) -> DemuxerResult<()> {
198 let riff_tag = self.src.read_u32be()?;
199 let size = self.src.read_u32le()? as usize;
200 let avi_tag = self.src.read_u32be()?;
201 if riff_tag != mktag!(b"RIFF") || avi_tag != mktag!(b"AVI ") {
202 return Err(InvalidData);
205 let mut rest_size = size;
207 let (csz, end) = self.parse_chunk(RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?;
208 if end { self.movi_size = csz - 4; break; }
211 if !self.sstate.valid_state() || self.sstate.strm_no != self.num_streams {
212 return Err(InvalidData);
217 fn read_extradata(&mut self, size: usize) -> DemuxerResult<Option<Vec<u8>>> {
218 if size == 0 { return Ok(None); }
219 let mut edvec: Vec<u8> = Vec::with_capacity(size);
220 edvec.resize(size, 0);
221 self.src.read_buf(&mut edvec)?;
226 const CHUNKS: [RIFFParser; 6] = [
227 RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"hdrl")), parse: parse_hdrl },
228 RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"strl")), parse: parse_strl },
229 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"avih")), parse: parse_avih },
230 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strf")), parse: parse_strf },
231 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strh")), parse: parse_strh },
232 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"JUNK")), parse: parse_junk },
235 fn is_list_tag(tag: u32) -> bool {
236 for i in 0..CHUNKS.len() {
237 if let RIFFTag::List(ltag, _) = CHUNKS[i].tag {
246 #[allow(unused_variables)]
247 fn parse_hdrl(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
251 #[allow(unused_variables)]
252 fn parse_strl(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
256 #[allow(unused_variables)]
257 fn parse_strh(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
258 if size < 0x38 { return Err(InvalidData); }
259 let tag = dmx.src.read_u32be()?; //stream type
260 let fcc = dmx.src.read_u32be()?; //handler(fourcc)
261 dmx.src.read_u32le()?; //flags
262 dmx.src.read_skip(2)?; //priority
263 dmx.src.read_skip(2)?; //language
264 dmx.src.read_skip(4)?; //initial frames
265 dmx.tb_num = dmx.src.read_u32le()?; //scale
266 dmx.tb_den = dmx.src.read_u32le()?; //rate
267 dmx.src.read_skip(4)?; //start
268 dmx.src.read_skip(4)?; //length
269 dmx.src.read_skip(4)?; //buf size
270 dmx.src.read_skip(4)?; //quality
271 dmx.src.read_skip(4)?; //sample size
272 let a = dmx.src.read_u16le()?;
273 let b = dmx.src.read_u16le()?;
274 let c = dmx.src.read_u16le()?;
275 let d = dmx.src.read_u16le()?;
277 dmx.src.read_skip(size - 0x38)?;
279 if !dmx.sstate.valid_state() || dmx.sstate.strm_no >= dmx.num_streams {
280 return Err(InvalidData);
282 if tag == mktag!(b"vids") {
283 dmx.sstate.strm_type = Some(StreamType::Video);
284 } else if tag == mktag!(b"auds") {
285 dmx.sstate.strm_type = Some(StreamType::Audio);
287 dmx.sstate.strm_type = Some(StreamType::Data);
289 dmx.sstate.got_strf = false;
294 fn parse_strf(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
295 if let None = dmx.sstate.strm_type { return Err(InvalidData); }
296 match dmx.sstate.strm_type.unwrap() {
297 StreamType::Video => parse_strf_vids(dmx, size),
298 StreamType::Audio => parse_strf_auds(dmx, size),
299 _ => parse_strf_xxxx(dmx, size),
303 #[allow(unused_variables)]
304 fn parse_strf_vids(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
305 if size < 40 { return Err(InvalidData); }
306 let bi_size = dmx.src.read_u32le()?;
307 if (bi_size as usize) > size { return Err(InvalidData); }
308 let width = dmx.src.read_u32le()?;
309 let height = dmx.src.read_u32le()? as i32;
310 let planes = dmx.src.read_u16le()?;
311 let bitcount = dmx.src.read_u16le()?;
312 let mut compression: [u8; 4] = [0; 4];
313 dmx.src.read_buf(&mut compression)?;
314 let img_size = dmx.src.read_u32le()?;
315 let xdpi = dmx.src.read_u32le()?;
316 let ydpi = dmx.src.read_u32le()?;
317 let colors = dmx.src.read_u32le()?;
318 let imp_colors = dmx.src.read_u32le()?;
320 let flip = height < 0;
321 let format = if bitcount > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
322 let vhdr = NAVideoInfo::new(width as usize, if flip { -height as usize } else { height as usize}, flip, PAL8_FORMAT);
323 let vci = NACodecTypeInfo::Video(vhdr);
324 let edata = dmx.read_extradata(size - 40)?;
325 let cname = match register::find_codec_from_avi_fourcc(&compression) {
329 let vinfo = NACodecInfo::new(cname, vci, edata);
330 let res = dmx.dmx.add_stream(NAStream::new(StreamType::Video, dmx.sstate.strm_no as u32, vinfo, dmx.tb_num, dmx.tb_den));
331 if let None = res { return Err(MemoryError); }
336 #[allow(unused_variables)]
337 fn parse_strf_auds(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
338 if size < 16 { return Err(InvalidData); }
339 let w_format_tag = dmx.src.read_u16le()?;
340 let channels = dmx.src.read_u16le()?;
341 let samplespersec = dmx.src.read_u32le()?;
342 let avgbytespersec = dmx.src.read_u32le()?;
343 let block_align = dmx.src.read_u16le()?;
344 let bits_per_sample = dmx.src.read_u16le()? * 8;
346 let soniton = NASoniton::new(bits_per_sample as u8, SONITON_FLAG_SIGNED);
347 let ahdr = NAAudioInfo::new(samplespersec, channels as u8, soniton, block_align as usize);
348 let edata = dmx.read_extradata(size - 16)?;
349 let cname = match register::find_codec_from_wav_twocc(w_format_tag) {
353 let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
354 let res = dmx.dmx.add_stream(NAStream::new(StreamType::Audio, dmx.sstate.strm_no as u32, ainfo, dmx.tb_num, dmx.tb_den));
355 if let None = res { return Err(MemoryError); }
360 fn parse_strf_xxxx(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
361 let edata = dmx.read_extradata(size)?;
362 let info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
363 let res = dmx.dmx.add_stream(NAStream::new(StreamType::Data, dmx.sstate.strm_no as u32, info, dmx.tb_num, dmx.tb_den));
364 if let None = res { return Err(MemoryError); }
369 #[allow(unused_variables)]
370 fn parse_avih(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
371 if size < 0x38 { return Err(InvalidData); }
372 let timebase = dmx.src.read_u32le()?; //microsec per frame
373 dmx.src.read_skip(4)?; //max frame size
374 dmx.src.read_skip(4)?; //padding
375 dmx.src.read_u32le()?; //flags
376 let frames = dmx.src.read_u32le()?; //frames
377 dmx.src.read_skip(4)?; //initial frames
378 let streams = dmx.src.read_u32le()?; //streams
379 if streams > 100 { return Err(InvalidData); }
380 dmx.num_streams = streams as u8;
382 dmx.src.read_skip(4)?; //buf size
383 let width = dmx.src.read_u32le()?; //width
384 let height = dmx.src.read_u32le()? as i32; //height
385 dmx.src.read_skip(16)?; //reserved
387 dmx.cur_frame.resize(streams as usize, 0);
388 dmx.src.read_skip(size - 0x38)?;
392 fn parse_junk(dmx: &mut AVIDemuxer, size: usize) -> DemuxerResult<usize> {
393 dmx.src.read_skip(size)?;
397 pub struct AVIDemuxerCreator { }
399 impl DemuxerCreator for AVIDemuxerCreator {
400 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<Demux<'a> + 'a> {
401 Box::new(AVIDemuxer::new(br))
403 fn get_name(&self) -> &'static str { "avi" }
412 fn test_avi_demux() {
413 let mut file = File::open("assets/laser05.avi").unwrap();
414 let mut fr = FileReader::new_read(&mut file);
415 let mut br = ByteReader::new(&mut fr);
416 let mut dmx = AVIDemuxer::new(&mut br);
420 let pktres = dmx.get_frame();
421 if let Err(e) = pktres {
422 if e == DemuxerError::EOF { break; }
425 let pkt = pktres.unwrap();
426 println!("Got {}", pkt);