feat: implement thorvg asset resolver for improved image handling

dotlottie-rs/src/dotlottie_player.rs

@@ -1,6 +1,6 @@
 use crate::time::{Duration, Instant};
 use std::sync::RwLock;
-use std::{fs, rc::Rc, sync::Arc};
+use std::{fs, rc::Rc, sync::Arc, ffi::c_void};
 
 use crate::actions::open_url_policy::OpenUrlPolicy;
 use crate::state_machine_engine::events::Event;
@@ -833,10 +833,39 @@ impl DotLottieRuntime {
                             )
                         };
 
+                    let manager_ptr = manager as *const DotLottieManager as *mut c_void;
+
+                    unsafe extern "C" fn asset_resolver_callback(
+                        src: *const i8,
+                        user_data: *mut c_void
+                    ) -> *mut Vec<u8> {
+                        let src_str = match std::ffi::CStr::from_ptr(src).to_str() {
+                            Ok(s) => s,
+                            Err(_) => return std::ptr::null_mut(),
+                        };
+
+                        if user_data.is_null() {
+                            return std::ptr::null_mut();
+                        }
+
+                        let manager = &*(user_data as *const DotLottieManager);
+                        match manager.resolve_asset(src_str) {
+                            Ok(asset_data) => {
+                                Box::into_raw(Box::new(asset_data))
+                            }
+                            Err(_) => {
+                                std::ptr::null_mut()
+                            }
+                        }
+                    }
+
                     if let Ok(animation_data) = active_animation {
                         self.markers = extract_markers(animation_data.as_str());
                         let animation_loaded = self.load_animation_common(
-                            |renderer, w, h| renderer.load_data(&animation_data, w, h),
+                            |renderer, w, h| {
+                                renderer.set_asset_resolver(Some(asset_resolver_callback), manager_ptr)?;
+                                renderer.load_data(&animation_data, w, h)
+                            },
                             width,
                             height,
                         );

dotlottie-rs/src/fms/mod.rs

@@ -14,7 +14,6 @@ const BASE64_CHARS: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrst
 const DATA_IMAGE_PREFIX: &str = "data:image/";
 const DATA_FONT_PREFIX: &str = "data:font/";
 const BASE64_PREFIX: &str = ";base64,";
-const DEFAULT_EXT: &str = "png";
 const DEFAULT_FONT_EXT: &str = "ttf";
 
 pub struct DotLottieManager {
@@ -91,40 +90,13 @@ impl DotLottieManager {
             .get_mut("assets")
             .and_then(|v| v.as_array_mut())
         {
-            let image_prefix = if self.version == 2 { "i/" } else { "images/" };
-            let mut asset_path = String::with_capacity(128); // Larger initial capacity
-
             let embedded_flag = Value::Number(1.into());
-            let empty_u = Value::String(String::new());
 
             for asset in assets.iter_mut() {
                 if let Some(asset_obj) = asset.as_object_mut() {
                     if let Some(p_str) = asset_obj.get("p").and_then(|v| v.as_str()) {
                         if p_str.starts_with(DATA_IMAGE_PREFIX) {
                             asset_obj.insert("e".to_string(), embedded_flag.clone());
-                        } else {
-                            asset_path.clear();
-                            asset_path.push_str(image_prefix);
-                            asset_path.push_str(p_str.trim_matches('"'));
-
-                            if let Ok(mut result) = archive.by_name(&asset_path) {
-                                let mut content = Vec::with_capacity(result.size() as usize);
-                                if result.read_to_end(&mut content).is_ok() {
-                                    let image_ext = p_str
-                                        .rfind('.')
-                                        .map(|i| &p_str[i + 1..])
-                                        .unwrap_or(DEFAULT_EXT);
-                                    let image_data_base64 = Self::encode_base64(&content);
-
-                                    let data_url = format!(
-                                        "{DATA_IMAGE_PREFIX}{image_ext}{BASE64_PREFIX}{image_data_base64}"
-                                    );
-
-                                    asset_obj.insert("u".to_string(), empty_u.clone());
-                                    asset_obj.insert("p".to_string(), Value::String(data_url));
-                                    asset_obj.insert("e".to_string(), embedded_flag.clone());
-                                }
-                            }
                         }
                     }
                 }
@@ -182,6 +154,23 @@ impl DotLottieManager {
         serde_json::to_string(&lottie_animation).map_err(|_| DotLottieError::ReadContentError)
     }
 
+    pub fn resolve_asset(&self, asset_path: &str) -> Result<Vec<u8>, DotLottieError> {
+        let mut archive = self.archive.borrow_mut();
+
+        let image_prefix = if self.version == 2 { "i/" } else { "images/" };
+        let asset_name = asset_path.split('/').next_back().unwrap_or("");
+        let asset_path = format!("{image_prefix}{asset_name}");
+
+        if let Ok(mut result) = archive.by_name(&asset_path) {
+            let mut content = Vec::with_capacity(result.size() as usize);
+            if result.read_to_end(&mut content).is_ok() {
+                return Ok(content);
+            }
+        }
+
+        Err(DotLottieError::FileFindError)
+    }
+
     #[inline]
     pub fn get_state_machine(&self, state_machine_id: &str) -> Result<String, DotLottieError> {
         let mut archive = self.archive.borrow_mut();

dotlottie-rs/src/lottie_renderer/mod.rs

@@ -8,7 +8,7 @@ pub use renderer::{Animation, ColorSpace, Drawable, Renderer, Shape};
 #[cfg(any(feature = "tvg-v0", feature = "tvg-v1"))]
 pub use thorvg::{TvgAnimation, TvgEngine, TvgError, TvgRenderer, TvgShape};
 
-use std::{error::Error, fmt};
+use std::{error::Error, fmt, ffi::c_void};
 
 #[derive(Debug)]
 pub enum LottieRendererError {
@@ -32,6 +32,8 @@ fn into_lottie<R: Renderer>(_err: R::Error) -> LottieRendererError {
     LottieRendererError::RendererError
 }
 
+pub type AssetResolverFn = unsafe extern "C" fn(*const i8, *mut c_void) -> *mut Vec<u8>;
+
 pub trait LottieRenderer {
     fn load_data(&mut self, data: &str, width: u32, height: u32)
         -> Result<(), LottieRendererError>;
@@ -96,6 +98,12 @@ pub trait LottieRenderer {
     fn get_transform(&self) -> Result<[f32; 9], LottieRendererError>;
 
     fn set_transform(&mut self, transform: &[f32; 9]) -> Result<(), LottieRendererError>;
+
+    fn set_asset_resolver(
+        &mut self,
+        resolver: Option<AssetResolverFn>,
+        user_data: *mut c_void,
+    ) -> Result<(), LottieRendererError>;
 }
 
 impl dyn LottieRenderer {
@@ -114,6 +122,8 @@ impl dyn LottieRenderer {
             buffer: vec![],
             layout: Layout::default(),
             user_transform: [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0],
+            asset_resolver: None,
+            asset_resolver_user_data: std::ptr::null_mut(),
         })
     }
 }
@@ -133,6 +143,8 @@ struct LottieRendererImpl<R: Renderer> {
     buffer: Vec<u32>,
     layout: Layout,
     user_transform: [f32; 9],
+    asset_resolver: Option<AssetResolverFn>,
+    asset_resolver_user_data: *mut c_void,
 }
 
 impl<R: Renderer> LottieRendererImpl<R> {
@@ -187,6 +199,11 @@ impl<R: Renderer> LottieRendererImpl<R> {
     fn load_animation(&mut self, data: &str) -> Result<R::Animation, LottieRendererError> {
         let mut animation = R::Animation::default();
 
+        #[cfg(feature = "tvg-v1")]
+        if let Some(resolver) = self.asset_resolver {
+            animation.set_asset_resolver(Some(resolver), self.asset_resolver_user_data).map_err(into_lottie::<R>)?;
+        }
+
         #[cfg(feature = "tvg-v0")]
         animation
             .load_data(data, "lottie")
@@ -577,6 +594,16 @@ impl<R: Renderer> LottieRenderer for LottieRendererImpl<R> {
 
         Ok(())
     }
+
+    fn set_asset_resolver(
+        &mut self,
+        resolver: Option<AssetResolverFn>,
+        user_data: *mut c_void,
+    ) -> Result<(), LottieRendererError> {
+        self.asset_resolver = resolver;
+        self.asset_resolver_user_data = user_data;
+        Ok(())
+    }
 }
 
 #[inline]

dotlottie-rs/src/lottie_renderer/renderer.rs

@@ -1,4 +1,5 @@
 use core::error;
+use std::ffi::c_void;
 
 pub enum ColorSpace {
     ABGR8888,
@@ -59,6 +60,12 @@ pub trait Animation: Default {
 
     fn set_quality(&mut self, quality: u8) -> Result<(), Self::Error>;
 
+    fn set_asset_resolver(
+        &mut self, 
+        resolver: Option<super::AssetResolverFn>,
+        user_data: *mut c_void,
+    ) -> Result<(), Self::Error>;
+
     fn tween(
         &mut self,
         to: f32,

dotlottie-rs/src/lottie_renderer/thorvg.rs

@@ -4,12 +4,15 @@ use crate::time::Instant;
 #[cfg_attr(not(feature = "tvg-v1"), allow(unused_imports))]
 use std::{
     error::Error,
-    ffi::{c_char, CString},
+    ffi::{c_char, c_void, CString},
     fmt, ptr,
     result::Result,
 };
 
-use super::{Animation, ColorSpace, Drawable, Renderer, Shape};
+use super::{Animation, ColorSpace, Drawable, Renderer, Shape, AssetResolverFn};
+
+#[cfg(feature = "tvg-v1")]
+const DEFAULT_EXT: &str = "png";
 
 #[expect(non_upper_case_globals)]
 #[allow(non_snake_case)]
@@ -507,6 +510,83 @@ impl Animation for TvgAnimation {
         Err(TvgError::NotSupported)
     }
 
+    fn set_asset_resolver(
+        &mut self, 
+        #[cfg_attr(not(feature = "tvg-v1"), allow(unused_variables))]
+        resolver: Option<AssetResolverFn>,
+        #[cfg_attr(not(feature = "tvg-v1"), allow(unused_variables))]
+        user_data: *mut c_void,
+    ) -> Result<(), TvgError> {
+        #[cfg(feature = "tvg-v1")]
+        {
+            if let Some(asset_resolver_fn) = resolver {
+                // Create a struct to hold both the resolver function and user_data
+                let resolver_data = Box::new((asset_resolver_fn, user_data));
+                let resolver_data_ptr = Box::into_raw(resolver_data) as *mut c_void;
+
+                unsafe extern "C" fn thorvg_asset_resolver_wrapper(
+                    paint: tvg::Tvg_Paint,
+                    src: *const i8,
+                    user_data: *mut c_void
+                ) -> bool {
+                    if user_data.is_null() {
+                        return false;
+                    }
+
+                    // Extract the resolver function and original user_data
+                    let (resolver_fn, original_user_data) = *(user_data as *const (AssetResolverFn, *mut c_void));
+
+                    let asset_data_ptr = resolver_fn(src, original_user_data);
+                    if asset_data_ptr.is_null() {
+                        return false;
+                    }
+
+                    let src_str = match std::ffi::CStr::from_ptr(src).to_str() {
+                        Ok(s) => s,
+                        Err(_) => return false,
+                    };
+
+                    let image_ext = src_str
+                                        .rfind('.')
+                                        .map(|i| &src_str[i + 1..])
+                                        .unwrap_or(DEFAULT_EXT);
+
+                    let asset_data = unsafe { Box::from_raw(asset_data_ptr) };
+
+                    let result = TvgAnimation::tvg_load_data_dispatch(
+                        paint,
+                        asset_data.as_ptr() as *const i8,
+                        asset_data.len() as u32,
+                        CString::new(image_ext).unwrap().as_ptr(),
+                    );
+
+                    drop(asset_data);
+
+                    result.is_ok()
+                }
+
+                unsafe {
+                    tvg::tvg_picture_set_asset_resolver(
+                        self.raw_paint,
+                        Some(thorvg_asset_resolver_wrapper),
+                        resolver_data_ptr,
+                    ).into_result()
+                }
+            } else {
+                unsafe {
+                    tvg::tvg_picture_set_asset_resolver(
+                        self.raw_paint,
+                        None,
+                        std::ptr::null_mut(),
+                    ).into_result()
+                }
+            }
+        }
+
+        #[cfg(not(feature = "tvg-v1"))]
+        Err(TvgError::NotSupported)
+    }
+
     fn tween(
         &mut self,
         _to: f32,