| /*---------------------------------------------------------------------------- |
| * |
| * File: |
| * eas_midi.c |
| * |
| * Contents and purpose: |
| * This file implements the MIDI stream parser. It is called by eas_smf.c to parse MIDI messages |
| * that are streamed out of the file. It can also parse live MIDI streams. |
| * |
| * Copyright Sonic Network Inc. 2005 |
| |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *---------------------------------------------------------------------------- |
| * Revision Control: |
| * $Revision: 794 $ |
| * $Date: 2007-08-01 00:08:48 -0700 (Wed, 01 Aug 2007) $ |
| *---------------------------------------------------------------------------- |
| */ |
| |
| #include "eas_data.h" |
| #include "eas_report.h" |
| #include "eas_miditypes.h" |
| #include "eas_midi.h" |
| #include "eas_vm_protos.h" |
| #include "eas_parser.h" |
| |
| #ifdef JET_INTERFACE |
| #include "jet_data.h" |
| #endif |
| |
| |
| /* state enumerations for ProcessSysExMessage */ |
| typedef enum |
| { |
| eSysEx, |
| eSysExUnivNonRealTime, |
| eSysExUnivNrtTargetID, |
| eSysExGMControl, |
| eSysExUnivRealTime, |
| eSysExUnivRtTargetID, |
| eSysExDeviceControl, |
| eSysExMasterVolume, |
| eSysExMasterVolLSB, |
| eSysExSPMIDI, |
| eSysExSPMIDIchan, |
| eSysExSPMIDIMIP, |
| eSysExMfgID1, |
| eSysExMfgID2, |
| eSysExMfgID3, |
| eSysExEnhancer, |
| eSysExEnhancerSubID, |
| eSysExEnhancerFeedback1, |
| eSysExEnhancerFeedback2, |
| eSysExEnhancerDrive, |
| eSysExEnhancerWet, |
| eSysExEOX, |
| eSysExIgnore |
| } E_SYSEX_STATES; |
| |
| /* local prototypes */ |
| static EAS_RESULT ProcessMIDIMessage (S_EAS_DATA *pEASData, S_SYNTH *pSynth, S_MIDI_STREAM *pMIDIStream, EAS_INT parserMode); |
| static EAS_RESULT ProcessSysExMessage (S_EAS_DATA *pEASData, S_SYNTH *pSynth, S_MIDI_STREAM *pMIDIStream, EAS_U8 c, EAS_INT parserMode); |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_InitMIDIStream() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Initializes the MIDI stream state for parsing. |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * returns EAS_RESULT (EAS_SUCCESS is OK) |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| void EAS_InitMIDIStream (S_MIDI_STREAM *pMIDIStream) |
| { |
| pMIDIStream->byte3 = EAS_FALSE; |
| pMIDIStream->pending = EAS_FALSE; |
| pMIDIStream->runningStatus = 0; |
| pMIDIStream->status = 0; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * EAS_ParseMIDIStream() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Parses a MIDI input stream character by character. Characters are pushed (rather than pulled) |
| * so the interface works equally well for both file and stream I/O. |
| * |
| * Inputs: |
| * c - character from MIDI stream |
| * |
| * Outputs: |
| * returns EAS_RESULT (EAS_SUCCESS is OK) |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| EAS_RESULT EAS_ParseMIDIStream (S_EAS_DATA *pEASData, S_SYNTH *pSynth, S_MIDI_STREAM *pMIDIStream, EAS_U8 c, EAS_INT parserMode) |
| { |
| |
| /* check for new status byte */ |
| if (c & 0x80) |
| { |
| /* save new running status */ |
| if (c < 0xf8) |
| { |
| pMIDIStream->runningStatus = c; |
| pMIDIStream->byte3 = EAS_FALSE; |
| |
| /* deal with SysEx */ |
| if ((c == 0xf7) || (c == 0xf0)) |
| { |
| if (parserMode == eParserModeMetaData) |
| return EAS_SUCCESS; |
| return ProcessSysExMessage(pEASData, pSynth, pMIDIStream, c, parserMode); |
| } |
| |
| /* inform the file parser that we're in the middle of a message */ |
| if ((c < 0xf4) || (c > 0xf6)) |
| pMIDIStream->pending = EAS_TRUE; |
| } |
| |
| /* real-time message - ignore it */ |
| return EAS_SUCCESS; |
| } |
| |
| /* 3rd byte of a 3-byte message? */ |
| if (pMIDIStream->byte3) |
| { |
| pMIDIStream->d2 = c; |
| pMIDIStream->byte3 = EAS_FALSE; |
| pMIDIStream->pending = EAS_FALSE; |
| if (parserMode == eParserModeMetaData) |
| return EAS_SUCCESS; |
| return ProcessMIDIMessage(pEASData, pSynth, pMIDIStream, parserMode); |
| } |
| |
| /* check for status received */ |
| if (pMIDIStream->runningStatus) |
| { |
| |
| /* save new status and data byte */ |
| pMIDIStream->status = pMIDIStream->runningStatus; |
| |
| /* check for 3-byte messages */ |
| if (pMIDIStream->status < 0xc0) |
| { |
| pMIDIStream->d1 = c; |
| pMIDIStream->pending = EAS_TRUE; |
| pMIDIStream->byte3 = EAS_TRUE; |
| return EAS_SUCCESS; |
| } |
| |
| /* check for 2-byte messages */ |
| if (pMIDIStream->status < 0xe0) |
| { |
| pMIDIStream->d1 = c; |
| pMIDIStream->pending = EAS_FALSE; |
| if (parserMode == eParserModeMetaData) |
| return EAS_SUCCESS; |
| return ProcessMIDIMessage(pEASData, pSynth, pMIDIStream, parserMode); |
| } |
| |
| /* check for more 3-bytes message */ |
| if (pMIDIStream->status < 0xf0) |
| { |
| pMIDIStream->d1 = c; |
| pMIDIStream->pending = EAS_TRUE; |
| pMIDIStream->byte3 = EAS_TRUE; |
| return EAS_SUCCESS; |
| } |
| |
| /* SysEx message? */ |
| if (pMIDIStream->status == 0xF0) |
| { |
| if (parserMode == eParserModeMetaData) |
| return EAS_SUCCESS; |
| return ProcessSysExMessage(pEASData, pSynth, pMIDIStream, c, parserMode); |
| } |
| |
| /* remaining messages all clear running status */ |
| pMIDIStream->runningStatus = 0; |
| |
| /* F2 is 3-byte message */ |
| if (pMIDIStream->status == 0xf2) |
| { |
| pMIDIStream->byte3 = EAS_TRUE; |
| return EAS_SUCCESS; |
| } |
| } |
| |
| /* no status byte received, provide a warning, but we should be able to recover */ |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Received MIDI data without a valid status byte: %d\n",c); */ } |
| pMIDIStream->pending = EAS_FALSE; |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * ProcessMIDIMessage() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * This function processes a typical MIDI message. All of the data has been received, just need |
| * to take appropriate action. |
| * |
| * Inputs: |
| * |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static EAS_RESULT ProcessMIDIMessage (S_EAS_DATA *pEASData, S_SYNTH *pSynth, S_MIDI_STREAM *pMIDIStream, EAS_INT parserMode) |
| { |
| EAS_U8 channel; |
| |
| channel = pMIDIStream->status & 0x0f; |
| switch (pMIDIStream->status & 0xf0) |
| { |
| case 0x80: |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL,"NoteOff: %02x %02x %02x\n", |
| pMIDIStream->status, pMIDIStream->d1, pMIDIStream->d2); */ } |
| if (parserMode < eParserModeMute) |
| VMStopNote(pEASData->pVoiceMgr, pSynth, channel, pMIDIStream->d1, pMIDIStream->d2); |
| break; |
| |
| case 0x90: |
| if (pMIDIStream->d2) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL,"NoteOn: %02x %02x %02x\n", |
| pMIDIStream->status, pMIDIStream->d1, pMIDIStream->d2); */ } |
| pMIDIStream->flags |= MIDI_FLAG_FIRST_NOTE; |
| if (parserMode == eParserModePlay) |
| VMStartNote(pEASData->pVoiceMgr, pSynth, channel, pMIDIStream->d1, pMIDIStream->d2); |
| } |
| else |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL,"NoteOff: %02x %02x %02x\n", |
| pMIDIStream->status, pMIDIStream->d1, pMIDIStream->d2); */ } |
| if (parserMode < eParserModeMute) |
| VMStopNote(pEASData->pVoiceMgr, pSynth, channel, pMIDIStream->d1, pMIDIStream->d2); |
| } |
| break; |
| |
| case 0xa0: |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL,"PolyPres: %02x %02x %02x\n", |
| pMIDIStream->status, pMIDIStream->d1, pMIDIStream->d2); */ } |
| break; |
| |
| case 0xb0: |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL,"Control: %02x %02x %02x\n", |
| pMIDIStream->status, pMIDIStream->d1, pMIDIStream->d2); */ } |
| if (parserMode < eParserModeMute) |
| VMControlChange(pEASData->pVoiceMgr, pSynth, channel, pMIDIStream->d1, pMIDIStream->d2); |
| #ifdef JET_INTERFACE |
| if (pMIDIStream->jetData & MIDI_FLAGS_JET_CB) |
| { |
| JET_Event(pEASData, pMIDIStream->jetData & (JET_EVENT_SEG_MASK | JET_EVENT_TRACK_MASK), |
| channel, pMIDIStream->d1, pMIDIStream->d2); |
| } |
| #endif |
| break; |
| |
| case 0xc0: |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL,"Program: %02x %02x\n", |
| pMIDIStream->status, pMIDIStream->d1); */ } |
| if (parserMode < eParserModeMute) |
| VMProgramChange(pEASData->pVoiceMgr, pSynth, channel, pMIDIStream->d1); |
| break; |
| |
| case 0xd0: |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL,"ChanPres: %02x %02x\n", |
| pMIDIStream->status, pMIDIStream->d1); */ } |
| if (parserMode < eParserModeMute) |
| VMChannelPressure(pSynth, channel, pMIDIStream->d1); |
| break; |
| |
| case 0xe0: |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL,"PBend: %02x %02x %02x\n", |
| pMIDIStream->status, pMIDIStream->d1, pMIDIStream->d2); */ } |
| if (parserMode < eParserModeMute) |
| VMPitchBend(pSynth, channel, pMIDIStream->d1, pMIDIStream->d2); |
| break; |
| |
| default: |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL,"Unknown: %02x %02x %02x\n", |
| pMIDIStream->status, pMIDIStream->d1, pMIDIStream->d2); */ } |
| } |
| return EAS_SUCCESS; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * ProcessSysExMessage() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Process a SysEx character byte from the MIDI stream. Since we cannot |
| * simply wait for the next character to arrive, we are forced to save |
| * state after each character. It would be easier to parse at the file |
| * level, but then we lose the nice feature of being able to support |
| * these messages in a real-time MIDI stream. |
| * |
| * Inputs: |
| * pEASData - pointer to synthesizer instance data |
| * c - character to be processed |
| * locating - if true, the sequencer is relocating to a new position |
| * |
| * Outputs: |
| * |
| * |
| * Side Effects: |
| * |
| * Notes: |
| * These are the SysEx messages we can receive: |
| * |
| * SysEx messages |
| * { f0 7e 7f 09 01 f7 } GM 1 On |
| * { f0 7e 7f 09 02 f7 } GM 1/2 Off |
| * { f0 7e 7f 09 03 f7 } GM 2 On |
| * { f0 7f 7f 04 01 lsb msb } Master Volume |
| * { f0 7f 7f 0b 01 ch mip [ch mip ...] f7 } SP-MIDI |
| * { f0 00 01 3a 04 01 fdbk1 fdbk2 drive wet dry f7 } Enhancer |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static EAS_RESULT ProcessSysExMessage (S_EAS_DATA *pEASData, S_SYNTH *pSynth, S_MIDI_STREAM *pMIDIStream, EAS_U8 c, EAS_INT parserMode) |
| { |
| |
| /* check for start byte */ |
| if (c == 0xf0) |
| { |
| pMIDIStream->sysExState = eSysEx; |
| } |
| /* check for end byte */ |
| else if (c == 0xf7) |
| { |
| /* if this was a MIP message, update the MIP table */ |
| if ((pMIDIStream->sysExState == eSysExSPMIDIchan) && (parserMode != eParserModeMetaData)) |
| VMUpdateMIPTable(pEASData->pVoiceMgr, pSynth); |
| pMIDIStream->sysExState = eSysExIgnore; |
| } |
| |
| /* process SysEx message */ |
| else |
| { |
| switch (pMIDIStream->sysExState) |
| { |
| case eSysEx: |
| |
| /* first byte, determine message class */ |
| switch (c) |
| { |
| case 0x7e: |
| pMIDIStream->sysExState = eSysExUnivNonRealTime; |
| break; |
| case 0x7f: |
| pMIDIStream->sysExState = eSysExUnivRealTime; |
| break; |
| case 0x00: |
| pMIDIStream->sysExState = eSysExMfgID1; |
| break; |
| default: |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| } |
| break; |
| |
| /* process GM message */ |
| case eSysExUnivNonRealTime: |
| if (c == 0x7f) |
| pMIDIStream->sysExState = eSysExUnivNrtTargetID; |
| else |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| case eSysExUnivNrtTargetID: |
| if (c == 0x09) |
| pMIDIStream->sysExState = eSysExGMControl; |
| else |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| case eSysExGMControl: |
| if ((c == 1) || (c == 3)) |
| { |
| /* GM 1 or GM2 On, reset synth */ |
| if (parserMode != eParserModeMetaData) |
| { |
| pMIDIStream->flags |= MIDI_FLAG_GM_ON; |
| VMReset(pEASData->pVoiceMgr, pSynth, EAS_FALSE); |
| VMInitMIPTable(pSynth); |
| } |
| pMIDIStream->sysExState = eSysExEOX; |
| } |
| else |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| /* Process Master Volume and SP-MIDI */ |
| case eSysExUnivRealTime: |
| if (c == 0x7f) |
| pMIDIStream->sysExState = eSysExUnivRtTargetID; |
| else |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| case eSysExUnivRtTargetID: |
| if (c == 0x04) |
| pMIDIStream->sysExState = eSysExDeviceControl; |
| else if (c == 0x0b) |
| pMIDIStream->sysExState = eSysExSPMIDI; |
| else |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| /* process master volume */ |
| case eSysExDeviceControl: |
| if (c == 0x01) |
| pMIDIStream->sysExState = eSysExMasterVolume; |
| else |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| case eSysExMasterVolume: |
| /* save LSB */ |
| pMIDIStream->d1 = c; |
| pMIDIStream->sysExState = eSysExMasterVolLSB; |
| break; |
| |
| case eSysExMasterVolLSB: |
| if (parserMode != eParserModeMetaData) |
| { |
| EAS_I32 gain = ((EAS_I32) c << 8) | ((EAS_I32) pMIDIStream->d1 << 1); |
| gain = (gain * gain) >> 15; |
| VMSetVolume(pSynth, (EAS_U16) gain); |
| } |
| pMIDIStream->sysExState = eSysExEOX; |
| break; |
| |
| /* process SP-MIDI MIP message */ |
| case eSysExSPMIDI: |
| if (c == 0x01) |
| { |
| /* assume all channels are muted */ |
| if (parserMode != eParserModeMetaData) |
| VMInitMIPTable(pSynth); |
| pMIDIStream->d1 = 0; |
| pMIDIStream->sysExState = eSysExSPMIDIchan; |
| } |
| else |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| case eSysExSPMIDIchan: |
| if (c < NUM_SYNTH_CHANNELS) |
| { |
| pMIDIStream->d2 = c; |
| pMIDIStream->sysExState = eSysExSPMIDIMIP; |
| } |
| else |
| { |
| /* bad MIP message - unmute channels */ |
| if (parserMode != eParserModeMetaData) |
| VMInitMIPTable(pSynth); |
| pMIDIStream->sysExState = eSysExIgnore; |
| } |
| break; |
| |
| case eSysExSPMIDIMIP: |
| /* process MIP entry here */ |
| if (parserMode != eParserModeMetaData) |
| VMSetMIPEntry(pEASData->pVoiceMgr, pSynth, pMIDIStream->d2, pMIDIStream->d1, c); |
| pMIDIStream->sysExState = eSysExSPMIDIchan; |
| |
| /* if 16 channels received, update MIP table */ |
| if (++pMIDIStream->d1 == NUM_SYNTH_CHANNELS) |
| { |
| if (parserMode != eParserModeMetaData) |
| VMUpdateMIPTable(pEASData->pVoiceMgr, pSynth); |
| pMIDIStream->sysExState = eSysExEOX; |
| } |
| break; |
| |
| /* process Enhancer */ |
| case eSysExMfgID1: |
| if (c == 0x01) |
| pMIDIStream->sysExState = eSysExMfgID1; |
| else |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| case eSysExMfgID2: |
| if (c == 0x3a) |
| pMIDIStream->sysExState = eSysExMfgID1; |
| else |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| case eSysExMfgID3: |
| if (c == 0x04) |
| pMIDIStream->sysExState = eSysExEnhancer; |
| else |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| case eSysExEnhancer: |
| if (c == 0x01) |
| pMIDIStream->sysExState = eSysExEnhancerSubID; |
| else |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| case eSysExEnhancerSubID: |
| pMIDIStream->sysExState = eSysExEnhancerFeedback1; |
| break; |
| |
| case eSysExEnhancerFeedback1: |
| pMIDIStream->sysExState = eSysExEnhancerFeedback2; |
| break; |
| |
| case eSysExEnhancerFeedback2: |
| pMIDIStream->sysExState = eSysExEnhancerDrive; |
| break; |
| |
| case eSysExEnhancerDrive: |
| pMIDIStream->sysExState = eSysExEnhancerWet; |
| break; |
| |
| case eSysExEnhancerWet: |
| pMIDIStream->sysExState = eSysExEOX; |
| break; |
| |
| case eSysExEOX: |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Expected F7, received %02x\n", c); */ } |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| |
| case eSysExIgnore: |
| break; |
| |
| default: |
| pMIDIStream->sysExState = eSysExIgnore; |
| break; |
| } |
| } |
| |
| if (pMIDIStream->sysExState == eSysExIgnore) |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Ignoring SysEx byte %02x\n", c); */ } |
| return EAS_SUCCESS; |
| } /* end ProcessSysExMessage */ |
| |
