fix clippy warnings

diff --git a/src/demux.rs b/src/demux.rs
index bf8a07215b5a0e24b3d3f16d21f1c8af8ecfb1b8..9ea9cbb16a9b03dfb3f809eeb8d2b9bcc7ff54f0 100644 (file)
--- a/src/demux.rs
+++ b/src/demux.rs
@@ -98,23 +98,33 @@ pub enum DemuxerObject<'a> {
 }
 
 impl<'a> DemuxerObject<'a> {
-    pub fn create(br: &'a mut ByteReader<'a>, reg: &FullRegister, name: &str, is_raw: bool) -> DemuxerObject<'a> {
+    pub fn create(br: &'a mut ByteReader<'a>, reg: &FullRegister, name: &str, force_dmx: Option<&str>, is_raw: bool, opts: &[NAOption]) -> DemuxerObject<'a> {
         if !is_raw {
             let res = detect::detect_format(name, br);
+            if let Some(dmx_name) = force_dmx {
+                println!("forcing demuxer {} on {}", dmx_name, name);
+                if let Some(dmx_fact) = reg.dmx_reg.find_demuxer(dmx_name) {
+                    br.seek(SeekFrom::Start(0)).unwrap();
+                    let dmx = create_demuxer_with_options(dmx_fact, br, opts).unwrap();
+                    return DemuxerObject::Normal(dmx);
+                } else {
+                    return DemuxerObject::None
+                }
+            }
             let (dmx_name, _) = res.unwrap_or(("", detect::DetectionScore::No));
-            if dmx_name != "" {
+            if !dmx_name.is_empty() {
                 println!("trying demuxer {} on {}", dmx_name, name);
                 if let Some(dmx_fact) = reg.dmx_reg.find_demuxer(dmx_name) {
                     br.seek(SeekFrom::Start(0)).unwrap();
-                    let dmx = create_demuxer(dmx_fact, br).unwrap();
+                    let dmx = create_demuxer_with_options(dmx_fact, br, opts).unwrap();
                     return DemuxerObject::Normal(dmx);
                 }
             }
-            if dmx_name != "" {
+            if !dmx_name.is_empty() {
                 println!("trying raw demuxer {} on {}", dmx_name, name);
                 if let Some(rdmx_fact) = reg.rdmx_reg.find_demuxer(dmx_name) {
                     br.seek(SeekFrom::Start(0)).unwrap();
-                    let dmx = create_raw_demuxer(rdmx_fact, br).unwrap();
+                    let dmx = create_raw_demuxer_with_options(rdmx_fact, br, opts).unwrap();
                     let mut pkts = Vec::new();
                     for stream in dmx.get_streams() {
                         if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
@@ -131,7 +141,7 @@ impl<'a> DemuxerObject<'a> {
                 if rdmx.check_format(br) {
                     println!("detected {} as {}", name, rdmx.get_name());
                     br.seek(SeekFrom::Start(0)).unwrap();
-                    let dmx = create_raw_demuxer(*rdmx, br).unwrap();
+                    let dmx = create_raw_demuxer_with_options(*rdmx, br, opts).unwrap();
                     let mut pkts = Vec::new();
                     for stream in dmx.get_streams() {
                         if let Some(pcreate) = reg.pkt_reg.find_packetiser(stream.get_info().get_name()) {
@@ -159,7 +169,7 @@ impl<'a> DemuxerObject<'a> {
                 break;
             }
         }
-        if pname != "" {
+        if !pname.is_empty() {
             println!("found raw stream of type {} for {}", pname, name);
             let pcreate = reg.pkt_reg.find_packetiser(pname).unwrap();
             let mut packetiser = (pcreate)();
@@ -172,10 +182,7 @@ impl<'a> DemuxerObject<'a> {
         }
     }
     pub fn is_none(&self) -> bool {
-        match *self {
-            DemuxerObject::None => true,
-            _ => false,
-        }
+        matches!(*self, DemuxerObject::None)
     }
     pub fn get_duration(&self) -> u64 {
         match *self {
@@ -370,6 +377,27 @@ pub fn detect_tags(br: &mut ByteReader) -> (bool, u64, Option<u64>) {
             end = Some(off - size);
         }
     }
+    // check for MusicMatch tag
+    let ret = if let Some(endpos) = end {
+            br.seek(SeekFrom::Start(endpos - 0x30))
+        } else {
+            br.seek(SeekFrom::End(-0x30))
+        };
+    if ret.is_ok() && br.tell() > (0x2000 - 0x30) {
+        let mut buf = [0; 19];
+        br.peek_buf(&mut buf).unwrap();
+        if &buf == b"Brava Software Inc." {
+            br.seek(SeekFrom::Current(-20)).unwrap();
+            let mut mm_start = u64::from(br.read_u32le().unwrap());
+            if mm_start > 4 && mm_start + 0x2000 <= br.tell() {
+                let diff = (br.tell() - mm_start) & 3;
+                if diff != 0 {
+                    mm_start -= 4 - diff;
+                }
+                end = Some(mm_start);
+            }
+        }
+    }
 
     (is_raw, start, end)
 }

diff --git a/src/main.rs b/src/main.rs
index 8280799a790bbc7b31af4a532eeee4369d6a1441..78c9fb09ec0bfe3057d6d2e7b8a2ba3398abab9f 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -104,6 +104,8 @@ fn main() {
     let mut apfx: Option<&str> = None;
     let mut ignore_errors = false;
     let mut dump_frames = false;
+    let mut force_dmx: Option<&str> = None;
+    let mut demux_opts: Vec<NAOption> = Vec::new();
 
     while (cur_arg < args.len()) && args[cur_arg].starts_with('-') {
         match args[cur_arg].as_str() {
@@ -145,6 +147,17 @@ fn main() {
                 }
                 vpfx = Some(args[cur_arg].clone());
             },
+            "-demuxer"     => {
+                cur_arg += 1;
+                if cur_arg == args.len() {
+                    println!("name missing");
+                    return;
+                }
+                force_dmx = Some(&args[cur_arg]);
+            },
+            "-print_mov_chunks" => {
+                demux_opts.push(NAOption{name: "print_chunks", value: NAValue::Bool(true) });
+            },
             "-ignerr"   => { ignore_errors = true; },
             "-dumpfrm"  => { dump_frames = true; },
             _           => { println!("unknown option {}", args[cur_arg]); return; },
@@ -179,7 +192,7 @@ fn main() {
     }
     let mut br = ByteReader::new(nfr.as_mut());
     let full_reg = FullRegister::new();
-    let mut demuxer = DemuxerObject::create(&mut br, &full_reg, name, is_raw);
+    let mut demuxer = DemuxerObject::create(&mut br, &full_reg, name, force_dmx, is_raw, &demux_opts);
     if demuxer.is_none() {
         println!("No demuxer found!");
         return;
@@ -295,7 +308,7 @@ println!("stream {} - {} {}", i, s, info.get_name());
                     }
                 },
             };
-            if pkt.get_pts() != None && lastpts != NATimePoint::None && !pkt.ts.less_than(lastpts) { break; }
+            if pkt.get_pts().is_some() && lastpts != NATimePoint::None && !pkt.ts.less_than(lastpts) { break; }
         }
     }
 //panic!("end");

diff --git a/src/wavwriter.rs b/src/wavwriter.rs
index c0b324dc19215288151e3d500c4234ae99f9b5dd..e32a4ec69a23fb5e7a84aa72e5dd7c2d9d53d549 100644 (file)
--- a/src/wavwriter.rs
+++ b/src/wavwriter.rs
@@ -77,14 +77,14 @@ impl<'a> WavWriter<'a> {
         self.io.write_u32le(16)?;
         self.io.write_u16le(0x0001)?; // PCM
         self.io.write_u16le(ainfo.get_channels() as u16)?;
-        self.io.write_u32le(ainfo.get_sample_rate() as u32)?;
+        self.io.write_u32le(ainfo.get_sample_rate())?;
 
-        if bits < 16 {
-            self.io.write_u32le((ainfo.get_channels() as u32) * (ainfo.get_sample_rate() as u32))?;
+        if bits <= 8 {
+            self.io.write_u32le((ainfo.get_channels() as u32) * ainfo.get_sample_rate())?;
             self.io.write_u16le(ainfo.get_channels() as u16)?; // block align
             self.io.write_u16le(8)?;
         } else {
-            self.io.write_u32le(2 * (ainfo.get_channels() as u32) * (ainfo.get_sample_rate() as u32))?;
+            self.io.write_u32le(2 * (ainfo.get_channels() as u32) * ainfo.get_sample_rate())?;
             self.io.write_u16le((2 * ainfo.get_channels()) as u16)?; // block align
             self.io.write_u16le(16)?;
         }
@@ -112,35 +112,51 @@ impl<'a> WavWriter<'a> {
                 write_data!(&mut self.io, buf, write_f32);
             }
             NABufferType::AudioPacked(ref buf) => {
-                if !self.be || self.bits == 8 {
-                    self.io.write_buf(buf.get_data().as_slice())?;
-                } else {
-                    let data = buf.get_data();
-                    match self.bits {
-                        16 => {
-                            for samp in data.chunks(2) {
-                                self.io.write_byte(samp[1])?;
-                                self.io.write_byte(samp[0])?;
-                            }
-                        },
-                        24 => {
-                            for samp in data.chunks(3) {
-                                self.io.write_byte(samp[2])?;
-                                self.io.write_byte(samp[1])?;
-                                self.io.write_byte(samp[0])?;
-                            }
-                        },
-                        32 => {
-                            for samp in data.chunks(4) {
-                                self.io.write_byte(samp[3])?;
-                                self.io.write_byte(samp[2])?;
-                                self.io.write_byte(samp[1])?;
-                                self.io.write_byte(samp[0])?;
-                            }
-                        },
-                        _ => unimplemented!(),
-                    };
-                }
+                let data = buf.get_data();
+                match self.bits {
+                    _ if !self.be && (self.bits & 7) == 0 => {
+                        self.io.write_buf(data.as_slice())?;
+                    },
+                    8 => {
+                        self.io.write_buf(data.as_slice())?;
+                    },
+                    12 if !self.be => {
+                        let mut src = data.chunks_exact(3);
+                        for chunk in src.by_ref() {
+                            self.io.write_byte(chunk[0] << 4)?;
+                            self.io.write_byte((chunk[1] << 4) | (chunk[0] >> 4))?;
+                            self.io.write_byte(chunk[1] & 0xF0)?;
+                            self.io.write_byte(chunk[2])?;
+                        }
+                        let tail = src.remainder();
+                        if tail.len() == 2 {
+                            self.io.write_byte(tail[0] << 4)?;
+                            self.io.write_byte(tail[1] << 4)?;
+                        }
+                    }
+                    16 => {
+                        for samp in data.chunks(2) {
+                            self.io.write_byte(samp[1])?;
+                            self.io.write_byte(samp[0])?;
+                        }
+                    },
+                    24 => {
+                        for samp in data.chunks(3) {
+                            self.io.write_byte(samp[2])?;
+                            self.io.write_byte(samp[1])?;
+                            self.io.write_byte(samp[0])?;
+                        }
+                    },
+                    32 => {
+                        for samp in data.chunks(4) {
+                            self.io.write_byte(samp[3])?;
+                            self.io.write_byte(samp[2])?;
+                            self.io.write_byte(samp[1])?;
+                            self.io.write_byte(samp[0])?;
+                        }
+                    },
+                    _ => unimplemented!(),
+                };
             }
             _ => {},
         };
@@ -156,7 +172,7 @@ impl<'a> Drop for WavWriter<'a> {
             let res = self.io.seek(SeekFrom::Start(4));
             let res = self.io.write_u32le((size - 8) as u32);
             let res = self.io.seek(SeekFrom::Start(self.data_pos - 4));
-            let res = self.io.write_u32le(((size as u64) - self.data_pos) as u32);
+            let res = self.io.write_u32le((size - self.data_pos) as u32);
             let res = self.io.flush();
         }
     }