[librsvg: 10/23] feConvolveMatrix - resolve and render separately

[Federico Mena Quintero <federico src gnome org>]

commit 96d8c0c372c089b44f882fe58ce925fc94d639f7
Author: Federico Mena Quintero <federico gnome org>
Date:   Thu Mar 11 14:15:06 2021 -0600

    feConvolveMatrix - resolve and render separately

 src/filters/convolve_matrix.rs | 48 +++++++++++++++++++++++++++++++++++-------
 src/filters/mod.rs             |  5 ++---
 2 files changed, 42 insertions(+), 11 deletions(-)
---
diff --git a/src/filters/convolve_matrix.rs b/src/filters/convolve_matrix.rs
index fbc33546..806bcb23 100644
--- a/src/filters/convolve_matrix.rs
+++ b/src/filters/convolve_matrix.rs
@@ -10,6 +10,7 @@ use crate::node::{CascadedValues, Node};
 use crate::parsers::{
     NonNegative, NumberList, NumberListLength, NumberOptionalNumber, Parse, ParseValue,
 };
+use crate::property_defs::ColorInterpolationFilters;
 use crate::rect::IRect;
 use crate::surface_utils::{
     iterators::{PixelRectangle, Pixels},
@@ -37,6 +38,21 @@ pub struct FeConvolveMatrix {
     preserve_alpha: bool,
 }
 
+pub struct ConvolveMatrix {
+    base: Primitive,
+    in1: Input,
+    order: (u32, u32),
+    kernel_matrix: Option<DMatrix<f64>>,
+    divisor: f64,
+    bias: f64,
+    target_x: Option<u32>,
+    target_y: Option<u32>,
+    edge_mode: EdgeMode,
+    kernel_unit_length: Option<(f64, f64)>,
+    preserve_alpha: bool,
+    color_interpolation_filters: ColorInterpolationFilters,
+}
+
 impl Default for FeConvolveMatrix {
     /// Constructs a new `ConvolveMatrix` with empty properties.
     #[inline]
@@ -121,21 +137,21 @@ impl SetAttributes for FeConvolveMatrix {
     }
 }
 
-impl FeConvolveMatrix {
+impl ConvolveMatrix {
     pub fn render(
         &self,
-        node: &Node,
         ctx: &FilterContext,
         acquired_nodes: &mut AcquiredNodes<'_>,
         draw_ctx: &mut DrawingCtx,
     ) -> Result<FilterResult, FilterError> {
         #![allow(clippy::many_single_char_names)]
 
-        let cascaded = CascadedValues::new_from_node(node);
-        let values = cascaded.get();
-        let cif = values.color_interpolation_filters();
-
-        let input_1 = ctx.get_input(acquired_nodes, draw_ctx, &self.in1, cif)?;
+        let input_1 = ctx.get_input(
+            acquired_nodes,
+            draw_ctx,
+            &self.in1,
+            self.color_interpolation_filters,
+        )?;
         let mut bounds = self
             .base
             .get_bounds(ctx)?
@@ -290,7 +306,23 @@ impl FeConvolveMatrix {
 
 impl FilterEffect for FeConvolveMatrix {
     fn resolve(&self, node: &Node) -> Result<PrimitiveParams, FilterError> {
-        Ok(PrimitiveParams::ConvolveMatrix(node.clone()))
+        let cascaded = CascadedValues::new_from_node(node);
+        let values = cascaded.get();
+
+        Ok(PrimitiveParams::ConvolveMatrix(ConvolveMatrix {
+            base: self.base.clone(),
+            in1: self.in1.clone(),
+            order: self.order.clone(),
+            kernel_matrix: self.kernel_matrix.clone(),
+            divisor: self.divisor.clone(),
+            bias: self.bias.clone(),
+            target_x: self.target_x.clone(),
+            target_y: self.target_y.clone(),
+            edge_mode: self.edge_mode.clone(),
+            kernel_unit_length: self.kernel_unit_length.clone(),
+            preserve_alpha: self.preserve_alpha.clone(),
+            color_interpolation_filters: values.color_interpolation_filters(),
+        }))
     }
 }
 
diff --git a/src/filters/mod.rs b/src/filters/mod.rs
index a2026004..013a0f8f 100644
--- a/src/filters/mod.rs
+++ b/src/filters/mod.rs
@@ -52,7 +52,6 @@ pub mod offset;
 pub mod tile;
 pub mod turbulence;
 
-use convolve_matrix::FeConvolveMatrix;
 use displacement_map::FeDisplacementMap;
 use flood::FeFlood;
 use gaussian_blur::FeGaussianBlur;
@@ -75,7 +74,7 @@ pub enum PrimitiveParams {
     ColorMatrix(color_matrix::ColorMatrix),
     ComponentTransfer(component_transfer::ComponentTransfer),
     Composite(composite::Composite),
-    ConvolveMatrix(Node),
+    ConvolveMatrix(convolve_matrix::ConvolveMatrix),
     DiffuseLighting(Node),
     DisplacementMap(Node),
     Flood(Node),
@@ -326,7 +325,7 @@ fn render_primitive(
         (Element::FeColorMatrix(_), ColorMatrix(p))             => p.render(ctx, acquired_nodes, draw_ctx),
         (Element::FeComponentTransfer(_), ComponentTransfer(p)) => p.render(ctx, acquired_nodes, draw_ctx),
         (Element::FeComposite(_), Composite(p))                 => p.render(ctx, acquired_nodes, draw_ctx),
-        (Element::FeConvolveMatrix(ref inner), ConvolveMatrix(node))       => 
FeConvolveMatrix::render(&inner.element_impl, &node, ctx, acquired_nodes, draw_ctx),
+        (Element::FeConvolveMatrix(_), ConvolveMatrix(p))       => p.render(ctx, acquired_nodes, draw_ctx),
         (Element::FeDiffuseLighting(ref inner), DiffuseLighting(node))     => 
FeDiffuseLighting::render(&inner.element_impl, &node, ctx, acquired_nodes, draw_ctx),
         (Element::FeDisplacementMap(ref inner), DisplacementMap(node))     => 
FeDisplacementMap::render(&inner.element_impl, &node, ctx, acquired_nodes, draw_ctx),
         (Element::FeFlood(ref inner), Flood(node))                         => 
FeFlood::render(&inner.element_impl, &node, ctx, acquired_nodes, draw_ctx),