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
//! DAEMON Tools (.mdx) disc 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::mds::{parse_mds_descriptor, MDS_MAGIC};
use crate::types::{
    Confidence, DiscDescriptor, DiscError, DiscType, Platform, TrackType, VolumeInfo,
};

const MDX_HEADER_MIN_SIZE: usize = 80;
const MDS_MEDIUM_DVD: u16 = 0x0010;
const MDS_MEDIUM_DVD_PLUS_R_DL: u16 = 0x0016;

fn find_track_file_offset(data: &[u8], point: u8) -> Option<u64> {
    if data.len() < 0x54 {
        return None;
    }
    let is_v2 = data.get(16).is_some_and(|&v| v >= 2);
    let session_block_size = if is_v2 { 32 } else { 24 };
    let sessions_offset = {
        let off = u32::from_le_bytes([data[0x50], data[0x51], data[0x52], data[0x53]]) as usize;
        if off > 0 && off < data.len() {
            off
        } else if data.len() >= 0x4a {
            u32::from_le_bytes([data[0x46], data[0x47], data[0x48], data[0x49]]) as usize
        } else {
            0x60
        }
    };
    let num_sessions = u16::from_le_bytes([data[20], data[21]]) as usize;

    for s in 0..num_sessions {
        let sess_pos = sessions_offset.checked_add(s.checked_mul(session_block_size)?)?;
        if sess_pos.checked_add(session_block_size)? > data.len() {
            break;
        }
        let s_data = &data[sess_pos..sess_pos + session_block_size];
        let num_all_tracks = s_data[10] as usize;
        let track_data_offset =
            u32::from_le_bytes([s_data[20], s_data[21], s_data[22], s_data[23]]) as usize;

        for t in 0..num_all_tracks {
            let trk_pos = track_data_offset.checked_add(t.checked_mul(80)?)?;
            if trk_pos.checked_add(80)? > data.len() {
                break;
            }
            let t_data = &data[trk_pos..trk_pos + 80];
            let pt = t_data[4];
            if pt == point {
                let off = u64::from_le_bytes(t_data[40..48].try_into().unwrap());
                if off > 0 {
                    return Some(off);
                }
            }
        }
    }
    None
}

/// Analyzes a DAEMON Tools `.mdx` monolithic container on disk.
pub(crate) fn inspect_mdx<P: AsRef<Path>>(mdx_path: P) -> Result<DiscDescriptor, DiscError> {
    let path = mdx_path.as_ref();
    let mut file = File::open(path).map_err(|e| {
        DiscError::Io(std::io::Error::new(
            e.kind(),
            format!("Failed to open MDX file '{}': {e}", path.display()),
        ))
    })?;

    let file_len = file.metadata().map(|m| m.len()).unwrap_or(0);
    if file_len < MDX_HEADER_MIN_SIZE as u64 {
        return Err(DiscError::InvalidDescriptor(format!(
            "MDX file is too short ({} bytes, minimum {})",
            file_len, MDX_HEADER_MIN_SIZE
        )));
    }

    let mut initial_hdr = [0u8; 0x60];
    file.read_exact(&mut initial_hdr).map_err(|e| {
        DiscError::Io(std::io::Error::new(
            e.kind(),
            format!("Failed to read MDX header '{}': {e}", path.display()),
        ))
    })?;

    if &initial_hdr[0..16] != MDS_MAGIC {
        return Err(DiscError::InvalidDescriptor(
            "Invalid MDX signature: missing 'MEDIA DESCRIPTOR' magic".to_string(),
        ));
    }

    let version_major = initial_hdr[16];
    let medium_type = u16::from_le_bytes([initial_hdr[18], initial_hdr[19]]);
    let is_dvd = medium_type == MDS_MEDIUM_DVD || medium_type == MDS_MEDIUM_DVD_PLUS_R_DL;
    let disc_type = if is_dvd { DiscType::Dvd } else { DiscType::Cd };

    let is_v2_encrypted = version_major >= 2 && initial_hdr[0x2c..0x30] == [0xff; 4];

    let stem = path.file_stem().and_then(|s| s.to_str());

    if is_v2_encrypted {
        let clean_title = stem.and_then(|s| crate::metadata::sanitize_image_basename(Path::new(s)));
        let volume_info = clean_title.map(|t| {
            Box::new(VolumeInfo {
                title: Some(t),
                ..Default::default()
            })
        });

        return Ok(DiscDescriptor {
            disc_type,
            confidence: Confidence::Definitive,
            primary_sector_size: if is_dvd { 2048 } else { 2352 },
            total_sectors: None,
            total_size_bytes: Some(file_len),
            tracks: Vec::new(),
            volume_info,
            summary: format!(
                "DAEMON Tools disc container (.mdx): compressed/encrypted {} medium",
                if is_dvd { "DVD" } else { "CD" }
            ),
            chd_plan: None,
        });
    }

    // Uncompressed MDX: descriptor is located at offset 0
    let read_limit = (file_len.min(64 * 1024)) as usize;
    let mut descriptor_buf = vec![0u8; read_limit];
    file.seek(SeekFrom::Start(0)).map_err(DiscError::Io)?;
    file.read_exact(&mut descriptor_buf)
        .map_err(DiscError::Io)?;

    let mut desc = parse_mds_descriptor(&descriptor_buf, None, stem);
    desc.summary = format!(
        "DAEMON Tools disc container (.mdx): {} medium with {} track(s)",
        if is_dvd { "DVD" } else { "CD" },
        desc.tracks.len()
    );

    // In a monolithic MDX container, the payload is contained in the .mdx file itself
    for track in &mut desc.tracks {
        track.file_path = Some(path.to_path_buf());
    }

    // Inspect metadata from sector 16 of the first data track
    if desc.volume_info.as_ref().and_then(|v| v.platform).is_none() {
        if let Some(t1) = desc
            .tracks
            .iter()
            .find(|t| t.track_type != TrackType::Audio)
        {
            let track_byte_offset = find_track_file_offset(&descriptor_buf, t1.track_number as u8)
                .unwrap_or_else(|| t1.start_lba * (t1.sector_size as u64));
            if track_byte_offset + (t1.sector_size as u64) <= file_len {
                let mut reader = BufReader::new(&mut file);
                let mut disc_reader = crate::metadata::StreamDiscReader::new_with_offset(
                    &mut reader,
                    track_byte_offset,
                    t1.sector_size,
                    file_len,
                );
                let meta = crate::metadata::inspect_metadata(&mut disc_reader, Some(path));
                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);
                }
                desc.volume_info = Some(Box::new(vol));
            }
        }
    }

    Ok(desc)
}

/// Returns referenced payload files for a given `.mdx` container path.
///
/// Since MDX is a monolithic container bundling both metadata and disc sectors,
/// no auxiliary track files are referenced.
pub fn extract_mdx_referenced_files<P: AsRef<Path>>(_mdx_path: P) -> Vec<PathBuf> {
    Vec::new()
}