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