use crate::{
AssetSource, DevicePixels, IsZero, RenderImage, Result, SharedString, Size, unpremultiply_rgba,
};
use image::Frame;
use resvg::tiny_skia::Pixmap;
use smallvec::SmallVec;
use std::{
hash::Hash,
sync::{Arc, LazyLock},
};
pub const SMOOTH_SVG_SCALE_FACTOR: f32 = 2.;
#[derive(Clone, PartialEq, Hash, Eq)]
#[doc(hidden)]
pub struct RenderSvgParams {
pub(crate) path: SharedString,
pub(crate) size: Size<DevicePixels>,
}
#[derive(Clone)]
pub struct SvgRenderer {
asset_source: Arc<dyn AssetSource>,
usvg_options: Arc<usvg::Options<'static>>,
}
pub enum SvgSize {
Size(Size<DevicePixels>),
ScaleFactor(f32),
}
impl SvgRenderer {
pub fn new(asset_source: Arc<dyn AssetSource>) -> Self {
static FONT_DB: LazyLock<Arc<usvg::fontdb::Database>> =
LazyLock::new(|| Arc::new(crate::platform::system_fonts::database()));
let default_font_resolver = usvg::FontResolver::default_font_selector();
let font_resolver = Box::new(
move |font: &usvg::Font, db: &mut Arc<usvg::fontdb::Database>| {
if db.is_empty() {
*db = FONT_DB.clone();
}
default_font_resolver(font, db)
},
);
let options = usvg::Options {
font_resolver: usvg::FontResolver {
select_font: font_resolver,
select_fallback: usvg::FontResolver::default_fallback_selector(),
},
..Default::default()
};
Self {
asset_source,
usvg_options: Arc::new(options),
}
}
pub fn render_single_frame(
&self,
bytes: &[u8],
scale_factor: f32,
_legacy_bgra: bool,
) -> Result<Arc<RenderImage>, usvg::Error> {
self.render_pixmap(
bytes,
SvgSize::ScaleFactor(scale_factor * SMOOTH_SVG_SCALE_FACTOR),
)
.map(|pixmap| {
let mut buffer =
image::ImageBuffer::from_raw(pixmap.width(), pixmap.height(), pixmap.take())
.unwrap();
unpremultiply_rgba(&mut buffer);
let mut image = RenderImage::new(SmallVec::from_const([Frame::new(buffer)]));
image.scale_factor = SMOOTH_SVG_SCALE_FACTOR;
Arc::new(image)
})
}
pub(crate) fn render_alpha_mask(
&self,
params: &RenderSvgParams,
bytes: Option<&[u8]>,
) -> Result<Option<(Size<DevicePixels>, Vec<u8>)>> {
anyhow::ensure!(!params.size.is_zero(), "can't render at a zero size");
let render_pixmap = |bytes| {
let pixmap = self.render_pixmap(bytes, SvgSize::Size(params.size))?;
let size = Size::new(
DevicePixels(pixmap.width() as i32),
DevicePixels(pixmap.height() as i32),
);
let alpha_mask = pixmap
.pixels()
.iter()
.map(|p| p.alpha())
.collect::<Vec<_>>();
Ok(Some((size, alpha_mask)))
};
if let Some(bytes) = bytes {
render_pixmap(bytes)
} else if let Some(bytes) = self.asset_source.load(¶ms.path)? {
render_pixmap(&bytes)
} else {
Ok(None)
}
}
fn render_pixmap(&self, bytes: &[u8], size: SvgSize) -> Result<Pixmap, usvg::Error> {
let tree = usvg::Tree::from_data(bytes, &self.usvg_options)?;
let svg_size = tree.size();
let scale = match size {
SvgSize::Size(size) => size.width.0 as f32 / svg_size.width(),
SvgSize::ScaleFactor(scale) => scale,
};
let mut pixmap = resvg::tiny_skia::Pixmap::new(
(svg_size.width() * scale) as u32,
(svg_size.height() * scale) as u32,
)
.ok_or(usvg::Error::InvalidSize)?;
let transform = resvg::tiny_skia::Transform::from_scale(scale, scale);
resvg::render(&tree, transform, &mut pixmap.as_mut());
Ok(pixmap)
}
}
#[cfg(test)]
mod tests {
use super::*;
use anyhow::Context as _;
const HALF_RED: &[u8] = br#"<svg xmlns="http://www.w3.org/2000/svg" width="4" height="2"><rect width="2" height="2" fill="red" opacity="0.5"/></svg>"#;
#[test]
fn svg_alpha_mask_preserves_scaled_size_and_transparency() -> anyhow::Result<()> {
let renderer = SvgRenderer::new(Arc::new(()));
let requested = Size::new(DevicePixels(8), DevicePixels(4));
let (size, alpha) = renderer
.render_alpha_mask(
&RenderSvgParams {
path: "inline.svg".into(),
size: requested,
},
Some(HALF_RED),
)?
.context("inline SVG must produce an alpha mask")?;
assert_eq!(size, requested);
assert_eq!(alpha.len(), 32);
for row in alpha.chunks_exact(8) {
assert_eq!(row, &[128, 128, 128, 128, 0, 0, 0, 0]);
}
Ok(())
}
#[test]
fn svg_single_frame_preserves_supersampling_and_straight_rgba() -> anyhow::Result<()> {
let renderer = SvgRenderer::new(Arc::new(()));
let rgba = renderer.render_single_frame(HALF_RED, 1.0, false)?;
let legacy = renderer.render_single_frame(HALF_RED, 1.0, true)?;
assert_eq!(rgba.frame_count(), 1);
assert_eq!(rgba.size(0), Size::new(DevicePixels(8), DevicePixels(4)));
assert_eq!(legacy.size(0), rgba.size(0));
assert_eq!(rgba.scale_factor, SMOOTH_SVG_SCALE_FACTOR);
let rgba = rgba.as_bytes(0).context("SVG frame must contain pixels")?;
let legacy = legacy
.as_bytes(0)
.context("SVG frame must contain pixels")?;
assert_eq!(rgba, legacy);
for pixel in rgba.chunks_exact(4) {
if pixel[3] == 0 {
assert_eq!(pixel, &[0, 0, 0, 0]);
} else {
assert!(pixel[0].abs_diff(255) <= 1);
assert_eq!(&pixel[1..], &[0, 0, 128]);
}
}
Ok(())
}
#[test]
fn svg_text_uses_system_fonts_and_preserves_clipping() -> anyhow::Result<()> {
let mut options = usvg::Options::default();
*options.fontdb_mut() = crate::platform::system_fonts::database();
let renderer = SvgRenderer {
asset_source: Arc::new(()),
usvg_options: Arc::new(options),
};
let pixmap = renderer.render_pixmap(
br#"<svg xmlns="http://www.w3.org/2000/svg" width="64" height="32"><defs><clipPath id="clip"><rect width="16" height="32"/></clipPath></defs><text x="2" y="24" font-family="sans-serif" font-size="24" clip-path="url(#clip)">Ag</text></svg>"#,
SvgSize::ScaleFactor(1.0),
)?;
assert!(pixmap.pixels().iter().any(|pixel| pixel.alpha() > 0));
for row in pixmap.pixels().chunks_exact(64) {
assert!(row.iter().skip(16).all(|pixel| pixel.alpha() == 0));
}
Ok(())
}
#[test]
fn svg_invalid_input_and_missing_assets_remain_fallible() -> anyhow::Result<()> {
let renderer = SvgRenderer::new(Arc::new(()));
assert!(
renderer
.render_single_frame(b"invalid SVG", 1.0, false)
.is_err()
);
assert!(renderer.render_single_frame(HALF_RED, 0.0, false).is_err());
let mut params = RenderSvgParams {
path: "missing.svg".into(),
size: Size::new(DevicePixels(8), DevicePixels(4)),
};
assert!(renderer.render_alpha_mask(¶ms, None)?.is_none());
params.size.width = DevicePixels(0);
assert!(renderer.render_alpha_mask(¶ms, Some(HALF_RED)).is_err());
Ok(())
}
}