Function lba_to_msf 

pub fn lba_to_msf(lba: u32) -> (u8, u8, u8)

Convert a Logical Block Address to its Minutes/Seconds/Frames address.

MSF addresses include the fixed 2-second (150-frame) lead-in offset, so lba_to_msf(0) is (0, 2, 0). This is handy when building a Toc for a file/image backing (see AudioSectorReader), where you have sector indices but need to populate Track::start_msf.

Examples found in repository

examples/file_backend.rs (line 53)

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

examples/bin_cue_backend.rs (line 272)

fn parse_cue(cue_path: &Path) -> Result<(PathBuf, Toc), Box<dyn Error>> {
    let text = std::fs::read_to_string(cue_path)?;
    let cue_dir = cue_path.parent().unwrap_or(Path::new("."));

    let mut bin_path: Option<PathBuf> = None;
    let mut pending: Option<(u8, bool)> = None;
    let mut tracks: Vec<Track> = Vec::new();

    for line in text.lines() {
        let line = line.trim();
        let mut fields = line.split_whitespace();
        let Some(keyword) = fields.next() else {
            continue;
        };

        match keyword.to_ascii_uppercase().as_str() {
            "FILE" => {
                if bin_path.is_some() {
                    return Err(
                        "multi-FILE cue sheets (one file per track) are not handled by \
                                this example; it assumes a single .bin addressed by sector"
                            .into(),
                    );
                }
                bin_path = Some(cue_dir.join(quoted_or_first_field(line)?));
            }

            "TRACK" => {
                // e.g. `TRACK 03 MODE1/2352`
                let number: u8 = fields.next().ok_or("TRACK line has no number")?.parse()?;
                let mode = fields.next().ok_or("TRACK line has no mode")?;

                // The whole image is addressed as a uniform grid of 2352-byte
                // sectors, so a cooked data track (MODE1/2048) would desync
                // every offset after it. Refuse rather than read garbage.
                let sector_size = mode_sector_size(mode);
                if sector_size != Some(SECTOR_SIZE) {
                    return Err(format!(
                        "track {number} is `{mode}`, which is not stored as 2352-byte sectors; \
                         this example needs a fully raw image"
                    )
                    .into());
                }

                pending = Some((number, mode.eq_ignore_ascii_case("AUDIO")));
            }

            // `INDEX 01 MM:SS:FF` is where the track proper begins.
            "INDEX" => {
                let index = fields.next().ok_or("INDEX line has no number")?;
                let msf = fields.next().ok_or("INDEX line has no timestamp")?;
                if index != "01" {
                    continue;
                }

                let (number, is_audio) = pending
                    .take()
                    .ok_or("INDEX 01 appeared before any TRACK line")?;
                let start_lba = msf_to_frames(msf)?;

                tracks.push(Track {
                    number,
                    start_lba,
                    start_msf: lba_to_msf(start_lba),
                    is_audio,
                });
            }

            _ => {}
        }
    }

    let bin_path = bin_path.ok_or("cue sheet has no FILE line")?;
    if tracks.is_empty() {
        return Err("cue sheet declares no tracks".into());
    }
    tracks.sort_by_key(|track| track.start_lba);

    // The cue has no leadout; the image's own length is the end of the disc.
    let bin_bytes = std::fs::metadata(&bin_path)
        .map_err(|e| format!("cannot open {}: {e}", bin_path.display()))?
        .len();
    let leadout_lba = (bin_bytes / SECTOR_SIZE as u64) as u32;

    let toc = Toc {
        first_track: tracks.first().map_or(1, |track| track.number),
        last_track: tracks.last().map_or(1, |track| track.number),
        tracks,
        leadout_lba,
    };

    Ok((bin_path, toc))
}