use std::path::{Path, PathBuf};
use crate::types::{Confidence, DiscDescriptor, DiscError, DiscType, TrackDescriptor, TrackType};
pub(crate) fn inspect_cue<P: AsRef<Path>>(cue_path: P) -> Result<DiscDescriptor, DiscError> {
let path = cue_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 CUE file '{}': {e}", path.display()),
))
})?;
let base_dir = path.parent().unwrap_or_else(|| Path::new("."));
let mut desc = parse_cue_sheet(&content, Some(base_dir));
if let Some(ref mut vol) = desc.volume_info {
let is_track_stem = vol.title.as_deref().is_some_and(|t| {
let l = t.to_ascii_lowercase();
l.contains("(track ") || l.contains("(track_")
});
if vol.title.is_none() || is_track_stem {
if let Some(sanitized) = crate::metadata::sanitize_image_basename(path) {
vol.title = Some(sanitized);
}
}
if let Some(plat) = vol.platform {
let id_str = vol
.disc_id
.as_deref()
.map(|id| format!(" [{id}]"))
.unwrap_or_default();
let title_str = vol
.title
.as_deref()
.map(|t| format!(" \"{t}\""))
.unwrap_or_default();
let base_summary = if desc.tracks.iter().any(|t| t.track_type == TrackType::Audio) {
"CUE sheet contains Red Book audio tracks or WAV files (CD-DA)"
} else {
"CUE sheet specifies raw CD track modes (2352/2336 bytes)"
};
desc.summary = format!("{plat} disc{id_str}{title_str} ({base_summary})");
}
}
Ok(desc)
}
pub fn parse_cue_sheet(content: &str, base_dir: Option<&Path>) -> DiscDescriptor {
let mut tracks = Vec::new();
let mut current_file: Option<PathBuf> = None;
let mut current_track: Option<TrackBuilder> = None;
let mut cue_title: Option<String> = None;
let mut has_audio_tracks = false;
let mut has_cd_modes = false;
let mut has_wav_files = false;
let mut has_recognized_directives = false;
for raw_line in content.lines() {
let line = raw_line.trim();
if line.is_empty() || line.starts_with("REM") {
continue;
}
let tokens = tokenize_cue_line(line);
if tokens.is_empty() {
continue;
}
match tokens[0].to_ascii_uppercase().as_str() {
"FILE" => {
has_recognized_directives = true;
if let Some(tb) = current_track.take() {
tracks.push(tb.build());
}
if tokens.len() >= 3 {
let filename = &tokens[1];
let file_type = &tokens[2];
if file_type.eq_ignore_ascii_case("WAVE")
|| Path::new(filename)
.extension()
.is_some_and(|e| e.eq_ignore_ascii_case("wav"))
{
has_wav_files = true;
}
let resolved = match base_dir {
Some(dir) => dir.join(filename),
None => PathBuf::from(filename),
};
current_file = Some(resolved);
}
}
"TRACK" => {
has_recognized_directives = true;
if let Some(tb) = current_track.take() {
tracks.push(tb.build());
}
if tokens.len() >= 3 {
let track_num = match tokens[1].parse::<u32>() {
Ok(n) => n,
Err(_) => {
return DiscDescriptor::unknown(format!(
"Invalid CUE track number '{}'",
tokens[1]
))
}
};
let mode_str = tokens[2].to_ascii_uppercase();
let (track_type, sector_size) = parse_track_mode(&mode_str);
if track_type == TrackType::Audio {
has_audio_tracks = true;
} else if matches!(
track_type,
TrackType::Mode1_2352
| TrackType::Mode2_2352
| TrackType::Mode2_2336
| TrackType::Cdi2352
) {
has_cd_modes = true;
}
current_track = Some(TrackBuilder {
track_number: track_num,
track_type,
sector_size,
start_lba: 0,
sector_count: None,
file_path: current_file.clone(),
pregap_sectors: None,
});
}
}
"INDEX" => {
has_recognized_directives = true;
if tokens.len() >= 3 {
let index_num = tokens[1].parse::<u32>().unwrap_or(0);
let lba = parse_cue_timestamp(&tokens[2]).unwrap_or(0);
if let Some(ref mut tb) = current_track {
if index_num == 1 {
tb.start_lba = lba;
}
}
}
}
"PREGAP" if tokens.len() >= 2 => {
has_recognized_directives = true;
let pregap = parse_cue_timestamp(&tokens[1]).unwrap_or(0);
if let Some(ref mut tb) = current_track {
tb.pregap_sectors = Some(pregap as u32);
}
}
"TITLE" if tokens.len() >= 2 => {
has_recognized_directives = true;
if cue_title.is_none() {
cue_title = Some(tokens[1..].join(" "));
}
}
_ => {}
}
}
if let Some(tb) = current_track.take() {
tracks.push(tb.build());
}
if !has_recognized_directives || tracks.is_empty() {
return DiscDescriptor::unknown("File is not a valid CUE sheet (no valid tracks found)");
}
let all_unknown_tracks = tracks.iter().all(|t| t.track_type == TrackType::Unknown);
if all_unknown_tracks {
return DiscDescriptor::unknown(
"CUE sheet contains only unrecognized or invalid track modes",
);
}
let primary_sector_size = tracks.first().map(|t| t.sector_size).unwrap_or(2352);
let mut total_size_bytes = 0u64;
for track in &mut tracks {
if let Some(ref path) = track.file_path {
if path.exists() {
if let Ok(meta) = std::fs::metadata(path) {
if meta.len() == 0 {
return DiscDescriptor::unknown(format!(
"Referenced CUE track file '{}' is empty (0 bytes)",
path.display()
));
}
total_size_bytes += meta.len();
if track.sector_size > 0 && track.sector_count.is_none() {
track.sector_count = Some(meta.len() / (track.sector_size as u64));
}
}
}
}
}
let is_multi_track = tracks.len() > 1;
let (disc_type, confidence, mut summary) = if has_audio_tracks || has_wav_files {
(
DiscType::Cd,
Confidence::Definitive,
"CUE sheet contains Red Book audio tracks or WAV files (CD-DA)".to_string(),
)
} else if has_cd_modes {
(
DiscType::Cd,
Confidence::Definitive,
"CUE sheet specifies raw CD track modes (2352/2336 bytes)".to_string(),
)
} else if is_multi_track {
(
DiscType::Cd,
Confidence::High,
"CUE sheet contains multiple data tracks (characteristic of CD)".to_string(),
)
} else if let Some(first_track) = tracks.first() {
if let Some(ref file_path) = first_track.file_path {
if file_path.exists() {
let meta_len = std::fs::metadata(file_path).map(|m| m.len()).unwrap_or(0);
if meta_len > 900 * 1024 * 1024 {
(
DiscType::Dvd,
Confidence::High,
"CUE references single 2048-byte track exceeding 900 MiB (DVD)".to_string(),
)
} else {
let is_cue = file_path
.extension()
.and_then(|e| e.to_str())
.is_some_and(|e| e.eq_ignore_ascii_case("cue"));
if is_cue {
return DiscDescriptor::unknown(format!(
"Invalid CUE sheet: referenced data file '{}' cannot be another CUE sheet",
file_path.display()
));
}
match crate::detector::inspect_disc(file_path) {
Ok(sub_desc) => {
if sub_desc.disc_type == DiscType::Unknown {
return DiscDescriptor::unknown(format!(
"Referenced data file '{}' is not a recognized optical image: {}",
file_path.display(),
sub_desc.summary
));
}
(
sub_desc.disc_type,
sub_desc.confidence,
format!(
"CUE single track evaluated referenced file: {}",
sub_desc.summary
),
)
}
Err(_) => (
DiscType::Cd,
Confidence::Medium,
"CUE single track MODE1/2048 with size <= 900 MiB".to_string(),
),
}
}
} else {
(
DiscType::Cd,
Confidence::Medium,
"CUE single track MODE1/2048 (referenced file not present on disk)".to_string(),
)
}
} else {
(
DiscType::Cd,
Confidence::Medium,
"CUE single track MODE1/2048 without referenced file".to_string(),
)
}
} else {
(
DiscType::Unknown,
Confidence::Definitive,
"CUE sheet evaluated as Unknown".to_string(),
)
};
let mut volume_info = None;
let first_data_track = tracks.iter().find(|t| t.track_type != TrackType::Audio);
if let Some(t1) = first_data_track {
if let Some(ref path) = t1.file_path {
if path.exists() {
if let Ok(mut file) = std::fs::File::open(path) {
let meta_len = file.metadata().map(|m| m.len()).unwrap_or(0);
if meta_len > 0 {
let base_offset = t1.start_lba.saturating_mul(t1.sector_size as u64);
let valid_offset = if base_offset < meta_len {
base_offset
} else {
0
};
let mut disc_reader = crate::metadata::StreamDiscReader::new_with_offset(
&mut file,
valid_offset,
t1.sector_size,
meta_len,
);
let meta = crate::metadata::inspect_metadata(&mut disc_reader, Some(path));
let ext = path.extension().and_then(|e| e.to_str());
let mut sub_vol =
crate::detector::detect_disc_from_reader(&mut file, meta_len, ext)
.ok()
.and_then(|d| d.volume_info.map(|v| *v))
.unwrap_or_default();
meta.apply_to_volume_info(&mut sub_vol);
if sub_vol.title.is_none() {
if let Some(ref ct) = cue_title {
sub_vol.title = Some(ct.clone());
}
}
volume_info = Some(Box::new(sub_vol));
}
}
}
}
}
if let Some(ref vol) = volume_info {
if let Some(plat) = vol.platform {
let id_str = vol
.disc_id
.as_deref()
.map(|id| format!(" [{id}]"))
.unwrap_or_default();
let title_str = vol
.title
.as_deref()
.map(|t| format!(" \"{t}\""))
.unwrap_or_default();
summary = format!("{plat} disc{id_str}{title_str} ({summary})");
}
}
let total_sectors = if total_size_bytes > 0 && primary_sector_size > 0 {
Some(total_size_bytes / (primary_sector_size as u64))
} else {
None
};
DiscDescriptor {
disc_type,
confidence,
primary_sector_size,
total_sectors,
total_size_bytes: if total_size_bytes > 0 {
Some(total_size_bytes)
} else {
None
},
tracks,
volume_info,
summary,
chd_plan: None,
}
}
fn parse_track_mode(mode: &str) -> (TrackType, u32) {
match mode {
"AUDIO" => (TrackType::Audio, 2352),
"MODE1/2048" => (TrackType::Mode1_2048, 2048),
"MODE1/2352" => (TrackType::Mode1_2352, 2352),
"MODE2/2336" => (TrackType::Mode2_2336, 2336),
"MODE2/2352" => (TrackType::Mode2_2352, 2352),
"CDI/2352" => (TrackType::Cdi2352, 2352),
"CDG" => (TrackType::Audio, 2448),
_ => (TrackType::Unknown, 2048),
}
}
fn parse_cue_timestamp(ts: &str) -> Option<u64> {
let mut parts = ts.split(':');
let mm: u64 = parts.next()?.parse().ok()?;
let ss: u64 = parts.next()?.parse().ok()?;
let ff: u64 = parts.next()?.parse().ok()?;
if parts.next().is_some() {
return None;
}
mm.checked_mul(60)?
.checked_add(ss)?
.checked_mul(75)?
.checked_add(ff)
}
fn tokenize_cue_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 string_val = String::new();
for sc in chars.by_ref() {
if sc == '"' {
break;
}
string_val.push(sc);
}
tokens.push(string_val);
} 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
}
struct TrackBuilder {
track_number: u32,
track_type: TrackType,
sector_size: u32,
start_lba: u64,
sector_count: Option<u64>,
file_path: Option<PathBuf>,
pregap_sectors: Option<u32>,
}
impl TrackBuilder {
fn build(self) -> TrackDescriptor {
TrackDescriptor {
track_number: self.track_number,
track_type: self.track_type,
sector_size: self.sector_size,
start_lba: self.start_lba,
sector_count: self.sector_count,
file_path: self.file_path,
pregap_sectors: self.pregap_sectors,
}
}
}
pub(crate) fn extract_cue_referenced_files<P: AsRef<Path>>(cue_path: P) -> Vec<PathBuf> {
let path = cue_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_cue_referenced_files_from_content(&content, Some(base_dir))
}
pub fn extract_cue_referenced_files_from_content(
content: &str,
base_dir: Option<&Path>,
) -> Vec<PathBuf> {
let mut files = Vec::new();
for raw_line in content.lines() {
let line = raw_line.trim();
if line.is_empty() || line.starts_with("REM") {
continue;
}
let tokens = tokenize_cue_line(line);
if tokens.len() >= 2 && tokens[0].eq_ignore_ascii_case("FILE") {
let filename = &tokens[1];
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
}
pub fn synthesize_cue_for_image(file_name: &str, descriptor: &DiscDescriptor) -> Option<String> {
if descriptor.disc_type != DiscType::Cd {
return None;
}
let track_mode = if let Some(track) = descriptor.tracks.first() {
match track.track_type {
TrackType::Mode1_2048 => "MODE1/2048",
TrackType::Mode1_2352 => "MODE1/2352",
TrackType::Mode2_2336 => "MODE2/2336",
TrackType::Mode2_2352 => "MODE2/2352",
TrackType::Audio => "AUDIO",
TrackType::Cdi2352 => "CDI/2352",
_ => {
if descriptor.primary_sector_size == 2048 {
"MODE1/2048"
} else {
"MODE1/2352"
}
}
}
} else if descriptor.primary_sector_size == 2048 {
"MODE1/2048"
} else {
"MODE1/2352"
};
Some(format!(
"FILE \"{}\" BINARY\n TRACK 01 {}\n INDEX 01 00:00:00\n",
file_name, track_mode
))
}