Nudged version

to hide RawChunkReader

Cargo.lock

@@ -2,7 +2,7 @@
 # It is not intended for manual editing.
 [[package]]
 name = "bwavfile"
-version = "0.1.4"
+version = "0.1.6"
 dependencies = [
  "byteorder",
  "encoding",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bwavfile"
-version = "0.1.4"
+version = "0.1.6"
 authors = ["Jamie Hardt <jamiehardt@me.com>"]
 edition = "2018"
 license = "MIT"
@@ -16,5 +16,9 @@ keywords = ["audio", "broadcast", "multimedia","smpte"]
 [dependencies]
 byteorder = "1.3.4"
 encoding = "0.2.33"
+serde_json = "1.0.59"
 uuid = "0.8.1"
-serde_json = "1.0.59"
+
+[profile.release]
+debug = true
+

README.md

@@ -8,9 +8,25 @@ Rust Wave File Reader/Writer with Broadcast-WAV, MBWF and RF64 Support
 
 This is currently a work-in-progress!
 
+### Features
+
+- Read standard WAV, Broadcast-Wave, and 64-bit RF64 and BW64 wave files with one interface for 
+  all types with transparent format detection.
+- Unified format definition interface for standard and extended-format wave files.
+- Read channel/speaker map metadata.
+- Read standard EBU Broadcast-Wave metadata and decode to fields, including timestamp and SMPTE UMID.
+- Validate the compatibility of a given wave file for certain regimes.
+- Metadata support for ambisonic B-format.
+
+### In Progress
+
+- Wave/RF64 file writing.
+- iXML and ADM XML metadata reading/writing.
+
+
 ## Use Examples
 
-### Reading a File
+### Reading Audio Frames From a File
 
 ```rust
 

src/audio_frame_reader.rs

@@ -1,11 +1,12 @@
 use std::io::{Read, Seek};
-use std::io::SeekFrom::{Start,};
+use std::io::SeekFrom::{Start,Current,};
 
 use byteorder::LittleEndian;
 use byteorder::ReadBytesExt;
 
 use super::fmt::{WaveFmt};
 use super::errors::Error;
+use super::CommonFormat;
 
 /// Read audio frames
 /// 
@@ -15,7 +16,9 @@ use super::errors::Error;
 #[derive(Debug)]
 pub struct AudioFrameReader<R: Read + Seek> {
     inner : R,
-    format: WaveFmt
+    format: WaveFmt,
+    start: u64,
+    length: u64
 }
 
 impl<R: Read + Seek> AudioFrameReader<R> {
@@ -28,25 +31,35 @@ impl<R: Read + Seek> AudioFrameReader<R> {
     /// parameter to confirm the `block_alignment` law is fulfilled
     /// and the format tag is readable by this implementation (only
     /// format 0x01 is supported at this time.) 
-    pub fn new(inner: R, format: WaveFmt) -> Self {
+    pub fn new(mut inner: R, format: WaveFmt, start: u64, length: u64) -> Result<Self, Error> {
         assert!(format.block_alignment * 8 == format.bits_per_sample * format.channel_count, 
             "Unable to read audio frames from packed formats: block alignment is {}, should be {}",
             format.block_alignment, (format.bits_per_sample / 8 ) * format.channel_count);
         
-
-        assert!(format.tag == 0x01 , 
+        assert!(format.common_format() == CommonFormat::IntegerPCM , 
                 "Unsupported format tag {:?}", format.tag);
-                
-        AudioFrameReader { inner , format }
+        
+        inner.seek(Start(start))?;
+        Ok( AudioFrameReader { inner , format , start, length} )
+    }
+
+    /// Unwrap the inner reader.
+    pub fn into_inner(self) -> R {
+        self.inner
     }
 
     /// Locate the read position to a different frame
     /// 
     /// Seeks within the audio stream.
+    /// 
+    /// Returns the new location of the read position.
+    /// 
+    /// locate() behaves similarly to Read methods in that
+    /// seeking after the end of the audio data is not an error.
     pub fn locate(&mut self, to :u64) -> Result<u64,Error> {
         let position = to * self.format.block_alignment as u64;
-        let seek_result = self.inner.seek(Start(position))?;
-        Ok( seek_result / self.format.block_alignment as u64 )
+        let seek_result = self.inner.seek(Start(self.start + position))?;
+        Ok( (seek_result - self.start) / self.format.block_alignment as u64 )
     }
 
     /// Create a frame buffer sized to hold frames of the reader
@@ -62,6 +75,15 @@ impl<R: Read + Seek> AudioFrameReader<R> {
     /// A single frame is read from the audio stream and the read location
     /// is advanced one frame.
     /// 
+    /// Regardless of the number of bits in the audio sample, this method
+    /// always writes `i32` samples back to the buffer. These samples are 
+    /// written back "right-aligned" so samples that are shorter than i32
+    /// will leave the MSB bits empty.
+    /// 
+    /// For example: A full-code sample in 16 bit (0xFFFF) will be written 
+    /// back to the buffer as 0x0000FFFF.
+    ///  
+    /// 
     /// ### Panics
     /// 
     /// The `buffer` must have a number of elements equal to the number of 
@@ -73,17 +95,22 @@ impl<R: Read + Seek> AudioFrameReader<R> {
 
         let framed_bits_per_sample = self.format.block_alignment * 8 / self.format.channel_count;
 
-        for n in 0..(self.format.channel_count as usize) {
-            buffer[n] = match (self.format.bits_per_sample, framed_bits_per_sample) {
-                (0..=8,8) => self.inner.read_u8()? as i32 - 0x80_i32, // EBU 3285 §A2.2
-                (9..=16,16) => self.inner.read_i16::<LittleEndian>()? as i32,
-                (10..=24,24) => self.inner.read_i24::<LittleEndian>()?,
-                (25..=32,32) => self.inner.read_i32::<LittleEndian>()?,
-                (b,_)=> panic!("Unrecognized integer format, bits per sample {}, channels {}, block_alignment {}", 
-                    b, self.format.channel_count, self.format.block_alignment)
-            }
-        }
+        let tell = self.inner.seek(Current(0))?;
 
-        Ok( 1 )
+        if (tell - self.start) < self.length {
+            for n in 0..(self.format.channel_count as usize) {
+                buffer[n] = match (self.format.bits_per_sample, framed_bits_per_sample) {
+                    (0..=8,8) => self.inner.read_u8()? as i32 - 0x80_i32, // EBU 3285 §A2.2
+                    (9..=16,16) => self.inner.read_i16::<LittleEndian>()? as i32,
+                    (10..=24,24) => self.inner.read_i24::<LittleEndian>()?,
+                    (25..=32,32) => self.inner.read_i32::<LittleEndian>()?,
+                    (b,_)=> panic!("Unrecognized integer format, bits per sample {}, channels {}, block_alignment {}", 
+                        b, self.format.channel_count, self.format.block_alignment)
+                }
+            }
+            Ok( 1 )
+        } else {
+            Ok( 0 )
+        }
     }
 }

src/common_format.rs

@@ -48,12 +48,25 @@ fn uuid_from_basic_tag(tag: u16) -> Uuid {
 ///
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum CommonFormat {
+    /// Integer linear PCM
     IntegerPCM,
+ 
+    /// IEEE Floating-point Linear PCM
     IeeeFloatPCM,
+ 
+    /// MPEG
     Mpeg,
+ 
+    /// Ambisonic B-Format Linear PCM
     AmbisonicBFormatIntegerPCM,
+ 
+    /// Ambisonic B-Format Float PCM
     AmbisonicBFormatIeeeFloatPCM,
+ 
+    /// An unknown format identified by a basic format tag.
     UnknownBasic(u16),
+ 
+    /// An unknown format identified by an extension UUID.
     UnknownExtended(Uuid),
 }
 
@@ -83,4 +96,4 @@ impl CommonFormat {
             Self::UnknownExtended(x) => ( BASIC_EXTENDED, x)
         }
     }
-}
+}

src/fmt.rs

@@ -1,8 +1,7 @@
-use std::convert::TryFrom;
 use uuid::Uuid;
-use super::errors::Error;
 use super::common_format::CommonFormat;
 
+#[allow(dead_code)]
 
 /// ADM Audio ID record
 /// 
@@ -23,16 +22,16 @@ pub struct ADMAudioID {
 /// Describes a single channel in a WAV file.
 pub struct ChannelDescriptor {
     /// Index, the offset of this channel's samples in one frame.
-    index: u16,
+    pub index: u16,
 
     /// Channel assignment
     /// 
     /// This is either implied (in the case of mono or stereo wave files) or
     /// explicitly given in `WaveFormatExtentended` for files with more tracks.
-    speaker: ChannelMask,
+    pub speaker: ChannelMask,
 
     /// ADM audioTrackUIDs
-    adm_track_audio_ids: Vec<ADMAudioID>,
+    pub adm_track_audio_ids: Vec<ADMAudioID>,
 }
 
 
@@ -149,7 +148,9 @@ pub struct WaveFmt {
     /// Count of audio channels in each frame
     pub channel_count: u16,
 
-    /// Sample rate of the audio data
+    /// Playback rate of the audio data
+    ///
+    /// In frames per second.
     pub sample_rate: u32,
 
     /// Count of bytes per second
@@ -163,6 +164,16 @@ pub struct WaveFmt {
     pub block_alignment: u16,
 
     /// Count of bits stored in the file per sample
+    ///
+    /// By rule, `bits_per_sample % 8 == 0` for Broadcast-Wave files.
+    ///
+    /// Modern clients will encode
+    /// unusual sample sizes in normal byte sizes but will set the valid_bits
+    /// flag in extended format record.
+    ///
+    /// Generally speaking this will be true for all modern wave files, though
+    /// there was an historical "packed" stereo format of 20 bits per sample,
+    /// 5 bytes per frame, 5 bytes block alignment.
     pub bits_per_sample: u16,
 
     /// Extended format description
@@ -197,10 +208,15 @@ impl WaveFmt {
         }
     }
 
+    /// Format or codec of the file's audio data.
+    /// 
+    /// The `CommonFormat` unifies the format tag and the format extension GUID. Use this
+    /// method to determine the codec.
     pub fn common_format(&self) -> CommonFormat {
         CommonFormat::make( self.tag, self.extended_format.map(|ext| ext.type_guid))
     }
 
+    /// Channel descriptors for each channel.
     pub fn channels(&self) -> Vec<ChannelDescriptor> {
         match self.channel_count {
             1 => vec![

src/fourcc.rs

@@ -106,7 +106,6 @@ pub const BEXT_SIG: FourCC = FourCC::make(b"bext");
 pub const JUNK_SIG: FourCC = FourCC::make(b"JUNK");
 pub const FLLR_SIG: FourCC = FourCC::make(b"FLLR");
 
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/lib.rs

@@ -119,8 +119,9 @@ mod wavereader;
 mod wavewriter;
 
 pub use errors::Error;
-pub use wavereader::{WaveReader};
+pub use wavereader::WaveReader;
+pub use wavewriter::WaveWriter;
 pub use bext::Bext;
-pub use fmt::{WaveFmt, WaveFmtExtended, ChannelDescriptor};
+pub use fmt::{WaveFmt, WaveFmtExtended, ChannelDescriptor, ChannelMask};
 pub use common_format::CommonFormat;
 pub use audio_frame_reader::AudioFrameReader;

src/raw_chunk_reader.rs

@@ -9,8 +9,8 @@ use std::io::{Seek,Read,Error,ErrorKind};
 #[derive(Debug)]
 pub struct RawChunkReader<'a, R: Read + Seek> {
     reader: &'a mut R,
-    start: u64,
-    length: u64,
+    pub start: u64,
+    pub length: u64,
     position: u64
 }
 
@@ -23,10 +23,6 @@ impl<'a,R: Read + Seek> RawChunkReader<'a, R> {
             position: 0
         }
     }
-
-    pub fn length(&self) -> u64 {
-        self.length
-    } 
 }
 
 impl<'a, R:Read + Seek> Read for RawChunkReader<'_, R> {

src/wavereader.rs

@@ -5,7 +5,7 @@ use super::parser::Parser;
 use super::fourcc::{FourCC, FMT__SIG,DATA_SIG, BEXT_SIG, JUNK_SIG, FLLR_SIG};
 use super::errors::Error as ParserError;
 use super::raw_chunk_reader::RawChunkReader;
-use super::fmt::WaveFmt;
+use super::fmt::{WaveFmt, ChannelDescriptor, ChannelMask};
 use super::bext::Bext;
 use super::audio_frame_reader::AudioFrameReader;
 use super::chunks::ReadBWaveChunks;
@@ -65,7 +65,7 @@ impl<R: Read + Seek> WaveReader<R> {
      * This function does a minimal validation on the provided stream and
      * will return an `Err(errors::Error)` immediately if there is a structural 
      * inconsistency that makes the stream unreadable or if it's missing 
-     * essential components that make interpreting the audio data impoossible.
+     * essential components that make interpreting the audio data impossible.
      * 
      * ```rust
      * use std::fs::File;
@@ -100,13 +100,13 @@ impl<R: Read + Seek> WaveReader<R> {
         return self.inner;
     }
 
-    /**
-     * Create an `AudioFrameReader` for reading each audio frame.
-    */
-    pub fn audio_frame_reader(&mut self) -> Result<AudioFrameReader<RawChunkReader<R>>, ParserError> {
+    ///
+    /// Create an `AudioFrameReader` for reading each audio frame and consume the `WaveReader`.
+    ///
+    pub fn audio_frame_reader(mut self) -> Result<AudioFrameReader<R>, ParserError> {
         let format = self.format()?;
-        let audio_chunk_reader = self.chunk_reader(DATA_SIG, 0)?;
-        Ok(AudioFrameReader::new(audio_chunk_reader, format))
+        let audio_chunk_reader = self.get_chunk_extent_at_index(DATA_SIG, 0)?;
+        Ok(AudioFrameReader::new(self.inner, format, audio_chunk_reader.0, audio_chunk_reader.1)?)
     }
 
     /**
@@ -132,6 +132,69 @@ impl<R: Read + Seek> WaveReader<R> {
         self.chunk_reader(BEXT_SIG, 0)?.read_bext()
     }
 
+    /// Describe the channels in this file
+    /// 
+    /// Returns a vector of channel descriptors, one for each channel
+    /// 
+    /// ```rust
+    /// # use bwavfile::WaveReader;
+    /// # use bwavfile::ChannelMask;
+    /// let mut f = WaveReader::open("tests/media/pt_24bit_51.wav").unwrap();
+    /// 
+    /// let chans = f.channels().unwrap();
+    /// assert_eq!(chans[0].index, 0);
+    /// assert_eq!(chans[0].speaker, ChannelMask::FrontLeft);
+    /// assert_eq!(chans[3].index, 3);
+    /// assert_eq!(chans[3].speaker, ChannelMask::LowFrequency);
+    /// assert_eq!(chans[4].speaker, ChannelMask::BackLeft);
+    /// ```
+    pub fn channels(&mut self) -> Result<Vec<ChannelDescriptor>, ParserError> {
+        
+        let format = self.format()?;
+        let channel_masks : Vec<ChannelMask> = match (format.channel_count, format.extended_format) {
+            (1,_) => vec![ChannelMask::FrontCenter],
+            (2,_) => vec![ChannelMask::FrontLeft, ChannelMask::FrontRight],
+            (n,Some(x)) => ChannelMask::channels(x.channel_mask, n),
+            (n,_) => vec![ChannelMask::DirectOut; n as usize]
+        };
+
+        Ok( (0..format.channel_count).zip(channel_masks)
+            .map(|(i,m)| ChannelDescriptor { index: i, speaker:m, adm_track_audio_ids: vec![] } )
+            .collect() )
+    }
+
+    /// Read iXML data.
+    /// 
+    /// If there are no iXML metadata present in the file, 
+    /// Err(Error::ChunkMissing { "iXML" } will be returned.
+    pub fn ixml(&mut self, buffer: &mut Vec<u8>) -> Result<usize, ParserError> {
+        let ixml_sig: FourCC = FourCC::make(b"iXML");
+        let mut chunk = self.chunk_reader(ixml_sig, 0)?;
+
+        match chunk.read_to_end(buffer) {
+            Ok(read) => Ok(read),
+            Err(error) => Err(error.into())
+        }
+    }
+
+    /// Read AXML data.
+    /// 
+    /// By convention this will generally be ADM metadata. 
+    /// 
+    /// If there are no iXML metadata present in the file, 
+    /// Err(Error::ChunkMissing { "axml" } will be returned. 
+    pub fn axml(&mut self, buffer: &mut Vec<u8>) -> Result<usize, ParserError> {
+        let axml_sig: FourCC = FourCC::make(b"axml");
+        let mut chunk = self.chunk_reader(axml_sig, 0)?;
+
+        match chunk.read_to_end(buffer) {
+            Ok(read) => Ok(read),
+            Err(error) => Err(error.into())
+        }
+    }
+
+
+
     /**
     * Validate file is readable.
     * 
@@ -286,3 +349,4 @@ impl<R:Read+Seek> WaveReader<R> { /* Private Implementation */
         }
     }
 }
