rawfile: Now the API is always faillible

This avoid many cases of panic and return errors instead
io now return Result instead of io::Result

Signed-off-by: Hubert Figuière <hub@figuiere.net>

Author: hfiguiere

benches/the_benchmark.rs

@@ -2,7 +2,7 @@
 /*
  * libopenraw - the_benchmark.rs
  *
- * Copyright (C) 2023 Hubert Figuière
+ * Copyright (C) 2023-2025 Hubert Figuière
  *
  * This library is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
@@ -53,9 +53,10 @@ pub fn ordiag_benchmark(c: &mut Criterion) {
             b.iter(|| {
                 let rawfile = rawfile_from_file(&file, None);
                 if let Ok(rawfile) = rawfile {
-                    let sizes = rawfile.thumbnail_sizes();
-                    for size in sizes {
-                        let _ = rawfile.thumbnail(*size);
+                    if let Some(sizes) = rawfile.thumbnail_sizes() {
+                        for size in sizes {
+                            let _ = rawfile.thumbnail(*size);
+                        }
                     }
                     let _ = rawfile.raw_data(false);
                 }

libopenraw-testing/src/lib.rs

@@ -2,7 +2,7 @@
 /*
  * libopenraw - libopenraw-testing.rs
  *
- * Copyright (C) 2022-2024 Hubert Figuière
+ * Copyright (C) 2022-2025 Hubert Figuière
  *
  * This library is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
@@ -95,17 +95,9 @@ pub struct Results {
         default
     )]
     pub raw_data_active_area: Option<Vec<u32>>,
-    #[serde(
-        deserialize_with = "from_list",
-        serialize_with = "to_list",
-        default
-    )]
+    #[serde(deserialize_with = "from_list", serialize_with = "to_list", default)]
     pub raw_data_user_crop: Option<Vec<u32>>,
-    #[serde(
-        deserialize_with = "from_list",
-        serialize_with = "to_list",
-        default
-    )]
+    #[serde(deserialize_with = "from_list", serialize_with = "to_list", default)]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub raw_data_user_aspect_ratio: Option<Vec<u32>>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -202,7 +194,7 @@ impl Test {
 
 pub fn make_results(rawfile: &dyn RawFile) -> Results {
     let raw_type = Some(rawfile.type_().into());
-    let raw_type_id = Some(rawfile.type_id().into());
+    let raw_type_id = rawfile.type_id().map(|id| id.into()).ok();
     let exif_make = rawfile
         .metadata_value("Exif.Image.Make")
         .as_ref()
@@ -222,37 +214,46 @@ pub fn make_results(rawfile: &dyn RawFile) -> Results {
         .map(|s| s.to_string_lossy().to_string());
 
     let thumbnail_sizes = rawfile.thumbnail_sizes();
-    let thumb_num = Some(thumbnail_sizes.len() as u32);
-    let thumb_sizes = Some(thumbnail_sizes.to_vec());
+    let thumb_num = thumbnail_sizes.map(|sizes| sizes.len() as u32);
+    let thumb_sizes = thumbnail_sizes.map(|sizes| sizes.to_vec());
 
     let thumbnails = rawfile.thumbnails();
-    let thumb_formats = Some(
-        thumbnails
-            .thumbnails
-            .iter()
-            .map(|t| t.1.data_type.into())
-            .collect::<Vec<String>>()
-            .join(" "),
-    );
-    let thumb_data_sizes = Some(
-        thumbnails
-            .thumbnails
-            .iter()
-            .map(|t| t.1.data_size() as u32)
-            .collect(),
-    );
-    let thumb_md5 = Some(
-        thumbnails
-            .thumbnails
-            .iter()
-            .flat_map(|t| {
-                rawfile
-                    .thumbnail(t.0)
-                    .ok()
-                    .and_then(|t| t.data8().map(raw_checksum))
-            })
-            .collect(),
-    );
+    let thumb_formats = thumbnails
+        .as_ref()
+        .map(|thumbnails| {
+            thumbnails
+                .thumbnails
+                .iter()
+                .map(|t| t.1.data_type.into())
+                .collect::<Vec<String>>()
+                .join(" ")
+        })
+        .ok();
+    let thumb_data_sizes = thumbnails
+        .as_ref()
+        .map(|thumbnails| {
+            thumbnails
+                .thumbnails
+                .iter()
+                .map(|t| t.1.data_size() as u32)
+                .collect()
+        })
+        .ok();
+    let thumb_md5 = thumbnails
+        .as_ref()
+        .map(|thumbnails| {
+            thumbnails
+                .thumbnails
+                .iter()
+                .flat_map(|t| {
+                    rawfile
+                        .thumbnail(t.0)
+                        .ok()
+                        .and_then(|t| t.data8().map(raw_checksum))
+                })
+                .collect()
+        })
+        .ok();
 
     let rawdata = rawfile.raw_data(false);
     let rawdata = rawdata.as_ref();
@@ -278,7 +279,9 @@ pub fn make_results(rawfile: &dyn RawFile) -> Results {
         .ok();
     let raw_min_value = rawdata.map(|rawdata| rawdata.blacks().to_vec()).ok();
     let raw_max_value = rawdata.map(|rawdata| rawdata.whites().to_vec()).ok();
-    let raw_as_shot_neutral = rawdata.ok().and_then(|rawdata| rawdata.as_shot_neutral())
+    let raw_as_shot_neutral = rawdata
+        .ok()
+        .and_then(|rawdata| rawdata.as_shot_neutral())
         .map(|as_shot| as_shot.to_vec());
     let raw_md5 = rawdata
         .ok()

src/bin/identify.rs

@@ -2,7 +2,7 @@
 /*
  * libopenraw - bin/identify.rs
  *
- * Copyright (C) 2022-2023 Hubert Figuière
+ * Copyright (C) 2022-2025 Hubert Figuière
  *
  * This library is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
@@ -63,11 +63,12 @@ pub fn main() {
         }
         let rawfile = rawfile_from_file(&p, format);
         match rawfile {
-            Ok(ref rawfile) => {
-                println!("{} {}", name, rawfile.type_id());
-            }
+            Ok(ref rawfile) => match rawfile.type_id() {
+                Ok(type_id) => println!("{} {}", name, type_id),
+                Err(err) => println!("Error getting type id {name}: {err}"),
+            },
             Err(err) => {
-                println!("Error {name}: {err}");
+                println!("Error opening file {name}: {err}");
             }
         }
     }

src/bin/metadata.rs

@@ -2,7 +2,7 @@
 /*
  * libopenraw - bin/metadata.rs
  *
- * Copyright (C) 2023-2024 Hubert Figuière
+ * Copyright (C) 2023-2025 Hubert Figuière
  *
  * This library is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
@@ -64,13 +64,15 @@ fn process_file(p: &str) {
     if let Ok(rawfile) = rawfile_from_file(p, None) {
         log::info!("Metadata raw file {}", p);
 
-        for metadata in rawfile.metadata() {
-            println!(
-                "{} ({}) => {:?}",
-                metadata.0,
-                type_to_string(metadata.2),
-                metadata.1.into_string(false)
-            );
+        if let Some(iterator) = rawfile.metadata() {
+            for metadata in iterator {
+                println!(
+                    "{} ({}) => {:?}",
+                    metadata.0,
+                    type_to_string(metadata.2),
+                    metadata.1.into_string(false)
+                );
+            }
         }
     }
 }

src/bin/ordiag.rs

@@ -2,7 +2,7 @@
 /*
  * libopenraw - bin/ordiag.rs
  *
- * Copyright (C) 2022-2024 Hubert Figuière
+ * Copyright (C) 2022-2025 Hubert Figuière
  *
  * This library is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
@@ -274,8 +274,13 @@ fn process_file(
 
             println!("Raw type: {:?}", rawfile.type_());
             println!("MIME type: {}", rawfile.mime_type());
-            println!("Vendor id: {}", rawfile.vendor_id());
-            println!("Type id: {:?}", rawfile.type_id());
+            if let Ok(type_id) = rawfile.type_id() {
+                println!("Vendor id: {}", rawfile.vendor_id().unwrap());
+                println!("Type id: {:?}", type_id);
+            } else {
+                println!("Couldn't guess file type ID");
+                return;
+            }
             if let Some(make) = rawfile
                 .metadata_value("Exif.Image.Make")
                 .as_ref()
@@ -298,25 +303,26 @@ fn process_file(
                 println!("Unique Camera Model: {:?}", unique);
             }
 
-            let sizes = rawfile.thumbnail_sizes();
-            println!("Thumbnail sizes: {:?}", &sizes);
-            for size in sizes {
-                let thumb = rawfile.thumbnail(*size);
-                match thumb {
-                    Ok(ref thumb) => {
-                        println!("\tThumbnail size: {} x {}", thumb.width(), thumb.height());
-                        println!("\tFormat: {:?}", thumb.data_type());
-                        println!(
-                            "\tSize: {} bytes",
-                            thumb.data8().map(|d| d.len()).unwrap_or(0)
-                        );
+            if let Some(sizes) = rawfile.thumbnail_sizes() {
+                println!("Thumbnail sizes: {:?}", &sizes);
+                for size in sizes {
+                    let thumb = rawfile.thumbnail(*size);
+                    match thumb {
+                        Ok(ref thumb) => {
+                            println!("\tThumbnail size: {} x {}", thumb.width(), thumb.height());
+                            println!("\tFormat: {:?}", thumb.data_type());
+                            println!(
+                                "\tSize: {} bytes",
+                                thumb.data8().map(|d| d.len()).unwrap_or(0)
+                            );
 
-                        if extract_thumbnails {
-                            save_thumbnail(p, thumb);
+                            if extract_thumbnails {
+                                save_thumbnail(p, thumb);
+                            }
+                        }
+                        Err(err) => {
+                            eprintln!("Failed to fetch preview for {size}: {err}");
                         }
-                    }
-                    Err(err) => {
-                        eprintln!("Failed to fetch preview for {size}: {err}");
                     }
                 }
             }

src/bin/probe.rs

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 /*
- * libopenraw - bin/ordiag.rs
+ * libopenraw - bin/probe.rs
  *
- * Copyright (C) 2024 Hubert Figuière
+ * Copyright (C) 2024-2025 Hubert Figuière
  *
  * This library is free software: you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
@@ -62,10 +62,11 @@ fn process_file(p: &str) {
             use std::rc::Rc;
             Rc::get_mut(rawfile).unwrap().set_probe(true);
 
-            let sizes = rawfile.thumbnail_sizes();
-            for size in sizes {
-                // is this needed for the probe?
-                let _ = rawfile.thumbnail(*size);
+            if let Some(sizes) = rawfile.thumbnail_sizes() {
+                for size in sizes {
+                    // is this needed for the probe?
+                    let _ = rawfile.thumbnail(*size);
+                }
             }
 
             let _rawdata = rawfile.raw_data(false);

src/bin/test-rawfile.rs

@@ -5,9 +5,10 @@ fn main() {
     let _ = libopenraw::rawfile_from_file(&args[1], None)
         .and_then(|rawfile| {
             let _ = rawfile.type_id();
-            let sizes = rawfile.thumbnail_sizes();
-            for size in sizes {
-                let _ = rawfile.thumbnail(*size)?;
+            if let Some(sizes) = rawfile.thumbnail_sizes() {
+                for size in sizes {
+                    let _ = rawfile.thumbnail(*size)?;
+                }
             }
 
             let _ = rawfile.raw_data(false)?;