Merge branch 'master' of https://github.com/iluvcapra/bwavfile

Author: iluvcapra

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "bwavfile"
-version = "1.1.0"
-authors = ["Jamie Hardt <[email protected]>"]
+version = "2.0.0"
+authors = ["Jamie Hardt <[email protected]>", "Ian Hobson <[email protected]>"]
 edition = "2018"
 license = "MIT"
 description = "Rust Wave File Reader/Writer with Broadcast-WAV, MBWF and RF64 Support"
@@ -15,6 +15,7 @@ keywords = ["audio", "broadcast", "multimedia","smpte"]
 
 [dependencies]
 byteorder = "1.3.4"
+dasp_sample = "0.11.0"
 encoding = "0.2.33"
 uuid = "0.8.1"
 clap = "2.33.3"

Cargo.toml

@@ -208,7 +208,7 @@ fn create_blits_file(file_name: &str, sample_rate: u32, bits_per_sample: u16) ->
     let mut fw = file.audio_frame_writer()?;
     for frame in frames {
         let buf = vec![frame.0, frame.1, frame.2, frame.3, frame.4, frame.5];
-        fw.write_integer_frames(&buf)?;
+        fw.write_frames(&buf)?;
     }
     fw.end()?;
 

examples/blits.rs

@@ -1,14 +1,17 @@
-//! wave-inter.rs
+//! wave-deinter.rs
 //! (c) 2021 Jamie Hardt. All rights reserved.
 //!
-//! This program demonstrats combining several wave files into a single
-//! polyphonic wave file.
+//! This program demonstrates splitting a multichannel file into separate monophonic files for each
+//! individual channel.
 
-use std::io;
+use std::io::{Read, Seek};
 use std::path::Path;
 
 extern crate bwavfile;
-use bwavfile::{ChannelDescriptor, ChannelMask, Error, WaveFmt, WaveReader, WaveWriter};
+use bwavfile::{
+    ChannelDescriptor, ChannelMask, CommonFormat, Error, Sample, WaveFmt, WaveReader, WaveWriter,
+    I24,
+};
 
 #[macro_use]
 extern crate clap;
@@ -48,17 +51,25 @@ fn name_suffix(
     }
 }
 
