← Back to branch summary

~ubuntu-branches/ubuntu/utopic/ardour3/utopic

« back to all changes in this revision

Viewing changes to libs/midi++2/parser.cc

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler
  • Date: 2013-09-21 19:05:02 UTC
  • Revision ID: package-import@ubuntu.com-20130921190502-8gsftrku6jnzhd7v
Tags: upstream-3.4~dfsg
Import upstream version 3.4~dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
        trace_stream = 0;
 
111
        trace_prefix = "";
 
112
        memset (message_counter, 0, sizeof (message_counter[0]) * 256);
 
113
        msgindex = 0;
 
114
        msgtype = none;
 
115
        msglen = 256;
 
116
        msgbuf = (unsigned char *) malloc (msglen);
 
117
        msgbuf[msgindex++] = 0x90;
 
118
        _mmc_forward = false;
 
119
        reset_mtc_state ();
 
120
        _offline = false;
 
121
 
 
122
        /* this hack deals with the possibility of our first MIDI
 
123
           bytes being running status messages.
 
124
        */
 
125
 
 
126
        channel_msg (0x90);
 
127
        state = NEEDSTATUS;
 
128
 
 
129
        pre_variable_state = NEEDSTATUS;
 
130
        pre_variable_msgtype = none;
 
131
}
 
132
 
 
133
Parser::~Parser ()
 
134
 
 
135
{
 
136
        delete msgbuf;
 
137
}
 
138
 
 
139
void
 
140
Parser::trace_event (Parser &, byte *msg, size_t len)
 
141
{
 
142
        eventType type;
 
143
        ostream *o;
 
144
 
 
145
        if ((o = trace_stream) == NULL) { /* can be asynchronously removed */
 
146
                return;
 
147
        }
 
148
        
 
149
        type = (eventType) (msg[0]&0xF0);
 
150
 
 
151
        switch (type) {
 
152
        case off:
 
153
                *o << trace_prefix
 
154
                   << "Channel "
 
155
                   << (msg[0]&0xF)+1
 
156
                   << " NoteOff NoteNum "
 
157
                   << (int) msg[1]
 
158
                   << " Vel "
 
159
                   << (int) msg[2]
 
160
                   << endmsg;
 
161
                break;
 
162
                
 
163
        case on:
 
164
                *o << trace_prefix
 
165
                   << "Channel "
 
166
                   << (msg[0]&0xF)+1
 
167
                   << " NoteOn NoteNum "
 
168
                   << (int) msg[1]
 
169
                   << " Vel "
 
170
                   << (int) msg[2]
 
171
                   << endmsg;
 
172
                break;
 
173
            
 
174
        case polypress:
 
175
                *o << trace_prefix
 
176
                   << "Channel "
 
177
                   << (msg[0]&0xF)+1
 
178
                   << " PolyPressure"
 
179
                   << (int) msg[1]
 
180
                   << endmsg;
 
181
                break;
 
182
            
 
183
        case MIDI::controller:
 
184
                *o << trace_prefix
 
185
                   << "Channel "
 
186
                   << (msg[0]&0xF)+1
 
187
                   << " Controller "
 
188
                   << (int) msg[1]
 
189
                   << " Value "
 
190
                   << (int) msg[2]
 
191
                   << endmsg;
 
192
                break;
 
193
                
 
194
        case program:
 
195
                *o << trace_prefix 
 
196
                   << "Channel "
 
197
                   << (msg[0]&0xF)+1
 
198
                   <<  " Program Change ProgNum "
 
199
                   << (int) msg[1]
 
200
                   << endmsg;
 
201
                break;
 
202
                
 
203
        case chanpress:
 
204
                *o << trace_prefix 
 
205
                   << "Channel "
 
206
                   << (msg[0]&0xF)+1
 
207
                   << " Channel Pressure "
 
208
                   << (int) msg[1]
 
209
                   << endmsg;
 
210
                break;
 
211
            
 
212
        case MIDI::pitchbend:
 
213
                *o << trace_prefix
 
214
                   << "Channel "
 
215
                   << (msg[0]&0xF)+1
 
216
                   << " Pitch Bend "
 
217
                   << ((msg[2]<<7)|msg[1])
 
218
                   << endmsg;
 
219
                break;
 
220
            
 
221
        case MIDI::sysex:
 
222
                if (len == 1) {
 
223
                        switch (msg[0]) {
 
224
                        case 0xf8:
 
225
                                *o << trace_prefix
 
226
                                   << "Clock"
 
227
                                   << endmsg;
 
228
                                break;
 
229
                        case 0xfa:
 
230
                                *o << trace_prefix
 
231
                                   << "Start"
 
232
                                   << endmsg;
 
233
                                break;
 
234
                        case 0xfb:
 
235
                                *o << trace_prefix
 
236
                                   << "Continue"
 
237
                                   << endmsg;
 
238
                                break;
 
239
                        case 0xfc:
 
240
                                *o << trace_prefix
 
241
                                   << "Stop"
 
242
                                   << endmsg;
 
243
                                break;
 
244
                        case 0xfe:
 
245
                                *o << trace_prefix
 
246
                                   << "Active Sense"
 
247
                                   << endmsg;
 
248
                                break;
 
249
                        case 0xff:
 
250
                                *o << trace_prefix
 
251
                                   << "System Reset"
 
252
                                   << endmsg;
 
253
                                break;
 
254
                        default:
 
255
                                *o << trace_prefix
 
256
                                   << "System Exclusive (1 byte : " << hex << (int) *msg << dec << ')'
 
257
                                   << endmsg;           
 
258
                                break;
 
259
                        } 
 
260
                } else {
 
261
                        *o << trace_prefix
 
262
                           << "System Exclusive (" << len << ") = [ " << hex;
 
263
                        for (unsigned int i = 0; i < len; ++i) {
 
264
                                *o << (int) msgbuf[i] << ' ';
 
265
                        }
 
266
                        *o << dec << ']' << endmsg;
 
267
                        
 
268
                }
 
269
                break;
 
270
            
 
271
        case MIDI::song:
 
272
                *o << trace_prefix << "Song" << endmsg;
 
273
                break;
 
274
            
 
275
        case MIDI::tune:
 
276
                *o << trace_prefix << "Tune" << endmsg;
 
277
                break;
 
278
            
 
279
        case MIDI::eox:
 
280
                *o << trace_prefix << "End-of-System Exclusive" << endmsg;
 
281
                break;
 
282
            
 
283
        case MIDI::timing:
 
284
                *o << trace_prefix << "Timing" << endmsg;
 
285
                break;
 
286
            
 
287
        case MIDI::start:
 
288
                *o << trace_prefix << "Start" << endmsg;
 
289
                break;
 
290
            
 
291
        case MIDI::stop:
 
292
                *o << trace_prefix << "Stop" << endmsg;
 
293
                break;
 
294
            
 
295
        case MIDI::contineu:
 
296
                *o << trace_prefix << "Continue" << endmsg;
 
297
                break;
 
298
            
 
299
        case active:
 
300
                *o << trace_prefix << "Active Sense" << endmsg;
 
301
                break;
 
302
            
 
303
        default:
 
304
                *o << trace_prefix << "Unrecognized MIDI message" << endmsg;
 
305
                break;
 
306
        }
 
307
}
 
