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::wrap));
 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         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("strip %1 handling button %2\n", _index, button.id()));
 368
 369         if (bs != press) {
 370                 return;
 371         }
 372
 373         int lock_mod = (MackieControlProtocol::MODIFIER_CONTROL|MackieControlProtocol::MODIFIER_SHIFT);
 374         int ms = _surface->mcp().modifier_state();
 375         bool modified = (ms & MackieControlProtocol::MODIFIER_CONTROL);
 376
 377         if (button.id() >= Button::select_base_id &&
 378             button.id() < Button::select_base_id + 8) {
 379                 if ((ms & lock_mod) == lock_mod) {
 380                         _controls_locked = !_controls_locked;
 381                         return;
 382                 }
 383         }
 384
 385         if (button.id() >= Button::fader_touch_base_id &&
 386             button.id() < Button::fader_touch_base_id + 8) {
 387
 388                 DEBUG_TRACE (DEBUG::MackieControl, string_compose ("fader touch, press ? %1\n", (bs == press)));
 389
 390                 bool state = (bs == press);
 391
 392                 _fader->set_in_use (state);
 393                 _fader->start_touch (_surface->mcp().transport_frame(), modified);
 394
 395                 if (!_surface->mcp().device_info().has_touch_sense_faders()) {
 396                         _surface->mcp().add_in_use_timeout (*_surface, *_fader, _fader->control (modified));
 397                 }
 398
 399                 return;
 400         }
 401
 402         if (ms & MackieControlProtocol::MODIFIER_OPTION) {
 403                 /* reset to default/normal value */
 404
 405                 boost::shared_ptr<AutomationControl> control = button.control (modified);
 406
 407                 if (control) {
 408                         control->set_value (!control->get_value());
 409                 }
 410         }
 411 }
 412
 413 void
 414 Strip::handle_fader (Fader& fader, float position)
 415 {
 416         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("fader to %1\n", position));
 417
 418         bool modified = (_surface->mcp().modifier_state() & MackieControlProtocol::MODIFIER_CONTROL);
 419
 420         fader.set_value (position, modified);
 421         fader.start_touch (_surface->mcp().transport_frame(), modified);
 422
 423         if (!_surface->mcp().device_info().has_touch_sense_faders()) {
 424                 _surface->mcp().add_in_use_timeout (*_surface, fader, fader.control (modified));
 425         }
 426
 427         // must echo bytes back to slider now, because
 428         // the notifier only works if the fader is not being
 429         // touched. Which it is if we're getting input.
 430
 431         _surface->write (fader.set_position (position));
 432 }
 433
 434 void
 435 Strip::handle_pot (Pot& pot, float delta)
 436 {
 437         /* Pots only emit events when they move, not when they
 438            stop moving. So to get a stop event, we need to use a timeout.
 439         */
 440
 441         bool modified = (_surface->mcp().modifier_state() & MackieControlProtocol::MODIFIER_CONTROL);
 442         pot.start_touch (_surface->mcp().transport_frame(), modified);
 443         _surface->mcp().add_in_use_timeout (*_surface, pot, pot.control (modified));
 444
 445         double p = pot.get_value (modified);
 446         p += delta;
 447         p = min (1.0, p);
 448         p = max (0.0, p);
 449         pot.set_value (p, modified);
 450 }
 451
 452 void
 453 Strip::periodic ()
 454 {
 455         if (!_route) {
 456                 return;
 457         }
 458
 459         update_automation ();
 460         update_meter ();
 461 }
 462
 463 void
 464 Strip::update_automation ()
 465 {
 466         ARDOUR::AutoState gain_state = _route->gain_control()->automation_state();
 467
 468         if (gain_state == Touch || gain_state == Play) {
 469                 notify_gain_changed (false);
 470         }
 471
 472         if (_route->panner()) {
 473                 ARDOUR::AutoState panner_state = _route->panner()->automation_state();
 474                 if (panner_state == Touch || panner_state == Play) {
 475                         notify_panner_changed (false);
 476                 }
 477         }
 478 }
 479
 480 void
 481 Strip::update_meter ()
 482 {
 483         if (_meter) {
 484                 float dB = const_cast<PeakMeter&> (_route->peak_meter()).peak_power (0);
 485                 _surface->write (_meter->update_message (dB));
 486         }
 487 }
 488
 489 MidiByteArray
 490 Strip::zero ()
 491 {
 492         MidiByteArray retval;
 493
 494         for (Group::Controls::const_iterator it = _controls.begin(); it != _controls.end(); ++it) {
 495                 retval << (*it)->zero ();
 496         }
 497
 498         retval << blank_display (0);
 499         retval << blank_display (1);
 500
 501         return retval;
 502 }
 503
 504 MidiByteArray
 505 Strip::blank_display (uint32_t line_number)
 506 {
 507         return display (line_number, string());
 508 }
 509
 510 MidiByteArray
 511 Strip::display (uint32_t line_number, const std::string& line)
 512 {
 513         assert (line_number <= 1);
 514
 515         MidiByteArray retval;
 516
 517         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("strip_display index: %1, line %2 = %3\n", _index, line_number, line));
 518
 519         // sysex header
 520         retval << _surface->sysex_hdr();
 521
 522         // code for display
 523         retval << 0x12;
 524         // offset (0 to 0x37 first line, 0x38 to 0x6f for second line)
 525         retval << (_index * 7 + (line_number * 0x38));
 526
 527         // ascii data to display
 528         retval << line;
 529         // pad with " " out to 6 chars
 530         for (int i = line.length(); i < 6; ++i) {
 531                 retval << ' ';
 532         }
 533
 534         // column spacer, unless it's the right-hand column
 535         if (_index < 7) {
 536                 retval << ' ';
 537         }
 538
 539         // sysex trailer
 540         retval << MIDI::eox;
 541
 542         DEBUG_TRACE (DEBUG::MackieControl, string_compose ("MackieMidiBuilder::strip_display midi: %1\n", retval));
 543
 544         return retval;
 545 }
 546
 547 void
 548 Strip::lock_controls ()
 549 {
 550         _controls_locked = true;
 551 }
 552
 553 void
 554 Strip::unlock_controls ()
 555 {
 556         _controls_locked = false;
 557 }
 558
 559 MidiByteArray
 560 Strip::gui_selection_changed (ARDOUR::RouteNotificationListPtr rl)
 561 {
 562         for (ARDOUR::RouteNotificationList::iterator i = rl->begin(); i != rl->end(); ++i) {
 563                 if ((*i) == _route) {
 564                         return _select->set_state (on);
 565                 }
 566         }
 567
 568         return _select->set_state (off);
 569 }
 570
 571 void
 572 Strip::flip_mode_changed (bool notify)
 573 {
 574         if (!_route) {
 575                 return;
 576         }
 577
 578         boost::shared_ptr<Pannable> pannable = _route->pannable();
 579
 580         if (_surface->mcp().flip_mode()) {
 581
 582                 if (pannable) {
 583                         _fader->set_normal_control (pannable->pan_azimuth_control);
 584                         _fader->set_modified_control (pannable->pan_width_control);
 585                 }
 586                 _vpot->set_normal_control (_route->gain_control());
 587                 _vpot->set_modified_control (boost::shared_ptr<AutomationControl>());
 588
 589                 _surface->write (display (1, "Fader"));
 590
 591         } else {
 592
 593                 if (pannable) {
 594                         _vpot->set_normal_control (pannable->pan_azimuth_control);
 595                         _vpot->set_modified_control (pannable->pan_width_control);
 596                 }
 597                 _fader->set_normal_control (_route->gain_control());
 598                 _fader->set_modified_control (boost::shared_ptr<AutomationControl>());
 599
 600                 _surface->write (display (1, "Pan"));
 601         }
 602
 603         if (notify) {
 604                 notify_all ();
 605         }
 606 }