#include <iostream>
#include <cmath>
+using namespace ARDOUR;
+
PluginEqGui::PluginEqGui(boost::shared_ptr<ARDOUR::PluginInsert> pluginInsert)
: _min_dB(-12.0),
_max_dB(+12.0),
_analysis_scale_surface = 0;
_analysis_area = new Gtk::DrawingArea();
- _analysis_width = 500.0;
- _analysis_height = 500.0;
+ _analysis_width = 256.0;
+ _analysis_height = 256.0;
_analysis_area->set_size_request(_analysis_width, _analysis_height);
_analysis_area->signal_expose_event().connect( sigc::mem_fun (*this, &PluginEqGui::expose_analysis_area));
_analysis_area->signal_size_allocate().connect( sigc::mem_fun (*this, &PluginEqGui::resize_analysis_area));
-
// dB selection
dBScaleModel = Gtk::ListStore::create(dBColumns);
dBScaleCombo = new Gtk::ComboBox(dBScaleModel);
- dBScaleCombo -> set_title("dB scale");
+ dBScaleCombo->set_title (_("dB scale"));
#define ADD_DB_ROW(MIN,MAX,STEP,NAME) \
{ \
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"));
Gtk::HBox *dBSelectBin = new Gtk::HBox(false, 5);
dBSelectBin->add( *manage(dBComboLabel));
dBSelectBin->add( *manage(dBScaleCombo));
// Phase checkbutton
- _phase_button = new Gtk::CheckButton("Show phase");
+ _phase_button = new Gtk::CheckButton (_("Show phase"));
_phase_button->set_active(true);
_phase_button->signal_toggled().connect( sigc::mem_fun(*this, &PluginEqGui::redraw_scales));
// Connect the realtime signal collection callback
- _plugin_insert->AnalysisDataGathered.connect (analysis_connection, ui_bind (&PluginEqGui::signal_collect_callback, this, _1, _2), gui_context());
+ _plugin_insert->AnalysisDataGathered.connect (analysis_connection, invalidator (*this), ui_bind (&PluginEqGui::signal_collect_callback, this, _1, _2), gui_context());
}
PluginEqGui::~PluginEqGui()
return;
- FFT *tmp1 = _impulse_fft;
- FFT *tmp2 = _signal_input_fft;
- FFT *tmp3 = _signal_output_fft;
+ GTKArdour::FFT *tmp1 = _impulse_fft;
+ GTKArdour::FFT *tmp2 = _signal_input_fft;
+ GTKArdour::FFT *tmp3 = _signal_output_fft;
try {
- _impulse_fft = new FFT(size);
- _signal_input_fft = new FFT(signal_size);
- _signal_output_fft = new FFT(signal_size);
+ _impulse_fft = new GTKArdour::FFT(size);
+ _signal_input_fft = new GTKArdour::FFT(signal_size);
+ _signal_output_fft = new GTKArdour::FFT(signal_size);
} catch( ... ) {
// Don't care about lost memory, we're screwed anyhow
_impulse_fft = tmp1;
_buffer_size = size;
_signal_buffer_size = signal_size;
- // These are for impulse analysis only, the signal analysis uses the actual
- // number of I/O's for the plugininsert
- uint32_t inputs = _plugin->get_info()->n_inputs.n_audio();
- uint32_t outputs = _plugin->get_info()->n_outputs.n_audio();
-
- // buffers for the signal analysis are ensured inside PluginInsert
- uint32_t n_chans = std::max(inputs, outputs);
- _bufferset.ensure_buffers(ARDOUR::DataType::AUDIO, n_chans, _buffer_size);
- _collect_bufferset.ensure_buffers(ARDOUR::DataType::AUDIO, n_chans, _buffer_size);
+ ARDOUR::ChanCount count = ARDOUR::ChanCount::max (_plugin->get_info()->n_inputs, _plugin->get_info()->n_outputs);
+ for (ARDOUR::DataType::iterator i = ARDOUR::DataType::begin(); i != ARDOUR::DataType::end(); ++i) {
+ _bufferset.ensure_buffers (*i, count.get (*i), _buffer_size);
+ _collect_bufferset.ensure_buffers (*i, count.get (*i), _buffer_size);
+ }
- ARDOUR::ChanCount chanCount(ARDOUR::DataType::AUDIO, n_chans);
- _bufferset.set_count(chanCount);
- _collect_bufferset.set_count(chanCount);
+ _bufferset.set_count (count);
+ _collect_bufferset.set_count (count);
}
void
_signal_output_fft->reset();
for (uint32_t i = 0; i < _plugin_insert->input_streams().n_audio(); ++i) {
- _signal_input_fft ->analyze(in ->get_audio(i).data(), FFT::HANN);
+ _signal_input_fft ->analyze(in ->get_audio(i).data(), GTKArdour::FFT::HANN);
}
for (uint32_t i = 0; i < _plugin_insert->output_streams().n_audio(); ++i) {
- _signal_output_fft->analyze(out->get_audio(i).data(), FFT::HANN);
+ _signal_output_fft->analyze(out->get_audio(i).data(), GTKArdour::FFT::HANN);
}
_signal_input_fft ->calculate();
ARDOUR::ChanMapping in_map(_plugin->get_info()->n_inputs);
ARDOUR::ChanMapping out_map(_plugin->get_info()->n_outputs);
- _plugin->connect_and_run(_bufferset, in_map, out_map, _buffer_size, (nframes_t)0);
- nframes_t f = _plugin->signal_latency();
+ _plugin->connect_and_run(_bufferset, in_map, out_map, _buffer_size, 0);
+ framecnt_t f = _plugin->signal_latency ();
// Adding user_latency() could be interesting
// Gather all output, taking latency into account.
} else {
//int C = 0;
//std::cerr << (++C) << ": latency is " << f << " frames, doing split processing.." << std::endl;
- nframes_t target_offset = 0;
- nframes_t frames_left = _buffer_size; // refaktoroi
+ framecnt_t target_offset = 0;
+ framecnt_t frames_left = _buffer_size; // refaktoroi
do {
if (f >= _buffer_size) {
//std::cerr << (++C) << ": f (=" << f << ") is larger than buffer_size, still trying to reach the actual output" << std::endl;
// we start at output offset "f"
// .. and copy "buffer size" - "f" - "offset" frames
- nframes_t length = _buffer_size - f - target_offset;
+ framecnt_t length = _buffer_size - f - target_offset;
//std::cerr << (++C) << ": copying " << length << " frames to _collect_bufferset.get_audio(i)+" << target_offset << " from bufferset at offset " << f << std::endl;
for (uint32_t i = 0; i < outputs; ++i) {
in_map = ARDOUR::ChanMapping(_plugin->get_info()->n_inputs);
out_map = ARDOUR::ChanMapping(_plugin->get_info()->n_outputs);
- _plugin->connect_and_run(_bufferset, in_map, out_map, _buffer_size, (nframes_t)0);
+ _plugin->connect_and_run(_bufferset, in_map, out_map, _buffer_size, 0);
}
} while ( frames_left > 0);
projects / ardour.git / blobdiff