Struct CdReader 

pub struct CdReader {}

Helper struct to interact with the audio CD. While it doesn’t hold any internal data directly, it implements Drop trait, so that the CD drive handle is properly closed.

Please note that you should not read multiple CDs at the same time, and preferably do not use it in multiple threads. CD drives are physical devices, so currently only sequential access is properly tested and supported.

Implementations

impl CdReader

pub fn list_drives() -> Result<Vec<DriveInfo>, CdReaderError>

Enumerate candidate optical drives and probe whether they currently have an audio CD.

On Windows, we try to read type of every drive from A to Z. On Linux, we read /sys/class/block directory and check every entry starting with “sr”

Examples found in repository

examples/list_drives.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let drives = CdReader::list_drives()?;

    if drives.is_empty() {
        println!("No optical drives found.");
        return Ok(());
    }

    println!("Found {} drive(s):\n", drives.len());
    for drive in &drives {
        let name = drive.display_name.as_deref().unwrap_or("(unknown)");
        let status = if drive.has_audio_cd {
            "audio CD inserted"
        } else {
            "no audio CD"
        };
        println!(
            "Drive: {}, name: {}, status: [{}]",
            drive.path, name, status
        );
    }

    Ok(())
}

pub fn open_default() -> Result<Self, CdReaderError>

Open the first discovered drive that currently has an audio CD.

On Windows and Linux, we get the first device from the list and try to open it, returning an error if it fails.

Examples found in repository

examples/read_first_track.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 = CdReader::create_wav(data);
    let filename = format!("track{:02}.wav", first_audio.number);
    std::fs::write(&filename, wav)?;
    println!("Saved {}", filename);

    Ok(())
}

examples/stream_last_track.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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, TrackStreamConfig::default())?;

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

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

    Ok(())
}

examples/read_toc.rs (line 5)

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

    println!("Table of Contents\n");

    println!(
        "Tracks {}-{} ({} total), lead-out at LBA {}\n",
        toc.first_track,
        toc.last_track,
        toc.tracks.len(),
        toc.leadout_lba,
    );

    for track in &toc.tracks {
        let kind = if track.is_audio { "audio" } else { "data " };
        let (m, s, f) = track.start_msf;
        let sectors = next_track_lba(&toc, track.number) - track.start_lba;
        let duration_secs = sectors as f64 / 75.0;
        let mins = (duration_secs / 60.0) as u32;
        let secs = (duration_secs % 60.0) as u32;

        println!(
            "  #{:>2}  {}  LBA {:>6}  MSF {:02}:{:02}.{:02}  duration: {:02}:{:02}",
            track.number, kind, track.start_lba, m, s, f, mins, secs,
        );
    }

    Ok(())
}

examples/custom_retry.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 {
        max_attempts: 8,
        initial_backoff_ms: 50,
        max_backoff_ms: 1000,
        reduce_chunk_on_retry: true,
        min_sectors_per_read: 1,
    };

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

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

    Ok(())
}

examples/read_all_tracks.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 = CdReader::create_wav(data);
                let filename = format!("track{:02}.wav", track.number);
                std::fs::write(&filename, wav)?;
                println!("saved {}", filename);
            }
            Err(e) => {
                println!("FAILED: {}", e);
                failed.push(track.number);
            }
        }
    }

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

    Ok(())
}

examples/stream_with_progress.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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, TrackStreamConfig::default())?;

    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 = CdReader::create_wav(pcm);
    let filename = format!("track{:02}.wav", first_audio.number);
    std::fs::write(&filename, wav)?;
    println!("\nSaved {}", filename);

    Ok(())
}

impl CdReader

pub fn open_track_stream<'a>( &'a self, toc: &Toc, track_no: u8, cfg: TrackStreamConfig, ) -> Result<TrackStream<'a>, CdReaderError>

Open a streaming reader for a specific track in the provided TOC. It is important to create track streams through this method so the drive session is managed through a single CDReader instance.

Use TrackStream::next_chunk to pull sector-aligned PCM chunks.

Examples found in repository

examples/stream_last_track.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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, TrackStreamConfig::default())?;

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

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

    Ok(())
}

examples/stream_with_progress.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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, TrackStreamConfig::default())?;

    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 = CdReader::create_wav(pcm);
    let filename = format!("track{:02}.wav", first_audio.number);
    std::fs::write(&filename, wav)?;
    println!("\nSaved {}", filename);

    Ok(())
}

impl CdReader

pub fn open(path: &str) -> Result<Self>

Opens a CD drive at the specified path in order to read data.

It is crucial to call this function and not to create the Reader by yourself, as each OS needs its own way of handling the drive access.

You don’t need to close the drive; it will be handled automatically when the CdReader is dropped.

Arguments

• path - The device path (e.g., “/dev/sr0” on Linux, “disk6” on macOS, and r“\.\E:“ on Windows)

Errors

Returns an error if the drive cannot be opened

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

While this is a low-level library and does not include any codecs to compress the audio, it includes a helper function to convert raw PCM data into a wav file, which is done by prepending a 44 RIFF bytes header

Arguments

• data - vector of bytes received from read_track function

Examples found in repository

