libs/surfaces/push2/push2.cc

   1 /*
   2   Copyright (C) 2016 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 #include "pbd/compose.h"
  20 #include "pbd/convert.h"
  21 #include "pbd/debug.h"
  22 #include "pbd/failed_constructor.h"
  23 #include "pbd/file_utils.h"
  24 #include "pbd/search_path.h"
  25 #include "pbd/enumwriter.h"
  26
  27 #include "midi++/parser.h"
  28 #include "timecode/time.h"
  29 #include "timecode/bbt_time.h"
  30
  31 #include "ardour/async_midi_port.h"
  32 #include "ardour/audioengine.h"
  33 #include "ardour/debug.h"
  34 #include "ardour/filesystem_paths.h"
  35 #include "ardour/midiport_manager.h"
  36 #include "ardour/midi_track.h"
  37 #include "ardour/midi_port.h"
  38 #include "ardour/session.h"
  39 #include "ardour/tempo.h"
  40
  41 #include "push2.h"
  42 #include "gui.h"
  43 #include "menu.h"
  44
  45 #include "i18n.h"
  46
  47 using namespace ARDOUR;
  48 using namespace std;
  49 using namespace PBD;
  50 using namespace Glib;
  51 using namespace ArdourSurface;
  52
  53 #include "pbd/abstract_ui.cc" // instantiate template
  54
  55 const int Push2::cols = 960;
  56 const int Push2::rows = 160;
  57 const int Push2::pixels_per_row = 1024;
  58
  59 #define ABLETON 0x2982
  60 #define PUSH2   0x1967
  61
  62 __attribute__((constructor)) static void
  63 register_enums ()
  64 {
  65         EnumWriter& enum_writer (EnumWriter::instance());
  66         vector<int> i;
  67         vector<string> s;
  68
  69         MusicalMode::Type mode;
  70
  71 #define REGISTER(e) enum_writer.register_distinct (typeid(e).name(), i, s); i.clear(); s.clear()
  72 #define REGISTER_CLASS_ENUM(t,e) i.push_back (t::e); s.push_back (#e)
  73
  74         REGISTER_CLASS_ENUM (MusicalMode,Dorian);
  75         REGISTER_CLASS_ENUM (MusicalMode, IonianMajor);
  76         REGISTER_CLASS_ENUM (MusicalMode, Minor);
  77         REGISTER_CLASS_ENUM (MusicalMode, HarmonicMinor);
  78         REGISTER_CLASS_ENUM (MusicalMode, MelodicMinorAscending);
  79         REGISTER_CLASS_ENUM (MusicalMode, MelodicMinorDescending);
  80         REGISTER_CLASS_ENUM (MusicalMode, Phrygian);
  81         REGISTER_CLASS_ENUM (MusicalMode, Lydian);
  82         REGISTER_CLASS_ENUM (MusicalMode, Mixolydian);
  83         REGISTER_CLASS_ENUM (MusicalMode, Aeolian);
  84         REGISTER_CLASS_ENUM (MusicalMode, Locrian);
  85         REGISTER_CLASS_ENUM (MusicalMode, PentatonicMajor);
  86         REGISTER_CLASS_ENUM (MusicalMode, PentatonicMinor);
  87         REGISTER_CLASS_ENUM (MusicalMode, Chromatic);
  88         REGISTER_CLASS_ENUM (MusicalMode, BluesScale);
  89         REGISTER_CLASS_ENUM (MusicalMode, NeapolitanMinor);
  90         REGISTER_CLASS_ENUM (MusicalMode, NeapolitanMajor);
  91         REGISTER_CLASS_ENUM (MusicalMode, Oriental);
  92         REGISTER_CLASS_ENUM (MusicalMode, DoubleHarmonic);
  93         REGISTER_CLASS_ENUM (MusicalMode, Enigmatic);
  94         REGISTER_CLASS_ENUM (MusicalMode, Hirajoshi);
  95         REGISTER_CLASS_ENUM (MusicalMode, HungarianMinor);
  96         REGISTER_CLASS_ENUM (MusicalMode, HungarianMajor);
  97         REGISTER_CLASS_ENUM (MusicalMode, Kumoi);
  98         REGISTER_CLASS_ENUM (MusicalMode, Iwato);
  99         REGISTER_CLASS_ENUM (MusicalMode, Hindu);
 100         REGISTER_CLASS_ENUM (MusicalMode, Spanish8Tone);
 101         REGISTER_CLASS_ENUM (MusicalMode, Pelog);
 102         REGISTER_CLASS_ENUM (MusicalMode, HungarianGypsy);
 103         REGISTER_CLASS_ENUM (MusicalMode, Overtone);
 104         REGISTER_CLASS_ENUM (MusicalMode, LeadingWholeTone);
 105         REGISTER_CLASS_ENUM (MusicalMode, Arabian);
 106         REGISTER_CLASS_ENUM (MusicalMode, Balinese);
 107         REGISTER_CLASS_ENUM (MusicalMode, Gypsy);
 108         REGISTER_CLASS_ENUM (MusicalMode, Mohammedan);
 109         REGISTER_CLASS_ENUM (MusicalMode, Javanese);
 110         REGISTER_CLASS_ENUM (MusicalMode, Persian);
 111         REGISTER_CLASS_ENUM (MusicalMode, Algerian);
 112         REGISTER (mode);
 113 }
 114
 115 Push2::Push2 (ARDOUR::Session& s)
 116         : ControlProtocol (s, string (X_("Ableton Push 2")))
 117         , AbstractUI<Push2Request> (name())
 118         , handle (0)
 119         , device_buffer (0)
 120         , frame_buffer (Cairo::ImageSurface::create (Cairo::FORMAT_ARGB32, cols, rows))
 121         , _modifier_state (None)
 122         , splash_start (0)
 123         , _current_layout (0)
 124         , drawn_layout (0)
 125         , connection_state (ConnectionState (0))
 126         , gui (0)
 127         , _mode (MusicalMode::IonianMajor)
 128         , _scale_root (0)
 129         , _root_octave (3)
 130         , _in_key (true)
 131         , octave_shift (0)
 132         , percussion (false)
 133 {
 134         context = Cairo::Context::create (frame_buffer);
 135
 136         build_maps ();
 137
 138         /* master cannot be removed, so no need to connect to going-away signal */
 139         master = session->master_out ();
 140
 141         if (open ()) {
 142                 throw failed_constructor ();
 143         }
 144
 145         ControlProtocol::StripableSelectionChanged.connect (selection_connection, MISSING_INVALIDATOR, boost::bind (&Push2::stripable_selection_change, this, _1), this);
 146
 147         /* catch current selection, if any */
 148         {
 149                 StripableNotificationListPtr sp (new StripableNotificationList (ControlProtocol::last_selected()));
 150                 stripable_selection_change (sp);
 151         }
 152
 153         /* catch arrival and departure of Push2 itself */
 154         ARDOUR::AudioEngine::instance()->PortRegisteredOrUnregistered.connect (port_reg_connection, MISSING_INVALIDATOR, boost::bind (&Push2::port_registration_handler, this), this);
 155
 156         /* Catch port connections and disconnections */
 157         ARDOUR::AudioEngine::instance()->PortConnectedOrDisconnected.connect (port_connection, MISSING_INVALIDATOR, boost::bind (&Push2::connection_handler, this, _1, _2, _3, _4, _5), this);
 158
 159         /* ports might already be there */
 160         port_registration_handler ();
 161 }
 162
 163 Push2::~Push2 ()
 164 {
 165         stop ();
 166 }
 167
 168 void
 169 Push2::port_registration_handler ()
 170 {
 171         if (_async_in->connected() && _async_out->connected()) {
 172                 /* don't waste cycles here */
 173                 return;
 174         }
 175
 176         string input_port_name = X_("Ableton Push 2 MIDI 1 in");
 177         string output_port_name = X_("Ableton Push 2 MIDI 1 out");
 178         vector<string> in;
 179         vector<string> out;
 180
 181         AudioEngine::instance()->get_ports (string_compose (".*%1", input_port_name), DataType::MIDI, PortFlags (IsPhysical|IsOutput), in);
 182         AudioEngine::instance()->get_ports (string_compose (".*%1", output_port_name), DataType::MIDI, PortFlags (IsPhysical|IsInput), out);
 183
 184         if (!in.empty() && !out.empty()) {
 185                 cerr << "Push2: both ports found\n";
 186                 cerr << "\tconnecting to " << in.front() <<  " + " << out.front() << endl;
 187                 if (!_async_in->connected()) {
 188                         AudioEngine::instance()->connect (_async_in->name(), in.front());
 189                 }
 190                 if (!_async_out->connected()) {
 191                         AudioEngine::instance()->connect (_async_out->name(), out.front());
 192                 }
 193         }
 194 }
 195
 196 int
 197 Push2::open ()
 198 {
 199         int err;
 200
 201         if (handle) {
 202                 /* already open */
 203                 return 0;
 204         }
 205
 206         if ((handle = libusb_open_device_with_vid_pid (NULL, ABLETON, PUSH2)) == 0) {
 207                 return -1;
 208         }
 209
 210         if ((err = libusb_claim_interface (handle, 0x00))) {
 211                 return -1;
 212         }
 213
 214         device_frame_buffer = new uint16_t[rows*pixels_per_row];
 215
 216         memset (device_frame_buffer, 0, sizeof (uint16_t) * rows * pixels_per_row);
 217
 218         frame_header[0] = 0xef;
 219         frame_header[1] = 0xcd;
 220         frame_header[2] = 0xab;
 221         frame_header[3] = 0x89;
 222         memset (&frame_header[4], 0, 12);
 223
 224         /* setup ports */
 225
 226         _async_in  = AudioEngine::instance()->register_input_port (DataType::MIDI, X_("Push 2 in"), true);
 227         _async_out = AudioEngine::instance()->register_output_port (DataType::MIDI, X_("Push 2 out"), true);
 228
 229         if (_async_in == 0 || _async_out == 0) {
 230                 return -1;
 231         }
 232
 233         /* We do not add our ports to the input/output bundles because we don't
 234          * want users wiring them by hand. They could use JACK tools if they
 235          * really insist on that.
 236          */
 237
 238         _input_port = boost::dynamic_pointer_cast<AsyncMIDIPort>(_async_in).get();
 239         _output_port = boost::dynamic_pointer_cast<AsyncMIDIPort>(_async_out).get();
 240
 241         /* Create a shadow port where, depending on the state of the surface,
 242          * we will make pad note on/off events appear. The surface code will
 243          * automatically this port to the first selected MIDI track.
 244          */
 245
 246         boost::dynamic_pointer_cast<AsyncMIDIPort>(_async_in)->add_shadow_port (string_compose (_("%1 Pads"), X_("Push 2")), boost::bind (&Push2::pad_filter, this, _1, _2));
 247         boost::shared_ptr<MidiPort> shadow_port = boost::dynamic_pointer_cast<AsyncMIDIPort>(_async_in)->shadow_port();
 248
 249         if (shadow_port) {
 250
 251                 _output_bundle.reset (new ARDOUR::Bundle (_("Push 2 Pads"), false));
 252
 253                 _output_bundle->add_channel (
 254                         shadow_port->name(),
 255                         ARDOUR::DataType::MIDI,
 256                         session->engine().make_port_name_non_relative (shadow_port->name())
 257                         );
 258         }
 259
 260         session->BundleAddedOrRemoved ();
 261
 262         connect_to_parser ();
 263
 264         mix_layout = new MixLayout (*this, *session, context);
 265         scale_layout = new ScaleLayout (*this, *session, context);
 266         _current_layout = mix_layout;
 267
 268         return 0;
 269 }
 270
 271 list<boost::shared_ptr<ARDOUR::Bundle> >
 272 Push2::bundles ()
 273 {
 274         list<boost::shared_ptr<ARDOUR::Bundle> > b;
 275
 276         if (_output_bundle) {
 277                 b.push_back (_output_bundle);
 278         }
 279
 280         return b;
 281 }
 282
 283 int
 284 Push2::close ()
 285 {
 286         init_buttons (false);
 287
 288         /* wait for button data to be flushed */
 289         AsyncMIDIPort* asp;
 290         asp = dynamic_cast<AsyncMIDIPort*> (_output_port);
 291         asp->drain (10000, 500000);
 292
 293         AudioEngine::instance()->unregister_port (_async_in);
 294         AudioEngine::instance()->unregister_port (_async_out);
 295
 296         _async_in.reset ((ARDOUR::Port*) 0);
 297         _async_out.reset ((ARDOUR::Port*) 0);
 298         _input_port = 0;
 299         _output_port = 0;
 300
 301         vblank_connection.disconnect ();
 302         periodic_connection.disconnect ();
 303         session_connections.drop_connections ();
 304
 305         _current_layout = 0;
 306         drawn_layout = 0;
 307         delete mix_layout;
 308         mix_layout = 0;
 309         delete scale_layout;
 310         scale_layout = 0;
 311
 312         if (handle) {
 313                 libusb_release_interface (handle, 0x00);
 314                 libusb_close (handle);
 315                 handle = 0;
 316         }
 317
 318         delete [] device_frame_buffer;
 319         device_frame_buffer = 0;
 320
 321         return 0;
 322 }
 323
 324 void
 325 Push2::init_buttons (bool startup)
 326 {
 327         /* This is a list of buttons that we want lit because they do something
 328            in ardour related (loosely, sometimes) to their illuminated label.
 329         */
 330
 331         ButtonID buttons[] = { Mute, Solo, Master, Up, Right, Left, Down, Note, Session, Mix, AddTrack, Delete, Undo,
 332                                Metronome, Shift, Select, Play, RecordEnable, Automate, Repeat, Note, Session, DoubleLoop,
 333                                Quantize, Duplicate, Browse, PageRight, PageLeft, OctaveUp, OctaveDown, Layout, Scale
 334         };
 335
 336         for (size_t n = 0; n < sizeof (buttons) / sizeof (buttons[0]); ++n) {
 337                 Button* b = id_button_map[buttons[n]];
 338
 339                 if (startup) {
 340                         b->set_color (LED::White);
 341                 } else {
 342                         b->set_color (LED::Black);
 343                 }
 344                 b->set_state (LED::OneShot24th);
 345                 write (b->state_msg());
 346         }
 347
 348         /* Strip buttons should all be off (black) by default. They will change
 349          * color to reflect various conditions
 350          */
 351
 352         ButtonID strip_buttons[] = { Upper1, Upper2, Upper3, Upper4, Upper5, Upper6, Upper7, Upper8,
 353                                      Lower1, Lower2, Lower3, Lower4, Lower5, Lower6, Lower7, Lower8, };
 354
 355         for (size_t n = 0; n < sizeof (strip_buttons) / sizeof (strip_buttons[0]); ++n) {
 356                 Button* b = id_button_map[strip_buttons[n]];
 357
 358                 b->set_color (LED::Black);
 359                 b->set_state (LED::OneShot24th);
 360                 write (b->state_msg());
 361         }
 362
 363         if (startup) {
 364
 365                 /* all other buttons are off (black) */
 366
 367                 ButtonID off_buttons[] = { TapTempo, Setup, User, Stop, Convert, New, FixedLength,
 368                                            Fwd32ndT, Fwd32nd, Fwd16thT, Fwd16th, Fwd8thT, Fwd8th, Fwd4trT, Fwd4tr,
 369                                            Accent, Note, Session,  };
 370
 371                 for (size_t n = 0; n < sizeof (off_buttons) / sizeof (off_buttons[0]); ++n) {
 372                         Button* b = id_button_map[off_buttons[n]];
 373
 374                         b->set_color (LED::Black);
 375                         b->set_state (LED::OneShot24th);
 376                         write (b->state_msg());
 377                 }
 378         }
 379
 380         if (!startup) {
 381                 for (NNPadMap::iterator pi = nn_pad_map.begin(); pi != nn_pad_map.end(); ++pi) {
 382                         Pad* pad = pi->second;
 383
 384                         pad->set_color (LED::Black);
 385                         pad->set_state (LED::OneShot24th);
 386                         write (pad->state_msg());
 387                 }
 388         }
 389 }
 390
 391 bool
 392 Push2::probe ()
 393 {
 394         libusb_device_handle *h;
 395         libusb_init (NULL);
 396
 397         if ((h = libusb_open_device_with_vid_pid (NULL, ABLETON, PUSH2)) == 0) {
 398                 DEBUG_TRACE (DEBUG::Push2, "no Push2 device found\n");
 399                 return false;
 400         }
 401
 402         libusb_close (h);
 403         DEBUG_TRACE (DEBUG::Push2, "Push2 device located\n");
 404         return true;
 405 }
 406
 407 void*
 408 Push2::request_factory (uint32_t num_requests)
 409 {
 410         /* AbstractUI<T>::request_buffer_factory() is a template method only
 411            instantiated in this source module. To provide something visible for
 412            use in the interface/descriptor, we have this static method that is
 413            template-free.
 414         */
 415         return request_buffer_factory (num_requests);
 416 }
 417
 418 void
 419 Push2::do_request (Push2Request * req)
 420 {
 421         DEBUG_TRACE (DEBUG::Push2, string_compose ("doing request type %1\n", req->type));
 422         if (req->type == CallSlot) {
 423
 424                 call_slot (MISSING_INVALIDATOR, req->the_slot);
 425
 426         } else if (req->type == Quit) {
 427
 428                 stop ();
 429         }
 430 }
 431
 432 int
 433 Push2::stop ()
 434 {
 435         BaseUI::quit ();
 436         close ();
 437         return 0;
 438 }
 439
 440 /** render host-side frame buffer (a Cairo ImageSurface) to the current
 441  * device-side frame buffer. The device frame buffer will be pushed to the
 442  * device on the next call to vblank()
 443  */
 444
 445 int
 446 Push2::blit_to_device_frame_buffer ()
 447 {
 448         /* ensure that all drawing has been done before we fetch pixel data */
 449
 450         frame_buffer->flush ();
 451
 452         const int stride = 3840; /* bytes per row for Cairo::FORMAT_ARGB32 */
 453         const uint8_t* data = frame_buffer->get_data ();
 454
 455         /* fill frame buffer (320kB) */
 456
 457         uint16_t* fb = (uint16_t*) device_frame_buffer;
 458
 459         for (int row = 0; row < rows; ++row) {
 460
 461                 const uint8_t* dp = data + row * stride;
 462
 463                 for (int col = 0; col < cols; ++col) {
 464
 465                         /* fetch r, g, b (range 0..255). Ignore alpha */
 466
 467                         const int r = (*((const uint32_t*)dp) >> 16) & 0xff;
 468                         const int g = (*((const uint32_t*)dp) >> 8) & 0xff;
 469                         const int b = *((const uint32_t*)dp) & 0xff;
 470
 471                         /* convert to 5 bits, 6 bits, 5 bits, respectively */
 472                         /* generate 16 bit BGB565 value */
 473
 474                         *fb++ = (r >> 3) | ((g & 0xfc) << 3) | ((b & 0xf8) << 8);
 475
 476                         /* the push2 docs state that we should xor the pixel
 477                          * data. Doing so doesn't work correctly, and not doing
 478                          * so seems to work fine (colors roughly match intended
 479                          * values).
 480                          */
 481
 482                         dp += 4;
 483                 }
 484
 485                 /* skip 128 bytes to next line. This is filler, used to avoid line borders occuring in the middle of 512
 486                    byte USB buffers
 487                 */
 488
 489                 fb += 64; /* 128 bytes = 64 int16_t */
 490         }
 491
 492         return 0;
 493 }
 494
 495 bool
 496 Push2::redraw ()
 497 {
 498         if (splash_start) {
 499
 500                 /* display splash for 3 seconds */
 501
 502                 if (get_microseconds() - splash_start > 3000000) {
 503                         splash_start = 0;
 504                 } else {
 505                         return false;
 506                 }
 507         }
 508
 509         Glib::Threads::Mutex::Lock lm (layout_lock, Glib::Threads::TRY_LOCK);
 510
 511         if (!lm.locked()) {
 512                 /* can't get layout, no re-render needed */
 513                 return false;
 514         }
 515
 516         bool render_needed = false;
 517
 518         if (drawn_layout != _current_layout) {
 519                 render_needed = true;
 520         }
 521
 522         bool dirty = _current_layout->redraw (context);
 523         drawn_layout = _current_layout;
 524
 525         return dirty || render_needed;
 526 }
 527
 528 bool
 529 Push2::vblank ()
 530 {
 531         int transferred = 0;
 532         const int timeout_msecs = 1000;
 533         int err;
 534
 535         if ((err = libusb_bulk_transfer (handle, 0x01, frame_header, sizeof (frame_header), &transferred, timeout_msecs))) {
 536                 return false;
 537         }
 538
 539         if (redraw()) {
 540                 /* things changed */
 541                 blit_to_device_frame_buffer ();
 542         }
 543
 544         if ((err = libusb_bulk_transfer (handle, 0x01, (uint8_t*) device_frame_buffer , 2 * rows * pixels_per_row, &transferred, timeout_msecs))) {
 545                 return false;
 546         }
 547
 548         return true;
 549 }
 550
 551 int
 552 Push2::set_active (bool yn)
 553 {
 554         DEBUG_TRACE (DEBUG::Push2, string_compose("Push2Protocol::set_active init with yn: '%1'\n", yn));
 555
 556         if (yn == active()) {
 557                 return 0;
 558         }
 559
 560         if (yn) {
 561
 562                 /* start event loop */
 563
 564                 BaseUI::run ();
 565
 566                 if (open ()) {
 567                         DEBUG_TRACE (DEBUG::Push2, "device open failed\n");
 568                         close ();
 569                         return -1;
 570                 }
 571
 572                 /* Connect input port to event loop */
 573
 574                 AsyncMIDIPort* asp;
 575
 576                 asp = dynamic_cast<AsyncMIDIPort*> (_input_port);
 577                 asp->xthread().set_receive_handler (sigc::bind (sigc::mem_fun (this, &Push2::midi_input_handler), _input_port));
 578                 asp->xthread().attach (main_loop()->get_context());
 579
 580                 connect_session_signals ();
 581
 582                 /* set up periodic task used to push a frame buffer to the
 583                  * device (25fps). The device can handle 60fps, but we don't
 584                  * need that frame rate.
 585                  */
 586
 587                 Glib::RefPtr<Glib::TimeoutSource> vblank_timeout = Glib::TimeoutSource::create (40); // milliseconds
 588                 vblank_connection = vblank_timeout->connect (sigc::mem_fun (*this, &Push2::vblank));
 589                 vblank_timeout->attach (main_loop()->get_context());
 590
 591
 592                 Glib::RefPtr<Glib::TimeoutSource> periodic_timeout = Glib::TimeoutSource::create (1000); // milliseconds
 593                 periodic_connection = periodic_timeout->connect (sigc::mem_fun (*this, &Push2::periodic));
 594                 periodic_timeout->attach (main_loop()->get_context());
 595
 596                 init_buttons (true);
 597                 init_touch_strip ();
 598                 set_pad_scale (_scale_root, _root_octave, _mode, _in_key);
 599                 splash ();
 600
 601
 602         } else {
 603
 604                 stop ();
 605
 606         }
 607
 608         ControlProtocol::set_active (yn);
 609
 610         DEBUG_TRACE (DEBUG::Push2, string_compose("Push2Protocol::set_active done with yn: '%1'\n", yn));
 611
 612         return 0;
 613 }
 614
 615 void
 616 Push2::init_touch_strip ()
 617 {
 618         MidiByteArray msg (9, 0xf0, 0x00, 0x21, 0x1d, 0x01, 0x01, 0x17, 0x00, 0xf7);
 619         /* flags are the final byte (ignore end-of-sysex */
 620
 621         /* show bar, not point
 622            autoreturn to center
 623            bar starts at center
 624         */
 625         msg[7] = (1<<4) | (1<<5) | (1<<6);
 626         write (msg);
 627 }
 628
 629 void
 630 Push2::write (const MidiByteArray& data)
 631 {
 632         /* immediate delivery */
 633         _output_port->write (&data[0], data.size(), 0);
 634 }
 635
 636 bool
 637 Push2::midi_input_handler (IOCondition ioc, MIDI::Port* port)
 638 {
 639         if (ioc & ~IO_IN) {
 640                 DEBUG_TRACE (DEBUG::Push2, "MIDI port closed\n");
 641                 return false;
 642         }
 643
 644         if (ioc & IO_IN) {
 645
 646                 // DEBUG_TRACE (DEBUG::Push2, string_compose ("something happend on  %1\n", port->name()));
 647
 648                 AsyncMIDIPort* asp = dynamic_cast<AsyncMIDIPort*>(port);
 649                 if (asp) {
 650                         asp->clear ();
 651                 }
 652
 653                 //DEBUG_TRACE (DEBUG::Push2, string_compose ("data available on %1\n", port->name()));
 654                 framepos_t now = AudioEngine::instance()->sample_time();
 655                 port->parse (now);
 656         }
 657
 658         return true;
 659 }
 660
 661 bool
 662 Push2::periodic ()
 663 {
 664         return true;
 665 }
 666
 667 void
 668 Push2::connect_to_parser ()
 669 {
 670         DEBUG_TRACE (DEBUG::Push2, string_compose ("Connecting to signals on port %2\n", _input_port->name()));
 671
 672         MIDI::Parser* p = _input_port->parser();
 673
 674         /* Incoming sysex */
 675         p->sysex.connect_same_thread (*this, boost::bind (&Push2::handle_midi_sysex, this, _1, _2, _3));
 676         /* V-Pot messages are Controller */
 677         p->controller.connect_same_thread (*this, boost::bind (&Push2::handle_midi_controller_message, this, _1, _2));
 678         /* Button messages are NoteOn */
 679         p->note_on.connect_same_thread (*this, boost::bind (&Push2::handle_midi_note_on_message, this, _1, _2));
 680         /* Button messages are NoteOn but libmidi++ sends note-on w/velocity = 0 as note-off so catch them too */
 681         p->note_off.connect_same_thread (*this, boost::bind (&Push2::handle_midi_note_on_message, this, _1, _2));
 682         /* Fader messages are Pitchbend */
 683         p->channel_pitchbend[0].connect_same_thread (*this, boost::bind (&Push2::handle_midi_pitchbend_message, this, _1, _2));
 684 }
 685
 686 void
 687 Push2::handle_midi_sysex (MIDI::Parser&, MIDI::byte* raw_bytes, size_t sz)
 688 {
 689         DEBUG_TRACE (DEBUG::Push2, string_compose ("Sysex, %1 bytes\n", sz));
 690 }
 691
 692 void
 693 Push2::handle_midi_controller_message (MIDI::Parser&, MIDI::EventTwoBytes* ev)
 694 {
 695         DEBUG_TRACE (DEBUG::Push2, string_compose ("CC %1 (value %2)\n", (int) ev->controller_number, (int) ev->value));
 696
 697         CCButtonMap::iterator b = cc_button_map.find (ev->controller_number);
 698
 699         if (ev->value) {
 700                 /* any press cancels any pending long press timeouts */
 701                 for (set<ButtonID>::iterator x = buttons_down.begin(); x != buttons_down.end(); ++x) {
 702                         Button* bb = id_button_map[*x];
 703                         bb->timeout_connection.disconnect ();
 704                 }
 705         }
 706
 707         if (b != cc_button_map.end()) {
 708
 709                 Button* button = b->second;
 710
 711                 if (ev->value) {
 712                         buttons_down.insert (button->id);
 713                         start_press_timeout (*button, button->id);
 714                 } else {
 715                         buttons_down.erase (button->id);
 716                         button->timeout_connection.disconnect ();
 717                 }
 718
 719
 720                 set<ButtonID>::iterator c = consumed.find (button->id);
 721
 722                 if (c == consumed.end()) {
 723                         if (ev->value == 0) {
 724                                 (this->*button->release_method)();
 725                         } else {
 726                                 (this->*button->press_method)();
 727                         }
 728                 } else {
 729                         DEBUG_TRACE (DEBUG::Push2, "button was consumed, ignored\n");
 730                         consumed.erase (c);
 731                 }
 732
 733         } else {
 734
 735                 /* encoder/vpot */
 736
 737                 int delta = ev->value;
 738
 739                 if (delta > 63) {
 740                         delta = -(128 - delta);
 741                 }
 742
 743                 switch (ev->controller_number) {
 744                 case 71:
 745                         _current_layout->strip_vpot (0, delta);
 746                         break;
 747                 case 72:
 748                         _current_layout->strip_vpot (1, delta);
 749                         break;
 750                 case 73:
 751                         _current_layout->strip_vpot (2, delta);
 752                         break;
 753                 case 74:
 754                         _current_layout->strip_vpot (3, delta);
 755                         break;
 756                 case 75:
 757                         _current_layout->strip_vpot (4, delta);
 758                         break;
 759                 case 76:
 760                         _current_layout->strip_vpot (5, delta);
 761                         break;
 762                 case 77:
 763                         _current_layout->strip_vpot (6, delta);
 764                         break;
 765                 case 78:
 766                         _current_layout->strip_vpot (7, delta);
 767                         break;
 768
 769                         /* left side pair */
 770                 case 14:
 771                         other_vpot (8, delta);
 772                         break;
 773                 case 15:
 774                         other_vpot (1, delta);
 775                         break;
 776
 777                         /* right side */
 778                 case 79:
 779                         other_vpot (2, delta);
 780                         break;
 781                 }
 782         }
 783 }
 784
 785 void
 786 Push2::handle_midi_note_on_message (MIDI::Parser& parser, MIDI::EventTwoBytes* ev)
 787 {
 788         DEBUG_TRACE (DEBUG::Push2, string_compose ("Note On %1 (velocity %2)\n", (int) ev->note_number, (int) ev->velocity));
 789
 790         if (ev->velocity == 0) {
 791                 handle_midi_note_off_message (parser, ev);
 792                 return;
 793         }
 794
 795         switch (ev->note_number) {
 796         case 0:
 797                 _current_layout->strip_vpot_touch (0, ev->velocity > 64);
 798                 break;
 799         case 1:
 800                 _current_layout->strip_vpot_touch (1, ev->velocity > 64);
 801                 break;
 802         case 2:
 803                 _current_layout->strip_vpot_touch (2, ev->velocity > 64);
 804                 break;
 805         case 3:
 806                 _current_layout->strip_vpot_touch (3, ev->velocity > 64);
 807                 break;
 808         case 4:
 809                 _current_layout->strip_vpot_touch (4, ev->velocity > 64);
 810                 break;
 811         case 5:
 812                 _current_layout->strip_vpot_touch (5, ev->velocity > 64);
 813                 break;
 814         case 6:
 815                 _current_layout->strip_vpot_touch (6, ev->velocity > 64);
 816                 break;
 817         case 7:
 818                 _current_layout->strip_vpot_touch (7, ev->velocity > 64);
 819                 break;
 820
 821                 /* left side */
 822         case 10:
 823                 other_vpot_touch (0, ev->velocity > 64);
 824                 break;
 825         case 9:
 826                 other_vpot_touch (1, ev->velocity > 64);
 827                 break;
 828
 829                 /* right side */
 830         case 8:
 831                 other_vpot_touch (3, ev->velocity > 64);
 832                 break;
 833
 834                 /* touch strip */
 835         case 12:
 836                 if (ev->velocity < 64) {
 837                         transport_stop ();
 838                 }
 839                 break;
 840         }
 841
 842         if (ev->note_number < 11) {
 843                 return;
 844         }
 845
 846         /* Pad */
 847
 848         NNPadMap::iterator pi = nn_pad_map.find (ev->note_number);
 849
 850         if (pi == nn_pad_map.end()) {
 851                 return;
 852         }
 853
 854         Pad* pad = pi->second;
 855
 856         if (pad->do_when_pressed == Pad::FlashOn) {
 857                 pad->set_color (LED::White);
 858                 pad->set_state (LED::OneShot24th);
 859                 write (pad->state_msg());
 860         } else if (pad->do_when_pressed == Pad::FlashOff) {
 861                 pad->set_color (LED::Black);
 862                 pad->set_state (LED::OneShot24th);
 863                 write (pad->state_msg());
 864         }
 865 }
 866
 867 void
 868 Push2::handle_midi_note_off_message (MIDI::Parser&, MIDI::EventTwoBytes* ev)
 869 {
 870         DEBUG_TRACE (DEBUG::Push2, string_compose ("Note Off %1 (velocity %2)\n", (int) ev->note_number, (int) ev->velocity));
 871
 872         if (ev->note_number < 11) {
 873                 /* theoretically related to encoder touch start/end, but
 874                  * actually they send note on with two different velocity
 875                  * values (127 & 64).
 876                  */
 877                 return;
 878         }
 879
 880         NNPadMap::iterator pi = nn_pad_map.find (ev->note_number);
 881
 882         if (pi == nn_pad_map.end()) {
 883                 return;
 884         }
 885
 886         Pad* pad = pi->second;
 887
 888         if (pad->do_when_pressed == Pad::FlashOn) {
 889                 pad->set_color (LED::Black);
 890                 pad->set_state (LED::OneShot24th);
 891                 write (pad->state_msg());
 892         } else if (pad->do_when_pressed == Pad::FlashOff) {
 893                 pad->set_color (pad->perma_color);
 894                 pad->set_state (LED::OneShot24th);
 895                 write (pad->state_msg());
 896         }
 897 }
 898
 899 void
 900 Push2::handle_midi_pitchbend_message (MIDI::Parser&, MIDI::pitchbend_t pb)
 901 {
 902 }
 903
 904 void
 905 Push2::thread_init ()
 906 {
 907         struct sched_param rtparam;
 908
 909         pthread_set_name (event_loop_name().c_str());
 910
 911         PBD::notify_event_loops_about_thread_creation (pthread_self(), event_loop_name(), 2048);
 912         ARDOUR::SessionEvent::create_per_thread_pool (event_loop_name(), 128);
 913
 914         memset (&rtparam, 0, sizeof (rtparam));
 915         rtparam.sched_priority = 9; /* XXX should be relative to audio (JACK) thread */
 916
 917         if (pthread_setschedparam (pthread_self(), SCHED_FIFO, &rtparam) != 0) {
 918                 // do we care? not particularly.
 919         }
 920 }
 921
 922 void
 923 Push2::connect_session_signals()
 924 {
 925         // receive routes added
 926         //session->RouteAdded.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&MackieControlProtocol::notify_routes_added, this, _1), this);
 927         // receive VCAs added
 928         //session->vca_manager().VCAAdded.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&Push2::notify_vca_added, this, _1), this);
 929
 930         // receive record state toggled
 931         session->RecordStateChanged.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&Push2::notify_record_state_changed, this), this);
 932         // receive transport state changed
 933         session->TransportStateChange.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&Push2::notify_transport_state_changed, this), this);
 934         session->TransportLooped.connect (session_connections, MISSING_INVALIDATOR, boost::bind (&Push2::notify_loop_state_changed, this), this);
 935         // receive punch-in and punch-out
 936         Config->ParameterChanged.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&Push2::notify_parameter_changed, this, _1), this);
 937         session->config.ParameterChanged.connect (session_connections, MISSING_INVALIDATOR, boost::bind (&Push2::notify_parameter_changed, this, _1), this);
 938         // receive rude solo changed
 939         session->SoloActive.connect(session_connections, MISSING_INVALIDATOR, boost::bind (&Push2::notify_solo_active_changed, this, _1), this);
 940 }
 941
 942 void
 943 Push2::notify_record_state_changed ()
 944 {
 945         IDButtonMap::iterator b = id_button_map.find (RecordEnable);
 946
 947         if (b == id_button_map.end()) {
 948                 return;
 949         }
 950
 951         switch (session->record_status ()) {
 952         case Session::Disabled:
 953                 b->second->set_color (LED::White);
 954                 b->second->set_state (LED::NoTransition);
 955                 break;
 956         case Session::Enabled:
 957                 b->second->set_color (LED::Red);
 958                 b->second->set_state (LED::Blinking4th);
 959                 break;
 960         case Session::Recording:
 961                 b->second->set_color (LED::Red);
 962                 b->second->set_state (LED::OneShot24th);
 963                 break;
 964         }
 965
 966         write (b->second->state_msg());
 967 }
 968
 969 void
 970 Push2::notify_transport_state_changed ()
 971 {
 972         Button* b = id_button_map[Play];
 973
 974         if (session->transport_rolling()) {
 975                 b->set_state (LED::OneShot24th);
 976                 b->set_color (LED::Green);
 977         } else {
 978
 979                 /* disable any blink on FixedLength from pending edit range op */
 980                 Button* fl = id_button_map[FixedLength];
 981
 982                 fl->set_color (LED::Black);
 983                 fl->set_state (LED::NoTransition);
 984                 write (fl->state_msg());
 985
 986                 b->set_color (LED::White);
 987                 b->set_state (LED::NoTransition);
 988         }
 989
 990         write (b->state_msg());
 991 }
 992
 993 void
 994 Push2::notify_loop_state_changed ()
 995 {
 996 }
 997
 998 void
 999 Push2::notify_parameter_changed (std::string param)
