1 /*
2 * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10 #include "api/audio/echo_canceller3_config_json.h"
11
12 #include <stddef.h>
13
14 #include <string>
15 #include <vector>
16
17 #include "rtc_base/checks.h"
18 #include "rtc_base/logging.h"
19 #include "rtc_base/strings/json.h"
20 #include "rtc_base/strings/string_builder.h"
21
22 namespace webrtc {
23 namespace {
ReadParam(const Json::Value & root,std::string param_name,bool * param)24 void ReadParam(const Json::Value& root, std::string param_name, bool* param) {
25 RTC_DCHECK(param);
26 bool v;
27 if (rtc::GetBoolFromJsonObject(root, param_name, &v)) {
28 *param = v;
29 }
30 }
31
ReadParam(const Json::Value & root,std::string param_name,size_t * param)32 void ReadParam(const Json::Value& root, std::string param_name, size_t* param) {
33 RTC_DCHECK(param);
34 int v;
35 if (rtc::GetIntFromJsonObject(root, param_name, &v) && v >= 0) {
36 *param = v;
37 }
38 }
39
ReadParam(const Json::Value & root,std::string param_name,int * param)40 void ReadParam(const Json::Value& root, std::string param_name, int* param) {
41 RTC_DCHECK(param);
42 int v;
43 if (rtc::GetIntFromJsonObject(root, param_name, &v)) {
44 *param = v;
45 }
46 }
47
ReadParam(const Json::Value & root,std::string param_name,float * param)48 void ReadParam(const Json::Value& root, std::string param_name, float* param) {
49 RTC_DCHECK(param);
50 double v;
51 if (rtc::GetDoubleFromJsonObject(root, param_name, &v)) {
52 *param = static_cast<float>(v);
53 }
54 }
55
ReadParam(const Json::Value & root,std::string param_name,EchoCanceller3Config::Filter::RefinedConfiguration * param)56 void ReadParam(const Json::Value& root,
57 std::string param_name,
58 EchoCanceller3Config::Filter::RefinedConfiguration* param) {
59 RTC_DCHECK(param);
60 Json::Value json_array;
61 if (rtc::GetValueFromJsonObject(root, param_name, &json_array)) {
62 std::vector<double> v;
63 rtc::JsonArrayToDoubleVector(json_array, &v);
64 if (v.size() != 6) {
65 RTC_LOG(LS_ERROR) << "Incorrect array size for " << param_name;
66 return;
67 }
68 param->length_blocks = static_cast<size_t>(v[0]);
69 param->leakage_converged = static_cast<float>(v[1]);
70 param->leakage_diverged = static_cast<float>(v[2]);
71 param->error_floor = static_cast<float>(v[3]);
72 param->error_ceil = static_cast<float>(v[4]);
73 param->noise_gate = static_cast<float>(v[5]);
74 }
75 }
76
ReadParam(const Json::Value & root,std::string param_name,EchoCanceller3Config::Filter::CoarseConfiguration * param)77 void ReadParam(const Json::Value& root,
78 std::string param_name,
79 EchoCanceller3Config::Filter::CoarseConfiguration* param) {
80 RTC_DCHECK(param);
81 Json::Value json_array;
82 if (rtc::GetValueFromJsonObject(root, param_name, &json_array)) {
83 std::vector<double> v;
84 rtc::JsonArrayToDoubleVector(json_array, &v);
85 if (v.size() != 3) {
86 RTC_LOG(LS_ERROR) << "Incorrect array size for " << param_name;
87 return;
88 }
89 param->length_blocks = static_cast<size_t>(v[0]);
90 param->rate = static_cast<float>(v[1]);
91 param->noise_gate = static_cast<float>(v[2]);
92 }
93 }
94
ReadParam(const Json::Value & root,std::string param_name,EchoCanceller3Config::Delay::AlignmentMixing * param)95 void ReadParam(const Json::Value& root,
96 std::string param_name,
97 EchoCanceller3Config::Delay::AlignmentMixing* param) {
98 RTC_DCHECK(param);
99
100 Json::Value subsection;
101 if (rtc::GetValueFromJsonObject(root, param_name, &subsection)) {
102 ReadParam(subsection, "downmix", ¶m->downmix);
103 ReadParam(subsection, "adaptive_selection", ¶m->adaptive_selection);
104 ReadParam(subsection, "activity_power_threshold",
105 ¶m->activity_power_threshold);
106 ReadParam(subsection, "prefer_first_two_channels",
107 ¶m->prefer_first_two_channels);
108 }
109 }
110
ReadParam(const Json::Value & root,std::string param_name,EchoCanceller3Config::Suppressor::SubbandNearendDetection::SubbandRegion * param)111 void ReadParam(
112 const Json::Value& root,
113 std::string param_name,
114 EchoCanceller3Config::Suppressor::SubbandNearendDetection::SubbandRegion*
115 param) {
116 RTC_DCHECK(param);
117 Json::Value json_array;
118 if (rtc::GetValueFromJsonObject(root, param_name, &json_array)) {
119 std::vector<int> v;
120 rtc::JsonArrayToIntVector(json_array, &v);
121 if (v.size() != 2) {
122 RTC_LOG(LS_ERROR) << "Incorrect array size for " << param_name;
123 return;
124 }
125 param->low = static_cast<size_t>(v[0]);
126 param->high = static_cast<size_t>(v[1]);
127 }
128 }
129
ReadParam(const Json::Value & root,std::string param_name,EchoCanceller3Config::Suppressor::MaskingThresholds * param)130 void ReadParam(const Json::Value& root,
131 std::string param_name,
132 EchoCanceller3Config::Suppressor::MaskingThresholds* param) {
133 RTC_DCHECK(param);
134 Json::Value json_array;
135 if (rtc::GetValueFromJsonObject(root, param_name, &json_array)) {
136 std::vector<double> v;
137 rtc::JsonArrayToDoubleVector(json_array, &v);
138 if (v.size() != 3) {
139 RTC_LOG(LS_ERROR) << "Incorrect array size for " << param_name;
140 return;
141 }
142 param->enr_transparent = static_cast<float>(v[0]);
143 param->enr_suppress = static_cast<float>(v[1]);
144 param->emr_transparent = static_cast<float>(v[2]);
145 }
146 }
147 } // namespace
148
Aec3ConfigFromJsonString(absl::string_view json_string,EchoCanceller3Config * config,bool * parsing_successful)149 void Aec3ConfigFromJsonString(absl::string_view json_string,
150 EchoCanceller3Config* config,
151 bool* parsing_successful) {
152 RTC_DCHECK(config);
153 RTC_DCHECK(parsing_successful);
154 EchoCanceller3Config& cfg = *config;
155 cfg = EchoCanceller3Config();
156 *parsing_successful = true;
157
158 Json::Value root;
159 bool success = Json::Reader().parse(std::string(json_string), root);
160 if (!success) {
161 RTC_LOG(LS_ERROR) << "Incorrect JSON format: " << json_string;
162 *parsing_successful = false;
163 return;
164 }
165
166 Json::Value aec3_root;
167 success = rtc::GetValueFromJsonObject(root, "aec3", &aec3_root);
168 if (!success) {
169 RTC_LOG(LS_ERROR) << "Missing AEC3 config field: " << json_string;
170 *parsing_successful = false;
171 return;
172 }
173
174 Json::Value section;
175 if (rtc::GetValueFromJsonObject(aec3_root, "buffering", §ion)) {
176 ReadParam(section, "excess_render_detection_interval_blocks",
177 &cfg.buffering.excess_render_detection_interval_blocks);
178 ReadParam(section, "max_allowed_excess_render_blocks",
179 &cfg.buffering.max_allowed_excess_render_blocks);
180 }
181
182 if (rtc::GetValueFromJsonObject(aec3_root, "delay", §ion)) {
183 ReadParam(section, "default_delay", &cfg.delay.default_delay);
184 ReadParam(section, "down_sampling_factor", &cfg.delay.down_sampling_factor);
185 ReadParam(section, "num_filters", &cfg.delay.num_filters);
186 ReadParam(section, "delay_headroom_samples",
187 &cfg.delay.delay_headroom_samples);
188 ReadParam(section, "hysteresis_limit_blocks",
189 &cfg.delay.hysteresis_limit_blocks);
190 ReadParam(section, "fixed_capture_delay_samples",
191 &cfg.delay.fixed_capture_delay_samples);
192 ReadParam(section, "delay_estimate_smoothing",
193 &cfg.delay.delay_estimate_smoothing);
194 ReadParam(section, "delay_candidate_detection_threshold",
195 &cfg.delay.delay_candidate_detection_threshold);
196
197 Json::Value subsection;
198 if (rtc::GetValueFromJsonObject(section, "delay_selection_thresholds",
199 &subsection)) {
200 ReadParam(subsection, "initial",
201 &cfg.delay.delay_selection_thresholds.initial);
202 ReadParam(subsection, "converged",
203 &cfg.delay.delay_selection_thresholds.converged);
204 }
205
206 ReadParam(section, "use_external_delay_estimator",
207 &cfg.delay.use_external_delay_estimator);
208 ReadParam(section, "log_warning_on_delay_changes",
209 &cfg.delay.log_warning_on_delay_changes);
210
211 ReadParam(section, "render_alignment_mixing",
212 &cfg.delay.render_alignment_mixing);
213 ReadParam(section, "capture_alignment_mixing",
214 &cfg.delay.capture_alignment_mixing);
215 }
216
217 if (rtc::GetValueFromJsonObject(aec3_root, "filter", §ion)) {
218 ReadParam(section, "refined", &cfg.filter.refined);
219 ReadParam(section, "coarse", &cfg.filter.coarse);
220 ReadParam(section, "refined_initial", &cfg.filter.refined_initial);
221 ReadParam(section, "coarse_initial", &cfg.filter.coarse_initial);
222 ReadParam(section, "config_change_duration_blocks",
223 &cfg.filter.config_change_duration_blocks);
224 ReadParam(section, "initial_state_seconds",
225 &cfg.filter.initial_state_seconds);
226 ReadParam(section, "conservative_initial_phase",
227 &cfg.filter.conservative_initial_phase);
228 ReadParam(section, "enable_coarse_filter_output_usage",
229 &cfg.filter.enable_coarse_filter_output_usage);
230 ReadParam(section, "use_linear_filter", &cfg.filter.use_linear_filter);
231 ReadParam(section, "export_linear_aec_output",
232 &cfg.filter.export_linear_aec_output);
233 }
234
235 if (rtc::GetValueFromJsonObject(aec3_root, "erle", §ion)) {
236 ReadParam(section, "min", &cfg.erle.min);
237 ReadParam(section, "max_l", &cfg.erle.max_l);
238 ReadParam(section, "max_h", &cfg.erle.max_h);
239 ReadParam(section, "onset_detection", &cfg.erle.onset_detection);
240 ReadParam(section, "num_sections", &cfg.erle.num_sections);
241 ReadParam(section, "clamp_quality_estimate_to_zero",
242 &cfg.erle.clamp_quality_estimate_to_zero);
243 ReadParam(section, "clamp_quality_estimate_to_one",
244 &cfg.erle.clamp_quality_estimate_to_one);
245 }
246
247 if (rtc::GetValueFromJsonObject(aec3_root, "ep_strength", §ion)) {
248 ReadParam(section, "default_gain", &cfg.ep_strength.default_gain);
249 ReadParam(section, "default_len", &cfg.ep_strength.default_len);
250 ReadParam(section, "echo_can_saturate", &cfg.ep_strength.echo_can_saturate);
251 ReadParam(section, "bounded_erl", &cfg.ep_strength.bounded_erl);
252 }
253
254 if (rtc::GetValueFromJsonObject(aec3_root, "echo_audibility", §ion)) {
255 ReadParam(section, "low_render_limit",
256 &cfg.echo_audibility.low_render_limit);
257 ReadParam(section, "normal_render_limit",
258 &cfg.echo_audibility.normal_render_limit);
259
260 ReadParam(section, "floor_power", &cfg.echo_audibility.floor_power);
261 ReadParam(section, "audibility_threshold_lf",
262 &cfg.echo_audibility.audibility_threshold_lf);
263 ReadParam(section, "audibility_threshold_mf",
264 &cfg.echo_audibility.audibility_threshold_mf);
265 ReadParam(section, "audibility_threshold_hf",
266 &cfg.echo_audibility.audibility_threshold_hf);
267 ReadParam(section, "use_stationarity_properties",
268 &cfg.echo_audibility.use_stationarity_properties);
269 ReadParam(section, "use_stationarity_properties_at_init",
270 &cfg.echo_audibility.use_stationarity_properties_at_init);
271 }
272
273 if (rtc::GetValueFromJsonObject(aec3_root, "render_levels", §ion)) {
274 ReadParam(section, "active_render_limit",
275 &cfg.render_levels.active_render_limit);
276 ReadParam(section, "poor_excitation_render_limit",
277 &cfg.render_levels.poor_excitation_render_limit);
278 ReadParam(section, "poor_excitation_render_limit_ds8",
279 &cfg.render_levels.poor_excitation_render_limit_ds8);
280 ReadParam(section, "render_power_gain_db",
281 &cfg.render_levels.render_power_gain_db);
282 }
283
284 if (rtc::GetValueFromJsonObject(aec3_root, "echo_removal_control",
285 §ion)) {
286 ReadParam(section, "has_clock_drift",
287 &cfg.echo_removal_control.has_clock_drift);
288 ReadParam(section, "linear_and_stable_echo_path",
289 &cfg.echo_removal_control.linear_and_stable_echo_path);
290 }
291
292 if (rtc::GetValueFromJsonObject(aec3_root, "echo_model", §ion)) {
293 Json::Value subsection;
294 ReadParam(section, "noise_floor_hold", &cfg.echo_model.noise_floor_hold);
295 ReadParam(section, "min_noise_floor_power",
296 &cfg.echo_model.min_noise_floor_power);
297 ReadParam(section, "stationary_gate_slope",
298 &cfg.echo_model.stationary_gate_slope);
299 ReadParam(section, "noise_gate_power", &cfg.echo_model.noise_gate_power);
300 ReadParam(section, "noise_gate_slope", &cfg.echo_model.noise_gate_slope);
301 ReadParam(section, "render_pre_window_size",
302 &cfg.echo_model.render_pre_window_size);
303 ReadParam(section, "render_post_window_size",
304 &cfg.echo_model.render_post_window_size);
305 ReadParam(section, "model_reverb_in_nonlinear_mode",
306 &cfg.echo_model.model_reverb_in_nonlinear_mode);
307 }
308
309 if (rtc::GetValueFromJsonObject(aec3_root, "comfort_noise", §ion)) {
310 ReadParam(section, "noise_floor_dbfs", &cfg.comfort_noise.noise_floor_dbfs);
311 }
312
313 Json::Value subsection;
314 if (rtc::GetValueFromJsonObject(aec3_root, "suppressor", §ion)) {
315 ReadParam(section, "nearend_average_blocks",
316 &cfg.suppressor.nearend_average_blocks);
317
318 if (rtc::GetValueFromJsonObject(section, "normal_tuning", &subsection)) {
319 ReadParam(subsection, "mask_lf", &cfg.suppressor.normal_tuning.mask_lf);
320 ReadParam(subsection, "mask_hf", &cfg.suppressor.normal_tuning.mask_hf);
321 ReadParam(subsection, "max_inc_factor",
322 &cfg.suppressor.normal_tuning.max_inc_factor);
323 ReadParam(subsection, "max_dec_factor_lf",
324 &cfg.suppressor.normal_tuning.max_dec_factor_lf);
325 }
326
327 if (rtc::GetValueFromJsonObject(section, "nearend_tuning", &subsection)) {
328 ReadParam(subsection, "mask_lf", &cfg.suppressor.nearend_tuning.mask_lf);
329 ReadParam(subsection, "mask_hf", &cfg.suppressor.nearend_tuning.mask_hf);
330 ReadParam(subsection, "max_inc_factor",
331 &cfg.suppressor.nearend_tuning.max_inc_factor);
332 ReadParam(subsection, "max_dec_factor_lf",
333 &cfg.suppressor.nearend_tuning.max_dec_factor_lf);
334 }
335
336 if (rtc::GetValueFromJsonObject(section, "dominant_nearend_detection",
337 &subsection)) {
338 ReadParam(subsection, "enr_threshold",
339 &cfg.suppressor.dominant_nearend_detection.enr_threshold);
340 ReadParam(subsection, "enr_exit_threshold",
341 &cfg.suppressor.dominant_nearend_detection.enr_exit_threshold);
342 ReadParam(subsection, "snr_threshold",
343 &cfg.suppressor.dominant_nearend_detection.snr_threshold);
344 ReadParam(subsection, "hold_duration",
345 &cfg.suppressor.dominant_nearend_detection.hold_duration);
346 ReadParam(subsection, "trigger_threshold",
347 &cfg.suppressor.dominant_nearend_detection.trigger_threshold);
348 ReadParam(
349 subsection, "use_during_initial_phase",
350 &cfg.suppressor.dominant_nearend_detection.use_during_initial_phase);
351 }
352
353 if (rtc::GetValueFromJsonObject(section, "subband_nearend_detection",
354 &subsection)) {
355 ReadParam(
356 subsection, "nearend_average_blocks",
357 &cfg.suppressor.subband_nearend_detection.nearend_average_blocks);
358 ReadParam(subsection, "subband1",
359 &cfg.suppressor.subband_nearend_detection.subband1);
360 ReadParam(subsection, "subband2",
361 &cfg.suppressor.subband_nearend_detection.subband2);
362 ReadParam(subsection, "nearend_threshold",
363 &cfg.suppressor.subband_nearend_detection.nearend_threshold);
364 ReadParam(subsection, "snr_threshold",
365 &cfg.suppressor.subband_nearend_detection.snr_threshold);
366 }
367
368 ReadParam(section, "use_subband_nearend_detection",
369 &cfg.suppressor.use_subband_nearend_detection);
370
371 if (rtc::GetValueFromJsonObject(section, "high_bands_suppression",
372 &subsection)) {
373 ReadParam(subsection, "enr_threshold",
374 &cfg.suppressor.high_bands_suppression.enr_threshold);
375 ReadParam(subsection, "max_gain_during_echo",
376 &cfg.suppressor.high_bands_suppression.max_gain_during_echo);
377 ReadParam(subsection, "anti_howling_activation_threshold",
378 &cfg.suppressor.high_bands_suppression
379 .anti_howling_activation_threshold);
380 ReadParam(subsection, "anti_howling_gain",
381 &cfg.suppressor.high_bands_suppression.anti_howling_gain);
382 }
383
384 ReadParam(section, "floor_first_increase",
385 &cfg.suppressor.floor_first_increase);
386 ReadParam(section, "conservative_hf_suppression",
387 &cfg.suppressor.conservative_hf_suppression);
388 }
389 }
390
Aec3ConfigFromJsonString(absl::string_view json_string)391 EchoCanceller3Config Aec3ConfigFromJsonString(absl::string_view json_string) {
392 EchoCanceller3Config cfg;
393 bool not_used;
394 Aec3ConfigFromJsonString(json_string, &cfg, ¬_used);
395 return cfg;
396 }
397
Aec3ConfigToJsonString(const EchoCanceller3Config & config)398 std::string Aec3ConfigToJsonString(const EchoCanceller3Config& config) {
399 rtc::StringBuilder ost;
400 ost << "{";
401 ost << "\"aec3\": {";
402 ost << "\"buffering\": {";
403 ost << "\"excess_render_detection_interval_blocks\": "
404 << config.buffering.excess_render_detection_interval_blocks << ",";
405 ost << "\"max_allowed_excess_render_blocks\": "
406 << config.buffering.max_allowed_excess_render_blocks;
407 ost << "},";
408
409 ost << "\"delay\": {";
410 ost << "\"default_delay\": " << config.delay.default_delay << ",";
411 ost << "\"down_sampling_factor\": " << config.delay.down_sampling_factor
412 << ",";
413 ost << "\"num_filters\": " << config.delay.num_filters << ",";
414 ost << "\"delay_headroom_samples\": " << config.delay.delay_headroom_samples
415 << ",";
416 ost << "\"hysteresis_limit_blocks\": " << config.delay.hysteresis_limit_blocks
417 << ",";
418 ost << "\"fixed_capture_delay_samples\": "
419 << config.delay.fixed_capture_delay_samples << ",";
420 ost << "\"delay_estimate_smoothing\": "
421 << config.delay.delay_estimate_smoothing << ",";
422 ost << "\"delay_candidate_detection_threshold\": "
423 << config.delay.delay_candidate_detection_threshold << ",";
424
425 ost << "\"delay_selection_thresholds\": {";
426 ost << "\"initial\": " << config.delay.delay_selection_thresholds.initial
427 << ",";
428 ost << "\"converged\": " << config.delay.delay_selection_thresholds.converged;
429 ost << "},";
430
431 ost << "\"use_external_delay_estimator\": "
432 << (config.delay.use_external_delay_estimator ? "true" : "false") << ",";
433 ost << "\"log_warning_on_delay_changes\": "
434 << (config.delay.log_warning_on_delay_changes ? "true" : "false") << ",";
435
436 ost << "\"render_alignment_mixing\": {";
437 ost << "\"downmix\": "
438 << (config.delay.render_alignment_mixing.downmix ? "true" : "false")
439 << ",";
440 ost << "\"adaptive_selection\": "
441 << (config.delay.render_alignment_mixing.adaptive_selection ? "true"
442 : "false")
443 << ",";
444 ost << "\"activity_power_threshold\": "
445 << config.delay.render_alignment_mixing.activity_power_threshold << ",";
446 ost << "\"prefer_first_two_channels\": "
447 << (config.delay.render_alignment_mixing.prefer_first_two_channels
448 ? "true"
449 : "false");
450 ost << "},";
451
452 ost << "\"capture_alignment_mixing\": {";
453 ost << "\"downmix\": "
454 << (config.delay.capture_alignment_mixing.downmix ? "true" : "false")
455 << ",";
456 ost << "\"adaptive_selection\": "
457 << (config.delay.capture_alignment_mixing.adaptive_selection ? "true"
458 : "false")
459 << ",";
460 ost << "\"activity_power_threshold\": "
461 << config.delay.capture_alignment_mixing.activity_power_threshold << ",";
462 ost << "\"prefer_first_two_channels\": "
463 << (config.delay.capture_alignment_mixing.prefer_first_two_channels
464 ? "true"
465 : "false");
466 ost << "}";
467 ost << "},";
468
469 ost << "\"filter\": {";
470
471 ost << "\"refined\": [";
472 ost << config.filter.refined.length_blocks << ",";
473 ost << config.filter.refined.leakage_converged << ",";
474 ost << config.filter.refined.leakage_diverged << ",";
475 ost << config.filter.refined.error_floor << ",";
476 ost << config.filter.refined.error_ceil << ",";
477 ost << config.filter.refined.noise_gate;
478 ost << "],";
479
480 ost << "\"coarse\": [";
481 ost << config.filter.coarse.length_blocks << ",";
482 ost << config.filter.coarse.rate << ",";
483 ost << config.filter.coarse.noise_gate;
484 ost << "],";
485
486 ost << "\"refined_initial\": [";
487 ost << config.filter.refined_initial.length_blocks << ",";
488 ost << config.filter.refined_initial.leakage_converged << ",";
489 ost << config.filter.refined_initial.leakage_diverged << ",";
490 ost << config.filter.refined_initial.error_floor << ",";
491 ost << config.filter.refined_initial.error_ceil << ",";
492 ost << config.filter.refined_initial.noise_gate;
493 ost << "],";
494
495 ost << "\"coarse_initial\": [";
496 ost << config.filter.coarse_initial.length_blocks << ",";
497 ost << config.filter.coarse_initial.rate << ",";
498 ost << config.filter.coarse_initial.noise_gate;
499 ost << "],";
500
501 ost << "\"config_change_duration_blocks\": "
502 << config.filter.config_change_duration_blocks << ",";
503 ost << "\"initial_state_seconds\": " << config.filter.initial_state_seconds
504 << ",";
505 ost << "\"conservative_initial_phase\": "
506 << (config.filter.conservative_initial_phase ? "true" : "false") << ",";
507 ost << "\"enable_coarse_filter_output_usage\": "
508 << (config.filter.enable_coarse_filter_output_usage ? "true" : "false")
509 << ",";
510 ost << "\"use_linear_filter\": "
511 << (config.filter.use_linear_filter ? "true" : "false") << ",";
512 ost << "\"export_linear_aec_output\": "
513 << (config.filter.export_linear_aec_output ? "true" : "false");
514
515 ost << "},";
516
517 ost << "\"erle\": {";
518 ost << "\"min\": " << config.erle.min << ",";
519 ost << "\"max_l\": " << config.erle.max_l << ",";
520 ost << "\"max_h\": " << config.erle.max_h << ",";
521 ost << "\"onset_detection\": "
522 << (config.erle.onset_detection ? "true" : "false") << ",";
523 ost << "\"num_sections\": " << config.erle.num_sections << ",";
524 ost << "\"clamp_quality_estimate_to_zero\": "
525 << (config.erle.clamp_quality_estimate_to_zero ? "true" : "false") << ",";
526 ost << "\"clamp_quality_estimate_to_one\": "
527 << (config.erle.clamp_quality_estimate_to_one ? "true" : "false");
528 ost << "},";
529
530 ost << "\"ep_strength\": {";
531 ost << "\"default_gain\": " << config.ep_strength.default_gain << ",";
532 ost << "\"default_len\": " << config.ep_strength.default_len << ",";
533 ost << "\"echo_can_saturate\": "
534 << (config.ep_strength.echo_can_saturate ? "true" : "false") << ",";
535 ost << "\"bounded_erl\": "
536 << (config.ep_strength.bounded_erl ? "true" : "false");
537
538 ost << "},";
539
540 ost << "\"echo_audibility\": {";
541 ost << "\"low_render_limit\": " << config.echo_audibility.low_render_limit
542 << ",";
543 ost << "\"normal_render_limit\": "
544 << config.echo_audibility.normal_render_limit << ",";
545 ost << "\"floor_power\": " << config.echo_audibility.floor_power << ",";
546 ost << "\"audibility_threshold_lf\": "
547 << config.echo_audibility.audibility_threshold_lf << ",";
548 ost << "\"audibility_threshold_mf\": "
549 << config.echo_audibility.audibility_threshold_mf << ",";
550 ost << "\"audibility_threshold_hf\": "
551 << config.echo_audibility.audibility_threshold_hf << ",";
552 ost << "\"use_stationarity_properties\": "
553 << (config.echo_audibility.use_stationarity_properties ? "true" : "false")
554 << ",";
555 ost << "\"use_stationarity_properties_at_init\": "
556 << (config.echo_audibility.use_stationarity_properties_at_init ? "true"
557 : "false");
558 ost << "},";
559
560 ost << "\"render_levels\": {";
561 ost << "\"active_render_limit\": " << config.render_levels.active_render_limit
562 << ",";
563 ost << "\"poor_excitation_render_limit\": "
564 << config.render_levels.poor_excitation_render_limit << ",";
565 ost << "\"poor_excitation_render_limit_ds8\": "
566 << config.render_levels.poor_excitation_render_limit_ds8 << ",";
567 ost << "\"render_power_gain_db\": "
568 << config.render_levels.render_power_gain_db;
569 ost << "},";
570
571 ost << "\"echo_removal_control\": {";
572 ost << "\"has_clock_drift\": "
573 << (config.echo_removal_control.has_clock_drift ? "true" : "false")
574 << ",";
575 ost << "\"linear_and_stable_echo_path\": "
576 << (config.echo_removal_control.linear_and_stable_echo_path ? "true"
577 : "false");
578
579 ost << "},";
580
581 ost << "\"echo_model\": {";
582 ost << "\"noise_floor_hold\": " << config.echo_model.noise_floor_hold << ",";
583 ost << "\"min_noise_floor_power\": "
584 << config.echo_model.min_noise_floor_power << ",";
585 ost << "\"stationary_gate_slope\": "
586 << config.echo_model.stationary_gate_slope << ",";
587 ost << "\"noise_gate_power\": " << config.echo_model.noise_gate_power << ",";
588 ost << "\"noise_gate_slope\": " << config.echo_model.noise_gate_slope << ",";
589 ost << "\"render_pre_window_size\": "
590 << config.echo_model.render_pre_window_size << ",";
591 ost << "\"render_post_window_size\": "
592 << config.echo_model.render_post_window_size << ",";
593 ost << "\"model_reverb_in_nonlinear_mode\": "
594 << (config.echo_model.model_reverb_in_nonlinear_mode ? "true" : "false");
595 ost << "},";
596
597 ost << "\"comfort_noise\": {";
598 ost << "\"noise_floor_dbfs\": " << config.comfort_noise.noise_floor_dbfs;
599 ost << "},";
600
601 ost << "\"suppressor\": {";
602 ost << "\"nearend_average_blocks\": "
603 << config.suppressor.nearend_average_blocks << ",";
604 ost << "\"normal_tuning\": {";
605 ost << "\"mask_lf\": [";
606 ost << config.suppressor.normal_tuning.mask_lf.enr_transparent << ",";
607 ost << config.suppressor.normal_tuning.mask_lf.enr_suppress << ",";
608 ost << config.suppressor.normal_tuning.mask_lf.emr_transparent;
609 ost << "],";
610 ost << "\"mask_hf\": [";
611 ost << config.suppressor.normal_tuning.mask_hf.enr_transparent << ",";
612 ost << config.suppressor.normal_tuning.mask_hf.enr_suppress << ",";
613 ost << config.suppressor.normal_tuning.mask_hf.emr_transparent;
614 ost << "],";
615 ost << "\"max_inc_factor\": "
616 << config.suppressor.normal_tuning.max_inc_factor << ",";
617 ost << "\"max_dec_factor_lf\": "
618 << config.suppressor.normal_tuning.max_dec_factor_lf;
619 ost << "},";
620 ost << "\"nearend_tuning\": {";
621 ost << "\"mask_lf\": [";
622 ost << config.suppressor.nearend_tuning.mask_lf.enr_transparent << ",";
623 ost << config.suppressor.nearend_tuning.mask_lf.enr_suppress << ",";
624 ost << config.suppressor.nearend_tuning.mask_lf.emr_transparent;
625 ost << "],";
626 ost << "\"mask_hf\": [";
627 ost << config.suppressor.nearend_tuning.mask_hf.enr_transparent << ",";
628 ost << config.suppressor.nearend_tuning.mask_hf.enr_suppress << ",";
629 ost << config.suppressor.nearend_tuning.mask_hf.emr_transparent;
630 ost << "],";
631 ost << "\"max_inc_factor\": "
632 << config.suppressor.nearend_tuning.max_inc_factor << ",";
633 ost << "\"max_dec_factor_lf\": "
634 << config.suppressor.nearend_tuning.max_dec_factor_lf;
635 ost << "},";
636 ost << "\"dominant_nearend_detection\": {";
637 ost << "\"enr_threshold\": "
638 << config.suppressor.dominant_nearend_detection.enr_threshold << ",";
639 ost << "\"enr_exit_threshold\": "
640 << config.suppressor.dominant_nearend_detection.enr_exit_threshold << ",";
641 ost << "\"snr_threshold\": "
642 << config.suppressor.dominant_nearend_detection.snr_threshold << ",";
643 ost << "\"hold_duration\": "
644 << config.suppressor.dominant_nearend_detection.hold_duration << ",";
645 ost << "\"trigger_threshold\": "
646 << config.suppressor.dominant_nearend_detection.trigger_threshold << ",";
647 ost << "\"use_during_initial_phase\": "
648 << config.suppressor.dominant_nearend_detection.use_during_initial_phase;
649 ost << "},";
650 ost << "\"subband_nearend_detection\": {";
651 ost << "\"nearend_average_blocks\": "
652 << config.suppressor.subband_nearend_detection.nearend_average_blocks
653 << ",";
654 ost << "\"subband1\": [";
655 ost << config.suppressor.subband_nearend_detection.subband1.low << ",";
656 ost << config.suppressor.subband_nearend_detection.subband1.high;
657 ost << "],";
658 ost << "\"subband2\": [";
659 ost << config.suppressor.subband_nearend_detection.subband2.low << ",";
660 ost << config.suppressor.subband_nearend_detection.subband2.high;
661 ost << "],";
662 ost << "\"nearend_threshold\": "
663 << config.suppressor.subband_nearend_detection.nearend_threshold << ",";
664 ost << "\"snr_threshold\": "
665 << config.suppressor.subband_nearend_detection.snr_threshold;
666 ost << "},";
667 ost << "\"use_subband_nearend_detection\": "
668 << config.suppressor.use_subband_nearend_detection << ",";
669 ost << "\"high_bands_suppression\": {";
670 ost << "\"enr_threshold\": "
671 << config.suppressor.high_bands_suppression.enr_threshold << ",";
672 ost << "\"max_gain_during_echo\": "
673 << config.suppressor.high_bands_suppression.max_gain_during_echo << ",";
674 ost << "\"anti_howling_activation_threshold\": "
675 << config.suppressor.high_bands_suppression
676 .anti_howling_activation_threshold
677 << ",";
678 ost << "\"anti_howling_gain\": "
679 << config.suppressor.high_bands_suppression.anti_howling_gain;
680 ost << "},";
681 ost << "\"floor_first_increase\": " << config.suppressor.floor_first_increase
682 << ",";
683 ost << "\"conservative_hf_suppression\": "
684 << config.suppressor.conservative_hf_suppression;
685 ost << "}";
686 ost << "}";
687 ost << "}";
688
689 return ost.Release();
690 }
691 } // namespace webrtc
692