Handle errors better

build.rs

@@ -4,7 +4,11 @@ fn main() {
     println!("cargo:rustc-link-lib=framework=CoreFoundation");
     println!("cargo:rustc-link-lib=framework=DiskArbitration");
     cc::Build::new()
-        .file("src/macos_cd_shim.c")
+        .file("src/mac/da_guard.c")
+        .file("src/mac/device_service.c")
+        .file("src/mac/toc_reader.c")
+        .file("src/mac/audio_reader.c")
+        .include("src/mac")
         // force C compilation
         .flag("-x")
         .flag("c")

examples/read_track.rs

@@ -1,43 +1,39 @@
 use cd_da_reader::CdReader;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    read_cd()?;
-    Ok(())
+    let drive_path = default_drive_path();
+    read_cd(drive_path)
 }
 
 #[cfg(target_os = "windows")]
-fn read_cd() -> Result<(), Box<dyn std::error::Error>> {
-    let reader = CdReader::open(r"\\.\E:")?;
-    let toc = reader.read_toc()?;
-    println!("{:#?}", toc);
-
-    let data = reader.read_track(&toc, 11)?;
-    let wav_track = CdReader::create_wav(data);
-    std::fs::write("myfile.wav", wav_track)?;
-
-    Ok(())
+fn default_drive_path() -> &'static str {
+    r"\\.\E:"
 }
 
 #[cfg(target_os = "macos")]
-fn read_cd() -> Result<(), Box<dyn std::error::Error>> {
-    let reader = CdReader::open("disk6")?;
-    let toc = reader.read_toc()?;
-    println!("{:#?}", toc);
-
-    let data = reader.read_track(&toc, 11)?;
-    let wav_track = CdReader::create_wav(data);
-    std::fs::write("myfile.wav", wav_track)?;
-
-    Ok(())
+fn default_drive_path() -> &'static str {
+    "disk14"
 }
 
 #[cfg(target_os = "linux")]
-fn read_cd() -> Result<(), Box<dyn std::error::Error>> {
-    let reader = CdReader::open("/dev/sr0")?;
+fn default_drive_path() -> &'static str {
+    "/dev/sr0"
+}
+
+fn read_cd(path: &str) -> Result<(), Box<dyn std::error::Error>> {
+    let reader = CdReader::open(path)?;
     let toc = reader.read_toc()?;
-    println!("{:#?}", toc);
+    println!("{toc:#?}");
+
+    let last_audio_track = toc
+        .tracks
+        .iter()
+        .rev()
+        .find(|track| track.is_audio)
+        .ok_or_else(|| std::io::Error::other("no audio tracks in TOC"))?;
 
-    let data = reader.read_track(&toc, 11)?;
+    println!("Reading track {}", last_audio_track.number);
+    let data = reader.read_track(&toc, last_audio_track.number)?;
     let wav_track = CdReader::create_wav(data);
     std::fs::write("myfile.wav", wav_track)?;
 

src/errors.rs

@@ -0,0 +1,48 @@
+use std::fmt;
+
+#[derive(Debug, Clone, Copy)]
+pub enum ScsiOp {
+    ReadToc,
+    ReadCd,
+    ReadSubChannel,
+}
+
+#[derive(Debug, Clone)]
+pub struct ScsiError {
+    pub op: ScsiOp,
+    pub lba: Option<u32>,
+    pub sectors: Option<u32>,
+    pub scsi_status: u8,
+    pub sense_key: Option<u8>,
+    pub asc: Option<u8>,
+    pub ascq: Option<u8>,
+}
+
+#[derive(Debug)]
+pub enum CdReaderError {
+    Io(std::io::Error),
+    Scsi(ScsiError),
+    Parse(String),
+}
+
+impl fmt::Display for CdReaderError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Io(err) => write!(f, "io error: {err}"),
+            Self::Scsi(err) => write!(
+                f,
+                "SCSI {:?} failed (status=0x{:02x}, lba={:?}, sectors={:?}, sense_key={:?}, asc={:?}, ascq={:?})",
+                err.op, err.scsi_status, err.lba, err.sectors, err.sense_key, err.asc, err.ascq
+            ),
+            Self::Parse(msg) => write!(f, "parse error: {msg}"),
+        }
+    }
+}
+
+impl std::error::Error for CdReaderError {}
+
+impl From<std::io::Error> for CdReaderError {
+    fn from(value: std::io::Error) -> Self {
+        Self::Io(value)
+    }
+}

src/lib.rs

@@ -43,7 +43,11 @@ mod macos;
 #[cfg(target_os = "windows")]
 mod windows;
 
+mod errors;
+mod retry;
 mod utils;
+pub use errors::{CdReaderError, ScsiError, ScsiOp};
+pub use retry::RetryConfig;
 
 mod parse_toc;
 
@@ -150,7 +154,7 @@ impl CdReader {
     /// Please note that each track in the vector has `number` property, which you should use
     /// when calling `read_track`, as it doesn't start with 0. It is important to do so,
     /// because in the future it might include 0 for the hidden track.
-    pub fn read_toc(&self) -> Result<Toc, std::io::Error> {
+    pub fn read_toc(&self) -> Result<Toc, CdReaderError> {
         #[cfg(target_os = "windows")]
         {
             windows::read_toc()
@@ -176,20 +180,30 @@ impl CdReader {
     /// It returns raw PCM data, but if you want to save it directly and make it playable,
     /// wrap the result with `create_wav` function, that will prepend a RIFF header and
     /// make it a proper music file.
-    pub fn read_track(&self, toc: &Toc, track_no: u8) -> std::io::Result<Vec<u8>> {
+    pub fn read_track(&self, toc: &Toc, track_no: u8) -> Result<Vec<u8>, CdReaderError> {
+        self.read_track_with_retry(toc, track_no, &RetryConfig::default())
+    }
+
+    /// Read raw data for the specified track number from the TOC using explicit retry config.
+    pub fn read_track_with_retry(
+        &self,
+        toc: &Toc,
+        track_no: u8,
+        cfg: &RetryConfig,
+    ) -> Result<Vec<u8>, CdReaderError> {
         #[cfg(target_os = "windows")]
         {
-            windows::read_track(toc, track_no)
+            windows::read_track_with_retry(toc, track_no, cfg)
         }
 
         #[cfg(target_os = "macos")]
         {
-            macos::read_track(toc, track_no)
+            macos::read_track_with_retry(toc, track_no, cfg)
         }
 
         #[cfg(target_os = "linux")]
         {
-            linux::read_track(toc, track_no)
+            linux::read_track_with_retry(toc, track_no, cfg)
         }
 
         #[cfg(not(any(target_os = "windows", target_os = "linux", target_os = "macos")))]