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
}
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,
});
}
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()
);
for track in &mut desc.tracks {
track.file_path = Some(path.to_path_buf());
}
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)
}
pub fn extract_mdx_referenced_files<P: AsRef<Path>>(_mdx_path: P) -> Vec<PathBuf> {
Vec::new()
}