RootChunkHandler { ctype: mktag!(b"moov"), parse: read_moov },
];
+fn print_cname(ctype: u32, size: u64, off: u64, depth: u8) {
+ for _ in 0..depth { print!(" "); }
+ let tag = [(ctype >> 24) as u8, (ctype >> 16) as u8, (ctype >> 8) as u8, ctype as u8];
+ let mut printable = true;
+ for &ch in tag.iter() {
+ if ch < 0x20 || ch > 0x7F {
+ printable = false;
+ break;
+ }
+ }
+ if printable {
+ print!(" '{}{}{}{}'", tag[0] as char, tag[1] as char, tag[2] as char, tag[3] as char);
+ } else {
+ print!(" {:08X}", ctype);
+ }
+ println!(" size {} @ {:X}", size, off);
+}
+
macro_rules! read_chunk_list {
(root; $name: expr, $fname: ident, $handlers: ident) => {
fn $fname(&mut self, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<()> {
let ret = read_chunk_header(&mut self.src);
if ret.is_err() { break; }
let (ctype, size) = ret.unwrap();
+ if self.print_chunks {
+ print_cname(ctype, size, self.src.tell(), self.depth as u8);
+ }
if self.src.tell() + size > list_end {
break;
}
let ret = read_chunk_header(br);
if ret.is_err() { break; }
let (ctype, size) = ret.unwrap();
+ if self.print_chunks {
+ print_cname(ctype, size, br.tell(), self.depth + 1);
+ }
if br.tell() + size > list_end {
break;
}
let (ctype, csize) = read_chunk_header(&mut br)?;
validate!(ctype == mktag!(b"moov"));
let mut ddmx = MOVDemuxer::new(&mut br);
+ ddmx.print_chunks = dmx.print_chunks;
ddmx.read_moov(strmgr, csize)?;
std::mem::swap(&mut dmx.tracks, &mut ddmx.tracks);
dmx.duration = ddmx.duration;
fn read_trak(dmx: &mut MOVDemuxer, strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
let mut track = Track::new(dmx.cur_track as u32, dmx.tb_den);
+ track.print_chunks = dmx.print_chunks;
track.read_trak(&mut dmx.src, size)?;
validate!(track.tkhd_found && track.stsd_found);
validate!(strmgr.get_stream_by_id(track.track_id).is_none());
}
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>>> {
} 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);
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,
tb_den: u32,
duration: u32,
pal: Option<Arc<[u8; 1024]>>,
+
+ print_chunks: bool,
}
struct Track {
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,
last_offset: u64,
pal: Option<Arc<[u8; 1024]>>,
timesearch: TimeSearcher,
+
+ print_chunks: bool,
}
#[derive(Default)]
}
}
+#[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,
last_offset: 0,
pal: None,
timesearch: TimeSearcher::new(),
+
+ print_chunks: false,
}
}
read_chunk_list!(track; "trak", read_trak, TRAK_CHUNK_HANDLERS);
}
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;
}
}
+const PRINT_CHUNKS: &str = "print_chunks";
+
+const DEMUXER_OPTIONS: &[NAOptionDefinition] = &[
+ NAOptionDefinition {
+ name: PRINT_CHUNKS,
+ description: "Print parsed file structure",
+ opt_type: NAOptionDefinitionType::Bool },
+];
+
impl<'a> NAOptionHandler for MOVDemuxer<'a> {
- fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
- fn set_options(&mut self, _options: &[NAOption]) { }
- fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
+ fn get_supported_options(&self) -> &[NAOptionDefinition] { DEMUXER_OPTIONS }
+ fn set_options(&mut self, options: &[NAOption]) {
+ for option in options.iter() {
+ for opt_def in DEMUXER_OPTIONS.iter() {
+ if opt_def.check(option).is_ok() {
+ match (option.name, &option.value) {
+ (PRINT_CHUNKS, NAValue::Bool(val)) => {
+ self.print_chunks = *val;
+ },
+ _ => {},
+ }
+ }
+ }
+ }
+ }
+ fn query_option_value(&self, name: &str) -> Option<NAValue> {
+ match name {
+ PRINT_CHUNKS => Some(NAValue::Bool(self.print_chunks)),
+ _ => None,
+ }
+ }
}
impl<'a> MOVDemuxer<'a> {
tb_den: 0,
duration: 0,
pal: None,
+
+ print_chunks: false,
}
}
fn read_root(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
projects / nihav.git / blobdiff