/*----------------------------------------------------------------------------
 *
 * File:
 * fmsynth.c
 *
 * Contents and purpose:
 * Implements the high-level FM synthesizer functions.
 *
 * Copyright Sonic Network Inc. 2004

 * 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: 795 $
 *   $Date: 2007-08-01 00:14:45 -0700 (Wed, 01 Aug 2007) $
 *----------------------------------------------------------------------------
*/

// includes
#include "eas_host.h"
#include "eas_report.h"

#include "eas_data.h"
#include "eas_synth_protos.h"
#include "eas_audioconst.h"
#include "eas_fmengine.h"
#include "eas_math.h"

/* option sanity check */
#ifdef _REVERB
#error "No reverb for FM synthesizer"
#endif
#ifdef _CHORUS
#error "No chorus for FM synthesizer"
#endif

/*
 * WARNING: These macros can cause unwanted side effects. Use them
 * with care. For example, min(x++,y++) will cause either x or y to be
 * incremented twice.
 */
#define min(a,b) ((a) < (b) ? (a) : (b))
#define max(a,b) ((a) > (b) ? (a) : (b))

/* pivot point for keyboard scalars */
#define EG_SCALE_PIVOT_POINT 64
#define KEY_SCALE_PIVOT_POINT 36

/* This number is the negative of the frequency of the note (in cents) of
 * the sine wave played at unity. The number can be calculated as follows:
 *
 * MAGIC_NUMBER = 1200 * log(base2) (SINE_TABLE_SIZE * 8.175798916 / SAMPLE_RATE)
 *
 * 8.17578 is a reference to the frequency of MIDI note 0
 */
#if defined (_SAMPLE_RATE_8000)
#define MAGIC_NUMBER 1279
#elif   defined (_SAMPLE_RATE_16000)
#define MAGIC_NUMBER 79
#elif   defined (_SAMPLE_RATE_20000)
#define MAGIC_NUMBER -308
#elif   defined (_SAMPLE_RATE_22050)
#define MAGIC_NUMBER -477
#elif   defined (_SAMPLE_RATE_24000)
#define MAGIC_NUMBER -623
#elif defined (_SAMPLE_RATE_32000)
#define MAGIC_NUMBER -1121
#elif defined (_SAMPLE_RATE_44100)
#define MAGIC_NUMBER -1677
#elif defined (_SAMPLE_RATE_48000)
#define MAGIC_NUMBER -1823
#endif

/* externs */
extern const EAS_I16 fmControlTable[128];
extern const EAS_U16 fmRateTable[256];
extern const EAS_U16 fmAttackTable[16];
extern const EAS_U8 fmDecayTable[16];
extern const EAS_U8 fmReleaseTable[16];
extern const EAS_U8 fmScaleTable[16];

/* local prototypes */
/*lint -esym(715, pVoiceMgr) standard synthesizer interface - pVoiceMgr not used */
static EAS_RESULT FM_Initialize (S_VOICE_MGR *pVoiceMgr) { return EAS_SUCCESS; }
static EAS_RESULT FM_StartVoice (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice, EAS_I32 voiceNum, EAS_U16 regionIndex);
static EAS_BOOL FM_UpdateVoice (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice, EAS_I32 voiceNum, EAS_I32 *pMixBuffer, EAS_I32 numSamples);
static void FM_ReleaseVoice (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice, EAS_I32 voiceNum);
static void FM_MuteVoice (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice, EAS_I32 voiceNum);
static void FM_SustainPedal (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice, S_SYNTH_CHANNEL *pChannel, EAS_I32 voiceNum);
static void FM_UpdateChannel (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U8 channel);


/*----------------------------------------------------------------------------
 * Synthesizer interface
 *----------------------------------------------------------------------------
*/
const S_SYNTH_INTERFACE fmSynth =
{
    FM_Initialize,
    FM_StartVoice,
    FM_UpdateVoice,
    FM_ReleaseVoice,
    FM_MuteVoice,
    FM_SustainPedal,
    FM_UpdateChannel
};

#ifdef FM_OFFBOARD
const S_FRAME_INTERFACE fmFrameInterface =
{
    FM_StartFrame,
    FM_EndFrame
};
#endif

