clearvideo: support overlapping mode

[nihav.git] / nihav-commonfmt / src / demuxers / mov.rs

diff --git a/nihav-commonfmt/src/demuxers/mov.rs b/nihav-commonfmt/src/demuxers/mov.rs
index 847d494877711700b13769dfc6c07bf6a8b89ba6..8e448faae2416783665f29bedb48f4ce6c882a4c 100644 (file)
--- a/nihav-commonfmt/src/demuxers/mov.rs
+++ b/nihav-commonfmt/src/demuxers/mov.rs
@@ -343,11 +343,29 @@ fn read_mdia(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult
 }
 
 const MDIA_CHUNK_HANDLERS: &[TrackChunkHandler] = &[
-    TrackChunkHandler { ctype: mktag!(b"mdhd"), parse: skip_chunk },
+    TrackChunkHandler { ctype: mktag!(b"mdhd"), parse: read_mdhd },
     TrackChunkHandler { ctype: mktag!(b"hdlr"), parse: read_hdlr },
     TrackChunkHandler { ctype: mktag!(b"minf"), parse: read_minf },
 ];
 
+fn read_mdhd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
+    const KNOWN_MDHD_SIZE: u64 = 24;
+    validate!(size >= KNOWN_MDHD_SIZE);
+    let version             = br.read_byte()?;
+    validate!(version == 0);
+    let flags               = br.read_u24be()?;
+    validate!(flags == 0);
+    let _ctime              = br.read_u32be()?;
+    let _mtime              = br.read_u32be()?;
+    track.tb_den            = br.read_u32be()?;
+    validate!(track.tb_den != 0);
+    track.duration          = br.read_u32be()?;
+    let _language           = br.read_u16be()?;
+    let _quality            = br.read_u16be()?;
+
+    Ok(KNOWN_MDHD_SIZE)
+}
+
 fn read_hdlr(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
     const KNOWN_HDLR_SIZE: u64 = 24;
     validate!(size >= KNOWN_HDLR_SIZE);
@@ -587,8 +605,21 @@ fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult
             let format = if depth > 8 { RGB24_FORMAT } else { PAL8_FORMAT };
             let mut vhdr = NAVideoInfo::new(width, height, false, format);
             vhdr.bits = depth as u8;
+            //skip various common atoms
+            while br.tell() - start_pos + 4 < size {
+                let mut buf = [0u8; 8];
+                br.peek_buf(&mut buf)?;
+                let tsize = read_u32be(&buf).unwrap() as usize;
+                let tag = &buf[4..8];
+                validate!(tsize >= 8);
+                match tag {
+                    b"pasp" | b"clap" => {
+                        br.read_skip(tsize)?;
+                    },
+                    _ => break,
+                };
+            }
             let edata = if br.tell() - start_pos + 4 < size {
-//todo skip various common atoms
                     let edata_size  = br.read_u32be()? as usize;
                     validate!(edata_size >= 4);
                     let mut buf = vec![0; edata_size - 4];
@@ -683,11 +714,12 @@ fn read_stts(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult
         if let Some(ref mut stream) = track.stream {
             let tb_den = stream.tb_den;
             let (tb_num, tb_den) = reduce_timebase(tb_num * stream.tb_num, tb_den);
-            stream.duration /= u64::from(stream.tb_den / tb_den);
+            stream.duration /= u64::from(track.tb_div);
             stream.tb_num = tb_num;
             stream.tb_den = tb_den;
             track.tb_num = tb_num;
             track.tb_den = tb_den;
+            track.duration /= track.tb_div;
         }
     } else {
         track.time_to_sample.truncate(0);
@@ -1208,8 +1240,37 @@ impl Track {
                         self.samples_left = csamp - self.cur_sample;
                         self.cur_chunk += 1;
                     }
-                } else {
+                } else if self.chunk_offsets.len() == self.chunk_sizes.len() {
                     self.cur_chunk = self.cur_sample;
+                } else {
+                    let mut csamp = 0;
+                    self.cur_chunk = 0;
+                    let mut cmap = self.sample_map.iter();
+                    let mut cur_samps = 0;
+                    let (mut next_idx, mut next_samples) = cmap.next().unwrap();
+                    loop {
+                        if self.cur_chunk + 1 == next_idx as usize {
+                            self.samples_left = cur_samps;
+                            cur_samps = next_samples as usize;
+                            if let Some((new_idx, new_samples)) = cmap.next() {
+                                next_idx = *new_idx;
+                                next_samples = *new_samples;
+                            }
+                        }
+                        csamp += cur_samps;
+                        if csamp > self.cur_sample {
+                            if self.cur_chunk >= self.chunk_offsets.len() {
+                                return Err(DemuxerError::SeekError);
+                            }
+                            self.last_offset = self.chunk_offsets[self.cur_chunk];
+                            break;
+                        }
+                        self.cur_chunk += 1;
+                    }
+                    self.cur_sample = csamp - cur_samps;
+                    self.samples_left = cur_samps;
+                    self.last_offset = self.chunk_offsets[self.cur_chunk];
+                    self.cur_chunk += 1;
                 }
             } else {
                 self.cur_chunk = self.cur_sample;
@@ -1293,11 +1354,33 @@ impl<'a> DemuxCore<'a> for MOVDemuxer<'a> {
     fn seek(&mut self, time: NATimePoint, seek_index: &SeekIndex) -> DemuxerResult<()> {
         let ret = seek_index.find_pos(time);
         if ret.is_none() {
+            if let NATimePoint::Milliseconds(_) = time {
+                let mut aonly = true;
+                for track in self.tracks.iter() {
+                    if track.stream_type != StreamType::Audio || !track.raw_audio {
+                        aonly = false;
+                        break;
+                    }
+                }
+                if aonly {
+                    for track in self.tracks.iter_mut() {
+                        track.seek(0, time)?;
+                    }
+                    return Ok(());
+                }
+            }
             return Err(DemuxerError::SeekError);
         }
         let seek_info = ret.unwrap();
+        let tbn = self.tracks[seek_info.str_id as usize].tb_num;
+        let tbd = self.tracks[seek_info.str_id as usize].tb_den;
         for track in self.tracks.iter_mut() {
-            track.seek(seek_info.pts, time)?;
+            let cur_pts = if track.track_id == seek_info.str_id {
+                    seek_info.pts
+                } else {
+                    seek_info.pts * u64::from(tbn) * u64::from(track.tb_den) / (u64::from(tbd) * u64::from(track.tb_num))
+                };
+            track.seek(cur_pts, time)?;
         }
         Ok(())
     }