Fixed some typos in this

Update to version 1.1
Merge pull request #10 from atoav/cuepoints
2025-12-31 17:00:44 +00:00 · 2021-09-28 13:49:04 -07:00 · 2021-09-28 13:46:34 -07:00 · 2021-09-28 13:39:09 -07:00 · 2021-09-28 13:18:07 -07:00 · 2021-09-28 12:30:45 -07:00
25 changed files with 1674 additions and 555 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,10 +1,37 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
+[[package]]
+name = "ansi_term"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
 [[package]]
 name = "bwavfile"
-version = "0.9.0"
+version = "1.1.0"
 dependencies = [
 "byteorder",
+ "clap",
 "encoding",
 "serde_json",
 "uuid",
@@ -12,9 +39,24 @@ dependencies = [

 [[package]]
 name = "byteorder"
-version = "1.3.4"
+version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
+checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+
+[[package]]
+name = "clap"
+version = "2.33.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "bitflags",
+ "strsim",
+ "textwrap",
+ "unicode-width",
+ "vec_map",
+]

 [[package]]
 name = "encoding"
@@ -81,10 +123,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a246d82be1c9d791c5dfde9a2bd045fc3cbba3fa2b11ad558f27d01712f00569"

 [[package]]
-name = "itoa"
-version = "0.4.6"
+name = "hermit-abi"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "itoa"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
+
+[[package]]
+name = "libc"
+version = "0.2.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd8f7255a17a627354f321ef0055d63b898c6fb27eff628af4d1b66b7331edf6"

 [[package]]
 name = "ryu"
@@ -94,15 +151,15 @@ checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"

 [[package]]
 name = "serde"
-version = "1.0.117"
+version = "1.0.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b88fa983de7720629c9387e9f517353ed404164b1e482c970a90c1a4aaf7dc1a"
+checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"

 [[package]]
 name = "serde_json"
-version = "1.0.59"
+version = "1.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcac07dbffa1c65e7f816ab9eba78eb142c6d44410f4eeba1e26e4f5dfa56b95"
+checksum = "0f690853975602e1bfe1ccbf50504d67174e3bcf340f23b5ea9992e0587a52d8"
 dependencies = [
 "itoa",
 "ryu",
@@ -110,7 +167,56 @@ dependencies = [
 ]

 [[package]]
-name = "uuid"
-version = "0.8.1"
+name = "strsim"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fde2f6a4bea1d6e007c4ad38c6839fa71cbb63b6dbf5b595aa38dc9b1093c11"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "unicode-width"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+
+[[package]]
+name = "uuid"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7"
+
+[[package]]
+name = "vec_map"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bwavfile"
-version = "0.9.0"
+version = "1.1.0"
 authors = ["Jamie Hardt <jamiehardt@me.com>"]
 edition = "2018"
 license = "MIT"
@@ -16,8 +16,11 @@ keywords = ["audio", "broadcast", "multimedia","smpte"]
 [dependencies]
 byteorder = "1.3.4"
 encoding = "0.2.33"
-serde_json = "1.0.59"
 uuid = "0.8.1"
+clap = "2.33.3"
+
+[dev-dependencies]
+serde_json = "1.0.61"

 [profile.release]
 debug = true
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2020 Jamie Hardt
+Copyright (c) 2021 Jamie Hardt

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/README.md
+++ b/README.md
@@ -4,64 +4,45 @@
 [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/iluvcapra/bwavfile/Rust)](https://github.com/iluvcapra/bwavfile/actions?query=workflow%3ARust)

 # bwavfile
-Rust Wave File Reader/Writer with Broadcast-WAV, MBWF and RF64 Support
+Wave File Reader/Writer library in Rust, with Broadcast-WAV, MBWF and RF64 Support

-### Features
+## Features

-This is currently a work-in-progress! However many features presently work:
+__bwavfile__ provides a reader `WaveReader` and writer type `WaveWriter` for 
+reading and creating new audio files respectively.

-| Feature                               | Read  | Write |
-|---------------------------------------|:-----:|:-----:|
-| Standard .wav files                   | ☑️   | ☑️ |
-| Transparent promotion to RF64/BW64    | ☑️   |    |
-| Unified interface for regular and extended Wave format | ☑️  |  |
-| Channel/speaker map metadata          | ☑️    |    |
-| Ambisonic B-format metadata           | ☑️    |   |
-| EBU Broadcast-WAVE metadata           | ☑️   |    |
-| Basic iXML/ADM metadata               | ☑️    |    |
-| Enhanced iXML metadata support        |        |    |
-| Broadcast-WAVE Level overview `levl` metadata         |    |    |
-| Cue list metadata                     | ☑️   |    |
-| Sampler and instrument metadata       |    |    |
-| Enhanced Wave file form validation    | ☑️   | 🚫   |
+`WaveReader` and `WaveWriter` support:
+  * A unified interface for standard RIFF and RF64/BW64 64-bit Wave files.
+  * When using `WaveWriter`, wave files are transparently upgraded from RIFF
+    to RF64 when required.
+  * Unpacked reading and writing of Integer PCM and IEEE float audio data 
+    formats.
+  * A unified interface for standard `WaveFormat` and extended `WaveFormatEx`
+    wave data format specification.
+  * Multichannel, surround, and ambisonic audio data description including 
+    surround channel maps, ADM `AudioTrackFormat`, `AudioChannelFormatRef` and 
+    `AudioPackRef` data structures.
+  * Broadcast-Wave metdata extension, including long description, originator 
+    information, SMPTE UMID and coding history.
+  * Reading and writing of embedded iXML and axml/ADM metadata.
+  * Reading and writing of timed cues and and timed cue regions.
+
+### Feature Roadmap
+
+Some features that may be included in the future include:
+  * Broadcast-Wave `levl` waveform overview data reading and writing.
+  * Sampler and Instrument metadata.
+  * Performance improvements.


 ## Use Examples

-### Reading Audio Frames From a File
-
-```rust
-
- use bwavfile::WaveReader;
- let mut r = WaveReader::open("tests/media/ff_silence.wav").unwrap();
- 
- let format = r.format().unwrap();
- assert_eq!(format.sample_rate, 44100);
- assert_eq!(format.channel_count, 1);
- 
- let mut buffer = format.create_frame_buffer();
- let mut frame_reader = r.audio_frame_reader().unwrap();
- 
- let read = frame_reader.read_integer_frame(&mut buffer).unwrap();
- 
- assert_eq!(buffer, [0i32]);
- assert_eq!(read, 1);
-```
-
-### Accessing Channel Descriptions
-
-```rust
- use bwavfile::{WaveReader, 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);
-```
+  * [blits](examples/blits.rs) shows how to use `WaveWriter` to create a new
+    file with BLITS alignment tones.
+  * [wave-inter](examples/wave-inter.rs) uses `WaveReader` and `WaveWriter` to
+    interleave several input Wave files into a single polyphonic Wave file.
+  * [wave-deinter](examples/wave-deinter.rs) uses `WaveReader` and `WaveWriter`
+    to de-interleave an input Wave file into several monoarual Wave files.

 ## Note on Testing

@@ -69,3 +50,5 @@ All of the media for the integration tests is committed to the respository
 in zipped form. Before you can run tests, you need to `cd` into the `tests` 
 directory and run the `create_test_media.sh` script. Note that one of the 
 test files (the RF64 test case) is over four gigs in size.
+
+[rf64test]: https://github.com/iluvcapra/bwavfile/blob/1f8542a7efb481da076120bf8107032c5b48889d/src/wavewriter.rs#L399
--- a/examples/blits.rs
+++ b/examples/blits.rs
@@ -0,0 +1,266 @@
+//! bilts.rs
+//! (c) 2021 Jamie Hardt. All rights reserved.
+//! 
+//! This program demonstrates the creation of a wave file with a BLITS
+//! ("Black and Lanes' Ident Tones for Surround") channel identification and 
+//! alignment signal.
+//! 
+//! TODO: Pre-calculate the sine waves to speed up generation
+//! TODO: Make tone onsets less snappy
+
+use std::f64;
+use std::io;
+
+extern crate bwavfile;
+use bwavfile::{WaveWriter, WaveFmt, Error};
+
+#[macro_use]
+extern crate clap;
+use clap::{Arg, App};
+
+
+fn sine_wave(t: u64, amplitude : i32, wavelength : u32) -> i32 {
+    //I did it this way because I'm weird
+    Some(t).map(|i| (i as f64) * 2f64 * f64::consts::PI / wavelength as f64 )
+    .map(|f| f.sin() )
+    .map(|s| (s * amplitude as f64) as i32)
+    .unwrap()
+}
+
+/// Return the corresponding f32 gain for a dbfs.
+/// 
+/// Retval will always be positive
+fn dbfs_to_f32(dbfs : f32) -> f32 {
+    10f32.powf(dbfs / 20f32)
+}
+
+fn dbfs_to_signed_int(dbfs: f32, bit_depth: u16) -> i32 {
+    let full_code : i32 = (1i32 << bit_depth - 1) - 1;
+    ((full_code as f32) * dbfs_to_f32(dbfs)) as i32
+}
+
+
+#[derive(Clone, Copy, PartialEq)]
+enum ToneBurst {
+    /// Tone of .0 frequency (hz) for .1 duration (ms) at .2 dBfs
+    Tone(f32, u64, f32),
+    /// Silence of .0 Duration (ms)
+    Silence(u64),
+}
+
+impl ToneBurst {
+    fn duration(&self, sample_rate : u32) -> u64 {
+        match self {
+            Self::Tone(_, dur, _) => *dur * sample_rate as u64 / 1000,
+            Self::Silence(dur) => *dur * sample_rate as u64 / 1000
+        }
+    }
+}
+
+trait ToneBurstSignal {
+
+    fn duration(&self, sample_rate: u32) -> u64;
+
+    fn signal(&self, t: u64, sample_rate: u32, bit_depth: u16) -> i32;
+}
+
+impl ToneBurstSignal for Vec<ToneBurst> {
+    
+    fn duration(&self, sample_rate: u32) -> u64 {
+        self.iter().fold(0u64, |accum, &item| {
+            accum + &item.duration(sample_rate)
+        })
+    }
+
+    fn signal(&self, t: u64, sample_rate: u32, bit_depth: u16) -> i32 { 
+        self.iter()
+            .scan(0u64, |accum, &item| {
+                let dur = item.duration(sample_rate);
+                let this_time_range = *accum..(*accum + dur);
+                *accum = *accum + dur;
+                Some( (this_time_range, item) )
+            })
+            .find(|(range, _)| range.contains(&t))
+            .map(|(_, item)| {
+                match item {
+                    ToneBurst::Tone(freq, _, dbfs) => {
+                        let gain = dbfs_to_signed_int(dbfs, bit_depth);
+                        sine_wave(t, gain, (sample_rate as f32 / freq) as u32)
+                    },
+                    ToneBurst::Silence(_) => {
+                        0
+                    }
+                }
+            }).unwrap_or(0i32)
+    }
+}
+
+fn create_blits_file(file_name: &str, sample_rate : u32, bits_per_sample : u16) -> Result<(),Error> {
+
+    // BLITS Tone signal format
+    // From EBU Tech 3304 §4 - https://tech.ebu.ch/docs/tech/tech3304.pdf
+    let left_channel_sequence : Vec<ToneBurst> = vec![
+        // channel ident    
+        ToneBurst::Tone(880.0, 600, -18.0),
+        ToneBurst::Silence(200),
+        ToneBurst::Silence(4000),
+
+        // LR ident
+        ToneBurst::Tone(1000.0, 1000, -18.0),
+        ToneBurst::Silence(300),
+        ToneBurst::Tone(1000.0, 300, -18.0),
+        ToneBurst::Silence(300),
+        ToneBurst::Tone(1000.0, 300, -18.0),
+        ToneBurst::Silence(300),
+        ToneBurst::Tone(1000.0, 300, -18.0),
+        ToneBurst::Silence(300),
+        ToneBurst::Tone(1000.0, 2000, -18.0),
+        ToneBurst::Silence(300),
+
+        // Phase check,
+        ToneBurst::Tone(2000.0, 3000, -24.0),
+        ToneBurst::Silence(200)
+    ];
+
+    let right_channel_sequence : Vec<ToneBurst> = vec![
+        // channel ident
+        ToneBurst::Silence(800),    
+        ToneBurst::Tone(880.0, 600, -18.0),
+        ToneBurst::Silence(200),
+        ToneBurst::Silence(3200),
+
+        // LR ident
+        ToneBurst::Tone(1000.0, 5100, -18.0),
+        ToneBurst::Silence(300),
+
+        // Phase check,
+        ToneBurst::Tone(2000.0, 3000, -24.0),
+        ToneBurst::Silence(200)
+    ];
+
+    let center_channel_sequence : Vec<ToneBurst> = vec![
+        // channel ident
+        ToneBurst::Silence(1600),    
+        ToneBurst::Tone(1320.0, 600, -18.0),
+        ToneBurst::Silence(200),
+        ToneBurst::Silence(2400),
+
+        // LR ident
+        ToneBurst::Silence(5400),
+
+        // Phase check,
+        ToneBurst::Tone(2000.0, 3000, -24.0),
+        ToneBurst::Silence(200)
+    ];
+
+    let lfe_channel_sequence : Vec<ToneBurst> = vec![
+        // channel ident
+        ToneBurst::Silence(2400),    
+        ToneBurst::Tone(82.5, 600, -18.0),
+        ToneBurst::Silence(200),
+        ToneBurst::Silence(1600),
+
+        // LR ident
+        ToneBurst::Silence(5400),
+
+        // Phase check,
+        ToneBurst::Tone(2000.0, 3000, -24.0),
+        ToneBurst::Silence(200)
+    ];
+
+    let ls_channel_sequence : Vec<ToneBurst> = vec![
+        // channel ident
+        ToneBurst::Silence(3200),    
+        ToneBurst::Tone(660.0, 600, -18.0),
+        ToneBurst::Silence(200),
+        ToneBurst::Silence(800),
+
+        // LR ident
+        ToneBurst::Silence(5400),
+
+        // Phase check,
+        ToneBurst::Tone(2000.0, 3000, -24.0),
+        ToneBurst::Silence(200)
+    ];
+
+    let rs_channel_sequence : Vec<ToneBurst> = vec![
+        // channel ident
+        ToneBurst::Silence(4000),    
+        ToneBurst::Tone(660.0, 600, -18.0),
+        ToneBurst::Silence(200),
+
+        // LR ident
+        ToneBurst::Silence(5400),
+
+        // Phase check,
+        ToneBurst::Tone(2000.0, 3000, -24.0),
+        ToneBurst::Silence(200)
+    ];
+
+    let length = [&left_channel_sequence, &right_channel_sequence, 
+        &center_channel_sequence, &lfe_channel_sequence, 
+        &ls_channel_sequence, &rs_channel_sequence].iter()
+            .map(|i| i.duration(sample_rate))
+            .max().unwrap_or(0);
+
+    let frames = (0..=length).map(|frame| {
+        (left_channel_sequence.signal(frame, sample_rate, bits_per_sample),
+        right_channel_sequence.signal(frame, sample_rate, bits_per_sample),
+        center_channel_sequence.signal(frame, sample_rate, bits_per_sample),
+        lfe_channel_sequence.signal(frame, sample_rate, bits_per_sample),
+        ls_channel_sequence.signal(frame, sample_rate, bits_per_sample),
+        rs_channel_sequence.signal(frame, sample_rate, bits_per_sample))
+    });
+
+    let format = WaveFmt::new_pcm_multichannel(sample_rate, bits_per_sample, 0b111111);
+
+    let file = WaveWriter::create(file_name, format)?;
+
+    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.end()?;
+
+    Ok(())
+}
+
+fn main() -> io::Result<()> {
+
+    let matches = App::new("blits")
+    .version(crate_version!())
+    .author(crate_authors!())
+    .about("Generate a BLITS 5.1 alignment tone.")
+    .arg(Arg::with_name("sample_rate")
+        .long("sample-rate")    
+        .short("s")
+        .help("Sample rate of output")
+        .default_value("48000")
+    )
+    .arg(Arg::with_name("bit_depth")
+        .long("bit-depth")
+        .short("b")
+        .help("Bit depth of output")
+        .default_value("24")
+    )
+    .arg(Arg::with_name("OUTPUT")
+        .help("Output wave file")
+        .default_value("blits.wav")
+    )
+    .get_matches();
+
+    let sample_rate = matches.value_of("sample_rate").unwrap().parse::<u32>()
+        .expect("Failed to read sample rate");
+
+    let bits_per_sample = matches.value_of("bit_depth").unwrap().parse::<u16>()
+        .expect("Failed to read bit depth");
+        
+    let filename = matches.value_of("OUTPUT").unwrap();
+
+    match create_blits_file(&filename, sample_rate, bits_per_sample) {
+        Err( Error::IOError(x) ) => panic!("IO Error: {:?}", x),
+        Err( err ) => panic!("Error: {:?}", err),
+        Ok(()) => Ok(())
+    }
+}
--- a/examples/wave-deinter.rs
+++ b/examples/wave-deinter.rs
@@ -0,0 +1,119 @@
+//! wave-inter.rs
+//! (c) 2021 Jamie Hardt. All rights reserved.
+//! 
+//! This program demonstrats combining several wave files into a single
+//! polyphonic wave file.
+
+use std::io;
+use std::path::Path;
+
+extern crate bwavfile;
+use bwavfile::{Error,WaveReader, WaveWriter, ChannelDescriptor, ChannelMask, WaveFmt};
+
+#[macro_use]
+extern crate clap;
+use clap::{Arg, App};
+
+fn name_suffix(force_numeric : bool, delim : &str, index: usize, channel_descriptor : &ChannelDescriptor) -> String {
+    if force_numeric || channel_descriptor.speaker == ChannelMask::DirectOut {
+        format!("{}A{:02}", delim, index)
+    } else {
+        let chan_name = match channel_descriptor.speaker {
+            ChannelMask::FrontLeft => "L",
+            ChannelMask::FrontCenter => "C",
+            ChannelMask::FrontRight => "R",
+            ChannelMask::BackLeft => "Ls",
+            ChannelMask::BackRight => "Rs",
+            ChannelMask::BackCenter => "S",
+            ChannelMask::TopCenter => "Tc",
+            ChannelMask::LowFrequency => "Lfe",
+            ChannelMask::SideLeft => "Lss",
+            ChannelMask::SideRight => "Rss",
+            ChannelMask::FrontCenterLeft => "Lc",
+            ChannelMask::FrontCenterRight => "Rc",
+            ChannelMask::TopFrontLeft => "Ltf",
+            ChannelMask::TopFrontCenter => "Ctf",
+            ChannelMask::TopFrontRight => "Rtf",
+            ChannelMask::TopBackLeft => "Ltb",
+            ChannelMask::TopBackCenter => "Ctb",
+            ChannelMask::TopBackRight => "Rtb",
+            ChannelMask::DirectOut => panic!("Error, can't get here")
+        };
+        format!("{}{}", delim, chan_name)
+    }
+}
+
+fn process_file(infile: &str, delim : &str, numeric_channel_names : bool) -> Result<(), Error> {
+    let mut input_file = WaveReader::open(infile)?;
+    let channel_desc = input_file.channels()?;
+    let input_format = input_file.format()?;
+
+    if channel_desc.len() == 1 {
+        println!("Input file in monoaural, exiting.");
+        return Ok(());
+    }
+
+    let infile_path = Path::new(infile);
+    let basename = infile_path.file_stem().expect("Unable to extract file basename").to_str().unwrap();
+    let output_dir = infile_path.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 mut output_wave_writer = output_file.audio_frame_writer()?;
+        let mut buffer = input_format.create_frame_buffer(1);
+
+        while input_wave_reader.read_integer_frame(&mut buffer)? > 0 {
+            output_wave_writer.write_integer_frames(&buffer[n..=n])?;
+        }
+
+        output_wave_writer.end()?;
+        input_wave_reader.locate(0)?;
+    }
+
+    Ok(())
+}
+
+fn main() -> io::Result<()> {
+    let matches = App::new("wave-deinter")
+        .version(crate_version!())
+        .author(crate_authors!())
+        .about("Extract each channel of a polyphonic wave file as a new monoaural wave file.")
+        .arg(Arg::with_name("numeric_names")
+            .long("numeric")    
+            .short("n")
+            .help("Use numeric channel names \"01\" \"02\" etc.")
+            .takes_value(false)
+        )
+        .arg(Arg::with_name("channel_delimiter")
+            .long("delim")
+            .short("d")
+            .help("Channel label delimiter.")
+            .default_value(".")
+        )
+        .arg(Arg::with_name("INPUT")
+            .help("Input wave file")
+            .required(true)
+            .multiple(true)
+        )
+        .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();
+
+    match process_file(infile, delimiter, use_numeric_names) {
+        Err(Error::IOError(io)) => Err(io),
+        Err(e) => panic!("Error: {:?}", e),
+        Ok(()) => Ok(())
+    }
+}
--- a/examples/wave-inter.rs
+++ b/examples/wave-inter.rs
@@ -0,0 +1,35 @@
+//! wave-inter.rs
+//! (c) 2021 Jamie Hardt. All rights reserved.
+//! 
+//! This program demonstrates combining several wave files into a single
+//! polyphonic wave file.
+
+use std::io;
+
+extern crate bwavfile;
+
+#[macro_use]
+extern crate clap;
+use clap::{Arg, App};
+
+fn main() -> io::Result<()> {
+    let matches = App::new("wave-inter")
+        .version(crate_version!())
+        .author(crate_authors!())
+        .about("Combine several wave files into a single polyphonic wave file.")
+        .arg(Arg::with_name("OUTPUT")
+            .long("output")
+            .short("o")
+            .help("Output file name. If absent, will be basename, minus any channel extension, of first INPUT.")
+        )
+        .arg(Arg::with_name("INPUT")
+            .help("Input wave file")
+            .required(true)
+            .multiple(true)
+        )
+        .get_matches();
+
+    println!("Command line opts: {:?}", matches);
+
+    todo!("Finish implementation");
+}
--- a/src/audio_frame_reader.rs
+++ b/src/audio_frame_reader.rs
@@ -1,109 +0,0 @@
-use std::io::{Read, Seek};
-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
-/// 
-/// The inner reader is interpreted as a raw audio data
-/// bitstream having a format specified by `format`.
-/// 
-#[derive(Debug)]
-pub struct AudioFrameReader<R: Read + Seek> {
-    inner : R,
-    format: WaveFmt,
-    start: u64,
-    length: u64
-}
-
-impl<R: Read + Seek> AudioFrameReader<R> {
-
-    /// Create a new `AudioFrameReader`
-    /// 
-    /// ### Panics
-    /// 
-    /// This method does a few sanity checks on the provided format
-    /// 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(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.common_format() == CommonFormat::IntegerPCM , 
-                "Unsupported format tag {:?}", format.tag);
-        
-        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(self.start + position))?;
-        Ok( (seek_result - self.start) / self.format.block_alignment as u64 )
-    }
-
-
-    /// Read a frame
-    /// 
-    /// 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 
-    /// channels and this method will panic if this is not the case.
-    pub fn read_integer_frame(&mut self, buffer:&mut [i32]) -> Result<u64,Error> {
-        assert!(buffer.len() as u16 == self.format.channel_count, 
-            "read_integer_frame was called with a mis-sized buffer, expected {}, was {}", 
-            self.format.channel_count, buffer.len());
-
-        let framed_bits_per_sample = self.format.block_alignment * 8 / self.format.channel_count;
-
-        let tell = self.inner.seek(Current(0))?;
-
-        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 )
-        }
-    }
-}
--- a/src/bext.rs
+++ b/src/bext.rs
@@ -3,20 +3,27 @@ pub type LU = f32;
 pub type LUFS = f32;
 pub type Decibels = f32;