/*----------------------------------------------------------------------------
 * inline functions
 *----------------------------------------------------------------------------
 */
EAS_INLINE S_FM_VOICE *GetFMVoicePtr (S_VOICE_MGR *pVoiceMgr, EAS_INT voiceNum)
{
    return &pVoiceMgr->fmVoices[voiceNum];
}
EAS_INLINE S_SYNTH_CHANNEL *GetChannelPtr (S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice)
{
    return &pSynth->channels[pVoice->channel & 15];
}
EAS_INLINE const S_FM_REGION *GetFMRegionPtr (S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice)
{
#ifdef _SECONDARY_SYNTH
    return &pSynth->pEAS->pFMRegions[pVoice->regionIndex & REGION_INDEX_MASK];
#else
    return &pSynth->pEAS->pFMRegions[pVoice->regionIndex];
#endif
}

/*----------------------------------------------------------------------------
 * FM_SynthIsOutputOperator
 *----------------------------------------------------------------------------
 * Purpose:
 * Returns true if the operator is a direct output and not muted
 *
 * Inputs:
 *
 * Outputs:
 * Returns boolean
 *----------------------------------------------------------------------------
*/
static EAS_BOOL FM_SynthIsOutputOperator (const S_FM_REGION *pRegion, EAS_INT operIndex)
{

    /* see if voice is muted */
    if ((pRegion->oper[operIndex].gain & 0xfc) == 0)
        return 0;

    /* check based on mode */
    switch (pRegion->region.keyGroupAndFlags & 7)
    {

        /* mode 0 - all operators are external */
        case 0:
            return EAS_TRUE;

        /* mode 1 - operators 1-3 are external */
        case 1:
            if (operIndex != 0)
                return EAS_TRUE;
        break;

        /* mode 2 - operators 1 & 3 are external */
        case 2:
            if ((operIndex == 1) || (operIndex == 3))
                return EAS_TRUE;
            break;

        /* mode 2 - operators 1 & 2 are external */
        case 3:
            if ((operIndex == 1) || (operIndex == 2))
                return EAS_TRUE;
            break;

        /* modes 4 & 5 - operator 1 is external */
        case 4:
        case 5:
            if (operIndex == 1)
                return EAS_TRUE;
            break;

        default:
            { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL,"Invalid voice mode: %d",
                pRegion->region.keyGroupAndFlags & 7); */ }
    }

    return EAS_FALSE;
}

/*----------------------------------------------------------------------------
 * FM_CalcEGRate()
 *----------------------------------------------------------------------------
 * Purpose:
 *
 * Inputs:
 * nKeyNumber - MIDI note
 * nLogRate - logarithmic scale rate from patch data
 * nKeyScale - key scaling factor for this EG
 *
 * Outputs:
 * 16-bit linear multiplier
 *----------------------------------------------------------------------------
*/

static EAS_U16 FM_CalcEGRate (EAS_U8 nKeyNumber, EAS_U8 nLogRate, EAS_U8 nEGScale)
{
    EAS_I32 temp;

    /* incorporate key scaling on release rate */
    temp = (EAS_I32) nLogRate << 7;
    temp += ((EAS_I32) nKeyNumber - EG_SCALE_PIVOT_POINT) * (EAS_I32) nEGScale;

    /* saturate */
    temp = max(temp, 0);
    temp = min(temp, 32767);

    /* look up in rate table */
    /*lint -e{704} use shift for performance */
    return fmRateTable[temp >> 8];
}

