nihav-commonfmt/src/demuxers/avi.rs

   1 use nihav_core::demuxers::*;
   2 use nihav_registry::register;
   3 use nihav_core::demuxers::DemuxerError::*;
   4 use std::str::FromStr;
   5
   6 macro_rules! mktag {
   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)
   9     });
  10     ($arr:expr) => ({
  11         (($arr[0] as u32) << 24) | (($arr[1] as u32) << 16) | (($arr[2] as u32) << 8) | ($arr[3] as u32)
  12     });
  13 }
  14
  15 struct StreamState {
  16     strm_no:    u8,
  17     got_strf:   bool,
  18     strm_type:  Option<StreamType>,
  19 }
  20
  21 impl StreamState {
  22     fn new() -> Self {
  23         StreamState { strm_no: 0, got_strf: true, strm_type: None }
  24     }
  25     fn reset(&mut self) {
  26         self.strm_type = None;
  27         self.got_strf  = true;
  28         self.strm_no  += 1;
  29     }
  30     fn valid_state(&self) -> bool {
  31         match self.strm_type {
  32             None => self.got_strf,
  33             _    => false,
  34         }
  35     }
  36 }
  37
  38 struct PalInfo {
  39     pal:        Arc<[u8; 1024]>,
  40     changed:    bool,
  41     stream_no:  usize,
  42 }
  43
  44 #[derive(Clone,Copy,Default)]
  45 struct RIFFSegment {
  46     pos:        u64,
  47     size:       usize,
  48     movi_pos:   u64,
  49     movi_size:  usize,
  50 }
  51
  52 impl RIFFSegment {
  53     fn contains(&self, pos: u64) -> bool {
  54         pos >= self.movi_pos && pos < self.movi_pos + (self.movi_size as u64)
  55     }
  56     fn get_end(&self) -> u64 {
  57         self.pos + (self.size as u64)
  58     }
  59 }
  60
  61 #[allow(dead_code)]
  62 struct AVIDemuxer<'a> {
  63     src:            &'a mut ByteReader<'a>,
  64     cur_frame:      Vec<u64>,
  65     num_streams:    u8,
  66     size:           usize,
  67     movi_size:      usize,
  68     movi_pos:       u64,
  69     movi_orig:      usize,
  70     sstate:         StreamState,
  71     tb_num:         u32,
  72     tb_den:         u32,
  73     strm_duration:  u32,
  74     key_offs:       Vec<u64>,
  75     pal:            Vec<PalInfo>,
  76     odml:           bool,
  77     odml_idx:       Vec<u64>,
  78     odml_riff:      Vec<RIFFSegment>,
  79 }
  80
  81 #[derive(Debug,Clone,Copy,PartialEq)]
  82 enum RIFFTag {
  83     Chunk(u32),
  84     List(u32,u32),
  85 }
  86
  87 struct RIFFParser {
  88     tag:   RIFFTag,
  89     parse: fn(&mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize>,
  90 }
  91
  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)?;
  95         Ok(())
  96     }
  97
  98     fn get_frame(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<NAPacket> {
  99         if self.movi_size == 0 {
 100             if !self.odml {
 101                 return Err(EOF);
 102             }
 103             self.try_next_odml_chunk()?;
 104         }
 105         let mut tag: [u8; 4] = [0; 4];
 106         loop {
 107             if (self.src.tell() & 1) == 1 {
 108                 self.src.read_skip(1)?;
 109                 self.movi_size -= 1;
 110                 if self.movi_size == 0 {
 111                     if !self.odml {
 112                         return Err(EOF);
 113                     }
 114                     self.try_next_odml_chunk()?;
 115                 }
 116             }
 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 {
 124                     if !self.odml {
 125                         return Err(EOF);
 126                     }
 127                     self.try_next_odml_chunk()?;
 128                 }
 129                 continue;
 130             }
 131             if mktag!(tag) == mktag!(b"LIST") {
 132                 self.movi_size -= 12;
 133                 self.src.read_skip(4)?;
 134                 if self.movi_size == 0 {
 135                     if !self.odml {
 136                         return Err(EOF);
 137                     }
 138                     self.try_next_odml_chunk()?;
 139                 }
 140                 continue;
 141             }
 142             if (tag[0] == b'i' && tag[1] == b'x') || (&tag == b"idx1") {
 143                 let idx_pos = self.src.tell() - 8;
 144                 if !self.odml {
 145                     return Err(EOF);
 146                 }
 147                 self.src.read_skip(size)?;
 148                 if idx_pos > self.movi_pos {
 149                     self.try_next_odml_chunk()?;
 150                 } else {
 151                     self.movi_pos = self.src.tell();
 152                 }
 153                 continue;
 154             }
 155             if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
 156                 return Err(InvalidData);
 157             }
 158             let stream_no = (tag[0] - b'0') * 10 + (tag[1] - b'0');
 159             if tag[2] == b'p' && tag[3] == b'c' {
 160                 self.parse_palette_change(stream_no as usize, size)?;
 161                 self.movi_size -= size;
 162                 if self.movi_size == 0 {
 163                     if !self.odml {
 164                         return Err(EOF);
 165                     }
 166                     self.try_next_odml_chunk()?;
 167                 }
 168                 continue;
 169             }
 170             let stream = strmgr.get_stream(stream_no as usize);
 171             if stream.is_none() {
 172                 self.src.read_skip(size)?;
 173                 self.movi_size -= size + 8;
 174                 continue;
 175             }
 176             let stream = stream.unwrap();
 177             if size == 0 {
 178                 self.movi_size -= 8;
 179                 if self.movi_size == 0 {
 180                     if !self.odml {
 181                         return Err(EOF);
 182                     }
 183                     self.try_next_odml_chunk()?;
 184                 }
 185                 continue;
 186             }
 187             let (tb_num, _) = stream.get_timebase();
 188             let mut ts = stream.make_ts(Some(self.cur_frame[stream_no as usize]), None, None);
 189             if stream.get_media_type() == StreamType::Audio && tb_num == 1 && stream.get_info().get_name() == "pcm" {
 190                 ts.pts = None;
 191             }
 192             let mut pkt = self.src.read_packet(stream, ts, is_keyframe, size)?;
 193             for pe in self.pal.iter_mut() {
 194                 if pe.stream_no == (stream_no as usize) {
 195                     pkt.add_side_data(NASideData::Palette(pe.changed, pe.pal.clone()));
 196                     pe.changed = false;
 197                     break;
 198                 }
 199             }
 200             self.cur_frame[stream_no as usize] += 1;
 201             self.movi_size -= size + 8;
 202
 203             return Ok(pkt);
 204         }
 205     }
 206
 207     fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> {
 208         let ret = seek_index.find_pos(time);
 209         if ret.is_none() {
 210             return Err(DemuxerError::SeekError);
 211         }
 212         let seek_info = ret.unwrap();
 213
 214         if self.odml && ((seek_info.pos < self.movi_pos) || (seek_info.pos > self.movi_pos + (self.movi_orig as u64))) {
 215             let mut found = false;
 216             for riff_seg in self.odml_riff.iter() {
 217                 if riff_seg.contains(seek_info.pos) {
 218                     found = true;
 219                     self.movi_pos = riff_seg.movi_pos;
 220                     self.movi_orig = riff_seg.movi_size;
 221                     self.movi_size = riff_seg.movi_size;
 222                     break;
 223                 }
 224             }
 225             if !found {
 226                 let riff_seg = self.odml_riff.last().unwrap();
 227                 self.src.seek(SeekFrom::Start(riff_seg.get_end()))?;
 228                 loop {
 229                     let ret = self.try_next_odml_chunk();
 230                     if ret.is_err() {
 231                         return Err(DemuxerError::SeekError);
 232                     }
 233                     let riff_seg = self.odml_riff.last().unwrap();
 234                     if riff_seg.contains(seek_info.pos) {
 235                         self.movi_pos = riff_seg.movi_pos;
 236                         self.movi_orig = riff_seg.movi_size;
 237                         self.movi_size = riff_seg.movi_size;
 238                         break;
 239                     }
 240                     self.src.seek(SeekFrom::Start(riff_seg.get_end()))?;
 241                 }
 242             }
 243         }
 244         if seek_info.pos < self.movi_pos { return Err(DemuxerError::SeekError); }
 245         let skip_size = (seek_info.pos - self.movi_pos) as usize;
 246         if skip_size > self.movi_orig { return Err(DemuxerError::SeekError); }
 247         self.movi_size = self.movi_orig - skip_size;
 248
 249         self.cur_frame[seek_info.str_id as usize] = seek_info.pts;
 250         self.src.seek(SeekFrom::Start(seek_info.pos))?;
 251
 252         Ok(())
 253     }
 254     fn get_duration(&self) -> u64 { 0 }
 255 }
 256
 257 impl<'a> NAOptionHandler for AVIDemuxer<'a> {
 258     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
 259     fn set_options(&mut self, _options: &[NAOption]) { }
 260     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
 261 }
 262
 263 impl<'a> AVIDemuxer<'a> {
 264     fn new(io: &'a mut ByteReader<'a>) -> Self {
 265         AVIDemuxer {
 266             cur_frame: Vec::new(),
 267             num_streams: 0,
 268             src: io,
 269             size: 0,
 270             movi_size: 0,
 271             movi_pos:  0,
 272             movi_orig: 0,
 273             sstate: StreamState::new(),
 274             tb_num: 0,
 275             tb_den: 0,
 276             strm_duration: 0,
 277             key_offs: Vec::new(),
 278             pal: Vec::new(),
 279             odml: false,
 280             odml_idx: Vec::new(),
 281             odml_riff: Vec::with_capacity(1),
 282         }
 283     }
 284
 285     fn parse_chunk(&mut self, strmgr: &mut StreamManager, end_tag: RIFFTag, csize: usize, depth: u16) -> DemuxerResult<(usize, bool)> {
 286         if csize < 8 { return Err(InvalidData); }
 287         if depth > 42 { return Err(InvalidData); }
 288
 289         let tag  = self.src.read_u32be()?;
 290         let size = self.src.read_u32le()? as usize;
 291         if size > csize { return Err(InvalidData); }
 292         if RIFFTag::Chunk(tag) == end_tag {
 293             return Ok((size, true));
 294         }
 295         let is_list = is_list_tag(tag);
 296         let ltag = if is_list { self.src.read_u32be()? } else { 0 };
 297         if RIFFTag::List(tag, ltag) == end_tag {
 298             return Ok((size, true));
 299         }
 300
 301         for chunk in CHUNKS.iter() {
 302             if RIFFTag::Chunk(tag) == chunk.tag {
 303                 let psize = (chunk.parse)(self, strmgr, size)?;
 304                 if psize != size { return Err(InvalidData); }
 305                 if (psize & 1) == 1 { self.src.read_skip(1)?; }
 306                 return Ok((size + 8, false));
 307             }
 308             if RIFFTag::List(tag, ltag) == chunk.tag {
 309                 let mut rest_size = size - 4;
 310                 let psize = (chunk.parse)(self, strmgr, rest_size)?;
 311                 if psize > rest_size { return Err(InvalidData); }
 312                 rest_size -= psize;
 313                 while rest_size > 0 {
 314                     let (psize, _) = self.parse_chunk(strmgr, end_tag, rest_size, depth+1)?;
 315                     if psize > rest_size { return Err(InvalidData); }
 316                     rest_size -= psize;
 317                     if ((psize & 1) == 1) && (rest_size > 0) {
 318                         rest_size -= 1;
 319                     }
 320                 }
 321
 322                 return Ok((size + 8, false));
 323             }
 324         }
 325         if !is_list {
 326             self.src.read_skip(size)?;
 327         } else {
 328             if size < 4 { return Err(InvalidData); }
 329             self.src.read_skip(size - 4)?;
 330         }
 331         if (size & 1) == 1 { self.src.read_skip(1)?; }
 332         Ok((size + 8, false))
 333     }
 334
 335     fn read_header(&mut self, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex) -> DemuxerResult<()> {
 336         let riff_tag = self.src.read_u32be()?;
 337         let size     = self.src.read_u32le()? as usize;
 338         self.odml_riff.push(RIFFSegment { pos: self.src.tell() - 8, size: size + 8, movi_pos: 0, movi_size: 0});
 339         let avi_tag  = self.src.read_u32be()?;
 340         let mut matches = false;
 341         for rt in RIFF_TAGS.iter() {
 342             if rt[0] == riff_tag && rt[1] == avi_tag {
 343                 matches = true;
 344                 break;
 345             }
 346         }
 347         if !matches {
 348             return Err(InvalidData);
 349         }
 350         self.size = size;
 351         let mut rest_size = size;
 352         loop {
 353             let (csz, end) = self.parse_chunk(strmgr, RIFFTag::List(mktag!(b"LIST"), mktag!(b"movi")), rest_size,0)?;
 354             if end {
 355                 self.movi_size = csz - 4;
 356                 self.movi_orig = self.movi_size;
 357                 self.movi_pos = self.src.tell();
 358
 359                 self.odml_riff[0].movi_pos  = self.movi_pos;
 360                 self.odml_riff[0].movi_size = self.movi_size;
 361                 break;
 362             }
 363             rest_size -= csz;
 364         }
 365         if !seek_idx.skip_index {
 366             if !self.odml {
 367                 self.src.read_skip(self.movi_size)?;
 368                 while rest_size > 0 {
 369                     let ret = self.parse_chunk(strmgr, RIFFTag::Chunk(mktag!(b"idx1")), rest_size,0);
 370                     if ret.is_err() { break; }
 371                     let (csz, end) = ret.unwrap();
 372                     if end {
 373                         let _res = parse_idx1(self.src, strmgr, seek_idx, csz, self.movi_pos, &mut self.key_offs);
 374                         break;
 375                     }
 376                     rest_size -= csz;
 377                 }
 378             } else {
 379                 let mut start = 0;
 380                 let mut last_strm_no = 255;
 381                 for &offset in self.odml_idx.iter() {
 382                     if self.src.seek(SeekFrom::Start(offset)).is_err() {
 383                         break;
 384                     }
 385                     let ret = self.src.read_tag();
 386                     if ret.is_err() { break; }
 387                     let tag = ret.unwrap();
 388                     let ret = self.src.read_u32le();
 389                     if ret.is_err() { break; }
 390                     let size = ret.unwrap() as usize;
 391                     if &tag[..2] != b"ix" || tag[2] < b'0' || tag[2] > b'9' || tag[3] < b'0' || tag[3] > b'9'{
 392                         break;
 393                     }
 394                     let stream_no = ((tag[2] - b'0') * 10 + (tag[3] - b'0')) as usize;
 395
 396                     if last_strm_no != stream_no {
 397                         start = 0;
 398                         last_strm_no = stream_no;
 399                     }
 400                     let ret = parse_odml_ix(self.src, strmgr, seek_idx, stream_no, size, start);
 401                     if let Ok(new_start) = ret {
 402                         start = new_start;
 403                     } else {
 404                         break;
 405                     }
 406                 }
 407             }
 408         }
 409         if self.movi_pos != 0 {
 410             self.src.seek(SeekFrom::Start(self.movi_pos))?;
 411         } else {
 412             return Err(InvalidData);
 413         }
 414         if !self.sstate.valid_state() || self.sstate.strm_no != self.num_streams {
 415             return Err(InvalidData);
 416         }
 417         Ok(())
 418     }
 419
 420     fn read_extradata(&mut self, size: usize) -> DemuxerResult<Option<Vec<u8>>> {
 421         if size == 0 { return Ok(None); }
 422         let mut edvec: Vec<u8> = vec![0; size];
 423         self.src.read_buf(&mut edvec)?;
 424         Ok(Some(edvec))
 425     }
 426
 427     fn parse_palette_change(&mut self, stream_no: usize, size: usize) -> DemuxerResult<()> {
 428         for pe in self.pal.iter_mut() {
 429             if pe.stream_no == stream_no {
 430                 let mut newpal = *pe.pal;
 431                 let mut data_left = size;
 432                 while data_left > 0 {
 433                     validate!(data_left >= 8);
 434                     let start_clr       = self.src.read_byte()? as usize;
 435                     let len             = self.src.read_byte()? as usize;
 436                     let len = if len == 0 { 256 } else { len };
 437                     let _flags          = self.src.read_u16le()?;
 438                     validate!(start_clr + len <= 256);
 439                     let change_size = len * 4 + 4;
 440                     validate!(change_size <= data_left);
 441                     for i in start_clr..(start_clr + len) {
 442                         newpal[i * 4]       = self.src.read_byte()?;
 443                         newpal[i * 4 + 1]   = self.src.read_byte()?;
 444                         newpal[i * 4 + 2]   = self.src.read_byte()?;
 445                         newpal[i * 4 + 3]   = 0;
 446                                           self.src.read_byte()?; // flags
 447                     }
 448                     data_left -= change_size;
 449                 }
 450                 pe.pal = Arc::new(newpal);
 451                 pe.changed = true;
 452                 return Ok(());
 453             }
 454         }
 455         self.src.read_skip(size)?;
 456         Ok(())
 457     }
 458     fn try_next_odml_chunk(&mut self) -> DemuxerResult<()> {
 459         let last_seg = self.odml_riff.last().unwrap();
 460         if self.src.tell() < last_seg.get_end() {
 461             for riff_seg in self.odml_riff.iter() {
 462                 if riff_seg.pos >= self.src.tell() {
 463                     self.src.seek(SeekFrom::Start(riff_seg.movi_pos))?;
 464                     self.movi_pos = riff_seg.movi_pos;
 465                     self.movi_size = riff_seg.movi_size;
 466                     return Ok(());
 467                 }
 468             }
 469         }
 470         self.src.seek(SeekFrom::Start(last_seg.get_end()))?;
 471
 472         let riff_pos = self.src.tell();
 473         let ret = self.src.read_tag();
 474         if let Ok([b'R', b'I', b'F', b'F']) = ret {
 475         } else {
 476             return Err(DemuxerError::EOF);
 477         }
 478         let riff_size = self.src.read_u32le()? as usize;
 479         let tag = self.src.read_tag()?;
 480         validate!(&tag == b"AVIX");
 481         let tag = self.src.read_tag()?;
 482         validate!(&tag == b"LIST");
 483         let list_size = self.src.read_u32le()? as usize;
 484         validate!(list_size >= 4);
 485         let tag = self.src.read_tag()?;
 486         validate!(&tag == b"movi");
 487         self.odml_riff.push(RIFFSegment{ pos: riff_pos, size: riff_size + 8, movi_pos: riff_pos + 24, movi_size: list_size - 4});
 488         self.movi_pos = riff_pos + 24;
 489         self.movi_size = list_size - 4;
 490         self.movi_orig = self.movi_size;
 491
 492         Ok(())
 493     }
 494 }
 495
 496 const RIFF_TAGS: &[[u32; 2]] = &[
 497     [ mktag!(b"RIFF"), mktag!(b"AVI ") ],
 498     [ mktag!(b"RIFF"), mktag!(b"AVIX") ],
 499     [ mktag!(b"ON2 "), mktag!(b"ON2f") ],
 500 ];
 501
 502 const CHUNKS: &[RIFFParser] = &[
 503     RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"hdrl")), parse: parse_hdrl },
 504     RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"strl")), parse: parse_strl },
 505     RIFFParser { tag: RIFFTag::Chunk(mktag!(b"avih")), parse: parse_avih },
 506     RIFFParser { tag: RIFFTag::Chunk(mktag!(b"ON2h")), parse: parse_avih },
 507     RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strf")), parse: parse_strf },
 508     RIFFParser { tag: RIFFTag::Chunk(mktag!(b"strh")), parse: parse_strh },
 509     RIFFParser { tag: RIFFTag::Chunk(mktag!(b"indx")), parse: parse_indx },
 510     RIFFParser { tag: RIFFTag::Chunk(mktag!(b"JUNK")), parse: parse_junk },
 511     RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"odml")), parse: parse_odml },
 512     RIFFParser { tag: RIFFTag::List(mktag!(b"LIST"), mktag!(b"rec ")), parse: parse_rec },
 513 ];
 514
 515 fn is_list_tag(tag: u32) -> bool {
 516     for chunk in CHUNKS.iter() {
 517         if let RIFFTag::List(ltag, _) = chunk.tag {
 518             if tag == ltag {
 519                 return true;
 520             }
 521         }
 522     }
 523     false
 524 }
 525
 526 #[allow(unused_variables)]
 527 fn parse_hdrl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 528     Ok(0)
 529 }
 530
 531 #[allow(unused_variables)]
 532 fn parse_strl(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 533     Ok(0)
 534 }
 535
 536 fn parse_odml(dmx: &mut AVIDemuxer, _strmgr: &mut StreamManager, _size: usize) -> DemuxerResult<usize> {
 537     dmx.odml = true;
 538     Ok(0)
 539 }
 540
 541 fn parse_rec(_dmx: &mut AVIDemuxer, _strmgr: &mut StreamManager, _size: usize) -> DemuxerResult<usize> {
 542     Ok(0)
 543 }
 544
 545 #[allow(unused_variables)]
 546 fn parse_strh(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 547     if size < 0x38 { return Err(InvalidData); }
 548     let tag = dmx.src.read_u32be()?; //stream type
 549     let fcc = dmx.src.read_u32be()?; //handler(fourcc)
 550     dmx.src.read_u32le()?; //flags
 551     dmx.src.read_skip(2)?; //priority
 552     dmx.src.read_skip(2)?; //language
 553     dmx.src.read_skip(4)?; //initial frames
 554     dmx.tb_num = dmx.src.read_u32le()?; //scale
 555     dmx.tb_den = dmx.src.read_u32le()?; //rate
 556     dmx.src.read_skip(4)?; //start
 557     dmx.strm_duration = dmx.src.read_u32le()?;
 558     dmx.src.read_skip(4)?; //buf size
 559     dmx.src.read_skip(4)?; //quality
 560     dmx.src.read_skip(4)?; //sample size
 561     let a = dmx.src.read_u16le()?;
 562     let b = dmx.src.read_u16le()?;
 563     let c = dmx.src.read_u16le()?;
 564     let d = dmx.src.read_u16le()?;
 565
 566     dmx.src.read_skip(size - 0x38)?;
 567
 568     if !dmx.sstate.valid_state() || dmx.sstate.strm_no >= dmx.num_streams {
 569         return Err(InvalidData);
 570     }
 571     if tag == mktag!(b"vids") {
 572         dmx.sstate.strm_type = Some(StreamType::Video);
 573     } else if tag == mktag!(b"auds") {
 574         dmx.sstate.strm_type = Some(StreamType::Audio);
 575     } else {
 576         dmx.sstate.strm_type = Some(StreamType::Data);
 577     }
 578     dmx.sstate.got_strf = false;
 579
 580     Ok(size)
 581 }
 582
 583 fn parse_strf(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 584     if dmx.sstate.strm_type.is_none() { return Err(InvalidData); }
 585     match dmx.sstate.strm_type.unwrap() {
 586         StreamType::Video    => parse_strf_vids(dmx, strmgr, size),
 587         StreamType::Audio    => parse_strf_auds(dmx, strmgr, size),
 588         _                    => parse_strf_xxxx(dmx, strmgr, size),
 589     }
 590 }
 591
 592 #[allow(unused_variables)]
 593 fn parse_strf_vids(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 594     if size < 40 { return Err(InvalidData); }
 595     let bi_size         = dmx.src.read_u32le()?;
 596     if (bi_size as usize) < 40 { return Err(InvalidData); }
 597     let width           = dmx.src.read_u32le()?;
 598     let height          = dmx.src.read_u32le()? as i32;
 599     let planes          = dmx.src.read_u16le()?;
 600     let bitcount        = dmx.src.read_u16le()?;
 601     let mut compression: [u8; 4] = [0; 4];
 602                           dmx.src.read_buf(&mut compression)?;
 603     let img_size        = dmx.src.read_u32le()?;
 604     let xdpi            = dmx.src.read_u32le()?;
 605     let ydpi            = dmx.src.read_u32le()?;
 606     let colors          = dmx.src.read_u32le()?;
 607     validate!(colors <= 256);
 608     let imp_colors      = dmx.src.read_u32le()?;
 609
 610     let flip = height < 0;
 611     let format = if bitcount > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
 612     let mut vhdr = NAVideoInfo::new(width as usize, if flip { -height as usize } else { height as usize}, flip, format);
 613     vhdr.bits = (planes as u8) * (bitcount as u8);
 614     let cname = if find_raw_rgb_fmt(&compression, planes, bitcount, flip, &mut vhdr) {
 615             "rawvideo-ms"
 616         } else if find_raw_yuv_fmt(&compression, &mut vhdr) {
 617             "rawvideo"
 618         } else {
 619             match register::find_codec_from_avi_fourcc(&compression) {
 620                 None => "unknown",
 621                 Some(name) => name,
 622             }
 623         };
 624     let vci = NACodecTypeInfo::Video(vhdr);
 625     let edata = dmx.read_extradata(size - 40)?;
 626     if colors > 0 {
 627         if let Some(ref buf) = edata {
 628             let mut pal = [0u8; 1024];
 629             for (dpal, spal) in pal.chunks_mut(4).take(colors as usize).zip(buf.chunks(4)) {
 630                 dpal[0] = spal[2];
 631                 dpal[1] = spal[1];
 632                 dpal[2] = spal[0];
 633                 dpal[3] = 0;
 634             }
 635             let pal = PalInfo { pal: Arc::new(pal), changed: true, stream_no: strmgr.get_num_streams() };
 636             dmx.pal.push(pal);
 637         }
 638     }
 639     let vinfo = NACodecInfo::new(cname, vci, edata);
 640     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)));
 641     if res.is_none() { return Err(MemoryError); }
 642     dmx.sstate.reset();
 643     Ok(size)
 644 }
 645
 646 fn find_raw_rgb_fmt(compr: &[u8; 4], planes: u16, bitcount: u16, flip: bool, vhdr: &mut NAVideoInfo) -> bool {
 647     match compr {
 648         &[0, 0, 0, 0] | b"DIB " => {
 649             if planes != 1 {
 650                 return false;
 651             }
 652             let fmt_name = match bitcount {
 653                      8 => "pal8",
 654                     16 => "bgr555",
 655                     24 => "bgr24",
 656                     32 => "bgra24",
 657                     _ => return false,
 658                 };
 659             if let Ok(fmt) = NAPixelFormaton::from_str(fmt_name) {
 660                 vhdr.format = fmt;
 661                 vhdr.flipped = !flip;
 662                 true
 663             } else {
 664                 false
 665             }
 666         },
 667         _ => false,
 668     }
 669 }
 670
 671 fn find_raw_yuv_fmt(compr: &[u8; 4], vhdr: &mut NAVideoInfo) -> bool {
 672     let (fmt_name, swapuv) = match compr {
 673             b"UYVY" | b"UYNY" | b"UYNV" | b"2vuy" => ("uyvy", false),
 674             b"I420" | b"IYUV" => ("yuv420p", false),
 675             b"YV12" => ("yuv420p", true),
 676             b"YVU9" => ("yuv410p", true),
 677             _ => return false,
 678         };
 679     if let Ok(fmt) = NAPixelFormaton::from_str(fmt_name) {
 680         vhdr.format = fmt;
 681         if swapuv {
 682             vhdr.format.comp_info.swap(1, 2);
 683         }
 684         true
 685     } else {
 686         false
 687     }
 688 }
 689
 690 #[allow(unused_variables)]
 691 fn parse_strf_auds(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 692     if size < 16 { return Err(InvalidData); }
 693     let w_format_tag        = dmx.src.read_u16le()?;
 694     let channels            = dmx.src.read_u16le()?;
 695     let samplespersec       = dmx.src.read_u32le()?;
 696     let avgbytespersec      = dmx.src.read_u32le()?;
 697     let block_align         = dmx.src.read_u16le()?;
 698     let bits_per_sample     = dmx.src.read_u16le()?;
 699
 700     let signed = bits_per_sample > 8;
 701     let soniton = NASoniton::new(bits_per_sample as u8, if signed { SONITON_FLAG_SIGNED } else { 0 });
 702     let ahdr = NAAudioInfo::new(samplespersec, channels as u8, soniton, block_align as usize);
 703     let edata = if size > 16 {
 704             let edata_size  = dmx.src.read_u16le()? as usize;
 705             validate!(edata_size + 18 <= size);
 706             dmx.read_extradata(size - 18)?
 707         } else {
 708             None
 709         };
 710     let cname = match register::find_codec_from_wav_twocc(w_format_tag) {
 711                     None => "unknown",
 712                     Some(name) => name,
 713                 };
 714     let ainfo = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
 715     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)));
 716     if res.is_none() { return Err(MemoryError); }
 717     dmx.sstate.reset();
 718     Ok(size)
 719 }
 720
 721 fn parse_strf_xxxx(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 722     let edata = dmx.read_extradata(size)?;
 723     let info = NACodecInfo::new("unknown", NACodecTypeInfo::None, edata);
 724     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)));
 725     if res.is_none() { return Err(MemoryError); }
 726     dmx.sstate.reset();
 727     Ok(size)
 728 }
 729
 730 #[allow(unused_variables)]
 731 fn parse_avih(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 732     if size < 0x38 { return Err(InvalidData); }
 733     let timebase = dmx.src.read_u32le()?; //microsec per frame
 734     dmx.src.read_skip(4)?; //max frame size
 735     dmx.src.read_skip(4)?; //padding
 736     dmx.src.read_u32le()?; //flags
 737     let frames = dmx.src.read_u32le()?; //frames
 738     dmx.src.read_skip(4)?; //initial frames
 739     let streams = dmx.src.read_u32le()?; //streams
 740     if streams > 100 { return Err(InvalidData); }
 741     dmx.num_streams = streams as u8;
 742
 743     dmx.src.read_skip(4)?; //buf size
 744     let width = dmx.src.read_u32le()?; //width
 745     let height = dmx.src.read_u32le()? as i32; //height
 746     dmx.src.read_skip(16)?; //reserved
 747
 748     dmx.cur_frame.resize(streams as usize, 0);
 749     dmx.src.read_skip(size - 0x38)?;
 750     Ok(size)
 751 }
 752
 753 fn parse_indx(dmx: &mut AVIDemuxer, _strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 754     dmx.odml = true;
 755     validate!(size >= 24);
 756     let entry_size = dmx.src.read_u16le()? as usize;
 757     if entry_size != 4 {
 758         dmx.src.read_skip(size - 2)?;
 759         return Ok(size);
 760     }
 761     let sub_type = dmx.src.read_byte()?;
 762     let idx_type = dmx.src.read_byte()?;
 763     validate!(sub_type == 0 && idx_type == 0);
 764     let entries = dmx.src.read_u32le()? as usize;
 765     validate!(size >= 24 + entries * 4 * entry_size);
 766     dmx.src.read_tag()?; //chunk id
 767     dmx.src.read_skip(12)?; // reserved
 768     for _ in 0..entries {
 769         let offset = dmx.src.read_u64le()?;
 770         let _idx_len = dmx.src.read_u32le()?;
 771         let _nframes = dmx.src.read_u32le()?;
 772         dmx.odml_idx.push(offset);
 773     }
 774     dmx.src.read_skip(size - 24 - entries * 4 * entry_size)?;
 775     Ok(size)
 776 }
 777
 778 #[allow(unused_variables)]
 779 fn parse_junk(dmx: &mut AVIDemuxer, strmgr: &mut StreamManager, size: usize) -> DemuxerResult<usize> {
 780     dmx.src.read_skip(size)?;
 781     Ok(size)
 782 }
 783
 784 #[allow(clippy::verbose_bit_mask)]
 785 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> {
 786     validate!((size & 15) == 0);
 787     let mut tag = [0u8; 4];
 788     let num_entries = size >> 4;
 789     let mut counter = [0u64; 100];
 790     let mut add_offset = 0;
 791     let mut set_offset = false;
 792     for _ in 0..num_entries {
 793                               src.read_buf(&mut tag)?;
 794         let flags           = src.read_u32le()?;
 795         let mut offset      = src.read_u32le()? as u64;
 796         let _length         = src.read_u32le()?;
 797
 798         if !set_offset && offset < movi_pos {
 799             add_offset = movi_pos - offset;
 800         }
 801         set_offset = true;
 802
 803         offset += add_offset;
 804
 805         if tag[0] < b'0' || tag[0] > b'9' || tag[1] < b'0' || tag[1] > b'9' {
 806             continue;
 807         }
 808         let stream_no = ((tag[0] - b'0') * 10 + (tag[1] - b'0')) as usize;
 809
 810         if (flags & 0x10) != 0 {
 811             if let Some(stream) = strmgr.get_stream(stream_no) {
 812                 if stream.get_media_type() == StreamType::Video {
 813                     let (tb_num, tb_den) = stream.get_timebase();
 814                     let pts = counter[stream_no];
 815                     let time = NATimeInfo::ts_to_time(pts, 1000, tb_num, tb_den);
 816                     validate!(offset >= movi_pos);
 817                     seek_idx.add_entry(stream_no as u32, SeekEntry { time, pts, pos: offset });
 818                 }
 819                 key_offs.push(offset);
 820             }
 821         }
 822         counter[stream_no] += 1;
 823     }
 824     key_offs.sort_unstable();
 825     Ok(size)
 826 }
 827
 828 fn parse_odml_ix(src: &mut ByteReader, strmgr: &mut StreamManager, seek_idx: &mut SeekIndex, stream_no: usize, size: usize, start: u64) -> DemuxerResult<u64> {
 829     validate!(size >= 24);
 830     let entry_size = src.read_u16le()? as usize;
 831     if entry_size != 2 {
 832         return Err(DemuxerError::NotImplemented);
 833     }
 834     let sub_type = src.read_byte()?;
 835     let idx_type = src.read_byte()?;
 836     validate!(sub_type == 0 && idx_type == 1);
 837     let entries = src.read_u32le()? as usize;
 838     validate!(size >= 24 + entries * 4 * entry_size);
 839     src.read_tag()?; //chunk id
 840     let base_offset = src.read_u64le()?;
 841     src.read_u32le()?; //reserved
 842     if let Some(stream) = strmgr.get_stream(stream_no) {
 843         if stream.get_media_type() == StreamType::Video {
 844             let (tb_num, tb_den) = stream.get_timebase();
 845
 846             for i in 0..entries {
 847                 let offset = src.read_u32le()?;
 848                 validate!(offset >= 8);
 849                 let _size  = src.read_u32le()?;
 850
 851                 let pts = start + (i as u64);
 852                 let time = NATimeInfo::ts_to_time(pts, 1000, tb_num, tb_den);
 853                 seek_idx.add_entry(stream_no as u32, SeekEntry { time, pts, pos: base_offset + u64::from(offset - 8) });
 854             }
 855
 856             Ok(start + (entries as u64))
 857         } else {
 858             Ok(0)
 859         }
 860     } else {
 861         Ok(0)
 862     }
 863 }
 864
 865 pub struct AVIDemuxerCreator { }
 866
 867 impl DemuxerCreator for AVIDemuxerCreator {
 868     fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
 869         Box::new(AVIDemuxer::new(br))
 870     }
 871     fn get_name(&self) -> &'static str { "avi" }
 872 }
 873
 874 #[cfg(test)]
 875 mod test {
 876     use super::*;
 877     use std::fs::File;
 878
 879     #[test]
 880     fn test_avi_demux() {
 881         //test sample: https://samples.mplayerhq.hu/V-codecs/RT21/320x240/laser05.avi
 882         let mut file = File::open("assets/Indeo/laser05.avi").unwrap();
 883         let mut fr = FileReader::new_read(&mut file);
 884         let mut br = ByteReader::new(&mut fr);
 885         let mut dmx = AVIDemuxer::new(&mut br);
 886         let mut sm = StreamManager::new();
 887         let mut si = SeekIndex::new();
 888         dmx.open(&mut sm, &mut si).unwrap();
 889
 890         loop {
 891             let pktres = dmx.get_frame(&mut sm);
 892             if let Err(e) = pktres {
 893                 if e == DemuxerError::EOF { break; }
 894                 panic!("error");
 895             }
 896             let pkt = pktres.unwrap();
 897             println!("Got {}", pkt);
 898         }
 899     }
 900 }