308
 
 
309
void
 
310
Parser::trace (bool onoff, ostream *o, const string &prefix)
 
311
{
 
312
        trace_connection.disconnect ();
 
313
 
 
314
        if (onoff) {
 
315
                trace_stream = o;
 
316
                trace_prefix = prefix;
 
317
                any.connect_same_thread (trace_connection, boost::bind (&Parser::trace_event, this, _1, _2, _3));
 
318
        } else {
 
319
                trace_prefix = "";
 
320
                trace_stream = 0;
 
321
        }
 
322
}
 
323
 
 
324
void
 
325
Parser::scanner (unsigned char inbyte)
 
326
{
 
327
        bool statusbit;
 
328
        boost::optional<int> edit_result;
 
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
 
 
501
                edit_result = edit (msgbuf, msgindex);
 
502
                
 
503
                if (edit_result.get_value_or (1)) {
 
504
                        
 
505
                        /* message not cancelled by an editor */
 
506
                        
 
507
                        message_counter[msgbuf[0] & 0xF0]++;
 
508
 
 
509
                        if (!_offline) {
 
510
                                signal (msgbuf, msgindex);
 
511
                        }
 
512
                }
 
513
                
 
514
                if (runnable) {
 
515
                        /* In Runnable mode, we reset the message 
 
516
                           index, but keep the callbacks_pending and state the 
 
517
                           same.  This provides the "running status 
 
518
                           byte" feature.
 
519
                        */
 
520
                        msgindex = 1;
 
521
                } else {
 
522
                        /* If not Runnable, reset to NEEDSTATUS mode */
 
523
                        state = NEEDSTATUS;
 
524
                }
 
525
                break;
 
526
                
 
527
        case VARIABLELENGTH:
 
528
                /* nothing to do */
 
529
                break;
 
530
        }
 
531
        return;
 
