fn read_palette(br: &mut ByteReader, size: u64, pal: &mut [u8; 1024]) -> DemuxerResult<u64> {
let _seed = br.read_u32be()?;
- let _flags = br.read_u16be()?;
+ let flags = br.read_u16be()?;
let palsize = (br.read_u16be()? as usize) + 1;
validate!(palsize <= 256);
- validate!((palsize as u64) * 8 + 8 == size);
+ validate!(flags == 0 || flags == 0x4000 || flags == 0x8000);
+ validate!((palsize as u64) * 8 + 8 <= size);
for i in 0..palsize {
let a = br.read_u16be()?;
let r = br.read_u16be()?;
pal[i * 4] = (r >> 8) as u8;
pal[i * 4 + 1] = (g >> 8) as u8;
pal[i * 4 + 2] = (b >> 8) as u8;
- pal[i * 4 + 3] = (a >> 8) as u8;
+ if flags == 0x8000 {
+ pal[i * 4 + 3] = (a >> 8) as u8;
+ }
+ }
+ if flags == 0x4000 {
+ br.read_skip(8)?;
}
Ok(size)
}
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 {
+ for ch in tag.iter() {
+ if !(0x20..=0x7F).contains(ch) {
printable = false;
break;
}
validate!(self.depth < 32);
let list_end = self.src.tell() + size;
while self.src.tell() < list_end {
- let ret = read_chunk_header(&mut self.src);
+ let ret = read_chunk_header(self.src);
if ret.is_err() { break; }
let (ctype, size) = ret.unwrap();
if self.print_chunks {
fn read_ctab(dmx: &mut MOVDemuxer, _strmgr: &mut StreamManager, size: u64) -> DemuxerResult<u64> {
let mut pal = [0; 1024];
- let size = read_palette(&mut dmx.src, size, &mut pal)?;
+ let size = read_palette(dmx.src, size, &mut pal)?;
dmx.pal = Some(Arc::new(pal));
Ok(size)
}
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)?;
+ track.read_trak(dmx.src, size)?;
validate!(track.tkhd_found && track.stsd_found);
validate!(strmgr.get_stream_by_id(track.track_id).is_none());
dmx.cur_track += 1;
}
if let Some(track) = track {
track.moof_off = dmx.moof_off;
- track.read_traf(&mut dmx.src, size)?;
+ track.read_traf(dmx.src, size)?;
Ok(size)
} else {
Ok(0)
}
}
+#[allow(clippy::neg_cmp_op_on_partial_ord)]
fn read_stsd(track: &mut Track, br: &mut ByteReader, size: u64) -> DemuxerResult<u64> {
const KNOWN_STSD_SIZE: u64 = 24;
validate!(size >= KNOWN_STSD_SIZE);
let ctable_id = br.read_u16be()?;
let grayscale = depth > 0x20 || depth == 1;
let depth = if grayscale { depth & 0x1F } else { depth };
- validate!(depth <= 8 || (ctable_id == 0xFFFF));
if ctable_id == 0 {
let max_pal_size = start_pos + size - br.tell();
- let mut pal = [0; 1024];
- read_palette(br, max_pal_size, &mut pal)?;
- track.pal = Some(Arc::new(pal));
+ if depth <= 8 {
+ let mut pal = [0; 1024];
+ read_palette(br, max_pal_size, &mut pal)?;
+ track.pal = Some(Arc::new(pal));
+ } else {
+ br.read_skip(max_pal_size as usize)?;
+ }
} else if (depth <= 8) && !grayscale {
match depth & 0x1F {
2 => {
let mut pal = [0; 1024];
- (&mut pal[..4 * 4]).copy_from_slice(&MOV_DEFAULT_PAL_2BIT);
+ pal[..4 * 4].copy_from_slice(&MOV_DEFAULT_PAL_2BIT);
track.pal = Some(Arc::new(pal));
},
4 => {
let mut pal = [0; 1024];
- (&mut pal[..16 * 4]).copy_from_slice(&MOV_DEFAULT_PAL_4BIT);
+ pal[..16 * 4].copy_from_slice(&MOV_DEFAULT_PAL_4BIT);
track.pal = Some(Arc::new(pal));
},
8 => {
track.bsize = (sample_size / 8) as usize;
},
};
- track.tb_den = sample_rate;
- track.raw_audio = match &fcc {
+ if track.tb_den <= 1 {
+ track.tb_den = sample_rate;
+ }
+ track.raw_audio = matches!(&fcc,
b"NONE" | b"raw " | b"twos" | b"sowt" |
b"in24" | b"in32" | b"fl32" | b"fl64" |
b"ima4" | b"ms\x00\x02" | b"ms\x00\x21" |
b"alaw" | b"ulaw" |
- b"MAC3" | b"MAC6" => true,
- _ => false,
- };
+ b"MAC3" | b"MAC6");
let ahdr = NAAudioInfo::new(sample_rate, nchannels as u8, soniton, block_align);
let edata = parse_audio_edata(br, start_pos, size)?;
codec_info = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ahdr), edata);
moof_off: u64,
print_chunks: bool,
+
+ macbinary: bool,
}
struct Track {
for kf_time in self.keyframes.iter() {
let pts = tsearch.map_time(*kf_time - 1, &self.time_to_sample);
let time = NATimeInfo::ts_to_time(pts, 1000, self.tb_num, self.tb_den);
- seek_index.add_entry(self.track_no as u32, SeekEntry { time, pts: u64::from(*kf_time - 1), pos: 0 });
+ seek_index.add_entry(self.track_no, SeekEntry { time, pts: u64::from(*kf_time - 1), pos: 0 });
}
}
fn calculate_chunk_size(&self, nsamp: usize) -> usize {
Some(dts)
}
} else {
- None
+ Some(pts_val)
};
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
}
}
#[allow(clippy::collapsible_if)]
- fn seek(&mut self, pts: u64, tpoint: NATimePoint) -> DemuxerResult<()> {
+ #[allow(clippy::collapsible_else_if)]
+ fn seek(&mut self, pts: u64, tpoint: NATimePoint) -> DemuxerResult<u64> {
self.cur_sample = pts as usize;
self.samples_left = 0;
self.cur_ts = None;
} else if self.chunk_offsets.len() == self.chunk_sizes.len() {
self.cur_chunk = self.cur_sample;
} else {
+ if !self.time_to_sample.is_empty() {
+ let mut remaining = exp_pts;
+ let mut abs_csamp = 0;
+ for &(count, scount) in self.time_to_sample.iter() {
+ let count = u64::from(count);
+ let scount = u64::from(scount);
+ let nblk = remaining / scount;
+ if nblk < count {
+ abs_csamp += nblk;
+ break;
+ }
+ remaining -= count * scount;
+ abs_csamp += count;
+ }
+ self.cur_sample = abs_csamp as usize;
+ } else {
+ self.cur_sample = exp_pts as usize;
+ }
+ let tgt_sample = self.cur_sample;
let mut csamp = 0;
self.cur_chunk = 0;
let mut cmap = self.sample_map.iter();
csamp += cur_samps;
if csamp > self.cur_sample {
if self.cur_chunk >= self.chunk_offsets.len() {
+ self.cur_sample = csamp - cur_samps;
+ self.samples_left = 0;
+ self.cur_sample = csamp;
return Err(DemuxerError::SeekError);
}
self.last_offset = self.chunk_offsets[self.cur_chunk];
self.samples_left = cur_samps;
self.last_offset = self.chunk_offsets[self.cur_chunk];
self.cur_chunk += 1;
+
+ // try to refine sample position
+ if self.chunk_sizes.len() > self.chunk_offsets.len() {
+ for i in self.cur_sample..tgt_sample {
+ self.cur_sample += 1;
+ self.samples_left -= 1;
+ self.last_offset += u64::from(self.chunk_sizes[i]);
+ }
+ }
}
} else {
self.cur_chunk = self.cur_sample;
self.samples_left = csamp + cur_samps - self.cur_sample;
self.cur_chunk += 1;
}
- Ok(())
+ let cur_pts = self.timesearch.map_time(self.cur_sample as u32, &self.time_to_sample);
+ let cur_time = NATimeInfo::ts_to_time(cur_pts, 1000, self.tb_num, self.tb_den);
+ Ok(cur_time)
}
}
} else {
track.cur_ts = None;
}
- let str = strmgr.get_stream(track.track_str_id);
- if str.is_none() { return Err(DemuxerError::InvalidData); }
- let stream = str.unwrap();
+ let stream = strmgr.get_stream(track.track_str_id);
+ if stream.is_none() { return Err(DemuxerError::InvalidData); }
+ let stream = stream.unwrap();
src.seek(SeekFrom::Start(offset))?;
let mut pkt = src.read_packet(stream, pts, false, size)?;
if let Some(ref pal) = track.pal {
impl<'a> DemuxCore<'a> for MOVDemuxer<'a> {
fn open(&mut self, strmgr: &mut StreamManager, seek_index: &mut SeekIndex) -> DemuxerResult<()> {
- self.read_root(strmgr)?;
+ if !self.macbinary {
+ self.read_root(strmgr)?;
+ } else {
+ let ver = self.src.read_byte()?;
+ validate!(ver == 0);
+ self.src.read_skip(64)?;
+ let tag = self.src.read_tag()?;
+ validate!(&tag == b"MooV");
+ self.src.read_skip(14)?;
+ let data_length = self.src.read_u32be()?;
+ validate!(data_length > 8);
+ let rsrc_length = self.src.read_u32be()?;
+ validate!(rsrc_length > 0);
+ self.src.read_skip(31)?;
+ let ver = self.src.read_byte()?;
+ validate!(ver == 0x81);
+ let ver = self.src.read_byte()?;
+ validate!(ver == 0x81);
+ //xxx: maybe check header CRC
+
+ let rsrc_start = 0x80 + ((data_length + 0x7F) & !0x7F);
+ self.src.seek(SeekFrom::Start(rsrc_start.into()))?;
+ let rsrc_off = self.src.read_u32be()?;
+ let rsrc_map_off = self.src.read_u32be()?;
+ let rsrc_size = self.src.read_u32be()?;
+ let _rsrc_map_size = self.src.read_u32be()?;
+ validate!(rsrc_off >= 0x10);
+ validate!(rsrc_map_off >= rsrc_off + rsrc_size);
+ self.src.seek(SeekFrom::Current(i64::from(rsrc_off - 16)))?;
+ // I'm too lazy to parse resource map, so let's just iterate over resources for movie header
+ let end_pos = u64::from(rsrc_start + rsrc_off + rsrc_size);
+ let mut peek_buf = [0u8; 8];
+ while self.src.tell() < end_pos {
+ let cur_size = self.src.read_u32be()?;
+ validate!(self.src.tell() + u64::from(cur_size) <= end_pos);
+ if cur_size > 8 {
+ let rsize = self.src.peek_u32be()?;
+ if rsize == cur_size {
+ self.src.peek_buf(&mut peek_buf)?;
+ if &peek_buf[4..] == b"moov" {
+ self.src.read_skip(8)?;
+ self.read_moov(strmgr, rsize.into())?;
+ self.mdat_pos = 8;
+ break;
+ }
+ }
+ }
+ self.src.read_skip(cur_size as usize)?;
+ }
+ }
validate!(self.mdat_pos > 0);
validate!(!self.tracks.is_empty());
for track in self.tracks.iter_mut() {
- let mut str = None;
- std::mem::swap(&mut track.stream, &mut str);
- if let Some(stream) = str {
+ let mut strm = None;
+ std::mem::swap(&mut track.stream, &mut strm);
+ if let Some(stream) = strm {
let str_id = strmgr.add_stream(stream).unwrap();
track.track_str_id = str_id;
}
}
+ if self.macbinary {
+ // patch data offsets
+ for track in self.tracks.iter_mut() {
+ for offset in track.chunk_offsets.iter_mut() {
+ *offset += 0x80;
+ }
+ }
+ }
for track in self.tracks.iter() {
track.fill_seek_index(seek_index);
}
let first = track.cur_sample == 0;
if let Some((pts, offset, size)) = track.get_next_chunk() {
self.cur_track = trk_no + 1;
- return process_packet(&mut self.src, strmgr, track, pts, offset, size, first);
+ return process_packet(self.src, strmgr, track, pts, offset, size, first);
}
}
}
self.cur_track += 1;
let first = track.cur_sample == 0;
if let Some((pts, offset, size)) = track.get_next_chunk() {
- return process_packet(&mut self.src, strmgr, track, pts, offset, size, first);
+ return process_packet(self.src, strmgr, track, pts, offset, size, first);
}
}
Err(DemuxerError::EOF)
if let NATimePoint::Milliseconds(_) = time {
let mut aonly = true;
for track in self.tracks.iter() {
- if track.stream_type != StreamType::Audio || !track.raw_audio {
+ if track.stream_type != StreamType::Audio {
aonly = false;
break;
}
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;
+ let mut vpts = None;
+ let mut apts = None;
for track in self.tracks.iter_mut() {
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)?;
+ let actual_time = track.seek(cur_pts, time)?;
+ match track.stream_type {
+ StreamType::Video => vpts = Some(actual_time),
+ StreamType::Audio => apts = Some(actual_time),
+ _ => {},
+ };
}
+ /* For audio+video stream case when the post-seek actual times differ
+ by more than half a second try to seek audio to a closer position
+ to video.
+ */
+ if let (true, Some(vtime), Some(atime)) = (self.tracks.len() == 2, vpts, apts) {
+ if vtime.max(atime) - vtime.min(atime) > 500 && atime != 0 {
+ for track in self.tracks.iter_mut() {
+ if track.stream_type == StreamType::Audio {
+ let new_pts = NATimeInfo::time_to_ts(vtime, 1000, track.tb_num, track.tb_den);
+ track.seek(new_pts, NATimePoint::Milliseconds(vtime))?;
+ }
+ }
+ }
+ }
+
Ok(())
}
fn get_duration(&self) -> u64 {
impl<'a> MOVDemuxer<'a> {
fn new(io: &'a mut ByteReader<'a>) -> Self {
+ Self::new_common(io, false)
+ }
+ fn new_macbinary(io: &'a mut ByteReader<'a>) -> Self {
+ Self::new_common(io, true)
+ }
+ fn new_common(io: &'a mut ByteReader<'a>, macbinary: bool) -> Self {
MOVDemuxer {
src: io,
depth: 0,
moof_off: 0,
print_chunks: false,
+
+ macbinary,
}
}
fn read_root(&mut self, strmgr: &mut StreamManager) -> DemuxerResult<()> {
self.depth = 0;
while self.src.left() != 0 {
- let ret = read_chunk_header(&mut self.src);
+ let ret = read_chunk_header(self.src);
if ret.is_err() { break; }
let (ctype, size) = ret.unwrap();
if self.print_chunks {
}
let handler = ROOT_CHUNK_HANDLERS.iter().find(|x| x.ctype == ctype);
let read_size;
- if let Some(ref handler) = handler {
+ if let Some(handler) = handler {
read_size = (handler.parse)(self, strmgr, size)?;
} else {
println!("skipping unknown chunk {:08X} size {}", ctype, size);
fn get_name(&self) -> &'static str { "mov" }
}
+pub struct MacBinaryMOVDemuxerCreator { }
+
+impl DemuxerCreator for MacBinaryMOVDemuxerCreator {
+ fn new_demuxer<'a>(&self, br: &'a mut ByteReader<'a>) -> Box<dyn DemuxCore<'a> + 'a> {
+ Box::new(MOVDemuxer::new_macbinary(br))
+ }
+ fn get_name(&self) -> &'static str { "mov-macbin" }
+}
+
const MOV_DEFAULT_PAL_2BIT: [u8; 4 * 4] = [
0x93, 0x65, 0x5E, 0x00,
0xFF, 0xFF, 0xFF, 0x00,
println!("Got {}", pkt);
}
}
+
+ #[test]
+ fn test_macbinary_demux() {
+ // sample from King's Quest VI Macintosh edition
+ let mut file = File::open("assets/QT/Halfdome.bin").unwrap();
+ let mut fr = FileReader::new_read(&mut file);
+ let mut br = ByteReader::new(&mut fr);
+ let mut dmx = MOVDemuxer::new_macbinary(&mut br);
+ let mut sm = StreamManager::new();
+ let mut si = SeekIndex::new();
+ dmx.open(&mut sm, &mut si).unwrap();
+
+ loop {
+ let pktres = dmx.get_frame(&mut sm);
+ if let Err(e) = pktres {
+ if e == DemuxerError::EOF { break; }
+ panic!("error");
+ }
+ let pkt = pktres.unwrap();
+ println!("Got {}", pkt);
+ }
+ }
}