libs/surfaces/mackie/strip.cc

   1 /*
   2         Copyright (C) 2006,2007 John Anderson
   3         Copyright (C) 2012 Paul Davis
   4
   5         This program is free software; you can redistribute it and/or modify
   6         it under the terms of the GNU General Public License as published by
   7         the Free Software Foundation; either version 2 of the License, or
   8         (at your option) any later version.
   9
  10         This program is distributed in the hope that it will be useful,
  11         but WITHOUT ANY WARRANTY; without even the implied warranty of
  12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13         GNU General Public License for more details.
  14
  15         You should have received a copy of the GNU General Public License
  16         along with this program; if not, write to the Free Software
  17         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include <sstream>
  21 #include <stdint.h>
  22 #include "strip.h"
  23
  24 #include "midi++/port.h"
  25
  26 #include "pbd/compose.h"
  27 #include "pbd/convert.h"
  28
  29 #include "ardour/debug.h"
  30 #include "ardour/midi_ui.h"
  31 #include "ardour/route.h"
  32 #include "ardour/track.h"
  33 #include "ardour/pannable.h"
  34 #include "ardour/panner.h"
  35 #include "ardour/panner_shell.h"
  36 #include "ardour/rc_configuration.h"
  37 #include "ardour/meter.h"
  38
  39 #include "mackie_control_protocol.h"
  40 #include "surface_port.h"
  41 #include "surface.h"
  42 #include "button.h"
  43 #include "led.h"
  44 #include "pot.h"
  45 #include "fader.h"
  46 #include "jog.h"
  47 #include "meter.h"
  48
  49 using namespace Mackie;
  50 using namespace std;
  51 using namespace ARDOUR;
  52 using namespace PBD;
  53
  54 #define ui_context() MackieControlProtocol::instance() /* a UICallback-derived object that specifies the event loop for signal handling */
  55 #define ui_bind(f, ...) boost::protect (boost::bind (f, __VA_ARGS__))
  56
  57 extern PBD::EventLoop::InvalidationRecord* __invalidator (sigc::trackable& trackable, const char*, int);
  58 #define invalidator() __invalidator (*(MackieControlProtocol::instance()), __FILE__, __LINE__)
  59
  60 Strip::Strip (Surface& s, const std::string& name, int index, StripControlDefinition* ctls)
  61         : Group (name)
  62         , _solo (0)
  63         , _recenable (0)
  64         , _mute (0)
  65         , _select (0)
  66         , _vselect (0)
  67         , _fader_touch (0)
  68         , _vpot (0)
  69         , _fader (0)
  70         , _index (index)
  71         , _surface (&s)
  72         , _controls_locked (false)
  73         , _last_gain_position_written (-1.0)
  74         , _last_pan_position_written (-1.0)
  75 {
  76         /* build the controls for this track, which will automatically add them
  77            to the Group
  78         */
  79
  80         for (uint32_t i = 0; ctls[i].name[0]; ++i) {
  81                 ctls[i].factory (*_surface, ctls[i].base_id + index, ctls[i].name, *this);
  82         }
  83 }
  84
  85 Strip::~Strip ()
  86 {
  87 }
  88
  89 /**
  90         TODO could optimise this to use enum, but it's only
  91         called during the protocol class instantiation.
  92 */
  93 void Strip::add (Control & control)
  94 {
  95         Group::add (control);
  96
  97         Fader* fader;
  98         Pot* pot;
  99         Button* button;
 100         Meter* meter;
 101
 102         if ((fader = dynamic_cast<Fader*>(&control)) != 0) {
 103
 104                 _fader = fader;
 105
 106         } else if ((pot = dynamic_cast<Pot*>(&control)) != 0) {
 107
 108                 _vpot = pot;
 109
 110         } else if ((button = dynamic_cast<Button*>(&control)) != 0) {
 111
 112                 if (control.id() >= Button::recenable_base_id &&
 113                     control.id() < Button::recenable_base_id + 8) {
 114
 115                         _recenable = button;
 116
 117                 } else if (control.id() >= Button::mute_base_id &&
 118                            control.id() < Button::mute_base_id + 8) {
 119
 120                         _mute = button;
 121
 122                 } else if (control.id() >= Button::solo_base_id &&
 123                            control.id() < Button::solo_base_id + 8) {
 124
 125                         _solo = button;
 126
 127                 } else if (control.id() >= Button::select_base_id &&
 128                            control.id() < Button::select_base_id + 8) {
 129
 130                         _select = button;
 131
 132                 } else if (control.id() >= Button::vselect_base_id &&
 133                            control.id() < Button::vselect_base_id + 8) {
 134
 135                         _vselect = button;
 136
 137                 } else if (control.id() >= Button::fader_touch_base_id &&
 138                            control.id() < Button::fader_touch_base_id + 8) {
 139
 140                         _fader_touch = button;
 141                 }
 142
 143         } else if ((meter = dynamic_cast<Meter*>(&control)) != 0) {
 144                 _meter = meter;
 145         }
 146 }
 147
 148 void
 149 Strip::set_route (boost::shared_ptr<Route> r)
 150 {
 151         if (_controls_locked) {
 152                 return;
 153         }
 154
 155         route_connections.drop_connections ();
 156
 157         _route = r;
 158
 159         if (r) {
 160
 161                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Surface %1 strip %2 now mapping route %3\n",
 162                                                                    _surface->number(), _index, _route->name()));
 163
 164
 165                 if (_solo) {
 166                         _solo->set_normal_control (_route->solo_control());
 167                         _route->solo_control()->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_solo_changed, this), ui_context());
 168                 }
 169
 170                 if (_mute) {
 171                         _mute->set_normal_control (_route->mute_control());
 172                         _route->mute_control()->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_mute_changed, this), ui_context());
 173                 }
 174
 175                 _route->gain_control()->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_gain_changed, this, false), ui_context());
 176
 177                 _route->PropertyChanged.connect (route_connections, invalidator(), ui_bind (&Strip::notify_property_changed, this, _1), ui_context());
 178
 179                 if (_route->pannable()) {
 180                         _route->pannable()->pan_azimuth_control->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_panner_changed, this, false), ui_context());
 181                         _route->pannable()->pan_width_control->Changed.connect(route_connections, invalidator(), ui_bind (&Strip::notify_panner_changed, this, false), ui_context());
 182                 }
 183
 184                 flip_mode_changed (false);
 185
 186                 boost::shared_ptr<Track> trk = boost::dynamic_pointer_cast<ARDOUR::Track>(_route);
 187
 188                 if (trk) {
 189                         // XXX FIX ME WHEN rec-enable IS-A AutomationControl
 190                         // _recenable->set_normal_control (trk->rec_enable_control());
 191                         trk->rec_enable_control()->Changed .connect(route_connections, invalidator(), ui_bind (&Strip::notify_record_enable_changed, this), ui_context());
 192                 }
 193
 194                 // TODO this works when a currently-banked route is made inactive, but not
 195                 // when a route is activated which should be currently banked.
 196
 197                 _route->active_changed.connect (route_connections, invalidator(), ui_bind (&Strip::notify_active_changed, this), ui_context());
 198                 _route->DropReferences.connect (route_connections, invalidator(), ui_bind (&Strip::notify_route_deleted, this), ui_context());
 199
 200                 // TODO
 201                 // SelectedChanged
 202                 // RemoteControlIDChanged. Better handled at Session level.
 203
 204                 /* Update */
 205
 206                 notify_all ();
 207         } else {
 208                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Surface %1 strip %2 now unmapped\n",
 209                                                                    _surface->number(), _index));
 210         }
 211 }
 212
 213 void
 214 Strip::notify_all()
 215 {
 216         notify_solo_changed ();
 217         notify_mute_changed ();
 218         notify_gain_changed ();
 219         notify_property_changed (PBD::PropertyChange (ARDOUR::Properties::name));
 220         notify_panner_changed ();
 221         notify_record_enable_changed ();
 222 }
 223
 224 void
 225 Strip::notify_solo_changed ()
 226 {
 227         if (_route && _solo) {
 228                 _surface->write (_solo->set_state (_route->soloed() ? on : off));
 229         }
 230 }
 231
 232 void
 233 Strip::notify_mute_changed ()
 234 {
 235         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Strip %1 mute changed\n", _index));
 236         if (_route && _mute) {
 237                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("\troute muted ? %1\n", _route->muted()));
 238                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("mute message: %1\n", _mute->set_state (_route->muted() ? on : off)));
 239
 240                 _surface->write (_mute->set_state (_route->muted() ? on : off));
 241         }
 242 }
 243
 244 void
 245 Strip::notify_record_enable_changed ()
 246 {
 247         if (_route && _recenable)  {
 248                 _surface->write (_recenable->set_state (_route->record_enabled() ? on : off));
 249         }
 250 }
 251
 252 void
 253 Strip::notify_active_changed ()
 254 {
 255         _surface->mcp().refresh_current_bank();
 256 }
 257
 258 void
 259 Strip::notify_route_deleted ()
 260 {
 261         _surface->mcp().refresh_current_bank();
 262 }
 263
 264 void
 265 Strip::notify_gain_changed (bool force_update)
 266 {
 267         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("gain changed for strip %1, flip mode %2\n", _index, _surface->mcp().flip_mode()));
 268
 269         if (_route) {
 270
 271                 Control* control;
 272
 273                 if (_surface->mcp().flip_mode()) {
 274                         control = _vpot;
 275                 } else {
 276                         control = _fader;
 277                 }
 278
 279                 if (!control->in_use()) {
 280
 281                         float pos = _route->gain_control()->internal_to_interface (_route->gain_control()->get_value());
 282
 283                         if (force_update || pos != _last_gain_position_written) {
 284
 285                                 if (_surface->mcp().flip_mode()) {
 286                                         _surface->write (_vpot->set_all (pos, true, Pot::boost_cut));
 287                                 } else {
 288                                         _surface->write (_fader->set_position (pos));
 289                                 }
 290                                 _last_gain_position_written = pos;
 291
 292                         } else {
 293                                 DEBUG_TRACE (DEBUG::MackieControl, "value is stale, no message sent\n");
 294                         }
 295                 } else {
 296                         DEBUG_TRACE (DEBUG::MackieControl, "fader in use, no message sent\n");
 297                 }
 298         } else {
 299                 DEBUG_TRACE (DEBUG::MackieControl, "no route or no fader\n");
 300         }
 301 }
 302
 303 void
 304 Strip::notify_property_changed (const PropertyChange& what_changed)
 305 {
 306         if (!what_changed.contains (ARDOUR::Properties::name)) {
 307                 return;
 308         }
 309
 310         if (_route) {
 311                 string line1;
 312                 string fullname = _route->name();
 313
 314                 if (fullname.length() <= 6) {
 315                         line1 = fullname;
 316                 } else {
 317                         line1 = PBD::short_version (fullname, 6);
 318                 }
 319
 320                 _surface->write (display (0, line1));
 321         }
 322 }
 323
 324 void
 325 Strip::notify_panner_changed (bool force_update)
 326 {
 327         if (_route) {
 328
 329                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("pan change for strip %1\n", _index));
 330
 331                 boost::shared_ptr<Pannable> pannable = _route->pannable();
 332
 333                 if (!pannable) {
 334                         _surface->write (_vpot->zero());
 335                         return;
 336                 }
 337
 338                 Control* control;
 339
 340                 if (_surface->mcp().flip_mode()) {
 341                         control = _fader;
 342                 } else {
 343                         control = _vpot;
 344                 }
 345
 346                 if (!control->in_use()) {
 347
 348                         double pos = pannable->pan_azimuth_control->internal_to_interface (pannable->pan_azimuth_control->get_value());
 349
 350                         if (force_update || pos != _last_pan_position_written) {
 351                                 if (_surface->mcp().flip_mode()) {
 352                                         _surface->write (_fader->set_position (pos));
 353                                 } else {
 354                                         _surface->write (_vpot->set_all (pos, true, Pot::dot));
 355                                 }
 356                                 _last_pan_position_written = pos;
 357                         }
 358                 }
 359         }
 360 }
 361
 362 void
 363 Strip::handle_button (Button& button, ButtonState bs)
 364 {
 365         button.set_in_use (bs == press);
 366
 367         int lock_mod = (MackieControlProtocol::MODIFIER_CONTROL|MackieControlProtocol::MODIFIER_SHIFT);
 368         int ms = _surface->mcp().modifier_state();
 369         bool modified = (ms & MackieControlProtocol::MODIFIER_CONTROL);
 370
 371         if (button.id() >= Button::select_base_id &&
 372             button.id() < Button::select_base_id + 8) {
 373                 if ((ms & lock_mod) == lock_mod) {
 374                         _controls_locked = !_controls_locked;
 375                         return;
 376                 }
 377         }
 378
 379         if (button.id() >= Button::fader_touch_base_id &&
 380             button.id() < Button::fader_touch_base_id + 8) {
 381
 382                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("fader touch, press ? %1\n", (bs == press)));
 383
 384                 bool state = (bs == press);
 385
 386                 _fader->set_in_use (state);
 387                 _fader->start_touch (_surface->mcp().transport_frame(), modified);
 388
 389                 if (!_surface->mcp().device_info().has_touch_sense_faders()) {
 390                         _surface->mcp().add_in_use_timeout (*_surface, *_fader, _fader->control (modified));
 391                 }
 392
 393                 return;
 394         }
 395
 396         if (ms & MackieControlProtocol::MODIFIER_OPTION) {
 397                 /* reset to default/normal value */
 398
 399                 boost::shared_ptr<AutomationControl> control = button.control (modified);
 400
 401                 if (control) {
 402                         control->set_value (!control->get_value());
 403                 }
 404         }
 405 }
 406
 407 void
 408 Strip::handle_fader (Fader& fader, float position)
 409 {
 410         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("fader to %1\n", position));
 411
 412         bool modified = (_surface->mcp().modifier_state() & MackieControlProtocol::MODIFIER_CONTROL);
 413
 414         fader.set_value (position, modified);
 415         fader.start_touch (_surface->mcp().transport_frame(), modified);
 416
 417         if (!_surface->mcp().device_info().has_touch_sense_faders()) {
 418                 _surface->mcp().add_in_use_timeout (*_surface, fader, fader.control (modified));
 419         }
 420
 421         // must echo bytes back to slider now, because
 422         // the notifier only works if the fader is not being
 423         // touched. Which it is if we're getting input.
 424
 425         _surface->write (fader.set_position (position));
 426 }
 427
 428 void
 429 Strip::handle_pot (Pot& pot, float delta)
 430 {
 431         /* Pots only emit events when they move, not when they
 432            stop moving. So to get a stop event, we need to use a timeout.
 433         */
 434
 435         bool modified = (_surface->mcp().modifier_state() & MackieControlProtocol::MODIFIER_CONTROL);
 436         pot.start_touch (_surface->mcp().transport_frame(), modified);
 437         _surface->mcp().add_in_use_timeout (*_surface, pot, pot.control (modified));
 438
 439         double p = pot.get_value (modified);
 440         p += delta;
 441         p = min (1.0, p);
 442         p = max (0.0, p);
 443         pot.set_value (p, modified);
 444 }
 445
 446 void
 447 Strip::periodic ()
 448 {
 449         if (!_route) {
 450                 return;
 451         }
 452
 453         update_automation ();
 454         update_meter ();
 455 }
 456
 457 void
 458 Strip::update_automation ()
 459 {
 460         ARDOUR::AutoState gain_state = _route->gain_control()->automation_state();
 461
 462         if (gain_state == Touch || gain_state == Play) {
 463                 notify_gain_changed (false);
 464         }
 465
 466         if (_route->panner()) {
 467                 ARDOUR::AutoState panner_state = _route->panner()->automation_state();
 468                 if (panner_state == Touch || panner_state == Play) {
 469                         notify_panner_changed (false);
 470                 }
 471         }
 472 }
 473
 474 void
 475 Strip::update_meter ()
 476 {
 477         if (_meter) {
 478                 float dB = const_cast<PeakMeter&> (_route->peak_meter()).peak_power (0);
 479                 _surface->write (_meter->update_message (dB));
 480         }
 481 }
 482
 483 MidiByteArray
 484 Strip::zero ()
 485 {
 486         MidiByteArray retval;
 487
 488         for (Group::Controls::const_iterator it = _controls.begin(); it != _controls.end(); ++it) {
 489                 retval << (*it)->zero ();
 490         }
 491
 492         retval << blank_display (0);
 493         retval << blank_display (1);
 494
 495         return retval;
 496 }
 497
 498 MidiByteArray
 499 Strip::blank_display (uint32_t line_number)
 500 {
 501         return display (line_number, string());
 502 }
 503
 504 MidiByteArray
 505 Strip::display (uint32_t line_number, const std::string& line)
 506 {
 507         assert (line_number <= 1);
 508
 509         MidiByteArray retval;
 510
 511         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("strip_display index: %1, line %2 = %3\n", _index, line_number, line));
 512
 513         // sysex header
 514         retval << _surface->sysex_hdr();
 515
 516         // code for display
 517         retval << 0x12;
 518         // offset (0 to 0x37 first line, 0x38 to 0x6f for second line)
 519         retval << (_index * 7 + (line_number * 0x38));
 520
 521         // ascii data to display
 522         retval << line;
 523         // pad with " " out to 6 chars
 524         for (int i = line.length(); i < 6; ++i) {
 525                 retval << ' ';
 526         }
 527
 528         // column spacer, unless it's the right-hand column
 529         if (_index < 7) {
 530                 retval << ' ';
 531         }
 532
 533         // sysex trailer
 534         retval << MIDI::eox;
 535
 536         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("MackieMidiBuilder::strip_display midi: %1\n", retval));
 537
 538         return retval;
 539 }
 540
 541 void
 542 Strip::lock_controls ()
 543 {
 544         _controls_locked = true;
 545 }
 546
 547 void
 548 Strip::unlock_controls ()
 549 {
 550         _controls_locked = false;
 551 }
 552
 553 MidiByteArray
 554 Strip::gui_selection_changed (ARDOUR::RouteNotificationListPtr rl)
 555 {
 556         for (ARDOUR::RouteNotificationList::iterator i = rl->begin(); i != rl->end(); ++i) {
 557                 if ((*i) == _route) {
 558                         std::cerr << "Strip " << _index << " selected, route = " << (*i)->name() << std::endl;
 559                         return _select->set_state (on);
 560                 }
 561         }
 562
 563         std::cerr << "Strip " << _index << " NOT selected\n";
 564         return _select->set_state (off);
 565 }
 566
 567 void
 568 Strip::flip_mode_changed (bool notify)
 569 {
 570         if (!_route) {
 571                 return;
 572         }
 573
 574         boost::shared_ptr<Pannable> pannable = _route->pannable();
 575
 576         if (_surface->mcp().flip_mode()) {
 577
 578                 if (pannable) {
 579                         _fader->set_normal_control (pannable->pan_azimuth_control);
 580                         _fader->set_modified_control (pannable->pan_width_control);
 581                 }
 582                 _vpot->set_normal_control (_route->gain_control());
 583                 _vpot->set_modified_control (boost::shared_ptr<AutomationControl>());
 584
 585                 _surface->write (display (1, "Pan"));
 586
 587         } else {
 588
 589                 if (pannable) {
 590                         _vpot->set_normal_control (pannable->pan_azimuth_control);
 591                         _vpot->set_modified_control (pannable->pan_width_control);
 592                 }
 593                 _fader->set_normal_control (_route->gain_control());
 594                 _fader->set_modified_control (boost::shared_ptr<AutomationControl>());
 595
 596                 _surface->write (display (1, "Fdr"));
 597         }
 598
 599         if (notify) {
 600                 notify_all ();
 601         }
 602 }