libs/surfaces/faderport/faderport.cc

   1 /*
   2     Copyright (C) 2015 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 <cstdlib>
  21 #include <sstream>
  22 #include <algorithm>
  23
  24 #include <stdint.h>
  25
  26 #include <glibmm/fileutils.h>
  27 #include <glibmm/miscutils.h>
  28
  29 #include "pbd/controllable_descriptor.h"
  30 #include "pbd/error.h"
  31 #include "pbd/failed_constructor.h"
  32 #include "pbd/file_utils.h"
  33 #include "pbd/pthread_utils.h"
  34 #include "pbd/compose.h"
  35 #include "pbd/xml++.h"
  36
  37 #include "midi++/port.h"
  38
  39 #include "ardour/async_midi_port.h"
  40 #include "ardour/audioengine.h"
  41 #include "ardour/amp.h"
  42 #include "ardour/bundle.h"
  43 #include "ardour/debug.h"
  44 #include "ardour/filesystem_paths.h"
  45 #include "ardour/midi_port.h"
  46 #include "ardour/midiport_manager.h"
  47 #include "ardour/monitor_processor.h"
  48 #include "ardour/profile.h"
  49 #include "ardour/rc_configuration.h"
  50 #include "ardour/route.h"
  51 #include "ardour/session.h"
  52 #include "ardour/session_configuration.h"
  53 #include "ardour/track.h"
  54
  55 #include "faderport.h"
  56
  57 using namespace ARDOUR;
  58 using namespace ArdourSurface;
  59 using namespace PBD;
  60 using namespace Glib;
  61 using namespace std;
  62
  63 #include "i18n.h"
  64
  65 #include "pbd/abstract_ui.cc" // instantiate template
  66
  67 FaderPort::FaderPort (Session& s)
  68         : ControlProtocol (s, _("Faderport"))
  69         , AbstractUI<FaderPortRequest> ("faderport")
  70         , gui (0)
  71         , connection_state (ConnectionState (0))
  72         , _device_active (false)
  73         , fader_msb (0)
  74         , fader_lsb (0)
  75         , fader_is_touched (false)
  76         , button_state (ButtonState (0))
  77         , blink_state (false)
  78 {
  79         last_encoder_time = 0;
  80
  81         boost::shared_ptr<ARDOUR::Port> inp;
  82         boost::shared_ptr<ARDOUR::Port> outp;
  83
  84         inp  = AudioEngine::instance()->register_input_port (DataType::MIDI, "Faderport Recv", true);
  85         outp = AudioEngine::instance()->register_output_port (DataType::MIDI, "Faderport Send", true);
  86
  87         _input_port = boost::dynamic_pointer_cast<AsyncMIDIPort>(inp);
  88         _output_port = boost::dynamic_pointer_cast<AsyncMIDIPort>(outp);
  89
  90         if (_input_port == 0 || _output_port == 0) {
  91                 throw failed_constructor();
  92         }
  93
  94         _input_bundle.reset (new ARDOUR::Bundle (_("Faderport Support (Receive)"), true));
  95         _output_bundle.reset (new ARDOUR::Bundle (_("Faderport Support (Send) "), false));
  96
  97         _input_bundle->add_channel (
  98                 inp->name(),
  99                 ARDOUR::DataType::MIDI,
 100                 session->engine().make_port_name_non_relative (inp->name())
 101                 );
 102
 103         _output_bundle->add_channel (
 104                 outp->name(),
 105                 ARDOUR::DataType::MIDI,
 106                 session->engine().make_port_name_non_relative (outp->name())
 107                 );
 108
 109
 110         TrackSelectionChanged.connect (selection_connection, MISSING_INVALIDATOR, boost::bind (&FaderPort::gui_track_selection_changed, this, _1), this);
 111
 112         /* Catch port connections and disconnections */
 113         ARDOUR::AudioEngine::instance()->PortConnectedOrDisconnected.connect (port_connection, MISSING_INVALIDATOR, boost::bind (&FaderPort::connection_handler, this, _1, _2, _3, _4, _5), this);
 114
 115         buttons.insert (std::make_pair (Mute, Button (*this, _("Mute"), Mute, 21)));
 116         buttons.insert (std::make_pair (Solo, Button (*this, _("Solo"), Solo, 22)));
 117         buttons.insert (std::make_pair (Rec, Button (*this, _("Rec"), Rec, 23)));
 118         buttons.insert (std::make_pair (Left, Button (*this, _("Left"), Left, 20)));
 119         buttons.insert (std::make_pair (Bank, Button (*this, _("Bank"), Bank, 19)));
 120         buttons.insert (std::make_pair (Right, Button (*this, _("Right"), Right, 18)));
 121         buttons.insert (std::make_pair (Output, Button (*this, _("Output"), Output, 17)));
 122         buttons.insert (std::make_pair (FP_Read, Button (*this, _("Read"), FP_Read, 13)));
 123         buttons.insert (std::make_pair (FP_Write, Button (*this, _("Write"), FP_Write, 14)));
 124         buttons.insert (std::make_pair (FP_Touch, Button (*this, _("Touch"), FP_Touch, 15)));
 125         buttons.insert (std::make_pair (FP_Off, Button (*this, _("Off"), FP_Off, 16)));
 126         buttons.insert (std::make_pair (Mix, Button (*this, _("Mix"), Mix, 12)));
 127         buttons.insert (std::make_pair (Proj, Button (*this, _("Proj"), Proj, 11)));
 128         buttons.insert (std::make_pair (Trns, Button (*this, _("Trns"), Trns, 10)));
 129         buttons.insert (std::make_pair (Undo, Button (*this, _("Undo"), Undo, 9)));
 130         buttons.insert (std::make_pair (Shift, Button (*this, _("Shift"), Shift, 5)));
 131         buttons.insert (std::make_pair (Punch, Button (*this, _("Punch"), Punch, 6)));
 132         buttons.insert (std::make_pair (User, Button (*this, _("User"), User, 7)));
 133         buttons.insert (std::make_pair (Loop, Button (*this, _("Loop"), Loop, 8)));
 134         buttons.insert (std::make_pair (Rewind, Button (*this, _("Rewind"), Rewind, 4)));
 135         buttons.insert (std::make_pair (Ffwd, Button (*this, _("Ffwd"), Ffwd, 3)));
 136         buttons.insert (std::make_pair (Stop, Button (*this, _("Stop"), Stop, 2)));
 137         buttons.insert (std::make_pair (Play, Button (*this, _("Play"), Play, 1)));
 138         buttons.insert (std::make_pair (RecEnable, Button (*this, _("RecEnable"), RecEnable, 0)));
 139         buttons.insert (std::make_pair (FaderTouch, Button (*this, _("Fader (touch)"), FaderTouch, -1)));
 140
 141         get_button (Shift).set_flash (true);
 142         get_button (Mix).set_flash (true);
 143         get_button (Proj).set_flash (true);
 144         get_button (Trns).set_flash (true);
 145         get_button (User).set_flash (true);
 146
 147         get_button (Left).set_action ( boost::bind (&FaderPort::left, this), true);
 148         get_button (Right).set_action ( boost::bind (&FaderPort::right, this), true);
 149
 150         get_button (Undo).set_action (boost::bind (&FaderPort::undo, this), true);
 151         get_button (Undo).set_action (boost::bind (&FaderPort::redo, this), true, ShiftDown);
 152         get_button (Undo).set_flash (true);
 153
 154         get_button (FP_Read).set_action (boost::bind (&FaderPort::read, this), true);
 155         get_button (FP_Write).set_action (boost::bind (&FaderPort::write, this), true);
 156         get_button (FP_Touch).set_action (boost::bind (&FaderPort::touch, this), true);
 157         get_button (FP_Off).set_action (boost::bind (&FaderPort::off, this), true);
 158
 159         get_button (Play).set_action (boost::bind (&BasicUI::transport_play, this, true), true);
 160         get_button (RecEnable).set_action (boost::bind (&BasicUI::rec_enable_toggle, this), true);
 161         /* Stop is a modifier, so we have to use its own button state to get
 162            the default action (since StopDown will be set when looking for the
 163            action to invoke.
 164         */
 165         get_button (Stop).set_action (boost::bind (&BasicUI::transport_stop, this), true, StopDown);
 166         get_button (Ffwd).set_action (boost::bind (&BasicUI::ffwd, this), true);
 167
 168         /* See comments about Stop above .. */
 169         get_button (Rewind).set_action (boost::bind (&BasicUI::rewind, this), true, RewindDown);
 170         get_button (Rewind).set_action (boost::bind (&BasicUI::goto_zero, this), true, ButtonState (RewindDown|StopDown));
 171         get_button (Rewind).set_action (boost::bind (&BasicUI::goto_start, this), true, ButtonState (RewindDown|ShiftDown));
 172
 173         get_button (Ffwd).set_action (boost::bind (&BasicUI::ffwd, this), true);
 174         get_button (Ffwd).set_action (boost::bind (&BasicUI::goto_end, this), true, ShiftDown);
 175
 176         get_button (Punch).set_action (boost::bind (&FaderPort::punch, this), true);
 177
 178         get_button (Loop).set_action (boost::bind (&BasicUI::loop_toggle, this), true);
 179         get_button (Loop).set_action (boost::bind (&BasicUI::add_marker, this, string()), true, ShiftDown);
 180
 181         get_button (Punch).set_action (boost::bind (&BasicUI::prev_marker, this), true, ShiftDown);
 182         get_button (User).set_action (boost::bind (&BasicUI::next_marker, this), true, ShiftDown);
 183
 184         get_button (Mute).set_action (boost::bind (&FaderPort::mute, this), true);
 185         get_button (Solo).set_action (boost::bind (&FaderPort::solo, this), true);
 186         get_button (Rec).set_action (boost::bind (&FaderPort::rec_enable, this), true);
 187
 188         get_button (Output).set_action (boost::bind (&FaderPort::use_master, this), true);
 189         get_button (Output).set_action (boost::bind (&FaderPort::use_monitor, this), true, ShiftDown);
 190 }
 191
 192 FaderPort::~FaderPort ()
 193 {
 194         if (_input_port) {
 195                 DEBUG_TRACE (DEBUG::FaderPort, string_compose ("unregistering input port %1\n", boost::shared_ptr<ARDOUR::Port>(_input_port)->name()));
 196                 AudioEngine::instance()->unregister_port (_input_port);
 197                 _input_port.reset ();
 198         }
 199
 200         if (_output_port) {
 201 //              _output_port->drain (10000);  //ToDo:  is this necessary?  It hangs the shutdown, for me
 202                 DEBUG_TRACE (DEBUG::FaderPort, string_compose ("unregistering output port %1\n", boost::shared_ptr<ARDOUR::Port>(_output_port)->name()));
 203                 AudioEngine::instance()->unregister_port (_output_port);
 204                 _output_port.reset ();
 205         }
 206
 207         tear_down_gui ();
 208 }
 209
 210 void
 211 FaderPort::start_midi_handling ()
 212 {
 213         /* handle device inquiry response */
 214         _input_port->parser()->sysex.connect_same_thread (midi_connections, boost::bind (&FaderPort::sysex_handler, this, _1, _2, _3));
 215         /* handle buttons */
 216         _input_port->parser()->poly_pressure.connect_same_thread (midi_connections, boost::bind (&FaderPort::button_handler, this, _1, _2));
 217         /* handle encoder */
 218         _input_port->parser()->pitchbend.connect_same_thread (midi_connections, boost::bind (&FaderPort::encoder_handler, this, _1, _2));
 219         /* handle fader */
 220         _input_port->parser()->controller.connect_same_thread (midi_connections, boost::bind (&FaderPort::fader_handler, this, _1, _2));
 221
 222         /* This connection means that whenever data is ready from the input
 223          * port, the relevant thread will invoke our ::midi_input_handler()
 224          * method, which will read the data, and invoke the parser.
 225          */
 226
 227         _input_port->xthread().set_receive_handler (sigc::bind (sigc::mem_fun (this, &FaderPort::midi_input_handler), _input_port));
 228         _input_port->xthread().attach (main_loop()->get_context());
 229 }
 230
 231 void
 232 FaderPort::stop_midi_handling ()
 233 {
 234         midi_connections.drop_connections ();
 235
 236         /* Note: the input handler is still active at this point, but we're no
 237          * longer connected to any of the parser signals
 238          */
 239 }
 240
 241 void
 242 FaderPort::do_request (FaderPortRequest* req)
 243 {
 244         if (req->type == CallSlot) {
 245
 246                 call_slot (MISSING_INVALIDATOR, req->the_slot);
 247
 248         } else if (req->type == Quit) {
 249
 250                 stop ();
 251         }
 252 }
 253
 254 int
 255 FaderPort::stop ()
 256 {
 257         BaseUI::quit ();
 258
 259         return 0;
 260 }
 261
 262 void
 263 FaderPort::thread_init ()
 264 {
 265         struct sched_param rtparam;
 266
 267         pthread_set_name (X_("FaderPort"));
 268
 269         PBD::notify_gui_about_thread_creation (X_("gui"), pthread_self(), X_("FaderPort"), 2048);
 270         ARDOUR::SessionEvent::create_per_thread_pool (X_("FaderPort"), 128);
 271
 272         memset (&rtparam, 0, sizeof (rtparam));
 273         rtparam.sched_priority = 9; /* XXX should be relative to audio (JACK) thread */
 274
 275         if (pthread_setschedparam (pthread_self(), SCHED_FIFO, &rtparam) != 0) {
 276                 // do we care? not particularly.
 277         }
 278 }
 279
 280 void
 281 FaderPort::all_lights_out ()
 282 {
 283         for (ButtonMap::iterator b = buttons.begin(); b != buttons.end(); ++b) {
 284                 b->second.set_led_state (_output_port, false, true);
 285         }
 286 }
 287
 288 FaderPort::Button&
 289 FaderPort::get_button (ButtonID id) const
 290 {
 291         ButtonMap::const_iterator b = buttons.find (id);
 292         assert (b != buttons.end());
 293         return const_cast<Button&>(b->second);
 294 }
 295
 296 bool
 297 FaderPort::button_long_press_timeout (ButtonID id)
 298 {
 299         if (buttons_down.find (id) != buttons_down.end()) {
 300                 get_button (id).invoke (ButtonState (LongPress|button_state), false);
 301         } else {
 302                 /* release happened and somehow we were not cancelled */
 303         }
 304
 305         return false; /* don't get called again */
 306 }
 307
 308 void
 309 FaderPort::start_press_timeout (Button& button, ButtonID id)
 310 {
 311         Glib::RefPtr<Glib::TimeoutSource> timeout = Glib::TimeoutSource::create (500); // milliseconds
 312         button.timeout_connection = timeout->connect (sigc::bind (sigc::mem_fun (*this, &FaderPort::button_long_press_timeout), id));
 313         timeout->attach (main_loop()->get_context());
 314 }
 315
 316 void
 317 FaderPort::button_handler (MIDI::Parser &, MIDI::EventTwoBytes* tb)
 318 {
 319         ButtonID id (ButtonID (tb->controller_number));
 320         Button& button (get_button (id));
 321
 322         if (tb->value) {
 323                 buttons_down.insert (id);
 324         } else {
 325                 buttons_down.erase (id);
 326                 button.timeout_connection.disconnect ();
 327         }
 328
 329         ButtonState bs (ButtonState (0));
 330
 331         switch (id) {
 332         case Shift:
 333                 /* set this bit on press, do NOT clear it on release */
 334                 if (tb->value) {
 335                         bs = ShiftDown;
 336                 }
 337                 break;
 338         case Stop:
 339                 bs = StopDown;
 340                 break;
 341         case Rewind:
 342                 bs = RewindDown;
 343                 break;
 344         case User:
 345                 bs = UserDown;
 346                 break;
 347         case FaderTouch:
 348                 fader_is_touched = tb->value;
 349                 if (_current_route) {
 350                         boost::shared_ptr<AutomationControl> gain = _current_route->gain_control ();
 351                         if (gain) {
 352                                 framepos_t now = session->engine().sample_time();
 353                                 if (tb->value) {
 354                                         gain->start_touch (now);
 355                                 } else {
 356                                         gain->stop_touch (true, now);
 357                                 }
 358                         }
 359                 }
 360                 break;
 361         default:
 362                 if (tb->value) {
 363                         start_press_timeout (button, id);
 364                 }
 365                 break;
 366         }
 367
 368         if (bs) {
 369                 button_state = (tb->value ? ButtonState (button_state|bs) : ButtonState (button_state&~bs));
 370                 DEBUG_TRACE (DEBUG::FaderPort, string_compose ("reset button state to %1%2 using %3%4\n", hex, button_state, bs, dec));
 371         }
 372
 373         if (button.uses_flash()) {
 374                 button.set_led_state (_output_port, (int)tb->value);
 375         }
 376
 377         button.invoke (button_state, tb->value ? true : false);
 378
 379         if (!tb->value && (id != Shift)) {
 380                 /* non-shift key was released, clear shift modifier */
 381                 button_state = ButtonState (button_state&~ShiftDown);
 382                 DEBUG_TRACE (DEBUG::FaderPort, "clear shift modifier\n");
 383         }
 384 }
 385
 386 void
 387 FaderPort::encoder_handler (MIDI::Parser &, MIDI::pitchbend_t pb)
 388 {
 389         int delta = 1;
 390
 391         if (pb >= 8192) {
 392                 delta = -1;
 393         }
 394
 395         //knob debouncing and hysteresis.  The presonus encoder often sends bursts of events, or goes the wrong direction
 396         {
 397                 last_last_encoder_delta = last_encoder_delta;
 398                 last_encoder_delta = delta;
 399                 microseconds_t now = get_microseconds ();
 400                 if ((now - last_encoder_time) < 10*1000) { //require at least 10ms interval between changes, because the device sometimes sends multiple deltas
 401                         return;
 402                 }
 403                 if ((now - last_encoder_time) < 100*1000) { //avoid directional changes while "spinning", 100ms window
 404                         if ( (delta == last_encoder_delta) && (delta == last_last_encoder_delta) ) {
 405                                 last_good_encoder_delta = delta;  //3 in a row, grudgingly accept this as the new direction
 406                         }
 407                         if (delta != last_good_encoder_delta) {  //otherwise ensure we keep going the same way
 408                                 delta = last_good_encoder_delta;
 409                         }
 410                 } else {  //we aren't yet in a spin window, just assume this move is really what we want
 411                         //NOTE:  if you are worried about where these get initialized, here it is.
 412                         last_last_encoder_delta = delta;
 413                         last_encoder_delta = delta;
 414                 }
 415                 last_encoder_time = now;
 416                 last_good_encoder_delta = delta;
 417         }
 418
 419         if (_current_route) {
 420
 421                 ButtonState trim_modifier;
 422                 ButtonState width_modifier;
 423
 424                 if (Profile->get_mixbus()) {
 425                         trim_modifier = ShiftDown;
 426                         width_modifier = ButtonState (0);
 427                 } else {
 428                         trim_modifier = UserDown;
 429                         width_modifier = ShiftDown;
 430                 }
 431
 432                 if ((button_state & trim_modifier) == trim_modifier ) {    // mod+encoder = input trim
 433                         boost::shared_ptr<AutomationControl> gain = _current_route->trim()->gain_control ();
 434                         if (gain) {
 435                                 float val = gain->get_user();  //for gain elements, the "user" value is in dB
 436                                 val += delta;
 437                                 gain->set_user(val);
 438                         }
 439                 } else if (width_modifier && ((button_state & width_modifier) == width_modifier)) {
 440                         ardour_pan_width (delta);
 441
 442                 } else {  // pan/balance
 443                         if (!Profile->get_mixbus()) {
 444                                 ardour_pan_azimuth (delta);
 445                         } else {
 446                                 mixbus_pan (delta);
 447                         }
 448                 }
 449         }
 450 }
 451
 452 void
 453 FaderPort::fader_handler (MIDI::Parser &, MIDI::EventTwoBytes* tb)
 454 {
 455         bool was_fader = false;
 456
 457         if (tb->controller_number == 0x0) {
 458                 fader_msb = tb->value;
 459                 was_fader = true;
 460         } else if (tb->controller_number == 0x20) {
 461                 fader_lsb = tb->value;
 462                 was_fader = true;
 463         }
 464
 465         if (was_fader) {
 466                 if (_current_route) {
 467                         boost::shared_ptr<AutomationControl> gain = _current_route->gain_control ();
 468                         if (gain) {
 469                                 int ival = (fader_msb << 7) | fader_lsb;
 470                                 float val = gain->interface_to_internal (ival/16384.0);
 471                                 _current_route->set_gain (val, this);
 472                         }
 473                 }
 474         }
 475 }
 476
 477 void
 478 FaderPort::sysex_handler (MIDI::Parser &p, MIDI::byte *buf, size_t sz)
 479 {
 480         if (sz < 17) {
 481                 return;
 482         }
 483
 484         if (buf[2] != 0x7f ||
 485             buf[3] != 0x06 ||
 486             buf[4] != 0x02 ||
 487             buf[5] != 0x0 ||
 488             buf[6] != 0x1 ||
 489             buf[7] != 0x06 ||
 490             buf[8] != 0x02 ||
 491             buf[9] != 0x0 ||
 492             buf[10] != 0x01 ||
 493             buf[11] != 0x0) {
 494                 return;
 495         }
 496
 497         _device_active = true;
 498
 499         DEBUG_TRACE (DEBUG::FaderPort, "FaderPort identified via MIDI Device Inquiry response\n");
 500
 501         /* put it into native mode */
 502
 503         MIDI::byte native[3];
 504         native[0] = 0x91;
 505         native[1] = 0x00;
 506         native[2] = 0x64;
 507
 508         _output_port->write (native, 3, 0);
 509
 510         all_lights_out ();
 511
 512         /* catch up on state */
 513
 514         notify_transport_state_changed ();
 515         notify_record_state_changed ();
 516 }
 517
 518 int
 519 FaderPort::set_active (bool yn)
 520 {
 521         DEBUG_TRACE (DEBUG::FaderPort, string_compose("MackieControlProtocol::set_active init with yn: '%1'\n", yn));
 522
 523         if (yn == active()) {
 524                 return 0;
 525         }
 526
 527         if (yn) {
 528
 529                 /* start event loop */
 530
 531                 BaseUI::run ();
 532
 533                 connect_session_signals ();
 534
 535                 Glib::RefPtr<Glib::TimeoutSource> blink_timeout = Glib::TimeoutSource::create (200); // milliseconds
 536                 blink_connection = blink_timeout->connect (sigc::mem_fun (*this, &FaderPort::blink));
 537                 blink_timeout->attach (main_loop()->get_context());
 538
 539         } else {
 540
 541                 BaseUI::quit ();
 542                 close ();
 543
 544         }
 545
 546         ControlProtocol::set_active (yn);
 547
 548         DEBUG_TRACE (DEBUG::FaderPort, string_compose("MackieControlProtocol::set_active done with yn: '%1'\n", yn));
 549
 550         return 0;
 551 }
 552
 553 void
 554 FaderPort::stop_blinking (ButtonID id)
 555 {
 556         blinkers.remove (id);
 557         get_button (id).set_led_state (_output_port, false);
 558 }
 559
 560 void
 561 FaderPort::start_blinking (ButtonID id)
 562 {
 563         blinkers.push_back (id);
 564         get_button (id).set_led_state (_output_port, true);
 565 }
 566
 567 bool
 568 FaderPort::blink ()
 569 {
 570         blink_state = !blink_state;
 571
 572         for (Blinkers::iterator b = blinkers.begin(); b != blinkers.end(); b++) {
 573                 get_button(*b).set_led_state (_output_port, blink_state);
 574         }
 575
 576         return true;
 577 }
 578
 579 void
 580 FaderPort::close ()
 581 {
 582         all_lights_out ();
 583
 584         stop_midi_handling ();
 585         session_connections.drop_connections ();
 586         port_connection.disconnect ();
 587         blink_connection.disconnect ();
 588         selection_connection.disconnect ();
 589         route_connections.drop_connections ();
 590
 591 #if 0
 592         route_connections.drop_connections ();
 593 #endif
 594 }
 595
 596 void
 597 FaderPort::notify_record_state_changed ()
 598 {
 599         switch (session->record_status()) {
 600         case Session::Disabled:
 601                 stop_blinking (RecEnable);
 602                 break;
 603         case Session::Enabled:
 604                 start_blinking (RecEnable);
 605                 break;
 606         case Session::Recording:
 607                 stop_blinking (RecEnable);
 608                 break;
 609         }
 610 }
 611
 612 void
 613 FaderPort::notify_transport_state_changed ()
 614 {
 615         get_button (Loop).set_led_state (_output_port, session->get_play_loop());
 616         get_button (Play).set_led_state (_output_port, session->transport_speed() == 1.0);
 617         get_button (Stop).set_led_state (_output_port, session->transport_stopped ());
 618         get_button (Rewind).set_led_state (_output_port, session->transport_speed() < 0.0);
 619         get_button (Ffwd).set_led_state (_output_port, session->transport_speed() > 1.0);
 620 }
 621
 622 void
 623 FaderPort::parameter_changed (string what)
 624 {
 625         if (what == "punch-in" || what == "punch-out") {
 626                 bool in = session->config.get_punch_in ();
 627                 bool out = session->config.get_punch_out ();
 628                 if (in && out) {
 629                         get_button (Punch).set_led_state (_output_port, true);
 630                         blinkers.remove (Punch);
 631                 } else if (in || out) {
 632                         start_blinking (Punch);
 633                 } else {
 634                         stop_blinking (Punch);
 635                 }
 636         }
 637 }
 638
 639 void
 640 FaderPort::connect_session_signals()
 641 {
 642         session->RecordStateChanged.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::notify_record_state_changed, this), this);
 643         session->TransportStateChange.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::notify_transport_state_changed, this), this);
 644         /* not session, but treat it similarly */
 645         session->config.ParameterChanged.connect (session_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::parameter_changed, this, _1), this);
 646 }
 647
 648 bool
 649 FaderPort::midi_input_handler (Glib::IOCondition ioc, boost::shared_ptr<ARDOUR::AsyncMIDIPort> port)
 650 {
 651         DEBUG_TRACE (DEBUG::FaderPort, string_compose ("something happend on  %1\n", boost::shared_ptr<MIDI::Port>(port)->name()));
 652
 653         if (ioc & ~IO_IN) {
 654                 return false;
 655         }
 656
 657         if (ioc & IO_IN) {
 658
 659                 if (port) {
 660                         port->clear ();
 661                 }
 662
 663                 DEBUG_TRACE (DEBUG::FaderPort, string_compose ("data available on %1\n", boost::shared_ptr<MIDI::Port>(port)->name()));
 664                 framepos_t now = session->engine().sample_time();
 665                 port->parse (now);
 666         }
 667
 668         return true;
 669 }
 670
 671
 672 XMLNode&
 673 FaderPort::get_state ()
 674 {
 675         XMLNode& node (ControlProtocol::get_state());
 676
 677         XMLNode* child;
 678
 679         child = new XMLNode (X_("Input"));
 680         child->add_child_nocopy (boost::shared_ptr<ARDOUR::Port>(_input_port)->get_state());
 681         node.add_child_nocopy (*child);
 682
 683
 684         child = new XMLNode (X_("Output"));
 685         child->add_child_nocopy (boost::shared_ptr<ARDOUR::Port>(_output_port)->get_state());
 686         node.add_child_nocopy (*child);
 687
 688         /* Save action state for Mix, Proj, Trns and User buttons, since these
 689          * are user controlled. We can only save named-action operations, since
 690          * internal functions are just pointers to functions and hard to
 691          * serialize without enumerating them all somewhere.
 692          */
 693
 694         node.add_child_nocopy (get_button (Mix).get_state());
 695         node.add_child_nocopy (get_button (Proj).get_state());
 696         node.add_child_nocopy (get_button (Trns).get_state());
 697         node.add_child_nocopy (get_button (User).get_state());
 698
 699         return node;
 700 }
 701
 702 int
 703 FaderPort::set_state (const XMLNode& node, int version)
 704 {
 705         XMLNodeList nlist;
 706         XMLNodeConstIterator niter;
 707         XMLNode const* child;
 708
 709         if (ControlProtocol::set_state (node, version)) {
 710                 return -1;
 711         }
 712
 713         if ((child = node.child (X_("Input"))) != 0) {
 714                 XMLNode* portnode = child->child (Port::state_node_name.c_str());
 715                 if (portnode) {
 716                         boost::shared_ptr<ARDOUR::Port>(_input_port)->set_state (*portnode, version);
 717                 }
 718         }
 719
 720         if ((child = node.child (X_("Output"))) != 0) {
 721                 XMLNode* portnode = child->child (Port::state_node_name.c_str());
 722                 if (portnode) {
 723                         boost::shared_ptr<ARDOUR::Port>(_output_port)->set_state (*portnode, version);
 724                 }
 725         }
 726
 727         for (XMLNodeList::const_iterator n = node.children().begin(); n != node.children().end(); ++n) {
 728                 if ((*n)->name() == X_("Button")) {
 729                         XMLProperty const * prop = (*n)->property (X_("id"));
 730                         if (!prop) {
 731                                 continue;
 732                         }
 733                         int xid = atoi (prop->value());
 734                         ButtonMap::iterator b = buttons.find (ButtonID (xid));
 735                         if (b == buttons.end()) {
 736                                 continue;
 737                         }
 738                         b->second.set_state (**n);
 739                 }
 740         }
 741
 742         return 0;
 743 }
 744
 745 bool
 746 FaderPort::connection_handler (boost::weak_ptr<ARDOUR::Port>, std::string name1, boost::weak_ptr<ARDOUR::Port>, std::string name2, bool yn)
 747 {
 748         if (!_input_port || !_output_port) {
 749                 return false;
 750         }
 751
 752         string ni = ARDOUR::AudioEngine::instance()->make_port_name_non_relative (boost::shared_ptr<ARDOUR::Port>(_input_port)->name());
 753         string no = ARDOUR::AudioEngine::instance()->make_port_name_non_relative (boost::shared_ptr<ARDOUR::Port>(_output_port)->name());
 754
 755         if (ni == name1 || ni == name2) {
 756                 if (yn) {
 757                         connection_state |= InputConnected;
 758                 } else {
 759                         connection_state &= ~InputConnected;
 760                 }
 761         } else if (no == name1 || no == name2) {
 762                 if (yn) {
 763                         connection_state |= OutputConnected;
 764                 } else {
 765                         connection_state &= ~OutputConnected;
 766                 }
 767         } else {
 768                 /* not our ports */
 769                 return false;
 770         }
 771
 772         if ((connection_state & (InputConnected|OutputConnected)) == (InputConnected|OutputConnected)) {
 773
 774                 /* XXX this is a horrible hack. Without a short sleep here,
 775                    something prevents the device wakeup messages from being
 776                    sent and/or the responses from being received.
 777                 */
 778
 779                 g_usleep (100000);
 780                 connected ();
 781
 782         } else {
 783                 DEBUG_TRACE (DEBUG::FaderPort, "Device disconnected (input or output or both) or not yet fully connected\n");
 784                 _device_active = false;
 785         }
 786
 787         ConnectionChange (); /* emit signal for our GUI */
 788
 789         return true; /* connection status changed */
 790 }
 791
 792 void
 793 FaderPort::connected ()
 794 {
 795         DEBUG_TRACE (DEBUG::FaderPort, "connection status changed\n");
 796
 797         start_midi_handling ();
 798
 799         /* send device inquiry */
 800
 801         MIDI::byte buf[6];
 802
 803         buf[0] = 0xf0;
 804         buf[1] = 0x7e;
 805         buf[2] = 0x7f;
 806         buf[3] = 0x06;
 807         buf[4] = 0x01;
 808         buf[5] = 0xf7;
 809
 810         _output_port->write (buf, 6, 0);
 811 }
 812
 813 void
 814 FaderPort::Button::invoke (FaderPort::ButtonState bs, bool press)
 815 {
 816         DEBUG_TRACE (DEBUG::FaderPort, string_compose ("invoke button %1 for %2 state %3%4%5\n", id, (press ? "press":"release"), hex, bs, dec));
 817
 818         ToDoMap::iterator x;
 819
 820         if (press) {
 821                 if ((x = on_press.find (bs)) == on_press.end()) {
 822                         DEBUG_TRACE (DEBUG::FaderPort, string_compose ("no press action for button %1 state %2%3\%4\n", id, hex, bs, dec));
 823                         return;
 824                 }
 825         } else {
 826                 if ((x = on_release.find (bs)) == on_release.end()) {
 827                         DEBUG_TRACE (DEBUG::FaderPort, string_compose ("no release action for button %1 state %2%3\%4\n", id, hex, bs, dec));
 828                         return;
 829                 }
 830         }
 831
 832         switch (x->second.type) {
 833         case NamedAction:
 834                 if (!x->second.action_name.empty()) {
 835                         fp.access_action (x->second.action_name);
 836                 }
 837                 break;
 838         case InternalFunction:
 839                 if (x->second.function) {
 840                         x->second.function ();
 841                 }
 842         }
 843 }
 844
 845 void
 846 FaderPort::Button::set_action (string const& name, bool when_pressed, FaderPort::ButtonState bs)
 847 {
 848         ToDo todo;
 849
 850         todo.type = NamedAction;
 851
 852         if (when_pressed) {
 853                 if (name.empty()) {
 854                         on_press.erase (bs);
 855                 } else {
 856                         DEBUG_TRACE (DEBUG::FaderPort, string_compose ("set button %1 to action %2 on press + %3%4%5\n", id, name, bs));
 857                         todo.action_name = name;
 858                         on_press[bs] = todo;
 859                 }
 860         } else {
 861                 if (name.empty()) {
 862                         on_release.erase (bs);
 863                 } else {
 864                         DEBUG_TRACE (DEBUG::FaderPort, string_compose ("set button %1 to action %2 on release + %3%4%5\n", id, name, bs));
 865                         todo.action_name = name;
 866                         on_release[bs] = todo;
 867                 }
 868         }
 869 }
 870
 871 string
 872 FaderPort::Button::get_action (bool press, FaderPort::ButtonState bs)
 873 {
 874         ToDoMap::iterator x;
 875
 876         if (press) {
 877                 if ((x = on_press.find (bs)) == on_press.end()) {
 878                         return string();
 879                 }
 880                 if (x->second.type != NamedAction) {
 881                         return string ();
 882                 }
 883                 return x->second.action_name;
 884         } else {
 885                 if ((x = on_release.find (bs)) == on_release.end()) {
 886                         return string();
 887                 }
 888                 if (x->second.type != NamedAction) {
 889                         return string ();
 890                 }
 891                 return x->second.action_name;
 892         }
 893 }
 894
 895 void
 896 FaderPort::Button::set_action (boost::function<void()> f, bool when_pressed, FaderPort::ButtonState bs)
 897 {
 898         ToDo todo;
 899         todo.type = InternalFunction;
 900
 901         if (when_pressed) {
 902                 todo.function = f;
 903                 on_press[bs] = todo;
 904         } else {
 905                 todo.function = f;
 906                 on_release[bs] = todo;
 907         }
 908 }
 909
 910 void
 911 FaderPort::Button::set_led_state (boost::shared_ptr<MIDI::Port> port, int onoff, bool force)
 912 {
 913         if (!force && (led_on == (bool) onoff)) {
 914                 /* nothing to do */
 915                 return;
 916         }
 917
 918         if (out < 0) {
 919                 /* fader button ID - no LED */
 920                 return;
 921         }
 922
 923         MIDI::byte buf[3];
 924         buf[0] = 0xa0;
 925         buf[1] = out;
 926         buf[2] = onoff ? 1 : 0;
 927         port->write (buf, 3, 0);
 928         led_on = (onoff ? true : false);
 929 }
 930
 931 int
 932 FaderPort::Button::set_state (XMLNode const& node)
 933 {
 934         const XMLProperty* prop = node.property ("id");
 935         if (!prop) {
 936                 return -1;
 937         }
 938
 939         int xid = atoi (prop->value());
 940         if (xid != id) {
 941                 return -1;
 942         }
 943
 944         typedef pair<string,FaderPort::ButtonState> state_pair_t;
 945         vector<state_pair_t> state_pairs;
 946
 947         state_pairs.push_back (make_pair (string ("plain"), ButtonState (0)));
 948         state_pairs.push_back (make_pair (string ("shift"), ShiftDown));
 949         state_pairs.push_back (make_pair (string ("long"), LongPress));
 950
 951         on_press.clear ();
 952         on_release.clear ();
 953
 954         for (vector<state_pair_t>::const_iterator sp = state_pairs.begin(); sp != state_pairs.end(); ++sp) {
 955                 string propname;
 956
 957                 propname = sp->first + X_("-press");
 958                 if ((prop = node.property (propname)) != 0) {
 959                         set_action (prop->value(), true, sp->second);
 960                 }
 961
 962                 propname = sp->first + X_("-release");
 963                 if ((prop = node.property (propname)) != 0) {
 964                         set_action (prop->value(), false, sp->second);
 965                 }
 966         }
 967
 968         return 0;
 969 }
 970
 971 XMLNode&
 972 FaderPort::Button::get_state () const
 973 {
 974         XMLNode* node = new XMLNode (X_("Button"));
 975         char buf[16];
 976         snprintf (buf, sizeof (buf), "%d", id);
 977
 978         node->add_property (X_("id"), buf);
 979
 980         ToDoMap::const_iterator x;
 981         ToDo null;
 982         null.type = NamedAction;
 983
 984         typedef pair<string,FaderPort::ButtonState> state_pair_t;
 985         vector<state_pair_t> state_pairs;
 986
 987         state_pairs.push_back (make_pair (string ("plain"), ButtonState (0)));
 988         state_pairs.push_back (make_pair (string ("shift"), ShiftDown));
 989         state_pairs.push_back (make_pair (string ("long"), LongPress));
 990
 991         for (vector<state_pair_t>::const_iterator sp = state_pairs.begin(); sp != state_pairs.end(); ++sp) {
 992                 if ((x = on_press.find (sp->second)) != on_press.end()) {
 993                         if (x->second.type == NamedAction) {
 994                                 node->add_property (string (sp->first + X_("-press")).c_str(), x->second.action_name);
 995                         }
 996                 }
 997
 998                 if ((x = on_release.find (sp->second)) != on_release.end()) {
 999                         if (x->second.type == NamedAction) {
1000                                 node->add_property (string (sp->first + X_("-release")).c_str(), x->second.action_name);
1001                         }
1002                 }
1003         }
1004
1005         return *node;
1006 }
1007
1008 void
1009 FaderPort::gui_track_selection_changed (RouteNotificationListPtr routes)
1010 {
1011         boost::shared_ptr<Route> r;
1012
1013         if (!routes->empty()) {
1014                 r = routes->front().lock();
1015         }
1016
1017         set_current_route (r);
1018 }
1019
1020 void
1021 FaderPort::drop_current_route ()
1022 {
1023         if (_current_route) {
1024                 if (_current_route == session->monitor_out()) {
1025                         set_current_route (session->master_out());
1026                 } else {
1027                         set_current_route (boost::shared_ptr<Route>());
1028                 }
1029         }
1030 }
1031
1032 void
1033 FaderPort::set_current_route (boost::shared_ptr<Route> r)
1034 {
1035         route_connections.drop_connections ();
1036
1037         _current_route = r;
1038
1039         /* turn this off. It will be turned on back on in use_master() or
1040            use_monitor() as appropriate.
1041         */
1042         get_button(Output).set_led_state (_output_port, false);
1043
1044         if (_current_route) {
1045                 _current_route->DropReferences.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::drop_current_route, this), this);
1046
1047                 _current_route->mute_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_mute, this, _1), this);
1048                 _current_route->solo_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_solo, this, _1, _2, _3), this);
1049                 _current_route->listen_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_listen, this, _1, _2), this);
1050
1051                 boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (_current_route);
1052                 if (t) {
1053                         t->RecordEnableChanged.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_recenable, this), this);
1054                 }
1055
1056                 boost::shared_ptr<AutomationControl> control = _current_route->gain_control ();
1057                 if (control) {
1058                         control->Changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_gain, this), this);
1059                         control->alist()->automation_state_changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_auto, this), this);
1060                 }
1061
1062                 boost::shared_ptr<MonitorProcessor> mp = _current_route->monitor_control();
1063                 if (mp) {
1064                         mp->cut_control()->Changed.connect (route_connections, MISSING_INVALIDATOR, boost::bind (&FaderPort::map_cut, this), this);
1065                 }
1066         }
1067
1068         //ToDo: subscribe to the fader automation modes so we can light the LEDs
1069
1070         map_route_state ();
1071 }
1072
1073 void
1074 FaderPort::map_auto ()
1075 {
1076         boost::shared_ptr<AutomationControl> control = _current_route->gain_control ();
1077         const AutoState as = control->automation_state ();
1078
1079         switch (as) {
1080                 case ARDOUR::Play:
1081                         get_button (FP_Read).set_led_state (_output_port, true);
1082                         get_button (FP_Write).set_led_state (_output_port, false);
1083                         get_button (FP_Touch).set_led_state (_output_port, false);
1084                         get_button (FP_Off).set_led_state (_output_port, false);
1085                 break;
1086                 case ARDOUR::Write:
1087                         get_button (FP_Read).set_led_state (_output_port, false);
1088                         get_button (FP_Write).set_led_state (_output_port, true);
1089                         get_button (FP_Touch).set_led_state (_output_port, false);
1090                         get_button (FP_Off).set_led_state (_output_port, false);
1091                 break;
1092                 case ARDOUR::Touch:
1093                         get_button (FP_Read).set_led_state (_output_port, false);
1094                         get_button (FP_Write).set_led_state (_output_port, false);
1095                         get_button (FP_Touch).set_led_state (_output_port, true);
1096                         get_button (FP_Off).set_led_state (_output_port, false);
1097                 break;
1098                 case ARDOUR::Off:
1099                         get_button (FP_Read).set_led_state (_output_port, false);
1100                         get_button (FP_Write).set_led_state (_output_port, false);
1101                         get_button (FP_Touch).set_led_state (_output_port, false);
1102                         get_button (FP_Off).set_led_state (_output_port, true);
1103                 break;
1104         }
1105
1106 }
1107
1108
1109 void
1110 FaderPort::map_cut ()
1111 {
1112         boost::shared_ptr<MonitorProcessor> mp = _current_route->monitor_control();
1113
1114         if (mp) {
1115                 bool yn = mp->cut_all ();
1116                 if (yn) {
1117                         start_blinking (Mute);
1118                 } else {
1119                         stop_blinking (Mute);
1120                 }
1121         } else {
1122                 stop_blinking (Mute);
1123         }
1124 }
1125
1126 void
1127 FaderPort::map_mute (void*)
1128 {
1129         get_button (Mute).set_led_state (_output_port, _current_route->muted());
1130 }
1131
1132 void
1133 FaderPort::map_solo (bool, void*, bool)
1134 {
1135         get_button (Solo).set_led_state (_output_port, _current_route->soloed() || _current_route->listening_via_monitor());
1136 }
1137
1138 void
1139 FaderPort::map_listen (void*, bool)
1140 {
1141         get_button (Solo).set_led_state (_output_port, _current_route->listening_via_monitor());
1142 }
1143
1144 void
1145 FaderPort::map_recenable ()
1146 {
1147         boost::shared_ptr<Track> t = boost::dynamic_pointer_cast<Track> (_current_route);
1148         if (t) {
1149                 get_button (Rec).set_led_state (_output_port, t->record_enabled());
1150         } else {
1151                 get_button (Rec).set_led_state (_output_port, false);
1152         }
1153 }
1154
1155 void
1156 FaderPort::map_gain ()
1157 {
1158         if (fader_is_touched) {
1159                 /* Do not send fader moves while the user is touching the fader */
1160                 return;
1161         }
1162
1163         if (!_current_route) {
1164                 return;
1165         }
1166
1167         boost::shared_ptr<AutomationControl> control = _current_route->gain_control ();
1168         double val;
1169
1170         if (!control) {
1171                 val = 0.0;
1172         } else {
1173                 val = control->internal_to_interface (control->get_value ());
1174         }
1175
1176         /* Faderport sends fader position with range 0..16384 (though some of
1177          * the least-significant bits at the top end are missing - it may only
1178          * get to 1636X or so).
1179          *
1180          * But ... position must be sent in the range 0..1023.
1181          *
1182          * Thanks, Obama.
1183          */
1184
1185         int ival = (int) lrintf (val * 1023.0);
1186
1187         /* MIDI normalization requires that we send two separate messages here,
1188          * not one single 6 byte one.
1189          */
1190
1191         MIDI::byte buf[3];
1192
1193         buf[0] = 0xb0;
1194         buf[1] = 0x0;
1195         buf[2] = ival >> 7;
1196
1197         _output_port->write (buf, 3, 0);
1198
1199         buf[1] = 0x20;
1200         buf[2] = ival & 0x7f;
1201
1202         _output_port->write (buf, 3, 0);
1203 }
1204
1205 void
1206 FaderPort::map_route_state ()
1207 {
1208         if (!_current_route) {
1209                 stop_blinking (Mute);
1210                 stop_blinking (Solo);
1211                 get_button (Rec).set_led_state (_output_port, false);
1212         } else {
1213                 /* arguments to these map_*() methods are all ignored */
1214                 map_mute (0);
1215                 map_solo (false, 0, false);
1216                 map_recenable ();
1217                 map_gain ();
1218                 map_cut ();
1219                 map_auto ();
1220         }
1221 }
1222
1223 list<boost::shared_ptr<ARDOUR::Bundle> >
1224 FaderPort::bundles ()
1225 {
1226         list<boost::shared_ptr<ARDOUR::Bundle> > b;
1227
1228         if (_input_bundle) {
1229                 b.push_back (_input_bundle);
1230                 b.push_back (_output_bundle);
1231         }
1232
1233         return b;
1234 }
1235
1236 boost::shared_ptr<Port>
1237 FaderPort::output_port()
1238 {
1239         return _output_port;
1240 }
1241
1242 boost::shared_ptr<Port>
1243 FaderPort::input_port()
1244 {
1245         return _input_port;
1246 }
1247
1248 void
1249 FaderPort::set_action (ButtonID id, std::string const& action_name, bool on_press, ButtonState bs)
1250 {
1251         get_button(id).set_action (action_name, on_press, bs);
1252 }
1253
1254 string
1255 FaderPort::get_action (ButtonID id, bool press, ButtonState bs)
1256 {
1257         return get_button(id).get_action (press, bs);
1258 }