/*----------------------------------------------------------------------------
 * FM_ReleaseVoice()
 *----------------------------------------------------------------------------
 * Purpose:
 * The selected voice is being released.
 *
 * Inputs:
 * psEASData - pointer to S_EAS_DATA
 * pVoice - pointer to voice to release
 *
 * Outputs:
 * None
 *----------------------------------------------------------------------------
*/
static void FM_ReleaseVoice (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice, EAS_I32 voiceNum)
{
    EAS_INT operIndex;
    const S_FM_REGION *pRegion;
    S_FM_VOICE *pFMVoice;

    /* check to see if voice responds to NOTE-OFF's */
    pRegion = GetFMRegionPtr(pSynth, pVoice);
    if (pRegion->region.keyGroupAndFlags & REGION_FLAG_ONE_SHOT)
        return;

    /* set all envelopes to release state */
    pFMVoice = GetFMVoicePtr(pVoiceMgr, voiceNum);
    for (operIndex = 0; operIndex < 4; operIndex++)
    {
        pFMVoice->oper[operIndex].envState = eFMEnvelopeStateRelease;

        /* incorporate key scaling on release rate */
        pFMVoice->oper[operIndex].envRate = FM_CalcEGRate(
                pVoice->note,
                fmReleaseTable[pRegion->oper[operIndex].velocityRelease & 0x0f],
                fmScaleTable[pRegion->oper[operIndex].egKeyScale >> 4]);
    } /* end for (operIndex = 0; operIndex < 4; operIndex++) */
}

/*----------------------------------------------------------------------------
 * FM_MuteVoice()
 *----------------------------------------------------------------------------
 * Purpose:
 * The selected voice is being muted.
 *
 * Inputs:
 * pVoice - pointer to voice to release
 *
 * Outputs:
 * None
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pSynth) standard interface, pVoiceMgr not used */
static void FM_MuteVoice (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice, EAS_I32 voiceNum)
{
    S_FM_VOICE *pFMVoice;

    /* clear deferred action flags */
    pVoice->voiceFlags &=
        ~(VOICE_FLAG_DEFER_MIDI_NOTE_OFF |
        VOICE_FLAG_SUSTAIN_PEDAL_DEFER_NOTE_OFF |
        VOICE_FLAG_DEFER_MUTE);

    /* set all envelopes to muted state */
    pFMVoice = GetFMVoicePtr(pVoiceMgr, voiceNum);
    pFMVoice->oper[0].envState = eFMEnvelopeStateMuted;
    pFMVoice->oper[1].envState = eFMEnvelopeStateMuted;
    pFMVoice->oper[2].envState = eFMEnvelopeStateMuted;
    pFMVoice->oper[3].envState = eFMEnvelopeStateMuted;
}

/*----------------------------------------------------------------------------
 * FM_SustainPedal()
 *----------------------------------------------------------------------------
 * Purpose:
 * The selected voice is held due to sustain pedal
 *
 * Inputs:
 * pVoice - pointer to voice to sustain
 *
 * Outputs:
 * None
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pChannel) standard interface, pVoiceMgr not used */
static void FM_SustainPedal (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice, S_SYNTH_CHANNEL *pChannel, EAS_I32 voiceNum)
{
    const S_FM_REGION *pRegion;
    S_FM_VOICE *pFMVoice;
    EAS_INT operIndex;

    pRegion = GetFMRegionPtr(pSynth, pVoice);
    pFMVoice = GetFMVoicePtr(pVoiceMgr, voiceNum);

    /* check to see if any envelopes are above the sustain level */
    for (operIndex = 0; operIndex < 4; operIndex++)
    {

        /* if level control or envelope gain is zero, skip this envelope */
        if (((pRegion->oper[operIndex].gain & 0xfc) == 0) ||
            (pFMVoice->oper[operIndex].envGain == 0))
        {
            continue;
        }

        /* if the envelope gain is above the sustain level, we need to catch this voice */
        if (pFMVoice->oper[operIndex].envGain >= ((EAS_U16) (pRegion->oper[operIndex].sustain & 0xfc) << 7))
        {

            /* reset envelope to decay state */
            pFMVoice->oper[operIndex].envState = eFMEnvelopeStateDecay;

            pFMVoice->oper[operIndex].envRate = FM_CalcEGRate(
                    pVoice->note,
                    fmDecayTable[pRegion->oper[operIndex].attackDecay & 0x0f],
                    fmScaleTable[pRegion->oper[operIndex].egKeyScale >> 4]);

            /* set voice to decay state */
            pVoice->voiceState = eVoiceStatePlay;

            /* set sustain flag */
            pVoice->voiceFlags |= VOICE_FLAG_SUSTAIN_PEDAL_DEFER_NOTE_OFF;
        }
    } /* end for (operIndex = 0; operIndex < 4; operIndex++) */
}

