libs/ardour/plugin.cc

   1 /*
   2     Copyright (C) 2000-2002 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18     $Id$
  19 */
  20
  21 #include <vector>
  22 #include <string>
  23
  24 #include <cstdlib>
  25 #include <cstdio> // so libraptor doesn't complain
  26 #include <cmath>
  27 #include <dirent.h>
  28 #include <sys/stat.h>
  29 #include <cerrno>
  30
  31 #include <lrdf.h>
  32
  33 #include <pbd/compose.h>
  34 #include <pbd/error.h>
  35 #include <pbd/pathscanner.h>
  36 #include <pbd/xml++.h>
  37
  38 #include <midi++/manager.h>
  39
  40 #include <ardour/ardour.h>
  41 #include <ardour/session.h>
  42 #include <ardour/audioengine.h>
  43 #include <ardour/plugin.h>
  44
  45 #include <pbd/stl_delete.h>
  46
  47 #include "i18n.h"
  48 #include <locale.h>
  49
  50 using namespace ARDOUR;
  51
  52 Plugin::Plugin (AudioEngine& e, Session& s)
  53         : _engine (e), _session (s)
  54 {
  55 }
  56
  57 Plugin::Plugin (const Plugin& other)
  58         : _engine (other._engine), _session (other._session), _info (other._info)
  59 {
  60 }
  61
  62 void
  63 Plugin::setup_midi_controls ()
  64 {
  65         uint32_t port_cnt;
  66
  67         port_cnt = parameter_count();
  68
  69         /* set up a vector of null pointers for the MIDI controls.
  70            we'll fill this in on an as-needed basis.
  71         */
  72
  73         for (uint32_t i = 0; i < port_cnt; ++i) {
  74                 midi_controls.push_back (0);
  75         }
  76 }
  77
  78 Plugin::~Plugin ()
  79 {
  80         for (vector<MIDIPortControl*>::iterator i = midi_controls.begin(); i != midi_controls.end(); ++i) {
  81                 if (*i) {
  82                         delete *i;
  83                 }
  84         }
  85 }
  86
  87 MIDI::Controllable *
  88 Plugin::get_nth_midi_control (uint32_t n)
  89 {
  90         if (n >= parameter_count()) {
  91                 return 0;
  92         }
  93
  94         if (midi_controls[n] == 0) {
  95
  96                 Plugin::ParameterDescriptor desc;
  97
  98                 get_parameter_descriptor (n, desc);
  99
 100                 midi_controls[n] = new MIDIPortControl (*this, n, _session.midi_port(), desc.lower, desc.upper, desc.toggled, desc.logarithmic);
 101         }
 102
 103         return midi_controls[n];
 104 }
 105
 106 Plugin::MIDIPortControl::MIDIPortControl (Plugin& p, uint32_t port_id, MIDI::Port *port,
 107                                           float low, float up, bool t, bool loga)
 108         : MIDI::Controllable (port, 0), plugin (p), absolute_port (port_id)
 109 {
 110         toggled = t;
 111         logarithmic = loga;
 112         lower = low;
 113         upper = up;
 114         range = upper - lower;
 115         last_written = 0; /* XXX need a good out-of-bound-value */
 116         setting = false;
 117 }
 118
 119 void
 120 Plugin::MIDIPortControl::set_value (float value)
 121 {
 122         if (toggled) {
 123                 if (value > 0.5) {
 124                         value = 1.0;
 125                 } else {
 126                         value = 0.0;
 127                 }
 128         } else {
 129                 value = lower + (range * value);
 130
 131                 if (logarithmic) {
 132                         value = exp(value);
 133                 }
 134         }
 135
 136         setting = true;
 137         plugin.set_parameter (absolute_port, value);
 138         setting = false;
 139 }
 140
 141 void
 142 Plugin::MIDIPortControl::send_feedback (float value)
 143 {
 144
 145         if (!setting && get_midi_feedback()) {
 146                 MIDI::byte val;
 147                 MIDI::channel_t ch = 0;
 148                 MIDI::eventType ev = MIDI::none;
 149                 MIDI::byte additional = 0;
 150                 MIDI::EventTwoBytes data;
 151
 152                 if (toggled) {
 153                         val = (MIDI::byte) (value * 127.0f);
 154                 } else {
 155                         if (logarithmic) {
 156                                 value = log(value);
 157                         }
 158
 159                         val = (MIDI::byte) (((value - lower) / range) * 127.0f);
 160                 }
 161
 162                 if (get_control_info (ch, ev, additional)) {
 163                         data.controller_number = additional;
 164                         data.value = val;
 165
 166                         plugin.session().send_midi_message (get_port(), ev, ch, data);
 167                 }
 168         }
 169
 170 }
 171
 172 MIDI::byte*
 173 Plugin::MIDIPortControl::write_feedback (MIDI::byte* buf, int32_t& bufsize, float value, bool force)
 174 {
 175         if (get_midi_feedback() && bufsize > 2) {
 176                 MIDI::channel_t ch = 0;
 177                 MIDI::eventType ev = MIDI::none;
 178                 MIDI::byte additional = 0;
 179
 180                 if (get_control_info (ch, ev, additional)) {
 181
 182                         MIDI::byte val;
 183
 184                         if (toggled) {
 185
 186                                 val = (MIDI::byte) (value * 127.0f);
 187
 188                         } else {
 189
 190                                 if (logarithmic) {
 191                                         value = log(value);
 192                                 }
 193
 194                                 val = (MIDI::byte) (((value - lower) / range) * 127.0f);
 195                         }
 196
 197                         if (val != last_written || force)  {
 198                                 *buf++ = MIDI::controller & ch;
 199                                 *buf++ = additional; /* controller number */
 200                                 *buf++ = val;
 201                                 last_written = val;
 202                                 bufsize -= 3;
 203                         }
 204                 }
 205         }
 206
 207         return buf;
 208 }
 209
 210
 211 void
 212 Plugin::reset_midi_control (MIDI::Port* port, bool on)
 213 {
 214         MIDI::channel_t chn;
 215         MIDI::eventType ev;
 216         MIDI::byte extra;
 217
 218         for (vector<MIDIPortControl*>::iterator i = midi_controls.begin(); i != midi_controls.end(); ++i) {
 219                 if (*i == 0)
 220                         continue;
 221                 (*i)->get_control_info (chn, ev, extra);
 222                 if (!on) {
 223                         chn = -1;
 224                 }
 225                 (*i)->midi_rebind (port, chn);
 226         }
 227 }
 228
 229 void
 230 Plugin::send_all_midi_feedback ()
 231 {
 232         if (_session.get_midi_feedback()) {
 233                 float val = 0.0;
 234                 uint32_t n = 0;
 235
 236                 for (vector<MIDIPortControl*>::iterator i = midi_controls.begin(); i != midi_controls.end(); ++i, ++n) {
 237                         if (*i == 0) {
 238                                 continue;
 239                         }
 240
 241                         val = (*i)->plugin.get_parameter (n);
 242                         (*i)->send_feedback (val);
 243                 }
 244
 245         }
 246 }
 247
 248 MIDI::byte*
 249 Plugin::write_midi_feedback (MIDI::byte* buf, int32_t& bufsize)
 250 {
 251         if (_session.get_midi_feedback()) {
 252                 float val = 0.0;
 253                 uint32_t n = 0;
 254
 255                 for (vector<MIDIPortControl*>::iterator i = midi_controls.begin(); i != midi_controls.end(); ++i, ++n) {
 256                         if (*i == 0) {
 257                                 continue;
 258                         }
 259
 260                         val = (*i)->plugin.get_parameter (n);
 261                         buf = (*i)->write_feedback (buf, bufsize, val);
 262                 }
 263         }
 264
 265         return buf;
 266 }
 267
 268 vector<string>
 269 Plugin::get_presets()
 270 {
 271         vector<string> labels;
 272         lrdf_uris* set_uris = lrdf_get_setting_uris(unique_id());
 273
 274         if (set_uris) {
 275                 for (uint32_t i = 0; i < set_uris->count; ++i) {
 276                         if (char* label = lrdf_get_label(set_uris->items[i])) {
 277                                 labels.push_back(label);
 278                                 presets[label] = set_uris->items[i];
 279                         }
 280                 }
 281                 lrdf_free_uris(set_uris);
 282         }
 283
 284         // GTK2FIX find an equivalent way to do this with a vector (needed by GUI apis)
 285         // labels.unique();
 286
 287         return labels;
 288 }
 289
 290 bool
 291 Plugin::load_preset(const string preset_label)
 292 {
 293         lrdf_defaults* defs = lrdf_get_setting_values(presets[preset_label].c_str());
 294
 295         if (defs) {
 296                 for (uint32_t i = 0; i < defs->count; ++i) {
 297                         // The defs->items[i].pid < defs->count check is to work around
 298                         // a bug in liblrdf that saves invalid values into the presets file.
 299                         if (((uint32_t) defs->items[i].pid < defs->count) && parameter_is_input (defs->items[i].pid)) {
 300                                 set_parameter(defs->items[i].pid, defs->items[i].value);
 301                         }
 302                 }
 303                 lrdf_free_setting_values(defs);
 304         }
 305
 306         return true;
 307 }
 308
 309 bool
 310 Plugin::save_preset (string name, string domain)
 311 {
 312         lrdf_portvalue portvalues[parameter_count()];
 313         lrdf_defaults defaults;
 314         defaults.count = parameter_count();
 315         defaults.items = portvalues;
 316
 317         for (uint32_t i = 0; i < parameter_count(); ++i) {
 318                 if (parameter_is_input (i)) {
 319                         portvalues[i].pid = i;
 320                         portvalues[i].value = get_parameter(i);
 321                 }
 322         }
 323
 324         char* envvar;
 325         if ((envvar = getenv ("HOME")) == 0) {
 326                 warning << _("Could not locate HOME.  Preset not saved.") << endmsg;
 327                 return false;
 328         }
 329
 330         string source(string_compose("file:%1/.%2/rdf/ardour-presets.n3", envvar, domain));
 331
 332         free(lrdf_add_preset(source.c_str(), name.c_str(), unique_id(), &defaults));
 333
 334         string path = string_compose("%1/.%2", envvar, domain);
 335         if (mkdir(path.c_str(), 0775) && errno != EEXIST) {
 336                 warning << string_compose(_("Could not create %1.  Preset not saved. (%2)"), path, strerror(errno)) << endmsg;
 337                 return false;
 338         }
 339
 340         path += "/rdf";
 341         if (mkdir(path.c_str(), 0775) && errno != EEXIST) {
 342                 warning << string_compose(_("Could not create %1.  Preset not saved. (%2)"), path, strerror(errno)) << endmsg;
 343                 return false;
 344         }
 345
 346         if (lrdf_export_by_source(source.c_str(), source.substr(5).c_str())) {
 347                 warning << string_compose(_("Error saving presets file %1."), source) << endmsg;
 348                 return false;
 349         }
 350
 351         return true;
 352 }