1 use nihav_core::demuxers::*;
2 use nihav_registry::register;
3 use nihav_core::demuxers::DemuxerError::*;
7 ($a:expr, $b:expr, $c:expr, $d:expr) => ({
8 (($a as u32) << 24) | (($b as u32) << 16) | (($c as u32) << 8) | ($d as u32)
11 (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
18 strm_type: Option<StreamType>,
23 StreamState { strm_no: 0, got_strf: true, strm_type: None }
26 self.strm_type = None;
30 fn valid_state(&self) -> bool {
31 match self.strm_type {
32 None => self.got_strf,
44 #[derive(Clone,Copy,Default)]
53 fn contains(&self, pos: u64) -> bool {
54 pos >= self.movi_pos && pos < self.movi_pos + (self.movi_size as u64)
56 fn get_end(&self) -> u64 {
57 self.pos + (self.size as u64)
62 struct AVIDemuxer<'a> {
63 src: &'a mut ByteReader<'a>,
78 odml_riff: Vec<RIFFSegment>,
81 #[derive(Debug,Clone,Copy,PartialEq)]
89 parse: fn(&mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize>,
92 impl<'a> DemuxCore<'a> for AVIDemuxer<'a> {
93 fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
94 self.read_header(strmgr, seek_index)?;
98 fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
99 if self.movi_size == 0 {
103 self.try_next_odml_chunk()?;
105 let mut tag: [u8; 4] = [0; 4];
107 if (self.src.tell() & 1) == 1 {
108 self.src.read_skip(1)?;
110 if self.movi_size == 0 {
114 self.try_next_odml_chunk()?;
117 let is_keyframe = self.key_offs.binary_search(&self.src.tell()).is_ok();
118 self.src.read_buf(&mut tag)?;
119 let size = self.src.read_u32le()? as usize;
120 if mktag!(tag) == mktag!(b"JUNK") {
121 self.movi_size -= size + 8;
122 self.src.read_skip(size)?;
123 if self.movi_size == 0 {
127 self.try_next_odml_chunk()?;
131 if mktag!(tag) == mktag!(b"LIST") {
132 self.movi_size -= 12;
133 self.src.read_skip(4)?;
134 if self.movi_size == 0 {
138 self.try_next_odml_chunk()?;
142 if (tag[0] == b'i' && tag[1] == b'x') || (&tag == b"idx1") {
146 self.src.read_skip(size)?;
147 self.try_next_odml_chunk()?;
150 if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
151 return Err(InvalidData);
153 let stream_no = (tag[0] - b'0') * 10 + (tag[1] - b'0');
154 if tag[2] == b'p' && tag[3] == b'c' {
155 self.parse_palette_change(stream_no as usize, size)?;
156 self.movi_size -= size;
157 if self.movi_size == 0 {
161 self.try_next_odml_chunk()?;
165 let str = strmgr.get_stream(stream_no as usize);
166 if str.is_none() { return Err(InvalidData); }
167 let stream = str.unwrap();
170 if self.movi_size == 0 {
174 self.try_next_odml_chunk()?;
178 let (tb_num, tb_den) = stream.get_timebase();
179 let mut ts = NATimeInfo::new(Some(self.cur_frame[stream_no as usize]), None, None, tb_num, tb_den);
180 if stream.get_media_type() == StreamType::Audio && tb_num == 1 && stream.get_info().get_name() == "pcm" {
183 let mut pkt = self.src.read_packet(stream, ts, is_keyframe, size)?;
184 for pe in self.pal.iter_mut() {
185 if pe.stream_no == (stream_no as usize) {
186 pkt.add_side_data(NASideData::Palette(pe.changed, pe.pal.clone()));
191 self.cur_frame[stream_no as usize] += 1;
192 self.movi_size -= size + 8;
198 fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> {
199 let ret = seek_index.find_pos(time);
201 return Err(DemuxerError::SeekError);
203 let seek_info = ret.unwrap();
205 if self.odml && ((seek_info.pos < self.movi_pos) || (seek_info.pos > self.movi_pos + (self.movi_orig as u64))) {
206 let mut found = false;
207 for riff_seg in self.odml_riff.iter() {
208 if riff_seg.contains(seek_info.pos) {
210 self.movi_pos = riff_seg.movi_pos;
211 self.movi_orig = riff_seg.movi_size;
212 self.movi_size = riff_seg.movi_size;
217 let riff_seg = self.odml_riff.last().unwrap();
218 self.src.seek(SeekFrom::Start(riff_seg.get_end()))?;
220 let ret = self.try_next_odml_chunk();
222 return Err(DemuxerError::SeekError);
224 let riff_seg = self.odml_riff.last().unwrap();
225 if riff_seg.contains(seek_info.pos) {
226 self.movi_pos = riff_seg.movi_pos;
227 self.movi_orig = riff_seg.movi_size;
228 self.movi_size = riff_seg.movi_size;
231 self.src.seek(SeekFrom::Start(riff_seg.get_end()))?;
235 if seek_info.pos < self.movi_pos { return Err(DemuxerError::SeekError); }
236 let skip_size = (seek_info.pos - self.movi_pos) as usize;
237 if skip_size > self.movi_size { return Err(DemuxerError::SeekError); }
238 self.movi_size = self.movi_orig - skip_size;
240 self.cur_frame[seek_info.str_id as usize] = seek_info.pts;
241 self.src.seek(SeekFrom::Start(seek_info.pos))?;
245 fn get_duration(&self) -> u64 { 0 }
248 impl<'a> NAOptionHandler for AVIDemuxer<'a> {
249 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
250 fn set_options(&mut self, _options: &[NAOption]) { }
251 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
254 impl<'a> AVIDemuxer<'a> {
255 fn new(io: &'a mut ByteReader<'a>) -> Self {
257 cur_frame: Vec::new(),
264 sstate: StreamState::new(),
268 key_offs: Vec::new(),
271 odml_idx: Vec::new(),
272 odml_riff: Vec::with_capacity(1),
276 fn parse_chunk(&mut self, strmgr: &mut StreamManager, end_tag: RIFFTag, csize: usize, depth: u16) -> DemuxerResult<(usize, bool)> {
277 if csize < 8 { return Err(InvalidData); }
278 if depth > 42 { return Err(InvalidData); }
280 let tag = self.src.read_u32be()?;
281 let size = self.src.read_u32le()? as usize;
282 if size > csize { return Err(InvalidData); }
283 if RIFFTag::Chunk(tag) == end_tag {
284 return Ok((size, true));
286 let is_list = is_list_tag(tag);
287 let ltag = if is_list { self.src.read_u32be()? } else { 0 };
288 if RIFFTag::List(tag, ltag) == end_tag {
289 return Ok((size, true));
292 for chunk in CHUNKS.iter() {
293 if RIFFTag::Chunk(tag) == chunk.tag {
294 let psize = (chunk.parse)(self, strmgr, size)?;
295 if psize != size { return Err(InvalidData); }
296 if (psize & 1) == 1 { self.src.read_skip(1)?; }
297 return Ok((size + 8, false));
299 if RIFFTag::List(tag, ltag) == chunk.tag {
300 let mut rest_size = size - 4;
301 let psize = (chunk.parse)(self, strmgr, rest_size)?;
302 if psize > rest_size { return Err(InvalidData); }
304 while rest_size > 0 {
305 let (psize, _) = self.parse_chunk(strmgr, end_tag, rest_size, depth+1)?;
306 if psize > rest_size { return Err(InvalidData); }
308 if ((psize & 1) == 1) && (rest_size > 0) {
313 return Ok((size + 8, false));
317 self.src.read_skip(size)?;
319 if size < 4 { return Err(InvalidData); }
320 self.src.read_skip(size - 4)?;
322 if (size & 1) == 1 { self.src.read_skip(1)?; }
323 Ok((size + 8, false))
326 fn read_header(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
327 let riff_tag = self.src.read_u32be()?;
328 let size = self.src.read_u32le()? as usize;
329 self.odml_riff.push(RIFFSegment { pos: self.src.tell() - 8, size: size + 8, movi_pos: 0, movi_size: 0});
330 let avi_tag = self.src.read_u32be()?;
331 let mut matches = false;
332 for rt in RIFF_TAGS.iter() {
333 if rt[0] == riff_tag && rt[1] == avi_tag {
339 return Err(InvalidData);
342 let mut rest_size = size;
344 let (csz, end) = self.parse_chunk(strmgr, RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?;
346 self.movi_size = csz - 4;
347 self.movi_orig = self.movi_size;
348 self.movi_pos = self.src.tell();
350 self.odml_riff[0].movi_pos = self.movi_pos;
351 self.odml_riff[0].movi_size = self.movi_size;
356 if !seek_idx.skip_index {
358 self.src.read_skip(self.movi_size)?;
359 while rest_size > 0 {
360 let ret = self.parse_chunk(strmgr, RIFFTag::Chunk(mktag!(b"idx1")), rest_size,0);
361 if ret.is_err() { break; }
362 let (csz, end) = ret.unwrap();
364 let _res = parse_idx1(&mut self.src, strmgr, seek_idx, csz, self.movi_pos, &mut self.key_offs);
371 let mut last_strm_no = 255;
372 for &offset in self.odml_idx.iter() {
373 if self.src.seek(SeekFrom::Start(offset)).is_err() {
376 let ret = self.src.read_tag();
377 if ret.is_err() { break; }
378 let tag = ret.unwrap();
379 let ret = self.src.read_u32le();
380 if ret.is_err() { break; }
381 let size = ret.unwrap() as usize;
382 if &tag[..2] != b"ix" || tag[2] < b'0' || tag[2] > b'9' || tag[3] < b'0' || tag[3] > b'9'{
385 let stream_no = ((tag[2] - b'0') * 10 + (tag[3] - b'0')) as usize;
387 if last_strm_no != stream_no {
389 last_strm_no = stream_no;
391 let ret = parse_odml_ix(&mut self.src, strmgr, seek_idx, stream_no, size, start);
392 if let Ok(new_start) = ret {
400 if self.movi_pos != 0 {
401 self.src.seek(SeekFrom::Start(self.movi_pos))?;
403 return Err(InvalidData);
405 if !self.sstate.valid_state() || self.sstate.strm_no != self.num_streams {
406 return Err(InvalidData);
411 fn read_extradata(&mut self, size: usize) -> DemuxerResult<Option<Vec<u8>>> {
412 if size == 0 { return Ok(None); }
413 let mut edvec: Vec<u8> = vec![0; size];
414 self.src.read_buf(&mut edvec)?;
418 fn parse_palette_change(&mut self, stream_no: usize, size: usize) -> DemuxerResult<()> {
419 for pe in self.pal.iter_mut() {
420 if pe.stream_no == stream_no {
421 let start_clr = self.src.read_byte()? as usize;
422 let len = self.src.read_byte()? as usize;
423 let _flags = self.src.read_u16le()?;
424 validate!(start_clr + len <= 256);
425 validate!(len * 4 + 4 == size);
426 let mut newpal = *pe.pal;
427 for i in start_clr..(start_clr + len) {
428 newpal[i * 4] = self.src.read_byte()?;
429 newpal[i * 4 + 1] = self.src.read_byte()?;
430 newpal[i * 4 + 2] = self.src.read_byte()?;
431 newpal[i * 4 + 3] = 0;
432 self.src.read_byte()?; // flags
434 pe.pal = Arc::new(newpal);
439 self.src.read_skip(size)?;
442 fn try_next_odml_chunk(&mut self) -> DemuxerResult<()> {
443 let last_seg = self.odml_riff.last().unwrap();
444 if self.src.tell() < last_seg.get_end() {
445 for riff_seg in self.odml_riff.iter() {
446 if riff_seg.pos >= self.src.tell() {
447 self.src.seek(SeekFrom::Start(riff_seg.movi_pos))?;
448 self.movi_pos = riff_seg.movi_pos;
449 self.movi_size = riff_seg.movi_size;
454 self.src.seek(SeekFrom::Start(last_seg.get_end()))?;
456 let riff_pos = self.src.tell();
457 let ret = self.src.read_tag();
458 if let Ok([b'R', b'I', b'F', b'F']) = ret {
460 return Err(DemuxerError::EOF);
462 let riff_size = self.src.read_u32le()? as usize;
463 let tag = self.src.read_tag()?;
464 validate!(&tag == b"AVIX");
465 let tag = self.src.read_tag()?;
466 validate!(&tag == b"LIST");
467 let list_size = self.src.read_u32le()? as usize;
468 validate!(list_size >= 4);
469 let tag = self.src.read_tag()?;
470 validate!(&tag == b"movi");
471 self.odml_riff.push(RIFFSegment{ pos: riff_pos, size: riff_size + 8, movi_pos: riff_pos + 24, movi_size: list_size - 4});
472 self.movi_pos = riff_pos + 24;
473 self.movi_size = list_size - 4;
474 self.movi_orig = self.movi_size;
480 const RIFF_TAGS: &[[u32; 2]] = &[
481 [ mktag!(b"RIFF"), mktag!(b"AVI ") ],
482 [ mktag!(b"RIFF"), mktag!(b"AVIX") ],
483 [ mktag!(b"ON2 "), mktag!(b"ON2f") ],
486 const CHUNKS: &[RIFFParser] = &[
487 RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"hdrl")), parse: parse_hdrl },
488 RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"strl")), parse: parse_strl },
489 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"avih")), parse: parse_avih },
490 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"ON2h")), parse: parse_avih },
491 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strf")), parse: parse_strf },
492 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strh")), parse: parse_strh },
493 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"indx")), parse: parse_indx },
494 RIFFParser { tag: RIFFTag::Chunk(mktag!(b"JUNK")), parse: parse_junk },
495 RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"odml")), parse: parse_odml },
498 fn is_list_tag(tag: u32) -> bool {
499 for chunk in CHUNKS.iter() {
500 if let RIFFTag::List(ltag, _) = chunk.tag {
509 #[allow(unused_variables)]
510 fn parse_hdrl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
514 #[allow(unused_variables)]
515 fn parse_strl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
519 fn parse_odml(dmx: &mut AVIDemuxer, _strmgr: &mut StreamManager, _size: usize) -> DemuxerResult<usize> {
524 #[allow(unused_variables)]
525 fn parse_strh(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
526 if size < 0x38 { return Err(InvalidData); }
527 let tag = dmx.src.read_u32be()?; //stream type
528 let fcc = dmx.src.read_u32be()?; //handler(fourcc)
529 dmx.src.read_u32le()?; //flags
530 dmx.src.read_skip(2)?; //priority
531 dmx.src.read_skip(2)?; //language
532 dmx.src.read_skip(4)?; //initial frames
533 dmx.tb_num = dmx.src.read_u32le()?; //scale
534 dmx.tb_den = dmx.src.read_u32le()?; //rate
535 dmx.src.read_skip(4)?; //start
536 dmx.strm_duration = dmx.src.read_u32le()?;
537 dmx.src.read_skip(4)?; //buf size
538 dmx.src.read_skip(4)?; //quality
539 dmx.src.read_skip(4)?; //sample size
540 let a = dmx.src.read_u16le()?;
541 let b = dmx.src.read_u16le()?;
542 let c = dmx.src.read_u16le()?;
543 let d = dmx.src.read_u16le()?;
545 dmx.src.read_skip(size - 0x38)?;
547 if !dmx.sstate.valid_state() || dmx.sstate.strm_no >= dmx.num_streams {
548 return Err(InvalidData);
550 if tag == mktag!(b"vids") {
551 dmx.sstate.strm_type = Some(StreamType::Video);
552 } else if tag == mktag!(b"auds") {
553 dmx.sstate.strm_type = Some(StreamType::Audio);
555 dmx.sstate.strm_type = Some(StreamType::Data);
557 dmx.sstate.got_strf = false;
562 fn parse_strf(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
563 if dmx.sstate.strm_type.is_none() { return Err(InvalidData); }
564 match dmx.sstate.strm_type.unwrap() {
565 StreamType::Video => parse_strf_vids(dmx, strmgr, size),
566 StreamType::Audio => parse_strf_auds(dmx, strmgr, size),
567 _ => parse_strf_xxxx(dmx, strmgr, size),
571 #[allow(unused_variables)]
572 fn parse_strf_vids(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
573 if size < 40 { return Err(InvalidData); }
574 let bi_size = dmx.src.read_u32le()?;
575 if (bi_size as usize) < 40 { return Err(InvalidData); }
576 let width = dmx.src.read_u32le()?;
577 let height = dmx.src.read_u32le()? as i32;
578 let planes = dmx.src.read_u16le()?;
579 let bitcount = dmx.src.read_u16le()?;
580 let mut compression: [u8; 4] = [0; 4];
581 dmx.src.read_buf(&mut compression)?;
582 let img_size = dmx.src.read_u32le()?;
583 let xdpi = dmx.src.read_u32le()?;
584 let ydpi = dmx.src.read_u32le()?;
585 let colors = dmx.src.read_u32le()?;
586 validate!(colors <= 256);
587 let imp_colors = dmx.src.read_u32le()?;
589 let flip = height < 0;
590 let format = if bitcount > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
591 let mut vhdr = NAVideoInfo::new(width as usize, if flip { -height as usize } else { height as usize}, flip, format);
592 vhdr.bits = (planes as u8) * (bitcount as u8);
593 let cname = if find_raw_rgb_fmt(&compression, planes, bitcount, flip, &mut vhdr) {
595 } else if find_raw_yuv_fmt(&compression, &mut vhdr) {
598 match register::find_codec_from_avi_fourcc(&compression) {
603 let vci = NACodecTypeInfo::Video(vhdr);
604 let edata = dmx.read_extradata(size - 40)?;
606 if let Some(ref buf) = edata {
607 let mut pal = [0u8; 1024];
608 for (dpal, spal) in pal.chunks_mut(4).take(colors as usize).zip(buf.chunks(4)) {
614 let pal = PalInfo { pal: Arc::new(pal), changed: true, stream_no: strmgr.get_num_streams() };
618 let vinfo = NACodecInfo::new(cname, vci, edata);
619 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)));
620 if res.is_none() { return Err(MemoryError); }
625 fn find_raw_rgb_fmt(compr: &[u8; 4], planes: u16, bitcount: u16, flip: bool, vhdr: &mut NAVideoInfo) -> bool {
627 &[0, 0, 0, 0] | b"DIB " => {
631 let fmt_name = match bitcount {
638 if let Ok(fmt) = NAPixelFormaton::from_str(fmt_name) {
640 vhdr.flipped = !flip;
650 fn find_raw_yuv_fmt(compr: &[u8; 4], vhdr: &mut NAVideoInfo) -> bool {
651 let (fmt_name, swapuv) = match compr {
652 b"UYVY" | b"UYNY" | b"UYNV" | b"2vuy" => ("uyvy", false),
653 b"I420" | b"IYUV" => ("yuv420p", false),
654 b"YV12" => ("yuv420p", true),
655 b"YVU9" => ("yuv410p", true),
658 if let Ok(fmt) = NAPixelFormaton::from_str(fmt_name) {
661 vhdr.format.comp_info.swap(1, 2);
669 #[allow(unused_variables)]
670 fn parse_strf_auds(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
671 if size < 16 { return Err(InvalidData); }
672 let w_format_tag = dmx.src.read_u16le()?;
673 let channels = dmx.src.read_u16le()?;
674 let samplespersec = dmx.src.read_u32le()?;
675 let avgbytespersec = dmx.src.read_u32le()?;
676 let block_align = dmx.src.read_u16le()?;
677 let bits_per_sample = dmx.src.read_u16le()?;
679 let signed = bits_per_sample > 8;
680 let soniton = NASoniton::new(bits_per_sample as u8, if signed { SONITON_FLAG_SIGNED } else { 0 });
681 let ahdr = NAAudioInfo::new(samplespersec, channels as u8, soniton, block_align as usize);
682 let edata = if size > 16 {
683 let edata_size = dmx.src.read_u16le()? as usize;
684 validate!(edata_size + 18 <= size);
685 dmx.read_extradata(size - 18)?
689 let cname = match register::find_codec_from_wav_twocc(w_format_tag) {
693 let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
694 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)));
695 if res.is_none() { return Err(MemoryError); }
700 fn parse_strf_xxxx(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
701 let edata = dmx.read_extradata(size)?;
702 let info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
703 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)));
704 if res.is_none() { return Err(MemoryError); }
709 #[allow(unused_variables)]
710 fn parse_avih(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
711 if size < 0x38 { return Err(InvalidData); }
712 let timebase = dmx.src.read_u32le()?; //microsec per frame
713 dmx.src.read_skip(4)?; //max frame size
714 dmx.src.read_skip(4)?; //padding
715 dmx.src.read_u32le()?; //flags
716 let frames = dmx.src.read_u32le()?; //frames
717 dmx.src.read_skip(4)?; //initial frames
718 let streams = dmx.src.read_u32le()?; //streams
719 if streams > 100 { return Err(InvalidData); }
720 dmx.num_streams = streams as u8;
722 dmx.src.read_skip(4)?; //buf size
723 let width = dmx.src.read_u32le()?; //width
724 let height = dmx.src.read_u32le()? as i32; //height
725 dmx.src.read_skip(16)?; //reserved
727 dmx.cur_frame.resize(streams as usize, 0);
728 dmx.src.read_skip(size - 0x38)?;
732 fn parse_indx(dmx: &mut AVIDemuxer, _strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
734 validate!(size >= 24);
735 let entry_size = dmx.src.read_u16le()? as usize;
737 dmx.src.read_skip(size - 2)?;
740 let sub_type = dmx.src.read_byte()?;
741 let idx_type = dmx.src.read_byte()?;
742 validate!(sub_type == 0 && idx_type == 0);
743 let entries = dmx.src.read_u32le()? as usize;
744 validate!(size >= 24 + entries * 4 * entry_size);
745 dmx.src.read_tag()?; //chunk id
746 dmx.src.read_skip(12)?; // reserved
747 for _ in 0..entries {
748 let offset = dmx.src.read_u64le()?;
749 let _idx_len = dmx.src.read_u32le()?;
750 let _nframes = dmx.src.read_u32le()?;
751 dmx.odml_idx.push(offset);
753 dmx.src.read_skip(size - 24 - entries * 4 * entry_size)?;
757 #[allow(unused_variables)]
758 fn parse_junk(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
759 dmx.src.read_skip(size)?;
763 #[allow(clippy::verbose_bit_mask)]
764 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> {
765 validate!((size & 15) == 0);
766 let mut tag = [0u8; 4];
767 let num_entries = size >> 4;
768 let mut counter = [0u64; 100];
769 let mut add_offset = 0;
770 let mut set_offset = false;
771 for _ in 0..num_entries {
772 src.read_buf(&mut tag)?;
773 let flags = src.read_u32le()?;
774 let mut offset = src.read_u32le()? as u64;
775 let _length = src.read_u32le()?;
777 if !set_offset && offset < movi_pos {
778 add_offset = movi_pos - offset;
782 offset += add_offset;
784 if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
785 return Err(InvalidData);
787 let stream_no = ((tag[0] - b'0') * 10 + (tag[1] - b'0')) as usize;
789 if (flags & 0x10) != 0 {
790 if let Some(str) = strmgr.get_stream(stream_no) {
791 if str.get_media_type() == StreamType::Video {
792 let (tb_num, tb_den) = str.get_timebase();
793 let pts = counter[stream_no];
794 let time = NATimeInfo::ts_to_time(pts, 1000, tb_num, tb_den);
795 validate!(offset >= movi_pos);
796 seek_idx.add_entry(stream_no as u32, SeekEntry { time, pts, pos: offset });
798 key_offs.push(offset);
801 counter[stream_no] += 1;
803 key_offs.sort_unstable();
807 fn parse_odml_ix(src: &mut ByteReader, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex, stream_no: usize, size: usize, start: u64) -> DemuxerResult<u64> {
808 validate!(size >= 24);
809 let entry_size = src.read_u16le()? as usize;
811 return Err(DemuxerError::NotImplemented);
813 let sub_type = src.read_byte()?;
814 let idx_type = src.read_byte()?;
815 validate!(sub_type == 0 && idx_type == 1);
816 let entries = src.read_u32le()? as usize;
817 validate!(size == 24 + entries * 4 * entry_size);
818 src.read_tag()?; //chunk id
819 let base_offset = src.read_u64le()?;
820 src.read_u32le()?; //reserved
821 if let Some(stream) = strmgr.get_stream(stream_no) {
822 if stream.get_media_type() == StreamType::Video {
823 let (tb_num, tb_den) = stream.get_timebase();
825 for i in 0..entries {
826 let offset = src.read_u32le()?;
827 validate!(offset >= 8);
828 let _size = src.read_u32le()?;
830 let pts = start + (i as u64);
831 let time = NATimeInfo::ts_to_time(pts, 1000, tb_num, tb_den);
832 seek_idx.add_entry(stream_no as u32, SeekEntry { time, pts, pos: base_offset + u64::from(offset - 8) });
835 Ok(start + (entries as u64))
844 pub struct AVIDemuxerCreator { }
846 impl DemuxerCreator for AVIDemuxerCreator {
847 fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
848 Box::new(AVIDemuxer::new(br))
850 fn get_name(&self) -> &'static str { "avi" }
859 fn test_avi_demux() {
860 //test sample: https://samples.mplayerhq.hu/V-codecs/RT21/320x240/laser05.avi
861 let mut file = File::open("assets/Indeo/laser05.avi").unwrap();
862 let mut fr = FileReader::new_read(&mut file);
863 let mut br = ByteReader::new(&mut fr);
864 let mut dmx = AVIDemuxer::new(&mut br);
865 let mut sm = StreamManager::new();
866 let mut si = SeekIndex::new();
867 dmx.open(&mut sm, &mut si).unwrap();
870 let pktres = dmx.get_frame(&mut sm);
871 if let Err(e) = pktres {
872 if e == DemuxerError::EOF { break; }
875 let pkt = pktres.unwrap();
876 println!("Got {}", pkt);