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 ts = NATimeInfo::new(Some(self.cur_frame[stream_no as usize]), None, None, tb_num, tb_den);
 124             let mut pkt = self.src.read_packet(stream, ts, is_keyframe, size)?;
 125             for pe in self.pal.iter_mut() {
 126                 if pe.stream_no == (stream_no as usize) {
 127                     pkt.add_side_data(NASideData::Palette(pe.changed, pe.pal.clone()));
 128                     pe.changed = false;
 129                     break;
 130                 }
 131             }
 132             self.cur_frame[stream_no as usize] += 1;
 133             self.movi_size -= size + 8;
 134
 135             return Ok(pkt);
 136         }
 137     }
 138
 139     fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> {
 140         let ret = seek_index.find_pos(time);
 141         if ret.is_none() {
 142             return Err(DemuxerError::SeekError);
 143         }
 144         let seek_info = ret.unwrap();
 145
 146         if seek_info.pos < self.movi_pos { return Err(DemuxerError::SeekError); }
 147         let skip_size = (seek_info.pos - self.movi_pos) as usize;
 148         if skip_size > self.movi_size { return Err(DemuxerError::SeekError); }
 149         self.movi_size = self.movi_orig - skip_size;
 150
 151         self.cur_frame[seek_info.str_id as usize] = seek_info.pts;
 152         self.src.seek(SeekFrom::Start(seek_info.pos))?;
 153
 154         Ok(())
 155     }
 156     fn get_duration(&self) -> u64 { 0 }
 157 }
 158
 159 impl<'a> NAOptionHandler for AVIDemuxer<'a> {
 160     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 161     fn set_options(&mut self, _options: &[NAOption]) { }
 162     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 163 }
 164
 165 impl<'a> AVIDemuxer<'a> {
 166     fn new(io: &'a mut ByteReader<'a>) -> Self {
 167         AVIDemuxer {
 168             cur_frame: Vec::new(),
 169             num_streams: 0,
 170             src: io,
 171             size: 0,
 172             movi_size: 0,
 173             movi_pos:  0,
 174             movi_orig: 0,
 175             sstate: StreamState::new(),
 176             tb_num: 0,
 177             tb_den: 0,
 178             strm_duration: 0,
 179             key_offs: Vec::new(),
 180             pal: Vec::new(),
 181         }
 182     }
 183
 184     fn parse_chunk(&mut self, strmgr: &mut StreamManager, end_tag: RIFFTag, csize: usize, depth: u16) -> DemuxerResult<(usize, bool)> {
 185         if csize < 8 { return Err(InvalidData); }
 186         if depth > 42 { return Err(InvalidData); }
 187
 188         let tag  = self.src.read_u32be()?;
 189         let size = self.src.read_u32le()? as usize;
 190         if size > csize { return Err(InvalidData); }
 191         if RIFFTag::Chunk(tag) == end_tag {
 192             return Ok((size, true));
 193         }
 194         let is_list = is_list_tag(tag);
 195         let ltag = if is_list { self.src.read_u32be()? } else { 0 };
 196         if RIFFTag::List(tag, ltag) == end_tag {
 197             return Ok((size, true));
 198         }
 199
 200         for chunk in CHUNKS.iter() {
 201             if RIFFTag::Chunk(tag) == chunk.tag {
 202                 let psize = (chunk.parse)(self, strmgr, size)?;
 203                 if psize != size { return Err(InvalidData); }
 204                 if (psize & 1) == 1 { self.src.read_skip(1)?; }
 205                 return Ok((size + 8, false));
 206             }
 207             if RIFFTag::List(tag, ltag) == chunk.tag {
 208                 let mut rest_size = size - 4;
 209                 let psize = (chunk.parse)(self, strmgr, rest_size)?;
 210                 if psize > rest_size { return Err(InvalidData); }
 211                 rest_size -= psize;
 212                 while rest_size > 0 {
 213                     let (psize, _) = self.parse_chunk(strmgr, end_tag, rest_size, depth+1)?;
 214                     if psize > rest_size { return Err(InvalidData); }
 215                     rest_size -= psize;
 216                     if ((psize & 1) == 1) && (rest_size > 0) {
 217                         rest_size -= 1;
 218                     }
 219                 }
 220
 221                 return Ok((size + 8, false));
 222             }
 223         }
 224         if !is_list {
 225             self.src.read_skip(size)?;
 226         } else {
 227             if size < 4 { return Err(InvalidData); }
 228             self.src.read_skip(size - 4)?;
 229         }
 230         if (size & 1) == 1 { self.src.read_skip(1)?; }
 231         Ok((size + 8, false))
 232     }
 233
 234     fn read_header(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
 235         let riff_tag = self.src.read_u32be()?;
 236         let size     = self.src.read_u32le()? as usize;
 237         let avi_tag  = self.src.read_u32be()?;
 238         let mut matches = false;
 239         for rt in RIFF_TAGS.iter() {
 240             if rt[0] == riff_tag && rt[1] == avi_tag {
 241                 matches = true;
 242                 break;
 243             }
 244         }
 245         if !matches {
 246             return Err(InvalidData);
 247         }
 248         self.size = size;
 249         let mut rest_size = size;
 250         loop {
 251             let (csz, end) = self.parse_chunk(strmgr, RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?;
 252             if end {
 253                 self.movi_size = csz - 4;
 254                 self.movi_orig = self.movi_size;
 255                 self.movi_pos = self.src.tell();
 256                 break;
 257             }
 258             rest_size -= csz;
 259         }
 260         if !seek_idx.skip_index {
 261             self.src.read_skip(self.movi_size)?;
 262             while rest_size > 0 {
 263                 let ret = self.parse_chunk(strmgr, RIFFTag::Chunk(mktag!(b"idx1")), rest_size,0);
 264                 if ret.is_err() { break; }
 265                 let (csz, end) = ret.unwrap();
 266                 if end {
 267                     let _res = parse_idx1(&mut self.src, strmgr, seek_idx, csz, self.movi_pos, &mut self.key_offs);
 268                     break;
 269                 }
 270                 rest_size -= csz;
 271             }
 272         }
 273         if self.movi_pos != 0 {
 274             self.src.seek(SeekFrom::Start(self.movi_pos))?;
 275         } else {
 276             return Err(InvalidData);
 277         }
 278         if !self.sstate.valid_state() || self.sstate.strm_no != self.num_streams {
 279             return Err(InvalidData);
 280         }
 281         Ok(())
 282     }
 283
 284     fn read_extradata(&mut self, size: usize) -> DemuxerResult<Option<Vec<u8>>> {
 285         if size == 0 { return Ok(None); }
 286         let mut edvec: Vec<u8> = vec![0; size];
 287         self.src.read_buf(&mut edvec)?;
 288         Ok(Some(edvec))
 289     }
 290
 291     fn parse_palette_change(&mut self, stream_no: usize, size: usize) -> DemuxerResult<()> {
 292         for pe in self.pal.iter_mut() {
 293             if pe.stream_no == stream_no {
 294                 let start_clr           = self.src.read_byte()? as usize;
 295                 let len                 = self.src.read_byte()? as usize;
 296                 let _flags              = self.src.read_u16le()?;
 297                 validate!(start_clr + len <= 256);
 298                 validate!(len * 4 + 4 == size);
 299                 let mut newpal = *pe.pal;
 300                 for i in start_clr..(start_clr + len) {
 301                     newpal[i * 4]       = self.src.read_byte()?;
 302                     newpal[i * 4 + 1]   = self.src.read_byte()?;
 303                     newpal[i * 4 + 2]   = self.src.read_byte()?;
 304                     newpal[i * 4 + 3]   = 0;
 305                                           self.src.read_byte()?; // flags
 306                 }
 307                 pe.pal = Arc::new(newpal);
 308                 pe.changed = true;
 309                 return Ok(());
 310             }
 311         }
 312         self.src.read_skip(size)?;
 313         Ok(())
 314     }
 315 }
 316
 317 const RIFF_TAGS: &[[u32; 2]] = &[
 318     [ mktag!(b"RIFF"), mktag!(b"AVI ") ],
 319     [ mktag!(b"RIFF"), mktag!(b"AVIX") ],
 320     [ mktag!(b"ON2 "), mktag!(b"ON2f") ],
 321 ];
 322
 323 const CHUNKS: [RIFFParser; 7] = [
 324     RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"hdrl")), parse: parse_hdrl },
 325     RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"strl")), parse: parse_strl },
 326     RIFFParser { tag: RIFFTag::Chunk(mktag!(b"avih")), parse: parse_avih },
 327     RIFFParser { tag: RIFFTag::Chunk(mktag!(b"ON2h")), parse: parse_avih },
 328     RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strf")), parse: parse_strf },
 329     RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strh")), parse: parse_strh },
 330     RIFFParser { tag: RIFFTag::Chunk(mktag!(b"JUNK")), parse: parse_junk },
 331 ];
 332
 333 fn is_list_tag(tag: u32) -> bool {
 334     for chunk in CHUNKS.iter() {
 335         if let RIFFTag::List(ltag, _) = chunk.tag {
 336             if tag == ltag {
 337                 return true;
 338             }
 339         }
 340     }
 341     false
 342 }
 343
 344 #[allow(unused_variables)]
 345 fn parse_hdrl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 346     Ok(0)
 347 }
 348
 349 #[allow(unused_variables)]
 350 fn parse_strl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 351     Ok(0)
 352 }
 353
 354 #[allow(unused_variables)]
 355 fn parse_strh(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 356     if size < 0x38 { return Err(InvalidData); }
 357     let tag = dmx.src.read_u32be()?; //stream type
 358     let fcc = dmx.src.read_u32be()?; //handler(fourcc)
 359     dmx.src.read_u32le()?; //flags
 360     dmx.src.read_skip(2)?; //priority
 361     dmx.src.read_skip(2)?; //language
 362     dmx.src.read_skip(4)?; //initial frames
 363     dmx.tb_num = dmx.src.read_u32le()?; //scale
 364     dmx.tb_den = dmx.src.read_u32le()?; //rate
 365     dmx.src.read_skip(4)?; //start
 366     dmx.strm_duration = dmx.src.read_u32le()?;
 367     dmx.src.read_skip(4)?; //buf size
 368     dmx.src.read_skip(4)?; //quality
 369     dmx.src.read_skip(4)?; //sample size
 370     let a = dmx.src.read_u16le()?;
 371     let b = dmx.src.read_u16le()?;
 372     let c = dmx.src.read_u16le()?;
 373     let d = dmx.src.read_u16le()?;
 374
 375     dmx.src.read_skip(size - 0x38)?;
 376
 377     if !dmx.sstate.valid_state() || dmx.sstate.strm_no >= dmx.num_streams {
 378         return Err(InvalidData);
 379     }
 380     if tag == mktag!(b"vids") {
 381         dmx.sstate.strm_type = Some(StreamType::Video);
 382     } else if tag == mktag!(b"auds") {
 383         dmx.sstate.strm_type = Some(StreamType::Audio);
 384     } else {
 385         dmx.sstate.strm_type = Some(StreamType::Data);
 386     }
 387     dmx.sstate.got_strf = false;
 388
 389     Ok(size)
 390 }
 391
 392 fn parse_strf(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 393     if dmx.sstate.strm_type.is_none() { return Err(InvalidData); }
 394     match dmx.sstate.strm_type.unwrap() {
 395         StreamType::Video    => parse_strf_vids(dmx, strmgr, size),
 396         StreamType::Audio    => parse_strf_auds(dmx, strmgr, size),
 397         _                    => parse_strf_xxxx(dmx, strmgr, size),
 398     }
 399 }
 400
 401 #[allow(unused_variables)]
 402 fn parse_strf_vids(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 403     if size < 40 { return Err(InvalidData); }
 404     let bi_size         = dmx.src.read_u32le()?;
 405     if (bi_size as usize) < 40 { return Err(InvalidData); }
 406     let width           = dmx.src.read_u32le()?;
 407     let height          = dmx.src.read_u32le()? as i32;
 408     let planes          = dmx.src.read_u16le()?;
 409     let bitcount        = dmx.src.read_u16le()?;
 410     let mut compression: [u8; 4] = [0; 4];
 411                           dmx.src.read_buf(&mut compression)?;
 412     let img_size        = dmx.src.read_u32le()?;
 413     let xdpi            = dmx.src.read_u32le()?;
 414     let ydpi            = dmx.src.read_u32le()?;
 415     let colors          = dmx.src.read_u32le()?;
 416     validate!(colors <= 256);
 417     let imp_colors      = dmx.src.read_u32le()?;
 418
 419     let flip = height < 0;
 420     let format = if bitcount > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
 421     let mut vhdr = NAVideoInfo::new(width as usize, if flip { -height as usize } else { height as usize}, flip, format);
 422     vhdr.bits = (planes as u8) * (bitcount as u8);
 423     let vci = NACodecTypeInfo::Video(vhdr);
 424     let edata = dmx.read_extradata(size - 40)?;
 425     if colors > 0 {
 426         if let Some(ref buf) = edata {
 427             let mut pal = [0u8; 1024];
 428             for (dpal, spal) in pal.chunks_mut(4).take(colors as usize).zip(buf.chunks(4)) {
 429                 dpal[0] = spal[2];
 430                 dpal[1] = spal[1];
 431                 dpal[2] = spal[0];
 432                 dpal[3] = 0;
 433             }
 434             let pal = PalInfo { pal: Arc::new(pal), changed: true, stream_no: strmgr.get_num_streams() };
 435             dmx.pal.push(pal);
 436         }
 437     }
 438     let cname = match register::find_codec_from_avi_fourcc(&compression) {
 439                     None => "unknown",
 440                     Some(name) => name,
 441                 };
 442     let vinfo = NACodecInfo::new(cname, vci, edata);
 443     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)));
 444     if res.is_none() { return Err(MemoryError); }
 445     dmx.sstate.reset();
 446     Ok(size)
 447 }
 448
 449 #[allow(unused_variables)]
 450 fn parse_strf_auds(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 451     if size < 16 { return Err(InvalidData); }
 452     let w_format_tag        = dmx.src.read_u16le()?;
 453     let channels            = dmx.src.read_u16le()?;
 454     let samplespersec       = dmx.src.read_u32le()?;
 455     let avgbytespersec      = dmx.src.read_u32le()?;
 456     let block_align         = dmx.src.read_u16le()?;
 457     let bits_per_sample     = dmx.src.read_u16le()?;
 458
 459     let soniton = NASoniton::new(bits_per_sample as u8, SONITON_FLAG_SIGNED);
 460     let ahdr = NAAudioInfo::new(samplespersec, channels as u8, soniton, block_align as usize);
 461     let edata = if size > 16 {
 462             let edata_size  = dmx.src.read_u16le()? as usize;
 463             validate!(edata_size + 18 <= size);
 464             dmx.read_extradata(size - 18)?
 465         } else {
 466             None
 467         };
 468     let cname = match register::find_codec_from_wav_twocc(w_format_tag) {
 469                     None => "unknown",
 470                     Some(name) => name,
 471                 };
 472     let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
 473     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)));
 474     if res.is_none() { return Err(MemoryError); }
 475     dmx.sstate.reset();
 476     Ok(size)
 477 }
 478
 479 fn parse_strf_xxxx(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 480     let edata = dmx.read_extradata(size)?;
 481     let info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
 482     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)));
 483     if res.is_none() { return Err(MemoryError); }
 484     dmx.sstate.reset();
 485     Ok(size)
 486 }
 487
 488 #[allow(unused_variables)]
 489 fn parse_avih(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 490     if size < 0x38 { return Err(InvalidData); }
 491     let timebase = dmx.src.read_u32le()?; //microsec per frame
 492     dmx.src.read_skip(4)?; //max frame size
 493     dmx.src.read_skip(4)?; //padding
 494     dmx.src.read_u32le()?; //flags
 495     let frames = dmx.src.read_u32le()?; //frames
 496     dmx.src.read_skip(4)?; //initial frames
 497     let streams = dmx.src.read_u32le()?; //streams
 498     if streams > 100 { return Err(InvalidData); }
 499     dmx.num_streams = streams as u8;
 500
 501     dmx.src.read_skip(4)?; //buf size
 502     let width = dmx.src.read_u32le()?; //width
 503     let height = dmx.src.read_u32le()? as i32; //height
 504     dmx.src.read_skip(16)?; //reserved
 505
 506     dmx.cur_frame.resize(streams as usize, 0);
 507     dmx.src.read_skip(size - 0x38)?;
 508     Ok(size)
 509 }
 510
 511 #[allow(unused_variables)]
 512 fn parse_junk(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 513     dmx.src.read_skip(size)?;
 514     Ok(size)
 515 }
 516
 517 #[allow(clippy::verbose_bit_mask)]
 518 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> {
 519     validate!((size & 15) == 0);
 520     let mut tag = [0u8; 4];
 521     let num_entries = size >> 4;
 522     let mut counter = [0u64; 100];
 523     let mut add_offset = 0;
 524     let mut set_offset = false;
 525     for _ in 0..num_entries {
 526                               src.read_buf(&mut tag)?;
 527         let flags           = src.read_u32le()?;
 528         let mut offset      = src.read_u32le()? as u64;
 529         let _length         = src.read_u32le()?;
 530
 531         if !set_offset && offset < movi_pos {
 532             add_offset = movi_pos - offset;
 533         }
 534         set_offset = true;
 535
 536         offset += add_offset;
 537
 538         if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
 539             return Err(InvalidData);
 540         }
 541         let stream_no = ((tag[0] - b'0') * 10 + (tag[1] - b'0')) as usize;
 542
 543         if (flags & 0x10) != 0 {
 544             if let Some(str) = strmgr.get_stream(stream_no) {
 545                 if str.get_media_type() == StreamType::Video {
 546                     let (tb_num, tb_den) = str.get_timebase();
 547                     let pts = counter[stream_no];
 548                     let time = NATimeInfo::ts_to_time(pts, 1000, tb_num, tb_den);
 549                     validate!(offset >= movi_pos);
 550                     seek_idx.add_entry(stream_no as u32, SeekEntry { time, pts, pos: offset });
 551                 }
 552                 key_offs.push(offset);
 553             }
 554         }
 555         counter[stream_no] += 1;
 556     }
 557     key_offs.sort_unstable();
 558     Ok(size)
 559 }
 560
 561 pub struct AVIDemuxerCreator { }
 562
 563 impl DemuxerCreator for AVIDemuxerCreator {
 564     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
 565         Box::new(AVIDemuxer::new(br))
 566     }
 567     fn get_name(&self) -> &'static str { "avi" }
 568 }
 569
 570 #[cfg(test)]
 571 mod test {
 572     use super::*;
 573     use std::fs::File;
 574
 575     #[test]
 576     fn test_avi_demux() {
 577         let mut file = File::open("assets/Indeo/laser05.avi").unwrap();
 578         let mut fr = FileReader::new_read(&mut file);
 579         let mut br = ByteReader::new(&mut fr);
 580         let mut dmx = AVIDemuxer::new(&mut br);
 581         let mut sm = StreamManager::new();
 582         let mut si = SeekIndex::new();
 583         dmx.open(&mut sm, &mut si).unwrap();
 584
 585         loop {
 586             let pktres = dmx.get_frame(&mut sm);
 587             if let Err(e) = pktres {
 588                 if e == DemuxerError::EOF { break; }
 589                 panic!("error");
 590             }
 591             let pkt = pktres.unwrap();
 592             println!("Got {}", pkt);
 593         }
 594     }
 595 }