voice.c File Reference

Go to the source code of this file.

Functions
void	au_flush_finished_voices (AuGlobals *globals)
	(UNUSED) Immediately flush all voices which have finished playing.
void	au_init_voices (AuGlobals *globals)
	Initializes all voices in the audio system.
void	au_update_voices (AuGlobals *globals)
	Main envelope system update, called once per frame.
void	au_voice_after_volume_change (AuVoice *voice)
	Applies volume update after a client-side volume change.
s32	au_voice_get_delta (s32 usecs)
	Converts envelope step duration from microseconds to num samples delta.
void	au_voice_start (AuVoice *voice, EnvelopeData *envData)
	Starts a new voice with the given envelope data.
u8	au_voice_step (AuVoice *voice)
	Parses and executes envelope commands until a time interval is found.
void	au_voice_set_vol_changed (AuVoice *voice)
	(UNUSED) Force recalculation of voice envelope volume during next update.

Function Documentation

au_flush_finished_voices()

void au_flush_finished_voices

(

AuGlobals *

globals

)

(UNUSED) Immediately flush all voices which have finished playing.

These are normally released automatically during the start of each audio frame.

Definition at line 4 of file voice.c.

                                                  {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(globals->voices); i++) {
        AuVoice* voice = &globals->voices[i];
 
        if (voice->donePending) {
            au_syn_stop_voice(i);
            voice->donePending = FALSE;
            voice->cmdPtr = NULL;
            voice->priority = AU_PRIORITY_FREE;
        }
    }
}

au_init_voices()

void au_init_voices

(

AuGlobals *

globals

)

Initializes all voices in the audio system.

Sets default values and clears previous envelope state.

Definition at line 19 of file voice.c.

                                        {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(globals->voices); i++) {
        AuVoice* voice = &globals->voices[i];
 
        voice->cmdPtr = NULL;
        voice->unused_20 = 0;
        voice->envDuration = 0;
        voice->envTimeLeft = 0;
        voice->envIntervalIndex = 0;
        voice->unused_3C = 0;
        voice->envelopeFlags = 0;
        voice->isRelativeRelease = FALSE;
        voice->envRelativeStart = ENV_VOL_MAX;
    }
}

Referenced by au_engine_init().

au_update_voices()

void au_update_voices

(

AuGlobals *

globals

)

Main envelope system update, called once per frame.

Progresses envelope state for all active voices.

