Struct CdReader 

pub struct CdReader { /* private fields */ }

Helper struct to interact with the audio CD. Internally it holds a platform-specific handle to the open CD drive to read from it and it is correctly closed when CDReader is dropped.

Implementations

impl CdReader

pub fn detect_track_format( &self, track: &Track, ) -> Result<SectorReadFormat, CdReaderError>

Detect the default read format for a track.

Audio tracks are identified directly from the TOC. Data tracks are queried with MMC READ TRACK INFORMATION. If its Data Mode is inconclusive, one raw sector is inspected as a fallback.

Errors

• Returns CdReaderError::CannotDetectTrackFormat if neither the track metadata nor a raw sector identifies the data format.
• Returns CdReaderError::Io, CdReaderError::Scsi, or CdReaderError::Parse if querying the drive fails.

Examples found in repository

examples/detect_track_formats.rs (line 9)

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

    for track in &toc.tracks {
        let format = reader.detect_track_format(track)?;
        println!("Track #{:>2}: {format:?}", track.number);
    }

    Ok(())
}

examples/save_data_track.rs (line 39)

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

    // There is no `find_data_track` helper in the crate — the idiom is a plain
    // filter on the TOC, since "data track" is simply `!is_audio`.
    let data_track = toc
        .tracks
        .iter()
        .find(|track| !track.is_audio)
        .ok_or("no data track on this disc (need a mixed-mode / enhanced CD)")?;

    let format = reader.detect_track_format(data_track)?;
    println!("Data track #{} detected as {format:?}\n", data_track.number);

    match format {
        SectorReadFormat::Mode1Cooked => {
            // Cooked Mode 1 strips sync/header/EDC/ECC, leaving exactly the
            // 2048-byte user data per sector — i.e. the raw ISO 9660 image.
            let iso_path = output_dir.join(format!("track{:02}.iso", data_track.number));
            let bytes = stream_track_to_file(&reader, &toc, data_track.number, format, &iso_path)?;

            println!(
                "Wrote {} ({bytes} bytes, {} sectors)\n",
                iso_path.display(),
                bytes / format.sector_size() as u64
            );
            print_mount_hint(&iso_path.display().to_string());
        }
        SectorReadFormat::Mode2Raw => {
            // Mode 2 forms are a per-sector property; producing a clean cooked
            // payload requires inspecting each sector's XA subheader, which is
            // left to the consumer. We save the complete raw sectors so nothing
            // is lost.
            let bin_path = output_dir.join(format!("track{:02}.mode2.bin", data_track.number));
            let bytes = stream_track_to_file(&reader, &toc, data_track.number, format, &bin_path)?;

            println!(
                "This is a Mode 2 track. Saved complete raw sectors to {} \
                 ({bytes} bytes, {} sectors).",
                bin_path.display(),
                bytes / format.sector_size() as u64
            );
            println!(
                "Extracting a mountable filesystem from Mode 2 is consumer territory: \
                 each sector's XA subheader decides which bytes are user data."
            );
        }
        other => {
            return Err(format!(
                "data track #{} detected as {other:?}, which is unexpected for a data track",
                data_track.number
            )
            .into());
        }
    }

    Ok(())
}

impl CdReader

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

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

Errors

Returns CdReaderError::Io if platform drive enumeration fails. Errors while probing an individual drive are represented by DriveInfo::has_audio_cd being false instead.

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 status = if drive.has_audio_cd {
            "audio CD inserted"
        } else {
            "no audio CD"
        };
        println!("Drive: {}, status: [{status}]", drive.path);
    }

    Ok(())
}

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

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

Errors

• Returns CdReaderError::NoUsableDrive if no discovered drive has a readable audio CD.
• Returns CdReaderError::Io if drive enumeration or opening the selected drive fails.

Examples found in repository

examples/detect_track_formats.rs (line 5)

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

    for track in &toc.tracks {
        let format = reader.detect_track_format(track)?;
        println!("Track #{:>2}: {format:?}", track.number);
    }

    Ok(())
}

examples/read_first_track.rs (line 8)

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 8)

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_toc.rs (line 7)

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 = track_end_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/read_all_tracks.rs (line 8)

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 14)

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(())
}

Additional examples can be found in:

• examples/stream_with_progress.rs
• examples/play_audio_track.rs
• examples/read_speed.rs
• examples/save_data_track.rs
• examples/read_data_track.rs

impl CdReader

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

Open a streaming reader for an audio track using the default options.

Errors

Returns the same errors as CdReader::open_track_stream_with_options.

Examples found in repository

examples/stream_last_track.rs (line 19)

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/stream_with_progress.rs (line 17)

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(())
}

pub fn open_track_stream_with_options<'a>( &'a self, toc: &Toc, track_no: u8, options: &ReadOptions, ) -> Result<TrackStream<'a>, CdReaderError>

Open a streaming reader using explicit read options.

