}
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);
TrackChunkHandler { ctype: mktag!(b"stsz"), parse: read_stsz },
TrackChunkHandler { ctype: mktag!(b"stco"), parse: read_stco },
TrackChunkHandler { ctype: mktag!(b"stsh"), parse: skip_chunk },
+ TrackChunkHandler { ctype: mktag!(b"ctts"), parse: read_ctts },
];
fn parse_audio_edata(br: &mut ByteReader, start_pos: u64, size: u64) -> DemuxerResult<Option<Vec<u8>>> {
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];
} else if entries == 1 {
let _count = br.read_u32be()?;
let tb_num = br.read_u32be()?;
+ validate!(tb_num != 0);
+ track.tb_div = tb_num;
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);
Ok(size)
}
+fn read_ctts(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
+ validate!(size >= 8);
+ let version = br.read_byte()?;
+ let _flags = br.read_u24be()?;
+ if version > 1 {
+ return Err(DemuxerError::NotImplemented);
+ }
+ let entries = br.read_u32be()? as usize;
+ track.ctts_version = version;
+ track.ctts_map.resize(entries);
+ match version {
+ 0 | 1 => {
+ validate!(size == (entries as u64) * 8 + 8);
+ for _ in 0..entries {
+ let samp_count = br.read_u32be()?;
+ let samp_offset = br.read_u32be()?;
+ track.ctts_map.add(samp_count, samp_offset / track.tb_div);
+ }
+ },
+ _ => unreachable!(),
+ };
+ track.ctts_map.reset();
+
+ Ok(size)
+}
+
struct MOVDemuxer<'a> {
src: &'a mut ByteReader<'a>,
depth: usize,
track_no: u32,
tb_num: u32,
tb_den: u32,
+ tb_div: u32,
raw_audio: bool,
raw_apos: u64,
duration: u32,
sample_map: Vec<(u32, u32)>,
sample_size: u32,
frame_samples: usize,
+ ctts_map: RLESearcher<u32>,
+ ctts_version: u8,
stream: Option<NAStream>,
cur_chunk: usize,
cur_sample: usize,
}
}
+#[derive(Default)]
+struct RLESearcher<T> {
+ array: Vec<(u32, T)>,
+ idx: usize,
+ start: u64,
+ next: u64,
+}
+
+impl<T:Default+Copy> RLESearcher<T> {
+ fn new() -> Self { Self::default() }
+ fn resize(&mut self, size: usize) {
+ self.array.truncate(0);
+ self.array.reserve(size);
+ }
+ fn add(&mut self, len: u32, val: T) {
+ self.array.push((len, val));
+ }
+ fn reset(&mut self) {
+ self.start = 0;
+ if !self.array.is_empty() {
+ self.idx = 0;
+ self.next = u64::from(self.array[0].0);
+ } else {
+ self.idx = self.array.len();
+ self.next = 0;
+ }
+ }
+ fn map(&mut self, sample: u64) -> Option<T> {
+ if sample < self.start {
+ self.reset();
+ }
+ if self.idx < self.array.len() {
+ if sample < self.next {
+ Some(self.array[self.idx].1)
+ } else {
+ while (self.idx < self.array.len()) && (sample >= self.next) {
+ self.start = self.next;
+ self.idx += 1;
+ if self.idx < self.array.len() {
+ self.next += u64::from(self.array[self.idx].0);
+ }
+ }
+ if self.idx < self.array.len() {
+ Some(self.array[self.idx].1)
+ } else {
+ None
+ }
+ }
+ } else {
+ None
+ }
+ }
+}
+
impl Track {
fn new(track_no: u32, tb_den: u32) -> Self {
Self {
track_no,
tb_num: 1,
tb_den,
+ tb_div: 1,
raw_audio: false,
raw_apos: 0,
duration: 0,
sample_map: Vec::new(),
sample_size: 0,
frame_samples: 0,
+ ctts_map: RLESearcher::new(),
+ ctts_version: 0,
stream: None,
depth: 0,
cur_chunk: 0,
}
fn get_next_chunk(&mut self) -> Option<(NATimeInfo, u64, usize)> {
let pts_val = self.timesearch.map_time(self.cur_sample as u32, &self.time_to_sample);
- let mut pts = NATimeInfo::new(Some(pts_val), None, None, self.tb_num, self.tb_den);
-//todo dts decoding
+ let dts = if let Some(dts_corr) = self.ctts_map.map(self.cur_sample as u64) {
+ let dts = match self.ctts_version {
+ 0 => pts_val.wrapping_add(u64::from(dts_corr)),
+ 1 => pts_val.wrapping_add(i64::from(dts_corr as i32) as u64),
+ _ => unimplemented!(),
+ };
+ if (dts as i64) < 0 {
+ None
+ } else {
+ Some(dts)
+ }
+ } else {
+ None
+ };
+ let mut pts = NATimeInfo::new(Some(pts_val), dts, None, self.tb_num, self.tb_den);
if self.chunk_offsets.len() == self.chunk_sizes.len() { // simple one-to-one mapping
if self.cur_sample >= self.chunk_sizes.len() {
return None;
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;
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(())
}
projects / nihav.git / blobdiff