/*----------------------------------------------------------------------------
 *
 * 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 */