disclady 0.4.0

Pure Rust library and CLI utility for optical and storage disc image heuristics, inspection, and format detection (CD, DVD, GDI, Hard Disk, LaserDisc, CHD).
Documentation
//! Nero Burning ROM (.nrg) container parser and analyzer.

use std::fs::File;
use std::io::{BufReader, Read, Seek, SeekFrom};
use std::path::{Path, PathBuf};

use crate::iso::parse_iso_pvd;
use crate::types::{
    Confidence, DiscDescriptor, DiscError, DiscType, Platform, TrackDescriptor, TrackType,
    VolumeInfo,
};

/// FourCC identifier for DAOX chunk (64-bit).
pub const CHUNK_DAOX: [u8; 4] = *b"DAOX";
/// FourCC identifier for DAOI chunk (32-bit).
pub const CHUNK_DAOI: [u8; 4] = *b"DAOI";
/// FourCC identifier for MTYP chunk (Media type).
pub const CHUNK_MTYP: [u8; 4] = *b"MTYP";
/// FourCC identifier for END! chunk.
pub const CHUNK_END: [u8; 4] = *b"END!";

/// Magic signature for NRG v2 trailer (last 12 bytes: NER5 + u64 offset).
pub const MAGIC_NER5: [u8; 4] = *b"NER5";
/// Magic signature for NRG v1 trailer (last 8 bytes: NERO + u32 offset).
pub const MAGIC_NERO: [u8; 4] = *b"NERO";

#[derive(Debug, Clone)]
struct ParsedNrgTrack {
    track_num: u8,
    mode_code: u16,
    sector_size: u32,
    pregap_offset: u64,
    start_offset: u64,
    end_offset: u64,
}

/// Analyzes an `.nrg` file on disk.
pub(crate) fn inspect_nrg<P: AsRef<Path>>(nrg_path: P) -> Result<DiscDescriptor, DiscError> {
    let path = nrg_path.as_ref();
    let file = File::open(path)?;
    let meta_len = file.metadata()?.len();
    let mut reader = BufReader::new(file);

    detect_nrg_from_reader(&mut reader, meta_len)
}

