2 Copyright (C) 2008 Paul Davis
3 Author: Sampo Savolainen
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "plugin_eq_gui.h"
24 #include "ardour_ui.h"
25 #include "gui_thread.h"
26 #include "ardour/audio_buffer.h"
27 #include "ardour/data_type.h"
28 #include "ardour/chan_mapping.h"
30 #include <gtkmm/box.h>
31 #include <gtkmm/button.h>
32 #include <gtkmm/checkbutton.h>
37 PluginEqGui::PluginEqGui(boost::shared_ptr
<ARDOUR::PluginInsert
> pluginInsert
)
43 _signal_output_fft(0),
44 _plugin_insert(pluginInsert
)
46 _signal_analysis_running
= false;
47 _samplerate
= ARDOUR_UI::instance()->the_session()->frame_rate();
49 _plugin
= _plugin_insert
->get_impulse_analysis_plugin();
52 set_buffer_size(4096, 16384);
53 //set_buffer_size(4096, 4096);
55 _log_coeff
= (1.0 - 2.0 * (1000.0/(_samplerate
/2.0))) / powf(1000.0/(_samplerate
/2.0), 2.0);
56 _log_max
= log10f(1 + _log_coeff
);
59 // Setup analysis drawing area
60 _analysis_scale_surface
= 0;
62 _analysis_area
= new Gtk::DrawingArea();
63 _analysis_width
= 500.0;
64 _analysis_height
= 500.0;
65 _analysis_area
->set_size_request(_analysis_width
, _analysis_height
);
67 _analysis_area
->signal_expose_event().connect( sigc::mem_fun (*this, &PluginEqGui::expose_analysis_area
));
68 _analysis_area
->signal_size_allocate().connect( sigc::mem_fun (*this, &PluginEqGui::resize_analysis_area
));
72 dBScaleModel
= Gtk::ListStore::create(dBColumns
);
74 dBScaleCombo
= new Gtk::ComboBox(dBScaleModel
);
75 dBScaleCombo
-> set_title("dB scale");
77 #define ADD_DB_ROW(MIN,MAX,STEP,NAME) \
79 Gtk::TreeModel::Row row = *(dBScaleModel->append()); \
80 row[dBColumns.dBMin] = (MIN); \
81 row[dBColumns.dBMax] = (MAX); \
82 row[dBColumns.dBStep] = (STEP); \
83 row[dBColumns.name] = NAME; \
86 ADD_DB_ROW( -6, +6, 1, "-6dB .. +6dB");
87 ADD_DB_ROW(-12, +12, 3, "-12dB .. +12dB");
88 ADD_DB_ROW(-24, +24, 5, "-24dB .. +24dB");
89 ADD_DB_ROW(-36, +36, 6, "-36dB .. +36dB");
90 ADD_DB_ROW(-64, +64,12, "-64dB .. +64dB");
94 dBScaleCombo
-> pack_start(dBColumns
.name
);
95 dBScaleCombo
-> set_active(1);
97 dBScaleCombo
-> signal_changed().connect( sigc::mem_fun(*this, &PluginEqGui::change_dB_scale
) );
99 Gtk::Label
*dBComboLabel
= new Gtk::Label("dB scale");
101 Gtk::HBox
*dBSelectBin
= new Gtk::HBox(false, 5);
102 dBSelectBin
->add( *manage(dBComboLabel
));
103 dBSelectBin
->add( *manage(dBScaleCombo
));
106 _phase_button
= new Gtk::CheckButton("Show phase");
107 _phase_button
->set_active(true);
108 _phase_button
->signal_toggled().connect( sigc::mem_fun(*this, &PluginEqGui::redraw_scales
));
111 attach( *manage(_analysis_area
), 1, 3, 1, 2);
112 attach( *manage(dBSelectBin
), 1, 2, 2, 3, Gtk::SHRINK
, Gtk::SHRINK
);
113 attach( *manage(_phase_button
), 2, 3, 2, 3, Gtk::SHRINK
, Gtk::SHRINK
);
116 // Connect the realtime signal collection callback
117 _plugin_insert
->AnalysisDataGathered
.connect( sigc::mem_fun(*this, &PluginEqGui::signal_collect_callback
));
120 PluginEqGui::~PluginEqGui()
122 if (_analysis_scale_surface
) {
123 cairo_surface_destroy (_analysis_scale_surface
);
127 delete _signal_input_fft
;
128 delete _signal_output_fft
;
130 _plugin
->deactivate();
132 // all gui objects are *manage'd by the inherited Table object
137 PluginEqGui::on_hide()
140 Gtk::Table::on_hide();
144 PluginEqGui::stop_updating()
146 if (_update_connection
.connected()) {
147 _update_connection
.disconnect();
152 PluginEqGui::start_updating()
154 if (!_update_connection
.connected() && is_visible()) {
155 _update_connection
= Glib::signal_timeout().connect( sigc::mem_fun(this, &PluginEqGui::timeout_callback
), 250);
160 PluginEqGui::on_show()
162 Gtk::Table::on_show();
166 Gtk::Widget
*toplevel
= get_toplevel();
168 std::cerr
<< "No toplevel widget for PluginEqGui?!?!" << std::endl
;
171 if (!_window_unmap_connection
.connected()) {
172 _window_unmap_connection
= toplevel
->signal_unmap().connect( sigc::mem_fun(this, &PluginEqGui::stop_updating
));
175 if (!_window_map_connection
.connected()) {
176 _window_map_connection
= toplevel
->signal_map().connect( sigc::mem_fun(this, &PluginEqGui::start_updating
));
182 PluginEqGui::change_dB_scale()
184 Gtk::TreeModel::iterator iter
= dBScaleCombo
-> get_active();
186 Gtk::TreeModel::Row row
;
188 if(iter
&& (row
= *iter
)) {
189 _min_dB
= row
[dBColumns
.dBMin
];
190 _max_dB
= row
[dBColumns
.dBMax
];
191 _step_dB
= row
[dBColumns
.dBStep
];
199 PluginEqGui::redraw_scales()
202 if (_analysis_scale_surface
) {
203 cairo_surface_destroy (_analysis_scale_surface
);
204 _analysis_scale_surface
= 0;
207 _analysis_area
->queue_draw();
209 // TODO: Add graph legend!
213 PluginEqGui::set_buffer_size(uint32_t size
, uint32_t signal_size
)
215 if (_buffer_size
== size
&& _signal_buffer_size
== signal_size
)
219 FFT
*tmp1
= _impulse_fft
;
220 FFT
*tmp2
= _signal_input_fft
;
221 FFT
*tmp3
= _signal_output_fft
;
224 _impulse_fft
= new FFT(size
);
225 _signal_input_fft
= new FFT(signal_size
);
226 _signal_output_fft
= new FFT(signal_size
);
228 // Don't care about lost memory, we're screwed anyhow
230 _signal_input_fft
= tmp2
;
231 _signal_output_fft
= tmp3
;
240 _signal_buffer_size
= signal_size
;
242 // These are for impulse analysis only, the signal analysis uses the actual
243 // number of I/O's for the plugininsert
244 uint32_t inputs
= _plugin
->get_info()->n_inputs
.n_audio();
245 uint32_t outputs
= _plugin
->get_info()->n_outputs
.n_audio();
247 // buffers for the signal analysis are ensured inside PluginInsert
248 uint32_t n_chans
= std::max(inputs
, outputs
);
249 _bufferset
.ensure_buffers(ARDOUR::DataType::AUDIO
, n_chans
, _buffer_size
);
250 _collect_bufferset
.ensure_buffers(ARDOUR::DataType::AUDIO
, n_chans
, _buffer_size
);
252 ARDOUR::ChanCount
chanCount(ARDOUR::DataType::AUDIO
, n_chans
);
253 _bufferset
.set_count(chanCount
);
254 _collect_bufferset
.set_count(chanCount
);
258 PluginEqGui::resize_analysis_area(Gtk::Allocation
& size
)
260 _analysis_width
= (float)size
.get_width();
261 _analysis_height
= (float)size
.get_height();
263 if (_analysis_scale_surface
) {
264 cairo_surface_destroy (_analysis_scale_surface
);
265 _analysis_scale_surface
= 0;
270 PluginEqGui::timeout_callback()
272 if (!_signal_analysis_running
) {
273 _signal_analysis_running
= true;
274 _plugin_insert
-> collect_signal_for_analysis(_signal_buffer_size
);
276 run_impulse_analysis();
282 PluginEqGui::signal_collect_callback(ARDOUR::BufferSet
*in
, ARDOUR::BufferSet
*out
)
284 ENSURE_GUI_THREAD(bind (mem_fun (*this, &PluginEqGui::signal_collect_callback
), in
, out
));
286 _signal_input_fft
->reset();
287 _signal_output_fft
->reset();
289 for (uint32_t i
= 0; i
< _plugin_insert
->input_streams().n_audio(); ++i
) {
290 _signal_input_fft
->analyze(in
->get_audio(i
).data(), FFT::HANN
);
293 for (uint32_t i
= 0; i
< _plugin_insert
->output_streams().n_audio(); ++i
) {
294 _signal_output_fft
->analyze(out
->get_audio(i
).data(), FFT::HANN
);
297 _signal_input_fft
->calculate();
298 _signal_output_fft
->calculate();
300 _signal_analysis_running
= false;
302 // This signals calls expose_analysis_area()
303 _analysis_area
->queue_draw();
307 PluginEqGui::run_impulse_analysis()
309 uint32_t inputs
= _plugin
->get_info()->n_inputs
.n_audio();
310 uint32_t outputs
= _plugin
->get_info()->n_outputs
.n_audio();
312 // Create the impulse, can't use silence() because consecutive calls won't work
313 for (uint32_t i
= 0; i
< inputs
; ++i
) {
314 ARDOUR::AudioBuffer
& buf
= _bufferset
.get_audio(i
);
315 ARDOUR::Sample
* d
= buf
.data();
316 memset(d
, 0, sizeof(ARDOUR::Sample
)*_buffer_size
);
320 ARDOUR::ChanMapping
in_map(_plugin
->get_info()->n_inputs
);
321 ARDOUR::ChanMapping
out_map(_plugin
->get_info()->n_outputs
);
323 _plugin
->connect_and_run(_bufferset
, in_map
, out_map
, _buffer_size
, (nframes_t
)0);
324 nframes_t f
= _plugin
->signal_latency();
325 // Adding user_latency() could be interesting
327 // Gather all output, taking latency into account.
328 _impulse_fft
->reset();
330 // Silence collect buffers to copy data to, can't use silence() because consecutive calls won't work
331 for (uint32_t i
= 0; i
< outputs
; ++i
) {
332 ARDOUR::AudioBuffer
&buf
= _collect_bufferset
.get_audio(i
);
333 ARDOUR::Sample
*d
= buf
.data();
334 memset(d
, 0, sizeof(ARDOUR::Sample
)*_buffer_size
);
338 //std::cerr << "0: no latency, copying full buffer, trivial.." << std::endl;
339 for (uint32_t i
= 0; i
< outputs
; ++i
) {
340 memcpy(_collect_bufferset
.get_audio(i
).data(),
341 _bufferset
.get_audio(i
).data(), _buffer_size
* sizeof(float));
345 //std::cerr << (++C) << ": latency is " << f << " frames, doing split processing.." << std::endl;
346 nframes_t target_offset
= 0;
347 nframes_t frames_left
= _buffer_size
; // refaktoroi
349 if (f
>= _buffer_size
) {
350 //std::cerr << (++C) << ": f (=" << f << ") is larger than buffer_size, still trying to reach the actual output" << std::endl;
351 // there is no data in this buffer regarding to the input!
354 // this buffer contains either the first, last or a whole bu the output of the impulse
355 // first part: offset is 0, so we copy to the start of _collect_bufferset
356 // we start at output offset "f"
357 // .. and copy "buffer size" - "f" - "offset" frames
359 nframes_t length
= _buffer_size
- f
- target_offset
;
361 //std::cerr << (++C) << ": copying " << length << " frames to _collect_bufferset.get_audio(i)+" << target_offset << " from bufferset at offset " << f << std::endl;
362 for (uint32_t i
= 0; i
< outputs
; ++i
) {
363 memcpy(_collect_bufferset
.get_audio(i
).data(target_offset
),
364 _bufferset
.get_audio(i
).data() + f
,
365 length
* sizeof(float));
368 target_offset
+= length
;
369 frames_left
-= length
;
372 if (frames_left
> 0) {
373 // Silence the buffers
374 for (uint32_t i
= 0; i
< inputs
; ++i
) {
375 ARDOUR::AudioBuffer
&buf
= _bufferset
.get_audio(i
);
376 ARDOUR::Sample
*d
= buf
.data();
377 memset(d
, 0, sizeof(ARDOUR::Sample
)*_buffer_size
);
380 in_map
= ARDOUR::ChanMapping(_plugin
->get_info()->n_inputs
);
381 out_map
= ARDOUR::ChanMapping(_plugin
->get_info()->n_outputs
);
382 _plugin
->connect_and_run(_bufferset
, in_map
, out_map
, _buffer_size
, (nframes_t
)0);
384 } while ( frames_left
> 0);
389 for (uint32_t i
= 0; i
< outputs
; ++i
) {
390 _impulse_fft
->analyze(_collect_bufferset
.get_audio(i
).data());
393 // normalize the output
394 _impulse_fft
->calculate();
396 // This signals calls expose_analysis_area()
397 _analysis_area
->queue_draw();
401 PluginEqGui::expose_analysis_area(GdkEventExpose
*)
403 redraw_analysis_area();
409 PluginEqGui::draw_analysis_scales(cairo_t
*ref_cr
)
411 // TODO: check whether we need rounding
412 _analysis_scale_surface
= cairo_surface_create_similar(cairo_get_target(ref_cr
),
417 cairo_t
*cr
= cairo_create (_analysis_scale_surface
);
419 cairo_set_source_rgb(cr
, 0.0, 0.0, 0.0);
420 cairo_rectangle(cr
, 0.0, 0.0, _analysis_width
, _analysis_height
);
424 draw_scales_power(_analysis_area
, cr
);
425 if (_phase_button
->get_active()) {
426 draw_scales_phase(_analysis_area
, cr
);
434 PluginEqGui::redraw_analysis_area()
438 cr
= gdk_cairo_create(GDK_DRAWABLE(_analysis_area
->get_window()->gobj()));
440 if (_analysis_scale_surface
== 0) {
441 draw_analysis_scales(cr
);
447 cairo_set_source_surface(cr
, _analysis_scale_surface
, 0.0, 0.0);
450 if (_phase_button
->get_active()) {
451 plot_impulse_phase(_analysis_area
, cr
);
453 plot_impulse_amplitude(_analysis_area
, cr
);
455 // TODO: make this optional
456 plot_signal_amplitude_difference(_analysis_area
, cr
);
463 #define PHASE_PROPORTION 0.5
466 PluginEqGui::draw_scales_phase(Gtk::Widget */
*w*/
, cairo_t
*cr
)
469 cairo_font_extents_t extents
;
470 cairo_font_extents(cr
, &extents
);
473 cairo_text_extents_t t_ext
;
475 for (uint32_t i
= 0; i
< 3; i
++) {
477 y
= _analysis_height
/2.0 - (float)i
*(_analysis_height
/8.0)*PHASE_PROPORTION
;
479 cairo_set_source_rgb(cr
, .8, .9, 0.2);
481 snprintf(buf
,256, "0\u00b0");
483 snprintf(buf
,256, "%d\u00b0", (i
* 45));
485 cairo_text_extents(cr
, buf
, &t_ext
);
486 cairo_move_to(cr
, _analysis_width
- t_ext
.width
- t_ext
.x_bearing
- 2.0, y
- extents
.descent
);
487 cairo_show_text(cr
, buf
);
493 cairo_set_source_rgba(cr
, .8, .9, 0.2, 0.6/(float)i
);
494 cairo_move_to(cr
, 0.0, y
);
495 cairo_line_to(cr
, _analysis_width
, y
);
498 y
= _analysis_height
/2.0 + (float)i
*(_analysis_height
/8.0)*PHASE_PROPORTION
;
501 snprintf(buf
,256, "-%d\u00b0", (i
* 45));
502 cairo_set_source_rgb(cr
, .8, .9, 0.2);
503 cairo_text_extents(cr
, buf
, &t_ext
);
504 cairo_move_to(cr
, _analysis_width
- t_ext
.width
- t_ext
.x_bearing
- 2.0, y
- extents
.descent
);
505 cairo_show_text(cr
, buf
);
508 cairo_set_source_rgba(cr
, .8, .9, 0.2, 0.6/(float)i
);
509 cairo_move_to(cr
, 0.0, y
);
510 cairo_line_to(cr
, _analysis_width
, y
);
512 cairo_set_line_width (cr
, 0.25 + 1.0/(float)(i
+1));
518 PluginEqGui::plot_impulse_phase(Gtk::Widget
*w
, cairo_t
*cr
)
526 // float width = w->get_width();
527 float height
= w
->get_height();
529 cairo_set_source_rgba(cr
, 0.95, 0.3, 0.2, 1.0);
530 for (uint32_t i
= 0; i
< _impulse_fft
->bins()-1; i
++) {
531 // x coordinate of bin i
532 x
= log10f(1.0 + (float)i
/ (float)_impulse_fft
->bins() * _log_coeff
) / _log_max
;
533 x
*= _analysis_width
;
535 y
= _analysis_height
/2.0 - (_impulse_fft
->phase_at_bin(i
)/M_PI
)*(_analysis_height
/2.0)*PHASE_PROPORTION
;
538 cairo_move_to(cr
, x
, y
);
542 } else if (rint(x
) > prevX
|| i
== _impulse_fft
->bins()-1 ) {
543 avgY
= avgY
/(float)avgNum
;
544 if (avgY
> (height
* 10.0) ) avgY
= height
* 10.0;
545 if (avgY
< (-height
* 10.0) ) avgY
= -height
* 10.0;
546 cairo_line_to(cr
, prevX
, avgY
);
547 //cairo_line_to(cr, prevX, avgY/(float)avgNum);
559 cairo_set_line_width (cr
, 2.0);
564 PluginEqGui::draw_scales_power(Gtk::Widget */
*w*/
, cairo_t
*cr
)
566 static float scales
[] = { 30.0, 70.0, 125.0, 250.0, 500.0, 1000.0, 2000.0, 5000.0, 10000.0, 15000.0, 20000.0, -1.0 };
568 float divisor
= _samplerate
/ 2.0 / _impulse_fft
->bins();
571 cairo_set_line_width (cr
, 1.5);
572 cairo_set_font_size(cr
, 9);
574 cairo_font_extents_t extents
;
575 cairo_font_extents(cr
, &extents
);
576 // float fontXOffset = extents.descent + 1.0;
580 for (uint32_t i
= 0; scales
[i
] != -1.0; ++i
) {
581 float bin
= scales
[i
] / divisor
;
583 x
= log10f(1.0 + bin
/ (float)_impulse_fft
->bins() * _log_coeff
) / _log_max
;
584 x
*= _analysis_width
;
586 if (scales
[i
] < 1000.0) {
587 snprintf(buf
, 256, "%0.0f", scales
[i
]);
589 snprintf(buf
, 256, "%0.0fk", scales
[i
]/1000.0);
592 cairo_set_source_rgb(cr
, 0.4, 0.4, 0.4);
594 //cairo_move_to(cr, x + fontXOffset, 3.0);
595 cairo_move_to(cr
, x
- extents
.height
, 3.0);
597 cairo_rotate(cr
, M_PI
/ 2.0);
598 cairo_show_text(cr
, buf
);
599 cairo_rotate(cr
, -M_PI
/ 2.0);
602 cairo_set_source_rgb(cr
, 0.3, 0.3, 0.3);
603 cairo_move_to(cr
, x
, _analysis_height
);
604 cairo_line_to(cr
, x
, 0.0);
610 //double dashes[] = { 1.0, 3.0, 4.5, 3.0 };
611 double dashes
[] = { 3.0, 5.0 };
613 for (float dB
= 0.0; dB
< _max_dB
; dB
+= _step_dB
) {
614 snprintf(buf
, 256, "+%0.0f", dB
);
616 y
= ( _max_dB
- dB
) / ( _max_dB
- _min_dB
);
617 //std::cerr << " y = " << y << std::endl;
618 y
*= _analysis_height
;
621 cairo_set_source_rgb(cr
, 0.4, 0.4, 0.4);
622 cairo_move_to(cr
, 1.0, y
+ extents
.height
+ 1.0);
623 cairo_show_text(cr
, buf
);
627 cairo_set_source_rgb(cr
, 0.2, 0.2, 0.2);
628 cairo_move_to(cr
, 0, y
);
629 cairo_line_to(cr
, _analysis_width
, y
);
633 cairo_set_dash(cr
, dashes
, 2, 0.0);
639 for (float dB
= - _step_dB
; dB
> _min_dB
; dB
-= _step_dB
) {
640 snprintf(buf
, 256, "%0.0f", dB
);
642 y
= ( _max_dB
- dB
) / ( _max_dB
- _min_dB
);
643 y
*= _analysis_height
;
645 cairo_set_source_rgb(cr
, 0.4, 0.4, 0.4);
646 cairo_move_to(cr
, 1.0, y
- extents
.descent
- 1.0);
647 cairo_show_text(cr
, buf
);
650 cairo_set_source_rgb(cr
, 0.2, 0.2, 0.2);
651 cairo_move_to(cr
, 0, y
);
652 cairo_line_to(cr
, _analysis_width
, y
);
656 cairo_set_dash(cr
, 0, 0, 0.0);
663 return 10.0 * log10f(a
);
667 PluginEqGui::plot_impulse_amplitude(Gtk::Widget
*w
, cairo_t
*cr
)
675 // float width = w->get_width();
676 float height
= w
->get_height();
678 cairo_set_source_rgb(cr
, 1.0, 1.0, 1.0);
679 cairo_set_line_width (cr
, 2.5);
681 for (uint32_t i
= 0; i
< _impulse_fft
->bins()-1; i
++) {
682 // x coordinate of bin i
683 x
= log10f(1.0 + (float)i
/ (float)_impulse_fft
->bins() * _log_coeff
) / _log_max
;
684 x
*= _analysis_width
;
686 float yCoeff
= ( power_to_dB(_impulse_fft
->power_at_bin(i
)) - _min_dB
) / (_max_dB
- _min_dB
);
688 y
= _analysis_height
- _analysis_height
*yCoeff
;
691 cairo_move_to(cr
, x
, y
);
695 } else if (rint(x
) > prevX
|| i
== _impulse_fft
->bins()-1 ) {
696 avgY
= avgY
/(float)avgNum
;
697 if (avgY
> (height
* 10.0) ) avgY
= height
* 10.0;
698 if (avgY
< (-height
* 10.0) ) avgY
= -height
* 10.0;
699 cairo_line_to(cr
, prevX
, avgY
);
700 //cairo_line_to(cr, prevX, avgY/(float)avgNum);
716 PluginEqGui::plot_signal_amplitude_difference(Gtk::Widget
*w
, cairo_t
*cr
)
724 // float width = w->get_width();
725 float height
= w
->get_height();
727 cairo_set_source_rgb(cr
, 0.0, 1.0, 0.0);
728 cairo_set_line_width (cr
, 2.5);
730 for (uint32_t i
= 0; i
< _signal_input_fft
->bins()-1; i
++) {
731 // x coordinate of bin i
732 x
= log10f(1.0 + (float)i
/ (float)_signal_input_fft
->bins() * _log_coeff
) / _log_max
;
733 x
*= _analysis_width
;
735 float power_out
= power_to_dB(_signal_output_fft
->power_at_bin(i
));
736 float power_in
= power_to_dB(_signal_input_fft
->power_at_bin(i
));
737 float power
= power_out
- power_in
;
741 double p = 10.0 * log10( 1.0 + (double)_signal_output_fft->power_at_bin(i) - (double)
742 - _signal_input_fft ->power_at_bin(i));
744 float power = (float)p;
746 if ( (i % 1000) == 0) {
747 std::cerr << i << ": " << power << std::endl;
751 if (std::isinf(power
)) {
753 power
= _min_dB
- 1.0;
755 power
= _max_dB
- 1.0;
757 } else if (std::isnan(power
)) {
758 power
= _min_dB
- 1.0;
761 float yCoeff
= ( power
- _min_dB
) / (_max_dB
- _min_dB
);
763 y
= _analysis_height
- _analysis_height
*yCoeff
;
766 cairo_move_to(cr
, x
, y
);
770 } else if (rint(x
) > prevX
|| i
== _impulse_fft
->bins()-1 ) {
771 avgY
= avgY
/(float)avgNum
;
772 if (avgY
> (height
* 10.0) ) avgY
= height
* 10.0;
773 if (avgY
< (-height
* 10.0) ) avgY
= -height
* 10.0;
774 cairo_line_to(cr
, prevX
, avgY
);