nihav-commonfmt/src/demuxers/avi.rs

   1 use nihav_core::demuxers::*;
   2 use nihav_registry::register;
   3 use nihav_core::demuxers::DemuxerError::*;
   4
   5 macro_rules! mktag {
   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)
   8     });
   9     ($arr:expr) => ({
  10         (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
  11     });
  12 }
  13
  14 struct StreamState {
  15     strm_no:    u8,
  16     got_strf:   bool,
  17     strm_type:  Option<StreamType>,
  18 }
  19
  20 impl StreamState {
  21     fn new() -> Self {
  22         StreamState { strm_no: 0, got_strf: true, strm_type: None }
  23     }
  24     fn reset(&mut self) {
  25         self.strm_type = None;
  26         self.got_strf  = true;
  27         self.strm_no  += 1;
  28     }
  29     fn valid_state(&self) -> bool {
  30         match self.strm_type {
  31             None => self.got_strf,
  32             _    => false,
  33         }
  34     }
  35 }
  36
  37 struct PalInfo {
  38     pal:        Arc<[u8; 1024]>,
  39     changed:    bool,
  40     stream_no:  usize,
  41 }
  42
  43 #[allow(dead_code)]
  44 struct AVIDemuxer<'a> {
  45     src:            &'a mut ByteReader<'a>,
  46     cur_frame:      Vec<u64>,
  47     num_streams:    u8,
  48     size:           usize,
  49     movi_size:      usize,
  50     movi_pos:       u64,
  51     movi_orig:      usize,
  52     sstate:         StreamState,
  53     tb_num:         u32,
  54     tb_den:         u32,
  55     strm_duration:  u32,
  56     key_offs:       Vec<u64>,
  57     pal:            Vec<PalInfo>,
  58 }
  59
  60 #[derive(Debug,Clone,Copy,PartialEq)]
  61 enum RIFFTag {
  62     Chunk(u32),
  63     List(u32,u32),
  64 }
  65
  66 struct RIFFParser {
  67     tag:   RIFFTag,
  68     parse: fn(&mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize>,
  69 }
  70
  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)?;
  74         Ok(())
  75     }
  76
  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];
  80         loop {
  81             if (self.src.tell() & 1) == 1 {
  82                 self.src.read_skip(1)?;
  83                 self.movi_size -= 1;
  84                 if self.movi_size == 0 { return Err(EOF); }
  85             }
  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); }
  93                 continue;
  94             }
  95             if mktag!(tag) == mktag!(b"LIST") {
  96                 self.movi_size -= 12;
  97                 self.src.read_skip(4)?;
  98                 if self.movi_size == 0 { return Err(EOF); }
  99                 continue;
 100             }
 101             if (tag[0] == b'i' && tag[1] == b'x') || (&tag == b"idx1") {
 102                 return Err(EOF);
 103             }
 104             if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
 105                 return Err(InvalidData);
 106             }
 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); }
 112                 continue;
 113             }
 114             let str = strmgr.get_stream(stream_no as usize);
 115             if str.is_none() { return Err(InvalidData); }
 116             let stream = str.unwrap();
 117             if size == 0 {
 118                 self.movi_size -= 8;
 119                 if self.movi_size == 0 { return Err(EOF); }
 120                 continue;
 121             }
 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" {
 125                 ts.pts = None;
 126             }
 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()));
 131                     pe.changed = false;
 132                     break;
 133                 }
 134             }
 135             self.cur_frame[stream_no as usize] += 1;
 136             self.movi_size -= size + 8;
 137
 138             return Ok(pkt);
 139         }
 140     }
 141
 142     fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> {
 143         let ret = seek_index.find_pos(time);
 144         if ret.is_none() {
 145             return Err(DemuxerError::SeekError);
 146         }
 147         let seek_info = ret.unwrap();
 148
 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;
 153
 154         self.cur_frame[seek_info.str_id as usize] = seek_info.pts;
 155         self.src.seek(SeekFrom::Start(seek_info.pos))?;
 156
 157         Ok(())
 158     }
 159     fn get_duration(&self) -> u64 { 0 }
 160 }
 161
 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 }
 166 }
 167
 168 impl<'a> AVIDemuxer<'a> {
 169     fn new(io: &'a mut ByteReader<'a>) -> Self {
 170         AVIDemuxer {
 171             cur_frame: Vec::new(),
 172             num_streams: 0,
 173             src: io,
 174             size: 0,
 175             movi_size: 0,
 176             movi_pos:  0,
 177             movi_orig: 0,
 178             sstate: StreamState::new(),
 179             tb_num: 0,
 180             tb_den: 0,
 181             strm_duration: 0,
 182             key_offs: Vec::new(),
 183             pal: Vec::new(),
 184         }
 185     }
 186
 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); }
 190
 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));
 196         }
 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));
 201         }
 202
 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));
 209             }
 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); }
 214                 rest_size -= psize;
 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); }
 218                     rest_size -= psize;
 219                     if ((psize & 1) == 1) && (rest_size > 0) {
 220                         rest_size -= 1;
 221                     }
 222                 }
 223
 224                 return Ok((size + 8, false));
 225             }
 226         }
 227         if !is_list {
 228             self.src.read_skip(size)?;
 229         } else {
 230             if size < 4 { return Err(InvalidData); }
 231             self.src.read_skip(size - 4)?;
 232         }
 233         if (size & 1) == 1 { self.src.read_skip(1)?; }
 234         Ok((size + 8, false))
 235     }
 236
 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 {
 244                 matches = true;
 245                 break;
 246             }
 247         }
 248         if !matches {
 249             return Err(InvalidData);
 250         }
 251         self.size = size;
 252         let mut rest_size = size;
 253         loop {
 254             let (csz, end) = self.parse_chunk(strmgr, RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?;
 255             if end {
 256                 self.movi_size = csz - 4;
 257                 self.movi_orig = self.movi_size;
 258                 self.movi_pos = self.src.tell();
 259                 break;
 260             }
 261             rest_size -= csz;
 262         }
 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();
 269                 if end {
 270                     let _res = parse_idx1(&mut self.src, strmgr, seek_idx, csz, self.movi_pos, &mut self.key_offs);
 271                     break;
 272                 }
 273                 rest_size -= csz;
 274             }
 275         }
 276         if self.movi_pos != 0 {
 277             self.src.seek(SeekFrom::Start(self.movi_pos))?;
 278         } else {
 279             return Err(InvalidData);
 280         }
 281         if !self.sstate.valid_state() || self.sstate.strm_no != self.num_streams {
 282             return Err(InvalidData);
 283         }
 284         Ok(())
 285     }
 286
 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)?;
 291         Ok(Some(edvec))
 292     }
 293
 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
 309                 }
 310                 pe.pal = Arc::new(newpal);
 311                 pe.changed = true;
 312                 return Ok(());
 313             }
 314         }
 315         self.src.read_skip(size)?;
 316         Ok(())
 317     }
 318 }
 319
 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") ],
 324 ];
 325
 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 },
 334 ];
 335
 336 fn is_list_tag(tag: u32) -> bool {
 337     for chunk in CHUNKS.iter() {
 338         if let RIFFTag::List(ltag, _) = chunk.tag {
 339             if tag == ltag {
 340                 return true;
 341             }
 342         }
 343     }
 344     false
 345 }
 346
 347 #[allow(unused_variables)]
 348 fn parse_hdrl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 349     Ok(0)
 350 }
 351
 352 #[allow(unused_variables)]
 353 fn parse_strl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 354     Ok(0)
 355 }
 356
 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()?;
 377
 378     dmx.src.read_skip(size - 0x38)?;
 379
 380     if !dmx.sstate.valid_state() || dmx.sstate.strm_no >= dmx.num_streams {
 381         return Err(InvalidData);
 382     }
 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);
 387     } else {
 388         dmx.sstate.strm_type = Some(StreamType::Data);
 389     }
 390     dmx.sstate.got_strf = false;
 391
 392     Ok(size)
 393 }
 394
 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),
 401     }
 402 }
 403
 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()?;
 421
 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)?;
 428     if colors > 0 {
 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)) {
 432                 dpal[0] = spal[2];
 433                 dpal[1] = spal[1];
 434                 dpal[2] = spal[0];
 435                 dpal[3] = 0;
 436             }
 437             let pal = PalInfo { pal: Arc::new(pal), changed: true, stream_no: strmgr.get_num_streams() };
 438             dmx.pal.push(pal);
 439         }
 440     }
 441     let cname = match register::find_codec_from_avi_fourcc(&compression) {
 442                     None => "unknown",
 443                     Some(name) => name,
 444                 };
 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); }
 448     dmx.sstate.reset();
 449     Ok(size)
 450 }
 451
 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()?;
 461
 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)?
 469         } else {
 470             None
 471         };
 472     let cname = match register::find_codec_from_wav_twocc(w_format_tag) {
 473                     None => "unknown",
 474                     Some(name) => name,
 475                 };
 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); }
 479     dmx.sstate.reset();
 480     Ok(size)
 481 }
 482
 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); }
 488     dmx.sstate.reset();
 489     Ok(size)
 490 }
 491
 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;
 504
 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
 509
 510     dmx.cur_frame.resize(streams as usize, 0);
 511     dmx.src.read_skip(size - 0x38)?;
 512     Ok(size)
 513 }
 514
 515 #[allow(unused_variables)]
 516 fn parse_junk(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 517     dmx.src.read_skip(size)?;
 518     Ok(size)
 519 }
 520
 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()?;
 534
 535         if !set_offset && offset < movi_pos {
 536             add_offset = movi_pos - offset;
 537         }
 538         set_offset = true;
 539
 540         offset += add_offset;
 541
 542         if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
 543             return Err(InvalidData);
 544         }
 545         let stream_no = ((tag[0] - b'0') * 10 + (tag[1] - b'0')) as usize;
 546
 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 });
 555                 }
 556                 key_offs.push(offset);
 557             }
 558         }
 559         counter[stream_no] += 1;
 560     }
 561     key_offs.sort_unstable();
 562     Ok(size)
 563 }
 564
 565 pub struct AVIDemuxerCreator { }
 566
 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))
 570     }
 571     fn get_name(&self) -> &'static str { "avi" }
 572 }
 573
 574 #[cfg(test)]
 575 mod test {
 576     use super::*;
 577     use std::fs::File;
 578
 579     #[test]
 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();
 588
 589         loop {
 590             let pktres = dmx.get_frame(&mut sm);
 591             if let Err(e) = pktres {
 592                 if e == DemuxerError::EOF { break; }
 593                 panic!("error");
 594             }
 595             let pkt = pktres.unwrap();
 596             println!("Got {}", pkt);
 597         }
 598     }
 599 }