libs/ardour/luaproc.cc

   1 /*
   2     Copyright (C) 2016 Robin Gareus <robin@gareus.org>
   3     Copyright (C) 2006 Paul Davis
   4
   5     This program is free software; you can redistribute it and/or modify it
   6     under the terms of the GNU General Public License as published by the Free
   7     Software Foundation; either version 2 of the License, or (at your option)
   8     any later version.
   9
  10     This program is distributed in the hope that it will be useful, but WITHOUT
  11     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13     for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include <glib.h>
  21 #include <glibmm/miscutils.h>
  22 #include <glibmm/fileutils.h>
  23
  24 #include "pbd/gstdio_compat.h"
  25 #include "pbd/locale_guard.h"
  26 #include "pbd/pthread_utils.h"
  27
  28 #include "ardour/audio_buffer.h"
  29 #include "ardour/buffer_set.h"
  30 #include "ardour/filesystem_paths.h"
  31 #include "ardour/luabindings.h"
  32 #include "ardour/luaproc.h"
  33 #include "ardour/luascripting.h"
  34 #include "ardour/midi_buffer.h"
  35 #include "ardour/plugin.h"
  36 #include "ardour/session.h"
  37
  38 #include "LuaBridge/LuaBridge.h"
  39
  40 #include "pbd/i18n.h"
  41
  42 using namespace ARDOUR;
  43 using namespace PBD;
  44
  45 LuaProc::LuaProc (AudioEngine& engine,
  46                   Session& session,
  47                   const std::string &script)
  48         : Plugin (engine, session)
  49         , _mempool ("LuaProc", 3145728)
  50 #ifdef USE_TLSF
  51         , lua (lua_newstate (&PBD::TLSF::lalloc, &_mempool))
  52 #elif defined USE_MALLOC
  53         , lua ()
  54 #else
  55         , lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
  56 #endif
  57         , _lua_dsp (0)
  58         , _script (script)
  59         , _lua_does_channelmapping (false)
  60         , _lua_has_inline_display (false)
  61         , _designated_bypass_port (UINT32_MAX)
  62         , _control_data (0)
  63         , _shadow_data (0)
  64         , _configured (false)
  65         , _has_midi_input (false)
  66         , _has_midi_output (false)
  67 {
  68         init ();
  69
  70         /* when loading a session, or pasing a processor,
  71          * the script is set during set_state();
  72          */
  73         if (!_script.empty () && load_script ()) {
  74                 throw failed_constructor ();
  75         }
  76 }
  77
  78 LuaProc::LuaProc (const LuaProc &other)
  79         : Plugin (other)
  80         , _mempool ("LuaProc", 3145728)
  81 #ifdef USE_TLSF
  82         , lua (lua_newstate (&PBD::TLSF::lalloc, &_mempool))
  83 #elif defined USE_MALLOC
  84         , lua ()
  85 #else
  86         , lua (lua_newstate (&PBD::ReallocPool::lalloc, &_mempool))
  87 #endif
  88         , _lua_dsp (0)
  89         , _script (other.script ())
  90         , _lua_does_channelmapping (false)
  91         , _lua_has_inline_display (false)
  92         , _designated_bypass_port (UINT32_MAX)
  93         , _control_data (0)
  94         , _shadow_data (0)
  95         , _configured (false)
  96         , _has_midi_input (false)
  97         , _has_midi_output (false)
  98 {
  99         init ();
 100
 101         if (load_script ()) {
 102                 throw failed_constructor ();
 103         }
 104
 105         for (uint32_t i = 0; i < parameter_count (); ++i) {
 106                 _control_data[i] = other._shadow_data[i];
 107                 _shadow_data[i]  = other._shadow_data[i];
 108         }
 109 }
 110
 111 LuaProc::~LuaProc () {
 112 #ifdef WITH_LUAPROC_STATS
 113         if (_info && _stats_cnt > 0) {
 114                 printf ("LuaProc: '%s' run()  avg: %.3f  max: %.3f [ms]\n",
 115                                 _info->name.c_str (),
 116                                 0.0001f * _stats_avg[0] / (float) _stats_cnt,
 117                                 0.0001f * _stats_max[0]);
 118                 printf ("LuaProc: '%s' gc()   avg: %.3f  max: %.3f [ms]\n",
 119                                 _info->name.c_str (),
 120                                 0.0001f * _stats_avg[1] / (float) _stats_cnt,
 121                                 0.0001f * _stats_max[1]);
 122         }
 123 #endif
 124         lua.do_command ("collectgarbage();");
 125         delete (_lua_dsp);
 126         delete [] _control_data;
 127         delete [] _shadow_data;
 128 }
 129
 130 void
 131 LuaProc::init ()
 132 {
 133 #ifdef WITH_LUAPROC_STATS
 134         _stats_avg[0] = _stats_avg[1] = _stats_max[0] = _stats_max[1] = _stats_cnt = 0;
 135 #endif
 136
 137         lua.tweak_rt_gc ();
 138         lua.Print.connect (sigc::mem_fun (*this, &LuaProc::lua_print));
 139         // register session object
 140         lua_State* L = lua.getState ();
 141         LuaBindings::stddef (L);
 142         LuaBindings::common (L);
 143         LuaBindings::dsp (L);
 144
 145         luabridge::getGlobalNamespace (L)
 146                 .beginNamespace ("Ardour")
 147                 .deriveClass <LuaProc, PBD::StatefulDestructible> ("LuaProc")
 148                 .addFunction ("queue_draw", &LuaProc::queue_draw)
 149                 .addFunction ("shmem", &LuaProc::instance_shm)
 150                 .addFunction ("table", &LuaProc::instance_ref)
 151                 .addFunction ("route", &LuaProc::route)
 152                 .addFunction ("unique_id", &LuaProc::unique_id)
 153                 .addFunction ("name", &LuaProc::name)
 154                 .endClass ()
 155                 .endNamespace ();
 156
 157         // add session to global lua namespace
 158         luabridge::push <Session *> (L, &_session);
 159         lua_setglobal (L, "Session");
 160
 161         // instance
 162         luabridge::push <LuaProc *> (L, this);
 163         lua_setglobal (L, "self");
 164
 165         // sandbox
 166         lua.do_command ("io = nil os = nil loadfile = nil require = nil dofile = nil package = nil debug = nil");
 167 #if 0
 168         lua.do_command ("for n in pairs(_G) do print(n) end print ('----')"); // print global env
 169 #endif
 170         lua.do_command ("function ardour () end");
 171 }
 172
 173 boost::weak_ptr<Route>
 174 LuaProc::route () const
 175 {
 176         return static_cast<Route*>(_owner)->weakroute ();
 177 }
 178
 179 void
 180 LuaProc::lua_print (std::string s) {
 181         std::cout <<"LuaProc: " << s << "\n";
 182         PBD::error << "LuaProc: " << s << "\n";
 183 }
 184
 185 bool
 186 LuaProc::load_script ()
 187 {
 188         assert (!_lua_dsp); // don't allow to re-initialize
 189         LuaPluginInfoPtr lpi;
 190
 191         // TODO: refine APIs; function arguments..
 192         // - perform channel-map in ardour (silent/scratch buffers) ?
 193         // - control-port API (explicit get/set functions ??)
 194         // - latency reporting (global var? ctrl-port? set-function ?)
 195         // - MIDI -> sparse table of events
 196         //     { [sample] => { Event }, .. }
 197         //   or  { { sample, Event }, .. }
 198
 199         try {
 200                 LuaScriptInfoPtr lsi = LuaScripting::script_info (_script);
 201                 lpi = LuaPluginInfoPtr (new LuaPluginInfo (lsi));
 202                 assert (lpi);
 203                 set_info (lpi);
 204                 _mempool.set_name ("LuaProc: " + lsi->name);
 205                 _docs = lsi->description;
 206         } catch (failed_constructor& err) {
 207                 return true;
 208         }
 209
 210         lua_State* L = lua.getState ();
 211         lua.do_command (_script);
 212
 213         // check if script has a DSP callback
 214         luabridge::LuaRef lua_dsp_run = luabridge::getGlobal (L, "dsp_run");
 215         luabridge::LuaRef lua_dsp_map = luabridge::getGlobal (L, "dsp_runmap");
 216
 217         if ((lua_dsp_run.type () != LUA_TFUNCTION) == (lua_dsp_map.type () != LUA_TFUNCTION)) {
 218                 return true;
 219         }
 220
 221         if (lua_dsp_run.type () == LUA_TFUNCTION) {
 222                 _lua_dsp = new luabridge::LuaRef (lua_dsp_run);
 223         }
 224         else if (lua_dsp_map.type () == LUA_TFUNCTION) {
 225                 _lua_dsp = new luabridge::LuaRef (lua_dsp_map);
 226                 _lua_does_channelmapping = true;
 227         }
 228         else {
 229                 assert (0);
 230         }
 231
 232         // initialize the DSP if needed
 233         luabridge::LuaRef lua_dsp_init = luabridge::getGlobal (L, "dsp_init");
 234         if (lua_dsp_init.type () == LUA_TFUNCTION) {
 235                 try {
 236                         lua_dsp_init (_session.nominal_frame_rate ());
 237                 } catch (luabridge::LuaException const& e) {
 238                         ;
 239                 }
 240         }
 241
 242         _ctrl_params.clear ();
 243
 244         luabridge::LuaRef lua_render = luabridge::getGlobal (L, "render_inline");
 245         if (lua_render.isFunction ()) {
 246                 _lua_has_inline_display = true;
 247         }
 248
 249         luabridge::LuaRef lua_params = luabridge::getGlobal (L, "dsp_params");
 250         if (lua_params.isFunction ()) {
 251
 252                 // call function // add try {} catch (luabridge::LuaException const& e)
 253                 luabridge::LuaRef params = lua_params ();
 254
 255                 if (params.isTable ()) {
 256
 257                         for (luabridge::Iterator i (params); !i.isNil (); ++i) {
 258                                 // required fields
 259                                 if (!i.key ().isNumber ())           { return false; }
 260                                 if (!i.value ().isTable ())          { return false; }
 261                                 if (!i.value ()["type"].isString ()) { return false; }
 262                                 if (!i.value ()["name"].isString ()) { return false; }
 263                                 if (!i.value ()["min"].isNumber ())  { return false; }
 264                                 if (!i.value ()["max"].isNumber ())  { return false; }
 265
 266                                 int pn = i.key ().cast<int> ();
 267                                 std::string type = i.value ()["type"].cast<std::string> ();
 268                                 if (type == "input") {
 269                                         if (!i.value ()["default"].isNumber ()) { return false; }
 270                                         _ctrl_params.push_back (std::make_pair (false, pn));
 271                                 }
 272                                 else if (type == "output") {
 273                                         _ctrl_params.push_back (std::make_pair (true, pn));
 274                                 } else {
 275                                         return false;
 276                                 }
 277                                 assert (pn == (int) _ctrl_params.size ());
 278
 279                                 //_param_desc[pn] = boost::shared_ptr<ParameterDescriptor> (new ParameterDescriptor());
 280                                 luabridge::LuaRef lr = i.value ();
 281
 282                                 if (type == "input") {
 283                                         _param_desc[pn].normal     = lr["default"].cast<float> ();
 284                                 } else {
 285                                         _param_desc[pn].normal     = lr["min"].cast<float> (); // output-port, no default
 286                                 }
 287                                 _param_desc[pn].lower        = lr["min"].cast<float> ();
 288                                 _param_desc[pn].upper        = lr["max"].cast<float> ();
 289                                 _param_desc[pn].toggled      = lr["toggled"].isBoolean () && (lr["toggled"]).cast<bool> ();
 290                                 _param_desc[pn].logarithmic  = lr["logarithmic"].isBoolean () && (lr["logarithmic"]).cast<bool> ();
 291                                 _param_desc[pn].integer_step = lr["integer"].isBoolean () && (lr["integer"]).cast<bool> ();
 292                                 _param_desc[pn].sr_dependent = lr["ratemult"].isBoolean () && (lr["ratemult"]).cast<bool> ();
 293                                 _param_desc[pn].enumeration  = lr["enum"].isBoolean () && (lr["enum"]).cast<bool> ();
 294
 295                                 if (lr["bypass"].isBoolean () && (lr["bypass"]).cast<bool> ()) {
 296                                         _designated_bypass_port = pn - 1; // lua table starts at 1.
 297                                 }
 298
 299                                 if (lr["unit"].isString ()) {
 300                                         std::string unit = lr["unit"].cast<std::string> ();
 301                                         if (unit == "dB")             { _param_desc[pn].unit = ParameterDescriptor::DB; }
 302                                         else if (unit == "Hz")        { _param_desc[pn].unit = ParameterDescriptor::HZ; }
 303                                         else if (unit == "Midi Note") { _param_desc[pn].unit = ParameterDescriptor::MIDI_NOTE; }
 304                                 }
 305                                 _param_desc[pn].label        = (lr["name"]).cast<std::string> ();
 306                                 _param_desc[pn].scale_points = parse_scale_points (&lr);
 307
 308                                 luabridge::LuaRef doc = lr["doc"];
 309                                 if (doc.isString ()) {
 310                                         _param_doc[pn] = doc.cast<std::string> ();
 311                                 } else {
 312                                         _param_doc[pn] = "";
 313                                 }
 314                                 assert (!(_param_desc[pn].toggled && _param_desc[pn].logarithmic));
 315                         }
 316                 }
 317         }
 318
 319         _control_data = new float[parameter_count ()];
 320         _shadow_data  = new float[parameter_count ()];
 321
 322         for (uint32_t i = 0; i < parameter_count (); ++i) {
 323                 if (parameter_is_input (i)) {
 324                         _control_data[i] = _shadow_data[i] = default_value (i);
 325                 }
 326         }
 327
 328         // expose ctrl-ports to global lua namespace
 329         luabridge::push <float *> (L, _control_data);
 330         lua_setglobal (L, "CtrlPorts");
 331
 332         return false; // no error
 333 }
 334
 335 bool
 336 LuaProc::can_support_io_configuration (const ChanCount& in, ChanCount& out, ChanCount* imprecise)
 337 {
 338         // caller must hold process lock (no concurrent calls to interpreter
 339         _output_configs.clear ();
 340
 341         lua_State* L = lua.getState ();
 342         luabridge::LuaRef ioconfig = luabridge::getGlobal (L, "dsp_ioconfig");
 343
 344         luabridge::LuaRef *_iotable = NULL; // can't use reference :(
 345
 346         if (ioconfig.isFunction ()) {
 347                 try {
 348                         luabridge::LuaRef iotable = ioconfig ();
 349                         if (iotable.isTable ()) {
 350                                 _iotable = new luabridge::LuaRef (iotable);
 351                         }
 352                 } catch (luabridge::LuaException const& e) {
 353                         _iotable = NULL;
 354                 }
 355         }
 356
 357         if (!_iotable) {
 358                 /* empty table as default */
 359                 luabridge::LuaRef iotable = luabridge::newTable(L);
 360                 _iotable = new luabridge::LuaRef (iotable);
 361         }
 362
 363         // now we can reference it.
 364         luabridge::LuaRef iotable (*_iotable);
 365         delete _iotable;
 366
 367         if ((iotable).length () < 1) {
 368                 /* empty table as only config, to get default values */
 369                 luabridge::LuaRef ioconf = luabridge::newTable(L);
 370                 iotable[1] = ioconf;
 371         }
 372
 373         const int audio_in = in.n_audio ();
 374         const int midi_in = in.n_midi ();
 375
 376         // preferred setting (provided by plugin_insert)
 377         const int preferred_out = out.n_audio ();
 378         const int preferred_midiout = out.n_midi ();
 379
 380         int midi_out = -1;
 381         int audio_out = -1;
 382         float penalty = 9999;
 383         bool found = false;
 384
 385 #define FOUNDCFG_PENALTY(in, out, p) {                              \
 386   _output_configs.insert (out);                                     \
 387   if (p < penalty) {                                                \
 388     audio_out = (out);                                              \
 389     midi_out = possible_midiout;                                    \
 390     if (imprecise) {                                                \
 391       imprecise->set (DataType::AUDIO, (in));                       \
 392       imprecise->set (DataType::MIDI, possible_midiin);             \
 393     }                                                               \
 394     _has_midi_input = (possible_midiin > 0);                        \
 395     _has_midi_output = (possible_midiout > 0);                      \
 396     penalty = p;                                                    \
 397     found = true;                                                   \
 398   }                                                                 \
 399 }
 400
 401 #define FOUNDCFG_IMPRECISE(in, out) {                               \
 402   const float p = fabsf ((float)(out) - preferred_out) *            \
 403                       (((out) > preferred_out) ? 1.1 : 1)           \
 404                 + fabsf ((float)possible_midiout - preferred_midiout) *    \
 405                       ((possible_midiout - preferred_midiout) ? 0.6 : 0.5) \
 406                 + fabsf ((float)(in) - audio_in) *                  \
 407                       (((in) > audio_in) ? 275 : 250)               \
 408                 + fabsf ((float)possible_midiin - midi_in) *        \
 409                       ((possible_midiin - midi_in) ? 100 : 110);    \
 410   FOUNDCFG_PENALTY(in, out, p);                                     \
 411 }
 412
 413 #define FOUNDCFG(out)                                               \
 414   FOUNDCFG_IMPRECISE(audio_in, out)
 415
 416 #define ANYTHINGGOES                                                \
 417   _output_configs.insert (0);
 418
 419 #define UPTO(nch) {                                                 \
 420   for (int n = 1; n < nch; ++n) {                                   \
 421     _output_configs.insert (n);                                     \
 422   }                                                                 \
 423 }
 424
 425         if (imprecise) {
 426                 *imprecise = in;
 427         }
 428
 429         for (luabridge::Iterator i (iotable); !i.isNil (); ++i) {
 430                 luabridge::LuaRef io (i.value ());
 431                 if (!io.isTable()) {
 432                         continue;
 433                 }
 434
 435                 int possible_in = io["audio_in"].isNumber() ? io["audio_in"] : -1;
 436                 int possible_out = io["audio_out"].isNumber() ? io["audio_out"] : -1;
 437                 int possible_midiin = io["midi_in"].isNumber() ? io["midi_in"] : 0;
 438                 int possible_midiout = io["midi_out"].isNumber() ? io["midi_out"] : 0;
 439
 440                 if (midi_in != possible_midiin && !imprecise) {
 441                         continue;
 442                 }
 443
 444                 // exact match
 445                 if ((possible_in == audio_in) && (possible_out == preferred_out)) {
 446                         /* Set penalty so low that this output configuration
 447                          * will trump any other one */
 448                         FOUNDCFG_PENALTY(audio_in, preferred_out, -1);
 449                 }
 450
 451                 if (possible_out == 0 && possible_midiout == 0) {
 452                         /* skip configurations with no output at all */
 453                         continue;
 454                 }
 455
 456                 if (possible_in == -1 || possible_in == -2) {
 457                         /* wildcard for input */
 458                         if (possible_out == possible_in) {
 459                                 /* either both -1 or both -2 (invalid and
 460                                  * interpreted as both -1): out must match in */
 461                                 FOUNDCFG (audio_in);
 462                         } else if (possible_out == -3 - possible_in) {
 463                                 /* one is -1, the other is -2: any output configuration
 464                                  * possible, pick what the insert prefers */
 465                                 FOUNDCFG (preferred_out);
 466                                 ANYTHINGGOES;
 467                         } else if (possible_out < -2) {
 468                                 /* variable number of outputs up to -N,
 469                                  * invalid if in == -2 but we accept it anyway */
 470                                 FOUNDCFG (min (-possible_out, preferred_out));
 471                                 UPTO (-possible_out)
 472                         } else {
 473                                 /* exact number of outputs */
 474                                 FOUNDCFG (possible_out);
 475                         }
 476                 }
 477
 478                 if (possible_in < -2 || possible_in >= 0) {
 479                         /* specified number, exact or up to */
 480                         int desired_in;
 481                         if (possible_in >= 0) {
 482                                 /* configuration can only match possible_in */
 483                                 desired_in = possible_in;
 484                         } else {
 485                                 /* configuration can match up to -possible_in */
 486                                 desired_in = min (-possible_in, audio_in);
 487                         }
 488                         if (!imprecise && audio_in != desired_in) {
 489                                 /* skip that configuration, it cannot match
 490                                  * the required audio input count, and we
 491                                  * cannot ask for change via \imprecise */
 492                         } else if (possible_out == -1 || possible_out == -2) {
 493                                 /* any output configuration possible
 494                                  * out == -2 is invalid, interpreted as out == -1.
 495                                  * Really imprecise only if desired_in != audio_in */
 496                                 FOUNDCFG_IMPRECISE (desired_in, preferred_out);
 497                                 ANYTHINGGOES;
 498                         } else if (possible_out < -2) {
 499                                 /* variable number of outputs up to -N
 500                                  * not specified if in > 0, but we accept it anyway.
 501                                  * Really imprecise only if desired_in != audio_in */
 502                                 FOUNDCFG_IMPRECISE (desired_in, min (-possible_out, preferred_out));
 503                                 UPTO (-possible_out)
 504                         } else {
 505                                 /* exact number of outputs
 506                                  * Really imprecise only if desired_in != audio_in */
 507                                 FOUNDCFG_IMPRECISE (desired_in, possible_out);
 508                         }
 509                 }
 510
 511         }
 512
 513         if (!found) {
 514                 return false;
 515         }
 516
 517         if (imprecise) {
 518                 _selected_in = *imprecise;
 519         } else {
 520                 _selected_in = in;
 521         }
 522
 523         out.set (DataType::MIDI, midi_out);
 524         out.set (DataType::AUDIO, audio_out);
 525         _selected_out = out;
 526
 527         return true;
 528 }
 529
 530 bool
 531 LuaProc::configure_io (ChanCount in, ChanCount out)
 532 {
 533         in.set (DataType::MIDI, _has_midi_input ? 1 : 0);
 534         out.set (DataType::MIDI, _has_midi_output ? 1 : 0);
 535
 536         _info->n_inputs = _selected_in;
 537         _info->n_outputs = _selected_out;
 538
 539         // configure the DSP if needed
 540         if (in != _configured_in || out != _configured_out || !_configured) {
 541                 lua_State* L = lua.getState ();
 542                 luabridge::LuaRef lua_dsp_configure = luabridge::getGlobal (L, "dsp_configure");
 543                 if (lua_dsp_configure.type () == LUA_TFUNCTION) {
 544                         try {
 545                                 luabridge::LuaRef io = lua_dsp_configure (&in, &out);
 546                                 if (io.isTable ()) {
 547                                         ChanCount lin (_selected_in);
 548                                         ChanCount lout (_selected_out);
 549
 550                                         if (io["audio_in"].type() == LUA_TNUMBER) {
 551                                                 const int c = io["audio_in"].cast<int> ();
 552                                                 if (c >= 0) {
 553                                                         lin.set (DataType::AUDIO, c);
 554                                                 }
 555                                         }
 556                                         if (io["audio_out"].type() == LUA_TNUMBER) {
 557                                                 const int c = io["audio_out"].cast<int> ();
 558                                                 if (c >= 0) {
 559                                                         lout.set (DataType::AUDIO, c);
 560                                                 }
 561                                         }
 562                                         if (io["midi_in"].type() == LUA_TNUMBER) {
 563                                                 const int c = io["midi_in"].cast<int> ();
 564                                                 if (c >= 0) {
 565                                                         lin.set (DataType::MIDI, c);
 566                                                 }
 567                                         }
 568                                         if (io["midi_out"].type() == LUA_TNUMBER) {
 569                                                 const int c = io["midi_out"].cast<int> ();
 570                                                 if (c >= 0) {
 571                                                         lout.set (DataType::MIDI, c);
 572                                                 }
 573                                         }
 574                                         _info->n_inputs = lin;
 575                                         _info->n_outputs = lout;
 576                                 }
 577                                 _configured = true;
 578                         } catch (luabridge::LuaException const& e) {
 579                                 PBD::error << "LuaException: " << e.what () << "\n";
 580 #ifndef NDEBUG
 581                                 std::cerr << "LuaException: " << e.what () << "\n";
 582 #endif
 583                                 return false;
 584                         }
 585                 }
 586         }
 587
 588         _configured_in = in;
 589         _configured_out = out;
 590
 591         return true;
 592 }
 593
 594 int
 595 LuaProc::connect_and_run (BufferSet& bufs,
 596                 framepos_t start, framepos_t end, double speed,
 597                 ChanMapping in, ChanMapping out,
 598                 pframes_t nframes, framecnt_t offset)
 599 {
 600         if (!_lua_dsp) {
 601                 return 0;
 602         }
 603
 604         Plugin::connect_and_run (bufs, start, end, speed, in, out, nframes, offset);
 605
 606         // This is needed for ARDOUR::Session requests :(
 607         if (! SessionEvent::has_per_thread_pool ()) {
 608                 char name[64];
 609                 snprintf (name, 64, "Proc-%p", this);
 610                 pthread_set_name (name);
 611                 SessionEvent::create_per_thread_pool (name, 64);
 612                 PBD::notify_event_loops_about_thread_creation (pthread_self(), name, 64);
 613         }
 614
 615         uint32_t const n = parameter_count ();
 616         for (uint32_t i = 0; i < n; ++i) {
 617                 if (parameter_is_control (i) && parameter_is_input (i)) {
 618                         _control_data[i] = _shadow_data[i];
 619                 }
 620         }
 621
 622 #ifdef WITH_LUAPROC_STATS
 623         int64_t t0 = g_get_monotonic_time ();
 624 #endif
 625
 626         try {
 627                 if (_lua_does_channelmapping) {
 628                         // run the DSP function
 629                         (*_lua_dsp)(&bufs, in, out, nframes, offset);
 630                 } else {
 631                         // map buffers
 632                         BufferSet& silent_bufs  = _session.get_silent_buffers (ChanCount (DataType::AUDIO, 1));
 633                         BufferSet& scratch_bufs = _session.get_scratch_buffers (ChanCount (DataType::AUDIO, 1));
 634
 635                         lua_State* L = lua.getState ();
 636                         luabridge::LuaRef in_map (luabridge::newTable (L));
 637                         luabridge::LuaRef out_map (luabridge::newTable (L));
 638
 639                         const uint32_t audio_in = _configured_in.n_audio ();
 640                         const uint32_t audio_out = _configured_out.n_audio ();
 641                         const uint32_t midi_in = _configured_in.n_midi ();
 642
 643                         for (uint32_t ap = 0; ap < audio_in; ++ap) {
 644                                 bool valid;
 645                                 const uint32_t buf_index = in.get(DataType::AUDIO, ap, &valid);
 646                                 if (valid) {
 647                                         in_map[ap + 1] = bufs.get_audio (buf_index).data (offset);
 648                                 } else {
 649                                         in_map[ap + 1] = silent_bufs.get_audio (0).data (offset);
 650                                 }
 651                         }
 652                         for (uint32_t ap = 0; ap < audio_out; ++ap) {
 653                                 bool valid;
 654                                 const uint32_t buf_index = out.get(DataType::AUDIO, ap, &valid);
 655                                 if (valid) {
 656                                         out_map[ap + 1] = bufs.get_audio (buf_index).data (offset);
 657                                 } else {
 658                                         out_map[ap + 1] = scratch_bufs.get_audio (0).data (offset);
 659                                 }
 660                         }
 661
 662                         luabridge::LuaRef lua_midi_src_tbl (luabridge::newTable (L));
 663                         int e = 1; // > 1 port, we merge events (unsorted)
 664                         for (uint32_t mp = 0; mp < midi_in; ++mp) {
 665                                 bool valid;
 666                                 const uint32_t idx = in.get(DataType::MIDI, mp, &valid);
 667                                 if (valid) {
 668                                         for (MidiBuffer::iterator m = bufs.get_midi(idx).begin();
 669                                                         m != bufs.get_midi(idx).end(); ++m, ++e) {
 670                                                 const Evoral::MIDIEvent<framepos_t> ev(*m, false);
 671                                                 luabridge::LuaRef lua_midi_data (luabridge::newTable (L));
 672                                                 const uint8_t* data = ev.buffer();
 673                                                 for (uint32_t i = 0; i < ev.size(); ++i) {
 674                                                         lua_midi_data [i + 1] = data[i];
 675                                                 }
 676                                                 luabridge::LuaRef lua_midi_event (luabridge::newTable (L));
 677                                                 lua_midi_event["time"] = 1 + (*m).time();
 678                                                 lua_midi_event["data"] = lua_midi_data;
 679                                                 lua_midi_event["bytes"] = data;
 680                                                 lua_midi_event["size"] = ev.size();
 681                                                 lua_midi_src_tbl[e] = lua_midi_event;
 682                                         }
 683                                 }
 684                         }
 685
 686                         if (_has_midi_input) {
 687                                 // XXX TODO This needs a better solution than global namespace
 688                                 luabridge::push (L, lua_midi_src_tbl);
 689                                 lua_setglobal (L, "midiin");
 690                         }
 691
 692                         luabridge::LuaRef lua_midi_sink_tbl (luabridge::newTable (L));
 693                         if (_has_midi_output) {
 694                                 luabridge::push (L, lua_midi_sink_tbl);
 695                                 lua_setglobal (L, "midiout");
 696                         }
 697
 698                         // run the DSP function
 699                         (*_lua_dsp)(in_map, out_map, nframes);
 700
 701                         // copy back midi events
 702                         if (_has_midi_output && lua_midi_sink_tbl.isTable ()) {
 703                                 bool valid;
 704                                 const uint32_t idx = out.get(DataType::MIDI, 0, &valid);
 705                                 if (valid && bufs.count().n_midi() > idx) {
 706                                         MidiBuffer& mbuf = bufs.get_midi(idx);
 707                                         mbuf.silence(0, 0);
 708                                         for (luabridge::Iterator i (lua_midi_sink_tbl); !i.isNil (); ++i) {
 709                                                 if (!i.key ().isNumber ()) { continue; }
 710                                                 if (!i.value ()["time"].isNumber ()) { continue; }
 711                                                 if (!i.value ()["data"].isTable ()) { continue; }
 712                                                 luabridge::LuaRef data_tbl (i.value ()["data"]);
 713                                                 framepos_t tme = i.value ()["time"];
 714                                                 if (tme < 1 || tme > nframes) { continue; }
 715                                                 uint8_t data[64];
 716                                                 size_t size = 0;
 717                                                 for (luabridge::Iterator di (data_tbl); !di.isNil () && size < sizeof(data); ++di, ++size) {
 718                                                         data[size] = di.value ();
 719                                                 }
 720                                                 if (size > 0 && size < 64) {
 721                                                         mbuf.push_back(tme - 1, size, data);
 722                                                 }
 723                                         }
 724
 725                                 }
 726                         }
 727                 }
 728         } catch (luabridge::LuaException const& e) {
 729                 PBD::error << "LuaException: " << e.what () << "\n";
 730 #ifndef NDEBUG
 731                 std::cerr << "LuaException: " << e.what () << "\n";
 732 #endif
 733                 return -1;
 734         }
 735 #ifdef WITH_LUAPROC_STATS
 736         int64_t t1 = g_get_monotonic_time ();
 737 #endif
 738
 739         lua.collect_garbage_step ();
 740 #ifdef WITH_LUAPROC_STATS
 741         ++_stats_cnt;
 742         int64_t t2 = g_get_monotonic_time ();
 743         int64_t ela0 = t1 - t0;
 744         int64_t ela1 = t2 - t1;
 745         if (ela0 > _stats_max[0]) _stats_max[0] = ela0;
 746         if (ela1 > _stats_max[1]) _stats_max[1] = ela1;
 747         _stats_avg[0] += ela0;
 748         _stats_avg[1] += ela1;
 749 #endif
 750         return 0;
 751 }
 752
 753
 754 void
 755 LuaProc::add_state (XMLNode* root) const
 756 {
 757         XMLNode*    child;
 758         char        buf[32];
 759         LocaleGuard lg;
 760
 761         gchar* b64 = g_base64_encode ((const guchar*)_script.c_str (), _script.size ());
 762         std::string b64s (b64);
 763         g_free (b64);
 764         XMLNode* script_node = new XMLNode (X_("script"));
 765         script_node->add_property (X_("lua"), LUA_VERSION);
 766         script_node->add_content (b64s);
 767         root->add_child_nocopy (*script_node);
 768
 769         for (uint32_t i = 0; i < parameter_count(); ++i) {
 770                 if (parameter_is_input(i) && parameter_is_control(i)) {
 771                         child = new XMLNode("Port");
 772                         snprintf(buf, sizeof(buf), "%u", i);
 773                         child->add_property("id", std::string(buf));
 774                         snprintf(buf, sizeof(buf), "%+f", _shadow_data[i]);
 775                         child->add_property("value", std::string(buf));
 776                         root->add_child_nocopy(*child);
 777                 }
 778         }
 779 }
 780
 781 int
 782 LuaProc::set_script_from_state (const XMLNode& node)
 783 {
 784         XMLNode* child;
 785         if (node.name () != state_node_name ()) {
 786                 return -1;
 787         }
 788
 789         if ((child = node.child (X_("script"))) != 0) {
 790                 for (XMLNodeList::const_iterator n = child->children ().begin (); n != child->children ().end (); ++n) {
 791                         if (!(*n)->is_content ()) { continue; }
 792                         gsize size;
 793                         guchar* buf = g_base64_decode ((*n)->content ().c_str (), &size);
 794                         _script = std::string ((const char*)buf, size);
 795                         g_free (buf);
 796                         if (load_script ()) {
 797                                 PBD::error << _("Failed to load Lua script from session state.") << endmsg;
 798 #ifndef NDEBUG
 799                                 std::cerr << "Failed Lua Script: " << _script << std::endl;
 800 #endif
 801                                 _script = "";
 802                         }
 803                         break;
 804                 }
 805         }
 806         if (_script.empty ()) {
 807                 PBD::error << _("Session State for LuaProcessor did not include a Lua script.") << endmsg;
 808                 return -1;
 809         }
 810         if (!_lua_dsp) {
 811                 PBD::error << _("Invalid/incompatible Lua script found for LuaProcessor.") << endmsg;
 812                 return -1;
 813         }
 814         return 0;
 815 }
 816
 817 int
 818 LuaProc::set_state (const XMLNode& node, int version)
 819 {
 820 #ifndef NO_PLUGIN_STATE
 821         XMLNodeList nodes;
 822         XMLProperty const * prop;
 823         XMLNodeConstIterator iter;
 824         XMLNode *child;
 825         const char *value;
 826         const char *port;
 827         uint32_t port_id;
 828 #endif
 829         LocaleGuard lg;
 830
 831         if (_script.empty ()) {
 832                 if (set_script_from_state (node)) {
 833                         return -1;
 834                 }
 835         }
 836
 837 #ifndef NO_PLUGIN_STATE
 838         if (node.name() != state_node_name()) {
 839                 error << _("Bad node sent to LuaProc::set_state") << endmsg;
 840                 return -1;
 841         }
 842
 843         nodes = node.children ("Port");
 844         for (iter = nodes.begin(); iter != nodes.end(); ++iter) {
 845                 child = *iter;
 846                 if ((prop = child->property("id")) != 0) {
 847                         port = prop->value().c_str();
 848                 } else {
 849                         warning << _("LuaProc: port has no symbol, ignored") << endmsg;
 850                         continue;
 851                 }
 852                 if ((prop = child->property("value")) != 0) {
 853                         value = prop->value().c_str();
 854                 } else {
 855                         warning << _("LuaProc: port has no value, ignored") << endmsg;
 856                         continue;
 857                 }
 858                 sscanf (port, "%" PRIu32, &port_id);
 859                 set_parameter (port_id, atof(value));
 860         }
 861 #endif
 862
 863         return Plugin::set_state (node, version);
 864 }
 865
 866 uint32_t
 867 LuaProc::parameter_count () const
 868 {
 869         return _ctrl_params.size ();
 870 }
 871
 872 float
 873 LuaProc::default_value (uint32_t port)
 874 {
 875         if (_ctrl_params[port].first) {
 876                 assert (0);
 877                 return 0;
 878         }
 879         int lp = _ctrl_params[port].second;
 880         return _param_desc[lp].normal;
 881 }
 882
 883 void
 884 LuaProc::set_parameter (uint32_t port, float val)
 885 {
 886         assert (port < parameter_count ());
 887         if (get_parameter (port) == val) {
 888                 return;
 889         }
 890         _shadow_data[port] = val;
 891         Plugin::set_parameter (port, val);
 892 }
 893
 894 float
 895 LuaProc::get_parameter (uint32_t port) const
 896 {
 897         if (parameter_is_input (port)) {
 898                 return _shadow_data[port];
 899         } else {
 900                 return _control_data[port];
 901         }
 902 }
 903
 904 int
 905 LuaProc::get_parameter_descriptor (uint32_t port, ParameterDescriptor& desc) const
 906 {
 907         assert (port <= parameter_count ());
 908         int lp = _ctrl_params[port].second;
 909         const ParameterDescriptor& d (_param_desc.find(lp)->second);
 910
 911         desc.lower        = d.lower;
 912         desc.upper        = d.upper;
 913         desc.normal       = d.normal;
 914         desc.toggled      = d.toggled;
 915         desc.logarithmic  = d.logarithmic;
 916         desc.integer_step = d.integer_step;
 917         desc.sr_dependent = d.sr_dependent;
 918         desc.enumeration  = d.enumeration;
 919         desc.unit         = d.unit;
 920         desc.label        = d.label;
 921         desc.scale_points = d.scale_points;
 922
 923         desc.update_steps ();
 924         return 0;
 925 }
 926
 927 std::string
 928 LuaProc::get_parameter_docs (uint32_t port) const {
 929         assert (port <= parameter_count ());
 930         int lp = _ctrl_params[port].second;
 931         return _param_doc.find(lp)->second;
 932 }
 933
 934 uint32_t
 935 LuaProc::nth_parameter (uint32_t port, bool& ok) const
 936 {
 937         if (port < _ctrl_params.size ()) {
 938                 ok = true;
 939                 return port;
 940         }
 941         ok = false;
 942         return 0;
 943 }
 944
 945 bool
 946 LuaProc::parameter_is_input (uint32_t port) const
 947 {
 948         assert (port < _ctrl_params.size ());
 949         return (!_ctrl_params[port].first);
 950 }
 951
 952 bool
 953 LuaProc::parameter_is_output (uint32_t port) const
 954 {
 955         assert (port < _ctrl_params.size ());
 956         return (_ctrl_params[port].first);
 957 }
 958
 959 std::set<Evoral::Parameter>
 960 LuaProc::automatable () const
 961 {
 962         std::set<Evoral::Parameter> automatables;
 963         for (uint32_t i = 0; i < _ctrl_params.size (); ++i) {
 964                 if (parameter_is_input (i)) {
 965                         automatables.insert (automatables.end (), Evoral::Parameter (PluginAutomation, 0, i));
 966                 }
 967         }
 968         return automatables;
 969 }
 970
 971 std::string
 972 LuaProc::describe_parameter (Evoral::Parameter param)
 973 {
 974         if (param.type () == PluginAutomation && param.id () < parameter_count ()) {
 975                 int lp = _ctrl_params[param.id ()].second;
 976                 return _param_desc[lp].label;
 977         }
 978         return "??";
 979 }
 980
 981 void
 982 LuaProc::print_parameter (uint32_t param, char* buf, uint32_t len) const
 983 {
 984         if (buf && len) {
 985                 if (param < parameter_count ()) {
 986                         snprintf (buf, len, "%.3f", get_parameter (param));
 987                 } else {
 988                         strcat (buf, "0");
 989                 }
 990         }
 991 }
 992
 993 boost::shared_ptr<ScalePoints>
 994 LuaProc::parse_scale_points (luabridge::LuaRef* lr)
 995 {
 996         if (!(*lr)["scalepoints"].isTable()) {
 997                 return boost::shared_ptr<ScalePoints> ();
 998         }
 999
1000         int cnt = 0;
1001         boost::shared_ptr<ScalePoints> rv = boost::shared_ptr<ScalePoints>(new ScalePoints());
1002         luabridge::LuaRef scalepoints ((*lr)["scalepoints"]);
1003
1004         for (luabridge::Iterator i (scalepoints); !i.isNil (); ++i) {
1005                 if (!i.key ().isString ())    { continue; }
1006                 if (!i.value ().isNumber ())  { continue; }
1007                 rv->insert(make_pair(i.key ().cast<std::string> (),
1008                                         i.value ().cast<float> ()));
1009                 ++cnt;
1010         }
1011
1012         if (rv->size() > 0) {
1013                 return rv;
1014         }
1015         return boost::shared_ptr<ScalePoints> ();
1016 }
1017
1018 boost::shared_ptr<ScalePoints>
1019 LuaProc::get_scale_points (uint32_t port) const
1020 {
1021         int lp = _ctrl_params[port].second;
1022         return _param_desc.find(lp)->second.scale_points;
1023 }
1024
1025 void
1026 LuaProc::setup_lua_inline_gui (LuaState *lua_gui)
1027 {
1028         lua_State* LG = lua_gui->getState ();
1029         LuaBindings::stddef (LG);
1030         LuaBindings::common (LG);
1031         LuaBindings::dsp (LG);
1032         LuaBindings::osc (LG);
1033
1034         lua_gui->Print.connect (sigc::mem_fun (*this, &LuaProc::lua_print));
1035         lua_gui->do_command ("function ardour () end");
1036         lua_gui->do_command (_script);
1037
1038         // TODO think: use a weak-pointer here ?
1039         // (the GUI itself uses a shared ptr to this plugin, so we should be good)
1040         luabridge::getGlobalNamespace (LG)
1041                 .beginNamespace ("Ardour")
1042                 .beginClass <LuaProc> ("LuaProc")
1043                 .addFunction ("shmem", &LuaProc::instance_shm)
1044                 .addFunction ("table", &LuaProc::instance_ref)
1045                 .endClass ()
1046                 .endNamespace ();
1047
1048         luabridge::push <LuaProc *> (LG, this);
1049         lua_setglobal (LG, "self");
1050
1051         luabridge::push <float *> (LG, _control_data);
1052         lua_setglobal (LG, "CtrlPorts");
1053 }
1054 ////////////////////////////////////////////////////////////////////////////////
1055
1056 #include "ardour/search_paths.h"
1057 #include "sha1.c"
1058
1059 std::string
1060 LuaProc::preset_name_to_uri (const std::string& name) const
1061 {
1062         std::string uri ("urn:lua:");
1063         char hash[41];
1064         Sha1Digest s;
1065         sha1_init (&s);
1066         sha1_write (&s, (const uint8_t *) name.c_str(), name.size ());
1067         sha1_write (&s, (const uint8_t *) _script.c_str(), _script.size ());
1068         sha1_result_hash (&s, hash);
1069         return uri + hash;
1070 }
1071
1072 std::string
1073 LuaProc::presets_file () const
1074 {
1075         return string_compose ("lua-%1", _info->unique_id);
1076 }
1077
1078 XMLTree*
1079 LuaProc::presets_tree () const
1080 {
1081         XMLTree* t = new XMLTree;
1082         std::string p = Glib::build_filename (ARDOUR::user_config_directory (), "presets");
1083
1084         if (!Glib::file_test (p, Glib::FILE_TEST_IS_DIR)) {
1085                 if (g_mkdir_with_parents (p.c_str(), 0755) != 0) {
1086                         error << _("Unable to create LuaProc presets directory") << endmsg;
1087                 };
1088         }
1089
1090         p = Glib::build_filename (p, presets_file ());
1091
1092         if (!Glib::file_test (p, Glib::FILE_TEST_EXISTS)) {
1093                 t->set_root (new XMLNode (X_("LuaPresets")));
1094                 return t;
1095         }
1096
1097         t->set_filename (p);
1098         if (!t->read ()) {
1099                 delete t;
1100                 return 0;
1101         }
1102         return t;
1103 }
1104
1105 bool
1106 LuaProc::load_preset (PresetRecord r)
1107 {
1108         boost::shared_ptr<XMLTree> t (presets_tree ());
1109         if (t == 0) {
1110                 return false;
1111         }
1112
1113         XMLNode* root = t->root ();
1114         for (XMLNodeList::const_iterator i = root->children().begin(); i != root->children().end(); ++i) {
1115                 XMLProperty const * label = (*i)->property (X_("label"));
1116                 assert (label);
1117                 if (label->value() != r.label) {
1118                         continue;
1119                 }
1120
1121                 for (XMLNodeList::const_iterator j = (*i)->children().begin(); j != (*i)->children().end(); ++j) {
1122                         if ((*j)->name() == X_("Parameter")) {
1123                                 XMLProperty const * index = (*j)->property (X_("index"));
1124                                 XMLProperty const * value = (*j)->property (X_("value"));
1125                                 assert (index);
1126                                 assert (value);
1127                                 LocaleGuard lg;
1128                                 set_parameter (atoi (index->value().c_str()), atof (value->value().c_str ()));
1129                         }
1130                 }
1131                 return Plugin::load_preset(r);
1132         }
1133         return false;
1134 }
1135
1136 std::string
1137 LuaProc::do_save_preset (std::string name) {
1138
1139         boost::shared_ptr<XMLTree> t (presets_tree ());
1140         if (t == 0) {
1141                 return "";
1142         }
1143
1144         std::string uri (preset_name_to_uri (name));
1145
1146         XMLNode* p = new XMLNode (X_("Preset"));
1147         p->add_property (X_("uri"), uri);
1148         p->add_property (X_("label"), name);
1149
1150         for (uint32_t i = 0; i < parameter_count(); ++i) {
1151                 if (parameter_is_input (i)) {
1152                         XMLNode* c = new XMLNode (X_("Parameter"));
1153                         c->add_property (X_("index"), string_compose ("%1", i));
1154                         c->add_property (X_("value"), string_compose ("%1", get_parameter (i)));
1155                         p->add_child_nocopy (*c);
1156                 }
1157         }
1158         t->root()->add_child_nocopy (*p);
1159
1160         std::string f = Glib::build_filename (ARDOUR::user_config_directory (), "presets");
1161         f = Glib::build_filename (f, presets_file ());
1162
1163         t->write (f);
1164         return uri;
1165 }
1166
1167 void
1168 LuaProc::do_remove_preset (std::string name)
1169 {
1170         boost::shared_ptr<XMLTree> t (presets_tree ());
1171         if (t == 0) {
1172                 return;
1173         }
1174         t->root()->remove_nodes_and_delete (X_("label"), name);
1175         std::string f = Glib::build_filename (ARDOUR::user_config_directory (), "presets");
1176         f = Glib::build_filename (f, presets_file ());
1177         t->write (f);
1178 }
1179
1180 void
1181 LuaProc::find_presets ()
1182 {
1183         boost::shared_ptr<XMLTree> t (presets_tree ());
1184         if (t) {
1185                 XMLNode* root = t->root ();
1186                 for (XMLNodeList::const_iterator i = root->children().begin(); i != root->children().end(); ++i) {
1187
1188                         XMLProperty const * uri = (*i)->property (X_("uri"));
1189                         XMLProperty const * label = (*i)->property (X_("label"));
1190
1191                         assert (uri);
1192                         assert (label);
1193
1194                         PresetRecord r (uri->value(), label->value(), true);
1195                         _presets.insert (make_pair (r.uri, r));
1196                 }
1197         }
1198 }
1199
1200 ////////////////////////////////////////////////////////////////////////////////
1201
1202 LuaPluginInfo::LuaPluginInfo (LuaScriptInfoPtr lsi) {
1203         if (lsi->type != LuaScriptInfo::DSP) {
1204                 throw failed_constructor ();
1205         }
1206
1207         path = lsi->path;
1208         name = lsi->name;
1209         creator = lsi->author;
1210         category = lsi->category;
1211         unique_id = lsi->unique_id;
1212
1213         n_inputs.set (DataType::AUDIO, 1);
1214         n_outputs.set (DataType::AUDIO, 1);
1215         type = Lua;
1216
1217         _is_instrument = category == "Instrument";
1218 }
1219
1220 PluginPtr
1221 LuaPluginInfo::load (Session& session)
1222 {
1223         std::string script = "";
1224         if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
1225                 return PluginPtr ();
1226         }
1227
1228         try {
1229                 script = Glib::file_get_contents (path);
1230         } catch (Glib::FileError err) {
1231                 return PluginPtr ();
1232         }
1233
1234         if (script.empty ()) {
1235                 return PluginPtr ();
1236         }
1237
1238         try {
1239                 PluginPtr plugin (new LuaProc (session.engine (), session, script));
1240                 return plugin;
1241         } catch (failed_constructor& err) {
1242                 ;
1243         }
1244         return PluginPtr ();
1245 }
1246
1247 std::vector<Plugin::PresetRecord>
1248 LuaPluginInfo::get_presets (bool /*user_only*/) const
1249 {
1250         std::vector<Plugin::PresetRecord> p;
1251         XMLTree* t = new XMLTree;
1252         std::string pf = Glib::build_filename (ARDOUR::user_config_directory (), "presets", string_compose ("lua-%1", unique_id));
1253         if (Glib::file_test (pf, Glib::FILE_TEST_EXISTS)) {
1254                 t->set_filename (pf);
1255                 if (t->read ()) {
1256                         XMLNode* root = t->root ();
1257                         for (XMLNodeList::const_iterator i = root->children().begin(); i != root->children().end(); ++i) {
1258                                 XMLProperty const * uri = (*i)->property (X_("uri"));
1259                                 XMLProperty const * label = (*i)->property (X_("label"));
1260                                 p.push_back (Plugin::PresetRecord (uri->value(), label->value(), true));
1261                         }
1262                 }
1263         }
1264         delete t;
1265         return p;
1266 }