diff --git a/include/audiothread_cmd.h b/include/audiothread_cmd.h new file mode 100644 index 0000000000..3ec2cdeba3 --- /dev/null +++ b/include/audiothread_cmd.h @@ -0,0 +1,537 @@ +#ifndef AUDIOTHREAD_CMD_H +#define AUDIOTHREAD_CMD_H + +/** + * Audio thread commands to safely transfer information/requests/data + * from the external graph thread to the internal audio thread + */ + +typedef enum { + // Channel Commands + /* 0x00 */ AUDIOCMD_OP_NOOP, + /* 0x01 */ AUDIOCMD_OP_CHANNEL_SET_VOL_SCALE, + /* 0x02 */ AUDIOCMD_OP_CHANNEL_SET_VOL, + /* 0x03 */ AUDIOCMD_OP_CHANNEL_SET_PAN, + /* 0x04 */ AUDIOCMD_OP_CHANNEL_SET_FREQ_SCALE, + /* 0x05 */ AUDIOCMD_OP_CHANNEL_SET_REVERB_VOLUME, + /* 0x06 */ AUDIOCMD_OP_CHANNEL_SET_IO, + /* 0x07 */ AUDIOCMD_OP_CHANNEL_SET_PAN_WEIGHT, + /* 0x08 */ AUDIOCMD_OP_CHANNEL_SET_MUTE, + /* 0x09 */ AUDIOCMD_OP_CHANNEL_SET_MUTE_BEHAVIOR, + /* 0x0A */ AUDIOCMD_OP_CHANNEL_SET_VIBRATO_DEPTH, + /* 0x0B */ AUDIOCMD_OP_CHANNEL_SET_VIBRATO_RATE, + /* 0x0C */ AUDIOCMD_OP_CHANNEL_SET_COMB_FILTER_SIZE, + /* 0x0D */ AUDIOCMD_OP_CHANNEL_SET_COMB_FILTER_GAIN, + /* 0x0E */ AUDIOCMD_OP_CHANNEL_SET_STEREO, + // SeqPlayer Commands + /* 0x41 */ AUDIOCMD_OP_SEQPLAYER_FADE_VOLUME_SCALE = 0x41, + /* 0x46 */ AUDIOCMD_OP_SEQPLAYER_SET_IO = 0x46, + /* 0x47 */ AUDIOCMD_OP_SEQPLAYER_SET_TEMPO, + /* 0x48 */ AUDIOCMD_OP_SEQPLAYER_SET_TRANSPOSITION, + /* 0x49 */ AUDIOCMD_OP_SEQPLAYER_CHANGE_TEMPO, + /* 0x4A */ AUDIOCMD_OP_SEQPLAYER_FADE_TO_SET_VOLUME, + /* 0x4B */ AUDIOCMD_OP_SEQPLAYER_FADE_TO_SCALED_VOLUME, + /* 0x4C */ AUDIOCMD_OP_SEQPLAYER_RESET_VOLUME, + /* 0x4D */ AUDIOCMD_OP_SEQPLAYER_SET_BEND, + /* 0x4E */ AUDIOCMD_OP_SEQPLAYER_CHANGE_TEMPO_SEQTICKS, + // Global Commands + /* 0x81 */ AUDIOCMD_OP_GLOBAL_SYNC_LOAD_SEQ_PARTS = 0x81, + /* 0x82 */ AUDIOCMD_OP_GLOBAL_INIT_SEQPLAYER, + /* 0x83 */ AUDIOCMD_OP_GLOBAL_DISABLE_SEQPLAYER, + /* 0x85 */ AUDIOCMD_OP_GLOBAL_INIT_SEQPLAYER_SKIP_TICKS = 0x85, + /* 0x90 */ AUDIOCMD_OP_GLOBAL_SET_CHANNEL_MASK = 0x90, + /* 0xE0 */ AUDIOCMD_OP_GLOBAL_SET_DRUM_FONT = 0xE0, + /* 0xE1 */ AUDIOCMD_OP_GLOBAL_SET_SFX_FONT, + /* 0xE2 */ AUDIOCMD_OP_GLOBAL_SET_INSTRUMENT_FONT, + /* 0xE3 */ AUDIOCMD_OP_GLOBAL_POP_PERSISTENT_CACHE, + /* 0xF0 */ AUDIOCMD_OP_GLOBAL_SET_SOUND_MODE = 0xF0, + /* 0xF1 */ AUDIOCMD_OP_GLOBAL_MUTE, + /* 0xF2 */ AUDIOCMD_OP_GLOBAL_UNMUTE, + /* 0xF3 */ AUDIOCMD_OP_GLOBAL_SYNC_LOAD_INSTRUMENT, + /* 0xF4 */ AUDIOCMD_OP_GLOBAL_ASYNC_LOAD_SAMPLE_BANK, + /* 0xF5 */ AUDIOCMD_OP_GLOBAL_ASYNC_LOAD_FONT, + /* 0xF6 */ AUDIOCMD_OP_GLOBAL_DISCARD_SEQ_FONTS, + /* 0xF8 */ AUDIOCMD_OP_GLOBAL_STOP_AUDIOCMDS = 0xF8, + /* 0xF9 */ AUDIOCMD_OP_GLOBAL_RESET_AUDIO_HEAP, + /* 0xFA */ AUDIOCMD_OP_GLOBAL_NOOP_1, // used but no code exists for it + /* 0xFB */ AUDIOCMD_OP_GLOBAL_SET_CUSTOM_UPDATE_FUNCTION, + /* 0xFC */ AUDIOCMD_OP_GLOBAL_ASYNC_LOAD_SEQ, + /* 0xFD */ AUDIOCMD_OP_GLOBAL_NOOP_2, // used but no code exists for it + /* 0xFE */ AUDIOCMD_OP_GLOBAL_DISABLE_ALL_SEQPLAYERS +} AudioThreadCmdOp; + +// Pass to a AUDIOCMD_CHANNEL_ command in place of a channelIndex to try and apply to all channels. +// Then uses `threadCmdChannelMask` to determine which channels to apply the command to. +#define AUDIOCMD_ALL_CHANNELS 0xFF + +// ==== Audio Thread Channel Commands ==== + +/** + * Set the volumeScale on a given channel + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param volumeScale (f32) the volume scale for the sequence. No change in volume is 1.0f + */ +#define AUDIOCMD_CHANNEL_SET_VOL_SCALE(seqPlayerIndex, channelIndex, volumeScale) \ + AudioThread_QueueCmdF32(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_VOL_SCALE, seqPlayerIndex, channelIndex, 0), \ + volumeScale) + +/** + * Set the volume on a given channel + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param volume (f32) the target volume for the sequence. Default volume is 1.0f + */ +#define AUDIOCMD_CHANNEL_SET_VOL(seqPlayerIndex, channelIndex, volume) \ + AudioThread_QueueCmdF32(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_VOL, seqPlayerIndex, channelIndex, 0), volume) + +/** + * Set the pan + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param pan (s8) the pan applied to the channel + */ +#define AUDIOCMD_CHANNEL_SET_PAN(seqPlayerIndex, channelIndex, pan) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_PAN, seqPlayerIndex, channelIndex, 0), pan) + +/** + * Set frequency scale + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param freqScale (f32) the scaling factor to shift the pitch. + */ +#define AUDIOCMD_CHANNEL_SET_FREQ_SCALE(seqPlayerIndex, channelIndex, freqScale) \ + AudioThread_QueueCmdF32(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_FREQ_SCALE, seqPlayerIndex, channelIndex, 0), \ + freqScale) + +/** + * Set reverb volume + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param reverbVolume (s8) volume to set the reverb to (dry/wet mix) + */ +#define AUDIOCMD_CHANNEL_SET_REVERB_VOLUME(seqPlayerIndex, channelIndex, reverbVolume) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_REVERB_VOLUME, seqPlayerIndex, channelIndex, 0), \ + reverbVolume) + +/** + * Write a value that can be read as input directly by the sequence itself. This will be set to the channel + * ioPort, which will only affect a single channel + * + * @param seqPlayerIndex the index of the seqPlayer to write the input to + * @param channelIndex the index of the channel to write the input to + * @param ioPort the index of the array to store the input-output value + * @param ioData (s8) the value that's written to the input-output array + */ +#define AUDIOCMD_CHANNEL_SET_IO(seqPlayerIndex, channelIndex, ioPort, ioData) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_IO, (seqPlayerIndex), (channelIndex), (ioPort)), \ + (ioData)) + +/** + * Set the proportion of pan that comes from the channel + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param panChannelWeight (s8) proportion of pan that comes from the channel. + * Set to 0 for layer-only, and 128 for channel-only. + * As the type used is `s8` and internally cast to u8 later, + * pass `-128` to produce 128, or just use 127 instead + */ +#define AUDIOCMD_CHANNEL_SET_PAN_WEIGHT(seqPlayerIndex, channelIndex, panChannelWeight) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_PAN_WEIGHT, seqPlayerIndex, channelIndex, 0), \ + panChannelWeight) + +/** + * Mute a specified channel. How a muted channel behaves will depend on channel mute flags + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param muted (s8) set true to mute + */ +#define AUDIOCMD_CHANNEL_SET_MUTE(seqPlayerIndex, channelIndex, muted) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_MUTE, seqPlayerIndex, channelIndex, 0), muted) + +/** + * Set the muteBehavior for a specified channel + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param muteBehavior (s8) Affected how a muted channel behaves. See `MUTE_BEHAVIOR_` macros + */ +#define AUDIOCMD_CHANNEL_SET_MUTE_BEHAVIOR(seqPlayerIndex, channelIndex, muteBehavior) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_MUTE_BEHAVIOR, seqPlayerIndex, channelIndex, 0), \ + muteBehavior) + +/** + * Set the vibrato depth (also called magnitude/amplitude/extent) + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param vibratoDepthTarget (s8) the vibrato depth scaled down by 1/8th + */ +#define AUDIOCMD_CHANNEL_SET_VIBRATO_DEPTH(seqPlayerIndex, channelIndex, vibratoDepthTarget) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_VIBRATO_DEPTH, seqPlayerIndex, channelIndex, 0), \ + vibratoDepthTarget) + +/** + * Set the vibrato rate (freq/pitch) + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param vibratoRateTarget (s8) the vibrato rate scaled down by 1/32nd + */ +#define AUDIOCMD_CHANNEL_SET_VIBRATO_RATE(seqPlayerIndex, channelIndex, vibratoRateTarget) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_VIBRATO_RATE, seqPlayerIndex, channelIndex, 0), \ + vibratoRateTarget) + +/** + * Set the comb filter size + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param combFilterSize (s8) delay number of sample bytes to offset and add back to itself + */ +#define AUDIOCMD_CHANNEL_SET_COMB_FILTER_SIZE(seqPlayerIndex, channelIndex, combFilterSize) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_COMB_FILTER_SIZE, seqPlayerIndex, channelIndex, 0), \ + combFilterSize) + +/** + * Set the comb filter gain + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param combFilterGain (u16) strength of the signal added back to itself + */ +#define AUDIOCMD_CHANNEL_SET_COMB_FILTER_GAIN(seqPlayerIndex, channelIndex, combFilterGain) \ + AudioThread_QueueCmdU16(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_COMB_FILTER_GAIN, seqPlayerIndex, channelIndex, 0), \ + combFilterGain) + +/** + * Set the stereo bits + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param channelIndex the index of the channel to modify + * @param stereoData (s8) bit-packed stereo information. See `StereoData` + */ +#define AUDIOCMD_CHANNEL_SET_STEREO(seqPlayerIndex, channelIndex, stereoData) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_CHANNEL_SET_STEREO, seqPlayerIndex, channelIndex, 0), stereoData) + +// ==== Audio Thread SeqPlayer Commands ==== + +/** + * Set the fade volume scale + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param fadeVolumeScale (f32) multiplicative scaling factor to apply to volume + */ +#define AUDIOCMD_SEQPLAYER_FADE_VOLUME_SCALE(seqPlayerIndex, fadeVolumeScale) \ + AudioThread_QueueCmdF32(AUDIO_MK_CMD(AUDIOCMD_OP_SEQPLAYER_FADE_VOLUME_SCALE, seqPlayerIndex, 0, 0), \ + fadeVolumeScale) + +/** + * Write a value that can be read as input directly by the sequence itself. This will be set to the global + * ioPort, which can affect the entire sequence + * + * @param seqPlayerIndex the index of the seqPlayer to write the input to + * @param ioPort the index of the array to store the input-output value + * @param ioData (s8) the value that's written to the input-output array + */ +#define AUDIOCMD_SEQPLAYER_SET_IO(seqPlayerIndex, ioPort, ioData) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_SEQPLAYER_SET_IO, seqPlayerIndex, 0, ioPort), ioData) + +/** + * Set the tempo (bpm) of a sequence on a given seqPlayer + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param tempo (s32) the tempo for the sequence, in bpm + */ +#define AUDIOCMD_SEQPLAYER_SET_TEMPO(seqPlayerIndex, tempo) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_SEQPLAYER_SET_TEMPO, seqPlayerIndex, 0, 0), tempo) + +/** + * Set the transposition + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param transposition (s8) the number of semitones to increase or decrease by for all notes on the seqPlayer + */ +#define AUDIOCMD_SEQPLAYER_SET_TRANSPOSITION(seqPlayerIndex, transposition) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_SEQPLAYER_SET_TRANSPOSITION, seqPlayerIndex, 0, 0), transposition) + +/** + * Set tempoChange in bpm + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param tempoChange (s32) difference in tempo to change, in bpm + */ +#define AUDIOCMD_SEQPLAYER_CHANGE_TEMPO(seqPlayerIndex, tempoChange) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_SEQPLAYER_CHANGE_TEMPO, seqPlayerIndex, 0, 0), tempoChange) + +/** + * Set tempoChange in seqTicks per minute + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param tempoChange (s32) difference in tempo to change, in seqTicks per minute + */ +#define AUDIOCMD_SEQPLAYER_CHANGE_TEMPO_SEQTICKS(seqPlayerIndex, tempoChange) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_SEQPLAYER_CHANGE_TEMPO_SEQTICKS, seqPlayerIndex, 0, 0), tempoChange) + +/** + * Fade the volume to the target volume requested in the command + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param fadeVolume target volume to fade to + * @param fadeTimer (s32) number of ticks to fade to `fadeVolume` + */ +#define AUDIOCMD_SEQPLAYER_FADE_TO_SET_VOLUME(seqPlayerIndex, fadeVolume, fadeTimer) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_SEQPLAYER_FADE_TO_SET_VOLUME, seqPlayerIndex, fadeVolume, 0), \ + fadeTimer) + +/** + * Fade the volume to the current volume scaled by a scale factor + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param fadeVolumeScale scaling factor to apply to volume to get the targetVolume + * @param fadeTimer (s32) number of ticks to fade to `targetVolume` + */ +#define AUDIOCMD_SEQPLAYER_FADE_TO_SCALED_VOLUME(seqPlayerIndex, fadeVolumeScale, fadeTimer) \ + AudioThread_QueueCmdS32( \ + AUDIO_MK_CMD(AUDIOCMD_OP_SEQPLAYER_FADE_TO_SCALED_VOLUME, seqPlayerIndex, fadeVolumeScale, 0), fadeTimer) + +/** + * Reset to the default volume of the seqPlayer + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param fadeTimer (s32) number of ticks to fade the sequence back to its default volume + */ +#define AUDIOCMD_SEQPLAYER_RESET_VOLUME(seqPlayerIndex, fadeTimer) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_SEQPLAYER_RESET_VOLUME, seqPlayerIndex, 0, 0), fadeTimer) + +/** + * Set the bend + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param bend (f32) ratio relative to 1.0f to scale channel frequencies by + */ +#define AUDIOCMD_SEQPLAYER_SET_BEND(seqPlayerIndex, bend) \ + AudioThread_QueueCmdF32(AUDIO_MK_CMD(AUDIOCMD_OP_SEQPLAYER_SET_BEND, seqPlayerIndex, 0, 0), bend) + +// ==== Audio Thread Global Commands ==== + +/** + * Synchronously load a sequence in parts + * + * @param seqId the id of the sequence to load, see `SeqId` + * @param flags set `& 1` to load the sequence, set `& 2` to load the soundfonts + */ +#define AUDIOCMD_GLOBAL_SYNC_LOAD_SEQ_PARTS(seqId, flags) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_SYNC_LOAD_SEQ_PARTS, 0, seqId, flags), 0) + +/** + * Synchronously initialize a sequence player + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param seqId the id of the sequence to play, see `SeqId` + * @param fadeInTimer (s32) number of ticks to fade in the sequence to the requested volume + */ +#define AUDIOCMD_GLOBAL_INIT_SEQPLAYER(seqPlayerIndex, seqId, fadeInTimer) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_INIT_SEQPLAYER, seqPlayerIndex, seqId, 0), fadeInTimer) + +/** + * Disable a sequence player + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param fadeOutTimer (s32) number of ticks to fade out the sequence + */ +#define AUDIOCMD_GLOBAL_DISABLE_SEQPLAYER(seqPlayerIndex, fadeOutTimer) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_DISABLE_SEQPLAYER, seqPlayerIndex, 0, 0), fadeOutTimer) + +/** + * Synchronously initialize a sequence player and skip ticks, + * allowing the sequence to start somewhere other than the beginning of the sequences + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param seqId the id of the sequence to play, see `SeqId` + * @param skipTicks (s32) number of ticks to skip before starting the sequence + */ +#define AUDIOCMD_GLOBAL_INIT_SEQPLAYER_SKIP_TICKS(seqPlayerIndex, seqId, skipTicks) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_INIT_SEQPLAYER_SKIP_TICKS, seqPlayerIndex, seqId, 0), \ + skipTicks) + +/** + * When processing an audio thread channel command on all channels, set which channels to process + * + * @param seqPlayerIndex the index of the seqPlayer to modify + * @param threadCmdChannelMask (u16) bitfield for 16 channels. Turn bit on to allow audio thread commands of type + * "Channel" to process that channel with `AUDIOCMD_ALL_CHANNELS` set. + */ +#define AUDIOCMD_GLOBAL_SET_CHANNEL_MASK(seqPlayerIndex, threadCmdChannelMask) \ + AudioThread_QueueCmdU16(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_SET_CHANNEL_MASK, seqPlayerIndex, 0, 0), \ + threadCmdChannelMask) + +/** + * Set a drum ptr within a soundfont + * + * @param fontId the id of the soundfont to set the drum in + * @param drumId the id of the drum to set + * @param drumPtr (s32) the ptr to the `Drum` struct + */ +#define AUDIOCMD_GLOBAL_SET_DRUM_FONT(fontId, drumId, drumPtr) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_SET_DRUM_FONT, fontId, drumId, 0), drumPtr) + +/** + * Set a soundeffect ptr within a soundfont + * + * @param fontId the id of the soundfont to set the sound effect in + * @param soundEffectId the id of the sound effect to set + * @param soundEffectPtr (s32) the ptr to the `SoundEffect` struct + */ +#define AUDIOCMD_GLOBAL_SET_SFX_FONT(fontId, soundEffectId, soundEffectPtr) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_SET_SFX_FONT, fontId, soundEffectId, 0), soundEffectPtr) + +/** + * Set an instrument ptr within a soundfont + * + * @param fontId the id of the soundfont to set the instrument in + * @param instId the id of the instrument to set + * @param instPtr (s32) the ptr to the `Instrument` struct + */ +#define AUDIOCMD_GLOBAL_SET_INSTRUMENT_FONT(fontId, instId, instPtr) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_SET_INSTRUMENT_FONT, fontId, instId, 0), instPtr) + +/** + * Pop the persistent cache of the specified table + * + * @param tableType (s32) see the `SampleBankTableType` enum + */ +#define AUDIOCMD_GLOBAL_POP_PERSISTENT_CACHE(tableType) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_POP_PERSISTENT_CACHE, 0, 0, 0), tableType) + +/** + * Change the sound mode of audio + * + * @param soundMode (s32) see the `SoundMode` enum + */ +#define AUDIOCMD_GLOBAL_SET_SOUND_MODE(soundMode) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_SET_SOUND_MODE, 0, 0, 0), soundMode) + +/** + * Mute all sequence players + */ +#define AUDIOCMD_GLOBAL_MUTE() \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_MUTE, 0, 0, 0), 0) + +/** + * Unmute all sequence players + * + * @param restartNotes (s32) if set to 1, then notes with the `MUTE_BEHAVIOR_STOP_SAMPLES` flag set + * are marked as finished for all seqPlayers + */ +#define AUDIOCMD_GLOBAL_UNMUTE(restartNotes) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_UNMUTE, 0, 0, 0), restartNotes) + +/** + * Synchronously load an instrument + * + * @param fontId the id of the soundfont to load + * @param instId If below 0x7F, the id of the instrument to use. If equal to 0x7F, load the drum using the drumId + * @param drumId the id of the drum to use + */ +#define AUDIOCMD_GLOBAL_SYNC_LOAD_INSTRUMENT(fontId, instId, drumId) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_SYNC_LOAD_INSTRUMENT, fontId, instId, drumId), 0) + +/** + * Asynchronously load a sample bank + * + * @param sampleBankId the id of the samplebank to load + * @param retData return data from `externalLoadQueue` + */ +#define AUDIOCMD_GLOBAL_ASYNC_LOAD_SAMPLE_BANK(sampleBankId, retData) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_ASYNC_LOAD_SAMPLE_BANK, sampleBankId, 0, retData), 0) + +/** + * Asynchronously load a font + * + * @param fontId the id of the soundfont to load + * @param retData return data from `externalLoadQueue` + */ +#define AUDIOCMD_GLOBAL_ASYNC_LOAD_FONT(fontId, retData) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_ASYNC_LOAD_FONT, fontId, 0, retData), 0) + +/** + * Discard sequence fonts + * + * @param seqId the id of the sequence to discard, see `SeqId` + */ +#define AUDIOCMD_GLOBAL_DISCARD_SEQ_FONTS(seqId) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_DISCARD_SEQ_FONTS, 0, seqId, 0), 0) + +/** + * Stop processing all audio thread commands + */ +#define AUDIOCMD_GLOBAL_STOP_AUDIOCMDS() \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_STOP_AUDIOCMDS, 0, 0, 0), 0) + +/** + * Reset Audio Heap + * + * @param specId (s32) index for the audio specifications to set high-level audio parameters + */ +#define AUDIOCMD_GLOBAL_RESET_AUDIO_HEAP(specId) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_RESET_AUDIO_HEAP, 0, 0, 0), specId) + +/** + * No Operation. No code exists for this OP + * + * @param arg0 No info + * @param arg1 No info + * @param arg2 No info + * @param data (s32) No info + */ +#define AUDIOCMD_GLOBAL_NOOP_1(arg0, arg1, arg2, data) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_NOOP_1, arg0, arg1, arg2), data) + +/** + * Set a custom function that runs every audio thread update, see `AudioCustomUpdateFunction` + * + * @param functionPtr (s32) address of the function to run once every audio frame + */ +#define AUDIOCMD_GLOBAL_SET_CUSTOM_UPDATE_FUNCTION(functionPtr) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_SET_CUSTOM_UPDATE_FUNCTION, 0, 0, 0), functionPtr) + +/** + * Asynchronously load a sequence + * + * @param seqId the id of the sequence to load, see `SeqId` + * @param retData return data from `externalLoadQueue` + */ +#define AUDIOCMD_GLOBAL_ASYNC_LOAD_SEQ(seqId, retData) \ + AudioThread_QueueCmdS8(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_ASYNC_LOAD_SEQ, seqId, 0, retData), 0) + +/** + * No Operation. No code exists for this OP + * + * @param arg0 No info + * @param arg1 No info + * @param arg2 No info + * @param data (s32) No info + */ +#define AUDIOCMD_GLOBAL_NOOP_2(arg0, arg1, arg2, data) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_NOOP_2, arg0, arg1, arg2), data) + +/** + * Disable all sequence players + * + * @param flags (s32) Set `& 1` to discard all sequences. + * + * @note Setting `& 3` will also only discard sampled notes, but the sequences are disabled anyway. + * Not setting `& 1` should make this command useless TODO: Test + */ +#define AUDIOCMD_GLOBAL_DISABLE_ALL_SEQPLAYERS(flags) \ + AudioThread_QueueCmdS32(AUDIO_MK_CMD(AUDIOCMD_OP_GLOBAL_DISABLE_ALL_SEQPLAYERS, 0, 0, 0), flags) + +#endif diff --git a/include/functions.h b/include/functions.h index fd6187141c..8305b94101 100644 --- a/include/functions.h +++ b/include/functions.h @@ -1536,20 +1536,22 @@ void AudioLoad_LoadPermanentSamples(void); void AudioLoad_ScriptLoad(s32 tableType, s32 id, s8* status); void AudioLoad_ProcessScriptLoads(void); void AudioLoad_InitScriptLoads(void); -AudioTask* func_800E4FE0(void); -void Audio_QueueCmdF32(u32 opArgs, f32 data); -void Audio_QueueCmdS32(u32 opArgs, s32 data); -void Audio_QueueCmdS8(u32 opArgs, s8 data); -void Audio_QueueCmdU16(u32 opArgs, u16 data); -s32 Audio_ScheduleProcessCmds(void); + +AudioTask* AudioThread_Update(void); +void AudioThread_QueueCmdF32(u32 opArgs, f32 data); +void AudioThread_QueueCmdS32(u32 opArgs, s32 data); +void AudioThread_QueueCmdS8(u32 opArgs, s8 data); +void AudioThread_QueueCmdU16(u32 opArgs, u16 data); +s32 AudioThread_ScheduleProcessCmds(void); u32 func_800E5E20(u32* out); -u8* func_800E5E84(s32 arg0, u32* arg1); +u8* AudioThread_GetFontsForSequence(s32 seqId, u32* outNumFonts); s32 func_800E5EDC(void); -s32 func_800E5F88(s32 resetPreloadID); -void Audio_PreNMIInternal(void); +s32 AudioThread_ResetAudioHeap(s32 specId); +void AudioThread_PreNMIInternal(void); s32 func_800E6680(void); -u32 Audio_NextRandom(void); -void Audio_InitMesgQueues(void); +u32 AudioThread_NextRandom(void); +void AudioThread_InitMesgQueues(void); + void Audio_InvalDCache(void* buf, s32 size); void Audio_WritebackDCache(void* buf, s32 size); s32 osAiSetNextBuffer(void*, u32); @@ -1616,8 +1618,8 @@ s32 AudioOcarina_MemoryGameNextNote(void); void AudioOcarina_PlayLongScarecrowSong(void); void AudioDebug_Draw(GfxPrint* printer); void AudioDebug_ScrPrt(const char* str, u16 num); -void func_800F3054(void); -void Audio_SetSfxProperties(u8 bankId, u8 entryIdx, u8 channelIdx); +void Audio_Update(void); +void Audio_SetSfxProperties(u8 bankId, u8 entryIdx, u8 channelIndex); void Audio_PlayCutsceneEffectsSequence(u8 csEffectType); void func_800F4010(Vec3f* pos, u16 sfxId, f32); void Audio_PlaySfxRandom(Vec3f* pos, u16 baseSfxId, u8 randLim); @@ -1680,8 +1682,8 @@ void Audio_InitSound(void); void func_800F7170(void); void func_800F71BC(s32 arg0); void Audio_SetSfxBanksMute(u16 muteMask); -void Audio_QueueSeqCmdMute(u8 channelIdx); -void Audio_ClearBGMMute(u8 channelIdx); +void Audio_QueueSeqCmdMute(u8 channelIndex); +void Audio_ClearBGMMute(u8 channelIndex); void Audio_PlaySfxGeneral(u16 sfxId, Vec3f* pos, u8 token, f32* freqScale, f32* vol, s8* reverbAdd); void Audio_ProcessSfxRequest(void); void Audio_ChooseActiveSfx(u8 bankId); diff --git a/include/seqcmd.h b/include/seqcmd.h index a2649b775f..f6c42b7014 100644 --- a/include/seqcmd.h +++ b/include/seqcmd.h @@ -10,10 +10,10 @@ typedef enum { /* 0x1 */ SEQCMD_OP_STOP_SEQUENCE, /* 0x2 */ SEQCMD_OP_QUEUE_SEQUENCE, /* 0x3 */ SEQCMD_OP_UNQUEUE_SEQUENCE, - /* 0x4 */ SEQCMD_OP_SET_PLAYER_VOLUME, - /* 0x5 */ SEQCMD_OP_SET_PLAYER_FREQ, + /* 0x4 */ SEQCMD_OP_SET_SEQPLAYER_VOLUME, + /* 0x5 */ SEQCMD_OP_SET_SEQPLAYER_FREQ, /* 0x6 */ SEQCMD_OP_SET_CHANNEL_VOLUME, - /* 0x7 */ SEQCMD_OP_SET_PLAYER_IO, + /* 0x7 */ SEQCMD_OP_SET_SEQPLAYER_IO, /* 0x8 */ SEQCMD_OP_SET_CHANNEL_IO, /* 0x9 */ SEQCMD_OP_SET_CHANNEL_IO_DISABLE_MASK, /* 0xA */ SEQCMD_OP_SET_CHANNEL_DISABLE_MASK, @@ -37,17 +37,17 @@ typedef enum { // Subset of `SEQCMD_OP_SETUP_CMD` typedef enum { - /* 0x0 */ SEQCMD_SUB_OP_SETUP_RESTORE_VOLUME, + /* 0x0 */ SEQCMD_SUB_OP_SETUP_RESTORE_SEQPLAYER_VOLUME, /* 0x1 */ SEQCMD_SUB_OP_SETUP_SEQ_UNQUEUE, /* 0x2 */ SEQCMD_SUB_OP_SETUP_RESTART_SEQ, /* 0x3 */ SEQCMD_SUB_OP_SETUP_TEMPO_SCALE, /* 0x4 */ SEQCMD_SUB_OP_SETUP_TEMPO_RESET, /* 0x5 */ SEQCMD_SUB_OP_SETUP_PLAY_SEQ, /* 0x6 */ SEQCMD_SUB_OP_SETUP_SET_FADE_TIMER, - /* 0x7 */ SEQCMD_SUB_OP_SETUP_RESTORE_VOLUME_IF_QUEUED, - /* 0x8 */ SEQCMD_SUB_OP_SETUP_RESTORE_VOLUME_WITH_SCALE_INDEX, + /* 0x7 */ SEQCMD_SUB_OP_SETUP_RESTORE_SEQPLAYER_VOLUME_IF_QUEUED, + /* 0x8 */ SEQCMD_SUB_OP_SETUP_RESTORE_SEQPLAYER_VOLUME_WITH_SCALE_INDEX, /* 0x9 */ SEQCMD_SUB_OP_SETUP_SET_CHANNEL_DISABLE_MASK, - /* 0xA */ SEQCMD_SUB_OP_SETUP_SET_PLAYER_FREQ, + /* 0xA */ SEQCMD_SUB_OP_SETUP_SET_SEQPLAYER_FREQ, /* 0xE */ SEQCMD_SUB_OP_SETUP_POP_PERSISTENT_CACHE = 0xE, /* 0xF */ SEQCMD_SUB_OP_SETUP_RESET_SETUP_CMDS } SeqCmdSetupCmdOp; @@ -64,13 +64,15 @@ typedef enum { * Play a sequence on a given seqPlayer * * @param seqPlayerIndex the index of the seqPlayer to play the sequence - * @param fadeInDuration duration the sequence will fade in over - * @param seqArg no effect: < 0x7F, skip ticks: = 0x7F, will not play: >= 0x80 (see note) + * @param fadeInDuration effect will depend on seqArg. See below + * @param seqArg no effect: < 0x7F, skip ahead: = 0x7F, will not play: >= 0x80 (see note) * @param seqId the id of the sequence to play, see `SeqId` * * @note seqArg will also be stored in gActiveSeqs.seqId, any check against that seqId must also include seqArg. - * seqArg = 0x7F will interpret the duration as the number of ticks to skip. - * seqArg >= 0x80 was intented to load a soundFont asynchronously but the code is unfinished (based on MM). + * seqArg < 0x7F: fade in the sequence over `fadeInDuration` in units of (1/30th) seconds + * seqArg = 0x7F: start the sequence immediately, but begins `fadeInDuration` number of second into the sequence. + * seqArg >= 0x80: no sequence will play. Intended to load a soundFont asynchronously but was only half implemented + * (inferred from MM). */ #define SEQCMD_PLAY_SEQUENCE(seqPlayerIndex, fadeInDuration, seqArg, seqId) \ Audio_QueueSeqCmd((SEQCMD_OP_PLAY_SEQUENCE << 28) | ((u8)(seqPlayerIndex) << 24) | ((u8)(fadeInDuration) << 16) | \ @@ -79,7 +81,7 @@ typedef enum { /** * Stop a sequence on a given seqPlayer * - * @param seqPlayerIndex the index of the seqPlayer to play the sequence + * @param seqPlayerIndex the index of the seqPlayer to stop the sequence * @param fadeOutDuration duration the sequence will fade out over * * @note the 0xFF in the command is not read from at all, but is common in all Stop SeqPlayer Commands @@ -125,8 +127,8 @@ typedef enum { * @param duration duration to transition to the volume * @param volume the target volume for the sequence. Ranged from 0-0xFF, with 0x7F mapping to 1.0f */ -#define SEQCMD_SET_PLAYER_VOLUME(seqPlayerIndex, duration, volume) \ - Audio_QueueSeqCmd((SEQCMD_OP_SET_PLAYER_VOLUME << 28) | ((u8)(seqPlayerIndex) << 24) | ((duration) << 16) | \ +#define SEQCMD_SET_SEQPLAYER_VOLUME(seqPlayerIndex, duration, volume) \ + Audio_QueueSeqCmd((SEQCMD_OP_SET_SEQPLAYER_VOLUME << 28) | ((u8)(seqPlayerIndex) << 24) | ((duration) << 16) | \ (volume)) /** @@ -139,8 +141,8 @@ typedef enum { * @note 2000 will double the frequency (raise an octave), 500 will halve the frequency (lower an octave). * Cannot be used with `SEQCMD_SET_CHANNEL_FREQ` as they will overwrite one another. */ -#define SEQCMD_SET_PLAYER_FREQ(seqPlayerIndex, duration, freqScale) \ - Audio_QueueSeqCmd((SEQCMD_OP_SET_PLAYER_FREQ << 28) | ((u8)(seqPlayerIndex) << 24) | ((duration) << 16) | \ +#define SEQCMD_SET_SEQPLAYER_FREQ(seqPlayerIndex, duration, freqScale) \ + Audio_QueueSeqCmd((SEQCMD_OP_SET_SEQPLAYER_FREQ << 28) | ((u8)(seqPlayerIndex) << 24) | ((duration) << 16) | \ (freqScale)) /** @@ -152,7 +154,7 @@ typedef enum { * @param freqScale the scaling factor to shift the pitch. Ranged from 0-0xFFF, with 1000 mapping to 1.0f * * @note a frequency of 2000 will double the frequency (raise an octave), 500 will halve the frequency (lower an octave). - * Cannot be used with `SEQCMD_SET_PLAYER_FREQ` as they will overwrite one another. + * Cannot be used with `SEQCMD_SET_SEQPLAYER_FREQ` as they will overwrite one another. */ #define SEQCMD_SET_CHANNEL_FREQ(seqPlayerIndex, channelIndex, duration, freqScale) \ Audio_QueueSeqCmd((SEQCMD_OP_SET_CHANNEL_FREQ << 28) | ((u8)(seqPlayerIndex) << 24) | ((duration) << 16) | \ @@ -175,15 +177,15 @@ typedef enum { * ioPort, which can affect the entire sequence. * * @param seqPlayerIndex the index of the seqPlayer to write the input to - * @param ioPort the index of the array to store the input-output value, + * @param ioPort the index of the array to store the input-output value * @param ioData the value s8 that's written to the input-output array * * @note Each seqPlayer has 8 global ioPorts indexed 0-7. * ioPort 0 and 1 are read-only-once, and will reset after being read by the sequence. * ioPort 2-7 can be read multiple times. */ -#define SEQCMD_SET_PLAYER_IO(seqPlayerIndex, ioPort, ioData) \ - Audio_QueueSeqCmd((SEQCMD_OP_SET_PLAYER_IO << 28) | ((u8)(seqPlayerIndex) << 24) | ((u8)(ioPort) << 16) | \ +#define SEQCMD_SET_SEQPLAYER_IO(seqPlayerIndex, ioPort, ioData) \ + Audio_QueueSeqCmd((SEQCMD_OP_SET_SEQPLAYER_IO << 28) | ((u8)(seqPlayerIndex) << 24) | ((u8)(ioPort) << 16) | \ (u8)(ioData)) /** @@ -209,7 +211,7 @@ typedef enum { * @param seqPlayerIndex the index of the seqPlayer to modify * @param channelMask a 16 bit mask where each bit maps to a channel. Bitflag on to disable * - * @note using Audio_QueueCmdS8 0x06 will bypass this channelMask + * @note using AUDIOCMD_CHANNEL_SET_IO will bypass this channelMask */ #define SEQCMD_SET_CHANNEL_IO_DISABLE_MASK(seqPlayerIndex, channelMask) \ Audio_QueueSeqCmd((SEQCMD_OP_SET_CHANNEL_IO_DISABLE_MASK << 28) | ((u8)(seqPlayerIndex) << 24) | (u16)(channelMask)) @@ -304,8 +306,8 @@ typedef enum { * @param targetSeqPlayerIndex the index of the seqPlayer to modify * @param duration duration to transition to the volume */ -#define SEQCMD_SETUP_RESTORE_PLAYER_VOLUME(setupSeqPlayerIndex, targetSeqPlayerIndex, duration) \ - Audio_QueueSeqCmd((SEQCMD_OP_SETUP_CMD << 28) | (SEQCMD_SUB_OP_SETUP_RESTORE_VOLUME << 20) | \ +#define SEQCMD_SETUP_RESTORE_SEQPLAYER_VOLUME(setupSeqPlayerIndex, targetSeqPlayerIndex, duration) \ + Audio_QueueSeqCmd((SEQCMD_OP_SETUP_CMD << 28) | (SEQCMD_SUB_OP_SETUP_RESTORE_SEQPLAYER_VOLUME << 20) | \ ((u8)(setupSeqPlayerIndex) << 24) | ((u8)(targetSeqPlayerIndex) << 16) | (u8)(duration)) /** @@ -394,9 +396,9 @@ typedef enum { * @param duration duration to transition to the volume * @param numSeqRequests the number of sequence requests queued that must match the actual number of sequence requests */ -#define SEQCMD_SETUP_RESTORE_PLAYER_VOLUME_IF_QUEUED(setupSeqPlayerIndex, targetSeqPlayerIndex, duration, \ - numSeqRequests) \ - Audio_QueueSeqCmd((SEQCMD_OP_SETUP_CMD << 28) | (SEQCMD_SUB_OP_SETUP_RESTORE_VOLUME_IF_QUEUED << 20) | \ +#define SEQCMD_SETUP_RESTORE_SEQPLAYER_VOLUME_IF_QUEUED(setupSeqPlayerIndex, targetSeqPlayerIndex, duration, \ + numSeqRequests) \ + Audio_QueueSeqCmd((SEQCMD_OP_SETUP_CMD << 28) | (SEQCMD_SUB_OP_SETUP_RESTORE_SEQPLAYER_VOLUME_IF_QUEUED << 20) | \ ((u8)(setupSeqPlayerIndex) << 24) | ((u8)(targetSeqPlayerIndex) << 16) | ((u8)(duration) << 8) | \ (u8)(numSeqRequests)) @@ -409,9 +411,11 @@ typedef enum { * @param scaleIndex the scale index of a seqPlayer * @param duration duration to transition to the volume */ -#define SEQCMD_SETUP_RESTORE_PLAYER_VOLUME_WITH_SCALE_INDEX(setupSeqPlayerIndex, targetSeqPlayerIndex, scaleIndex, duration) \ - Audio_QueueSeqCmd((SEQCMD_OP_SETUP_CMD << 28) | (SEQCMD_SUB_OP_SETUP_RESTORE_VOLUME_WITH_SCALE_INDEX << 20) | \ - ((u8)(setupSeqPlayerIndex) << 24) | ((u8)(targetSeqPlayerIndex) << 16) | \ +#define SEQCMD_SETUP_RESTORE_SEQPLAYER_VOLUME_WITH_SCALE_INDEX(setupSeqPlayerIndex, targetSeqPlayerIndex, scaleIndex, \ + duration) \ + Audio_QueueSeqCmd((SEQCMD_OP_SETUP_CMD << 28) | \ + (SEQCMD_SUB_OP_SETUP_RESTORE_SEQPLAYER_VOLUME_WITH_SCALE_INDEX << 20) | \ + ((u8)(setupSeqPlayerIndex) << 24) | ((u8)(targetSeqPlayerIndex) << 16) | \ ((u8)(scaleIndex) << 8) | (u8)(duration)) /** @@ -438,8 +442,8 @@ typedef enum { * @note The base value for frequency, 100, is 10 times smaller than other frequency commands. * 200 will double the frequency (raise an octave), 50 will halve the frequency (lower an octave). */ -#define SEQCMD_SETUP_SET_PLAYER_FREQ(setupSeqPlayerIndex, targetSeqPlayerIndex, duration, freqScale) \ - Audio_QueueSeqCmd((SEQCMD_OP_SETUP_CMD << 28) | (SEQCMD_SUB_OP_SETUP_SET_PLAYER_FREQ << 20) | \ +#define SEQCMD_SETUP_SET_SEQPLAYER_FREQ(setupSeqPlayerIndex, targetSeqPlayerIndex, duration, freqScale) \ + Audio_QueueSeqCmd((SEQCMD_OP_SETUP_CMD << 28) | (SEQCMD_SUB_OP_SETUP_SET_SEQPLAYER_FREQ << 20) | \ ((u8)(setupSeqPlayerIndex) << 24) | ((u8)(targetSeqPlayerIndex) << 16) | ((u8)(duration) << 8) | \ (u8)(freqScale)) diff --git a/include/sfx.h b/include/sfx.h index e008d13720..d5545af8d6 100644 --- a/include/sfx.h +++ b/include/sfx.h @@ -21,24 +21,24 @@ typedef enum { } SfxState; typedef struct { - /* 0x00 */ f32* posX; - /* 0x04 */ f32* posY; - /* 0x08 */ f32* posZ; - /* 0x0C */ u8 token; - /* 0x10 */ f32* freqScale; - /* 0x14 */ f32* vol; - /* 0x18 */ s8* reverbAdd; - /* 0x1C */ f32 dist; - /* 0x20 */ u32 priority; // lower is more prioritized - /* 0x24 */ u8 sfxImportance; - /* 0x26 */ u16 sfxParams; - /* 0x28 */ u16 sfxId; - /* 0x2A */ u8 state; // uses SfxState enum - /* 0x2B */ u8 freshness; - /* 0x2C */ u8 prev; - /* 0x2D */ u8 next; - /* 0x2E */ u8 channelIdx; - /* 0x2F */ u8 unk_2F; + /* 0x00 */ f32* posX; + /* 0x04 */ f32* posY; + /* 0x08 */ f32* posZ; + /* 0x0C */ u8 token; + /* 0x10 */ f32* freqScale; + /* 0x14 */ f32* vol; + /* 0x18 */ s8* reverbAdd; + /* 0x1C */ f32 dist; + /* 0x20 */ u32 priority; // lower is more prioritized + /* 0x24 */ u8 sfxImportance; + /* 0x26 */ u16 sfxParams; + /* 0x28 */ u16 sfxId; + /* 0x2A */ u8 state; // uses SfxState enum + /* 0x2B */ u8 freshness; + /* 0x2C */ u8 prev; + /* 0x2D */ u8 next; + /* 0x2E */ u8 channelIndex; + /* 0x2F */ u8 unk_2F; } SfxBankEntry; // size = 0x30 /* diff --git a/include/variables.h b/include/variables.h index 12b8e734b7..922a3c15fb 100644 --- a/include/variables.h +++ b/include/variables.h @@ -157,8 +157,7 @@ extern s32 gSystemArenaLogSeverity; extern u8 __osPfsInodeCacheBank; extern s32 __osPfsLastChannel; -extern const s16 D_8014A6C0[]; -#define gTatumsPerBeat (D_8014A6C0[1]) +extern const TempoData gTempoData; extern const AudioHeapInitSizes gAudioHeapInitSizes; extern s16 gOcarinaSongItemMap[]; extern u8 gSoundFontTable[]; @@ -215,7 +214,7 @@ extern u16 gAudioSfxSwapTarget[10]; extern u8 gAudioSfxSwapMode[10]; extern ActiveSequence gActiveSeqs[4]; extern AudioContext gAudioCtx; -extern void(*D_801755D0)(void); +extern AudioCustomUpdateFunction gAudioCustomUpdateFunction; extern u32 __osMalloc_FreeBlockTest_Enable; extern Arena gSystemArena; diff --git a/include/z64.h b/include/z64.h index 976d932cce..0d8b37d843 100644 --- a/include/z64.h +++ b/include/z64.h @@ -38,6 +38,7 @@ #include "z64view.h" #include "z64vis.h" #include "alignment.h" +#include "audiothread_cmd.h" #include "seqcmd.h" #include "sequence.h" #include "sfx.h" diff --git a/include/z64audio.h b/include/z64audio.h index 7e6f4e40bf..1ec0f4a4d3 100644 --- a/include/z64audio.h +++ b/include/z64audio.h @@ -1,11 +1,25 @@ #ifndef Z64_AUDIO_H #define Z64_AUDIO_H -#define MK_CMD(b0,b1,b2,b3) ((((b0) & 0xFF) << 0x18) | (((b1) & 0xFF) << 0x10) | (((b2) & 0xFF) << 0x8) | (((b3) & 0xFF) << 0)) +typedef void (*AudioCustomUpdateFunction)(void); + + +#define REFRESH_RATE_PAL 50 +#define REFRESH_RATE_MPAL 60 +#define REFRESH_RATE_NTSC 60 + +// Small deviation parameters used in estimating the max tempo +// It is unclear why these vary by region, and aren't all just 1 +#define REFRESH_RATE_DEVIATION_PAL 1.001521f +#define REFRESH_RATE_DEVIATION_MPAL 0.99276f +#define REFRESH_RATE_DEVIATION_NTSC 1.00278f + +#define AUDIO_MK_CMD(b0,b1,b2,b3) ((((b0) & 0xFF) << 0x18) | (((b1) & 0xFF) << 0x10) | (((b2) & 0xFF) << 0x8) | (((b3) & 0xFF) << 0)) #define NO_LAYER ((SequenceLayer*)(-1)) -#define TATUMS_PER_BEAT 48 +// Also known as "Pulses Per Quarter Note" or "Tatums Per Beat" +#define SEQTICKS_PER_BEAT 48 #define IS_SEQUENCE_CHANNEL_VALID(ptr) ((u32)(ptr) != (u32)&gAudioCtx.sequenceChannelNone) #define SEQ_NUM_CHANNELS 16 @@ -297,12 +311,12 @@ typedef struct { /* 0x005 */ u8 defaultFont; /* 0x006 */ u8 unk_06[1]; /* 0x007 */ s8 playerIdx; - /* 0x008 */ u16 tempo; // tatums per minute - /* 0x00A */ u16 tempoAcc; - /* 0x00C */ u16 unk_0C; + /* 0x008 */ u16 tempo; // seqTicks per minute + /* 0x00A */ u16 tempoAcc; // tempo accumulation, used in a discretized algorithm to apply tempo. + /* 0x00C */ u16 tempoChange; // Used to adjust the tempo without altering the base tempo. /* 0x00E */ s16 transposition; /* 0x010 */ u16 delay; - /* 0x012 */ u16 fadeTimer; + /* 0x012 */ u16 fadeTimer; // in ticks /* 0x014 */ u16 fadeTimerUnkEu; /* 0x018 */ u8* seqData; /* 0x01C */ f32 fadeVolume; @@ -320,7 +334,7 @@ typedef struct { /* 0x0DC */ s32 skipTicks; /* 0x0E0 */ u32 scriptCounter; /* 0x0E4 */ char unk_E4[0x74]; // unused struct members for sequence/sound font dma management, according to sm64 decomp - /* 0x158 */ s8 soundScriptIO[8]; + /* 0x158 */ s8 seqScriptIO[8]; } SequencePlayer; // size = 0x160 typedef struct { @@ -332,7 +346,7 @@ typedef struct { typedef struct { /* 0x00 */ union { struct A { - /* 0x00 */ u8 unk_0b80 : 1; + /* 0x00 */ u8 unused : 1; /* 0x00 */ u8 hang : 1; /* 0x00 */ u8 decay : 1; /* 0x00 */ u8 release : 1; @@ -370,8 +384,8 @@ typedef struct { /* 0x01 */ u8 gain; // Increases volume by a multiplicative scaling factor. Represented as a UQ4.4 number /* 0x02 */ u8 pan; /* 0x03 */ Stereo stereo; - /* 0x04 */ u8 unk_4; - /* 0x06 */ u16 unk_6; + /* 0x04 */ u8 combFilterSize; + /* 0x06 */ u16 combFilterGain; /* 0x08 */ f32 freqScale; /* 0x0C */ f32 velocity; /* 0x10 */ s16* filter; @@ -383,7 +397,7 @@ typedef struct SequenceChannel { /* 0x00 */ u8 enabled : 1; /* 0x00 */ u8 finished : 1; /* 0x00 */ u8 stopScript : 1; - /* 0x00 */ u8 stopSomething2 : 1; // sets SequenceLayer.stopSomething + /* 0x00 */ u8 muted : 1; // sets SequenceLayer.muted /* 0x00 */ u8 hasInstrument : 1; /* 0x00 */ u8 stereoHeadsetEffects : 1; /* 0x00 */ u8 largeNotes : 1; // notes specify duration and velocity @@ -398,7 +412,7 @@ typedef struct SequenceChannel { } changes; /* 0x02 */ u8 noteAllocPolicy; /* 0x03 */ u8 muteBehavior; - /* 0x04 */ u8 reverb; // or dry/wet mix + /* 0x04 */ u8 targetReverbVol; /* 0x05 */ u8 notePriority; // 0-3 /* 0x06 */ u8 someOtherPriority; /* 0x07 */ u8 fontId; @@ -409,16 +423,16 @@ typedef struct SequenceChannel { /* 0x0C */ u8 gain; // Increases volume by a multiplicative scaling factor. Represented as a UQ4.4 number /* 0x0D */ u8 velocityRandomVariance; /* 0x0E */ u8 gateTimeRandomVariance; - /* 0x0F */ u8 unk_0F; + /* 0x0F */ u8 combFilterSize; /* 0x10 */ u16 vibratoRateStart; - /* 0x12 */ u16 vibratoExtentStart; + /* 0x12 */ u16 vibratoDepthStart; /* 0x14 */ u16 vibratoRateTarget; - /* 0x16 */ u16 vibratoExtentTarget; + /* 0x16 */ u16 vibratoDepthTarget; /* 0x18 */ u16 vibratoRateChangeDelay; - /* 0x1A */ u16 vibratoExtentChangeDelay; + /* 0x1A */ u16 vibratoDepthChangeDelay; /* 0x1C */ u16 vibratoDelay; /* 0x1E */ u16 delay; - /* 0x20 */ u16 unk_20; + /* 0x20 */ u16 combFilterGain; /* 0x22 */ u16 unk_22; /* 0x24 */ s16 instOrWave; // either 0 (none), instrument index + 1, or // 0x80..0x83 for sawtooth/triangle/sine/square waves. @@ -437,7 +451,7 @@ typedef struct SequenceChannel { /* 0x60 */ SeqScriptState scriptState; /* 0x7C */ AdsrSettings adsr; /* 0x84 */ NotePool notePool; - /* 0xC4 */ s8 soundScriptIO[8]; // bridge between sound script and audio lib, "io ports" + /* 0xC4 */ s8 seqScriptIO[8]; // bridge between .seq script and audio lib, "io ports" /* 0xCC */ s16* filter; /* 0xD0 */ Stereo stereo; } SequenceChannel; // size = 0xD4 @@ -446,7 +460,7 @@ typedef struct SequenceChannel { typedef struct SequenceLayer { /* 0x00 */ u8 enabled : 1; /* 0x00 */ u8 finished : 1; - /* 0x00 */ u8 stopSomething : 1; + /* 0x00 */ u8 muted : 1; /* 0x00 */ u8 continuousNotes : 1; // keep the same note for consecutive notes with the same sound /* 0x00 */ u8 bit3 : 1; // "loaded"? /* 0x00 */ u8 ignoreDrumPan : 1; @@ -490,7 +504,7 @@ typedef struct { /* 0x040 */ s16 mixEnvelopeState[32]; /* 0x080 */ s16 unusedState[16]; /* 0x0A0 */ s16 haasEffectDelayState[32]; - /* 0x0E0 */ s16 unkState[128]; + /* 0x0E0 */ s16 combFilterState[128]; } NoteSynthesisBuffers; // size = 0x1E0 typedef struct { @@ -505,23 +519,20 @@ typedef struct { /* 0x0C */ NoteSynthesisBuffers* synthesisBuffers; /* 0x10 */ s16 curVolLeft; /* 0x12 */ s16 curVolRight; - /* 0x14 */ u16 unk_14; - /* 0x16 */ u16 unk_16; - /* 0x18 */ u16 unk_18; - /* 0x1A */ u8 unk_1A; - /* 0x1C */ u16 unk_1C; - /* 0x1E */ u16 unk_1E; + /* 0x14 */ char unk_14[0x6]; + /* 0x1A */ u8 combFilterNeedsInit; + /* 0x1C */ char unk_1C[0x4]; } NoteSynthesisState; // size = 0x20 typedef struct { /* 0x00 */ struct SequenceChannel* channel; /* 0x04 */ u32 time; - /* 0x08 */ s16* curve; - /* 0x0C */ f32 extent; + /* 0x08 */ s16* curve; // sineWave + /* 0x0C */ f32 depth; /* 0x10 */ f32 rate; /* 0x14 */ u8 active; /* 0x16 */ u16 rateChangeTimer; - /* 0x18 */ u16 extentChangeTimer; + /* 0x18 */ u16 depthChangeTimer; /* 0x1A */ u16 delay; } VibratoState; // size = 0x1C @@ -567,11 +578,11 @@ typedef struct { /* 0x04 */ u8 haasEffectRightDelaySize; /* 0x05 */ u8 reverbVol; /* 0x06 */ u8 harmonicIndexCurAndPrev; // bits 3..2 store curHarmonicIndex, bits 1..0 store prevHarmonicIndex - /* 0x07 */ u8 unk_07; + /* 0x07 */ u8 combFilterSize; /* 0x08 */ u16 targetVolLeft; /* 0x0A */ u16 targetVolRight; /* 0x0C */ u16 resamplingRateFixedPoint; - /* 0x0E */ u16 unk_0E; + /* 0x0E */ u16 combFilterGain; /* 0x10 */ union { TunedSample* tunedSample; s16* waveSampleAddr; // used for synthetic waves @@ -642,15 +653,15 @@ typedef struct { /* 0x06 */ s16 samplesPerFrameTarget; /* 0x08 */ s16 maxAiBufferLength; /* 0x0A */ s16 minAiBufferLength; - /* 0x0C */ s16 updatesPerFrame; // for each frame of the audio thread (default 60 fps), number of updates to process audio - /* 0x0E */ s16 samplesPerUpdate; - /* 0x10 */ s16 samplesPerUpdateMax; - /* 0x12 */ s16 samplesPerUpdateMin; + /* 0x0C */ s16 ticksPerUpdate; // for each audio thread update, number of ticks to process audio + /* 0x0E */ s16 samplesPerTick; + /* 0x10 */ s16 samplesPerTickMax; + /* 0x12 */ s16 samplesPerTickMin; /* 0x14 */ s16 numSequencePlayers; /* 0x18 */ f32 resampleRate; - /* 0x1C */ f32 updatesPerFrameInv; // inverse (reciprocal) of updatesPerFrame - /* 0x20 */ f32 updatesPerFrameInvScaled; // updatesPerFrameInv scaled down by a factor of 256 - /* 0x24 */ f32 updatesPerFrameScaled; // updatesPerFrame scaled down by a factor of 4 + /* 0x1C */ f32 ticksPerUpdateInv; // inverse (reciprocal) of ticksPerUpdate + /* 0x20 */ f32 ticksPerUpdateInvScaled; // ticksPerUpdateInv scaled down by a factor of 256 + /* 0x24 */ f32 ticksPerUpdateScaled; // ticksPerUpdate scaled down by a factor of 4 } AudioBufferParameters; // size = 0x28 /** @@ -887,7 +898,7 @@ typedef struct { /* 0x288C */ s32 sampleDmaBufSize; /* 0x2890 */ s32 maxAudioCmds; /* 0x2894 */ s32 numNotes; - /* 0x2898 */ s16 tempoInternalToExternal; + /* 0x2898 */ s16 maxTempo; // Maximum possible tempo (seqTicks per minute), using every tick as a seqTick to process a .seq file /* 0x289A */ s8 soundMode; /* 0x289C */ s32 totalTaskCount; // The total number of times the top-level function on the audio thread has run since audio was initialized /* 0x28A0 */ s32 curAudioFrameDmaCount; @@ -898,7 +909,7 @@ typedef struct { /* 0x28B8 */ AudioTask* curTask; /* 0x28BC */ char unk_28BC[0x4]; /* 0x28C0 */ AudioTask rspTask[2]; - /* 0x2960 */ f32 unk_2960; + /* 0x2960 */ f32 maxTempoTvTypeFactors; // tvType factors that impact maxTempo, in units of milliseconds/frame /* 0x2964 */ s32 refreshRate; /* 0x2968 */ s16* aiBuffers[3]; /* 0x2974 */ s16 aiBufLengths[3]; @@ -929,7 +940,7 @@ typedef struct { /* 0x3468 */ u8 fontLoadStatus[0x30]; /* 0x3498 */ u8 seqLoadStatus[0x80]; /* 0x3518 */ volatile u8 resetStatus; - /* 0x3519 */ u8 audioResetSpecIdToLoad; + /* 0x3519 */ u8 specId; /* 0x351C */ s32 audioResetFadeOutFramesLeft; /* 0x3520 */ f32* adsrDecayTable; // A table on the audio heap that stores decay rates used for adsr /* 0x3524 */ u8* audioHeap; @@ -941,20 +952,20 @@ typedef struct { /* 0x5B84 */ s32 noteSubEuOffset; /* 0x5B88 */ AudioListItem layerFreeList; /* 0x5B98 */ NotePool noteFreeLists; - /* 0x5BD8 */ u8 cmdWrPos; - /* 0x5BD9 */ u8 cmdRdPos; - /* 0x5BDA */ u8 cmdQueueFinished; - /* 0x5BDC */ u16 unk_5BDC[4]; + /* 0x5BD8 */ u8 threadCmdWritePos; + /* 0x5BD9 */ u8 threadCmdReadPos; + /* 0x5BDA */ u8 threadCmdQueueFinished; + /* 0x5BDC */ u16 threadCmdChannelMask[4]; // bitfield for 16 channels. When processing an audio thread channel command on all channels, only process channels with their bit set. /* 0x5BE4 */ OSMesgQueue* audioResetQueueP; /* 0x5BE8 */ OSMesgQueue* taskStartQueueP; - /* 0x5BEC */ OSMesgQueue* cmdProcQueueP; + /* 0x5BEC */ OSMesgQueue* threadCmdProcQueueP; /* 0x5BF0 */ OSMesgQueue taskStartQueue; - /* 0x5C08 */ OSMesgQueue cmdProcQueue; + /* 0x5C08 */ OSMesgQueue threadCmdProcQueue; /* 0x5C20 */ OSMesgQueue audioResetQueue; /* 0x5C38 */ OSMesg taskStartMsgBuf[1]; /* 0x5C3C */ OSMesg audioResetMsgBuf[1]; - /* 0x5C40 */ OSMesg cmdProcMsgBuf[4]; - /* 0x5C50 */ AudioCmd cmdBuf[0x100]; // Audio commands used to transfer audio requests from the graph thread to the audio thread + /* 0x5C40 */ OSMesg threadCmdProcMsgBuf[4]; + /* 0x5C50 */ AudioCmd threadCmdBuf[0x100]; // Audio thread commands used to transfer audio requests from the graph thread to the audio thread } AudioContext; // size = 0x6450 typedef struct { @@ -966,10 +977,15 @@ typedef struct { /* 0x08 */ f32 velocity; /* 0x0C */ char unk_0C[0x4]; /* 0x10 */ s16* filter; - /* 0x14 */ u8 unk_14; - /* 0x16 */ u16 unk_16; + /* 0x14 */ u8 combFilterSize; + /* 0x16 */ u16 combFilterGain; } NoteSubAttributes; // size = 0x18 +typedef struct { + /* 0x0 */ s16 unk_00; // set to 0x1C00, unused + /* 0x2 */ s16 seqTicksPerBeat; +} TempoData; // size = 0x4 + typedef struct { /* 0x00 */ u32 heapSize; // total number of bytes allocated to the audio heap. Must be <= the size of `gAudioHeap` (ideally about the same size) /* 0x04 */ u32 initPoolSize; // The entire audio heap is split into two pools. diff --git a/src/audio/debug.inc.c b/src/audio/debug.inc.c index c400306e05..5af3030f39 100644 --- a/src/audio/debug.inc.c +++ b/src/audio/debug.inc.c @@ -240,7 +240,7 @@ void AudioDebug_Draw(GfxPrint* printer) { for (k2 = 0; k2 < gChannelsPerBank[gSfxChannelLayout][k]; k2++) { #define entryIndex (gActiveSfx[k][k2].entryIndex) #define entry (&gSfxBanks[k][entryIndex]) -#define chan (gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[entry->channelIdx]) +#define chan (gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[entry->channelIndex]) GfxPrint_SetPos(printer, 2 + sAudioIntInfoX, 5 + ind + sAudioIntInfoY); if (sAudioIntInfoBankPage[k] == 1) { if ((entryIndex != 0xFF) && @@ -265,7 +265,7 @@ void AudioDebug_Draw(GfxPrint* printer) { ((entry->state == SFX_STATE_PLAYING_1) || (entry->state == SFX_STATE_PLAYING_2))) { GfxPrint_Printf(printer, "%2X %5d %5d %5d %3d %3d %04X", entryIndex, (s32)*entry->posX, (s32)*entry->posY, (s32)*entry->posZ, (s32)(chan->freqScale * 100.0f), - chan->reverb, entry->sfxId); + chan->targetReverbVol, entry->sfxId); } else { GfxPrint_Printf(printer, "FF ----- ----- ----- --- --- ----"); } @@ -410,7 +410,7 @@ void AudioDebug_Draw(GfxPrint* printer) { } GfxPrint_SetPos(printer, 15 + i, 8); - if (gAudioCtx.seqPlayers[sAudioSubTrackInfoPlayerSel].channels[i]->stopSomething2) { + if (gAudioCtx.seqPlayers[sAudioSubTrackInfoPlayerSel].channels[i]->muted) { GfxPrint_Printf(printer, "O"); } else { GfxPrint_Printf(printer, "X"); @@ -476,7 +476,7 @@ void AudioDebug_Draw(GfxPrint* printer) { GfxPrint_Printf(printer, "%02X ", (u8)gAudioCtx.seqPlayers[sAudioSubTrackInfoPlayerSel] .channels[sAudioSubTrackInfoChannelSel] - ->soundScriptIO[i]); + ->seqScriptIO[i]); } if (gAudioCtx.seqPlayers[sAudioSubTrackInfoPlayerSel].channels[sAudioSubTrackInfoChannelSel]->enabled) { @@ -526,9 +526,10 @@ void AudioDebug_Draw(GfxPrint* printer) { ->panChannelWeight); GfxPrint_SetPos(printer, 15, 17); - GfxPrint_Printf( - printer, "%d", - gAudioCtx.seqPlayers[sAudioSubTrackInfoPlayerSel].channels[sAudioSubTrackInfoChannelSel]->reverb); + GfxPrint_Printf(printer, "%d", + gAudioCtx.seqPlayers[sAudioSubTrackInfoPlayerSel] + .channels[sAudioSubTrackInfoChannelSel] + ->targetReverbVol); GfxPrint_SetPos(printer, 15, 18); GfxPrint_Printf(printer, "%d", @@ -547,7 +548,7 @@ void AudioDebug_Draw(GfxPrint* printer) { GfxPrint_Printf(printer, "%d", (u8)(gAudioCtx.seqPlayers[sAudioSubTrackInfoPlayerSel] .channels[sAudioSubTrackInfoChannelSel] - ->vibratoExtentTarget / + ->vibratoDepthTarget / 8)); GfxPrint_SetPos(printer, 15, 21); @@ -623,35 +624,33 @@ void AudioDebug_Draw(GfxPrint* printer) { SETCOL(255, 255, 255); GfxPrint_SetPos(printer, 3, 7); - GfxPrint_Printf(printer, "NEXT SCENE %02X %s", - (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[2], - sAudioSceneNames[(u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[2]]); + GfxPrint_Printf(printer, "NEXT SCENE %02X %s", (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[2], + sAudioSceneNames[(u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[2]]); GfxPrint_SetPos(printer, 3, 8); - GfxPrint_Printf(printer, "NOW SCENE %02X %s", - (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[4], - sAudioSceneNames[(u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[4]]); + GfxPrint_Printf(printer, "NOW SCENE %02X %s", (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[4], + sAudioSceneNames[(u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[4]]); GfxPrint_SetPos(printer, 3, 9); GfxPrint_Printf(printer, "NOW BLOCK %02X", - (gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[5] + 1) & 0xFF); + (gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[5] + 1) & 0xFF); GfxPrint_SetPos(printer, 3, 11); GfxPrint_Printf(printer, "PORT"); GfxPrint_SetPos(printer, 3, 12); GfxPrint_Printf(printer, "%02X %02X %02X %02X", - (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[0], - (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[1], - (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[2], - (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[3]); + (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[0], + (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[1], + (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[2], + (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[3]); GfxPrint_SetPos(printer, 3, 13); GfxPrint_Printf(printer, "%02X %02X %02X %02X", - (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[4], - (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[5], - (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[6], - (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[7]); + (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[4], + (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[5], + (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[6], + (u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[7]); break; case PAGE_OCARINA_TEST: @@ -1174,7 +1173,7 @@ void AudioDebug_ProcessInput_BlkChgBgm(void) { } if (CHECK_BTN_ANY(sDebugPadPress, BTN_A)) { - Audio_QueueCmdS8(MK_CMD(0x46, SEQ_PLAYER_BGM_MAIN, 0x00, 0x00), sAudioBlkChgBgmWork[1]); + AUDIOCMD_SEQPLAYER_SET_IO(SEQ_PLAYER_BGM_MAIN, 0, sAudioBlkChgBgmWork[1]); SEQCMD_PLAY_SEQUENCE(SEQ_PLAYER_BGM_MAIN, 1, 0, sAudioBlkChgBgmWork[0]); } diff --git a/src/audio/general.c b/src/audio/general.c index 881c98a93a..a70a35823b 100644 --- a/src/audio/general.c +++ b/src/audio/general.c @@ -1,18 +1,16 @@ #include "ultra64.h" #include "global.h" -#define Audio_DisableSeq(seqPlayerIndex, fadeOut) Audio_QueueCmdS32(0x83000000 | ((u8)seqPlayerIndex << 16), fadeOut) - #define ABS_ALT(x) ((x) < 0 ? -(x) : (x)) typedef struct { /* 0x0 */ f32 vol; /* 0x4 */ f32 freqScale; /* 0x8 */ s8 reverb; - /* 0x9 */ s8 panSigned; + /* 0x9 */ s8 pan; /* 0xA */ s8 stereoBits; /* 0xB */ u8 filter; - /* 0xC */ u8 unk_0C; + /* 0xC */ u8 combFilterGain; } SfxPlayerState; typedef enum { @@ -1728,7 +1726,7 @@ void AudioOcarina_PlayControllerInput(u8 unused) { // Add vibrato of the ocarina note based on the x control stick sCurOcarinaVibrato = ABS_ALT(sOcarinaInputStickAdj.x) >> 2; // Sets vibrato to io port 6 - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | SFX_CHANNEL_OCARINA << 8 | 6, sCurOcarinaVibrato); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, SFX_CHANNEL_OCARINA, 6, sCurOcarinaVibrato); } else { // no bending or vibrato for recording state OCARINA_RECORD_SCARECROW_SPAWN sCurOcarinaBendIndex = 0; @@ -1737,11 +1735,11 @@ void AudioOcarina_PlayControllerInput(u8 unused) { // Processes new and valid notes if ((sCurOcarinaPitch != OCARINA_PITCH_NONE) && (sPrevOcarinaPitch != sCurOcarinaPitch)) { - // Sets ocarina instrument Id to channelIdx io port 7, which is used + // Sets ocarina instrument Id to channelIndex io port 7, which is used // as an index in seq 0 to get the true instrument Id - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | SFX_CHANNEL_OCARINA << 8 | 7, sOcarinaInstrumentId - 1); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, SFX_CHANNEL_OCARINA, 7, sOcarinaInstrumentId - 1); // Sets pitch to io port 5 - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | SFX_CHANNEL_OCARINA << 8 | 5, sCurOcarinaPitch); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, SFX_CHANNEL_OCARINA, 5, sCurOcarinaPitch); Audio_PlaySfxGeneral(NA_SE_OC_OCARINA, &gSfxDefaultPos, 4, &sCurOcarinaBendFreq, &sRelativeOcarinaVolume, &gSfxDefaultReverb); } else if ((sPrevOcarinaPitch != OCARINA_PITCH_NONE) && (sCurOcarinaPitch == OCARINA_PITCH_NONE)) { @@ -1879,7 +1877,7 @@ void AudioOcarina_PlaybackSong(void) { if (sNotePlaybackVibrato != sPlaybackSong[sPlaybackNotePos].vibrato) { sNotePlaybackVibrato = sPlaybackSong[sPlaybackNotePos].vibrato; // Sets vibrato to io port 6 - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | SFX_CHANNEL_OCARINA << 8 | 6, sNotePlaybackVibrato); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, SFX_CHANNEL_OCARINA, 6, sNotePlaybackVibrato); } // Update bend @@ -1908,13 +1906,11 @@ void AudioOcarina_PlaybackSong(void) { if (sPlaybackPitch != OCARINA_PITCH_NONE) { sPlaybackStaffPos++; - // Sets ocarina instrument Id to channelIdx io port 7, which is used + // Sets ocarina instrument Id to channelIndex io port 7, which is used // as an index in seq 0 to get the true instrument Id - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | SFX_CHANNEL_OCARINA << 8 | 7, - sOcarinaInstrumentId - 1); - // Sets sPlaybackPitch to channelIdx io port 5 - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | SFX_CHANNEL_OCARINA << 8 | 5, - sPlaybackPitch & 0x3F); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, SFX_CHANNEL_OCARINA, 7, sOcarinaInstrumentId - 1); + // Sets sPlaybackPitch to channelIndex io port 5 + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, SFX_CHANNEL_OCARINA, 5, sPlaybackPitch & 0x3F); Audio_PlaySfxGeneral(NA_SE_OC_OCARINA, &gSfxDefaultPos, 4, &sRelativeNotePlaybackBend, &sRelativeNotePlaybackVolume, &gSfxDefaultReverb); } else { @@ -2198,7 +2194,7 @@ s32 AudioOcarina_MemoryGameNextNote(void) { return 1; } - randomButtonIndex = Audio_NextRandom(); + randomButtonIndex = AudioThread_NextRandom(); randomPitch = sButtonToPitchMap[randomButtonIndex % 5]; if (sOcarinaSongNotes[OCARINA_SONG_MEMORY_GAME][sOcaMemoryGameAppendPos - 1].pitch == randomPitch) { @@ -2322,7 +2318,7 @@ void Audio_UpdateFanfare(void); /** * This is Audio_Update for the graph thread */ -void func_800F3054(void) { +void Audio_Update(void) { if (func_800FAD34() == 0) { #if OOT_DEBUG sAudioUpdateTaskStart = gAudioCtx.totalTaskCount; @@ -2348,7 +2344,7 @@ void func_800F3054(void) { AudioDebug_ProcessInput(); #endif - Audio_ScheduleProcessCmds(); + AudioThread_ScheduleProcessCmds(); #if OOT_DEBUG sAudioUpdateTaskEnd = gAudioCtx.totalTaskCount; @@ -2363,8 +2359,8 @@ void func_800F3138(UNK_TYPE arg0) { void func_800F3140(UNK_TYPE arg0, UNK_TYPE arg1) { } -void func_800F314C(s8 arg0) { - Audio_QueueCmdS32(0x82 << 24 | SEQ_PLAYER_BGM_MAIN << 16 | (((u8)arg0 & 0xFF) << 8), 1); +void func_800F314C(s8 seqId) { + AUDIOCMD_GLOBAL_INIT_SEQPLAYER(SEQ_PLAYER_BGM_MAIN, (u8)seqId, 1); } f32 Audio_ComputeSfxVolume(u8 bankId, u8 entryIdx) { @@ -2427,8 +2423,8 @@ s8 Audio_ComputeSfxReverb(u8 bankId, u8 entryIdx, u8 channelIdx) { } if (IS_SEQUENCE_CHANNEL_VALID(gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[channelIdx])) { - scriptAdd = gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[channelIdx]->soundScriptIO[1]; - if (gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[channelIdx]->soundScriptIO[1] <= SEQ_IO_VAL_NONE) { + scriptAdd = gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[channelIdx]->seqScriptIO[1]; + if (gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[channelIdx]->seqScriptIO[1] <= SEQ_IO_VAL_NONE) { scriptAdd = 0; } } @@ -2588,28 +2584,28 @@ u8 func_800F37B8(f32 behindScreenZ, SfxBankEntry* arg1, s8 arg2) { return (phi_v1 * 0x10) + (u8)((phi_f0 * phi_f12) / (10000.0f / 5.2f)); } -s8 func_800F3990(f32 arg0, u16 sfxParams) { - s8 ret = 0; +s8 func_800F3990(f32 posY, u16 sfxParams) { + s8 combFilterGain = 0; - if (arg0 >= 0.0f) { - if (arg0 > 625.0f) { - ret = 127; + if (posY >= 0.0f) { + if (posY > 625.0f) { + combFilterGain = 127; } else { - ret = (arg0 / 625.0f) * 126.0f; + combFilterGain = (posY / 625.0f) * 126.0f; } } - return ret | 1; + return combFilterGain | 1; } -void Audio_SetSfxProperties(u8 bankId, u8 entryIdx, u8 channelIdx) { +void Audio_SetSfxProperties(u8 bankId, u8 entryIdx, u8 channelIndex) { f32 vol = 1.0f; s8 volS8; s8 reverb = 0; f32 freqScale = 1.0f; - s8 panSigned = 0x40; + s8 pan = 0x40; u8 stereoBits = 0; u8 filter = 0; - s8 sp38 = 0; + s8 combFilterGain = 0; f32 behindScreenZ; u8 baseFilter = 0; SfxBankEntry* entry = &gSfxBanks[bankId][entryIdx]; @@ -2621,15 +2617,15 @@ void Audio_SetSfxProperties(u8 bankId, u8 entryIdx, u8 channelIdx) { case BANK_ENEMY: case BANK_VOICE: if (sSoundMode == SOUNDMODE_SURROUND) { - sp38 = func_800F3990(*entry->posY, entry->sfxParams); + combFilterGain = func_800F3990(*entry->posY, entry->sfxParams); } FALLTHROUGH; case BANK_OCARINA: entry->dist = sqrtf(entry->dist * SFX_DIST_SCALING); vol = Audio_ComputeSfxVolume(bankId, entryIdx) * *entry->vol; - reverb = Audio_ComputeSfxReverb(bankId, entryIdx, channelIdx); - panSigned = Audio_ComputeSfxPanSigned(*entry->posX, *entry->posZ, entry->token); + reverb = Audio_ComputeSfxReverb(bankId, entryIdx, channelIndex); + pan = Audio_ComputeSfxPanSigned(*entry->posX, *entry->posZ, entry->token); freqScale = Audio_ComputeSfxFreqScale(bankId, entryIdx) * *entry->freqScale; if (sSoundMode == SOUNDMODE_SURROUND) { @@ -2639,14 +2635,14 @@ void Audio_SetSfxProperties(u8 bankId, u8 entryIdx, u8 channelIdx) { stereoBits = 0x10; } - if ((sSfxChannelState[channelIdx].stereoBits ^ stereoBits) & 0x10) { - if (panSigned < 0x40) { - stereoBits = sSfxChannelState[channelIdx].stereoBits ^ 0x14; + if ((sSfxChannelState[channelIndex].stereoBits ^ stereoBits) & 0x10) { + if (pan < 0x40) { + stereoBits = sSfxChannelState[channelIndex].stereoBits ^ 0x14; } else { - stereoBits = sSfxChannelState[channelIdx].stereoBits ^ 0x18; + stereoBits = sSfxChannelState[channelIndex].stereoBits ^ 0x18; } } else { - stereoBits = sSfxChannelState[channelIdx].stereoBits; + stereoBits = sSfxChannelState[channelIndex].stereoBits; } } } @@ -2659,49 +2655,54 @@ void Audio_SetSfxProperties(u8 bankId, u8 entryIdx, u8 channelIdx) { if ((baseFilter | sAudioExtraFilter) != 0) { filter = (baseFilter | sAudioExtraFilter); } else if ((sSoundMode == SOUNDMODE_SURROUND) && !(entry->sfxParams & SFX_FLAG_13)) { - filter = func_800F37B8(behindScreenZ, entry, panSigned); + filter = func_800F37B8(behindScreenZ, entry, pan); } break; case BANK_SYSTEM: break; } - if (sSfxChannelState[channelIdx].vol != vol) { + if (sSfxChannelState[channelIndex].vol != vol) { volS8 = (u8)(vol * 127.0f); - sSfxChannelState[channelIdx].vol = vol; + sSfxChannelState[channelIndex].vol = vol; } else { volS8 = -1; } // CHAN_UPD_SCRIPT_IO (slot 2, sets volume) - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | (channelIdx << 8) | 2, volS8); - if (reverb != sSfxChannelState[channelIdx].reverb) { - Audio_QueueCmdS8(0x5 << 24 | SEQ_PLAYER_SFX << 16 | (channelIdx << 8), reverb); - sSfxChannelState[channelIdx].reverb = reverb; + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, channelIndex, 2, volS8); + + if (reverb != sSfxChannelState[channelIndex].reverb) { + AUDIOCMD_CHANNEL_SET_REVERB_VOLUME(SEQ_PLAYER_SFX, channelIndex, reverb); + sSfxChannelState[channelIndex].reverb = reverb; } - if (freqScale != sSfxChannelState[channelIdx].freqScale) { - Audio_QueueCmdF32(0x4 << 24 | SEQ_PLAYER_SFX << 16 | (channelIdx << 8), freqScale); - sSfxChannelState[channelIdx].freqScale = freqScale; + + if (freqScale != sSfxChannelState[channelIndex].freqScale) { + AUDIOCMD_CHANNEL_SET_FREQ_SCALE(SEQ_PLAYER_SFX, channelIndex, freqScale); + sSfxChannelState[channelIndex].freqScale = freqScale; } - if (stereoBits != sSfxChannelState[channelIdx].stereoBits) { - Audio_QueueCmdS8(0xE << 24 | SEQ_PLAYER_SFX << 16 | (channelIdx << 8), stereoBits | 0x10); - sSfxChannelState[channelIdx].stereoBits = stereoBits; + + //! @bug: comparing a `u8` to an `s8`. if the most significant bit is set, + //! it'll always pass because the s8 value will be <0 and the u8 value is always >=0 + if (stereoBits != sSfxChannelState[channelIndex].stereoBits) { + AUDIOCMD_CHANNEL_SET_STEREO(SEQ_PLAYER_SFX, channelIndex, stereoBits | 0x10); + sSfxChannelState[channelIndex].stereoBits = stereoBits; } - if (filter != sSfxChannelState[channelIdx].filter) { - // CHAN_UPD_SCRIPT_IO (slot 3, sets filter) - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | (channelIdx << 8) | 3, filter); - sSfxChannelState[channelIdx].filter = filter; + + if (filter != sSfxChannelState[channelIndex].filter) { + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, channelIndex, 3, filter); + sSfxChannelState[channelIndex].filter = filter; } - if (sp38 != sSfxChannelState[channelIdx].unk_0C) { - // CHAN_UPD_UNK_0F - Audio_QueueCmdS8(0xC << 24 | SEQ_PLAYER_SFX << 16 | (channelIdx << 8), 0x10); - // CHAN_UPD_UNK_20 - Audio_QueueCmdU16(0xD << 24 | SEQ_PLAYER_SFX << 16 | (channelIdx << 8), ((u16)(sp38) << 8) + 0xFF); - sSfxChannelState[channelIdx].unk_0C = sp38; + + if (combFilterGain != sSfxChannelState[channelIndex].combFilterGain) { + AUDIOCMD_CHANNEL_SET_COMB_FILTER_SIZE(SEQ_PLAYER_SFX, channelIndex, 0x10); + AUDIOCMD_CHANNEL_SET_COMB_FILTER_GAIN(SEQ_PLAYER_SFX, channelIndex, ((u16)(combFilterGain) << 8) + 0xFF); + sSfxChannelState[channelIndex].combFilterGain = combFilterGain; } - if (panSigned != sSfxChannelState[channelIdx].panSigned) { - Audio_QueueCmdS8(0x3 << 24 | SEQ_PLAYER_SFX << 16 | (channelIdx << 8), panSigned); - sSfxChannelState[channelIdx].panSigned = panSigned; + + if (pan != sSfxChannelState[channelIndex].pan) { + AUDIOCMD_CHANNEL_SET_PAN(SEQ_PLAYER_SFX, channelIndex, pan); + sSfxChannelState[channelIndex].pan = pan; } } @@ -2714,13 +2715,13 @@ void Audio_ResetSfxChannelState(void) { state->vol = 1.0f; state->freqScale = 1.0f; state->reverb = 0; - state->panSigned = 0x40; + state->pan = 0x40; state->stereoBits = 0; state->filter = 0xFF; - state->unk_0C = 0xFF; + state->combFilterGain = 0xFF; } - sSfxChannelState[SFX_CHANNEL_OCARINA].unk_0C = 0; + sSfxChannelState[SFX_CHANNEL_OCARINA].combFilterGain = 0; sPrevSeqMode = 0; sAudioCodeReverb = 0; } @@ -2788,7 +2789,7 @@ void func_800F4190(Vec3f* pos, u16 sfxId) { Audio_PlaySfxGeneral(sfxId, pos, 4, &D_801305B0, &gSfxDefaultFreqAndVolScale, &D_801305B4); } void Audio_PlaySfxRandom(Vec3f* pos, u16 baseSfxId, u8 randLim) { - u8 offset = Audio_NextRandom() % randLim; + u8 offset = AudioThread_NextRandom() % randLim; Audio_PlaySfxGeneral(baseSfxId + offset, pos, 4, &gSfxDefaultFreqAndVolScale, &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb); @@ -2916,19 +2917,17 @@ void Audio_SetMainBgmVolume(u8 targetVol, u8 volFadeTimer) { * Incrementally increase volume of NA_BGM_GANON_TOWER for each new room during the climb of Ganon's Tower */ void Audio_SetGanonsTowerBgmVolumeLevel(u8 ganonsTowerLevel) { - u8 channelIdx; - s8 pan = 0; + u8 channelIndex; + s8 panChannelWeight = 0; // Pan comes entirely from the SequenceLayer // Ganondorf's Lair if (ganonsTowerLevel == 0) { - pan = 0x7F; + // Pan comes entirely from the SequenceChannel + panChannelWeight = 0x7F; } - for (channelIdx = 0; channelIdx < 16; channelIdx++) { - // CHAN_UPD_PAN_UNSIGNED - Audio_QueueCmdS8(_SHIFTL(0x7, 24, 8) | _SHIFTL(SEQ_PLAYER_BGM_MAIN, 16, 8) | _SHIFTL(channelIdx, 8, 8) | - _SHIFTL(0, 0, 8), - pan); + for (channelIndex = 0; channelIndex < SEQ_NUM_CHANNELS; channelIndex++) { + AUDIOCMD_CHANNEL_SET_PAN_WEIGHT(SEQ_PLAYER_BGM_MAIN, (u32)channelIndex, panChannelWeight); } // Lowest room in Ganon's Tower (Entrance Room) @@ -2947,7 +2946,7 @@ void Audio_SetGanonsTowerBgmVolumeLevel(u8 ganonsTowerLevel) { s32 Audio_SetGanonsTowerBgmVolume(u8 targetVol) { u8 lowPassFilterCutoff; u16 reverb; - u8 channelIdx; + u8 channelIndex; if (sGanonsTowerVol != targetVol) { // Sets the volume @@ -2966,22 +2965,19 @@ s32 Audio_SetGanonsTowerBgmVolume(u8 targetVol) { SEQCMD_SET_CHANNEL_IO(SEQ_PLAYER_BGM_MAIN, 15, 4, lowPassFilterCutoff); // Sets the reverb - for (channelIdx = 0; channelIdx < 16; channelIdx++) { - if (gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIdx] != &gAudioCtx.sequenceChannelNone) { - // soundScriptIO[5] is set to 0x40 in channels 0, 1, and 4 - if ((u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIdx]->soundScriptIO[5] != + for (channelIndex = 0; channelIndex < SEQ_NUM_CHANNELS; channelIndex++) { + if (gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIndex] != &gAudioCtx.sequenceChannelNone) { + // seqScriptIO[5] is set to 0x40 in channels 0, 1, and 4 + if ((u8)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIndex]->seqScriptIO[5] != (u8)SEQ_IO_VAL_NONE) { // Higher volume leads to lower reverb - reverb = ((u16)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIdx]->soundScriptIO[5] - + reverb = ((u16)gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].channels[channelIndex]->seqScriptIO[5] - targetVol) + 0x7F; if (reverb > 0x7F) { reverb = 0x7F; } - // CHAN_UPD_REVERB - Audio_QueueCmdS8(_SHIFTL(0x5, 24, 8) | _SHIFTL(SEQ_PLAYER_BGM_MAIN, 16, 8) | - _SHIFTL(channelIdx, 8, 8) | _SHIFTL(0, 0, 8), - (u8)reverb); + AUDIOCMD_CHANNEL_SET_REVERB_VOLUME(SEQ_PLAYER_BGM_MAIN, (u32)channelIndex, (u8)reverb); } } } @@ -3043,31 +3039,30 @@ void Audio_PlaySfxTransposed(Vec3f* pos, u16 sfxId, s8 semitone) { &gSfxDefaultReverb); } -void func_800F4C58(Vec3f* pos, u16 sfxId, u8 arg2) { - u8 phi_s1 = 0; +void func_800F4C58(Vec3f* pos, u16 sfxId, u8 ioData) { + u8 channelIndex = 0; u8 i; u8 bankId; bankId = SFX_BANK_SHIFT(sfxId); for (i = 0; i < bankId; i++) { - phi_s1 += gChannelsPerBank[gSfxChannelLayout][i]; + channelIndex += gChannelsPerBank[gSfxChannelLayout][i]; } for (i = 0; i < gChannelsPerBank[gSfxChannelLayout][bankId]; i++) { if ((gActiveSfx[bankId][i].entryIndex != 0xFF) && (sfxId == gSfxBanks[bankId][gActiveSfx[bankId][i].entryIndex].sfxId)) { - Audio_QueueCmdS8( - _SHIFTL(0x6, 24, 8) | _SHIFTL(SEQ_PLAYER_SFX, 16, 8) | _SHIFTL(phi_s1, 8, 8) | _SHIFTL(6, 0, 8), arg2); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, channelIndex, 6, ioData); } - phi_s1++; + channelIndex++; } Audio_PlaySfxGeneral(sfxId, pos, 4, &gSfxDefaultFreqAndVolScale, &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb); } void func_800F4E30(Vec3f* pos, f32 arg1) { f32 phi_f22; - s8 phi_s4; - u8 i; + s8 pan; + u8 channelIndex; if (sSariaBgmPtr == NULL) { sSariaBgmPtr = pos; @@ -3082,11 +3077,11 @@ void func_800F4E30(Vec3f* pos, f32 arg1) { } if (sSariaBgmPtr->x > 100.0f) { - phi_s4 = 0x7F; + pan = 0x7F; } else if (sSariaBgmPtr->x < -100.0f) { - phi_s4 = 0; + pan = 0; } else { - phi_s4 = ((sSariaBgmPtr->x / 100.0f) * 64.0f) + 64.0f; + pan = ((sSariaBgmPtr->x / 100.0f) * 64.0f) + 64.0f; } if (D_80130650 > 400.0f) { @@ -3097,10 +3092,10 @@ void func_800F4E30(Vec3f* pos, f32 arg1) { phi_f22 = ((1.0f - ((D_80130650 - 120.0f) / 280.0f)) * 0.9f) + 0.1f; } - for (i = 0; i < 0x10; i++) { - if (i != 9) { - SEQCMD_SET_CHANNEL_VOLUME(SEQ_PLAYER_BGM_MAIN, i, 2, (127.0f * phi_f22)); - Audio_QueueCmdS8(0x3 << 24 | SEQ_PLAYER_BGM_MAIN << 16 | ((u8)((u32)i) << 8), phi_s4); + for (channelIndex = 0; channelIndex < SEQ_NUM_CHANNELS; channelIndex++) { + if (channelIndex != 9) { + SEQCMD_SET_CHANNEL_VOLUME(SEQ_PLAYER_BGM_MAIN, channelIndex, 2, (127.0f * phi_f22)); + AUDIOCMD_CHANNEL_SET_PAN(SEQ_PLAYER_BGM_MAIN, (u32)channelIndex, pan); } } } @@ -3227,8 +3222,7 @@ void Audio_PlaySceneSequence(u16 seqId) { if (Audio_GetActiveSeqId(SEQ_PLAYER_BGM_MAIN) != NA_BGM_WINDMILL) { if (Audio_GetActiveSeqId(SEQ_PLAYER_BGM_SUB) == NA_BGM_LONLON) { Audio_StopSequence(SEQ_PLAYER_BGM_SUB, 0); - // Terminate all internal audio cmds - Audio_QueueCmdS32(0xF8000000, 0); + AUDIOCMD_GLOBAL_STOP_AUDIOCMDS(); } if ((sSeqFlags[sPrevSceneSeqId] & SEQ_FLAG_RESUME_PREV) && (sSeqFlags[seqId & 0xFF & 0xFF] & SEQ_FLAG_RESUME)) { @@ -3263,7 +3257,7 @@ void Audio_UpdateSceneSequenceResumePoint(void) { if ((seqId != NA_BGM_DISABLED) && (sSeqFlags[seqId & 0xFF & 0xFF] & SEQ_FLAG_RESUME)) { if (sSeqResumePoint != SEQ_RESUME_POINT_NONE) { // Get the current point to resume from - sSeqResumePoint = gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].soundScriptIO[3]; + sSeqResumePoint = gAudioCtx.seqPlayers[SEQ_PLAYER_BGM_MAIN].seqScriptIO[3]; } else { // Initialize the point to resume from to the start of the sequence. sSeqResumePoint = 0; @@ -3285,7 +3279,7 @@ void Audio_SetMainBgmTempoFreqAfterFanfare(f32 scaleTempoAndFreq, u8 duration) { SEQCMD_SETUP_SCALE_TEMPO(SEQ_PLAYER_FANFARE, SEQ_PLAYER_BGM_MAIN, duration, scaleTempoAndFreq * 100.0f); } - SEQCMD_SETUP_SET_PLAYER_FREQ(SEQ_PLAYER_FANFARE, SEQ_PLAYER_BGM_MAIN, duration, scaleTempoAndFreq * 100.0f); + SEQCMD_SETUP_SET_SEQPLAYER_FREQ(SEQ_PLAYER_FANFARE, SEQ_PLAYER_BGM_MAIN, duration, scaleTempoAndFreq * 100.0f); } /** @@ -3406,8 +3400,8 @@ void Audio_PlayFanfare(u16 seqId) { curSeqId = Audio_GetActiveSeqId(SEQ_PLAYER_FANFARE); - curFontId = func_800E5E84(curSeqId & 0xFF, &outNumFonts); - requestedFontId = func_800E5E84(seqId & 0xFF, &outNumFonts); + curFontId = AudioThread_GetFontsForSequence(curSeqId & 0xFF, &outNumFonts); + requestedFontId = AudioThread_GetFontsForSequence(seqId & 0xFF, &outNumFonts); if ((curSeqId == NA_BGM_DISABLED) || (*curFontId == *requestedFontId)) { sFanfareStartTimer = 1; @@ -3428,8 +3422,8 @@ void Audio_UpdateFanfare(void) { if (sFanfareStartTimer != 0) { sFanfareStartTimer--; if (sFanfareStartTimer == 0) { - Audio_QueueCmdS32(0xE3000000, SEQUENCE_TABLE); - Audio_QueueCmdS32(0xE3000000, FONT_TABLE); + AUDIOCMD_GLOBAL_POP_PERSISTENT_CACHE(SEQUENCE_TABLE); + AUDIOCMD_GLOBAL_POP_PERSISTENT_CACHE(FONT_TABLE); seqIdBgmMain = Audio_GetActiveSeqId(SEQ_PLAYER_BGM_MAIN); seqIdFanfare = Audio_GetActiveSeqId(SEQ_PLAYER_FANFARE); @@ -3439,10 +3433,10 @@ void Audio_UpdateFanfare(void) { if (seqIdFanfare == NA_BGM_DISABLED) { Audio_SetVolumeScale(SEQ_PLAYER_BGM_MAIN, VOL_SCALE_INDEX_FANFARE, 0, 5); Audio_SetVolumeScale(SEQ_PLAYER_BGM_SUB, VOL_SCALE_INDEX_FANFARE, 0, 5); - SEQCMD_SETUP_RESTORE_PLAYER_VOLUME_WITH_SCALE_INDEX(SEQ_PLAYER_FANFARE, SEQ_PLAYER_BGM_MAIN, - VOL_SCALE_INDEX_FANFARE, 10); - SEQCMD_SETUP_RESTORE_PLAYER_VOLUME_WITH_SCALE_INDEX(SEQ_PLAYER_FANFARE, SEQ_PLAYER_BGM_SUB, - VOL_SCALE_INDEX_FANFARE, 10); + SEQCMD_SETUP_RESTORE_SEQPLAYER_VOLUME_WITH_SCALE_INDEX(SEQ_PLAYER_FANFARE, SEQ_PLAYER_BGM_MAIN, + VOL_SCALE_INDEX_FANFARE, 10); + SEQCMD_SETUP_RESTORE_SEQPLAYER_VOLUME_WITH_SCALE_INDEX(SEQ_PLAYER_FANFARE, SEQ_PLAYER_BGM_SUB, + VOL_SCALE_INDEX_FANFARE, 10); SEQCMD_SETUP_SET_CHANNEL_DISABLE_MASK(SEQ_PLAYER_FANFARE, SEQ_PLAYER_BGM_MAIN, 0); if (seqIdBgmSub != NA_BGM_LONLON) { SEQCMD_SETUP_SET_CHANNEL_DISABLE_MASK(SEQ_PLAYER_FANFARE, SEQ_PLAYER_BGM_SUB, 0); @@ -3458,7 +3452,7 @@ void Audio_UpdateFanfare(void) { } void Audio_PlaySequenceWithSeqPlayerIO(u8 seqPlayerIndex, u16 seqId, u8 fadeInDuration, s8 ioPort, s8 ioData) { - SEQCMD_SET_PLAYER_IO(seqPlayerIndex, ioPort, ioData); + SEQCMD_SET_SEQPLAYER_IO(seqPlayerIndex, ioPort, ioData); SEQCMD_PLAY_SEQUENCE(seqPlayerIndex, fadeInDuration, 0, seqId); } @@ -3537,7 +3531,7 @@ void Audio_SetSequenceMode(u8 seqMode) { } sPrevSeqMode = seqMode; - SEQCMD_SET_PLAYER_IO(SEQ_PLAYER_BGM_MAIN, 2, seqMode); + SEQCMD_SET_SEQPLAYER_IO(SEQ_PLAYER_BGM_MAIN, 2, seqMode); } } } @@ -3641,11 +3635,11 @@ void func_800F64E0(u8 arg0) { if (arg0 != 0) { Audio_PlaySfxGeneral(NA_SE_SY_WIN_OPEN, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale, &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb); - Audio_QueueCmdS32(0xF1000000, 0); + AUDIOCMD_GLOBAL_MUTE(); } else { Audio_PlaySfxGeneral(NA_SE_SY_WIN_CLOSE, &gSfxDefaultPos, 4, &gSfxDefaultFreqAndVolScale, &gSfxDefaultFreqAndVolScale, &gSfxDefaultReverb); - Audio_QueueCmdS32(0xF2000000, 0); + AUDIOCMD_GLOBAL_UNMUTE(0); } } @@ -3754,16 +3748,13 @@ void Audio_SetBaseFilter(u8 filter) { } void Audio_SetExtraFilter(u8 filter) { - u32 t; - u8 i; + u8 channelIndex; sAudioExtraFilter2 = filter; sAudioExtraFilter = filter; if (gActiveSeqs[SEQ_PLAYER_BGM_MAIN].seqId == NA_BGM_NATURE_AMBIENCE) { - for (i = 0; i < 16; i++) { - t = i; - // CHAN_UPD_SCRIPT_IO (seq player 0, all channels, slot 6) - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_BGM_MAIN << 16 | ((t & 0xFF) << 8) | 6, filter); + for (channelIndex = 0; channelIndex < SEQ_NUM_CHANNELS; channelIndex++) { + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_BGM_MAIN, (u32)channelIndex, 6, filter); } } } @@ -3824,11 +3815,11 @@ void func_800F6B3C(void) { } void Audio_DisableAllSeq(void) { - Audio_DisableSeq(SEQ_PLAYER_BGM_MAIN, 0); - Audio_DisableSeq(SEQ_PLAYER_FANFARE, 0); - Audio_DisableSeq(SEQ_PLAYER_SFX, 0); - Audio_DisableSeq(SEQ_PLAYER_BGM_SUB, 0); - Audio_ScheduleProcessCmds(); + AUDIOCMD_GLOBAL_DISABLE_SEQPLAYER(SEQ_PLAYER_BGM_MAIN, 0); + AUDIOCMD_GLOBAL_DISABLE_SEQPLAYER(SEQ_PLAYER_FANFARE, 0); + AUDIOCMD_GLOBAL_DISABLE_SEQPLAYER(SEQ_PLAYER_SFX, 0); + AUDIOCMD_GLOBAL_DISABLE_SEQPLAYER(SEQ_PLAYER_BGM_SUB, 0); + AudioThread_ScheduleProcessCmds(); } s8 func_800F6BB8(void) { @@ -3837,7 +3828,7 @@ s8 func_800F6BB8(void) { void func_800F6BDC(void) { Audio_DisableAllSeq(); - Audio_ScheduleProcessCmds(); + AudioThread_ScheduleProcessCmds(); while (true) { if (!func_800F6BB8()) { return; @@ -3846,7 +3837,7 @@ void func_800F6BDC(void) { } void Audio_PreNMI(void) { - Audio_PreNMIInternal(); + AudioThread_PreNMIInternal(); } void func_800F6C34(void) { @@ -3872,7 +3863,7 @@ void func_800F6C34(void) { sSpecReverb = sSpecReverbs[gAudioSpecId]; D_80130608 = 0; sPrevMainBgmSeqId = NA_BGM_DISABLED; - Audio_QueueCmdS8(0x46 << 24 | SEQ_PLAYER_BGM_MAIN << 16, -1); + AUDIOCMD_SEQPLAYER_SET_IO(SEQ_PLAYER_BGM_MAIN, 0, SEQ_IO_VAL_NONE); sSariaBgmPtr = NULL; sFanfareStartTimer = 0; D_8016B9F3 = 1; @@ -3921,9 +3912,9 @@ void Audio_StartNatureAmbienceSequence(u16 playerIO, u16 channelMask) { return; } - SEQCMD_SET_PLAYER_IO(SEQ_PLAYER_BGM_MAIN, 0, 1); - SEQCMD_SET_PLAYER_IO(SEQ_PLAYER_BGM_MAIN, 4, playerIO >> 8); - SEQCMD_SET_PLAYER_IO(SEQ_PLAYER_BGM_MAIN, 5, playerIO & 0xFF); + SEQCMD_SET_SEQPLAYER_IO(SEQ_PLAYER_BGM_MAIN, 0, 1); + SEQCMD_SET_SEQPLAYER_IO(SEQ_PLAYER_BGM_MAIN, 4, playerIO >> 8); + SEQCMD_SET_SEQPLAYER_IO(SEQ_PLAYER_BGM_MAIN, 5, playerIO & 0xFF); Audio_SetVolumeScale(SEQ_PLAYER_BGM_MAIN, VOL_SCALE_INDEX_BGM_MAIN, 0x7F, 1); channelIdx = false; @@ -3986,9 +3977,9 @@ void Audio_InitSound(void) { void func_800F7170(void) { Audio_StartSequence(SEQ_PLAYER_SFX, 0, 0x70, 1); - Audio_QueueCmdS32(0xF2000000, 1); - Audio_ScheduleProcessCmds(); - Audio_QueueCmdS32(0xF8000000, 0); + AUDIOCMD_GLOBAL_UNMUTE(1); + AudioThread_ScheduleProcessCmds(); + AUDIOCMD_GLOBAL_STOP_AUDIOCMDS(); } void func_800F71BC(s32 arg0) { @@ -4002,7 +3993,7 @@ void func_800F71BC(s32 arg0) { void func_800F7208(void) { Audio_ResetActiveSequences(); - Audio_QueueCmdS32(0xF2000000, 1); + AUDIOCMD_GLOBAL_UNMUTE(1); func_800F6C34(); Audio_ResetSfxChannelState(); Audio_StartSequence(SEQ_PLAYER_SFX, 0, 0x70, 1); diff --git a/src/audio/lib/effects.c b/src/audio/lib/effects.c index 8de03887e9..bbfcaf61ad 100644 --- a/src/audio/lib/effects.c +++ b/src/audio/lib/effects.c @@ -113,8 +113,8 @@ f32 Audio_GetVibratoFreqScale(VibratoState* vib) { static f32 D_80130510 = 0.0f; static s32 D_80130514 = 0; f32 pitchChange; - f32 extent; - f32 invExtent; + f32 depth; + f32 invDepth; f32 result; f32 temp; SequenceChannel* channel = vib->channel; @@ -127,17 +127,17 @@ f32 Audio_GetVibratoFreqScale(VibratoState* vib) { //! @bug this probably meant to compare with gAudioCtx.sequenceChannelNone. //! -1 isn't used as a channel pointer anywhere else. if (channel != ((SequenceChannel*)(-1))) { - if (vib->extentChangeTimer) { - if (vib->extentChangeTimer == 1) { - vib->extent = (s32)channel->vibratoExtentTarget; + if (vib->depthChangeTimer) { + if (vib->depthChangeTimer == 1) { + vib->depth = (s32)channel->vibratoDepthTarget; } else { - vib->extent += ((s32)channel->vibratoExtentTarget - vib->extent) / (s32)vib->extentChangeTimer; + vib->depth += ((s32)channel->vibratoDepthTarget - vib->depth) / (s32)vib->depthChangeTimer; } - vib->extentChangeTimer--; - } else if (channel->vibratoExtentTarget != (s32)vib->extent) { - if ((vib->extentChangeTimer = channel->vibratoExtentChangeDelay) == 0) { - vib->extent = (s32)channel->vibratoExtentTarget; + vib->depthChangeTimer--; + } else if (channel->vibratoDepthTarget != (s32)vib->depth) { + if ((vib->depthChangeTimer = channel->vibratoDepthChangeDelay) == 0) { + vib->depth = (s32)channel->vibratoDepthTarget; } } @@ -156,16 +156,16 @@ f32 Audio_GetVibratoFreqScale(VibratoState* vib) { } } - if (vib->extent == 0.0f) { + if (vib->depth == 0.0f) { return 1.0f; } pitchChange = Audio_GetVibratoPitchChange(vib) + 32768.0f; - temp = vib->extent / 4096.0f; - extent = temp + 1.0f; - invExtent = 1.0f / extent; + temp = vib->depth / 4096.0f; + depth = temp + 1.0f; + invDepth = 1.0f / depth; - result = 1.0f / ((extent - invExtent) * pitchChange / 65536.0f + invExtent); + result = 1.0f / ((depth - invDepth) * pitchChange / 65536.0f + invDepth); D_80130510 += result; D_80130514++; @@ -190,16 +190,16 @@ void Audio_NoteVibratoInit(Note* note) { vib = ¬e->playbackState.vibratoState; - vib->active = 1; + vib->active = true; vib->time = 0; + vib->curve = gWaveSamples[2]; // gSineWaveSample[0..63] - vib->curve = gWaveSamples[2]; vib->channel = note->playbackState.parentLayer->channel; channel = vib->channel; - if ((vib->extentChangeTimer = channel->vibratoExtentChangeDelay) == 0) { - vib->extent = (s32)channel->vibratoExtentTarget; + if ((vib->depthChangeTimer = channel->vibratoDepthChangeDelay) == 0) { + vib->depth = (s32)channel->vibratoDepthTarget; } else { - vib->extent = (s32)channel->vibratoExtentStart; + vib->depth = (s32)channel->vibratoDepthStart; } if ((vib->rateChangeTimer = channel->vibratoRateChangeDelay) == 0) { @@ -264,7 +264,7 @@ f32 Audio_AdsrUpdate(AdsrState* adsr) { break; default: - adsr->delay *= gAudioCtx.audioBufferParameters.updatesPerFrameScaled; + adsr->delay *= gAudioCtx.audioBufferParameters.ticksPerUpdateScaled; if (adsr->delay == 0) { adsr->delay = 1; } diff --git a/src/audio/lib/heap.c b/src/audio/lib/heap.c index 899cf912b9..dcb027d491 100644 --- a/src/audio/lib/heap.c +++ b/src/audio/lib/heap.c @@ -11,12 +11,10 @@ void AudioHeap_DiscardSampleBank(s32 sampleBankId); void AudioHeap_DiscardSampleBanks(void); /** - * Effectively scales `updatesPerFrameInv` by the reciprocal of `scaleInv` - * `updatesPerFrameInvScaled` is just `updatesPerFrameInv` scaled down by a factor of 256.0f - * i.e. (256.0f * `updatesPerFrameInvScaled`) is just `updatesPerFrameInv` + * Effectively scales `ticksPerUpdateInv` by the reciprocal of `scaleInv` */ f32 AudioHeap_CalculateAdsrDecay(f32 scaleInv) { - return (256.0f * gAudioCtx.audioBufferParameters.updatesPerFrameInvScaled) / scaleInv; + return (256.0f * gAudioCtx.audioBufferParameters.ticksPerUpdateInvScaled) / scaleInv; } /** @@ -96,7 +94,7 @@ void AudioHeap_ReleaseNotesForFont(s32 fontId) { if (playbackState->fontId == fontId) { if ((playbackState->priority != 0) && (playbackState->adsr.action.s.state == ADSR_STATE_DECAY)) { playbackState->priority = 1; - playbackState->adsr.fadeOutVel = gAudioCtx.audioBufferParameters.updatesPerFrameInv; + playbackState->adsr.fadeOutVel = gAudioCtx.audioBufferParameters.ticksPerUpdateInv; playbackState->adsr.action.s.release = true; } } @@ -793,7 +791,7 @@ s32 AudioHeap_ResetStep(void) { if (gAudioCtx.notes[i].noteSubEu.bitField0.enabled && gAudioCtx.notes[i].playbackState.adsr.action.s.state != ADSR_STATE_DISABLED) { gAudioCtx.notes[i].playbackState.adsr.fadeOutVel = - gAudioCtx.audioBufferParameters.updatesPerFrameInv; + gAudioCtx.audioBufferParameters.ticksPerUpdateInv; gAudioCtx.notes[i].playbackState.adsr.action.s.release = true; } } @@ -853,7 +851,7 @@ void AudioHeap_Init(void) { s32 i; s32 j; s32 pad2; - AudioSpec* spec = &gAudioSpecs[gAudioCtx.audioResetSpecIdToLoad]; // Audio Specifications + AudioSpec* spec = &gAudioSpecs[gAudioCtx.specId]; // Audio Specifications gAudioCtx.sampleDmaCount = 0; @@ -865,17 +863,17 @@ void AudioHeap_Init(void) { ALIGN16(gAudioCtx.audioBufferParameters.samplingFrequency / gAudioCtx.refreshRate); gAudioCtx.audioBufferParameters.minAiBufferLength = gAudioCtx.audioBufferParameters.samplesPerFrameTarget - 0x10; gAudioCtx.audioBufferParameters.maxAiBufferLength = gAudioCtx.audioBufferParameters.samplesPerFrameTarget + 0x10; - gAudioCtx.audioBufferParameters.updatesPerFrame = + gAudioCtx.audioBufferParameters.ticksPerUpdate = ((gAudioCtx.audioBufferParameters.samplesPerFrameTarget + 0x10) / 0xD0) + 1; - gAudioCtx.audioBufferParameters.samplesPerUpdate = - (gAudioCtx.audioBufferParameters.samplesPerFrameTarget / gAudioCtx.audioBufferParameters.updatesPerFrame) & ~7; - gAudioCtx.audioBufferParameters.samplesPerUpdateMax = gAudioCtx.audioBufferParameters.samplesPerUpdate + 8; - gAudioCtx.audioBufferParameters.samplesPerUpdateMin = gAudioCtx.audioBufferParameters.samplesPerUpdate - 8; + gAudioCtx.audioBufferParameters.samplesPerTick = + (gAudioCtx.audioBufferParameters.samplesPerFrameTarget / gAudioCtx.audioBufferParameters.ticksPerUpdate) & ~7; + gAudioCtx.audioBufferParameters.samplesPerTickMax = gAudioCtx.audioBufferParameters.samplesPerTick + 8; + gAudioCtx.audioBufferParameters.samplesPerTickMin = gAudioCtx.audioBufferParameters.samplesPerTick - 8; gAudioCtx.audioBufferParameters.resampleRate = 32000.0f / (s32)gAudioCtx.audioBufferParameters.samplingFrequency; - gAudioCtx.audioBufferParameters.updatesPerFrameInvScaled = - (1.0f / 256.0f) / gAudioCtx.audioBufferParameters.updatesPerFrame; - gAudioCtx.audioBufferParameters.updatesPerFrameScaled = gAudioCtx.audioBufferParameters.updatesPerFrame / 4.0f; - gAudioCtx.audioBufferParameters.updatesPerFrameInv = 1.0f / gAudioCtx.audioBufferParameters.updatesPerFrame; + gAudioCtx.audioBufferParameters.ticksPerUpdateInvScaled = + (1.0f / 256.0f) / gAudioCtx.audioBufferParameters.ticksPerUpdate; + gAudioCtx.audioBufferParameters.ticksPerUpdateScaled = gAudioCtx.audioBufferParameters.ticksPerUpdate / 4.0f; + gAudioCtx.audioBufferParameters.ticksPerUpdateInv = 1.0f / gAudioCtx.audioBufferParameters.ticksPerUpdate; // SampleDma buffer size gAudioCtx.sampleDmaBufSize1 = spec->sampleDmaBufSize1; @@ -887,19 +885,22 @@ void AudioHeap_Init(void) { gAudioCtx.audioBufferParameters.numSequencePlayers = 4; } gAudioCtx.unk_2 = spec->unk_14; - gAudioCtx.tempoInternalToExternal = - (u32)(gAudioCtx.audioBufferParameters.updatesPerFrame * 2880000.0f / gTatumsPerBeat / gAudioCtx.unk_2960); + + // (ticks / min) + // 60 * 1000 is a conversion from milliseconds to minutes + gAudioCtx.maxTempo = (u32)(gAudioCtx.audioBufferParameters.ticksPerUpdate * (f32)(60 * 1000 * SEQTICKS_PER_BEAT) / + gTempoData.seqTicksPerBeat / gAudioCtx.maxTempoTvTypeFactors); gAudioCtx.unk_2870 = gAudioCtx.refreshRate; - gAudioCtx.unk_2870 *= gAudioCtx.audioBufferParameters.updatesPerFrame; + gAudioCtx.unk_2870 *= gAudioCtx.audioBufferParameters.ticksPerUpdate; gAudioCtx.unk_2870 /= gAudioCtx.audioBufferParameters.aiSamplingFrequency; - gAudioCtx.unk_2870 /= gAudioCtx.tempoInternalToExternal; + gAudioCtx.unk_2870 /= gAudioCtx.maxTempo; gAudioCtx.audioBufferParameters.specUnk4 = spec->unk_04; gAudioCtx.audioBufferParameters.samplesPerFrameTarget *= gAudioCtx.audioBufferParameters.specUnk4; gAudioCtx.audioBufferParameters.maxAiBufferLength *= gAudioCtx.audioBufferParameters.specUnk4; gAudioCtx.audioBufferParameters.minAiBufferLength *= gAudioCtx.audioBufferParameters.specUnk4; - gAudioCtx.audioBufferParameters.updatesPerFrame *= gAudioCtx.audioBufferParameters.specUnk4; + gAudioCtx.audioBufferParameters.ticksPerUpdate *= gAudioCtx.audioBufferParameters.specUnk4; if (gAudioCtx.audioBufferParameters.specUnk4 >= 2) { gAudioCtx.audioBufferParameters.maxAiBufferLength -= 0x10; @@ -907,7 +908,7 @@ void AudioHeap_Init(void) { // Determine the length of the buffer for storing the audio command list passed to the rsp audio microcode gAudioCtx.maxAudioCmds = - gAudioCtx.numNotes * 0x10 * gAudioCtx.audioBufferParameters.updatesPerFrame + spec->numReverbs * 0x18 + 0x140; + gAudioCtx.numNotes * 0x10 * gAudioCtx.audioBufferParameters.ticksPerUpdate + spec->numReverbs * 0x18 + 0x140; // Calculate sizes for various caches on the audio heap persistentSize = @@ -949,7 +950,7 @@ void AudioHeap_Init(void) { gAudioCtx.notes = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, gAudioCtx.numNotes * sizeof(Note)); Audio_NoteInitAll(); Audio_InitNoteFreeList(); - gAudioCtx.noteSubsEu = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, gAudioCtx.audioBufferParameters.updatesPerFrame * + gAudioCtx.noteSubsEu = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, gAudioCtx.audioBufferParameters.ticksPerUpdate * gAudioCtx.numNotes * sizeof(NoteSubEu)); // Initialize audio binary interface command list buffers for (i = 0; i != 2; i++) { @@ -1011,7 +1012,7 @@ void AudioHeap_Init(void) { reverb->unk_34 = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, sizeof(RESAMPLE_STATE)); reverb->unk_38 = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, sizeof(RESAMPLE_STATE)); reverb->unk_3C = AudioHeap_AllocZeroed(&gAudioCtx.miscPool, sizeof(RESAMPLE_STATE)); - for (j = 0; j < gAudioCtx.audioBufferParameters.updatesPerFrame; j++) { + for (j = 0; j < gAudioCtx.audioBufferParameters.ticksPerUpdate; j++) { ramAddr = AudioHeap_AllocZeroedAttemptExternal(&gAudioCtx.miscPool, DMEM_2CH_SIZE); reverb->items[0][j].toDownsampleLeft = ramAddr; reverb->items[0][j].toDownsampleRight = ramAddr + DMEM_1CH_SIZE / SAMPLE_SIZE; diff --git a/src/audio/lib/load.c b/src/audio/lib/load.c index b7b674a237..c542c80620 100644 --- a/src/audio/lib/load.c +++ b/src/audio/lib/load.c @@ -1126,7 +1126,7 @@ void AudioLoad_Init(void* heap, u32 heapSize) { void* ramAddr; s32 i; - D_801755D0 = NULL; + gAudioCustomUpdateFunction = NULL; gAudioCtx.resetTimer = 0; { @@ -1138,25 +1138,26 @@ void AudioLoad_Init(void* heap, u32 heapSize) { } } + // 1000 is a conversion from seconds to milliseconds switch (osTvType) { case OS_TV_PAL: - gAudioCtx.unk_2960 = 20.03042f; - gAudioCtx.refreshRate = 50; + gAudioCtx.maxTempoTvTypeFactors = 1000 * REFRESH_RATE_DEVIATION_PAL / REFRESH_RATE_PAL; + gAudioCtx.refreshRate = REFRESH_RATE_PAL; break; case OS_TV_MPAL: - gAudioCtx.unk_2960 = 16.546f; - gAudioCtx.refreshRate = 60; + gAudioCtx.maxTempoTvTypeFactors = 1000 * REFRESH_RATE_DEVIATION_MPAL / REFRESH_RATE_MPAL; + gAudioCtx.refreshRate = REFRESH_RATE_MPAL; break; case OS_TV_NTSC: default: - gAudioCtx.unk_2960 = 16.713f; - gAudioCtx.refreshRate = 60; + gAudioCtx.maxTempoTvTypeFactors = 1000 * REFRESH_RATE_DEVIATION_NTSC / REFRESH_RATE_NTSC; + gAudioCtx.refreshRate = REFRESH_RATE_NTSC; break; } - Audio_InitMesgQueues(); + AudioThread_InitMesgQueues(); for (i = 0; i < 3; i++) { gAudioCtx.aiBufLengths[i] = 0xA0; @@ -1209,7 +1210,7 @@ void AudioLoad_Init(void* heap, u32 heapSize) { gAudioCtx.numSequences = gAudioCtx.sequenceTable->numEntries; - gAudioCtx.audioResetSpecIdToLoad = 0; + gAudioCtx.specId = 0; gAudioCtx.resetStatus = 1; // Set reset to immediately initialize the audio heap AudioHeap_ResetStep(); diff --git a/src/audio/lib/playback.c b/src/audio/lib/playback.c index 87e2f792c2..9c1b8126e4 100644 --- a/src/audio/lib/playback.c +++ b/src/audio/lib/playback.c @@ -100,8 +100,8 @@ void Audio_InitNoteSub(Note* note, NoteSubEu* sub, NoteSubAttributes* attrs) { sub->gain = attrs->gain; sub->filter = attrs->filter; - sub->unk_07 = attrs->unk_14; - sub->unk_0E = attrs->unk_16; + sub->combFilterSize = attrs->combFilterSize; + sub->combFilterGain = attrs->combFilterGain; sub->reverbVol = reverbVol; } @@ -174,7 +174,7 @@ void Audio_ProcessNotes(void) { if (note != playbackState->parentLayer->note && playbackState->unk_04 == 0) { playbackState->adsr.action.s.release = true; - playbackState->adsr.fadeOutVel = gAudioCtx.audioBufferParameters.updatesPerFrameInv; + playbackState->adsr.fadeOutVel = gAudioCtx.audioBufferParameters.ticksPerUpdateInv; playbackState->priority = 1; playbackState->unk_04 = 2; goto out; @@ -256,8 +256,8 @@ void Audio_ProcessNotes(void) { subAttrs.stereo = attrs->stereo; subAttrs.gain = attrs->gain; subAttrs.filter = attrs->filter; - subAttrs.unk_14 = attrs->unk_4; - subAttrs.unk_16 = attrs->unk_6; + subAttrs.combFilterSize = attrs->combFilterSize; + subAttrs.combFilterGain = attrs->combFilterGain; bookOffset = noteSubEu->bitField1.bookOffset; } else { SequenceLayer* layer = playbackState->parentLayer; @@ -271,11 +271,11 @@ void Audio_ProcessNotes(void) { } else { subAttrs.stereo = layer->stereo; } - subAttrs.reverbVol = channel->reverb; + subAttrs.reverbVol = channel->targetReverbVol; subAttrs.gain = channel->gain; subAttrs.filter = channel->filter; - subAttrs.unk_14 = channel->unk_0F; - subAttrs.unk_16 = channel->unk_20; + subAttrs.combFilterSize = channel->combFilterSize; + subAttrs.combFilterGain = channel->combFilterGain; bookOffset = channel->bookOffset & 0x7; if (channel->seqPlayer->muted && (channel->muteBehavior & MUTE_BEHAVIOR_3)) { @@ -433,7 +433,7 @@ s32 Audio_SetFontInstrument(s32 instrumentType, s32 fontId, s32 index, void* val void Audio_SeqLayerDecayRelease(SequenceLayer* layer, s32 target) { Note* note; NoteAttributes* attrs; - SequenceChannel* chan; + SequenceChannel* channel; s32 i; if (layer == NO_LAYER) { @@ -456,7 +456,7 @@ void Audio_SeqLayerDecayRelease(SequenceLayer* layer, s32 target) { if (note->playbackState.parentLayer != layer) { if (note->playbackState.parentLayer == NO_LAYER && note->playbackState.wantedParentLayer == NO_LAYER && note->playbackState.prevParentLayer == layer && target != ADSR_STATE_DECAY) { - note->playbackState.adsr.fadeOutVel = gAudioCtx.audioBufferParameters.updatesPerFrameInv; + note->playbackState.adsr.fadeOutVel = gAudioCtx.audioBufferParameters.ticksPerUpdateInv; note->playbackState.adsr.action.s.release = true; } return; @@ -468,10 +468,10 @@ void Audio_SeqLayerDecayRelease(SequenceLayer* layer, s32 target) { attrs->pan = layer->notePan; if (layer->channel != NULL) { - chan = layer->channel; - attrs->reverb = chan->reverb; - attrs->gain = chan->gain; - attrs->filter = chan->filter; + channel = layer->channel; + attrs->reverb = channel->targetReverbVol; + attrs->gain = channel->gain; + attrs->filter = channel->filter; if (attrs->filter != NULL) { for (i = 0; i < 8; i++) { @@ -480,18 +480,18 @@ void Audio_SeqLayerDecayRelease(SequenceLayer* layer, s32 target) { attrs->filter = attrs->filterBuf; } - attrs->unk_6 = chan->unk_20; - attrs->unk_4 = chan->unk_0F; - if (chan->seqPlayer->muted && (chan->muteBehavior & MUTE_BEHAVIOR_3)) { + attrs->combFilterGain = channel->combFilterGain; + attrs->combFilterSize = channel->combFilterSize; + if (channel->seqPlayer->muted && (channel->muteBehavior & MUTE_BEHAVIOR_3)) { note->noteSubEu.bitField0.finished = true; } if (layer->stereo.asByte == 0) { - attrs->stereo = chan->stereo; + attrs->stereo = channel->stereo; } else { attrs->stereo = layer->stereo; } - note->playbackState.priority = chan->someOtherPriority; + note->playbackState.priority = channel->someOtherPriority; } else { attrs->stereo = layer->stereo; note->playbackState.priority = 1; @@ -500,7 +500,7 @@ void Audio_SeqLayerDecayRelease(SequenceLayer* layer, s32 target) { note->playbackState.prevParentLayer = note->playbackState.parentLayer; note->playbackState.parentLayer = NO_LAYER; if (target == ADSR_STATE_RELEASE) { - note->playbackState.adsr.fadeOutVel = gAudioCtx.audioBufferParameters.updatesPerFrameInv; + note->playbackState.adsr.fadeOutVel = gAudioCtx.audioBufferParameters.ticksPerUpdateInv; note->playbackState.adsr.action.s.release = true; note->playbackState.unk_04 = 2; } else { @@ -805,7 +805,7 @@ void Audio_NoteReleaseAndTakeOwnership(Note* note, SequenceLayer* layer) { note->playbackState.wantedParentLayer = layer; note->playbackState.priority = layer->channel->notePriority; - note->playbackState.adsr.fadeOutVel = gAudioCtx.audioBufferParameters.updatesPerFrameInv; + note->playbackState.adsr.fadeOutVel = gAudioCtx.audioBufferParameters.ticksPerUpdateInv; note->playbackState.adsr.action.s.release = true; } diff --git a/src/audio/lib/seqplayer.c b/src/audio/lib/seqplayer.c index 008bedea61..620f7a4534 100644 --- a/src/audio/lib/seqplayer.c +++ b/src/audio/lib/seqplayer.c @@ -259,7 +259,7 @@ void AudioSeq_InitSequenceChannel(SequenceChannel* channel) { channel->enabled = false; channel->finished = false; channel->stopScript = false; - channel->stopSomething2 = false; + channel->muted = false; channel->hasInstrument = false; channel->stereoHeadsetEffects = false; channel->transposition = 0; @@ -274,7 +274,7 @@ void AudioSeq_InitSequenceChannel(SequenceChannel* channel) { channel->gateTimeRandomVariance = 0; channel->noteUnused = NULL; channel->reverbIndex = 0; - channel->reverb = 0; + channel->targetReverbVol = 0; channel->gain = 0; channel->notePriority = 3; channel->someOtherPriority = 1; @@ -284,20 +284,20 @@ void AudioSeq_InitSequenceChannel(SequenceChannel* channel) { channel->adsr.sustain = 0; channel->vibratoRateTarget = 0x800; channel->vibratoRateStart = 0x800; - channel->vibratoExtentTarget = 0; - channel->vibratoExtentStart = 0; + channel->vibratoDepthTarget = 0; + channel->vibratoDepthStart = 0; channel->vibratoRateChangeDelay = 0; - channel->vibratoExtentChangeDelay = 0; + channel->vibratoDepthChangeDelay = 0; channel->vibratoDelay = 0; channel->filter = NULL; - channel->unk_20 = 0; - channel->unk_0F = 0; + channel->combFilterGain = 0; + channel->combFilterSize = 0; channel->volume = 1.0f; channel->volumeScale = 1.0f; channel->freqScale = 1.0f; - for (i = 0; i < ARRAY_COUNT(channel->soundScriptIO); i++) { - channel->soundScriptIO[i] = SEQ_IO_VAL_NONE; + for (i = 0; i < ARRAY_COUNT(channel->seqScriptIO); i++) { + channel->seqScriptIO[i] = SEQ_IO_VAL_NONE; } channel->unused = false; @@ -326,7 +326,7 @@ s32 AudioSeq_SeqChannelSetLayer(SequenceChannel* channel, s32 layerIndex) { layer->adsr.decayIndex = 0; layer->enabled = true; layer->finished = false; - layer->stopSomething = false; + layer->muted = false; layer->continuousNotes = false; layer->bit3 = false; layer->ignoreDrumPan = false; @@ -530,9 +530,9 @@ void AudioSeq_SeqLayerProcessScript(SequenceLayer* layer) { if (layer->delay > 1) { layer->delay--; - if (!layer->stopSomething && layer->delay <= layer->gateDelay) { + if (!layer->muted && (layer->delay <= layer->gateDelay)) { Audio_SeqLayerNoteDecay(layer); - layer->stopSomething = true; + layer->muted = true; } return; } @@ -555,7 +555,7 @@ void AudioSeq_SeqLayerProcessScript(SequenceLayer* layer) { AudioSeq_SeqLayerProcessScriptStep5(layer, cmd); } - if (layer->stopSomething == true) { + if (layer->muted == true) { if ((layer->note != NULL) || layer->continuousNotes) { Audio_SeqLayerNoteDecay(layer); } @@ -579,9 +579,9 @@ void AudioSeq_SeqLayerProcessScriptStep1(SequenceLayer* layer) { s32 AudioSeq_SeqLayerProcessScriptStep5(SequenceLayer* layer, s32 sameTunedSample) { Note* note; - if (!layer->stopSomething && layer->tunedSample != NULL && - layer->tunedSample->sample->codec == CODEC_S16_INMEMORY && layer->tunedSample->sample->medium != MEDIUM_RAM) { - layer->stopSomething = true; + if (!layer->muted && (layer->tunedSample != NULL) && (layer->tunedSample->sample->codec == CODEC_S16_INMEMORY) && + (layer->tunedSample->sample->medium != MEDIUM_RAM)) { + layer->muted = true; return PROCESS_SCRIPT_END; } @@ -812,7 +812,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) { drum = Audio_GetDrum(channel->fontId, semitone); if (drum == NULL) { - layer->stopSomething = true; + layer->muted = true; layer->delay2 = layer->delay; return PROCESS_SCRIPT_END; } @@ -834,7 +834,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) { soundEffect = Audio_GetSoundEffect(channel->fontId, sfxId); if (soundEffect == NULL) { - layer->stopSomething = true; + layer->muted = true; layer->delay2 = layer->delay + 1; return PROCESS_SCRIPT_END; } @@ -850,7 +850,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) { layer->semitone = semitone; if (semitone >= 0x80) { - layer->stopSomething = true; + layer->muted = true; return PROCESS_SCRIPT_END; } @@ -903,12 +903,12 @@ s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) { portamento->extent = (freqScale2 / freqScale) - 1.0f; if (PORTAMENTO_IS_SPECIAL(*portamento)) { - speed = seqPlayer->tempo * 0x8000 / gAudioCtx.tempoInternalToExternal; + speed = seqPlayer->tempo * 0x8000 / gAudioCtx.maxTempo; if (layer->delay != 0) { speed = speed * 0x100 / (layer->delay * layer->portamentoTime); } } else { - speed = 0x20000 / (layer->portamentoTime * gAudioCtx.audioBufferParameters.updatesPerFrame); + speed = 0x20000 / (layer->portamentoTime * gAudioCtx.audioBufferParameters.ticksPerUpdate); } if (speed >= 0x7FFF) { @@ -964,7 +964,7 @@ s32 AudioSeq_SeqLayerProcessScriptStep4(SequenceLayer* layer, s32 cmd) { // (It's a bit unclear if 'portamento' has actually always been // set when this is reached...) if (PORTAMENTO_IS_SPECIAL(*portamento)) { - speed2 = seqPlayer->tempo * 0x8000 / gAudioCtx.tempoInternalToExternal; + speed2 = seqPlayer->tempo * 0x8000 / gAudioCtx.maxTempo; speed2 = speed2 * 0x100 / (layer->delay * layer->portamentoTime); if (speed2 >= 0x7FFF) { speed2 = 0x7FFF; @@ -989,12 +989,12 @@ s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd) { if (cmd == 0xC0) { layer->delay = AudioSeq_ScriptReadCompressedU16(state); - layer->stopSomething = true; + layer->muted = true; layer->bit1 = false; return PROCESS_SCRIPT_END; } - layer->stopSomething = false; + layer->muted = false; if (channel->largeNotes == true) { switch (cmd & 0xC0) { @@ -1078,13 +1078,13 @@ s32 AudioSeq_SeqLayerProcessScriptStep3(SequenceLayer* layer, s32 cmd) { } if ((seqPlayer->muted && (channel->muteBehavior & (MUTE_BEHAVIOR_STOP_NOTES | MUTE_BEHAVIOR_4))) || - channel->stopSomething2) { - layer->stopSomething = true; + channel->muted) { + layer->muted = true; return PROCESS_SCRIPT_END; } if (seqPlayer->skipTicks != 0) { - layer->stopSomething = true; + layer->muted = true; return PROCESS_SCRIPT_END; } @@ -1329,9 +1329,9 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { case 0xD8: cmd = (u8)cmdArgs[0]; - channel->vibratoExtentTarget = cmd * 8; - channel->vibratoExtentStart = 0; - channel->vibratoExtentChangeDelay = 0; + channel->vibratoDepthTarget = cmd * 8; + channel->vibratoDepthStart = 0; + channel->vibratoDepthChangeDelay = 0; break; case 0xD7: @@ -1343,11 +1343,11 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { case 0xE2: cmd = (u8)cmdArgs[0]; - channel->vibratoExtentStart = cmd * 8; + channel->vibratoDepthStart = cmd * 8; cmd = (u8)cmdArgs[1]; - channel->vibratoExtentTarget = cmd * 8; + channel->vibratoDepthTarget = cmd * 8; cmd = (u8)cmdArgs[2]; - channel->vibratoExtentChangeDelay = cmd * 16; + channel->vibratoDepthChangeDelay = cmd * 16; break; case 0xE1: @@ -1366,7 +1366,7 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { case 0xD4: cmd = (u8)cmdArgs[0]; - channel->reverb = cmd; + channel->targetReverbVol = cmd; break; case 0xC6: @@ -1483,7 +1483,7 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { data += 4; channel->newPan = data[-3]; channel->panChannelWeight = data[-2]; - channel->reverb = data[-1]; + channel->targetReverbVol = data[-1]; channel->reverbIndex = data[0]; //! @bug: Not marking reverb state as changed channel->changes.s.pan = true; @@ -1497,16 +1497,16 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { channel->transposition = (s8)AudioSeq_ScriptReadU8(scriptState); channel->newPan = AudioSeq_ScriptReadU8(scriptState); channel->panChannelWeight = AudioSeq_ScriptReadU8(scriptState); - channel->reverb = AudioSeq_ScriptReadU8(scriptState); + channel->targetReverbVol = AudioSeq_ScriptReadU8(scriptState); channel->reverbIndex = AudioSeq_ScriptReadU8(scriptState); //! @bug: Not marking reverb state as changed channel->changes.s.pan = true; break; case 0xEC: - channel->vibratoExtentTarget = 0; - channel->vibratoExtentStart = 0; - channel->vibratoExtentChangeDelay = 0; + channel->vibratoDepthTarget = 0; + channel->vibratoDepthStart = 0; + channel->vibratoDepthChangeDelay = 0; channel->vibratoRateTarget = 0; channel->vibratoRateStart = 0; channel->vibratoRateChangeDelay = 0; @@ -1515,8 +1515,8 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { channel->adsr.sustain = 0; channel->velocityRandomVariance = 0; channel->gateTimeRandomVariance = 0; - channel->unk_0F = 0; - channel->unk_20 = 0; + channel->combFilterSize = 0; + channel->combFilterGain = 0; channel->bookOffset = 0; channel->freqScale = 1.0f; break; @@ -1578,7 +1578,7 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { break; case 0xBD: - temp2 = Audio_NextRandom(); + temp2 = AudioThread_NextRandom(); channel->unk_22 = (cmdArgs[0] == 0) ? (temp2 & 0xFFFF) : (temp2 % cmdArgs[0]); channel->unk_22 += cmdArgs[1]; temp2 = (channel->unk_22 / 0x100) + 0x80; @@ -1595,8 +1595,8 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { break; case 0xBB: - channel->unk_0F = cmdArgs[0]; - channel->unk_20 = cmdArgs[1]; + channel->combFilterSize = cmdArgs[0]; + channel->combFilterGain = cmdArgs[1]; break; case 0xBC: @@ -1642,7 +1642,7 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { break; case 0x70: - channel->soundScriptIO[lowBits] = scriptState->value; + channel->seqScriptIO[lowBits] = scriptState->value; break; case 0x78: @@ -1664,26 +1664,26 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { case 0x10: if (lowBits < 8) { - channel->soundScriptIO[lowBits] = SEQ_IO_VAL_NONE; - if (AudioLoad_SlowLoadSample(channel->fontId, scriptState->value, - &channel->soundScriptIO[lowBits]) == -1) {} + channel->seqScriptIO[lowBits] = SEQ_IO_VAL_NONE; + if (AudioLoad_SlowLoadSample(channel->fontId, scriptState->value, &channel->seqScriptIO[lowBits]) == + -1) {} } else { lowBits -= 8; - channel->soundScriptIO[lowBits] = SEQ_IO_VAL_NONE; + channel->seqScriptIO[lowBits] = SEQ_IO_VAL_NONE; if (AudioLoad_SlowLoadSample(channel->fontId, channel->unk_22 + 0x100, - &channel->soundScriptIO[lowBits]) == -1) {} + &channel->seqScriptIO[lowBits]) == -1) {} } break; case 0x60: - scriptState->value = channel->soundScriptIO[lowBits]; + scriptState->value = channel->seqScriptIO[lowBits]; if (lowBits < 2) { - channel->soundScriptIO[lowBits] = SEQ_IO_VAL_NONE; + channel->seqScriptIO[lowBits] = SEQ_IO_VAL_NONE; } break; case 0x50: - scriptState->value -= channel->soundScriptIO[lowBits]; + scriptState->value -= channel->seqScriptIO[lowBits]; break; case 0x20: @@ -1693,12 +1693,12 @@ void AudioSeq_SequenceChannelProcessScript(SequenceChannel* channel) { case 0x30: cmd = AudioSeq_ScriptReadU8(scriptState); - seqPlayer->channels[lowBits]->soundScriptIO[cmd] = scriptState->value; + seqPlayer->channels[lowBits]->seqScriptIO[cmd] = scriptState->value; break; case 0x40: cmd = AudioSeq_ScriptReadU8(scriptState); - scriptState->value = seqPlayer->channels[lowBits]->soundScriptIO[cmd]; + scriptState->value = seqPlayer->channels[lowBits]->seqScriptIO[cmd]; break; } } @@ -1743,14 +1743,18 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) { } seqPlayer->scriptCounter++; - seqPlayer->tempoAcc += seqPlayer->tempo; - seqPlayer->tempoAcc += (s16)seqPlayer->unk_0C; - if (seqPlayer->tempoAcc < gAudioCtx.tempoInternalToExternal) { + // Apply the tempo by controlling the number of updates run on the .seq script. + // Processing the .seq script every possible update will result in a tempo = maxTempo + // Processing the .seq script a fraction of the updates will result in a `tempo = fraction * maxTempo` + // where `fraction = (tempo + tempoChange) / maxTempo` + // This algorithm uses `tempoAcc` to discretize `(tempo + tempoChange) / maxTempo` + seqPlayer->tempoAcc += seqPlayer->tempo; + seqPlayer->tempoAcc += (s16)seqPlayer->tempoChange; + if (seqPlayer->tempoAcc < gAudioCtx.maxTempo) { return; } - - seqPlayer->tempoAcc -= (u16)gAudioCtx.tempoInternalToExternal; + seqPlayer->tempoAcc -= (u16)gAudioCtx.maxTempo; if (seqPlayer->stopScript == true) { return; @@ -1810,9 +1814,9 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) { break; case 0xDD: - seqPlayer->tempo = AudioSeq_ScriptReadU8(seqScript) * TATUMS_PER_BEAT; - if (seqPlayer->tempo > gAudioCtx.tempoInternalToExternal) { - seqPlayer->tempo = (u16)gAudioCtx.tempoInternalToExternal; + seqPlayer->tempo = AudioSeq_ScriptReadU8(seqScript) * SEQTICKS_PER_BEAT; + if (seqPlayer->tempo > gAudioCtx.maxTempo) { + seqPlayer->tempo = (u16)gAudioCtx.maxTempo; } if ((s16)seqPlayer->tempo <= 0) { @@ -1821,7 +1825,7 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) { break; case 0xDC: - seqPlayer->unk_0C = (s8)AudioSeq_ScriptReadU8(seqScript) * TATUMS_PER_BEAT; + seqPlayer->tempoChange = (s8)AudioSeq_ScriptReadU8(seqScript) * SEQTICKS_PER_BEAT; break; case 0xDA: @@ -1982,17 +1986,17 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) { break; case 0x50: - seqScript->value -= seqPlayer->soundScriptIO[cmdLowBits]; + seqScript->value -= seqPlayer->seqScriptIO[cmdLowBits]; break; case 0x70: - seqPlayer->soundScriptIO[cmdLowBits] = seqScript->value; + seqPlayer->seqScriptIO[cmdLowBits] = seqScript->value; break; case 0x80: - seqScript->value = seqPlayer->soundScriptIO[cmdLowBits]; + seqScript->value = seqPlayer->seqScriptIO[cmdLowBits]; if (cmdLowBits < 2) { - seqPlayer->soundScriptIO[cmdLowBits] = SEQ_IO_VAL_NONE; + seqPlayer->seqScriptIO[cmdLowBits] = SEQ_IO_VAL_NONE; } break; @@ -2014,14 +2018,14 @@ void AudioSeq_SequencePlayerProcessSequence(SequencePlayer* seqPlayer) { cmd = AudioSeq_ScriptReadU8(seqScript); temp = AudioSeq_ScriptReadS16(seqScript); data2 = &seqPlayer->seqData[temp]; - AudioLoad_SlowLoadSeq(cmd, data2, &seqPlayer->soundScriptIO[cmdLowBits]); + AudioLoad_SlowLoadSeq(cmd, data2, &seqPlayer->seqScriptIO[cmdLowBits]); break; case 0x60: cmd = AudioSeq_ScriptReadU8(seqScript); value = cmd; temp = AudioSeq_ScriptReadU8(seqScript); - AudioLoad_ScriptLoad(value, temp, &seqPlayer->soundScriptIO[cmdLowBits]); + AudioLoad_ScriptLoad(value, temp, &seqPlayer->seqScriptIO[cmdLowBits]); break; } } @@ -2038,7 +2042,7 @@ void AudioSeq_ProcessSequences(s32 arg0) { SequencePlayer* seqPlayer; u32 i; - gAudioCtx.noteSubEuOffset = (gAudioCtx.audioBufferParameters.updatesPerFrame - arg0 - 1) * gAudioCtx.numNotes; + gAudioCtx.noteSubEuOffset = (gAudioCtx.audioBufferParameters.ticksPerUpdate - arg0 - 1) * gAudioCtx.numNotes; for (i = 0; i < (u32)gAudioCtx.audioBufferParameters.numSequencePlayers; i++) { seqPlayer = &gAudioCtx.seqPlayers[i]; @@ -2069,8 +2073,8 @@ void AudioSeq_ResetSequencePlayer(SequencePlayer* seqPlayer) { seqPlayer->fadeTimer = 0; seqPlayer->fadeTimerUnkEu = 0; seqPlayer->tempoAcc = 0; - seqPlayer->tempo = 120 * TATUMS_PER_BEAT; // 120 BPM - seqPlayer->unk_0C = 0; + seqPlayer->tempo = 120 * SEQTICKS_PER_BEAT; // 120 BPM + seqPlayer->tempoChange = 0; seqPlayer->transposition = 0; seqPlayer->noteAllocPolicy = 0; seqPlayer->shortNoteVelocityTable = gDefaultShortNoteVelocityTable; @@ -2122,8 +2126,8 @@ void AudioSeq_InitSequencePlayer(SequencePlayer* seqPlayer) { seqPlayer->seqDmaInProgress = false; seqPlayer->applyBend = false; - for (j = 0; j < ARRAY_COUNT(seqPlayer->soundScriptIO); j++) { - seqPlayer->soundScriptIO[j] = SEQ_IO_VAL_NONE; + for (j = 0; j < ARRAY_COUNT(seqPlayer->seqScriptIO); j++) { + seqPlayer->seqScriptIO[j] = SEQ_IO_VAL_NONE; } seqPlayer->muteBehavior = MUTE_BEHAVIOR_SOFTEN | MUTE_BEHAVIOR_STOP_NOTES; diff --git a/src/audio/lib/synthesis.c b/src/audio/lib/synthesis.c index 51b2c2e5ab..321bd79a51 100644 --- a/src/audio/lib/synthesis.c +++ b/src/audio/lib/synthesis.c @@ -5,7 +5,7 @@ #define DMEM_TEMP 0x3C0 #define DMEM_UNCOMPRESSED_NOTE 0x580 #define DMEM_HAAS_TEMP 0x5C0 -#define DMEM_SCRATCH2 0x760 // = DMEM_TEMP + DMEM_2CH_SIZE + a bit more +#define DMEM_COMB_TEMP 0x760 // = DMEM_TEMP + DMEM_2CH_SIZE + a bit more #define DMEM_COMPRESSED_ADPCM_DATA 0x940 // = DMEM_LEFT_CH #define DMEM_LEFT_CH 0x940 #define DMEM_RIGHT_CH 0xAE0 @@ -38,14 +38,14 @@ u32 sEnvMixerOp = _SHIFTL(A_ENVMIXER, 24, 8); // Store the left dry channel in a temp space to be delayed to produce the haas effect u32 sEnvMixerLeftHaasDmemDests = - MK_CMD(DMEM_HAAS_TEMP >> 4, DMEM_RIGHT_CH >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4); + AUDIO_MK_CMD(DMEM_HAAS_TEMP >> 4, DMEM_RIGHT_CH >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4); // Store the right dry channel in a temp space to be delayed to produce the haas effect u32 sEnvMixerRightHaasDmemDests = - MK_CMD(DMEM_LEFT_CH >> 4, DMEM_HAAS_TEMP >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4); + AUDIO_MK_CMD(DMEM_LEFT_CH >> 4, DMEM_HAAS_TEMP >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4); u32 sEnvMixerDefaultDmemDests = - MK_CMD(DMEM_LEFT_CH >> 4, DMEM_RIGHT_CH >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4); + AUDIO_MK_CMD(DMEM_LEFT_CH >> 4, DMEM_RIGHT_CH >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4); u16 D_801304B0[] = { 0x7FFF, 0xD001, 0x3FFF, 0xF001, 0x5FFF, 0x9001, 0x7FFF, 0x8001, @@ -158,32 +158,32 @@ Acmd* AudioSynth_Update(Acmd* cmdStart, s32* cmdCnt, s16* aiStart, s32 aiBufLen) SynthesisReverb* reverb; cmdP = cmdStart; - for (i = gAudioCtx.audioBufferParameters.updatesPerFrame; i > 0; i--) { + for (i = gAudioCtx.audioBufferParameters.ticksPerUpdate; i > 0; i--) { AudioSeq_ProcessSequences(i - 1); - func_800DB03C(gAudioCtx.audioBufferParameters.updatesPerFrame - i); + func_800DB03C(gAudioCtx.audioBufferParameters.ticksPerUpdate - i); } aiBufP = aiStart; gAudioCtx.curLoadedBook = NULL; - for (i = gAudioCtx.audioBufferParameters.updatesPerFrame; i > 0; i--) { + for (i = gAudioCtx.audioBufferParameters.ticksPerUpdate; i > 0; i--) { if (i == 1) { chunkLen = aiBufLen; - } else if ((aiBufLen / i) >= gAudioCtx.audioBufferParameters.samplesPerUpdateMax) { - chunkLen = gAudioCtx.audioBufferParameters.samplesPerUpdateMax; - } else if (gAudioCtx.audioBufferParameters.samplesPerUpdateMin >= (aiBufLen / i)) { - chunkLen = gAudioCtx.audioBufferParameters.samplesPerUpdateMin; + } else if ((aiBufLen / i) >= gAudioCtx.audioBufferParameters.samplesPerTickMax) { + chunkLen = gAudioCtx.audioBufferParameters.samplesPerTickMax; + } else if (gAudioCtx.audioBufferParameters.samplesPerTickMin >= (aiBufLen / i)) { + chunkLen = gAudioCtx.audioBufferParameters.samplesPerTickMin; } else { - chunkLen = gAudioCtx.audioBufferParameters.samplesPerUpdate; + chunkLen = gAudioCtx.audioBufferParameters.samplesPerTick; } for (j = 0; j < gAudioCtx.numSynthesisReverbs; j++) { if (gAudioCtx.synthesisReverbs[j].useReverb) { - AudioSynth_InitNextRingBuf(chunkLen, gAudioCtx.audioBufferParameters.updatesPerFrame - i, j); + AudioSynth_InitNextRingBuf(chunkLen, gAudioCtx.audioBufferParameters.ticksPerUpdate - i, j); } } - cmdP = AudioSynth_DoOneAudioUpdate(aiBufP, chunkLen, cmdP, gAudioCtx.audioBufferParameters.updatesPerFrame - i); + cmdP = AudioSynth_DoOneAudioUpdate(aiBufP, chunkLen, cmdP, gAudioCtx.audioBufferParameters.ticksPerUpdate - i); aiBufLen -= chunkLen; aiBufP += 2 * chunkLen; } @@ -203,7 +203,7 @@ void func_800DB2C0(s32 updateIndex, s32 noteIndex) { NoteSubEu* noteSubEu; s32 i; - for (i = updateIndex + 1; i < gAudioCtx.audioBufferParameters.updatesPerFrame; i++) { + for (i = updateIndex + 1; i < gAudioCtx.audioBufferParameters.ticksPerUpdate; i++) { noteSubEu = &gAudioCtx.noteSubsEu[(gAudioCtx.numNotes * i) + noteIndex]; if (!noteSubEu->bitField0.needsInit) { noteSubEu->bitField0.enabled = false; @@ -717,7 +717,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS s32 frameIndex; s32 skipBytes; s32 temp_v1_6; - void* buf; + s16* combFilterState; s32 nSamplesToDecode; u32 sampleAddr; u32 samplesLenFixedPoint; @@ -740,12 +740,12 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS s32 resampledTempLen; u16 sampleDmemBeforeResampling; s32 sampleDataOffset; - s32 thing; + s32 combFilterDmem; s32 s5; Note* note; u32 numSamplesToLoad; - u16 unk7; - u16 unkE; + u16 combFilterSize; + u16 combFilterGain; s16* filter; s32 bookOffset; s32 finished; @@ -769,7 +769,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS synthState->prevHaasEffectRightDelaySize = 0; synthState->reverbVol = noteSubEu->reverbVol; synthState->numParts = 0; - synthState->unk_1A = 1; + synthState->combFilterNeedsInit = true; note->noteSubEu.bitField0.finished = false; finished = false; } @@ -1089,23 +1089,26 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS AudioSynth_LoadFilterBuffer(cmd++, flags, DMEM_TEMP, synthState->synthesisBuffers->mixEnvelopeState); } - unk7 = noteSubEu->unk_07; - unkE = noteSubEu->unk_0E; - buf = synthState->synthesisBuffers->unkState; - if (unk7 != 0 && noteSubEu->unk_0E != 0) { - AudioSynth_DMemMove(cmd++, DMEM_TEMP, DMEM_SCRATCH2, aiBufLen * SAMPLE_SIZE); - thing = DMEM_SCRATCH2 - unk7; - if (synthState->unk_1A != 0) { - AudioSynth_ClearBuffer(cmd++, thing, unk7); - synthState->unk_1A = 0; + // Apply the comb filter to the mono-signal by taking the signal with a small temporal offset, + // and adding it back to itself + combFilterSize = noteSubEu->combFilterSize; + combFilterGain = noteSubEu->combFilterGain; + combFilterState = synthState->synthesisBuffers->combFilterState; + if ((combFilterSize != 0) && (noteSubEu->combFilterGain != 0)) { + AudioSynth_DMemMove(cmd++, DMEM_TEMP, DMEM_COMB_TEMP, aiBufLen * SAMPLE_SIZE); + combFilterDmem = DMEM_COMB_TEMP - combFilterSize; + if (synthState->combFilterNeedsInit) { + AudioSynth_ClearBuffer(cmd++, combFilterDmem, combFilterSize); + synthState->combFilterNeedsInit = false; } else { - AudioSynth_LoadBuffer(cmd++, thing, unk7, buf); + AudioSynth_LoadBuffer(cmd++, combFilterDmem, combFilterSize, combFilterState); } - AudioSynth_SaveBuffer(cmd++, DMEM_TEMP + (aiBufLen * SAMPLE_SIZE) - unk7, unk7, buf); - AudioSynth_Mix(cmd++, (aiBufLen * (s32)SAMPLE_SIZE) >> 4, unkE, DMEM_SCRATCH2, thing); - AudioSynth_DMemMove(cmd++, thing, DMEM_TEMP, aiBufLen * SAMPLE_SIZE); + AudioSynth_SaveBuffer(cmd++, DMEM_TEMP + (aiBufLen * SAMPLE_SIZE) - combFilterSize, combFilterSize, + combFilterState); + AudioSynth_Mix(cmd++, (aiBufLen * (s32)SAMPLE_SIZE) >> 4, combFilterGain, DMEM_COMB_TEMP, combFilterDmem); + AudioSynth_DMemMove(cmd++, combFilterDmem, DMEM_TEMP, aiBufLen * SAMPLE_SIZE); } else { - synthState->unk_1A = 1; + synthState->combFilterNeedsInit = true; } if ((noteSubEu->haasEffectLeftDelaySize != 0) || (synthState->prevHaasEffectLeftDelaySize != 0)) { diff --git a/src/audio/lib/thread.c b/src/audio/lib/thread.c index 53cd7d2467..22afc33fdf 100644 --- a/src/audio/lib/thread.c +++ b/src/audio/lib/thread.c @@ -3,42 +3,23 @@ #define SAMPLES_TO_OVERPRODUCE 0x10 #define EXTRA_BUFFERED_AI_SAMPLES_TARGET 0x80 -typedef enum { - CHAN_UPD_UNK_0, // 0 - CHAN_UPD_VOL_SCALE, // 1 - CHAN_UPD_VOL, // 2 - CHAN_UPD_PAN_SIGNED, // 3 - CHAN_UPD_FREQ_SCALE, // 4 - CHAN_UPD_REVERB, // 5 - CHAN_UPD_SCRIPT_IO, // 6 - CHAN_UPD_PAN_UNSIGNED, // 7 - CHAN_UPD_STOP_SOMETHING2, // 8 - CHAN_UPD_MUTE_BEHAVE, // 9 - CHAN_UPD_VIBE_X8, // 10 - CHAN_UPD_VIBE_X32, // 11 - CHAN_UPD_UNK_0F, // 12 - CHAN_UPD_UNK_20, // 13 - CHAN_UPD_STEREO // 14 -} ChannelUpdateType; - -void func_800E6300(SequenceChannel* channel, AudioCmd* cmd); -void func_800E59AC(s32 playerIdx, s32 fadeTimer); -void Audio_InitMesgQueues(void); -AudioTask* func_800E5000(void); -void Audio_ProcessCmds(u32); -void func_800E6128(SequencePlayer* seqPlayer, AudioCmd* cmd); -void func_800E5958(s32 playerIdx, s32 fadeTimer); -s32 func_800E66C0(s32 arg0); +AudioTask* AudioThread_UpdateImpl(void); +void AudioThread_SetFadeInTimer(s32 seqPlayerIndex, s32 fadeTimer); +void AudioThread_SetFadeOutTimer(s32 seqPlayerIndex, s32 fadeTimer); +void AudioThread_ProcessCmds(u32); +void AudioThread_ProcessSeqPlayerCmd(SequencePlayer* seqPlayer, AudioCmd* cmd); +void AudioThread_ProcessChannelCmd(SequenceChannel* channel, AudioCmd* cmd); +s32 func_800E66C0(s32 flags); // AudioMgr_Retrace -AudioTask* func_800E4FE0(void) { - return func_800E5000(); +AudioTask* AudioThread_Update(void) { + return AudioThread_UpdateImpl(); } /** * This is Audio_Update for the audio thread */ -AudioTask* func_800E5000(void) { +AudioTask* AudioThread_UpdateImpl(void) { static s32 sMaxAbiCmdCnt = 0x80; static AudioTask* sWaitingAudioTask = NULL; u32 samplesRemainingInAi; @@ -55,8 +36,8 @@ AudioTask* func_800E5000(void) { gAudioCtx.totalTaskCount++; if (gAudioCtx.totalTaskCount % (gAudioCtx.audioBufferParameters.specUnk4) != 0) { - if (D_801755D0 != NULL) { - D_801755D0(); + if (gAudioCustomUpdateFunction != NULL) { + gAudioCustomUpdateFunction(); } if ((gAudioCtx.totalTaskCount % gAudioCtx.audioBufferParameters.specUnk4) + 1 == @@ -82,8 +63,8 @@ AudioTask* func_800E5000(void) { } } - if (D_801755D0 != NULL) { - D_801755D0(); + if (gAudioCustomUpdateFunction != NULL) { + gAudioCustomUpdateFunction(); } sp5C = gAudioCtx.curAudioFrameDmaCount; @@ -114,7 +95,7 @@ AudioTask* func_800E5000(void) { if (gAudioCtx.resetStatus != 0) { if (AudioHeap_ResetStep() == 0) { if (gAudioCtx.resetStatus == 0) { - osSendMesg(gAudioCtx.audioResetQueueP, (OSMesg)(u32)gAudioCtx.audioResetSpecIdToLoad, OS_MESG_NOBLOCK); + osSendMesg(gAudioCtx.audioResetQueueP, (OSMesg)(u32)gAudioCtx.specId, OS_MESG_NOBLOCK); } sWaitingAudioTask = NULL; @@ -151,13 +132,13 @@ AudioTask* func_800E5000(void) { j = 0; if (gAudioCtx.resetStatus == 0) { // msg = 0000RREE R = read pos, E = End Pos - while (osRecvMesg(gAudioCtx.cmdProcQueueP, (OSMesg*)&sp4C, OS_MESG_NOBLOCK) != -1) { + while (osRecvMesg(gAudioCtx.threadCmdProcQueueP, (OSMesg*)&sp4C, OS_MESG_NOBLOCK) != -1) { if (1) {} - Audio_ProcessCmds(sp4C); + AudioThread_ProcessCmds(sp4C); j++; } - if ((j == 0) && (gAudioCtx.cmdQueueFinished)) { - Audio_ScheduleProcessCmds(); + if ((j == 0) && (gAudioCtx.threadCmdQueueFinished)) { + AudioThread_ScheduleProcessCmds(); } } @@ -169,9 +150,9 @@ AudioTask* func_800E5000(void) { gAudioCtx.audioRandom = gAudioCtx.audioRandom + gAudioCtx.aiBuffers[index][gAudioCtx.totalTaskCount & 0xFF]; // gWaveSamples[8] interprets compiled assembly code as s16 samples as a way to generate sound with noise. - // Start with the address of func_800E4FE0, and offset it by a random number between 0 - 0xFFF0 + // Start with the address of AudioThread_Update, and offset it by a random number between 0 - 0xFFF0 // Use the resulting address as the starting address to interpret an array of samples i.e. `s16 samples[]` - gWaveSamples[8] = (s16*)(((u8*)func_800E4FE0) + (gAudioCtx.audioRandom & 0xFFF0)); + gWaveSamples[8] = (s16*)((u8*)AudioThread_Update + (gAudioCtx.audioRandom & 0xFFF0)); index = gAudioCtx.rspTaskIndex; gAudioCtx.curTask->msgQueue = NULL; @@ -208,63 +189,57 @@ AudioTask* func_800E5000(void) { } } -#define ACMD_SND_MDE ((u32)0xF0000000) -#define ACMD_MUTE ((u32)0xF1000000) - -void func_800E5584(AudioCmd* cmd) { +void AudioThread_ProcessGlobalCmd(AudioCmd* cmd) { s32 i; - s32 pad; - s32 pad2; - u32 temp_a1_5; - u32 temp_t7; + s32 pad[3]; + u32 flags; switch (cmd->op) { - case 0x81: + case AUDIOCMD_OP_GLOBAL_SYNC_LOAD_SEQ_PARTS: AudioLoad_SyncLoadSeqParts(cmd->arg1, cmd->arg2); break; - case 0x82: + case AUDIOCMD_OP_GLOBAL_INIT_SEQPLAYER: AudioLoad_SyncInitSeqPlayer(cmd->arg0, cmd->arg1, cmd->arg2); - func_800E59AC(cmd->arg0, cmd->asInt); + AudioThread_SetFadeInTimer(cmd->arg0, cmd->asInt); break; - case 0x85: + case AUDIOCMD_OP_GLOBAL_INIT_SEQPLAYER_SKIP_TICKS: AudioLoad_SyncInitSeqPlayerSkipTicks(cmd->arg0, cmd->arg1, cmd->asInt); break; - case 0x83: + case AUDIOCMD_OP_GLOBAL_DISABLE_SEQPLAYER: if (gAudioCtx.seqPlayers[cmd->arg0].enabled) { if (cmd->asInt == 0) { AudioSeq_SequencePlayerDisableAsFinished(&gAudioCtx.seqPlayers[cmd->arg0]); } else { - func_800E5958(cmd->arg0, cmd->asInt); + AudioThread_SetFadeOutTimer(cmd->arg0, cmd->asInt); } } break; - case 0xF0: + case AUDIOCMD_OP_GLOBAL_SET_SOUND_MODE: gAudioCtx.soundMode = cmd->asUInt; break; - case 0xF1: + case AUDIOCMD_OP_GLOBAL_MUTE: for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) { SequencePlayer* seqPlayer = &gAudioCtx.seqPlayers[i]; - seqPlayer->muted = 1; - seqPlayer->recalculateVolume = 1; + seqPlayer->muted = true; + seqPlayer->recalculateVolume = true; } break; - case 0xF2: + case AUDIOCMD_OP_GLOBAL_UNMUTE: if (cmd->asUInt == 1) { for (i = 0; i < gAudioCtx.numNotes; i++) { Note* note = &gAudioCtx.notes[i]; NoteSubEu* subEu = ¬e->noteSubEu; - if (subEu->bitField0.enabled && note->playbackState.unk_04 == 0) { - if (note->playbackState.parentLayer->channel->muteBehavior & MUTE_BEHAVIOR_3) { - subEu->bitField0.finished = true; - } + if (subEu->bitField0.enabled && (note->playbackState.unk_04 == 0) && + (note->playbackState.parentLayer->channel->muteBehavior & MUTE_BEHAVIOR_3)) { + subEu->bitField0.finished = true; } } } @@ -272,53 +247,53 @@ void func_800E5584(AudioCmd* cmd) { for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) { SequencePlayer* seqPlayer = &gAudioCtx.seqPlayers[i]; - seqPlayer->muted = 0; - seqPlayer->recalculateVolume = 1; + seqPlayer->muted = false; + seqPlayer->recalculateVolume = true; } break; - case 0xF3: + case AUDIOCMD_OP_GLOBAL_SYNC_LOAD_INSTRUMENT: AudioLoad_SyncLoadInstrument(cmd->arg0, cmd->arg1, cmd->arg2); break; - case 0xF4: + case AUDIOCMD_OP_GLOBAL_ASYNC_LOAD_SAMPLE_BANK: AudioLoad_AsyncLoadSampleBank(cmd->arg0, cmd->arg1, cmd->arg2, &gAudioCtx.externalLoadQueue); break; - case 0xF5: + case AUDIOCMD_OP_GLOBAL_ASYNC_LOAD_FONT: AudioLoad_AsyncLoadFont(cmd->arg0, cmd->arg1, cmd->arg2, &gAudioCtx.externalLoadQueue); break; - case 0xFC: + case AUDIOCMD_OP_GLOBAL_ASYNC_LOAD_SEQ: AudioLoad_AsyncLoadSeq(cmd->arg0, cmd->arg1, cmd->arg2, &gAudioCtx.externalLoadQueue); break; - case 0xF6: + case AUDIOCMD_OP_GLOBAL_DISCARD_SEQ_FONTS: AudioLoad_DiscardSeqFonts(cmd->arg1); break; - case 0x90: - gAudioCtx.unk_5BDC[cmd->arg0] = cmd->asUShort; + case AUDIOCMD_OP_GLOBAL_SET_CHANNEL_MASK: + gAudioCtx.threadCmdChannelMask[cmd->arg0] = cmd->asUShort; break; - case 0xF9: + case AUDIOCMD_OP_GLOBAL_RESET_AUDIO_HEAP: gAudioCtx.resetStatus = 5; - gAudioCtx.audioResetSpecIdToLoad = cmd->asUInt; + gAudioCtx.specId = cmd->asUInt; break; - case 0xFB: - D_801755D0 = (void (*)(void))cmd->asUInt; + case AUDIOCMD_OP_GLOBAL_SET_CUSTOM_UPDATE_FUNCTION: + gAudioCustomUpdateFunction = (AudioCustomUpdateFunction)cmd->asUInt; break; - case 0xE0: - case 0xE1: - case 0xE2: - Audio_SetFontInstrument(cmd->op - 0xE0, cmd->arg0, cmd->arg1, cmd->data); + case AUDIOCMD_OP_GLOBAL_SET_DRUM_FONT: + case AUDIOCMD_OP_GLOBAL_SET_SFX_FONT: + case AUDIOCMD_OP_GLOBAL_SET_INSTRUMENT_FONT: + Audio_SetFontInstrument(cmd->op - AUDIOCMD_OP_GLOBAL_SET_DRUM_FONT, cmd->arg0, cmd->arg1, cmd->data); break; - case 0xFE: - temp_t7 = cmd->asUInt; - if (temp_t7 == 1) { + case AUDIOCMD_OP_GLOBAL_DISABLE_ALL_SEQPLAYERS: + flags = cmd->asUInt; + if (flags == 1) { for (i = 0; i < gAudioCtx.audioBufferParameters.numSequencePlayers; i++) { SequencePlayer* seqPlayer = &gAudioCtx.seqPlayers[i]; @@ -327,10 +302,10 @@ void func_800E5584(AudioCmd* cmd) { } } } - func_800E66C0(temp_t7); + func_800E66C0(flags); break; - case 0xE3: + case AUDIOCMD_OP_GLOBAL_POP_PERSISTENT_CACHE: AudioHeap_PopPersistentCache(cmd->asInt); break; @@ -339,9 +314,8 @@ void func_800E5584(AudioCmd* cmd) { } } -// SetFadeOutTimer -void func_800E5958(s32 playerIdx, s32 fadeTimer) { - SequencePlayer* seqPlayer = &gAudioCtx.seqPlayers[playerIdx]; +void AudioThread_SetFadeOutTimer(s32 seqPlayerIndex, s32 fadeTimer) { + SequencePlayer* seqPlayer = &gAudioCtx.seqPlayers[seqPlayerIndex]; if (fadeTimer == 0) { fadeTimer = 1; @@ -352,12 +326,11 @@ void func_800E5958(s32 playerIdx, s32 fadeTimer) { seqPlayer->fadeTimer = fadeTimer; } -// SetFadeInTimer -void func_800E59AC(s32 playerIdx, s32 fadeTimer) { +void AudioThread_SetFadeInTimer(s32 seqPlayerIndex, s32 fadeTimer) { SequencePlayer* seqPlayer; if (fadeTimer != 0) { - seqPlayer = &gAudioCtx.seqPlayers[playerIdx]; + seqPlayer = &gAudioCtx.seqPlayers[seqPlayerIndex]; seqPlayer->state = 1; seqPlayer->fadeTimerUnkEu = fadeTimer; seqPlayer->fadeTimer = fadeTimer; @@ -366,63 +339,67 @@ void func_800E59AC(s32 playerIdx, s32 fadeTimer) { } } -void Audio_InitMesgQueuesInternal(void) { - gAudioCtx.cmdWrPos = 0; - gAudioCtx.cmdRdPos = 0; - gAudioCtx.cmdQueueFinished = 0; +void AudioThread_InitMesgQueuesImpl(void) { + gAudioCtx.threadCmdWritePos = 0; + gAudioCtx.threadCmdReadPos = 0; + gAudioCtx.threadCmdQueueFinished = false; + gAudioCtx.taskStartQueueP = &gAudioCtx.taskStartQueue; - gAudioCtx.cmdProcQueueP = &gAudioCtx.cmdProcQueue; + gAudioCtx.threadCmdProcQueueP = &gAudioCtx.threadCmdProcQueue; gAudioCtx.audioResetQueueP = &gAudioCtx.audioResetQueue; + osCreateMesgQueue(gAudioCtx.taskStartQueueP, gAudioCtx.taskStartMsgBuf, ARRAY_COUNT(gAudioCtx.taskStartMsgBuf)); - osCreateMesgQueue(gAudioCtx.cmdProcQueueP, gAudioCtx.cmdProcMsgBuf, ARRAY_COUNT(gAudioCtx.cmdProcMsgBuf)); + osCreateMesgQueue(gAudioCtx.threadCmdProcQueueP, gAudioCtx.threadCmdProcMsgBuf, + ARRAY_COUNT(gAudioCtx.threadCmdProcMsgBuf)); osCreateMesgQueue(gAudioCtx.audioResetQueueP, gAudioCtx.audioResetMsgBuf, ARRAY_COUNT(gAudioCtx.audioResetMsgBuf)); } -void Audio_QueueCmd(u32 opArgs, void** data) { - AudioCmd* cmd = &gAudioCtx.cmdBuf[gAudioCtx.cmdWrPos & 0xFF]; +void AudioThread_QueueCmd(u32 opArgs, void** data) { + AudioCmd* cmd = &gAudioCtx.threadCmdBuf[gAudioCtx.threadCmdWritePos & 0xFF]; cmd->opArgs = opArgs; cmd->data = *data; - gAudioCtx.cmdWrPos++; + gAudioCtx.threadCmdWritePos++; - if (gAudioCtx.cmdWrPos == gAudioCtx.cmdRdPos) { - gAudioCtx.cmdWrPos--; + if (gAudioCtx.threadCmdWritePos == gAudioCtx.threadCmdReadPos) { + gAudioCtx.threadCmdWritePos--; } } -void Audio_QueueCmdF32(u32 opArgs, f32 data) { - Audio_QueueCmd(opArgs, (void**)&data); +void AudioThread_QueueCmdF32(u32 opArgs, f32 data) { + AudioThread_QueueCmd(opArgs, (void**)&data); } -void Audio_QueueCmdS32(u32 opArgs, s32 data) { - Audio_QueueCmd(opArgs, (void**)&data); +void AudioThread_QueueCmdS32(u32 opArgs, s32 data) { + AudioThread_QueueCmd(opArgs, (void**)&data); } -void Audio_QueueCmdS8(u32 opArgs, s8 data) { +void AudioThread_QueueCmdS8(u32 opArgs, s8 data) { u32 uData = data << 0x18; - Audio_QueueCmd(opArgs, (void**)&uData); + AudioThread_QueueCmd(opArgs, (void**)&uData); } -void Audio_QueueCmdU16(u32 opArgs, u16 data) { +void AudioThread_QueueCmdU16(u32 opArgs, u16 data) { u32 uData = data << 0x10; - Audio_QueueCmd(opArgs, (void**)&uData); + AudioThread_QueueCmd(opArgs, (void**)&uData); } -s32 Audio_ScheduleProcessCmds(void) { +s32 AudioThread_ScheduleProcessCmds(void) { static s32 D_801304E8 = 0; s32 ret; - if (D_801304E8 < (u8)((gAudioCtx.cmdWrPos - gAudioCtx.cmdRdPos) + 0x100)) { - D_801304E8 = (u8)((gAudioCtx.cmdWrPos - gAudioCtx.cmdRdPos) + 0x100); + if (D_801304E8 < (u8)((gAudioCtx.threadCmdWritePos - gAudioCtx.threadCmdReadPos) + 0x100)) { + D_801304E8 = (u8)((gAudioCtx.threadCmdWritePos - gAudioCtx.threadCmdReadPos) + 0x100); } - ret = osSendMesg(gAudioCtx.cmdProcQueueP, - (OSMesg)(((gAudioCtx.cmdRdPos & 0xFF) << 8) | (gAudioCtx.cmdWrPos & 0xFF)), OS_MESG_NOBLOCK); + ret = osSendMesg(gAudioCtx.threadCmdProcQueueP, + (OSMesg)(((gAudioCtx.threadCmdReadPos & 0xFF) << 8) | (gAudioCtx.threadCmdWritePos & 0xFF)), + OS_MESG_NOBLOCK); if (ret != -1) { - gAudioCtx.cmdRdPos = gAudioCtx.cmdWrPos; + gAudioCtx.threadCmdReadPos = gAudioCtx.threadCmdWritePos; ret = 0; } else { return -1; @@ -431,72 +408,72 @@ s32 Audio_ScheduleProcessCmds(void) { return ret; } -void Audio_ResetCmdQueue(void) { - gAudioCtx.cmdQueueFinished = 0; - gAudioCtx.cmdRdPos = gAudioCtx.cmdWrPos; +void AudioThread_ResetCmdQueue(void) { + gAudioCtx.threadCmdQueueFinished = false; + gAudioCtx.threadCmdReadPos = gAudioCtx.threadCmdWritePos; } -void Audio_ProcessCmd(AudioCmd* cmd) { +void AudioThread_ProcessCmd(AudioCmd* cmd) { SequencePlayer* seqPlayer; - u16 phi_v0; - s32 i; + u16 threadCmdChannelMask; + s32 channelIndex; if ((cmd->op & 0xF0) == 0xF0) { - func_800E5584(cmd); + AudioThread_ProcessGlobalCmd(cmd); return; } if (cmd->arg0 < gAudioCtx.audioBufferParameters.numSequencePlayers) { seqPlayer = &gAudioCtx.seqPlayers[cmd->arg0]; if (cmd->op & 0x80) { - func_800E5584(cmd); + AudioThread_ProcessGlobalCmd(cmd); return; } if (cmd->op & 0x40) { - func_800E6128(seqPlayer, cmd); + AudioThread_ProcessSeqPlayerCmd(seqPlayer, cmd); return; } - if (cmd->arg1 < 0x10) { - func_800E6300(seqPlayer->channels[cmd->arg1], cmd); + if (cmd->arg1 < SEQ_NUM_CHANNELS) { + AudioThread_ProcessChannelCmd(seqPlayer->channels[cmd->arg1], cmd); return; } - if (cmd->arg1 == 0xFF) { - phi_v0 = gAudioCtx.unk_5BDC[cmd->arg0]; - for (i = 0; i < 16; i++) { - if (phi_v0 & 1) { - func_800E6300(seqPlayer->channels[i], cmd); + if (cmd->arg1 == AUDIOCMD_ALL_CHANNELS) { + threadCmdChannelMask = gAudioCtx.threadCmdChannelMask[cmd->arg0]; + for (channelIndex = 0; channelIndex < SEQ_NUM_CHANNELS; channelIndex++) { + if (threadCmdChannelMask & 1) { + AudioThread_ProcessChannelCmd(seqPlayer->channels[channelIndex], cmd); } - phi_v0 = phi_v0 >> 1; + threadCmdChannelMask = threadCmdChannelMask >> 1; } } } } -void Audio_ProcessCmds(u32 msg) { - static u8 curCmdRdPos = 0; +void AudioThread_ProcessCmds(u32 msg) { + static u8 sCurCmdRdPos = 0; AudioCmd* cmd; u8 endPos; - if (!gAudioCtx.cmdQueueFinished) { - curCmdRdPos = msg >> 8; + if (!gAudioCtx.threadCmdQueueFinished) { + sCurCmdRdPos = msg >> 8; } while (true) { endPos = msg & 0xFF; - if (curCmdRdPos == endPos) { - gAudioCtx.cmdQueueFinished = 0; + if (sCurCmdRdPos == endPos) { + gAudioCtx.threadCmdQueueFinished = false; return; } - cmd = &gAudioCtx.cmdBuf[curCmdRdPos++ & 0xFF]; - if (cmd->op == 0xF8) { - gAudioCtx.cmdQueueFinished = 1; + cmd = &gAudioCtx.threadCmdBuf[sCurCmdRdPos++ & 0xFF]; + if (cmd->op == AUDIOCMD_OP_GLOBAL_STOP_AUDIOCMDS) { + gAudioCtx.threadCmdQueueFinished = true; return; } - Audio_ProcessCmd(cmd); - cmd->op = 0; + AudioThread_ProcessCmd(cmd); + cmd->op = AUDIOCMD_OP_NOOP; } } @@ -511,8 +488,8 @@ u32 func_800E5E20(u32* out) { return sp1C >> 0x18; } -u8* func_800E5E84(s32 arg0, u32* arg1) { - return AudioLoad_GetFontsForSequence(arg0, arg1); +u8* AudioThread_GetFontsForSequence(s32 seqId, u32* outNumFonts) { + return AudioLoad_GetFontsForSequence(seqId, outNumFonts); } void Audio_GetSampleBankIdsOfFont(s32 fontId, u32* sampleBankId1, u32* sampleBankId2) { @@ -522,11 +499,11 @@ void Audio_GetSampleBankIdsOfFont(s32 fontId, u32* sampleBankId1, u32* sampleBan s32 func_800E5EDC(void) { s32 pad; - s32 sp18; + s32 specId; - if (osRecvMesg(gAudioCtx.audioResetQueueP, (OSMesg*)&sp18, OS_MESG_NOBLOCK) == -1) { + if (osRecvMesg(gAudioCtx.audioResetQueueP, (OSMesg*)&specId, OS_MESG_NOBLOCK) == -1) { return 0; - } else if (gAudioCtx.audioResetSpecIdToLoad != sp18) { + } else if (gAudioCtx.specId != specId) { return -1; } else { return 1; @@ -540,7 +517,7 @@ void func_800E5F34(void) { // clang-format on } -s32 func_800E5F88(s32 resetPreloadID) { +s32 AudioThread_ResetAudioHeap(s32 specId) { s32 resetStatus; OSMesg msg; s32 pad; @@ -548,11 +525,11 @@ s32 func_800E5F88(s32 resetPreloadID) { func_800E5F34(); resetStatus = gAudioCtx.resetStatus; if (resetStatus != 0) { - Audio_ResetCmdQueue(); - if (gAudioCtx.audioResetSpecIdToLoad == resetPreloadID) { + AudioThread_ResetCmdQueue(); + if (gAudioCtx.specId == specId) { return -2; } else if (resetStatus > 2) { - gAudioCtx.audioResetSpecIdToLoad = resetPreloadID; + gAudioCtx.specId = specId; return -3; } else { osRecvMesg(gAudioCtx.audioResetQueueP, &msg, OS_MESG_BLOCK); @@ -560,81 +537,81 @@ s32 func_800E5F88(s32 resetPreloadID) { } func_800E5F34(); - Audio_QueueCmdS32(0xF9000000, resetPreloadID); + AUDIOCMD_GLOBAL_RESET_AUDIO_HEAP(specId); - return Audio_ScheduleProcessCmds(); + return AudioThread_ScheduleProcessCmds(); } -void Audio_PreNMIInternal(void) { +void AudioThread_PreNMIInternal(void) { gAudioCtx.resetTimer = 1; if (gAudioContextInitialized) { - func_800E5F88(0); + AudioThread_ResetAudioHeap(0); gAudioCtx.resetStatus = 0; } } -s8 func_800E6070(s32 playerIdx, s32 channelIdx, s32 scriptIdx) { - SequencePlayer* seqPlayer = &gAudioCtx.seqPlayers[playerIdx]; +s8 AudioThread_GetChannelIO(s32 seqPlayerIndex, s32 channelIndex, s32 ioPort) { + SequencePlayer* seqPlayer = &gAudioCtx.seqPlayers[seqPlayerIndex]; SequenceChannel* channel; if (seqPlayer->enabled) { - channel = seqPlayer->channels[channelIdx]; - return channel->soundScriptIO[scriptIdx]; + channel = seqPlayer->channels[channelIndex]; + return channel->seqScriptIO[ioPort]; } else { - return -1; + return SEQ_IO_VAL_NONE; } } -s8 func_800E60C4(s32 playerIdx, s32 port) { - return gAudioCtx.seqPlayers[playerIdx].soundScriptIO[port]; +s8 AudioThread_GetSeqPlayerIO(s32 seqPlayerIndex, s32 ioPort) { + return gAudioCtx.seqPlayers[seqPlayerIndex].seqScriptIO[ioPort]; } -void Audio_InitExternalPool(void* ramAddr, u32 size) { +void AudioThread_InitExternalPool(void* ramAddr, u32 size) { AudioHeap_InitPool(&gAudioCtx.externalPool, ramAddr, size); } -void Audio_DestroyExternalPool(void) { +void AudioThread_ResetExternalPool(void) { gAudioCtx.externalPool.startRamAddr = NULL; } -void func_800E6128(SequencePlayer* seqPlayer, AudioCmd* cmd) { +void AudioThread_ProcessSeqPlayerCmd(SequencePlayer* seqPlayer, AudioCmd* cmd) { f32 fadeVolume; switch (cmd->op) { - case 0x41: + case AUDIOCMD_OP_SEQPLAYER_FADE_VOLUME_SCALE: if (seqPlayer->fadeVolumeScale != cmd->asFloat) { seqPlayer->fadeVolumeScale = cmd->asFloat; - seqPlayer->recalculateVolume = 1; + seqPlayer->recalculateVolume = true; } break; - case 0x47: - seqPlayer->tempo = cmd->asInt * 0x30; + case AUDIOCMD_OP_SEQPLAYER_SET_TEMPO: + seqPlayer->tempo = cmd->asInt * SEQTICKS_PER_BEAT; break; - case 0x49: - seqPlayer->unk_0C = cmd->asInt * 0x30; + case AUDIOCMD_OP_SEQPLAYER_CHANGE_TEMPO: + seqPlayer->tempoChange = cmd->asInt * SEQTICKS_PER_BEAT; break; - case 0x4E: - seqPlayer->unk_0C = cmd->asInt; + case AUDIOCMD_OP_SEQPLAYER_CHANGE_TEMPO_SEQTICKS: + seqPlayer->tempoChange = cmd->asInt; break; - case 0x48: + case AUDIOCMD_OP_SEQPLAYER_SET_TRANSPOSITION: seqPlayer->transposition = cmd->asSbyte; break; - case 0x46: - seqPlayer->soundScriptIO[cmd->arg2] = cmd->asSbyte; + case AUDIOCMD_OP_SEQPLAYER_SET_IO: + seqPlayer->seqScriptIO[cmd->arg2] = cmd->asSbyte; break; - case 0x4A: + case AUDIOCMD_OP_SEQPLAYER_FADE_TO_SET_VOLUME: fadeVolume = (s32)cmd->arg1 / 127.0f; - goto block_11; + goto apply_fade; - case 0x4B: + case AUDIOCMD_OP_SEQPLAYER_FADE_TO_SCALED_VOLUME: fadeVolume = ((s32)cmd->arg1 / 100.0f) * seqPlayer->fadeVolume; - block_11: + apply_fade: if (seqPlayer->state != 2) { seqPlayer->volume = seqPlayer->fadeVolume; if (cmd->asInt == 0) { @@ -649,7 +626,7 @@ void func_800E6128(SequencePlayer* seqPlayer, AudioCmd* cmd) { } break; - case 0x4C: + case AUDIOCMD_OP_SEQPLAYER_RESET_VOLUME: if (seqPlayer->state != 2) { if (cmd->asInt == 0) { seqPlayer->fadeVolume = seqPlayer->volume; @@ -663,7 +640,7 @@ void func_800E6128(SequencePlayer* seqPlayer, AudioCmd* cmd) { } break; - case 0x4D: + case AUDIOCMD_OP_SEQPLAYER_SET_BEND: seqPlayer->bend = cmd->asFloat; if (seqPlayer->bend == 1.0f) { seqPlayer->applyBend = false; @@ -677,82 +654,83 @@ void func_800E6128(SequencePlayer* seqPlayer, AudioCmd* cmd) { } } -void func_800E6300(SequenceChannel* channel, AudioCmd* cmd) { +void AudioThread_ProcessChannelCmd(SequenceChannel* channel, AudioCmd* cmd) { switch (cmd->op) { - case CHAN_UPD_VOL_SCALE: + case AUDIOCMD_OP_CHANNEL_SET_VOL_SCALE: if (channel->volumeScale != cmd->asFloat) { channel->volumeScale = cmd->asFloat; - channel->changes.s.volume = 1; + channel->changes.s.volume = true; } break; - case CHAN_UPD_VOL: + case AUDIOCMD_OP_CHANNEL_SET_VOL: if (channel->volume != cmd->asFloat) { channel->volume = cmd->asFloat; - channel->changes.s.volume = 1; + channel->changes.s.volume = true; } break; - case CHAN_UPD_PAN_SIGNED: + case AUDIOCMD_OP_CHANNEL_SET_PAN: if (channel->newPan != cmd->asSbyte) { channel->newPan = cmd->asSbyte; - channel->changes.s.pan = 1; + channel->changes.s.pan = true; } break; - case CHAN_UPD_PAN_UNSIGNED: + case AUDIOCMD_OP_CHANNEL_SET_PAN_WEIGHT: + //! @bug: Should compare `asSbyte` to `panChannelWeight` if (channel->newPan != cmd->asSbyte) { channel->panChannelWeight = cmd->asSbyte; - channel->changes.s.pan = 1; + channel->changes.s.pan = true; } break; - case CHAN_UPD_FREQ_SCALE: + case AUDIOCMD_OP_CHANNEL_SET_FREQ_SCALE: if (channel->freqScale != cmd->asFloat) { channel->freqScale = cmd->asFloat; - channel->changes.s.freqScale = 1; + channel->changes.s.freqScale = true; } break; - case CHAN_UPD_REVERB: - if (channel->reverb != cmd->asSbyte) { - channel->reverb = cmd->asSbyte; + case AUDIOCMD_OP_CHANNEL_SET_REVERB_VOLUME: + if (channel->targetReverbVol != cmd->asSbyte) { + channel->targetReverbVol = cmd->asSbyte; } break; - case CHAN_UPD_SCRIPT_IO: - if (cmd->arg2 < 8) { - channel->soundScriptIO[cmd->arg2] = cmd->asSbyte; + case AUDIOCMD_OP_CHANNEL_SET_IO: + if (cmd->arg2 < ARRAY_COUNT(channel->seqScriptIO)) { + channel->seqScriptIO[cmd->arg2] = cmd->asSbyte; } break; - case CHAN_UPD_STOP_SOMETHING2: - channel->stopSomething2 = cmd->asSbyte; + case AUDIOCMD_OP_CHANNEL_SET_MUTE: + channel->muted = cmd->asSbyte; break; - case CHAN_UPD_MUTE_BEHAVE: + case AUDIOCMD_OP_CHANNEL_SET_MUTE_BEHAVIOR: channel->muteBehavior = cmd->asSbyte; break; - case CHAN_UPD_VIBE_X8: - channel->vibratoExtentTarget = cmd->asUbyte * 8; - channel->vibratoExtentChangeDelay = 1; + case AUDIOCMD_OP_CHANNEL_SET_VIBRATO_DEPTH: + channel->vibratoDepthTarget = cmd->asUbyte * 8; + channel->vibratoDepthChangeDelay = 1; break; - case CHAN_UPD_VIBE_X32: + case AUDIOCMD_OP_CHANNEL_SET_VIBRATO_RATE: channel->vibratoRateTarget = cmd->asUbyte * 32; channel->vibratoRateChangeDelay = 1; break; - case CHAN_UPD_UNK_0F: - channel->unk_0F = cmd->asUbyte; + case AUDIOCMD_OP_CHANNEL_SET_COMB_FILTER_SIZE: + channel->combFilterSize = cmd->asUbyte; break; - case CHAN_UPD_UNK_20: - channel->unk_20 = cmd->asUShort; + case AUDIOCMD_OP_CHANNEL_SET_COMB_FILTER_GAIN: + channel->combFilterGain = cmd->asUShort; break; - case CHAN_UPD_STEREO: + case AUDIOCMD_OP_CHANNEL_SET_STEREO: channel->stereo.asByte = cmd->asUbyte; break; @@ -761,24 +739,33 @@ void func_800E6300(SequenceChannel* channel, AudioCmd* cmd) { } } -void func_800E64B0(s32 arg0, s32 arg1, s32 arg2) { - Audio_QueueCmdS32(((arg0 & 0xFF) << 0x10) | 0xFA000000 | ((arg1 & 0xFF) << 8) | (arg2 & 0xFF), 1); +/** + * Call an audio-thread command that has no code to process it. Unused. + */ +void AudioThread_Noop1Cmd(s32 arg0, s32 arg1, s32 arg2) { + AUDIOCMD_GLOBAL_NOOP_1(arg0, arg1, arg2, 1); } -void func_800E64F8(void) { - Audio_QueueCmdS32(0xFA000000, 0); +/** + * Call an audio-thread command that has no code to process it. Unused. + */ +void AudioThread_Noop1CmdZeroed(void) { + AUDIOCMD_GLOBAL_NOOP_1(0, 0, 0, 0); } -void func_800E651C(u32 arg0, s32 arg1) { - Audio_QueueCmdS32((arg1 & 0xFF) | 0xFD000000, arg0); +/** + * Call an audio-thread command that has no code to process it. Unused. + */ +void AudioThread_Noop2Cmd(u32 arg0, s32 arg1) { + AUDIOCMD_GLOBAL_NOOP_2(0, 0, arg1, arg0); } -void Audio_WaitForAudioTask(void) { +void AudioThread_WaitForAudioTask(void) { osRecvMesg(gAudioCtx.taskStartQueueP, NULL, OS_MESG_NOBLOCK); osRecvMesg(gAudioCtx.taskStartQueueP, NULL, OS_MESG_BLOCK); } -s32 func_800E6590(s32 playerIdx, s32 arg1, s32 arg2) { +s32 func_800E6590(s32 seqPlayerIndex, s32 channelIndex, s32 layerIndex) { SequencePlayer* seqPlayer; SequenceLayer* layer; Note* note; @@ -786,9 +773,9 @@ s32 func_800E6590(s32 playerIdx, s32 arg1, s32 arg2) { s32 loopEnd; s32 samplePos; - seqPlayer = &gAudioCtx.seqPlayers[playerIdx]; - if (seqPlayer->enabled && seqPlayer->channels[arg1]->enabled) { - layer = seqPlayer->channels[arg1]->layers[arg2]; + seqPlayer = &gAudioCtx.seqPlayers[seqPlayerIndex]; + if (seqPlayer->enabled && seqPlayer->channels[channelIndex]->enabled) { + layer = seqPlayer->channels[channelIndex]->layers[layerIndex]; if (layer == NULL) { return 0; } @@ -826,7 +813,7 @@ void func_800E66A0(void) { func_800E66C0(2); } -s32 func_800E66C0(s32 arg0) { +s32 func_800E66C0(s32 flags) { s32 phi_v1; NotePlaybackState* playbackState; NoteSubEu* noteSubEu; @@ -841,7 +828,7 @@ s32 func_800E66C0(s32 arg0) { if (note->noteSubEu.bitField0.enabled) { noteSubEu = ¬e->noteSubEu; if (playbackState->adsr.action.s.state != 0) { - if (arg0 >= 2) { + if (flags >= 2) { tunedSample = noteSubEu->tunedSample; if (tunedSample == NULL || noteSubEu->bitField1.isSyntheticWave) { continue; @@ -852,8 +839,8 @@ s32 func_800E66C0(s32 arg0) { } phi_v1++; - if ((arg0 & 1) == 1) { - playbackState->adsr.fadeOutVel = gAudioCtx.audioBufferParameters.updatesPerFrameInv; + if ((flags & 1) == 1) { + playbackState->adsr.fadeOutVel = gAudioCtx.audioBufferParameters.ticksPerUpdateInv; playbackState->adsr.action.s.release = 1; } } @@ -862,14 +849,15 @@ s32 func_800E66C0(s32 arg0) { return phi_v1; } -u32 Audio_NextRandom(void) { - static u32 audRand = 0x12345678; +u32 AudioThread_NextRandom(void) { + static u32 sAudioRandom = 0x12345678; - audRand = ((osGetCount() + 0x1234567) * (audRand + gAudioCtx.totalTaskCount)); - audRand += gAudioCtx.audioRandom; - return audRand; + sAudioRandom = ((osGetCount() + 0x1234567) * (sAudioRandom + gAudioCtx.totalTaskCount)); + sAudioRandom += gAudioCtx.audioRandom; + + return sAudioRandom; } -void Audio_InitMesgQueues(void) { - Audio_InitMesgQueuesInternal(); +void AudioThread_InitMesgQueues(void) { + AudioThread_InitMesgQueuesImpl(); } diff --git a/src/audio/sequence.c b/src/audio/sequence.c index c349beeedb..e04a5668ac 100644 --- a/src/audio/sequence.c +++ b/src/audio/sequence.c @@ -7,7 +7,7 @@ * These commands are generated using `Audio_QueueSeqCmd`, and a user-friendly interface for this function * can be found in `seqcmd.h` * - * These commands change sequences by generating internal audio commands `Audio_QueueCmd` which allows these + * These commands change sequences by generating internal audio commands `AudioThread_QueueCmd` which allows these * sequence requests to be passed onto the audio thread. It is worth noting all functions in this file are * called from the graph thread. * @@ -22,14 +22,14 @@ #include "ultra64/abi.h" // Direct audio command (skips the queueing system) -#define SEQCMD_SET_PLAYER_VOLUME_NOW(seqPlayerIndex, duration, volume) \ - Audio_ProcessSeqCmd((SEQCMD_OP_SET_PLAYER_VOLUME << 28) | ((u8)(seqPlayerIndex) << 24) | ((u8)(duration) << 16) | \ - ((u8)((volume)*127.0f))); +#define SEQCMD_SET_SEQPLAYER_VOLUME_NOW(seqPlayerIndex, duration, volume) \ + Audio_ProcessSeqCmd((SEQCMD_OP_SET_SEQPLAYER_VOLUME << 28) | ((u8)(seqPlayerIndex) << 24) | \ + ((u8)(duration) << 16) | ((u8)((volume)*127.0f))); typedef struct { - u8 seqId; - u8 priority; // higher values have higher priority -} SeqRequest; + /* 0x0 */ u8 seqId; + /* 0x1 */ u8 priority; // higher values have higher priority +} SeqRequest; // size = 0x2 SeqRequest sSeqRequests[4][5]; u8 sNumSeqRequests[4]; @@ -38,26 +38,26 @@ ActiveSequence gActiveSeqs[4]; void Audio_StartSequence(u8 seqPlayerIndex, u8 seqId, u8 seqArgs, u16 fadeInDuration) { u8 channelIndex; - u16 duration; + u16 skipTicks; s32 pad; if (!gStartSeqDisabled || (seqPlayerIndex == SEQ_PLAYER_SFX)) { seqArgs &= 0x7F; if (OOT_DEBUG && (seqArgs == 0x7F)) { - // `fadeInDuration` is interpreted as skip ticks - duration = (fadeInDuration >> 3) * 60 * gAudioCtx.audioBufferParameters.updatesPerFrame; - Audio_QueueCmdS32(0x85000000 | _SHIFTL(seqPlayerIndex, 16, 8) | _SHIFTL(seqId, 8, 8), duration); + // `fadeInDuration` interpreted as seconds, 60 is refresh rate and does not account for PAL + skipTicks = (fadeInDuration >> 3) * 60 * gAudioCtx.audioBufferParameters.ticksPerUpdate; + AUDIOCMD_GLOBAL_INIT_SEQPLAYER_SKIP_TICKS((u32)seqPlayerIndex, (u32)seqId, skipTicks); } else { - // `fadeInDuration` is interpreted as number of frames at 30 fps - Audio_QueueCmdS32(0x82000000 | _SHIFTL(seqPlayerIndex, 16, 8) | _SHIFTL(seqId, 8, 8), - (fadeInDuration * (u16)gAudioCtx.audioBufferParameters.updatesPerFrame) / 4); + // `fadeInDuration` interpreted as 1/30th of a second, does not account for change in refresh rate for PAL + AUDIOCMD_GLOBAL_INIT_SEQPLAYER((u32)seqPlayerIndex, (u32)seqId, + (fadeInDuration * (u16)gAudioCtx.audioBufferParameters.ticksPerUpdate) / 4); } gActiveSeqs[seqPlayerIndex].seqId = seqId | (seqArgs << 8); gActiveSeqs[seqPlayerIndex].prevSeqId = seqId | (seqArgs << 8); if (gActiveSeqs[seqPlayerIndex].volCur != 1.0f) { - Audio_QueueCmdF32(0x41000000 | _SHIFTL(seqPlayerIndex, 16, 8), gActiveSeqs[seqPlayerIndex].volCur); + AUDIOCMD_SEQPLAYER_FADE_VOLUME_SCALE((u32)seqPlayerIndex, gActiveSeqs[seqPlayerIndex].volCur); } gActiveSeqs[seqPlayerIndex].tempoTimer = 0; @@ -77,8 +77,8 @@ void Audio_StartSequence(u8 seqPlayerIndex, u8 seqId, u8 seqArgs, u16 fadeInDura } void Audio_StopSequence(u8 seqPlayerIndex, u16 fadeOutDuration) { - Audio_QueueCmdS32(0x83000000 | ((u8)seqPlayerIndex << 16), - (fadeOutDuration * (u16)gAudioCtx.audioBufferParameters.updatesPerFrame) / 4); + AUDIOCMD_GLOBAL_DISABLE_SEQPLAYER(seqPlayerIndex, + (fadeOutDuration * (u16)gAudioCtx.audioBufferParameters.ticksPerUpdate) / 4); gActiveSeqs[seqPlayerIndex].seqId = NA_BGM_DISABLED; } @@ -88,15 +88,15 @@ void Audio_ProcessSeqCmd(u32 cmd) { u16 channelMaskDisable; u16 fadeTimer; u16 val; - u8 oldSpec; - u8 spec; + u8 oldSpecId; + u8 specId; u8 op; u8 subOp; u8 seqPlayerIndex; u8 seqId; u8 seqArgs; u8 found; - u8 port; + u8 ioPort; u8 duration; u8 channelIndex; u8 i; @@ -104,7 +104,7 @@ void Audio_ProcessSeqCmd(u32 cmd) { s32 pad; #if OOT_DEBUG - if (gAudioDebugPrintSeqCmd && (cmd & SEQCMD_OP_MASK) != (SEQCMD_OP_SET_PLAYER_IO << 28)) { + if (gAudioDebugPrintSeqCmd && (cmd & SEQCMD_OP_MASK) != (SEQCMD_OP_SET_SEQPLAYER_IO << 28)) { AudioDebug_ScrPrt("SEQ H", (cmd >> 16) & 0xFFFF); AudioDebug_ScrPrt(" L", cmd & 0xFFFF); } @@ -215,7 +215,7 @@ void Audio_ProcessSeqCmd(u32 cmd) { } break; - case SEQCMD_OP_SET_PLAYER_VOLUME: + case SEQCMD_OP_SET_SEQPLAYER_VOLUME: // Transition volume to a target volume for an entire player duration = (cmd & 0xFF0000) >> 15; val = cmd & 0xFF; @@ -231,7 +231,7 @@ void Audio_ProcessSeqCmd(u32 cmd) { } break; - case SEQCMD_OP_SET_PLAYER_FREQ: + case SEQCMD_OP_SET_SEQPLAYER_FREQ: // Transition freq scale to a target freq for all channels duration = (cmd & 0xFF0000) >> 15; val = cmd & 0xFFFF; @@ -287,29 +287,27 @@ void Audio_ProcessSeqCmd(u32 cmd) { } break; - case SEQCMD_OP_SET_PLAYER_IO: + case SEQCMD_OP_SET_SEQPLAYER_IO: // Set global io port - port = (cmd & 0xFF0000) >> 16; + ioPort = (cmd & 0xFF0000) >> 16; val = cmd & 0xFF; - Audio_QueueCmdS8(0x46000000 | _SHIFTL(seqPlayerIndex, 16, 8) | _SHIFTL(port, 0, 8), val); + AUDIOCMD_SEQPLAYER_SET_IO(seqPlayerIndex, ioPort, val); break; case SEQCMD_OP_SET_CHANNEL_IO: // Set io port if channel masked channelIndex = (cmd & 0xF00) >> 8; - port = (cmd & 0xFF0000) >> 16; + ioPort = (cmd & 0xFF0000) >> 16; val = cmd & 0xFF; if (!(gActiveSeqs[seqPlayerIndex].channelPortMask & (1 << channelIndex))) { - Audio_QueueCmdS8(0x06000000 | _SHIFTL(seqPlayerIndex, 16, 8) | _SHIFTL(channelIndex, 8, 8) | - _SHIFTL(port, 0, 8), - val); + AUDIOCMD_CHANNEL_SET_IO(seqPlayerIndex, (u32)channelIndex, ioPort, val); } break; case SEQCMD_OP_SET_CHANNEL_IO_DISABLE_MASK: - // Disable channel io specifically for - // `SEQCMD_OP_SET_CHANNEL_IO` This can be bypassed by setting channel io through `Audio_QueueCmdS8` 0x6 - // directly. This is accomplished by setting a channel mask. + // Disable channel io specifically for `SEQCMD_OP_SET_CHANNEL_IO`. + // This can be bypassed by setting channel io through using `AUDIOCMD_CHANNEL_SET_IO` directly. + // This is accomplished by setting a channel mask. gActiveSeqs[seqPlayerIndex].channelPortMask = cmd & 0xFFFF; break; @@ -320,18 +318,18 @@ void Audio_ProcessSeqCmd(u32 cmd) { channelMaskDisable = cmd & 0xFFFF; if (channelMaskDisable != 0) { // Apply channel mask `channelMaskDisable` - Audio_QueueCmdU16(0x90000000 | _SHIFTL(seqPlayerIndex, 16, 8), channelMaskDisable); + AUDIOCMD_GLOBAL_SET_CHANNEL_MASK(seqPlayerIndex, channelMaskDisable); // Disable channels - Audio_QueueCmdS8(0x08000000 | _SHIFTL(seqPlayerIndex, 16, 8) | 0xFF00, 1); + AUDIOCMD_CHANNEL_SET_MUTE(seqPlayerIndex, AUDIOCMD_ALL_CHANNELS, true); } // Reenable channels channelMaskEnable = (channelMaskDisable ^ 0xFFFF); if (channelMaskEnable != 0) { // Apply channel mask `channelMaskEnable` - Audio_QueueCmdU16(0x90000000 | _SHIFTL(seqPlayerIndex, 16, 8), channelMaskEnable); + AUDIOCMD_GLOBAL_SET_CHANNEL_MASK(seqPlayerIndex, channelMaskEnable); // Enable channels - Audio_QueueCmdS8(0x08000000 | _SHIFTL(seqPlayerIndex, 16, 8) | 0xFF00, 0); + AUDIOCMD_CHANNEL_SET_MUTE(seqPlayerIndex, AUDIOCMD_ALL_CHANNELS, false); } break; @@ -373,7 +371,7 @@ void Audio_ProcessSeqCmd(u32 cmd) { switch (subOp) { case SEQCMD_SUB_OP_GLOBAL_SET_SOUND_MODE: // Set sound mode - Audio_QueueCmdS32(0xF0000000, gSoundModeList[val]); + AUDIOCMD_GLOBAL_SET_SOUND_MODE(gSoundModeList[val]); break; case SEQCMD_SUB_OP_GLOBAL_DISABLE_NEW_SEQUENCES: @@ -385,13 +383,13 @@ void Audio_ProcessSeqCmd(u32 cmd) { case SEQCMD_OP_RESET_AUDIO_HEAP: // Resets the audio heap based on the audio specifications and sfx channel layout - spec = cmd & 0xFF; + specId = cmd & 0xFF; gSfxChannelLayout = (cmd & 0xFF00) >> 8; - oldSpec = gAudioSpecId; - gAudioSpecId = spec; - func_800E5F88(spec); - func_800F71BC(oldSpec); - Audio_QueueCmdS32(0xF8000000, 0); + oldSpecId = gAudioSpecId; + gAudioSpecId = specId; + AudioThread_ResetAudioHeap(specId); + func_800F71BC(oldSpecId); + AUDIOCMD_GLOBAL_STOP_AUDIOCMDS(); break; } } @@ -435,7 +433,7 @@ void Audio_ResetSequenceRequests(u8 seqPlayerIndex) { /** * Check if the setup command is queued. If it is, then replace the command - * with `SEQCMD_SUB_OP_SETUP_RESTORE_VOLUME`. + * with `SEQCMD_SUB_OP_SETUP_RESTORE_SEQPLAYER_VOLUME`. * Unused */ void Audio_ReplaceSeqCmdSetupOpVolRestore(u8 seqPlayerIndex, u8 setupOpDisabled) { @@ -464,7 +462,7 @@ void Audio_SetVolumeScale(u8 seqPlayerIndex, u8 scaleIndex, u8 targetVol, u8 vol volScale *= gActiveSeqs[seqPlayerIndex].volScales[i] / 127.0f; } - SEQCMD_SET_PLAYER_VOLUME_NOW(seqPlayerIndex, volFadeTimer, volScale); + SEQCMD_SET_SEQPLAYER_VOLUME_NOW(seqPlayerIndex, volFadeTimer, volScale); } } @@ -517,7 +515,8 @@ void Audio_UpdateActiveSequences(void) { for (j = 0; j < VOL_SCALE_INDEX_MAX; j++) { volume *= (gActiveSeqs[seqPlayerIndex].volScales[j] / 127.0f); } - SEQCMD_SET_PLAYER_VOLUME(seqPlayerIndex, gActiveSeqs[seqPlayerIndex].volFadeTimer, (u8)(volume * 127.0f)); + SEQCMD_SET_SEQPLAYER_VOLUME(seqPlayerIndex, gActiveSeqs[seqPlayerIndex].volFadeTimer, + (u8)(volume * 127.0f)); gActiveSeqs[seqPlayerIndex].fadeVolUpdate = false; } @@ -530,7 +529,7 @@ void Audio_UpdateActiveSequences(void) { gActiveSeqs[seqPlayerIndex].volCur = gActiveSeqs[seqPlayerIndex].volTarget; } - Audio_QueueCmdF32(0x41000000 | _SHIFTL(seqPlayerIndex, 16, 8), gActiveSeqs[seqPlayerIndex].volCur); + AUDIOCMD_SEQPLAYER_FADE_VOLUME_SCALE((u32)seqPlayerIndex, gActiveSeqs[seqPlayerIndex].volCur); } // Process tempo @@ -544,7 +543,7 @@ void Audio_UpdateActiveSequences(void) { // Process tempo commands if (gAudioCtx.seqPlayers[seqPlayerIndex].enabled) { - tempoPrev = gAudioCtx.seqPlayers[seqPlayerIndex].tempo / TATUMS_PER_BEAT; + tempoPrev = gAudioCtx.seqPlayers[seqPlayerIndex].tempo / SEQTICKS_PER_BEAT; tempoOp = (tempoCmd & 0xF000) >> 12; switch (tempoOp) { case SEQCMD_SUB_OP_TEMPO_SPEED_UP: @@ -585,7 +584,7 @@ void Audio_UpdateActiveSequences(void) { } gActiveSeqs[seqPlayerIndex].tempoTarget = tempoTarget; - gActiveSeqs[seqPlayerIndex].tempoCur = gAudioCtx.seqPlayers[seqPlayerIndex].tempo / TATUMS_PER_BEAT; + gActiveSeqs[seqPlayerIndex].tempoCur = gAudioCtx.seqPlayers[seqPlayerIndex].tempo / SEQTICKS_PER_BEAT; gActiveSeqs[seqPlayerIndex].tempoStep = (gActiveSeqs[seqPlayerIndex].tempoCur - gActiveSeqs[seqPlayerIndex].tempoTarget) / tempoTimer; gActiveSeqs[seqPlayerIndex].tempoTimer = tempoTimer; @@ -601,8 +600,8 @@ void Audio_UpdateActiveSequences(void) { } else { gActiveSeqs[seqPlayerIndex].tempoCur = gActiveSeqs[seqPlayerIndex].tempoTarget; } - // Set tempo - Audio_QueueCmdS32(0x47000000 | _SHIFTL(seqPlayerIndex, 16, 8), gActiveSeqs[seqPlayerIndex].tempoCur); + + AUDIOCMD_SEQPLAYER_SET_TEMPO((u32)seqPlayerIndex, gActiveSeqs[seqPlayerIndex].tempoCur); } // Update channel volumes @@ -618,9 +617,9 @@ void Audio_UpdateActiveSequences(void) { gActiveSeqs[seqPlayerIndex].channelData[channelIndex].volTarget; gActiveSeqs[seqPlayerIndex].volChannelFlags ^= (1 << channelIndex); } - // `CHAN_UPD_VOL_SCALE` - Audio_QueueCmdF32(0x01000000 | _SHIFTL(seqPlayerIndex, 16, 8) | _SHIFTL(channelIndex, 8, 8), - gActiveSeqs[seqPlayerIndex].channelData[channelIndex].volCur); + + AUDIOCMD_CHANNEL_SET_VOL_SCALE(seqPlayerIndex, (u32)channelIndex, + gActiveSeqs[seqPlayerIndex].channelData[channelIndex].volCur); } } } @@ -638,9 +637,9 @@ void Audio_UpdateActiveSequences(void) { gActiveSeqs[seqPlayerIndex].channelData[channelIndex].freqScaleTarget; gActiveSeqs[seqPlayerIndex].freqScaleChannelFlags ^= (1 << channelIndex); } - // `CHAN_UPD_FREQ_SCALE` - Audio_QueueCmdF32(0x04000000 | _SHIFTL(seqPlayerIndex, 16, 8) | _SHIFTL(channelIndex, 8, 8), - gActiveSeqs[seqPlayerIndex].channelData[channelIndex].freqScaleCur); + + AUDIOCMD_CHANNEL_SET_FREQ_SCALE(seqPlayerIndex, (u32)channelIndex, + gActiveSeqs[seqPlayerIndex].channelData[channelIndex].freqScaleCur); } } } @@ -672,12 +671,12 @@ void Audio_UpdateActiveSequences(void) { setupVal1 = gActiveSeqs[seqPlayerIndex].setupCmd[j] & 0xFF; switch (setupOp) { - case SEQCMD_SUB_OP_SETUP_RESTORE_VOLUME: + case SEQCMD_SUB_OP_SETUP_RESTORE_SEQPLAYER_VOLUME: // Restore `targetSeqPlayerIndex` volume back to normal levels Audio_SetVolumeScale(targetSeqPlayerIndex, VOL_SCALE_INDEX_FANFARE, 0x7F, setupVal1); break; - case SEQCMD_SUB_OP_SETUP_RESTORE_VOLUME_IF_QUEUED: + case SEQCMD_SUB_OP_SETUP_RESTORE_SEQPLAYER_VOLUME_IF_QUEUED: // Restore `targetSeqPlayerIndex` volume back to normal levels, // but only if the number of sequence queue requests from `sSeqRequests` // exactly matches the argument to the command @@ -731,7 +730,7 @@ void Audio_UpdateActiveSequences(void) { gActiveSeqs[seqPlayerIndex].setupFadeTimer = setupVal2; break; - case SEQCMD_SUB_OP_SETUP_RESTORE_VOLUME_WITH_SCALE_INDEX: + case SEQCMD_SUB_OP_SETUP_RESTORE_SEQPLAYER_VOLUME_WITH_SCALE_INDEX: // Restore the volume back to default levels // Allows a `scaleIndex` to be specified. Audio_SetVolumeScale(targetSeqPlayerIndex, setupVal2, 0x7F, setupVal1); @@ -740,13 +739,13 @@ void Audio_UpdateActiveSequences(void) { case SEQCMD_SUB_OP_SETUP_POP_PERSISTENT_CACHE: // Discard audio data by popping one more audio caches from the audio heap if (setupVal1 & (1 << SEQUENCE_TABLE)) { - Audio_QueueCmdS32(0xE3000000, SEQUENCE_TABLE); + AUDIOCMD_GLOBAL_POP_PERSISTENT_CACHE(SEQUENCE_TABLE); } if (setupVal1 & (1 << FONT_TABLE)) { - Audio_QueueCmdS32(0xE3000000, FONT_TABLE); + AUDIOCMD_GLOBAL_POP_PERSISTENT_CACHE(FONT_TABLE); } if (setupVal1 & (1 << SAMPLE_TABLE)) { - Audio_QueueCmdS32(0xE3000000, SAMPLE_TABLE); + AUDIOCMD_GLOBAL_POP_PERSISTENT_CACHE(SAMPLE_TABLE); } break; @@ -756,9 +755,9 @@ void Audio_UpdateActiveSequences(void) { SEQCMD_SET_CHANNEL_DISABLE_MASK(targetSeqPlayerIndex, channelMask); break; - case SEQCMD_SUB_OP_SETUP_SET_PLAYER_FREQ: + case SEQCMD_SUB_OP_SETUP_SET_SEQPLAYER_FREQ: // Scale all channels of `targetSeqPlayerIndex` - SEQCMD_SET_PLAYER_FREQ(targetSeqPlayerIndex, setupVal2, (setupVal1 * 10) & 0xFFFF); + SEQCMD_SET_SEQPLAYER_FREQ(targetSeqPlayerIndex, setupVal2, (setupVal1 * 10) & 0xFFFF); break; } } @@ -773,13 +772,13 @@ u8 func_800FAD34(void) { if (D_80133418 == 1) { if (func_800E5EDC() == 1) { D_80133418 = 0; - Audio_QueueCmdS8(0x46020000, gSfxChannelLayout); + AUDIOCMD_SEQPLAYER_SET_IO(SEQ_PLAYER_SFX, 0, gSfxChannelLayout); func_800F7170(); } } else if (D_80133418 == 2) { while (func_800E5EDC() != 1) {} D_80133418 = 0; - Audio_QueueCmdS8(0x46020000, gSfxChannelLayout); + AUDIOCMD_SEQPLAYER_SET_IO(SEQ_PLAYER_SFX, 0, gSfxChannelLayout); func_800F7170(); } } diff --git a/src/audio/session_config.c b/src/audio/session_config.c index 56b8999930..2178a12e88 100644 --- a/src/audio/session_config.c +++ b/src/audio/session_config.c @@ -2,12 +2,12 @@ u8 D_8016F0E0[0xA0]; // unused AudioContext gAudioCtx; -void (*D_801755D0)(void); +AudioCustomUpdateFunction gAudioCustomUpdateFunction; s32 D_801755D8[3]; // unused -const s16 D_8014A6C0[] = { - 0x1C00, // unused - 0x0030, // gTatumsPerBeat +const TempoData gTempoData = { + 0x1C00, // unk_00 + SEQTICKS_PER_BEAT, // seqTicksPerBeat }; // TODO: Extract from table? diff --git a/src/audio/sfx.c b/src/audio/sfx.c index 2507172b5a..9f87874678 100644 --- a/src/audio/sfx.c +++ b/src/audio/sfx.c @@ -30,7 +30,7 @@ u8 sSfxBankListEnd[7]; u8 sSfxBankFreeListStart[7]; u8 sSfxBankUnused[7]; ActiveSfx gActiveSfx[7][3]; -u8 sCurSfxPlayerChannelIdx; +u8 sCurSfxPlayerChannelIndex; u8 gSfxBankMuted[7]; UnusedBankLerp sUnusedBankLerp[7]; u16 gAudioSfxSwapSource[10]; @@ -50,14 +50,14 @@ void Audio_SetSfxBanksMute(u16 muteMask) { } } -void Audio_QueueSeqCmdMute(u8 channelIdx) { - D_801333D0 |= (1 << channelIdx); +void Audio_QueueSeqCmdMute(u8 channelIndex) { + D_801333D0 |= (1 << channelIndex); Audio_SetVolumeScale(SEQ_PLAYER_BGM_MAIN, VOL_SCALE_INDEX_SFX, 0x40, 0xF); Audio_SetVolumeScale(SEQ_PLAYER_BGM_SUB, VOL_SCALE_INDEX_SFX, 0x40, 0xF); } -void Audio_ClearBGMMute(u8 channelIdx) { - D_801333D0 &= ((1 << channelIdx) ^ 0xFFFF); +void Audio_ClearBGMMute(u8 channelIndex) { + D_801333D0 &= ((1 << channelIndex) ^ 0xFFFF); if (D_801333D0 == 0) { Audio_SetVolumeScale(SEQ_PLAYER_BGM_MAIN, VOL_SCALE_INDEX_SFX, 0x7F, 0xF); Audio_SetVolumeScale(SEQ_PLAYER_BGM_SUB, VOL_SCALE_INDEX_SFX, 0x7F, 0xF); @@ -211,7 +211,7 @@ void Audio_ProcessSfxRequest(void) { if ((req->sfxId & 0xC00) || (sfxParams->params & SFX_FLAG_2) || (index == evictIndex)) { if ((gSfxBanks[bankId][index].sfxParams & SFX_FLAG_3) && gSfxBanks[bankId][index].state != SFX_STATE_QUEUED) { - Audio_ClearBGMMute(gSfxBanks[bankId][index].channelIdx); + Audio_ClearBGMMute(gSfxBanks[bankId][index].channelIndex); } gSfxBanks[bankId][index].token = req->token; gSfxBanks[bankId][index].sfxId = req->sfxId; @@ -262,7 +262,7 @@ void Audio_RemoveSfxBankEntry(u8 bankId, u8 entryIndex) { u8 i; if (entry->sfxParams & SFX_FLAG_3) { - Audio_ClearBGMMute(entry->channelIdx); + Audio_ClearBGMMute(entry->channelIndex); } if (entryIndex == sSfxBankListEnd[bankId]) { sSfxBankListEnd[bankId] = entry->prev; @@ -314,7 +314,7 @@ void Audio_ChooseActiveSfx(u8 bankId) { gSfxBanks[bankId][entryIndex].freshness--; } else if (!(gSfxBanks[bankId][entryIndex].sfxId & 0xC00) && (gSfxBanks[bankId][entryIndex].state == SFX_STATE_PLAYING_2)) { - Audio_QueueCmdS8((gSfxBanks[bankId][entryIndex].channelIdx << 8) | 0x6020000, 0); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, gSfxBanks[bankId][entryIndex].channelIndex, 0, 0); Audio_RemoveSfxBankEntry(bankId, entryIndex); } if (gSfxBanks[bankId][entryIndex].freshness == 0) { @@ -346,7 +346,7 @@ void Audio_ChooseActiveSfx(u8 bankId) { } if (entry->dist > SQ(1e5f)) { if (entry->state == SFX_STATE_PLAYING_1) { - Audio_QueueCmdS8((entry->channelIdx << 8) | 0x6020000, 0); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, entry->channelIndex, 0, 0); if (entry->sfxId & 0xC00) { Audio_RemoveSfxBankEntry(bankId, entryIndex); entryIndex = k; @@ -451,45 +451,51 @@ void Audio_PlayActiveSfx(u8 bankId) { entryIndex = gActiveSfx[bankId][i].entryIndex; if (entryIndex != 0xFF) { entry = &gSfxBanks[bankId][entryIndex]; - channel = gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[sCurSfxPlayerChannelIdx]; + channel = gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[sCurSfxPlayerChannelIndex]; if (entry->state == SFX_STATE_READY) { - entry->channelIdx = sCurSfxPlayerChannelIdx; + entry->channelIndex = sCurSfxPlayerChannelIndex; if (entry->sfxParams & SFX_FLAG_3) { - Audio_QueueSeqCmdMute(sCurSfxPlayerChannelIdx); + Audio_QueueSeqCmdMute(sCurSfxPlayerChannelIndex); } if ((entry->sfxParams & SFX_PARAM_67_MASK) != (0 << SFX_PARAM_67_SHIFT)) { switch (entry->sfxParams & SFX_PARAM_67_MASK) { case (1 << SFX_PARAM_67_SHIFT): - entry->unk_2F = Audio_NextRandom() & 0xF; + entry->unk_2F = AudioThread_NextRandom() & 0xF; break; case (2 << SFX_PARAM_67_SHIFT): - entry->unk_2F = Audio_NextRandom() & 0x1F; + entry->unk_2F = AudioThread_NextRandom() & 0x1F; break; case (3 << SFX_PARAM_67_SHIFT): - entry->unk_2F = Audio_NextRandom() & 0x3F; + entry->unk_2F = AudioThread_NextRandom() & 0x3F; break; default: entry->unk_2F = 0; break; } } - Audio_SetSfxProperties(bankId, entryIndex, sCurSfxPlayerChannelIdx); - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | ((sCurSfxPlayerChannelIdx & 0xFF) << 8), 1); - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | ((sCurSfxPlayerChannelIdx & 0xFF) << 8) | 4, - entry->sfxId & 0xFF); + Audio_SetSfxProperties(bankId, entryIndex, sCurSfxPlayerChannelIndex); + + // ioPort 0, enable the sfx to play in `NA_BGM_GENERAL_SFX` + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, sCurSfxPlayerChannelIndex, 0, 1); + + // ioPort 4, write the lower bits sfx index for `NA_BGM_GENERAL_SFX` to find the right code to execute + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, sCurSfxPlayerChannelIndex, 4, entry->sfxId & 0xFF); + + // If the sfx bank has more than 255 entries (greater than a u8 can store), + // then store the Id in upper and lower bits if (gIsLargeSfxBank[bankId]) { - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | ((sCurSfxPlayerChannelIdx & 0xFF) << 8) | 5, - (entry->sfxId & 0x100) >> 8); + // ioPort 5, write the upper bits sfx index for `NA_BGM_GENERAL_SFX`, for banks with > 0xFF entries + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, sCurSfxPlayerChannelIndex, 5, (entry->sfxId & 0x100) >> 8); } if (entry->sfxId & 0xC00) { entry->state = SFX_STATE_PLAYING_1; } else { entry->state = SFX_STATE_PLAYING_2; } - } else if ((u8)channel->soundScriptIO[1] == (u8)SEQ_IO_VAL_NONE) { + } else if ((u8)channel->seqScriptIO[1] == (u8)SEQ_IO_VAL_NONE) { Audio_RemoveSfxBankEntry(bankId, entryIndex); } else if (entry->state == SFX_STATE_PLAYING_REFRESH) { - Audio_SetSfxProperties(bankId, entryIndex, sCurSfxPlayerChannelIdx); + Audio_SetSfxProperties(bankId, entryIndex, sCurSfxPlayerChannelIndex); if (entry->sfxId & 0xC00) { entry->state = SFX_STATE_PLAYING_1; } else { @@ -497,7 +503,7 @@ void Audio_PlayActiveSfx(u8 bankId) { } } } - sCurSfxPlayerChannelIdx++; + sCurSfxPlayerChannelIndex++; } } @@ -510,7 +516,7 @@ void Audio_StopSfxByBank(u8 bankId) { while (entryIndex != 0xFF) { entry = &gSfxBanks[bankId][entryIndex]; if (entry->state >= SFX_STATE_PLAYING_REFRESH) { - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | ((entry->channelIdx & 0xFF) << 8), 0); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, entry->channelIndex, 0, 0); } if (entry->state != SFX_STATE_EMPTY) { Audio_RemoveSfxBankEntry(bankId, entryIndex); @@ -530,7 +536,7 @@ void func_800F8884(u8 bankId, Vec3f* pos) { entry = &gSfxBanks[bankId][entryIndex]; if (entry->posX == &pos->x) { if (entry->state >= SFX_STATE_PLAYING_REFRESH) { - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | ((entry->channelIdx & 0xFF) << 8), 0); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, entry->channelIndex, 0, 0); } if (entry->state != SFX_STATE_EMPTY) { Audio_RemoveSfxBankEntry(bankId, entryIndex); @@ -572,7 +578,7 @@ void Audio_StopSfxByPosAndId(Vec3f* pos, u16 sfxId) { entry = &gSfxBanks[SFX_BANK(sfxId)][entryIndex]; if (entry->posX == &pos->x && entry->sfxId == sfxId) { if (entry->state >= SFX_STATE_PLAYING_REFRESH) { - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | ((entry->channelIdx & 0xFF) << 8), 0); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, entry->channelIndex, 0, 0); } if (entry->state != SFX_STATE_EMPTY) { Audio_RemoveSfxBankEntry(SFX_BANK(sfxId), entryIndex); @@ -600,7 +606,7 @@ void Audio_StopSfxByTokenAndId(u8 token, u16 sfxId) { entry = &gSfxBanks[SFX_BANK(sfxId)][entryIndex]; if (entry->token == token && entry->sfxId == sfxId) { if (entry->state >= SFX_STATE_PLAYING_REFRESH) { - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | ((entry->channelIdx & 0xFF) << 8), 0); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, entry->channelIndex, 0, 0); } if (entry->state != SFX_STATE_EMPTY) { Audio_RemoveSfxBankEntry(SFX_BANK(sfxId), entryIndex); @@ -627,7 +633,7 @@ void Audio_StopSfxById(u32 sfxId) { entry = &gSfxBanks[SFX_BANK(sfxId)][entryIndex]; if (entry->sfxId == sfxId) { if (entry->state >= SFX_STATE_PLAYING_REFRESH) { - Audio_QueueCmdS8(0x6 << 24 | SEQ_PLAYER_SFX << 16 | ((entry->channelIdx & 0xFF) << 8), 0); + AUDIOCMD_CHANNEL_SET_IO(SEQ_PLAYER_SFX, entry->channelIndex, 0, 0); } if (entry->state != SFX_STATE_EMPTY) { Audio_RemoveSfxBankEntry(SFX_BANK(sfxId), entryIndex); @@ -672,7 +678,7 @@ void func_800F8F88(void) { u8 bankId; if (IS_SEQUENCE_CHANNEL_VALID(gAudioCtx.seqPlayers[SEQ_PLAYER_SFX].channels[0])) { - sCurSfxPlayerChannelIdx = 0; + sCurSfxPlayerChannelIndex = 0; for (bankId = 0; bankId < ARRAY_COUNT(gSfxBanks); bankId++) { Audio_ChooseActiveSfx(bankId); Audio_PlayActiveSfx(bankId); diff --git a/src/code/audio_thread_manager.c b/src/code/audio_thread_manager.c index 04f20a8f5f..bbec08dead 100644 --- a/src/code/audio_thread_manager.c +++ b/src/code/audio_thread_manager.c @@ -51,7 +51,7 @@ void AudioMgr_HandleRetrace(AudioMgr* audioMgr) { // Skip update, no rsp task produced rspTask = NULL; } else { - rspTask = func_800E4FE0(); + rspTask = AudioThread_Update(); } gAudioThreadUpdateTimeAcc += osGetTime() - gAudioThreadUpdateTimeStart; diff --git a/src/code/game.c b/src/code/game.c index 2b60c66dd0..2bc179d686 100644 --- a/src/code/game.c +++ b/src/code/game.c @@ -456,7 +456,7 @@ void GameState_Init(GameState* gameState, GameStateFunc init, GraphicsContext* g void GameState_Destroy(GameState* gameState) { PRINTF("game デストラクタ開始\n"); // "game destructor start" AudioMgr_StopAllSfx(); - func_800F3054(); + Audio_Update(); osRecvMesg(&gameState->gfxCtx->queue, NULL, OS_MESG_BLOCK); LOG_UTILS_CHECK_NULL_POINTER("this->cleanup", gameState->destroy, "../game.c", 1139); if (gameState->destroy != NULL) { diff --git a/src/code/graph.c b/src/code/graph.c index b25612ccc9..c6f165b74a 100644 --- a/src/code/graph.c +++ b/src/code/graph.c @@ -373,7 +373,7 @@ void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState) { gfxCtx->fbIdx++; } - func_800F3054(); + Audio_Update(); { OSTime timeNow = osGetTime(); diff --git a/src/code/speed_meter.c b/src/code/speed_meter.c index 086c3ea70c..dff46d91e3 100644 --- a/src/code/speed_meter.c +++ b/src/code/speed_meter.c @@ -2,8 +2,8 @@ #include "terminal.h" /** - * How much time the audio update on the audio thread (`func_800E4FE0`) took in total, between scheduling the last two - * graphics tasks. + * How much time the audio update on the audio thread (`AudioThread_Update`) took in total, between scheduling the last + * two graphics tasks. */ volatile OSTime gAudioThreadUpdateTimeTotalPerGfxTask; diff --git a/tools/disasm/gc-eu-mq/functions.txt b/tools/disasm/gc-eu-mq/functions.txt index c6f4c0b2c5..cf57800018 100644 --- a/tools/disasm/gc-eu-mq/functions.txt +++ b/tools/disasm/gc-eu-mq/functions.txt @@ -2553,44 +2553,44 @@ AudioLoad_Unused5 = 0x800BADE4; // type:func AudioLoad_ScriptLoad = 0x800BADEC; // type:func AudioLoad_ProcessScriptLoads = 0x800BAE58; // type:func AudioLoad_InitScriptLoads = 0x800BAEB0; // type:func -func_800E4FE0 = 0x800BAEE0; // type:func -func_800E5000 = 0x800BAF00; // type:func -func_800E5584 = 0x800BB484; // type:func -func_800E5958 = 0x800BB858; // type:func -func_800E59AC = 0x800BB8AC; // type:func -Audio_InitMesgQueuesInternal = 0x800BB8F4; // type:func -Audio_QueueCmd = 0x800BB98C; // type:func -Audio_QueueCmdF32 = 0x800BB9D8; // type:func -Audio_QueueCmdS32 = 0x800BB9FC; // type:func -Audio_QueueCmdS8 = 0x800BBA20; // type:func -Audio_QueueCmdU16 = 0x800BBA50; // type:func -Audio_ScheduleProcessCmds = 0x800BBA80; // type:func -Audio_ResetCmdQueue = 0x800BBB10; // type:func -Audio_ProcessCmd = 0x800BBB28; // type:func -Audio_ProcessCmds = 0x800BBC6C; // type:func +AudioThread_Update = 0x800BAEE0; // type:func +AudioThread_UpdateImpl = 0x800BAF00; // type:func +AudioThread_ProcessGlobalCmd = 0x800BB484; // type:func +AudioThread_SetFadeOutTimer = 0x800BB858; // type:func +AudioThread_SetFadeInTimer = 0x800BB8AC; // type:func +AudioThread_InitMesgQueuesImpl = 0x800BB8F4; // type:func +AudioThread_QueueCmd = 0x800BB98C; // type:func +AudioThread_QueueCmdF32 = 0x800BB9D8; // type:func +AudioThread_QueueCmdS32 = 0x800BB9FC; // type:func +AudioThread_QueueCmdS8 = 0x800BBA20; // type:func +AudioThread_QueueCmdU16 = 0x800BBA50; // type:func +AudioThread_ScheduleProcessCmds = 0x800BBA80; // type:func +AudioThread_ResetCmdQueue = 0x800BBB10; // type:func +AudioThread_ProcessCmd = 0x800BBB28; // type:func +AudioThread_ProcessCmds = 0x800BBC6C; // type:func func_800E5E20 = 0x800BBD20; // type:func -func_800E5E84 = 0x800BBD84; // type:func +AudioThread_GetFontsForSequence = 0x800BBD84; // type:func Audio_GetSampleBankIdsOfFont = 0x800BBDA4; // type:func func_800E5EDC = 0x800BBDDC; // type:func func_800E5F34 = 0x800BBE34; // type:func -func_800E5F88 = 0x800BBE88; // type:func -Audio_PreNMIInternal = 0x800BBF24; // type:func -func_800E6070 = 0x800BBF70; // type:func -func_800E60C4 = 0x800BBFC4; // type:func -Audio_InitExternalPool = 0x800BBFEC; // type:func -Audio_DestroyExternalPool = 0x800BC01C; // type:func -func_800E6128 = 0x800BC028; // type:func -func_800E6300 = 0x800BC200; // type:func -func_800E64B0 = 0x800BC3B0; // type:func -func_800E64F8 = 0x800BC3F8; // type:func -func_800E651C = 0x800BC41C; // type:func -Audio_WaitForAudioTask = 0x800BC450; // type:func +AudioThread_ResetAudioHeap = 0x800BBE88; // type:func +AudioThread_PreNMIInternal = 0x800BBF24; // type:func +AudioThread_GetChannelIO = 0x800BBF70; // type:func +AudioThread_GetSeqPlayerIO = 0x800BBFC4; // type:func +AudioThread_InitExternalPool = 0x800BBFEC; // type:func +AudioThread_ResetExternalPool = 0x800BC01C; // type:func +AudioThread_ProcessSeqPlayerCmd = 0x800BC028; // type:func +AudioThread_ProcessChannelCmd = 0x800BC200; // type:func +AudioThread_Noop1Cmd = 0x800BC3B0; // type:func +AudioThread_Noop1CmdZeroed = 0x800BC3F8; // type:func +AudioThread_Noop2Cmd = 0x800BC41C; // type:func +AudioThread_WaitForAudioTask = 0x800BC450; // type:func func_800E6590 = 0x800BC490; // type:func func_800E6680 = 0x800BC580; // type:func func_800E66A0 = 0x800BC5A0; // type:func func_800E66C0 = 0x800BC5C0; // type:func -Audio_NextRandom = 0x800BC6C0; // type:func -Audio_InitMesgQueues = 0x800BC718; // type:func +AudioThread_NextRandom = 0x800BC6C0; // type:func +AudioThread_InitMesgQueues = 0x800BC718; // type:func Audio_InvalDCache = 0x800BC740; // type:func Audio_WritebackDCache = 0x800BC780; // type:func osAiSetNextBuffer = 0x800BC7C0; // type:func @@ -2702,7 +2702,7 @@ AudioOcarina_PlayLongScarecrowSong = 0x800C4724; // type:func AudioOcarina_ResetStaffs = 0x800C4830; // type:func AudioDebug_Draw = 0x800C487C; // type:func AudioDebug_ScrPrt = 0x800C4884; // type:func -func_800F3054 = 0x800C4890; // type:func +Audio_Update = 0x800C4890; // type:func func_800F3138 = 0x800C4934; // type:func func_800F3140 = 0x800C493C; // type:func func_800F314C = 0x800C4948; // type:func diff --git a/tools/disasm/gc-eu-mq/variables.txt b/tools/disasm/gc-eu-mq/variables.txt index 6b708ba3bf..14c1220682 100644 --- a/tools/disasm/gc-eu-mq/variables.txt +++ b/tools/disasm/gc-eu-mq/variables.txt @@ -472,7 +472,7 @@ zeroes = 0x80102694; // size:0x21 __osPfsInodeCacheChannel = 0x80102730; // size:0x4 __osPfsInodeCacheBank = 0x80102734; // size:0x1 __osPfsLastChannel = 0x80102740; // size:0x4 -D_8014A6C0 = 0x80107240; // size:0x4 +gTempoData = 0x80107240; // size:0x4 gAudioHeapInitSizes = 0x80107244; // size:0xC __libm_qnan_f = 0x80107740; // size:0x4 sTextFade = 0x801077C0; // size:0x2 @@ -675,7 +675,7 @@ sSfxBankListEnd = 0x80123020; // size:0x7 sSfxBankFreeListStart = 0x80123028; // size:0x7 sSfxBankUnused = 0x80123030; // size:0x7 gActiveSfx = 0x80123038; // size:0xA8 -sCurSfxPlayerChannelIdx = 0x801230E0; // size:0x1 +sCurSfxPlayerChannelIndex = 0x801230E0; // size:0x1 gSfxBankMuted = 0x801230E4; // size:0x7 sUnusedBankLerp = 0x801230F0; // size:0x70 sSeqRequests = 0x80123160; // size:0x28 @@ -683,7 +683,7 @@ sNumSeqRequests = 0x80123188; // size:0x4 sAudioSeqCmds = 0x80123190; // size:0x400 gActiveSeqs = 0x80123590; // size:0x990 gAudioCtx = 0x80123FC0; // size:0x6450 -D_801755D0 = 0x8012A410; // size:0x4 +gAudioCustomUpdateFunction = 0x8012A410; // size:0x4 gUseAtanContFrac = 0x8012A440; // size:0x4 gSystemArena = 0x8012A450; // size:0x24 type:Arena sArenaLockMsg = 0x8012A490; // size:0x4 type:OSMesg