1 use nihav_core::demuxers::*;
2 use nihav_registry::register;
3 use nihav_core::demuxers::DemuxerError::*;
6 ($a:expr, $b:expr, $c:expr, $d:expr) => ({
7 (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
10 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
17 strm_type: Option<StreamType>,
22 StreamState { strm_no: 0, got_strf: true, strm_type: None }
25 self.strm_type = None;
29 fn valid_state(&self) -> bool {
30 match self.strm_type {
31 None => self.got_strf,
44 struct AVIDemuxer<'a> {
45 src: &'a mut ByteReader<'a>,
60 #[derive(Debug,Clone,Copy,PartialEq)]
68 parse: fn(&mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize>,
71 impl<'a> DemuxCore<'a> for AVIDemuxer<'a> {
72 fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
73 self.read_header(strmgr, seek_index)?;
77 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
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 let is_keyframe = self.key_offs.binary_search(&self.src.tell()).is_ok();
87 self.src.read_buf(&mut tag)?;
88 let size = self.src.read_u32le()? as usize;
89 if mktag!(tag) == mktag!(b"JUNK") {
90 self.movi_size -= size + 8;
91 self.src.read_skip(size)?;
92 if self.movi_size == 0 { return Err(EOF); }
95 if mktag!(tag) == mktag!(b"LIST") {
97 self.src.read_skip(4)?;
98 if self.movi_size == 0 { return Err(EOF); }
101 if (tag[0] == b'i' && tag[1] == b'x') || (&tag == b"idx1") {
104 if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
105 return Err(InvalidData);
107 let stream_no = (tag[0] - b'0') * 10 + (tag[1] - b'0');
108 if tag[2] == b'p' && tag[3] == b'c' {
109 self.parse_palette_change(stream_no as usize, size)?;
110 self.movi_size -= size;
111 if self.movi_size == 0 { return Err(EOF); }
114 let str = strmgr.get_stream(stream_no as usize);
115 if str.is_none() { return Err(InvalidData); }
116 let stream = str.unwrap();
119 if self.movi_size == 0 { return Err(EOF); }
122 let (tb_num, tb_den) = stream.get_timebase();
123 let mut ts = NATimeInfo::new(Some(self.cur_frame[stream_no as usize]), None, None, tb_num, tb_den);
124 if stream.get_media_type() == StreamType::Audio && tb_num == 1 && stream.get_info().get_name() == "pcm" {
127 let mut pkt = self.src.read_packet(stream, ts, is_keyframe, size)?;
128 for pe in self.pal.iter_mut() {
129 if pe.stream_no == (stream_no as usize) {
130 pkt.add_side_data(NASideData::Palette(pe.changed, pe.pal.clone()));
135 self.cur_frame[stream_no as usize] += 1;
136 self.movi_size -= size + 8;
142 fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> {
143 let ret = seek_index.find_pos(time);
145 return Err(DemuxerError::SeekError);
147 let seek_info = ret.unwrap();
149 if seek_info.pos < self.movi_pos { return Err(DemuxerError::SeekError); }
150 let skip_size = (seek_info.pos - self.movi_pos) as usize;
151 if skip_size > self.movi_size { return Err(DemuxerError::SeekError); }
152 self.movi_size = self.movi_orig - skip_size;
154 self.cur_frame[seek_info.str_id as usize] = seek_info.pts;
155 self.src.seek(SeekFrom::Start(seek_info.pos))?;
159 fn get_duration(&self) -> u64 { 0 }
162 impl<'a> NAOptionHandler for AVIDemuxer<'a> {
163 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
164 fn set_options(&mut self, _options: &[NAOption]) { }
165 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
168 impl<'a> AVIDemuxer<'a> {
169 fn new(io: &'a mut ByteReader<'a>) -> Self {
171 cur_frame: Vec::new(),
178 sstate: StreamState::new(),
182 key_offs: Vec::new(),
187 fn parse_chunk(&mut self, strmgr: &mut StreamManager, end_tag: RIFFTag, csize: usize, depth: u16) -> DemuxerResult<(usize, bool)> {
188 if csize < 8 { return Err(InvalidData); }
189 if depth > 42 { return Err(InvalidData); }
191 let tag = self.src.read_u32be()?;
192 let size = self.src.read_u32le()? as usize;
193 if size > csize { return Err(InvalidData); }
194 if RIFFTag::Chunk(tag) == end_tag {
195 return Ok((size, true));
197 let is_list = is_list_tag(tag);
198 let ltag = if is_list { self.src.read_u32be()? } else { 0 };
199 if RIFFTag::List(tag, ltag) == end_tag {
200 return Ok((size, true));
203 for chunk in CHUNKS.iter() {
204 if RIFFTag::Chunk(tag) == chunk.tag {
205 let psize = (chunk.parse)(self, strmgr, size)?;
206 if psize != size { return Err(InvalidData); }
207 if (psize & 1) == 1 { self.src.read_skip(1)?; }
208 return Ok((size + 8, false));
210 if RIFFTag::List(tag, ltag) == chunk.tag {
211 let mut rest_size = size - 4;
212 let psize = (chunk.parse)(self, strmgr, rest_size)?;
213 if psize > rest_size { return Err(InvalidData); }
215 while rest_size > 0 {
216 let (psize, _) = self.parse_chunk(strmgr, end_tag, rest_size, depth+1)?;
217 if psize > rest_size { return Err(InvalidData); }
219 if ((psize & 1) == 1) && (rest_size > 0) {
224 return Ok((size + 8, false));
228 self.src.read_skip(size)?;
230 if size < 4 { return Err(InvalidData); }
231 self.src.read_skip(size - 4)?;
233 if (size & 1) == 1 { self.src.read_skip(1)?; }
234 Ok((size + 8, false))
237 fn read_header(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
238 let riff_tag = self.src.read_u32be()?;
239 let size = self.src.read_u32le()? as usize;
240 let avi_tag = self.src.read_u32be()?;
241 let mut matches = false;
242 for rt in RIFF_TAGS.iter() {
243 if rt[0] == riff_tag && rt[1] == avi_tag {
249 return Err(InvalidData);
252 let mut rest_size = size;
254 let (csz, end) = self.parse_chunk(strmgr, RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?;
256 self.movi_size = csz - 4;
257 self.movi_orig = self.movi_size;
258 self.movi_pos = self.src.tell();
263 if !seek_idx.skip_index {
264 self.src.read_skip(self.movi_size)?;
265 while rest_size > 0 {
266 let ret = self.parse_chunk(strmgr, RIFFTag::Chunk(mktag!(b"idx1")), rest_size,0);
267 if ret.is_err() { break; }
268 let (csz, end) = ret.unwrap();
270 let _res = parse_idx1(&mut self.src, strmgr, seek_idx, csz, self.movi_pos, &mut self.key_offs);
276 if self.movi_pos != 0 {
277 self.src.seek(SeekFrom::Start(self.movi_pos))?;
279 return Err(InvalidData);
281 if !self.sstate.valid_state() || self.sstate.strm_no != self.num_streams {
282 return Err(InvalidData);
287 fn read_extradata(&mut self, size: usize) -> DemuxerResult<Option<Vec<u8>>> {
288 if size == 0 { return Ok(None); }
289 let mut edvec: Vec<u8> = vec![0; size];
290 self.src.read_buf(&mut edvec)?;
294 fn parse_palette_change(&mut self, stream_no: usize, size: usize) -> DemuxerResult<()> {
295 for pe in self.pal.iter_mut() {
296 if pe.stream_no == stream_no {
297 let start_clr = self.src.read_byte()? as usize;
298 let len = self.src.read_byte()? as usize;
299 let _flags = self.src.read_u16le()?;
300 validate!(start_clr + len <= 256);
301 validate!(len * 4 + 4 == size);
302 let mut newpal = *pe.pal;
303 for i in start_clr..(start_clr + len) {
304 newpal[i * 4] = self.src.read_byte()?;
305 newpal[i * 4 + 1] = self.src.read_byte()?;
306 newpal[i * 4 + 2] = self.src.read_byte()?;
307 newpal[i * 4 + 3] = 0;
308 self.src.read_byte()?; // flags
310 pe.pal = Arc::new(newpal);
315 self.src.read_skip(size)?;
320 const RIFF_TAGS: &[[u32; 2]] = &[
321 [ mktag!(b"RIFF"), mktag!(b"AVI ") ],
322 [ mktag!(b"RIFF"), mktag!(b"AVIX") ],
323 [ mktag!(b"ON2 "), mktag!(b"ON2f") ],
326 const CHUNKS: [RIFFParser; 7] = [
327 RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"hdrl")), parse: parse_hdrl },
328 RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"strl")), parse: parse_strl },
329 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"avih")), parse: parse_avih },
330 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"ON2h")), parse: parse_avih },
331 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strf")), parse: parse_strf },
332 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strh")), parse: parse_strh },
333 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"JUNK")), parse: parse_junk },
336 fn is_list_tag(tag: u32) -> bool {
337 for chunk in CHUNKS.iter() {
338 if let RIFFTag::List(ltag, _) = chunk.tag {
347 #[allow(unused_variables)]
348 fn parse_hdrl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
352 #[allow(unused_variables)]
353 fn parse_strl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
357 #[allow(unused_variables)]
358 fn parse_strh(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
359 if size < 0x38 { return Err(InvalidData); }
360 let tag = dmx.src.read_u32be()?; //stream type
361 let fcc = dmx.src.read_u32be()?; //handler(fourcc)
362 dmx.src.read_u32le()?; //flags
363 dmx.src.read_skip(2)?; //priority
364 dmx.src.read_skip(2)?; //language
365 dmx.src.read_skip(4)?; //initial frames
366 dmx.tb_num = dmx.src.read_u32le()?; //scale
367 dmx.tb_den = dmx.src.read_u32le()?; //rate
368 dmx.src.read_skip(4)?; //start
369 dmx.strm_duration = dmx.src.read_u32le()?;
370 dmx.src.read_skip(4)?; //buf size
371 dmx.src.read_skip(4)?; //quality
372 dmx.src.read_skip(4)?; //sample size
373 let a = dmx.src.read_u16le()?;
374 let b = dmx.src.read_u16le()?;
375 let c = dmx.src.read_u16le()?;
376 let d = dmx.src.read_u16le()?;
378 dmx.src.read_skip(size - 0x38)?;
380 if !dmx.sstate.valid_state() || dmx.sstate.strm_no >= dmx.num_streams {
381 return Err(InvalidData);
383 if tag == mktag!(b"vids") {
384 dmx.sstate.strm_type = Some(StreamType::Video);
385 } else if tag == mktag!(b"auds") {
386 dmx.sstate.strm_type = Some(StreamType::Audio);
388 dmx.sstate.strm_type = Some(StreamType::Data);
390 dmx.sstate.got_strf = false;
395 fn parse_strf(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
396 if dmx.sstate.strm_type.is_none() { return Err(InvalidData); }
397 match dmx.sstate.strm_type.unwrap() {
398 StreamType::Video => parse_strf_vids(dmx, strmgr, size),
399 StreamType::Audio => parse_strf_auds(dmx, strmgr, size),
400 _ => parse_strf_xxxx(dmx, strmgr, size),
404 #[allow(unused_variables)]
405 fn parse_strf_vids(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
406 if size < 40 { return Err(InvalidData); }
407 let bi_size = dmx.src.read_u32le()?;
408 if (bi_size as usize) < 40 { return Err(InvalidData); }
409 let width = dmx.src.read_u32le()?;
410 let height = dmx.src.read_u32le()? as i32;
411 let planes = dmx.src.read_u16le()?;
412 let bitcount = dmx.src.read_u16le()?;
413 let mut compression: [u8; 4] = [0; 4];
414 dmx.src.read_buf(&mut compression)?;
415 let img_size = dmx.src.read_u32le()?;
416 let xdpi = dmx.src.read_u32le()?;
417 let ydpi = dmx.src.read_u32le()?;
418 let colors = dmx.src.read_u32le()?;
419 validate!(colors <= 256);
420 let imp_colors = dmx.src.read_u32le()?;
422 let flip = height < 0;
423 let format = if bitcount > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
424 let mut vhdr = NAVideoInfo::new(width as usize, if flip { -height as usize } else { height as usize}, flip, format);
425 vhdr.bits = (planes as u8) * (bitcount as u8);
426 let vci = NACodecTypeInfo::Video(vhdr);
427 let edata = dmx.read_extradata(size - 40)?;
429 if let Some(ref buf) = edata {
430 let mut pal = [0u8; 1024];
431 for (dpal, spal) in pal.chunks_mut(4).take(colors as usize).zip(buf.chunks(4)) {
437 let pal = PalInfo { pal: Arc::new(pal), changed: true, stream_no: strmgr.get_num_streams() };
441 let cname = match register::find_codec_from_avi_fourcc(&compression) {
445 let vinfo = NACodecInfo::new(cname, vci, edata);
446 let res = strmgr.add_stream(NAStream::new(StreamType::Video, u32::from(dmx.sstate.strm_no), vinfo, dmx.tb_num, dmx.tb_den, u64::from(dmx.strm_duration)));
447 if res.is_none() { return Err(MemoryError); }
452 #[allow(unused_variables)]
453 fn parse_strf_auds(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
454 if size < 16 { return Err(InvalidData); }
455 let w_format_tag = dmx.src.read_u16le()?;
456 let channels = dmx.src.read_u16le()?;
457 let samplespersec = dmx.src.read_u32le()?;
458 let avgbytespersec = dmx.src.read_u32le()?;
459 let block_align = dmx.src.read_u16le()?;
460 let bits_per_sample = dmx.src.read_u16le()?;
462 let signed = bits_per_sample > 8;
463 let soniton = NASoniton::new(bits_per_sample as u8, if signed { SONITON_FLAG_SIGNED } else { 0 });
464 let ahdr = NAAudioInfo::new(samplespersec, channels as u8, soniton, block_align as usize);
465 let edata = if size > 16 {
466 let edata_size = dmx.src.read_u16le()? as usize;
467 validate!(edata_size + 18 <= size);
468 dmx.read_extradata(size - 18)?
472 let cname = match register::find_codec_from_wav_twocc(w_format_tag) {
476 let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
477 let res = strmgr.add_stream(NAStream::new(StreamType::Audio, u32::from(dmx.sstate.strm_no), ainfo, dmx.tb_num, dmx.tb_den, u64::from(dmx.strm_duration)));
478 if res.is_none() { return Err(MemoryError); }
483 fn parse_strf_xxxx(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
484 let edata = dmx.read_extradata(size)?;
485 let info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
486 let res = strmgr.add_stream(NAStream::new(StreamType::Data, u32::from(dmx.sstate.strm_no), info, dmx.tb_num, dmx.tb_den, u64::from(dmx.strm_duration)));
487 if res.is_none() { return Err(MemoryError); }
492 #[allow(unused_variables)]
493 fn parse_avih(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
494 if size < 0x38 { return Err(InvalidData); }
495 let timebase = dmx.src.read_u32le()?; //microsec per frame
496 dmx.src.read_skip(4)?; //max frame size
497 dmx.src.read_skip(4)?; //padding
498 dmx.src.read_u32le()?; //flags
499 let frames = dmx.src.read_u32le()?; //frames
500 dmx.src.read_skip(4)?; //initial frames
501 let streams = dmx.src.read_u32le()?; //streams
502 if streams > 100 { return Err(InvalidData); }
503 dmx.num_streams = streams as u8;
505 dmx.src.read_skip(4)?; //buf size
506 let width = dmx.src.read_u32le()?; //width
507 let height = dmx.src.read_u32le()? as i32; //height
508 dmx.src.read_skip(16)?; //reserved
510 dmx.cur_frame.resize(streams as usize, 0);
511 dmx.src.read_skip(size - 0x38)?;
515 #[allow(unused_variables)]
516 fn parse_junk(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
517 dmx.src.read_skip(size)?;
521 #[allow(clippy::verbose_bit_mask)]
522 fn parse_idx1(src: &mut ByteReader, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex, size: usize, movi_pos: u64, key_offs: &mut Vec<u64>) -> DemuxerResult<usize> {
523 validate!((size & 15) == 0);
524 let mut tag = [0u8; 4];
525 let num_entries = size >> 4;
526 let mut counter = [0u64; 100];
527 let mut add_offset = 0;
528 let mut set_offset = false;
529 for _ in 0..num_entries {
530 src.read_buf(&mut tag)?;
531 let flags = src.read_u32le()?;
532 let mut offset = src.read_u32le()? as u64;
533 let _length = src.read_u32le()?;
535 if !set_offset && offset < movi_pos {
536 add_offset = movi_pos - offset;
540 offset += add_offset;
542 if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
543 return Err(InvalidData);
545 let stream_no = ((tag[0] - b'0') * 10 + (tag[1] - b'0')) as usize;
547 if (flags & 0x10) != 0 {
548 if let Some(str) = strmgr.get_stream(stream_no) {
549 if str.get_media_type() == StreamType::Video {
550 let (tb_num, tb_den) = str.get_timebase();
551 let pts = counter[stream_no];
552 let time = NATimeInfo::ts_to_time(pts, 1000, tb_num, tb_den);
553 validate!(offset >= movi_pos);
554 seek_idx.add_entry(stream_no as u32, SeekEntry { time, pts, pos: offset });
556 key_offs.push(offset);
559 counter[stream_no] += 1;
561 key_offs.sort_unstable();
565 pub struct AVIDemuxerCreator { }
567 impl DemuxerCreator for AVIDemuxerCreator {
568 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
569 Box::new(AVIDemuxer::new(br))
571 fn get_name(&self) -> &'static str { "avi" }
580 fn test_avi_demux() {
581 let mut file = File::open("assets/Indeo/laser05.avi").unwrap();
582 let mut fr = FileReader::new_read(&mut file);
583 let mut br = ByteReader::new(&mut fr);
584 let mut dmx = AVIDemuxer::new(&mut br);
585 let mut sm = StreamManager::new();
586 let mut si = SeekIndex::new();
587 dmx.open(&mut sm, &mut si).unwrap();
590 let pktres = dmx.get_frame(&mut sm);
591 if let Err(e) = pktres {
592 if e == DemuxerError::EOF { break; }
595 let pkt = pktres.unwrap();
596 println!("Got {}", pkt);