/// Detects and parses an NRG image from a seekable stream.
pub fn detect_nrg_from_reader<R: Read + Seek>(
    reader: &mut R,
    file_size: u64,
) -> Result<DiscDescriptor, DiscError> {
    if file_size < 12 {
        return Ok(DiscDescriptor::unknown(
            "File too small to be a valid NRG image (< 12 bytes)",
        ));
    }

    reader.seek(SeekFrom::End(-12))?;
    let mut tail12 = [0u8; 12];
    reader.read_exact(&mut tail12)?;

    let (is_v2, chunk_offset) = if tail12[0..4] == MAGIC_NER5 {
        let offset = u64::from_be_bytes([
            tail12[4], tail12[5], tail12[6], tail12[7], tail12[8], tail12[9], tail12[10],
            tail12[11],
        ]);
        (true, offset)
    } else if tail12[4..8] == MAGIC_NERO {
        let offset = u32::from_be_bytes([tail12[8], tail12[9], tail12[10], tail12[11]]) as u64;
        (false, offset)
    } else {
        return Ok(DiscDescriptor::unknown(
            "Missing NER5 or NERO signature in file trailer",
        ));
    };

    let trailer_len = if is_v2 { 12u64 } else { 8u64 };
    if chunk_offset > file_size.saturating_sub(trailer_len) {
        return Ok(DiscDescriptor::unknown(format!(
            "Invalid NRG chunk offset {chunk_offset} exceeds file size {file_size}"
        )));
    }

    let chunk_data_len = (file_size - trailer_len) - chunk_offset;
    if chunk_data_len > 16 * 1024 * 1024 {
        return Ok(DiscDescriptor::unknown(
            "NRG chunk chain exceeds 16 MiB sanity limit",
        ));
    }

    reader.seek(SeekFrom::Start(chunk_offset))?;
    let mut chunk_bytes = vec![0u8; chunk_data_len as usize];
    reader.read_exact(&mut chunk_bytes)?;

    let mut pos = 0usize;
    let mut tracks = Vec::new();
    let mut media_type = 1u32; // 1 = CD, 2 = DVD

    while pos + 8 <= chunk_bytes.len() {
        let chunk_id = &chunk_bytes[pos..pos + 4];
        let chunk_size = u32::from_be_bytes([
            chunk_bytes[pos + 4],
            chunk_bytes[pos + 5],
            chunk_bytes[pos + 6],
            chunk_bytes[pos + 7],
        ]) as usize;
        let payload_start = pos + 8;
        let Some(payload_end) = payload_start.checked_add(chunk_size) else {
            break;
        };

        if payload_end > chunk_bytes.len() {
            break;
        }

        let payload = &chunk_bytes[payload_start..payload_end];

        if chunk_id == CHUNK_DAOX {
            if payload.len() >= 22 {
                let track_size = 42usize;
                let num_tracks = (payload.len() - 22) / track_size;
                for t in 0..num_tracks {
                    let off = 22 + t * track_size;
                    let t_bytes = &payload[off..off + track_size];
                    let sec_size = u16::from_be_bytes([t_bytes[12], t_bytes[13]]) as u32;
                    let mode_code = u16::from_be_bytes([t_bytes[14], t_bytes[15]]);
                    let pregap_offset = u64::from_be_bytes([
                        t_bytes[18],
                        t_bytes[19],
                        t_bytes[20],
                        t_bytes[21],
                        t_bytes[22],
                        t_bytes[23],
                        t_bytes[24],
                        t_bytes[25],
                    ]);
                    let start_offset = u64::from_be_bytes([
                        t_bytes[26],
                        t_bytes[27],
                        t_bytes[28],
                        t_bytes[29],
                        t_bytes[30],
                        t_bytes[31],
                        t_bytes[32],
                        t_bytes[33],
                    ]);
                    let end_offset = u64::from_be_bytes([
                        t_bytes[34],
                        t_bytes[35],
                        t_bytes[36],
                        t_bytes[37],
                        t_bytes[38],
                        t_bytes[39],
                        t_bytes[40],
                        t_bytes[41],
                    ]);
                    let track_num = (tracks.len() + 1) as u8;

                    tracks.push(ParsedNrgTrack {
                        track_num,
                        mode_code,
                        sector_size: if sec_size > 0 {
                            sec_size
                        } else {
                            mode_to_sector_size(mode_code)
                        },
                        pregap_offset,
                        start_offset,
                        end_offset,
                    });
                }
            }
        } else if chunk_id == CHUNK_DAOI {
            if payload.len() >= 22 {
                let track_size = 30usize;
                let num_tracks = (payload.len() - 22) / track_size;
                for t in 0..num_tracks {
                    let off = 22 + t * track_size;
                    let t_bytes = &payload[off..off + track_size];
                    let sec_size = u16::from_be_bytes([t_bytes[12], t_bytes[13]]) as u32;
                    let mode_code = u16::from_be_bytes([t_bytes[14], t_bytes[15]]);
                    let pregap_offset =
                        u32::from_be_bytes([t_bytes[18], t_bytes[19], t_bytes[20], t_bytes[21]])
                            as u64;
                    let start_offset =
                        u32::from_be_bytes([t_bytes[22], t_bytes[23], t_bytes[24], t_bytes[25]])
                            as u64;
                    let end_offset =
                        u32::from_be_bytes([t_bytes[26], t_bytes[27], t_bytes[28], t_bytes[29]])
                            as u64;
                    let track_num = (tracks.len() + 1) as u8;

                    tracks.push(ParsedNrgTrack {
                        track_num,
                        mode_code,
                        sector_size: if sec_size > 0 {
                            sec_size
                        } else {
                            mode_to_sector_size(mode_code)
                        },
                        pregap_offset,
                        start_offset,
                        end_offset,
                    });
                }
            }
        } else if chunk_id == CHUNK_MTYP && payload.len() >= 4 {
            media_type = u32::from_be_bytes([payload[0], payload[1], payload[2], payload[3]]);
        } else if chunk_id == CHUNK_END {
            break;
        }

        pos = payload_end;
    }

    if tracks.is_empty() {
        return Ok(DiscDescriptor::unknown(
            "NRG container contains no valid track chunks (DAOX/DAOI)",
        ));
    }

    let is_dvd = media_type == 2;
    let disc_type = if is_dvd { DiscType::Dvd } else { DiscType::Cd };

    let mut out_tracks = Vec::new();
    let mut current_lba = 0u64;

    for t in &tracks {
        let sec_size = if is_dvd { 2048 } else { t.sector_size };
        let track_len_bytes = t.end_offset.saturating_sub(t.start_offset);
        let sector_count = if sec_size > 0 {
            track_len_bytes / (sec_size as u64)
        } else {
            0
        };

        let mode_byte = if (t.mode_code & 0xFF00) != 0 {
            (t.mode_code >> 8) as u8
        } else {
            (t.mode_code & 0xFF) as u8
        };

        let is_audio = mode_byte == 0x07 || mode_byte == 0x10;
        let track_type = if is_dvd {
            TrackType::DvdData
        } else if is_audio {
            TrackType::Audio
        } else if sec_size == 2048 {
            TrackType::Mode1_2048
        } else if mode_byte == 0x02 || mode_byte == 0x03 {
            TrackType::Mode2_2336
        } else if mode_byte == 0x06 || mode_byte == 0x11 {
            TrackType::Mode2_2352
        } else {
            TrackType::Mode1_2352
        };

        let pregap_sectors = if t.pregap_offset < t.start_offset && sec_size > 0 {
            Some(((t.start_offset - t.pregap_offset) / (sec_size as u64)) as u32)
        } else {
            None
        };

        out_tracks.push(TrackDescriptor {
            track_number: t.track_num as u32,
            track_type,
            sector_size: sec_size,
            start_lba: current_lba,
            sector_count: Some(sector_count),
            file_path: None,
            pregap_sectors,
        });

        current_lba += sector_count;
    }

    let mut volume_info = None;
    let first_data = tracks.iter().find(|t| {
        let mode_byte = if (t.mode_code & 0xFF00) != 0 {
            (t.mode_code >> 8) as u8
        } else {
            (t.mode_code & 0xFF) as u8
        };
        mode_byte != 0x07 && mode_byte != 0x10
    });
    if let Some(t1) = first_data {
        let sec_size = if is_dvd { 2048 } else { t1.sector_size };
        let track_len_bytes = t1.end_offset.saturating_sub(t1.start_offset);
        let mut disc_reader = crate::metadata::StreamDiscReader::new_with_offset(
            reader,
            t1.start_offset,
            sec_size,
            track_len_bytes,
        );
        let meta = crate::metadata::inspect_metadata(&mut disc_reader, None);
        let mut pvd_sec = [0u8; 2048];
        let mut vol =
            if crate::metadata::DiscReader::read_sector(&mut disc_reader, 16, &mut pvd_sec).is_ok()
            {
                parse_iso_pvd(&pvd_sec).unwrap_or_default()
            } else {
                VolumeInfo::default()
            };
        meta.apply_to_volume_info(&mut vol);
        if vol.platform.is_none() && vol.has_iso9660 {
            vol.platform = Some(Platform::StandardIso);
        }
        volume_info = Some(Box::new(vol));
    }

    let total_sectors = Some(current_lba);
    let primary_sec_size = out_tracks
        .first()
        .map(|t| t.sector_size)
        .unwrap_or(if is_dvd { 2048 } else { 2352 });

    Ok(DiscDescriptor {
        disc_type,
        confidence: Confidence::Definitive,
        primary_sector_size: primary_sec_size,
        total_sectors,
        total_size_bytes: Some(file_size),
        tracks: out_tracks,
        volume_info,
        summary: format!(
            "Nero Burning ROM image (.nrg): {} {} format with {} track(s)",
            if is_dvd { "DVD" } else { "CD" },
            if is_v2 { "v2 (NER5)" } else { "v1 (NERO)" },
            tracks.len()
        ),
        chd_plan: None,
    })
}

fn mode_to_sector_size(mode_code: u16) -> u32 {
    match mode_code {
        0x0000 => 2352, // Audio
        0x0300 => 2048, // Mode 1
        0x0500 => 2336, // Mode 2
        0x0600 => 2048, // Mode 2 Form 1
        0x0700 => 2324, // Mode 2 Form 2
        0x0F00 => 2352, // Mode 1/2 Raw
        0x1000 => 2448, // Raw + Subcode
        _ => 2352,
    }
}

/// Returns referenced payload files for an NRG image (empty because NRG is monolithic).
pub fn extract_nrg_referenced_files<P: AsRef<Path>>(_nrg_path: P) -> Vec<PathBuf> {
    Vec::new()
}