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