libs/midi++2/parser.cc

   1 /*
   2     Copyright (C) 1998 Paul Barton-Davis
   3
   4     This file was inspired by the MIDI parser for KeyKit by
   5     Tim Thompson.
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21     $Id$
  22 */
  23
  24 #include <cstring>
  25 #include <cstdlib>
  26 #include <unistd.h>
  27 #include <cstring>
  28 #include <iostream>
  29 #include <iterator>
  30
  31 #include "midi++/types.h"
  32 #include "midi++/parser.h"
  33 #include "midi++/port.h"
  34 #include "midi++/mmc.h"
  35 #include "pbd/transmitter.h"
  36
  37 using namespace std;
  38 using namespace MIDI;
  39
  40 const char *
  41 Parser::midi_event_type_name (eventType t)
  42
  43 {
  44         switch (t) {
  45         case none:
  46                 return "no midi messages";
  47
  48         case raw:
  49                 return "raw midi data";
  50
  51         case MIDI::any:
  52                 return "any midi message";
  53
  54         case off:
  55                 return "note off";
  56
  57         case on:
  58                 return "note on";
  59
  60         case polypress:
  61                 return "aftertouch";
  62
  63         case MIDI::controller:
  64                 return "controller";
  65
  66         case program:
  67                 return "program change";
  68
  69         case chanpress:
  70                 return "channel pressure";
  71
  72         case MIDI::pitchbend:
  73                 return "pitch bend";
  74
  75         case MIDI::sysex:
  76                 return "system exclusive";
  77
  78         case MIDI::song:
  79                 return "song position";
  80
  81         case MIDI::tune:
  82                 return "tune";
  83
  84         case MIDI::eox:
  85                 return "end of sysex";
  86
  87         case MIDI::timing:
  88                 return "timing";
  89
  90         case MIDI::start:
  91                 return "start";
  92
  93         case MIDI::stop:
  94                 return "continue";
  95
  96         case MIDI::contineu:
  97                 return "stop";
  98
  99         case active:
 100                 return "active sense";
 101
 102         default:
 103                 return "unknow MIDI event type";
 104         }
 105 }
 106
 107 Parser::Parser (Port &p)
 108         : _port (p)
 109
 110 {
 111         trace_stream = 0;
 112         trace_prefix = "";
 113         memset (message_counter, 0, sizeof (message_counter[0]) * 256);
 114         msgindex = 0;
 115         msgtype = none;
 116         msglen = 256;
 117         msgbuf = (unsigned char *) malloc (msglen);
 118         msgbuf[msgindex++] = 0x90;
 119         _mmc_forward = false;
 120         reset_mtc_state ();
 121         _offline = false;
 122
 123         /* this hack deals with the possibility of our first MIDI
 124            bytes being running status messages.
 125         */
 126
 127         channel_msg (0x90);
 128         state = NEEDSTATUS;
 129
 130         pre_variable_state = NEEDSTATUS;
 131         pre_variable_msgtype = none;
 132 }
 133
 134 Parser::~Parser ()
 135
 136 {
 137         delete msgbuf;
 138 }
 139
 140 void
 141 Parser::trace_event (Parser &, byte *msg, size_t len)
 142 {
 143         eventType type;
 144         ostream *o;
 145
 146         if ((o = trace_stream) == NULL) { /* can be asynchronously removed */
 147                 return;
 148         }
 149
 150         type = (eventType) (msg[0]&0xF0);
 151
 152         switch (type) {
 153         case off:
 154                 *o << trace_prefix
 155                    << "Channel "
 156                    << (msg[0]&0xF)+1
 157                    << " NoteOff NoteNum "
 158                    << (int) msg[1]
 159                    << " Vel "
 160                    << (int) msg[2]
 161                    << endmsg;
 162                 break;
 163
 164         case on:
 165                 *o << trace_prefix
 166                    << "Channel "
 167                    << (msg[0]&0xF)+1
 168                    << " NoteOn NoteNum "
 169                    << (int) msg[1]
 170                    << " Vel "
 171                    << (int) msg[2]
 172                    << endmsg;
 173                 break;
 174
 175         case polypress:
 176                 *o << trace_prefix
 177                    << "Channel "
 178                    << (msg[0]&0xF)+1
 179                    << " PolyPressure"
 180                    << (int) msg[1]
 181                    << endmsg;
 182                 break;
 183
 184         case MIDI::controller:
 185                 *o << trace_prefix
 186                    << "Channel "
 187                    << (msg[0]&0xF)+1
 188                    << " Controller "
 189                    << (int) msg[1]
 190                    << " Value "
 191                    << (int) msg[2]
 192                    << endmsg;
 193                 break;
 194
 195         case program:
 196                 *o << trace_prefix
 197                    << "Channel "
 198                    << (msg[0]&0xF)+1
 199                    <<  " Program PropertyChange ProgNum "
 200                    << (int) msg[1]
 201                    << endmsg;
 202                 break;
 203
 204         case chanpress:
 205                 *o << trace_prefix
 206                    << "Channel "
 207                    << (msg[0]&0xF)+1
 208                    << " Channel Pressure "
 209                    << (int) msg[1]
 210                    << endmsg;
 211                 break;
 212
 213         case MIDI::pitchbend:
 214                 *o << trace_prefix
 215                    << "Channel "
 216                    << (msg[0]&0xF)+1
 217                    << " Pitch Bend "
 218                    << ((msg[2]<<7)|msg[1])
 219                    << endmsg;
 220                 break;
 221
 222         case MIDI::sysex:
 223                 if (len == 1) {
 224                         switch (msg[0]) {
 225                         case 0xf8:
 226                                 *o << trace_prefix
 227                                    << "Clock"
 228                                    << endmsg;
 229                                 break;
 230                         case 0xfa:
 231                                 *o << trace_prefix
 232                                    << "Start"
 233                                    << endmsg;
 234                                 break;
 235                         case 0xfb:
 236                                 *o << trace_prefix
 237                                    << "Continue"
 238                                    << endmsg;
 239                                 break;
 240                         case 0xfc:
 241                                 *o << trace_prefix
 242                                    << "Stop"
 243                                    << endmsg;
 244                                 break;
 245                         case 0xfe:
 246                                 *o << trace_prefix
 247                                    << "Active Sense"
 248                                    << endmsg;
 249                                 break;
 250                         case 0xff:
 251                                 *o << trace_prefix
 252                                    << "System Reset"
 253                                    << endmsg;
 254                                 break;
 255                         default:
 256                                 *o << trace_prefix
 257                                    << "System Exclusive (1 byte : " << hex << (int) *msg << dec << ')'
 258                                    << endmsg;
 259                                 break;
 260                         }
 261                 } else {
 262                         *o << trace_prefix
 263                            << "System Exclusive (" << len << ") = [ " << hex;
 264                         for (unsigned int i = 0; i < len; ++i) {
 265                                 *o << (int) msgbuf[i] << ' ';
 266                         }
 267                         *o << dec << ']' << endmsg;
 268
 269                 }
 270                 break;
 271
 272         case MIDI::song:
 273                 *o << trace_prefix << "Song" << endmsg;
 274                 break;
 275
 276         case MIDI::tune:
 277                 *o << trace_prefix << "Tune" << endmsg;
 278                 break;
 279
 280         case MIDI::eox:
 281                 *o << trace_prefix << "End-of-System Exclusive" << endmsg;
 282                 break;
 283
 284         case MIDI::timing:
 285                 *o << trace_prefix << "Timing" << endmsg;
 286                 break;
 287
 288         case MIDI::start:
 289                 *o << trace_prefix << "Start" << endmsg;
 290                 break;
 291
 292         case MIDI::stop:
 293                 *o << trace_prefix << "Stop" << endmsg;
 294                 break;
 295
 296         case MIDI::contineu:
 297                 *o << trace_prefix << "Continue" << endmsg;
 298                 break;
 299
 300         case active:
 301                 *o << trace_prefix << "Active Sense" << endmsg;
 302                 break;
 303
 304         default:
 305                 *o << trace_prefix << "Unrecognized MIDI message" << endmsg;
 306                 break;
 307         }
 308 }
 309
 310 void
 311 Parser::trace (bool onoff, ostream *o, const string &prefix)
 312 {
 313         trace_connection.disconnect ();
 314
 315         if (onoff) {
 316                 trace_stream = o;
 317                 trace_prefix = prefix;
 318                 any.connect_same_thread (trace_connection, boost::bind (&Parser::trace_event, this, _1, _2, _3));
 319         } else {
 320                 trace_prefix = "";
 321                 trace_stream = 0;
 322         }
 323 }
 324
 325 void
 326 Parser::scanner (unsigned char inbyte)
 327 {
 328         bool statusbit;
 329
 330         // cerr << "parse: " << hex << (int) inbyte << dec << " state = " << state << " msgindex = " << msgindex << " runnable = " << runnable << endl;
 331
 332         /* Check active sensing early, so it doesn't interrupt sysex.
 333
 334            NOTE: active sense messages are not considered to fit under
 335            "any" for the purposes of callbacks. If a caller wants
 336            active sense messages handled, which is unlikely, then
 337            they can just ask for it specifically. They are so unlike
 338            every other MIDI message in terms of semantics that its
 339            counter-productive to treat them similarly.
 340         */
 341
 342         if (inbyte == 0xfe) {
 343                 message_counter[inbyte]++;
 344                 if (!_offline) {
 345                         active_sense (*this);
 346                 }
 347                 return;
 348         }
 349
 350         /* If necessary, allocate larger message buffer. */
 351
 352         if (msgindex >= msglen) {
 353                 msglen *= 2;
 354                 msgbuf = (unsigned char *) realloc (msgbuf, msglen);
 355         }
 356
 357         /*
 358           Real time messages can occur ANYPLACE,
 359           but do not interrupt running status.
 360         */
 361
 362         bool rtmsg = false;
 363
 364         switch (inbyte) {
 365         case 0xf8:
 366                 rtmsg = true;
 367                 break;
 368         case 0xfa:
 369                 rtmsg = true;
 370                 break;
 371         case 0xfb:
 372                 rtmsg = true;
 373                 break;
 374         case 0xfc:
 375                 rtmsg = true;
 376                 break;
 377         case 0xfd:
 378                 rtmsg = true;
 379                 break;
 380         case 0xfe:
 381                 rtmsg = true;
 382                 break;
 383         case 0xff:
 384                 rtmsg = true;
 385                 break;
 386         }
 387
 388         if (rtmsg) {
 389                 boost::optional<int> res = edit (&inbyte, 1);
 390
 391                 if (res.get_value_or (1) >= 0 && !_offline) {
 392                         realtime_msg (inbyte);
 393                 }
 394
 395                 return;
 396         }
 397
 398         statusbit = (inbyte & 0x80);
 399
 400         /*
 401          * Variable length messages (ie. the 'system exclusive')
 402          * can be terminated by the next status byte, not necessarily
 403          * an EOX.  Actually, since EOX is a status byte, this
 404          * code ALWAYS handles the end of a VARIABLELENGTH message.
 405          */
 406
 407         if (state == VARIABLELENGTH && statusbit)  {
 408
 409                 /* The message has ended, so process it */
 410
 411                 /* add EOX to any sysex message */
 412
 413                 if (inbyte == MIDI::eox) {
 414                         msgbuf[msgindex++] = inbyte;
 415                 }
 416
 417 #if 0
 418                 cerr << "SYSEX: " << hex;
 419                 for (unsigned int i = 0; i < msgindex; ++i) {
 420                         cerr << (int) msgbuf[i] << ' ';
 421                 }
 422                 cerr << dec << endl;
 423 #endif
 424                 if (msgindex > 0) {
 425
 426                         boost::optional<int> res = edit (msgbuf, msgindex);
 427
 428                         if (res.get_value_or (1) >= 0) {
 429                                 if (!possible_mmc (msgbuf, msgindex) || _mmc_forward) {
 430                                         if (!possible_mtc (msgbuf, msgindex) || _mtc_forward) {
 431                                                 if (!_offline) {
 432                                                         sysex (*this, msgbuf, msgindex);
 433                                                 }
 434                                         }
 435                                 }
 436                                 if (!_offline) {
 437                                         any (*this, msgbuf, msgindex);
 438                                 }
 439                         }
 440                 }
 441         }
 442
 443         /*
 444          * Status bytes always start a new message, except EOX
 445          */
 446
 447         if (statusbit) {
 448
 449                 msgindex = 0;
 450
 451                 if (inbyte == MIDI::eox) {
 452                         /* return to the state we had pre-sysex */
 453
 454                         state = pre_variable_state;
 455                         runnable = was_runnable;
 456                         msgtype = pre_variable_msgtype;
 457
 458                         if (state != NEEDSTATUS && runnable) {
 459                                 msgbuf[msgindex++] = last_status_byte;
 460                         }
 461                 } else {
 462                         msgbuf[msgindex++] = inbyte;
 463                         if ((inbyte & 0xf0) == 0xf0) {
 464                                 system_msg (inbyte);
 465                                 runnable = false;
 466                         } else {
 467                                 channel_msg (inbyte);
 468                         }
 469                 }
 470
 471                 return;
 472         }
 473
 474         /*
 475          * We've got a Data byte.
 476          */
 477
 478         msgbuf[msgindex++] = inbyte;
 479
 480         switch (state) {
 481         case NEEDSTATUS:
 482                 /*
 483                  * We shouldn't get here, since in NEEDSTATUS mode
 484                  * we're expecting a new status byte, NOT any
 485                  * data bytes. On the other hand, some equipment
 486                  * with leaky modwheels and the like might be
 487                  * sending data bytes as part of running controller
 488                  * messages, so just handle it silently.
 489                  */
 490                 break;
 491
 492         case NEEDTWOBYTES:
 493                 /* wait for the second byte */
 494                 if (msgindex < 3)
 495                         return;
 496                 /*FALLTHRU*/
 497
 498         case NEEDONEBYTE:
 499                 /* We've completed a 1 or 2 byte message. */
 500                 if (edit.empty() || !(*edit (msgbuf, msgindex) == 0)) {
 501
 502                         /* message not cancelled by an editor */
 503
 504                         message_counter[msgbuf[0] & 0xF0]++;
 505
 506                         if (!_offline) {
 507                                 signal (msgbuf, msgindex);
 508                         }
 509                 }
 510
 511                 if (runnable) {
 512                         /* In Runnable mode, we reset the message
 513                            index, but keep the callbacks_pending and state the
 514                            same.  This provides the "running status
 515                            byte" feature.
 516                         */
 517                         msgindex = 1;
 518                 } else {
 519                         /* If not Runnable, reset to NEEDSTATUS mode */
 520                         state = NEEDSTATUS;
 521                 }
 522                 break;
 523
 524         case VARIABLELENGTH:
 525                 /* nothing to do */
 526                 break;
 527         }
 528         return;
 529 }
 530
 531 /** Call the real-time function for the specified byte, immediately.
 532  * These can occur anywhere, so they don't change the state.
 533  */
 534 void
 535 Parser::realtime_msg(unsigned char inbyte)
 536
 537 {
 538         message_counter[inbyte]++;
 539
 540         if (_offline) {
 541                 return;
 542         }
 543
 544         switch (inbyte) {
 545         case 0xf8:
 546                 timing (*this, _timestamp);
 547                 break;
 548         case 0xfa:
 549                 start (*this, _timestamp);
 550                 break;
 551         case 0xfb:
 552                 contineu (*this, _timestamp);
 553                 break;
 554         case 0xfc:
 555                 stop (*this, _timestamp);
 556                 break;
 557         case 0xfe:
 558                 /* !!! active sense message in realtime_msg: should not reach here
 559                  */
 560                 break;
 561         case 0xff:
 562                 reset (*this);
 563                 break;
 564         }
 565
 566         any (*this, &inbyte, 1);
 567 }
 568
 569
 570 /** Interpret a Channel (voice or mode) Message status byte.
 571  */
 572 void
 573 Parser::channel_msg(unsigned char inbyte)
 574 {
 575         last_status_byte = inbyte;
 576         runnable = true;                /* Channel messages can use running status */
 577
 578         /* The high 4 bits, which determine the type of channel message. */
 579
 580         switch (inbyte&0xF0) {
 581         case 0x80:
 582                 msgtype = off;
 583                 state = NEEDTWOBYTES;
 584                 break;
 585         case 0x90:
 586                 msgtype = on;
 587                 state = NEEDTWOBYTES;
 588                 break;
 589         case 0xa0:
 590                 msgtype = polypress;
 591                 state = NEEDTWOBYTES;
 592                 break;
 593         case 0xb0:
 594                 msgtype = MIDI::controller;
 595                 state = NEEDTWOBYTES;
 596                 break;
 597         case 0xc0:
 598                 msgtype = program;
 599                 state = NEEDONEBYTE;
 600                 break;
 601         case 0xd0:
 602                 msgtype = chanpress;
 603                 state = NEEDONEBYTE;
 604                 break;
 605         case 0xe0:
 606                 msgtype = MIDI::pitchbend;
 607                 state = NEEDTWOBYTES;
 608                 break;
 609         }
 610 }
 611
 612 /** Initialize (and possibly emit) the signals for the
 613  * specified byte.  Set the state that the state-machine
 614  * should go into.  If the signal is not emitted
 615  * immediately, it will be when the state machine gets to
 616  * the end of the MIDI message.
 617  */
 618 void
 619 Parser::system_msg (unsigned char inbyte)
 620 {
 621         message_counter[inbyte]++;
 622
 623         switch (inbyte) {
 624         case 0xf0:
 625                 pre_variable_msgtype = msgtype;
 626                 pre_variable_state = state;
 627                 was_runnable = runnable;
 628                 msgtype = MIDI::sysex;
 629                 state = VARIABLELENGTH;
 630                 break;
 631         case 0xf1:
 632                 msgtype = MIDI::mtc_quarter;
 633                 state = NEEDONEBYTE;
 634                 break;
 635         case 0xf2:
 636                 msgtype = MIDI::position;
 637                 state = NEEDTWOBYTES;
 638                 break;
 639         case 0xf3:
 640                 msgtype = MIDI::song;
 641                 state = NEEDONEBYTE;
 642                 break;
 643         case 0xf6:
 644                 if (!_offline) {
 645                         tune (*this);
 646                 }
 647                 state = NEEDSTATUS;
 648                 break;
 649         case 0xf7:
 650                 break;
 651         }
 652
 653         // all these messages will be sent via any()
 654         // when they are complete.
 655         // any (*this, &inbyte, 1);
 656 }
 657
 658 void
 659 Parser::signal (byte *msg, size_t len)
 660 {
 661         channel_t chan = msg[0]&0xF;
 662         int chan_i = chan;
 663
 664         switch (msgtype) {
 665         case none:
 666                 break;
 667
 668         case off:
 669                 channel_active_preparse[chan_i] (*this);
 670                 note_off (*this, (EventTwoBytes *) &msg[1]);
 671                 channel_note_off[chan_i]
 672                         (*this, (EventTwoBytes *) &msg[1]);
 673                 channel_active_postparse[chan_i] (*this);
 674                 break;
 675
 676         case on:
 677                 channel_active_preparse[chan_i] (*this);
 678
 679                 /* Hack to deal with MIDI sources that use velocity=0
 680                    instead of noteOff.
 681                 */
 682
 683                 if (msg[2] == 0) {
 684                         note_off (*this, (EventTwoBytes *) &msg[1]);
 685                         channel_note_off[chan_i]
 686                                 (*this, (EventTwoBytes *) &msg[1]);
 687                 } else {
 688                         note_on (*this, (EventTwoBytes *) &msg[1]);
 689                         channel_note_on[chan_i]
 690                                 (*this, (EventTwoBytes *) &msg[1]);
 691                 }
 692
 693                 channel_active_postparse[chan_i] (*this);
 694                 break;
 695
 696         case MIDI::controller:
 697                 channel_active_preparse[chan_i] (*this);
 698                 controller (*this, (EventTwoBytes *) &msg[1]);
 699                 channel_controller[chan_i]
 700                         (*this, (EventTwoBytes *) &msg[1]);
 701                 channel_active_postparse[chan_i] (*this);
 702                 break;
 703
 704         case program:
 705                 channel_active_preparse[chan_i] (*this);
 706                 program_change (*this, msg[1]);
 707                 channel_program_change[chan_i] (*this, msg[1]);
 708                 channel_active_postparse[chan_i] (*this);
 709                 break;
 710
 711         case chanpress:
 712                 channel_active_preparse[chan_i] (*this);
 713                 pressure (*this, msg[1]);
 714                 channel_pressure[chan_i] (*this, msg[1]);
 715                 channel_active_postparse[chan_i] (*this);
 716                 break;
 717
 718         case polypress:
 719                 channel_active_preparse[chan_i] (*this);
 720                 poly_pressure (*this, (EventTwoBytes *) &msg[1]);
 721                 channel_poly_pressure[chan_i]
 722                         (*this, (EventTwoBytes *) &msg[1]);
 723                 channel_active_postparse[chan_i] (*this);
 724                 break;
 725
 726         case MIDI::pitchbend:
 727                 channel_active_preparse[chan_i] (*this);
 728                 pitchbend (*this, (msg[2]<<7)|msg[1]);
 729                 channel_pitchbend[chan_i] (*this, (msg[2]<<7)|msg[1]);
 730                 channel_active_postparse[chan_i] (*this);
 731                 break;
 732
 733         case MIDI::sysex:
 734                 sysex (*this, msg, len);
 735                 break;
 736
 737         case MIDI::mtc_quarter:
 738                 process_mtc_quarter_frame (msg);
 739                 mtc_quarter_frame (*this, *msg);
 740                 break;
 741
 742         case MIDI::position:
 743                 position (*this, msg, len);
 744                 break;
 745
 746         case MIDI::song:
 747                 song (*this, msg, len);
 748                 break;
 749
 750         case MIDI::tune:
 751                 tune (*this);
 752
 753         default:
 754                 /* XXX some kind of warning ? */
 755                 break;
 756         }
 757
 758         any (*this, msg, len);
 759 }
 760
 761 bool
 762 Parser::possible_mmc (byte *msg, size_t msglen)
 763 {
 764         if (!MachineControl::is_mmc (msg, msglen)) {
 765                 return false;
 766         }
 767
 768         /* hand over the just the interior MMC part of
 769            the sysex msg without the leading 0xF0
 770         */
 771
 772         if (!_offline) {
 773                 mmc (*this, &msg[1], msglen - 1);
 774         }
 775
 776         return true;
 777 }
 778
 779 void
 780 Parser::set_offline (bool yn)
 781 {
 782         if (_offline != yn) {
 783                 _offline = yn;
 784                 OfflineStatusChanged ();
 785
 786                 /* this hack deals with the possibility of our first MIDI
 787                    bytes being running status messages.
 788                 */
 789
 790                 channel_msg (0x90);
 791                 state = NEEDSTATUS;
 792         }
 793 }
 794