Struct TrackStream 

pub struct TrackStream<'a> { /* private fields */ }

Track-scoped streaming reader for audio or data sectors.

You can pull sector-aligned chunks incrementally and seek to track-relative sector or time positions. Create a stream with CdReader::open_track_stream.

Implementations

impl<'a> TrackStream<'a>

pub fn with_sectors_per_chunk(self, sectors: u32) -> Self

Set the target chunk size in sectors (default 27).

The byte size of a chunk also depends on the SectorReadFormat selected in ReadOptions. A value of zero is normalized to one sector.

pub fn next_chunk(&mut self) -> Result<Option<Vec<u8>>, CdReaderError>

Read the next chunk of sector data.

Returns Ok(None) when end-of-track is reached. The bytes per sector depend on the SectorReadFormat selected in ReadOptions.

Errors

Returns CdReaderError::Io or CdReaderError::Scsi if the drive read fails. The stream position does not advance on error.

Examples found in repository

examples/stream_last_track.rs (line 22)

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/save_data_track.rs (line 106)

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

examples/stream_with_progress.rs (line 28)

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 total_sectors(&self) -> u32

Total number of sectors in this track stream.

Examples found in repository

examples/save_data_track.rs (line 102)

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

examples/stream_with_progress.rs (line 23)

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 current_sector(&self) -> u32

Current stream position as a track-relative sector index. Keep in mind that if you are playing the sound directly, this is likely not the track’s current position because you probably keep some of the data in your buffer.

Examples found in repository

examples/save_data_track.rs (line 110)

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

pub fn seek_to_sector(&mut self, sector: u32) -> Result<(), CdReaderError>

Seek to a sector position relative to the start of the track.

Valid range is 0..=total_sectors().

Errors

Returns CdReaderError::Io containing std::io::ErrorKind::InvalidInput if sector exceeds the track length.

pub fn current_seconds(&self) -> f32

Current stream position in seconds. Functionally equivalent to “current_sector”, but converted to seconds.

CD addresses advance at 75 sectors = 1 second.

Examples found in repository

examples/stream_with_progress.rs (line 31)

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 total_seconds(&self) -> f32

Total stream duration in seconds. Functionally equivalent to “total_sectors”, but converted to seconds.

CD addresses advance at 75 sectors = 1 second.

Examples found in repository

examples/stream_with_progress.rs (line 19)

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 seek_to_seconds(&mut self, seconds: f32) -> Result<(), CdReaderError>

Seek to a time position relative to the start of the track in seconds.

Input is converted to sector offset and clamped to track bounds.

Errors

Returns CdReaderError::Io containing std::io::ErrorKind::InvalidInput if seconds is negative or not finite.