1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
use crate::error::{ParseError, SaveError};
use crate::microphone::compressor::Compressor;
use crate::microphone::equalizer::Equalizer;
use crate::microphone::gate::Gate;
use crate::microphone::mic_setup::MicSetup;
use crate::microphone::ui_setup::UiSetup;
use std::collections::HashMap;
use std::fs::File;
use std::io::{Read, Write};
use std::os::raw::c_float;
use std::path::Path;
use xml::reader::XmlEvent as XmlReaderEvent;
use xml::writer::events::StartElementBuilder;
use xml::writer::XmlEvent as XmlWriterEvent;
use xml::{EmitterConfig, EventReader};
use crate::microphone::equalizer_mini::EqualizerMini;
#[derive(Debug)]
pub struct MicProfileSettings {
equalizer: Equalizer,
equalizer_mini: EqualizerMini,
compressor: Compressor,
gate: Gate,
deess: u8,
mic_setup: MicSetup,
ui_setup: UiSetup,
}
impl MicProfileSettings {
pub fn load<R: Read>(read: R) -> Result<Self, ParseError> {
let parser = EventReader::new(read);
let mut equalizer = Equalizer::new();
let mut equalizer_mini = EqualizerMini::new();
let mut compressor = Compressor::new();
let mut gate = Gate::new();
let mut deess = 0;
let mut mic_setup = MicSetup::new();
let mut ui_setup = UiSetup::new();
for e in parser {
match e {
Ok(XmlReaderEvent::StartElement {
name, attributes, ..
}) => {
if name.local_name == "dspTreeMicProfile" {
equalizer.parse_equaliser(&attributes)?;
equalizer_mini.parse_equaliser(&attributes)?;
compressor.parse_compressor(&attributes)?;
gate.parse_gate(&attributes)?;
for attr in &attributes {
if attr.name.local_name == "MIC_DEESS_AMOUNT" {
deess = attr.value.parse::<c_float>()? as u8;
break;
}
}
continue;
}
if name.local_name == "setupTreeMicProfile" {
mic_setup.parse_config(&attributes)?;
continue;
}
if name.local_name == "micProfileUIMicProfile" {
ui_setup.parse_ui(&attributes)?;
continue;
}
if name.local_name == "MicProfileTree" {
continue;
}
println!("Unhandled Tag: {}", name.local_name);
}
Err(e) => {
println!("Error: {}", e);
break;
}
_ => {}
}
}
Ok(Self {
equalizer,
equalizer_mini,
compressor,
gate,
deess,
mic_setup,
ui_setup,
})
}
pub fn save(&self, path: impl AsRef<Path>) -> Result<(), SaveError> {
dbg!("Saving File: {}", &path.as_ref());
let out_file = File::create(path)?;
self.write_to(out_file)?;
Ok(())
}
pub fn write_to<W: Write>(&self, mut sink: W) -> Result<(), xml::writer::Error> {
let mut writer = EmitterConfig::new()
.perform_indent(true)
.create_writer(&mut sink);
writer.write(XmlWriterEvent::start_element("MicProfileTree"))?;
let mut attributes: HashMap<String, String> = HashMap::default();
self.equalizer.write_equaliser(&mut attributes);
self.equalizer_mini.write_equaliser(&mut attributes);
self.compressor.write_compressor(&mut attributes);
self.gate.write_gate(&mut attributes);
attributes.insert("MIC_DEESS_AMOUNT".to_string(), format!("{}", self.deess));
let mut element: StartElementBuilder = XmlWriterEvent::start_element("dspTreeMicProfile");
for (key, value) in &attributes {
element = element.attr(key.as_str(), value.as_str());
}
writer.write(element)?;
writer.write(XmlWriterEvent::end_element())?;
self.mic_setup.write_config(&mut writer)?;
self.ui_setup.write_ui(&mut writer)?;
writer.write(XmlWriterEvent::end_element())?;
Ok(())
}
pub fn setup_mut(&mut self) -> &mut MicSetup {
&mut self.mic_setup
}
pub fn setup(&self) -> &MicSetup {
&self.mic_setup
}
pub fn gate(&self) -> &Gate { &self.gate }
pub fn gate_mut(&mut self) -> &mut Gate {
&mut self.gate
}
pub fn compressor(&self) -> &Compressor { &self.compressor }
pub fn compressor_mut(&mut self) -> &mut Compressor {
&mut self.compressor
}
pub fn equalizer(&self) -> &Equalizer { &self.equalizer }
pub fn equalizer_mut(&mut self) -> &mut Equalizer {
&mut self.equalizer
}
pub fn equalizer_mini(&self) -> &EqualizerMini { &self.equalizer_mini }
pub fn equalizer_mini_mut(&mut self) -> &mut EqualizerMini {
&mut self.equalizer_mini
}
pub fn deess(&self) -> u8 { self.deess }
}