smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-08 15:54:57 +01:00
Code Issues Projects Releases Wiki Activity

Make EQ Gui optional and seize updating the graph when the analysis is not visible (either via the toggle or window visibility).

Browse source 
git-svn-id: svn://localhost/ardour2/branches/3.0@3973 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Sampo Savolainen 2008-10-15 19:21:26 +00:00
parent 68d8f26dc4
commit 1bca6b5c74
8 changed files with 273 additions and 206 deletions
Download patch file Download diff file Expand all files Collapse all files

2
gtk2_ardour/SConscript
View file

@ -179,7 +179,7 @@ export_timespan_selector.cc
fft.cc fft.cc
fft_graph.cc fft_graph.cc
fft_result.cc fft_result.cc
eq_gui.cc plugin_eq_gui.cc
gain_meter.cc gain_meter.cc
generic_pluginui.cc generic_pluginui.cc
ghostregion.cc ghostregion.cc

42
gtk2_ardour/fft.cc
View file

@ -24,18 +24,18 @@
#include <math.h> #include <math.h>
FFT::FFT(uint32_t windowSize) FFT::FFT(uint32_t windowSize)
: _windowSize(windowSize), : _window_size(windowSize),
_dataSize(_windowSize/2), _data_size(_window_size/2),
_iterations(0) _iterations(0)
{ {
_fftInput = (float *) fftwf_malloc(sizeof(float) * _windowSize); _fftInput = (float *) fftwf_malloc(sizeof(float) * _window_size);
_fftOutput = (float *) fftwf_malloc(sizeof(float) * _windowSize); _fftOutput = (float *) fftwf_malloc(sizeof(float) * _window_size);
_powerAtBin = (float *) malloc(sizeof(float) * _dataSize); _power_at_bin = (float *) malloc(sizeof(float) * _data_size);
_phaseAtBin = (float *) malloc(sizeof(float) * _dataSize); _phase_at_bin = (float *) malloc(sizeof(float) * _data_size);
_plan = fftwf_plan_r2r_1d(_windowSize, _fftInput, _fftOutput, FFTW_R2HC, FFTW_ESTIMATE); _plan = fftwf_plan_r2r_1d(_window_size, _fftInput, _fftOutput, FFTW_R2HC, FFTW_ESTIMATE);
reset(); reset();
} }
@ -43,8 +43,8 @@ FFT::FFT(uint32_t windowSize)
void void
FFT::reset() FFT::reset()
{ {
memset(_powerAtBin, 0, sizeof(float) * _dataSize); memset(_power_at_bin, 0, sizeof(float) * _data_size);
memset(_phaseAtBin, 0, sizeof(float) * _dataSize); memset(_phase_at_bin, 0, sizeof(float) * _data_size);
_iterations = 0; _iterations = 0;
} }
@ -54,19 +54,19 @@ FFT::analyze(ARDOUR::Sample *input)
{ {
_iterations++; _iterations++;
memcpy(_fftInput, input, sizeof(float) * _windowSize); memcpy(_fftInput, input, sizeof(float) * _window_size);
fftwf_execute(_plan); fftwf_execute(_plan);
_powerAtBin[0] += _fftOutput[0] * _fftOutput[0]; _power_at_bin[0] += _fftOutput[0] * _fftOutput[0];
_phaseAtBin[0] += 0.0; _phase_at_bin[0] += 0.0;
float power; float power;
float phase; float phase;
#define Re (_fftOutput[i]) #define Re (_fftOutput[i])
#define Im (_fftOutput[_windowSize-i]) #define Im (_fftOutput[_window_size-i])
for (uint32_t i=1; i < _dataSize - 1; i++) { for (uint32_t i=1; i < _data_size - 1; i++) {
power = (Re * Re) + (Im * Im); power = (Re * Re) + (Im * Im);
phase = atanf(Im / Re); phase = atanf(Im / Re);
@ -77,8 +77,8 @@ FFT::analyze(ARDOUR::Sample *input)
phase -= M_PI; phase -= M_PI;
} }
_powerAtBin[i] += power; _power_at_bin[i] += power;
_phaseAtBin[i] += phase; _phase_at_bin[i] += phase;
} }
#undef Re #undef Re
#undef Im #undef Im
@ -88,9 +88,9 @@ void
FFT::calculate() FFT::calculate()
{ {
if (_iterations > 1) { if (_iterations > 1) {
for (uint32_t i=0; i < _dataSize - 1; i++) { for (uint32_t i=0; i < _data_size - 1; i++) {
_powerAtBin[i] /= (float)_iterations; _power_at_bin[i] /= (float)_iterations;
_phaseAtBin[i] /= (float)_iterations; _phase_at_bin[i] /= (float)_iterations;
} }
_iterations = 1; _iterations = 1;
} }
@ -100,8 +100,8 @@ FFT::calculate()
FFT::~FFT() FFT::~FFT()
{ {
fftwf_destroy_plan(_plan); fftwf_destroy_plan(_plan);
free(_powerAtBin); free(_power_at_bin);
free(_phaseAtBin); free(_phase_at_bin);
free(_fftOutput); free(_fftOutput);
free(_fftInput); free(_fftInput);
} }

14
gtk2_ardour/fft.h
View file

@ -42,22 +42,22 @@ class FFT
void analyze(ARDOUR::Sample *); void analyze(ARDOUR::Sample *);
void calculate(); void calculate();
uint32_t bins() const { return _dataSize; } uint32_t bins() const { return _data_size; }
float powerAtBin(uint32_t i) const { return _powerAtBin[i]; } float power_at_bin(uint32_t i) const { return _power_at_bin[i]; }
float phaseAtBin(uint32_t i) const { return _phaseAtBin[i]; } float phase_at_bin(uint32_t i) const { return _phase_at_bin[i]; }
private: private:
uint32_t const _windowSize; uint32_t const _window_size;
uint32_t const _dataSize; uint32_t const _data_size;
uint32_t _iterations; uint32_t _iterations;
float *_fftInput; float *_fftInput;
float *_fftOutput; float *_fftOutput;
float *_powerAtBin; float *_power_at_bin;
float *_phaseAtBin; float *_phase_at_bin;
fftwf_plan _plan; fftwf_plan _plan;
}; };