/*----------------------------------------------------------------------------
 * FM_StartVoice()
 *----------------------------------------------------------------------------
 * Purpose:
 * Assign the region for the given instrument using the midi key number
 * and the RPN2 (coarse tuning) value. By using RPN2 as part of the
 * region selection process, we reduce the amount a given sample has
 * to be transposed by selecting the closest recorded root instead.
 *
 * This routine is the second half of SynthAssignRegion().
 * If the region was successfully found by SynthFindRegionIndex(),
 * then assign the region's parameters to the voice.
 *
 * Setup and initialize the following voice parameters:
 * m_nRegionIndex
 *
 * Inputs:
 * pVoice - ptr to the voice we have assigned for this channel
 * nRegionIndex - index of the region
 * psEASData - pointer to overall EAS data structure
 *
 * Outputs:
 * success - could find and assign the region for this voice's note otherwise
 * failure - could not find nor assign the region for this voice's note
 *
 * Side Effects:
 * psSynthObject->m_sVoice[].m_nRegionIndex is assigned
 * psSynthObject->m_sVoice[] parameters are assigned
 *----------------------------------------------------------------------------
*/
static EAS_RESULT FM_StartVoice (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice, EAS_I32 voiceNum, EAS_U16 regionIndex)
{
    S_FM_VOICE *pFMVoice;
    S_SYNTH_CHANNEL *pChannel;
    const S_FM_REGION *pRegion;
    EAS_I32 temp;
    EAS_INT operIndex;

    /* establish pointers to data */
    pVoice->regionIndex = regionIndex;
    pFMVoice = GetFMVoicePtr(pVoiceMgr, voiceNum);
    pChannel = GetChannelPtr(pSynth, pVoice);
    pRegion = GetFMRegionPtr(pSynth, pVoice);

    /* update static channel parameters */
    if (pChannel->channelFlags & CHANNEL_FLAG_UPDATE_CHANNEL_PARAMETERS)
        FM_UpdateChannel(pVoiceMgr, pSynth, pVoice->channel & 15);

    /* init the LFO */
    pFMVoice->lfoValue = 0;
    pFMVoice->lfoPhase = 0;
    pFMVoice->lfoDelay = (EAS_U16) (fmScaleTable[pRegion->lfoFreqDelay & 0x0f] >> 1);

#if (NUM_OUTPUT_CHANNELS == 2)
    /* calculate pan gain values only if stereo output */
    /* set up panning only at note start */
    temp = (EAS_I32) pChannel->pan - 64;
    temp += (EAS_I32) pRegion->pan;
    if (temp < -64)
        temp = -64;
    if (temp > 64)
        temp = 64;
    pFMVoice->pan = (EAS_I8) temp;
#endif /* #if (NUM_OUTPUT_CHANNELS == 2) */

    /* no samples have been synthesized for this note yet */
    pVoice->voiceFlags = VOICE_FLAG_NO_SAMPLES_SYNTHESIZED_YET;

    /* initialize gain value for anti-zipper filter */
    pFMVoice->voiceGain = (EAS_I16) EAS_LogToLinear16(pChannel->staticGain);
    pFMVoice->voiceGain = (EAS_I16) FMUL_15x15(pFMVoice->voiceGain, pSynth->masterVolume);

    /* initialize the operators */
    for (operIndex = 0; operIndex < 4; operIndex++)
    {

        /* establish operator output gain level */
        /*lint -e{701} <use shift for performance> */
        pFMVoice->oper[operIndex].outputGain = EAS_LogToLinear16(((EAS_I16) (pRegion->oper[operIndex].gain & 0xfc) - 0xfc) << 7);

        /* check for linear velocity flag */
        /*lint -e{703} <use shift for performance> */
        if (pRegion->oper[operIndex].flags & FM_OPER_FLAG_LINEAR_VELOCITY)
            temp = (EAS_I32) (pVoice->velocity - 127) << 5;
        else
            temp = (EAS_I32) fmControlTable[pVoice->velocity];

        /* scale velocity */
        /*lint -e{704} use shift for performance */
        temp = (temp * (EAS_I32)(pRegion->oper[operIndex].velocityRelease & 0xf0)) >> 7;

        /* include key scalar */
        temp -= ((EAS_I32) pVoice->note - KEY_SCALE_PIVOT_POINT) * (EAS_I32) fmScaleTable[pRegion->oper[operIndex].egKeyScale & 0x0f];

        /* saturate */
        temp = min(temp, 0);
        temp = max(temp, -32768);

        /* save static gain parameters */
        pFMVoice->oper[operIndex].baseGain = (EAS_I16) EAS_LogToLinear16(temp);

        /* incorporate key scaling on decay rate */
        pFMVoice->oper[operIndex].envRate = FM_CalcEGRate(
            pVoice->note,
            fmDecayTable[pRegion->oper[operIndex].attackDecay & 0x0f],
            fmScaleTable[pRegion->oper[operIndex].egKeyScale >> 4]);

        /* if zero attack time, max out envelope and jump to decay state */
        if ((pRegion->oper[operIndex].attackDecay & 0xf0) == 0xf0)
        {

            /* start out envelope at max */
            pFMVoice->oper[operIndex].envGain = 0x7fff;

            /* set envelope to decay state */
            pFMVoice->oper[operIndex].envState = eFMEnvelopeStateDecay;
        }

        /* start envelope at zero and start in attack state */
        else
        {
            pFMVoice->oper[operIndex].envGain = 0;
            pFMVoice->oper[operIndex].envState = eFMEnvelopeStateAttack;
        }
    }

    return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * FM_UpdateChannel()
 *----------------------------------------------------------------------------
 * Purpose:
 * Calculate and assign static channel parameters
 * These values only need to be updated if one of the controller values
 * for this channel changes.
 * Called when CHANNEL_FLAG_UPDATE_CHANNEL_PARAMETERS flag is set.
 *
 * Inputs:
 * nChannel - channel to update
 * psEASData - pointer to overall EAS data structure
 *
 * Outputs:
 *
 * Side Effects:
 * - the given channel's static gain and static pitch are updated
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pVoiceMgr) standard interface, pVoiceMgr not used */
static void FM_UpdateChannel (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, EAS_U8 channel)
{
    S_SYNTH_CHANNEL *pChannel;
    EAS_I32 temp;

    pChannel = &pSynth->channels[channel];

    /* convert CC7 volume controller to log scale */
    temp = fmControlTable[pChannel->volume];

    /* incorporate CC11 expression controller */
    temp += fmControlTable[pChannel->expression];

    /* saturate */
    pChannel->staticGain = (EAS_I16) max(temp,-32768);

    /* calculate pitch bend */
    /*lint -e{703} <avoid multiply for performance>*/
    temp = (((EAS_I32)(pChannel->pitchBend) << 2) - 32768);

    temp = FMUL_15x15(temp, pChannel->pitchBendSensitivity);

    /* include "magic number" compensation for sample rate and lookup table size */
    temp += MAGIC_NUMBER;

    /* if this is not a drum channel, then add in the per-channel tuning */
    if (!(pChannel->channelFlags & CHANNEL_FLAG_RHYTHM_CHANNEL))
        temp += (pChannel->finePitch + (pChannel->coarsePitch * 100));

    /* save static pitch */
    pChannel->staticPitch = temp;

    /* Calculate LFO modulation depth */
    /* mod wheel to LFO depth */
    temp = FMUL_15x15(DEFAULT_LFO_MOD_WHEEL_TO_PITCH_CENTS,
    pChannel->modWheel << (NUM_EG1_FRAC_BITS -7));

    /* channel pressure to LFO depth */
    pChannel->lfoAmt = (EAS_I16) (temp +
    FMUL_15x15(DEFAULT_LFO_CHANNEL_PRESSURE_TO_PITCH_CENTS,
    pChannel->channelPressure << (NUM_EG1_FRAC_BITS -7)));

    /* clear update flag */
    pChannel->channelFlags &= ~CHANNEL_FLAG_UPDATE_CHANNEL_PARAMETERS;
    return;
}

