Enum SectorReadFormat 

pub enum SectorReadFormat {
    Audio,
    Mode1Cooked,
    Mode1Raw,
    Mode2Raw,
}

Selects the type and layout of sectors returned when reading from an optical drive.

This is the crate’s platform-independent representation of the sector type and main-channel fields requested by the MMC READ CD command (0xBE) or the equivalent platform API.

ReadOptions defaults to Audio, so callers reading audio tracks normally do not need to select a format. For a data track, call CdReader::detect_track_format and pass the result to ReadOptions::with_format. Detection chooses Mode1Cooked for Mode 1 tracks and Mode2Raw for Mode 2 tracks.

Selecting a format does not convert the sectors. It tells the drive what sector type and fields to return, so the selection must match the track being read. A mismatched format may be rejected by the library or the drive.

The Raw variants return the complete 2,352-byte main-channel sector. They do not include subchannel data or C2 error information. Use sector_size to obtain the number of bytes returned per sector for any variant.

Variants

Audio

CD-DA audio as 2,352 bytes of headerless PCM per sector.

The samples are signed 16-bit little-endian stereo at 44.1 kHz. Each sector contains 588 stereo sample frames and represents 1/75 second of audio. The returned bytes can be passed directly to create_wav.

Mode1Cooked

The 2,048-byte user-data field from a Mode 1 sector.

The drive omits the sync pattern, sector header, Error Detection Code (EDC), reserved bytes, and Error Correction Code (ECC). This is usually the preferred representation for reading filesystems; concatenating the cooked sectors of a typical ISO 9660 track produces a directly usable disc image.

Mode1Raw

A complete 2,352-byte Mode 1 main-channel sector.

This includes the 12-byte sync pattern, 4-byte header, 2,048-byte user data field, EDC, reserved bytes, and ECC. Use this when preserving or inspecting the original sector framing. For normal filesystem access, Mode1Cooked is usually more convenient.

Mode2Raw

A complete 2,352-byte Mode 2 main-channel sector.

This is the only Mode 2 representation provided by the crate. Mode 2 XA tracks can mix Form 1 and Form 2 sectors within the same track: Form 1 carries 2,048 bytes of user data with stronger error correction, while Form 2 carries 2,324 bytes of user data.

The form is recorded in each sector’s XA subheader. The crate does not expose a cooked Mode 2 reader or a public XA payload parser, so callers must inspect each sector and extract the appropriate payload themselves.

Implementations

impl SectorReadFormat

pub fn sector_size(&self) -> usize

Bytes returned per sector for this format.

Examples found in repository

examples/save_data_track.rs (line 52)

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

Trait Implementations

impl Clone for SectorReadFormat

fn clone(&self) -> SectorReadFormat

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for SectorReadFormat

impl Debug for SectorReadFormat

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for SectorReadFormat

impl PartialEq for SectorReadFormat

fn eq(&self, other: &SectorReadFormat) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for SectorReadFormat