Definition at line 37 of file voice.c.

                                          {
    AuVoice* voice;
    s16 current;
    s8 temp;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(globals->voices); i++) {
        voice = &globals->voices[i];
 
        // skip inactive voices
        if (voice->cmdPtr == NULL) {
            continue;
        }
 
        if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE) {
            // client volume changed on previous frame
            au_voice_after_volume_change(voice);
            continue;
        }
 
        if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_KEY_RELEASED) {
            // client released the key
            voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_KEY_RELEASED;
            voice->envelopeFlags |= AU_VOICE_ENV_FLAG_RELEASING;
            voice->cmdPtr = (u8*)voice->envelope.cmdListRelease;
 
            // the key can be released before the press envelope is complete
            if (voice->envTimeLeft > AU_FRAME_USEC) {
                // get interpolated "current" value
                voice->envInitial += (s32) (voice->envDelta * (f32) (voice->envDuration - voice->envTimeLeft));
            } else {
                voice->envInitial = voice->envTarget;
            }
 
            // read the first interval of the release envelope
            voice->envIntervalIndex = *voice->cmdPtr++;
            temp = *voice->cmdPtr;
            if (*(s8*)voice->cmdPtr++ < 0) {
                // in this case release volumes are relative to last press volume
                temp &= 0x7F;
                voice->isRelativeRelease = TRUE;
                voice->envRelativeStart = voice->envInitial;
            }
            voice->envTarget = temp;
            voice->envTimeLeft = AuEnvelopeIntervals[voice->envIntervalIndex];
            voice->envDuration = voice->envTimeLeft;
 
            if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_VOL_CHANGED) {
                voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_VOL_CHANGED;
                if (voice->envTimeLeft > AU_FRAME_USEC) {
                    voice->envTimeLeft -= AU_FRAME_USEC;
                    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE;
                    current = voice->envInitial + (s32) (voice->envDelta * (voice->envDuration - voice->envTimeLeft));
                } else {
                    current = voice->envTarget;
                }
                voice->delta = AUDIO_SAMPLES;
            } else {
                voice->delta = au_voice_get_delta(voice->envDuration);
                current = voice->envTarget;
            }
            voice->volume = VOL_MULT_4(current, voice->clientVolume, voice->envRelativeStart, voice->envScale);
            voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
        } else {
            if (voice->envTimeLeft == -1) {
                // keep current volume, this is 'sustain' phase
                if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_VOL_CHANGED) {
                    voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_VOL_CHANGED;
                    voice->volume = VOL_MULT_4(voice->envInitial, voice->clientVolume, voice->envRelativeStart, voice->envScale);
                    voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
                }
            } else {
                voice->envTimeLeft -= AU_FRAME_USEC;
                if (voice->envTimeLeft <= 0) {
                    if (*voice->cmdPtr == ENV_CMD_END) {
                        if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_RELEASING) {
                            // if we reached the end after key release, stop the voice completely
                            voice->envelopeFlags = 0;
                            voice->cmdPtr = NULL;
                            voice->donePending = TRUE;
                        } else {
                            // we reached the end of press cmdlist, keep the last volume until the key is released
                            voice->envTimeLeft = -1;
                            voice->envDuration = -1;
                            voice->envIntervalIndex = ENV_TIME_300MS; // doesn't seem to affect anything
                            voice->delta = AUDIO_SAMPLES;
                            voice->envDelta = 0.0f;
                            voice->envInitial = voice->envTarget;
                        }
                    } else {
                        // get next envelope point
                        voice->envIntervalIndex = au_voice_step(voice);
                        voice->envInitial = voice->envTarget;
                        voice->envTarget = (*voice->cmdPtr++) & 0x7F;
                        voice->envTimeLeft = AuEnvelopeIntervals[voice->envIntervalIndex];
                        voice->envDuration = voice->envTimeLeft;
                        if (voice->envDuration != 0) {
                            voice->envDelta = ((f32) voice->envTarget - (f32) voice->envInitial) / (f32) voice->envDuration;
                        } else {
                            voice->envDelta = 0.0f;
                        }
                        if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_VOL_CHANGED) {
                            voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_VOL_CHANGED;
                            if (voice->envTimeLeft > AU_FRAME_USEC) {
                                voice->envTimeLeft -= AU_FRAME_USEC;
                                voice->envelopeFlags |= AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE;
                                current = voice->envInitial + (s32) (voice->envDelta * (voice->envDuration - voice->envTimeLeft));
                            } else {
                                current = voice->envTarget;
                            }
                            voice->delta = AUDIO_SAMPLES;
                        } else {
                            voice->delta = au_voice_get_delta(voice->envDuration);
                            current = voice->envTarget;
                        }
                        voice->volume = VOL_MULT_4(current, voice->clientVolume, voice->envRelativeStart, voice->envScale);
                        voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
                    }
                } else {
                    // we are between two envelope points, do nothing, just handle client volume change
                    if (voice->envelopeFlags & AU_VOICE_ENV_FLAG_VOL_CHANGED) {
                        voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_VOL_CHANGED;
                        if (voice->envTimeLeft > AU_FRAME_USEC) {
                            voice->envTimeLeft -= AU_FRAME_USEC;
                            voice->envelopeFlags |= AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE;
                            current = voice->envInitial + (s32) (voice->envDelta * (voice->envDuration - voice->envTimeLeft));
                        } else {
                            current = voice->envTarget;
                        }
                        voice->delta = AUDIO_SAMPLES;
                        voice->volume = VOL_MULT_4(current, voice->clientVolume, voice->envRelativeStart, voice->envScale);
                        voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
                    }
                }
            }
        }
    }
}

Referenced by au_update_clients_for_audio_frame().

au_voice_after_volume_change()

void au_voice_after_volume_change

(

AuVoice *

voice

)

Applies volume update after a client-side volume change.

This is deferred to avoid modifying envelope state mid-step.

Definition at line 176 of file voice.c.

                                                  {
    voice->volume = VOL_MULT_4(voice->envTarget, voice->clientVolume, voice->envRelativeStart, voice->envScale);
    voice->delta = au_voice_get_delta(voice->envTimeLeft);
    voice->envelopeFlags &= ~AU_VOICE_ENV_FLAG_HANDLED_VOL_CHANGE;
    voice->syncFlags |= AU_VOICE_SYNC_FLAG_PARAMS;
}