/*----------------------------------------------------------------------------
 * FM_UpdateLFO()
 *----------------------------------------------------------------------------
 * Purpose:
 * Calculate the LFO for the given voice
 *
 * Inputs:
 * pVoice - ptr to the voice whose LFO we want to update
 * psEASData - pointer to overall EAS data structure - used for debug only
 *
 * Outputs:
 *
 * Side Effects:
 * - updates LFO values for the given voice
 *----------------------------------------------------------------------------
*/
static void FM_UpdateLFO (S_FM_VOICE *pFMVoice, const S_FM_REGION *pRegion)
{

    /* increment the LFO phase if the delay time has elapsed */
    if (!pFMVoice->lfoDelay)
    {
        /*lint -e{701} <use shift for performance> */
        pFMVoice->lfoPhase = pFMVoice->lfoPhase + (EAS_U16) (-fmControlTable[((15 - (pRegion->lfoFreqDelay >> 4)) << 3) + 4]);

        /* square wave LFO? */
        if (pRegion->region.keyGroupAndFlags & REGION_FLAG_SQUARE_WAVE)
            pFMVoice->lfoValue = (EAS_I16)(pFMVoice->lfoPhase & 0x8000 ? -32767 : 32767);

        /* trick to get a triangle wave out of a sawtooth */
        else
        {
            pFMVoice->lfoValue = (EAS_I16) (pFMVoice->lfoPhase << 1);
            /*lint -e{502} <shortcut to turn sawtooth into sine wave> */
            if ((pFMVoice->lfoPhase > 0x3fff) && (pFMVoice->lfoPhase < 0xC000))
                pFMVoice->lfoValue = ~pFMVoice->lfoValue;
        }
    }

    /* still in delay */
    else
        pFMVoice->lfoDelay--;

    return;
}

