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