532
}
 
533
 
 
534
/** Call the real-time function for the specified byte, immediately.
 
535
 * These can occur anywhere, so they don't change the state.
 
536
 */
 
537
void
 
538
Parser::realtime_msg(unsigned char inbyte)
 
539
 
 
540
{
 
541
        message_counter[inbyte]++;
 
542
 
 
543
        if (_offline) {
 
544
                return;
 
545
        }
 
546
 
 
547
        switch (inbyte) {
 
548
        case 0xf8:
 
549
                timing (*this, _timestamp);
 
550
                break;
 
551
        case 0xfa:
 
552
                start (*this, _timestamp);
 
553
                break;
 
554
        case 0xfb:
 
555
                contineu (*this, _timestamp);
 
556
                break;
 
557
        case 0xfc:
 
558
                stop (*this, _timestamp);
 
559
                break;
 
560
        case 0xfe:
 
561
                /* !!! active sense message in realtime_msg: should not reach here
 
562
                 */  
 
563
                break;
 
564
        case 0xff:
 
565
                reset (*this);
 
566
                break;
 
567
        }
 
568
 
 
569
        any (*this, &inbyte, 1);
 
570
}
 
571
 
 
572
 
 
573
/** Interpret a Channel (voice or mode) Message status byte.
 
574
 */
 
575
void
 
576
Parser::channel_msg(unsigned char inbyte)
 
577
{
 
578
        last_status_byte = inbyte;
 
579
        runnable = true;                /* Channel messages can use running status */
 
580
    
 
581
        /* The high 4 bits, which determine the type of channel message. */
 
582
    
 
583
        switch (inbyte&0xF0) {
 
584
        case 0x80:
 
585
                msgtype = off;
 
586
                state = NEEDTWOBYTES;
 
587
                break;
 
588
        case 0x90:
 
589
                msgtype = on;
 
590
                state = NEEDTWOBYTES;
 
591
                break;
 
592
        case 0xa0:
 
593
                msgtype = polypress;
 
594
                state = NEEDTWOBYTES;
 
595
                break;
 
596
        case 0xb0:
 
597
                msgtype = MIDI::controller;
 
598
                state = NEEDTWOBYTES;
 
599
                break;
 
600
        case 0xc0:
 
601
                msgtype = program;
 
602
                state = NEEDONEBYTE;
 
603
                break;
 
604
        case 0xd0:
 
605
                msgtype = chanpress;
 
606
                state = NEEDONEBYTE;
 
607
                break;
 
608
        case 0xe0:
 
609
                msgtype = MIDI::pitchbend;
 
610
                state = NEEDTWOBYTES;
 
611
                break;
 
612
        }
 
613
}
 
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
void
 
622
Parser::system_msg (unsigned char inbyte)
 
623
{
 
624
        message_counter[inbyte]++;
 
625
 
 
626
        switch (inbyte) {
 
627
        case 0xf0:
 
628
                pre_variable_msgtype = msgtype;
 
629
                pre_variable_state = state;
 
630
                was_runnable = runnable;
 
631
                msgtype = MIDI::sysex;
 
632
                state = VARIABLELENGTH;
 
633
                break;
 
634
        case 0xf1:
 
635
                msgtype = MIDI::mtc_quarter;
 
636
                state = NEEDONEBYTE;
 
637
                break;
 
638
        case 0xf2:
 
639
                msgtype = MIDI::position;
 
640
                state = NEEDTWOBYTES;
 
641
                break;
 
642
        case 0xf3:
 
643
                msgtype = MIDI::song;
 
644
                state = NEEDONEBYTE;
 
645
                break;
 
646
        case 0xf6:
 
647
                if (!_offline) {
 
648
                        tune (*this);
 
649
                }
 
650
                state = NEEDSTATUS;
 
651
                break;
 
652
        case 0xf7:
 
653
                break;
 
654
        }
 
655
 
 
656
        // all these messages will be sent via any() 
 
657
        // when they are complete.
 
658
        // any (*this, &inbyte, 1);
 
659
}
 
660
 
 
661
void 
 
662
Parser::signal (byte *msg, size_t len)
 