/*----------------------------------------------------------------------------
 * FM_UpdateEG()
 *----------------------------------------------------------------------------
 * Purpose:
 * Calculate the synthesis parameters for an operator to be used during
 * the next buffer
 *
 * Inputs:
 * pVoice - pointer to the voice being updated
 * psEASData - pointer to overall EAS data structure
 *
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_BOOL FM_UpdateEG (S_SYNTH_VOICE *pVoice, S_OPERATOR *pOper, const S_FM_OPER *pOperData, EAS_BOOL oneShot)
{
    EAS_U32 temp;
    EAS_BOOL done;

    /* set flag assuming the envelope is not done */
    done = EAS_FALSE;

    /* take appropriate action based on state */
    switch (pOper->envState)
    {

        case eFMEnvelopeStateAttack:

            /* the envelope is linear during the attack, so add the value */
            temp = pOper->envGain + fmAttackTable[pOperData->attackDecay >> 4];

            /* check for end of attack */
            if (temp >= 0x7fff)
            {
                pOper->envGain = 0x7fff;
                pOper->envState = eFMEnvelopeStateDecay;
            }
            else
                pOper->envGain = (EAS_U16) temp;
            break;

        case eFMEnvelopeStateDecay:

            /* decay is exponential, multiply by decay rate */
            pOper->envGain = (EAS_U16) FMUL_15x15(pOper->envGain, pOper->envRate);

            /* check for sustain level reached */
            temp = (EAS_U32) (pOperData->sustain & 0xfc) << 7;
            if (pOper->envGain <= (EAS_U16) temp)
            {
                /* if this is a one-shot patch, go directly to release phase */
                if (oneShot)
                {
                    pOper->envRate = FM_CalcEGRate(
                    pVoice->note,
                    fmReleaseTable[pOperData->velocityRelease & 0x0f],
                    fmScaleTable[pOperData->egKeyScale >> 4]);
                    pOper->envState = eFMEnvelopeStateRelease;
                }

                /* normal sustaining type */
                else
                {
                    pOper->envGain = (EAS_U16) temp;
                    pOper->envState = eFMEnvelopeStateSustain;
                }
            }
            break;

        case eFMEnvelopeStateSustain:
            pOper->envGain = (EAS_U16)((EAS_U16)(pOperData->sustain & 0xfc) << 7);
            break;

        case eFMEnvelopeStateRelease:

            /* release is exponential, multiply by release rate */
            pOper->envGain = (EAS_U16) FMUL_15x15(pOper->envGain, pOper->envRate);

            /* fully released */
            if (pOper->envGain == 0)
            {
                pOper->envGain = 0;
                pOper->envState = eFMEnvelopeStateMuted;
                done = EAS_TRUE;
            }
            break;

        case eFMEnvelopeStateMuted:
            pOper->envGain = 0;
            done = EAS_TRUE;
            break;
        default:
            { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL,"Invalid operator state: %d", pOper->envState); */ }
    } /* end switch (pOper->m_eState) */

    return done;
}

