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)
let sver = br.read_u16be()?;
let _revision = br.read_u16le()?;
let _vendor = br.read_u32be()?;
- let nchannels = br.read_u16be()?;
- validate!(nchannels <= 64);
+ let mut nchannels = br.read_u16be()?;
+ if sver != 2 {
+ validate!(nchannels <= 64);
+ }
let sample_size = br.read_u16be()?;
validate!(sample_size <= 128);
let _compr_id = br.read_u16be()?;
let packet_size = br.read_u16be()? as usize;
validate!(packet_size == 0);
- let sample_rate = br.read_u32be()?;
- validate!(sample_rate > (1 << 16));
+ let mut sample_rate = br.read_u32be()? >> 16;
+ if sver != 2 {
+ validate!(sample_rate > 0);
+ }
let cname = if let Some(name) = find_codec_from_mov_audio_fourcc(&fcc) {
name
} else if let (true, Some(name)) = ((fcc[0] == b'm' && fcc[1] == b's'), find_codec_from_wav_twocc(u16::from(fcc[2]) * 256 + u16::from(fcc[3]))) {
soniton.signed = false;
}
let block_align = 1;
- if sver == 1 {
- let samples_per_packet = br.read_u32be()?;
- let _bytes_per_packet = br.read_u32be()?;
- let bytes_per_frame = br.read_u32be()?;
- let _bytes_per_sample = br.read_u32be()?;
- track.bsize = bytes_per_frame as usize;
- track.frame_samples = samples_per_packet as usize;
- track.tb_num = samples_per_packet;
- } else {
- track.bsize = (sample_size / 8) as usize;
- }
- track.tb_den = sample_rate >> 16;
- track.raw_audio = match &fcc {
+ match sver {
+ 1 => {
+ let samples_per_packet = br.read_u32be()?;
+ let _bytes_per_packet = br.read_u32be()?;
+ let bytes_per_frame = br.read_u32be()?;
+ let _bytes_per_sample = br.read_u32be()?;
+ track.bsize = bytes_per_frame as usize;
+ track.frame_samples = samples_per_packet as usize;
+ track.tb_num = samples_per_packet;
+ },
+ 2 => {
+ br.read_u32be()?; // some size
+ let srate = br.read_f64be()?;
+ validate!(srate > 1.0);
+ sample_rate = srate as u32;
+ let channels = br.read_u32be()?;
+ validate!(channels > 0 && channels < 255);
+ nchannels = channels as u16;
+ br.read_u32be()?; // always 0x7F000000
+ let _bits_per_csample = br.read_u32be()?;
+ let _codec_flags = br.read_u32be()?;
+ let bytes_per_frame = br.read_u32be()?;
+ let samples_per_packet = br.read_u32be()?;
+ track.bsize = bytes_per_frame as usize;
+ track.frame_samples = samples_per_packet as usize;
+ track.tb_num = samples_per_packet;
+ },
+ _ => {
+ track.bsize = (sample_size / 8) as usize;
+ },
+ };
+ 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,
- };
- let ahdr = NAAudioInfo::new(sample_rate >> 16, nchannels as u8, soniton, block_align);
+ 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);
track.channels = nchannels as usize;
validate!(tb_num != 0);
track.rescale(tb_num);
} else {
- track.time_to_sample.truncate(0);
+ track.time_to_sample.clear();
track.time_to_sample.reserve(entries);
for _ in 0..entries {
let count = br.read_u32be()?;
track.ctts_map.reserve(sample_count);
}
+ if track.chunk_offsets.len() < (std::u32::MAX as usize) {
+ track.keyframes.push((track.chunk_offsets.len() + 1) as u32);
+ }
for _ in 0..sample_count {
if sample_duration_present {
let _duration = br.read_u32be()?;
impl<T:Default+Copy> RLESearcher<T> {
fn new() -> Self { Self::default() }
fn resize(&mut self, size: usize) {
- self.array.truncate(0);
+ self.array.clear();
self.array.reserve(size);
}
fn reserve(&mut self, size: usize) {
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)
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);
#[test]
fn test_mov_demux() {
+ // sample: https://samples.mplayerhq.hu/V-codecs/IV32/cubes.mov
let mut file = File::open("assets/Indeo/cubes.mov").unwrap();
let mut fr = FileReader::new_read(&mut file);
let mut br = ByteReader::new(&mut fr);
#[test]
fn test_dash_demux() {
+ // sample: a stream downloaded with youtube-dl
let mut file = File::open("assets/ITU/dash.m4a").unwrap();
let mut fr = FileReader::new_read(&mut file);
let mut br = ByteReader::new(&mut fr);
projects / nihav.git / blobdiff