script/dom/audio/
iirfilternode.rs1use std::sync::Arc;
6
7use dom_struct::dom_struct;
8use itertools::Itertools;
9use js::context::JSContext;
10use js::gc::CustomAutoRooterGuard;
11use js::rust::HandleObject;
12use js::typedarray::Float32Array;
13use script_bindings::reflector::reflect_dom_object_with_proto;
14use servo_media::audio::audio_node::AudioNodeInit;
15use servo_media::audio::graph::NodeId;
16use servo_media::audio::iir_filter_node::{IIRFilterNode as IIRFilter, IIRFilterNodeOptions};
17
18use crate::conversions::Convert;
19use crate::dom::audio::audionode::{AudioNode, AudioNodeOptionsHelper};
20use crate::dom::audio::baseaudiocontext::BaseAudioContext;
21use crate::dom::audionode::UnwrappedAudioNodeOptions;
22use crate::dom::bindings::codegen::Bindings::AudioNodeBinding::{
23 ChannelCountMode, ChannelInterpretation,
24};
25use crate::dom::bindings::codegen::Bindings::IIRFilterNodeBinding::{
26 IIRFilterNodeMethods, IIRFilterOptions,
27};
28use crate::dom::bindings::error::{Error, Fallible};
29use crate::dom::bindings::num::Finite;
30use crate::dom::bindings::root::DomRoot;
31use crate::dom::window::Window;
32
33#[dom_struct]
34pub(crate) struct IIRFilterNode {
35 node: AudioNode,
36 feedforward: Vec<Finite<f64>>,
37 feedback: Vec<Finite<f64>>,
38}
39
40impl IIRFilterNode {
41 fn new_inherited(
42 node_id: Option<NodeId>,
43 context: &BaseAudioContext,
44 node_options: UnwrappedAudioNodeOptions,
45 feedforward: Vec<Finite<f64>>,
46 feedback: Vec<Finite<f64>>,
47 ) -> Self {
48 IIRFilterNode {
49 node: AudioNode::new_inherited(
50 node_id,
51 context,
52 node_options,
53 1, 1, ),
56 feedforward,
57 feedback,
58 }
59 }
60}
61
62impl IIRFilterNodeMethods<crate::DomTypeHolder> for IIRFilterNode {
63 fn Constructor(
65 cx: &mut JSContext,
66 window: &Window,
67 proto: Option<HandleObject>,
68 context: &BaseAudioContext,
69 options: &IIRFilterOptions,
70 ) -> Fallible<DomRoot<IIRFilterNode>> {
71 if !(1..=20).contains(&options.feedforward.len()) ||
72 !(1..=20).contains(&options.feedback.len())
73 {
74 return Err(Error::NotSupported(Some(
75 "Invalid number of filter coefficients".into(),
76 )));
77 }
78 if options.feedforward.iter().all(|v| **v == 0.0) || *options.feedback[0] == 0.0 {
79 return Err(Error::InvalidState(Some(
80 "Invalid filter coefficients".into(),
81 )));
82 }
83 let node_options =
84 options
85 .parent
86 .unwrap_or(2, ChannelCountMode::Max, ChannelInterpretation::Speakers);
87
88 if AudioNode::channel_count_check(node_options.count) {
89 return Err(Error::NotSupported(Some(String::from(
90 "Channel count not supported",
91 ))));
92 }
93
94 let feedforward = (*options.feedforward).to_vec();
95 let feedback = (*options.feedback).to_vec();
96 let init_options = options.clone().convert();
97 let audio_node_init = AudioNodeInit::IIRFilterNode(init_options);
98 let node_id =
99 AudioNode::generate_audio_node_id(cx, &node_options, audio_node_init, context);
100
101 Ok(reflect_dom_object_with_proto(
102 cx,
103 Box::new(IIRFilterNode::new_inherited(
104 node_id,
105 context,
106 node_options,
107 feedforward,
108 feedback,
109 )),
110 window,
111 proto,
112 ))
113 }
114
115 fn GetFrequencyResponse(
117 &self,
118 frequency_hz: CustomAutoRooterGuard<Float32Array>,
119 mut mag_response: CustomAutoRooterGuard<Float32Array>,
120 mut phase_response: CustomAutoRooterGuard<Float32Array>,
121 ) -> Result<(), Error> {
122 let frequency_hz_vec = frequency_hz.to_vec().unwrap_or(vec![]);
123 let mut mag_response_vec = mag_response.to_vec().unwrap_or(vec![]);
124 let mut phase_response_vec = phase_response.to_vec().unwrap_or(vec![]);
125
126 let len = frequency_hz.len();
127 if len != mag_response.len() || len != phase_response.len() {
128 return Err(Error::InvalidAccess(Some(
129 "Arrays must have the same length".into(),
130 )));
131 }
132 let feedforward: Vec<f64> = (self.feedforward.iter().map(|v| **v).collect_vec()).to_vec();
133 let feedback: Vec<f64> = (self.feedback.iter().map(|v| **v).collect_vec()).to_vec();
134 IIRFilter::get_frequency_response(
135 &feedforward,
136 &feedback,
137 &frequency_hz_vec,
138 &mut mag_response_vec,
139 &mut phase_response_vec,
140 );
141
142 mag_response.update(&mag_response_vec);
143 phase_response.update(&phase_response_vec);
144
145 Ok(())
146 }
147}
148
149impl Convert<IIRFilterNodeOptions> for IIRFilterOptions {
150 fn convert(self) -> IIRFilterNodeOptions {
151 let feedforward: Vec<f64> = (*self.feedforward.iter().map(|v| **v).collect_vec()).to_vec();
152 let feedback: Vec<f64> = (*self.feedback.iter().map(|v| **v).collect_vec()).to_vec();
153 IIRFilterNodeOptions {
154 feedforward: Arc::new(feedforward),
155 feedback: Arc::new(feedback),
156 }
157 }
158}