Referenced by au_update_voices().

au_voice_get_delta()

s32 au_voice_get_delta

(

s32

usecs

)

Converts envelope step duration from microseconds to num samples delta.

Uses AU_FRAME_USEC as the base time slice, returning the number of audio samples corresponding to the provided duration.

Parameters

msecs

Time duration in microseconds.

Returns

Number of samples that should pass in this interval.

Definition at line 183 of file voice.c.

                                  {
    return (usecs / AU_FRAME_USEC) * AUDIO_SAMPLES;
}

Referenced by au_update_voices(), au_voice_after_volume_change(), and au_voice_start().

au_voice_start()

void au_voice_start	(	AuVoice *	voice,
		EnvelopeData *	envData )

Starts a new voice with the given envelope data.

Initializes envelope state and prepares the press phase for playback.

Parameters

voice	Pointer to the voice being started.
envData	Envelope command lists (press and release) to use.

Definition at line 187 of file voice.c.

                                                           {
    s32 intervalIndex;
 
    voice->envelope.cmdListPress = envData->cmdListPress;
    voice->cmdPtr = voice->envelope.cmdListPress;
    voice->envelope.cmdListRelease = envData->cmdListRelease;
    voice->envScale = ENV_VOL_MAX;
    voice->loopStart = NULL;
 
    intervalIndex = au_voice_step(voice);
    voice->envelopeFlags = 0;
    voice->envInitial = 0;
    voice->envTarget = *voice->cmdPtr++;
    voice->envIntervalIndex = intervalIndex;
    voice->envDuration = AuEnvelopeIntervals[intervalIndex];
    voice->envTimeLeft = voice->envDuration;
 
    voice->volume = VOL_MULT_3(voice->envTarget, voice->clientVolume, voice->envScale);
    voice->delta = au_voice_get_delta(voice->envDuration);
    if (voice->envDuration != 0) {
        voice->envDelta = ((f32) voice->envTarget - (f32) voice->envInitial) / voice->envDuration;
    } else {
        voice->envDelta = 0.0f;
    }
    voice->isRelativeRelease = FALSE;
    voice->envRelativeStart = ENV_VOL_MAX;
}

Referenced by au_syn_begin_audio_frame().

au_voice_step()

u8 au_voice_step

(

AuVoice *

voice

)

Parses and executes envelope commands until a time interval is found.

Commands include setting multipliers, loop control, etc.

Definition at line 215 of file voice.c.

                                 {
    u32 op;
    u8 arg;
 
    while (TRUE) {
        if ((s8)(op = *voice->cmdPtr++) >= 0) {
            break;
        }
        switch ((u8)op) {
            case ENV_CMD_SET_SCALE:
                arg = *voice->cmdPtr++;
                if (arg > ENV_VOL_MAX) {
                    arg = ENV_VOL_MAX;
                }
                voice->envScale = arg;
                break;
            case ENV_CMD_ADD_SCALE:
                voice->envScale += (s8) *voice->cmdPtr++;
                if (voice->envScale > ENV_VOL_MAX) {
                    voice->envScale = ENV_VOL_MAX;
                } else if (voice->envScale < 0) {
                    voice->envScale = 0;
                }
                break;
            case ENV_CMD_START_LOOP:
                voice->loopCounter = *voice->cmdPtr++; // 0 = infinite loop
                voice->loopStart = voice->cmdPtr;
                break;
            case ENV_CMD_END_LOOP:
                voice->cmdPtr++;
                if (voice->loopCounter == 0 || --voice->loopCounter != 0) {
                    voice->cmdPtr = voice->loopStart;
                }
                break;
            default:
                // unknown command, skip argument
                voice->cmdPtr++;
                break;
        }
    }
    return op;
}

Referenced by au_update_voices(), and au_voice_start().

au_voice_set_vol_changed()

void au_voice_set_vol_changed

(

AuVoice *

voice

)

(UNUSED) Force recalculation of voice envelope volume during next update.

Definition at line 258 of file voice.c.

                                              {
    voice->envelopeFlags |= AU_VOICE_ENV_FLAG_VOL_CHANGED;
}