X-Git-Url: https://git.nihav.org/?p=nihav-tool.git;a=blobdiff_plain;f=src%2Fwavwriter.rs;h=e32a4ec69a23fb5e7a84aa72e5dd7c2d9d53d549;hp=2296f6f456f1d5753f1d68b69f9eab69a8224b1f;hb=HEAD;hpb=3660c127f52a92862248464767a3d92cf63aa182

diff --git a/src/wavwriter.rs b/src/wavwriter.rs
index 2296f6f..e32a4ec 100644
--- a/src/wavwriter.rs
+++ b/src/wavwriter.rs
@@ -1,13 +1,15 @@
-extern crate nihav;
+extern crate nihav_core;
 
-use nihav::io::byteio::*;
-use nihav::frame::*;
+use nihav_core::io::byteio::*;
+use nihav_core::frame::*;
 use std::fs::File;
 use std::io::SeekFrom;
 
 pub struct WavWriter<'a> {
     io: Box<ByteWriter<'a>>,
     data_pos: u64,
+    be: bool,
+    bits: u8,
 }
 
 fn write_byte(wr: &mut ByteWriter, sample: u8) -> ByteIOResult<()> {
@@ -37,11 +39,19 @@ macro_rules! write_data {
         let nch = ainfo.get_channels() as usize;
         let mut offs: Vec<usize> = Vec::with_capacity(nch);
         for ch in 0..nch { offs.push($buf.get_offset(ch)); }
+        let is_planar = $buf.get_step() == 1;
         let data = $buf.get_data();
 
-        for i in 0..len {
-            for ch in 0..nch {
-                let sample = data[offs[ch] + i];
+        if is_planar {
+            for i in 0..len {
+                for ch in 0..nch {
+                    let sample = data[offs[ch] + i];
+                    $write($wr, sample)?;
+                }
+            }
+        } else {
+            for i in 0..len*nch {
+                let sample = data[i];
                 $write($wr, sample)?;
             }
         }
@@ -49,11 +59,12 @@ macro_rules! write_data {
 }
 
 impl<'a> WavWriter<'a> {
-    pub fn new(name: &String) -> Self {
+    pub fn new(name: &str) -> Self {
         let file = File::create(name).unwrap();
+        let file = std::io::BufWriter::new(file);
         let fw   = Box::new(FileWriter::new_write(file));
         let io   = ByteWriter::new(Box::leak(fw));
-        WavWriter { io: Box::new(io), data_pos: 0 }
+        WavWriter { io: Box::new(io), data_pos: 0, be: false, bits: 0 }
     }
     pub fn write_header(&mut self, ainfo: NAAudioInfo) -> ByteIOResult<()> {
         let bits = ainfo.get_format().get_bits() as usize;
@@ -66,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)?;
         }
@@ -81,6 +92,8 @@ impl<'a> WavWriter<'a> {
         self.io.write_buf(b"data")?;
         self.io.write_u32le(0)?;
 
+        self.bits = bits as u8;
+        self.be = ainfo.get_format().is_be();
         self.data_pos = self.io.tell();
         Ok(())
     }
@@ -99,7 +112,51 @@ impl<'a> WavWriter<'a> {
                 write_data!(&mut self.io, buf, write_f32);
             }
             NABufferType::AudioPacked(ref buf) => {
-                self.io.write_buf(buf.get_data().as_slice())?;
+                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!(),
+                };
             }
             _ => {},
         };
@@ -115,7 +172,8 @@ 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();
         }
     }
 }