Use TrackStream::next_chunk to pull sector-aligned chunks in the selected format. The requested read speed is applied once before the stream is returned. To override the default chunk size, call TrackStream::with_sectors_per_chunk on the returned stream.

Errors

• Returns CdReaderError::TrackFormatMismatch if the selected format is incompatible with the track.
• Returns CdReaderError::Io if the track is absent, its bounds are invalid, or the read-speed request fails.

Examples found in repository

examples/save_data_track.rs (line 100)

fn stream_track_to_file(
    reader: &CdReader,
    toc: &Toc,
    track_no: u8,
    format: SectorReadFormat,
    path: &Path,
) -> Result<u64, Box<dyn std::error::Error>> {
    let options = ReadOptions::default().with_format(format);
    let mut stream = reader.open_track_stream_with_options(toc, track_no, &options)?;

    let total_sectors = stream.total_sectors();
    let mut writer = BufWriter::new(File::create(path)?);
    let mut written = 0u64;

    while let Some(chunk) = stream.next_chunk()? {
        writer.write_all(&chunk)?;
        written += chunk.len() as u64;

        let done = stream.current_sector();
        let pct = done as f32 / total_sectors as f32 * 100.0;
        eprint!("\r  {done}/{total_sectors} sectors ({pct:5.1}%)");
    }
    eprintln!("\r  {total_sectors}/{total_sectors} sectors (100.0%)");

    writer.flush()?;
    Ok(written)
}

impl CdReader

pub fn open(drive: &DriveInfo) -> Result<Self, CdReaderError>

Opens a drive returned by CdReader::list_drives.

The reader owns the opened drive until it is dropped.

Errors

Returns CdReaderError::Io if the discovered drive path cannot be opened with the access required for raw drive commands.

pub fn open_path(path: &str) -> Result<Self, CdReaderError>

Opens a CD drive at a platform-specific device path.

Example paths are /dev/sr0 on Linux, disk6 on macOS, and \\.\E: on Windows. The reader owns the opened drive until it is dropped.

Errors

Returns CdReaderError::Io if path is invalid or the operating system cannot open it with the required access.

pub fn from_file(file: File) -> Self

Builds a reader from an already-open handle to the drive’s device node, instead of opening the path ourselves.

This exists for privileged access. Reading a raw optical device can require more rights than the calling process has, and there is no way to gain them after the fact — the descriptor has to come from somewhere else. A caller that hits EPERM / EACCES from CdReader::open_path can obtain one through a privilege-escalation helper (macOS /usr/libexec/authopen, a setuid helper, a launchd service) and hand it over here.

The handle must refer to the drive’s device node — /dev/rdiskN on macOS, /dev/srN on Linux — and the reader takes ownership of it, closing it on drop.

On Linux the handle must have been opened O_RDWR: the SG_IO ioctls this crate issues are rejected on a read-only descriptor. On macOS O_RDONLY is correct and preferred, since a write-capable open of an optical device demands exclusivity.

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.

Errors

Returns CdReaderError::Io or CdReaderError::Scsi if the drive command fails, and CdReaderError::Parse if the returned TOC is malformed.

Examples found in repository

examples/detect_track_formats.rs (line 6)

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

    for track in &toc.tracks {
        let format = reader.detect_track_format(track)?;
        println!("Track #{:>2}: {format:?}", track.number);
    }

    Ok(())
}

examples/read_first_track.rs (line 9)

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 9)

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_toc.rs (line 8)

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 = track_end_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/read_all_tracks.rs (line 9)

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 15)

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(())
}

Additional examples can be found in:

• examples/stream_with_progress.rs
• examples/play_audio_track.rs
• examples/read_speed.rs
• examples/save_data_track.rs
• examples/read_data_track.rs

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

Read an audio track using the default options.

It returns raw PCM data, but if you want to save it directly and make it playable, wrap the result with create_wav.

Errors

Returns the same errors as CdReader::read_track_with_options.

Examples found in repository

examples/read_first_track.rs (line 18)

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/read_all_tracks.rs (line 18)

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(())
}

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

Read a complete track using explicit read options.

Errors

• Returns CdReaderError::TrackFormatMismatch if the selected sector format is incompatible with the track.
• Returns CdReaderError::Io if the track is absent, its bounds are invalid, or an operating-system drive operation fails.
• Returns CdReaderError::Scsi if the drive rejects a read command.

Examples found in repository