-/**
- * Broadcast-WAV metadata record.
- * 
- * The `bext` record contains information about the original recording of the 
- * Wave file, including a longish (256 ASCII chars) description field, 
- * originator identification fields, creation calendar date and time, a 
- * sample-accurate recording time field, and a SMPTE UMID. 
- * 
- * For a Wave file to be a complaint "Broadcast-WAV" file, it must contain
- * a `bext` metadata record.
- * 
- * For reference on the structure and use of the BEXT record
- * check out [EBU Tech 3285](https://tech.ebu.ch/docs/tech/tech3285.pdf).
- */
+
+///  Broadcast-WAV metadata record.
+///
+///  The `bext` record contains information about the original recording of the 
+///  Wave file, including a longish (256 ASCII chars) description field, 
+///  originator identification fields, creation calendar date and time, a 
+///  sample-accurate recording time field, and a SMPTE UMID. 
+///
+///  For a Wave file to be a complaint "Broadcast-WAV" file, it must contain
+///  a `bext` metadata record.
+///
+/// ## Resources
+/// - [EBU Tech 3285](https://tech.ebu.ch/docs/tech/tech3285.pdf).
+/// - [EBU Tech R098](https://tech.ebu.ch/docs/r/r098.pdf) (1999) "Format for the &lt;CodingHistory&gt; field in Broadcast Wave Format files, BWF"
+/// - [EBU Tech R099](https://tech.ebu.ch/docs/r/r099.pdf) (October 2011) "‘Unique’ Source Identifier (USID) for use in the 
+///   &lt;OriginatorReference&gt; field of the Broadcast Wave Format"
+
+// Note for me later:
+// get env values: https://doc.rust-lang.org/std/macro.option_env.html
+// Cargo env values: https://doc.rust-lang.org/cargo/reference/environment-variables.html
+
 #[derive(Debug)]
 pub struct Bext {

@@ -47,7 +54,6 @@ pub struct Bext {

    /// SMPTE 330M UMID
    /// 
-    /// 
    /// This field is `None` if the version is less than 1.
    pub umid: Option<[u8; 64]>,

--- a/src/chunks.rs
+++ b/src/chunks.rs
@@ -33,7 +33,14 @@ impl<T> WriteBWaveChunks for T where T: Write {
        self.write_u32::<LittleEndian>(format.bytes_per_second)?;
        self.write_u16::<LittleEndian>(format.block_alignment)?;
        self.write_u16::<LittleEndian>(format.bits_per_sample)?;
-        // self.write_u8(0)?;
+        if let Some(ext) = format.extended_format {
+            let cb_size = 24u16;
+            self.write_u16::<LittleEndian>(cb_size)?;
+            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)?;
+        }
        Ok(())
    }

--- a/src/common_format.rs
+++ b/src/common_format.rs
@@ -1,12 +1,5 @@
 use uuid::Uuid;

-/**
- * References:
- * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/multichaudP.pdf
-*/
-
-// http://dream.cs.bath.ac.uk/researchdev/wave-ex/bformat.html
-
 const BASIC_PCM: u16        = 0x0001;
 const BASIC_FLOAT: u16      = 0x0003;
 const BASIC_MPEG: u16       = 0x0050;
@@ -45,7 +38,7 @@ fn uuid_from_basic_tag(tag: u16) -> Uuid {

 /// Sample format of the Wave file.
 /// 
-///
+/// 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum CommonFormat {
    /// Integer linear PCM
@@ -71,6 +64,7 @@ pub enum CommonFormat {
 }

 impl CommonFormat {
+    /// Resolve a tag and Uuid to a `CommonFormat`.
    pub fn make(basic: u16, uuid: Option<Uuid>) -> Self {
        match (basic, uuid) {
            (BASIC_PCM, _) => Self::IntegerPCM,
@@ -85,6 +79,10 @@ impl CommonFormat {
        }
    }

+    /// Get the appropriate tag and `Uuid` for the callee.
+    /// 
+    /// If there is no appropriate tag for the format of the callee, the 
+    /// returned tag will be 0xFFFE and the `Uuid` will describe the format.
    pub fn take(self) -> (u16, Uuid) {
        match self {
            Self::IntegerPCM => (BASIC_PCM, UUID_PCM),
--- a/src/cue.rs
+++ b/src/cue.rs
@@ -1,13 +1,14 @@
-use super::fourcc::{FourCC,ReadFourCC, LABL_SIG, NOTE_SIG, LTXT_SIG};
+use super::fourcc::{FourCC,ReadFourCC, WriteFourCC, LABL_SIG, NOTE_SIG, 
+    ADTL_SIG, LTXT_SIG, DATA_SIG};
 use super::list_form::collect_list_form;

-use byteorder::{ReadBytesExt, LittleEndian};
+use byteorder::{WriteBytesExt, ReadBytesExt, LittleEndian};

-use encoding::{DecoderTrap};
+use encoding::{DecoderTrap,EncoderTrap};
 use encoding::{Encoding};
 use encoding::all::ASCII;

-use std::io::{Cursor, Error, Read};
+use std::io::{Cursor, Error, Read, Write};

 #[derive(Copy,Clone, Debug)]
 struct RawCue {
@@ -20,6 +21,23 @@ struct RawCue {
 }

 impl RawCue {
+
+    fn write_to(cues : Vec<Self>) -> Vec<u8> {
+        let mut writer = Cursor::new(vec![0u8; 0]);
+        
+        writer.write_u32::<LittleEndian>(cues.len() as u32).unwrap();
+        for cue in cues.iter() {
+            writer.write_u32::<LittleEndian>(cue.cue_point_id).unwrap();
+            writer.write_u32::<LittleEndian>(cue.frame).unwrap();
+            writer.write_fourcc(cue.chunk_id).unwrap();
+            writer.write_u32::<LittleEndian>(cue.chunk_start).unwrap();
+            writer.write_u32::<LittleEndian>(cue.block_start).unwrap();
+            writer.write_u32::<LittleEndian>(cue.frame_offset).unwrap();
+        }
+
+        writer.into_inner()
+    }
+
    fn read_from(data : &[u8]) -> Result<Vec<Self>,Error> {
        let mut rdr = Cursor::new(data);
        let count = rdr.read_u32::<LittleEndian>()?;
@@ -47,6 +65,14 @@ struct RawLabel {
 }

 impl RawLabel {
+
+    fn write_to(&self) -> Vec<u8> {
+        let mut writer = Cursor::new(vec![0u8;0]);
+        writer.write_u32::<LittleEndian>(self.cue_point_id as u32).unwrap();
+        writer.write(&self.text).unwrap();
+        writer.into_inner()
+    }
+
    fn read_from(data : &[u8]) -> Result<Self, Error> {
        let mut rdr = Cursor::new(data);
        let length = data.len();
@@ -69,6 +95,14 @@ struct RawNote {
 }

 impl RawNote {
+
+    fn write_to(&self) -> Vec<u8> {
+        let mut writer = Cursor::new(vec![0u8; 0]);
+        writer.write_u32::<LittleEndian>(self.cue_point_id).unwrap();
+        writer.write(&self.text).unwrap();
+        writer.into_inner()
+    }
+
    fn read_from(data : &[u8]) -> Result<Self, Error> {
        let mut rdr = Cursor::new(data);
        let length = data.len();
@@ -97,6 +131,22 @@ struct RawLtxt {
 }

 impl RawLtxt {
+
+    fn write_to(&self) -> Vec<u8> {
+        let mut writer = Cursor::new(vec![0u8; 0]);
+        writer.write_u32::<LittleEndian>(self.cue_point_id).unwrap();
+        writer.write_u32::<LittleEndian>(self.frame_length).unwrap();
+        writer.write_fourcc(self.purpose).unwrap();
+        writer.write_u16::<LittleEndian>(self.country).unwrap();
+        writer.write_u16::<LittleEndian>(self.language).unwrap();
+        writer.write_u16::<LittleEndian>(self.dialect).unwrap();
+        writer.write_u16::<LittleEndian>(self.code_page).unwrap();
+        if let Some(ext_text) = &self.text {
+            writer.write(ext_text).unwrap();
+        }
+        writer.into_inner()
+    }
+
    fn read_from(data : &[u8]) -> Result<Self, Error> {
        let mut rdr = Cursor::new(data);
        let length = data.len();
@@ -131,6 +181,30 @@ enum RawAdtlMember {
 }

 impl RawAdtlMember {
+    fn compile_adtl(members : &[Self]) -> Vec<u8> {
+        let mut w = Cursor::new(vec![0u8; 0]);
+        // It seems like all this casing could be done with traits
+        for member in members.iter() {
+            let (fcc, buf) = match member {
+                RawAdtlMember::Label(l) => ( (LABL_SIG, l.write_to()) ),
+                RawAdtlMember::Note(n) => ( (NOTE_SIG, n.write_to()) ),
+                RawAdtlMember::LabeledText(t) => ( (LTXT_SIG, t.write_to()) ),
+                RawAdtlMember::Unrecognized(f) => (*f, vec![0u8;0] ) // <-- this is a dopey case but here for completeness
+            };
+            w.write_fourcc(fcc).unwrap();
+            w.write_u32::<LittleEndian>(buf.len() as u32).unwrap();
+            w.write(&buf).unwrap();
+            if buf.len() % 2 == 1 { w.write_u8(0).unwrap(); }
+        }
+
+        let chunk_content = w.into_inner();
+        let mut writer = Cursor::new(vec![0u8; 0]);
+        writer.write_fourcc(ADTL_SIG).unwrap();
+        writer.write_u32::<LittleEndian>(chunk_content.len() as u32).unwrap();
+        writer.write(&chunk_content).unwrap();
+        writer.into_inner()
+    }
+
    fn collect_from(chunk : &[u8]) -> Result<Vec<RawAdtlMember>,Error> {
        let chunks = collect_list_form(chunk)?;
        let mut retval : Vec<RawAdtlMember> = vec![];
@@ -190,12 +264,13 @@ impl AdtlMemberSearch for Vec<RawAdtlMember> {

 /// A cue point recorded in the `cue` and `adtl` metadata.
 /// 
+/// ## Resources
+/// - [Cue list, label and other metadata](https://sites.google.com/site/musicgapi/technical-documents/wav-file-format#smpl)
 /// 
+/// ### Not Implemented
+/// - [EBU 3285 Supplement 2](https://tech.ebu.ch/docs/tech/tech3285s2.pdf) (July 2001): Quality chunk and cuesheet
 pub struct Cue {

-    /// Unique numeric identifier for this cue
-    pub ident : u32,
-
    /// The time of this marker
    pub frame : u32,

@@ -206,7 +281,16 @@ pub struct Cue {
    pub label : Option<String>,

    /// The text "note"/comment of this marker if provided
-    pub note : Option<String>
+    pub note : Option<String>,
+    
+    /// The offser of this marker
+    /// 
+    /// **Note:** Applications use the `frame` and `offset` fields
+    /// in different ways. iZotope RX Audio Editor writes the
+    /// marker position to *both* fields, while a Sound Devices
+    /// recorder writes the marker position to *only* the `offset`
+    /// field.
+    pub offset : u32
 }


@@ -215,8 +299,64 @@ fn convert_to_cue_string(buffer : &[u8]) -> String {
    ASCII.decode(&trimmed, DecoderTrap::Ignore).expect("Error decoding text")
 }

+fn convert_from_cue_string(val : &str) -> Vec<u8> {
+    ASCII.encode(&val, EncoderTrap::Ignore).expect("Error encoding text")
+}
+
 impl Cue {

+    /// Take a list of `Cue`s and convert it into `RawCue` and `RawAdtlMember`s
+    fn compile_to(cues : &[Cue]) -> (Vec<RawCue>, Vec<RawAdtlMember>) {
+        cues.iter().enumerate()
+            .map(|(n, cue)| {
+                let raw_cue = RawCue {
+                    cue_point_id: n as u32,
+                    frame : cue.frame,
+                    chunk_id: DATA_SIG,
+                    chunk_start: 0,
+                    block_start: 0,
+                    frame_offset: cue.offset
+                };
+
+                let raw_label = cue.label.as_ref().map(|val| {
+                    RawLabel {
+                        cue_point_id : n as u32,
+                        text: convert_from_cue_string(&val)
+                    }
+                });
+
+                let raw_note = cue.note.as_ref().map(|val| {
+                    RawNote { 
+                        cue_point_id: n as u32,
+                        text : convert_from_cue_string(&val)
+                    }
+                });
+
+                let raw_ltxt = cue.length.map(|val| {
+                    RawLtxt {
+                        cue_point_id : n as u32,
+                        frame_length : val,
+                        purpose : FourCC::make(b"rgn "),
+                        country : 0,
+                        language : 0,
+                        dialect : 0,
+                        code_page : 0,
+                        text : None
+                    }
+                });
+
+                (raw_cue, raw_label, raw_note, raw_ltxt)
+            })
+            .fold((Vec::<RawCue>::new(), Vec::<RawAdtlMember>::new()),
+            |(mut cues, mut adtls) , (cue, label, note, ltxt)| {
+                cues.push(cue);
+                label.map(|l| adtls.push( RawAdtlMember::Label(l)));
+                note.map(|n| adtls.push(RawAdtlMember::Note(n)));
+                ltxt.map(|m| adtls.push(RawAdtlMember::LabeledText(m)));
+                (cues, adtls)
+            })
+    }
+
    pub fn collect_from(cue_chunk : &[u8], adtl_chunk : Option<&[u8]>) -> Result<Vec<Cue>, Error> {
        let raw_cues = RawCue::read_from(cue_chunk)?;
        let raw_adtl : Vec<RawAdtlMember>;
@@ -232,7 +372,7 @@ impl Cue {
            raw_cues.iter()
            .map(|i| {
                Cue {
-                    ident : i.cue_point_id,
+                    //ident : i.cue_point_id,
                    frame : i.frame,
                    length: {
                        raw_adtl.ltxt_for_cue_point(i.cue_point_id).first()
@@ -249,10 +389,11 @@ impl Cue {
                            //.filter_map(|x| str::from_utf8(&x.text).ok())
                            .map(|s| convert_to_cue_string(&s.text))
                            .next()
-                    }
+                    },
+                    offset: i.frame_offset
                }
            }).collect() 
        )
    }

-}
+}
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -1,4 +1,5 @@
-use std::io;
+use std::{fmt::{Debug,Display}, io};
+use std::error::Error as StdError;
 use super::fourcc::FourCC;

 use uuid;
@@ -43,6 +44,14 @@ pub enum Error {

 }

+impl StdError for Error {}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Debug::fmt(self, f)
+    }
+}
+

 impl From<io::Error> for Error {
    fn from(error: io::Error) -> Error {
--- a/src/fmt.rs
+++ b/src/fmt.rs
@@ -1,6 +1,11 @@
 use uuid::Uuid;
-use super::common_format::{CommonFormat, UUID_PCM};
+use super::common_format::{CommonFormat, UUID_PCM,UUID_BFORMAT_PCM};
+use std::io::Cursor;

+use byteorder::LittleEndian;
+use byteorder::{WriteBytesExt, ReadBytesExt};
+
+// Need more test cases for ADMAudioID
 #[allow(dead_code)]

 /// ADM Audio ID record.
@@ -13,6 +18,7 @@ use super::common_format::{CommonFormat, UUID_PCM};
 /// `AudioProgramme`.
 /// 
 /// See BS.2088-1 § 8, also BS.2094, also blahblahblah...
+#[derive(Debug)]
 pub struct ADMAudioID {
    pub track_uid: [char; 12],
    pub channel_format_ref: [char; 14],
@@ -20,6 +26,10 @@ pub struct ADMAudioID {
 }

 /// Describes a single channel in a WAV file.
+/// 
+/// This information is correlated from the Wave format ChannelMap field and
+/// the `chna` chunk, if present.
+#[derive(Debug)]
 pub struct ChannelDescriptor {
    /// Index, the offset of this channel's samples in one frame.
    pub index: u16,
@@ -124,14 +134,30 @@ pub struct WaveFmtExtended {
    pub type_guid : Uuid,
 }

-/**
- * WAV file data format record.
- * 
- * The `fmt` record contains essential information describing the binary
- * structure of the data segment of the WAVE file, such as sample 
- * rate, sample binary format, channel count, etc.
- *
- */
+///
+/// WAV file data format record.
+///
+/// The `fmt` record contains essential information describing the binary
+/// structure of the data segment of the WAVE file, such as sample 
+/// rate, sample binary format, channel count, etc.
+///
+/// 
+/// ## Resources 
+/// 
+/// ### Implementation of Wave format `fmt` chunk
+/// - [MSDN WAVEFORMATEX](https://docs.microsoft.com/en-us/windows/win32/api/mmeapi/ns-mmeapi-waveformatex)
+/// - [MSDN WAVEFORMATEXTENSIBLE](https://docs.microsoft.com/en-us/windows/win32/api/mmreg/ns-mmreg-waveformatextensible)
+///
+/// ### Other resources
+/// - [RFC 3261][rfc3261] (June 1998) "WAVE and AVI Codec Registries"
+/// - [Sampler Metadata](http://www.piclist.com/techref/io/serial/midi/wave.html)
+/// - [Peter Kabal, McGill University](http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html)
+/// - [Multimedia Programming Interface and Data Specifications 1.0](http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/riffmci.pdf) 
+///    (August 1991), IBM Corporation and Microsoft Corporation
+/// 
+/// [rfc3261]: https://tools.ietf.org/html/rfc2361 
+
+
 #[derive(Debug, Copy, Clone)]
 pub struct WaveFmt {

@@ -182,35 +208,79 @@ pub struct WaveFmt {

 impl WaveFmt {

-    /// Create a new integer PCM format `WaveFmt` 
-    pub fn new_pcm(sample_rate: u32, bits_per_sample: u16, channel_count: u16) -> Self {
+    pub fn valid_bits_per_sample(&self) -> u16 {
+        if let Some(ext) = self.extended_format {
+            ext.valid_bits_per_sample
+        } else {
+            self.bits_per_sample
+        }
+    }
+
+    /// Create a new integer PCM format for a monoaural audio stream.
+    pub fn new_pcm_mono(sample_rate: u32, bits_per_sample: u16) -> Self {
+        Self::new_pcm_multichannel(sample_rate, bits_per_sample, 0x4)
+    }
+
+    /// Create a new integer PCM format for a standard Left-Right stereo audio 
+    /// stream.
+    pub fn new_pcm_stereo(sample_rate: u32, bits_per_sample: u16) -> Self {
+        Self::new_pcm_multichannel(sample_rate, bits_per_sample, 0x3)
+    }
+
+    /// Create a new integer PCM format for ambisonic b-format.
+    pub fn new_pcm_ambisonic(sample_rate: u32, bits_per_sample: u16, channel_count: u16) -> Self {
        let container_bits_per_sample = bits_per_sample + (bits_per_sample % 8);
        let container_bytes_per_sample= container_bits_per_sample / 8;

-        let tag : u16 = match channel_count {
-            1..=2 => 0x01,
-            x if x > 2 => 0xFFFE,
-            x => panic!("Invalid channel count {}", x)
-        };
-
        WaveFmt {
-            tag, 
+            tag : 0xFFFE,
            channel_count,
            sample_rate,
            bytes_per_second: container_bytes_per_sample as u32 * sample_rate * channel_count as u32,
            block_alignment: container_bytes_per_sample * channel_count,
            bits_per_sample: container_bits_per_sample,
-            extended_format: {
-                if channel_count > 2 {
-                    Some( WaveFmtExtended {
-                        channel_mask : !(0xFFFF_FFFF << channel_count),
-                        type_guid: UUID_PCM,
-                        valid_bits_per_sample: bits_per_sample
-                    })
-                } else {
-                    None
-                }
-            }
+            extended_format: Some(WaveFmtExtended {
+                valid_bits_per_sample: bits_per_sample,
+                channel_mask: ChannelMask::DirectOut as u32,
+                type_guid: UUID_BFORMAT_PCM
+            })
+        }
+    }
+
+    /// Create a new integer PCM format `WaveFmt` with a custom channel bitmap.
+    /// 
+    /// The order of `channels` is not important. When reading or writing 
+    /// audio frames you must use the standard multichannel order for Wave 
+    /// files, the numerical order of the cases of `ChannelMask`.
+    pub fn new_pcm_multichannel(sample_rate: u32, bits_per_sample: u16, channel_bitmap: u32) -> Self {
+        let container_bits_per_sample = bits_per_sample + (bits_per_sample % 8);
+        let container_bytes_per_sample= container_bits_per_sample / 8;
+        
+        let channel_count: u16 = (0..=31).fold(0u16, |accum, n| accum + (0x1 & (channel_bitmap >> n) as u16) );
+
+        let result : (u16, Option<WaveFmtExtended>) = match channel_bitmap {
+            ch if bits_per_sample != container_bits_per_sample => (
+                (0xFFFE, Some(WaveFmtExtended { valid_bits_per_sample: bits_per_sample, channel_mask: ch, 
+                    type_guid: UUID_PCM }) )
+            ),
+            0b0100 => (0x0001, None),
+            0b0011 => (0x0001, None),
+            ch => (
+                (0xFFFE, Some( WaveFmtExtended { valid_bits_per_sample: bits_per_sample, channel_mask: ch, 
+                    type_guid: UUID_PCM}))
+            )
+        };
+
+        let (tag, extformat) = result;
+
+        WaveFmt {
+            tag,
+            channel_count,
+            sample_rate,
+            bytes_per_second: container_bytes_per_sample as u32 * sample_rate * channel_count as u32,
+            block_alignment: container_bytes_per_sample * channel_count,
+            bits_per_sample: container_bits_per_sample,
+            extended_format: extformat
        }
    }

@@ -222,12 +292,54 @@ impl WaveFmt {
        CommonFormat::make( self.tag, self.extended_format.map(|ext| ext.type_guid))
    }

-    /// Create a frame buffer sized to hold frames for a reader or writer
+    /// Create a frame buffer sized to hold `length` frames for a reader or 
+    /// writer
    /// 
    /// This is a conveneince method that creates a `Vec<i32>` with
    /// as many elements as there are channels in the underlying stream. 
-    pub fn create_frame_buffer(&self) -> Vec<i32> {
-        vec![0i32; self.channel_count as usize]
+    pub fn create_frame_buffer(&self, length : usize) -> Vec<i32> {
+        vec![0i32; self.channel_count as usize * length]
+    }
+
+    /// Create a raw byte buffer to hold `length` blocks from a reader or 
+    /// writer
+    pub fn create_raw_buffer(&self, length : usize) -> Vec<u8> {
+        vec![0u8; self.block_alignment as usize * length]
+    }
+
+    /// Write frames into a byte vector
+    pub fn pack_frames(&self, from_frames: &[i32], into_bytes: &mut [u8]) -> () {
+        let mut write_cursor = Cursor::new(into_bytes);
+
+        assert!(from_frames.len() % self.channel_count as usize == 0, 
+            "frames buffer does not contain a number of samples % channel_count == 0");
+
+            for n in 0..from_frames.len() {
+                match (self.valid_bits_per_sample(), self.bits_per_sample) {
+                    (0..=8,8) => write_cursor.write_u8((from_frames[n] + 0x80) as u8 ).unwrap(), // EBU 3285 §A2.2
+                    (9..=16,16) => write_cursor.write_i16::<LittleEndian>(from_frames[n] as i16).unwrap(),
+                    (10..=24,24) => write_cursor.write_i24::<LittleEndian>(from_frames[n]).unwrap(),
+                    (25..=32,32) => write_cursor.write_i32::<LittleEndian>(from_frames[n]).unwrap(),
+                    (b,_)=> panic!("Unrecognized integer format, bits per sample {}, channels {}, block_alignment {}", 
+                        b, self.channel_count, self.block_alignment)
+                }
+            }
+        ()
+    }
+
+    /// Read bytes into frames
+    pub fn unpack_frames(&self, from_bytes: &[u8], into_frames: &mut [i32]) -> () {
+        let mut rdr = Cursor::new(from_bytes);
+        for n in 0..(into_frames.len()) {
+            into_frames[n] = match (self.valid_bits_per_sample(), self.bits_per_sample) {
+                (0..=8,8) => rdr.read_u8().unwrap() as i32 - 0x80_i32, // EBU 3285 §A2.2
+                (9..=16,16) => rdr.read_i16::<LittleEndian>().unwrap() as i32,
+                (10..=24,24) => rdr.read_i24::<LittleEndian>().unwrap(),
+                (25..=32,32) => rdr.read_i32::<LittleEndian>().unwrap(),
+                (b,_)=> panic!("Unrecognized integer format, bits per sample {}, channels {}, block_alignment {}", 
+                    b, self.channel_count, self.block_alignment)
+            }
+        }
    }


@@ -271,3 +383,47 @@ impl WaveFmt {
    }
 }

+trait ReadWavAudioData {
+    fn read_i32_frames(&mut self, format: WaveFmt, into: &mut [i32]) -> Result<usize,std::io::Error>;
+    fn read_f32_frames(&mut self, format: WaveFmt, into: &mut [f32]) -> Result<usize,std::io::Error>;
+}
+
+impl<T> ReadWavAudioData for T where T: std::io::Read {
+
+    fn read_i32_frames(&mut self, format: WaveFmt, into: &mut [i32]) -> Result<usize, std::io::Error> { 
+        assert!(into.len() % format.channel_count as usize == 0);
+
+        for n in 0..(into.len()) {
+            into[n] = match (format.valid_bits_per_sample(), format.bits_per_sample) {
+                (0..=8,8) => self.read_u8().unwrap() as i32 - 0x80_i32, // EBU 3285 §A2.2
+                (9..=16,16) => self.read_i16::<LittleEndian>().unwrap() as i32,
+                (10..=24,24) => self.read_i24::<LittleEndian>().unwrap(),
+                (25..=32,32) => self.read_i32::<LittleEndian>().unwrap(),
+                (b,_)=> panic!("Unrecognized integer format, bits per sample {}, channels {}, block_alignment {}", 
+                    b, format.channel_count, format.block_alignment)
+            }
+        }
+
+        todo!()
+    }
+    fn read_f32_frames(&mut self, format: WaveFmt, into: &mut [f32]) -> Result<usize, std::io::Error> { 
+        assert!(into.len() % format.channel_count as usize == 0);
+        todo!()
+    }
+
+}
+
+trait WriteWavAudioData {
+    fn write_i32_frames(&mut self, format: WaveFmt, from: &[i32]) -> Result<usize, std::io::Error>;
+    fn write_f32_frames(&mut self, format: WaveFmt, from: &[f32]) -> Result<usize, std::io::Error>;
+}
+
+impl<T> WriteWavAudioData for T where T: std::io::Write {
+
+    fn write_i32_frames(&mut self, format: WaveFmt, _: &[i32]) -> Result<usize, std::io::Error> { 
+        todo!() 
+    }
+    fn write_f32_frames(&mut self, format: WaveFmt, _: &[f32]) -> Result<usize, std::io::Error> { 
+        todo!() 
+    }
+}
--- a/src/fourcc.rs
+++ b/src/fourcc.rs
@@ -103,6 +103,8 @@ pub const FMT__SIG: FourCC = FourCC::make(b"fmt ");

 pub const BEXT_SIG: FourCC = FourCC::make(b"bext");
 //pub const FACT_SIG: FourCC = FourCC::make(b"fact");
+pub const IXML_SIG: FourCC = FourCC::make(b"iXML");
+pub const AXML_SIG: FourCC = FourCC::make(b"axml");

 pub const JUNK_SIG: FourCC = FourCC::make(b"JUNK");
 pub const FLLR_SIG: FourCC = FourCC::make(b"FLLR");
--- a/src/levl.rs
+++ b/src/levl.rs
@@ -0,0 +1,3 @@
+/// Resources
+/// 
+/// [EBU 3285 Supplement 3](https://tech.ebu.ch/docs/tech/tech3285s3.pdf) (July 2001): Peak Metadata
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,10 +2,23 @@
 # bwavfile
 
 Rust Wave File Reader/Writer with Broadcast-WAV, MBWF and RF64 Support
- 
-__(Note: This crate is still in an alpha or pre-alpha stage of development. Reading of
-files works however the interfaces may change significantly. Stay up-to-date on the
-status of this project at [Github][github].)__
+
+## Interfaces
+
+### `WaveReader`
+
+`WaveReader` can open and parse a Wave, Broadcast-Wave, or RF64/BW64 64-bit 
+wave file. Metadata can be accessed and parsed in arbitrary order and audio
+samples can be accessed using the `AudioFrameReader` type, created by an 
+accessor method of `WaveReader`.
+
+### `WaveWriter`
+
+`WaveWriter` can create a new Wave, Broadcast-Wave, or RF64/BW64 64-bit wave 
+file. Metadata chunks and audio samples are added sequentially, write-only, to 
+a Wave file which is automatically promoted from standard Wave to RF64 wave 
+when the total WAVE form size exceeds 0xFFFFFFFF bytes.
+

 ## Objectives and Roadmap

@@ -18,89 +31,11 @@ Apps we test against:
 - iZotope RX Audio Editor
 - FFMpeg
 - Audacity
+- Sound Devices field recorders: 702T, MixPre-10 II

-Wave features we want to support with maximum reliability and ease of use:
-
- Large file size, RF64 support
- Multichannel audio formats 
- Embedded metadata
-
-In addition to reading the audio, we want to support all of the different 
-metadata planes you are liable to need to use.
-
- Broadcast-WAV metadata (including the SMPTE UMID and EBU v2 extensions)
- iXML Production recorder metadata
- ADM XML (with associated `chna` mappings)
- Dolby metadata block
-
-Things that are _not_ necessarily in the scope of this package:
-
- Broad codec support. There are a little more than one-hundred 
-  [registered wave codecs][rfc3261], but because this library is targeting
-  professional formats being created today, we only plan on supporting
-  two of them: tag 0x0001 (Integer Linear PCM) and tag 0x0003 (IEEE Float 
-  Linear PCM).
- Music library metadata. There are several packages that can read ID3
-  metadata and it's not particuarly common in wave files in any case. INFO
-  metadata is more common though in professional applications it tends not
-  to be used by many applications.
-
-
-## Resources
-
-### Implementation of Broadcast Wave Files
- [EBU Tech 3285][ebu3285] (May 2011), "Specification of the Broadcast Wave Format (BWF)"
-  - [Supplement 1](https://tech.ebu.ch/docs/tech/tech3285s1.pdf) (July 1997): MPEG Audio
- [EBU Rec 68](https://tech.ebu.ch/docs/r/r068.pdf): Signal modulation and format constraints
-
-
-### Implementation of 64-bit Wave Files
- [ITU-R 2088][itu2088] (October 2019), "Long-form file format for the international exchange of audio programme materials with metadata"
-  - Presently in force, adopted by the EBU in [EBU Tech 3306v2][ebu3306v2] (June 2018).
- [EBU Tech 3306v1][ebu3306v1] (July 2009), "MBWF / RF64: An extended File Format for Audio"
-  - No longer in force, however long-established. 
-
-
-### Implementation of Wave format `fmt` chunk
- [MSDN WAVEFORMATEX](https://docs.microsoft.com/en-us/windows/win32/api/mmeapi/ns-mmeapi-waveformatex)
- [MSDN WAVEFORMATEXTENSIBLE](https://docs.microsoft.com/en-us/windows/win32/api/mmreg/ns-mmreg-waveformatextensible)
-
-
-### Other resources
- [RFC 3261][rfc3261] (June 1998) "WAVE and AVI Codec Registries"
- [Sampler Metadata](http://www.piclist.com/techref/io/serial/midi/wave.html)
- [Cue list, label and other metadata](https://sites.google.com/site/musicgapi/technical-documents/wav-file-format#smpl)
- [Peter Kabal, McGill University](http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html)
- - [Multimedia Programming Interface and Data Specifications 1.0](http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/riffmci.pdf) 
-    (August 1991), IBM Corporation and Microsoft Corporation
-
-
-### Formatting of Specific Metadatums
- [iXML Metadata Specification](http://www.gallery.co.uk/ixml/) (April 2019) 
- EBU 3285 Supplements:
-  - [Supplement 2](https://tech.ebu.ch/docs/tech/tech3285s2.pdf) (July 2001): Quality chunk and cuesheet
-  - [Supplement 3](https://tech.ebu.ch/docs/tech/tech3285s3.pdf) (July 2001): Peak Metadata
-  - [Supplement 4](https://tech.ebu.ch/docs/tech/tech3285s4.pdf) (April 2003): Link Metadata
-  - [Supplement 5](https://tech.ebu.ch/docs/tech/tech3285s5.pdf) (May 2018): ADM Metadata
-  - [Supplement 6](https://tech.ebu.ch/docs/tech/tech3285s6.pdf) (October 2009): Dolby Metadata 
- [EBU Tech R099](https://tech.ebu.ch/docs/r/r099.pdf) (October 2011) "‘Unique’ Source Identifier (USID) for use in the 
-  <OriginatorReference> field of the Broadcast Wave Format"
- [EBU Tech R098](https://tech.ebu.ch/docs/r/r098.pdf) (1999) "Format for the &lt;CodingHistory&gt; field in Broadcast Wave Format files, BWF"
-
-[ebu3285]: https://tech.ebu.ch/docs/tech/tech3285.pdf
-[ebu3306v1]: https://tech.ebu.ch/docs/tech/tech3306v1_1.pdf
-[ebu3306v2]: https://tech.ebu.ch/docs/tech/tech3306.pdf
-[itu2088]: https://www.itu.int/dms_pubrec/itu-r/rec/bs/R-REC-BS.2088-1-201910-I!!PDF-E.pdf
-[rfc3261]: https://tools.ietf.org/html/rfc2361
 [github]: https://github.com/iluvcapra/bwavfile
 */

-// #![feature(external_doc)]
-
-// #[doc(include="../README.md")]
-// #[cfg(doctest)]
-// pub struct ReadmeDoctests;
-
 extern crate encoding;
 extern crate byteorder;
 extern crate uuid;
@@ -110,8 +45,6 @@ mod errors;
 mod common_format;

 mod parser;
-
-mod audio_frame_reader;
 mod list_form;

 mod chunks;
@@ -123,10 +56,9 @@ mod wavereader;
 mod wavewriter;

 pub use errors::Error;
-pub use wavereader::WaveReader;
-pub use wavewriter::WaveWriter;
+pub use wavereader::{WaveReader, AudioFrameReader};
+pub use wavewriter::{WaveWriter, AudioFrameWriter};
 pub use bext::Bext;
 pub use fmt::{WaveFmt, WaveFmtExtended, ChannelDescriptor, ChannelMask, ADMAudioID};
 pub use common_format::CommonFormat;
-pub use audio_frame_reader::AudioFrameReader;
 pub use cue::Cue;
--- a/src/sampler.rs
+++ b/src/sampler.rs
@@ -0,0 +1,2 @@
+/// ## Resources
+/// - [Sampler Metadata](http://www.piclist.com/techref/io/serial/midi/wave.html)
--- a/src/wavebuffer.rs
+++ b/src/wavebuffer.rs
@@ -0,0 +1,3 @@
+pub struct WaveBuffer {
+    pub format : WaveFmt
+}
--- a/src/wavereader.rs
+++ b/src/wavereader.rs
@@ -1,102 +1,262 @@

-use std::io::SeekFrom;
 use std::fs::File;

+use std::io::SeekFrom;
+use std::io::Cursor;
+use std::io::{Read, Seek, BufReader};
+use std::io::SeekFrom::{Start,Current,};
+
 use super::parser::Parser;
-use super::fourcc::{FourCC, ReadFourCC, FMT__SIG,DATA_SIG, BEXT_SIG, LIST_SIG, JUNK_SIG, FLLR_SIG, CUE__SIG, ADTL_SIG};
+use super::fourcc::{FourCC, ReadFourCC, FMT__SIG, DATA_SIG, BEXT_SIG, LIST_SIG,
+    JUNK_SIG, FLLR_SIG, CUE__SIG, ADTL_SIG, AXML_SIG, IXML_SIG};
 use super::errors::Error as ParserError;
 use super::fmt::{WaveFmt, ChannelDescriptor, ChannelMask};
 use super::bext::Bext;
-use super::audio_frame_reader::AudioFrameReader;
 use super::chunks::ReadBWaveChunks;
 use super::cue::Cue;
+use super::errors::Error;
+use super::CommonFormat;

-use std::io::Cursor;
-use std::io::{Read, Seek};
+use byteorder::LittleEndian;
+use byteorder::ReadBytesExt;
+
+
+
+/// Read audio frames
+/// 
+/// The inner reader is interpreted as a raw audio data
+/// bitstream having a format specified by `format`.
+/// 
+#[derive(Debug)]
+pub struct AudioFrameReader<R: Read + Seek> {
+    inner : R,
+    format: WaveFmt,
+    start: u64,
+    length: u64
+}
+
+impl<R: Read + Seek> AudioFrameReader<R> {
+
+    /// Create a new `AudioFrameReader`
+    /// 
+    /// ### Panics
+    /// 
+    /// This method does a few sanity checks on the provided format
+    /// 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(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.common_format() == CommonFormat::IntegerPCM || format.common_format() == CommonFormat::IeeeFloatPCM, 
+                "Unsupported format tag {:?}", format.tag);
+        
+        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(self.start + position))?;
+        Ok( (seek_result - self.start) / self.format.block_alignment as u64 )
+    }
+
+
+    /// Read a frame
+    /// 
+    /// 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 
+    /// channels and this method will panic if this is not the case.
+    pub fn read_integer_frame(&mut self, buffer:&mut [i32]) -> Result<u64,Error> {
+        assert!(buffer.len() as u16 == self.format.channel_count, 
+            "read_integer_frame was called with a mis-sized buffer, expected {}, was {}", 
+            self.format.channel_count, buffer.len());
+
+        let framed_bits_per_sample = self.format.block_alignment * 8 / self.format.channel_count;
+
+        let tell = self.inner.seek(Current(0))?;
+
+        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 )
+        }
+    }
+
+    pub fn read_float_frame(&mut self, buffer: &mut [f32]) -> Result<u64, Error> {
+        assert!(buffer.len() as u16 == self.format.channel_count,
+            "read_float_frame was called with a mis-sized buffer, expected {}, was {}",
+            self.format.channel_count, buffer.len());
+
+        let framed_bits_per_sample = self.format.block_alignment * 8 / self.format.channel_count;
+
+        let tell = self.inner.seek(Current(0))?;
+
+        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) {
+                    (25..=32,32) => self.inner.read_f32::<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 )
+        }
+    }
+}
+
+/// Wave, Broadcast-WAV and RF64/BW64 parser/reader.
+///
+/// ```
+/// use bwavfile::WaveReader; 
+/// let mut r = WaveReader::open("tests/media/ff_silence.wav").unwrap();
+///
+/// let format = r.format().unwrap();
+/// assert_eq!(format.sample_rate, 44100);
+/// assert_eq!(format.channel_count, 1);
+///
+/// let mut frame_reader = r.audio_frame_reader().unwrap();
+/// let mut buffer = format.create_frame_buffer(1);
+///
+/// let read = frame_reader.read_integer_frame(&mut buffer).unwrap();
+/// 
+/// assert_eq!(buffer, [0i32]);
+/// assert_eq!(read, 1);
+/// 
+/// ```
+/// 
+/// ## Resources
+/// 
+/// ### Implementation of Wave Files
+/// - [Peter Kabal, McGill University](http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html)
+/// - [Multimedia Programming Interface and Data Specifications 1.0](http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/riffmci.pdf) 
+///   (August 1991), IBM Corporation and Microsoft Corporation
+///  
+/// ### Implementation of Broadcast Wave Files
+/// - [EBU Tech 3285][ebu3285] (May 2011), "Specification of the Broadcast Wave Format (BWF)"
+///   - [Supplement 1](https://tech.ebu.ch/docs/tech/tech3285s1.pdf) (July 1997): MPEG Audio
+///   - [EBU Rec 68](https://tech.ebu.ch/docs/r/r068.pdf): Signal modulation and format constraints
+///
+/// ### Implementation of 64-bit Wave Files
+/// - [ITU-R 2088][itu2088] (October 2019), "Long-form file format for the international exchange of audio programme materials with metadata"
+///   - Presently in force, adopted by the EBU in [EBU Tech 3306v2][ebu3306v2] (June 2018).
+/// - [EBU Tech 3306v1][ebu3306v1] (July 2009), "MBWF / RF64: An extended File Format for Audio"
+///   - No longer in force, however long-established.
+/// 
+///
+/// [ebu3285]: https://tech.ebu.ch/docs/tech/tech3285.pdf
+/// [ebu3306v1]: https://tech.ebu.ch/docs/tech/tech3306v1_1.pdf
+/// [ebu3306v2]: https://tech.ebu.ch/docs/tech/tech3306.pdf
+/// [itu2088]: https://www.itu.int/dms_pubrec/itu-r/rec/bs/R-REC-BS.2088-1-201910-I!!PDF-E.pdf
+/// [rfc3261]: https://tools.ietf.org/html/rfc2361 


-/**
- * Wave, Broadcast-WAV and RF64/BW64 parser/reader.
- * 
- * ```
- * use bwavfile::WaveReader;
- * let mut r = WaveReader::open("tests/media/ff_silence.wav").unwrap();
- * 
- * let format = r.format().unwrap();
- * assert_eq!(format.sample_rate, 44100);
- * assert_eq!(format.channel_count, 1);
- * 
- * let mut frame_reader = r.audio_frame_reader().unwrap();
- * let mut buffer = format.create_frame_buffer();
- * 
- * let read = frame_reader.read_integer_frame(&mut buffer).unwrap();
- * 
- * assert_eq!(buffer, [0i32]);
- * assert_eq!(read, 1);
- * 
- * ```
-*/
 #[derive(Debug)]
 pub struct WaveReader<R: Read + Seek> {
    pub inner: R,
 }

-impl WaveReader<File> {
-    /**
-     * Open a file for reading.
-     * 
-     * A convenience that opens `path` and calls `Self::new()`
-     *   
-     */
+impl WaveReader<BufReader<File>> {
+
    pub fn open(path: &str) -> Result<Self, ParserError> {
+        let f = File::open(path)?;
+        let inner = BufReader::new(f);
+        Ok( Self::new(inner)? )
+    }
+}
+
+impl WaveReader<File> {
+    
+     /// Open a file for reading with unbuffered IO.
+     ///
+     /// A convenience that opens `path` and calls `Self::new()`
+     
+    pub fn open_unbuffered(path: &str) -> Result<Self, ParserError> {
        let inner = File::open(path)?;
        return Ok( Self::new(inner)? )
    }
 }

 impl<R: Read + Seek> WaveReader<R> {
-    /**
-     * Wrap a `Read` struct in a new `WaveReader`.
-     * 
-     * This is the primary entry point into the `WaveReader` interface. The
-     * stream passed as `inner` must be at the beginning of the header of the
-     * WAVE data. For a .wav file, this means it must be at the start of the 
-     * file.
-     * 
-     * 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 impossible.
-     * 
-     * ```rust
-     * use std::fs::File;
-     * use std::io::{Error,ErrorKind};
-     * use bwavfile::{WaveReader, Error as WavError};
-     * 
-     * let f = File::open("tests/media/error.wav").unwrap();
-     * 
-     * let reader = WaveReader::new(f);
-     * 
-     * match reader {
-     *      Ok(_) => panic!("error.wav should not be openable"),
-     *      Err( WavError::IOError( e ) ) => {
-     *          assert_eq!(e.kind(), ErrorKind::UnexpectedEof)
-     *      }
-     *      Err(e) => panic!("Unexpected error was returned {:?}", e)
-     * }
-     * 
-     * ```
-     * 
-    */
+    
+    /// Wrap a `Read` struct in a new `WaveReader`.
+    /// 
+    /// This is the primary entry point into the `WaveReader` interface. The
+    /// stream passed as `inner` must be at the beginning of the header of the
+    /// WAVE data. For a .wav file, this means it must be at the start of the 
+    /// file.
+    ///
+    /// 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 impossible.
+     
+    /// ```rust
+    /// use std::fs::File;
+    /// use std::io::{Error,ErrorKind};
+    /// use bwavfile::{WaveReader, Error as WavError};
+    ///
+    /// let f = File::open("tests/media/error.wav").unwrap();
+    ///
+    /// let reader = WaveReader::new(f);
+    ///
+    /// match reader {
+    ///      Ok(_) => panic!("error.wav should not be openable"),
+    ///      Err( WavError::IOError( e ) ) => {
+    ///          assert_eq!(e.kind(), ErrorKind::UnexpectedEof)
+    ///      }
+    ///      Err(e) => panic!("Unexpected error was returned {:?}", e)
+    /// }
+    /// 
+    /// ```
    pub fn new(inner: R) -> Result<Self,ParserError> {
        let mut retval = Self { inner };
        retval.validate_readable()?;
        Ok(retval)
    }

-    /**
-     * Unwrap the inner reader.
-     */
+    
+    /// Unwrap the inner reader.
    pub fn into_inner(self) -> R {
        return self.inner;
    }
@@ -110,9 +270,8 @@ impl<R: Read + Seek> WaveReader<R> {
        Ok(AudioFrameReader::new(self.inner, format, audio_chunk_reader.0, audio_chunk_reader.1)?)
    }

-    /**
-     * The count of audio frames in the file.
-     */
+    
+    /// The count of audio frames in the file.
    pub fn frame_length(&mut self) -> Result<u64, ParserError> {
        let (_, data_length ) = self.get_chunk_extent_at_index(DATA_SIG, 0)?;
        let format = self.format()?;
@@ -128,7 +287,6 @@ impl<R: Read + Seek> WaveReader<R> {
        self.inner.read_wave_fmt()
    }

-    ///
    /// The Broadcast-WAV metadata record for this file, if present.
    /// 
    pub fn broadcast_extension(&mut self) -> Result<Option<Bext>, ParserError> {
@@ -185,19 +343,16 @@ impl<R: Read + Seek> WaveReader<R> {
    /// let cue_points = f.cue_points().unwrap();
    /// 
    /// assert_eq!(cue_points.len(), 3);
-    /// assert_eq!(cue_points[0].ident, 1);
    /// assert_eq!(cue_points[0].frame, 12532);
    /// assert_eq!(cue_points[0].length, None);
    /// assert_eq!(cue_points[0].label, Some(String::from("Marker 1")));
    /// assert_eq!(cue_points[0].note, Some(String::from("Marker 1 Comment")));
    /// 
-    /// assert_eq!(cue_points[1].ident, 2);
    /// assert_eq!(cue_points[1].frame, 20997);
    /// assert_eq!(cue_points[1].length, None);
    /// assert_eq!(cue_points[1].label, Some(String::from("Marker 2")));
    /// assert_eq!(cue_points[1].note, Some(String::from("Marker 2 Comment"))); 
    /// 
-    /// assert_eq!(cue_points[2].ident, 3);
    /// assert_eq!(cue_points[2].frame, 26711);
    /// assert_eq!(cue_points[2].length, Some(6465));
    /// assert_eq!(cue_points[2].label, Some(String::from("Timed Region")));
@@ -224,8 +379,7 @@ impl<R: Read + Seek> WaveReader<R> {
    /// If there are no iXML metadata present in the file, 
    /// Ok(0) will be returned.
    pub fn read_ixml(&mut self, buffer: &mut Vec<u8>) -> Result<usize, ParserError> {
-        let ixml_fourcc = FourCC::make(b"iXML");
-        self.read_chunk(ixml_fourcc, 0, buffer) 
+        self.read_chunk(IXML_SIG, 0, buffer) 
    }

    /// Read AXML data.
@@ -236,8 +390,7 @@ impl<R: Read + Seek> WaveReader<R> {
    /// If there are no axml metadata present in the file, 
    /// Ok(0) will be returned
    pub fn read_axml(&mut self, buffer: &mut Vec<u8>) -> Result<usize, ParserError> {
-        let axml_fourcc = FourCC::make(b"axml");
-        self.read_chunk(axml_fourcc, 0, buffer)
+        self.read_chunk(AXML_SIG, 0, buffer)
    }


@@ -260,35 +413,33 @@ impl<R: Read + Seek> WaveReader<R> {
        }
    }

-    /** 
-     * Validate minimal WAVE file.
-     * 
-     * `Ok(())` if the source is `validate_readable()` AND
-     * 
-     *   - Contains _only_ a `fmt` chunk and `data` chunk, with no other chunks present
-     *   - `fmt` chunk is exactly 16 bytes long and begins _exactly_ at file offset 12
-     *   - `data` content begins _exactly_ at file offset 36
-     *   - is not an RF64/BW64
-     * 
-     * Some clients require a WAVE file to only contain format and data without any other
-     * metadata and this function is provided to validate this condition.
-     * 
-     * ### Examples
-     * 
-     * ```
-     * # use bwavfile::WaveReader;
-     * 
-     * let mut w = WaveReader::open("tests/media/ff_minimal.wav").unwrap();
-     * w.validate_minimal().expect("Minimal wav did not validate not minimal!");
-     * ```
-     * 
-     * ```
-     * # use bwavfile::WaveReader;
-     * 
-     * let mut x = WaveReader::open("tests/media/pt_24bit_51.wav").unwrap();
-     * x.validate_minimal().expect_err("Complex WAV validated minimal!");
-     * ```
-    */
+    /// Validate minimal WAVE file.
+    ///
+    /// `Ok(())` if the source is `validate_readable()` AND
+    ///
+    ///   - Contains _only_ a `fmt` chunk and `data` chunk, with no other chunks present
+    ///   - `fmt` chunk is exactly 16 bytes long and begins _exactly_ at file offset 12
+    ///   - `data` content begins _exactly_ at file offset 36
+    ///   - is not an RF64/BW64
+    ///
+    /// Some clients require a WAVE file to only contain format and data without any other
+    /// metadata and this function is provided to validate this condition.
+    ///
+    /// ### Examples
+    ///
+    /// ```
+    /// # use bwavfile::WaveReader;
+    ///
+    /// let mut w = WaveReader::open("tests/media/ff_minimal.wav").unwrap();
+    /// w.validate_minimal().expect("Minimal wav did not validate not minimal!");
+    /// ```
+    ///
+    /// ```
+    /// # use bwavfile::WaveReader;
+    ///
+    /// let mut x = WaveReader::open("tests/media/pt_24bit_51.wav").unwrap();
+    /// x.validate_minimal().expect_err("Complex WAV validated minimal!");
+    /// ```
    pub fn validate_minimal(&mut self) -> Result<(), ParserError>  {
        self.validate_readable()?;

@@ -302,39 +453,37 @@ impl<R: Read + Seek> WaveReader<R> {
        }
    }

-    /**
-     * Validate Broadcast-WAVE file format
-     * 
-     * Returns `Ok(())` if `validate_readable()` and file contains a 
-     * Broadcast-WAV metadata record (a `bext` chunk).
-     * 
-     * ### Examples
-     * 
-     * ```
-     * # use bwavfile::WaveReader;
-     * 
-     * let mut w = WaveReader::open("tests/media/ff_bwav_stereo.wav").unwrap();
-     * w.validate_broadcast_wave().expect("BWAVE file did not validate BWAVE");
-     * 
-     * let mut x = WaveReader::open("tests/media/pt_24bit.wav").unwrap();
-     * x.validate_broadcast_wave().expect("BWAVE file did not validate BWAVE");
-     * 
-     * let mut y = WaveReader::open("tests/media/audacity_16bit.wav").unwrap();
-     * y.validate_broadcast_wave().expect_err("Plain WAV file DID validate BWAVE");
-     * ```
-    */
+    /// Validate Broadcast-WAVE file format
+    /// 
+    /// Returns `Ok(())` if `validate_readable()` and file contains a 
+    /// Broadcast-WAV metadata record (a `bext` chunk).
+    /// 
+    /// ### Examples
+    /// 
+    /// ```
+    /// # use bwavfile::WaveReader;
+    /// 
+    /// let mut w = WaveReader::open("tests/media/ff_bwav_stereo.wav").unwrap();
+    /// w.validate_broadcast_wave().expect("BWAVE file did not validate BWAVE");
+    /// 
+    /// let mut x = WaveReader::open("tests/media/pt_24bit.wav").unwrap();
+    /// x.validate_broadcast_wave().expect("BWAVE file did not validate BWAVE");
+    /// 
+    /// let mut y = WaveReader::open("tests/media/audacity_16bit.wav").unwrap();
+    /// y.validate_broadcast_wave().expect_err("Plain WAV file DID validate BWAVE");
+    /// ```
+    ///
    pub fn validate_broadcast_wave(&mut self) -> Result<(), ParserError> {
        self.validate_readable()?;
        let (_, _) = self.get_chunk_extent_at_index(BEXT_SIG, 0)?;
        Ok(())
    } 

-    /**
-     * Verify data is aligned to a block boundary.
-     * 
-     * Returns `Ok(())` if `validate_readable()` and the start of the 
-     * `data` chunk's content begins at 0x4000.
-    */
+    ///
+    /// Verify data is aligned to a block boundary.
+    ///
+    /// Returns `Ok(())` if `validate_readable()` and the start of the 
+    /// `data` chunk's content begins at 0x4000.
    pub fn validate_data_chunk_alignment(&mut self) -> Result<() , ParserError> {
        self.validate_readable()?;
        let (start, _) = self.get_chunk_extent_at_index(DATA_SIG, 0)?;
@@ -345,15 +494,13 @@ impl<R: Read + Seek> WaveReader<R> {
        }
    }

-    /**
-     * Verify audio data can be appended immediately to this file.
-     * 
-     * Returns `Ok(())` if:
-     *  - `validate_readable()`
-     *  - there is a `JUNK` or `FLLR` immediately at the beginning of the chunk 
-     *    list adequately large enough to be overwritten by a `ds64` (92 bytes)
-     *  - `data` is the final chunk
-    */
+    /// Verify audio data can be appended immediately to this file.
+    /// 
+    /// Returns `Ok(())` if:
+    ///  - `validate_readable()`
+    ///  - there is a `JUNK` or `FLLR` immediately at the beginning of the chunk 
+    ///    list adequately large enough to be overwritten by a `ds64` (92 bytes)
+    ///  - `data` is the final chunk
    pub fn validate_prepared_for_append(&mut self) -> Result<(), ParserError> {
        self.validate_readable()?;

--- a/src/wavewriter.rs
+++ b/src/wavewriter.rs
@@ -1,50 +1,74 @@
 use std::fs::File;
-use std::io::{Write,Seek,SeekFrom};
+use std::io::{Write,Seek,SeekFrom,Cursor,BufWriter};

 use super::Error;
-use super::fourcc::{FourCC, WriteFourCC, RIFF_SIG, WAVE_SIG, FMT__SIG, DATA_SIG, ELM1_SIG};
+use super::fourcc::{FourCC, WriteFourCC, RIFF_SIG, RF64_SIG, DS64_SIG,
+    WAVE_SIG, FMT__SIG, DATA_SIG, ELM1_SIG, JUNK_SIG, BEXT_SIG,AXML_SIG, 
+    IXML_SIG};
 use super::fmt::WaveFmt;
 //use super::common_format::CommonFormat;
 use super::chunks::WriteBWaveChunks;
+use super::bext::Bext;

 use byteorder::LittleEndian;
 use byteorder::WriteBytesExt;

-
+/// Write audio frames to a `WaveWriter`.
+/// 
+/// 
 pub struct AudioFrameWriter<W> where W: Write + Seek {
    inner : WaveChunkWriter<W>
 }

 impl<W> AudioFrameWriter<W> where W: Write + Seek {
-    pub fn write_integer_frame(&mut self, buffer: &[i32]) -> Result<u64,Error> {
-        let format = self.inner.inner.format;
-        assert!(buffer.len() as u16 == format.channel_count, 
-            "read_integer_frame was called with a mis-sized buffer, expected {}, was {}", 
-            format.channel_count, buffer.len());

-        let framed_bits_per_sample = format.block_alignment * 8 / format.channel_count;
-
-        for n in 0..(format.channel_count as usize) {
-            match (format.bits_per_sample, framed_bits_per_sample) {
-                (0..=8,8) => self.inner.write_u8((buffer[n] + 0x80) as u8 )?, // EBU 3285 §A2.2
-                (9..=16,16) => self.inner.write_i16::<LittleEndian>(buffer[n] as i16)?,
-                (10..=24,24) => self.inner.write_i24::<LittleEndian>(buffer[n])?,
-                (25..=32,32) => self.inner.write_i32::<LittleEndian>(buffer[n])?,
-                (b,_)=> panic!("Unrecognized integer format, bits per sample {}, channels {}, block_alignment {}", 
-                    b, format.channel_count, format.block_alignment)
-            }
-        }
-
-        Ok(1)
+    fn new(inner: WaveChunkWriter<W>) -> Self {
+        AudioFrameWriter { inner }
    }

+    fn write_integer_frames_to_buffer(&self, from_frames :&[i32], to_buffer : &mut [u8]) -> () {
+        assert!(from_frames.len() % self.inner.inner.format.channel_count as usize == 0, 
+            "frames buffer does not contain a number of samples % channel_count == 0");
+        self.inner.inner.format.pack_frames(&from_frames, to_buffer);
+        ()
+    }
+
+    /// Write interleaved samples in `buffer`
+    /// 
+    /// # Panics
+    /// 
+    /// This function will panic if `buffer.len()` modulo the Wave file's channel count
+    /// is not zero.
+    pub fn write_integer_frames(&mut self, buffer: &[i32]) -> Result<u64,Error> {
+        let mut write_buffer = self.inner.inner.format
+            .create_raw_buffer(buffer.len() / self.inner.inner.format.channel_count as usize);
+
+        self.write_integer_frames_to_buffer(&buffer, &mut write_buffer);
+
+        self.inner.write(&write_buffer)?;
+        self.inner.flush()?;
+        Ok(write_buffer.len() as u64 / self.inner.inner.format.channel_count as u64)
+    }
+
+    /// Finish writing audio frames and unwrap the inner `WaveWriter`.
+    /// 
+    /// This method must be called when the client has finished writing audio
+    /// data. This will finalize the audio data chunk.
    pub fn end(self) -> Result<WaveWriter<W>, Error> {
        self.inner.end()
    }
 }

-
+/// Write a wave data chunk.
+/// 
+/// `WaveChunkWriter` implements `Write` and as bytes are written to it,
+/// 
+/// ### Important! 
+/// 
+/// When you are done writing to a chunk you must call `end()` in order to 
+/// finalize the chunk for storage.
 pub struct WaveChunkWriter<W> where W: Write + Seek {
+    ident : FourCC,
    inner : WaveWriter<W>,
    content_start_pos : u64,
    length : u64
@@ -58,7 +82,7 @@ impl<W> WaveChunkWriter<W> where W: Write + Seek {
        inner.inner.write_u32::<LittleEndian>(length as u32)?;
        inner.increment_form_length(8)?;
        let content_start_pos = inner.inner.seek(SeekFrom::End(0))?;
-        Ok( WaveChunkWriter { inner , content_start_pos, length } )
+        Ok( WaveChunkWriter { ident, inner , content_start_pos, length } )
    }

    fn end(mut self) -> Result<WaveWriter<W>, Error> {
@@ -72,11 +96,22 @@ impl<W> WaveChunkWriter<W> where W: Write + Seek {

    fn increment_chunk_length(&mut self, amount: u64) -> Result<(), std::io::Error> {
        self.length = self.length + amount;
-        if self.length < u32::MAX as u64 {
+        if !self.inner.is_rf64 {
            self.inner.inner.seek(SeekFrom::Start(self.content_start_pos - 4))?;
            self.inner.inner.write_u32::<LittleEndian>(self.length as u32)?;
        } else {
-            todo!()
+            if self.ident == DATA_SIG {
+                let data_chunk_64bit_field_offset = 8 + 4 + 8 + 8;
+                self.inner.inner.seek(SeekFrom::Start(self.content_start_pos - 4))?;
+                self.inner.inner.write_u32::<LittleEndian>(0xFFFF_FFFF)?; 
+                    // this only need to happen once, not every time we increment
+
+                self.inner.inner.seek(SeekFrom::Start(data_chunk_64bit_field_offset))?;
+                self.inner.inner.write_u64::<LittleEndian>(self.length)?;
+            } else {
+                todo!("FIXME RF64 wave writing is not yet supported for chunks other than `data`")
+            }
+            
        }

        Ok(())
@@ -88,8 +123,8 @@ impl<W> Write for WaveChunkWriter<W> where W: Write + Seek {
    fn write(&mut self, buffer: &[u8]) -> Result<usize, std::io::Error> { 
        self.inner.inner.seek(SeekFrom::End(0))?;
        let written = self.inner.inner.write(buffer)?;
-        self.increment_chunk_length(written as u64)?;
        self.inner.increment_form_length(written as u64)?;
+        self.increment_chunk_length(written as u64)?;

        Ok( written )
    }
@@ -101,34 +136,93 @@ impl<W> Write for WaveChunkWriter<W> where W: Write + Seek {

 /// Wave, Broadcast-WAV and RF64/BW64 writer.
 /// 
+/// A `WaveWriter` creates a new wave file at the given path (with `create()`)
+/// or into the given `Write`- and `Seek`-able inner writer.
+/// 
+/// Audio is added to the wave file by starting the audio data chunk with
+/// `WaveWriter::audio_frame_writer()`. All of the functions that add chunks
+/// move the WaveWriter and return it to the host when complete.
+/// 
+/// # Structure of New Wave Files
+/// 
+/// `WaveWriter` will create a Wave file with two chunks automatically: a 96
+/// byte `JUNK` chunk and a standard `fmt ` chunk, which has the extended 
+/// length if the format your provided requires it. The first `JUNK` chunk is 
+/// a reservation for a `ds64` record which will be written over it if
+/// the file needs to be upgraded to RF64 format.
+/// 
+/// Chunks are added to the file in the order the client adds them. 
+/// `audio_file_writer()` will add a `data` chunk for the audio data, and will
+/// also add an `elm1` filler chunk prior to the data chunk to ensure that the 
+/// first byte of the data chunk's content is aligned with 0x4000.
+/// 
 /// ```
 /// use bwavfile::{WaveWriter,WaveFmt};
 /// # use std::io::Cursor;
 /// 
 /// // Write a three-sample wave file to a cursor
 /// let mut cursor = Cursor::new(vec![0u8;0]);
-/// let format = WaveFmt::new_pcm(48000, 24, 1);
+/// let format = WaveFmt::new_pcm_mono(48000, 24);
 /// let w = WaveWriter::new(&mut cursor, format).unwrap();
 ///
 /// let mut frame_writer = w.audio_frame_writer().unwrap();
 ///
-/// frame_writer.write_integer_frame(&[0i32]).unwrap();
-/// frame_writer.write_integer_frame(&[0i32]).unwrap();
-/// frame_writer.write_integer_frame(&[0i32]).unwrap();
+/// frame_writer.write_integer_frames(&[0i32]).unwrap();
+/// frame_writer.write_integer_frames(&[0i32]).unwrap();
+/// frame_writer.write_integer_frames(&[0i32]).unwrap();
 /// frame_writer.end().unwrap();
-/// ``` 
+/// ```
+///
+/// ## Resources
+/// 
+/// ### Implementation of Wave Files
+/// - [Peter Kabal, McGill University](http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html)
+/// - [Multimedia Programming Interface and Data Specifications 1.0](http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/riffmci.pdf) 
+///   (August 1991), IBM Corporation and Microsoft Corporation
+///  
+/// ### Implementation of Broadcast Wave Files
+/// - [EBU Tech 3285][ebu3285] (May 2011), "Specification of the Broadcast Wave Format (BWF)"
+///   - [Supplement 1](https://tech.ebu.ch/docs/tech/tech3285s1.pdf) (July 1997): MPEG Audio
+///   - [EBU Rec 68](https://tech.ebu.ch/docs/r/r068.pdf): Signal modulation and format constraints
+///
+/// ### Implementation of 64-bit Wave Files
+/// - [ITU-R 2088][itu2088] (October 2019), "Long-form file format for the international exchange of audio programme materials with metadata"
+///   - Presently in force, adopted by the EBU in [EBU Tech 3306v2][ebu3306v2] (June 2018).
+/// - [EBU Tech 3306v1][ebu3306v1] (July 2009), "MBWF / RF64: An extended File Format for Audio"
+///   - No longer in force, however long-established.
+/// 
+///
+/// [ebu3285]: https://tech.ebu.ch/docs/tech/tech3285.pdf
+/// [ebu3306v1]: https://tech.ebu.ch/docs/tech/tech3306v1_1.pdf
+/// [ebu3306v2]: https://tech.ebu.ch/docs/tech/tech3306.pdf
+/// [itu2088]: https://www.itu.int/dms_pubrec/itu-r/rec/bs/R-REC-BS.2088-1-201910-I!!PDF-E.pdf
+/// [rfc3261]: https://tools.ietf.org/html/rfc2361 
 pub struct WaveWriter<W> where W: Write + Seek {
    inner : W,
    form_length: u64,

+    /// True if file is RF64
+    pub is_rf64: bool,
+
    /// Format of the wave file.
    pub format: WaveFmt
 }

-impl WaveWriter<File> {
+const DS64_RESERVATION_LENGTH : u32 = 96;
+
+impl WaveWriter<BufWriter<File>> {

    /// Create a new Wave file at `path`.
    pub fn create(path : &str, format : WaveFmt) -> Result<Self, Error> {
+        let f = File::create(path)?;
+        let b = BufWriter::new(f);
+        Ok( Self::new(b, format)? )
+    }
+}
+
+impl WaveWriter<File> {
+    /// Creare a new Wave file with unbuffered IO at `path`
+    pub fn create_unbuffered(path : &str, format : WaveFmt) -> Result<Self, Error> {
        let f = File::create(path)?;
        Ok( Self::new(f, format)? )
    }
@@ -146,25 +240,70 @@ impl<W> WaveWriter<W> where W: Write + Seek {
        inner.write_u32::<LittleEndian>(0)?;
        inner.write_fourcc(WAVE_SIG)?;

-        let mut retval = WaveWriter { inner, form_length: 0, format};
+        let mut retval = WaveWriter { inner, form_length: 0, is_rf64: false, format};
+
        retval.increment_form_length(4)?;

-        let mut chunk = retval.begin_chunk(FMT__SIG)?;
+        // write ds64_reservation
+        retval.write_junk(DS64_RESERVATION_LENGTH)?;
+
+        let mut chunk = retval.chunk(FMT__SIG)?;
        chunk.write_wave_fmt(&format)?;
        let retval = chunk.end()?;

        Ok( retval )
    }

-    /// Create a new chunk writer, which takes posession of the `WaveWriter`.
-    /// 
-    /// Begin writing a chunk segment. To close the chunk (and perhaps write 
-    /// another), call `end()` on the chunk writer.
-    pub fn begin_chunk(mut self, ident: FourCC) -> Result<WaveChunkWriter<W>,Error> {
+    fn write_chunk(&mut self, ident: FourCC, data : &[u8]) -> Result<(),Error> {
        self.inner.seek(SeekFrom::End(0))?;
-        WaveChunkWriter::begin(self, ident)
+        self.inner.write_fourcc(ident)?;
+        assert!(data.len() < u32::MAX as usize);
+        self.inner.write_u32::<LittleEndian>(data.len() as u32)?;
+        self.inner.write(data)?;
+        if data.len() % 2 == 0 {
+            self.increment_form_length(8 + data.len() as u64)?;
+        } else {
+            self.inner.write(&[0u8])?;
+            self.increment_form_length(8 + data.len() as u64 + 1)?;
+        }
+        Ok(())
    }

+    /// Write Broadcast-Wave metadata to the file.
+    /// 
+    /// This function will write the metadata chunk immediately to the end of 
+    /// the file; if you have already written and closed the audio data the 
+    /// bext chunk will be positioned after it.
+    pub fn write_broadcast_metadata(&mut self, bext: &Bext) -> Result<(),Error> {
+        //FIXME Implement re-writing
+        let mut c = Cursor::new(vec![0u8; 0]);
+        c.write_bext(&bext)?;
+        let buf = c.into_inner();
+        self.write_chunk(BEXT_SIG, &buf )?;
+        Ok(())
+    }
+
+    /// Write iXML metadata
+    pub fn write_ixml(&mut self, ixml: &[u8]) -> Result<(),Error> {
+        //FIXME Implement re-writing
+        self.write_chunk(IXML_SIG, &ixml)
+    }
+
+    /// Write axml/ADM metadata
+    pub fn write_axml(&mut self, axml: &[u8]) -> Result<(), Error> {
+        //FIXME Implement re-writing
+        self.write_chunk(AXML_SIG, &axml)
+    }
+
+    /// Write a `JUNK` filler chunk
+    pub fn write_junk(&mut self, length: u32) -> Result<(), Error> {
+        let filler = vec![0u8; length as usize];
+        self.write_chunk(JUNK_SIG, &filler)
+    }
+
+    /// Create an audio frame writer, which takes possession of the callee 
+    /// `WaveWriter`.
+    ///  
    pub fn audio_frame_writer(mut self) -> Result<AudioFrameWriter<W>, Error> {
        // append elm1 chunk

@@ -172,22 +311,51 @@ impl<W> WaveWriter<W> where W: Write + Seek {

        let lip = self.inner.seek(SeekFrom::End(0))?;
        let to_add = framing - (lip % framing) - 16;
-        let mut chunk = self.begin_chunk(ELM1_SIG)?;
+        let mut chunk = self.chunk(ELM1_SIG)?;
        let buf = vec![0u8; to_add as usize];
        chunk.write(&buf)?;
        let closed = chunk.end()?;
-
-        let inner = closed.begin_chunk(DATA_SIG)?;
-        Ok( AudioFrameWriter { inner } )
+        let inner = closed.chunk(DATA_SIG)?;
+        Ok( AudioFrameWriter::new(inner) )
    }

-    fn increment_form_length(&mut self, amount: u64) -> Result<(), std::io::Error> {
-        self.form_length = self.form_length + amount;
-        self.inner.seek(SeekFrom::Start(4))?;
-        self.inner.write_u32::<LittleEndian>(self.form_length as u32)?;
+    /// Open a wave chunk writer here
+    fn chunk(mut self, ident: FourCC) -> Result<WaveChunkWriter<W>,Error> {
+        self.inner.seek(SeekFrom::End(0))?;
+        WaveChunkWriter::begin(self, ident)
+    }
+
+    /// Upgrade this file to RF64
+    fn promote_to_rf64(&mut self) -> Result<(), std::io::Error> {
+        if !self.is_rf64 {
+            self.inner.seek(SeekFrom::Start(0))?;
+            self.inner.write_fourcc(RF64_SIG)?;
+            self.inner.write_u32::<LittleEndian>(0xFFFF_FFFF)?;
+            self.inner.seek(SeekFrom::Start(12))?;
+
+            self.inner.write_fourcc(DS64_SIG)?;
+            self.inner.seek(SeekFrom::Current(4))?;
+            self.inner.write_u64::<LittleEndian>(self.form_length)?;
+            self.is_rf64 = true;
+        }
        Ok(())
    }

+    /// Add `amount` to the RIFF/RF64 form length
+    fn increment_form_length(&mut self, amount: u64) -> Result<(), std::io::Error> {
+        self.form_length = self.form_length + amount;
+        if self.is_rf64 {
+            self.inner.seek(SeekFrom::Start(8 + 4 + 8))?;
+            self.inner.write_u64::<LittleEndian>(self.form_length)?;
+        } else if self.form_length < u32::MAX as u64 {
+            self.inner.seek(SeekFrom::Start(4))?;
+            self.inner.write_u32::<LittleEndian>(self.form_length as u32)?;
+        } else {
+            self.promote_to_rf64()?;
+            
+        }
+        Ok(())
+    }
 }

 #[test]
@@ -197,16 +365,23 @@ fn test_new() {
    use byteorder::ReadBytesExt;

    let mut cursor = Cursor::new(vec![0u8;0]);
-    let format = WaveFmt::new_pcm(4800, 24, 1);
+    let format = WaveFmt::new_pcm_mono(4800, 24);
    WaveWriter::new(&mut cursor, format).unwrap();

    cursor.seek(SeekFrom::Start(0)).unwrap();
+
    assert_eq!(cursor.read_fourcc().unwrap(), RIFF_SIG);
    let form_size = cursor.read_u32::<LittleEndian>().unwrap();
    assert_eq!(cursor.read_fourcc().unwrap(), WAVE_SIG);
+
+    assert_eq!(cursor.read_fourcc().unwrap(), JUNK_SIG);
+    let junk_size = cursor.read_u32::<LittleEndian>().unwrap();
+    assert_eq!(junk_size,96);
+    cursor.seek(SeekFrom::Current(junk_size as i64)).unwrap();
+
    assert_eq!(cursor.read_fourcc().unwrap(), FMT__SIG);
    let fmt_size = cursor.read_u32::<LittleEndian>().unwrap();
-    assert_eq!(form_size, fmt_size + 8 + 4);
+    assert_eq!(form_size, 4 + 8 + junk_size + 8 + fmt_size);
 }

 #[test]
@@ -216,14 +391,14 @@ fn test_write_audio() {
    use byteorder::ReadBytesExt;

    let mut cursor = Cursor::new(vec![0u8;0]);
-    let format = WaveFmt::new_pcm(48000, 24, 1);
+    let format = WaveFmt::new_pcm_mono(48000, 24);
    let w = WaveWriter::new(&mut cursor, format).unwrap();
    
    let mut frame_writer = w.audio_frame_writer().unwrap();

-    frame_writer.write_integer_frame(&[0i32]).unwrap();
-    frame_writer.write_integer_frame(&[0i32]).unwrap();
-    frame_writer.write_integer_frame(&[0i32]).unwrap();
+    frame_writer.write_integer_frames(&[0i32]).unwrap();
+    frame_writer.write_integer_frames(&[0i32]).unwrap();
+    frame_writer.write_integer_frames(&[0i32]).unwrap();

    frame_writer.end().unwrap();

@@ -231,22 +406,119 @@ fn test_write_audio() {

    cursor.seek(SeekFrom::Start(0)).unwrap();
    assert_eq!(cursor.read_fourcc().unwrap(), RIFF_SIG);
-    let _ = cursor.read_u32::<LittleEndian>().unwrap();
-    assert_eq!(cursor.read_fourcc().unwrap(), WAVE_SIG);
-    assert_eq!(cursor.read_fourcc().unwrap(), FMT__SIG);
-    let seek = cursor.read_u32::<LittleEndian>().unwrap();
-    cursor.seek(SeekFrom::Current(seek as i64)).unwrap();
+    let form_size = cursor.read_u32::<LittleEndian>().unwrap();

-    assert_eq!(cursor.read_fourcc().unwrap(), ELM1_SIG);
-    let seek = cursor.read_u32::<LittleEndian>().unwrap();
-    cursor.seek(SeekFrom::Current(seek as i64)).unwrap();
+    assert_eq!(cursor.read_fourcc().unwrap(), WAVE_SIG); //4

-    assert_eq!(cursor.read_fourcc().unwrap(), DATA_SIG);
-    let data_size = cursor.read_u32::<LittleEndian>().unwrap();
+    assert_eq!(cursor.read_fourcc().unwrap(), JUNK_SIG); //4
+    let junk_size = cursor.read_u32::<LittleEndian>().unwrap(); //4
+    cursor.seek(SeekFrom::Current(junk_size as i64)).unwrap();
+
+    assert_eq!(cursor.read_fourcc().unwrap(), FMT__SIG); //4
+    let fmt_size = cursor.read_u32::<LittleEndian>().unwrap(); //4
+    cursor.seek(SeekFrom::Current(fmt_size as i64)).unwrap();
+
+    assert_eq!(cursor.read_fourcc().unwrap(), ELM1_SIG); //4
+    let elm1_size = cursor.read_u32::<LittleEndian>().unwrap(); //4
+    cursor.seek(SeekFrom::Current(elm1_size as i64)).unwrap();
+
+    assert_eq!(cursor.read_fourcc().unwrap(), DATA_SIG); //4
+    let data_size = cursor.read_u32::<LittleEndian>().unwrap(); //4
    assert_eq!(data_size, 9);

    let tell = cursor.seek(SeekFrom::Current(0)).unwrap();
    assert!(tell % 0x4000 == 0);
-    

+    assert_eq!(form_size, 4 + 8 + junk_size + 8 + fmt_size + 8 + elm1_size + 8 + data_size + data_size % 2)
+}
+
+#[test]
+fn test_write_bext() {
+    use std::io::Cursor;
+
+    let mut cursor = Cursor::new(vec![0u8;0]);
+    let format = WaveFmt::new_pcm_mono(48000, 24);
+    let mut w = WaveWriter::new(&mut cursor, format).unwrap();
+
+    let bext = Bext {
+        description: String::from("Test description"),
+        originator: String::from(""),
+        originator_reference: String::from(""),
+        origination_date: String::from("2020-01-01"),
+        origination_time: String::from("12:34:56"),
+        time_reference: 0,
+        version: 0,
+        umid: None,
+        loudness_value: None,
+        loudness_range: None,
+        max_true_peak_level: None,
+        max_momentary_loudness: None,
+        max_short_term_loudness: None,
+        coding_history: String::from(""),
+    };
+
+    w.write_broadcast_metadata(&bext).unwrap();
+
+    let mut frame_writer = w.audio_frame_writer().unwrap();
+
+    frame_writer.write_integer_frames(&[0i32]).unwrap();
+    frame_writer.write_integer_frames(&[0i32]).unwrap();
+    frame_writer.write_integer_frames(&[0i32]).unwrap();
+
+    frame_writer.end().unwrap();
+}
+
+
+// NOTE! This test of RF64 writing takes several minutes to complete.
+#[test]
+fn test_create_rf64() {
+    use super::fourcc::ReadFourCC;
+    use byteorder::ReadBytesExt;
+
+    let mut cursor = Cursor::new(vec![0u8;0]);
+    let format = WaveFmt::new_pcm_stereo(48000, 24);
+    let w = WaveWriter::new(&mut cursor, format).unwrap();
+
+    let buflen = 16000 as u64;
+
+    let buf = vec![0i32; buflen as usize];
+
+    let four_and_a_half_hours_of_frames = 48000 * 16_200;
+
+    let mut af = w.audio_frame_writer().unwrap();
+
+    for _ in 0..(four_and_a_half_hours_of_frames * format.channel_count as u64 / buflen) {
+        af.write_integer_frames(&buf).unwrap();
+    }
+    af.end().unwrap();
+
+    assert!(cursor.seek(SeekFrom::End(0)).unwrap() > 0xFFFF_FFFFu64, "internal test error, Created file is not long enough to be RF64" );
+    let expected_data_length = four_and_a_half_hours_of_frames * format.block_alignment as u64;
+
+    cursor.seek(SeekFrom::Start(0)).unwrap();
+    assert_eq!(cursor.read_fourcc().unwrap(), RF64_SIG);
+    assert_eq!(cursor.read_u32::<LittleEndian>().unwrap(), 0xFFFF_FFFF);
+    assert_eq!(cursor.read_fourcc().unwrap(), WAVE_SIG);
+
+    assert_eq!(cursor.read_fourcc().unwrap(), DS64_SIG);
+    let ds64_size = cursor.read_u32::<LittleEndian>().unwrap();
+    let form_size = cursor.read_u64::<LittleEndian>().unwrap();
+    let data_size = cursor.read_u64::<LittleEndian>().unwrap();
+    assert_eq!(data_size, expected_data_length);
+    cursor.seek(SeekFrom::Current(ds64_size as i64 - 16)).unwrap();
+
+    assert_eq!(cursor.read_fourcc().unwrap(), FMT__SIG);
+    let fmt_size = cursor.read_u32::<LittleEndian>().unwrap();
+    cursor.seek(SeekFrom::Current((fmt_size + fmt_size % 2) as i64)).unwrap();
+    
+    assert_eq!(cursor.read_fourcc().unwrap(), ELM1_SIG);
+    let elm1_size = cursor.read_u32::<LittleEndian>().unwrap();
+    let data_start = cursor.seek(SeekFrom::Current((elm1_size + elm1_size % 2) as i64)).unwrap();
+    
+    assert!((data_start + 8) % 0x4000 == 0, "data content start is not aligned, starts at {}", data_start + 8);
+    assert_eq!(cursor.read_fourcc().unwrap(), DATA_SIG);
+    assert_eq!(cursor.read_u32::<LittleEndian>().unwrap(), 0xFFFF_FFFF);
+    cursor.seek(SeekFrom::Current(data_size as i64)).unwrap();
+
+    assert_eq!(4 + 8 + ds64_size as u64 + 8 + data_size + 8 + fmt_size as u64 + 8 + elm1_size as u64, form_size)
 }
--- a/tests/Untitled.txt
+++ b/tests/Untitled.txt
@@ -1,5 +0,0 @@
-Marker file version: 1
-Time format: Time
-Marker 1	00:00:00.28417234		Marker 1 Comment
-Marker 2	00:00:00.47612245		Marker 2 Comment
-Timed Region	00:00:00.60569161	00:00:00.75226757	Region Comment
--- a/tests/ffprobe_media_tests.rs
+++ b/tests/ffprobe_media_tests.rs
@@ -30,7 +30,7 @@ fn assert_match_stream<T>(stream_key: &str,
            .for_each(|value| {
                let filen : &str = value["format"]["filename"].as_str().unwrap();
                let json_value : &Value = &value["streams"][0][stream_key];
-                let mut wavfile = WaveReader::open(filen).unwrap();
+                let mut wavfile = WaveReader::open_unbuffered(filen).unwrap();
                let wavfile_value: T = other(&mut wavfile);
                println!("asserting {} for {}",stream_key, filen);
                assert_eq!(Into::<Value>::into(wavfile_value), *json_value);
--- a/tests/integration_test.rs
+++ b/tests/integration_test.rs
@@ -82,7 +82,7 @@ fn test_read() {
    let path = "tests/media/audacity_16bit.wav";

    let mut w = WaveReader::open(path).expect("Failure opening test file");
-    let mut buffer = w.format().unwrap().create_frame_buffer();
+    let mut buffer = w.format().unwrap().create_frame_buffer(1);

    let mut reader = w.audio_frame_reader().unwrap();

@@ -101,7 +101,7 @@ fn test_locate_multichannel_read() {
    let path = "tests/media/ff_pink.wav";

    let mut w = WaveReader::open(path).expect("Failure opening test file");
-    let mut buffer = w.format().unwrap().create_frame_buffer();
+    let mut buffer = w.format().unwrap().create_frame_buffer(1);

    let mut reader = w.audio_frame_reader().unwrap();

@@ -158,14 +158,13 @@ fn test_channels_stereo_no_fmt_extended() {
    assert_eq!(channels[1].speaker,ChannelMask::FrontRight);
 }

-//See issue 6 and 7
+///See issue 6 and 7
 #[test]
 fn test_frame_reader_consumes_reader() {
    // Issue #6
-    use bwavfile::WaveFmt;
-    use bwavfile::AudioFrameReader;
+    use bwavfile::{WaveFmt, AudioFrameReader};
    use std::fs::File;
-    fn from_wav_filename(wav_filename: &str) -> Result<(WaveFmt, AudioFrameReader<File>), ()> {
+    fn from_wav_filename(wav_filename: &str) -> Result<(WaveFmt, AudioFrameReader<std::io::BufReader<File>>), ()> {
        if let Ok(mut r) = WaveReader::open(&wav_filename) {
            let format = r.format().unwrap();
            let frame_reader = r.audio_frame_reader().unwrap();
@@ -176,4 +175,48 @@ fn test_frame_reader_consumes_reader() {
    }

    let _result = from_wav_filename("tests/media/pt_24bit_stereo.wav").unwrap();
+}
+
+///See to PR#10
+#[test]
+fn test_cue_read_sounddevices() {
+    let mut f = WaveReader::open("tests/media/sounddevices_6_cue_points.wav").unwrap();
+    let cue_points = f.cue_points().unwrap();
+    assert_eq!(cue_points.len(), 6);
+
+    assert_eq!(cue_points[0].frame, 0);
+    assert_eq!(cue_points[0].length, None);
+    assert_eq!(cue_points[0].label, None);
+    assert_eq!(cue_points[0].note, None);
+    assert_eq!(cue_points[0].offset, 90112);
+    
+    assert_eq!(cue_points[1].frame, 0);
+    assert_eq!(cue_points[1].length, None);
+    assert_eq!(cue_points[1].label, None);
+    assert_eq!(cue_points[1].note, None); 
+    assert_eq!(cue_points[1].offset, 176128);
+     
+    assert_eq!(cue_points[2].frame, 0);
+    assert_eq!(cue_points[2].length, None);
+    assert_eq!(cue_points[2].label, None);
+    assert_eq!(cue_points[2].note, None); 
+    assert_eq!(cue_points[2].offset, 237568);
+
+    assert_eq!(cue_points[3].frame, 0);
+    assert_eq!(cue_points[3].length, None);
+    assert_eq!(cue_points[3].label, None);
+    assert_eq!(cue_points[3].note, None); 
+    assert_eq!(cue_points[3].offset, 294912);
+
+    assert_eq!(cue_points[4].frame, 0);
+    assert_eq!(cue_points[4].length, None);
+    assert_eq!(cue_points[4].label, None);
+    assert_eq!(cue_points[4].note, None); 
+    assert_eq!(cue_points[4].offset, 380928);
+
+    assert_eq!(cue_points[5].frame, 0);
+    assert_eq!(cue_points[5].length, None);
+    assert_eq!(cue_points[5].label, None);
+    assert_eq!(cue_points[5].note, None); 
+    assert_eq!(cue_points[5].offset, 385024);
 }
--- a/tests/test_media.tgz
+++ b/tests/test_media.tgz
Author	SHA1	Message	Date
Jamie Hardt	69fd5f310c	Fixed some typos in this	2021-09-28 13:49:04 -07:00
Jamie Hardt	a8bb5e8c8e	Update to version 1.1	2021-09-28 13:46:34 -07:00
Jamie Hardt	468ed12304	Merge pull request #10 from atoav/cuepoints Surface cue frame_offset field in UI and test for sounddevices files.	2021-09-28 13:39:09 -07:00
Jamie Hardt	a015d7cf8a	Added sounddevices test WAV And unit tests for cue metadata.	2021-09-28 13:18:07 -07:00
Jamie Hardt	e89e87045c	Merge pull request #11 from EaterLabs/misc-fixes implement basic f32le support and some other misc fixes	2021-09-28 12:30:45 -07:00
Jamie Hardt	ecc1db703d	Update Cargo.lock	2021-09-28 12:27:53 -07:00
Jamie Hardt	4cd28c9efe	Create wavebuffer.rs	2021-09-28 11:59:56 -07:00
eater	663b9fad43	derive Debug for ADMAudioID and ChannelDescriptor and implement f32 reading	2021-08-22 23:40:07 +02:00
eater	9fe741d913	implement std::error::Error for Error	2021-08-22 23:35:47 +02:00
David Huss	2ecae51e8d	Adding sounddevices testfile for cue points As described in issue #9 the function cue_points() didn't display the expected frame values for cue points created on a Sound Devices MixPre-Series recorder. The file added by this commit (sounddevices_6_cue_points.wav) is short and mono channel, but has 6 cue points in it. The expected frames for the cue points are: 0: 90112 1: 176128 2: 237568 3: 294912 4: 380928 5: 385024	2021-08-17 09:08:07 +02:00
David Huss	56dc4d1048	Try fix for cuepoints	2021-08-16 17:03:57 +02:00
Jamie Hardt	1af4c675c7	Merge commit 'a625b485d993d912556cdf72605bf7b2c48c18c2'	2021-06-23 10:21:41 -07:00
Jamie Hardt	a625b485d9	Merge branch 'candidate-v1' into HEAD	2021-06-23 10:19:48 -07:00
Jamie Hardt	d17c6badfa	Removed unused import	2021-06-23 10:18:44 -07:00
Jamie Hardt	bc6be79715	Merge commit '53fcecfc451f9d38e2b541a728ea444162d04125' into candidate-v1	2021-06-23 10:13:05 -07:00
Jamie Hardt	763e9a10a3	Merge commit 'eee3c3f62592f024dd1308edeedc1b98565bbcd3' into candidate-v1	2021-06-23 10:08:48 -07:00
Jamie Hardt	319845ae49	In progress format plumbing	2021-01-05 00:32:09 -08:00
Jamie Hardt	53fcecfc45	Nudge version	2021-01-04 19:13:47 -08:00
Jamie Hardt	6776820e16	Working, but very slow	2021-01-04 19:12:03 -08:00
Jamie Hardt	eee3c3f625	exmaple impo	2021-01-03 23:43:32 -08:00
Jamie Hardt	6375567af1	Update README.md	2021-01-03 18:41:37 -08:00
Jamie Hardt	1a169da48f	removed inapplicable code	2021-01-03 13:27:35 -08:00
Jamie Hardt	50b7b7b640	Merge commit '72d6be406e75ca0c40c134311f558cbec9c9f356' into candidate-v1	2021-01-03 13:26:50 -08:00
Jamie Hardt	72d6be406e	Twiddles	2021-01-03 13:20:04 -08:00
Jamie Hardt	814b54a6e8	Cue writing impl Needs tests	2021-01-03 13:16:47 -08:00
Jamie Hardt	e826628096	FIXME comments	2021-01-03 13:16:36 -08:00
Jamie Hardt	0a307fbf05	Removed Cue.ident field from interface	2021-01-03 11:27:49 -08:00
Jamie Hardt	e941358c8d	reorganized use	2021-01-03 11:05:02 -08:00
Jamie Hardt	c2cff2a893	Consolidated AudioFrameWriter	2021-01-03 10:49:05 -08:00
Jamie Hardt	94eb36bbb5	Merge branch 'master' into candidate-v1	2021-01-02 18:14:14 -08:00
Jamie Hardt	f2c53061dc	Made a TODO note	2021-01-02 18:13:34 -08:00
Jamie Hardt	190e8bc677	Fixed bug in decibels code, was too loud	2021-01-02 18:09:39 -08:00
Jamie Hardt	80be74c8fb	Features	2021-01-02 16:04:44 -08:00
Jamie Hardt	5057862258	Bump license year	2021-01-02 15:45:56 -08:00
Jamie Hardt	75fc40d638	Bump version and license year	2021-01-02 15:45:24 -08:00
Jamie Hardt	2780bfb31b	Structuring Readme	2021-01-02 15:44:05 -08:00
Jamie Hardt	b160284e21	Reorganized imports	2021-01-02 15:16:38 -08:00
Jamie Hardt	8d55b126ae	Examples interface Notes on Bext	2021-01-02 13:38:56 -08:00
Jamie Hardt	b1c806598e	Tweaked dependencies	2021-01-02 13:38:32 -08:00
Jamie Hardt	58e43902cd	Updated README	2021-01-02 12:30:48 -08:00
Jamie Hardt	48517c22bc	Merge branch 'master' of https://github.com/iluvcapra/bwavfile	2021-01-02 12:23:14 -08:00
Jamie Hardt	634c21dc9a	Added buffered IO And updated tests to reflect this	2021-01-02 12:23:08 -08:00
Jamie Hardt	b7f82a9d63	blits example impl is basically done	2021-01-02 12:00:47 -08:00
Jamie Hardt	3b88b95065	Update blits.rs	2021-01-02 09:25:17 -08:00
Jamie Hardt	a21e17ee78	Added todos	2021-01-01 23:20:39 -08:00
Jamie Hardt	e495ad704e	Added CLI options	2021-01-01 23:13:17 -08:00
Jamie Hardt	bbab81746f	Twiddle varname silence error	2021-01-01 22:37:01 -08:00
Jamie Hardt	ca1d5eb714	Goofing around with examples	2021-01-01 22:36:08 -08:00
Jamie Hardt	e652722250	Update dependencies Added docopt	2021-01-01 22:04:00 -08:00
Jamie Hardt	d0b4582dca	More docs, example ideas	2021-01-01 21:59:53 -08:00
Jamie Hardt	4a0a9b7ec1	Update blits.rs TODO note	2021-01-01 21:51:58 -08:00
Jamie Hardt	a851ed7a7f	Blits file generator implementation	2021-01-01 21:49:42 -08:00
Jamie Hardt	fc21173312	Renamed example	2021-01-01 21:32:01 -08:00
Jamie Hardt	350599411f	Fixed WaveFmt writing for extended	2021-01-01 21:31:44 -08:00
Jamie Hardt	ec462a0b96	Merge remote-tracking branch 'origin/release'	2021-01-01 12:42:51 -08:00
Jamie Hardt	f0b1c51bd8	Merge branch 'master' into release	2021-01-01 12:26:50 -08:00
Jamie Hardt	e14bcd8c76	Update version	2021-01-01 12:26:16 -08:00
Jamie Hardt	1cb7174861	Comment	2021-01-01 12:14:51 -08:00
Jamie Hardt	a855410d6f	Added rf64 test back in ...and will push to github see if the action completes	2021-01-01 12:14:06 -08:00
Jamie Hardt	28b9272456	Updated doucmentation to proper comment style	2021-01-01 12:09:26 -08:00
Jamie Hardt	62c9aa7262	Merge branch 'master' of https://github.com/iluvcapra/bwavfile	2021-01-01 11:59:33 -08:00
Jamie Hardt	1f56e0f380	Documentation	2021-01-01 11:59:28 -08:00
Jamie Hardt	ef8a3adf69	Removed example folders	2020-12-31 15:31:55 -08:00
Jamie Hardt	daeb69c08c	added main functions	2020-12-31 14:22:31 -08:00
Jamie Hardt	aca56558bc	Added examples	2020-12-31 14:19:57 -08:00
Jamie Hardt	b11e1d7354	Merge branch 'master' of https://github.com/iluvcapra/bwavfile	2020-12-31 14:17:32 -08:00
Jamie Hardt	dfaf55955d	Update README.md	2020-12-29 21:10:50 -08:00
Jamie Hardt	7ea7ac5ce7	DS64 constant	2020-12-29 14:42:11 -08:00
Jamie Hardt	41977adb83	Fixed a bug in write_chunk	2020-12-29 14:38:05 -08:00
Jamie Hardt	f63d6279c3	Update README.md iXML/AXML writing support noted	2020-12-29 14:27:13 -08:00
Jamie Hardt	84942a4186	Implented AXML/iXML writing functions	2020-12-29 14:26:34 -08:00
Jamie Hardt	78ad1ae114	More docs, improved bext writer interface	2020-12-29 13:03:20 -08:00
Jamie Hardt	5e4c2c7da9	Doc	2020-12-29 12:17:31 -08:00
Jamie Hardt	d43ddf6338	Reorganized documentation	2020-12-29 12:09:00 -08:00
Jamie Hardt	84366089ba	Implementation	2020-12-27 12:05:21 -08:00
Jamie Hardt	cbfcce235c	Frame writing methods to make go faster	2020-12-27 11:34:12 -08:00
Jamie Hardt	087d98b228	Reduced commenting of rf64 test case ...to just the line we want to comment-out	2020-12-26 22:22:59 -08:00
Jamie Hardt	f978eb95ed	Update README.md Twiddles, RF64 writing test case note.	2020-12-26 21:28:47 -08:00
Jamie Hardt	1f8542a7ef	Update README.md	2020-12-26 21:25:41 -08:00
Jamie Hardt	25589ea848	Version 0.9.1	2020-12-26 21:16:36 -08:00
Jamie Hardt	d242dff686	Added to README	2020-12-26 21:11:56 -08:00
Jamie Hardt	155a26ace0	RF64 implementation	2020-12-26 19:01:32 -08:00
Jamie Hardt	1d2edcb675	Documentation and RF64 impl	2020-12-26 18:50:16 -08:00
Jamie Hardt	213a856e41	Documentation	2020-12-26 18:29:59 -08:00
Jamie Hardt	70bf402776	Ambisonic format create/write	2020-12-26 13:52:52 -08:00
Jamie Hardt	3ab3a28d0e	Format implementation	2020-12-26 13:41:08 -08:00
Jamie Hardt	620ca8a968	Bext writing	2020-12-26 12:12:46 -08:00
Jamie Hardt	bb6390a95c	Write ds64 reservation	2020-12-26 11:29:09 -08:00
Jamie Hardt	15b4ccf851	Documentation	2020-12-26 00:24:56 -08:00
Jamie Hardt	ea9a0b6cbe	Twiddles	2020-12-25 23:57:09 -08:00
Jamie Hardt	95700b642d	Removed confusing emoji	2020-12-25 23:51:36 -08:00