/*----------------------------------------------------------------------------
 * FM_UpdateDynamic()
 *----------------------------------------------------------------------------
 * Purpose:
 * Calculate the synthesis parameters for this voice that will be used to
 * synthesize the next buffer
 *
 * Inputs:
 * pVoice - pointer to the voice being updated
 * psEASData - pointer to overall EAS data structure
 *
 * Outputs:
 * Returns EAS_TRUE if voice will be fully ramped to zero at the end of
 * the next synthesized buffer.
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_BOOL FM_UpdateDynamic (S_SYNTH_VOICE *pVoice, S_FM_VOICE *pFMVoice, const S_FM_REGION *pRegion, S_SYNTH_CHANNEL *pChannel)
{
    EAS_I32 temp;
    EAS_I32 pitch;
    EAS_I32 lfoPitch;
    EAS_INT operIndex;
    EAS_BOOL done;

    /* increment LFO phase */
    FM_UpdateLFO(pFMVoice, pRegion);

    /* base pitch in cents */
    pitch = pVoice->note * 100;

    /* LFO amount includes LFO depth from programming + channel dynamics */
    temp = (fmScaleTable[pRegion->vibTrem >> 4] >> 1) + pChannel->lfoAmt;

    /* multiply by LFO output to get final pitch modulation */
    lfoPitch = FMUL_15x15(pFMVoice->lfoValue, temp);

    /* flag to indicate this voice is done */
    done = EAS_TRUE;

    /* iterate through operators to establish parameters */
    for (operIndex = 0; operIndex < 4; operIndex++)
    {
        EAS_BOOL bTemp;

        /* set base phase increment for each operator */
        temp = pRegion->oper[operIndex].tuning +
        pChannel->staticPitch;

        /* add vibrato effect unless it is disabled for this operator */
        if ((pRegion->oper[operIndex].flags & FM_OPER_FLAG_NO_VIBRATO) == 0)
            temp += lfoPitch;

        /* if note is monotonic, bias to MIDI note 60 */
        if (pRegion->oper[operIndex].flags & FM_OPER_FLAG_MONOTONE)
            temp += 6000;
        else
            temp += pitch;
        pFMVoice->oper[operIndex].pitch = (EAS_I16) temp;

        /* calculate envelope, returns true if done */
        bTemp = FM_UpdateEG(pVoice, &pFMVoice->oper[operIndex], &pRegion->oper[operIndex], pRegion->region.keyGroupAndFlags & REGION_FLAG_ONE_SHOT);

        /* check if all output envelopes have completed */
        if (FM_SynthIsOutputOperator(pRegion, operIndex))
            done = done && bTemp;
    }

    return done;
}

