exporter: Use anyhow to enforce better error messages & Sendability

Cargo.lock

@@ -74,6 +74,12 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "anyhow"
+version = "1.0.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c794e162a5eff65c72ef524dfe393eb923c354e350bb78b9c7383df13f3bc142"
+
 [[package]]
 name = "approx"
 version = "0.5.1"
@@ -1212,6 +1218,7 @@ checksum = "77f3309417938f28bf8228fcff79a4a37103981e3e186d2ccd19c74b38f4eb71"
 name = "exporter"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "clap",
  "futures",
  "image",

exporter/Cargo.toml

@@ -14,6 +14,7 @@ image = "0.24.2"
 log = "0.4"
 walkdir = "2.3.2"
 indicatif = "0.17"
+anyhow = "1.0"
 
 [features]
 avm_debug = ["ruffle_core/avm_debug"]

exporter/src/main.rs

@@ -1,3 +1,4 @@
+use anyhow::{anyhow, Result};
 use clap::Parser;
 use image::RgbaImage;
 use indicatif::{ProgressBar, ProgressStyle};
@@ -6,7 +7,6 @@ use ruffle_core::PlayerBuilder;
 use ruffle_render_wgpu::clap::{GraphicsBackend, PowerPreference};
 use ruffle_render_wgpu::target::TextureTarget;
 use ruffle_render_wgpu::{wgpu, Descriptors, WgpuRenderBackend};
-use std::error::Error;
 use std::fs::create_dir_all;
 use std::panic::catch_unwind;
 use std::path::{Path, PathBuf};
@@ -81,8 +81,8 @@ fn take_screenshot(
     skipframes: u32,
     progress: &Option<ProgressBar>,
     size: SizeOpt,
-) -> Result<Vec<RgbaImage>, Box<dyn std::error::Error>> {
+) -> Result<Vec<RgbaImage>> {
-    let movie = SwfMovie::from_path(&swf_path, None)?;
+    let movie = SwfMovie::from_path(&swf_path, None).map_err(|e| anyhow!(e.to_string()))?;
 
     let width = size
         .width
@@ -98,7 +98,9 @@ fn take_screenshot(
 
     let target = TextureTarget::new(&descriptors.device, (width, height));
     let player = PlayerBuilder::new()
-        .with_renderer(WgpuRenderBackend::new(descriptors, target)?)
+        .with_renderer(
+            WgpuRenderBackend::new(descriptors, target).map_err(|e| anyhow!(e.to_string()))?,
+        )
         .with_software_video()
         .with_movie(movie)
         .with_viewport_dimensions(width, height, size.scale as f64)
@@ -127,13 +129,14 @@ fn take_screenshot(
                 renderer.capture_frame()
             }) {
                 Ok(Some(image)) => result.push(image),
-                Ok(None) => {
+                Ok(None) => return Err(anyhow!("Unable to capture frame {} of {:?}", i, swf_path)),
-                    return Err(format!("Unable to capture frame {} of {:?}", i, swf_path).into())
-                }
                 Err(e) => {
-                    return Err(
+                    return Err(anyhow!(
-                        format!("Unable to capture frame {} of {:?}: {:?}", i, swf_path, e).into(),
+                        "Unable to capture frame {} of {:?}: {:?}",
-                    )
+                        i,
+                        swf_path,
+                        e
+                    ))
                 }
             }
         }
@@ -175,7 +178,7 @@ fn find_files(root: &Path, with_progress: bool) -> Vec<DirEntry> {
     results
 }
 
-fn capture_single_swf(descriptors: Arc<Descriptors>, opt: &Opt) -> Result<(), Box<dyn Error>> {
+fn capture_single_swf(descriptors: Arc<Descriptors>, opt: &Opt) -> Result<()> {
     let output = opt.output_path.clone().unwrap_or_else(|| {
         let mut result = PathBuf::new();
         result.set_file_name(opt.swf.file_stem().unwrap());
@@ -251,7 +254,7 @@ fn capture_single_swf(descriptors: Arc<Descriptors>, opt: &Opt) -> Result<(), Bo
 }
 
 #[allow(clippy::branches_sharing_code)]
-fn capture_multiple_swfs(descriptors: Arc<Descriptors>, opt: &Opt) -> Result<(), Box<dyn Error>> {
+fn capture_multiple_swfs(descriptors: Arc<Descriptors>, opt: &Opt) -> Result<()> {
     let output = opt.output_path.clone().unwrap();
     let files = find_files(&opt.swf, !opt.silent);
 
@@ -355,25 +358,28 @@ fn trace_path(_opt: &Opt) -> Option<&Path> {
     None
 }
 
-fn main() -> Result<(), Box<dyn Error>> {
+fn main() -> Result<()> {
     let opt: Opt = Opt::parse();
     let instance = wgpu::Instance::new(opt.graphics.into());
-    let descriptors = Arc::new(futures::executor::block_on(WgpuRenderBackend::<
+    let descriptors = Arc::new(
-        TextureTarget,
+        futures::executor::block_on(WgpuRenderBackend::<TextureTarget>::build_descriptors(
-    >::build_descriptors(
+            opt.graphics.into(),
-        opt.graphics.into(),
+            instance,
-        instance,
+            None,
-        None,
+            opt.power.into(),
-        opt.power.into(),
+            trace_path(&opt),
-        trace_path(&opt),
+        ))
-    ))?);
+        .map_err(|e| anyhow!(e.to_string()))?,
+    );
 
     if opt.swf.is_file() {
         capture_single_swf(descriptors, &opt)?;
     } else if opt.output_path.is_some() {
         capture_multiple_swfs(descriptors, &opt)?;
     } else {
-        return Err("Output directory is required when exporting multiple files.".into());
+        return Err(anyhow!(
+            "Output directory is required when exporting multiple files."
+        ));
     }
 
     Ok(())