Rustfmt

Update Cargo.toml
Nudge version
2025-12-31 17:00:44 +00:00 · 2024-12-10 17:41:50 -08:00 · 2023-06-02 21:04:12 -07:00 · 2023-06-02 20:37:44 -07:00 · 2023-06-02 11:06:53 -07:00 · 2023-06-02 09:53:23 -07:00
36 changed files with 3709 additions and 963 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,28 @@
 ---
 name: Bug report
 about: Create a report to help us improve
 title: "[Bug] __Enter a title here__"
 labels: bug
 assignees: iluvcapra
 ---
 **Describe the bug**
 A clear and concise description of what the bug is.
 **Expected behavior**
 A clear and concise description of what you expected to happen.
 **Example Code**:
 ```rust
 // Give an example of code that is failing here.
 ```
 **Platform**:
 - OS
 - `rustc` version: ____ (from `rustup -V`)
 - Host: ____ (from `rustup show` e.g. x86_64-apple-darwin)
 - Rust toolchain: ____ (e.g. stable-x86_64-apple-darwin)
 **Additional context**
 Add any other context about the problem here.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,25 @@
 ---
 name: Feature request
 about: Suggest an idea for this project
 title: "[Feature] __Name the Feature__"
 labels: enhancement
 assignees: iluvcapra
 ---
 **Is your feature request related to a problem? Please describe.**
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 **Describe the solution you'd like:**
 A clear and concise description of what you want to happen.
 **Code Example:**
 ```rust
 // Give an example of how you would like your feature to work.
 ```
 **Describe alternatives you've considered:**
 A clear and concise description of any alternative solutions or features you've considered.
 **Additional context:**
 Add any other context or screenshots about the feature request here.
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -11,13 +11,32 @@ env:
 jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
 #     - name: Install ffmpeg
 #       run: sudo apt-get install ffmpeg
    - name: clippy-check
      # You may pin to the exact commit or the version.
      # uses: LoliGothick/clippy-check@9cd01de4387f9c644b6489355bcff686da6a00f2
      uses: LoliGothick/clippy-check@v0.2.11
      with:
        # GitHub token
        token: ${{ secrets.GITHUB_TOKEN }}
        # Arguments for the `cargo clippy` command
        # options: # optional
        # Sequence of lint warnings (without `clippy::` prefix)
 #         warn: # optional
 #         # Sequence of lint allowed (without `clippy::` prefix)
 #         allow: # optional
 #         # Sequence of lint denied (without `clippy::` prefix)
 #         deny: # optional
 #         # Sequence of lint forbidden (without `clippy::` prefix)
 #         forbid: # optional
 #         # Display name of the created GitHub check. Must be unique across several LoliGothick/clippy-check invocations.
 #         name: # optional, default is clippy
 #         # working directory where to execute `cargo clippy`.
 #         working-directory: # optional, default is .
    - name: Create Test Media
      run: cd tests; sh create_test_media.sh
    - name: Build
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,19 +1,71 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
 version = 3
 [[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.1.2"
+version = "2.0.0"
 dependencies = [
 "byteorder",
 "clap",
 "dasp_sample",
 "encoding",
 "serde_json",
 "uuid",
 ]
 [[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 = "dasp_sample"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
 [[package]]
 name = "encoding"
@@ -80,10 +132,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a246d82be1c9d791c5dfde9a2bd045fc3cbba3fa2b11ad558f27d01712f00569"
 [[package]]
-name = "itoa"
+name = "hermit-abi"
-version = "0.4.6"
+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"
@@ -93,17 +160,72 @@ 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",
 "serde",
 ]
 [[package]]
 name = "strsim"
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 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,7 +1,7 @@
 [package]
 name = "bwavfile"
-version = "0.1.2"
+version = "2.0.1"
-authors = ["Jamie Hardt <jamiehardt@me.com>"]
+authors = ["Jamie Hardt <jamiehardt@me.com>", "Ian Hobson <ian.r.hobson@gmail.com>"]
 edition = "2018"
 license = "MIT"
 description = "Rust Wave File Reader/Writer with Broadcast-WAV, MBWF and RF64 Support"
@@ -15,5 +15,14 @@ keywords = ["audio", "broadcast", "multimedia","smpte"]
 [dependencies]
 byteorder = "1.3.4"
 dasp_sample = "0.11.0"
 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
@@ -1,34 +1,53 @@
 [![Crates.io](https://img.shields.io/crates/l/bwavfile)](LICENSE)
 [![Crates.io](https://img.shields.io/crates/v/bwavfile)](https://crates.io/crates/bwavfile/)
 ![GitHub last commit](https://img.shields.io/github/last-commit/iluvcapra/bwavfile)
-[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/iluvcapra/bwavfile/Rust)](https://github.com/iluvcapra/bwavfile/actions?query=workflow%3ARust)
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/iluvcapra/bwavfile/rust.yml?branch=master)](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, RF64 and production metadata support
 ## Features
 __bwavfile__ provides a reader `WaveReader` and writer type `WaveWriter` for 
 reading and creating new wave audio files.
 `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.
 The library has extensive metadata support, with emphasis on film and video 
 production metadata:
  * Broadcast-Wave metadata extension, including long description, originator, 
 		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.
  * Multichannel, surround, and ambisonic audio data description including 
    surround channel maps, ADM `AudioTrackFormat`, `AudioChannelFormatRef` and 
    `AudioPackRef` data structures.
 ## 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.
 This is currently a work-in-progress!
 ## Use Examples
-### Reading a File
+  * [blits](examples/blits.rs) shows how to use `WaveWriter` to create a new
-
+    file with BLITS alignment tones.
-```rust
+  * [wave-inter](examples/wave-inter.rs) uses `WaveReader` and `WaveWriter` to
-
+    interleave several input Wave files into a single polyphonic Wave file.
- use bwavfile::WaveReader;
+  * [wave-deinter](examples/wave-deinter.rs) uses `WaveReader` and `WaveWriter`
- let mut r = WaveReader::open("tests/media/ff_silence.wav").unwrap();
+    to de-interleave an input Wave file into several monoarual Wave files.
 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 = frame_reader.create_frame_buffer();
 let read = frame_reader.read_integer_frame(&mut buffer).unwrap();
 assert_eq!(buffer, [0i32]);
 assert_eq!(read, 1);
 ```
 ## Note on Testing
@@ -36,3 +55,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,263 @@
 //! 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::{Error, WaveFmt, WaveWriter};
 #[macro_use]
 extern crate clap;
 use clap::{App, Arg};
 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_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,201 @@
 //! wave-deinter.rs
 //! (c) 2021 Jamie Hardt. All rights reserved.
 //!
 //! This program demonstrates splitting a multichannel file into separate monophonic files for each
 //! individual channel.
 use std::io::{Read, Seek};
 use std::path::Path;
 extern crate bwavfile;
 use bwavfile::{
    ChannelDescriptor, ChannelMask, CommonFormat, Error, Sample, WaveFmt, WaveReader, WaveWriter,
    I24,
 };
 #[macro_use]
 extern crate clap;
 use clap::{App, Arg};
 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 deinterleave_file<S, R>(
    mut input_file: WaveReader<R>,
    input_format: WaveFmt,
    settings: Settings,
 ) -> Result<(), Error>
 where
    S: Sample,
    R: Read + Seek,
 {
    let frames_per_read = 4096;
    let channel_desc = input_file.channels()?;
    let channel_count = channel_desc.len();
    if channel_desc.len() == 1 {
        println!("Input file in monoaural, exiting.");
        return Ok(());
    }
    let infile_path = Path::new(&settings.input_path);
    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 output_block_alignment = input_format.bits_per_sample / 8;
    let output_format = WaveFmt {
        channel_count: 1,
        block_alignment: output_block_alignment,
        bytes_per_second: output_block_alignment as u32 * input_format.sample_rate,
        ..input_format
    };
    let mut reader = input_file.audio_frame_reader()?;
    let mut writers = channel_desc
        .iter()
        .enumerate()
        .map(|(n, channel)| {
            let suffix = name_suffix(
                settings.use_numeric_names,
                &settings.delimiter,
                n + 1,
                channel,
            );
            let outfile_name = output_dir
                .join(format!("{}{}.wav", basename, suffix))
                .into_os_string()
                .into_string()
                .unwrap();
            println!("Will create file {}", outfile_name);
            WaveWriter::create(&outfile_name, output_format)
                .expect("Failed to create new file")
                .audio_frame_writer()
        })
        .collect::<Result<Vec<_>, _>>()?;
    let mut input_buffer = vec![S::EQUILIBRIUM; frames_per_read * channel_count];
    let mut output_buffer = vec![S::EQUILIBRIUM; frames_per_read];
    loop {
        let frames_read = reader.read_frames(&mut input_buffer)? as usize;
        if frames_read == 0 {
            break;
        }
        output_buffer.resize(frames_read, S::EQUILIBRIUM);
        for (n, writer) in writers.iter_mut().enumerate() {
            for (output, input) in output_buffer
                .iter_mut()
                .zip(input_buffer.iter().skip(n).step_by(channel_count))
            {
                *output = *input;
            }
            writer.write_frames(&output_buffer)?;
        }
    }
    for writer in writers.drain(..) {
        writer.end()?;
    }
    Ok(())
 }
 fn process_file<R>(mut input: WaveReader<R>, settings: Settings) -> Result<(), Error>
 where
    R: Read + Seek,
 {
    let format = input.format()?;
    use CommonFormat::*;
    match (format.common_format(), format.bits_per_sample) {
        (IntegerPCM, 8) => deinterleave_file::<u8, R>(input, format, settings),
        (IntegerPCM, 16) => deinterleave_file::<i16, R>(input, format, settings),
        (IntegerPCM, 24) => deinterleave_file::<I24, R>(input, format, settings),
        (IntegerPCM, 32) => deinterleave_file::<i32, R>(input, format, settings),
        (IeeeFloatPCM, 32) => deinterleave_file::<f32, R>(input, format, settings),
        other => panic!("Unsupported format: {:?}", other),
    }
 }
 struct Settings {
    input_path: String,
    delimiter: String,
    use_numeric_names: bool,
 }
 fn main() -> Result<(), Box<dyn std::error::Error>> {
    let matches = App::new("wave-deinter")
        .version(crate_version!())
        .author(crate_authors!())
        .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 settings = Settings {
        input_path: matches.value_of("INPUT").unwrap().into(),
        delimiter: matches.value_of("channel_delimiter").unwrap().into(),
        use_numeric_names: matches.is_present("numeric_names"),
    };
    process_file(WaveReader::open(&settings.input_path)?, settings)?;
    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::{App, Arg};
 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,58 +0,0 @@
 use std::io::{Read, Seek};
 use std::io::SeekFrom::{Start,};
 use byteorder::LittleEndian;
 use byteorder::ReadBytesExt;
 use super::chunks::WaveFmt;
 use super::errors::Error;
 #[derive(Debug)]
 pub struct AudioFrameReader<R: Read + Seek> {
    inner : R,
    format: WaveFmt
 }
 impl<R: Read + Seek> AudioFrameReader<R> {
    /// Create a new AudioFrameReader, taking possession of a reader.
    pub fn new(inner: R, format: WaveFmt) -> Self {
        assert!(format.block_alignment * 8 == format.bits_per_sample * format.channel_count, 
            "Unable to read audio frames from packed formats: block alignment is {}, should be {}",
            format.block_alignment, (format.bits_per_sample / 8 ) * format.channel_count);
        assert!(format.tag == 1, "Unsupported format tag {}", format.tag);
        AudioFrameReader { inner , format }
    }
    pub fn locate(&mut self, to :u64) -> Result<u64,Error> {
        let position = to * self.format.block_alignment as u64;
        let seek_result = self.inner.seek(Start(position))?;
        Ok( seek_result / self.format.block_alignment as u64 )
    }
    pub fn create_frame_buffer(&self) -> Vec<i32> {
        vec![0i32; self.format.channel_count as usize]
    }
    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;
        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 )
    }
 }
--- a/src/bext.rs
+++ b/src/bext.rs
@@ -0,0 +1,81 @@
 pub type LU = f32;
 #[allow(clippy::upper_case_acronyms)]
 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.
 ///
 /// ## Resources
 /// - [EBU Tech 3285](https://tech.ebu.ch/docs/tech/tech3285.pdf) "Specification of the Broadcast Wave Format (BWF)"
 /// - [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"
 #[derive(Debug)]
 pub struct Bext {
    /// 0..256 ASCII character field with free text.
    pub description: String,
    /// 0..32 ASCII character Originating application.
    pub originator: String,
    /// 0..32 ASCII character application-specific UID or EBU R099-formatted UID.
    pub originator_reference: String,
    /// Creation date in format `YYYY-MM-DD`.
    pub origination_date: String,
    /// Creation time in format `HH:MM:SS`.
    pub origination_time: String,
    /// Start timestamp of this wave file, in number of samples
    /// since local midnight.
    pub time_reference: u64,
    /// Bext chunk version.
    ///
    /// Version 1 contains a UMID, version 2 contains a UMID and
    /// loudness metadata.
    pub version: u16,
    /// SMPTE 330M UMID
    ///
    /// This field is `None` if the version is less than 1.
    pub umid: Option<[u8; 64]>,
    /// Integrated loudness in LUFS.
    ///
    /// This field is `None` if the version is less than 2.
    pub loudness_value: Option<LUFS>,
    /// Loudness range in LU.
    ///
    /// This field is `None` if the version is less than 2.
    pub loudness_range: Option<LU>,
    /// Maximum True Peak Level in decibels True Peak.
    ///
    /// This field is `None` if the version is less than 2.
    pub max_true_peak_level: Option<Decibels>,
    /// Maximum momentary loudness in LUFS.
    ///
    /// This field is `None` if the version is less than 2.
    pub max_momentary_loudness: Option<LUFS>,
    /// Maximum short-term loudness in LUFS.
    ///
    /// This field is `None` if the version is less than 2.
    pub max_short_term_loudness: Option<LUFS>,
    // 180 bytes of nothing
    /// Coding History.
    pub coding_history: String,
 }
--- a/src/chunks.rs
+++ b/src/chunks.rs
@@ -1,219 +1,60 @@
 use std::io::{Read, Write};
 use super::errors::Error as ParserError;
 use encoding::{DecoderTrap, EncoderTrap};
 use encoding::{Encoding};
 use encoding::all::ASCII;
 use encoding::Encoding;
 use encoding::{DecoderTrap, EncoderTrap};
 use byteorder::LittleEndian;
 use byteorder::{ReadBytesExt, WriteBytesExt};
-/**
+use uuid::Uuid;
 * References:
 * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/multichaudP.pdf
 */
 #[derive(PartialEq)]
 enum FormatTags {
    Integer = 0x0001,
    Float = 0x0003,
    Extensible = 0xFFFE
 }
-const PCM_SUBTYPE_UUID: [u8; 16] = [0x00, 0x00, 0x00, 0x01,
+use super::bext::Bext;
-                                    0x00, 0x00, 0x00, 0x10,
+use super::errors::Error as ParserError;
-                                    0x80, 0x00, 0x00, 0xaa,
+use super::fmt::{WaveFmt, WaveFmtExtended};
                                    0x00, 0x38, 0x9b, 0x71];
 const FLOAT_SUBTYPE_UUID: [u8; 16] = [0x00, 0x00, 0x00, 0x03,
                                      0x00, 0x00, 0x00, 0x10,
                                      0x80, 0x00, 0x00, 0xaa,
                                      0x00, 0x38, 0x9b, 0x71];
 /*
 https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/subformat-guids-for-compressed-audio-formats
 http://dream.cs.bath.ac.uk/researchdev/wave-ex/bformat.html
 These are from http://dream.cs.bath.ac.uk/researchdev/wave-ex/mulchaud.rtf
 */
 #[derive(Debug)]
 pub enum WaveFmtExtendedChannelMask {
    FrontLeft        = 0x1,
    FrontRight       = 0x2,
    FrontCenter      = 0x4,
    LowFrequency     = 0x8,
    BackLeft         = 0x10,
    BackRight        = 0x20,
    FrontCenterLeft  = 0x40,
    FrontCenterRight = 0x80,
    BackCenter       = 0x100,
    SideLeft         = 0x200,
    SideRight        = 0x400,
    TopCenter        = 0x800,
    TopFrontLeft     = 0x1000,
    TopFrontCenter   = 0x2000,
    TopFrontRight    = 0x4000,
    TopBackLeft      = 0x8000,
    TopBackCenter    = 0x10000,
    TopBackRight     = 0x20000 
 }
 /**
 * Extended Wave Format
 * 
 * https://docs.microsoft.com/en-us/windows/win32/api/mmreg/ns-mmreg-waveformatextensible
 */
 #[derive(Debug)]
 pub struct WaveFmtExtended {
    /// Valid bits per sample
    pub valid_bits_per_sample : u16,
    /// Channel mask
    /// 
    /// Identifies the speaker assignment for each channel in the file
    pub channel_mask : WaveFmtExtendedChannelMask,
    /// Codec GUID
    /// 
    /// Identifies the codec of the audio stream
    pub type_guid : [u8; 16],
 }
 /**
 * 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.
 *
 */
 #[derive(Debug)]
 pub struct WaveFmt {
    /// A tag identifying the codec in use.
    /// 
    /// If this is 0xFFFE, the codec will be identified by a GUID
    /// in `extended_format`
    pub tag: u16,
    /// Count of audio channels in each frame
    pub channel_count: u16,
    /// Sample rate of the audio data
    pub sample_rate: u32,
    /// Count of bytes per second
    /// 
    /// By rule, this is `block_alignment * sample_rate`
    pub bytes_per_second: u32,
    /// Count of bytes per audio frame
    /// 
    /// By rule, this is `channel_count * bits_per_sample / 8`
    pub block_alignment: u16,
    /// Count of bits stored in the file per sample
    pub bits_per_sample: u16,
    /// Extended format description
    /// 
    /// Additional format metadata if `channel_count` is greater than 2,
    /// or if certain codecs are used.
    pub extended_format: Option<WaveFmtExtended>
 }
 impl WaveFmt {
    /// Create a new integer PCM format `WaveFmt` 
    pub fn new_pcm(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 {
            0 => panic!("Error"),
            1..=2 => FormatTags::Integer as u16,
            _ => FormatTags::Extensible as u16,
        };
        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: None
        }
    }
 }
 /**
 * 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).
 */
 #[derive(Debug)]
 pub struct Bext {
    pub description: String,
    pub originator: String,
    pub originator_reference: String,
    pub origination_date: String,
    pub origination_time: String,
    pub time_reference: u64,
    pub version: u16,
    pub umid: Option<[u8; 64]>,
    pub loudness_value: Option<f32>,
    pub loudness_range: Option<f32>,
    pub max_true_peak_level: Option<f32>,
    pub max_momentary_loudness: Option<f32>,
    pub max_short_term_loudness: Option<f32>,
    // 180 bytes of nothing
    pub coding_history: String
 }
 pub trait ReadBWaveChunks: Read {
    fn read_bext(&mut self) -> Result<Bext, ParserError>;
-    fn read_bext_string_field(&mut self, length: usize) -> Result<String,ParserError>;
+    fn read_bext_string_field(&mut self, length: usize) -> Result<String, ParserError>;
    fn read_wave_fmt(&mut self) -> Result<WaveFmt, ParserError>;
 }
 pub trait WriteBWaveChunks: Write {
-    fn write_wave_fmt(&mut self, format : &WaveFmt) -> Result<(), ParserError>;
+    fn write_wave_fmt(&mut self, format: &WaveFmt) -> Result<(), ParserError>;
-    fn write_bext_string_field(&mut self, string: &String, length: usize) -> Result<(),ParserError>;
+    fn write_bext_string_field(&mut self, string: &str, length: usize) -> Result<(), ParserError>;
-    fn write_bext(&mut self, bext: &Bext) -> Result<(),ParserError>;
+    fn write_bext(&mut self, bext: &Bext) -> Result<(), ParserError>;
 }
-impl<T> WriteBWaveChunks for T where T: Write {
+impl<T> WriteBWaveChunks for T
-    fn write_wave_fmt(&mut self, format : &WaveFmt) -> Result<(), ParserError> {
+where
    T: Write,
 {
    fn write_wave_fmt(&mut self, format: &WaveFmt) -> Result<(), ParserError> {
        self.write_u16::<LittleEndian>(format.tag)?;
        self.write_u16::<LittleEndian>(format.channel_count)?;
        self.write_u32::<LittleEndian>(format.sample_rate)?;
        self.write_u32::<LittleEndian>(format.bytes_per_second)?;
        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_all(uuid)?;
        }
        Ok(())
    }
-    fn write_bext_string_field(&mut self, string: &String, length: usize) -> Result<(),ParserError> {
+    fn write_bext_string_field(&mut self, string: &str, length: usize) -> Result<(), ParserError> {
-        let mut buf = ASCII.encode(&string, EncoderTrap::Ignore).expect("Error encoding text");
+        let mut buf = ASCII
            .encode(string, EncoderTrap::Ignore)
            .expect("Error encoding text");
        buf.truncate(length);
        let filler_length = length - buf.len();
-        if filler_length > 0{
+        if filler_length > 0 {
-            let mut filler = vec![0u8; filler_length ];
+            let mut filler = vec![0u8; filler_length];
            buf.append(&mut filler);
        }
@@ -221,7 +62,7 @@ impl<T> WriteBWaveChunks for T where T: Write {
        Ok(())
    }
-    fn write_bext(&mut self, bext: &Bext) -> Result<(),ParserError> {
+    fn write_bext(&mut self, bext: &Bext) -> Result<(), ParserError> {
        self.write_bext_string_field(&bext.description, 256)?;
        self.write_bext_string_field(&bext.originator, 32)?;
        self.write_bext_string_field(&bext.originator_reference, 32)?;
@@ -233,21 +74,21 @@ impl<T> WriteBWaveChunks for T where T: Write {
        let buf = bext.umid.unwrap_or([0u8; 64]);
        self.write_all(&buf)?;
        self.write_i16::<LittleEndian>((bext.loudness_value.unwrap_or(0.0) * 100.0) as i16)?;
        self.write_i16::<LittleEndian>((bext.loudness_range.unwrap_or(0.0) * 100.0) as i16)?;
        self.write_i16::<LittleEndian>((bext.max_true_peak_level.unwrap_or(0.0) * 100.0) as i16)?;
        self.write_i16::<LittleEndian>(
-            (bext.loudness_value.unwrap_or(0.0) * 100.0) as i16 )?;
+            (bext.max_momentary_loudness.unwrap_or(0.0) * 100.0) as i16,
        )?;
        self.write_i16::<LittleEndian>(
-            (bext.loudness_range.unwrap_or(0.0) * 100.0) as i16 )?;
+            (bext.max_short_term_loudness.unwrap_or(0.0) * 100.0) as i16,
-        self.write_i16::<LittleEndian>( 
+        )?;
            (bext.max_true_peak_level.unwrap_or(0.0) * 100.0) as i16 )?;
        self.write_i16::<LittleEndian>( 
            (bext.max_momentary_loudness.unwrap_or(0.0) * 100.0) as i16 )?;
        self.write_i16::<LittleEndian>( 
            (bext.max_short_term_loudness.unwrap_or(0.0) * 100.0) as i16 )?;
        let padding = [0u8; 180];
        self.write_all(&padding)?;
-        let coding = ASCII.encode(&bext.coding_history, EncoderTrap::Ignore)
+        let coding = ASCII
            .encode(&bext.coding_history, EncoderTrap::Ignore)
            .expect("Error");
        self.write_all(&coding)?;
@@ -255,71 +96,156 @@ impl<T> WriteBWaveChunks for T where T: Write {
    }
 }
-impl<T> ReadBWaveChunks for T where T: Read {
+impl<T> ReadBWaveChunks for T
-
+where
    T: Read,
 {
    fn read_wave_fmt(&mut self) -> Result<WaveFmt, ParserError> {
        let tag_value: u16;
        Ok(WaveFmt {
-            tag:                self.read_u16::<LittleEndian>()?,
+            tag: {
-            channel_count:      self.read_u16::<LittleEndian>()?,
+                tag_value = self.read_u16::<LittleEndian>()?;
-            sample_rate:        self.read_u32::<LittleEndian>()?,
+                tag_value
-            bytes_per_second:   self.read_u32::<LittleEndian>()?,
+            },
-            block_alignment:    self.read_u16::<LittleEndian>()?,
+            channel_count: self.read_u16::<LittleEndian>()?,
-            bits_per_sample:    self.read_u16::<LittleEndian>()?, 
+            sample_rate: self.read_u32::<LittleEndian>()?,
-            extended_format: None
+            bytes_per_second: self.read_u32::<LittleEndian>()?,
            block_alignment: self.read_u16::<LittleEndian>()?,
            bits_per_sample: self.read_u16::<LittleEndian>()?,
            extended_format: {
                if tag_value == 0xFFFE {
                    let cb_size = self.read_u16::<LittleEndian>()?;
                    assert!(cb_size >= 22, "Format extension is not correct size");
                    Some(WaveFmtExtended {
                        valid_bits_per_sample: self.read_u16::<LittleEndian>()?,
                        channel_mask: self.read_u32::<LittleEndian>()?,
                        type_guid: {
                            let mut buf: [u8; 16] = [0; 16];
                            self.read_exact(&mut buf)?;
                            Uuid::from_slice(&buf)?
                        },
                    })
                } else {
                    None
                }
            },
        })
    }
-    fn read_bext_string_field(&mut self, length: usize) -> Result<String,ParserError> {
+    fn read_bext_string_field(&mut self, length: usize) -> Result<String, ParserError> {
-        let mut buffer : Vec<u8> = vec![0; length];
+        let mut buffer: Vec<u8> = vec![0; length];
-        self.read(&mut buffer)?;
+        self.read_exact(&mut buffer)?;
-        let trimmed : Vec<u8> = buffer.iter().take_while(|c| **c != 0 as u8).cloned().collect();
+        let trimmed: Vec<u8> = buffer.iter().take_while(|c| **c != 0_u8).cloned().collect();
-        Ok(ASCII.decode(&trimmed, DecoderTrap::Ignore).expect("Error decoding text")) 
+        Ok(ASCII
            .decode(&trimmed, DecoderTrap::Ignore)
            .expect("Error decoding text"))
    }
    fn read_bext(&mut self) -> Result<Bext, ParserError> {
-        let version : u16; 
+        let version: u16;
-        Ok( Bext { 
+        Ok(Bext {
-                description:            self.read_bext_string_field(256)?,
+            description: self.read_bext_string_field(256)?,
-                originator:             self.read_bext_string_field(32)?,
+            originator: self.read_bext_string_field(32)?,
-                originator_reference :  self.read_bext_string_field(32)?,
+            originator_reference: self.read_bext_string_field(32)?,
-                origination_date :      self.read_bext_string_field(10)?, 
+            origination_date: self.read_bext_string_field(10)?,
-                origination_time :      self.read_bext_string_field(8)?, 
+            origination_time: self.read_bext_string_field(8)?,
-                time_reference:         self.read_u64::<LittleEndian>()?,
+            time_reference: self.read_u64::<LittleEndian>()?,
-                version: {
+            version: {
-                    version = self.read_u16::<LittleEndian>()?;
+                version = self.read_u16::<LittleEndian>()?;
-                    version
+                version
-                },
+            },
-                umid: {
+            umid: {
-                    let mut buf = [0u8 ; 64];
+                let mut buf = [0u8; 64];
-                    self.read(&mut buf)?;
+                self.read_exact(&mut buf)?;
-                    if version > 0 { Some(buf) } else { None }
+                if version > 0 {
-                },
+                    Some(buf)
-                loudness_value: {
+                } else {
-                    let val = (self.read_i16::<LittleEndian>()? as f32) / 100f32;
+                    None
                    if version > 1 { Some(val) } else { None }
                },
                loudness_range: {
                    let val = self.read_i16::<LittleEndian>()? as f32 / 100f32;
                    if version > 1 { Some(val) } else { None }
                },
                max_true_peak_level: {
                    let val = self.read_i16::<LittleEndian>()? as f32 / 100f32;
                    if version > 1 { Some(val) } else { None }
                },
                max_momentary_loudness: {
                    let val = self.read_i16::<LittleEndian>()? as f32 / 100f32;
                    if version > 1 { Some(val) } else { None }
                },
                max_short_term_loudness: {
                    let val = self.read_i16::<LittleEndian>()? as f32 / 100f32;
                    if version > 1 { Some(val) } else { None }
                }, 
                coding_history: {
                    for _ in 0..=180 { self.read_u8()?; }
                    let mut buf = vec![];
                    self.read_to_end(&mut buf)?;
                    ASCII.decode(&buf, DecoderTrap::Ignore).expect("Error decoding text")
                }
            },
            loudness_value: {
                let val = (self.read_i16::<LittleEndian>()? as f32) / 100f32;
                if version > 1 {
                    Some(val)
                } else {
                    None
                }
            },
            loudness_range: {
                let val = self.read_i16::<LittleEndian>()? as f32 / 100f32;
                if version > 1 {
                    Some(val)
                } else {
                    None
                }
            },
            max_true_peak_level: {
                let val = self.read_i16::<LittleEndian>()? as f32 / 100f32;
                if version > 1 {
                    Some(val)
                } else {
                    None
                }
            },
            max_momentary_loudness: {
                let val = self.read_i16::<LittleEndian>()? as f32 / 100f32;
                if version > 1 {
                    Some(val)
                } else {
                    None
                }
            },
            max_short_term_loudness: {
                let val = self.read_i16::<LittleEndian>()? as f32 / 100f32;
                if version > 1 {
                    Some(val)
                } else {
                    None
                }
            },
            coding_history: {
                for _ in 0..180 {
                    self.read_u8()?;
                }
                let mut buf = vec![];
                self.read_to_end(&mut buf)?;
                ASCII
                    .decode(&buf, DecoderTrap::Ignore)
                    .expect("Error decoding text")
            },
        })
-     }
+    }
 }
 #[test]
 fn test_read_51_wav() {
    use super::common_format::CommonFormat;
    use super::fmt::ChannelMask;
    let path = "tests/media/pt_24bit_51.wav";
    let mut w = super::wavereader::WaveReader::open(path).unwrap();
    let format = w.format().unwrap();
    assert_eq!(format.tag, 0xFFFE);
    assert_eq!(format.channel_count, 6);
    assert_eq!(format.sample_rate, 48000);
    let extended = format.extended_format.unwrap();
    assert_eq!(extended.valid_bits_per_sample, 24);
    let channels = ChannelMask::channels(extended.channel_mask, format.channel_count);
    assert_eq!(
        channels,
        [
            ChannelMask::FrontLeft,
            ChannelMask::FrontRight,
            ChannelMask::FrontCenter,
            ChannelMask::LowFrequency,
            ChannelMask::BackLeft,
            ChannelMask::BackRight
        ]
    );
    assert_eq!(format.common_format(), CommonFormat::IntegerPCM);
 }
--- a/src/common_format.rs
+++ b/src/common_format.rs
@@ -0,0 +1,115 @@
 /// Format tags, UUIDs and utilities
 use uuid::Uuid;
 /// Format tag for integer LPCM
 pub const WAVE_TAG_PCM: u16 = 0x0001;
 /// Format tag for float LPCM
 pub const WAVE_TAG_FLOAT: u16 = 0x0003;
 /// Format tag for MPEG1
 pub const WAVE_TAG_MPEG: u16 = 0x0050;
 /// Format tag indicating extended format
 pub const WAVE_TAG_EXTENDED: u16 = 0xFFFE;
 /* RC 2361 §4:
 WAVE Format IDs are converted to GUIDs by inserting the hexadecimal
   value of the WAVE Format ID into the XXXXXXXX part of the following
   template: {XXXXXXXX-0000-0010-8000-00AA00389B71}. For example, a WAVE
   Format ID of 123 has the GUID value of {00000123-0000-0010-8000-
   00AA00389B71}.
 */
 /// Extended format UUID for integer PCM
 pub const WAVE_UUID_PCM: Uuid = Uuid::from_bytes([
    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71,
 ]);
 /// Extended format UUID for float PCM
 pub const WAVE_UUID_FLOAT: Uuid = Uuid::from_bytes([
    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71,
 ]);
 /// Extended format UUID for MPEG1 data
 pub const WAVE_UUID_MPEG: Uuid = Uuid::from_bytes([
    0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71,
 ]);
 /// Extended format for integer Ambisonic B-Format
 pub const WAVE_UUID_BFORMAT_PCM: Uuid = Uuid::from_bytes([
    0x01, 0x00, 0x00, 0x00, 0x21, 0x07, 0xd3, 0x11, 0x86, 0x44, 0xc8, 0xc1, 0xca, 0x00, 0x00, 0x00,
 ]);
 /// Extended format for float Ambisonic B-Format
 pub const WAVE_UUID_BFORMAT_FLOAT: Uuid = Uuid::from_bytes([
    0x03, 0x00, 0x00, 0x00, 0x21, 0x07, 0xd3, 0x11, 0x86, 0x44, 0xc8, 0xc1, 0xca, 0x00, 0x00, 0x00,
 ]);
 /// Generate an extended format UUID for the given basic format tag from [WaveFmt::tag].
 fn uuid_from_basic_tag(tag: u16) -> Uuid {
    let tail: [u8; 6] = [0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71];
    Uuid::from_fields_le(tag as u32, 0x0000, 0x0010, &tail).unwrap()
 }
 /// Sample format of the Wave file.
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum CommonFormat {
    /// Integer linear PCM
    IntegerPCM,
    /// IEEE Floating-point Linear PCM
    IeeeFloatPCM,
    /// MPEG
    Mpeg,
    /// Ambisonic B-Format Linear PCM
    AmbisonicBFormatIntegerPCM,
    /// Ambisonic B-Format Float PCM
    AmbisonicBFormatIeeeFloatPCM,
    /// An unknown format identified by a basic format tag.
    UnknownBasic(u16),
    /// An unknown format identified by an extension UUID.
    UnknownExtended(Uuid),
 }
 impl CommonFormat {
    /// Resolve a tag and Uuid to a `CommonFormat`.
    pub fn make(basic: u16, uuid: Option<Uuid>) -> Self {
        match (basic, uuid) {
            (WAVE_TAG_PCM, _) => Self::IntegerPCM,
            (WAVE_TAG_FLOAT, _) => Self::IeeeFloatPCM,
            (WAVE_TAG_MPEG, _) => Self::Mpeg,
            (WAVE_TAG_EXTENDED, Some(WAVE_UUID_PCM)) => Self::IntegerPCM,
            (WAVE_TAG_EXTENDED, Some(WAVE_UUID_FLOAT)) => Self::IeeeFloatPCM,
            (WAVE_TAG_EXTENDED, Some(WAVE_UUID_BFORMAT_PCM)) => Self::AmbisonicBFormatIntegerPCM,
            (WAVE_TAG_EXTENDED, Some(WAVE_UUID_BFORMAT_FLOAT)) => {
                Self::AmbisonicBFormatIeeeFloatPCM
            }
            (WAVE_TAG_EXTENDED, Some(x)) => CommonFormat::UnknownExtended(x),
            (x, _) => CommonFormat::UnknownBasic(x),
        }
    }
    /// 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 => (WAVE_TAG_PCM, WAVE_UUID_PCM),
            Self::IeeeFloatPCM => (WAVE_TAG_FLOAT, WAVE_UUID_FLOAT),
            Self::Mpeg => (WAVE_TAG_MPEG, WAVE_UUID_MPEG),
            Self::AmbisonicBFormatIntegerPCM => (WAVE_TAG_EXTENDED, WAVE_UUID_BFORMAT_PCM),
            Self::AmbisonicBFormatIeeeFloatPCM => (WAVE_TAG_EXTENDED, WAVE_UUID_BFORMAT_FLOAT),
            Self::UnknownBasic(x) => (x, uuid_from_basic_tag(x)),
            Self::UnknownExtended(x) => (WAVE_TAG_EXTENDED, x),
        }
    }
 }
--- a/src/cue.rs
+++ b/src/cue.rs
@@ -0,0 +1,404 @@
 #![allow(dead_code)]
 use super::fourcc::{
    FourCC, ReadFourCC, WriteFourCC, ADTL_SIG, DATA_SIG, LABL_SIG, LTXT_SIG, NOTE_SIG,
 };
 use super::list_form::collect_list_form;
 use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
 use encoding::all::ASCII;
 use encoding::Encoding;
 use encoding::{DecoderTrap, EncoderTrap};
 use std::io::{Cursor, Error, Read, Write};
 #[derive(Copy, Clone, Debug)]
 struct RawCue {
    cue_point_id: u32,
    frame: u32,
    chunk_id: FourCC,
    chunk_start: u32,
    block_start: u32,
    frame_offset: u32,
 }
 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>()?;
        let mut retval: Vec<Self> = vec![];
        for _ in 0..count {
            retval.push(Self {
                cue_point_id: rdr.read_u32::<LittleEndian>()?,
                frame: rdr.read_u32::<LittleEndian>()?,
                chunk_id: rdr.read_fourcc()?,
                chunk_start: rdr.read_u32::<LittleEndian>()?,
                block_start: rdr.read_u32::<LittleEndian>()?,
                frame_offset: rdr.read_u32::<LittleEndian>()?,
            })
        }
        Ok(retval)
    }
 }
 #[derive(Clone, Debug)]
 struct RawLabel {
    cue_point_id: u32,
    text: Vec<u8>,
 }
 impl RawLabel {
    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_all(&self.text).unwrap();
        writer.into_inner()
    }
    fn read_from(data: &[u8]) -> Result<Self, Error> {
        let mut rdr = Cursor::new(data);
        let length = data.len();
        Ok(Self {
            cue_point_id: rdr.read_u32::<LittleEndian>()?,
            text: {
                let mut buf = vec![0u8; length - 4];
                rdr.read_exact(&mut buf)?;
                buf
            },
        })
    }
 }
 #[derive(Clone, Debug)]
 struct RawNote {
    cue_point_id: u32,
    text: Vec<u8>,
 }
 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_all(&self.text).unwrap();
        writer.into_inner()
    }
    fn read_from(data: &[u8]) -> Result<Self, Error> {
        let mut rdr = Cursor::new(data);
        let length = data.len();
        Ok(Self {
            cue_point_id: rdr.read_u32::<LittleEndian>()?,
            text: {
                let mut buf = vec![0u8; length - 4];
                rdr.read_exact(&mut buf)?;
                buf
            },
        })
    }
 }
 #[derive(Clone, Debug)]
 struct RawLtxt {
    cue_point_id: u32,
    frame_length: u32,
    purpose: FourCC,
    country: u16,
    language: u16,
    dialect: u16,
    code_page: u16,
    text: Option<Vec<u8>>,
 }
 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_all(ext_text).unwrap();
        }
        writer.into_inner()
    }
    fn read_from(data: &[u8]) -> Result<Self, Error> {
        let mut rdr = Cursor::new(data);
        let length = data.len();
        Ok(Self {
            cue_point_id: rdr.read_u32::<LittleEndian>()?,
            frame_length: rdr.read_u32::<LittleEndian>()?,
            purpose: rdr.read_fourcc()?,
            country: rdr.read_u16::<LittleEndian>()?,
            language: rdr.read_u16::<LittleEndian>()?,
            dialect: rdr.read_u16::<LittleEndian>()?,
            code_page: rdr.read_u16::<LittleEndian>()?,
            text: {
                if length - 20 > 0 {
                    let mut buf = vec![0u8; length - 20];
                    rdr.read_exact(&mut buf)?;
                    Some(buf)
                } else {
                    None
                }
            },
        })
    }
 }
 #[derive(Clone, Debug)]
 enum RawAdtlMember {
    Label(RawLabel),
    Note(RawNote),
    LabeledText(RawLtxt),
    Unrecognized(FourCC),
 }
 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_all(&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_all(&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![];
        for chunk in chunks.iter() {
            retval.push(match chunk.signature {
                LABL_SIG => RawAdtlMember::Label(RawLabel::read_from(&chunk.contents)?),
                NOTE_SIG => RawAdtlMember::Note(RawNote::read_from(&chunk.contents)?),
                LTXT_SIG => RawAdtlMember::LabeledText(RawLtxt::read_from(&chunk.contents)?),
                x => RawAdtlMember::Unrecognized(x),
            })
        }
        Ok(retval)
    }
 }
 trait AdtlMemberSearch {
    fn labels_for_cue_point(&self, id: u32) -> Vec<&RawLabel>;
    fn notes_for_cue_point(&self, id: u32) -> Vec<&RawNote>;
    fn ltxt_for_cue_point(&self, id: u32) -> Vec<&RawLtxt>;
 }
 impl AdtlMemberSearch for Vec<RawAdtlMember> {
    fn labels_for_cue_point(&self, id: u32) -> Vec<&RawLabel> {
        self.iter()
            .filter_map(|item| match item {
                RawAdtlMember::Label(x) if x.cue_point_id == id => Some(x),
                _ => None,
            })
            .collect()
    }
    fn notes_for_cue_point(&self, id: u32) -> Vec<&RawNote> {
        self.iter()
            .filter_map(|item| match item {
                RawAdtlMember::Note(x) if x.cue_point_id == id => Some(x),
                _ => None,
            })
            .collect()
    }
    fn ltxt_for_cue_point(&self, id: u32) -> Vec<&RawLtxt> {
        self.iter()
            .filter_map(|item| match item {
                RawAdtlMember::LabeledText(x) if x.cue_point_id == id => Some(x),
                _ => None,
            })
            .collect()
    }
 }
 /// 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 {
    /// The time of this marker
    pub frame: u32,
    /// The length of this marker, if it is a range
    pub length: Option<u32>,
    /// The text "label"/name of this marker if provided
    pub label: Option<String>,
    /// The text "note"/comment of this marker if provided
    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,
 }
 fn convert_to_cue_string(buffer: &[u8]) -> String {
    let trimmed: Vec<u8> = buffer.iter().take_while(|c| **c != 0_u8).cloned().collect();
    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);
                    if let Some(l) = label {
                        adtls.push(RawAdtlMember::Label(l))
                    }
                    if let Some(n) = note {
                        adtls.push(RawAdtlMember::Note(n))
                    }
                    if let Some(m) = ltxt {
                        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>;
        if let Some(adtl) = adtl_chunk {
            raw_adtl = RawAdtlMember::collect_from(adtl)?;
        } else {
            raw_adtl = vec![];
        }
        Ok(raw_cues
            .iter()
            .map(|i| {
                Cue {
                    //ident : i.cue_point_id,
                    frame: i.frame,
                    length: {
                        raw_adtl
                            .ltxt_for_cue_point(i.cue_point_id)
                            .first()
                            .filter(|x| x.purpose == FourCC::make(b"rgn "))
                            .map(|x| x.frame_length)
                    },
                    label: {
                        raw_adtl
                            .labels_for_cue_point(i.cue_point_id)
                            .iter()
                            .map(|s| convert_to_cue_string(&s.text))
                            .next()
                    },
                    note: {
                        raw_adtl
                            .notes_for_cue_point(i.cue_point_id)
                            .iter()
                            //.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,13 +1,19 @@
 use std::io;
 use super::fourcc::FourCC;
 use std::error::Error as StdError;
 use std::{
    fmt::{Debug, Display},
    io,
 };
 /// Errors returned by methods in this crate.
 #[derive(Debug)]
 pub enum Error {
    /// An `io::Error` occurred
    IOError(io::Error),
    /// An error occured reading a tag UUID
    UuidError(uuid::Error),
    /// The file does not begin with a recognized WAVE header
    HeaderNotRecognized,
@@ -17,7 +23,7 @@ pub enum Error {
    /// A data chunk required to complete the operation
    /// is not present in the file
-    ChunkMissing { signature : FourCC },
+    ChunkMissing { signature: FourCC },
    /// The file is formatted improperly
    FmtChunkAfterData,
@@ -31,15 +37,34 @@ pub enum Error {
    /// The file cannot be converted into an RF64 file due
    /// to its internal structure
-    InsufficientDS64Reservation {expected: u64, actual: u64},
+    InsufficientDS64Reservation { expected: u64, actual: u64 },
    /// The file is not optimized for writing new data
-    DataChunkNotPreparedForAppend
+    DataChunkNotPreparedForAppend,
    /// A buffer with a length that isn't a multiple of channel_count was provided
    InvalidBufferSize {
        buffer_size: usize,
        channel_count: u16,
    },
 }
 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 {
        Error::IOError(error)
    }
 }
 impl From<uuid::Error> for Error {
    fn from(error: uuid::Error) -> Error {
        Error::UuidError(error)
    }
 }
--- a/src/fmt.rs
+++ b/src/fmt.rs
@@ -0,0 +1,447 @@
 use crate::common_format::{CommonFormat, WAVE_UUID_BFORMAT_PCM, WAVE_UUID_PCM};
 use crate::Sample;
 use std::io::Cursor;
 use uuid::Uuid;
 use byteorder::LittleEndian;
 use byteorder::ReadBytesExt;
 // Need more test cases for ADMAudioID
 #[allow(dead_code)]
 /// ADM Audio ID record.
 ///
 /// This structure relates a channel in the wave file to either a common ADM
 /// channel definition or further definition in the WAV file's ADM metadata
 /// chunk.
 ///
 /// An individual channel in a WAV file can have multiple Audio IDs in an ADM
 /// `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],
    pub pack_ref: [char; 11],
 }
 /// 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,
    /// Channel assignment
    ///
    /// This is either implied (in the case of mono or stereo wave files) or
    /// explicitly given in `WaveFormatExtentended` for files with more tracks.
    pub speaker: ChannelMask,
    /// ADM audioTrackUIDs
    pub adm_track_audio_ids: Vec<ADMAudioID>,
 }
 /// A bitmask indicating which channels are present in
 /// the file.
 ///
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum ChannelMask {
    DirectOut = 0x0,
    FrontLeft = 0x1,
    FrontRight = 0x2,
    FrontCenter = 0x4,
    LowFrequency = 0x8,
    BackLeft = 0x10,
    BackRight = 0x20,
    FrontCenterLeft = 0x40,
    FrontCenterRight = 0x80,
    BackCenter = 0x100,
    SideLeft = 0x200,
    SideRight = 0x400,
    TopCenter = 0x800,
    TopFrontLeft = 0x1000,
    TopFrontCenter = 0x2000,
    TopFrontRight = 0x4000,
    TopBackLeft = 0x8000,
    TopBackCenter = 0x10000,
    TopBackRight = 0x20000,
 }
 impl From<u32> for ChannelMask {
    fn from(value: u32) -> Self {
        match value {
            0x1 => Self::FrontLeft,
            0x2 => Self::FrontRight,
            0x4 => Self::FrontCenter,
            0x8 => Self::LowFrequency,
            0x10 => Self::BackLeft,
            0x20 => Self::BackRight,
            0x40 => Self::FrontCenterLeft,
            0x80 => Self::FrontCenterRight,
            0x100 => Self::BackCenter,
            0x200 => Self::SideLeft,
            0x400 => Self::SideRight,
            0x800 => Self::TopCenter,
            0x1000 => Self::TopFrontLeft,
            0x2000 => Self::TopFrontCenter,
            0x4000 => Self::TopFrontRight,
            0x8000 => Self::TopBackLeft,
            0x10000 => Self::TopBackCenter,
            0x20000 => Self::TopBackRight,
            _ => Self::DirectOut,
        }
    }
 }
 impl ChannelMask {
    pub fn channels(input_mask: u32, channel_count: u16) -> Vec<ChannelMask> {
        let reserved_mask = 0xfff2_0000_u32;
        if (input_mask & reserved_mask) > 0 {
            vec![ChannelMask::DirectOut; channel_count as usize]
        } else {
            (0..18)
                .map(|i| 1 << i)
                .filter(|mask| mask & input_mask > 0)
                .map(ChannelMask::from)
                .collect()
        }
    }
 }
 /**
 * Extended Wave Format
 *
 * Resources:
 * * [WAVEFORMATEXTENSIBLE structure](https://docs.microsoft.com/en-us/windows/win32/api/mmreg/ns-mmreg-waveformatextensible)
 */
 #[derive(Debug, Copy, Clone)]
 pub struct WaveFmtExtended {
    /// Valid bits per sample
    pub valid_bits_per_sample: u16,
    /// Channel mask
    ///
    /// Identifies the speaker assignment for each channel in the file
    pub channel_mask: u32,
    /// Codec GUID
    ///
    /// Identifies the codec of the audio stream
    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.
 ///
 ///
 /// ## 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)
 /// - [Audio File Format Specifications](http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html) (September 2022) Prof. Peter Kabal, MMSP Lab, ECE, McGill University
 /// - [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 {
    /// A tag identifying the codec in use.
    ///
    /// If this is 0xFFFE, the codec will be identified by a GUID
    /// in [`extended_format`](WaveFmt::extended_format).
    pub tag: u16,
    /// Count of audio channels in each frame
    pub channel_count: u16,
    /// Playback rate of the audio data
    ///
    /// In frames per second.
    pub sample_rate: u32,
    /// Count of bytes per second
    ///
    /// By rule, this is `block_alignment * sample_rate`
    pub bytes_per_second: u32,
    /// Count of bytes per audio frame
    ///
    /// By rule, this is `channel_count * bits_per_sample / 8`
    pub block_alignment: u16,
    /// Count of bits stored in the file per sample
    ///
    /// By rule, `bits_per_sample % 8 == 0` for Broadcast-Wave files.
    ///
    /// Modern clients will encode
    /// unusual sample sizes in normal byte sizes but will set the valid_bits
    /// flag in extended format record.
    ///
    /// Generally speaking this will be true for all modern wave files, though
    /// there was an historical "packed" stereo format of 20 bits per sample,
    /// 5 bytes per frame, 5 bytes block alignment.
    pub bits_per_sample: u16,
    /// Extended format description
    ///
    /// Additional format metadata if channel_count is greater than 2,
    /// or if certain codecs are used.
    pub extended_format: Option<WaveFmtExtended>,
 }
 impl WaveFmt {
    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;
        WaveFmt {
            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: Some(WaveFmtExtended {
                valid_bits_per_sample: bits_per_sample,
                channel_mask: ChannelMask::DirectOut as u32,
                type_guid: WAVE_UUID_BFORMAT_PCM,
            }),
        }
    }
    /// Create a new integer PCM format [WaveFmt] with a custom channel bitmap.
    ///
    /// The order of [channels](WaveFmt::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: WAVE_UUID_PCM,
                }),
            ),
            0b0100 => (0x0001, None),
            0b0011 => (0x0001, None),
            ch => (
                0xFFFE,
                Some(WaveFmtExtended {
                    valid_bits_per_sample: bits_per_sample,
                    channel_mask: ch,
                    type_guid: WAVE_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,
        }
    }
    /// Format or codec of the file's audio data.
    ///
    /// The [CommonFormat] unifies the format tag and the format extension GUID. Use this
    /// method to determine the codec.
    pub fn common_format(&self) -> CommonFormat {
        CommonFormat::make(self.tag, self.extended_format.map(|ext| ext.type_guid))
    }
    /// 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<S: Sample>(&self, length: usize) -> Vec<S> {
        vec![S::EQUILIBRIUM; 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]
    }
    /// Read bytes into frames
    pub fn unpack_frames(&self, from_bytes: &[u8], into_frames: &mut [i32]) {
        let mut rdr = Cursor::new(from_bytes);
        for frame in into_frames {
            *frame = 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)
            }
        }
    }
    /// Channel descriptors for each channel.
    pub fn channels(&self) -> Vec<ChannelDescriptor> {
        match self.channel_count {
            1 => vec![ChannelDescriptor {
                index: 0,
                speaker: ChannelMask::FrontCenter,
                adm_track_audio_ids: vec![],
            }],
            2 => vec![
                ChannelDescriptor {
                    index: 0,
                    speaker: ChannelMask::FrontLeft,
                    adm_track_audio_ids: vec![],
                },
                ChannelDescriptor {
                    index: 1,
                    speaker: ChannelMask::FrontRight,
                    adm_track_audio_ids: vec![],
                },
            ],
            x if x > 2 => {
                let channel_mask = self.extended_format.map(|x| x.channel_mask).unwrap_or(0);
                let channels = ChannelMask::channels(channel_mask, self.channel_count);
                let channels_expanded = channels
                    .iter()
                    .chain(std::iter::repeat(&ChannelMask::DirectOut));
                (0..self.channel_count)
                    .zip(channels_expanded)
                    .map(|(n, chan)| ChannelDescriptor {
                        index: n,
                        speaker: *chan,
                        adm_track_audio_ids: vec![],
                    })
                    .collect()
            }
            x => panic!("Channel count ({}) was illegal!", x),
        }
    }
 }
 pub trait ReadWavAudioData {
    /// Read audio data from the receiver as interleaved [i32] samples.
    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,
 {
    /// # Panics:
    /// * If the format's [valid bits per sample](WaveFmt::valid_bits_per_sample) is
    ///   not compatible with the format's [bits per sample](WaveFmt::bits_per_sample).
    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 frame in into {
            *frame = 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
@@ -15,8 +15,13 @@ impl FourCC {
 }
 impl From<[char; 4]> for FourCC {
-    fn from(chars : [char; 4]) -> Self {
+    fn from(chars: [char; 4]) -> Self {
-        Self([chars[0] as u8 , chars[1] as u8, chars[2] as u8, chars[3] as u8])
+        Self([
            chars[0] as u8,
            chars[1] as u8,
            chars[2] as u8,
            chars[3] as u8,
        ])
    }
 }
@@ -32,37 +37,45 @@ impl From<FourCC> for [u8; 4] {
    }
 }
-
+impl From<&FourCC> for [char; 4] {
-impl From<&FourCC> for [char;4] {
+    fn from(f: &FourCC) -> Self {
-    fn from( f: &FourCC) -> Self {
+        [
-        [f.0[0] as char, f.0[1] as char, f.0[2] as char, f.0[3] as char,]
+            f.0[0] as char,
            f.0[1] as char,
            f.0[2] as char,
            f.0[3] as char,
        ]
    }
 }
-impl From<FourCC> for [char;4] {
+impl From<FourCC> for [char; 4] {
-    fn from( f: FourCC) -> Self {
+    fn from(f: FourCC) -> Self {
-        [f.0[0] as char, f.0[1] as char, f.0[2] as char, f.0[3] as char,]
+        [
            f.0[0] as char,
            f.0[1] as char,
            f.0[2] as char,
            f.0[3] as char,
        ]
    }
 }
 impl From<&FourCC> for String {
    fn from(f: &FourCC) -> Self {
-        let chars: [char;4] = f.into();
+        let chars: [char; 4] = f.into();
        chars.iter().collect::<String>()
    }
 }
 impl From<FourCC> for String {
    fn from(f: FourCC) -> Self {
-        let chars: [char;4] = f.into();
+        let chars: [char; 4] = f.into();
        chars.iter().collect::<String>()
    }
 }
 impl Debug for FourCC {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
-        let s : String = self.into();
+        let s: String = self.into();
        write!(f, "FourCC({})", s)
    }
 }
@@ -72,26 +85,31 @@ pub trait ReadFourCC: io::Read {
 }
 pub trait WriteFourCC: io::Write {
-    fn write_fourcc(&mut self, fourcc :FourCC) -> Result<(), io::Error>;
+    fn write_fourcc(&mut self, fourcc: FourCC) -> Result<(), io::Error>;
 }
-impl<T> ReadFourCC for T where T: io::Read { 
+impl<T> ReadFourCC for T
 where
    T: io::Read,
 {
    fn read_fourcc(&mut self) -> Result<FourCC, io::Error> {
-        let mut buf : [u8; 4] = [0 ; 4];
+        let mut buf: [u8; 4] = [0; 4];
        self.read_exact(&mut buf)?;
-        Ok( FourCC::from(buf) )
+        Ok(FourCC::from(buf))
    }
 }
-impl<T> WriteFourCC for T where T: io::Write {
+impl<T> WriteFourCC for T
-    fn write_fourcc(&mut self, fourcc :FourCC) -> Result<(), io::Error> {
+where
-        let buf : [u8; 4] = fourcc.into();
+    T: io::Write,
 {
    fn write_fourcc(&mut self, fourcc: FourCC) -> Result<(), io::Error> {
        let buf: [u8; 4] = fourcc.into();
        self.write_all(&buf)?;
        Ok(())
    }
 }
 pub const RIFF_SIG: FourCC = FourCC::make(b"RIFF");
 pub const WAVE_SIG: FourCC = FourCC::make(b"WAVE");
 pub const RF64_SIG: FourCC = FourCC::make(b"RF64");
@@ -102,10 +120,20 @@ pub const DATA_SIG: FourCC = FourCC::make(b"data");
 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");
 pub const ELM1_SIG: FourCC = FourCC::make(b"elm1");
 pub const LIST_SIG: FourCC = FourCC::make(b"LIST");
 pub const CUE__SIG: FourCC = FourCC::make(b"cue ");
 pub const ADTL_SIG: FourCC = FourCC::make(b"adtl");
 pub const LABL_SIG: FourCC = FourCC::make(b"labl");
 pub const NOTE_SIG: FourCC = FourCC::make(b"note");
 pub const LTXT_SIG: FourCC = FourCC::make(b"ltxt");
 #[cfg(test)]
 mod tests {
@@ -114,7 +142,7 @@ mod tests {
    #[test]
    fn test_to_string() {
        let a = FourCC::make(b"a1b2");
-        let s : String = a.into();
+        let s: String = a.into();
        assert_eq!(s, "a1b2");
    }
 }
--- 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
@@ -1,67 +1,58 @@
 //
 /*!
 # 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
+Refer to the individual modules for relevant documentation. For opening
-files works however the interfaces may change significantly. Stay up-to-date on the
+and writing files begin with [WaveReader] and [WaveWriter] respectively.
 status of this project at [Github][github].)
-## Resources
+## Objectives and Roadmap
-### Implementation of Broadcast Wave Files
+This package aims to support read and writing any kind of WAV file you are likely
- [EBU Tech 3285][ebu3285] (May 2011), "Specification of the Broadcast Wave Format (BWF)"
+to encounter in a professional audio, motion picture production, broadcast, or music
 production.
-### Implementation of 64-bit Wave Files
+Apps we test against:
- [ITU-R 2088][itu2088] (October 2019), "Long-form file format for the international exchange of audio programme materials with metadata"
+- Avid Pro Tools
- - Presently in force, adopted by the EBU in [EBU Tech 3306v2][ebu3306v2] (June 2018).
+- iZotope RX Audio Editor
- [EBU Tech 3306v1][ebu3306v1] (July 2009), "MBWF / RF64: An extended File Format for Audio"
+- FFMpeg
- - No longer in force, however long-established. 
+- Audacity
 - Sound Devices field recorders: 702T, MixPre-10 II
 ### 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" 
 - [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) 
    IBM Corporation and Microsoft Corporation, (August 1991)
 [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 encoding;
 extern crate uuid;
-mod parser;
+mod common_format;
 mod fourcc;
 mod errors;
 mod fourcc;
-mod validation;
+mod list_form;
 mod parser;
-mod raw_chunk_reader;
+mod bext;
 mod audio_frame_reader;
 mod chunks;
 mod cue;
 mod fmt;
 mod sample;
 mod wavereader;
 mod wavewriter;
-pub use wavereader::{WaveReader};
+pub use bext::Bext;
-pub use chunks::{WaveFmt,Bext};
+pub use common_format::{
    CommonFormat, WAVE_TAG_EXTENDED, WAVE_TAG_FLOAT, WAVE_TAG_MPEG, WAVE_TAG_PCM,
    WAVE_UUID_BFORMAT_FLOAT, WAVE_UUID_BFORMAT_PCM, WAVE_UUID_FLOAT, WAVE_UUID_MPEG, WAVE_UUID_PCM,
 };
 pub use cue::Cue;
 pub use errors::Error;
 pub use fmt::{
    ADMAudioID, ChannelDescriptor, ChannelMask, ReadWavAudioData, WaveFmt, WaveFmtExtended,
 };
 pub use sample::{Sample, I24};
 pub use wavereader::{AudioFrameReader, WaveReader};
 pub use wavewriter::{AudioFrameWriter, WaveWriter};
--- a/src/list_form.rs
+++ b/src/list_form.rs
@@ -0,0 +1,42 @@
 use super::fourcc::{FourCC, ReadFourCC};
 use byteorder::{LittleEndian, ReadBytesExt};
 use std::io::{Cursor, Error, Read};
 pub struct ListFormItem {
    pub signature: FourCC,
    pub contents: Vec<u8>,
 }
 /// A helper that will accept a LIST chunk as a [u8]
 /// and give you back each segment
 ///
 pub fn collect_list_form(list_contents: &[u8]) -> Result<Vec<ListFormItem>, Error> {
    let mut cursor = Cursor::new(list_contents);
    let mut remain = list_contents.len();
    let _ = cursor.read_fourcc()?; // skip signature
    remain -= 4;
    let mut retval: Vec<ListFormItem> = vec![];
    while remain > 0 {
        let this_sig = cursor.read_fourcc()?;
        let this_size = cursor.read_u32::<LittleEndian>()? as usize;
        remain -= 8;
        let mut content_buf = vec![0u8; this_size];
        cursor.read_exact(&mut content_buf)?;
        remain -= this_size;
        retval.push(ListFormItem {
            signature: this_sig,
            contents: content_buf,
        });
        if this_size % 2 == 1 {
            cursor.read_u8()?;
            //panic!("Got this far!");
            remain -= 1;
        }
    }
    Ok(retval)
 }
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -1,15 +1,14 @@
-
+use std::collections::HashMap;
 use std::io;
 use std::io::SeekFrom::{Current, Start};
-use std::io::{Seek, Read};
+use std::io::{Read, Seek};
 use std::collections::HashMap;
 use byteorder::LittleEndian;
 use byteorder::ReadBytesExt;
 use super::errors::Error;
 use super::fourcc::{FourCC, ReadFourCC};
-use super::fourcc::{RIFF_SIG, RF64_SIG, BW64_SIG, WAVE_SIG, DS64_SIG, DATA_SIG};
+use super::fourcc::{BW64_SIG, DATA_SIG, DS64_SIG, RF64_SIG, RIFF_SIG, WAVE_SIG};
 // just for your reference...
 // RF64 documentation https://www.itu.int/dms_pubrec/itu-r/rec/bs/R-REC-BS.2088-1-201910-I!!PDF-E.pdf
@@ -21,12 +20,26 @@ const RF64_SIZE_MARKER: u32 = 0xFF_FF_FF_FF;
 #[derive(Debug)]
 pub enum Event {
    StartParse,
-    ReadHeader { signature: FourCC, length_field: u32 },
+    ReadHeader {
-    ReadRF64Header { signature: FourCC },
+        signature: FourCC,
-    ReadDS64 {file_size: u64, long_sizes: HashMap<FourCC,u64> },
+        length_field: u32,
-    BeginChunk { signature: FourCC, content_start: u64, content_length: u64 },
+    },
-    Failed { error: Error },
+    ReadRF64Header {
-    FinishParse
+        signature: FourCC,
    },
    ReadDS64 {
        file_size: u64,
        long_sizes: HashMap<FourCC, u64>,
    },
    BeginChunk {
        signature: FourCC,
        content_start: u64,
        content_length: u64,
    },
    Failed {
        error: Error,
    },
    FinishParse,
 }
 #[derive(Debug)]
@@ -36,29 +49,29 @@ enum State {
    ReadyForDS64,
    ReadyForChunk { at: u64, remaining: u64 },
    Error,
-    Complete
+    Complete,
 }
 pub struct Parser<R: Read + Seek> {
    stream: R,
    state: State,
-    ds64state: HashMap<FourCC,u64>
+    ds64state: HashMap<FourCC, u64>,
 }
 #[derive(Debug, PartialEq, Eq)]
 pub struct ChunkIteratorItem {
    pub signature: FourCC,
    pub start: u64,
-    pub length: u64
+    pub length: u64,
 }
 impl<R: Read + Seek> Parser<R> {
    // wraps a stream
    pub fn make(stream: R) -> Result<Self, Error> {
        let newmap: HashMap<FourCC, u64> = HashMap::new();
        let mut the_stream = stream;
        the_stream.seek(Start(0))?;
-        return Ok(Parser {
+        Ok(Parser {
            stream: the_stream,
            state: State::New,
            ds64state: newmap,
@@ -69,33 +82,47 @@ impl<R: Read + Seek> Parser<R> {
    //     self.stream
    // }
-    pub fn into_chunk_iterator(self) -> impl Iterator<Item = Result<ChunkIteratorItem, Error>>{
+    pub fn into_chunk_iterator(self) -> impl Iterator<Item = Result<ChunkIteratorItem, Error>> {
-        self.filter_map({|event|
+        self.filter_map({
-            if let Event::BeginChunk {signature , content_start, content_length } = event {
+            |event| {
-                Some(Ok(ChunkIteratorItem {signature, start: content_start, length: content_length }))
+                if let Event::BeginChunk {
-            } else if let Event::Failed { error }  = event {
+                    signature,
-                Some(Err(error))
+                    content_start,
-            } else {
+                    content_length,
-                None
+                } = event
                {
                    Some(Ok(ChunkIteratorItem {
                        signature,
                        start: content_start,
                        length: content_length,
                    }))
                } else if let Event::Failed { error } = event {
                    Some(Err(error))
                } else {
                    None
                }
            }
        })
    }
-    pub fn into_chunk_list(self) -> Result<Vec<ChunkIteratorItem>,Error> {
+    pub fn into_chunk_list(self) -> Result<Vec<ChunkIteratorItem>, Error> {
        let mut error = Ok(());
-        let chunks = self.into_chunk_iterator()
+        let chunks = self
            .into_chunk_iterator()
            .scan(&mut error, |err, res| match res {
                Ok(ok) => Some(ok),
-                Err(e) => { **err = Err(e); None }
+                Err(e) => {
                    **err = Err(e);
                    None
                }
            })
            .collect();
        error?;
-        Ok( chunks )
+        Ok(chunks)
    }
 }
 impl<R: Read + Seek> Iterator for Parser<R> {
@@ -103,62 +130,59 @@ impl<R: Read + Seek> Iterator for Parser<R> {
    fn next(&mut self) -> Option<Event> {
        let (event, next_state) = self.advance();
        //println!("{:?}", event);
        self.state = next_state;
-        return event;
+        event
    }
 }
 impl<R: Read + Seek> Parser<R> {
-
+    fn parse_header(&mut self) -> Result<(Event, State), io::Error> {
    fn parse_header(&mut self) -> Result<(Event,State),io::Error> {
        let file_sig = self.stream.read_fourcc()?;
        let length = self.stream.read_u32::<LittleEndian>()?;
        let list_sig = self.stream.read_fourcc()?;
-        let event : Event;
+        let event: Event;
        let next_state: State;
        match (file_sig, length, list_sig) {
            (RIFF_SIG, size, WAVE_SIG) => {
                event = Event::ReadHeader {
                    signature: file_sig,
-                    length_field: size
+                    length_field: size,
                };
                next_state = State::ReadyForChunk {
                    at: 12,
                    remaining: (length - 4) as u64,
                };
-            },
+            }
            (RF64_SIG, RF64_SIZE_MARKER, WAVE_SIG) | (BW64_SIG, RF64_SIZE_MARKER, WAVE_SIG) => {
                event = Event::ReadRF64Header {
-                    signature: file_sig
+                    signature: file_sig,
                };
                next_state = State::ReadyForDS64;
-            },
+            }
            _ => {
                event = Event::Failed {
-                    error: Error::HeaderNotRecognized
+                    error: Error::HeaderNotRecognized,
                };
                next_state = State::Error;
            }
        }
-        return Ok( (event, next_state) );
+        Ok((event, next_state))
    }
    fn parse_ds64(&mut self) -> Result<(Event, State), Error> {
-        let at :u64 = 12;
+        let at: u64 = 12;
        let ds64_sig = self.stream.read_fourcc()?;
        let ds64_size = self.stream.read_u32::<LittleEndian>()? as u64;
-        let mut read :u64 = 0;
+        let mut read: u64 = 0;
        if ds64_sig != DS64_SIG {
-            return Err(Error::MissingRequiredDS64);
+            Err(Error::MissingRequiredDS64)
        } else {
            let long_file_size = self.stream.read_u64::<LittleEndian>()?;
            let long_data_size = self.stream.read_u64::<LittleEndian>()?;
@@ -189,7 +213,7 @@ impl<R: Read + Seek> Parser<R> {
            let event = Event::ReadDS64 {
                file_size: long_file_size,
-                long_sizes : self.ds64state.clone(),
+                long_sizes: self.ds64state.clone(),
            };
            let state = State::ReadyForChunk {
@@ -197,19 +221,17 @@ impl<R: Read + Seek> Parser<R> {
                remaining: long_file_size - (4 + 8 + ds64_size),
            };
-            return Ok( (event, state) );
+            Ok((event, state))
        }
    }
-    fn enter_chunk(&mut self, at :u64, remaining: u64) -> Result<(Event, State), io::Error> {
+    fn enter_chunk(&mut self, at: u64, remaining: u64) -> Result<(Event, State), io::Error> {
        let event;
        let state;
        if remaining == 0 {
            event = Event::FinishParse;
            state = State::Complete;
        } else {
            let this_fourcc = self.stream.read_fourcc()?;
            let this_size: u64;
@@ -221,59 +243,52 @@ impl<R: Read + Seek> Parser<R> {
                this_size = self.stream.read_u32::<LittleEndian>()? as u64;
            }
-            let this_displacement :u64 = if this_size % 2 == 1 { this_size + 1 } else { this_size }; 
+            let this_displacement: u64 = if this_size % 2 == 1 {
                this_size + 1
            } else {
                this_size
            };
            self.stream.seek(Current(this_displacement as i64))?;
            event = Event::BeginChunk {
                signature: this_fourcc,
                content_start: at + 8,
-                content_length: this_size
+                content_length: this_size,
            };
            state = State::ReadyForChunk {
                at: at + 8 + this_displacement,
-                remaining: remaining - 8 - this_displacement
+                remaining: remaining - 8 - this_displacement,
            }
        }
-        return Ok( (event, state) );
+        Ok((event, state))
    }
    fn handle_state(&mut self) -> Result<(Option<Event>, State), Error> {
        match self.state {
-            State::New => {
+            State::New => Ok((Some(Event::StartParse), State::ReadyForHeader)),
                return Ok( ( Some(Event::StartParse) , State::ReadyForHeader) );
            },
            State::ReadyForHeader => {
                let (event, state) = self.parse_header()?;
-                return Ok( ( Some(event), state ) );
+                Ok((Some(event), state))
-            },
+            }
            State::ReadyForDS64 => {
                let (event, state) = self.parse_ds64()?;
-                return Ok( ( Some(event), state ) );
+                Ok((Some(event), state))
-            },
+            }
            State::ReadyForChunk { at, remaining } => {
                let (event, state) = self.enter_chunk(at, remaining)?;
-                return Ok( ( Some(event), state ) );
+                Ok((Some(event), state))
            },
            State::Error => {
                return Ok( ( Some(Event::FinishParse) , State::Complete ) );
            },
            State::Complete => {
                return Ok( ( None, State::Complete ) );
            }
            State::Error => Ok((Some(Event::FinishParse), State::Complete)),
            State::Complete => Ok((None, State::Complete)),
        }
    }
    fn advance(&mut self) -> (Option<Event>, State) {
        match self.handle_state() {
-            Ok(( event , state) ) => {
+            Ok((event, state)) => (event, state),
-                return (event, state);
+            Err(error) => (Some(Event::Failed { error }), State::Error),
            },
            Err(error) => {
                return (Some(Event::Failed { error: error.into() } ), State::Error );
            }
        }
    }
 }
--- a/src/raw_chunk_reader.rs
+++ b/src/raw_chunk_reader.rs
@@ -1,73 +0,0 @@
 use std::cmp::min;
 use std::io::SeekFrom;
 use std::io::SeekFrom::{Start, Current, End};
 use std::io::{Seek,Read,Error,ErrorKind};
 // I'm not sure this hasn't already been written somewhere in
 // std but I'm just doing this here as an exercise.
 #[derive(Debug)]
 pub struct RawChunkReader<'a, R: Read + Seek> {
    reader: &'a mut R,
    start: u64,
    length: u64,
    position: u64
 }
 impl<'a,R: Read + Seek> RawChunkReader<'a, R> {
    pub fn new(reader: &'a mut R, start: u64, length: u64) -> Self {
        return Self {
            reader: reader, 
            start: start, 
            length: length, 
            position: 0
        }
    }
    pub fn length(&self) -> u64 {
        self.length
    } 
 }
 impl<'a, R:Read + Seek> Read for RawChunkReader<'_, R> {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error> { 
        if self.position >= self.length {
            Err(Error::new(ErrorKind::UnexpectedEof, "RawChunkReader encountered end-of-file"))
        } else {
            self.reader.seek(Start(self.start + self.position))?;
            let to_read = min(self.length - self.position, buf.len() as u64);
            self.reader.take(to_read).read(buf)?;
            self.position += to_read;
            Ok(to_read as usize)
        }
    }
 }
 impl<'a, R:Read + Seek> Seek for RawChunkReader<'_, R> {
    fn seek(&mut self, seek: SeekFrom) -> Result<u64, std::io::Error> { 
        match seek {
            Start(s) => {
                self.position = s;
                Ok(self.position)
            },
            Current(s) => {
                let new_position = s + self.position as i64;
                if new_position < 0 {
                    Err( Error::new(ErrorKind::Other, "Attempted seek before beginning of chunk") )
                } else {
                    self.position = new_position as u64;
                    Ok(self.position)
                }
            },
            End(s) => {
                let new_position = s + self.length as i64;
                if new_position < 0 {
                    Err( Error::new(ErrorKind::Other, "Attempted seek before beginning of chunk") )
                } else {
                    self.position = new_position as u64;
                    Ok(self.position)
                }
            }
        }
    }
 }
--- a/src/sample.rs
+++ b/src/sample.rs
@@ -0,0 +1,14 @@
 pub use dasp_sample::I24;
 use dasp_sample::Duplex;
 pub trait Sample:
    dasp_sample::Sample + Duplex<u8> + Duplex<i16> + Duplex<I24> + Duplex<i32> + Duplex<f32>
 {
 }
 impl Sample for u8 {}
 impl Sample for i16 {}
 impl Sample for I24 {}
 impl Sample for i32 {}
 impl Sample for f32 {}
--- 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/validation.rs
+++ b/src/validation.rs
@@ -1,144 +0,0 @@
 use super::parser::{Parser};
 use super::fourcc::{FourCC, FMT__SIG,DATA_SIG, BEXT_SIG, JUNK_SIG, FLLR_SIG};
 use super::errors::Error as ParserError;
 use super::wavereader::{WaveReader};
 use std::io::{Read,Seek};
 impl<R:Read + Seek> WaveReader<R> {
    /**
    *  Returns without `Err` if the source meets the minimum standard of 
    *  readability by a permissive client:
    *  1. `fmt` chunk and `data` chunk are present
    *  1. `fmt` chunk appears before `data` chunk
    */
    pub fn validate_readable(&mut self) -> Result<(), ParserError> {
        let (fmt_pos, _)  = self.get_chunk_extent_at_index(FMT__SIG, 0)?;
        let (data_pos, _) = self.get_chunk_extent_at_index(DATA_SIG, 0)?;
        if fmt_pos < data_pos {
            Ok(())
        } else {
            Err( ParserError::FmtChunkAfterData)
        }
    }
    /** 
     * Validate minimal WAVE file
     * 
     * Returns without `Err` the source is `validate_readable` AND
     * 
     *   - Contains _only_ a `fmt` chunk and `data` chunk, with no other chunks present
     *   - 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.
     * 
     * ```
     * # 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()?;
        let chunk_fourccs : Vec<FourCC> = Parser::make(&mut self.inner)?
            .into_chunk_list()?.iter().map(|c| c.signature ).collect();
        if chunk_fourccs == vec![FMT__SIG, DATA_SIG] {
            Ok(())
        } else {
            Err( ParserError::NotMinimalWaveFile )
        }
    }
    /**
     * Validate Broadcast-WAVE file format
     * 
     * Returns without `Err` if `validate_readable()` and file contains a 
     * Broadcast-WAV metadata record (a `bext` chunk).
     * 
     * ```
     * # 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 without `Err` 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)?;
        if start == 0x4000 {
            Ok(())
        } else {
            Err(ParserError::DataChunkNotAligned)
        }
    }
    /**
     * Returns without `Err` 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` (96 bytes)
     *  - `data` is the final chunk
    */
    pub fn validate_prepared_for_append(&mut self) -> Result<(), ParserError> {
        self.validate_readable()?;
        let chunks = Parser::make(&mut self.inner)?.into_chunk_list()?;
        let ds64_space_required = 92;
        let eligible_filler_chunks = chunks.iter()
            .take_while(|c| c.signature == JUNK_SIG || c.signature == FLLR_SIG);
        let filler = eligible_filler_chunks
            .enumerate()
            .fold(0, |accum, (n, item)| if n == 0 { accum + item.length } else {accum + item.length + 8});
        if filler < ds64_space_required {
            Err(ParserError::InsufficientDS64Reservation {expected: ds64_space_required, actual: filler})
        } else {
            let data_pos = chunks.iter().position(|c| c.signature == DATA_SIG);
            match data_pos {
                Some(p) if p == chunks.len() - 1 => Ok(()),
                _ => Err(ParserError::DataChunkNotPreparedForAppend)
            }
        }
    }
 }
--- a/src/wavereader.rs
+++ b/src/wavereader.rs
@@ -1,151 +1,642 @@
 use std::fs::File;
-use super::parser::Parser;
+use std::path::Path;
-use super::fourcc::{FourCC, FMT__SIG, BEXT_SIG, DATA_SIG};
+
-use super::errors::Error as ParserError;
+use std::io::Cursor;
-use super::raw_chunk_reader::RawChunkReader;
+use std::io::SeekFrom;
-use super::chunks::{WaveFmt, Bext};
+use std::io::SeekFrom::Start;
-use super::audio_frame_reader::AudioFrameReader;
+use std::io::{BufReader, Read, Seek};
 use super::bext::Bext;
 use super::chunks::ReadBWaveChunks;
-//use super::validation;
+use super::cue::Cue;
-//use std::io::SeekFrom::{Start};
+use super::errors::Error as ParserError;
-use std::io::{Read, Seek};
+use super::errors::Error;
 use super::fmt::{ChannelDescriptor, ChannelMask, WaveFmt};
 use super::fourcc::{
    FourCC, ReadFourCC, ADTL_SIG, AXML_SIG, BEXT_SIG, CUE__SIG, DATA_SIG, FLLR_SIG, FMT__SIG,
    IXML_SIG, JUNK_SIG, LIST_SIG,
 };
 use super::parser::Parser;
 use super::{CommonFormat, Sample, I24};
 use byteorder::LittleEndian;
 use byteorder::ReadBytesExt;
 use dasp_sample::Sample as _; // Expose to_sample()
 /// 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)
    }
    /// Reads frames from the file into the provided buffer
    ///
    /// The function will attempt to fill the buffer, but will stop without error when the end of
    /// the file is reached.
    ///
    /// The reader will convert from the file's sample type into the buffer's sample type.
    /// Note that no dithering will be applied during sample type conversion,
    /// if dithering is required then it will need to be applied manually.
    ///
    /// The return value is the number of frames read into the buffer.
    pub fn read_frames<S>(&mut self, buffer: &mut [S]) -> Result<u64, Error>
    where
        S: Sample,
    {
        use CommonFormat::*;
        let channel_count = self.format.channel_count as usize;
        let common_format = self.format.common_format();
        let bits_per_sample = self.format.bits_per_sample;
        if buffer.len() % channel_count != 0 {
            return Err(Error::InvalidBufferSize {
                buffer_size: buffer.len(),
                channel_count: self.format.channel_count,
            });
        }
        let position = self.inner.stream_position()? - self.start;
        let frames_requested = (buffer.len() / channel_count) as u64;
        let bytes_per_frame = self.format.block_alignment as u64;
        let frames_remaining = (self.length - position) / bytes_per_frame;
        let frames_to_read = frames_requested.min(frames_remaining);
        let samples_to_read = frames_to_read as usize * channel_count;
        match (common_format, bits_per_sample) {
            (IntegerPCM, 8) => read_into_buffer(samples_to_read, buffer, || {
                Ok(self.inner.read_u8()?.to_sample())
            }),
            (IntegerPCM, 16) => read_into_buffer(samples_to_read, buffer, || {
                Ok(self.inner.read_i16::<LittleEndian>()?.to_sample())
            }),
            (IntegerPCM, 24) => read_into_buffer(samples_to_read, buffer, || {
                Ok(I24::from(self.inner.read_i24::<LittleEndian>()?).to_sample())
            }),
            (IntegerPCM, 32) => read_into_buffer(samples_to_read, buffer, || {
                Ok(self.inner.read_i32::<LittleEndian>()?.to_sample())
            }),
            (IeeeFloatPCM, 32) => read_into_buffer(samples_to_read, buffer, || {
                Ok(self.inner.read_f32::<LittleEndian>()?.to_sample())
            }),
            (_, _) => panic!(
                "Unsupported format, bits per sample {}, channels {}, sample format: {:?}",
                bits_per_sample, channel_count, common_format
            ),
        }?;
        Ok(frames_to_read)
    }
 }
 fn read_into_buffer<S, F>(
    sample_count: usize,
    buffer: &mut [S],
    mut read_fn: F,
 ) -> Result<(), Error>
 where
    F: FnMut() -> Result<S, Error>,
 {
    for output in buffer.iter_mut().take(sample_count) {
        *output = read_fn()?;
    }
    Ok(())
 }
 /// 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::<i32>(1);
 ///
 /// let read = frame_reader.read_frames(&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 = frame_reader.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<BufReader<File>> {
    pub fn open<P: AsRef<Path>>(path: P) -> Result<Self, ParserError> {
        let f = File::open(path)?;
        let inner = BufReader::new(f);
        Self::new(inner)
    }
 }
 impl WaveReader<File> {
-    /**
+    /// Open a file for reading with unbuffered IO.
-     * Open a file for reading.
+    ///
-     * 
+    /// A convenience that opens `path` and calls `Self::new()`
-     * A convenience that opens `path` and calls `Self::new()`
+    pub fn open_unbuffered<P: AsRef<Path>>(path: P) -> Result<Self, ParserError> {
     *   
     */
    pub fn open(path: &str) -> Result<Self, ParserError> {
        let inner = File::open(path)?;
-        return Ok( Self::new(inner)? )
+        Self::new(inner)
    }
 }
 impl<R: Read + Seek> WaveReader<R> {
-    /**
+    /// Wrap a `Read` struct in a new `WaveReader`.
-     * Wrap a `Read` struct in a new `WaveReader`.
+    ///
-     * 
+    /// This is the primary entry point into the `WaveReader` interface. The
-     * 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
-     * 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
-     * WAVE data. For a .wav file, this means it must be at the start of the 
+    /// file.
-     * file.
+    ///
-     * 
+    /// This function does a minimal validation on the provided stream and
-     * This function does a minimal validation on the provided stream and
+    /// will return an `Err(errors::Error)` immediately if there is a structural
-     * will return an `Err(errors::Error)` immediately if there is a structural 
+    /// inconsistency that makes the stream unreadable or if it's missing
-     * inconsistency that makes the stream unreadable or if it's missing 
+    /// essential components that make interpreting the audio data impossible.
-     * essential components that make interpreting the audio data impoossible.
+
-     * 
+    /// ```rust
-     * ```rust
+    /// use std::fs::File;
-     * use std::fs::File;
+    /// use std::io::{Error,ErrorKind};
-     * use std::io::{Error,ErrorKind};
+    /// use bwavfile::{WaveReader, Error as WavError};
-     * use bwavfile::{WaveReader, Error as WavError};
+    ///
-     * 
+    /// let f = File::open("tests/media/error.wav").unwrap();
-     * let f = File::open("tests/media/error.wav").unwrap();
+    ///
-     * 
+    /// let reader = WaveReader::new(f);
-     * let reader = WaveReader::new(f);
+    ///
-     * 
+    /// match reader {
-     * match reader {
+    ///      Ok(_) => panic!("error.wav should not be openable"),
-     *      Ok(_) => panic!("error.wav should not be openable"),
+    ///      Err( WavError::IOError( e ) ) => {
-     *      Err( WavError::IOError( e ) ) => {
+    ///          assert_eq!(e.kind(), ErrorKind::UnexpectedEof)
-     *          assert_eq!(e.kind(), ErrorKind::UnexpectedEof)
+    ///      }
-     *      }
+    ///      Err(e) => panic!("Unexpected error was returned {:?}", e)
-     *      Err(e) => panic!("Unexpected error was returned {:?}", e)
+    /// }
-     * }
+    ///
-     * 
+    /// ```
-     * ```
+    pub fn new(inner: R) -> Result<Self, ParserError> {
     * 
    */
    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;
+        self.inner
    }
-    /**
+    ///
-     * Create an `AudioFrameReader` for reading each audio frame.
+    /// Create an `AudioFrameReader` for reading each audio frame and consume the `WaveReader`.
-    */
+    ///
-    pub fn audio_frame_reader(&mut self) -> Result<AudioFrameReader<RawChunkReader<R>>, ParserError> {
+    pub fn audio_frame_reader(mut self) -> Result<AudioFrameReader<R>, ParserError> {
        let format = self.format()?;
-        let audio_chunk_reader = self.chunk_reader(DATA_SIG, 0)?;
+        let audio_chunk_reader = self.get_chunk_extent_at_index(DATA_SIG, 0)?;
-        Ok(AudioFrameReader::new(audio_chunk_reader, format))
+        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 (_, data_length) = self.get_chunk_extent_at_index(DATA_SIG, 0)?;
        let format = self.format()?;
-        Ok( data_length / (format.block_alignment as u64) )
+        Ok(data_length / (format.block_alignment as u64))
    }
-    /**
+    /// Sample and frame format of this wave file.
-     * Sample and frame format of this wave file.
+    ///
     */
    pub fn format(&mut self) -> Result<WaveFmt, ParserError> {
-        self.chunk_reader(FMT__SIG, 0)?.read_wave_fmt()
+        let (start, _) = self.get_chunk_extent_at_index(FMT__SIG, 0)?;
        self.inner.seek(SeekFrom::Start(start))?;
        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> {
        let mut bext_buff: Vec<u8> = vec![];
        let result = self.read_chunk(BEXT_SIG, 0, &mut bext_buff)?;
        if result > 0 {
            let mut bext_cursor = Cursor::new(bext_buff);
            Ok(Some(bext_cursor.read_bext()?))
        } else {
            Ok(None)
        }
    }
    /// Describe the channels in this file
    ///
    /// Returns a vector of channel descriptors, one for each channel
    ///
    /// ```rust
    /// use bwavfile::WaveReader;
    /// use bwavfile::ChannelMask;
    ///
    /// let mut f = WaveReader::open("tests/media/pt_24bit_51.wav").unwrap();
    ///
    /// let chans = f.channels().unwrap();
    /// assert_eq!(chans[0].index, 0);
    /// assert_eq!(chans[0].speaker, ChannelMask::FrontLeft);
    /// assert_eq!(chans[3].index, 3);
    /// assert_eq!(chans[3].speaker, ChannelMask::LowFrequency);
    /// assert_eq!(chans[4].speaker, ChannelMask::BackLeft);
    /// ```
    pub fn channels(&mut self) -> Result<Vec<ChannelDescriptor>, ParserError> {
        let format = self.format()?;
        let channel_masks: Vec<ChannelMask> = match (format.channel_count, format.extended_format) {
            (1, _) => vec![ChannelMask::FrontCenter],
            (2, _) => vec![ChannelMask::FrontLeft, ChannelMask::FrontRight],
            (n, Some(x)) => ChannelMask::channels(x.channel_mask, n),
            (n, _) => vec![ChannelMask::DirectOut; n as usize],
        };
        Ok((0..format.channel_count)
            .zip(channel_masks)
            .map(|(i, m)| ChannelDescriptor {
                index: i,
                speaker: m,
                adm_track_audio_ids: vec![],
            })
            .collect())
    }
    /// Read cue points.
    ///
    /// ```rust
    /// use bwavfile::WaveReader;
    /// use bwavfile::Cue;
    ///
    /// let mut f = WaveReader::open("tests/media/izotope_test.wav").unwrap();
    /// let cue_points = f.cue_points().unwrap();
    ///
    /// assert_eq!(cue_points.len(), 3);
    /// 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].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].frame, 26711);
    /// assert_eq!(cue_points[2].length, Some(6465));
    /// assert_eq!(cue_points[2].label, Some(String::from("Timed Region")));
    /// assert_eq!(cue_points[2].note, Some(String::from("Region Comment")));
    ///
    /// ```
    pub fn cue_points(&mut self) -> Result<Vec<Cue>, ParserError> {
        let mut cue_buffer: Vec<u8> = vec![];
        let mut adtl_buffer: Vec<u8> = vec![];
        let cue_read = self.read_chunk(CUE__SIG, 0, &mut cue_buffer)?;
        let adtl_read = self.read_list(ADTL_SIG, &mut adtl_buffer)?;
        match (cue_read, adtl_read) {
            (0, _) => Ok(vec![]),
            (_, 0) => Ok(Cue::collect_from(&cue_buffer, None)?),
            (_, _) => Ok(Cue::collect_from(&cue_buffer, Some(&adtl_buffer))?),
        }
    }
    /// Read iXML data.
    ///
    /// The iXML data will be appended to `buffer`.
    /// 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> {
        self.read_chunk(IXML_SIG, 0, buffer)
    }
    /// Read AXML data.
    ///
    /// The axml data will be appended to `buffer`. By convention this will
    /// generally be ADM metadata.
    ///
    /// 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> {
        self.read_chunk(AXML_SIG, 0, buffer)
    }
    /**
-     * The Broadcast-WAV metadata record for this file.
+     * Validate file is readable.
     *
     *  `Ok(())` if the source meets the minimum standard of
     *  readability by a permissive client:
     *  - `fmt` chunk and `data` chunk are present
     *  - `fmt` chunk appears before `data` chunk
     */
-    pub fn broadcast_extension(&mut self) -> Result<Bext, ParserError> {
+    pub fn validate_readable(&mut self) -> Result<(), ParserError> {
-        self.chunk_reader(BEXT_SIG, 0)?.read_bext()
+        let (fmt_pos, _) = self.get_chunk_extent_at_index(FMT__SIG, 0)?;
-    }
+        let (data_pos, _) = self.get_chunk_extent_at_index(DATA_SIG, 0)?;
 }
-impl<R:Read+Seek> WaveReader<R> { /* Private Implementation */
+        if fmt_pos < data_pos {
-
+            Ok(())
    fn chunk_reader(&mut self, signature: FourCC, at_index: u32) -> Result<RawChunkReader<R>, ParserError> {
        let (start, length) = self.get_chunk_extent_at_index(signature, at_index)?;
        Ok( RawChunkReader::new(&mut self.inner, start, length) )
    } 
    pub fn get_chunk_extent_at_index(&mut self, fourcc: FourCC, index: u32) -> Result<(u64,u64), ParserError> {
        let p = Parser::make(&mut self.inner)?.into_chunk_list()?;
        if let Some(chunk) = p.iter().filter(|item| item.signature == fourcc).nth(index as usize) {
            Ok ((chunk.start, chunk.length))
        } else {
-            Err( ParserError::ChunkMissing { signature : fourcc })
+            Err(ParserError::FmtChunkAfterData)
        }
    }
    /// 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()?;
        let chunk_fourccs: Vec<FourCC> = Parser::make(&mut self.inner)?
            .into_chunk_list()?
            .iter()
            .map(|c| c.signature)
            .collect();
        if chunk_fourccs == vec![FMT__SIG, DATA_SIG] {
            Ok(()) /* FIXME: finish implementation */
        } else {
            Err(ParserError::NotMinimalWaveFile)
        }
    }
    /// 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.
    pub fn validate_data_chunk_alignment(&mut self) -> Result<(), ParserError> {
        self.validate_readable()?;
        let (start, _) = self.get_chunk_extent_at_index(DATA_SIG, 0)?;
        if start == 0x4000 {
            Ok(())
        } else {
            Err(ParserError::DataChunkNotAligned)
        }
    }
    /// 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()?;
        let chunks = Parser::make(&mut self.inner)?.into_chunk_list()?;
        let ds64_space_required = 92;
        let eligible_filler_chunks = chunks
            .iter()
            .take_while(|c| c.signature == JUNK_SIG || c.signature == FLLR_SIG);
        let filler = eligible_filler_chunks
            .enumerate()
            .fold(0, |accum, (n, item)| {
                if n == 0 {
                    accum + item.length
                } else {
                    accum + item.length + 8
                }
            });
        if filler < ds64_space_required {
            Err(ParserError::InsufficientDS64Reservation {
                expected: ds64_space_required,
                actual: filler,
            })
        } else {
            let data_pos = chunks.iter().position(|c| c.signature == DATA_SIG);
            match data_pos {
                Some(p) if p == chunks.len() - 1 => Ok(()),
                _ => Err(ParserError::DataChunkNotPreparedForAppend),
            }
        }
    }
 }
 impl<R: Read + Seek> WaveReader<R> {
    // Private implementation
    //
    // As time passes this get smore obnoxious because I haven't implemented recursive chunk
    // parsing in the raw parser and I'm working around it
    // fn chunk_reader(&mut self, signature: FourCC, at_index: u32) -> Result<RawChunkReader<R>, ParserError> {
    //     let (start, length) = self.get_chunk_extent_at_index(signature, at_index)?;
    //     Ok( RawChunkReader::new(&mut self.inner, start, length) )
    // }
    fn read_list(&mut self, ident: FourCC, buffer: &mut Vec<u8>) -> Result<usize, ParserError> {
        if let Some(index) = self.get_list_form(ident)? {
            self.read_chunk(LIST_SIG, index, buffer)
        } else {
            Ok(0)
        }
    }
    fn read_chunk(
        &mut self,
        ident: FourCC,
        at: u32,
        buffer: &mut Vec<u8>,
    ) -> Result<usize, ParserError> {
        match self.get_chunk_extent_at_index(ident, at) {
            Ok((start, length)) => {
                buffer.resize(length as usize, 0x0);
                self.inner.seek(SeekFrom::Start(start))?;
                self.inner.read(buffer).map_err(ParserError::IOError)
            }
            Err(ParserError::ChunkMissing { signature: _ }) => Ok(0),
            Err(any) => Err(any),
        }
    }
    /// Extent of every chunk with the given fourcc
    fn get_chunks_extents(&mut self, fourcc: FourCC) -> Result<Vec<(u64, u64)>, ParserError> {
        let p = Parser::make(&mut self.inner)?.into_chunk_list()?;
        Ok(p.iter()
            .filter(|item| item.signature == fourcc)
            .map(|item| (item.start, item.length))
            .collect())
    }
    /// Index of first LIST for with the given FORM fourcc
    fn get_list_form(&mut self, fourcc: FourCC) -> Result<Option<u32>, ParserError> {
        for (n, (start, _)) in self.get_chunks_extents(LIST_SIG)?.iter().enumerate() {
            self.inner.seek(SeekFrom::Start(*start))?;
            let this_fourcc = self.inner.read_fourcc()?;
            if this_fourcc == fourcc {
                return Ok(Some(n as u32));
            }
        }
        Ok(None)
    }
    fn get_chunk_extent_at_index(
        &mut self,
        fourcc: FourCC,
        index: u32,
    ) -> Result<(u64, u64), ParserError> {
        if let Some((start, length)) = self.get_chunks_extents(fourcc)?.get(index as usize) {
            Ok((*start, *length))
        } else {
            Err(ParserError::ChunkMissing { signature: fourcc })
        }
    }
 }
 #[test]
 fn test_list_form() {
    let mut f = WaveReader::open("tests/media/izotope_test.wav").unwrap();
    let mut buf: Vec<u8> = vec![];
    f.read_list(ADTL_SIG, &mut buf).unwrap();
    assert_ne!(buf.len(), 0);
 }
--- a/src/wavewriter.rs
+++ b/src/wavewriter.rs
@@ -1,102 +1,621 @@
 use std::io::{Write, Seek, SeekFrom};
 use std::fs::File;
-use std::io::Cursor;
+use std::io::{BufWriter, Cursor, Seek, SeekFrom, Write};
 use std::path::Path;
-use super::errors::Error;
+use crate::CommonFormat;
-use super::chunks::{WaveFmt, Bext, WriteBWaveChunks};
+
-use super::fourcc::{FourCC, RIFF_SIG, WAVE_SIG, FMT__SIG, JUNK_SIG, BEXT_SIG, DATA_SIG, WriteFourCC};
+use super::fmt::WaveFmt;
 use super::fourcc::{
    FourCC, WriteFourCC, AXML_SIG, BEXT_SIG, DATA_SIG, DS64_SIG, ELM1_SIG, FMT__SIG, IXML_SIG,
    JUNK_SIG, RF64_SIG, RIFF_SIG, WAVE_SIG,
 };
 use super::{Error, Sample, I24};
 //use super::common_format::CommonFormat;
 use super::bext::Bext;
 use super::chunks::WriteBWaveChunks;
 use byteorder::LittleEndian;
 use byteorder::WriteBytesExt;
-struct WaveWriter<W> where W: Write + Seek {
+/// Write audio frames to a `WaveWriter`.
-    inner : W
+///
 ///
 pub struct AudioFrameWriter<W>
 where
    W: Write + Seek,
 {
    inner: WaveChunkWriter<W>,
    write_buffer: Vec<u8>,
 }
-impl WaveWriter<File> {
+impl<W> AudioFrameWriter<W>
-    pub fn create(path : &str, format:WaveFmt, broadcast_extension: Option<Bext>) -> Result<Self,Error> {
+where
-        let inner = File::create(path)?;
+    W: Write + Seek,
-        Self::make(inner, format, broadcast_extension)
+{
-    }
+    fn new(inner: WaveChunkWriter<W>) -> Self {
-}
+        AudioFrameWriter {
-
+            inner,
-impl<W:Write + Seek> WaveWriter<W> {
+            write_buffer: Vec::new(),
-
+        }
    pub fn make(inner : W, format: WaveFmt, broadcast_extension: Option<Bext>) -> Result<Self, Error> {
        let mut retval = Self { inner };
        retval.prepare_created(format, broadcast_extension)?;
        Ok(retval) 
    }
-    fn prepare_created(&mut self, format : WaveFmt, broadcast_extension: Option<Bext>) -> Result<(),Error> {
+    /// Write interleaved samples in `buffer`
-        self.inner.write_fourcc(RIFF_SIG)?;
+    ///
-        self.inner.write_u32::<LittleEndian>(4)?;
+    /// The writer will convert from the buffer's sample type into the file's sample type.
-        self.inner.write_fourcc(WAVE_SIG)?;
+    /// Note that no dithering will be applied during sample type conversion,
-        let mut written : u64 = 4;
+    /// if dithering is required then it will need to be applied manually.
    pub fn write_frames<S>(&mut self, buffer: &[S]) -> Result<(), Error>
    where
        S: Sample,
    {
        let format = &self.inner.inner.format;
        let channel_count = format.channel_count as usize;
-        let ds64_reservation = [0u8; 92];
+        if buffer.len() % channel_count != 0 {
-
+            return Err(Error::InvalidBufferSize {
-        written += self.primitive_append_chunk(JUNK_SIG, &ds64_reservation)?;
+                buffer_size: buffer.len(),
-
+                channel_count: format.channel_count,
-        let fmt_data : Vec<u8> = {
+            });
            let mut c = Cursor::new(vec![]);
            c.write_wave_fmt(&format)?;
            c.into_inner()
        };
        written += self.primitive_append_chunk(FMT__SIG, &fmt_data)?;
        if let Some(bext) = broadcast_extension {
            let mut b = Cursor::new(vec![]);
            b.write_bext(&bext)?;
            let data = b.into_inner();
            written += self.primitive_append_chunk(BEXT_SIG, &data)?;
        }
-        // show our work
+        let frame_count = buffer.len() / channel_count;
-        let desired_data_alignment = 0x4000;
+        let write_buffer_size = format.block_alignment as usize * frame_count;
-        let data_fourcc_start = desired_data_alignment - 8;
+        self.write_buffer.resize(write_buffer_size, 0);
        let current_position_from_start = written + 8;
        let data_pad_length = data_fourcc_start - current_position_from_start;
-        let data_padding = vec![0u8; data_pad_length as usize];
+        let mut write_cursor = Cursor::new(&mut self.write_buffer);
-        written += self.primitive_append_chunk(JUNK_SIG, &data_padding)?;
+        let common_format = format.common_format();
        let bits_per_sample = format.bits_per_sample;
-        self.inner.write_fourcc(DATA_SIG)?;
+        match (common_format, bits_per_sample) {
-        self.inner.write_u32::<LittleEndian>(0)?;
+            (_, 8) => {
-
+                for sample in buffer {
-        written += 8;
+                    write_cursor.write_u8(sample.to_sample())?
-        self.inner.seek(SeekFrom::Start(4))?;
+                }
-        self.inner.write_u32::<LittleEndian>(written as u32)?;
+            }
            (_, 16) => {
                for sample in buffer {
                    write_cursor.write_i16::<LittleEndian>(sample.to_sample())?
                }
            }
            (_, 24) => {
                for sample in buffer {
                    write_cursor.write_i24::<LittleEndian>(sample.to_sample::<I24>().inner())?
                }
            }
            (CommonFormat::IntegerPCM, 32) => {
                for sample in buffer {
                    write_cursor.write_i32::<LittleEndian>(sample.to_sample())?
                }
            }
            (CommonFormat::IeeeFloatPCM, 32) => {
                for sample in buffer {
                    write_cursor.write_f32::<LittleEndian>(sample.to_sample())?
                }
            }
            (_, _) => panic!(
                "Unrecognized format, bits per sample {}, channels {}, sample format {:?}",
                bits_per_sample, channel_count, common_format
            ),
        }
        self.inner.write_all(&self.write_buffer)?;
        Ok(())
    }
-    fn primitive_append_chunk(&mut self, signature: FourCC, data: &[u8]) -> Result<u64,Error> {
+    /// Finish writing audio frames and unwrap the inner `WaveWriter`.
-        assert!((data.len() as u32) < u32::MAX, 
+    ///
-            "primitive_append_chunk called with a long data buffer");
+    /// 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()
    }
 }
-        self.inner.write_fourcc(signature)?;
+/// Write a wave data chunk.
-        self.inner.write_u32::<LittleEndian>(data.len() as u32)?;
+///
-        self.inner.write_all(&data)?;
+/// `WaveChunkWriter` implements `Write` and as bytes are written to it,
-        let padding : u64 = data.len() as u64 % 2;
+///
-        if padding == 1 {
+/// ### Important!
-            self.inner.write_u8(0)?;
+///
 /// 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,
 }
 impl<W> WaveChunkWriter<W>
 where
    W: Write + Seek,
 {
    fn begin(mut inner: WaveWriter<W>, ident: FourCC) -> Result<Self, Error> {
        let length: u64 = 0;
        inner.inner.write_fourcc(ident)?;
        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 {
            ident,
            inner,
            content_start_pos,
            length,
        })
    }
    fn end(mut self) -> Result<WaveWriter<W>, Error> {
        if self.length % 2 == 1 {
            self.inner.inner.seek(SeekFrom::End(0))?;
            self.inner.inner.write_u8(0)?;
            self.inner.increment_form_length(1)?;
        }
        Ok(self.inner)
    }
    fn increment_chunk_length(&mut self, amount: u64) -> Result<(), std::io::Error> {
        self.length += amount;
        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 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(8 + data.len() as u64 + padding)
+        Ok(())
    }
 }
 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.inner.increment_form_length(written as u64)?;
        self.increment_chunk_length(written as u64)?;
        Ok(written)
    }
    fn flush(&mut self) -> Result<(), std::io::Error> {
        self.inner.inner.flush()
    }
 }
 /// 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_mono(48000, 24);
 /// let w = WaveWriter::new(&mut cursor, format).unwrap();
 ///
 /// let mut frame_writer = w.audio_frame_writer().unwrap();
 ///
 /// frame_writer.write_frames(&[0i32]).unwrap();
 /// frame_writer.write_frames(&[0i32]).unwrap();
 /// frame_writer.write_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,
 }
 const DS64_RESERVATION_LENGTH: u32 = 96;
 impl WaveWriter<BufWriter<File>> {
    /// Create a new Wave file at `path`.
    pub fn create<P: AsRef<Path>>(path: P, format: WaveFmt) -> Result<Self, Error> {
        let f = File::create(path)?;
        let b = BufWriter::new(f);
        Self::new(b, format)
    }
 }
 impl WaveWriter<File> {
    /// Creare a new Wave file with unbuffered IO at `path`
    pub fn create_unbuffered<P: AsRef<Path>>(path: P, format: WaveFmt) -> Result<Self, Error> {
        let f = File::create(path)?;
        Self::new(f, format)
    }
 }
 impl<W> WaveWriter<W>
 where
    W: Write + Seek,
 {
    /// Wrap a writer in a Wave writer.
    ///
    /// The inner writer will immediately have a RIFF WAVE file header
    /// written to it along with the format descriptor (and possibly a `fact`
    /// chunk if appropriate).
    pub fn new(mut inner: W, format: WaveFmt) -> Result<Self, Error> {
        inner.write_fourcc(RIFF_SIG)?;
        inner.write_u32::<LittleEndian>(0)?;
        inner.write_fourcc(WAVE_SIG)?;
        let mut retval = WaveWriter {
            inner,
            form_length: 0,
            is_rf64: false,
            format,
        };
        retval.increment_form_length(4)?;
        // 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)
    }
    fn write_chunk(&mut self, ident: FourCC, data: &[u8]) -> Result<(), Error> {
        self.inner.seek(SeekFrom::End(0))?;
        self.inner.write_fourcc(ident)?;
        assert!(data.len() < u32::MAX as usize);
        self.inner.write_u32::<LittleEndian>(data.len() as u32)?;
        self.inner.write_all(data)?;
        if data.len() % 2 == 0 {
            self.increment_form_length(8 + data.len() as u64)?;
        } else {
            self.inner.write_u8(0)?;
            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
        let framing = 0x4000;
        let lip = self.inner.seek(SeekFrom::End(0))?;
        let to_add = framing - (lip % framing) - 16;
        let mut chunk = self.chunk(ELM1_SIG)?;
        let buf = vec![0u8; to_add as usize];
        chunk.write_all(&buf)?;
        let closed = chunk.end()?;
        let inner = closed.chunk(DATA_SIG)?;
        Ok(AudioFrameWriter::new(inner))
    }
    /// 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 += 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]
-fn test_chunk_append() -> Result<(), Error> {
+fn test_new() {
-    let mut test :Vec<u8> = vec![];
+    use super::fourcc::ReadFourCC;
-    let mut cursor = Cursor::new(test);
+    use byteorder::ReadBytesExt;
-    let f = WaveFmt::new_pcm(48000, 16, 1);
+    use std::io::Cursor;
    let mut w = WaveWriter::make(cursor, f, None)?;
    let mut cursor = Cursor::new(vec![0u8; 0]);
    let format = WaveFmt::new_pcm_mono(4800, 24);
    WaveWriter::new(&mut cursor, format).unwrap();
    cursor.seek(SeekFrom::Start(0)).unwrap();
-    Ok(())
+    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, 4 + 8 + junk_size + 8 + fmt_size);
 }
 #[test]
 fn test_write_audio() {
    use super::fourcc::ReadFourCC;
    use byteorder::ReadBytesExt;
    use std::io::Cursor;
    let mut cursor = Cursor::new(vec![0u8; 0]);
    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_frames(&[0i32]).unwrap();
    frame_writer.write_frames(&[0i32]).unwrap();
    frame_writer.write_frames(&[0i32]).unwrap();
    frame_writer.end().unwrap();
    cursor.seek(SeekFrom::Start(0)).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); //4
    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_frames(&[0i32]).unwrap();
    frame_writer.write_frames(&[0i32]).unwrap();
    frame_writer.write_frames(&[0i32]).unwrap();
    frame_writer.end().unwrap();
 }
 // NOTE! This test of RF64 writing takes several minutes to complete in debug builds
 #[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_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/.DS_Store
+++ b/tests/.DS_Store
--- a/tests/arch_audacity_media.zip
+++ b/tests/arch_audacity_media.zip
--- a/tests/arch_pt_media.zip
+++ b/tests/arch_pt_media.zip
--- a/tests/create_test_media.sh
+++ b/tests/create_test_media.sh
@@ -1,15 +1,10 @@
 #!/bin/zsh
 mkdir -p media
 cd media
 touch media/error.wav
-touch error.wav
+tar xzf test_media.tgz
 unzip ../arch_pt_media.zip
 unzip ../arch_audacity_media.zip
 unzip ../arch_ff_media.zip
 rm -rf __MACOSX
 # create a silent bext wave file with fixture metadata and a time refernce starting at
 # one minute
--- a/tests/media_ffprobe_result.json
+++ b/tests/media_ffprobe_result.json
@@ -1,4 +1,57 @@
 [
  {
    "streams": [
      {
        "index": 0,
        "codec_name": "pcm_s24le",
        "codec_long_name": "PCM signed 24-bit little-endian",
        "codec_type": "audio",
        "codec_time_base": "1/48000",
        "codec_tag_string": "[1][0][0][0]",
        "codec_tag": "0x0001",
        "sample_fmt": "s32",
        "sample_rate": "48000",
        "channels": 2,
        "channel_layout": "stereo",
        "bits_per_sample": 24,
        "r_frame_rate": "0/0",
        "avg_frame_rate": "0/0",
        "time_base": "1/48000",
        "duration_ts": 4800,
        "duration": "0.100000",
        "bit_rate": "2304000",
        "bits_per_raw_sample": "24",
        "disposition": {
          "default": 0,
          "dub": 0,
          "original": 0,
          "comment": 0,
          "lyrics": 0,
          "karaoke": 0,
          "forced": 0,
          "hearing_impaired": 0,
          "visual_impaired": 0,
          "clean_effects": 0,
          "attached_pic": 0,
          "timed_thumbnails": 0
        }
      }
    ],
    "format": {
      "filename": "tests/media/ff_pink.wav",
      "nb_streams": 1,
      "nb_programs": 0,
      "format_name": "wav",
      "format_long_name": "WAV / WAVE (Waveform Audio)",
      "duration": "0.100000",
      "size": "28902",
      "bit_rate": "2312160",
      "probe_score": 99,
      "tags": {
        "encoder": "Lavf58.45.100"
      }
    }
  },
  {
    "streams": [
      {
--- a/tests/ffprobe_media_tests.rs
+++ b/tests/ffprobe_media_tests.rs
@@ -1,50 +1,53 @@
 extern crate serde_json;
 use core::fmt::Debug;
-use serde_json::{Value, from_str};
+use serde_json::{from_str, Value};
 use std::fs::File;
 use std::io::Read;
 use bwavfile::WaveReader;
-// This seems rickety but we're going with it
+// Media Tests
-fn assert_match_stream<T>(stream_key: &str, 
+//
-                    other: impl Fn(&mut WaveReader<File>) -> T)
+// These tests compare metadata and format data read by ffprobe with the same values
-                    where T: PartialEq + Debug,
+// as read by `WaveReader`.
                          T: Into<Value>
                    {
-    let mut json_file = File::open("tests/media_ffprobe_result.json").unwrap();
+// This is rickety but we're going with it
 fn assert_match_stream<T>(stream_key: &str, other: impl Fn(&mut WaveReader<File>) -> T)
 where
    T: PartialEq + Debug,
    T: Into<Value>,
 {
    let mut json_file = File::open("tests/ffprobe_media_tests.json").unwrap();
    let mut s = String::new();
    json_file.read_to_string(&mut s).unwrap();
-    if let Value::Array(v) = from_str(&mut s).unwrap() { /* */
+    if let Value::Array(v) = from_str(&mut s).unwrap() {
        /* */
        v.iter()
-            .filter(|value| {
+            .filter(|value| !value["format"]["filename"].is_null())
                !value["format"]["filename"].is_null()
            })
            .for_each(|value| {
-                let filen : &str = value["format"]["filename"].as_str().unwrap();
+                let filen: &str = value["format"]["filename"].as_str().unwrap();
-                let json_value : &Value = &value["streams"][0][stream_key];
+                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);
+                println!("asserting {} for {}", stream_key, filen);
                assert_eq!(Into::<Value>::into(wavfile_value), *json_value);
            })
    }
 }
 #[test]
 fn test_frame_count() {
-    assert_match_stream("duration_ts", |w| w.frame_length().unwrap() );
+    assert_match_stream("duration_ts", |w| w.frame_length().unwrap());
 }
 #[test]
 fn test_sample_rate() {
-    assert_match_stream("sample_rate", |w| format!("{}", w.format().unwrap().sample_rate) );
+    assert_match_stream("sample_rate", |w| {
        format!("{}", w.format().unwrap().sample_rate)
    });
 }
 #[test]
 fn test_channel_count() {
-    assert_match_stream("channels", |w| w.format().unwrap().channel_count );
+    assert_match_stream("channels", |w| w.format().unwrap().channel_count);
 }
--- a/tests/integration_test.rs
+++ b/tests/integration_test.rs
@@ -1,16 +1,16 @@
 extern crate bwavfile;
-use bwavfile::WaveReader;
+use bwavfile::ChannelMask;
 use bwavfile::Error;
 use bwavfile::WaveReader;
 use bwavfile::I24;
 #[test]
 fn test_open() {
    let path = "tests/media/ff_silence.wav";
    match WaveReader::open(path) {
-        Ok(_) => {
+        Ok(_) => (),
            ()
        }, 
        Err(x) => {
            assert!(false, "Opened error.wav with unexpected error {:?}", x)
        }
@@ -18,7 +18,7 @@ fn test_open() {
 }
 #[test]
-fn test_format_silence() -> Result<(),Error> {
+fn test_format_silence() -> Result<(), Error> {
    let path = "tests/media/ff_silence.wav";
    let mut w = WaveReader::open(path)?;
@@ -27,8 +27,8 @@ fn test_format_silence() -> Result<(),Error> {
    assert_eq!(format.sample_rate, 44100);
    assert_eq!(format.channel_count, 1);
-    assert_eq!(format.tag, 1);
+    assert_eq!(format.tag as u16, 1);
-    Ok( () )
+    Ok(())
 }
 #[test]
@@ -43,18 +43,18 @@ fn test_format_error() {
 }
 #[test]
-fn test_frame_count() -> Result<(),Error> {
+fn test_frame_count() -> Result<(), Error> {
    let path = "tests/media/ff_silence.wav";
    let mut w = WaveReader::open(path)?;
    let l = w.frame_length()?;
    assert_eq!(l, 44100);
-    Ok( () )
+    Ok(())
 }
 #[test]
-fn test_minimal_wave()  {
+fn test_minimal_wave() {
    let path = "tests/media/ff_silence.wav";
    let mut w = WaveReader::open(path).expect("Failure opening file");
@@ -75,3 +75,147 @@ fn test_minimal_wave()  {
        assert!(true);
    }
 }
 #[test]
 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::<i16>(1);
    let mut reader = w.audio_frame_reader().unwrap();
    assert_eq!(reader.read_frames(&mut buffer).unwrap(), 1);
    assert_eq!(buffer[0], -2823_i16);
    assert_eq!(reader.read_frames(&mut buffer).unwrap(), 1);
    assert_eq!(buffer[0], 2012_i16);
    assert_eq!(reader.read_frames(&mut buffer).unwrap(), 1);
    assert_eq!(buffer[0], 4524_i16);
 }
 #[test]
 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::<I24>(1);
    let mut reader = w.audio_frame_reader().unwrap();
    assert_eq!(reader.read_frames(&mut buffer).unwrap(), 1);
    assert_eq!(buffer[0], I24::from(332702));
    assert_eq!(buffer[1], I24::from(3258791));
    assert_eq!(reader.read_frames(&mut buffer).unwrap(), 1);
    assert_eq!(buffer[0], I24::from(-258742)); // 0x800000 = 8388608 // 8129866 - 8388608
    assert_eq!(buffer[1], I24::from(0x0D7EF9));
    assert_eq!(reader.locate(100).unwrap(), 100);
    assert_eq!(reader.read_frames(&mut buffer).unwrap(), 1);
    assert_eq!(buffer[0], I24::from(0x109422));
    assert_eq!(buffer[1], I24::from(-698901)); // 7689707 - 8388608
 }
 #[test]
 fn test_channels_stereo() {
    let path = "tests/media/ff_pink.wav";
    let mut w = WaveReader::open(path).expect("Failure opening test file");
    let channels = w.channels().unwrap();
    assert_eq!(channels.len(), 2);
    assert_eq!(channels[0].index, 0);
    assert_eq!(channels[1].index, 1);
    assert_eq!(channels[0].speaker, ChannelMask::FrontLeft);
    assert_eq!(channels[1].speaker, ChannelMask::FrontRight);
 }
 #[test]
 fn test_channels_mono_no_extended() {
    let path = "tests/media/audacity_16bit.wav";
    let mut w = WaveReader::open(path).expect("Failure opening test file");
    let channels = w.channels().unwrap();
    assert_eq!(channels.len(), 1);
    assert_eq!(channels[0].index, 0);
    assert_eq!(channels[0].speaker, ChannelMask::FrontCenter);
 }
 #[test]
 fn test_channels_stereo_no_fmt_extended() {
    let path = "tests/media/pt_24bit_stereo.wav";
    let mut w = WaveReader::open(path).expect("Failure opening test file");
    let channels = w.channels().unwrap();
    assert_eq!(channels.len(), 2);
    assert_eq!(channels[0].index, 0);
    assert_eq!(channels[1].index, 1);
    assert_eq!(channels[0].speaker, ChannelMask::FrontLeft);
    assert_eq!(channels[1].speaker, ChannelMask::FrontRight);
 }
 ///See issue 6 and 7
 #[test]
 fn test_frame_reader_consumes_reader() {
    // Issue #6
    use bwavfile::{AudioFrameReader, WaveFmt};
    use std::fs::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();
            Ok((format, frame_reader))
        } else {
            Err(())
        }
    }
    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/arch_ff_media.zip
+++ b/tests/arch_ff_media.zip
Author	SHA1	Message	Date
Jamie Hardt	8e341990fa	Rustfmt	2024-12-10 17:41:50 -08:00
Jamie Hardt	2dfddff0b5	Update Cargo.toml Nudge version	2023-06-02 21:04:12 -07:00
Jamie Hardt	aa8365a38d	Documentation	2023-06-02 20:37:44 -07:00
Jamie Hardt	b8a428e757	Documentation and exposure Documentation in the fmt module has been improved. ReadWaveData trait is now public. The	2023-06-02 11:06:53 -07:00
Jamie Hardt	c1d2b2c836	Documentation fixes. Made a trait public.	2023-06-02 09:53:23 -07:00
Jamie Hardt	f41b7ea575	Update lib.rs	2023-06-02 08:53:27 -07:00
Jamie Hardt	9a62bdc375	Update issue templates	2023-06-02 08:47:38 -07:00
Jamie Hardt	368ef4366d	Delete bwavefile.code-workspace	2023-06-02 08:42:55 -07:00
Jamie Hardt	bfa51a4e4c	Update issue templates	2023-06-02 08:42:27 -07:00
Jamie Hardt	4270dc9866	Merge pull request #16 from iluvcapra/release Committing lock file	2023-05-26 22:31:27 -07:00
Jamie Hardt	92d76289e4	Update README.md	2023-05-26 12:29:28 -07:00
Jamie Hardt	15f9a240c0	Committing lock file	2023-05-22 18:04:53 -07:00
Jamie Hardt	da2e6f61ee	Merge branch 'master' of https://github.com/iluvcapra/bwavfile	2023-05-22 17:53:44 -07:00
Jamie Hardt	eff4fe199f	Update Cargo.toml Bumping version 2.0.0	2023-05-22 17:45:28 -07:00
Jamie Hardt	4e84756417	Merge pull request #14 from irh/performance-improvements Performance improvements	2023-05-22 17:44:43 -07:00
Ian Hobson	5592e87f0e	Update Cargo.toml author list	2023-05-19 11:05:22 +02:00
Ian Hobson	72fea1a493	Expose and rename the supported wave tags and UUIDs	2023-05-19 10:57:39 +02:00
Ian Hobson	bd09ed207a	Re-use the write buffer between calls to write_frames This resulted in a ~10% speedup in test runs of the deinter example.	2023-05-19 10:57:39 +02:00
Ian Hobson	3d1826007e	Avoid panics when incorrect buffer sizes are provided to read/write_frames	2023-05-19 10:57:39 +02:00
Ian Hobson	3400778991	Introduce generic read_frames and write_frames functions	2023-05-19 10:57:39 +02:00
Ian Hobson	7290d5ec81	Rework the deinter example, create writers before reading through the input file	2023-05-19 10:57:39 +02:00
Ian Hobson	0074e13bff	Avoid flushing output on each write	2023-05-19 10:57:39 +02:00
Ian Hobson	60a3eac072	clippy: Collapse nested else/if into else if	2023-05-19 10:57:39 +02:00
Ian Hobson	0c46a0e21f	clippy: Remove unnecessary import	2023-05-19 10:57:39 +02:00
Ian Hobson	8d34a517fc	clippy: Don't warn about the LUFS type name	2023-05-19 10:57:39 +02:00
Ian Hobson	86ffd4310a	clippy: Prefer `if let Some(_)` over Option::map	2023-05-19 10:57:39 +02:00
Ian Hobson	ceb8c4371e	clippy: Avoid unnecessary conversion	2023-05-19 10:57:39 +02:00
Ian Hobson	22e8dc79d1	clippy: Use a slice argument instead of the owned equivalent	2023-05-19 10:57:39 +02:00
Ian Hobson	f6f4869b5b	clippy: Avoid () as return type	2023-05-19 10:57:39 +02:00
Ian Hobson	cf5ec121da	clippy: Avoid unnecessary closures	2023-05-19 10:57:39 +02:00
Ian Hobson	7c01778029	clippy: Use .write_u8() when writing a single value	2023-05-19 10:57:39 +02:00
Ian Hobson	4e370c57c1	clippy: Use .write_all() when writing a slice	2023-05-19 10:57:39 +02:00
Ian Hobson	fc3b411717	clippy: Use .read_exact() when reading a fixed number of bytes	2023-05-19 10:57:39 +02:00
Ian Hobson	4d81ef36cd	clippy: Use the += operator	2023-05-19 10:57:39 +02:00
Ian Hobson	651009c96a	clippy: Avoid making unnecessary references	2023-05-19 10:57:39 +02:00
Ian Hobson	566ad07247	clippy: Remove unnecessary use of .into()	2023-05-19 10:57:39 +02:00
Ian Hobson	6989520743	clippy: Use Vec::get() instead of iter().nth()	2023-05-19 10:57:39 +02:00
Ian Hobson	b6c20ae410	clippy: Remove unnecessary casts	2023-05-19 10:57:39 +02:00
Ian Hobson	9eb655cd27	clippy: Remove unnecessary use of `return`	2023-05-19 10:57:39 +02:00
Ian Hobson	bbd84b7bbb	clippy: Remove unnecessary uses of `?`	2023-05-19 10:57:39 +02:00
Ian Hobson	04d282ccd6	clippy: Use Avoid unnecessary indexing in for loops	2023-05-19 10:57:39 +02:00
Ian Hobson	1234c897a3	clippy: Use stream_position() to get current position	2023-05-19 10:57:39 +02:00
Ian Hobson	313f5408ca	Update the comment in wave-deinter.rs	2023-05-19 10:57:38 +02:00
Ian Hobson	e1b93b24ad	Run cargo format	2023-05-19 10:57:18 +02:00
Ian Hobson	369d261ba0	Fix build warnings	2023-05-19 10:57:18 +02:00
Jamie Hardt	72d3c4abef	Tweaked documentation	2023-05-18 10:41:18 -07:00
Jamie Hardt	6191adf30a	Removed dead comment	2023-05-18 10:19:46 -07:00
Jamie Hardt	a69755d8aa	Fixed misspelling	2023-05-18 10:18:57 -07:00
Jamie Hardt	11d701b687	More readme tweak	2023-05-18 10:16:33 -07:00
Jamie Hardt	0fe11a48ee	Reqording readme	2023-05-18 09:54:12 -07:00
Jamie Hardt	4877aa0458	Update rust.yml Adding clippy	2023-05-18 09:23:15 -07:00
Jamie Hardt	b9fe3b9701	Merge branch 'master' of https://github.com/iluvcapra/bwavfile	2023-05-13 11:02:52 -07:00
Jamie Hardt	4925f95b68	Removed old src/wavebuffer.rs file	2023-05-13 11:02:02 -07:00
Jamie Hardt	f1ec1cf43a	Update README.md master branch not main branch!	2023-05-13 10:50:02 -07:00
Jamie Hardt	30b3e83fd4	Update README.md Updated workflow shield	2023-05-13 10:43:17 -07:00
Jamie Hardt	e30d60ff0d	Merge branch 'master' of https://github.com/Wuelle/bwavfile into Wuelle-master	2021-12-31 13:28:55 -08:00
Jamie Hardt	442394ad5e	Removed dead-code warnings	2021-12-31 12:57:46 -08:00
Jamie Hardt	52c26156a9	Merge branch 'master' of https://github.com/iluvcapra/bwavfile	2021-12-31 12:56:11 -08:00
Jamie Hardt	4ddffa0b4a	Read trait	2021-12-31 12:56:08 -08:00
Wuelle	9a010ca0c4	prettify code	2021-12-30 21:59:29 +01:00
Wuelle	5e563cddf8	allow more types to be used as paths	2021-12-30 21:59:17 +01:00
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
Jamie Hardt	f3b646868f	Update to v0.9.0	2020-12-25 22:23:48 -08:00
Jamie Hardt	b303a74d45	Wave writer	2020-12-25 22:21:47 -08:00
Jamie Hardt	73d2cf8cd9	Writer impl	2020-12-25 21:58:22 -08:00
Jamie Hardt	e4fc4732b5	Wavewriter impl	2020-12-25 20:55:38 -08:00
Jamie Hardt	e8b030bd1e	WaveWriter impl, a new approach	2020-12-25 20:26:56 -08:00
Jamie Hardt	1219a4162f	Wavewriter impl	2020-12-25 18:31:17 -08:00
Jamie Hardt	9a275a69c3	Writer impl in progress	2020-12-25 12:30:08 -08:00
Jamie Hardt	3d7c74fc94	Updated sample code in readme To reflect changes in create_frame_buffer()	2020-12-24 23:02:55 -08:00
Jamie Hardt	e6e42f1c09	Merge branch 'master' of https://github.com/iluvcapra/bwavfile	2020-12-24 22:58:38 -08:00
Jamie Hardt	465bad40fc	Writer implementation creaet_frame_buffer() interface has been moved to WaveFmt	2020-12-24 22:57:54 -08:00
Jamie Hardt	388c46d0ee	Update README.md	2020-12-24 21:59:31 -08:00
Jamie Hardt	5dba30fe23	Update README.md	2020-12-24 21:57:28 -08:00
Jamie Hardt	84e4ed1e50	Update README.md	2020-12-24 21:56:33 -08:00
Jamie Hardt	23dccecedb	Update README.md Changed presentation of features	2020-12-24 21:55:32 -08:00
Jamie Hardt	e2e029d3a3	Wavewriter implementation in progress	2020-12-24 21:41:10 -08:00
Jamie Hardt	1edfa7384d	Removed raw_chunk_reader from implementation	2020-12-24 20:56:19 -08:00
Jamie Hardt	c73c9ad81d	Added a workspace	2020-12-24 20:08:12 -08:00
Jamie Hardt	1edce82525	Revert "Update wavereader.rs" This reverts commit `f4b27f8545`.	2020-12-13 12:40:53 -08:00
Jamie Hardt	f4b27f8545	Update wavereader.rs	2020-12-13 12:30:43 -08:00
Jamie Hardt	4cb6105073	Got rid of old code, will rewrite this	2020-12-11 01:58:01 -08:00
Jamie Hardt	ad0736dcc6	Documentation	2020-12-10 18:46:53 -08:00
Jamie Hardt	45311ad748	Documentation fix Angle brackets were getting swallowed	2020-12-10 18:35:25 -08:00
Jamie Hardt	e502913f4f	Updated readme	2020-12-10 18:11:48 -08:00
Jamie Hardt	4890483dcd	Cue lists implemented	2020-12-10 18:09:28 -08:00
Jamie Hardt	8519854596	Cue lists in progress Need to clean up zero-terminated strings in adtl	2020-12-10 14:48:25 -08:00
Jamie Hardt	c947904d0f	Cue point implementation	2020-12-10 12:26:49 -08:00
Jamie Hardt	2323d61ee9	Added test media from izotope RX Editor	2020-12-09 20:35:06 -08:00
Jamie Hardt	60af2f43ff	Update README.md	2020-12-06 12:16:49 -08:00
Jamie Hardt	eb431f865f	Update README.md	2020-12-06 11:47:53 -08:00
Jamie Hardt	8b049e4245	Chanegd reader interface broadcast_extension returns an Option<> now	2020-12-04 22:22:40 -08:00
Jamie Hardt	dfe90fba4a	Documentation	2020-12-04 22:11:25 -08:00
Jamie Hardt	b2d4bff28b	Update lib.rs	2020-12-04 20:39:58 -08:00
Jamie Hardt	79173b0576	Update README.md	2020-12-04 20:39:04 -08:00
Jamie Hardt	e15e36d65d	Update README.md	2020-12-04 20:35:39 -08:00
Jamie Hardt	1dc5f153b0	Update README.md	2020-12-04 20:34:08 -08:00
Jamie Hardt	7a9f9c8bb3	Update README.md Roadmap updates to "Features"	2020-12-04 20:33:30 -08:00
Jamie Hardt	0dd7ee4d18	Merge branch 'master' of https://github.com/iluvcapra/bwavfile	2020-12-03 23:57:43 -08:00
Jamie Hardt	a213e748db	Sampler resources	2020-12-03 23:47:41 -08:00
Jamie Hardt	d221629b3e	More notes on things to do	2020-12-02 22:39:02 -08:00
Jamie Hardt	2fcb211a67	Docs	2020-12-02 22:28:33 -08:00
Jamie Hardt	dfe513b596	iXML and axml cleanup impl	2020-12-02 22:27:14 -08:00
Jamie Hardt	7e1c368862	Nudged version	2020-12-02 21:45:40 -08:00
Jamie Hardt	8985361029	AudioFrameReader consumes the file of WaveReader	2020-12-02 21:36:50 -08:00
Jamie Hardt	e23529e7b6	Note	2020-12-02 17:05:03 -08:00
Jamie Hardt	538aedd413	Playing with comment	2020-12-02 12:52:58 -08:00
Jamie Hardt	09a9413ff2	Changed audio_frame_reader interface to hide RawChunkReader	2020-12-02 12:21:20 -08:00
Jamie Hardt	016f5e3e3b	Update wavereader.rs Fixed typo	2020-11-29 14:06:16 -08:00
Jamie Hardt	11b834be76	Update fmt.rs Documentation	2020-11-29 14:04:52 -08:00
Jamie Hardt	a4ded50112	Merge branch 'master' of https://github.com/iluvcapra/bwavfile	2020-11-28 16:36:59 -08:00
Jamie Hardt	9b2a9783a0	Updated Cargo.toml	2020-11-28 16:35:55 -08:00
Jamie Hardt	1e53436d4b	Update README.md	2020-11-28 15:57:34 -08:00
Jamie Hardt	a9d9081fad	Update README.md	2020-11-28 15:55:12 -08:00
Jamie Hardt	c43144c9db	Update README.md	2020-11-28 15:53:53 -08:00
Jamie Hardt	082a8596af	Made changes to eliminate warnings	2020-11-28 11:30:21 -08:00
Jamie Hardt	208aa7f064	Fixed typo	2020-11-28 11:24:05 -08:00
Jamie Hardt	69da33b3dc	Renamed axml method	2020-11-28 11:01:50 -08:00
Jamie Hardt	9cbb2664d4	axml and iXML access methods	2020-11-27 22:47:48 -08:00
Jamie Hardt	a4c4936665	Fixed thinko in documentation	2020-11-27 22:32:55 -08:00
Jamie Hardt	5f69ec8c61	Nudged version 0.1.5	2020-11-27 22:14:52 -08:00
Jamie Hardt	ac6bd9c1e8	Added tests for channel info	2020-11-27 22:10:01 -08:00
Jamie Hardt	010f261598	Channel descriptor implementation	2020-11-27 22:03:54 -08:00
Jamie Hardt	b40e8edf23	Have created read tests	2020-11-27 21:42:53 -08:00
Jamie Hardt	3c221bce40	Update common_format.rs	2020-11-23 23:15:27 -08:00
Jamie Hardt	883b6c73e8	Documentation	2020-11-23 22:56:46 -08:00
Jamie Hardt	5bd292e964	Bumped version	2020-11-23 22:39:08 -08:00
Jamie Hardt	34e473dc49	Implementation of complex formats	2020-11-23 22:38:10 -08:00
Jamie Hardt	358aa06f7c	Removed validation methods and added to main implementation	2020-11-23 13:16:28 -08:00
Jamie Hardt	8191eedf14	ADM anc channel structures	2020-11-23 11:11:12 -08:00
Jamie Hardt	521e9d0670	Reorganized source, comments	2020-11-23 00:23:17 -08:00
Jamie Hardt	dea68662f8	Comments and documentation	2020-11-22 23:32:25 -08:00
Jamie Hardt	0685e7baca	Removed dead line	2020-11-22 22:38:53 -08:00
Jamie Hardt	123d971624	Comments	2020-11-22 22:38:47 -08:00
Jamie Hardt	f410cda9ed	removed .DS_Store	2020-11-22 22:15:58 -08:00
Jamie Hardt	cf06b50fea	Comment	2020-11-22 22:04:04 -08:00
Jamie Hardt	e8d679b725	Merge branch 'master' of https://github.com/iluvcapra/bwavfile	2020-11-22 22:02:50 -08:00
Jamie Hardt	e63ab6bffd	Renamed some files	2020-11-22 22:02:45 -08:00
Jamie Hardt	271da75f90	Update ffprobe_media_tests.rs	2020-11-22 22:01:11 -08:00
Jamie Hardt	6c393d9958	Restructred test files	2020-11-22 21:36:40 -08:00
Jamie Hardt	99e5d6fe29	Nudging version	2020-11-22 21:20:23 -08:00
		`@@ -0,0 +1,2 @@`
							`/// ## Resources`
							`/// - [Sampler Metadata](http://www.piclist.com/techref/io/serial/midi/wave.html)`