-fn process_file(infile: &str, delim: &str, numeric_channel_names: bool) -> Result<(), Error> {
-    let mut input_file = WaveReader::open(infile)?;
+fn deinterleave_file<S, R>(
+    mut input_file: WaveReader<R>,
+    input_format: WaveFmt,
+    settings: Settings,
+) -> Result<(), Error>
+where
+    S: Sample,
+    R: Read + Seek,
+{
+    let frames_per_read = 4096;
     let channel_desc = input_file.channels()?;
-    let input_format = input_file.format()?;
+    let channel_count = channel_desc.len();
 
     if channel_desc.len() == 1 {
         println!("Input file in monoaural, exiting.");
         return Ok(());
     }
 
-    let infile_path = Path::new(infile);
+    let infile_path = Path::new(&settings.input_path);
     let basename = infile_path
         .file_stem()
         .expect("Unable to extract file basename")
@@ -68,38 +79,91 @@ fn process_file(infile: &str, delim: &str, numeric_channel_names: bool) -> Resul
         .parent()
         .expect("Unable to derive parent directory");
 
-    let ouptut_format =
-        WaveFmt::new_pcm_mono(input_format.sample_rate, input_format.bits_per_sample);
-    let mut input_wave_reader = input_file.audio_frame_reader()?;
-
-    for (n, channel) in channel_desc.iter().enumerate() {
-        let suffix = name_suffix(numeric_channel_names, delim, n + 1, channel);
-        let outfile_name = output_dir
-            .join(format!("{}{}.wav", basename, suffix))
-            .into_os_string()
-            .into_string()
-            .unwrap();
-
-        println!("Will create file {}", outfile_name);
-
-        let output_file =
-            WaveWriter::create(&outfile_name, ouptut_format).expect("Failed to create new file");
+    let output_block_alignment = input_format.bits_per_sample / 8;
+    let output_format = WaveFmt {
+        channel_count: 1,
+        block_alignment: output_block_alignment,
+        bytes_per_second: output_block_alignment as u32 * input_format.sample_rate,
+        ..input_format
+    };
+    let mut reader = input_file.audio_frame_reader()?;
+    let mut writers = channel_desc
+        .iter()
+        .enumerate()
+        .map(|(n, channel)| {
+            let suffix = name_suffix(
+                settings.use_numeric_names,
+                &settings.delimiter,
+                n + 1,
+                channel,
+            );
+            let outfile_name = output_dir
+                .join(format!("{}{}.wav", basename, suffix))
+                .into_os_string()
+                .into_string()
+                .unwrap();
+
+            println!("Will create file {}", outfile_name);
+
+            WaveWriter::create(&outfile_name, output_format)
+                .expect("Failed to create new file")
+                .audio_frame_writer()
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let mut input_buffer = vec![S::EQUILIBRIUM; frames_per_read * channel_count];
+    let mut output_buffer = vec![S::EQUILIBRIUM; frames_per_read];
+
+    loop {
+        let frames_read = reader.read_frames(&mut input_buffer)? as usize;
+        if frames_read == 0 {
+            break;
+        }
 
-        let mut output_wave_writer = output_file.audio_frame_writer()?;
-        let mut buffer = input_format.create_frame_buffer(1);
+        output_buffer.resize(frames_read, S::EQUILIBRIUM);
 
-        while input_wave_reader.read_integer_frame(&mut buffer)? > 0 {
-            output_wave_writer.write_integer_frames(&buffer[n..=n])?;
+        for (n, writer) in writers.iter_mut().enumerate() {
+            for (output, input) in output_buffer
+                .iter_mut()
+                .zip(input_buffer.iter().skip(n).step_by(channel_count))
+            {
+                *output = *input;
+            }
+            writer.write_frames(&output_buffer)?;
         }
+    }
 
-        output_wave_writer.end()?;
-        input_wave_reader.locate(0)?;
+    for writer in writers.drain(..) {
+        writer.end()?;
     }
 
     Ok(())
 }
 
-fn main() -> io::Result<()> {
+fn process_file<R>(mut input: WaveReader<R>, settings: Settings) -> Result<(), Error>
+where
+    R: Read + Seek,
+{
+    let format = input.format()?;
+
+    use CommonFormat::*;
+    match (format.common_format(), format.bits_per_sample) {
+        (IntegerPCM, 8) => deinterleave_file::<u8, R>(input, format, settings),
+        (IntegerPCM, 16) => deinterleave_file::<i16, R>(input, format, settings),
+        (IntegerPCM, 24) => deinterleave_file::<I24, R>(input, format, settings),
+        (IntegerPCM, 32) => deinterleave_file::<i32, R>(input, format, settings),
+        (IeeeFloatPCM, 32) => deinterleave_file::<f32, R>(input, format, settings),
+        other => panic!("Unsupported format: {:?}", other),
+    }
+}
+
+struct Settings {
+    input_path: String,
+    delimiter: String,
+    use_numeric_names: bool,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     let matches = App::new("wave-deinter")
         .version(crate_version!())
         .author(crate_authors!())
@@ -126,13 +190,12 @@ fn main() -> io::Result<()> {
         )
         .get_matches();
 
-    let delimiter = matches.value_of("channel_delimiter").unwrap();
-    let use_numeric_names = matches.is_present("numeric_names");
-    let infile = matches.value_of("INPUT").unwrap();
+    let settings = Settings {
+        input_path: matches.value_of("INPUT").unwrap().into(),
+        delimiter: matches.value_of("channel_delimiter").unwrap().into(),
+        use_numeric_names: matches.is_present("numeric_names"),
+    };
 
-    match process_file(infile, delimiter, use_numeric_names) {
-        Err(Error::IOError(io)) => Err(io),
-        Err(e) => panic!("Error: {:?}", e),
-        Ok(()) => Ok(()),
-    }
+    process_file(WaveReader::open(&settings.input_path)?, settings)?;
+    Ok(())
 }

examples/wave-deinter.rs

@@ -1,4 +1,5 @@
 pub type LU = f32;
+#[allow(clippy::upper_case_acronyms)]
 pub type LUFS = f32;
 pub type Decibels = f32;
 

src/bext.rs

@@ -21,11 +21,7 @@ pub trait ReadBWaveChunks: Read {
 
 pub trait WriteBWaveChunks: Write {
     fn write_wave_fmt(&mut self, format: &WaveFmt) -> Result<(), ParserError>;
-    fn write_bext_string_field(
-        &mut self,
-        string: &String,
-        length: usize,
-    ) -> Result<(), ParserError>;
+    fn write_bext_string_field(&mut self, string: &str, length: usize) -> Result<(), ParserError>;
     fn write_bext(&mut self, bext: &Bext) -> Result<(), ParserError>;
 }
 
@@ -34,7 +30,7 @@ where
     T: Write,
 {
     fn write_wave_fmt(&mut self, format: &WaveFmt) -> Result<(), ParserError> {
-        self.write_u16::<LittleEndian>(format.tag as u16)?;
+        self.write_u16::<LittleEndian>(format.tag)?;
         self.write_u16::<LittleEndian>(format.channel_count)?;
         self.write_u32::<LittleEndian>(format.sample_rate)?;
         self.write_u32::<LittleEndian>(format.bytes_per_second)?;
@@ -46,18 +42,14 @@ where
             self.write_u16::<LittleEndian>(ext.valid_bits_per_sample)?;
             self.write_u32::<LittleEndian>(ext.channel_mask)?;
             let uuid = ext.type_guid.as_bytes();
-            self.write(uuid)?;
+            self.write_all(uuid)?;
         }
         Ok(())
     }
 
-    fn write_bext_string_field(
-        &mut self,
-        string: &String,
-        length: usize,
-    ) -> Result<(), ParserError> {
+    fn write_bext_string_field(&mut self, string: &str, length: usize) -> Result<(), ParserError> {
         let mut buf = ASCII
-            .encode(&string, EncoderTrap::Ignore)
+            .encode(string, EncoderTrap::Ignore)
             .expect("Error encoding text");
         buf.truncate(length);
         let filler_length = length - buf.len();
@@ -142,12 +134,8 @@ where
 
     fn read_bext_string_field(&mut self, length: usize) -> Result<String, ParserError> {
         let mut buffer: Vec<u8> = vec![0; length];
-        self.read(&mut buffer)?;
-        let trimmed: Vec<u8> = buffer
-            .iter()
-            .take_while(|c| **c != 0 as u8)
-            .cloned()
-            .collect();
+        self.read_exact(&mut buffer)?;
+        let trimmed: Vec<u8> = buffer.iter().take_while(|c| **c != 0_u8).cloned().collect();
         Ok(ASCII
             .decode(&trimmed, DecoderTrap::Ignore)
             .expect("Error decoding text"))
@@ -168,7 +156,7 @@ where
             },
             umid: {
                 let mut buf = [0u8; 64];
-                self.read(&mut buf)?;
+                self.read_exact(&mut buf)?;
                 if version > 0 {
                     Some(buf)
                 } else {