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"
29 #include "ardour/session.h"
31 #include <gtkmm/box.h>
32 #include <gtkmm/button.h>
33 #include <gtkmm/checkbutton.h>
38 using namespace ARDOUR
;
40 PluginEqGui::PluginEqGui(boost::shared_ptr
<ARDOUR::PluginInsert
> pluginInsert
)
46 _signal_output_fft(0),
47 _plugin_insert(pluginInsert
)
49 _signal_analysis_running
= false;
50 _samplerate
= ARDOUR_UI::instance()->the_session()->frame_rate();
52 _plugin
= _plugin_insert
->get_impulse_analysis_plugin();
55 set_buffer_size(4096, 16384);
56 //set_buffer_size(4096, 4096);
58 _log_coeff
= (1.0 - 2.0 * (1000.0/(_samplerate
/2.0))) / powf(1000.0/(_samplerate
/2.0), 2.0);
59 _log_max
= log10f(1 + _log_coeff
);
62 // Setup analysis drawing area
63 _analysis_scale_surface
= 0;
65 _analysis_area
= new Gtk::DrawingArea();
66 _analysis_width
= 256.0;
67 _analysis_height
= 256.0;
68 _analysis_area
->set_size_request(_analysis_width
, _analysis_height
);
70 _analysis_area
->signal_expose_event().connect( sigc::mem_fun (*this, &PluginEqGui::expose_analysis_area
));
71 _analysis_area
->signal_size_allocate().connect( sigc::mem_fun (*this, &PluginEqGui::resize_analysis_area
));
74 dBScaleModel
= Gtk::ListStore::create(dBColumns
);
76 dBScaleCombo
= new Gtk::ComboBox(dBScaleModel
);
77 dBScaleCombo
->set_title (_("dB scale"));
79 #define ADD_DB_ROW(MIN,MAX,STEP,NAME) \
81 Gtk::TreeModel::Row row = *(dBScaleModel->append()); \
82 row[dBColumns.dBMin] = (MIN); \
83 row[dBColumns.dBMax] = (MAX); \
84 row[dBColumns.dBStep] = (STEP); \
85 row[dBColumns.name] = NAME; \
88 ADD_DB_ROW( -6, +6, 1, "-6dB .. +6dB");
89 ADD_DB_ROW(-12, +12, 3, "-12dB .. +12dB");
90 ADD_DB_ROW(-24, +24, 5, "-24dB .. +24dB");
91 ADD_DB_ROW(-36, +36, 6, "-36dB .. +36dB");
92 ADD_DB_ROW(-64, +64,12, "-64dB .. +64dB");
96 dBScaleCombo
-> pack_start(dBColumns
.name
);
97 dBScaleCombo
-> set_active(1);
99 dBScaleCombo
-> signal_changed().connect( sigc::mem_fun(*this, &PluginEqGui::change_dB_scale
) );
101 Gtk::Label
*dBComboLabel
= new Gtk::Label (_("dB scale"));
103 Gtk::HBox
*dBSelectBin
= new Gtk::HBox(false, 5);
104 dBSelectBin
->add( *manage(dBComboLabel
));
105 dBSelectBin
->add( *manage(dBScaleCombo
));
108 _phase_button
= new Gtk::CheckButton (_("Show phase"));
109 _phase_button
->set_active(true);
110 _phase_button
->signal_toggled().connect( sigc::mem_fun(*this, &PluginEqGui::redraw_scales
));
113 attach( *manage(_analysis_area
), 1, 3, 1, 2);
114 attach( *manage(dBSelectBin
), 1, 2, 2, 3, Gtk::SHRINK
, Gtk::SHRINK
);
115 attach( *manage(_phase_button
), 2, 3, 2, 3, Gtk::SHRINK
, Gtk::SHRINK
);
118 // Connect the realtime signal collection callback
119 _plugin_insert
->AnalysisDataGathered
.connect (analysis_connection
, invalidator (*this), ui_bind (&PluginEqGui::signal_collect_callback
, this, _1
, _2
), gui_context());
122 PluginEqGui::~PluginEqGui()
124 if (_analysis_scale_surface
) {
125 cairo_surface_destroy (_analysis_scale_surface
);
129 delete _signal_input_fft
;
130 delete _signal_output_fft
;
132 _plugin
->deactivate();
134 // all gui objects are *manage'd by the inherited Table object
139 PluginEqGui::on_hide()
142 Gtk::Table::on_hide();
146 PluginEqGui::stop_updating()
148 if (_update_connection
.connected()) {
149 _update_connection
.disconnect();
154 PluginEqGui::start_updating()
156 if (!_update_connection
.connected() && is_visible()) {
157 _update_connection
= Glib::signal_timeout().connect( sigc::mem_fun(this, &PluginEqGui::timeout_callback
), 250);
162 PluginEqGui::on_show()
164 Gtk::Table::on_show();
168 Gtk::Widget
*toplevel
= get_toplevel();
170 std::cerr
<< "No toplevel widget for PluginEqGui?!?!" << std::endl
;
173 if (!_window_unmap_connection
.connected()) {
174 _window_unmap_connection
= toplevel
->signal_unmap().connect( sigc::mem_fun(this, &PluginEqGui::stop_updating
));
177 if (!_window_map_connection
.connected()) {
178 _window_map_connection
= toplevel
->signal_map().connect( sigc::mem_fun(this, &PluginEqGui::start_updating
));
184 PluginEqGui::change_dB_scale()
186 Gtk::TreeModel::iterator iter
= dBScaleCombo
-> get_active();
188 Gtk::TreeModel::Row row
;
190 if(iter
&& (row
= *iter
)) {
191 _min_dB
= row
[dBColumns
.dBMin
];
192 _max_dB
= row
[dBColumns
.dBMax
];
193 _step_dB
= row
[dBColumns
.dBStep
];
201 PluginEqGui::redraw_scales()
204 if (_analysis_scale_surface
) {
205 cairo_surface_destroy (_analysis_scale_surface
);
206 _analysis_scale_surface
= 0;
209 _analysis_area
->queue_draw();
211 // TODO: Add graph legend!
215 PluginEqGui::set_buffer_size(uint32_t size
, uint32_t signal_size
)
217 if (_buffer_size
== size
&& _signal_buffer_size
== signal_size
)
221 FFT
*tmp1
= _impulse_fft
;
222 FFT
*tmp2
= _signal_input_fft
;
223 FFT
*tmp3
= _signal_output_fft
;
226 _impulse_fft
= new FFT(size
);
227 _signal_input_fft
= new FFT(signal_size
);
228 _signal_output_fft
= new FFT(signal_size
);
230 // Don't care about lost memory, we're screwed anyhow
232 _signal_input_fft
= tmp2
;
233 _signal_output_fft
= tmp3
;
242 _signal_buffer_size
= signal_size
;
244 ARDOUR::ChanCount count
= ARDOUR::ChanCount::max (_plugin
->get_info()->n_inputs
, _plugin
->get_info()->n_outputs
);
245 for (ARDOUR::DataType::iterator i
= ARDOUR::DataType::begin(); i
!= ARDOUR::DataType::end(); ++i
) {
246 _bufferset
.ensure_buffers (*i
, count
.get (*i
), _buffer_size
);
247 _collect_bufferset
.ensure_buffers (*i
, count
.get (*i
), _buffer_size
);
250 _bufferset
.set_count (count
);
251 _collect_bufferset
.set_count (count
);
255 PluginEqGui::resize_analysis_area(Gtk::Allocation
& size
)
257 _analysis_width
= (float)size
.get_width();
258 _analysis_height
= (float)size
.get_height();
260 if (_analysis_scale_surface
) {
261 cairo_surface_destroy (_analysis_scale_surface
);
262 _analysis_scale_surface
= 0;
267 PluginEqGui::timeout_callback()
269 if (!_signal_analysis_running
) {
270 _signal_analysis_running
= true;
271 _plugin_insert
-> collect_signal_for_analysis(_signal_buffer_size
);
273 run_impulse_analysis();
279 PluginEqGui::signal_collect_callback(ARDOUR::BufferSet
*in
, ARDOUR::BufferSet
*out
)
281 ENSURE_GUI_THREAD (*this, &PluginEqGui::signal_collect_callback
, in
, out
)
283 _signal_input_fft
->reset();
284 _signal_output_fft
->reset();
286 for (uint32_t i
= 0; i
< _plugin_insert
->input_streams().n_audio(); ++i
) {
287 _signal_input_fft
->analyze(in
->get_audio(i
).data(), FFT::HANN
);
290 for (uint32_t i
= 0; i
< _plugin_insert
->output_streams().n_audio(); ++i
) {
291 _signal_output_fft
->analyze(out
->get_audio(i
).data(), FFT::HANN
);
294 _signal_input_fft
->calculate();
295 _signal_output_fft
->calculate();
297 _signal_analysis_running
= false;
299 // This signals calls expose_analysis_area()
300 _analysis_area
->queue_draw();
304 PluginEqGui::run_impulse_analysis()
306 uint32_t inputs
= _plugin
->get_info()->n_inputs
.n_audio();
307 uint32_t outputs
= _plugin
->get_info()->n_outputs
.n_audio();
309 // Create the impulse, can't use silence() because consecutive calls won't work
310 for (uint32_t i
= 0; i
< inputs
; ++i
) {
311 ARDOUR::AudioBuffer
& buf
= _bufferset
.get_audio(i
);
312 ARDOUR::Sample
* d
= buf
.data();
313 memset(d
, 0, sizeof(ARDOUR::Sample
)*_buffer_size
);
317 ARDOUR::ChanMapping
in_map(_plugin
->get_info()->n_inputs
);
318 ARDOUR::ChanMapping
out_map(_plugin
->get_info()->n_outputs
);
320 _plugin
->connect_and_run(_bufferset
, in_map
, out_map
, _buffer_size
, 0);
321 framecnt_t f
= _plugin
->signal_latency ();
322 // Adding user_latency() could be interesting
324 // Gather all output, taking latency into account.
325 _impulse_fft
->reset();
327 // Silence collect buffers to copy data to, can't use silence() because consecutive calls won't work
328 for (uint32_t i
= 0; i
< outputs
; ++i
) {
329 ARDOUR::AudioBuffer
&buf
= _collect_bufferset
.get_audio(i
);
330 ARDOUR::Sample
*d
= buf
.data();
331 memset(d
, 0, sizeof(ARDOUR::Sample
)*_buffer_size
);
335 //std::cerr << "0: no latency, copying full buffer, trivial.." << std::endl;
336 for (uint32_t i
= 0; i
< outputs
; ++i
) {
337 memcpy(_collect_bufferset
.get_audio(i
).data(),
338 _bufferset
.get_audio(i
).data(), _buffer_size
* sizeof(float));
342 //std::cerr << (++C) << ": latency is " << f << " frames, doing split processing.." << std::endl;
343 framecnt_t target_offset
= 0;
344 framecnt_t frames_left
= _buffer_size
; // refaktoroi
346 if (f
>= _buffer_size
) {
347 //std::cerr << (++C) << ": f (=" << f << ") is larger than buffer_size, still trying to reach the actual output" << std::endl;
348 // there is no data in this buffer regarding to the input!
351 // this buffer contains either the first, last or a whole bu the output of the impulse
352 // first part: offset is 0, so we copy to the start of _collect_bufferset
353 // we start at output offset "f"
354 // .. and copy "buffer size" - "f" - "offset" frames
356 framecnt_t length
= _buffer_size
- f
- target_offset
;
358 //std::cerr << (++C) << ": copying " << length << " frames to _collect_bufferset.get_audio(i)+" << target_offset << " from bufferset at offset " << f << std::endl;
359 for (uint32_t i
= 0; i
< outputs
; ++i
) {
360 memcpy(_collect_bufferset
.get_audio(i
).data(target_offset
),
361 _bufferset
.get_audio(i
).data() + f
,
362 length
* sizeof(float));
365 target_offset
+= length
;
366 frames_left
-= length
;
369 if (frames_left
> 0) {
370 // Silence the buffers
371 for (uint32_t i
= 0; i
< inputs
; ++i
) {
372 ARDOUR::AudioBuffer
&buf
= _bufferset
.get_audio(i
);
373 ARDOUR::Sample
*d
= buf
.data();
374 memset(d
, 0, sizeof(ARDOUR::Sample
)*_buffer_size
);
377 in_map
= ARDOUR::ChanMapping(_plugin
->get_info()->n_inputs
);
378 out_map
= ARDOUR::ChanMapping(_plugin
->get_info()->n_outputs
);
379 _plugin
->connect_and_run(_bufferset
, in_map
, out_map
, _buffer_size
, 0);
381 } while ( frames_left
> 0);
386 for (uint32_t i
= 0; i
< outputs
; ++i
) {
387 _impulse_fft
->analyze(_collect_bufferset
.get_audio(i
).data());
390 // normalize the output
391 _impulse_fft
->calculate();
393 // This signals calls expose_analysis_area()
394 _analysis_area
->queue_draw();
398 PluginEqGui::expose_analysis_area(GdkEventExpose
*)
400 redraw_analysis_area();
406 PluginEqGui::draw_analysis_scales(cairo_t
*ref_cr
)
408 // TODO: check whether we need rounding
409 _analysis_scale_surface
= cairo_surface_create_similar(cairo_get_target(ref_cr
),
414 cairo_t
*cr
= cairo_create (_analysis_scale_surface
);
416 cairo_set_source_rgb(cr
, 0.0, 0.0, 0.0);
417 cairo_rectangle(cr
, 0.0, 0.0, _analysis_width
, _analysis_height
);
421 draw_scales_power(_analysis_area
, cr
);
422 if (_phase_button
->get_active()) {
423 draw_scales_phase(_analysis_area
, cr
);
431 PluginEqGui::redraw_analysis_area()
435 cr
= gdk_cairo_create(GDK_DRAWABLE(_analysis_area
->get_window()->gobj()));
437 if (_analysis_scale_surface
== 0) {
438 draw_analysis_scales(cr
);
444 cairo_set_source_surface(cr
, _analysis_scale_surface
, 0.0, 0.0);
447 if (_phase_button
->get_active()) {
448 plot_impulse_phase(_analysis_area
, cr
);
450 plot_impulse_amplitude(_analysis_area
, cr
);
452 // TODO: make this optional
453 plot_signal_amplitude_difference(_analysis_area
, cr
);
460 #define PHASE_PROPORTION 0.5
463 PluginEqGui::draw_scales_phase(Gtk::Widget */
*w*/
, cairo_t
*cr
)
466 cairo_font_extents_t extents
;
467 cairo_font_extents(cr
, &extents
);
470 cairo_text_extents_t t_ext
;
472 for (uint32_t i
= 0; i
< 3; i
++) {
474 y
= _analysis_height
/2.0 - (float)i
*(_analysis_height
/8.0)*PHASE_PROPORTION
;
476 cairo_set_source_rgb(cr
, .8, .9, 0.2);
478 snprintf(buf
,256, "0\u00b0");
480 snprintf(buf
,256, "%d\u00b0", (i
* 45));
482 cairo_text_extents(cr
, buf
, &t_ext
);
483 cairo_move_to(cr
, _analysis_width
- t_ext
.width
- t_ext
.x_bearing
- 2.0, y
- extents
.descent
);
484 cairo_show_text(cr
, buf
);
490 cairo_set_source_rgba(cr
, .8, .9, 0.2, 0.6/(float)i
);
491 cairo_move_to(cr
, 0.0, y
);
492 cairo_line_to(cr
, _analysis_width
, y
);
495 y
= _analysis_height
/2.0 + (float)i
*(_analysis_height
/8.0)*PHASE_PROPORTION
;
498 snprintf(buf
,256, "-%d\u00b0", (i
* 45));
499 cairo_set_source_rgb(cr
, .8, .9, 0.2);
500 cairo_text_extents(cr
, buf
, &t_ext
);
501 cairo_move_to(cr
, _analysis_width
- t_ext
.width
- t_ext
.x_bearing
- 2.0, y
- extents
.descent
);
502 cairo_show_text(cr
, buf
);
505 cairo_set_source_rgba(cr
, .8, .9, 0.2, 0.6/(float)i
);
506 cairo_move_to(cr
, 0.0, y
);
507 cairo_line_to(cr
, _analysis_width
, y
);
509 cairo_set_line_width (cr
, 0.25 + 1.0/(float)(i
+1));
515 PluginEqGui::plot_impulse_phase(Gtk::Widget
*w
, cairo_t
*cr
)
523 // float width = w->get_width();
524 float height
= w
->get_height();
526 cairo_set_source_rgba(cr
, 0.95, 0.3, 0.2, 1.0);
527 for (uint32_t i
= 0; i
< _impulse_fft
->bins()-1; i
++) {
528 // x coordinate of bin i
529 x
= log10f(1.0 + (float)i
/ (float)_impulse_fft
->bins() * _log_coeff
) / _log_max
;
530 x
*= _analysis_width
;
532 y
= _analysis_height
/2.0 - (_impulse_fft
->phase_at_bin(i
)/M_PI
)*(_analysis_height
/2.0)*PHASE_PROPORTION
;
535 cairo_move_to(cr
, x
, y
);
539 } else if (rint(x
) > prevX
|| i
== _impulse_fft
->bins()-1 ) {
540 avgY
= avgY
/(float)avgNum
;
541 if (avgY
> (height
* 10.0) ) avgY
= height
* 10.0;
542 if (avgY
< (-height
* 10.0) ) avgY
= -height
* 10.0;
543 cairo_line_to(cr
, prevX
, avgY
);
544 //cairo_line_to(cr, prevX, avgY/(float)avgNum);
556 cairo_set_line_width (cr
, 2.0);
561 PluginEqGui::draw_scales_power(Gtk::Widget */
*w*/
, cairo_t
*cr
)
563 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 };
565 float divisor
= _samplerate
/ 2.0 / _impulse_fft
->bins();
568 cairo_set_line_width (cr
, 1.5);
569 cairo_set_font_size(cr
, 9);
571 cairo_font_extents_t extents
;
572 cairo_font_extents(cr
, &extents
);
573 // float fontXOffset = extents.descent + 1.0;
577 for (uint32_t i
= 0; scales
[i
] != -1.0; ++i
) {
578 float bin
= scales
[i
] / divisor
;
580 x
= log10f(1.0 + bin
/ (float)_impulse_fft
->bins() * _log_coeff
) / _log_max
;
581 x
*= _analysis_width
;
583 if (scales
[i
] < 1000.0) {
584 snprintf(buf
, 256, "%0.0f", scales
[i
]);
586 snprintf(buf
, 256, "%0.0fk", scales
[i
]/1000.0);
589 cairo_set_source_rgb(cr
, 0.4, 0.4, 0.4);
591 //cairo_move_to(cr, x + fontXOffset, 3.0);
592 cairo_move_to(cr
, x
- extents
.height
, 3.0);
594 cairo_rotate(cr
, M_PI
/ 2.0);
595 cairo_show_text(cr
, buf
);
596 cairo_rotate(cr
, -M_PI
/ 2.0);
599 cairo_set_source_rgb(cr
, 0.3, 0.3, 0.3);
600 cairo_move_to(cr
, x
, _analysis_height
);
601 cairo_line_to(cr
, x
, 0.0);
607 //double dashes[] = { 1.0, 3.0, 4.5, 3.0 };
608 double dashes
[] = { 3.0, 5.0 };
610 for (float dB
= 0.0; dB
< _max_dB
; dB
+= _step_dB
) {
611 snprintf(buf
, 256, "+%0.0f", dB
);
613 y
= ( _max_dB
- dB
) / ( _max_dB
- _min_dB
);
614 //std::cerr << " y = " << y << std::endl;
615 y
*= _analysis_height
;
618 cairo_set_source_rgb(cr
, 0.4, 0.4, 0.4);
619 cairo_move_to(cr
, 1.0, y
+ extents
.height
+ 1.0);
620 cairo_show_text(cr
, buf
);
624 cairo_set_source_rgb(cr
, 0.2, 0.2, 0.2);
625 cairo_move_to(cr
, 0, y
);
626 cairo_line_to(cr
, _analysis_width
, y
);
630 cairo_set_dash(cr
, dashes
, 2, 0.0);
636 for (float dB
= - _step_dB
; dB
> _min_dB
; dB
-= _step_dB
) {
637 snprintf(buf
, 256, "%0.0f", dB
);
639 y
= ( _max_dB
- dB
) / ( _max_dB
- _min_dB
);
640 y
*= _analysis_height
;
642 cairo_set_source_rgb(cr
, 0.4, 0.4, 0.4);
643 cairo_move_to(cr
, 1.0, y
- extents
.descent
- 1.0);
644 cairo_show_text(cr
, buf
);
647 cairo_set_source_rgb(cr
, 0.2, 0.2, 0.2);
648 cairo_move_to(cr
, 0, y
);
649 cairo_line_to(cr
, _analysis_width
, y
);
653 cairo_set_dash(cr
, 0, 0, 0.0);
660 return 10.0 * log10f(a
);
664 PluginEqGui::plot_impulse_amplitude(Gtk::Widget
*w
, cairo_t
*cr
)
672 // float width = w->get_width();
673 float height
= w
->get_height();
675 cairo_set_source_rgb(cr
, 1.0, 1.0, 1.0);
676 cairo_set_line_width (cr
, 2.5);
678 for (uint32_t i
= 0; i
< _impulse_fft
->bins()-1; i
++) {
679 // x coordinate of bin i
680 x
= log10f(1.0 + (float)i
/ (float)_impulse_fft
->bins() * _log_coeff
) / _log_max
;
681 x
*= _analysis_width
;
683 float yCoeff
= ( power_to_dB(_impulse_fft
->power_at_bin(i
)) - _min_dB
) / (_max_dB
- _min_dB
);
685 y
= _analysis_height
- _analysis_height
*yCoeff
;
688 cairo_move_to(cr
, x
, y
);
692 } else if (rint(x
) > prevX
|| i
== _impulse_fft
->bins()-1 ) {
693 avgY
= avgY
/(float)avgNum
;
694 if (avgY
> (height
* 10.0) ) avgY
= height
* 10.0;
695 if (avgY
< (-height
* 10.0) ) avgY
= -height
* 10.0;
696 cairo_line_to(cr
, prevX
, avgY
);
697 //cairo_line_to(cr, prevX, avgY/(float)avgNum);
713 PluginEqGui::plot_signal_amplitude_difference(Gtk::Widget
*w
, cairo_t
*cr
)
721 // float width = w->get_width();
722 float height
= w
->get_height();
724 cairo_set_source_rgb(cr
, 0.0, 1.0, 0.0);
725 cairo_set_line_width (cr
, 2.5);
727 for (uint32_t i
= 0; i
< _signal_input_fft
->bins()-1; i
++) {
728 // x coordinate of bin i
729 x
= log10f(1.0 + (float)i
/ (float)_signal_input_fft
->bins() * _log_coeff
) / _log_max
;
730 x
*= _analysis_width
;
732 float power_out
= power_to_dB(_signal_output_fft
->power_at_bin(i
));
733 float power_in
= power_to_dB(_signal_input_fft
->power_at_bin(i
));
734 float power
= power_out
- power_in
;
738 double p = 10.0 * log10( 1.0 + (double)_signal_output_fft->power_at_bin(i) - (double)
739 - _signal_input_fft ->power_at_bin(i));
741 float power = (float)p;
743 if ( (i % 1000) == 0) {
744 std::cerr << i << ": " << power << std::endl;
748 if (std::isinf(power
)) {
750 power
= _min_dB
- 1.0;
752 power
= _max_dB
- 1.0;
754 } else if (std::isnan(power
)) {
755 power
= _min_dB
- 1.0;
758 float yCoeff
= ( power
- _min_dB
) / (_max_dB
- _min_dB
);
760 y
= _analysis_height
- _analysis_height
*yCoeff
;
763 cairo_move_to(cr
, x
, y
);
767 } else if (rint(x
) > prevX
|| i
== _impulse_fft
->bins()-1 ) {
768 avgY
= avgY
/(float)avgNum
;
769 if (avgY
> (height
* 10.0) ) avgY
= height
* 10.0;
770 if (avgY
< (-height
* 10.0) ) avgY
= -height
* 10.0;
771 cairo_line_to(cr
, prevX
, avgY
);