Function read_track 

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

Reads one complete audio track from an AudioSectorReader into memory.

track_no is the disc track number stored in Track::number, not an index into Toc::tracks. The source and the Toc must use the same LBA address space.

This convenience function resolves the track’s sector range using TrackBounds::SessionGap. That policy is appropriate for physical discs and images that preserve the original CD geometry, including the CD-Extra inter-session gap. For a contiguous, gap-stripped source, use read_track_with_bounds with TrackBounds::Gapless.

The returned vector contains headerless CD-DA PCM in the format required by AudioSectorReader: signed 16-bit little-endian stereo at 44.1 kHz, with 2,352 bytes per sector. It can be passed directly to create_wav.

This is a blocking operation that buffers the entire track, which may require hundreds of megabytes. Use open_track_stream or open_track_stream_with_bounds to process the track incrementally.

Only audio tracks are meaningful for this API. Callers should select a track whose Track::is_audio field is true.

Errors

Returns CdReaderError::Io if track_no is absent from the Toc or its calculated sector bounds are invalid.

Returns CdReaderError::Backend if the source cannot read the requested sectors. The source’s original error is preserved as the boxed source.

Examples found in repository

examples/file_backend.rs (line 72)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let output_dir = common::fresh_output_dir("file_backend")?;

    // A real backing derives this TOC from the image's own track metadata.
    // Here we fabricate a 2-track disc: 2 seconds + 3 seconds of audio.
    let track1_sectors = 75 * 2;
    let track2_sectors = 75 * 3;
    let total_sectors = track1_sectors + track2_sectors;

    let toc = Toc {
        first_track: 1,
        last_track: 2,
        tracks: vec![
            Track {
                number: 1,
                start_lba: 0,
                start_msf: lba_to_msf(0),
                is_audio: true,
            },
            Track {
                number: 2,
                start_lba: track1_sectors,
                start_msf: lba_to_msf(track1_sectors),
                is_audio: true,
            },
        ],
        leadout_lba: total_sectors,
    };

    // Silence, just for the demo — a real backing decodes actual audio here.
    let disc = InMemoryDisc {
        pcm: vec![0u8; total_sectors as usize * 2352],
    };

    for track in &toc.tracks {
        let pcm = read_track(&disc, &toc, track.number)?;
        println!(
            "track {}: {} bytes ({} sectors)",
            track.number,
            pcm.len(),
            pcm.len() / 2352
        );

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

    // The same backing can be streamed instead of buffered: pull sector-aligned
    // chunks so a player never holds a whole track in memory at once. (A backing
    // whose tracks are addressed contiguously — a gap-stripped extract — would
    // open with `TrackBounds::Gapless`, or supply its own bounds via
    // `open_track_stream_at`; this demo TOC has no trailing data track, so plain
    // `open_track_stream` is equivalent.)
    let mut stream = open_track_stream(&disc, &toc, 1)?;
    let (mut chunks, mut bytes) = (0u32, 0usize);
    while let Some(chunk) = stream.next_chunk()? {
        chunks += 1;
        bytes += chunk.len();
    }
    println!(
        "streamed track 1: {bytes} bytes in {chunks} chunks ({:.1}s of audio)",
        stream.total_seconds()
    );

    Ok(())
}