1000 {
1001         IDButtonMap::iterator b;
1002
1003         if (param == "clicking") {
1004                 if ((b = id_button_map.find (Metronome)) == id_button_map.end()) {
1005                         return;
1006                 }
1007                 if (Config->get_clicking()) {
1008                         b->second->set_state (LED::Blinking4th);
1009                         b->second->set_color (LED::White);
1010                 } else {
1011                         b->second->set_color (LED::White);
1012                         b->second->set_state (LED::NoTransition);
1013                 }
1014                 write (b->second->state_msg ());
1015         }
1016 }
1017
1018 void
1019 Push2::notify_solo_active_changed (bool yn)
1020 {
1021         IDButtonMap::iterator b = id_button_map.find (Solo);
1022
1023         if (b == id_button_map.end()) {
1024                 return;
1025         }
1026
1027         if (yn) {
1028                 b->second->set_state (LED::Blinking4th);
1029                 b->second->set_color (LED::Red);
1030         } else {
1031                 b->second->set_state (LED::NoTransition);
1032                 b->second->set_color (LED::White);
1033         }
1034
1035         write (b->second->state_msg());
1036 }
1037
1038 XMLNode&
1039 Push2::get_state()
1040 {
1041         XMLNode& node (ControlProtocol::get_state());
1042         XMLNode* child;
1043
1044         child = new XMLNode (X_("Input"));
1045         child->add_child_nocopy (_async_in->get_state());
1046         node.add_child_nocopy (*child);
1047         child = new XMLNode (X_("Output"));
1048         child->add_child_nocopy (_async_out->get_state());
1049         node.add_child_nocopy (*child);
1050
1051         node.add_property (X_("root"), to_string (_scale_root, std::dec));
1052         node.add_property (X_("root_octave"), to_string (_root_octave, std::dec));
1053         node.add_property (X_("in_key"), _in_key ? X_("yes") : X_("no"));
1054         node.add_property (X_("mode"), enum_2_string (_mode));
1055
1056         return node;
1057 }
1058
1059 int
1060 Push2::set_state (const XMLNode & node, int version)
1061 {
1062         DEBUG_TRACE (DEBUG::Push2, string_compose ("Push2::set_state: active %1\n", active()));
1063
1064         int retval = 0;
1065
1066         if (ControlProtocol::set_state (node, version)) {
1067                 return -1;
1068         }
1069
1070         XMLNode* child;
1071
1072         if ((child = node.child (X_("Input"))) != 0) {
1073                 XMLNode* portnode = child->child (Port::state_node_name.c_str());
1074                 if (portnode) {
1075                         _async_in->set_state (*portnode, version);
1076                 }
1077         }
1078
1079         if ((child = node.child (X_("Output"))) != 0) {
1080                 XMLNode* portnode = child->child (Port::state_node_name.c_str());
1081                 if (portnode) {
1082                         _async_out->set_state (*portnode, version);
1083                 }
1084         }
1085
1086         XMLProperty const* prop;
1087
1088         if ((prop = node.property (X_("root"))) != 0) {
1089                 _scale_root = atoi (prop->value());
1090         }
1091
1092         if ((prop = node.property (X_("root_octave"))) != 0) {
1093                 _root_octave = atoi (prop->value());
1094         }
1095
1096         if ((prop = node.property (X_("in_key"))) != 0) {
1097                 _in_key = string_is_affirmative (prop->value());
1098         }
1099
1100         if ((prop = node.property (X_("mode"))) != 0) {
1101                 _mode = (MusicalMode::Type) string_2_enum (prop->value(), _mode);
1102         }
1103
1104         return retval;
1105 }
1106
1107 void
1108 Push2::other_vpot (int n, int delta)
1109 {
1110         switch (n) {
1111         case 0:
1112                 break;
1113         case 1:
1114                 break;
1115         case 2:
1116                 /* master gain control */
1117                 if (master) {
1118                         boost::shared_ptr<AutomationControl> ac = master->gain_control();
1119                         if (ac) {
1120                                 ac->set_value (ac->get_value() + ((2.0/64.0) * delta), PBD::Controllable::UseGroup);
1121                         }
1122                 }
1123                 break;
1124         }
1125 }
1126
1127 void
1128 Push2::other_vpot_touch (int n, bool touching)
1129 {
1130         switch (n) {
1131         case 0:
1132                 break;
1133         case 1:
1134                 break;
1135         case 2:
1136                 if (master) {
1137                         boost::shared_ptr<AutomationControl> ac = master->gain_control();
1138                         if (ac) {
1139                                 if (touching) {
1140                                         ac->start_touch (session->audible_frame());
1141                                 } else {
1142                                         ac->stop_touch (true, session->audible_frame());
1143                                 }
1144                         }
1145                 }
1146         }
1147 }
1148
1149 void
1150 Push2::start_shift ()
1151 {
1152         cerr << "start shift\n";
1153         _modifier_state = ModifierState (_modifier_state | ModShift);
1154         Button* b = id_button_map[Shift];
1155         b->set_color (LED::White);
1156         b->set_state (LED::Blinking16th);
1157         write (b->state_msg());
1158 }
1159
1160 void
1161 Push2::end_shift ()
1162 {
1163         if (_modifier_state & ModShift) {
1164                 cerr << "end shift\n";
1165                 _modifier_state = ModifierState (_modifier_state & ~(ModShift));
1166                 Button* b = id_button_map[Shift];
1167                 b->timeout_connection.disconnect ();
1168                 b->set_color (LED::White);
1169                 b->set_state (LED::OneShot24th);
1170                 write (b->state_msg());
1171         }
1172 }
1173
1174 void
1175 Push2::splash ()
1176 {
1177         std::string splash_file;
1178
1179         Searchpath rc (ARDOUR::ardour_data_search_path());
1180         rc.add_subdirectory_to_paths ("resources");
1181
1182         if (!find_file (rc, PROGRAM_NAME "-splash.png", splash_file)) {
1183                 cerr << "Cannot find splash screen image file\n";
1184                 throw failed_constructor();
1185         }
1186
1187         Cairo::RefPtr<Cairo::ImageSurface> img = Cairo::ImageSurface::create_from_png (splash_file);
1188
1189         double x_ratio = (double) img->get_width() / (cols - 20);
1190         double y_ratio = (double) img->get_height() / (rows - 20);
1191         double scale = min (x_ratio, y_ratio);
1192
1193         /* background */
1194
1195         context->set_source_rgb (0.764, 0.882, 0.882);
1196         context->paint ();
1197
1198         /* image */
1199
1200         context->save ();
1201         context->translate (5, 5);
1202         context->scale (scale, scale);
1203         context->set_source (img, 0, 0);
1204         context->paint ();
1205         context->restore ();
1206
1207         /* text */
1208
1209         Glib::RefPtr<Pango::Layout> some_text = Pango::Layout::create (context);
1210
1211         Pango::FontDescription fd ("Sans 38");
1212         some_text->set_font_description (fd);
1213         some_text->set_text (string_compose ("%1 %2", PROGRAM_NAME, VERSIONSTRING));
1214
1215         context->move_to (200, 10);
1216         context->set_source_rgb (0, 0, 0);
1217         some_text->update_from_cairo_context (context);
1218         some_text->show_in_cairo_context (context);
1219
1220         Pango::FontDescription fd2 ("Sans Italic 18");
1221         some_text->set_font_description (fd2);
1222         some_text->set_text (_("Ableton Push 2 Support"));
1223
1224         context->move_to (200, 80);
1225         context->set_source_rgb (0, 0, 0);
1226         some_text->update_from_cairo_context (context);
1227         some_text->show_in_cairo_context (context);
1228
1229         splash_start = get_microseconds ();
1230         blit_to_device_frame_buffer ();
1231 }
1232
1233 bool
1234 Push2::pad_filter (MidiBuffer& in, MidiBuffer& out) const
1235 {
1236         /* This filter is called asynchronously from a realtime process
1237            context. It must use atomics to check state, and must not block.
1238         */
1239
1240         bool matched = false;
1241
1242         for (MidiBuffer::iterator ev = in.begin(); ev != in.end(); ++ev) {
1243                 if ((*ev).is_note_on() || (*ev).is_note_off()) {
1244
1245                         /* encoder touch start/touch end use note
1246                          * 0-10. touchstrip uses note 12
1247                          */
1248
1249                         if ((*ev).note() > 10 && (*ev).note() != 12) {
1250
1251                                 const int n = (*ev).note ();
1252                                 NNPadMap::const_iterator nni = nn_pad_map.find (n);
1253
1254                                 if (nni != nn_pad_map.end()) {
1255                                         Pad const * pad = nni->second;
1256                                         /* shift for output to the shadow port */
1257                                         if (pad->filtered >= 0) {
1258                                                 (*ev).set_note (pad->filtered + (octave_shift*12));
1259                                                 out.push_back (*ev);
1260                                                 /* shift back so that the pads light correctly  */
1261                                                 (*ev).set_note (n);
1262                                         } else {
1263                                                 /* no mapping, don't send event */
1264                                         }
1265                                 } else {
1266                                         out.push_back (*ev);
1267                                 }
1268
1269                                 matched = true;
1270                         }
1271                 } else if ((*ev).is_pitch_bender() || (*ev).is_aftertouch() || (*ev).is_channel_pressure()) {
1272                         out.push_back (*ev);
1273                 }
1274         }
1275
1276         return matched;
1277 }
1278
1279 bool
1280 Push2::connection_handler (boost::weak_ptr<ARDOUR::Port>, std::string name1, boost::weak_ptr<ARDOUR::Port>, std::string name2, bool yn)
1281 {
1282         DEBUG_TRACE (DEBUG::FaderPort, "FaderPort::connection_handler  start\n");
1283         if (!_input_port || !_output_port) {
1284                 return false;
1285         }
1286
1287         string ni = ARDOUR::AudioEngine::instance()->make_port_name_non_relative (boost::shared_ptr<ARDOUR::Port>(_async_in)->name());
1288         string no = ARDOUR::AudioEngine::instance()->make_port_name_non_relative (boost::shared_ptr<ARDOUR::Port>(_async_out)->name());
1289
1290         if (ni == name1 || ni == name2) {
1291                 if (yn) {
1292                         connection_state |= InputConnected;
1293                 } else {
1294                         connection_state &= ~InputConnected;
1295                 }
1296         } else if (no == name1 || no == name2) {
1297                 if (yn) {
1298                         connection_state |= OutputConnected;
1299                 } else {
1300                         connection_state &= ~OutputConnected;
1301                 }
1302         } else {
1303                 DEBUG_TRACE (DEBUG::FaderPort, string_compose ("Connections between %1 and %2 changed, but I ignored it\n", name1, name2));
1304                 /* not our ports */
1305                 return false;
1306         }
1307
1308         if ((connection_state & (InputConnected|OutputConnected)) == (InputConnected|OutputConnected)) {
1309
1310                 /* XXX this is a horrible hack. Without a short sleep here,
1311                    something prevents the device wakeup messages from being
1312                    sent and/or the responses from being received.
1313                 */
1314
1315                 g_usleep (100000);
1316                 DEBUG_TRACE (DEBUG::FaderPort, "device now connected for both input and output\n");
1317                 // connected ();
1318
1319         } else {
1320                 DEBUG_TRACE (DEBUG::FaderPort, "Device disconnected (input or output or both) or not yet fully connected\n");
1321         }
1322
1323         ConnectionChange (); /* emit signal for our GUI */
1324
1325         DEBUG_TRACE (DEBUG::FaderPort, "FaderPort::connection_handler  end\n");
1326
1327         return true; /* connection status changed */
1328 }
1329
1330 boost::shared_ptr<Port>
1331 Push2::output_port()
1332 {
1333         return _async_out;
1334 }
1335
1336 boost::shared_ptr<Port>
1337 Push2::input_port()
1338 {
1339         return _async_in;
1340 }
1341
1342 int
1343 Push2::pad_note (int row, int col) const
1344 {
1345         NNPadMap::const_iterator nni = nn_pad_map.find (36+(row*8)+col);
1346
1347         if (nni != nn_pad_map.end()) {
1348                 return nni->second->filtered;
1349         }
1350
1351         return 0;
1352 }
1353
1354 void
1355 Push2::set_pad_scale (int root, int octave, MusicalMode::Type mode, bool inkey)
1356 {
1357         MusicalMode m (mode);
1358         vector<float>::iterator interval;
1359         int note;
1360         const int original_root = root;
1361
1362         interval = m.steps.begin();
1363         root += (octave*12);
1364         note = root;
1365
1366         const int root_start = root;
1367
1368         set<int> mode_map; /* contains only notes in mode, O(logN) lookup */
1369         vector<int> mode_vector; /* sorted in note order */
1370
1371         mode_map.insert (note);
1372         mode_vector.push_back (note);
1373
1374         /* build a map of all notes in the mode, from the root to 127 */
1375
1376         while (note < 128) {
1377
1378                 if (interval == m.steps.end()) {
1379
1380                         /* last distance was the end of the scale,
1381                            so wrap, adding the next note at one
1382                            octave above the last root.
1383                         */
1384
1385                         interval = m.steps.begin();
1386                         root += 12;
1387                         mode_map.insert (root);
1388                         mode_vector.push_back (root);
1389
1390                 } else {
1391                         note = (int) floor (root + (2.0 * (*interval)));
1392                         interval++;
1393                         mode_map.insert (note);
1394                         mode_vector.push_back (note);
1395                 }
1396         }
1397
1398         if (inkey) {
1399
1400                 vector<int>::iterator notei;
1401                 int row_offset = 0;
1402                 for (int row = 0; row < 8; ++row) {
1403
1404                         /* Ableton's grid layout wraps the available notes in the scale
1405                          * by offsetting 3 notes per row (from the bottom)
1406                          */
1407
1408                         notei = mode_vector.begin();
1409                         notei += row_offset;
1410                         row_offset += 3;
1411
1412                         for (int col = 0; col < 8; ++col) {
1413                                 int index = 36 + (row*8) + col;
1414                                 Pad* pad = nn_pad_map[index];
1415                                 int notenum;
1416                                 if (notei != mode_vector.end()) {
1417
1418                                         notenum = *notei;
1419                                         pad->filtered = notenum;
1420
1421                                         if ((notenum % 12) == original_root) {
1422                                                 pad->set_color (LED::Green);
1423                                                 pad->perma_color = LED::Green;
1424                                         } else {
1425                                                 pad->set_color (LED::White);
1426                                                 pad->perma_color = LED::White;
1427                                         }
1428
1429                                         pad->do_when_pressed = Pad::FlashOff;
1430                                         notei++;
1431
1432                                 } else {
1433
1434                                         pad->set_color (LED::Black);
1435                                         pad->do_when_pressed = Pad::Nothing;
1436                                         pad->filtered = -1;
1437                                 }
1438
1439                                 write (pad->state_msg());
1440                         }
1441                 }
1442
1443         } else {
1444
1445                 /* chromatic: all notes available, but highlight those in the scale */
1446
1447                 for (note = 36; note < 100; ++note) {
1448
1449                         Pad* pad = nn_pad_map[note];
1450
1451                         /* Chromatic: all pads play, half-tone steps. Light
1452                          * those in the scale, and highlight root notes
1453                          */
1454
1455                         pad->filtered = root_start + (note - 36);
1456
1457                         if (mode_map.find (note) != mode_map.end()) {
1458
1459                                 if ((note % 12) == original_root) {
1460                                         pad->set_color (LED::Green);
1461                                         pad->perma_color = LED::Green;
1462                                 } else {
1463                                         pad->set_color (LED::White);
1464                                         pad->perma_color = LED::White;
1465                                 }
1466
1467                                 pad->do_when_pressed = Pad::FlashOff;
1468
1469                         } else {
1470
1471                                 /* note is not in mode, turn it off */
1472
1473                                 pad->do_when_pressed = Pad::FlashOn;
1474                                 pad->set_color (LED::Black);
1475
1476                         }
1477
1478                         write (pad->state_msg());
1479                 }
1480         }
1481
1482         PadChange (); /* EMIT SIGNAL */
1483
1484         /* store state */
1485
1486         _scale_root = original_root;
1487         _root_octave = octave;
1488         _in_key = inkey;
1489         _mode = mode;
1490 }
1491
1492 void
1493 Push2::set_percussive_mode (bool yn)
1494 {
1495         if (!yn) {
1496                 cerr << "back to scale\n";
1497                 set_pad_scale (_scale_root, _root_octave, _mode, _in_key);
1498                 percussion = false;
1499                 return;
1500         }
1501
1502         int drum_note = 36;
1503
1504         for (int row = 0; row < 8; ++row) {
1505
1506                 for (int col = 0; col < 4; ++col) {
1507
1508                         int index = 36 + (row*8) + col;
1509                         Pad* pad = nn_pad_map[index];
1510
1511                         pad->filtered = drum_note;
1512                         drum_note++;
1513                 }
1514         }
1515
1516         for (int row = 0; row < 8; ++row) {
1517
1518                 for (int col = 4; col < 8; ++col) {
1519
1520                         int index = 36 + (row*8) + col;
1521                         Pad* pad = nn_pad_map[index];
1522
1523                         pad->filtered = drum_note;
1524                         drum_note++;
1525                 }
1526         }
1527
1528         percussion = true;
1529
1530         PadChange (); /* EMIT SIGNAL */
1531 }
1532
1533 Push2Layout*
1534 Push2::current_layout () const
1535 {
1536         Glib::Threads::Mutex::Lock lm (layout_lock);
1537         return _current_layout;
1538 }
1539
1540 void
1541 Push2::stripable_selection_change (StripableNotificationListPtr selected)
1542 {
1543         boost::shared_ptr<MidiPort> pad_port = boost::dynamic_pointer_cast<AsyncMIDIPort>(_async_in)->shadow_port();
1544         boost::shared_ptr<MidiTrack> current_midi_track = current_pad_target.lock();
1545         boost::shared_ptr<MidiTrack> new_pad_target;
1546
1547         /* See if there's a MIDI track selected */
1548
1549         for (StripableNotificationList::iterator si = selected->begin(); si != selected->end(); ++si) {
1550
1551                 new_pad_target = boost::dynamic_pointer_cast<MidiTrack> ((*si).lock());
1552
1553                 if (new_pad_target) {
1554                         break;
1555                 }
1556         }
1557
1558         if (new_pad_target) {
1559                 cerr << "new midi pad target " << new_pad_target->name() << endl;
1560         } else {
1561                 cerr << "no midi pad target\n";
1562         }
1563
1564         if (current_midi_track == new_pad_target) {
1565                 /* nothing to do */
1566                 return;
1567         }
1568
1569         if (!new_pad_target) {
1570                 /* leave existing connection alone */
1571                 return;
1572         }
1573
1574         /* disconnect from pad port, if appropriate */
1575
1576         if (current_midi_track && pad_port) {
1577                 cerr << "Disconnect pads from " << current_midi_track->name() << endl;
1578                 current_midi_track->input()->disconnect (current_midi_track->input()->nth(0), pad_port->name(), this);
1579         }
1580
1581         /* now connect the pad port to this (newly) selected midi
1582          * track, if indeed there is one.
1583          */
1584
1585         if (new_pad_target && pad_port) {
1586                 cerr << "Reconnect pads to " << new_pad_target->name() << endl;
1587                 new_pad_target->input()->connect (new_pad_target->input()->nth (0), pad_port->name(), this);
1588                 current_pad_target = new_pad_target;
1589         } else {
1590                 current_pad_target.reset ();
1591         }
1592 }
1593
1594 Push2::Button*
1595 Push2::button_by_id (ButtonID bid)
1596 {
1597         return id_button_map[bid];
1598 }