use std::fmt;
use std::path::PathBuf;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum DiscType {
Cd,
Dvd,
Gdi,
HardDisk,
LaserDisc,
Unknown,
}
impl DiscType {
pub fn is_known(&self) -> bool {
!matches!(self, DiscType::Unknown)
}
}
impl fmt::Display for DiscType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
DiscType::Cd => write!(f, "CD"),
DiscType::Dvd => write!(f, "DVD"),
DiscType::Gdi => write!(f, "GDI"),
DiscType::HardDisk => write!(f, "Hard Disk"),
DiscType::LaserDisc => write!(f, "LaserDisc"),
DiscType::Unknown => write!(f, "Unknown"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Confidence {
Low,
Medium,
High,
Definitive,
}
impl fmt::Display for Confidence {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Confidence::Low => write!(f, "Low"),
Confidence::Medium => write!(f, "Medium"),
Confidence::High => write!(f, "High"),
Confidence::Definitive => write!(f, "Definitive"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Platform {
PlayStation1,
PlayStation2,
PlayStationPortable,
Dreamcast,
SegaSaturn,
MegaCd,
ThreeDo,
AmigaCd32,
PcEngineCd,
PcFx,
NeoGeoCd,
PhilipsCdi,
Xbox,
Xbox360,
GameCube,
Wii,
DvdVideo,
DvdAudio,
StandardIso,
ArcadeHardDisk,
PcHardDisk,
LaserDiscArcade,
Generic,
}
impl fmt::Display for Platform {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Platform::PlayStation1 => write!(f, "Sony PlayStation"),
Platform::PlayStation2 => write!(f, "Sony PlayStation 2"),
Platform::PlayStationPortable => write!(f, "Sony PlayStation Portable"),
Platform::Dreamcast => write!(f, "Sega Dreamcast"),
Platform::SegaSaturn => write!(f, "Sega Saturn"),
Platform::MegaCd => write!(f, "Sega Mega-CD / Sega CD"),
Platform::ThreeDo => write!(f, "3DO Interactive Multiplayer"),
Platform::AmigaCd32 => write!(f, "Amiga CD32"),
Platform::PcEngineCd => write!(f, "PC Engine CD / TurboGrafx-CD"),
Platform::PcFx => write!(f, "NEC PC-FX"),
Platform::NeoGeoCd => write!(f, "SNK Neo Geo CD"),
Platform::PhilipsCdi => write!(f, "Philips CD-i"),
Platform::Xbox => write!(f, "Microsoft Xbox"),
Platform::Xbox360 => write!(f, "Microsoft Xbox 360"),
Platform::GameCube => write!(f, "Nintendo GameCube"),
Platform::Wii => write!(f, "Nintendo Wii"),
Platform::DvdVideo => write!(f, "DVD-Video"),
Platform::DvdAudio => write!(f, "DVD-Audio"),
Platform::StandardIso => write!(f, "Standard ISO 9660"),
Platform::ArcadeHardDisk => write!(f, "Arcade Hard Disk"),
Platform::PcHardDisk => write!(f, "PC Hard Disk"),
Platform::LaserDiscArcade => write!(f, "LaserDisc Arcade"),
Platform::Generic => write!(f, "Generic Optical Disc"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum TrackType {
Audio,
Mode1_2048,
Mode1_2352,
Mode2_2336,
Mode2_2352,
Cdi2352,
DvdData,
GdiData,
HardDiskSector512,
LaserDiscFrame,
Unknown,
}
impl fmt::Display for TrackType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Audio => write!(f, "AUDIO"),
Self::Mode1_2048 => write!(f, "MODE1/2048"),
Self::Mode1_2352 => write!(f, "MODE1/2352"),
Self::Mode2_2336 => write!(f, "MODE2/2336"),
Self::Mode2_2352 => write!(f, "MODE2/2352"),
Self::Cdi2352 => write!(f, "CDI/2352"),
Self::DvdData => write!(f, "DVD/2048"),
Self::GdiData => write!(f, "GDI/DATA"),
Self::HardDiskSector512 => write!(f, "HD/512"),
Self::LaserDiscFrame => write!(f, "LASERDISC"),
Self::Unknown => write!(f, "UNKNOWN"),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TrackDescriptor {
pub track_number: u32,
pub track_type: TrackType,
pub sector_size: u32,
pub start_lba: u64,
pub sector_count: Option<u64>,
pub file_path: Option<PathBuf>,
pub pregap_sectors: Option<u32>,
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct VolumeInfo {
pub system_identifier: Option<String>,
pub volume_identifier: Option<String>,
pub volume_set_identifier: Option<String>,
pub publisher_identifier: Option<String>,
pub application_identifier: Option<String>,
pub volume_space_size: Option<u64>,
pub logical_block_size: Option<u32>,
pub has_iso9660: bool,
pub has_udf: bool,
pub has_dvd_video: bool,
pub has_dvd_audio: bool,
pub platform: Option<Platform>,
pub disc_id: Option<String>,
pub title: Option<String>,
pub metadata: Option<crate::metadata::DiscMetadata>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DiscDescriptor {
pub disc_type: DiscType,
pub confidence: Confidence,
pub primary_sector_size: u32,
pub total_sectors: Option<u64>,
pub total_size_bytes: Option<u64>,
pub tracks: Vec<TrackDescriptor>,
pub volume_info: Option<Box<VolumeInfo>>,
pub summary: String,
pub chd_plan: Option<crate::chd::ChdExtractionPlan>,
}
impl DiscDescriptor {
#[must_use]
pub fn disc_id(&self) -> Option<&str> {
self.volume_info.as_ref().and_then(|v| v.disc_id.as_deref())
}
#[must_use]
pub fn title(&self) -> Option<&str> {
self.volume_info.as_ref().and_then(|v| v.title.as_deref())
}
#[must_use]
pub fn metadata(&self) -> Option<&crate::metadata::DiscMetadata> {
self.volume_info.as_ref().and_then(|v| v.metadata.as_ref())
}
pub fn unknown(reason: impl Into<String>) -> Self {
Self {
disc_type: DiscType::Unknown,
confidence: Confidence::Definitive,
primary_sector_size: 0,
total_sectors: None,
total_size_bytes: None,
tracks: Vec::new(),
volume_info: None,
summary: reason.into(),
chd_plan: None,
}
}
#[must_use]
pub const fn is_chd(&self) -> bool {
self.chd_plan.is_some()
}
#[must_use]
pub fn has_raw_subcode(&self) -> bool {
self.chd_plan.as_ref().is_some_and(|p| p.has_raw_subcode)
}
#[must_use]
pub fn viable_extraction_formats(&self) -> Vec<&'static str> {
match self.disc_type {
DiscType::Cd => {
if self.has_raw_subcode() {
vec!["cue", "ccd", "mds", "mdx", "nrg"]
} else {
vec!["cue", "mds", "mdx", "nrg"]
}
}
DiscType::Dvd => vec!["iso"],
DiscType::Gdi => vec!["gdi"],
DiscType::HardDisk => vec!["img", "raw"],
DiscType::LaserDisc => vec!["avi"],
DiscType::Unknown => vec!["raw"],
}
}
#[must_use]
pub fn is_extraction_format_viable(&self, ext: &str) -> bool {
let clean = ext.trim().trim_start_matches('.').to_ascii_lowercase();
self.viable_extraction_formats().iter().any(|&f| f == clean)
}
}
#[derive(Debug)]
pub enum DiscError {
Io(std::io::Error),
InvalidPath(PathBuf),
InvalidDescriptor(String),
OnlineError(String),
}
impl fmt::Display for DiscError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Io(e) => write!(f, "I/O error during disc inspection: {e}"),
Self::InvalidPath(p) => write!(f, "Invalid file path: {}", p.display()),
Self::InvalidDescriptor(msg) => write!(f, "Invalid disc descriptor: {msg}"),
Self::OnlineError(msg) => write!(f, "Online database error: {msg}"),
}
}
}
impl std::error::Error for DiscError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Self::Io(e) => Some(e),
_ => None,
}
}
}
impl From<std::io::Error> for DiscError {
fn from(e: std::io::Error) -> Self {
Self::Io(e)
}
}