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,
};
pub const CHUNK_DAOX: [u8; 4] = *b"DAOX";
pub const CHUNK_DAOI: [u8; 4] = *b"DAOI";
pub const CHUNK_MTYP: [u8; 4] = *b"MTYP";
pub const CHUNK_END: [u8; 4] = *b"END!";
pub const MAGIC_NER5: [u8; 4] = *b"NER5";
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,
}
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)
}
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;
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, 0x0300 => 2048, 0x0500 => 2336, 0x0600 => 2048, 0x0700 => 2324, 0x0F00 => 2352, 0x1000 => 2448, _ => 2352,
}
}
pub fn extract_nrg_referenced_files<P: AsRef<Path>>(_nrg_path: P) -> Vec<PathBuf> {
Vec::new()
}