+

src/wavewriter.rs

@@ -11,7 +11,8 @@ use super::fourcc::{FourCC, RIFF_SIG, WAVE_SIG, FMT__SIG, JUNK_SIG, BEXT_SIG, DA
 use byteorder::LittleEndian;
 use byteorder::WriteBytesExt;
 
-struct WaveWriter<W> where W: Write + Seek {
+/// This isn't working yet, do not use.
+pub struct WaveWriter<W> where W: Write + Seek {
     inner : W
 }
 
@@ -91,14 +92,3 @@ impl<W:Write + Seek> WaveWriter<W> {
     }
 }
 
-#[test]
-fn test_chunk_append() -> Result<(), Error> {
-    let mut test :Vec<u8> = vec![];
-    let mut cursor = Cursor::new(test);
-    let f = WaveFmt::new_pcm(48000, 16, 1);
-    let mut w = WaveWriter::make(cursor, f, None)?;
-
-    
-
-    Ok(())
-}

tests/ffprobe_media_tests.json

@@ -1,4 +1,57 @@
 [
+  {
+    "streams": [
+      {
+        "index": 0,
+        "codec_name": "pcm_s24le",
+        "codec_long_name": "PCM signed 24-bit little-endian",
+        "codec_type": "audio",
+        "codec_time_base": "1/48000",
+        "codec_tag_string": "[1][0][0][0]",
+        "codec_tag": "0x0001",
+        "sample_fmt": "s32",
+        "sample_rate": "48000",
+        "channels": 2,
+        "channel_layout": "stereo",
+        "bits_per_sample": 24,
+        "r_frame_rate": "0/0",
+        "avg_frame_rate": "0/0",
+        "time_base": "1/48000",
+        "duration_ts": 4800,
+        "duration": "0.100000",
+        "bit_rate": "2304000",
+        "bits_per_raw_sample": "24",
+        "disposition": {
+          "default": 0,
+          "dub": 0,
+          "original": 0,
+          "comment": 0,
+          "lyrics": 0,
+          "karaoke": 0,
+          "forced": 0,
+          "hearing_impaired": 0,
+          "visual_impaired": 0,
+          "clean_effects": 0,
+          "attached_pic": 0,
+          "timed_thumbnails": 0
+        }
+      }
+    ],
+    "format": {
+      "filename": "tests/media/ff_pink.wav",
+      "nb_streams": 1,
+      "nb_programs": 0,
+      "format_name": "wav",
+      "format_long_name": "WAV / WAVE (Waveform Audio)",
+      "duration": "0.100000",
+      "size": "28902",
+      "bit_rate": "2312160",
+      "probe_score": 99,
+      "tags": {
+        "encoder": "Lavf58.45.100"
+      }
+    }
+  },
   {
     "streams": [
       {

tests/integration_test.rs

@@ -2,6 +2,7 @@ extern crate bwavfile;
 
 use bwavfile::WaveReader;
 use bwavfile::Error;
+use bwavfile::{ ChannelMask}; 
 
 #[test]
 fn test_open() {
@@ -74,4 +75,105 @@ fn test_minimal_wave()  {
     } else {
         assert!(true);
     }
+}
+
+#[test]
+fn test_read() {
+    let path = "tests/media/audacity_16bit.wav";
+
+    let w = WaveReader::open(path).expect("Failure opening test file");
+
+    let mut reader = w.audio_frame_reader().unwrap();
+
+    let mut buffer = reader.create_frame_buffer();
+
+    assert_eq!(reader.read_integer_frame(&mut buffer).unwrap(), 1);
+    assert_eq!(buffer[0], -2823_i32);
+    assert_eq!(reader.read_integer_frame(&mut buffer).unwrap(), 1);
+    assert_eq!(buffer[0], 2012_i32);
+    assert_eq!(reader.read_integer_frame(&mut buffer).unwrap(), 1);
+    assert_eq!(buffer[0], 4524_i32); 
+}
+
+#[test]
+fn test_locate_multichannel_read() {
+    let path = "tests/media/ff_pink.wav";
+
+    let w = WaveReader::open(path).expect("Failure opening test file");
+
+    let mut reader = w.audio_frame_reader().unwrap();
+
+    let mut buffer = reader.create_frame_buffer();
+
+    assert_eq!(reader.read_integer_frame(&mut buffer).unwrap(), 1);
+    assert_eq!(buffer[0], 332702_i32);
+    assert_eq!(buffer[1], 3258791_i32);
+    assert_eq!(reader.read_integer_frame(&mut buffer).unwrap(), 1);
+    assert_eq!(buffer[0], -258742_i32); // 0x800000 = 8388608 // 8129866 - 8388608
+    assert_eq!(buffer[1], 0x0D7EF9_i32);
+
+    assert_eq!(reader.locate(100).unwrap(), 100);
+    assert_eq!(reader.read_integer_frame(&mut buffer).unwrap(), 1);
+    assert_eq!(buffer[0], 0x109422_i32);
+    assert_eq!(buffer[1], -698901_i32); // 7689707 - 8388608
+}
+
+#[test]
+fn test_channels_stereo() {
+    let path = "tests/media/ff_pink.wav";
+
+    let mut w = WaveReader::open(path).expect("Failure opening test file");
+    let channels = w.channels().unwrap();
+
+    assert_eq!(channels.len(), 2);
+    assert_eq!(channels[0].index,0);
+    assert_eq!(channels[1].index,1);
+    assert_eq!(channels[0].speaker,ChannelMask::FrontLeft);
+    assert_eq!(channels[1].speaker,ChannelMask::FrontRight);
+}
+
+#[test]
+fn test_channels_mono_no_extended() {
+    let path = "tests/media/audacity_16bit.wav";
+
+    let mut w = WaveReader::open(path).expect("Failure opening test file");
+    let channels = w.channels().unwrap();
+
+    assert_eq!(channels.len(), 1);
+    assert_eq!(channels[0].index,0);
+    assert_eq!(channels[0].speaker,ChannelMask::FrontCenter);
+}
+
+#[test]
+fn test_channels_stereo_no_fmt_extended() {
+    let path = "tests/media/pt_24bit_stereo.wav";
+
+    let mut w = WaveReader::open(path).expect("Failure opening test file");
+    let channels = w.channels().unwrap();
+
+    assert_eq!(channels.len(), 2);
+    assert_eq!(channels[0].index,0);
+    assert_eq!(channels[1].index,1);
+    assert_eq!(channels[0].speaker,ChannelMask::FrontLeft);
+    assert_eq!(channels[1].speaker,ChannelMask::FrontRight);
+}
+
+//See issue 6 and 7
+#[test]
+fn test_frame_reader_consumes_reader() {
+    // Issue #6
+    use bwavfile::WaveFmt;
+    use bwavfile::AudioFrameReader;
+    use std::fs::File;
+    fn from_wav_filename(wav_filename: &str) -> Result<(WaveFmt, AudioFrameReader<File>), ()> {
+        if let Ok(mut r) = WaveReader::open(&wav_filename) {
+            let format = r.format().unwrap();
+            let frame_reader = r.audio_frame_reader().unwrap();
+            Ok((format, frame_reader))
+        } else {
+            Err(())
+        }
+    }
+
+    let _result = from_wav_filename("tests/media/pt_24bit_stereo.wav").unwrap();
 }