smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-16 03:36:32 +01:00
Code Issues Projects Releases Wiki Activity

merge from trunk

Browse source 
git-svn-id: svn://localhost/ardour2/branches/undo@794 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Hans Fugal 2006-08-12 01:36:34 +00:00
parent 1b45cf4044
commit f995ac3786
52 changed files with 1097 additions and 943 deletions
Download patch file Download diff file Expand all files Collapse all files

14
gtk2_ardour/SConscript
View file

@ -57,14 +57,13 @@ if gtkardour['FFT_ANALYSIS']:
gtkardour.Merge ([libraries['fftw3f']])
gtkardour.Append(CCFLAGS='-DFFT_ANALYSIS')
if gtkardour['COREAUDIO']:
gtkardour.Append(CCFLAGS='-DHAVE_COREAUDIO')
gtkardour.Merge([libraries['appleutility']])
skipped_files=Split("""
connection_editor.cc
""")
coreaudio_files=Split("""
au_pluginui.cc
""")
gtkardour_files=Split("""
about.cc
@ -140,6 +139,7 @@ imageframe_time_axis_view.cc
imageframe_view.cc
io_selector.cc
keyboard.cc
ladspa_pluginui.cc
location_ui.cc
main.cc
marker.cc
@ -186,7 +186,6 @@ visual_time_axis.cc
waveview.cc
""")
fft_analysis_files=Split("""
analysis_window.cc
fft_graph.cc
@ -213,6 +212,11 @@ if env['VST']:
extra_sources += vst_files
gtkardour.Append (CCFLAGS="-DVST_SUPPORT", CPPPATH="#libs/fst")
if gtkardour['COREAUDIO']:
extra_sources += coreaudio_files
gtkardour.Append(CCFLAGS='-DHAVE_COREAUDIO')
gtkardour.Merge([libraries['appleutility']])
if env['FFT_ANALYSIS']:
extra_sources += fft_analysis_files

6
gtk2_ardour/analysis_window.cc
View file

@ -221,7 +221,6 @@ AnalysisWindow::analyze_data (Gtk::Button *button)
Sample *buf = (Sample *) malloc(sizeof(Sample) * fft_graph.windowSize());
Sample *mixbuf = (Sample *) malloc(sizeof(Sample) * fft_graph.windowSize());
float *gain = (float *) malloc(sizeof(float) * fft_graph.windowSize());
char *work = (char *) malloc(sizeof(char) * fft_graph.windowSize());
Selection s = PublicEditor::instance().get_selection();
TimeSelection ts = s.time;
@ -261,7 +260,7 @@ AnalysisWindow::analyze_data (Gtk::Button *button)
n = (*j).length() - i;
}
n = pl->read(buf, mixbuf, gain, work, (*j).start + i, n);
n = pl->read(buf, mixbuf, gain, (*j).start + i, n);
if ( n < fft_graph.windowSize()) {
for (int j = n; j < fft_graph.windowSize(); j++) {
@ -301,7 +300,7 @@ AnalysisWindow::analyze_data (Gtk::Button *button)
n = arv->region().length() - i;
}
n = arv->audio_region().read_at(buf, mixbuf, gain, work, arv->region().position() + i, n);
n = arv->audio_region().read_at(buf, mixbuf, gain, arv->region().position() + i, n);
if ( n < fft_graph.windowSize()) {
for (int j = n; j < fft_graph.windowSize(); j++) {
@ -331,7 +330,6 @@ AnalysisWindow::analyze_data (Gtk::Button *button)
free(buf);
free(mixbuf);
free(work);
track_list_ready = true;
} /* end lock */

31
au_pluginui.cc → gtk2_ardour/au_pluginui.cc
View file

@ -23,13 +23,32 @@
#include "plugin_ui.h"
#include "i18n.h"
using namespace ARDOUR;
using namespace PBD;
AUPluginUI::AUPluginUI (boost::shared_ptr<PluginInsert> pi, boost::shared_ptr<AUPlugin> ap)
: PlugUIBase (pi),
au (ap)
AUPluginUI::AUPluginUI (boost::shared_ptr<PluginInsert> ap)
{
if ((au = boost::dynamic_pointer_cast<AUPlugin> (ap->plugin())) == 0) {
error << _("unknown type of editor-supplying plugin (note: no AudioUnit support in this version of ardour)") << endmsg;
throw failed_constructor ();
}
#if 0
set_position (Gtk::WIN_POS_MOUSE);
set_name ("PluginEditor");
add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), reinterpret_cast<Window*> (this)));
insert->GoingAway.connect (mem_fun(*this, &PluginUIWindow::plugin_going_away));
if (scrollable) {
gint h = _pluginui->get_preferred_height ();
if (h > 600) h = 600;
set_default_size (450, h);
}
#endif
info << "AUPluginUI created" << endmsg;
}
@ -37,9 +56,3 @@ AUPluginUI::~AUPluginUI ()
{
// nothing to do here - plugin destructor destroys the GUI
}
int
AUPluginUI::get_preferred_height ()
{
return -1;
}

12
gtk2_ardour/editor_export_audio.cc
View file

@ -162,7 +162,6 @@ Editor::write_region (string path, AudioRegion& region)
jack_nframes_t to_read;
Sample buf[chunk_size];
gain_t gain_buffer[chunk_size];
char workbuf[chunk_size *4];
jack_nframes_t pos;
char s[PATH_MAX+1];
uint32_t cnt;
@ -234,11 +233,11 @@ Editor::write_region (string path, AudioRegion& region)
fs = (*src);
if (region.read_at (buf, buf, gain_buffer, workbuf, pos, this_time) != this_time) {
if (region.read_at (buf, buf, gain_buffer, pos, this_time) != this_time) {
break;
}
if (fs->write (buf, this_time, workbuf) != this_time) {
if (fs->write (buf, this_time) != this_time) {
error << "" << endmsg;
goto error_out;
}
@ -309,7 +308,6 @@ Editor::write_audio_range (AudioPlaylist& playlist, uint32_t channels, list<Audi
jack_nframes_t nframes;
Sample buf[chunk_size];
gain_t gain_buffer[chunk_size];
char workbuf[chunk_size*4];
jack_nframes_t pos;
char s[PATH_MAX+1];
uint32_t cnt;
@ -367,11 +365,11 @@ Editor::write_audio_range (AudioPlaylist& playlist, uint32_t channels, list<Audi
fs = sources[n];
if (playlist.read (buf, buf, gain_buffer, workbuf, pos, this_time, n) != this_time) {
if (playlist.read (buf, buf, gain_buffer, pos, this_time, n) != this_time) {
break;
}
if (fs->write (buf, this_time, workbuf) != this_time) {
if (fs->write (buf, this_time) != this_time) {
goto error_out;
}
}
@ -397,7 +395,7 @@ Editor::write_audio_range (AudioPlaylist& playlist, uint32_t channels, list<Audi
for (uint32_t n=0; n < channels; ++n) {
fs = sources[n];
if (fs->write (buf, this_time, workbuf) != this_time) {
if (fs->write (buf, this_time) != this_time) {
goto error_out;
}
}

757
gtk2_ardour/ladspa_pluginui.cc Normal file
View file

@ -0,0 +1,757 @@
/*
Copyright (C) 2000 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <climits>
#include <cerrno>
#include <cmath>
#include <string>
#include <pbd/stl_delete.h>
#include <pbd/xml++.h>
#include <pbd/failed_constructor.h>
#include <gtkmm2ext/click_box.h>
#include <gtkmm2ext/fastmeter.h>
#include <gtkmm2ext/barcontroller.h>
#include <gtkmm2ext/utils.h>
#include <gtkmm2ext/doi.h>
#include <gtkmm2ext/slider_controller.h>
#include <midi++/manager.h>
#include <ardour/plugin.h>
#include <ardour/insert.h>
#include <ardour/ladspa_plugin.h>
#include <lrdf.h>
#include "ardour_ui.h"
#include "prompter.h"
#include "plugin_ui.h"
#include "utils.h"
#include "gui_thread.h"
#include "i18n.h"
using namespace std;
using namespace ARDOUR;
using namespace PBD;
using namespace Gtkmm2ext;
using namespace Gtk;
using namespace sigc;
LadspaPluginUI::LadspaPluginUI (boost::shared_ptr<PluginInsert> pi, bool scrollable)
: PlugUIBase (pi),
button_table (initial_button_rows, initial_button_cols),
output_table (initial_output_rows, initial_output_cols),
hAdjustment(0.0, 0.0, 0.0),
vAdjustment(0.0, 0.0, 0.0),
scroller_view(hAdjustment, vAdjustment),
automation_menu (0),
is_scrollable(scrollable)
{
set_name ("PluginEditor");
set_border_width (10);
set_homogeneous (false);
settings_box.set_homogeneous (false);
HBox* constraint_hbox = manage (new HBox);
HBox* smaller_hbox = manage (new HBox);
Label* combo_label = manage (new Label (_("<span size=\"large\">Presets</span>")));
combo_label->set_use_markup (true);
smaller_hbox->pack_start (*combo_label, false, false, 10);
smaller_hbox->pack_start (combo, false, false);
smaller_hbox->pack_start (save_button, false, false);
constraint_hbox->set_spacing (5);
constraint_hbox->pack_start (*smaller_hbox, true, false);
constraint_hbox->pack_end (bypass_button, false, false);
settings_box.pack_end (*constraint_hbox, false, false);
pack_start (settings_box, false, false);
if ( is_scrollable ) {
scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
scroller.set_name ("PluginEditor");
scroller_view.set_name("PluginEditor");
scroller_view.add (hpacker);
scroller.add (scroller_view);
pack_start (scroller, true, true);
}
else {
pack_start (hpacker, false, false);
}
insert->active_changed.connect (mem_fun(*this, &LadspaPluginUI::redirect_active_changed));
bypass_button.set_active (!insert->active());
build ();
}
LadspaPluginUI::~LadspaPluginUI ()
{
if (output_controls.size() > 0) {
screen_update_connection.disconnect();
}
}
void
LadspaPluginUI::build ()
{
guint32 i = 0;
guint32 x = 0;
Frame* frame;
Frame* bt_frame;
VBox* box;
int output_row, output_col;
int button_row, button_col;
int output_rows, output_cols;
int button_rows, button_cols;
guint32 n_ins=0, n_outs = 0;
prefheight = 30;
hpacker.set_spacing (10);
output_rows = initial_output_rows;
output_cols = initial_output_cols;
button_rows = initial_button_rows;
button_cols = initial_button_cols;
output_row = 0;
button_row = 0;
output_col = 0;
button_col = 0;
button_table.set_homogeneous (false);
button_table.set_row_spacings (2);
button_table.set_col_spacings (2);
output_table.set_homogeneous (true);
output_table.set_row_spacings (2);
output_table.set_col_spacings (2);
button_table.set_border_width (5);
output_table.set_border_width (5);
hpacker.set_border_width (10);
bt_frame = manage (new Frame);
bt_frame->set_name ("BaseFrame");
bt_frame->add (button_table);
hpacker.pack_start(*bt_frame, true, true);
box = manage (new VBox);
box->set_border_width (5);
box->set_spacing (1);
frame = manage (new Frame);
frame->set_name ("BaseFrame");
frame->set_label (_("Controls"));
frame->add (*box);
hpacker.pack_start(*frame, true, true);
/* find all ports. build control elements for all appropriate control ports */
for (i = 0; i < plugin->parameter_count(); ++i) {
if (plugin->parameter_is_control (i)) {
/* Don't show latency control ports */
if (plugin->describe_parameter (i) == X_("latency")) {
continue;
}
ControlUI* cui;
/* if we are scrollable, just use one long column */
if (!is_scrollable) {
if (x++ > 7){
frame = manage (new Frame);
frame->set_name ("BaseFrame");
box = manage (new VBox);
box->set_border_width (5);
box->set_spacing (1);
frame->add (*box);
hpacker.pack_start(*frame,true,true);
x = 0;
}
}
if ((cui = build_control_ui (i, plugin->get_nth_control (i))) == 0) {
error << string_compose(_("Plugin Editor: could not build control element for port %1"), i) << endmsg;
continue;
}
if (cui->control || cui->clickbox || cui->combo) {
box->pack_start (*cui, false, false);
} else if (cui->button) {
if (button_row == button_rows) {
button_row = 0;
if (++button_col == button_cols) {
button_cols += 2;
button_table.resize (button_rows, button_cols);
}
}
button_table.attach (*cui, button_col, button_col + 1, button_row, button_row+1,
FILL|EXPAND, FILL);
button_row++;
} else if (cui->display) {
output_table.attach (*cui, output_col, output_col + 1, output_row, output_row+1,
FILL|EXPAND, FILL);
// TODO: The meters should be divided into multiple rows
if (++output_col == output_cols) {
output_cols ++;
output_table.resize (output_rows, output_cols);
}
/* old code, which divides meters into
* columns first, rows later. New code divides into one row
if (output_row == output_rows) {
output_row = 0;
if (++output_col == output_cols) {
output_cols += 2;
output_table.resize (output_rows, output_cols);
}
}
output_table.attach (*cui, output_col, output_col + 1, output_row, output_row+1,
FILL|EXPAND, FILL);
output_row++;
*/
}
/* HACK: ideally the preferred height would be queried from
the complete hpacker, but I can't seem to get that
information in time, so this is an estimation
*/
prefheight += 30;
}
}
n_ins = plugin->get_info()->n_inputs;
n_outs = plugin->get_info()->n_outputs;
if (box->children().empty()) {
hpacker.remove (*frame);
}
if (button_table.children().empty()) {
hpacker.remove (*bt_frame);
}
if (!output_table.children().empty()) {
frame = manage (new Frame);
frame->set_name ("BaseFrame");
frame->add (output_table);
hpacker.pack_end (*frame, true, true);
}
output_update ();
output_table.show_all ();
button_table.show_all ();
}
LadspaPluginUI::ControlUI::ControlUI ()
: automate_button (X_("")) // force creation of a label
{
automate_button.set_name ("PluginAutomateButton");
ARDOUR_UI::instance()->tooltips().set_tip (automate_button,
_("Automation control"));
/* don't fix the height, it messes up the bar controllers */
set_size_request_to_display_given_text (automate_button, X_("lngnuf"), 2, 2);
ignore_change = 0;
display = 0;
button = 0;
control = 0;
clickbox = 0;
adjustment = 0;
meterinfo = 0;
}
LadspaPluginUI::ControlUI::~ControlUI()
{
if (adjustment) {
delete adjustment;
}
if (meterinfo) {
delete meterinfo->meter;
delete meterinfo;
}
}
void
LadspaPluginUI::automation_state_changed (ControlUI* cui)
{
/* update button label */
switch (insert->get_port_automation_state (cui->port_index) & (Off|Play|Touch|Write)) {
case Off:
cui->automate_button.set_label (_("Off"));
break;
case Play:
cui->automate_button.set_label (_("Play"));
break;
case Write:
cui->automate_button.set_label (_("Write"));
break;
case Touch:
cui->automate_button.set_label (_("Touch"));
break;
default:
cui->automate_button.set_label (_("???"));
break;
}
}
static void integer_printer (char buf[32], Adjustment &adj, void *arg)
{
snprintf (buf, 32, "%.0f", adj.get_value());
}
void
LadspaPluginUI::print_parameter (char *buf, uint32_t len, uint32_t param)
{
plugin->print_parameter (param, buf, len);
}
LadspaPluginUI::ControlUI*
LadspaPluginUI::build_control_ui (guint32 port_index, PBD::Controllable* mcontrol)
{
ControlUI* control_ui;
Plugin::ParameterDescriptor desc;
plugin->get_parameter_descriptor (port_index, desc);
control_ui = manage (new ControlUI ());
control_ui->adjustment = 0;
control_ui->combo = 0;
control_ui->combo_map = 0;
control_ui->port_index = port_index;
control_ui->update_pending = false;
control_ui->label.set_text (desc.label);
control_ui->label.set_alignment (0.0, 0.5);
control_ui->label.set_name ("PluginParameterLabel");
control_ui->set_spacing (5);
if (plugin->parameter_is_input (port_index)) {
boost::shared_ptr<LadspaPlugin> lp;
if ((lp = boost::dynamic_pointer_cast<LadspaPlugin>(plugin)) != 0) {
lrdf_defaults* defaults = lrdf_get_scale_values(lp->unique_id(), port_index);
if (defaults && defaults->count > 0) {
control_ui->combo = new Gtk::ComboBoxText;
//control_ui->combo->set_value_in_list(true, false);
set_popdown_strings (*control_ui->combo, setup_scale_values(port_index, control_ui));
control_ui->combo->signal_changed().connect (bind (mem_fun(*this, &LadspaPluginUI::control_combo_changed), control_ui));
plugin->ParameterChanged.connect (bind (mem_fun (*this, &LadspaPluginUI::parameter_changed), control_ui));
control_ui->pack_start(control_ui->label, true, true);
control_ui->pack_start(*control_ui->combo, false, true);
update_control_display(control_ui);
lrdf_free_setting_values(defaults);
return control_ui;
}
}
if (desc.toggled) {
/* Build a button */
control_ui->button = manage (new ToggleButton ());
control_ui->button->set_name ("PluginEditorButton");
control_ui->button->set_size_request (20, 20);
control_ui->pack_start (control_ui->label, true, true);
control_ui->pack_start (*control_ui->button, false, true);
control_ui->pack_start (control_ui->automate_button, false, false);
control_ui->button->signal_clicked().connect (bind (mem_fun(*this, &LadspaPluginUI::control_port_toggled), control_ui));
if(plugin->get_parameter (port_index) == 1){
control_ui->button->set_active(true);
}
return control_ui;
}
control_ui->adjustment = new Adjustment (0, 0, 0, 0, 0);
/* XXX this code is not right yet, because it doesn't handle
the absence of bounds in any sensible fashion.
*/
control_ui->adjustment->set_lower (desc.lower);
control_ui->adjustment->set_upper (desc.upper);
control_ui->logarithmic = desc.logarithmic;
if (control_ui->logarithmic) {
if (control_ui->adjustment->get_lower() == 0.0) {
control_ui->adjustment->set_lower (control_ui->adjustment->get_upper()/10000);
}
control_ui->adjustment->set_upper (log(control_ui->adjustment->get_upper()));
control_ui->adjustment->set_lower (log(control_ui->adjustment->get_lower()));
}
float delta = desc.upper - desc.lower;
control_ui->adjustment->set_page_size (delta/100.0);
control_ui->adjustment->set_step_increment (desc.step);
control_ui->adjustment->set_page_increment (desc.largestep);
if (desc.integer_step) {
control_ui->clickbox = new ClickBox (control_ui->adjustment, "PluginUIClickBox");
Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->clickbox, "g9999999", 2, 2);
control_ui->clickbox->set_print_func (integer_printer, 0);
} else {
sigc::slot<void,char*,uint32_t> pslot = sigc::bind (mem_fun(*this, &LadspaPluginUI::print_parameter), (uint32_t) port_index);
control_ui->control = new BarController (*control_ui->adjustment, *mcontrol, pslot);
// should really match the height of the text in the automation button+label
control_ui->control->set_size_request (200, 22);
control_ui->control->set_name (X_("PluginSlider"));
control_ui->control->set_style (BarController::LeftToRight);
control_ui->control->set_use_parent (true);
control_ui->control->StartGesture.connect (bind (mem_fun(*this, &LadspaPluginUI::start_touch), control_ui));
control_ui->control->StopGesture.connect (bind (mem_fun(*this, &LadspaPluginUI::stop_touch), control_ui));
}
if (control_ui->logarithmic) {
control_ui->adjustment->set_value(log(plugin->get_parameter(port_index)));
} else{
control_ui->adjustment->set_value(plugin->get_parameter(port_index));
}
/* XXX memory leak: SliderController not destroyed by ControlUI
destructor, and manage() reports object hierarchy
ambiguity.
*/
control_ui->pack_start (control_ui->label, true, true);
if (desc.integer_step) {
control_ui->pack_start (*control_ui->clickbox, false, false);
} else {
control_ui->pack_start (*control_ui->control, false, false);
}
control_ui->pack_start (control_ui->automate_button, false, false);
control_ui->adjustment->signal_value_changed().connect (bind (mem_fun(*this, &LadspaPluginUI::control_adjustment_changed), control_ui));
control_ui->automate_button.signal_clicked().connect (bind (mem_fun(*this, &LadspaPluginUI::astate_clicked), control_ui, (uint32_t) port_index));
automation_state_changed (control_ui);
plugin->ParameterChanged.connect (bind (mem_fun(*this, &LadspaPluginUI::parameter_changed), control_ui));
insert->automation_list (port_index).automation_state_changed.connect
(bind (mem_fun(*this, &LadspaPluginUI::automation_state_changed), control_ui));
} else if (plugin->parameter_is_output (port_index)) {
control_ui->display = manage (new EventBox);
control_ui->display->set_name ("ParameterValueDisplay");
control_ui->display_label = manage (new Label);
control_ui->display_label->set_name ("ParameterValueDisplay");
control_ui->display->add (*control_ui->display_label);
Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->display, "-99,99", 2, 2);
control_ui->display->show_all ();
/* set up a meter */
/* TODO: only make a meter if the port is Hinted for it */
MeterInfo * info = new MeterInfo(port_index);
control_ui->meterinfo = info;
info->meter = new FastMeter (5, 100, FastMeter::Vertical);
info->min_unbound = desc.min_unbound;
info->max_unbound = desc.max_unbound;
info->min = desc.lower;
info->max = desc.upper;
control_ui->vbox = manage (new VBox);
control_ui->hbox = manage (new HBox);
control_ui->label.set_angle(90);
control_ui->hbox->pack_start (control_ui->label, false, false);
control_ui->hbox->pack_start (*info->meter, false, false);
control_ui->vbox->pack_start (*control_ui->hbox, false, false);
control_ui->vbox->pack_start (*control_ui->display, false, false);
control_ui->pack_start (*control_ui->vbox);
control_ui->meterinfo->meter->show_all();
control_ui->meterinfo->packed = true;
output_controls.push_back (control_ui);
}
plugin->ParameterChanged.connect (bind (mem_fun(*this, &LadspaPluginUI::parameter_changed), control_ui));
return control_ui;
}
void
LadspaPluginUI::start_touch (LadspaPluginUI::ControlUI* cui)
{
insert->automation_list (cui->port_index).start_touch ();
}
void
LadspaPluginUI::stop_touch (LadspaPluginUI::ControlUI* cui)
{
insert->automation_list (cui->port_index).stop_touch ();
}
void
LadspaPluginUI::astate_clicked (ControlUI* cui, uint32_t port)
{
using namespace Menu_Helpers;
if (automation_menu == 0) {
automation_menu = manage (new Menu);
automation_menu->set_name ("ArdourContextMenu");
}
MenuList& items (automation_menu->items());
items.clear ();
items.push_back (MenuElem (_("Off"),
bind (mem_fun(*this, &LadspaPluginUI::set_automation_state), (AutoState) Off, cui)));
items.push_back (MenuElem (_("Play"),
bind (mem_fun(*this, &LadspaPluginUI::set_automation_state), (AutoState) Play, cui)));
items.push_back (MenuElem (_("Write"),
bind (mem_fun(*this, &LadspaPluginUI::set_automation_state), (AutoState) Write, cui)));
items.push_back (MenuElem (_("Touch"),
bind (mem_fun(*this, &LadspaPluginUI::set_automation_state), (AutoState) Touch, cui)));
automation_menu->popup (1, 0);
}
void
LadspaPluginUI::set_automation_state (AutoState state, ControlUI* cui)
{
insert->set_port_automation_state (cui->port_index, state);
}
void
LadspaPluginUI::control_adjustment_changed (ControlUI* cui)
{
if (cui->ignore_change) {
return;
}
double value = cui->adjustment->get_value();
if (cui->logarithmic) {
value = exp(value);
}
insert->set_parameter (cui->port_index, (float) value);
}
void
LadspaPluginUI::parameter_changed (uint32_t abs_port_id, float val, ControlUI* cui)
{
if (cui->port_index == abs_port_id) {
if (!cui->update_pending) {
cui->update_pending = true;
Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun(*this, &LadspaPluginUI::update_control_display), cui));
}
}
}
void
LadspaPluginUI::update_control_display (ControlUI* cui)
{
/* XXX how do we handle logarithmic stuff here ? */
cui->update_pending = false;
float val = plugin->get_parameter (cui->port_index);
cui->ignore_change++;
if (cui->combo) {
std::map<string,float>::iterator it;
for (it = cui->combo_map->begin(); it != cui->combo_map->end(); ++it) {
if (it->second == val) {
cui->combo->set_active_text(it->first);
break;
}
}
} else if (cui->adjustment == 0) {
if (val > 0.5) {
cui->button->set_active (true);
} else {
cui->button->set_active (false);
}
} else {
if (cui->logarithmic) {
val = log(val);
}
if (val != cui->adjustment->get_value()) {
cui->adjustment->set_value (val);
}
}
cui->ignore_change--;
}
void
LadspaPluginUI::control_port_toggled (ControlUI* cui)
{
if (!cui->ignore_change) {
insert->set_parameter (cui->port_index, cui->button->get_active());
}
}
void
LadspaPluginUI::control_combo_changed (ControlUI* cui)
{
if (!cui->ignore_change) {
string value = cui->combo->get_active_text();
std::map<string,float> mapping = *cui->combo_map;
insert->set_parameter (cui->port_index, mapping[value]);
}
}
void
LadspaPluginUI::redirect_active_changed (Redirect* r, void* src)
{
ENSURE_GUI_THREAD(bind (mem_fun(*this, &LadspaPluginUI::redirect_active_changed), r, src));
bypass_button.set_active (!r->active());
}
bool
LadspaPluginUI::start_updating (GdkEventAny* ignored)
{
if (output_controls.size() > 0 ) {
screen_update_connection.disconnect();
screen_update_connection = ARDOUR_UI::instance()->RapidScreenUpdate.connect
(mem_fun(*this, &LadspaPluginUI::output_update));
}
return false;
}
bool
LadspaPluginUI::stop_updating (GdkEventAny* ignored)
{
if (output_controls.size() > 0 ) {
screen_update_connection.disconnect();
}
return false;
}
void
LadspaPluginUI::output_update ()
{
for (vector<ControlUI*>::iterator i = output_controls.begin(); i != output_controls.end(); ++i) {
float val = plugin->get_parameter ((*i)->port_index);
char buf[32];
snprintf (buf, sizeof(buf), "%.2f", val);
(*i)->display_label->set_text (buf);
/* autoscaling for the meter */
if ((*i)->meterinfo && (*i)->meterinfo->packed) {
if (val < (*i)->meterinfo->min) {
if ((*i)->meterinfo->min_unbound)
(*i)->meterinfo->min = val;
else
val = (*i)->meterinfo->min;
}
if (val > (*i)->meterinfo->max) {
if ((*i)->meterinfo->max_unbound)
(*i)->meterinfo->max = val;
else
val = (*i)->meterinfo->max;
}
if ((*i)->meterinfo->max > (*i)->meterinfo->min ) {
float lval = (val - (*i)->meterinfo->min) / ((*i)->meterinfo->max - (*i)->meterinfo->min) ;
(*i)->meterinfo->meter->set (lval );
}
}
}
}
vector<string>
LadspaPluginUI::setup_scale_values(guint32 port_index, ControlUI* cui)
{
vector<string> enums;
boost::shared_ptr<LadspaPlugin> lp = boost::dynamic_pointer_cast<LadspaPlugin> (plugin);
cui->combo_map = new std::map<string, float>;
lrdf_defaults* defaults = lrdf_get_scale_values(lp->unique_id(), port_index);
if (defaults) {
for (uint32_t i = 0; i < defaults->count; ++i) {
enums.push_back(defaults->items[i].label);
pair<string, float> newpair;
newpair.first = defaults->items[i].label;
newpair.second = defaults->items[i].value;
cui->combo_map->insert(newpair);
}
lrdf_free_setting_values(defaults);
}
return enums;
}

23
gtk2_ardour/new_session_dialog.cc
View file

@ -141,15 +141,17 @@ NewSessionDialog::NewSessionDialog()
advanced_table->attach(*m_control_bus_channel_count, 1, 2, 2, 3, Gtk::AttachOptions(), Gtk::AttachOptions(), 0, 0);
advanced_table->attach(*m_master_bus_channel_count, 1, 2, 1, 2, Gtk::AttachOptions(), Gtk::AttachOptions(), 0, 0);
advanced_table->attach(*m_create_master_bus, 0, 1, 1, 2, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
m_connect_inputs->set_flags(Gtk::CAN_FOCUS);
m_connect_inputs->set_relief(Gtk::RELIEF_NORMAL);
m_connect_inputs->set_mode(true);
m_connect_inputs->set_active(false);
m_connect_inputs->set_active(true);
m_connect_inputs->set_border_width(0);
m_limit_input_ports->set_flags(Gtk::CAN_FOCUS);
m_limit_input_ports->set_relief(Gtk::RELIEF_NORMAL);
m_limit_input_ports->set_mode(true);
m_limit_input_ports->set_sensitive(false);
m_limit_input_ports->set_sensitive(true);
m_limit_input_ports->set_border_width(0);
m_input_limit_count->set_flags(Gtk::CAN_FOCUS);
m_input_limit_count->set_update_policy(Gtk::UPDATE_ALWAYS);
@ -157,6 +159,7 @@ NewSessionDialog::NewSessionDialog()
m_input_limit_count->set_digits(0);
m_input_limit_count->set_wrap(false);
m_input_limit_count->set_sensitive(false);
input_port_limit_hbox->pack_start(*m_limit_input_ports, Gtk::PACK_SHRINK, 6);
input_port_limit_hbox->pack_start(*m_input_limit_count, Gtk::PACK_EXPAND_PADDING, 0);
input_port_vbox->pack_start(*m_connect_inputs, Gtk::PACK_SHRINK, 0);
@ -177,12 +180,12 @@ NewSessionDialog::NewSessionDialog()
m_connect_outputs->set_flags(Gtk::CAN_FOCUS);
m_connect_outputs->set_relief(Gtk::RELIEF_NORMAL);
m_connect_outputs->set_mode(true);
m_connect_outputs->set_active(false);
m_connect_outputs->set_active(true);
m_connect_outputs->set_border_width(0);
m_limit_output_ports->set_flags(Gtk::CAN_FOCUS);
m_limit_output_ports->set_relief(Gtk::RELIEF_NORMAL);
m_limit_output_ports->set_mode(true);
m_limit_output_ports->set_sensitive(false);
m_limit_output_ports->set_sensitive(true);
m_limit_output_ports->set_border_width(0);
m_output_limit_count->set_flags(Gtk::CAN_FOCUS);
m_output_limit_count->set_update_policy(Gtk::UPDATE_ALWAYS);
@ -597,12 +600,24 @@ void
NewSessionDialog::connect_inputs_clicked ()
{
m_limit_input_ports->set_sensitive(m_connect_inputs->get_active());
if (m_connect_inputs->get_active() && m_limit_input_ports->get_active()) {
m_input_limit_count->set_sensitive(true);
} else {
m_input_limit_count->set_sensitive(false);
}
}
void
NewSessionDialog::connect_outputs_clicked ()
{
m_limit_output_ports->set_sensitive(m_connect_outputs->get_active());
if (m_connect_outputs->get_active() && m_limit_output_ports->get_active()) {
m_output_limit_count->set_sensitive(true);
} else {
m_output_limit_count->set_sensitive(false);
}
}
void

2
gtk2_ardour/pan_automation_time_axis.cc
View file

@ -108,7 +108,7 @@ void
PanAutomationTimeAxisView::add_line (AutomationLine& line)
{
char buf[32];
snprintf(buf,32,"Line %u",lines.size()+1);
snprintf(buf,32,"Line %zu",lines.size()+1);
multiline_selector.append_text(buf);
if (lines.empty()) {

53
gtk2_ardour/plugin_selector.cc
View file

@ -49,7 +49,7 @@ PluginSelector::PluginSelector (PluginManager *mgr)
manager = mgr;
session = 0;
current_selection = PluginInfo::LADSPA;
current_selection = ARDOUR::LADSPA;
lmodel = Gtk::ListStore::create(lcols);
ladspa_display.set_model (lmodel);
@ -141,6 +141,7 @@ PluginSelector::PluginSelector (PluginManager *mgr)
set_response_sensitive (RESPONSE_APPLY, false);
get_vbox()->pack_start (*table);
// Notebook tab order must be the same in here as in set_correct_focus()
using namespace Gtk::Notebook_Helpers;
notebook.pages().push_back (TabElem (lscroller, _("LADSPA")));
@ -161,6 +162,7 @@ PluginSelector::PluginSelector (PluginManager *mgr)
ladspa_display.signal_button_press_event().connect_notify (mem_fun(*this, &PluginSelector::row_clicked));
ladspa_display.get_selection()->signal_changed().connect (mem_fun(*this, &PluginSelector::ladspa_display_selection_changed));
ladspa_display.grab_focus();
#ifdef VST_SUPPORT
if (Config->get_use_vst()) {
@ -188,6 +190,43 @@ PluginSelector::PluginSelector (PluginManager *mgr)
#ifdef HAVE_COREAUDIO
au_refiller ();
#endif
signal_show().connect (mem_fun (*this, &PluginSelector::set_correct_focus));
}
/**
* Makes sure keyboard focus is always in the plugin list
* of the selected notebook tab.
**/
void
PluginSelector::set_correct_focus()
{
int cp = notebook.get_current_page();
if (cp == 0) {
ladspa_display.grab_focus();
return;
}
#ifdef VST_SUPPORT
if (Config->get_use_vst()) {
cp--;
if (cp == 0) {
vst_display.grab_focus();
return;
}
}
#endif
#ifdef HAVE_COREAUDIO
cp--;
if (cp == 0) {
au_display.grab_focus();
return;
}
#endif;
}
void
@ -286,7 +325,7 @@ PluginSelector::vst_display_selection_changed()
btn_add->set_sensitive (false);
}
current_selection = PluginInfo::VST;
current_selection = ARDOUR::VST;
}
#endif //VST_SUPPORT
@ -332,7 +371,7 @@ PluginSelector::au_display_selection_changed()
btn_add->set_sensitive (false);
}
current_selection = PluginInfo::AudioUnit;
current_selection = ARDOUR::AudioUnit;
}
#endif //HAVE_COREAUDIO
@ -361,19 +400,19 @@ PluginSelector::btn_add_clicked()
Gtk::TreeModel::Row row;
switch (current_selection) {
case PluginInfo::LADSPA:
case ARDOUR::LADSPA:
row = *(ladspa_display.get_selection()->get_selected());
name = row[lcols.name];
pi = row[lcols.plugin];
break;
case PluginInfo::VST:
case ARDOUR::VST:
#ifdef VST_SUPPORT
row = *(vst_display.get_selection()->get_selected());
name = row[vcols.name];
pi = row[vcols.plugin];
#endif
break;
case PluginInfo::AudioUnit:
case ARDOUR::AudioUnit:
#ifdef HAVE_COREAUDIO
row = *(au_display.get_selection()->get_selected());
name = row[aucols.name];
@ -426,7 +465,7 @@ PluginSelector::ladspa_display_selection_changed()
btn_add->set_sensitive (false);
}
current_selection = PluginInfo::LADSPA;
current_selection = ARDOUR::LADSPA;
}
void

4
gtk2_ardour/plugin_selector.h
View file

@ -50,7 +50,7 @@ class PluginSelector : public ArdourDialog
Gtk::ScrolledWindow auscroller; // AudioUnit
Gtk::ScrolledWindow ascroller; // Added plugins
ARDOUR::PluginInfo::Type current_selection;
ARDOUR::PluginType current_selection;
// page 1
struct LadspaColumns : public Gtk::TreeModel::ColumnRecord {
@ -147,6 +147,8 @@ class PluginSelector : public ArdourDialog
void btn_apply_clicked();
void use_plugin (ARDOUR::PluginInfoPtr);
void cleanup ();
void set_correct_focus();
};
#endif // __ardour_plugin_selector_h__

711
gtk2_ardour/plugin_ui.cc
View file

@ -27,6 +27,7 @@
#include <pbd/xml++.h>
#include <pbd/failed_constructor.h>
#include <gtkmm/widget.h>
#include <gtkmm2ext/click_box.h>
#include <gtkmm2ext/fastmeter.h>
#include <gtkmm2ext/barcontroller.h>
@ -36,7 +37,6 @@
#include <midi++/manager.h>
#include <ardour/audioengine.h>
#include <ardour/plugin.h>
#include <ardour/insert.h>
#include <ardour/ladspa_plugin.h>
@ -51,6 +51,7 @@
#include "plugin_ui.h"
#include "utils.h"
#include "gui_thread.h"
#include "public_editor.h"
#include "i18n.h"
@ -61,7 +62,7 @@ using namespace Gtkmm2ext;
using namespace Gtk;
using namespace sigc;
PluginUIWindow::PluginUIWindow (AudioEngine &engine, boost::shared_ptr<PluginInsert> insert, bool scrollable)
PluginUIWindow::PluginUIWindow (boost::shared_ptr<PluginInsert> insert, bool scrollable)
: ArdourDialog ("plugin ui")
{
if (insert->plugin()->has_editor()) {
@ -90,7 +91,7 @@ PluginUIWindow::PluginUIWindow (AudioEngine &engine, boost::shared_ptr<PluginIns
} else {
LadspaPluginUI* pu = new LadspaPluginUI (engine, insert, scrollable);
LadspaPluginUI* pu = new LadspaPluginUI (insert, scrollable);
_pluginui = pu;
get_vbox()->add (*pu);
@ -111,626 +112,22 @@ PluginUIWindow::PluginUIWindow (AudioEngine &engine, boost::shared_ptr<PluginIns
if (h > 600) h = 600;
set_default_size (450, h);
}
}
PluginUIWindow::~PluginUIWindow ()
{
}
LadspaPluginUI::LadspaPluginUI (AudioEngine &engine, boost::shared_ptr<PluginInsert> pi, bool scrollable)
: PlugUIBase (pi),
engine(engine),
button_table (initial_button_rows, initial_button_cols),
output_table (initial_output_rows, initial_output_cols),
hAdjustment(0.0, 0.0, 0.0),
vAdjustment(0.0, 0.0, 0.0),
scroller_view(hAdjustment, vAdjustment),
automation_menu (0),
is_scrollable(scrollable)
bool
PluginUIWindow::on_key_press_event (GdkEventKey* event)
{
set_name ("PluginEditor");
set_border_width (10);
set_homogeneous (false);
settings_box.set_homogeneous (false);
HBox* constraint_hbox = manage (new HBox);
HBox* smaller_hbox = manage (new HBox);
Label* combo_label = manage (new Label (_("<span size=\"large\">Presets</span>")));
combo_label->set_use_markup (true);
smaller_hbox->pack_start (*combo_label, false, false, 10);
smaller_hbox->pack_start (combo, false, false);
smaller_hbox->pack_start (save_button, false, false);
constraint_hbox->set_spacing (5);
constraint_hbox->pack_start (*smaller_hbox, true, false);
constraint_hbox->pack_end (bypass_button, false, false);
settings_box.pack_end (*constraint_hbox, false, false);
pack_start (settings_box, false, false);
if ( is_scrollable ) {
scroller.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
scroller.set_name ("PluginEditor");
scroller_view.set_name("PluginEditor");
scroller_view.add (hpacker);
scroller.add (scroller_view);
pack_start (scroller, true, true);
}
else {
pack_start (hpacker, false, false);
}
insert->active_changed.connect (mem_fun(*this, &LadspaPluginUI::redirect_active_changed));
bypass_button.set_active (!insert->active());
build (engine);
return PublicEditor::instance().on_key_press_event(event);
}
LadspaPluginUI::~LadspaPluginUI ()
bool
PluginUIWindow::on_key_release_event (GdkEventKey* event)
{
if (output_controls.size() > 0) {
screen_update_connection.disconnect();
}
}
void
LadspaPluginUI::build (AudioEngine &engine)
{
guint32 i = 0;
guint32 x = 0;
Frame* frame;
Frame* bt_frame;
VBox* box;
int output_row, output_col;
int button_row, button_col;
int output_rows, output_cols;
int button_rows, button_cols;
guint32 n_ins=0, n_outs = 0;
prefheight = 30;
hpacker.set_spacing (10);
output_rows = initial_output_rows;
output_cols = initial_output_cols;
button_rows = initial_button_rows;
button_cols = initial_button_cols;
output_row = 0;
button_row = 0;
output_col = 0;
button_col = 0;
button_table.set_homogeneous (false);
button_table.set_row_spacings (2);
button_table.set_col_spacings (2);
output_table.set_homogeneous (true);
output_table.set_row_spacings (2);
output_table.set_col_spacings (2);
button_table.set_border_width (5);
output_table.set_border_width (5);
hpacker.set_border_width (10);
bt_frame = manage (new Frame);
bt_frame->set_name ("BaseFrame");
bt_frame->add (button_table);
hpacker.pack_start(*bt_frame, true, true);
box = manage (new VBox);
box->set_border_width (5);
box->set_spacing (1);
frame = manage (new Frame);
frame->set_name ("BaseFrame");
frame->set_label (_("Controls"));
frame->add (*box);
hpacker.pack_start(*frame, true, true);
/* find all ports. build control elements for all appropriate control ports */
for (i = 0; i < plugin->parameter_count(); ++i) {
if (plugin->parameter_is_control (i)) {
/* Don't show latency control ports */
if (plugin->describe_parameter (i) == X_("latency")) {
continue;
}
ControlUI* cui;
/* if we are scrollable, just use one long column */
if (!is_scrollable) {
if (x++ > 7){
frame = manage (new Frame);
frame->set_name ("BaseFrame");
box = manage (new VBox);
box->set_border_width (5);
box->set_spacing (1);
frame->add (*box);
hpacker.pack_start(*frame,true,true);
x = 0;
}
}
if ((cui = build_control_ui (engine, i, plugin->get_nth_control (i))) == 0) {
error << string_compose(_("Plugin Editor: could not build control element for port %1"), i) << endmsg;
continue;
}
if (cui->control || cui->clickbox || cui->combo) {
box->pack_start (*cui, false, false);
} else if (cui->button) {
if (button_row == button_rows) {
button_row = 0;
if (++button_col == button_cols) {
button_cols += 2;
button_table.resize (button_rows, button_cols);
}
}
button_table.attach (*cui, button_col, button_col + 1, button_row, button_row+1,
FILL|EXPAND, FILL);
button_row++;
} else if (cui->display) {
output_table.attach (*cui, output_col, output_col + 1, output_row, output_row+1,
FILL|EXPAND, FILL);
// TODO: The meters should be divided into multiple rows
if (++output_col == output_cols) {
output_cols ++;
output_table.resize (output_rows, output_cols);
}
/* old code, which divides meters into
* columns first, rows later. New code divides into one row
if (output_row == output_rows) {
output_row = 0;
if (++output_col == output_cols) {
output_cols += 2;
output_table.resize (output_rows, output_cols);
}
}
output_table.attach (*cui, output_col, output_col + 1, output_row, output_row+1,
FILL|EXPAND, FILL);
output_row++;
*/
}
/* HACK: ideally the preferred height would be queried from
the complete hpacker, but I can't seem to get that
information in time, so this is an estimation
*/
prefheight += 30;
}
}
n_ins = plugin->get_info()->n_inputs;
n_outs = plugin->get_info()->n_outputs;
if (box->children().empty()) {
hpacker.remove (*frame);
}
if (button_table.children().empty()) {
hpacker.remove (*bt_frame);
}
if (!output_table.children().empty()) {
frame = manage (new Frame);
frame->set_name ("BaseFrame");
frame->add (output_table);
hpacker.pack_end (*frame, true, true);
}
output_update ();
output_table.show_all ();
button_table.show_all ();
}
LadspaPluginUI::ControlUI::ControlUI ()
: automate_button (X_("")) // force creation of a label
{
automate_button.set_name ("PluginAutomateButton");
ARDOUR_UI::instance()->tooltips().set_tip (automate_button,
_("Automation control"));
/* don't fix the height, it messes up the bar controllers */
set_size_request_to_display_given_text (automate_button, X_("lngnuf"), 2, 2);
ignore_change = 0;
display = 0;
button = 0;
control = 0;
clickbox = 0;
adjustment = 0;
meterinfo = 0;
}
LadspaPluginUI::ControlUI::~ControlUI()
{
if (adjustment) {
delete adjustment;
}
if (meterinfo) {
delete meterinfo->meter;
delete meterinfo;
}
}
void
LadspaPluginUI::automation_state_changed (ControlUI* cui)
{
/* update button label */
switch (insert->get_port_automation_state (cui->port_index) & (Off|Play|Touch|Write)) {
case Off:
cui->automate_button.set_label (_("Off"));
break;
case Play:
cui->automate_button.set_label (_("Play"));
break;
case Write:
cui->automate_button.set_label (_("Write"));
break;
case Touch:
cui->automate_button.set_label (_("Touch"));
break;
default:
cui->automate_button.set_label (_("???"));
break;
}
}
static void integer_printer (char buf[32], Adjustment &adj, void *arg)
{
snprintf (buf, 32, "%.0f", adj.get_value());
}
void
LadspaPluginUI::print_parameter (char *buf, uint32_t len, uint32_t param)
{
plugin->print_parameter (param, buf, len);
}
LadspaPluginUI::ControlUI*
LadspaPluginUI::build_control_ui (AudioEngine &engine, guint32 port_index, PBD::Controllable* mcontrol)
{
ControlUI* control_ui;
Plugin::ParameterDescriptor desc;
plugin->get_parameter_descriptor (port_index, desc);
control_ui = manage (new ControlUI ());
control_ui->adjustment = 0;
control_ui->combo = 0;
control_ui->combo_map = 0;
control_ui->port_index = port_index;
control_ui->update_pending = false;
control_ui->label.set_text (desc.label);
control_ui->label.set_alignment (0.0, 0.5);
control_ui->label.set_name ("PluginParameterLabel");
control_ui->set_spacing (5);
if (plugin->parameter_is_input (port_index)) {
boost::shared_ptr<LadspaPlugin> lp;
if ((lp = boost::dynamic_pointer_cast<LadspaPlugin>(plugin)) != 0) {
lrdf_defaults* defaults = lrdf_get_scale_values(lp->unique_id(), port_index);
if (defaults && defaults->count > 0) {
control_ui->combo = new Gtk::ComboBoxText;
//control_ui->combo->set_value_in_list(true, false);
set_popdown_strings (*control_ui->combo, setup_scale_values(port_index, control_ui));
control_ui->combo->signal_changed().connect (bind (mem_fun(*this, &LadspaPluginUI::control_combo_changed), control_ui));
plugin->ParameterChanged.connect (bind (mem_fun (*this, &LadspaPluginUI::parameter_changed), control_ui));
control_ui->pack_start(control_ui->label, true, true);
control_ui->pack_start(*control_ui->combo, false, true);
update_control_display(control_ui);
lrdf_free_setting_values(defaults);
return control_ui;
}
}
if (desc.toggled) {
/* Build a button */
control_ui->button = manage (new ToggleButton ());
control_ui->button->set_name ("PluginEditorButton");
control_ui->button->set_size_request (20, 20);
control_ui->pack_start (control_ui->label, true, true);
control_ui->pack_start (*control_ui->button, false, true);
control_ui->pack_start (control_ui->automate_button, false, false);
control_ui->button->signal_clicked().connect (bind (mem_fun(*this, &LadspaPluginUI::control_port_toggled), control_ui));
if(plugin->get_parameter (port_index) == 1){
control_ui->button->set_active(true);
}
return control_ui;
}
control_ui->adjustment = new Adjustment (0, 0, 0, 0, 0);
/* XXX this code is not right yet, because it doesn't handle
the absence of bounds in any sensible fashion.
*/
control_ui->adjustment->set_lower (desc.lower);
control_ui->adjustment->set_upper (desc.upper);
control_ui->logarithmic = desc.logarithmic;
if (control_ui->logarithmic) {
if (control_ui->adjustment->get_lower() == 0.0) {
control_ui->adjustment->set_lower (control_ui->adjustment->get_upper()/10000);
}
control_ui->adjustment->set_upper (log(control_ui->adjustment->get_upper()));
control_ui->adjustment->set_lower (log(control_ui->adjustment->get_lower()));
}
float delta = desc.upper - desc.lower;
control_ui->adjustment->set_page_size (delta/100.0);
control_ui->adjustment->set_step_increment (desc.step);
control_ui->adjustment->set_page_increment (desc.largestep);
if (desc.integer_step) {
control_ui->clickbox = new ClickBox (control_ui->adjustment, "PluginUIClickBox");
Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->clickbox, "g9999999", 2, 2);
control_ui->clickbox->set_print_func (integer_printer, 0);
} else {
sigc::slot<void,char*,uint32_t> pslot = sigc::bind (mem_fun(*this, &LadspaPluginUI::print_parameter), (uint32_t) port_index);
control_ui->control = new BarController (*control_ui->adjustment, *mcontrol, pslot);
// should really match the height of the text in the automation button+label
control_ui->control->set_size_request (200, 22);
control_ui->control->set_name (X_("PluginSlider"));
control_ui->control->set_style (BarController::LeftToRight);
control_ui->control->set_use_parent (true);
control_ui->control->StartGesture.connect (bind (mem_fun(*this, &LadspaPluginUI::start_touch), control_ui));
control_ui->control->StopGesture.connect (bind (mem_fun(*this, &LadspaPluginUI::stop_touch), control_ui));
}
if (control_ui->logarithmic) {
control_ui->adjustment->set_value(log(plugin->get_parameter(port_index)));
} else{
control_ui->adjustment->set_value(plugin->get_parameter(port_index));
}
/* XXX memory leak: SliderController not destroyed by ControlUI
destructor, and manage() reports object hierarchy
ambiguity.
*/
control_ui->pack_start (control_ui->label, true, true);
if (desc.integer_step) {
control_ui->pack_start (*control_ui->clickbox, false, false);
} else {
control_ui->pack_start (*control_ui->control, false, false);
}
control_ui->pack_start (control_ui->automate_button, false, false);
control_ui->adjustment->signal_value_changed().connect (bind (mem_fun(*this, &LadspaPluginUI::control_adjustment_changed), control_ui));
control_ui->automate_button.signal_clicked().connect (bind (mem_fun(*this, &LadspaPluginUI::astate_clicked), control_ui, (uint32_t) port_index));
automation_state_changed (control_ui);
plugin->ParameterChanged.connect (bind (mem_fun(*this, &LadspaPluginUI::parameter_changed), control_ui));
insert->automation_list (port_index).automation_state_changed.connect
(bind (mem_fun(*this, &LadspaPluginUI::automation_state_changed), control_ui));
} else if (plugin->parameter_is_output (port_index)) {
control_ui->display = manage (new EventBox);
control_ui->display->set_name ("ParameterValueDisplay");
control_ui->display_label = manage (new Label);
control_ui->display_label->set_name ("ParameterValueDisplay");
control_ui->display->add (*control_ui->display_label);
Gtkmm2ext::set_size_request_to_display_given_text (*control_ui->display, "-99,99", 2, 2);
control_ui->display->show_all ();
/* set up a meter */
/* TODO: only make a meter if the port is Hinted for it */
MeterInfo * info = new MeterInfo(port_index);
control_ui->meterinfo = info;
info->meter = new FastMeter (5, 100, FastMeter::Vertical);
info->min_unbound = desc.min_unbound;
info->max_unbound = desc.max_unbound;
info->min = desc.lower;
info->max = desc.upper;
control_ui->vbox = manage (new VBox);
control_ui->hbox = manage (new HBox);
control_ui->label.set_angle(90);
control_ui->hbox->pack_start (control_ui->label, false, false);
control_ui->hbox->pack_start (*info->meter, false, false);
control_ui->vbox->pack_start (*control_ui->hbox, false, false);
control_ui->vbox->pack_start (*control_ui->display, false, false);
control_ui->pack_start (*control_ui->vbox);
control_ui->meterinfo->meter->show_all();
control_ui->meterinfo->packed = true;
output_controls.push_back (control_ui);
}
plugin->ParameterChanged.connect (bind (mem_fun(*this, &LadspaPluginUI::parameter_changed), control_ui));
return control_ui;
}
void
LadspaPluginUI::start_touch (LadspaPluginUI::ControlUI* cui)
{
insert->automation_list (cui->port_index).start_touch ();
}
void
LadspaPluginUI::stop_touch (LadspaPluginUI::ControlUI* cui)
{
insert->automation_list (cui->port_index).stop_touch ();
}
void
LadspaPluginUI::astate_clicked (ControlUI* cui, uint32_t port)
{
using namespace Menu_Helpers;
if (automation_menu == 0) {
automation_menu = manage (new Menu);
automation_menu->set_name ("ArdourContextMenu");
}
MenuList& items (automation_menu->items());
items.clear ();
items.push_back (MenuElem (_("Off"),
bind (mem_fun(*this, &LadspaPluginUI::set_automation_state), (AutoState) Off, cui)));
items.push_back (MenuElem (_("Play"),
bind (mem_fun(*this, &LadspaPluginUI::set_automation_state), (AutoState) Play, cui)));
items.push_back (MenuElem (_("Write"),
bind (mem_fun(*this, &LadspaPluginUI::set_automation_state), (AutoState) Write, cui)));
items.push_back (MenuElem (_("Touch"),
bind (mem_fun(*this, &LadspaPluginUI::set_automation_state), (AutoState) Touch, cui)));
automation_menu->popup (1, 0);
}
void
LadspaPluginUI::set_automation_state (AutoState state, ControlUI* cui)
{
insert->set_port_automation_state (cui->port_index, state);
}
void
LadspaPluginUI::control_adjustment_changed (ControlUI* cui)
{
if (cui->ignore_change) {
return;
}
double value = cui->adjustment->get_value();
if (cui->logarithmic) {
value = exp(value);
}
insert->set_parameter (cui->port_index, (float) value);
}
void
LadspaPluginUI::parameter_changed (uint32_t abs_port_id, float val, ControlUI* cui)
{
if (cui->port_index == abs_port_id) {
if (!cui->update_pending) {
cui->update_pending = true;
Gtkmm2ext::UI::instance()->call_slot (bind (mem_fun(*this, &LadspaPluginUI::update_control_display), cui));
}
}
}
void
LadspaPluginUI::update_control_display (ControlUI* cui)
{
/* XXX how do we handle logarithmic stuff here ? */
cui->update_pending = false;
float val = plugin->get_parameter (cui->port_index);
cui->ignore_change++;
if (cui->combo) {
std::map<string,float>::iterator it;
for (it = cui->combo_map->begin(); it != cui->combo_map->end(); ++it) {
if (it->second == val) {
cui->combo->set_active_text(it->first);
break;
}
}
} else if (cui->adjustment == 0) {
if (val > 0.5) {
cui->button->set_active (true);
} else {
cui->button->set_active (false);
}
} else {
if (cui->logarithmic) {
val = log(val);
}
if (val != cui->adjustment->get_value()) {
cui->adjustment->set_value (val);
}
}
cui->ignore_change--;
}
void
LadspaPluginUI::control_port_toggled (ControlUI* cui)
{
if (!cui->ignore_change) {
insert->set_parameter (cui->port_index, cui->button->get_active());
}
}
void
LadspaPluginUI::control_combo_changed (ControlUI* cui)
{
if (!cui->ignore_change) {
string value = cui->combo->get_active_text();
std::map<string,float> mapping = *cui->combo_map;
insert->set_parameter (cui->port_index, mapping[value]);
}
return PublicEditor::instance().on_key_release_event(event);
}
void
@ -742,91 +139,6 @@ PluginUIWindow::plugin_going_away (ARDOUR::Redirect* ignored)
delete_when_idle (this);
}
void
LadspaPluginUI::redirect_active_changed (Redirect* r, void* src)
{
ENSURE_GUI_THREAD(bind (mem_fun(*this, &LadspaPluginUI::redirect_active_changed), r, src));
bypass_button.set_active (!r->active());
}
bool
LadspaPluginUI::start_updating (GdkEventAny* ignored)
{
if (output_controls.size() > 0 ) {
screen_update_connection.disconnect();
screen_update_connection = ARDOUR_UI::instance()->RapidScreenUpdate.connect
(mem_fun(*this, &LadspaPluginUI::output_update));
}
return false;
}
bool
LadspaPluginUI::stop_updating (GdkEventAny* ignored)
{
if (output_controls.size() > 0 ) {
screen_update_connection.disconnect();
}
return false;
}
void
LadspaPluginUI::output_update ()
{
for (vector<ControlUI*>::iterator i = output_controls.begin(); i != output_controls.end(); ++i) {
float val = plugin->get_parameter ((*i)->port_index);
char buf[32];
snprintf (buf, sizeof(buf), "%.2f", val);
(*i)->display_label->set_text (buf);
/* autoscaling for the meter */
if ((*i)->meterinfo && (*i)->meterinfo->packed) {
if (val < (*i)->meterinfo->min) {
if ((*i)->meterinfo->min_unbound)
(*i)->meterinfo->min = val;
else
val = (*i)->meterinfo->min;
}
if (val > (*i)->meterinfo->max) {
if ((*i)->meterinfo->max_unbound)
(*i)->meterinfo->max = val;
else
val = (*i)->meterinfo->max;
}
if ((*i)->meterinfo->max > (*i)->meterinfo->min ) {
float lval = (val - (*i)->meterinfo->min) / ((*i)->meterinfo->max - (*i)->meterinfo->min) ;
(*i)->meterinfo->meter->set (lval );
}
}
}
}
vector<string>
LadspaPluginUI::setup_scale_values(guint32 port_index, ControlUI* cui)
{
vector<string> enums;
boost::shared_ptr<LadspaPlugin> lp = boost::dynamic_pointer_cast<LadspaPlugin> (plugin);
cui->combo_map = new std::map<string, float>;
lrdf_defaults* defaults = lrdf_get_scale_values(lp->unique_id(), port_index);
if (defaults) {
for (uint32_t i = 0; i < defaults->count; ++i) {
enums.push_back(defaults->items[i].label);
pair<string, float> newpair;
newpair.first = defaults->items[i].label;
newpair.second = defaults->items[i].value;
cui->combo_map->insert(newpair);
}
lrdf_free_setting_values(defaults);
}
return enums;
}
PlugUIBase::PlugUIBase (boost::shared_ptr<PluginInsert> pi)
: insert (pi),
plugin (insert->plugin()),
@ -893,4 +205,3 @@ PlugUIBase::bypass_toggled ()
insert->set_active (!x, this);
}
}

22
gtk2_ardour/plugin_ui.h
View file

@ -45,7 +45,6 @@
#include <ardour/types.h>
namespace ARDOUR {
class AudioEngine;
class PluginInsert;
class Plugin;
class VSTPlugin;
@ -90,7 +89,7 @@ class PlugUIBase : public virtual sigc::trackable
class LadspaPluginUI : public PlugUIBase, public Gtk::VBox
{
public:
LadspaPluginUI (ARDOUR::AudioEngine &, boost::shared_ptr<ARDOUR::PluginInsert> plug, bool scrollable=false);
LadspaPluginUI (boost::shared_ptr<ARDOUR::PluginInsert> plug, bool scrollable=false);
~LadspaPluginUI ();
gint get_preferred_height () { return prefheight; }
@ -99,7 +98,6 @@ class LadspaPluginUI : public PlugUIBase, public Gtk::VBox
bool stop_updating(GdkEventAny*);
private:
ARDOUR::AudioEngine &engine;
Gtk::HBox settings_box;
Gtk::HBox hpacker;
@ -174,8 +172,8 @@ class LadspaPluginUI : public PlugUIBase, public Gtk::VBox
sigc::connection screen_update_connection;
void output_update();
void build (ARDOUR::AudioEngine &);
ControlUI* build_control_ui (ARDOUR::AudioEngine &, guint32 port_index, PBD::Controllable *);
void build ();
ControlUI* build_control_ui (guint32 port_index, PBD::Controllable *);
std::vector<string> setup_scale_values(guint32 port_index, ControlUI* cui);
void control_adjustment_changed (ControlUI* cui);
void parameter_changed (uint32_t, float, ControlUI* cui);
@ -197,19 +195,21 @@ class LadspaPluginUI : public PlugUIBase, public Gtk::VBox
class PluginUIWindow : public ArdourDialog
{
public:
PluginUIWindow (ARDOUR::AudioEngine &, boost::shared_ptr<ARDOUR::PluginInsert> insert, bool scrollable=false);
PluginUIWindow (boost::shared_ptr<ARDOUR::PluginInsert> insert, bool scrollable=false);
~PluginUIWindow ();
PlugUIBase& pluginui() { return *_pluginui; }
void resize_preferred();
virtual bool on_key_press_event (GdkEventKey*);
virtual bool on_key_release_event (GdkEventKey*);
private:
PlugUIBase* _pluginui;
void plugin_going_away (ARDOUR::Redirect*);
};
#ifdef VST_SUPPORT
class VSTPluginUI : public PlugUIBase, public Gtk::VBox
{
@ -235,16 +235,12 @@ class VSTPluginUI : public PlugUIBase, public Gtk::VBox
#endif // VST_SUPPORT
#ifdef HAVE_COREAUDIO
class AUPluginUI : public PlugUIBase
class AUPluginUI
{
public:
AUPluginUI (boost::shared_ptr<ARDOUR::PluginInsert>, boost::shared_ptr<ARDOUR::AUPlugin>);
AUPluginUI (boost::shared_ptr<ARDOUR::PluginInsert>);
~AUPluginUI ();
gint get_preferred_height ();
bool start_updating(GdkEventAny*) {return false;}
bool stop_updating(GdkEventAny*) {return false;}
private:
boost::shared_ptr<ARDOUR::AUPlugin> au;
};

3
gtk2_ardour/public_editor.h
View file

@ -31,6 +31,7 @@ namespace Gtk {
class Editor;
class TimeAxisViewItem;
class TimeAxisView;
class PluginUIWindow;
class PluginSelector;
class PlaylistSelector;
class XMLNode;
@ -171,6 +172,8 @@ class PublicEditor : public Gtk::Window, public Stateful {
virtual bool canvas_markerview_end_handle_event(GdkEvent* event, ArdourCanvas::Item*,MarkerView*) = 0;
static PublicEditor* _instance;
friend class PluginUIWindow;
};
#endif // __gtk_ardour_public_editor_h__

19
gtk2_ardour/redirect_box.cc
View file

@ -957,6 +957,9 @@ RedirectBox::edit_redirect (boost::shared_ptr<Redirect> redirect)
if ((plugin_insert = boost::dynamic_pointer_cast<PluginInsert> (insert)) != 0) {
ARDOUR::PluginType type = plugin_insert->type();
if (type == ARDOUR::LADSPA || type == ARDOUR::VST) {
PluginUIWindow *plugin_ui;
if (plugin_insert->get_gui() == 0) {
@ -976,7 +979,7 @@ RedirectBox::edit_redirect (boost::shared_ptr<Redirect> redirect)
title = string_compose(_("ardour: %1: %2 (by %3)"), _route->name(), plugin_insert->name(), maker);
plugin_ui = new PluginUIWindow (_session.engine(), plugin_insert);
plugin_ui = new PluginUIWindow (plugin_insert);
if (_owner_is_mixer) {
ARDOUR_UI::instance()->the_mixer()->ensure_float (*plugin_ui);
} else {
@ -994,7 +997,21 @@ RedirectBox::edit_redirect (boost::shared_ptr<Redirect> redirect)
} else {
plugin_ui->show_all ();
}
#ifdef HAVE_COREAUDIO
} else if (type == ARDOUR::AudioUnit) {
AUPluginUI* plugin_ui;
if (plugin_insert->get_gui() == 0) {
plugin_ui = new AUPluginUI (plugin_insert);
} else {
plugin_ui = reinterpret_cast<AUPluginUI*> (plugin_insert->get_gui());
}
// raise window, somehow
#endif
} else {
warning << "Unsupported plugin sent to RedirectBox::edit_redirect()" << endmsg;
return;
}
} else if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (insert)) != 0) {
if (!_session.engine().connected()) {

2
gtk2_ardour/route_params_ui.cc
View file

@ -556,7 +556,7 @@ RouteParams_UI::redirect_selected (boost::shared_ptr<ARDOUR::Redirect> redirect,
if ((plugin_insert = boost::dynamic_pointer_cast<PluginInsert> (insert)) != 0) {
LadspaPluginUI *plugin_ui = new LadspaPluginUI (session->engine(), plugin_insert, true);
LadspaPluginUI *plugin_ui = new LadspaPluginUI (plugin_insert, true);
if (place == PreFader) {
cleanup_pre_view();

9
libs/ardour/ardour/audio_diskstream.h
View file

@ -211,11 +211,11 @@ class AudioDiskstream : public Diskstream
/* The two central butler operations */
int do_flush (Session::RunContext context, bool force = false);
int do_refill () { return _do_refill(_mixdown_buffer, _gain_buffer, _conversion_buffer); }
int do_refill () { return _do_refill(_mixdown_buffer, _gain_buffer); }
int do_refill_with_alloc();
int read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, char * workbuf,
int read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
jack_nframes_t& start, jack_nframes_t cnt,
ChannelInfo& channel_info, int channel, bool reversed);
@ -251,10 +251,9 @@ class AudioDiskstream : public Diskstream
static size_t _working_buffers_size;
static Sample* _mixdown_buffer;
static gain_t* _gain_buffer;
static char* _conversion_buffer;
// Uh, /really/ private? (death to friend classes)
int _do_refill (Sample *mixdown_buffer, float *gain_buffer, char *workbuf);
// Uh, /really/ private? (there should probably be less friends of Diskstream)
int _do_refill (Sample *mixdown_buffer, float *gain_buffer);
std::vector<AudioFileSource*> capturing_sources;

2
libs/ardour/ardour/audio_track.h
View file

@ -51,7 +51,7 @@ class AudioTrack : public Track
int use_diskstream (string name);
int use_diskstream (const PBD::ID& id);
int export_stuff (vector<Sample*>& buffers, char * workbuf, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t end_frame);
int export_stuff (vector<Sample*>& buffers, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t end_frame);
void freeze (InterThreadInfo&);
void unfreeze ();

2
libs/ardour/ardour/audio_unit.h
View file

@ -96,6 +96,8 @@ class AUPlugin : public ARDOUR::Plugin
std::vector<std::pair<uint32_t, uint32_t> > parameter_map;
};
typedef boost::shared_ptr<AUPlugin> AUPluginPtr;
class AUPluginInfo : public PluginInfo {
public:
AUPluginInfo () { };

2
libs/ardour/ardour/audioplaylist.h
View file

@ -60,7 +60,7 @@ class AudioPlaylist : public ARDOUR::Playlist
void clear (bool with_delete = false, bool with_save = true);
jack_nframes_t read (Sample *dst, Sample *mixdown, float *gain_buffer, char * workbuf, jack_nframes_t start, jack_nframes_t cnt, uint32_t chan_n=0);
jack_nframes_t read (Sample *dst, Sample *mixdown, float *gain_buffer, jack_nframes_t start, jack_nframes_t cnt, uint32_t chan_n=0);
int set_state (const XMLNode&);
UndoAction get_memento() const;

6
libs/ardour/ardour/audioregion.h
View file

@ -106,13 +106,13 @@ class AudioRegion : public Region
uint32_t chan_n=0, double samples_per_unit= 1.0) const;
virtual jack_nframes_t read_at (Sample *buf, Sample *mixdown_buf,
float *gain_buf, char * workbuf, jack_nframes_t position, jack_nframes_t cnt,
float *gain_buf, jack_nframes_t position, jack_nframes_t cnt,
uint32_t chan_n = 0,
jack_nframes_t read_frames = 0,
jack_nframes_t skip_frames = 0) const;
jack_nframes_t master_read_at (Sample *buf, Sample *mixdown_buf,
float *gain_buf, char * workbuf,
float *gain_buf,
jack_nframes_t position, jack_nframes_t cnt, uint32_t chan_n=0) const;
XMLNode& state (bool);
@ -177,7 +177,7 @@ class AudioRegion : public Region
void recompute_gain_at_start ();
jack_nframes_t _read_at (const SourceList&, Sample *buf, Sample *mixdown_buffer,
float *gain_buffer, char * workbuf, jack_nframes_t position, jack_nframes_t cnt,
float *gain_buffer, jack_nframes_t position, jack_nframes_t cnt,
uint32_t chan_n = 0,
jack_nframes_t read_frames = 0,
jack_nframes_t skip_frames = 0) const;

8
libs/ardour/ardour/audiosource.h
View file

@ -66,8 +66,8 @@ class AudioSource : public Source
virtual jack_nframes_t available_peaks (double zoom) const;
virtual jack_nframes_t read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const;
virtual jack_nframes_t write (Sample *src, jack_nframes_t cnt, char * workbuf);
virtual jack_nframes_t read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const;
virtual jack_nframes_t write (Sample *src, jack_nframes_t cnt);
virtual float sample_rate () const = 0;
@ -124,8 +124,8 @@ class AudioSource : public Source
int do_build_peak (jack_nframes_t, jack_nframes_t);
virtual jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const = 0;
virtual jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt, char * workbuf) = 0;
virtual jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const = 0;
virtual jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt) = 0;
virtual string peak_path(string audio_path) = 0;
virtual string old_peak_path(string audio_path) = 0;

4
libs/ardour/ardour/coreaudiosource.h
View file

@ -38,9 +38,9 @@ class CoreAudioSource : public AudioFileSource {
void set_header_timeline_position () {};
protected:
jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const;
jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const;
jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt, char * workbuf)
jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt)
{ return 0; }

2
libs/ardour/ardour/crossfade.h
View file

@ -92,7 +92,7 @@ class Crossfade : public Stateful, public StateManager
ARDOUR::AudioRegion& out() const { return *_out; }
jack_nframes_t read_at (Sample *buf, Sample *mixdown_buffer,
float *gain_buffer, char * workbuf, jack_nframes_t position, jack_nframes_t cnt,
float *gain_buffer, jack_nframes_t position, jack_nframes_t cnt,
uint32_t chan_n,
jack_nframes_t read_frames = 0,
jack_nframes_t skip_frames = 0);

4
libs/ardour/ardour/destructive_filesource.h
View file

@ -49,7 +49,7 @@ class DestructiveFileSource : public SndFileSource {
static void setup_standard_crossfades (jack_nframes_t sample_rate);
protected:
jack_nframes_t write_unlocked (Sample *src, jack_nframes_t cnt, char * workbuf);
jack_nframes_t write_unlocked (Sample *src, jack_nframes_t cnt);
virtual void handle_header_position_change ();
@ -65,7 +65,7 @@ class DestructiveFileSource : public SndFileSource {
Sample* xfade_buf;
void init ();
jack_nframes_t crossfade (Sample* data, jack_nframes_t cnt, int dir, char * workbuf);
jack_nframes_t crossfade (Sample* data, jack_nframes_t cnt, int dir);
void set_timeline_position (jack_nframes_t);
};

5
libs/ardour/ardour/insert.h
View file

@ -29,6 +29,7 @@
#include <ardour/ardour.h>
#include <ardour/redirect.h>
#include <ardour/plugin_state.h>
#include <ardour/types.h>
class XMLNode;
@ -39,8 +40,8 @@ namespace MIDI {
namespace ARDOUR {
class Session;
class Plugin;
class Route;
class Plugin;
class Insert : public Redirect
{
@ -149,6 +150,8 @@ class PluginInsert : public Insert
}
}
PluginType type ();
string describe_parameter (uint32_t);
jack_nframes_t latency();

11
libs/ardour/ardour/plugin.h
View file

@ -47,16 +47,11 @@ class AudioEngine;
class Session;
class Plugin;
typedef boost::shared_ptr<Plugin> PluginPtr;
class PluginInfo {
public:
enum Type {
AudioUnit,
LADSPA,
VST
};
PluginInfo () { }
PluginInfo (const PluginInfo &o)
: name(o.name), n_inputs(o.n_inputs), n_outputs(o.n_outputs),
@ -67,7 +62,7 @@ class PluginInfo {
string category;
uint32_t n_inputs;
uint32_t n_outputs;
Type type;
ARDOUR::PluginType type;
long unique_id;
@ -187,7 +182,7 @@ class Plugin : public Stateful, public sigc::trackable
vector<PortControllable*> controls;
};
PluginPtr find_plugin(ARDOUR::Session&, string name, long unique_id, PluginInfo::Type);
PluginPtr find_plugin(ARDOUR::Session&, string name, long unique_id, ARDOUR::PluginType);
} // namespace ARDOUR

3
libs/ardour/ardour/session.h
View file

@ -974,8 +974,6 @@ class Session : public sigc::trackable, public Stateful
ExportContext
};
char * conversion_buffer(RunContext context) { return _conversion_buffers[context]; }
/* VST support */
static long vst_callback (AEffect* effect,
@ -1059,7 +1057,6 @@ class Session : public sigc::trackable, public Stateful
vector<Sample *> _passthru_buffers;
vector<Sample *> _silent_buffers;
vector<Sample *> _send_buffers;
map<RunContext,char*> _conversion_buffers;
jack_nframes_t current_block_size;
jack_nframes_t _worst_output_latency;
jack_nframes_t _worst_input_latency;

4
libs/ardour/ardour/sndfilesource.h
View file

@ -56,8 +56,8 @@ class SndFileSource : public AudioFileSource {
protected:
void set_header_timeline_position ();
jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const;
jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt, char * workbuf);
jack_nframes_t read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const;
jack_nframes_t write_unlocked (Sample *dst, jack_nframes_t cnt);
jack_nframes_t write_float (Sample* data, jack_nframes_t pos, jack_nframes_t cnt);

10
libs/ardour/ardour/types.h
View file

@ -243,7 +243,14 @@ namespace ARDOUR {
PeakDatum min;
PeakDatum max;
};
}
enum PluginType {
AudioUnit,
LADSPA,
VST
};
} // namespace ARDOUR
std::istream& operator>>(std::istream& o, ARDOUR::SampleFormat& sf);
std::istream& operator>>(std::istream& o, ARDOUR::HeaderFormat& sf);
@ -254,7 +261,6 @@ session_frame_to_track_frame (jack_nframes_t session_frame, double speed)
return (jack_nframes_t)( (double)session_frame * speed );
}
static inline jack_nframes_t
track_frame_to_session_frame (jack_nframes_t track_frame, double speed)
{

2
libs/ardour/ardour/vst_plugin.h
View file

@ -113,6 +113,8 @@ class VSTPluginInfo : public PluginInfo
PluginPtr load (Session& session);
};
typedef boost::shared_ptr<VSTPluginInfo> VSTPluginInfoPtr;
} // namespace ARDOUR
#endif /* __ardour_vst_plugin_h__ */

33
libs/ardour/audio_diskstream.cc
View file

@ -58,7 +58,6 @@ using namespace PBD;
size_t AudioDiskstream::_working_buffers_size = 0;
Sample* AudioDiskstream::_mixdown_buffer = 0;
gain_t* AudioDiskstream::_gain_buffer = 0;
char* AudioDiskstream::_conversion_buffer = 0;
AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
: Diskstream(sess, name, flag)
@ -188,7 +187,6 @@ AudioDiskstream::allocate_working_buffers()
_working_buffers_size = disk_io_frames();
_mixdown_buffer = new Sample[_working_buffers_size];
_gain_buffer = new gain_t[_working_buffers_size];
_conversion_buffer = new char[_working_buffers_size * 4];
}
void
@ -196,11 +194,9 @@ AudioDiskstream::free_working_buffers()
{
delete _mixdown_buffer;
delete _gain_buffer;
delete _conversion_buffer;
_working_buffers_size = 0;
_mixdown_buffer = 0;
_gain_buffer = 0;
_conversion_buffer = 0;
}
void
@ -895,7 +891,6 @@ AudioDiskstream::overwrite_existing_buffers ()
{
Sample* mixdown_buffer;
float* gain_buffer;
char * workbuf;
int ret = -1;
bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
@ -906,7 +901,6 @@ AudioDiskstream::overwrite_existing_buffers ()
mixdown_buffer = new Sample[size];
gain_buffer = new float[size];
workbuf = new char[size*4];
/* reduce size so that we can fill the buffer correctly. */
size--;
@ -932,8 +926,7 @@ AudioDiskstream::overwrite_existing_buffers ()
jack_nframes_t to_read = size - overwrite_offset;
if (read ((*chan).playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, workbuf,
start, to_read, *chan, n, reversed)) {
if (read ((*chan).playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
_id, size, playback_sample) << endmsg;
goto out;
@ -943,7 +936,7 @@ AudioDiskstream::overwrite_existing_buffers ()
cnt -= to_read;
if (read ((*chan).playback_buf->buffer(), mixdown_buffer, gain_buffer, workbuf,
if (read ((*chan).playback_buf->buffer(), mixdown_buffer, gain_buffer,
start, cnt, *chan, n, reversed)) {
error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
_id, size, playback_sample) << endmsg;
@ -958,7 +951,6 @@ AudioDiskstream::overwrite_existing_buffers ()
pending_overwrite = false;
delete [] gain_buffer;
delete [] mixdown_buffer;
delete [] workbuf;
return ret;
}
@ -1022,7 +1014,7 @@ AudioDiskstream::internal_playback_seek (jack_nframes_t distance)
}
int
AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, char * workbuf, jack_nframes_t& start, jack_nframes_t cnt,
AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, jack_nframes_t& start, jack_nframes_t cnt,
ChannelInfo& channel_info, int channel, bool reversed)
{
jack_nframes_t this_read = 0;
@ -1079,7 +1071,7 @@ AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
this_read = min(cnt,this_read);
if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, workbuf, start, this_read, channel) != this_read) {
if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
start) << endmsg;
return -1;
@ -1117,19 +1109,17 @@ AudioDiskstream::do_refill_with_alloc()
{
Sample* mix_buf = new Sample[disk_io_chunk_frames];
float* gain_buf = new float[disk_io_chunk_frames];
char* work_buf = new char[disk_io_chunk_frames * 4];
int ret = _do_refill(mix_buf, gain_buf, work_buf);
int ret = _do_refill(mix_buf, gain_buf);
delete [] mix_buf;
delete [] gain_buf;
delete [] work_buf;
return ret;
}
int
AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer, char * workbuf)
AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
{
int32_t ret = 0;
jack_nframes_t to_read;
@ -1143,7 +1133,6 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer, char *
assert(mixdown_buffer);
assert(gain_buffer);
assert(workbuf);
channels.front().playback_buf->get_write_vector (&vector);
@ -1284,7 +1273,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer, char *
if (to_read) {
if (read (buf1, mixdown_buffer, gain_buffer, workbuf, file_frame_tmp, to_read, chan, chan_n, reversed)) {
if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
ret = -1;
goto out;
}
@ -1302,7 +1291,7 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer, char *
so read some or all of vector.len[1] as well.
*/
if (read (buf2, mixdown_buffer, gain_buffer, workbuf, file_frame_tmp, to_read, chan, chan_n, reversed)) {
if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
ret = -1;
goto out;
}
@ -1336,8 +1325,6 @@ AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer, char *
int
AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
{
char* workbuf = _session.conversion_buffer(context);
uint32_t to_write;
int32_t ret = 0;
RingBufferNPT<Sample>::rw_vector vector;
@ -1427,7 +1414,7 @@ AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
}
}
if ((!(*chan).write_source) || (*chan).write_source->write (vector.buf[0], to_write, workbuf) != to_write) {
if ((!(*chan).write_source) || (*chan).write_source->write (vector.buf[0], to_write) != to_write) {
error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
return -1;
}
@ -1444,7 +1431,7 @@ AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
to_write = min ((jack_nframes_t)(disk_io_chunk_frames - to_write), (jack_nframes_t) vector.len[1]);
if ((*chan).write_source->write (vector.buf[1], to_write, workbuf) != to_write) {
if ((*chan).write_source->write (vector.buf[1], to_write) != to_write) {
error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
return -1;
}

6
libs/ardour/audio_playlist.cc
View file

@ -177,7 +177,7 @@ struct RegionSortByLayer {
};
jack_nframes_t
AudioPlaylist::read (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, char * workbuf, jack_nframes_t start,
AudioPlaylist::read (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, jack_nframes_t start,
jack_nframes_t cnt, unsigned chan_n)
{
jack_nframes_t ret = cnt;
@ -250,12 +250,12 @@ AudioPlaylist::read (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, ch
for (vector<Region*>::iterator i = r.begin(); i != r.end(); ++i) {
AudioRegion* const ar = dynamic_cast<AudioRegion*>(*i);
assert(ar);
ar->read_at (buf, mixdown_buffer, gain_buffer, workbuf, start, cnt, chan_n, read_frames, skip_frames);
ar->read_at (buf, mixdown_buffer, gain_buffer, start, cnt, chan_n, read_frames, skip_frames);
_read_data_count += ar->read_data_count();
}
for (vector<Crossfade*>::iterator i = x.begin(); i != x.end(); ++i) {
(*i)->read_at (buf, mixdown_buffer, gain_buffer, workbuf, start, cnt, chan_n);
(*i)->read_at (buf, mixdown_buffer, gain_buffer, start, cnt, chan_n);
/* don't JACK up _read_data_count, since its the same data as we just
read from the regions, and the OS should handle that for us.

6
libs/ardour/audio_track.cc
View file

@ -627,7 +627,7 @@ AudioTrack::silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jac
}
int
AudioTrack::export_stuff (vector<Sample*>& buffers, char * workbuf, uint32_t nbufs, jack_nframes_t start, jack_nframes_t nframes)
AudioTrack::export_stuff (vector<Sample*>& buffers, uint32_t nbufs, jack_nframes_t start, jack_nframes_t nframes)
{
gain_t gain_automation[nframes];
gain_t gain_buffer[nframes];
@ -645,7 +645,7 @@ AudioTrack::export_stuff (vector<Sample*>& buffers, char * workbuf, uint32_t nbu
AudioPlaylist* const apl = dynamic_cast<AudioPlaylist*>(diskstream.playlist());
assert(apl);
if (apl->read (buffers[0], mix_buffer, gain_buffer, workbuf, start, nframes) != nframes) {
if (apl->read (buffers[0], mix_buffer, gain_buffer, start, nframes) != nframes) {
return -1;
}
@ -655,7 +655,7 @@ AudioTrack::export_stuff (vector<Sample*>& buffers, char * workbuf, uint32_t nbu
++bi;
for (; bi != buffers.end(); ++bi, ++n) {
if (n < diskstream.n_channels()) {
if (apl->read ((*bi), mix_buffer, gain_buffer, workbuf, start, nframes, n) != nframes) {
if (apl->read ((*bi), mix_buffer, gain_buffer, start, nframes, n) != nframes) {
return -1;
}
b = (*bi);

2
libs/ardour/audio_unit.cc
View file

@ -322,7 +322,7 @@ AUPluginInfo::discover ()
AUPluginInfoPtr plug(new AUPluginInfo);
plug->name = AUPluginInfo::get_name (temp);
plug->type = PluginInfo::AudioUnit;
plug->type = ARDOUR::AudioUnit;
plug->n_inputs = 0;
plug->n_outputs = 0;
plug->category = "AudioUnit";

19
libs/ardour/audioregion.cc
View file

@ -466,22 +466,22 @@ AudioRegion::read_peaks (PeakData *buf, jack_nframes_t npeaks, jack_nframes_t of
}
jack_nframes_t
AudioRegion::read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, char * workbuf, jack_nframes_t position,
AudioRegion::read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, jack_nframes_t position,
jack_nframes_t cnt,
uint32_t chan_n, jack_nframes_t read_frames, jack_nframes_t skip_frames) const
{
return _read_at (sources, buf, mixdown_buffer, gain_buffer, workbuf, position, cnt, chan_n, read_frames, skip_frames);
return _read_at (sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, read_frames, skip_frames);
}
jack_nframes_t
AudioRegion::master_read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, char * workbuf, jack_nframes_t position,
AudioRegion::master_read_at (Sample *buf, Sample *mixdown_buffer, float *gain_buffer, jack_nframes_t position,
jack_nframes_t cnt, uint32_t chan_n) const
{
return _read_at (master_sources, buf, mixdown_buffer, gain_buffer, workbuf, position, cnt, chan_n, 0, 0);
return _read_at (master_sources, buf, mixdown_buffer, gain_buffer, position, cnt, chan_n, 0, 0);
}
jack_nframes_t
AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buffer, float *gain_buffer, char * workbuf,
AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buffer, float *gain_buffer,
jack_nframes_t position, jack_nframes_t cnt,
uint32_t chan_n, jack_nframes_t read_frames, jack_nframes_t skip_frames) const
{
@ -526,7 +526,7 @@ AudioRegion::_read_at (const SourceList& srcs, Sample *buf, Sample *mixdown_buff
_read_data_count = 0;
if (srcs[chan_n]->read (mixdown_buffer, _start + internal_offset, to_read, workbuf) != to_read) {
if (srcs[chan_n]->read (mixdown_buffer, _start + internal_offset, to_read) != to_read) {
return 0; /* "read nothing" */
}
@ -1188,7 +1188,7 @@ AudioRegion::exportme (Session& session, AudioExportSpecification& spec)
if (spec.channels == 1) {
if (sources.front()->read (spec.dataF, _start + spec.pos, to_read, 0) != to_read) {
if (sources.front()->read (spec.dataF, _start + spec.pos, to_read) != to_read) {
goto out;
}
@ -1198,7 +1198,7 @@ AudioRegion::exportme (Session& session, AudioExportSpecification& spec)
for (uint32_t chan = 0; chan < spec.channels; ++chan) {
if (sources[chan]->read (buf, _start + spec.pos, to_read, 0) != to_read) {
if (sources[chan]->read (buf, _start + spec.pos, to_read) != to_read) {
goto out;
}
@ -1260,7 +1260,6 @@ AudioRegion::normalize_to (float target_dB)
{
const jack_nframes_t blocksize = 64 * 1024;
Sample buf[blocksize];
char workbuf[blocksize * 4];
jack_nframes_t fpos;
jack_nframes_t fend;
jack_nframes_t to_read;
@ -1289,7 +1288,7 @@ AudioRegion::normalize_to (float target_dB)
/* read it in */
if (source (n).read (buf, fpos, to_read, workbuf) != to_read) {
if (source (n).read (buf, fpos, to_read) != to_read) {
return;
}

27
libs/ardour/audiosource.cc
View file

@ -379,17 +379,17 @@ AudioSource::initialize_peakfile (bool newfile, string audio_path)
}
jack_nframes_t
AudioSource::read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const
AudioSource::read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
{
Glib::Mutex::Lock lm (_lock);
return read_unlocked (dst, start, cnt, workbuf);
return read_unlocked (dst, start, cnt);
}
jack_nframes_t
AudioSource::write (Sample *dst, jack_nframes_t cnt, char * workbuf)
AudioSource::write (Sample *dst, jack_nframes_t cnt)
{
Glib::Mutex::Lock lm (_lock);
return write_unlocked (dst, cnt, workbuf);
return write_unlocked (dst, cnt);
}
int
@ -406,7 +406,6 @@ AudioSource::read_peaks (PeakData *peaks, jack_nframes_t npeaks, jack_nframes_t
int ret = -1;
PeakData* staging = 0;
Sample* raw_staging = 0;
char * workbuf = 0;
int peakfile = -1;
expected_peaks = (cnt / (double) frames_per_peak);
@ -445,9 +444,8 @@ AudioSource::read_peaks (PeakData *peaks, jack_nframes_t npeaks, jack_nframes_t
*/
Sample* raw_staging = new Sample[cnt];
workbuf = new char[cnt*4];
if (read_unlocked (raw_staging, start, cnt, workbuf) != cnt) {
if (read_unlocked (raw_staging, start, cnt) != cnt) {
error << _("cannot read sample data for unscaled peak computation") << endmsg;
return -1;
}
@ -458,7 +456,6 @@ AudioSource::read_peaks (PeakData *peaks, jack_nframes_t npeaks, jack_nframes_t
}
delete [] raw_staging;
delete [] workbuf;
return 0;
}
@ -624,7 +621,6 @@ AudioSource::read_peaks (PeakData *peaks, jack_nframes_t npeaks, jack_nframes_t
jack_nframes_t nvisual_peaks = 0;
jack_nframes_t chunksize = (jack_nframes_t) min (cnt, (jack_nframes_t) 4096);
raw_staging = new Sample[chunksize];
workbuf = new char[chunksize *4];
jack_nframes_t frame_pos = start;
double pixel_pos = floor (frame_pos / samples_per_visual_peak);
@ -640,7 +636,7 @@ AudioSource::read_peaks (PeakData *peaks, jack_nframes_t npeaks, jack_nframes_t
to_read = min (chunksize, (_length - current_frame));
if ((frames_read = read_unlocked (raw_staging, current_frame, to_read, workbuf)) == 0) {
if ((frames_read = read_unlocked (raw_staging, current_frame, to_read)) == 0) {
error << string_compose(_("AudioSource[%1]: peak read - cannot read %2 samples at offset %3")
, _name, to_read, current_frame)
<< endmsg;
@ -688,10 +684,6 @@ AudioSource::read_peaks (PeakData *peaks, jack_nframes_t npeaks, jack_nframes_t
delete [] raw_staging;
}
if (workbuf) {
delete [] workbuf;
}
return ret;
}
@ -760,7 +752,6 @@ AudioSource::do_build_peak (jack_nframes_t first_frame, jack_nframes_t cnt)
Sample xmin, xmax;
uint32_t peaki;
PeakData* peakbuf;
char * workbuf = 0;
jack_nframes_t frames_read;
jack_nframes_t frames_to_read;
off_t first_peak_byte;
@ -781,8 +772,6 @@ AudioSource::do_build_peak (jack_nframes_t first_frame, jack_nframes_t cnt)
peakbuf = new PeakData[(cnt/frames_per_peak)+1];
peaki = 0;
workbuf = new char[max(frames_per_peak, cnt) * 4];
if ((peakfile = ::open (peakpath.c_str(), O_RDWR|O_CREAT, 0664)) < 0) {
error << string_compose(_("AudioSource: cannot open peakpath \"%1\" (%2)"), peakpath, strerror (errno)) << endmsg;
return -1;
@ -794,7 +783,7 @@ AudioSource::do_build_peak (jack_nframes_t first_frame, jack_nframes_t cnt)
/* lock for every read */
if ((frames_read = read (buf, current_frame, frames_to_read, workbuf)) != frames_to_read) {
if ((frames_read = read (buf, current_frame, frames_to_read)) != frames_to_read) {
error << string_compose(_("%1: could not write read raw data for peak computation (%2)"), _name, strerror (errno)) << endmsg;
goto out;
}
@ -831,8 +820,6 @@ AudioSource::do_build_peak (jack_nframes_t first_frame, jack_nframes_t cnt)
if (peakfile >= 0) {
close (peakfile);
}
if (workbuf)
delete [] workbuf;
return ret;
}

2
libs/ardour/configuration.cc
View file

@ -236,7 +236,7 @@ Configuration::set_state (const XMLNode& root)
}
}
AudioDiskstream::set_disk_io_chunk_frames (minimum_disk_io_bytes.get() / sizeof (Sample));
Diskstream::set_disk_io_chunk_frames (minimum_disk_io_bytes.get() / sizeof (Sample));
return 0;
}

2
libs/ardour/coreaudiosource.cc
View file

@ -153,7 +153,7 @@ CoreAudioSource::~CoreAudioSource ()
}
jack_nframes_t
CoreAudioSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const
CoreAudioSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
{
OSStatus err = noErr;

6
libs/ardour/crossfade.cc
View file

@ -402,7 +402,7 @@ Crossfade::compute (AudioRegion& a, AudioRegion& b, CrossfadeModel model)
jack_nframes_t
Crossfade::read_at (Sample *buf, Sample *mixdown_buffer,
float *gain_buffer, char * workbuf, jack_nframes_t start, jack_nframes_t cnt, uint32_t chan_n,
float *gain_buffer, jack_nframes_t start, jack_nframes_t cnt, uint32_t chan_n,
jack_nframes_t read_frames, jack_nframes_t skip_frames)
{
jack_nframes_t offset;
@ -438,8 +438,8 @@ Crossfade::read_at (Sample *buf, Sample *mixdown_buffer,
offset = start - _position;
_out->read_at (crossfade_buffer_out, mixdown_buffer, gain_buffer, workbuf, start, to_write, chan_n, read_frames, skip_frames);
_in->read_at (crossfade_buffer_in, mixdown_buffer, gain_buffer, workbuf, start, to_write, chan_n, read_frames, skip_frames);
_out->read_at (crossfade_buffer_out, mixdown_buffer, gain_buffer, start, to_write, chan_n, read_frames, skip_frames);
_in->read_at (crossfade_buffer_in, mixdown_buffer, gain_buffer, start, to_write, chan_n, read_frames, skip_frames);
float* fiv = new float[to_write];
float* fov = new float[to_write];

12
libs/ardour/destructive_filesource.cc
View file

@ -158,7 +158,7 @@ DestructiveFileSource::clear_capture_marks ()
}
jack_nframes_t
DestructiveFileSource::crossfade (Sample* data, jack_nframes_t cnt, int fade_in, char * workbuf)
DestructiveFileSource::crossfade (Sample* data, jack_nframes_t cnt, int fade_in)
{
jack_nframes_t xfade = min (xfade_frames, cnt);
jack_nframes_t nofade = cnt - xfade;
@ -272,7 +272,7 @@ DestructiveFileSource::crossfade (Sample* data, jack_nframes_t cnt, int fade_in,
}
jack_nframes_t
DestructiveFileSource::write_unlocked (Sample* data, jack_nframes_t cnt, char * workbuf)
DestructiveFileSource::write_unlocked (Sample* data, jack_nframes_t cnt)
{
jack_nframes_t old_file_pos;
@ -297,7 +297,7 @@ DestructiveFileSource::write_unlocked (Sample* data, jack_nframes_t cnt, char *
jack_nframes_t ofilepos = file_pos;
// fade in
if (crossfade (data, subcnt, 1, workbuf) != subcnt) {
if (crossfade (data, subcnt, 1) != subcnt) {
return 0;
}
@ -306,7 +306,7 @@ DestructiveFileSource::write_unlocked (Sample* data, jack_nframes_t cnt, char *
// fade out
subcnt = cnt - subcnt;
if (crossfade (tmpdata, subcnt, 0, workbuf) != subcnt) {
if (crossfade (tmpdata, subcnt, 0) != subcnt) {
return 0;
}
@ -324,7 +324,7 @@ DestructiveFileSource::write_unlocked (Sample* data, jack_nframes_t cnt, char *
/* move to the correct location place */
file_pos = capture_start_frame;
if (crossfade (data, cnt, 1, workbuf) != cnt) {
if (crossfade (data, cnt, 1) != cnt) {
return 0;
}
@ -337,7 +337,7 @@ DestructiveFileSource::write_unlocked (Sample* data, jack_nframes_t cnt, char *
_capture_start = false;
_capture_end = false;
if (crossfade (data, cnt, 0, workbuf) != cnt) {
if (crossfade (data, cnt, 0) != cnt) {
return 0;
}

8
libs/ardour/diskstream.cc
View file

@ -19,6 +19,7 @@
*/
#include <fstream>
#include <cassert>
#include <cstdio>
#include <unistd.h>
#include <cmath>
@ -55,7 +56,12 @@ using namespace std;
using namespace ARDOUR;
using namespace PBD;
jack_nframes_t Diskstream::disk_io_chunk_frames = 0;
/* XXX This goes uninitialized when there is no ~/.ardour2 directory.
* I can't figure out why, so this will do for now (just stole the
* default from configuration_vars.h). 0 is not a good value for
* allocating buffer sizes..
*/
jack_nframes_t Diskstream::disk_io_chunk_frames = 1024 * 256;
sigc::signal<void,Diskstream*> Diskstream::DiskstreamCreated;
sigc::signal<void,list<Source*>*> Diskstream::DeleteSources;

7
libs/ardour/import.cc
View file

@ -57,7 +57,6 @@ Session::import_audiofile (import_status& status)
SF_INFO info;
float *data = 0;
Sample **channel_data = 0;
char * workbuf = 0;
long nfiles = 0;
long n;
string basepath;
@ -156,7 +155,6 @@ Session::import_audiofile (import_status& status)
data = new float[BLOCKSIZE * info.channels];
channel_data = new Sample * [ info.channels ];
workbuf = new char[BLOCKSIZE * 4];
for (n = 0; n < info.channels; ++n) {
channel_data[n] = new Sample[BLOCKSIZE];
@ -188,7 +186,7 @@ Session::import_audiofile (import_status& status)
/* flush to disk */
for (chn = 0; chn < info.channels; ++chn) {
newfiles[chn]->write (channel_data[chn], nread, workbuf);
newfiles[chn]->write (channel_data[chn], nread);
}
so_far += nread;
@ -255,9 +253,6 @@ Session::import_audiofile (import_status& status)
if (data) {
delete [] data;
}
if (workbuf) {
delete [] workbuf;
}
if (channel_data) {
for (n = 0; n < info.channels; ++n) {

52
libs/ardour/insert.cc
View file

@ -30,9 +30,18 @@
#include <ardour/port.h>
#include <ardour/route.h>
#include <ardour/ladspa_plugin.h>
#ifdef VST_SUPPORT
#include <ardour/vst_plugin.h>
#endif
#ifdef HAVE_COREAUDIO
#include <ardour/audio_unit.h>
#endif
#include <ardour/audioengine.h>
#include <ardour/session.h>
#include <ardour/types.h>
#include "i18n.h"
@ -45,7 +54,6 @@ Insert::Insert(Session& s, Placement p)
{
}
Insert::Insert(Session& s, Placement p, int imin, int imax, int omin, int omax)
: Redirect (s, s.next_insert_name(), p, imin, imax, omin, omax)
{
@ -505,12 +513,19 @@ PluginInsert::plugin_factory (boost::shared_ptr<Plugin> other)
#ifdef VST_SUPPORT
boost::shared_ptr<VSTPlugin> vp;
#endif
#ifdef HAVE_COREAUDIO
boost::shared_ptr<AUPlugin> ap;
#endif
if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
return boost::shared_ptr<Plugin> (new LadspaPlugin (*lp));
#ifdef VST_SUPPORT
} else if ((vp = boost::dynamic_pointer_cast<VSTPlugin> (other)) != 0) {
return boost::shared_ptr<Plugin> (new VSTPlugin (*vp));
#endif
#ifdef HAVE_COREAUDIO
} else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
return boost::shared_ptr<Plugin> (new AUPlugin (*ap));
#endif
}
@ -630,7 +645,7 @@ PluginInsert::set_state(const XMLNode& node)
XMLPropertyList plist;
const XMLProperty *prop;
long unique = 0;
PluginInfo::Type type;
ARDOUR::PluginType type;
if ((prop = node.property ("type")) == 0) {
error << _("XML node describing insert is missing the `type' field") << endmsg;
@ -638,9 +653,9 @@ PluginInsert::set_state(const XMLNode& node)
}
if (prop->value() == X_("ladspa") || prop->value() == X_("Ladspa")) { /* handle old school sessions */
type = PluginInfo::LADSPA;
type = ARDOUR::LADSPA;
} else if (prop->value() == X_("vst")) {
type = PluginInfo::VST;
type = ARDOUR::VST;
} else {
error << string_compose (_("unknown plugin type %1 in plugin insert state"),
prop->value())
@ -807,6 +822,35 @@ PluginInsert::state_factory (std::string why) const
return state;
}
ARDOUR::PluginType
PluginInsert::type ()
{
boost::shared_ptr<LadspaPlugin> lp;
#ifdef VST_SUPPORT
boost::shared_ptr<VSTPlugin> vp;
#endif
#ifdef HAVE_COREAUDIO
boost::shared_ptr<AUPlugin> ap;
#endif
PluginPtr other = plugin ();
if ((lp = boost::dynamic_pointer_cast<LadspaPlugin> (other)) != 0) {
return ARDOUR::LADSPA;
#ifdef VST_SUPPORT
} else if ((vp = boost::dynamic_pointer_cast<VSTPlugin> (other)) != 0) {
return ARDOUR::VST;
#endif
#ifdef HAVE_COREAUDIO
} else if ((ap = boost::dynamic_pointer_cast<AUPlugin> (other)) != 0) {
return ARDOUR::AudioUnit;
#endif
} else {
/* NOT REACHED */
return (ARDOUR::PluginType) 0;
}
}
/***************************************************************
Port inserts: send output to a port, pick up input at a port
***************************************************************/

4
libs/ardour/panner.cc
View file

@ -1258,10 +1258,10 @@ Panner::set_state (const XMLNode& node)
float x, y;
prop = (*niter)->property (X_("x"));
sscanf (prop->value().c_str(), "%.12g", &x);
sscanf (prop->value().c_str(), "%g", &x);
prop = (*niter)->property (X_("y"));
sscanf (prop->value().c_str(), "%.12g", &y);
sscanf (prop->value().c_str(), "%g", &y);
outputs.push_back (Output (x, y));
}

8
libs/ardour/plugin.cc
View file

@ -244,25 +244,25 @@ Plugin::save_preset (string name, string domain)
}
PluginPtr
ARDOUR::find_plugin(Session& session, string name, long unique_id, PluginInfo::Type type)
ARDOUR::find_plugin(Session& session, string name, long unique_id, PluginType type)
{
PluginManager *mgr = PluginManager::the_manager();
PluginInfoList plugs;
switch (type) {
case PluginInfo::LADSPA:
case ARDOUR::LADSPA:
plugs = mgr->ladspa_plugin_info();
break;
#ifdef VST_SUPPORT
case PluginInfo::VST:
case ARDOUR::VST:
plugs = mgr->vst_plugin_info();
unique_id = 0; // VST plugins don't have a unique id.
break;
#endif
#ifdef HAVE_COREAUDIO
case PluginInfo::AudioUnit:
case ARDOUR::AudioUnit:
plugs = AUPluginInfo::discover ();
unique_id = 0; // Neither do AU.
break;

4
libs/ardour/plugin_manager.cc
View file

@ -254,7 +254,7 @@ PluginManager::ladspa_discover (string path)
info->index = i;
info->n_inputs = 0;
info->n_outputs = 0;
info->type = PluginInfo::LADSPA;
info->type = ARDOUR::LADSPA;
info->unique_id = descriptor->UniqueID;
for (uint32_t n=0; n < descriptor->PortCount; ++n) {
@ -397,7 +397,7 @@ PluginManager::vst_discover (string path)
info->index = 0;
info->n_inputs = finfo->numInputs;
info->n_outputs = finfo->numOutputs;
info->type = PluginInfo::VST;
info->type = ARDOUR::VST;
_vst_plugin_info.push_back (info);
fst_free_info (finfo);

10
libs/ardour/reverse.cc
View file

@ -49,7 +49,6 @@ Reverse::run (AudioRegion& region)
AudioRegion::SourceList::iterator si;
const jack_nframes_t blocksize = 256 * 1048;
Sample buf[blocksize];
char * workbuf = 0;;
jack_nframes_t fpos;
jack_nframes_t fend;
jack_nframes_t fstart;
@ -62,8 +61,6 @@ Reverse::run (AudioRegion& region)
goto out;
}
workbuf = new char[blocksize * 4];
fend = region.start() + region.length();
fstart = region.start();
@ -85,7 +82,7 @@ Reverse::run (AudioRegion& region)
/* read it in */
if (region.source (n).read (buf, fpos, to_read, workbuf) != to_read) {
if (region.source (n).read (buf, fpos, to_read) != to_read) {
goto out;
}
@ -97,7 +94,7 @@ Reverse::run (AudioRegion& region)
/* write it out */
if ((*si)->write (buf, to_read, workbuf) != to_read) {
if ((*si)->write (buf, to_read) != to_read) {
goto out;
}
}
@ -123,9 +120,6 @@ Reverse::run (AudioRegion& region)
delete *si;
}
}
if (workbuf) {
delete [] workbuf;
}
return ret;
}

15
libs/ardour/session.cc
View file

@ -394,10 +394,6 @@ Session::~Session ()
free(*i);
}
for (map<RunContext,char*>::iterator i = _conversion_buffers.begin(); i != _conversion_buffers.end(); ++i) {
delete [] (i->second);
}
AudioDiskstream::free_working_buffers();
#undef TRACK_DESTRUCTION
@ -3596,7 +3592,6 @@ Session::write_one_audio_track (AudioTrack& track, jack_nframes_t start, jack_nf
jack_nframes_t this_chunk;
jack_nframes_t to_do;
vector<Sample*> buffers;
char * workbuf = 0;
// any bigger than this seems to cause stack overflows in called functions
const jack_nframes_t chunk_size = (128 * 1024)/4;
@ -3666,13 +3661,11 @@ Session::write_one_audio_track (AudioTrack& track, jack_nframes_t start, jack_nf
buffers.push_back (b);
}
workbuf = new char[chunk_size * 4];
while (to_do && !itt.cancel) {
this_chunk = min (to_do, chunk_size);
if (track.export_stuff (buffers, workbuf, nchans, start, this_chunk)) {
if (track.export_stuff (buffers, nchans, start, this_chunk)) {
goto out;
}
@ -3681,7 +3674,7 @@ Session::write_one_audio_track (AudioTrack& track, jack_nframes_t start, jack_nf
AudioFileSource* afs = dynamic_cast<AudioFileSource*>(*src);
if (afs) {
if (afs->write (buffers[n], this_chunk, workbuf) != this_chunk) {
if (afs->write (buffers[n], this_chunk) != this_chunk) {
goto out;
}
}
@ -3735,10 +3728,6 @@ Session::write_one_audio_track (AudioTrack& track, jack_nframes_t start, jack_nf
free(*i);
}
if (workbuf) {
delete [] workbuf;
}
g_atomic_int_set (&processing_prohibited, 0);
itt.done = true;

3
libs/ardour/session_state.cc
View file

@ -191,9 +191,6 @@ Session::first_stage_init (string fullpath, string snapshot_name)
xfade_model = ShortCrossfade;
destructive_index = 0;
/* allocate conversion buffers */
_conversion_buffers[ButlerContext] = new char[AudioDiskstream::disk_io_frames() * 4];
_conversion_buffers[TransportContext] = new char[AudioDiskstream::disk_io_frames() * 4];
AudioDiskstream::allocate_working_buffers();
/* default short fade = 15ms */

7
libs/ardour/session_timefx.cc
View file

@ -96,7 +96,6 @@ Session::tempoize_region (TimeStretchRequest& tsr)
for (uint32_t i = 0; i < sources.size(); ++i) {
gain_t gain_buffer[bufsize];
Sample buffer[bufsize];
char workbuf[bufsize*4];
jack_nframes_t pos = 0;
jack_nframes_t this_read = 0;
@ -110,7 +109,7 @@ Session::tempoize_region (TimeStretchRequest& tsr)
not the ones currently in use, in case it's already been
subject to timefx. */
if ((this_read = tsr.region->master_read_at (buffer, buffer, gain_buffer, workbuf, pos + tsr.region->position(), this_time)) != this_time) {
if ((this_read = tsr.region->master_read_at (buffer, buffer, gain_buffer, pos + tsr.region->position(), this_time)) != this_time) {
error << string_compose (_("tempoize: error reading data from %1"), sources[i]->name()) << endmsg;
goto out;
}
@ -123,7 +122,7 @@ Session::tempoize_region (TimeStretchRequest& tsr)
st.putSamples (buffer, this_read);
while ((this_read = st.receiveSamples (buffer, bufsize)) > 0 && tsr.running) {
if (sources[i]->write (buffer, this_read, workbuf) != this_read) {
if (sources[i]->write (buffer, this_read) != this_read) {
error << string_compose (_("error writing tempo-adjusted data to %1"), sources[i]->name()) << endmsg;
goto out;
}
@ -135,7 +134,7 @@ Session::tempoize_region (TimeStretchRequest& tsr)
}
while (tsr.running && (this_read = st.receiveSamples (buffer, bufsize)) > 0) {
if (sources[i]->write (buffer, this_read, workbuf) != this_read) {
if (sources[i]->write (buffer, this_read) != this_read) {
error << string_compose (_("error writing tempo-adjusted data to %1"), sources[i]->name()) << endmsg;
goto out;
}

4
libs/ardour/sndfilesource.cc
View file

@ -292,7 +292,7 @@ SndFileSource::sample_rate () const
}
jack_nframes_t
SndFileSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const
SndFileSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
{
int32_t nread;
float *ptr;
@ -367,7 +367,7 @@ SndFileSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t
}
jack_nframes_t
SndFileSource::write_unlocked (Sample *data, jack_nframes_t cnt, char * workbuf)
SndFileSource::write_unlocked (Sample *data, jack_nframes_t cnt)
{
if (!writable()) {
return 0;

2
libs/ardour/track.cc
View file

@ -152,7 +152,7 @@ bool
Track::can_record()
{
bool will_record = true;
for (int i = 0; i < _inputs.size() && will_record; i++) {
for (size_t i = 0; i < _inputs.size() && will_record; i++) {
if (!_inputs[i]->connected())
will_record = false;
}