use std::collections::BTreeMap;
use std::fs::File;
use std::path::{Path, PathBuf};
use crate::iso::parse_iso_pvd;
use crate::types::{
Confidence, DiscDescriptor, DiscError, DiscType, Platform, TrackDescriptor, TrackType,
VolumeInfo,
};
#[derive(Debug, Clone, PartialEq, Eq, Default)]
struct CcdEntry {
session: u32,
point: u8,
adr: u8,
control: u8,
track_no: u8,
a_lba: i32,
p_lba: i32,
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
struct CcdTrackSection {
mode: u8,
index0: Option<i32>,
index1: i32,
}
fn clean_val(val: &str) -> &str {
let no_comment = if let Some(idx) = val.find([';', '#']) {
&val[..idx]
} else {
val
};
no_comment
.trim()
.trim_matches('"')
.trim_matches('\'')
.trim()
}
fn parse_i32(val: &str) -> Result<i32, DiscError> {
let s = clean_val(val);
if let Some(hex) = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")) {
i32::from_str_radix(hex, 16)
.map_err(|e| DiscError::InvalidDescriptor(format!("invalid hex integer '{val}': {e}")))
} else {
s.parse::<i32>()
.map_err(|e| DiscError::InvalidDescriptor(format!("invalid integer '{val}': {e}")))
}
}
fn parse_u32(val: &str) -> Result<u32, DiscError> {
let s = clean_val(val);
if let Some(hex) = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")) {
u32::from_str_radix(hex, 16)
.map_err(|e| DiscError::InvalidDescriptor(format!("invalid hex integer '{val}': {e}")))
} else {
s.parse::<u32>()
.map_err(|e| DiscError::InvalidDescriptor(format!("invalid integer '{val}': {e}")))
}
}
fn parse_u8(val: &str) -> Result<u8, DiscError> {
let s = clean_val(val);
if let Some(hex) = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")) {
u8::from_str_radix(hex, 16)
.map_err(|e| DiscError::InvalidDescriptor(format!("invalid hex byte '{val}': {e}")))
} else {
s.parse::<u8>()
.map_err(|e| DiscError::InvalidDescriptor(format!("invalid byte '{val}': {e}")))
}
}
enum SectionType {
None,
CloneCd,
Disc,
Session(#[allow(dead_code)] u32),
Entry(u32),
Track(u32),
}
pub(crate) fn inspect_ccd<P: AsRef<Path>>(ccd_path: P) -> Result<DiscDescriptor, DiscError> {
let path = ccd_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 CCD 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_ccd_descriptor(&content, Some(base_dir), stem))
}
pub fn parse_ccd_descriptor(
content: &str,
base_dir: Option<&Path>,
ccd_stem: Option<&str>,
) -> DiscDescriptor {
let content = content.strip_prefix('\u{feff}').unwrap_or(content);
let mut entry_map: BTreeMap<u32, CcdEntry> = BTreeMap::new();
let mut track_map: BTreeMap<u32, CcdTrackSection> = BTreeMap::new();
let mut current_section = SectionType::None;
for line in content.lines() {
let trimmed = line.trim();
if trimmed.is_empty() || trimmed.starts_with(';') || trimmed.starts_with('#') {
continue;
}
if trimmed.starts_with('[') {
if let Some(close_bracket) = trimmed.find(']') {
let sec_name = trimmed[1..close_bracket].trim();
let lower = sec_name.to_ascii_lowercase();
if lower == "clonecd" {
current_section = SectionType::CloneCd;
} else if lower == "disc" {
current_section = SectionType::Disc;
} else if let Some(rest) = lower.strip_prefix("session ") {
if let Ok(num) = parse_u32(rest) {
current_section = SectionType::Session(num);
}
} else if let Some(rest) = lower.strip_prefix("entry ") {
if let Ok(num) = parse_u32(rest) {
entry_map.entry(num).or_default();
current_section = SectionType::Entry(num);
}
} else if let Some(rest) = lower.strip_prefix("track ") {
if let Ok(num) = parse_u32(rest) {
track_map.entry(num).or_default();
current_section = SectionType::Track(num);
}
} else {
current_section = SectionType::None;
}
continue;
}
}
if let Some((key_raw, val_raw)) = trimmed.split_once('=') {
let key = key_raw.trim().to_ascii_uppercase();
let val = clean_val(val_raw);
match current_section {
SectionType::Entry(num) => {
if let Some(entry) = entry_map.get_mut(&num) {
match key.as_str() {
"SESSION" => {
if let Ok(v) = parse_u32(val) {
entry.session = v;
}
}
"POINT" => {
if let Ok(v) = parse_u8(val) {
entry.point = v;
}
}
"ADR" => {
if let Ok(v) = parse_u8(val) {
entry.adr = v;
}
}
"CONTROL" => {
if let Ok(v) = parse_u8(val) {
entry.control = v;
}
}
"TRACKNO" => {
if let Ok(v) = parse_u8(val) {
entry.track_no = v;
}
}
"ALBA" => {
if let Ok(v) = parse_i32(val) {
entry.a_lba = v;
}
}
"PLBA" => {
if let Ok(v) = parse_i32(val) {
entry.p_lba = v;
}
}
_ => {}
}
}
}
SectionType::Track(num) => {
if let Some(tr) = track_map.get_mut(&num) {
match key.as_str() {
"MODE" => {
if let Ok(v) = parse_u8(val) {
tr.mode = v;
}
}
"INDEX 0" => {
if let Ok(v) = parse_i32(val) {
tr.index0 = Some(v);
}
}
"INDEX 1" => {
if let Ok(v) = parse_i32(val) {
tr.index1 = v;
}
}
_ => {}
}
}
}
_ => {}
}
}
}
let entries: Vec<CcdEntry> = entry_map.into_values().collect();
let mut user_entries: Vec<&CcdEntry> = entries
.iter()
.filter(|e| (1..=99).contains(&e.point))
.collect();
user_entries.sort_by_key(|e| (e.point, e.p_lba));
if user_entries.is_empty() && track_map.is_empty() {
return DiscDescriptor::unknown("CloneCD descriptor contains no track definitions");
}
let leadout_lba = entries
.iter()
.find(|e| e.point == 0xa2)
.map(|e| e.p_lba.max(0) as u64);
let mut tracks = Vec::new();
let resolved_img_path = if let (Some(dir), Some(stem)) = (base_dir, ccd_stem) {
let candidate_lower = dir.join(format!("{stem}.img"));
if candidate_lower.is_file() {
Some(candidate_lower)
} else {
let candidate_upper = dir.join(format!("{stem}.IMG"));
if candidate_upper.is_file() {
Some(candidate_upper)
} else {
Some(candidate_lower)
}
}
} else {
None
};
if !user_entries.is_empty() {
for (i, entry) in user_entries.iter().enumerate() {
let track_num = entry.point as u32;
let is_data = (entry.control & 0x04) != 0;
let track_info = track_map.get(&track_num);
let track_type = if is_data {
if let Some(info) = track_info {
if info.mode == 2 {
TrackType::Mode2_2352
} else {
TrackType::Mode1_2352
}
} else {
TrackType::Mode1_2352
}
} else {
TrackType::Audio
};
let start_lba = entry.p_lba.max(0) as u64;
let pregap_sectors = track_info.and_then(|t| {
t.index0
.map(|idx0| (t.index1.saturating_sub(idx0)).max(0) as u32)
});
let sector_count = if i + 1 < user_entries.len() {
let next_start = user_entries[i + 1].p_lba.max(0) as u64;
Some(next_start.saturating_sub(start_lba))
} else {
leadout_lba.map(|leadout| leadout.saturating_sub(start_lba))
};
tracks.push(TrackDescriptor {
track_number: track_num,
track_type,
sector_size: 2352,
start_lba,
sector_count,
file_path: resolved_img_path.clone(),
pregap_sectors,
});
}
} else {
let track_nums: Vec<u32> = track_map.keys().copied().collect();
for (i, &track_num) in track_nums.iter().enumerate() {
let info = &track_map[&track_num];
let is_data = info.mode != 0;
let track_type = if is_data {
if info.mode == 2 {
TrackType::Mode2_2352
} else {
TrackType::Mode1_2352
}
} else {
TrackType::Audio
};
let start_lba = info.index1.max(0) as u64;
let pregap_sectors = info
.index0
.map(|idx0| (info.index1.saturating_sub(idx0)).max(0) as u32);
let sector_count = if i + 1 < track_nums.len() {
let next_info = &track_map[&track_nums[i + 1]];
Some((next_info.index1.max(0) as u64).saturating_sub(start_lba))
} else {
leadout_lba.map(|leadout| leadout.saturating_sub(start_lba))
};
tracks.push(TrackDescriptor {
track_number: track_num,
track_type,
sector_size: 2352,
start_lba,
sector_count,
file_path: resolved_img_path.clone(),
pregap_sectors,
});
}
}
let mut volume_info = None;
let mut total_size_bytes = None;
let mut total_sectors = leadout_lba;
if let Some(ref img_path) = resolved_img_path {
if let Ok(file) = File::open(img_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() {
total_sectors = Some(meta_len / 2352);
}
}
let first_data_track = tracks.iter().find(|t| t.track_type != TrackType::Audio);
if let Some(t1) = first_data_track {
let mut disc_reader =
crate::metadata::StreamDiscReader::new(file, t1.sector_size, meta_len);
let fallback_path = base_dir.and_then(|d| ccd_stem.map(|s| d.join(s)));
let meta =
crate::metadata::inspect_metadata(&mut disc_reader, fallback_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);
}
if vol.platform.is_some()
|| vol.has_iso9660
|| vol.title.is_some()
|| vol.disc_id.is_some()
{
volume_info = Some(Box::new(vol));
}
}
}
}
if total_sectors.is_none() {
let sum_sectors: u64 = tracks.iter().filter_map(|t| t.sector_count).sum();
if sum_sectors > 0 {
total_sectors = Some(sum_sectors);
}
}
if total_size_bytes.is_none() {
if let Some(sec) = total_sectors {
total_size_bytes = Some(sec * 2352);
}
}
DiscDescriptor {
disc_type: DiscType::Cd,
confidence: Confidence::Definitive,
primary_sector_size: 2352,
total_sectors,
total_size_bytes,
tracks,
volume_info,
summary: "CloneCD disc image (.ccd)".to_string(),
chd_plan: None,
}
}
pub fn extract_ccd_referenced_files<P: AsRef<Path>>(ccd_path: P) -> Vec<PathBuf> {
let p = ccd_path.as_ref();
let mut files = Vec::new();
let img = p.with_extension("img");
if img.is_file() {
files.push(img);
} else {
let img_upper = p.with_extension("IMG");
if img_upper.is_file() {
files.push(img_upper);
} else {
files.push(img);
}
}
let sub = p.with_extension("sub");
if sub.is_file() {
files.push(sub);
} else {
let sub_upper = p.with_extension("SUB");
if sub_upper.is_file() {
files.push(sub_upper);
} else {
files.push(sub);
}
}
files
}