libs/midi++2/midiparser.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 <cstdlib>
  25 #include <unistd.h>
  26 #include <string>
  27 #include <iostream>
  28 #include <iterator>
  29
  30 #include <midi++/types.h>
  31 #include <midi++/parser.h>
  32 #include <midi++/port.h>
  33 #include <midi++/mmc.h>
  34 #include <pbd/transmitter.h>
  35
  36 using namespace std;
  37 using namespace sigc;
  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 &p, 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 Change 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[1]<<7)|msg[2])
 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                 trace_connection = any.connect (mem_fun (*this, &Parser::trace_event));
 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                 if (edit (&inbyte, 1) >= 0 && !_offline) {
 390                         realtime_msg (inbyte);
 391                 }
 392
 393                 return;
 394         }
 395
 396         statusbit = (inbyte & 0x80);
 397
 398         /*
 399          * Variable length messages (ie. the 'system exclusive')
 400          * can be terminated by the next status byte, not necessarily
 401          * an EOX.  Actually, since EOX is a status byte, this
 402          * code ALWAYS handles the end of a VARIABLELENGTH message.
 403          */
 404
 405         if (state == VARIABLELENGTH && statusbit)  {
 406                 /* The message has ended, so process it */
 407
 408                 /* add EOX to any sysex message */
 409
 410                 if (inbyte == MIDI::eox) {
 411                         msgbuf[msgindex++] = inbyte;
 412                 }
 413
 414 #if 0
 415                 cerr << "SYSEX: " << hex;
 416                 for (unsigned int i = 0; i < msgindex; ++i) {
 417                         cerr << (int) msgbuf[i] << ' ';
 418                 }
 419                 cerr << dec << endl;
 420 #endif
 421                 if (msgindex > 0 && edit (msgbuf, msgindex) >= 0) {
 422                         if (!possible_mmc (msgbuf, msgindex) || _mmc_forward) {
 423                                 if (!possible_mtc (msgbuf, msgindex) || _mtc_forward) {
 424                                         if (!_offline) {
 425                                                 sysex (*this, msgbuf, msgindex);
 426                                         }
 427                                 }
 428                         }
 429                         if (!_offline) {
 430                                 any (*this, msgbuf, msgindex);
 431                         }
 432                 }
 433         }
 434
 435         /*
 436          * Status bytes always start a new message, except EOX
 437          */
 438
 439         if (statusbit) {
 440
 441                 msgindex = 0;
 442
 443                 if (inbyte == MIDI::eox) {
 444                         /* return to the state we had pre-sysex */
 445
 446                         state = pre_variable_state;
 447                         runnable = was_runnable;
 448                         msgtype = pre_variable_msgtype;
 449
 450                         if (state != NEEDSTATUS && runnable) {
 451                                 msgbuf[msgindex++] = last_status_byte;
 452                         }
 453                 } else {
 454                         msgbuf[msgindex++] = inbyte;
 455                         if ((inbyte & 0xf0) == 0xf0) {
 456                                 system_msg (inbyte);
 457                                 runnable = false;
 458                         } else {
 459                                 channel_msg (inbyte);
 460                         }
 461                 }
 462
 463                 return;
 464         }
 465
 466         /*
 467          * We've got a Data byte.
 468          */
 469
 470         msgbuf[msgindex++] = inbyte;
 471
 472         switch (state) {
 473         case NEEDSTATUS:
 474                 /*
 475                  * We shouldn't get here, since in NEEDSTATUS mode
 476                  * we're expecting a new status byte, NOT any
 477                  * data bytes. On the other hand, some equipment
 478                  * with leaky modwheels and the like might be
 479                  * sending data bytes as part of running controller
 480                  * messages, so just handle it silently.
 481                  */
 482                 break;
 483
 484         case NEEDTWOBYTES:
 485                 /* wait for the second byte */
 486                 if (msgindex < 3)
 487                         return;
 488                 /*FALLTHRU*/
 489
 490         case NEEDONEBYTE:
 491                 /* We've completed a 1 or 2 byte message. */
 492
 493                 if (edit (msgbuf, msgindex) == 0) {
 494
 495                         /* message not cancelled by an editor */
 496
 497                         message_counter[msgbuf[0] & 0xF0]++;
 498
 499                         if (!_offline) {
 500                                 signal (msgbuf, msgindex);
 501                         }
 502                 }
 503
 504                 if (runnable) {
 505                         /* In Runnable mode, we reset the message
 506                            index, but keep the callbacks_pending and state the
 507                            same.  This provides the "running status
 508                            byte" feature.
 509                         */
 510                         msgindex = 1;
 511                 } else {
 512                         /* If not Runnable, reset to NEEDSTATUS mode */
 513                         state = NEEDSTATUS;
 514                 }
 515                 break;
 516
 517         case VARIABLELENGTH:
 518                 /* nothing to do */
 519                 break;
 520         }
 521         return;
 522 }
 523
 524 /*
 525  * realtime_msg(inbyte)
 526  *
 527  * Call the real-time function for the specified byte, immediately.
 528  * These can occur anywhere, so they don't change the state.
 529  */
 530
 531 void
 532 Parser::realtime_msg(unsigned char inbyte)
 533
 534 {
 535         message_counter[inbyte]++;
 536
 537         if (_offline) {
 538                 return;
 539         }
 540
 541         switch (inbyte) {
 542         case 0xf8:
 543                 timing (*this);
 544                 break;
 545         case 0xfa:
 546                 start (*this);
 547                 break;
 548         case 0xfb:
 549                 contineu (*this);
 550                 break;
 551         case 0xfc:
 552                 stop (*this);
 553                 break;
 554         case 0xfe:
 555                 /* !!! active sense message in realtime_msg: should not reach here
 556                  */
 557                 break;
 558         case 0xff:
 559                 reset (*this);
 560                 break;
 561         }
 562
 563         any (*this, &inbyte, 1);
 564 }
 565
 566 /*
 567  * channel_msg(inbyte)
 568  *
 569  * Interpret a Channel (voice or mode) Message status byte.
 570  */
 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 /*
 613  * system_msg(inbyte)
 614  *
 615  * Initialize (and possibly emit) the signals for the
 616  * specified byte.  Set the state that the state-machine
 617  * should go into.  If the signal is not emitted
 618  * immediately, it will be when the state machine gets to
 619  * the end of the MIDI message.
 620  */
 621
 622 void
 623 Parser::system_msg (unsigned char inbyte)
 624 {
 625         message_counter[inbyte]++;
 626
 627         switch (inbyte) {
 628         case 0xf0:
 629                 pre_variable_msgtype = msgtype;
 630                 pre_variable_state = state;
 631                 was_runnable = runnable;
 632                 msgtype = MIDI::sysex;
 633                 state = VARIABLELENGTH;
 634                 break;
 635         case 0xf1:
 636                 msgtype = MIDI::mtc_quarter;
 637                 state = NEEDONEBYTE;
 638                 break;
 639         case 0xf2:
 640                 msgtype = MIDI::position;
 641                 state = NEEDTWOBYTES;
 642                 break;
 643         case 0xf3:
 644                 msgtype = MIDI::song;
 645                 state = NEEDONEBYTE;
 646                 break;
 647         case 0xf6:
 648                 if (!_offline) {
 649                         tune (*this);
 650                 }
 651                 state = NEEDSTATUS;
 652                 break;
 653         case 0xf7:
 654                 break;
 655         }
 656
 657         // all these messages will be sent via any()
 658         // when they are complete.
 659         // any (*this, &inbyte, 1);
 660 }
 661
 662 void
 663 Parser::signal (byte *msg, size_t len)
 664 {
 665         channel_t chan = msg[0]&0xF;
 666         int chan_i = chan;
 667
 668         switch (msgtype) {
 669         case none:
 670                 break;
 671
 672         case off:
 673                 channel_active_preparse[chan_i] (*this);
 674                 note_off (*this, (EventTwoBytes *) &msg[1]);
 675                 channel_note_off[chan_i]
 676                         (*this, (EventTwoBytes *) &msg[1]);
 677                 channel_active_postparse[chan_i] (*this);
 678                 break;
 679
 680         case on:
 681                 channel_active_preparse[chan_i] (*this);
 682
 683                 /* Hack to deal with MIDI sources that use velocity=0
 684                    instead of noteOff.
 685                 */
 686
 687                 if (msg[2] == 0) {
 688                         note_off (*this, (EventTwoBytes *) &msg[1]);
 689                         channel_note_off[chan_i]
 690                                 (*this, (EventTwoBytes *) &msg[1]);
 691                 } else {
 692                         note_on (*this, (EventTwoBytes *) &msg[1]);
 693                         channel_note_on[chan_i]
 694                                 (*this, (EventTwoBytes *) &msg[1]);
 695                 }
 696
 697                 channel_active_postparse[chan_i] (*this);
 698                 break;
 699
 700         case MIDI::controller:
 701                 channel_active_preparse[chan_i] (*this);
 702                 controller (*this, (EventTwoBytes *) &msg[1]);
 703                 channel_controller[chan_i]
 704                         (*this, (EventTwoBytes *) &msg[1]);
 705                 channel_active_postparse[chan_i] (*this);
 706                 break;
 707
 708         case program:
 709                 channel_active_preparse[chan_i] (*this);
 710                 program_change (*this, msg[1]);
 711                 channel_program_change[chan_i] (*this, msg[1]);
 712                 channel_active_postparse[chan_i] (*this);
 713                 break;
 714
 715         case chanpress:
 716                 channel_active_preparse[chan_i] (*this);
 717                 pressure (*this, msg[1]);
 718                 channel_pressure[chan_i] (*this, msg[1]);
 719                 channel_active_postparse[chan_i] (*this);
 720                 break;
 721
 722         case polypress:
 723                 channel_active_preparse[chan_i] (*this);
 724                 poly_pressure (*this, (EventTwoBytes *) &msg[1]);
 725                 channel_poly_pressure[chan_i]
 726                         (*this, (EventTwoBytes *) &msg[1]);
 727                 channel_active_postparse[chan_i] (*this);
 728                 break;
 729
 730         case MIDI::pitchbend:
 731                 channel_active_preparse[chan_i] (*this);
 732                 pitchbend (*this, (msg[1]<<7)|msg[2]);
 733                 channel_pitchbend[chan_i] (*this, (msg[1]<<7)|msg[2]);
 734                 channel_active_postparse[chan_i] (*this);
 735                 break;
 736
 737         case MIDI::sysex:
 738                 sysex (*this, msg, len);
 739                 break;
 740
 741         case MIDI::mtc_quarter:
 742                 process_mtc_quarter_frame (msg);
 743                 mtc_quarter_frame (*this, *msg);
 744                 break;
 745
 746         case MIDI::position:
 747                 position (*this, msg, len);
 748                 break;
 749
 750         case MIDI::song:
 751                 song (*this, msg, len);
 752                 break;
 753
 754         case MIDI::tune:
 755                 tune (*this);
 756
 757         default:
 758                 /* XXX some kind of warning ? */
 759                 break;
 760         }
 761
 762         any (*this, msg, len);
 763 }
 764
 765 bool
 766 Parser::possible_mmc (byte *msg, size_t msglen)
 767 {
 768         if (!MachineControl::is_mmc (msg, msglen)) {
 769                 return false;
 770         }
 771
 772         /* hand over the just the interior MMC part of
 773            the sysex msg without the leading 0xF0
 774         */
 775
 776         if (!_offline) {
 777                 mmc (*this, &msg[1], msglen - 1);
 778         }
 779
 780         return true;
 781 }
 782
 783 void
 784 Parser::set_offline (bool yn)
 785 {
 786         if (_offline != yn) {
 787                 _offline = yn;
 788                 OfflineStatusChanged ();
 789
 790                 /* this hack deals with the possibility of our first MIDI
 791                    bytes being running status messages.
 792                 */
 793
 794                 channel_msg (0x90);
 795                 state = NEEDSTATUS;
 796         }
 797 }
 798