TinyAudio

Android

• API Level: Requires API Level 26+ (Android 8.1 Oreo) as it uses the AAudio API.
• Initialization Timing: You must initialize the audio device only after your application has gained focus (e.g., receiving the GainedFocus event in the android-activity crate). Failure to do so will cause device creation to fail.

WebAssembly

• User Interaction: Browsers require a user gesture (like a button click) to allow audio playback. You must initialize the audio device only after an action on the web page has occurred.

To use the TinyAudio iOS example, you must first install cargo-lipo to enable building universal libraries for iOS.

Additionally, the iOS project requires specific linking configuration in Xcode:

1. Link the header file(s) generated from the Rust project.
2. Link the following libraries/frameworks:
   • AudioToolbox.framework
   • libresolv.tbd
   • libtinyaudioexample.a

cargo install cargo-lipo

The iOS project is configured to automatically rebuild the Rust library during the build process. You can build and launch the project normally through Xcode.

The build process utilizes two custom 'Run Script Phases' in the 'Build Phase' settings:

1. Build static library: Uses cargo lipo with --xcode-integ to build the universal library from the Rust manifest.
2. Cleanup: Deletes the generated static library from the Rust target directory to keep the workspace clean.

cargo lipo --xcode-integ --manifest-path $(PROJECT_DIR)../Rust-TinyAudioExample/Cargo.toml

# Cleanup script executed after build:
rm -fv $(PROJECT_DIR)/../Rust-TinyAudioExample/target/universal/*/*.a

On Linux, TinyAudio supports two backends: ALSA (default) and PulseAudio.

Prerequisites

To compile on Linux, you must install the following development libraries:

sudo apt-get install libasound2-dev libudev-dev pkg-config

If you wish to use the PulseAudio backend, you must also install libpulse-dev:

sudo apt-get install libpulse-dev

Enabling PulseAudio

To use PulseAudio instead of the default ALSA, configure your Cargo.toml to disable default features and enable the pulse feature:

tinyaudio = { version = "2", default-features = false, features = ["pulse"] }

This example demonstrates how to generate a 440 Hz sine wave within the audio callback. The callback iterates through chunks of data corresponding to the number of channels and calculates the sine value based on a running clock.

# use tinyaudio::prelude::*;
let params = OutputDeviceParameters {
    channels_count: 2,
    sample_rate: 44100,
    channel_sample_count: 4410,
};

let _device = run_output_device(params, {
    let mut clock = 0f32;
    move |data| {
        for samples in data.chunks_mut(params.channels_count) {
            clock = (clock + 1.0) % params.sample_rate as f32;
            let value =
                (clock * 440.0 * 2.0 * std::f32::consts::PI / params.sample_rate as f32).sin();
            for sample in samples {
                *sample = value;
            }
        }
    }
})
.unwrap();

std::thread::sleep(std::time::Duration::from_secs(5));

Use the OutputDeviceParameters struct to define the audio format for your output device.

Key fields:

• sample_rate: The frequency of your audio data in Hz (e.g., 44100, 48000).
• channels_count: The number of audio channels (e.g., 1 for mono, 2 for stereo). Data is provided in an interleaved format (LRLRLR...).
• channel_sample_count: The number of samples per channel per callback. This controls audio latency. Higher values increase latency but reduce the risk of audio glitches. To target a specific duration in seconds, use: channel_sample_count = sample_rate * time_in_seconds.

let params = OutputDeviceParameters {
    channels_count: 2,
    sample_rate: 44100,
    channel_sample_count: 4410,
};

This example demonstrates how to implement a data_callback to generate a continuous 440 Hz sine wave for 5 seconds using run_output_device.

# use tinyaudio::prelude::*;
let params = OutputDeviceParameters {
    channels_count: 2,
    sample_rate: 44100,
    channel_sample_count: 4410,
};

let _device = run_output_device(params, {
    let mut clock = 0f32;
    move |data| {
        for samples in data.chunks_mut(params.channels_count) {
            clock = (clock + 1.0) % params.sample_rate as f32;
            let value =
                (clock * 440.0 * 2.0 * std::f32::consts::PI / params.sample_rate as f32).sin();
            for sample in samples {
                *sample = value;
            }
        }
    }
})
.unwrap();

std::thread::sleep(std::time::Duration::from_secs(5));

The OutputDevice struct acts as an opaque handle to the active platform-dependent audio device. To release all system resources occupied by the device and stop playback, call the .close() method.

let mut device = run_output_device(params, callback).unwrap();
// ... play audio ...
device.close();