Function create_wav 

pub fn create_wav(data: Vec<u8>) -> Vec<u8> 

Prepends a standard 44-byte RIFF/WAVE header to raw CD-DA PCM.

data must already contain headerless, signed 16-bit little-endian, interleaved stereo PCM sampled at 44,100 Hz. This function does not validate or convert the audio data; it only adds a header describing that format.

PCM returned by CdReader::read_track or the source-independent read_track function already has the required format. The returned vector contains a complete WAV file and can be written directly to a .wav file.

Examples found in repository

examples/read_first_track.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("read_first_track")?;
    let reader = CdReader::open_default()?;
    let toc = reader.read_toc()?;

    let first_audio = toc
        .tracks
        .iter()
        .find(|t| t.is_audio)
        .ok_or("no audio tracks found")?;

    println!("Reading track {}...", first_audio.number);
    let data = reader.read_track(&toc, first_audio.number)?;

    let wav = create_wav(data);
    let output_path = output_dir.join(format!("track{:02}.wav", first_audio.number));
    std::fs::write(&output_path, wav)?;
    println!("Saved {}", output_path.display());

    Ok(())
}

examples/stream_last_track.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("stream_last_track")?;
    let reader = CdReader::open_default()?;
    let toc = reader.read_toc()?;

    let last_audio = toc
        .tracks
        .iter()
        .rev()
        .find(|t| t.is_audio)
        .ok_or("no audio tracks found")?;

    println!("Streaming track {}...", last_audio.number);
    let mut stream = reader.open_track_stream(&toc, last_audio.number)?;

    let mut pcm = Vec::new();
    while let Some(chunk) = stream.next_chunk()? {
        pcm.extend_from_slice(&chunk);
    }

    let wav = create_wav(pcm);
    let output_path = output_dir.join(format!("track{:02}.wav", last_audio.number));
    std::fs::write(&output_path, wav)?;
    println!("Saved {}", output_path.display());

    Ok(())
}

examples/read_all_tracks.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("read_all_tracks")?;
    let reader = CdReader::open_default()?;
    let toc = reader.read_toc()?;

    let audio_tracks: Vec<_> = toc.tracks.iter().filter(|t| t.is_audio).collect();
    println!("Found {} audio track(s)\n", audio_tracks.len());

    let mut failed = Vec::new();

    for track in &audio_tracks {
        print!("Reading track {:>2}... ", track.number);
        match reader.read_track(&toc, track.number) {
            Ok(data) => {
                let wav = create_wav(data);
                let output_path = output_dir.join(format!("track{:02}.wav", track.number));
                std::fs::write(&output_path, wav)?;
                println!("saved {}", output_path.display());
            }
            Err(e) => {
                println!("FAILED: {}", e);
                failed.push(track.number);
            }
        }
    }

    if !failed.is_empty() {
        eprintln!("\nFailed to read tracks: {:?}", failed);
    }

    Ok(())
}

examples/custom_retry.rs (line 39)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("custom_retry")?;
    let reader = CdReader::open_default()?;
    let toc = reader.read_toc()?;

    let first_audio = toc
        .tracks
        .iter()
        .find(|t| t.is_audio)
        .ok_or("no audio tracks found")?;

    // More attempts, longer backoff, and sector reduction down to 1
    // for maximum resilience on scratched media.
    let retry = RetryConfig::default()
        .with_max_attempts(8)
        .with_initial_backoff(Duration::from_millis(50))
        .with_max_backoff(Duration::from_secs(1))
        .with_chunk_reduction(true)
        .with_min_sectors_per_read(1);
    let options = ReadOptions::default().with_retry(retry);

    println!(
        "Reading track {} with aggressive retry...",
        first_audio.number
    );
    let data = reader.read_track_with_options(&toc, first_audio.number, &options)?;

    let wav = create_wav(data);
    let output_path = output_dir.join(format!("track{:02}.wav", first_audio.number));
    std::fs::write(&output_path, wav)?;
    println!("Saved {}", output_path.display());

    Ok(())
}

examples/stream_with_progress.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("stream_with_progress")?;
    let reader = CdReader::open_default()?;
    let toc = reader.read_toc()?;

    let first_audio = toc
        .tracks
        .iter()
        .find(|t| t.is_audio)
        .ok_or("no audio tracks found")?;

    let mut stream = reader.open_track_stream(&toc, first_audio.number)?;

    let total_secs = stream.total_seconds();
    println!(
        "Track {} — {} sectors ({:.0}s)\n",
        first_audio.number,
        stream.total_sectors(),
        total_secs,
    );

    let mut pcm = Vec::new();
    while let Some(chunk) = stream.next_chunk()? {
        pcm.extend_from_slice(&chunk);

        let cur = stream.current_seconds();
        let pct = cur / total_secs * 100.0;
        eprint!("\r  [{:>5.1}s / {:.1}s] {:5.1}%", cur, total_secs, pct,);
    }
    eprintln!("\r  [{:.1}s / {:.1}s] 100.0%", total_secs, total_secs);

    let wav = create_wav(pcm);
    let output_path = output_dir.join(format!("track{:02}.wav", first_audio.number));
    std::fs::write(&output_path, wav)?;
    println!("\nSaved {}", output_path.display());

    Ok(())
}

examples/play_audio_track.rs (line 69)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("play_audio_track")?;
    let seconds: u32 = match std::env::args().nth(1) {
        Some(a) => a.parse()?,
        None => 30,
    };

    let reader = CdReader::open_default()?;
    let toc = reader.read_toc()?;

    let track = toc
        .tracks
        .iter()
        .find(|t| t.is_audio)
        .ok_or("no audio tracks found on this disc")?;

    // Clamp the preview to what the track actually holds: the track ends where
    // the next track starts, or at the lead-out if it's the last one.
    let track_end = toc
        .tracks
        .iter()
        .map(|t| t.start_lba)
        .filter(|&lba| lba > track.start_lba)
        .min()
        .unwrap_or(toc.leadout_lba);
    let track_sectors = track_end - track.start_lba;
    let sectors = (seconds * SECTORS_PER_SECOND).min(track_sectors);
    let actual_seconds = sectors / SECTORS_PER_SECOND;

    println!(
        "Reading first {actual_seconds}s ({sectors} sectors) of audio track #{}...",
        track.number
    );
    let pcm = reader.read_sector_range(track.start_lba, sectors, &ReadOptions::default())?;
    println!(
        "Read {} bytes of PCM ({:.1} MiB)",
        pcm.len(),
        pcm.len() as f64 / (1024.0 * 1024.0)
    );

    let output_path = output_dir.join(format!("track{:02}_preview.wav", track.number));
    std::fs::write(&output_path, create_wav(pcm))?;
    println!("Saved {}", output_path.display());

    play(&output_path)
}

Additional examples can be found in:

• examples/bin_cue_backend.rs
• examples/file_backend.rs