/*----------------------------------------------------------------------------
 * FM_UpdateVoice()
 *----------------------------------------------------------------------------
 * Purpose:
 * Synthesize a block of samples for the given voice.
 *
 * Inputs:
 * psEASData - pointer to overall EAS data structure
 *
 * Outputs:
 * number of samples actually written to buffer
 *
 * Side Effects:
 * - samples are added to the presently free buffer
 *
 *----------------------------------------------------------------------------
*/
static EAS_BOOL FM_UpdateVoice (S_VOICE_MGR *pVoiceMgr, S_SYNTH *pSynth, S_SYNTH_VOICE *pVoice, EAS_I32 voiceNum, EAS_I32 *pMixBuffer, EAS_I32 numSamples)
{
    S_SYNTH_CHANNEL *pChannel;
    const S_FM_REGION *pRegion;
    S_FM_VOICE *pFMVoice;
    S_FM_VOICE_CONFIG vCfg;
    S_FM_VOICE_FRAME vFrame;
    EAS_I32 temp;
    EAS_INT oper;
    EAS_U16 voiceGainTarget;
    EAS_BOOL done;

    /* setup some pointers */
    pChannel = GetChannelPtr(pSynth, pVoice);
    pRegion = GetFMRegionPtr(pSynth, pVoice);
    pFMVoice = GetFMVoicePtr(pVoiceMgr, voiceNum);

    /* if the voice is just starting, get the voice configuration data */
    if (pVoice->voiceFlags & VOICE_FLAG_NO_SAMPLES_SYNTHESIZED_YET)
    {

        /* split architecture may limit the number of voice starts */
#ifdef MAX_VOICE_STARTS
        if (pVoiceMgr->numVoiceStarts == MAX_VOICE_STARTS)
            return EAS_FALSE;
        pVoiceMgr->numVoiceStarts++;
#endif

        /* get initial parameters */
        vCfg.feedback = pRegion->feedback;
        vCfg.voiceGain = (EAS_U16) pFMVoice->voiceGain;

#if (NUM_OUTPUT_CHANNELS == 2)
        vCfg.pan = pFMVoice->pan;
#endif

        /* get voice mode */
        vCfg.flags = pRegion->region.keyGroupAndFlags & 7;

        /* get operator parameters */
        for (oper = 0; oper < 4; oper++)
        {
            /* calculate initial gain */
            vCfg.gain[oper] = (EAS_U16) FMUL_15x15(pFMVoice->oper[oper].baseGain, pFMVoice->oper[oper].envGain);
            vCfg.outputGain[oper] = pFMVoice->oper[oper].outputGain;

            /* copy noise waveform flag */
            if (pRegion->oper[oper].flags & FM_OPER_FLAG_NOISE)
                vCfg.flags |= (EAS_U8) (FLAG_FM_ENG_VOICE_OP1_NOISE << oper);
        }

#ifdef FM_OFFBOARD
        FM_ConfigVoice(voiceNum, &vCfg, pVoiceMgr->pFrameBuffer);
#else
        FM_ConfigVoice(voiceNum, &vCfg, NULL);
#endif

        /* clear startup flag */
        pVoice->voiceFlags &= ~VOICE_FLAG_NO_SAMPLES_SYNTHESIZED_YET;
    }

    /* calculate new synthesis parameters */
    done = FM_UpdateDynamic(pVoice, pFMVoice, pRegion, pChannel);

    /* calculate LFO gain modulation */
    /*lint -e{702} <use shift for performance> */
    temp = ((fmScaleTable[pRegion->vibTrem & 0x0f] >> 1) * pFMVoice->lfoValue) >> FM_LFO_GAIN_SHIFT;

    /* include channel gain */
    temp += pChannel->staticGain;

    /* -32768 or lower is infinite attenuation */
    if (temp < -32767)
        voiceGainTarget = 0;

    /* translate to linear gain multiplier */
    else
        voiceGainTarget = EAS_LogToLinear16(temp);

    /* include synth master volume */
    voiceGainTarget = (EAS_U16) FMUL_15x15(voiceGainTarget, pSynth->masterVolume);

    /* save target values for this frame */
    vFrame.voiceGain = voiceGainTarget;

    /* assume voice output is zero */
    pVoice->gain = 0;

    /* save operator targets for this frame */
    for (oper = 0; oper < 4; oper++)
    {
        vFrame.gain[oper] = (EAS_U16) FMUL_15x15(pFMVoice->oper[oper].baseGain, pFMVoice->oper[oper].envGain);
        vFrame.pitch[oper] = pFMVoice->oper[oper].pitch;

        /* use the highest output envelope level as the gain for the voice stealing algorithm */
        if (FM_SynthIsOutputOperator(pRegion, oper))
            pVoice->gain = max(pVoice->gain, (EAS_I16) vFrame.gain[oper]);
    }

    /* consider voice gain multiplier in calculating gain for stealing algorithm */
    pVoice->gain = (EAS_I16) FMUL_15x15(voiceGainTarget, pVoice->gain);

    /* synthesize samples */
#ifdef FM_OFFBOARD
    FM_ProcessVoice(voiceNum, &vFrame, numSamples, pVoiceMgr->operMixBuffer, pVoiceMgr->voiceBuffer, pMixBuffer, pVoiceMgr->pFrameBuffer);
#else
    FM_ProcessVoice(voiceNum, &vFrame, numSamples, pVoiceMgr->operMixBuffer, pVoiceMgr->voiceBuffer, pMixBuffer, NULL);
#endif

    return done;
}