56
gtk2_ardour/generic_pluginui.cc
View file

@ -50,6 +50,7 @@
#include "utils.h" #include "utils.h"
#include "gui_thread.h" #include "gui_thread.h"
#include "automation_controller.h" #include "automation_controller.h"
#include "plugin_eq_gui.h"
#include "i18n.h" #include "i18n.h"
@ -64,6 +65,7 @@ GenericPluginUI::GenericPluginUI (boost::shared_ptr<PluginInsert> pi, bool scrol
: PlugUIBase (pi), : PlugUIBase (pi),
button_table (initial_button_rows, initial_button_cols), button_table (initial_button_rows, initial_button_cols),
output_table (initial_output_rows, initial_output_cols), output_table (initial_output_rows, initial_output_cols),
eqgui_toggle(_("Freq Analysis")),
hAdjustment(0.0, 0.0, 0.0), hAdjustment(0.0, 0.0, 0.0),
vAdjustment(0.0, 0.0, 0.0), vAdjustment(0.0, 0.0, 0.0),
scroller_view(hAdjustment, vAdjustment), scroller_view(hAdjustment, vAdjustment),
@ -72,7 +74,9 @@ GenericPluginUI::GenericPluginUI (boost::shared_ptr<PluginInsert> pi, bool scrol
{ {
set_name ("PluginEditor"); set_name ("PluginEditor");
set_border_width (10); set_border_width (10);
set_homogeneous (false); //set_homogeneous (false);
pack1(main_contents);
settings_box.set_homogeneous (false); settings_box.set_homogeneous (false);
@ -92,10 +96,11 @@ GenericPluginUI::GenericPluginUI (boost::shared_ptr<PluginInsert> pi, bool scrol
constraint_hbox->set_spacing (5); constraint_hbox->set_spacing (5);
constraint_hbox->pack_start (*smaller_hbox, true, false); constraint_hbox->pack_start (*smaller_hbox, true, false);
constraint_hbox->pack_end (bypass_button, false, false); constraint_hbox->pack_end (bypass_button, false, false);
constraint_hbox->pack_start (eqgui_toggle, false, false);
settings_box.pack_end (*constraint_hbox, false, false); settings_box.pack_end (*constraint_hbox, false, false);
pack_start (settings_box, false, false); main_contents.pack_start (settings_box, false, false);
if ( is_scrollable ) { if ( is_scrollable ) {
scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
@ -104,13 +109,16 @@ GenericPluginUI::GenericPluginUI (boost::shared_ptr<PluginInsert> pi, bool scrol
scroller_view.add (hpacker); scroller_view.add (hpacker);
scroller.add (scroller_view); scroller.add (scroller_view);
pack_start (scroller, true, true); main_contents.pack_start (scroller, true, true);
} }
else { else {
pack_start (hpacker, false, false); main_contents.pack_start (hpacker, false, false);
} }
eqgui_toggle.set_active (false);
eqgui_toggle.signal_toggled().connect( mem_fun(*this, &GenericPluginUI::toggle_plugin_analysis));
pi->ActiveChanged.connect (bind(mem_fun(*this, &GenericPluginUI::processor_active_changed), pi->ActiveChanged.connect (bind(mem_fun(*this, &GenericPluginUI::processor_active_changed),
boost::weak_ptr<Processor>(pi))); boost::weak_ptr<Processor>(pi)));
bypass_button.set_active (!pi->active()); bypass_button.set_active (!pi->active());
@ -817,3 +825,43 @@ GenericPluginUI::setup_scale_values(guint32 port_index, ControlUI* cui)
return enums; return enums;
} }
void
GenericPluginUI::toggle_plugin_analysis()
{
if (eqgui_toggle.get_active() && !get_child2()) {
// Create the GUI
PluginEqGui *foo = new PluginEqGui(insert);
pack2( *foo );
show_all();
}
Gtk::Widget *gui;
if (!eqgui_toggle.get_active() && (gui = get_child2())) {
// Hide & remove
gui->hide();
remove(*gui);
delete gui;
Gtk::Widget *toplevel = get_toplevel();
if (!toplevel) {
std::cerr << "No toplevel widget?!?!" << std::endl;
return;
}
Gtk::Container *cont = dynamic_cast<Gtk::Container *>(toplevel);
if (!cont) {
std::cerr << "Toplevel widget is not a container?!?" << std::endl;
return;
}
Gtk::Allocation alloc(0, 0, 50, 50); // Just make it small
toplevel->size_allocate(alloc);
}
}

283
gtk2_ardour/eq_gui.cc → gtk2_ardour/plugin_eq_gui.cc
View file

@ -18,7 +18,7 @@
*/ */
#include "eq_gui.h" #include "plugin_eq_gui.h"
#include "fft.h" #include "fft.h"
#include "ardour_ui.h" #include "ardour_ui.h"
@ -33,32 +33,32 @@
PluginEqGui::PluginEqGui(boost::shared_ptr<ARDOUR::PluginInsert> pluginInsert) PluginEqGui::PluginEqGui(boost::shared_ptr<ARDOUR::PluginInsert> pluginInsert)
: _mindB(-12.0), : _min_dB(-12.0),
_maxdB(+12.0), _max_dB(+12.0),
_dBStep(3.0), _step_dB(3.0),
_impulseFft(0) _impulse_fft(0)
{ {
_samplerate = ARDOUR_UI::instance()->the_session()->frame_rate(); _samplerate = ARDOUR_UI::instance()->the_session()->frame_rate();
_plugin = pluginInsert->get_impulse_analysis_plugin(); _plugin = pluginInsert->get_impulse_analysis_plugin();
_plugin->activate(); _plugin->activate();
setBufferSize(4096); set_buffer_size(4096);
_logCoeff = (1.0 - 2.0 * (1000.0/(_samplerate/2.0))) / powf(1000.0/(_samplerate/2.0), 2.0); _log_coeff = (1.0 - 2.0 * (1000.0/(_samplerate/2.0))) / powf(1000.0/(_samplerate/2.0), 2.0);
_logMax = log10f(1 + _logCoeff); _log_max = log10f(1 + _log_coeff);
// Setup analysis drawing area // Setup analysis drawing area
_analysisScaleSurface = 0; _analysis_scale_surface = 0;
_analysisArea = new Gtk::DrawingArea(); _analysis_area = new Gtk::DrawingArea();
_analysisWidth = 500.0; _analysis_width = 500.0;
_analysisHeight = 500.0; _analysis_height = 500.0;
_analysisArea->set_size_request(_analysisWidth, _analysisHeight); _analysis_area->set_size_request(_analysis_width, _analysis_height);
_analysisArea->signal_expose_event().connect( sigc::mem_fun (*this, &PluginEqGui::exposeAnalysisArea)); _analysis_area->signal_expose_event().connect( sigc::mem_fun (*this, &PluginEqGui::expose_analysis_area));
_analysisArea->signal_size_allocate().connect( sigc::mem_fun (*this, &PluginEqGui::resizeAnalysisArea)); _analysis_area->signal_size_allocate().connect( sigc::mem_fun (*this, &PluginEqGui::resize_analysis_area));
// dB selection // dB selection
@ -86,7 +86,7 @@ PluginEqGui::PluginEqGui(boost::shared_ptr<ARDOUR::PluginInsert> pluginInsert)
dBScaleCombo -> pack_start(dBColumns.name); dBScaleCombo -> pack_start(dBColumns.name);
dBScaleCombo -> set_active(1); dBScaleCombo -> set_active(1);
dBScaleCombo -> signal_changed().connect( sigc::mem_fun(*this, &PluginEqGui::dBScaleChanged) ); dBScaleCombo -> signal_changed().connect( sigc::mem_fun(*this, &PluginEqGui::change_dB_scale) );
Gtk::Label *dBComboLabel = new Gtk::Label("dB scale"); Gtk::Label *dBComboLabel = new Gtk::Label("dB scale");
@ -95,200 +95,207 @@ PluginEqGui::PluginEqGui(boost::shared_ptr<ARDOUR::PluginInsert> pluginInsert)
dBSelectBin->add( *manage(dBScaleCombo)); dBSelectBin->add( *manage(dBScaleCombo));
// Phase checkbutton // Phase checkbutton
phaseSelect = new Gtk::CheckButton("Show phase"); _phase_button = new Gtk::CheckButton("Show phase");
phaseSelect->set_active(true); _phase_button->set_active(true);
phaseSelect->signal_toggled().connect( sigc::mem_fun(*this, &PluginEqGui::redrawScales)); _phase_button->signal_toggled().connect( sigc::mem_fun(*this, &PluginEqGui::redraw_scales));
// Update button
Gtk::Button *btn = new Gtk::Button("Update");
btn->signal_clicked().connect( sigc::mem_fun(*this, &PluginEqGui::runAnalysis));
// populate table // populate table
attach( *manage(_analysisArea), 1, 4, 1, 2); attach( *manage(_analysis_area), 1, 3, 1, 2);
attach( *manage(dBSelectBin), 1, 2, 2, 3, Gtk::SHRINK, Gtk::SHRINK); attach( *manage(dBSelectBin), 1, 2, 2, 3, Gtk::SHRINK, Gtk::SHRINK);
attach( *manage(phaseSelect), 2, 3, 2, 3, Gtk::SHRINK, Gtk::SHRINK); attach( *manage(_phase_button), 2, 3, 2, 3, Gtk::SHRINK, Gtk::SHRINK);
attach( *manage(btn), 3, 4, 2, 3, Gtk::SHRINK, Gtk::SHRINK);
// Timeout
//_updateConn = Glib::signal_timeout().connect( sigc::mem_fun(this, &PluginEqGui::timeoutCallback), 250);
} }
PluginEqGui::~PluginEqGui() PluginEqGui::~PluginEqGui()
{ {
std::cerr << "Destroying PluginEqGui for " << _plugin->name() << std::endl; if (_analysis_scale_surface) {
if (_analysisScaleSurface) { cairo_surface_destroy (_analysis_scale_surface);
cairo_surface_destroy (_analysisScaleSurface);
} }
delete _impulseFft; delete _impulse_fft;
_plugin->deactivate(); _plugin->deactivate();
// all gui objects are *manage'd by the inherited Table object // all gui objects are *manage'd by the inherited Table object
} }
void void
PluginEqGui::on_hide() PluginEqGui::on_hide()
{ {
stop_updating();
Gtk::Table::on_hide(); Gtk::Table::on_hide();
_updateConn.disconnect(); }
void
PluginEqGui::stop_updating()
{
if (_update_connection.connected()) {
_update_connection.disconnect();
}
}
void
PluginEqGui::start_updating()
{
if (!_update_connection.connected() && is_visible()) {
_update_connection = Glib::signal_timeout().connect( sigc::mem_fun(this, &PluginEqGui::timeout_callback), 250);
}
} }
void void
PluginEqGui::on_show() PluginEqGui::on_show()
{ {
Gtk::Table::on_show(); Gtk::Table::on_show();
_updateConn = Glib::signal_timeout().connect( sigc::mem_fun(this, &PluginEqGui::timeoutCallback), 250);
start_updating();
Gtk::Widget *toplevel = get_toplevel();
if (!toplevel) {
std::cerr << "No toplevel widget for PluginEqGui?!?!" << std::endl;
}
if (!_window_unmap_connection.connected()) {
_window_unmap_connection = toplevel->signal_unmap().connect( sigc::mem_fun(this, &PluginEqGui::stop_updating));
}
if (!_window_map_connection.connected()) {
_window_map_connection = toplevel->signal_map().connect( sigc::mem_fun(this, &PluginEqGui::start_updating));
}
} }
void void
PluginEqGui::dBScaleChanged() PluginEqGui::change_dB_scale()
{ {
Gtk::TreeModel::iterator iter = dBScaleCombo -> get_active(); Gtk::TreeModel::iterator iter = dBScaleCombo -> get_active();
Gtk::TreeModel::Row row; Gtk::TreeModel::Row row;
if(iter && (row = *iter)) { if(iter && (row = *iter)) {
_mindB = row[dBColumns.dBMin]; _min_dB = row[dBColumns.dBMin];
_maxdB = row[dBColumns.dBMax]; _max_dB = row[dBColumns.dBMax];
_dBStep = row[dBColumns.dBStep]; _step_dB = row[dBColumns.dBStep];
redrawScales(); redraw_scales();
} }
} }
void void
PluginEqGui::redrawScales() PluginEqGui::redraw_scales()
{ {
if (_analysisScaleSurface) { if (_analysis_scale_surface) {
cairo_surface_destroy (_analysisScaleSurface); cairo_surface_destroy (_analysis_scale_surface);
_analysisScaleSurface = 0; _analysis_scale_surface = 0;
} }
_analysisArea->queue_draw(); _analysis_area->queue_draw();
} }
void void
PluginEqGui::setBufferSize(uint32_t size) PluginEqGui::set_buffer_size(uint32_t size)
{ {
if (_bufferSize == size) if (_buffer_size == size)
return; return;
_bufferSize = size; _buffer_size = size;
if (_impulseFft) { if (_impulse_fft) {
delete _impulseFft; delete _impulse_fft;
_impulseFft = 0; _impulse_fft = 0;
} }
_impulseFft = new FFT(_bufferSize); _impulse_fft = new FFT(_buffer_size);
uint32_t inputs = _plugin->get_info()->n_inputs.n_audio(); uint32_t inputs = _plugin->get_info()->n_inputs.n_audio();
uint32_t outputs = _plugin->get_info()->n_outputs.n_audio(); uint32_t outputs = _plugin->get_info()->n_outputs.n_audio();
uint32_t n_chans = std::max(inputs, outputs); uint32_t n_chans = std::max(inputs, outputs);
_bufferset.ensure_buffers(ARDOUR::DataType::AUDIO, n_chans, _bufferSize); _bufferset.ensure_buffers(ARDOUR::DataType::AUDIO, n_chans, _buffer_size);
ARDOUR::ChanCount chanCount(ARDOUR::DataType::AUDIO, n_chans); ARDOUR::ChanCount chanCount(ARDOUR::DataType::AUDIO, n_chans);
_bufferset.set_count(chanCount); _bufferset.set_count(chanCount);
/*
const uint32_t nbufs = _bufferset.count().n_audio();
std::cerr << "ensure_buffers(ARDOUR::DataType::Audio, " << n_chans << ", " << _bufferSize << "), _bufferset.count().n_audio() = " << nbufs << std::endl;
*/
} }
void void
PluginEqGui::resizeAnalysisArea(Gtk::Allocation& size) PluginEqGui::resize_analysis_area(Gtk::Allocation& size)
{ {
_analysisWidth = (float)size.get_width(); _analysis_width = (float)size.get_width();
_analysisHeight = (float)size.get_height(); _analysis_height = (float)size.get_height();
if (_analysisScaleSurface) { if (_analysis_scale_surface) {
cairo_surface_destroy (_analysisScaleSurface); cairo_surface_destroy (_analysis_scale_surface);
_analysisScaleSurface = 0; _analysis_scale_surface = 0;
} }
} }
bool bool
PluginEqGui::timeoutCallback() PluginEqGui::timeout_callback()
{ {
/* run_analysis();
struct timeval tv;
struct timezone tz;
gettimeofday(&tv, &tz);
std::cerr << " time = " << tv.tv_sec << ":" << tv.tv_usec << std::endl;
*/
runAnalysis();
return true; return true;
} }
void void
PluginEqGui::runAnalysis() PluginEqGui::run_analysis()
{ {
uint32_t inputs = _plugin->get_info()->n_inputs.n_audio(); uint32_t inputs = _plugin->get_info()->n_inputs.n_audio();
uint32_t outputs = _plugin->get_info()->n_outputs.n_audio(); uint32_t outputs = _plugin->get_info()->n_outputs.n_audio();
const uint32_t nbufs = _bufferset.count().n_audio();
// Create the impulse, can't use silence() because consecutive calls won't work // Create the impulse, can't use silence() because consecutive calls won't work
for (uint32_t i = 0; i < inputs; ++i) { for (uint32_t i = 0; i < inputs; ++i) {
ARDOUR::AudioBuffer &buf = _bufferset.get_audio(i); ARDOUR::AudioBuffer &buf = _bufferset.get_audio(i);
ARDOUR::Sample *d = buf.data(_bufferSize, 0); ARDOUR::Sample *d = buf.data(_buffer_size, 0);
memset(d, 0, sizeof(ARDOUR::Sample)*_bufferSize); memset(d, 0, sizeof(ARDOUR::Sample)*_buffer_size);
*d = 1.0; *d = 1.0;
} }
uint32_t x,y; uint32_t x,y;
x=y=0; x=y=0;
_plugin->connect_and_run(_bufferset, x, y, _bufferSize, (nframes_t)0); _plugin->connect_and_run(_bufferset, x, y, _buffer_size, (nframes_t)0);
// Analyze all output buffers // Analyze all output buffers
_impulseFft->reset(); _impulse_fft->reset();
for (uint32_t i = 0; i < outputs; ++i) { for (uint32_t i = 0; i < outputs; ++i) {
_impulseFft->analyze(_bufferset.get_audio(i).data(_bufferSize, 0)); _impulse_fft->analyze(_bufferset.get_audio(i).data(_buffer_size, 0));
} }
// normalize the output // normalize the output
_impulseFft->calculate(); _impulse_fft->calculate();
// This signals calls exposeAnalysisArea() // This signals calls expose_analysis_area()
_analysisArea->queue_draw(); _analysis_area->queue_draw();
} }
bool bool
PluginEqGui::exposeAnalysisArea(GdkEventExpose *evt) PluginEqGui::expose_analysis_area(GdkEventExpose *evt)
{ {
redrawAnalysisArea(); redraw_analysis_area();
return false; return false;
} }
void void
PluginEqGui::generateAnalysisScale(cairo_t *ref_cr) PluginEqGui::draw_analysis_scales(cairo_t *ref_cr)
{ {
// TODO: check whether we need rounding // TODO: check whether we need rounding
_analysisScaleSurface = cairo_surface_create_similar(cairo_get_target(ref_cr), _analysis_scale_surface = cairo_surface_create_similar(cairo_get_target(ref_cr),
CAIRO_CONTENT_COLOR, CAIRO_CONTENT_COLOR,
_analysisWidth, _analysis_width,
_analysisHeight); _analysis_height);
cairo_t *cr = cairo_create (_analysisScaleSurface); cairo_t *cr = cairo_create (_analysis_scale_surface);
cairo_set_source_rgb(cr, 0.0, 0.0, 0.0); cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
cairo_rectangle(cr, 0.0, 0.0, _analysisWidth, _analysisHeight); cairo_rectangle(cr, 0.0, 0.0, _analysis_width, _analysis_height);
cairo_fill(cr); cairo_fill(cr);
drawPowerScale(_analysisArea, cr); draw_scales_power(_analysis_area, cr);
if (phaseSelect->get_active()) { if (_phase_button->get_active()) {
drawPhaseScale(_analysisArea, cr); draw_scales_phase(_analysis_area, cr);
} }
cairo_destroy(cr); cairo_destroy(cr);
@ -296,26 +303,26 @@ PluginEqGui::generateAnalysisScale(cairo_t *ref_cr)
} }
void void
PluginEqGui::redrawAnalysisArea() PluginEqGui::redraw_analysis_area()
{ {
cairo_t *cr; cairo_t *cr;
cr = gdk_cairo_create(GDK_DRAWABLE(_analysisArea->get_window()->gobj())); cr = gdk_cairo_create(GDK_DRAWABLE(_analysis_area->get_window()->gobj()));
if (_analysisScaleSurface == 0) { if (_analysis_scale_surface == 0) {
generateAnalysisScale(cr); draw_analysis_scales(cr);
} }
cairo_copy_page(cr); cairo_copy_page(cr);
cairo_set_source_surface(cr, _analysisScaleSurface, 0.0, 0.0); cairo_set_source_surface(cr, _analysis_scale_surface, 0.0, 0.0);
cairo_paint(cr); cairo_paint(cr);
if (phaseSelect->get_active()) { if (_phase_button->get_active()) {
drawPhase(_analysisArea, cr); plot_phase(_analysis_area, cr);
} }
drawPower(_analysisArea, cr); plot_amplitude(_analysis_area, cr);
cairo_destroy(cr); cairo_destroy(cr);
@ -326,7 +333,7 @@ PluginEqGui::redrawAnalysisArea()
#define PHASE_PROPORTION 0.6 #define PHASE_PROPORTION 0.6
void void
PluginEqGui::drawPhaseScale(Gtk::Widget *w, cairo_t *cr) PluginEqGui::draw_scales_phase(Gtk::Widget *w, cairo_t *cr)
{ {
float y; float y;
cairo_font_extents_t extents; cairo_font_extents_t extents;
@ -337,7 +344,7 @@ PluginEqGui::drawPhaseScale(Gtk::Widget *w, cairo_t *cr)
for (uint32_t i = 0; i < 3; i++) { for (uint32_t i = 0; i < 3; i++) {
y = _analysisHeight/2.0 - (float)i*(_analysisHeight/8.0)*PHASE_PROPORTION; y = _analysis_height/2.0 - (float)i*(_analysis_height/8.0)*PHASE_PROPORTION;
cairo_set_source_rgb(cr, .8, .9, 0.2); cairo_set_source_rgb(cr, .8, .9, 0.2);
if (i == 0) { if (i == 0) {
@ -346,7 +353,7 @@ PluginEqGui::drawPhaseScale(Gtk::Widget *w, cairo_t *cr)
snprintf(buf,256, "%d\u00b0", (i * 45)); snprintf(buf,256, "%d\u00b0", (i * 45));
} }
cairo_text_extents(cr, buf, &t_ext); cairo_text_extents(cr, buf, &t_ext);
cairo_move_to(cr, _analysisWidth - t_ext.width - t_ext.x_bearing - 2.0, y - extents.descent); cairo_move_to(cr, _analysis_width - t_ext.width - t_ext.x_bearing - 2.0, y - extents.descent);
cairo_show_text(cr, buf); cairo_show_text(cr, buf);
if (i == 0) if (i == 0)
@ -355,22 +362,22 @@ PluginEqGui::drawPhaseScale(Gtk::Widget *w, cairo_t *cr)
cairo_set_source_rgba(cr, .8, .9, 0.2, 0.6/(float)i); cairo_set_source_rgba(cr, .8, .9, 0.2, 0.6/(float)i);
cairo_move_to(cr, 0.0, y); cairo_move_to(cr, 0.0, y);
cairo_line_to(cr, _analysisWidth, y); cairo_line_to(cr, _analysis_width, y);
y = _analysisHeight/2.0 + (float)i*(_analysisHeight/8.0)*PHASE_PROPORTION; y = _analysis_height/2.0 + (float)i*(_analysis_height/8.0)*PHASE_PROPORTION;
// label // label
snprintf(buf,256, "-%d\u00b0", (i * 45)); snprintf(buf,256, "-%d\u00b0", (i * 45));
cairo_set_source_rgb(cr, .8, .9, 0.2); cairo_set_source_rgb(cr, .8, .9, 0.2);
cairo_text_extents(cr, buf, &t_ext); cairo_text_extents(cr, buf, &t_ext);
cairo_move_to(cr, _analysisWidth - t_ext.width - t_ext.x_bearing - 2.0, y - extents.descent); cairo_move_to(cr, _analysis_width - t_ext.width - t_ext.x_bearing - 2.0, y - extents.descent);
cairo_show_text(cr, buf); cairo_show_text(cr, buf);
// line // line
cairo_set_source_rgba(cr, .8, .9, 0.2, 0.6/(float)i); cairo_set_source_rgba(cr, .8, .9, 0.2, 0.6/(float)i);
cairo_move_to(cr, 0.0, y); cairo_move_to(cr, 0.0, y);
cairo_line_to(cr, _analysisWidth, y); cairo_line_to(cr, _analysis_width, y);
cairo_set_line_width (cr, 0.25 + 1.0/(float)(i+1)); cairo_set_line_width (cr, 0.25 + 1.0/(float)(i+1));
cairo_stroke(cr); cairo_stroke(cr);
@ -378,7 +385,7 @@ PluginEqGui::drawPhaseScale(Gtk::Widget *w, cairo_t *cr)
} }
void void
PluginEqGui::drawPhase(Gtk::Widget *w, cairo_t *cr) PluginEqGui::plot_phase(Gtk::Widget *w, cairo_t *cr)
{ {
float x,y; float x,y;
@ -387,19 +394,19 @@ PluginEqGui::drawPhase(Gtk::Widget *w, cairo_t *cr)
int avgNum = 0; int avgNum = 0;
cairo_set_source_rgba(cr, 0.95, 0.3, 0.2, 1.0); cairo_set_source_rgba(cr, 0.95, 0.3, 0.2, 1.0);
for (uint32_t i = 0; i < _impulseFft->bins()-1; i++) { for (uint32_t i = 0; i < _impulse_fft->bins()-1; i++) {
// x coordinate of bin i // x coordinate of bin i
x = log10f(1.0 + (float)i / (float)_impulseFft->bins() * _logCoeff) / _logMax; x = log10f(1.0 + (float)i / (float)_impulse_fft->bins() * _log_coeff) / _log_max;
x *= _analysisWidth; x *= _analysis_width;
y = _analysisHeight/2.0 - (_impulseFft->phaseAtBin(i)/M_PI)*(_analysisHeight/2.0)*PHASE_PROPORTION; y = _analysis_height/2.0 - (_impulse_fft->phase_at_bin(i)/M_PI)*(_analysis_height/2.0)*PHASE_PROPORTION;
if ( i == 0 ) { if ( i == 0 ) {
cairo_move_to(cr, x, y); cairo_move_to(cr, x, y);
avgY = 0; avgY = 0;
avgNum = 0; avgNum = 0;
} else if (rint(x) > prevX || i == _impulseFft->bins()-1 ) { } else if (rint(x) > prevX || i == _impulse_fft->bins()-1 ) {
cairo_line_to(cr, prevX, avgY/(float)avgNum); cairo_line_to(cr, prevX, avgY/(float)avgNum);
avgY = 0; avgY = 0;
@ -417,11 +424,11 @@ PluginEqGui::drawPhase(Gtk::Widget *w, cairo_t *cr)
} }
void void
PluginEqGui::drawPowerScale(Gtk::Widget *w, cairo_t *cr) PluginEqGui::draw_scales_power(Gtk::Widget *w, cairo_t *cr)
{ {
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 }; 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 };
float divisor = _samplerate / 2.0 / _impulseFft->bins(); float divisor = _samplerate / 2.0 / _impulse_fft->bins();
float x; float x;
cairo_set_line_width (cr, 1.5); cairo_set_line_width (cr, 1.5);
@ -436,8 +443,8 @@ PluginEqGui::drawPowerScale(Gtk::Widget *w, cairo_t *cr)
for (uint32_t i = 0; scales[i] != -1.0; ++i) { for (uint32_t i = 0; scales[i] != -1.0; ++i) {
float bin = scales[i] / divisor; float bin = scales[i] / divisor;
x = log10f(1.0 + bin / (float)_impulseFft->bins() * _logCoeff) / _logMax; x = log10f(1.0 + bin / (float)_impulse_fft->bins() * _log_coeff) / _log_max;
x *= _analysisWidth; x *= _analysis_width;
if (scales[i] < 1000.0) { if (scales[i] < 1000.0) {
snprintf(buf, 256, "%0.0f", scales[i]); snprintf(buf, 256, "%0.0f", scales[i]);
@ -455,7 +462,7 @@ PluginEqGui::drawPowerScale(Gtk::Widget *w, cairo_t *cr)
cairo_stroke(cr); cairo_stroke(cr);
cairo_set_source_rgb(cr, 0.3, 0.3, 0.3); cairo_set_source_rgb(cr, 0.3, 0.3, 0.3);
cairo_move_to(cr, x, _analysisHeight); cairo_move_to(cr, x, _analysis_height);
cairo_line_to(cr, x, 0.0); cairo_line_to(cr, x, 0.0);
cairo_stroke(cr); cairo_stroke(cr);
} }
@ -465,12 +472,12 @@ PluginEqGui::drawPowerScale(Gtk::Widget *w, cairo_t *cr)
//double dashes[] = { 1.0, 3.0, 4.5, 3.0 }; //double dashes[] = { 1.0, 3.0, 4.5, 3.0 };
double dashes[] = { 3.0, 5.0 }; double dashes[] = { 3.0, 5.0 };
for (float dB = 0.0; dB < _maxdB; dB += _dBStep ) { for (float dB = 0.0; dB < _max_dB; dB += _step_dB ) {
snprintf(buf, 256, "+%0.0f", dB ); snprintf(buf, 256, "+%0.0f", dB );
y = ( _maxdB - dB) / ( _maxdB - _mindB ); y = ( _max_dB - dB) / ( _max_dB - _min_dB );
//std::cerr << " y = " << y << std::endl; //std::cerr << " y = " << y << std::endl;
y *= _analysisHeight; y *= _analysis_height;
if (dB != 0.0) { if (dB != 0.0) {
cairo_set_source_rgb(cr, 0.4, 0.4, 0.4); cairo_set_source_rgb(cr, 0.4, 0.4, 0.4);
@ -481,7 +488,7 @@ PluginEqGui::drawPowerScale(Gtk::Widget *w, cairo_t *cr)
cairo_set_source_rgb(cr, 0.2, 0.2, 0.2); cairo_set_source_rgb(cr, 0.2, 0.2, 0.2);
cairo_move_to(cr, 0, y); cairo_move_to(cr, 0, y);
cairo_line_to(cr, _analysisWidth, y); cairo_line_to(cr, _analysis_width, y);
cairo_stroke(cr); cairo_stroke(cr);
if (dB == 0.0) { if (dB == 0.0) {
@ -491,11 +498,11 @@ PluginEqGui::drawPowerScale(Gtk::Widget *w, cairo_t *cr)
for (float dB = - _dBStep; dB > _mindB; dB -= _dBStep ) { for (float dB = - _step_dB; dB > _min_dB; dB -= _step_dB ) {
snprintf(buf, 256, "%0.0f", dB ); snprintf(buf, 256, "%0.0f", dB );
y = ( _maxdB - dB) / ( _maxdB - _mindB ); y = ( _max_dB - dB) / ( _max_dB - _min_dB );
y *= _analysisHeight; y *= _analysis_height;
cairo_set_source_rgb(cr, 0.4, 0.4, 0.4); cairo_set_source_rgb(cr, 0.4, 0.4, 0.4);
cairo_move_to(cr, 1.0, y - extents.descent - 1.0); cairo_move_to(cr, 1.0, y - extents.descent - 1.0);
@ -504,7 +511,7 @@ PluginEqGui::drawPowerScale(Gtk::Widget *w, cairo_t *cr)
cairo_set_source_rgb(cr, 0.2, 0.2, 0.2); cairo_set_source_rgb(cr, 0.2, 0.2, 0.2);
cairo_move_to(cr, 0, y); cairo_move_to(cr, 0, y);
cairo_line_to(cr, _analysisWidth, y); cairo_line_to(cr, _analysis_width, y);
cairo_stroke(cr); cairo_stroke(cr);
} }
@ -519,7 +526,7 @@ power_to_dB(float a)
} }
void void
PluginEqGui::drawPower(Gtk::Widget *w, cairo_t *cr) PluginEqGui::plot_amplitude(Gtk::Widget *w, cairo_t *cr)
{ {
float x,y; float x,y;
@ -530,21 +537,21 @@ PluginEqGui::drawPower(Gtk::Widget *w, cairo_t *cr)
cairo_set_source_rgb(cr, 1.0, 1.0, 1.0); cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
cairo_set_line_width (cr, 2.5); cairo_set_line_width (cr, 2.5);
for (uint32_t i = 0; i < _impulseFft->bins()-1; i++) { for (uint32_t i = 0; i < _impulse_fft->bins()-1; i++) {
// x coordinate of bin i // x coordinate of bin i
x = log10f(1.0 + (float)i / (float)_impulseFft->bins() * _logCoeff) / _logMax; x = log10f(1.0 + (float)i / (float)_impulse_fft->bins() * _log_coeff) / _log_max;
x *= _analysisWidth; x *= _analysis_width;
float yCoeff = ( power_to_dB(_impulseFft->powerAtBin(i)) - _mindB) / (_maxdB - _mindB); float yCoeff = ( power_to_dB(_impulse_fft->power_at_bin(i)) - _min_dB) / (_max_dB - _min_dB);
y = _analysisHeight - _analysisHeight*yCoeff; y = _analysis_height - _analysis_height*yCoeff;
if ( i == 0 ) { if ( i == 0 ) {
cairo_move_to(cr, x, y); cairo_move_to(cr, x, y);
avgY = 0; avgY = 0;
avgNum = 0; avgNum = 0;
} else if (rint(x) > prevX || i == _impulseFft->bins()-1 ) { } else if (rint(x) > prevX || i == _impulse_fft->bins()-1 ) {
cairo_line_to(cr, prevX, avgY/(float)avgNum); cairo_line_to(cr, prevX, avgY/(float)avgNum);
avgY = 0; avgY = 0;

62
gtk2_ardour/eq_gui.h → gtk2_ardour/plugin_eq_gui.h
View file

@ -18,8 +18,8 @@
*/ */
#ifndef __ardour_eq_gui_h #ifndef __ardour_plugin_eq_gui_h
#define __ardour_eq_gui_h #define __ardour_plugin_eq_gui_h
#include <ardour/buffer_set.h> #include <ardour/buffer_set.h>
#include <ardour/plugin_insert.h> #include <ardour/plugin_insert.h>
@ -30,7 +30,6 @@
#include <gtkmm/combobox.h> #include <gtkmm/combobox.h>
#include <gtkmm/liststore.h> #include <gtkmm/liststore.h>
class Plugin;
class FFT; class FFT;
class PluginEqGui : public Gtk::Table class PluginEqGui : public Gtk::Table
@ -43,31 +42,34 @@ class PluginEqGui : public Gtk::Table
private: private:
// Setup // Setup
void setBufferSize(uint32_t); void set_buffer_size(uint32_t);
void dBScaleChanged(); void change_dB_scale();
// Analysis // Analysis
void runAnalysis(); void run_analysis();
// Drawing // Drawing
virtual void on_hide(); virtual void on_hide();
virtual void on_show(); virtual void on_show();
void resizeAnalysisArea(Gtk::Allocation&); void stop_updating();
void start_updating();
void redrawAnalysisArea(); void resize_analysis_area(Gtk::Allocation&);
void generateAnalysisScale(cairo_t *); void redraw_analysis_area();
bool exposeAnalysisArea(GdkEventExpose *);
void drawPowerScale(Gtk::Widget *, cairo_t *); void draw_analysis_scales(cairo_t *);
void drawPower(Gtk::Widget *,cairo_t *); bool expose_analysis_area(GdkEventExpose *);
void drawPhaseScale(Gtk::Widget *,cairo_t *); void draw_scales_power(Gtk::Widget *, cairo_t *);
void drawPhase(Gtk::Widget *,cairo_t *); void plot_amplitude(Gtk::Widget *,cairo_t *);
void draw_scales_phase(Gtk::Widget *,cairo_t *);
void plot_phase(Gtk::Widget *,cairo_t *);
// Helpers // Helpers
bool timeoutCallback(); bool timeout_callback();
void redrawScales(); void redraw_scales();
// Fields: // Fields:
@ -75,31 +77,31 @@ class PluginEqGui : public Gtk::Table
// analysis parameters // analysis parameters
float _samplerate; float _samplerate;
float _mindB; float _min_dB;
float _maxdB; float _max_dB;
float _dBStep; float _step_dB;
float _logCoeff; float _log_coeff;
float _logMax; float _log_max;
nframes_t _bufferSize; nframes_t _buffer_size;
// buffers // buffers
ARDOUR::BufferSet _bufferset; ARDOUR::BufferSet _bufferset;
// dimensions // dimensions
float _analysisWidth; float _analysis_width;
float _analysisHeight; float _analysis_height;
// My objects // My objects
FFT *_impulseFft; FFT *_impulse_fft;
boost::shared_ptr<ARDOUR::Plugin> _plugin; boost::shared_ptr<ARDOUR::Plugin> _plugin;
// gui objects // gui objects
Gtk::DrawingArea *_analysisArea; Gtk::DrawingArea *_analysis_area;
cairo_surface_t *_analysisScaleSurface; cairo_surface_t *_analysis_scale_surface;
// dB scale selection: // dB scale selection:
@ -120,10 +122,12 @@ class PluginEqGui : public Gtk::Table
Gtk::ComboBox *dBScaleCombo; Gtk::ComboBox *dBScaleCombo;
Glib::RefPtr<Gtk::ListStore> dBScaleModel; Glib::RefPtr<Gtk::ListStore> dBScaleModel;
Gtk::CheckButton *phaseSelect; Gtk::CheckButton *_phase_button;
// signals and connections // signals and connections
sigc::connection _updateConn; sigc::connection _update_connection;
sigc::connection _window_unmap_connection;
sigc::connection _window_map_connection;
}; };
#endif #endif

7
gtk2_ardour/plugin_ui.cc
View file

@ -57,7 +57,6 @@
#include "gui_thread.h" #include "gui_thread.h"
#include "public_editor.h" #include "public_editor.h"
#include "keyboard.h" #include "keyboard.h"
#include "eq_gui.h"
#include "i18n.h" #include "i18n.h"
@ -114,14 +113,16 @@ PluginUIWindow::PluginUIWindow (Gtk::Window* win, boost::shared_ptr<PluginInsert
GenericPluginUI* pu = new GenericPluginUI (insert, scrollable); GenericPluginUI* pu = new GenericPluginUI (insert, scrollable);
_pluginui = pu; _pluginui = pu;
add( *pu );
/*
Gtk::HBox *hbox = new Gtk::HBox(); Gtk::HBox *hbox = new Gtk::HBox();
hbox->pack_start( *pu); hbox->pack_start( *pu);
// TODO: this should be nicer // TODO: this should be nicer
hbox->pack_start( *manage(new PluginEqGui(insert))); hbox->pack_start( eqgui_bin );
add (*manage(hbox)); add (*manage(hbox));
*/
set_wmclass (X_("ardour_plugin_editor"), "Ardour"); set_wmclass (X_("ardour_plugin_editor"), "Ardour");

9
gtk2_ardour/plugin_ui.h
View file

@ -87,6 +87,7 @@ class PlugUIBase : public virtual sigc::trackable
Gtk::ComboBoxText preset_combo; Gtk::ComboBoxText preset_combo;
Gtk::Button save_button; Gtk::Button save_button;
Gtk::ToggleButton bypass_button; Gtk::ToggleButton bypass_button;
LatencyGUI latency_gui; LatencyGUI latency_gui;
void setting_selected(); void setting_selected();
@ -95,7 +96,7 @@ class PlugUIBase : public virtual sigc::trackable
void processor_active_changed (boost::weak_ptr<ARDOUR::Processor> p); void processor_active_changed (boost::weak_ptr<ARDOUR::Processor> p);
}; };
class GenericPluginUI : public PlugUIBase, public Gtk::VBox class GenericPluginUI : public PlugUIBase, public Gtk::HPaned
{ {
public: public:
GenericPluginUI (boost::shared_ptr<ARDOUR::PluginInsert> plug, bool scrollable=false); GenericPluginUI (boost::shared_ptr<ARDOUR::PluginInsert> plug, bool scrollable=false);
@ -108,12 +109,16 @@ class GenericPluginUI : public PlugUIBase, public Gtk::VBox
bool stop_updating(GdkEventAny*); bool stop_updating(GdkEventAny*);
private: private:
Gtk::VBox main_contents;
Gtk::HBox settings_box; Gtk::HBox settings_box;
Gtk::HBox hpacker; Gtk::HBox hpacker;
Gtk::Table button_table; Gtk::Table button_table;
Gtk::Table output_table; Gtk::Table output_table;
Gtk::ToggleButton eqgui_toggle;
Gtk::ScrolledWindow scroller; Gtk::ScrolledWindow scroller;
Gtk::Adjustment hAdjustment; Gtk::Adjustment hAdjustment;
Gtk::Adjustment vAdjustment; Gtk::Adjustment vAdjustment;
@ -200,6 +205,8 @@ class GenericPluginUI : public PlugUIBase, public Gtk::VBox
void start_touch (ControlUI*); void start_touch (ControlUI*);
void stop_touch (ControlUI*); void stop_touch (ControlUI*);
void toggle_plugin_analysis ();
void print_parameter (char *buf, uint32_t len, uint32_t param); void print_parameter (char *buf, uint32_t len, uint32_t param);
}; };