use std::fs::File;
use std::path::{Path, PathBuf};
use crate::types::{
Confidence, DiscDescriptor, DiscError, DiscType, Platform, TrackDescriptor, TrackType,
VolumeInfo,
};
pub const GDROM_HIGH_DENSITY_LBA: u64 = 40000;
pub(crate) fn inspect_gdi<P: AsRef<Path>>(gdi_path: P) -> Result<DiscDescriptor, DiscError> {
let path = gdi_path.as_ref();
let content = std::fs::read_to_string(path).map_err(|e| {
DiscError::Io(std::io::Error::new(
e.kind(),
format!("Failed to read GDI file '{}': {e}", path.display()),
))
})?;
let base_dir = path.parent().unwrap_or_else(|| Path::new("."));
Ok(parse_gdi_internal(&content, Some(base_dir), Some(path)))
}
pub fn parse_gdi_descriptor(content: &str, base_dir: Option<&Path>) -> DiscDescriptor {
parse_gdi_internal(content, base_dir, None)
}
fn parse_gdi_internal(
content: &str,
base_dir: Option<&Path>,
gdi_path: Option<&Path>,
) -> DiscDescriptor {
let mut lines = content.lines().map(|l| l.trim()).filter(|l| !l.is_empty());
let track_count_str = match lines.next() {
Some(s) => s,
None => return DiscDescriptor::unknown("Empty GDI descriptor file"),
};
let expected_tracks = match track_count_str.parse::<usize>() {
Ok(n) if (3..=99).contains(&n) => n,
_ => {
return DiscDescriptor::unknown(format!(
"Invalid GDI track count '{track_count_str}': must be between 3 and 99"
))
}
};
let mut tracks = Vec::with_capacity(expected_tracks);
let mut has_high_density = false;
let mut total_size_bytes = 0u64;
for (index, line) in lines.enumerate() {
if index >= expected_tracks {
break;
}
let tokens = tokenize_gdi_line(line);
if tokens.len() < 5 {
return DiscDescriptor::unknown(format!(
"Malformed GDI line #{}: insufficient tokens (expected >= 5)",
index + 2
));
}
let track_num = match tokens[0].parse::<u32>() {
Ok(num) if num == (index + 1) as u32 => num,
_ => {
return DiscDescriptor::unknown(format!(
"Invalid GDI track sequence: expected track #{}, found '{}'",
index + 1,
tokens[0]
))
}
};
let start_lba = match tokens[1].parse::<u64>() {
Ok(lba) => lba,
Err(_) => {
return DiscDescriptor::unknown(format!(
"Invalid GDI start LBA '{}' on track #{track_num}",
tokens[1]
))
}
};
let track_type_code = match tokens[2].parse::<u32>() {
Ok(code) if code == 0 || code == 4 => code,
_ => {
return DiscDescriptor::unknown(format!(
"Invalid GDI track type '{}' on track #{track_num} (expected 0 or 4)",
tokens[2]
))
}
};
let sector_size = match tokens[3].parse::<u32>() {
Ok(sz) if sz == 2048 || sz == 2352 || sz == 2336 => sz,
_ => {
return DiscDescriptor::unknown(format!(
"Invalid GDI sector size '{}' on track #{track_num}",
tokens[3]
))
}
};
let filename = &tokens[4];
if track_num == 1 && start_lba != 0 {
return DiscDescriptor::unknown(format!(
"Invalid GDI descriptor: track 1 must start at LBA 0 (found {start_lba})"
));
}
if start_lba >= GDROM_HIGH_DENSITY_LBA {
has_high_density = true;
}
let track_type = match track_type_code {
0 => TrackType::Audio,
4 => TrackType::GdiData,
_ => TrackType::Unknown,
};
let resolved_path = match base_dir {
Some(dir) => dir.join(filename),
None => PathBuf::from(filename),
};
let mut sector_count = None;
if resolved_path.exists() {
if let Ok(meta) = std::fs::metadata(&resolved_path) {
if meta.len() == 0 {
return DiscDescriptor::unknown(format!(
"Referenced GDI track file '{}' is empty (0 bytes)",
resolved_path.display()
));
}
total_size_bytes += meta.len();
if sector_size > 0 {
sector_count = Some(meta.len() / (sector_size as u64));
}
}
}
tracks.push(TrackDescriptor {
track_number: track_num,
track_type,
sector_size,
start_lba,
sector_count,
file_path: Some(resolved_path),
pregap_sectors: None,
});
}
if tracks.len() != expected_tracks {
return DiscDescriptor::unknown(format!(
"GDI specifies {expected_tracks} tracks, but only {} valid track lines were found",
tracks.len()
));
}
if !has_high_density {
return DiscDescriptor::unknown(
"Invalid GDI descriptor: missing high-density partition (no track with LBA >= 40000)"
.to_string(),
);
}
let primary_sector_size = tracks.first().map(|t| t.sector_size).unwrap_or(2352);
let total_sectors = if total_size_bytes > 0 && primary_sector_size > 0 {
Some(total_size_bytes / (primary_sector_size as u64))
} else {
None
};
let mut volume_info = VolumeInfo {
platform: Some(Platform::Dreamcast),
..Default::default()
};
if let Some(track3) = tracks
.iter()
.find(|t| t.start_lba >= GDROM_HIGH_DENSITY_LBA)
{
if let Some(ref path) = track3.file_path {
if path.exists() {
if let Ok(mut file) = File::open(path) {
let meta_len = file.metadata().map(|m| m.len()).unwrap_or(0);
if meta_len > 0 {
let mut disc_reader = crate::metadata::StreamDiscReader::new(
&mut file,
track3.sector_size,
meta_len,
);
let meta = crate::metadata::inspect_metadata(&mut disc_reader, gdi_path);
let mut pvd_sec = [0u8; 2048];
if crate::metadata::DiscReader::read_sector(
&mut disc_reader,
16,
&mut pvd_sec,
)
.is_ok()
{
if let Some(pvd_vol) = crate::iso::parse_iso_pvd(&pvd_sec) {
volume_info = pvd_vol;
}
}
meta.apply_to_volume_info(&mut volume_info);
volume_info.platform = Some(Platform::Dreamcast);
if volume_info.system_identifier.is_none() {
volume_info.system_identifier = Some("SEGA SEGAKATANA".to_string());
}
let mut sec0 = [0u8; 2048];
if crate::metadata::DiscReader::read_sector(&mut disc_reader, 0, &mut sec0)
.is_ok()
&& sec0.starts_with(b"SEGA SEGAKATANA ")
{
let dc_meta = crate::console::extract_dreamcast_full_metadata(&sec0);
if volume_info.publisher_identifier.is_none() {
volume_info.publisher_identifier = dc_meta.publisher;
}
if volume_info.application_identifier.is_none() {
volume_info.application_identifier = dc_meta.boot_file;
}
}
}
}
}
}
}
if volume_info.title.is_none() {
if let Some(clean_title) = gdi_path.and_then(crate::metadata::sanitize_image_basename) {
volume_info.title = Some(clean_title);
}
}
let track_count = tracks.len();
let base_summary = format!(
"Dreamcast GDI image with {} tracks (high-density GD-ROM partition verified)",
track_count
);
let id_str = volume_info
.disc_id
.as_deref()
.map(|id| format!(" [{id}]"))
.unwrap_or_default();
let title_str = volume_info
.title
.as_deref()
.map(|t| format!(" \"{t}\""))
.unwrap_or_default();
let summary = if !id_str.is_empty() || !title_str.is_empty() {
format!("Sega Dreamcast disc{id_str}{title_str} ({base_summary})")
} else {
base_summary
};
DiscDescriptor {
disc_type: DiscType::Gdi,
confidence: Confidence::Definitive,
primary_sector_size,
total_sectors,
total_size_bytes: if total_size_bytes > 0 {
Some(total_size_bytes)
} else {
None
},
tracks,
volume_info: Some(Box::new(volume_info)),
summary,
chd_plan: None,
}
}
fn tokenize_gdi_line(line: &str) -> Vec<String> {
let mut tokens = Vec::new();
let mut chars = line.chars().peekable();
while let Some(&c) = chars.peek() {
if c.is_whitespace() {
chars.next();
continue;
}
if c == '"' {
chars.next();
let mut s = String::new();
for sc in chars.by_ref() {
if sc == '"' {
break;
}
s.push(sc);
}
tokens.push(s);
} else {
let mut word = String::new();
while let Some(&wc) = chars.peek() {
if wc.is_whitespace() || wc == '"' {
break;
}
word.push(wc);
chars.next();
}
tokens.push(word);
}
}
tokens
}
pub(crate) fn extract_gdi_referenced_files<P: AsRef<Path>>(gdi_path: P) -> Vec<PathBuf> {
let path = gdi_path.as_ref();
let content = match std::fs::read_to_string(path) {
Ok(c) => c,
Err(_) => return Vec::new(),
};
let base_dir = path.parent().unwrap_or_else(|| Path::new("."));
extract_gdi_referenced_files_from_content(&content, Some(base_dir))
}
pub fn extract_gdi_referenced_files_from_content(
content: &str,
base_dir: Option<&Path>,
) -> Vec<PathBuf> {
let mut lines = content.lines().map(|l| l.trim()).filter(|l| !l.is_empty());
let _ = lines.next();
let mut files = Vec::new();
for line in lines {
let tokens = tokenize_gdi_line(line);
if tokens.len() >= 5 {
let filename = &tokens[4];
let normalized = filename.replace('\\', "/");
let file_path = Path::new(&normalized);
let is_win_drive = normalized.len() >= 2
&& normalized.as_bytes()[0].is_ascii_alphabetic()
&& normalized.as_bytes()[1] == b':';
let resolved = match base_dir {
Some(dir) => {
if is_win_drive {
if let Some(name) = Path::new(&normalized).file_name() {
dir.join(name)
} else {
PathBuf::from(&normalized)
}
} else if file_path.is_absolute() {
file_path.to_path_buf()
} else {
dir.join(file_path)
}
}
None => file_path.to_path_buf(),
};
files.push(resolved);
}
}
files
}