663
{
 
664
        channel_t chan = msg[0]&0xF;
 
665
        int chan_i = chan;
 
666
 
 
667
        switch (msgtype) {
 
668
        case none:
 
669
                break;
 
670
                
 
671
        case off:
 
672
                channel_active_preparse[chan_i] (*this);
 
673
                note_off (*this, (EventTwoBytes *) &msg[1]);
 
674
                channel_note_off[chan_i] 
 
675
                        (*this, (EventTwoBytes *) &msg[1]);
 
676
                channel_active_postparse[chan_i] (*this);
 
677
                break;
 
678
                
 
679
        case on:
 
680
                channel_active_preparse[chan_i] (*this);
 
681
 
 
682
                /* Hack to deal with MIDI sources that use velocity=0
 
683
                   instead of noteOff.
 
684
                */
 
685
 
 
686
                if (msg[2] == 0) {
 
687
                        note_off (*this, (EventTwoBytes *) &msg[1]);
 
688
                        channel_note_off[chan_i] 
 
689
                                (*this, (EventTwoBytes *) &msg[1]);
 
690
                } else {
 
691
                        note_on (*this, (EventTwoBytes *) &msg[1]);
 
692
                        channel_note_on[chan_i] 
 
693
                                (*this, (EventTwoBytes *) &msg[1]);
 
694
                }
 
695
 
 
696
                channel_active_postparse[chan_i] (*this);
 
697
                break;
 
698
                
 
699
        case MIDI::controller:
 
700
                channel_active_preparse[chan_i] (*this);
 
701
                controller (*this, (EventTwoBytes *) &msg[1]);
 
702
                channel_controller[chan_i] 
 
703
                        (*this, (EventTwoBytes *) &msg[1]);
 
704
                channel_active_postparse[chan_i] (*this);
 
705
                break;
 
706
                
 
707
        case program:
 
708
                channel_active_preparse[chan_i] (*this);
 
709
                program_change (*this, msg[1]);
 
710
                channel_program_change[chan_i] (*this, msg[1]);
 
711
                channel_active_postparse[chan_i] (*this);
 
712
                break;
 
713
                
 
714
        case chanpress:
 
715
                channel_active_preparse[chan_i] (*this);
 
716
                pressure (*this, msg[1]);
 
717
                channel_pressure[chan_i] (*this, msg[1]);
 
718
                channel_active_postparse[chan_i] (*this);
 
719
                break;
 
720
                
 
721
        case polypress:
 
722
                channel_active_preparse[chan_i] (*this);
 
723
                poly_pressure (*this, (EventTwoBytes *) &msg[1]);
 
724
                channel_poly_pressure[chan_i] 
 
725
                        (*this, (EventTwoBytes *) &msg[1]);
 
726
                channel_active_postparse[chan_i] (*this);
 
727
                break;
 
728
                
 
729
        case MIDI::pitchbend:
 
730
                channel_active_preparse[chan_i] (*this);
 
731
                pitchbend (*this, (msg[2]<<7)|msg[1]);
 
732
                channel_pitchbend[chan_i] (*this, (msg[2]<<7)|msg[1]);
 
733
                channel_active_postparse[chan_i] (*this);
 
734
                break;
 
735
                
 
736
        case MIDI::sysex:
 
737
                sysex (*this, msg, len);
 
738
                break;
 
739
 
 
740
        case MIDI::mtc_quarter:
 
741
                process_mtc_quarter_frame (msg);
 
742
                mtc_quarter_frame (*this, *msg);
 
743
                break;
 
744
                
 
745
        case MIDI::position:
 
746
                position (*this, msg, len);
 
747
                break;
 
748
                
 
749
        case MIDI::song:
 
750
                song (*this, msg, len);
 
751
                break;
 
752
        
 
753
        case MIDI::tune:
 
754
                tune (*this);
 
755
        
 
756
        default:
 
757
                /* XXX some kind of warning ? */
 
758
                break;
 
759
        }
 
760
        
 
761
        any (*this, msg, len);
 
762
}
 
763
 
 
764
bool
 
765
Parser::possible_mmc (byte *msg, size_t msglen)
 
766
{
 
767
        if (!MachineControl::is_mmc (msg, msglen)) {
 
768
                return false;
 
769
        }
 
770
 
 
771
        /* hand over the just the interior MMC part of
 
772
           the sysex msg without the leading 0xF0
 
773
        */
 
774
 
 
775
        if (!_offline) {
 
776
                mmc (*this, &msg[1], msglen - 1);
 
777
        }
 
778
 
 
779
        return true;
 
780
}
 
781
 
 
782
void
 
783
Parser::set_offline (bool yn)
 
784
{
 
785
        if (_offline != yn) {
 
786
                _offline = yn;
 
787
                OfflineStatusChanged ();
 
788
 
 
789
                /* this hack deals with the possibility of our first MIDI
 
790
                   bytes being running status messages.
 
791
                */
 
792
                
 
793
                channel_msg (0x90);
 
794
                state = NEEDSTATUS;
 
795
        }
 
796
}
 
797