examples/custom_retry.rs (line 37)

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/read_speed.rs (line 40)

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(|track| track.is_audio)
        .ok_or("no audio tracks found")?;

    // Keep "unchanged" immediately after 1x so it tests whether the previous speed
    // request remains in effect when no new speed command is sent.
    let speed_tests = [
        ("1x", ReadSpeed::CustomMultiplier(1)),
        ("unchanged (after 1x)", ReadSpeed::Unchanged),
        ("10x", ReadSpeed::CustomMultiplier(10)),
        ("30x", ReadSpeed::CustomMultiplier(30)),
        ("optimal", ReadSpeed::Optimal),
    ];

    println!(
        "Reading audio track {} {} times\n",
        first_audio.number,
        speed_tests.len()
    );

    let mut timings = Vec::with_capacity(speed_tests.len());

    for (label, read_speed) in speed_tests {
        let options = ReadOptions::default().with_read_speed(read_speed);

        println!("Reading at {label}...");
        let started = Instant::now();
        let data = reader.read_track_with_options(&toc, first_audio.number, &options)?;
        let elapsed = started.elapsed();

        println!(
            "Read {} bytes in {:.3} seconds\n",
            data.len(),
            elapsed.as_secs_f64()
        );
        timings.push((label, elapsed));
    }

    println!("Timing summary:");
    for (label, elapsed) in timings {
        println!("  {label:<22} {:>10.3} seconds", elapsed.as_secs_f64());
    }

    Ok(())
}

pub fn read_sector_range( &self, start_lba: u32, sectors: u32, options: &ReadOptions, ) -> Result<Vec<u8>, CdReaderError>

Read an arbitrary range of sectors using explicit read options.

Low-level API

Callers are responsible for providing valid sector boundaries and selecting a format compatible with the sectors on the disc. Prefer CdReader::read_track or CdReader::read_track_with_options when reading a complete TOC track.

Errors

• Returns CdReaderError::Io if the range is invalid, the read-speed request fails, or an operating-system read fails.
• Returns CdReaderError::Scsi if the drive rejects a read command.

Examples found in repository

examples/play_audio_track.rs (line 61)

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)
}

examples/read_data_track.rs (line 36)

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

    let data_track = toc
        .tracks
        .iter()
        .find(|t| !t.is_audio)
        .ok_or("no data track on this disc (need a mixed-mode / enhanced CD)")?;

    let pvd_lba = data_track.start_lba + PVD_SECTOR_OFFSET;
    println!(
        "Data track #{} starts at LBA {}; reading PVD at LBA {}\n",
        data_track.number, data_track.start_lba, pvd_lba
    );

    let mut options = ReadOptions::default().with_format(SectorReadFormat::Mode1Raw);

    // --- raw read (2352 B) -------------------------------------------------
    let raw = reader.read_sector_range(pvd_lba, 1, &options)?;
    if raw.len() != 2352 {
        return Err(format!("raw read returned {} bytes, expected 2352", raw.len()).into());
    }

    let sync_ok = raw[0] == 0x00 && raw[1..11].iter().all(|&b| b == 0xFF) && raw[11] == 0x00;
    let mode = raw[15];
    println!("raw sync pattern : {}", pass(sync_ok));
    println!("raw sector mode  : Mode {mode}");

    // User data sits after sync(12) + header(4) for Mode 1, and additionally
    // after an 8-byte subheader for Mode 2 Form 1.
    let user_offset = match mode {
        1 => 16,
        2 => 24,
        other => return Err(format!("unexpected sector mode {other}").into()),
    };
    let raw_user = &raw[user_offset..user_offset + 2048];

    let iso_ok = raw_user[0] == 0x01 && &raw_user[1..6] == b"CD001";
    println!("ISO 9660 'CD001' : {}", pass(iso_ok));

    // --- cooked read (2048 B) ---------------------------------------------
    // The cooked format is specifically Mode 1, so only cross-check it there.
    if mode == 1 {
        options = options.with_format(SectorReadFormat::Mode1Cooked);
        let cooked = reader.read_sector_range(pvd_lba, 1, &options)?;
        if cooked.len() != 2048 {
            return Err(
                format!("cooked read returned {} bytes, expected 2048", cooked.len()).into(),
            );
        }
        let matches_raw = cooked == raw_user;
        println!("cooked == raw[16..]: {}", pass(matches_raw));

        if sync_ok && iso_ok && matches_raw {
            println!("\nALL CHECKS PASSED — cooked and raw data reads are correct.");
            return Ok(());
        }
    } else {
        println!(
            "\nData track is Mode {mode} (e.g. CD-Extra / Mode 2 Form 1). The cooked path \
             targets Mode 1, so only the raw checks apply here."
        );
        if sync_ok && iso_ok {
            println!("Raw read verified against on-disc ISO structure.");
            return Ok(());
        }
    }

    Err("one or more verification checks FAILED — see output above".into())
}

Trait Implementations

impl AudioSectorReader for CdReader

The physical drive is itself an AudioSectorReader, so drive-backed and file-backed code can share the generic read_track path. This uses the default read options (audio sectors, default retry policy); for explicit control, prefer the inherent CdReader::read_track_with_options.

type Error = CdReaderError

Error produced when this backing cannot satisfy a sector read.

fn read_audio_sectors( &self, start_lba: u32, count: u32, ) -> Result<Vec<u8>, Self::Error>

Read the sector range start_lba..start_lba + count.