feat: Migrate Error Handling to thiserror

Author: bindiego

Cargo.lock

@@ -23,6 +23,7 @@ usvg = "0.47.0"
 # Video support (optional) — builds FFmpeg from source, statically linked
 ffmpeg-next = { version = "7", features = ["build", "build-license-gpl", "build-lib-x264"], optional = true }
 nalgebra = { version = "0.33", optional = true }
+thiserror = "2"
 
 [dev-dependencies]
 tempfile = "3"

Cargo.toml

@@ -30,17 +30,13 @@ pub fn total_encoded_bits(num_blocks: usize) -> usize {
 /// A 2-byte length header (big-endian u16) is prepended. The payload is
 /// zero-padded to fill the full capacity so that the encoded bit length
 /// is always `total_encoded_bits(num_blocks)`.
-pub fn encode(message: &[u8], num_blocks: usize) -> Result<Vec<bool>, String> {
+pub fn encode(message: &[u8], num_blocks: usize) -> Result<Vec<bool>, crate::common::WatermarkError> {
     let max_msg = max_message_bytes(num_blocks);
     if max_msg == 0 {
-        return Err("Image too small: insufficient capacity".to_string());
+        return Err(crate::common::WatermarkError::ImageTooSmall);
     }
     if message.len() > max_msg {
-        return Err(format!(
-            "Message too long: max {} bytes, got {} bytes",
-            max_msg,
-            message.len()
-        ));
+        return Err(crate::common::WatermarkError::CapacityExceeded { max: max_msg, actual: message.len(), mode: "global-dwt" });
     }
 
     let total_data_bits = num_blocks / REPETITION_FACTOR;
@@ -76,9 +72,9 @@ pub fn encode(message: &[u8], num_blocks: usize) -> Result<Vec<bool>, String> {
 ///
 /// `bits` should contain the raw extracted bits (scrambled order already resolved).
 /// Returns the decoded message bytes.
-pub fn decode(bits: &[bool]) -> Result<Vec<u8>, String> {
+pub fn decode(bits: &[bool]) -> Result<Vec<u8>, crate::common::WatermarkError> {
     if bits.len() < REPETITION_FACTOR * 16 {
-        return Err("Not enough data to decode (need at least 2 header bytes)".to_string());
+        return Err(crate::common::WatermarkError::ExtractionCorrupt);
     }
 
     // Majority vote to recover original bits
@@ -112,21 +108,17 @@ pub fn decode(bits: &[bool]) -> Result<Vec<u8>, String> {
 
     // Read length header
     if bytes.len() < 2 {
-        return Err("Decoded data too short".to_string());
+        return Err(crate::common::WatermarkError::ExtractionCorrupt);
     }
     let msg_len = ((bytes[0] as u16) << 8) | (bytes[1] as u16);
     let msg_len = msg_len as usize;
 
     if msg_len == 0 {
-        return Err("Invalid message length: 0".to_string());
+        return Err(crate::common::WatermarkError::ExtractionCorrupt);
     }
 
     if 2 + msg_len > bytes.len() {
-        return Err(format!(
-            "Message length {} exceeds available data {}",
-            msg_len,
-            bytes.len() - 2
-        ));
+        return Err(crate::common::WatermarkError::ExtractionCorrupt);
     }
 
     Ok(bytes[2..2 + msg_len].to_vec())

src/common/ecc.rs

@@ -99,16 +99,54 @@ pub struct ExtractResult {
 ///
 /// Each engine implements format-specific feature detection and embedding
 /// while sharing the common layer (ECC, scrambling, password hashing).
+use std::io;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum WatermarkError {
+    #[error(transparent)]
+    Image(#[from] image::ImageError),
+
+    #[error(transparent)]
+    Io(#[from] io::Error),
+
+    #[error("message exceeds capacity: {actual} bytes, max {max} bytes (mode: {mode})")]
+    CapacityExceeded {
+        max: usize,
+        actual: usize,
+        mode: &'static str,
+    },
+
+    #[error("image too small for watermarking: insufficient DWT coefficients")]
+    ImageTooSmall,
+
+    #[error("unsupported file format: .{extension}")]
+    UnsupportedFormat { extension: String },
+
+    #[error("no qualifying SVG paths with >= {min_coords} coordinates")]
+    NoQualifyingPaths { min_coords: usize },
+
+    #[error("extraction failed: corrupt or missing watermark data")]
+    ExtractionCorrupt,
+
+    #[error("video support not enabled; rebuild with: cargo build --features video")]
+    VideoNotEnabled,
+
+    #[error("video processing failed: {0}")]
+    VideoProcessing(String),
+
+}
+
 pub trait WatermarkEngine {
-    /// Embed a watermark message into a file.
+    /// Embed a watermark into a file.
     fn embed(
         &self,
         input_path: &str,
         message: &str,
         password: &str,
         intensity: u8,
         output_path: &str,
-    ) -> Result<EmbedResult, String>;
+    ) -> Result<EmbedResult, WatermarkError>;
 
     /// Dry run: compute embedding info without writing any file.
     fn dry_run(
@@ -118,8 +156,8 @@ pub trait WatermarkEngine {
         password: &str,
         intensity: u8,
         output_path: &str,
-    ) -> Result<EmbedInfo, String>;
+    ) -> Result<EmbedInfo, WatermarkError>;
 
     /// Verify and extract a watermark from a file.
-    fn verify(&self, input_path: &str, password: &str) -> Result<ExtractResult, String>;
+    fn verify(&self, input_path: &str, password: &str) -> Result<ExtractResult, WatermarkError>;
 }

src/common/engine.rs

@@ -4,6 +4,6 @@ pub mod password;
 pub mod scramble;
 pub mod temp_input_for_inference;
 
-pub use engine::{EmbedInfo, EmbedResult, ExtractResult, WatermarkEngine};
+pub use engine::{EmbedInfo, EmbedResult, ExtractResult, WatermarkEngine, WatermarkError};
 pub use password::password_to_seed;
 pub use temp_input_for_inference::TempInputForInference;

src/common/mod.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use clap::{CommandFactory, Parser, Subcommand};
-use infinishield::common::WatermarkEngine;
+use infinishield::common::{WatermarkEngine, WatermarkError};
 use infinishield::raster::RasterEngine;
 use infinishield::vector::VectorEngine;
 #[cfg(feature = "video")]
@@ -81,7 +81,7 @@ enum Commands {
 }
 
 /// Detect file format and return the appropriate engine.
-fn engine_for_file(path: &str) -> Result<Box<dyn WatermarkEngine>, String> {
+fn engine_for_file(path: &str) -> Result<Box<dyn WatermarkEngine>, infinishield::common::WatermarkError> {
     let ext = Path::new(path)
         .extension()
         .and_then(|e| e.to_str())
@@ -96,13 +96,8 @@ fn engine_for_file(path: &str) -> Result<Box<dyn WatermarkEngine>, String> {
         #[cfg(feature = "video")]
         "mp4" | "webm" | "mov" | "avi" | "mkv" => Ok(Box::new(VideoEngine)),
         #[cfg(not(feature = "video"))]
-        "mp4" | "webm" | "mov" | "avi" | "mkv" => Err(
-            "Video support not enabled. Rebuild with: cargo build --features video".to_string(),
-        ),
-        _ => Err(format!(
-            "Unsupported file format: .{}. Supported: jpg, jpeg, png, webp, bmp, tiff, gif, svg, mp4, webm, mov, avi, mkv",
-            ext
-        )),
+        "mp4" | "webm" | "mov" | "avi" | "mkv" => Err(WatermarkError::VideoNotEnabled.into()),
+        _ => Err(WatermarkError::UnsupportedFormat { extension: ext.to_string() }.into()),
     }
 }
 
@@ -180,7 +175,7 @@ fn main() {
                     }
                     Err(e) => {
                         eprintln!("[错误] {}", e);
-                        std::process::exit(1);
+                    std::process::exit(1);
                     }
                 }
             } else {
@@ -190,7 +185,7 @@ fn main() {
                     }
                     Err(e) => {
                         eprintln!("[错误] {}", e);
-                        std::process::exit(1);
+                    std::process::exit(1);
                     }
                 }
             }
@@ -227,4 +222,4 @@ fn main() {
             }
         }
     }
-}
+}

src/main.rs

@@ -3,7 +3,7 @@ pub mod features;
 
 use crate::common::engine::{EmbedInfo, EmbedResult, ExtractResult, WatermarkEngine};
 use crate::common::temp_input_for_inference::TempInputForInference;
-use crate::common::{ecc, password, scramble};
+use crate::common::{WatermarkError, ecc, password, scramble};
 
 use features::{detect_keypoints, FeaturePoint, PATCH_SIZE};
 use image::{DynamicImage, GenericImageView, GrayImage, Luma};
@@ -57,7 +57,7 @@ fn analyze(
     message: &str,
     intensity: u8,
     output_path: &str,
-) -> Result<(EmbedInfo, bool), String> {
+) -> Result<(EmbedInfo, bool), crate::common::WatermarkError> {
     let (w, h) = img.dimensions();
     let intensity = resolve_intensity(intensity, w, h);
     let gray = channel_to_gray(img);
@@ -100,8 +100,8 @@ impl WatermarkEngine for RasterEngine {
         password: &str,
         intensity: u8,
         output_path: &str,
-    ) -> Result<EmbedResult, String> {
-        let img = image::open(input_path).map_err(|e| format!("Failed to open image: {}", e))?;
+    ) -> Result<EmbedResult, WatermarkError> {
+        let img = image::open(input_path)?;
         let (info, use_fp) = analyze(&img, message, intensity, output_path)?;
         let gray = channel_to_gray(&img);
         let kps = detect_keypoints(&gray, MAX_KEYPOINTS);
@@ -125,20 +125,17 @@ impl WatermarkEngine for RasterEngine {
         _password: &str,
         intensity: u8,
         output_path: &str,
-    ) -> Result<EmbedInfo, String> {
-        let img = image::open(input_path).map_err(|e| format!("Failed to open image: {}", e))?;
+    ) -> Result<EmbedInfo, WatermarkError> {
+        let img = image::open(input_path)?;
         let (info, _) = analyze(&img, message, intensity, output_path)?;
         if info.message_bytes > info.max_capacity {
-            return Err(format!(
-                "Message too long: {} bytes, max capacity: {} bytes (mode: {})",
-                info.message_bytes, info.max_capacity, info.mode
-            ));
+            return Err(WatermarkError::CapacityExceeded { max: info.max_capacity, actual: info.message_bytes, mode: "global-dwt" });
         }
         Ok(info)
     }
 
-    fn verify(&self, input_path: &str, password: &str) -> Result<ExtractResult, String> {
-        let img = image::open(input_path).map_err(|e| format!("Failed to open image: {}", e))?;
+    fn verify(&self, input_path: &str, password: &str) -> Result<ExtractResult, WatermarkError> {
+        let img = image::open(input_path)?;
         let gray = channel_to_gray(&img);
         let kps = detect_keypoints(&gray, MAX_KEYPOINTS);
         let channel = extract_channel(&img);
@@ -170,7 +167,7 @@ impl RasterEngine {
         message: &str,
         password: &str,
         intensity: u8,
-    ) -> Result<(), String> {
+    ) -> Result<(), WatermarkError> {
         let gray = gray_from_rgb(rgb, width, height, DETECT_CHANNEL);
         let kps = detect_keypoints(&gray, MAX_KEYPOINTS);
         let channel = channel_from_rgb(rgb, width, height, EMBED_CHANNEL);
@@ -222,7 +219,7 @@ impl RasterEngine {
             let mut coeffs = dwt::forward(&channel);
             let (br, bc, nb) = count_blocks(coeffs.hl.len(), coeffs.hl[0].len());
             if nb == 0 {
-                return Err("Image too small for watermarking".to_string());
+                return Err(WatermarkError::ImageTooSmall);
             }
             let bits = ecc::encode(message.as_bytes(), nb)?;
             let seed = password::password_to_seed(password);
@@ -267,7 +264,7 @@ impl RasterEngine {
         width: u32,
         height: u32,
         password: &str,
-    ) -> Result<ExtractResult, String> {
+    ) -> Result<ExtractResult, WatermarkError> {
         let gray = gray_from_rgb(rgb, width, height, DETECT_CHANNEL);
         let kps = detect_keypoints(&gray, MAX_KEYPOINTS);
         let channel = channel_from_rgb(rgb, width, height, EMBED_CHANNEL);
@@ -371,13 +368,9 @@ fn calculate_local_alpha(
     global_alpha * multiplier
 }
 
-fn fp_encode(message: &[u8]) -> Result<Vec<bool>, String> {
+fn fp_encode(message: &[u8]) -> Result<Vec<bool>, WatermarkError> {
     if message.len() > FP_MAX_MESSAGE {
-        return Err(format!(
-            "Message too long for feature-point mode: max {} bytes, got {}",
-            FP_MAX_MESSAGE,
-            message.len()
-        ));
+        return Err(WatermarkError::CapacityExceeded { max: FP_MAX_MESSAGE, actual: message.len(), mode: "feature-point" });
     }
     let total_bytes = BLOCKS_PER_PATCH / 8;
     let mut payload = vec![0u8; total_bytes];
@@ -393,9 +386,9 @@ fn fp_encode(message: &[u8]) -> Result<Vec<bool>, String> {
     Ok(bits)
 }
 
-fn fp_decode(bits: &[bool]) -> Result<Vec<u8>, String> {
+fn fp_decode(bits: &[bool]) -> Result<Vec<u8>, WatermarkError> {
     if bits.len() < 8 {
-        return Err("Not enough bits".to_string());
+        return Err(WatermarkError::ExtractionCorrupt);
     }
     let mut bytes = Vec::with_capacity(bits.len() / 8);
     for chunk in bits.chunks(8) {
@@ -412,7 +405,7 @@ fn fp_decode(bits: &[bool]) -> Result<Vec<u8>, String> {
     }
     let len = bytes[0] as usize;
     if len == 0 || 1 + len > bytes.len() {
-        return Err("Invalid message length".to_string());
+        return Err(WatermarkError::ExtractionCorrupt);
     }
     Ok(bytes[1..1 + len].to_vec())
 }
@@ -424,7 +417,7 @@ fn embed_feature_point(
     password: &str,
     raw_intensity: u8,
     output_path: &str,
-) -> Result<(), String> {
+) -> Result<(), WatermarkError> {
     let (width, height) = img.dimensions();
     let alpha = fp_alpha(raw_intensity, width, height);
 
@@ -478,7 +471,7 @@ fn verify_feature_point(
     keypoints: &[FeaturePoint],
     password: &str,
     channel: &[Vec<f64>],
-) -> Result<ExtractResult, String> {
+) -> Result<ExtractResult, WatermarkError> {
     let seed = password::password_to_seed(password);
     let ch_h = channel.len();
     let ch_w = if ch_h > 0 { channel[0].len() } else { 0 };
@@ -580,14 +573,14 @@ fn embed_global_dwt(
     password: &str,
     raw_intensity: u8,
     output_path: &str,
-) -> Result<(), String> {
+) -> Result<(), WatermarkError> {
     let (w, h) = img.dimensions();
     let alpha = dwt_alpha(raw_intensity, w, h);
     let ch = extract_channel(img);
     let mut coeffs = dwt::forward(&ch);
     let (br, bc, nb) = count_blocks(coeffs.hl.len(), coeffs.hl[0].len());
     if nb == 0 {
-        return Err("Image too small for watermarking".to_string());
+        return Err(WatermarkError::ImageTooSmall);
     }
 
     let bits = ecc::encode(message.as_bytes(), nb)?;
@@ -629,7 +622,7 @@ fn embed_global_dwt(
 fn verify_global_dwt_from_channel(
     channel: &[Vec<f64>],
     password: &str,
-) -> Result<ExtractResult, String> {
+) -> Result<ExtractResult, WatermarkError> {
     let coeffs = dwt::forward(channel);
     let (_, bc, nb) = count_blocks(coeffs.hl.len(), coeffs.hl[0].len());
     if nb == 0 {
@@ -809,7 +802,7 @@ fn save_channel_to_image(
     width: u32,
     height: u32,
     path: &str,
-) -> Result<(), String> {
+) -> Result<(), WatermarkError> {
     let mut out = img.to_rgba8();
     let oh = height.min(channel.len() as u32);
     let ow = width.min(if channel.is_empty() {
@@ -825,8 +818,7 @@ fn save_channel_to_image(
             out.put_pixel(x, y, px);
         }
     }
-    out.save(path)
-        .map_err(|e| format!("Failed to save image: {}", e))
+    Ok(out.save(path)?)
 }
 
 #[cfg(test)]