Rust - Simple Wave Generator

Here's a step-by-step method for Rust beginners to create a simple audio wave generator project. This guide includes all the essential steps.
NOTE: This method uses the Linux terminal - if you're on Windows 10, you can use WSL.

1. Install Rust and Cargo Before starting, ensure you have Rust and Cargo installed. If not, you can install Rust using the following command:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Follow the instructions to complete the installation. This also installs Cargo, Rust's package manager and build tool.

1. Create a New Rust Project Using Cargo

To create a new Rust project, open your terminal and run:

cargo new wave_gen --bin

(The --bin flag when running cargo new specifies that you want to create a binary (executable) project, meaning the project will produce an executable file when built.)

This creates a directory called wave_gen with the following structure:

wave_gen/
├── Cargo.toml
└── src
└── main.rs
• Cargo.toml is the file where dependencies are declared.
• src/main.rs is the main Rust file for the project.

1. Add the hound Dependency to Cargo.toml

Open the Cargo.toml file and add the hound crate to the [dependencies] section. This crate allows us to create and manipulate WAV files. Edit Cargo.toml (nano or your favorite text editor) as follows:

[dependencies]
hound = "3.4"

This tells Cargo to download the hound crate when building the project. (Internet connection required for first time.)

1. Edit src/main.rs Next, replace the contents of src/main.rs with the following Rust code. This code generates a sine wave and saves it as a .wav file.

use hound;
use std::f32::consts::PI;
use std::fs;

fn main() {
    // Parameters for the sine wave
    let sample_rate = 44100;
    let duration = 2.0;  // Duration in seconds
    let frequency = 220.0;  // Frequency of the sine wave in Hz
    let amplitude = 0.5;  // Amplitude

    // Ensure the "output" directory exists
    fs::create_dir_all("./output").unwrap();

    // Create a WAV file writer
    let spec = hound::WavSpec {
        channels: 1,
        sample_rate: sample_rate,
        bits_per_sample: 16,
        sample_format: hound::SampleFormat::Int,
    };

    let mut writer = hound::WavWriter::create("./output/audio220.wav", spec).unwrap();

    // Generate the sine wave samples
    let samples = (0..(sample_rate as f32 * duration) as u32).map(|x| {
        let t = x as f32 / sample_rate as f32;
        let sample = (amplitude * (2.0 * PI * frequency * t).sin()) as f32;
        (sample * i16::MAX as f32) as i16
    });

    // Write the samples to the WAV file
    for sample in samples {
        writer.write_sample(sample).unwrap();
    }

    writer.finalize().unwrap();
}

1. Build the Project After editing main.rs and adding the hound dependency, you can now build the project. In your terminal, run:

cargo build

This will compile the project, download the hound crate, and handle all dependencies.

1. Run the Program Once the build is successful, you can run the program using:

cargo run

This will generate a .wav file called audio220.wav in the output directory. The file will contain a 2-second sine wave at 220 Hz.

1. Optional: Clean Up the Build Artifacts Cargo creates several build artifacts and dependencies. If you want to clean them up, you can run:

cargo clean

Let me know if you'd like further clarification or refinements!

Ben Santora - October 2024