examples/read_first_track.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 = CdReader::create_wav(data);
    let filename = format!("track{:02}.wav", first_audio.number);
    std::fs::write(&filename, wav)?;
    println!("Saved {}", filename);

    Ok(())
}

examples/stream_last_track.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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, TrackStreamConfig::default())?;

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

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

    Ok(())
}

examples/custom_retry.rs (line 34)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 {
        max_attempts: 8,
        initial_backoff_ms: 50,
        max_backoff_ms: 1000,
        reduce_chunk_on_retry: true,
        min_sectors_per_read: 1,
    };

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

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

    Ok(())
}

examples/read_all_tracks.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 = CdReader::create_wav(data);
                let filename = format!("track{:02}.wav", track.number);
                std::fs::write(&filename, wav)?;
                println!("saved {}", filename);
            }
            Err(e) => {
                println!("FAILED: {}", e);
                failed.push(track.number);
            }
        }
    }

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

    Ok(())
}

examples/stream_with_progress.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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, TrackStreamConfig::default())?;

    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 = CdReader::create_wav(pcm);
    let filename = format!("track{:02}.wav", first_audio.number);
    std::fs::write(&filename, wav)?;
    println!("\nSaved {}", filename);

    Ok(())
}

pub fn read_toc(&self) -> Result<Toc, CdReaderError>

Read Table of Contents for the opened drive. You’ll likely only need to access tracks from the returned value in order to iterate and read each track’s raw data. Please note that each track in the vector has number property, which you should use when calling read_track, as it doesn’t start with 0. It is important to do so, because in the future it might include 0 for the hidden track.

Examples found in repository

examples/read_first_track.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 = CdReader::create_wav(data);
    let filename = format!("track{:02}.wav", first_audio.number);
    std::fs::write(&filename, wav)?;
    println!("Saved {}", filename);

    Ok(())
}

examples/stream_last_track.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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, TrackStreamConfig::default())?;

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

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

    Ok(())
}

examples/read_toc.rs (line 6)

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

    println!("Table of Contents\n");

    println!(
        "Tracks {}-{} ({} total), lead-out at LBA {}\n",
        toc.first_track,
        toc.last_track,
        toc.tracks.len(),
        toc.leadout_lba,
    );

    for track in &toc.tracks {
        let kind = if track.is_audio { "audio" } else { "data " };
        let (m, s, f) = track.start_msf;
        let sectors = next_track_lba(&toc, track.number) - track.start_lba;
        let duration_secs = sectors as f64 / 75.0;
        let mins = (duration_secs / 60.0) as u32;
        let secs = (duration_secs % 60.0) as u32;

        println!(
            "  #{:>2}  {}  LBA {:>6}  MSF {:02}:{:02}.{:02}  duration: {:02}:{:02}",
            track.number, kind, track.start_lba, m, s, f, mins, secs,
        );
    }

    Ok(())
}

examples/custom_retry.rs (line 10)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 {
        max_attempts: 8,
        initial_backoff_ms: 50,
        max_backoff_ms: 1000,
        reduce_chunk_on_retry: true,
        min_sectors_per_read: 1,
    };

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

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

    Ok(())
}

examples/read_all_tracks.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 = CdReader::create_wav(data);
                let filename = format!("track{:02}.wav", track.number);
                std::fs::write(&filename, wav)?;
                println!("saved {}", filename);
            }
            Err(e) => {
                println!("FAILED: {}", e);
                failed.push(track.number);
            }
        }
    }

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

    Ok(())
}

examples/stream_with_progress.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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, TrackStreamConfig::default())?;

    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 = CdReader::create_wav(pcm);
    let filename = format!("track{:02}.wav", first_audio.number);
    std::fs::write(&filename, wav)?;
    println!("\nSaved {}", filename);

    Ok(())
}

pub fn read_track( &self, toc: &Toc, track_no: u8, ) -> Result<Vec<u8>, CdReaderError>

Read raw data for the specified track number from the TOC. It returns raw PCM data, but if you want to save it directly and make it playable, wrap the result with create_wav function, that will prepend a RIFF header and make it a proper music file.

Examples found in repository

examples/read_first_track.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 = CdReader::create_wav(data);
    let filename = format!("track{:02}.wav", first_audio.number);
    std::fs::write(&filename, wav)?;
    println!("Saved {}", filename);

    Ok(())
}

examples/read_all_tracks.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 = CdReader::create_wav(data);
                let filename = format!("track{:02}.wav", track.number);
                std::fs::write(&filename, wav)?;
                println!("saved {}", filename);
            }
            Err(e) => {
                println!("FAILED: {}", e);
                failed.push(track.number);
            }
        }
    }

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

    Ok(())
}

pub fn read_track_with_retry( &self, toc: &Toc, track_no: u8, cfg: &RetryConfig, ) -> Result<Vec<u8>, CdReaderError>

Read raw data for the specified track number from the TOC using explicit retry config.

Examples found in repository

examples/custom_retry.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    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 {
        max_attempts: 8,
        initial_backoff_ms: 50,
        max_backoff_ms: 1000,
        reduce_chunk_on_retry: true,
        min_sectors_per_read: 1,
    };

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

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

    Ok(())
}

Trait Implementations

impl Drop for CdReader

fn drop(&mut self)

Executes the destructor for this type.