libs/ardour/session_midi.cc

   1
   2 /*
   3   Copyright (C) 1999-2002 Paul Davis
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9
  10   This program is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13   GNU General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with this program; if not, write to the Free Software
  17   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include <string>
  22 #include <cmath>
  23 #include <cerrno>
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <poll.h>
  27
  28 #include <midi++/mmc.h>
  29 #include <midi++/port.h>
  30 #include <midi++/manager.h>
  31 #include <pbd/error.h>
  32 #include <glibmm/thread.h>
  33 #include <pbd/pthread_utils.h>
  34
  35 #include <ardour/configuration.h>
  36 #include <ardour/audioengine.h>
  37 #include <ardour/session.h>
  38 #include <ardour/audio_track.h>
  39 #include <ardour/audio_diskstream.h>
  40 #include <ardour/slave.h>
  41 #include <ardour/cycles.h>
  42
  43 #include "i18n.h"
  44
  45 using namespace std;
  46 using namespace ARDOUR;
  47 using namespace PBD;
  48 using namespace MIDI;
  49
  50 MachineControl::CommandSignature MMC_CommandSignature;
  51 MachineControl::ResponseSignature MMC_ResponseSignature;
  52
  53 MultiAllocSingleReleasePool Session::MIDIRequest::pool ("midi", sizeof (Session::MIDIRequest), 1024);
  54
  55 int
  56 Session::use_config_midi_ports ()
  57 {
  58         string port_name;
  59
  60         if (default_mmc_port) {
  61                 set_mmc_port (default_mmc_port->name());
  62         } else {
  63                 set_mmc_port ("");
  64         }
  65
  66         if (default_mtc_port) {
  67                 set_mtc_port (default_mtc_port->name());
  68         } else {
  69                 set_mtc_port ("");
  70         }
  71
  72         if (default_midi_port) {
  73                 set_midi_port (default_midi_port->name());
  74         } else {
  75                 set_midi_port ("");
  76         }
  77
  78         return 0;
  79 }
  80
  81
  82 /***********************************************************************
  83  MTC, MMC, etc.
  84 **********************************************************************/
  85
  86 int
  87 Session::set_mtc_port (string port_tag)
  88 {
  89         MTC_Slave *ms;
  90
  91         if (port_tag.length() == 0) {
  92
  93                 if (_slave && ((ms = dynamic_cast<MTC_Slave*> (_slave)) != 0)) {
  94                         error << _("Ardour is slaved to MTC - port cannot be reset") << endmsg;
  95                         return -1;
  96                 }
  97
  98                 if (_mtc_port == 0) {
  99                         return 0;
 100                 }
 101
 102                 _mtc_port = 0;
 103                 goto out;
 104         }
 105
 106         MIDI::Port* port;
 107
 108         if ((port = MIDI::Manager::instance()->port (port_tag)) == 0) {
 109                 error << string_compose (_("unknown port %1 requested for MTC"), port_tag) << endl;
 110                 return -1;
 111         }
 112
 113         _mtc_port = port;
 114
 115         if (_slave && ((ms = dynamic_cast<MTC_Slave*> (_slave)) != 0)) {
 116                 ms->rebind (*port);
 117         }
 118
 119         Config->set_mtc_port_name (port_tag);
 120
 121   out:
 122         MTC_PortChanged(); /* EMIT SIGNAL */
 123         change_midi_ports ();
 124         set_dirty();
 125         return 0;
 126 }
 127
 128 void
 129 Session::set_mmc_receive_device_id (uint32_t device_id)
 130 {
 131         if (mmc) {
 132                 mmc->set_receive_device_id (device_id);
 133         }
 134 }
 135
 136 void
 137 Session::set_mmc_send_device_id (uint32_t device_id)
 138 {
 139         if (mmc) {
 140                 mmc->set_send_device_id (device_id);
 141                 /* reset MMC buffer */
 142                 mmc_buffer[2] = mmc->send_device_id();
 143         }
 144 }
 145
 146 int
 147 Session::set_mmc_port (string port_tag)
 148 {
 149         MIDI::byte old_recv_device_id = 0;
 150         MIDI::byte old_send_device_id = 0;
 151         bool reset_id = false;
 152
 153         if (port_tag.length() == 0) {
 154                 if (_mmc_port == 0) {
 155                         return 0;
 156                 }
 157                 _mmc_port = 0;
 158                 goto out;
 159         }
 160
 161         MIDI::Port* port;
 162
 163         if ((port = MIDI::Manager::instance()->port (port_tag)) == 0) {
 164                 return -1;
 165         }
 166
 167         _mmc_port = port;
 168
 169         if (mmc) {
 170                 old_recv_device_id = mmc->receive_device_id();
 171                 old_recv_device_id = mmc->send_device_id();
 172                 reset_id = true;
 173                 delete mmc;
 174         }
 175
 176         mmc = new MIDI::MachineControl (*_mmc_port, 1.0,
 177                                         MMC_CommandSignature,
 178                                         MMC_ResponseSignature);
 179
 180         if (reset_id) {
 181                 set_mmc_receive_device_id (old_recv_device_id);
 182                 set_mmc_send_device_id (old_send_device_id);
 183         }
 184
 185         mmc->Play.connect
 186                 (mem_fun (*this, &Session::mmc_deferred_play));
 187         mmc->DeferredPlay.connect
 188                 (mem_fun (*this, &Session::mmc_deferred_play));
 189         mmc->Stop.connect
 190                 (mem_fun (*this, &Session::mmc_stop));
 191         mmc->FastForward.connect
 192                 (mem_fun (*this, &Session::mmc_fast_forward));
 193         mmc->Rewind.connect
 194                 (mem_fun (*this, &Session::mmc_rewind));
 195         mmc->Pause.connect
 196                 (mem_fun (*this, &Session::mmc_pause));
 197         mmc->RecordPause.connect
 198                 (mem_fun (*this, &Session::mmc_record_pause));
 199         mmc->RecordStrobe.connect
 200                 (mem_fun (*this, &Session::mmc_record_strobe));
 201         mmc->RecordExit.connect
 202                 (mem_fun (*this, &Session::mmc_record_exit));
 203         mmc->Locate.connect
 204                 (mem_fun (*this, &Session::mmc_locate));
 205         mmc->Step.connect
 206                 (mem_fun (*this, &Session::mmc_step));
 207         mmc->Shuttle.connect
 208                 (mem_fun (*this, &Session::mmc_shuttle));
 209         mmc->TrackRecordStatusChange.connect
 210                 (mem_fun (*this, &Session::mmc_record_enable));
 211
 212
 213         /* also handle MIDI SPP because its so common */
 214
 215         _mmc_port->input()->start.connect (mem_fun (*this, &Session::spp_start));
 216         _mmc_port->input()->contineu.connect (mem_fun (*this, &Session::spp_continue));
 217         _mmc_port->input()->stop.connect (mem_fun (*this, &Session::spp_stop));
 218
 219         Config->set_mmc_port_name (port_tag);
 220
 221   out:
 222         MMC_PortChanged(); /* EMIT SIGNAL */
 223         change_midi_ports ();
 224         set_dirty();
 225         return 0;
 226 }
 227
 228 int
 229 Session::set_midi_port (string port_tag)
 230 {
 231         if (port_tag.length() == 0) {
 232                 if (_midi_port == 0) {
 233                         return 0;
 234                 }
 235                 _midi_port = 0;
 236                 goto out;
 237         }
 238
 239         MIDI::Port* port;
 240
 241         if ((port = MIDI::Manager::instance()->port (port_tag)) == 0) {
 242                 return -1;
 243         }
 244
 245         _midi_port = port;
 246
 247         /* XXX need something to forward this to control protocols ? or just
 248            use the signal below
 249         */
 250
 251         Config->set_midi_port_name (port_tag);
 252
 253   out:
 254         MIDI_PortChanged(); /* EMIT SIGNAL */
 255         change_midi_ports ();
 256         set_dirty();
 257         return 0;
 258 }
 259
 260 void
 261 Session::set_trace_midi_input (bool yn, MIDI::Port* port)
 262 {
 263         MIDI::Parser* input_parser;
 264
 265         if (port) {
 266                 if ((input_parser = port->input()) != 0) {
 267                         input_parser->trace (yn, &cout, "input: ");
 268                 }
 269         } else {
 270
 271                 if (_mmc_port) {
 272                         if ((input_parser = _mmc_port->input()) != 0) {
 273                                 input_parser->trace (yn, &cout, "input: ");
 274                         }
 275                 }
 276
 277                 if (_mtc_port && _mtc_port != _mmc_port) {
 278                         if ((input_parser = _mtc_port->input()) != 0) {
 279                                 input_parser->trace (yn, &cout, "input: ");
 280                         }
 281                 }
 282
 283                 if (_midi_port && _midi_port != _mmc_port && _midi_port != _mtc_port  ) {
 284                         if ((input_parser = _midi_port->input()) != 0) {
 285                                 input_parser->trace (yn, &cout, "input: ");
 286                         }
 287                 }
 288         }
 289
 290         Config->set_trace_midi_input (yn);
 291 }
 292
 293 void
 294 Session::set_trace_midi_output (bool yn, MIDI::Port* port)
 295 {
 296         MIDI::Parser* output_parser;
 297
 298         if (port) {
 299                 if ((output_parser = port->output()) != 0) {
 300                         output_parser->trace (yn, &cout, "output: ");
 301                 }
 302         } else {
 303                 if (_mmc_port) {
 304                         if ((output_parser = _mmc_port->output()) != 0) {
 305                                 output_parser->trace (yn, &cout, "output: ");
 306                         }
 307                 }
 308
 309                 if (_mtc_port && _mtc_port != _mmc_port) {
 310                         if ((output_parser = _mtc_port->output()) != 0) {
 311                                 output_parser->trace (yn, &cout, "output: ");
 312                         }
 313                 }
 314
 315                 if (_midi_port && _midi_port != _mmc_port && _midi_port != _mtc_port  ) {
 316                         if ((output_parser = _midi_port->output()) != 0) {
 317                                 output_parser->trace (yn, &cout, "output: ");
 318                         }
 319                 }
 320
 321         }
 322
 323         Config->set_trace_midi_output (yn);
 324 }
 325
 326 bool
 327 Session::get_trace_midi_input(MIDI::Port *port)
 328 {
 329         MIDI::Parser* input_parser;
 330         if (port) {
 331                 if ((input_parser = port->input()) != 0) {
 332                         return input_parser->tracing();
 333                 }
 334         }
 335         else {
 336                 if (_mmc_port) {
 337                         if ((input_parser = _mmc_port->input()) != 0) {
 338                                 return input_parser->tracing();
 339                         }
 340                 }
 341
 342                 if (_mtc_port) {
 343                         if ((input_parser = _mtc_port->input()) != 0) {
 344                                 return input_parser->tracing();
 345                         }
 346                 }
 347
 348                 if (_midi_port) {
 349                         if ((input_parser = _midi_port->input()) != 0) {
 350                                 return input_parser->tracing();
 351                         }
 352                 }
 353         }
 354
 355         return false;
 356 }
 357
 358 bool
 359 Session::get_trace_midi_output(MIDI::Port *port)
 360 {
 361         MIDI::Parser* output_parser;
 362         if (port) {
 363                 if ((output_parser = port->output()) != 0) {
 364                         return output_parser->tracing();
 365                 }
 366         }
 367         else {
 368                 if (_mmc_port) {
 369                         if ((output_parser = _mmc_port->output()) != 0) {
 370                                 return output_parser->tracing();
 371                         }
 372                 }
 373
 374                 if (_mtc_port) {
 375                         if ((output_parser = _mtc_port->output()) != 0) {
 376                                 return output_parser->tracing();
 377                         }
 378                 }
 379
 380                 if (_midi_port) {
 381                         if ((output_parser = _midi_port->output()) != 0) {
 382                                 return output_parser->tracing();
 383                         }
 384                 }
 385         }
 386
 387         return false;
 388
 389 }
 390
 391 void
 392 Session::setup_midi_control ()
 393 {
 394         outbound_mtc_smpte_frame = 0;
 395         next_quarter_frame_to_send = -1;
 396
 397         /* setup the MMC buffer */
 398
 399         mmc_buffer[0] = 0xf0; // SysEx
 400         mmc_buffer[1] = 0x7f; // Real Time SysEx ID for MMC
 401         mmc_buffer[2] = (mmc ? mmc->send_device_id() : 0x7f);
 402         mmc_buffer[3] = 0x6;  // MCC
 403
 404         /* Set up the qtr frame message */
 405
 406         mtc_msg[0] = 0xf1;
 407         mtc_msg[2] = 0xf1;
 408         mtc_msg[4] = 0xf1;
 409         mtc_msg[6] = 0xf1;
 410         mtc_msg[8] = 0xf1;
 411         mtc_msg[10] = 0xf1;
 412         mtc_msg[12] = 0xf1;
 413         mtc_msg[14] = 0xf1;
 414 }
 415
 416 int
 417 Session::midi_read (MIDI::Port* port)
 418 {
 419         MIDI::byte buf[512];
 420
 421         /* reading from the MIDI port activates the Parser
 422            that in turn generates signals that we care
 423            about. the port is already set to NONBLOCK so that
 424            can read freely here.
 425         */
 426
 427         while (1) {
 428
 429                 // cerr << "+++ READ ON " << port->name() << endl;
 430
 431                 int nread = port->read (buf, sizeof (buf));
 432
 433                 // cerr << "-- READ (" << nread << " ON " << port->name() << endl;
 434
 435                 if (nread > 0) {
 436                         if ((size_t) nread < sizeof (buf)) {
 437                                 break;
 438                         } else {
 439                                 continue;
 440                         }
 441                 } else if (nread == 0) {
 442                         break;
 443                 } else if (errno == EAGAIN) {
 444                         break;
 445                 } else {
 446                         fatal << string_compose(_("Error reading from MIDI port %1"), port->name()) << endmsg;
 447                         /*NOTREACHED*/
 448                 }
 449         }
 450
 451         return 0;
 452 }
 453
 454 void
 455 Session::spp_start (Parser& ignored)
 456 {
 457         if (Config->get_mmc_control() && (Config->get_slave_source() != MTC)) {
 458                 request_transport_speed (1.0);
 459         }
 460 }
 461
 462 void
 463 Session::spp_continue (Parser& ignored)
 464 {
 465         spp_start (ignored);
 466 }
 467
 468 void
 469 Session::spp_stop (Parser& ignored)
 470 {
 471         if (Config->get_mmc_control()) {
 472                 request_stop ();
 473         }
 474 }
 475
 476 void
 477 Session::mmc_deferred_play (MIDI::MachineControl &mmc)
 478 {
 479         if (Config->get_mmc_control() && (Config->get_slave_source() != MTC)) {
 480                 request_transport_speed (1.0);
 481         }
 482 }
 483
 484 void
 485 Session::mmc_record_pause (MIDI::MachineControl &mmc)
 486 {
 487         if (Config->get_mmc_control()) {
 488                 maybe_enable_record();
 489         }
 490 }
 491
 492 void
 493 Session::mmc_record_strobe (MIDI::MachineControl &mmc)
 494 {
 495         if (!Config->get_mmc_control())
 496                 return;
 497
 498         /* record strobe does an implicit "Play" command */
 499
 500         if (_transport_speed != 1.0) {
 501
 502                 /* start_transport() will move from Enabled->Recording, so we
 503                    don't need to do anything here except enable recording.
 504                    its not the same as maybe_enable_record() though, because
 505                    that *can* switch to Recording, which we do not want.
 506                 */
 507
 508                 save_state ("", true);
 509                 g_atomic_int_set (&_record_status, Enabled);
 510                 RecordStateChanged (); /* EMIT SIGNAL */
 511
 512                 request_transport_speed (1.0);
 513
 514         } else {
 515
 516                 enable_record ();
 517         }
 518 }
 519
 520 void
 521 Session::mmc_record_exit (MIDI::MachineControl &mmc)
 522 {
 523         if (Config->get_mmc_control()) {
 524                 disable_record (false);
 525         }
 526 }
 527
 528 void
 529 Session::mmc_stop (MIDI::MachineControl &mmc)
 530 {
 531         if (Config->get_mmc_control()) {
 532                 request_stop ();
 533         }
 534 }
 535
 536 void
 537 Session::mmc_pause (MIDI::MachineControl &mmc)
 538 {
 539         if (Config->get_mmc_control()) {
 540
 541                 /* We support RECORD_PAUSE, so the spec says that
 542                    we must interpret PAUSE like RECORD_PAUSE if
 543                    recording.
 544                 */
 545
 546                 if (actively_recording()) {
 547                         maybe_enable_record ();
 548                 } else {
 549                         request_stop ();
 550                 }
 551         }
 552 }
 553
 554 static bool step_queued = false;
 555
 556 void
 557 Session::mmc_step (MIDI::MachineControl &mmc, int steps)
 558 {
 559         if (!Config->get_mmc_control()) {
 560                 return;
 561         }
 562
 563         struct timeval now;
 564         struct timeval diff = { 0, 0 };
 565
 566         gettimeofday (&now, 0);
 567
 568         timersub (&now, &last_mmc_step, &diff);
 569
 570         gettimeofday (&now, 0);
 571         timersub (&now, &last_mmc_step, &diff);
 572
 573         if (last_mmc_step.tv_sec != 0 && (diff.tv_usec + (diff.tv_sec * 1000000)) < _engine.usecs_per_cycle()) {
 574                 return;
 575         }
 576
 577         double diff_secs = diff.tv_sec + (diff.tv_usec / 1000000.0);
 578         double cur_speed = (((steps * 0.5) * smpte_frames_per_second()) / diff_secs) / smpte_frames_per_second();
 579
 580         if (_transport_speed == 0 || cur_speed * _transport_speed < 0) {
 581                 /* change direction */
 582                 step_speed = cur_speed;
 583         } else {
 584                 step_speed = (0.6 * step_speed) + (0.4 * cur_speed);
 585         }
 586
 587         step_speed *= 0.25;
 588
 589 #if 0
 590         cerr << "delta = " << diff_secs
 591              << " ct = " << _transport_speed
 592              << " steps = " << steps
 593              << " new speed = " << cur_speed
 594              << " speed = " << step_speed
 595              << endl;
 596 #endif
 597
 598         request_transport_speed (step_speed);
 599         last_mmc_step = now;
 600
 601         if (!step_queued) {
 602                 midi_timeouts.push_back (mem_fun (*this, &Session::mmc_step_timeout));
 603                 step_queued = true;
 604         }
 605 }
 606
 607 void
 608 Session::mmc_rewind (MIDI::MachineControl &mmc)
 609 {
 610         if (Config->get_mmc_control()) {
 611                 request_transport_speed(-8.0f);
 612         }
 613 }
 614
 615 void
 616 Session::mmc_fast_forward (MIDI::MachineControl &mmc)
 617 {
 618         if (Config->get_mmc_control()) {
 619                 request_transport_speed(8.0f);
 620         }
 621 }
 622
 623 void
 624 Session::mmc_locate (MIDI::MachineControl &mmc, const MIDI::byte* mmc_tc)
 625 {
 626         if (!Config->get_mmc_control()) {
 627                 return;
 628         }
 629
 630         nframes_t target_frame;
 631         SMPTE::Time smpte;
 632
 633         smpte.hours = mmc_tc[0] & 0xf;
 634         smpte.minutes = mmc_tc[1];
 635         smpte.seconds = mmc_tc[2];
 636         smpte.frames = mmc_tc[3];
 637         smpte.rate = smpte_frames_per_second();
 638         smpte.drop = smpte_drop_frames();
 639
 640         // Also takes smpte offset into account:
 641         smpte_to_sample( smpte, target_frame, true /* use_offset */, false /* use_subframes */ );
 642
 643         if (target_frame > max_frames) {
 644                 target_frame = max_frames;
 645         }
 646
 647         /* Some (all?) MTC/MMC devices do not send a full MTC frame
 648            at the end of a locate, instead sending only an MMC
 649            locate command. This causes the current position
 650            of an MTC slave to become out of date. Catch this.
 651         */
 652
 653         MTC_Slave* mtcs = dynamic_cast<MTC_Slave*> (_slave);
 654
 655         if (mtcs != 0) {
 656                 // cerr << "Locate *with* MTC slave\n";
 657                 mtcs->handle_locate (mmc_tc);
 658         } else {
 659                 // cerr << "Locate without MTC slave\n";
 660                 request_locate (target_frame, false);
 661         }
 662 }
 663
 664 void
 665 Session::mmc_shuttle (MIDI::MachineControl &mmc, float speed, bool forw)
 666 {
 667         if (!Config->get_mmc_control()) {
 668                 return;
 669         }
 670
 671         if (Config->get_shuttle_speed_threshold() >= 0 && speed > Config->get_shuttle_speed_threshold()) {
 672                 speed *= Config->get_shuttle_speed_factor();
 673         }
 674
 675         if (forw) {
 676                 request_transport_speed (speed);
 677         } else {
 678                 request_transport_speed (-speed);
 679         }
 680 }
 681
 682 void
 683 Session::mmc_record_enable (MIDI::MachineControl &mmc, size_t trk, bool enabled)
 684 {
 685         if (Config->get_mmc_control()) {
 686
 687                 RouteList::iterator i;
 688                 boost::shared_ptr<RouteList> r = routes.reader();
 689
 690                 for (i = r->begin(); i != r->end(); ++i) {
 691                         AudioTrack *at;
 692
 693                         if ((at = dynamic_cast<AudioTrack*>((*i).get())) != 0) {
 694                                 if (trk == at->remote_control_id()) {
 695                                         at->set_record_enable (enabled, &mmc);
 696                                         break;
 697                                 }
 698                         }
 699                 }
 700         }
 701 }
 702
 703 void
 704 Session::send_full_time_code_in_another_thread ()
 705 {
 706         send_time_code_in_another_thread (true);
 707 }
 708
 709 void
 710 Session::send_midi_time_code_in_another_thread ()
 711 {
 712         send_time_code_in_another_thread (false);
 713 }
 714
 715 void
 716 Session::send_time_code_in_another_thread (bool full)
 717 {
 718         nframes_t two_smpte_frames_duration;
 719         nframes_t quarter_frame_duration;
 720
 721         /* Duration of two smpte frames */
 722         two_smpte_frames_duration = ((long) _frames_per_smpte_frame) << 1;
 723
 724         /* Duration of one quarter frame */
 725         quarter_frame_duration = ((long) _frames_per_smpte_frame) >> 2;
 726
 727         if (_transport_frame < (outbound_mtc_smpte_frame + (next_quarter_frame_to_send * quarter_frame_duration)))
 728         {
 729                 /* There is no work to do.
 730                    We throttle this here so that we don't overload
 731                    the transport thread with requests.
 732                 */
 733                 return;
 734         }
 735
 736         MIDIRequest* request = new MIDIRequest;
 737
 738         if (full) {
 739                 request->type = MIDIRequest::SendFullMTC;
 740         } else {
 741                 request->type = MIDIRequest::SendMTC;
 742         }
 743
 744         midi_requests.write (&request, 1);
 745         poke_midi_thread ();
 746 }
 747
 748 void
 749 Session::change_midi_ports ()
 750 {
 751         MIDIRequest* request = new MIDIRequest;
 752
 753         request->type = MIDIRequest::PortChange;
 754         midi_requests.write (&request, 1);
 755         poke_midi_thread ();
 756 }
 757
 758 int
 759 Session::send_full_time_code ()
 760
 761 {
 762         MIDI::byte msg[10];
 763         SMPTE::Time smpte;
 764
 765         _send_smpte_update = false;
 766
 767         if (_mtc_port == 0 || !session_send_mtc) {
 768                 return 0;
 769         }
 770
 771         // Get smpte time for this transport frame
 772         sample_to_smpte(_transport_frame, smpte, true /* use_offset */, false /* no subframes */);
 773
 774         // Check for negative smpte time and prepare for quarter frame transmission
 775         if (smpte.negative) {
 776                 // Negative mtc is not defined, so sync slave to smpte zero.
 777                 // When _transport_frame gets there we will start transmitting quarter frames
 778                 smpte.hours = 0;
 779                 smpte.minutes = 0;
 780                 smpte.seconds = 0;
 781                 smpte.frames = 0;
 782                 smpte.subframes = 0;
 783                 smpte.negative = false;
 784                 smpte_to_sample( smpte, outbound_mtc_smpte_frame, true, false );
 785                 transmitting_smpte_time = smpte;
 786         } else {
 787                 transmitting_smpte_time = smpte;
 788                 outbound_mtc_smpte_frame = _transport_frame;
 789                 if (((mtc_smpte_bits >> 5) != MIDI::MTC_25_FPS) && (transmitting_smpte_time.frames % 2)) {
 790                         // start MTC quarter frame transmission on an even frame
 791                         SMPTE::increment( transmitting_smpte_time );
 792                         outbound_mtc_smpte_frame += (nframes_t) _frames_per_smpte_frame;
 793                 }
 794         }
 795
 796         // Compensate for audio latency
 797         outbound_mtc_smpte_frame += _worst_output_latency;
 798
 799         next_quarter_frame_to_send = 0;
 800
 801         // Sync slave to the same smpte time as we are on (except if negative, see above)
 802         msg[0] = 0xf0;
 803         msg[1] = 0x7f;
 804         msg[2] = 0x7f;
 805         msg[3] = 0x1;
 806         msg[4] = 0x1;
 807         msg[9] = 0xf7;
 808
 809         msg[5] = mtc_smpte_bits | smpte.hours;
 810         msg[6] = smpte.minutes;
 811         msg[7] = smpte.seconds;
 812         msg[8] = smpte.frames;
 813
 814         {
 815                 Glib::Mutex::Lock lm (midi_lock);
 816
 817                 if (_mtc_port->midimsg (msg, sizeof (msg))) {
 818                         error << _("Session: could not send full MIDI time code") << endmsg;
 819
 820                         return -1;
 821                 }
 822         }
 823
 824         return 0;
 825 }
 826
 827 int
 828 Session::send_midi_time_code ()
 829 {
 830         if (_mtc_port == 0 || !session_send_mtc || transmitting_smpte_time.negative || (next_quarter_frame_to_send < 0) )  {
 831                 return 0;
 832         }
 833
 834         /* Duration of one quarter frame */
 835         nframes_t const quarter_frame_duration = ((long) _frames_per_smpte_frame) >> 2;
 836
 837         while (_transport_frame >= (outbound_mtc_smpte_frame + (next_quarter_frame_to_send * quarter_frame_duration))) {
 838
 839                 // Send quarter frames up to current time
 840                 {
 841                         Glib::Mutex::Lock lm (midi_lock);
 842
 843                         switch(next_quarter_frame_to_send) {
 844                         case 0:
 845                                 mtc_msg[1] =  0x00 | (transmitting_smpte_time.frames & 0xf);
 846                                 break;
 847                         case 1:
 848                                 mtc_msg[1] =  0x10 | ((transmitting_smpte_time.frames & 0xf0) >> 4);
 849                                 break;
 850                         case 2:
 851                                 mtc_msg[1] =  0x20 | (transmitting_smpte_time.seconds & 0xf);
 852                                 break;
 853                         case 3:
 854                                 mtc_msg[1] =  0x30 | ((transmitting_smpte_time.seconds & 0xf0) >> 4);
 855                                 break;
 856                         case 4:
 857                                 mtc_msg[1] =  0x40 | (transmitting_smpte_time.minutes & 0xf);
 858                                 break;
 859                         case 5:
 860                                 mtc_msg[1] = 0x50 | ((transmitting_smpte_time.minutes & 0xf0) >> 4);
 861                                 break;
 862                         case 6:
 863                                 mtc_msg[1] = 0x60 | ((mtc_smpte_bits|transmitting_smpte_time.hours) & 0xf);
 864                                 break;
 865                         case 7:
 866                                 mtc_msg[1] = 0x70 | (((mtc_smpte_bits|transmitting_smpte_time.hours) & 0xf0) >> 4);
 867                                 break;
 868                         }
 869
 870                         if (_mtc_port->midimsg (mtc_msg, 2)) {
 871                                 error << string_compose(_("Session: cannot send quarter-frame MTC message (%1)"), strerror (errno))
 872                                       << endmsg;
 873
 874                                 return -1;
 875                         }
 876
 877                         //       cout << "smpte = " << transmitting_smpte_time.hours << ":" << transmitting_smpte_time.minutes << ":" << transmitting_smpte_time.seconds << ":" << transmitting_smpte_time.frames << ", qfm = " << next_quarter_frame_to_send << endl;
 878
 879                         // Increment quarter frame counter
 880                         next_quarter_frame_to_send++;
 881
 882                         if (next_quarter_frame_to_send >= 8) {
 883                                 // Wrap quarter frame counter
 884                                 next_quarter_frame_to_send = 0;
 885                                 // Increment smpte time twice
 886                                 SMPTE::increment( transmitting_smpte_time );
 887                                 SMPTE::increment( transmitting_smpte_time );
 888                                 // Re-calculate timing of first quarter frame
 889                                 smpte_to_sample( transmitting_smpte_time, outbound_mtc_smpte_frame, true /* use_offset */, false );
 890                                 // Compensate for audio latency
 891                                 outbound_mtc_smpte_frame += _worst_output_latency;
 892                         }
 893                 }
 894         }
 895         return 0;
 896 }
 897
 898 /***********************************************************************
 899  OUTBOUND MMC STUFF
 900 **********************************************************************/
 901
 902 void
 903 Session::send_mmc_in_another_thread (MIDI::MachineControl::Command cmd, nframes_t target_frame)
 904 {
 905         MIDIRequest* request;
 906
 907         if (_mtc_port == 0 || !session_send_mmc) {
 908                 return;
 909         }
 910
 911         request = new MIDIRequest;
 912         request->type = MIDIRequest::SendMMC;
 913         request->mmc_cmd = cmd;
 914         request->locate_frame = target_frame;
 915
 916         midi_requests.write (&request, 1);
 917         poke_midi_thread ();
 918 }
 919
 920 void
 921 Session::deliver_mmc (MIDI::MachineControl::Command cmd, nframes_t where)
 922 {
 923         using namespace MIDI;
 924         int nbytes = 4;
 925         SMPTE::Time smpte;
 926
 927         if (_mmc_port == 0 || !session_send_mmc) {
 928                 return;
 929         }
 930
 931         mmc_buffer[nbytes++] = cmd;
 932
 933         // cerr << "delivering MMC, cmd = " << hex << (int) cmd << dec << endl;
 934
 935         switch (cmd) {
 936         case MachineControl::cmdLocate:
 937                 smpte_time_subframes (where, smpte);
 938
 939                 mmc_buffer[nbytes++] = 0x6; // byte count
 940                 mmc_buffer[nbytes++] = 0x1; // "TARGET" subcommand
 941                 mmc_buffer[nbytes++] = smpte.hours;
 942                 mmc_buffer[nbytes++] = smpte.minutes;
 943                 mmc_buffer[nbytes++] = smpte.seconds;
 944                 mmc_buffer[nbytes++] = smpte.frames;
 945                 mmc_buffer[nbytes++] = smpte.subframes;
 946                 break;
 947
 948         case MachineControl::cmdStop:
 949                 break;
 950
 951         case MachineControl::cmdPlay:
 952                 /* always convert Play into Deferred Play */
 953                 mmc_buffer[4] = MachineControl::cmdDeferredPlay;
 954                 break;
 955
 956         case MachineControl::cmdDeferredPlay:
 957                 break;
 958
 959         case MachineControl::cmdRecordStrobe:
 960                 break;
 961
 962         case MachineControl::cmdRecordExit:
 963                 break;
 964
 965         case MachineControl::cmdRecordPause:
 966                 break;
 967
 968         default:
 969                 nbytes = 0;
 970         };
 971
 972         if (nbytes) {
 973
 974                 mmc_buffer[nbytes++] = 0xf7; // terminate SysEx/MMC message
 975
 976                 Glib::Mutex::Lock lm (midi_lock);
 977
 978                 if (_mmc_port->write (mmc_buffer, nbytes) != nbytes) {
 979                         error << string_compose(_("MMC: cannot send command %1%2%3"), &hex, cmd, &dec) << endmsg;
 980                 }
 981         }
 982 }
 983
 984 bool
 985 Session::mmc_step_timeout ()
 986 {
 987         struct timeval now;
 988         struct timeval diff;
 989         double diff_usecs;
 990         gettimeofday (&now, 0);
 991
 992         timersub (&now, &last_mmc_step, &diff);
 993         diff_usecs = diff.tv_sec * 1000000 + diff.tv_usec;
 994
 995         if (diff_usecs > 1000000.0 || fabs (_transport_speed) < 0.0000001) {
 996                 /* too long or too slow, stop transport */
 997                 request_transport_speed (0.0);
 998                 step_queued = false;
 999                 return false;
1000         }
1001
1002         if (diff_usecs < 250000.0) {
1003                 /* too short, just keep going */
1004                 return true;
1005         }
1006
1007         /* slow it down */
1008
1009         request_transport_speed (_transport_speed * 0.75);
1010         return true;
1011 }
1012
1013
1014 void
1015 Session::send_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t ch, MIDI::EventTwoBytes data)
1016 {
1017         // in another thread, really
1018
1019         MIDIRequest* request = new MIDIRequest;
1020
1021         request->type = MIDIRequest::SendMessage;
1022         request->port = port;
1023         request->ev = ev;
1024         request->chan = ch;
1025         request->data = data;
1026
1027         midi_requests.write (&request, 1);
1028         poke_midi_thread ();
1029 }
1030
1031 void
1032 Session::deliver_midi (MIDI::Port * port, MIDI::byte* buf, int32_t bufsize)
1033 {
1034         // in another thread, really
1035
1036         MIDIRequest* request = new MIDIRequest;
1037
1038         request->type = MIDIRequest::Deliver;
1039         request->port = port;
1040         request->buf = buf;
1041         request->size = bufsize;
1042
1043         midi_requests.write (&request, 1);
1044         poke_midi_thread ();
1045 }
1046
1047 void
1048 Session::deliver_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t ch, MIDI::EventTwoBytes data)
1049 {
1050         if (port == 0 || ev == MIDI::none) {
1051                 return;
1052         }
1053
1054         midi_msg[0] = (ev & 0xF0) | (ch & 0xF);
1055         midi_msg[1] = data.controller_number;
1056         midi_msg[2] = data.value;
1057
1058         port->write (midi_msg, 3);
1059 }
1060
1061 void
1062 Session::deliver_data (MIDI::Port * port, MIDI::byte* buf, int32_t size)
1063 {
1064         if (port) {
1065                 port->write (buf, size);
1066         }
1067
1068         /* this is part of the semantics of the Deliver request */
1069
1070         delete [] buf;
1071 }
1072
1073 /*---------------------------------------------------------------------------
1074   MIDI THREAD
1075   ---------------------------------------------------------------------------*/
1076
1077 int
1078 Session::start_midi_thread ()
1079 {
1080         if (pipe (midi_request_pipe)) {
1081                 error << string_compose(_("Cannot create transport request signal pipe (%1)"), strerror (errno)) << endmsg;
1082                 return -1;
1083         }
1084
1085         if (fcntl (midi_request_pipe[0], F_SETFL, O_NONBLOCK)) {
1086                 error << string_compose(_("UI: cannot set O_NONBLOCK on "    "signal read pipe (%1)"), strerror (errno)) << endmsg;
1087                 return -1;
1088         }
1089
1090         if (fcntl (midi_request_pipe[1], F_SETFL, O_NONBLOCK)) {
1091                 error << string_compose(_("UI: cannot set O_NONBLOCK on "    "signal write pipe (%1)"), strerror (errno)) << endmsg;
1092                 return -1;
1093         }
1094
1095         if (pthread_create_and_store ("transport", &midi_thread, 0, _midi_thread_work, this)) {
1096                 error << _("Session: could not create transport thread") << endmsg;
1097                 return -1;
1098         }
1099
1100         // pthread_detach (midi_thread);
1101
1102         return 0;
1103 }
1104
1105 void
1106 Session::terminate_midi_thread ()
1107 {
1108         if (midi_thread) {
1109                 MIDIRequest* request = new MIDIRequest;
1110                 void* status;
1111
1112                 request->type = MIDIRequest::Quit;
1113
1114                 midi_requests.write (&request, 1);
1115                 poke_midi_thread ();
1116
1117                 pthread_join (midi_thread, &status);
1118         }
1119 }
1120
1121 void
1122 Session::poke_midi_thread ()
1123 {
1124         static char c = 0;
1125
1126         if (write (midi_request_pipe[1], &c, 1) != 1) {
1127                 error << string_compose(_("cannot send signal to midi thread! (%1)"), strerror (errno)) << endmsg;
1128         }
1129 }
1130
1131 void *
1132 Session::_midi_thread_work (void* arg)
1133 {
1134         pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, 0);
1135         pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, 0);
1136
1137         ((Session *) arg)->midi_thread_work ();
1138         return 0;
1139 }
1140
1141 void
1142 Session::midi_thread_work ()
1143 {
1144         MIDIRequest* request;
1145         struct pollfd pfd[4];
1146         int nfds = 0;
1147         int timeout;
1148         int fds_ready;
1149         struct sched_param rtparam;
1150         int x;
1151         bool restart;
1152         vector<MIDI::Port*> ports;
1153
1154         PBD::notify_gui_about_thread_creation (pthread_self(), X_("MIDI"), 2048);
1155
1156         memset (&rtparam, 0, sizeof (rtparam));
1157         rtparam.sched_priority = 9; /* XXX should be relative to audio (JACK) thread */
1158
1159         if ((x = pthread_setschedparam (pthread_self(), SCHED_FIFO, &rtparam)) != 0) {
1160                 // do we care? not particularly.
1161         }
1162
1163         /* set up the port vector; 4 is the largest possible size for now */
1164
1165         ports.push_back (0);
1166         ports.push_back (0);
1167         ports.push_back (0);
1168         ports.push_back (0);
1169
1170         while (1) {
1171
1172                 nfds = 0;
1173
1174                 pfd[nfds].fd = midi_request_pipe[0];
1175                 pfd[nfds].events = POLLIN|POLLHUP|POLLERR;
1176                 nfds++;
1177
1178                 /* if we are using MMC control, we obviously have to listen
1179                    on the appropriate port.
1180                 */
1181
1182                 if (Config->get_mmc_control() && _mmc_port && _mmc_port->selectable() >= 0) {
1183                         pfd[nfds].fd = _mmc_port->selectable();
1184                         pfd[nfds].events = POLLIN|POLLHUP|POLLERR;
1185                         ports[nfds] = _mmc_port;
1186                         //cerr << "MIDI port " << nfds << " = MMC @ " << _mmc_port << endl;
1187                         nfds++;
1188                 }
1189
1190                 /* if MTC is being handled on a different port from MMC
1191                    or we are not handling MMC at all, poll
1192                    the relevant port.
1193                 */
1194
1195                 if (_mtc_port && (_mtc_port != _mmc_port || !Config->get_mmc_control()) && _mtc_port->selectable() >= 0) {
1196                         pfd[nfds].fd = _mtc_port->selectable();
1197                         pfd[nfds].events = POLLIN|POLLHUP|POLLERR;
1198                         ports[nfds] = _mtc_port;
1199                         //cerr << "MIDI port " << nfds << " = MTC @ " << _mtc_port << endl;
1200                         nfds++;
1201                 }
1202
1203                 if (_midi_port && (_midi_port != _mmc_port || !Config->get_mmc_control()) && (_midi_port != _mtc_port) && _midi_port->selectable() >= 0) {
1204                         pfd[nfds].fd = _midi_port->selectable();
1205                         pfd[nfds].events = POLLIN|POLLHUP|POLLERR;
1206                         ports[nfds] = _midi_port;
1207                         // cerr << "MIDI port " << nfds << " = MIDI @ " << _midi_port << endl;
1208                         nfds++;
1209                 }
1210
1211                 if (!midi_timeouts.empty()) {
1212                         timeout = 100; /* 10msecs */
1213                 } else {
1214                         timeout = -1; /* if there is no data, we don't care */
1215                 }
1216
1217           again:
1218                 // cerr << "MIDI poll on " << nfds << " for " << timeout << endl;
1219                 if (poll (pfd, nfds, timeout) < 0) {
1220                         if (errno == EINTR) {
1221                                 /* gdb at work, perhaps */
1222                                 goto again;
1223                         }
1224
1225                         error << string_compose(_("MIDI thread poll failed (%1)"), strerror (errno)) << endmsg;
1226
1227                         break;
1228                 }
1229                 // cerr << "MIDI thread wakes at " << get_cycles () << endl;
1230
1231                 fds_ready = 0;
1232                 restart = false;
1233
1234                 /* check the transport request pipe */
1235
1236                 if (pfd[0].revents & ~POLLIN) {
1237                         error << _("Error on transport thread request pipe") << endmsg;
1238                         break;
1239                 }
1240
1241                 if (pfd[0].revents & POLLIN) {
1242
1243                         char foo[16];
1244
1245                         // cerr << "MIDI request FIFO ready\n";
1246                         fds_ready++;
1247
1248                         /* empty the pipe of all current requests */
1249
1250                         while (1) {
1251                                 size_t nread = read (midi_request_pipe[0], &foo, sizeof (foo));
1252
1253                                 if (nread > 0) {
1254                                         if ((size_t) nread < sizeof (foo)) {
1255                                                 break;
1256                                         } else {
1257                                                 continue;
1258                                         }
1259                                 } else if (nread == 0) {
1260                                         break;
1261                                 } else if (errno == EAGAIN) {
1262                                         break;
1263                                 } else {
1264                                         fatal << _("Error reading from transport request pipe") << endmsg;
1265                                         /*NOTREACHED*/
1266                                 }
1267                         }
1268
1269                         while (midi_requests.read (&request, 1) == 1) {
1270
1271                                 switch (request->type) {
1272
1273                                 case MIDIRequest::SendFullMTC:
1274                                         // cerr << "send full MTC\n";
1275                                         send_full_time_code ();
1276                                         // cerr << "... done\n";
1277                                         break;
1278
1279                                 case MIDIRequest::SendMTC:
1280                                         // cerr << "send qtr MTC\n";
1281                                         send_midi_time_code ();
1282                                         // cerr << "... done\n";
1283                                         break;
1284
1285                                 case MIDIRequest::SendMMC:
1286                                         // cerr << "send MMC\n";
1287                                         deliver_mmc (request->mmc_cmd, request->locate_frame);
1288                                         // cerr << "... done\n";
1289                                         break;
1290
1291                                 case MIDIRequest::SendMessage:
1292                                         // cerr << "send Message\n";
1293                                         deliver_midi_message (request->port, request->ev, request->chan, request->data);
1294                                         // cerr << "... done\n";
1295                                         break;
1296
1297                                 case MIDIRequest::Deliver:
1298                                         // cerr << "deliver\n";
1299                                         deliver_data (_midi_port, request->buf, request->size);
1300                                         // cerr << "... done\n";
1301                                         break;
1302
1303                                 case MIDIRequest::PortChange:
1304                                         /* restart poll with new ports */
1305                                         // cerr << "rebind\n";
1306                                         restart = true;
1307                                         break;
1308
1309                                 case MIDIRequest::Quit:
1310                                         delete request;
1311                                         pthread_exit_pbd (0);
1312                                         /*NOTREACHED*/
1313                                         break;
1314
1315                                 default:
1316                                         break;
1317                                 }
1318
1319
1320                                 delete request;
1321                         }
1322
1323                 }
1324
1325                 if (restart) {
1326                         continue;
1327                 }
1328
1329                 /* now read the rest of the ports */
1330
1331                 for (int p = 1; p < nfds; ++p) {
1332                         if ((pfd[p].revents & ~POLLIN)) {
1333                                 // error << string_compose(_("Transport: error polling MIDI port %1 (revents =%2%3%4"), p, &hex, pfd[p].revents, &dec) << endmsg;
1334                                 break;
1335                         }
1336
1337                         if (pfd[p].revents & POLLIN) {
1338                                 fds_ready++;
1339                                 midi_read (ports[p]);
1340                         }
1341                 }
1342
1343                 /* timeout driven */
1344
1345                 if (fds_ready < 2 && timeout != -1) {
1346
1347                         for (MidiTimeoutList::iterator i = midi_timeouts.begin(); i != midi_timeouts.end(); ) {
1348
1349                                 MidiTimeoutList::iterator tmp;
1350                                 tmp = i;
1351                                 ++tmp;
1352
1353                                 if (!(*i)()) {
1354                                         midi_timeouts.erase (i);
1355                                 }
1356
1357                                 i = tmp;
1358                         }
1359                 }
1360         }
1361 }
1362