use std::fs::File;
use std::io::BufReader;
use std::path::{Path, PathBuf};
use crate::iso::parse_iso_pvd;
use crate::types::{
Confidence, DiscDescriptor, DiscError, DiscType, Platform, TrackDescriptor, TrackType,
VolumeInfo,
};
pub const MDS_MAGIC: &[u8; 16] = b"MEDIA DESCRIPTOR";
const MDS_HEADER_MIN_SIZE: usize = 80;
const MDS_SESSION_BLOCK_SIZE: usize = 24;
const MDS_SESSION_BLOCK_SIZE_V2: usize = 32;
const MDS_TRACK_BLOCK_SIZE: usize = 80;
const MDS_MEDIUM_DVD: u16 = 0x0010;
const MDS_MEDIUM_DVD_PLUS_R_DL: u16 = 0x0016;
pub(crate) fn inspect_mds<P: AsRef<Path>>(mds_path: P) -> Result<DiscDescriptor, DiscError> {
let path = mds_path.as_ref();
let data = std::fs::read(path).map_err(|e| {
DiscError::Io(std::io::Error::new(
e.kind(),
format!("Failed to read MDS file '{}': {e}", path.display()),
))
})?;
let base_dir = path.parent().unwrap_or_else(|| Path::new("."));
let stem = path.file_stem().and_then(|s| s.to_str());
Ok(parse_mds_descriptor(&data, Some(base_dir), stem))
}
pub fn parse_mds_descriptor(
data: &[u8],
base_dir: Option<&Path>,
mds_stem: Option<&str>,
) -> DiscDescriptor {
if data.len() < MDS_HEADER_MIN_SIZE {
return DiscDescriptor::unknown(format!(
"MDS file is too short ({} bytes, minimum {})",
data.len(),
MDS_HEADER_MIN_SIZE
));
}
if !data.starts_with(MDS_MAGIC) {
return DiscDescriptor::unknown("Invalid MDS signature: missing 'MEDIA DESCRIPTOR' magic");
}
let medium_type = u16::from_le_bytes([data[18], data[19]]);
let num_sessions = u16::from_le_bytes([data[20], data[21]]);
if num_sessions == 0 {
return DiscDescriptor::unknown("MDS header specifies 0 sessions");
}
let sessions_offset = if data.len() >= 0x54 {
let off = u32::from_le_bytes([data[0x50], data[0x51], data[0x52], data[0x53]]);
if off > 0 && (off as usize) < data.len() {
off
} else if data.len() >= 0x4a {
u32::from_le_bytes([data[0x46], data[0x47], data[0x48], data[0x49]])
} else {
0x60
}
} else if data.len() >= 0x4a {
u32::from_le_bytes([data[0x46], data[0x47], data[0x48], data[0x49]])
} else {
0x60
};
let version_major = data[16];
let is_v2 = version_major >= 2;
let session_block_size = if is_v2 {
MDS_SESSION_BLOCK_SIZE_V2
} else {
MDS_SESSION_BLOCK_SIZE
};
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 mut tracks = Vec::new();
let mut total_sectors_calc = 0u64;
let mut embedded_filename: Option<String> = None;
for s in 0..num_sessions as usize {
let Some(sess_offset) = s.checked_mul(session_block_size) else {
break;
};
let Some(sess_pos) = (sessions_offset as usize).checked_add(sess_offset) else {
break;
};
if sess_pos
.checked_add(session_block_size)
.is_none_or(|end| end > 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 Some(trk_offset) = t.checked_mul(MDS_TRACK_BLOCK_SIZE) else {
break;
};
let Some(trk_pos) = track_data_offset.checked_add(trk_offset) else {
break;
};
if trk_pos
.checked_add(MDS_TRACK_BLOCK_SIZE)
.is_none_or(|end| end > data.len())
{
break;
}
let t_data = &data[trk_pos..trk_pos + MDS_TRACK_BLOCK_SIZE];
let mode = t_data[0];
let subchannel_mode = t_data[1];
let adr_control = t_data[2];
let track_num = t_data[3];
let point = t_data[4];
if !(1..=99).contains(&point) {
continue;
}
let extra_offset =
u32::from_le_bytes([t_data[12], t_data[13], t_data[14], t_data[15]]) as usize;
let raw_sector_size = u16::from_le_bytes([t_data[16], t_data[17]]) as u32;
let sector_size = if raw_sector_size == 0 {
if subchannel_mode == 0x08 {
2448
} else if is_dvd {
2048
} else {
2352
}
} else {
raw_sector_size
};
let start_lba =
i32::from_le_bytes([t_data[36], t_data[37], t_data[38], t_data[39]]).max(0) as u64;
let (pregap_sectors, sector_count) = if extra_offset > 0
&& extra_offset
.checked_add(8)
.is_some_and(|end| end <= data.len())
{
let pg = u32::from_le_bytes([
data[extra_offset],
data[extra_offset + 1],
data[extra_offset + 2],
data[extra_offset + 3],
]);
let sc = u32::from_le_bytes([
data[extra_offset + 4],
data[extra_offset + 5],
data[extra_offset + 6],
data[extra_offset + 7],
]) as u64;
(pg, sc)
} else {
(0, 0)
};
let footer_or_fn_offset =
u32::from_le_bytes([t_data[52], t_data[53], t_data[54], t_data[55]]) as usize;
let (fn_block_offset, sector_count) = if is_v2 {
if footer_or_fn_offset > 0
&& footer_or_fn_offset
.checked_add(32)
.is_some_and(|end| end <= data.len())
{
let fn_off = u32::from_le_bytes(
data[footer_or_fn_offset..footer_or_fn_offset + 4]
.try_into()
.unwrap(),
) as usize;
let trk_len = u64::from_le_bytes(
data[footer_or_fn_offset + 16..footer_or_fn_offset + 24]
.try_into()
.unwrap(),
);
let sc = if trk_len > 0 { trk_len } else { sector_count };
(fn_off, sc)
} else {
(footer_or_fn_offset, sector_count)
}
} else {
(footer_or_fn_offset, sector_count)
};
if embedded_filename.is_none()
&& fn_block_offset > 0
&& fn_block_offset
.checked_add(8)
.is_some_and(|end| end <= data.len())
{
let name_offset = u32::from_le_bytes([
data[fn_block_offset],
data[fn_block_offset + 1],
data[fn_block_offset + 2],
data[fn_block_offset + 3],
]) as usize;
let is_wide = u32::from_le_bytes([
data[fn_block_offset + 4],
data[fn_block_offset + 5],
data[fn_block_offset + 6],
data[fn_block_offset + 7],
]);
if name_offset > 0 && name_offset < data.len() {
let raw_slice = &data[name_offset..];
if is_wide == 1 {
let mut u16_chars = Vec::new();
for chunk in raw_slice.as_chunks::<2>().0 {
let c = u16::from_le_bytes(*chunk);
if c == 0 {
break;
}
u16_chars.push(c);
}
if let Ok(name) = String::from_utf16(&u16_chars) {
if !name.trim().is_empty() && name != "*" {
embedded_filename = Some(name.trim().to_string());
}
}
} else {
let null_pos = raw_slice
.iter()
.position(|&b| b == 0)
.unwrap_or(raw_slice.len());
if let Ok(name) = std::str::from_utf8(&raw_slice[..null_pos]) {
if !name.trim().is_empty() && name != "*" {
embedded_filename = Some(name.trim().to_string());
}
}
}
}
}
let is_data = (adr_control & 0x04) != 0;
let track_type = if is_dvd {
TrackType::DvdData
} else if is_data {
if mode == 2 {
TrackType::Mode2_2352
} else if sector_size == 2048 {
TrackType::Mode1_2048
} else {
TrackType::Mode1_2352
}
} else {
TrackType::Audio
};
total_sectors_calc += sector_count;
tracks.push(TrackDescriptor {
track_number: if track_num == 0 {
point as u32
} else {
track_num as u32
},
track_type,
sector_size,
start_lba,
sector_count: if sector_count > 0 {
Some(sector_count)
} else {
None
},
file_path: None,
pregap_sectors: if pregap_sectors > 0 {
Some(pregap_sectors)
} else {
None
},
});
}
}
if tracks.is_empty() {
return DiscDescriptor::unknown("MDS descriptor contains no valid user tracks");
}
let resolved_mdf_path = if let Some(dir) = base_dir {
if let Some(ref name) = embedded_filename {
let p = dir.join(name);
if p.is_file() {
Some(p)
} else if let Some(stem) = mds_stem {
let candidate = dir.join(format!("{stem}.mdf"));
if candidate.is_file() {
Some(candidate)
} else {
Some(dir.join(format!("{stem}.MDF")))
}
} else {
Some(p)
}
} else if let Some(stem) = mds_stem {
let candidate_lower = dir.join(format!("{stem}.mdf"));
if candidate_lower.is_file() {
Some(candidate_lower)
} else {
let candidate_upper = dir.join(format!("{stem}.MDF"));
if candidate_upper.is_file() {
Some(candidate_upper)
} else {
Some(candidate_lower)
}
}
} else {
None
}
} else {
None
};
for track in &mut tracks {
track.file_path = resolved_mdf_path.clone();
}
let mut volume_info = None;
let mut total_size_bytes = None;
let mut total_sectors = if total_sectors_calc > 0 {
Some(total_sectors_calc)
} else {
None
};
let primary_sec_size =
tracks
.first()
.map(|t| t.sector_size)
.unwrap_or(if is_dvd { 2048 } else { 2352 });
if let Some(ref mdf_path) = resolved_mdf_path {
if let Ok(file) = File::open(mdf_path) {
let meta_len = file.metadata().map(|m| m.len()).unwrap_or(0);
if meta_len > 0 {
total_size_bytes = Some(meta_len);
if total_sectors.is_none() && primary_sec_size > 0 {
total_sectors = Some(meta_len / primary_sec_size as u64);
}
}
let mut reader = BufReader::new(file);
let first_data_track = tracks.iter().find(|t| t.track_type != TrackType::Audio);
if let Some(t1) = first_data_track {
let track_byte_offset = t1.start_lba * (t1.sector_size as u64);
let base_offset = if track_byte_offset + (t1.sector_size as u64) <= meta_len {
track_byte_offset
} else {
0
};
let mut disc_reader = crate::metadata::StreamDiscReader::new_with_offset(
&mut reader,
base_offset,
t1.sector_size,
meta_len,
);
let meta = crate::metadata::inspect_metadata(
&mut disc_reader,
resolved_mdf_path.as_deref(),
);
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));
}
}
}
if volume_info.is_none() {
let fallback_title = resolved_mdf_path
.as_deref()
.and_then(crate::metadata::sanitize_image_basename)
.or_else(|| {
mds_stem.and_then(|s| crate::metadata::sanitize_image_basename(Path::new(s)))
});
if let Some(clean_title) = fallback_title {
let vol = VolumeInfo {
title: Some(clean_title),
..Default::default()
};
volume_info = Some(Box::new(vol));
}
}
if total_size_bytes.is_none() {
if let Some(sec) = total_sectors {
total_size_bytes = Some(sec * primary_sec_size as u64);
}
}
let track_count = tracks.len();
DiscDescriptor {
disc_type,
confidence: Confidence::Definitive,
primary_sector_size: primary_sec_size,
total_sectors,
total_size_bytes,
tracks,
volume_info,
summary: format!(
"Alcohol 120% disc descriptor (.mds{}): {} medium with {} track(s)",
if is_v2 { " v2" } else { "" },
if is_dvd { "DVD" } else { "CD" },
track_count
),
chd_plan: None,
}
}
pub fn extract_mds_referenced_files<P: AsRef<Path>>(mds_path: P) -> Vec<PathBuf> {
let p = mds_path.as_ref();
let mut files = Vec::new();
let mdf = p.with_extension("mdf");
if mdf.is_file() {
files.push(mdf);
} else {
let mdf_upper = p.with_extension("MDF");
if mdf_upper.is_file() {
files.push(mdf_upper);
} else {
files.push(mdf);
}
}
files
}