libs/surfaces/generic_midi/generic_midi_control_protocol.cc

   1 /*
   2     Copyright (C) 2006 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 */
  19
  20 #include <stdint.h>
  21
  22 #include <sstream>
  23 #include <algorithm>
  24
  25 #include <glibmm/fileutils.h>
  26 #include <glibmm/miscutils.h>
  27
  28 #include "pbd/error.h"
  29 #include "pbd/failed_constructor.h"
  30 #include "pbd/file_utils.h"
  31 #include "pbd/xml++.h"
  32 #include "pbd/compose.h"
  33
  34 #include "midi++/port.h"
  35
  36 #include "ardour/async_midi_port.h"
  37 #include "ardour/audioengine.h"
  38 #include "ardour/audioengine.h"
  39 #include "ardour/controllable_descriptor.h"
  40 #include "ardour/filesystem_paths.h"
  41 #include "ardour/session.h"
  42 #include "ardour/midi_ui.h"
  43 #include "ardour/rc_configuration.h"
  44 #include "ardour/midiport_manager.h"
  45 #include "ardour/debug.h"
  46
  47 #include "generic_midi_control_protocol.h"
  48 #include "midicontrollable.h"
  49 #include "midifunction.h"
  50 #include "midiaction.h"
  51
  52 using namespace ARDOUR;
  53 using namespace PBD;
  54 using namespace std;
  55
  56 #include "pbd/i18n.h"
  57
  58 #define midi_ui_context() MidiControlUI::instance() /* a UICallback-derived object that specifies the event loop for signal handling */
  59
  60 GenericMidiControlProtocol::GenericMidiControlProtocol (Session& s)
  61         : ControlProtocol (s, _("Generic MIDI"))
  62         , connection_state (ConnectionState (0))
  63         , _motorised (false)
  64         , _threshold (10)
  65         , gui (0)
  66 {
  67         _input_port = boost::dynamic_pointer_cast<AsyncMIDIPort> (s.midi_input_port ());
  68         _output_port = boost::dynamic_pointer_cast<AsyncMIDIPort> (s.midi_output_port ());
  69
  70         do_feedback = false;
  71         _feedback_interval = 10000; // microseconds
  72         last_feedback_time = 0;
  73
  74         _current_bank = 0;
  75         _bank_size = 0;
  76
  77         /* these signals are emitted by the MidiControlUI's event loop thread
  78          * and we may as well handle them right there in the same the same
  79          * thread
  80          */
  81
  82         Controllable::StartLearning.connect_same_thread (*this, boost::bind (&GenericMidiControlProtocol::start_learning, this, _1));
  83         Controllable::StopLearning.connect_same_thread (*this, boost::bind (&GenericMidiControlProtocol::stop_learning, this, _1));
  84         Controllable::CreateBinding.connect_same_thread (*this, boost::bind (&GenericMidiControlProtocol::create_binding, this, _1, _2, _3));
  85         Controllable::DeleteBinding.connect_same_thread (*this, boost::bind (&GenericMidiControlProtocol::delete_binding, this, _1));
  86
  87         /* this signal is emitted by the process() callback, and if
  88          * send_feedback() is going to do anything, it should do it in the
  89          * context of the process() callback itself.
  90          */
  91
  92         Session::SendFeedback.connect_same_thread (*this, boost::bind (&GenericMidiControlProtocol::send_feedback, this));
  93         //Session::SendFeedback.connect (*this, MISSING_INVALIDATOR, boost::bind (&GenericMidiControlProtocol::send_feedback, this), midi_ui_context());;
  94
  95         /* this one is cross-thread */
  96
  97         PresentationInfo::Change.connect (*this, MISSING_INVALIDATOR, boost::bind (&GenericMidiControlProtocol::reset_controllables, this), midi_ui_context());
  98
  99         /* Catch port connections and disconnections (cross-thread) */
 100         ARDOUR::AudioEngine::instance()->PortConnectedOrDisconnected.connect (port_connection, MISSING_INVALIDATOR,
 101                                                                               boost::bind (&GenericMidiControlProtocol::connection_handler, this, _1, _2, _3, _4, _5),
 102                                                                               midi_ui_context());
 103
 104         reload_maps ();
 105 }
 106
 107 GenericMidiControlProtocol::~GenericMidiControlProtocol ()
 108 {
 109         drop_all ();
 110         tear_down_gui ();
 111 }
 112
 113 static const char * const midimap_env_variable_name = "ARDOUR_MIDIMAPS_PATH";
 114 static const char* const midi_map_dir_name = "midi_maps";
 115 static const char* const midi_map_suffix = ".map";
 116
 117 Searchpath
 118 system_midi_map_search_path ()
 119 {
 120         bool midimap_path_defined = false;
 121         std::string spath_env (Glib::getenv (midimap_env_variable_name, midimap_path_defined));
 122
 123         if (midimap_path_defined) {
 124                 return spath_env;
 125         }
 126
 127         Searchpath spath (ardour_data_search_path());
 128         spath.add_subdirectory_to_paths(midi_map_dir_name);
 129         return spath;
 130 }
 131
 132 static std::string
 133 user_midi_map_directory ()
 134 {
 135         return Glib::build_filename (user_config_directory(), midi_map_dir_name);
 136 }
 137
 138 static bool
 139 midi_map_filter (const string &str, void* /*arg*/)
 140 {
 141         return (str.length() > strlen(midi_map_suffix) &&
 142                 str.find (midi_map_suffix) == (str.length() - strlen (midi_map_suffix)));
 143 }
 144
 145 void
 146 GenericMidiControlProtocol::reload_maps ()
 147 {
 148         vector<string> midi_maps;
 149         Searchpath spath (system_midi_map_search_path());
 150         spath += user_midi_map_directory ();
 151
 152         find_files_matching_filter (midi_maps, spath, midi_map_filter, 0, false, true);
 153
 154         if (midi_maps.empty()) {
 155                 cerr << "No MIDI maps found using " << spath.to_string() << endl;
 156                 return;
 157         }
 158
 159         for (vector<string>::iterator i = midi_maps.begin(); i != midi_maps.end(); ++i) {
 160                 string fullpath = *i;
 161
 162                 XMLTree tree;
 163
 164                 if (!tree.read (fullpath.c_str())) {
 165                         continue;
 166                 }
 167
 168                 MapInfo mi;
 169
 170                 XMLProperty const * prop = tree.root()->property ("name");
 171
 172                 if (!prop) {
 173                         continue;
 174                 }
 175
 176                 mi.name = prop->value ();
 177                 mi.path = fullpath;
 178
 179                 map_info.push_back (mi);
 180         }
 181 }
 182
 183 void
 184 GenericMidiControlProtocol::drop_all ()
 185 {
 186         DEBUG_TRACE (DEBUG::GenericMidi, "Drop all bindings\n");
 187         Glib::Threads::Mutex::Lock lm (pending_lock);
 188         Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 189
 190         for (MIDIControllables::iterator i = controllables.begin(); i != controllables.end(); ++i) {
 191                 delete *i;
 192         }
 193         controllables.clear ();
 194
 195         for (MIDIPendingControllables::iterator i = pending_controllables.begin(); i != pending_controllables.end(); ++i) {
 196                 delete *i;
 197         }
 198         pending_controllables.clear ();
 199
 200         for (MIDIFunctions::iterator i = functions.begin(); i != functions.end(); ++i) {
 201                 delete *i;
 202         }
 203         functions.clear ();
 204
 205         for (MIDIActions::iterator i = actions.begin(); i != actions.end(); ++i) {
 206                 delete *i;
 207         }
 208         actions.clear ();
 209 }
 210
 211 void
 212 GenericMidiControlProtocol::drop_bindings ()
 213 {
 214         DEBUG_TRACE (DEBUG::GenericMidi, "Drop bindings, leave learned\n");
 215         Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 216
 217         for (MIDIControllables::iterator i = controllables.begin(); i != controllables.end(); ) {
 218                 if (!(*i)->learned()) {
 219                         delete *i;
 220                         i = controllables.erase (i);
 221                 } else {
 222                         ++i;
 223                 }
 224         }
 225
 226         for (MIDIFunctions::iterator i = functions.begin(); i != functions.end(); ++i) {
 227                 delete *i;
 228         }
 229         functions.clear ();
 230
 231         _current_binding = "";
 232         _bank_size = 0;
 233         _current_bank = 0;
 234 }
 235
 236 int
 237 GenericMidiControlProtocol::set_active (bool /*yn*/)
 238 {
 239         /* nothing to do here: the MIDI UI thread in libardour handles all our
 240            I/O needs.
 241         */
 242         return 0;
 243 }
 244
 245 void
 246 GenericMidiControlProtocol::set_feedback_interval (microseconds_t ms)
 247 {
 248         _feedback_interval = ms;
 249 }
 250
 251 void
 252 GenericMidiControlProtocol::send_feedback ()
 253 {
 254         /* This is executed in RT "process" context", so no blocking calls
 255          */
 256
 257         if (!do_feedback) {
 258                 return;
 259         }
 260
 261         microseconds_t now = get_microseconds ();
 262
 263         if (last_feedback_time != 0) {
 264                 if ((now - last_feedback_time) < _feedback_interval) {
 265                         return;
 266                 }
 267         }
 268
 269         _send_feedback ();
 270
 271         last_feedback_time = now;
 272 }
 273
 274 void
 275 GenericMidiControlProtocol::_send_feedback ()
 276 {
 277         /* This is executed in RT "process" context", so no blocking calls
 278          */
 279
 280         const int32_t bufsize = 16 * 1024; /* XXX too big */
 281         MIDI::byte buf[bufsize];
 282         int32_t bsize = bufsize;
 283
 284         /* XXX: due to bugs in some ALSA / JACK MIDI bridges, we have to do separate
 285            writes for each controllable here; if we send more than one MIDI message
 286            in a single jack_midi_event_write then some bridges will only pass the
 287            first on to ALSA.
 288         */
 289
 290         Glib::Threads::Mutex::Lock lm (controllables_lock, Glib::Threads::TRY_LOCK);
 291         if (!lm.locked ()) {
 292                 return;
 293         }
 294
 295         for (MIDIControllables::iterator r = controllables.begin(); r != controllables.end(); ++r) {
 296                 MIDI::byte* end = (*r)->write_feedback (buf, bsize);
 297                 if (end != buf) {
 298                         _output_port->write (buf, (int32_t) (end - buf), 0);
 299                 }
 300         }
 301 }
 302
 303 bool
 304 GenericMidiControlProtocol::start_learning (Controllable* c)
 305 {
 306         if (c == 0) {
 307                 return false;
 308         }
 309
 310         Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 311         DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Learn binding: Controlable number: %1\n", c));
 312
 313         MIDIControllables::iterator tmp;
 314         for (MIDIControllables::iterator i = controllables.begin(); i != controllables.end(); ) {
 315                 tmp = i;
 316                 ++tmp;
 317                 if ((*i)->get_controllable() == c) {
 318                         delete (*i);
 319                         controllables.erase (i);
 320                 }
 321                 i = tmp;
 322         }
 323
 324         {
 325                 Glib::Threads::Mutex::Lock lm (pending_lock);
 326
 327                 MIDIPendingControllables::iterator ptmp;
 328                 for (MIDIPendingControllables::iterator i = pending_controllables.begin(); i != pending_controllables.end(); ) {
 329                         ptmp = i;
 330                         ++ptmp;
 331                         if (((*i)->first)->get_controllable() == c) {
 332                                 (*i)->second.disconnect();
 333                                 delete (*i)->first;
 334                                 delete *i;
 335                                 pending_controllables.erase (i);
 336                         }
 337                         i = ptmp;
 338                 }
 339         }
 340
 341         MIDIControllable* mc = 0;
 342
 343         for (MIDIControllables::iterator i = controllables.begin(); i != controllables.end(); ++i) {
 344                 if ((*i)->get_controllable() && ((*i)->get_controllable()->id() == c->id())) {
 345                         mc = *i;
 346                         break;
 347                 }
 348         }
 349
 350         if (!mc) {
 351                 mc = new MIDIControllable (this, *_input_port->parser(), *c, false);
 352         }
 353
 354         {
 355                 Glib::Threads::Mutex::Lock lm (pending_lock);
 356
 357                 MIDIPendingControllable* element = new MIDIPendingControllable;
 358                 element->first = mc;
 359                 c->LearningFinished.connect_same_thread (element->second, boost::bind (&GenericMidiControlProtocol::learning_stopped, this, mc));
 360
 361                 pending_controllables.push_back (element);
 362         }
 363         mc->learn_about_external_control ();
 364         return true;
 365 }
 366
 367 void
 368 GenericMidiControlProtocol::learning_stopped (MIDIControllable* mc)
 369 {
 370         Glib::Threads::Mutex::Lock lm (pending_lock);
 371         Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 372
 373         MIDIPendingControllables::iterator tmp;
 374
 375         for (MIDIPendingControllables::iterator i = pending_controllables.begin(); i != pending_controllables.end(); ) {
 376                 tmp = i;
 377                 ++tmp;
 378
 379                 if ( (*i)->first == mc) {
 380                         (*i)->second.disconnect();
 381                         delete *i;
 382                         pending_controllables.erase(i);
 383                 }
 384
 385                 i = tmp;
 386         }
 387
 388         controllables.push_back (mc);
 389 }
 390
 391 void
 392 GenericMidiControlProtocol::stop_learning (Controllable* c)
 393 {
 394         Glib::Threads::Mutex::Lock lm (pending_lock);
 395         Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 396         MIDIControllable* dptr = 0;
 397
 398         /* learning timed out, and we've been told to consider this attempt to learn to be cancelled. find the
 399            relevant MIDIControllable and remove it from the pending list.
 400         */
 401
 402         for (MIDIPendingControllables::iterator i = pending_controllables.begin(); i != pending_controllables.end(); ++i) {
 403                 if (((*i)->first)->get_controllable() == c) {
 404                         (*i)->first->stop_learning ();
 405                         dptr = (*i)->first;
 406                         (*i)->second.disconnect();
 407
 408                         delete *i;
 409                         pending_controllables.erase (i);
 410                         break;
 411                 }
 412         }
 413
 414         delete dptr;
 415 }
 416
 417 void
 418 GenericMidiControlProtocol::delete_binding (PBD::Controllable* control)
 419 {
 420         if (control != 0) {
 421                 Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 422
 423                 for (MIDIControllables::iterator iter = controllables.begin(); iter != controllables.end();) {
 424                         MIDIControllable* existingBinding = (*iter);
 425
 426                         if (control == (existingBinding->get_controllable())) {
 427                                 delete existingBinding;
 428                                 iter = controllables.erase (iter);
 429                         } else {
 430                                 ++iter;
 431                         }
 432
 433                 }
 434         }
 435 }
 436
 437 // This next function seems unused
 438 void
 439 GenericMidiControlProtocol::create_binding (PBD::Controllable* control, int pos, int control_number)
 440 {
 441         if (control != NULL) {
 442                 Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 443
 444                 MIDI::channel_t channel = (pos & 0xf);
 445                 MIDI::byte value = control_number;
 446
 447                 // Create a MIDIControllable
 448                 MIDIControllable* mc = new MIDIControllable (this, *_input_port->parser(), *control, false);
 449
 450                 // Remove any old binding for this midi channel/type/value pair
 451                 // Note:  can't use delete_binding() here because we don't know the specific controllable we want to remove, only the midi information
 452                 for (MIDIControllables::iterator iter = controllables.begin(); iter != controllables.end();) {
 453                         MIDIControllable* existingBinding = (*iter);
 454
 455                         if ((existingBinding->get_control_channel() & 0xf ) == channel &&
 456                             existingBinding->get_control_additional() == value &&
 457                             (existingBinding->get_control_type() & 0xf0 ) == MIDI::controller) {
 458
 459                                 delete existingBinding;
 460                                 iter = controllables.erase (iter);
 461                         } else {
 462                                 ++iter;
 463                         }
 464
 465                 }
 466
 467                 // Update the MIDI Controllable based on the the pos param
 468                 // Here is where a table lookup for user mappings could go; for now we'll just wing it...
 469                 mc->bind_midi(channel, MIDI::controller, value);
 470                 DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Create binding: Channel: %1 Controller: %2 Value: %3 \n", channel, MIDI::controller, value));
 471                 controllables.push_back (mc);
 472         }
 473 }
 474
 475 void
 476 GenericMidiControlProtocol::check_used_event (int pos, int control_number)
 477 {
 478         Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 479
 480         MIDI::channel_t channel = (pos & 0xf);
 481         MIDI::byte value = control_number;
 482
 483         DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("checking for used event: Channel: %1 Controller: %2 value: %3\n", (int) channel, (pos & 0xf0), (int) value));
 484
 485         // Remove any old binding for this midi channel/type/value pair
 486         // Note:  can't use delete_binding() here because we don't know the specific controllable we want to remove, only the midi information
 487         for (MIDIControllables::iterator iter = controllables.begin(); iter != controllables.end();) {
 488                 MIDIControllable* existingBinding = (*iter);
 489                 if ( (existingBinding->get_control_type() & 0xf0 ) == (pos & 0xf0) && (existingBinding->get_control_channel() & 0xf ) == channel ) {
 490                         if ( ((int) existingBinding->get_control_additional() == (int) value) || ((pos & 0xf0) == MIDI::pitchbend)) {
 491                                 DEBUG_TRACE (DEBUG::GenericMidi, "checking: found match, delete old binding.\n");
 492                                 delete existingBinding;
 493                                 iter = controllables.erase (iter);
 494                         } else {
 495                                 ++iter;
 496                         }
 497                 } else {
 498                         ++iter;
 499                 }
 500         }
 501
 502         for (MIDIFunctions::iterator iter = functions.begin(); iter != functions.end();) {
 503                 MIDIFunction* existingBinding = (*iter);
 504                 if ( (existingBinding->get_control_type() & 0xf0 ) == (pos & 0xf0) && (existingBinding->get_control_channel() & 0xf ) == channel ) {
 505                         if ( ((int) existingBinding->get_control_additional() == (int) value) || ((pos & 0xf0) == MIDI::pitchbend)) {
 506                                 DEBUG_TRACE (DEBUG::GenericMidi, "checking: found match, delete old binding.\n");
 507                                 delete existingBinding;
 508                                 iter = functions.erase (iter);
 509                         } else {
 510                                 ++iter;
 511                         }
 512                 } else {
 513                         ++iter;
 514                 }
 515         }
 516
 517         for (MIDIActions::iterator iter = actions.begin(); iter != actions.end();) {
 518                 MIDIAction* existingBinding = (*iter);
 519                 if ( (existingBinding->get_control_type() & 0xf0 ) == (pos & 0xf0) && (existingBinding->get_control_channel() & 0xf ) == channel ) {
 520                         if ( ((int) existingBinding->get_control_additional() == (int) value) || ((pos & 0xf0) == MIDI::pitchbend)) {
 521                                 DEBUG_TRACE (DEBUG::GenericMidi, "checking: found match, delete old binding.\n");
 522                                 delete existingBinding;
 523                                 iter = actions.erase (iter);
 524                         } else {
 525                                 ++iter;
 526                         }
 527                 } else {
 528                         ++iter;
 529                 }
 530         }
 531
 532 }
 533
 534 XMLNode&
 535 GenericMidiControlProtocol::get_state ()
 536 {
 537         XMLNode& node (ControlProtocol::get_state());
 538         char buf[32];
 539
 540         snprintf (buf, sizeof (buf), "%" PRIu64, _feedback_interval);
 541         node.add_property (X_("feedback_interval"), buf);
 542         snprintf (buf, sizeof (buf), "%d", _threshold);
 543         node.add_property (X_("threshold"), buf);
 544
 545         node.add_property (X_("motorized"), _motorised ? "yes" : "no");
 546
 547         if (!_current_binding.empty()) {
 548                 node.add_property ("binding", _current_binding);
 549         }
 550
 551         XMLNode* children = new XMLNode (X_("Controls"));
 552
 553         node.add_child_nocopy (*children);
 554
 555         Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 556         for (MIDIControllables::iterator i = controllables.begin(); i != controllables.end(); ++i) {
 557
 558                 /* we don't care about bindings that come from a bindings map, because
 559                    they will all be reset/recreated when we load the relevant bindings
 560                    file.
 561                 */
 562
 563                 if ((*i)->get_controllable() && (*i)->learned()) {
 564                         children->add_child_nocopy ((*i)->get_state());
 565                 }
 566         }
 567
 568         return node;
 569 }
 570
 571 int
 572 GenericMidiControlProtocol::set_state (const XMLNode& node, int version)
 573 {
 574         XMLNodeList nlist;
 575         XMLNodeConstIterator niter;
 576         const XMLProperty* prop;
 577
 578         if (ControlProtocol::set_state (node, version)) {
 579                 return -1;
 580         }
 581
 582         if ((prop = node.property ("feedback_interval")) != 0) {
 583                 if (sscanf (prop->value().c_str(), "%" PRIu64, &_feedback_interval) != 1) {
 584                         _feedback_interval = 10000;
 585                 }
 586         } else {
 587                 _feedback_interval = 10000;
 588         }
 589
 590         if ((prop = node.property ("threshold")) != 0) {
 591                 if (sscanf (prop->value().c_str(), "%d", &_threshold) != 1) {
 592                         _threshold = 10;
 593                 }
 594         } else {
 595                 _threshold = 10;
 596         }
 597
 598         if ((prop = node.property ("motorized")) != 0) {
 599                 _motorised = string_is_affirmative (prop->value ());
 600         } else {
 601                 _motorised = false;
 602         }
 603
 604         boost::shared_ptr<Controllable> c;
 605
 606         {
 607                 Glib::Threads::Mutex::Lock lm (pending_lock);
 608                 for (MIDIPendingControllables::iterator i = pending_controllables.begin(); i != pending_controllables.end(); ++i) {
 609                         delete *i;
 610                 }
 611                 pending_controllables.clear ();
 612         }
 613
 614         // midi map has to be loaded first so learned binding can go on top
 615         if ((prop = node.property ("binding")) != 0) {
 616                 for (list<MapInfo>::iterator x = map_info.begin(); x != map_info.end(); ++x) {
 617                         if (prop->value() == (*x).name) {
 618                                 load_bindings ((*x).path);
 619                                 break;
 620                         }
 621                 }
 622         }
 623
 624         /* Load up specific bindings from the
 625          * <Controls><MidiControllable>...</MidiControllable><Controls> section
 626          */
 627
 628         {
 629                 Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 630                 nlist = node.children(); // "Controls"
 631
 632                 if (!nlist.empty()) {
 633                         nlist = nlist.front()->children(); // "MIDIControllable" ...
 634
 635                         if (!nlist.empty()) {
 636                                 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
 637
 638                                         if ((prop = (*niter)->property ("id")) != 0) {
 639
 640                                                 ID id = prop->value ();
 641                                                 DEBUG_TRACE (DEBUG::GenericMidi, string_compose ("Relearned binding for session: Control ID: %1\n", id.to_s()));
 642                                                 Controllable* c = Controllable::by_id (id);
 643
 644                                                 if (c) {
 645                                                         MIDIControllable* mc = new MIDIControllable (this, *_input_port->parser(), *c, false);
 646
 647                                                         if (mc->set_state (**niter, version) == 0) {
 648                                                                 controllables.push_back (mc);
 649                                                         }
 650
 651                                                 } else {
 652                                                         warning << string_compose (
 653                                                                 _("Generic MIDI control: controllable %1 not found in session (ignored)"),
 654                                                                 id.to_s()) << endmsg;
 655                                                 }
 656                                         }
 657                                 }
 658                         }
 659                 }
 660         }
 661
 662         return 0;
 663 }
 664
 665 int
 666 GenericMidiControlProtocol::set_feedback (bool yn)
 667 {
 668         do_feedback = yn;
 669         last_feedback_time = 0;
 670         return 0;
 671 }
 672
 673 bool
 674 GenericMidiControlProtocol::get_feedback () const
 675 {
 676         return do_feedback;
 677 }
 678
 679 int
 680 GenericMidiControlProtocol::load_bindings (const string& xmlpath)
 681 {
 682         DEBUG_TRACE (DEBUG::GenericMidi, "Load bindings: Reading midi map\n");
 683         XMLTree state_tree;
 684
 685         if (!state_tree.read (xmlpath.c_str())) {
 686                 error << string_compose(_("Could not understand MIDI bindings file %1"), xmlpath) << endmsg;
 687                 return -1;
 688         }
 689
 690         XMLNode* root = state_tree.root();
 691
 692         if (root->name() != X_("ArdourMIDIBindings")) {
 693                 error << string_compose (_("MIDI Bindings file %1 is not really a MIDI bindings file"), xmlpath) << endmsg;
 694                 return -1;
 695         }
 696
 697         const XMLProperty* prop;
 698
 699         if ((prop = root->property ("version")) == 0) {
 700                 return -1;
 701         } else {
 702                 int major;
 703                 int minor;
 704                 int micro;
 705
 706                 sscanf (prop->value().c_str(), "%d.%d.%d", &major, &minor, &micro);
 707                 Stateful::loading_state_version = (major * 1000) + minor;
 708         }
 709
 710         const XMLNodeList& children (root->children());
 711         XMLNodeConstIterator citer;
 712         XMLNodeConstIterator gciter;
 713
 714         MIDIControllable* mc;
 715
 716         drop_all ();
 717
 718         DEBUG_TRACE (DEBUG::GenericMidi, "Loading bindings\n");
 719         for (citer = children.begin(); citer != children.end(); ++citer) {
 720
 721                 if ((*citer)->name() == "DeviceInfo") {
 722                         const XMLProperty* prop;
 723
 724                         if ((prop = (*citer)->property ("bank-size")) != 0) {
 725                                 _bank_size = atoi (prop->value());
 726                                 _current_bank = 0;
 727                         }
 728
 729                         if ((prop = (*citer)->property ("motorized")) != 0) {
 730                                 _motorised = string_is_affirmative (prop->value ());
 731                         } else {
 732                                 _motorised = false;
 733                         }
 734
 735                         if ((prop = (*citer)->property ("threshold")) != 0) {
 736                                 _threshold = atoi (prop->value ());
 737                         } else {
 738                                 _threshold = 10;
 739                         }
 740
 741                 }
 742
 743                 if ((*citer)->name() == "Binding") {
 744                         const XMLNode* child = *citer;
 745
 746                         if (child->property ("uri")) {
 747                                 /* controllable */
 748
 749                                 if ((mc = create_binding (*child)) != 0) {
 750                                         Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 751                                         controllables.push_back (mc);
 752                                 }
 753
 754                         } else if (child->property ("function")) {
 755
 756                                 /* function */
 757                                 MIDIFunction* mf;
 758
 759                                 if ((mf = create_function (*child)) != 0) {
 760                                         functions.push_back (mf);
 761                                 }
 762
 763                         } else if (child->property ("action")) {
 764                                 MIDIAction* ma;
 765
 766                                 if ((ma = create_action (*child)) != 0) {
 767                                         actions.push_back (ma);
 768                                 }
 769                         }
 770                 }
 771         }
 772
 773         if ((prop = root->property ("name")) != 0) {
 774                 _current_binding = prop->value ();
 775         }
 776
 777         reset_controllables ();
 778
 779         return 0;
 780 }
 781
 782 MIDIControllable*
 783 GenericMidiControlProtocol::create_binding (const XMLNode& node)
 784 {
 785         const XMLProperty* prop;
 786         MIDI::byte detail;
 787         MIDI::channel_t channel;
 788         string uri;
 789         MIDI::eventType ev;
 790         int intval;
 791         bool momentary;
 792         MIDIControllable::Encoder encoder = MIDIControllable::No_enc;
 793         bool rpn_value = false;
 794         bool nrpn_value = false;
 795         bool rpn_change = false;
 796         bool nrpn_change = false;
 797
 798         if ((prop = node.property (X_("ctl"))) != 0) {
 799                 ev = MIDI::controller;
 800         } else if ((prop = node.property (X_("note"))) != 0) {
 801                 ev = MIDI::on;
 802         } else if ((prop = node.property (X_("pgm"))) != 0) {
 803                 ev = MIDI::program;
 804         } else if ((prop = node.property (X_("pb"))) != 0) {
 805                 ev = MIDI::pitchbend;
 806         } else if ((prop = node.property (X_("enc-l"))) != 0) {
 807                 encoder = MIDIControllable::Enc_L;
 808                 ev = MIDI::controller;
 809         } else if ((prop = node.property (X_("enc-r"))) != 0) {
 810                 encoder = MIDIControllable::Enc_R;
 811                 ev = MIDI::controller;
 812         } else if ((prop = node.property (X_("enc-2"))) != 0) {
 813                 encoder = MIDIControllable::Enc_2;
 814                 ev = MIDI::controller;
 815         } else if ((prop = node.property (X_("enc-b"))) != 0) {
 816                 encoder = MIDIControllable::Enc_B;
 817                 ev = MIDI::controller;
 818         } else if ((prop = node.property (X_("rpn"))) != 0) {
 819                 rpn_value = true;
 820         } else if ((prop = node.property (X_("nrpn"))) != 0) {
 821                 nrpn_value = true;
 822         } else if ((prop = node.property (X_("rpn-delta"))) != 0) {
 823                 rpn_change = true;
 824         } else if ((prop = node.property (X_("nrpn-delta"))) != 0) {
 825                 nrpn_change = true;
 826         } else {
 827                 return 0;
 828         }
 829
 830         if (sscanf (prop->value().c_str(), "%d", &intval) != 1) {
 831                 return 0;
 832         }
 833
 834         detail = (MIDI::byte) intval;
 835
 836         if ((prop = node.property (X_("channel"))) == 0) {
 837                 return 0;
 838         }
 839
 840         if (sscanf (prop->value().c_str(), "%d", &intval) != 1) {
 841                 return 0;
 842         }
 843         channel = (MIDI::channel_t) intval;
 844         /* adjust channel to zero-based counting */
 845         if (channel > 0) {
 846                 channel -= 1;
 847         }
 848
 849         if ((prop = node.property (X_("momentary"))) != 0) {
 850                 momentary = string_is_affirmative (prop->value());
 851         } else {
 852                 momentary = false;
 853         }
 854
 855         prop = node.property (X_("uri"));
 856         uri = prop->value();
 857
 858         MIDIControllable* mc = new MIDIControllable (this, *_input_port->parser(), momentary);
 859
 860         if (mc->init (uri)) {
 861                 delete mc;
 862                 return 0;
 863         }
 864
 865         if (rpn_value) {
 866                 mc->bind_rpn_value (channel, detail);
 867         } else if (nrpn_value) {
 868                 mc->bind_nrpn_value (channel, detail);
 869         } else if (rpn_change) {
 870                 mc->bind_rpn_change (channel, detail);
 871         } else if (nrpn_change) {
 872                 mc->bind_nrpn_change (channel, detail);
 873         } else {
 874                 mc->set_encoder (encoder);
 875                 mc->bind_midi (channel, ev, detail);
 876         }
 877
 878         return mc;
 879 }
 880
 881 void
 882 GenericMidiControlProtocol::reset_controllables ()
 883 {
 884         Glib::Threads::Mutex::Lock lm2 (controllables_lock);
 885
 886         for (MIDIControllables::iterator iter = controllables.begin(); iter != controllables.end(); ) {
 887                 MIDIControllable* existingBinding = (*iter);
 888                 MIDIControllables::iterator next = iter;
 889                 ++next;
 890
 891                 if (!existingBinding->learned()) {
 892                         ControllableDescriptor& desc (existingBinding->descriptor());
 893
 894                         if (desc.banked()) {
 895                                 desc.set_bank_offset (_current_bank * _bank_size);
 896                         }
 897
 898                         /* its entirely possible that the session doesn't have
 899                          * the specified controllable (e.g. it has too few
 900                          * tracks). if we find this to be the case, we just leave
 901                          * the binding around, unbound, and it will do "late
 902                          * binding" (or "lazy binding") if/when any data arrives.
 903                          */
 904
 905                         existingBinding->lookup_controllable ();
 906                 }
 907
 908                 iter = next;
 909         }
 910 }
 911
 912 boost::shared_ptr<Controllable>
 913 GenericMidiControlProtocol::lookup_controllable (const ControllableDescriptor& desc) const
 914 {
 915         return session->controllable_by_descriptor (desc);
 916 }
 917
 918 MIDIFunction*
 919 GenericMidiControlProtocol::create_function (const XMLNode& node)
 920 {
 921         const XMLProperty* prop;
 922         int intval;
 923         MIDI::byte detail = 0;
 924         MIDI::channel_t channel = 0;
 925         string uri;
 926         MIDI::eventType ev;
 927         MIDI::byte* data = 0;
 928         uint32_t data_size = 0;
 929         string argument;
 930
 931         if ((prop = node.property (X_("ctl"))) != 0) {
 932                 ev = MIDI::controller;
 933         } else if ((prop = node.property (X_("note"))) != 0) {
 934                 ev = MIDI::on;
 935         } else if ((prop = node.property (X_("pgm"))) != 0) {
 936                 ev = MIDI::program;
 937         } else if ((prop = node.property (X_("sysex"))) != 0 || (prop = node.property (X_("msg"))) != 0) {
 938
 939                 if (prop->name() == X_("sysex")) {
 940                         ev = MIDI::sysex;
 941                 } else {
 942                         ev = MIDI::any;
 943                 }
 944
 945                 int val;
 946                 uint32_t cnt;
 947
 948                 {
 949                         cnt = 0;
 950                         stringstream ss (prop->value());
 951                         ss << hex;
 952
 953                         while (ss >> val) {
 954                                 cnt++;
 955                         }
 956                 }
 957
 958                 if (cnt == 0) {
 959                         return 0;
 960                 }
 961
 962                 data = new MIDI::byte[cnt];
 963                 data_size = cnt;
 964
 965                 {
 966                         stringstream ss (prop->value());
 967                         ss << hex;
 968                         cnt = 0;
 969
 970                         while (ss >> val) {
 971                                 data[cnt++] = (MIDI::byte) val;
 972                         }
 973                 }
 974
 975         } else {
 976                 warning << "Binding ignored - unknown type" << endmsg;
 977                 return 0;
 978         }
 979
 980         if (data_size == 0) {
 981                 if (sscanf (prop->value().c_str(), "%d", &intval) != 1) {
 982                         return 0;
 983                 }
 984
 985                 detail = (MIDI::byte) intval;
 986
 987                 if ((prop = node.property (X_("channel"))) == 0) {
 988                         return 0;
 989                 }
 990
 991                 if (sscanf (prop->value().c_str(), "%d", &intval) != 1) {
 992                         return 0;
 993                 }
 994                 channel = (MIDI::channel_t) intval;
 995                 /* adjust channel to zero-based counting */
 996                 if (channel > 0) {
 997                         channel -= 1;
 998                 }
 999         }
1000
1001         if ((prop = node.property (X_("arg"))) != 0 || (prop = node.property (X_("argument"))) != 0 || (prop = node.property (X_("arguments"))) != 0) {
1002                 argument = prop->value ();
1003         }
1004
1005         prop = node.property (X_("function"));
1006
1007         MIDIFunction* mf = new MIDIFunction (*_input_port->parser());
1008
1009         if (mf->setup (*this, prop->value(), argument, data, data_size)) {
1010                 delete mf;
1011                 return 0;
1012         }
1013
1014         mf->bind_midi (channel, ev, detail);
1015
1016         return mf;
1017 }
1018
1019 MIDIAction*
1020 GenericMidiControlProtocol::create_action (const XMLNode& node)
1021 {
1022         const XMLProperty* prop;
1023         int intval;
1024         MIDI::byte detail = 0;
1025         MIDI::channel_t channel = 0;
1026         string uri;
1027         MIDI::eventType ev;
1028         MIDI::byte* data = 0;
1029         uint32_t data_size = 0;
1030
1031         if ((prop = node.property (X_("ctl"))) != 0) {
1032                 ev = MIDI::controller;
1033         } else if ((prop = node.property (X_("note"))) != 0) {
1034                 ev = MIDI::on;
1035         } else if ((prop = node.property (X_("pgm"))) != 0) {
1036                 ev = MIDI::program;
1037         } else if ((prop = node.property (X_("sysex"))) != 0 || (prop = node.property (X_("msg"))) != 0) {
1038
1039                 if (prop->name() == X_("sysex")) {
1040                         ev = MIDI::sysex;
1041                 } else {
1042                         ev = MIDI::any;
1043                 }
1044
1045                 int val;
1046                 uint32_t cnt;
1047
1048                 {
1049                         cnt = 0;
1050                         stringstream ss (prop->value());
1051                         ss << hex;
1052
1053                         while (ss >> val) {
1054                                 cnt++;
1055                         }
1056                 }
1057
1058                 if (cnt == 0) {
1059                         return 0;
1060                 }
1061
1062                 data = new MIDI::byte[cnt];
1063                 data_size = cnt;
1064
1065                 {
1066                         stringstream ss (prop->value());
1067                         ss << hex;
1068                         cnt = 0;
1069
1070                         while (ss >> val) {
1071                                 data[cnt++] = (MIDI::byte) val;
1072                         }
1073                 }
1074
1075         } else {
1076                 warning << "Binding ignored - unknown type" << endmsg;
1077                 return 0;
1078         }
1079
1080         if (data_size == 0) {
1081                 if (sscanf (prop->value().c_str(), "%d", &intval) != 1) {
1082                         return 0;
1083                 }
1084
1085                 detail = (MIDI::byte) intval;
1086
1087                 if ((prop = node.property (X_("channel"))) == 0) {
1088                         return 0;
1089                 }
1090
1091                 if (sscanf (prop->value().c_str(), "%d", &intval) != 1) {
1092                         return 0;
1093                 }
1094                 channel = (MIDI::channel_t) intval;
1095                 /* adjust channel to zero-based counting */
1096                 if (channel > 0) {
1097                         channel -= 1;
1098                 }
1099         }
1100
1101         prop = node.property (X_("action"));
1102
1103         MIDIAction* ma = new MIDIAction (*_input_port->parser());
1104
1105         if (ma->init (*this, prop->value(), data, data_size)) {
1106                 delete ma;
1107                 return 0;
1108         }
1109
1110         ma->bind_midi (channel, ev, detail);
1111
1112         return ma;
1113 }
1114
1115 void
1116 GenericMidiControlProtocol::set_current_bank (uint32_t b)
1117 {
1118         _current_bank = b;
1119         reset_controllables ();
1120 }
1121
1122 void
1123 GenericMidiControlProtocol::next_bank ()
1124 {
1125         _current_bank++;
1126         reset_controllables ();
1127 }
1128
1129 void
1130 GenericMidiControlProtocol::prev_bank()
1131 {
1132         if (_current_bank) {
1133                 _current_bank--;
1134                 reset_controllables ();
1135         }
1136 }
1137
1138 void
1139 GenericMidiControlProtocol::set_motorised (bool m)
1140 {
1141         _motorised = m;
1142 }
1143
1144 void
1145 GenericMidiControlProtocol::set_threshold (int t)
1146 {
1147         _threshold = t;
1148 }
1149
1150 bool
1151 GenericMidiControlProtocol::connection_handler (boost::weak_ptr<ARDOUR::Port>, std::string name1, boost::weak_ptr<ARDOUR::Port>, std::string name2, bool yn)
1152 {
1153         if (!_input_port || !_output_port) {
1154                 return false;
1155         }
1156
1157         string ni = ARDOUR::AudioEngine::instance()->make_port_name_non_relative (boost::shared_ptr<ARDOUR::Port>(_input_port)->name());
1158         string no = ARDOUR::AudioEngine::instance()->make_port_name_non_relative (boost::shared_ptr<ARDOUR::Port>(_output_port)->name());
1159
1160         if (ni == name1 || ni == name2) {
1161                 if (yn) {
1162                         connection_state |= InputConnected;
1163                 } else {
1164                         connection_state &= ~InputConnected;
1165                 }
1166         } else if (no == name1 || no == name2) {
1167                 if (yn) {
1168                         connection_state |= OutputConnected;
1169                 } else {
1170                         connection_state &= ~OutputConnected;
1171                 }
1172         } else {
1173                 /* not our ports */
1174                 return false;
1175         }
1176
1177         if ((connection_state & (InputConnected|OutputConnected)) == (InputConnected|OutputConnected)) {
1178
1179                 /* XXX this is a horrible hack. Without a short sleep here,
1180                    something prevents the device wakeup messages from being
1181                    sent and/or the responses from being received.
1182                 */
1183
1184                 g_usleep (100000);
1185                 connected ();
1186
1187         } else {
1188
1189         }
1190
1191         ConnectionChange (); /* emit signal for our GUI */
1192
1193         return true; /* connection status changed */
1194 }
1195
1196 void
1197 GenericMidiControlProtocol::connected ()
1198 {
1199         cerr << "Now connected\n";
1200 }
1201
1202 boost::shared_ptr<Port>
1203 GenericMidiControlProtocol::output_port() const
1204 {
1205         return _output_port;
1206 }
1207
1208 boost::shared_ptr<Port>
1209 GenericMidiControlProtocol::input_port() const
1210 {
1211         return _input_port;
1212 }