falso
/
perfect_dark
mirror of https://github.com/n64decomp/perfect_dark.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename a heap of audio symbols

This commit is contained in:
Ryan Dwyer 2025-03-02 13:23:03 +10:00
parent 75455a04ef
commit d7909db729
32 changed files with 713 additions and 585 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
include/PR/libaudio.h
View File

@ -441,8 +441,8 @@ enum ALMsg {
/*0x15*/ AL_CSP_NOTEOFF_EVT,
/*0x16*/ AL_TREM_OSC_EVT,
/*0x17*/ AL_VIB_OSC_EVT,
/*0x18*/ AL_18_EVT,
/*0x19*/ AL_19_EVT
/*0x18*/ AL_SEQP_FXMIX_EVT,
/*0x19*/ AL_SEQP_FXPARAM_EVT
};
/*
@ -493,22 +493,46 @@ enum AL_MIDIstatus {
};
enum AL_MIDIctrl {
AL_MIDI_VOLUME_CTRL = 0x07,
AL_MIDI_PAN_CTRL = 0x0A,
AL_MIDI_PRIORITY_CTRL = 0x10, /* use general purpose controller for priority */
AL_MIDI_FX_CTRL_0 = 0x14,
AL_MIDI_FX_CTRL_1 = 0x15,
AL_MIDI_FX_CTRL_2 = 0x16,
AL_MIDI_FX_CTRL_3 = 0x17,
AL_MIDI_FX_CTRL_4 = 0x18,
AL_MIDI_FX_CTRL_5 = 0x19,
AL_MIDI_FX_CTRL_6 = 0x1A,
AL_MIDI_FX_CTRL_7 = 0x1B,
AL_MIDI_FX_CTRL_8 = 0x1C,
AL_MIDI_FX_CTRL_9 = 0x1D,
AL_MIDI_SUSTAIN_CTRL = 0x40,
AL_MIDI_FX1_CTRL = 0x5B,
AL_MIDI_FX3_CTRL = 0x5D
AL_MIDI_NOOP_CTRL = 0x00, // Exists in Extraction outro, but there's no handler for it
AL_MIDI_OSC_CTRL = 0x01, // Used in Defection ambience
AL_MIDI_PITCH_CTRL = 0x02, // Not used
AL_MIDI_BENDRANGE_MINOR_CTRL = 0x03, // Not used
AL_MIDI_BENDRANGE_MAJOR_CTRL = 0x04, // Not used
AL_MIDI_VOLUME_CTRL = 0x07, // Not used
AL_MIDI_PAN_CTRL = 0x0A, // Not used
AL_MIDI_VIBTYPE_CTRL = 0x0B, // Not used
AL_MIDI_VIBRATE_CTRL = 0x0C, // Not used
AL_MIDI_VIBDEPTH_CTRL = 0x0D, // Not used
AL_MIDI_VIBDELAY_CTRL = 0x0E, // Not used
AL_MIDI_TREMTYPE_CTRL = 0x0F, // Not used
AL_MIDI_PRIORITY_CTRL = 0x10, // Not used
AL_MIDI_TREMRATE_CTRL = 0x11, // Not used
AL_MIDI_TREMDEPTH_CTRL = 0x12, // Not used
AL_MIDI_TREMDELAY_CTRL = 0x13, // Not used
AL_MIDI_ATTACKTIME_CTRL = 0x14, // Not used
AL_MIDI_ATTACKVOL_CTRL = 0x15, // Not used
AL_MIDI_DECAYTIME_CTRL = 0x16, // Not used
AL_MIDI_DECAYVOL_CTRL = 0x17, // Not used
AL_MIDI_RELEASETIME_CTRL = 0x18, // Not used
AL_MIDI_TIMEINDEX_CTRL = 0x19, // Not used
AL_MIDI_MP3_CTRL = 0x1A, // Not used
AL_MIDI_FX_CTRL_7 = 0x1B, // Not used
AL_MIDI_FX_CTRL_8 = 0x1C, // Not used
AL_MIDI_FX_CTRL_9 = 0x1D, // Not used
AL_MIDI_OSMESG_CTRL = 0x1E, // Not used
AL_MIDI_INST_MAJOR_CTRL = 0x20, // Not used
AL_MIDI_UNK11_CTRL = 0x21, // Not used
AL_MIDI_UNK12_CTRL = 0x22, // Not used
AL_MIDI_UNK13_CTRL = 0x23, // Not used
AL_MIDI_SUSTAIN_CTRL = 0x40, // Not used
AL_MIDI_FXMIX80_CTRL = 0x41, // Used in most sequences
AL_MIDI_FXMIX7F_CTRL = 0x5B, // Used in most sequences
AL_MIDI_FXBUS_CTRL = 0x5C, // Not used
AL_MIDI_FX3_CTRL = 0x5D, // Not used
AL_MIDI_FADEEND_CTRL = 0xFC, // Not used
AL_MIDI_FADESPEED_CTRL = 0xFD, // Not used
AL_MIDI_SETFADEINC_CTRL = 0xFE, // Not used
AL_MIDI_FADESTART_CTRL = 0xFF // Not used
};
enum AL_MIDImeta {
@ -667,12 +691,12 @@ typedef struct {
u8 priority; /* priority for this chan */
u8 vol; /* current volume for this chan */
u8 fxmix; /* current fx mix for this chan */
u8 unk0b;
u8 fxbus;
u8 sustain; /* current sustain pedal state */
u8 unk0d;
u8 unk0e;
u8 unk0f;
u8 unk10;
u8 fadevolcurrent;
u8 fadevoltarget;
u8 fadevolinc;
u8 notemesgflags;
u8 unk11;
u8 unk12;
u8 unk13;
@ -680,10 +704,10 @@ typedef struct {
ALMicroTime attackTime;
ALMicroTime decayTime;
ALMicroTime releaseTime;
u8 unk24;
u8 usechanparams;
u8 attackVolume;
u8 decayVolume;
s8 unk27;
s8 pitch;
u8 tremType;
u8 tremRate;
u8 tremDepth;
@ -693,8 +717,8 @@ typedef struct {
u8 vibDepth;
u8 vibDelay;
u8 unk30;
u8 unk31;
u8 unk32;
u8 timeindex;
u8 instmajor;
} ALChanState;
typedef struct ALSeq_s {

14
include/PR/n_libaudio.h
View File

@ -85,7 +85,7 @@ s32 n_alSynAllocVoice( N_ALVoice *voice, ALVoiceConfig *vc);
void n_alSynFreeVoice(N_ALVoice *voice);
ALFxRef n_alSynGetFXRef( s16 bus, s16 index);
ALFxRef n_alSynGetFXRef(s16 bus);
s16 n_alSynGetPriority( N_ALVoice *voice);
void n_alSynRemovePlayer( ALPlayer *client);
void n_alSynSetFXMix(N_ALVoice *v, u8 fxmix);
@ -257,8 +257,8 @@ typedef struct {
ALSeqMarker *loopStart;
ALSeqMarker *loopEnd;
s32 loopCount; /* -1 = loop forever, 0 = no loop */
u8 unk88;
u8 unk89;
u8 voicelimit;
u8 voicecount;
} N_ALSeqPlayer;
typedef struct {
@ -284,11 +284,11 @@ typedef struct {
ALOscInit initOsc;
ALOscUpdate updateOsc;
ALOscStop stopOsc;
f32 unk7c;
f32 unk80;
f32 fxmixmajor;
f32 fxmixmega;
void *queue;
u8 unk88;
u8 unk89;
u8 voicelimit;
u8 voicecount;
} N_ALCSPlayer;

2
include/PR/n_libaudio_s_to_n.h
View File

@ -7,7 +7,7 @@
#define alSynAllocVoice( a, b, c) n_alSynAllocVoice( b, c)
#define alSynDelete( a) n_alSynDelete()
#define alSynFreeVoice( a, b) n_alSynFreeVoice( b)
#define alSynGetFXRef( a, b, c) n_alSynGetFXRef( b, c)
#define alSynGetFXRef( a, b, c) n_alSynGetFXRef( b)
#define alSynGetPriority( a, b) n_alSynGetPriority( b)
#define alSynRemovePlayer( a, b) n_alSynRemovePlayer( b)
#define alSynSetFXMix( a, b, c) n_alSynSetFXMix( b, c)

18
src/game/mplayer/setup.c
View File

@ -3829,13 +3829,6 @@ struct menudialogdef g_MpTeamsMenuDialog = {
NULL,
};
u32 var80085ce8[] = {
L_MISC_166, // "Random"
L_MISC_167, // "Select All"
L_MISC_168, // "Select None"
L_MISC_169, // "Randomize"
};
/**
* List handler for the select tune dialog.
*
@ -3847,6 +3840,13 @@ u32 var80085ce8[] = {
*/
MenuItemHandlerResult mp_select_tune_list_handler(s32 operation, struct menuitem *item, union handlerdata *data)
{
static s32 specialoptions[] = {
L_MISC_166, // "Random"
L_MISC_167, // "Select All"
L_MISC_168, // "Select None"
L_MISC_169, // "Randomize"
};
switch (operation) {
case MENUOP_GET_OPTION_COUNT:
data->list.value = mp_get_num_unlocked_tracks();
@ -3866,10 +3866,10 @@ MenuItemHandlerResult mp_select_tune_list_handler(s32 operation, struct menuitem
}
if (mp_get_using_multiple_tunes()) {
return (s32) lang_get(var80085ce8[1 + data->list.value - numtracks]);
return (s32) lang_get(specialoptions[1 + data->list.value - numtracks]);
}
return (s32) lang_get(var80085ce8[data->list.value - numtracks]);
return (s32) lang_get(specialoptions[data->list.value - numtracks]);
}
case MENUOP_CONFIRM:
{

8
src/game/music.c
View File

@ -179,12 +179,12 @@ s32 music_get_channel_by_track_type(s32 tracktype)
return -1;
}
void music_queue_start_event(u32 tracktype, u32 tracknum, f32 arg2, u16 volume)
void music_queue_start_event(u32 tracktype, u32 tracknum, f32 seconds, u16 volume)
{
if (!g_SndDisabled) {
g_MusicEventQueue[g_MusicEventQueueLength].tracktype = tracktype;
g_MusicEventQueue[g_MusicEventQueueLength].tracknum = tracknum;
g_MusicEventQueue[g_MusicEventQueueLength].unk0c = arg2;
g_MusicEventQueue[g_MusicEventQueueLength].fadesecs = seconds;
g_MusicEventQueue[g_MusicEventQueueLength].volume = volume;
g_MusicEventQueue[g_MusicEventQueueLength].eventtype = MUSICEVENTTYPE_PLAY;
g_MusicEventQueue[g_MusicEventQueueLength].id = g_MusicNextEventId++;
@ -206,11 +206,11 @@ void music_queue_stop_event(s32 tracktype)
}
}
void music_queue_fade_event(s32 tracktype, f32 arg1, bool keepafterfade)
void music_queue_fade_event(s32 tracktype, f32 seconds, bool keepafterfade)
{
if (!g_SndDisabled) {
g_MusicEventQueue[g_MusicEventQueueLength].tracktype = tracktype;
g_MusicEventQueue[g_MusicEventQueueLength].unk0c = arg1;
g_MusicEventQueue[g_MusicEventQueueLength].fadesecs = seconds;
g_MusicEventQueue[g_MusicEventQueueLength].keepafterfade = keepafterfade;
g_MusicEventQueue[g_MusicEventQueueLength].eventtype = MUSICEVENTTYPE_FADE;
g_MusicEventQueue[g_MusicEventQueueLength].id = g_MusicNextEventId++;

3
src/include/constants.h
View File

@ -3831,7 +3831,8 @@
#define SNDSTATEFLAG_LEAF 0x01
#define SNDSTATEFLAG_NO_DECAY 0x02
#define SNDSTATEFLAG_HAS_VOICE 0x04
#define SNDSTATEFLAG_10 0x10
#define SNDSTATEFLAG_RELATIVE_DELAY 0x10
#define SNDSTATEFLAG_PARENT_OF_LEAF 0x10
#define SNDSTATEFLAG_HAS_DETUNE_PITCH 0x20
#define SOLOSTAGEINDEX_DEFECTION 0x00

1
src/include/data.h
View File

@ -68,7 +68,6 @@ extern u16 *g_RdpOutBufferEnd;
extern u16 *g_RdpOutBufferStart;
extern struct rdptask *g_RdpCurTask;
extern N_ALSndPlayer *g_SndPlayer;
extern u32 var8005f4dc;
extern u32 var8005f548;
extern s16 n_eqpower[];
extern u32 var8005f66c;

4
src/include/game/music.h
View File

@ -7,9 +7,9 @@
u16 music_get_volume(void);
void music_set_volume(u16 volume);
bool music_is_track_state(s32 tracktype, s32 state);
void music_queue_start_event(u32 tracktype, u32 tracknum, f32 arg2, u16 volume);
void music_queue_start_event(u32 tracktype, u32 tracknum, f32 seconds, u16 volume);
void music_queue_stop_event(s32 tracktype);
void music_queue_fade_event(s32 tracktype, f32 arg1, bool keepafterfade);
void music_queue_fade_event(s32 tracktype, f32 seconds, bool keepafterfade);
void music_reset(void);
void music_queue_stop_all_event(void);
void music_start_primary(f32 arg0);

4
src/include/lib/lib_2fc60.h
View File

@ -5,7 +5,7 @@
#include "types.h"
f32 _depth2Cents(u8 arg0);
void func00030bfc(s32 arg0, s32 arg1);
void func00030c98(ALSeqpConfig *config);
void osc_build_linkedlist(s32 arg0, s32 arg1);
void osc_set_handlers(ALSeqpConfig *config);
#endif

4
src/include/lib/lib_39c80.h
View File

@ -4,7 +4,7 @@
#include "data.h"
#include "types.h"
void func00039cd0(N_ALCSPlayer *seqp);
void func00039e5c(N_ALCSPlayer *seqp, s32 arg1, u8 arg2, u8 arg3);
void n_alCSPAllChanOn(N_ALCSPlayer *seqp);
void n_alCSPChanFade(N_ALCSPlayer *seqp, s32 arg1, u8 arg2, u8 arg3);
#endif

2
src/include/lib/lib_3d280.h
View File

@ -7,6 +7,6 @@
u32 __n_unmapVoice(void);
u32 __n_mapVoice(void);
u32 __n_lookupSoundQuick(void);
u8 func0003d9cc(N_ALVoiceState *vs, N_ALCSPlayer *seqp);
u8 __n_vsMix(N_ALVoiceState *vs, N_ALCSPlayer *seqp);
#endif

6
src/include/lib/lib_3e3e0.h
View File

@ -4,8 +4,8 @@
#include "data.h"
#include "types.h"
ALFxRef func0003e540(s16 index);
ALFxRef func0003e5b8(s16 index);
void func0003e674(struct fx *fx, s16 arg1, void *param);
ALFxRef n_alSynGetFXRef(s16 index);
ALFxRef n_alSynGetOutputLPRef(s16 index);
void n_alSynSetOutputLPParam(struct fx *fx, s16 arg1, void *param);
#endif

4
src/include/lib/speaker.h
View File

@ -4,7 +4,7 @@
#include "data.h"
#include "types.h"
void speakers_set_mode(u8 mode);
void speaker00034104(s32 index, s32 arg1);
void alSurround_OutputType(u8 mode);
void alSurround_ReverbSetup(s32 index, s32 arg1);
#endif

2
src/include/types.h
View File

@ -5109,7 +5109,7 @@ struct musicevent {
s32 timer240;
};
bool keepafterfade;
f32 unk0c;
f32 fadesecs;
s16 volume;
u16 eventtype;
s16 id;

124
src/lib/audiomgr.c
View File

@ -114,34 +114,120 @@ void amgr_create(ALSynConfig *config)
g_AudioManager.audioInfo[i]->data = alHeapAlloc(&g_SndHeap, 1, PAL ? 3688 : 1024 * 3);
}
{
s32 sp590[] = { 0x00000001, 0x000014a0, 0x00000000, 0x00001358, 0x00004d0c, 0x00000000, 0x000053ff, 0x00000000, 0x00000000, 0x00000000 };
s32 sp568[] = { 0x00000001, 0x000001b8, 0x00000000, 0x00000068, 0x00004000, 0x00000000, 0x00007fff, 0x00001db0, 0x00001b58, 0x00000000 };
s32 sp540[] = { 0x00000001, 0x000001b8, 0x00000000, 0x00000068, 0x00000000, 0x00005fff, 0x00007fff, 0x0000017c, 0x000001f4, 0x00000000 };
s32 sp478[] = { 0x00000006, 0x00001868, 0x00000000, 0x00000160, 0x00002666, 0xffffd99a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000188, 0x00000640, 0x0000235e, 0xffffd99a, 0x0000750c, 0x00000000, 0x00000000, 0x00000bca, 0x00000318, 0x000009f8, 0x00004000, 0xffffc000, 0x00006d78, 0x00000000, 0x00000000, 0x00001286, 0x00000c78, 0x000015d8, 0x0000521a, 0xffffc000, 0x0000724f, 0x00000000, 0x00000000, 0x00001650, 0x00000d28, 0x000012c0, 0x00002143, 0xffffe000, 0x00005de4, 0x00000000, 0x00000000, 0x00002286, 0x00000000, 0x00001720, 0x000032c8, 0xffffcd38, 0x00000000, 0x00000000, 0x00000000, 0x00004500 };
s32 sp430[] = { 0x00000002, 0x000008b0, 0x00000600, 0x00000760, 0x00007142, 0x00000000, 0x00005bff, 0x00000000, 0x00000000, 0x00007bc9, 0x00000000, 0x00000528, 0x00005f27, 0xffffb288, 0x00007ef1, 0x00000000, 0x00000001, 0x000066bb };
s32 sp3c8[] = { 0x00000003, 0x00000b40, 0x00000000, 0x00000160, 0x00002666, 0xffffd99a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000188, 0x00000640, 0x0000235e, 0xffffd99a, 0x000016f2, 0x00000000, 0x00000000, 0x00000bca, 0x00000318, 0x000009f8, 0x00004000, 0xffffc000, 0x0000186b, 0x00000000, 0x00000000, 0x00001286 };
s32 sp360[] = { 0x00000003, 0x00000b40, 0x00000000, 0x00000160, 0x00002666, 0xffffd99a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000188, 0x00000640, 0x0000235e, 0xffffd99a, 0x000016f2, 0x00000000, 0x00000000, 0x00000bca, 0x00000318, 0x000009f8, 0x00004000, 0xffffc000, 0x0000186b, 0x00000000, 0x00000000, 0x00001286 };
s32 sp2f8[] = { 0x00000003, 0x00000898, 0x00000000, 0x000004a0, 0x00002666, 0xffffd99a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x000001a0, 0x00000340, 0x00000ccc, 0xfffff334, 0x00003fff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000528, 0x00001388, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00005000 };
s32 sp270[] = { 0x00000004, 0x00000898, 0x00000000, 0x000005a8, 0x00002666, 0xffffd99a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x000001e0, 0x000004a0, 0x00000ccc, 0xfffff334, 0x00003fff, 0x00000000, 0x00000000, 0x00000000, 0x000005a8, 0x000007d0, 0x00000ccc, 0xfffff334, 0x00003fff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000810, 0x00001f40, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00005000 };
s32 sp248[] = { 0x00000001, 0x00001130, 0x00000000, 0x00000f60, 0x00002ee0, 0x00000000, 0x00007fff, 0x00000000, 0x00000000, 0x00000000 };
s32 sp1c0[] = { 0x00000004, 0x00000e98, 0x000000c0, 0x00000188, 0x00002666, 0xffffd99a, 0x00003484, 0x00000000, 0x00000000, 0x00000000, 0x000001b8, 0x00000580, 0x00004000, 0xffffc000, 0x000019eb, 0x00000000, 0x00000000, 0x00000000, 0x00000a50, 0x00000b98, 0x00002000, 0xffffe000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000cb8, 0x00004650, 0xffffb9b0, 0x00000000, 0x0000017c, 0x0000000a, 0x00000000 };
s32 sp198[] = { 0x00000001, 0x00000528, 0x00000000, 0x00000448, 0x00003334, 0x00000000, 0x00007335, 0x00000000, 0x00000000, 0x00000000 };
s32 sp090[] = { 0x00000008, 0x00001b80, 0x00000000, 0x000000c0, 0x00002666, 0xffffd99a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x000000c0, 0x00000188, 0x00002666, 0xffffd99a, 0x00002b84, 0x00000000, 0x00000000, 0x00000000, 0x00000370, 0x00000b00, 0x00004000, 0xffffc000, 0x000011eb, 0x00000000, 0x00000000, 0x00000000, 0x00000420, 0x00000840, 0x00002000, 0xffffe000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000dc0, 0x00001810, 0x00004000, 0xffffc000, 0x000011eb, 0x00000000, 0x00000000, 0x00000000, 0x00000e70, 0x000014a0, 0x00002000, 0xffffe000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x000014a0, 0x00001738, 0x00002000, 0xffffe000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00001970, 0x000032c8, 0xffffcd38, 0x00000000, 0x0000017c, 0x0000000a, 0x00000000 };
s32 sp068[] = { 0x00000001, 0x00000a50, 0x00000000, 0x00000898, 0x00003334, 0x00000000, 0x00007335, 0x00000000, 0x00000000, 0x00000000 };
s32 sp040[] = { 0x00000001, 0x00000148, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 };
#define ms *(((s32) ((f32) 44.1))&~0x7)
config->params[0] = (s32 *) (IS4MB() ? sp1c0 : sp090);
{
s32 sp590[] = { 1, 132 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 123.8 ms, 19724, 0, 21503, 0, 0, 0,
};
s32 sp568[] = { 1, 11 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 2.6 ms, 16384, 0, 32767, 7600, 7000, 0
};
s32 sp540[] = { 1, 11 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 2.6 ms, 0, 24575, 32767, 380, 500, 0,
};
s32 sp478[] = { 6, 156.2 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 8.8 ms, 9830, -9830, 0, 0, 0, 0,
9.8 ms, 40 ms, 9054, -9830, 29964, 0, 0, 3018,
19.8 ms, 63.8 ms, 16384, -16384, 28024, 0, 0, 4742,
79.8 ms, 139.8 ms, 21018, -16384, 29263, 0, 0, 5712,
84.2 ms, 120 ms, 8515, -8192, 24036, 0, 0, 8838,
0 ms, 148 ms, 13000, -13000, 0, 0, 0, 17664,
};
s32 sp430[] = { 2, 55.6 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
38.4 ms, 47.2 ms, 28994, 0, 23551, 0, 0, 31689,
0 ms, 33 ms, 24359, -19832, 32497, 0, 1, 26299,
};
s32 sp3c8[] = { 3, 72 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 8.8 ms, 9830, -9830, 0, 0, 0, 0,
9.8 ms, 40 ms, 9054, -9830, 5874, 0, 0, 3018,
19.8 ms, 63.8 ms, 16384, -16384, 6251, 0, 0, 4742,
};
s32 sp360[] = { 3, 72 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 8.8 ms, 9830, -9830, 0, 0, 0, 0,
9.8 ms, 40 ms, 9054, -9830, 5874, 0, 0, 3018,
19.8 ms, 63.8 ms, 16384, -16384, 6251, 0, 0, 4742,
};
s32 sp2f8[] = { 3, 55 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 29.6 ms, 9830, -9830, 0, 0, 0, 0,
10.4 ms, 20.8 ms, 3276, -3276, 16383, 0, 0, 0,
0 ms, 33 ms, 5000, 0, 0, 0, 0, 20480,
};
s32 sp270[] = { 4, 55 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 36.2 ms, 9830, -9830, 0, 0, 0, 0,
12 ms, 29.6 ms, 3276, -3276, 16383, 0, 0, 0,
36.2 ms, 50 ms, 3276, -3276, 16383, 0, 0, 0,
0 ms, 51.6 ms, 8000, 0, 0, 0, 0, 20480,
};
s32 sp248[] = { 1, 110 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 98.4 ms, 12000, 0, 32767, 0, 0, 0,
};
s32 params_bus0_4mb[] = { 4, 93.4 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
4.8 ms, 9.8 ms, 9830, -9830, 13444, 0, 0, 0,
11 ms, 35.2 ms, 16384, -16384, 6635, 0, 0, 0,
66 ms, 74.2 ms, 8192, -8192, 0, 0, 0, 0,
0 ms, 81.4 ms, 18000, -18000, 0, 380, 10, 0,
};
s32 params_bus1_4mb[] = { 1, 33 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 27.4 ms, 13108, 0, 29493, 0, 0, 0,
};
s32 params_bus0_8mb[] = { 8, 176 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 4.8 ms, 9830, -9830, 0, 0, 0, 0,
4.8 ms, 9.8 ms, 9830, -9830, 11140, 0, 0, 0,
22 ms, 70.4 ms, 16384, -16384, 4587, 0, 0, 0,
26.4 ms, 52.8 ms, 8192, -8192, 0, 0, 0, 0,
88 ms, 154 ms, 16384, -16384, 4587, 0, 0, 0,
92.4 ms, 132 ms, 8192, -8192, 0, 0, 0, 0,
132 ms, 148.6 ms, 8192, -8192, 0, 0, 0, 0,
0 ms, 162.8 ms, 13000, -13000, 0, 380, 10, 0,
};
s32 params_bus1_8mb[] = { 1, 66 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 55 ms, 13108, 0, 29493, 0, 0, 0,
};
s32 sp040[] = { 1, 8.2 ms,
// input output fbcoef ffcoef gain chorusrate chorusdepth filtercoef
0 ms, 0 ms, 0, 0, 0, 0, 0, 0,
};
config->params[0] = (s32 *) (IS4MB() ? params_bus0_4mb : params_bus0_8mb);
if (g_SndMaxFxBusses >= 2) {
for (i = 1; i < g_SndMaxFxBusses; i++) {
config->params[i] = (s32 *) (IS4MB() ? sp198 : sp068);
config->params[i] = (s32 *) (IS4MB() ? params_bus1_4mb : params_bus1_8mb);
}
}
}
n_alInit(&g_AudioManager.g, config);
func00030bfc(0, 60);
osc_build_linkedlist(0, 60);
osCreateThread(&g_AudioManager.thread, THREAD_AUDIO, &amgr_main, 0, g_AudioSp, THREADPRI_AUDIO);
}

195
src/lib/lib_2fc60.c
View File

@ -2,12 +2,33 @@
#include "constants.h"
#include "types.h"
struct typea {
/**
* The seq.ctl file uses values 0 and 1 for tremType, and 0 and 128 for vibType.
*
* The other values are not used in seq.ctl but are referenced in this file.
*/
#define OSCTYPE_OFF 0
#define OSCTYPE_TREM 1
#define OSCTYPE_02 2
#define OSCTYPE_03 3
#define OSCTYPE_04 4
#define OSCTYPE_05 5
#define OSCTYPE_06 6
#define OSCTYPE_07 7
#define OSCTYPE_08 8
#define OSCTYPE_09 9
#define OSCTYPE_10 10
#define OSCTYPE_11 11
#define OSCTYPE_12 12
#define OSCTYPE_13 13
#define OSCTYPE_VIB 128
struct typetrem {
u8 unk28;
u8 unk29;
};
struct typeb {
struct typevib {
f32 unk28;
};
@ -28,8 +49,8 @@ typedef struct oscData_s {
u16 unk24;
u16 unk26;
union {
struct typea a;
struct typeb b;
struct typetrem trem;
struct typevib vib;
} data;
} oscData;
@ -40,10 +61,10 @@ u32 var8009c2c8;
u32 var8009c2cc;
N_ALSndPlayer var8009c2d0;
ALMicroTime updateOsc(void *oscState, f32 *updateVal);
ALMicroTime updateOscMain(oscData *statePtr, f32 *updateVal);
void func00030bd8(void *oscState);
ALMicroTime initOscMain(void **oscState, f32 *initVal, u8 oscType, u8 arg3, u8 oscDepth, u8 arg5, u8 arg6);
ALMicroTime osc_update(void *oscState, f32 *updateVal);
ALMicroTime osc_update_other(oscData *statePtr, f32 *updateVal);
void osc_stop_other(void *oscState);
ALMicroTime osc_init_other(void **oscState, f32 *initVal, u8 oscType, u8 oscRate, u8 oscDepth, u8 oscDelay, u8 arg6);
f32 _depth2Cents(u8 depth)
{
@ -62,7 +83,7 @@ f32 _depth2Cents(u8 depth)
return cents;
}
ALMicroTime initOsc(void **oscState, f32 *initVal, u8 oscType, u8 oscRate, u8 oscDepth, u8 oscDelay, u8 arg6)
ALMicroTime osc_init(void **oscState, f32 *initVal, u8 oscType, u8 oscRate, u8 oscDepth, u8 oscDelay, u8 arg6)
{
oscData *state;
ALMicroTime result = 0;
@ -71,8 +92,8 @@ ALMicroTime initOsc(void **oscState, f32 *initVal, u8 oscType, u8 oscRate, u8 os
return 0;
}
if (oscType != 1 && oscType != 0x80) {
return initOscMain(oscState, initVal, oscType, oscRate, oscDepth, oscDelay, arg6);
if (oscType != OSCTYPE_TREM && oscType != OSCTYPE_VIB) {
return osc_init_other(oscState, initVal, oscType, oscRate, oscDepth, oscDelay, arg6);
}
if (freeOscStateList != NULL) {
@ -83,15 +104,15 @@ ALMicroTime initOsc(void **oscState, f32 *initVal, u8 oscType, u8 oscRate, u8 os
result = oscDelay << 14;
switch (oscType) {
case 1:
case OSCTYPE_TREM:
state->unk24 = 0;
state->unk22 = 259 - oscRate;
state->data.a.unk28 = oscDepth >> 1;
state->data.a.unk29 = 127 - state->data.a.unk28;
*initVal = state->data.a.unk29;
state->data.trem.unk28 = oscDepth >> 1;
state->data.trem.unk29 = 127 - state->data.trem.unk28;
*initVal = state->data.trem.unk29;
break;
case 0x80:
state->data.b.unk28 = _depth2Cents(oscDepth);
case OSCTYPE_VIB:
state->data.vib.unk28 = _depth2Cents(oscDepth);
state->unk24 = 0;
state->unk22 = 259 - oscRate;
*initVal = 1.0f;
@ -104,18 +125,18 @@ ALMicroTime initOsc(void **oscState, f32 *initVal, u8 oscType, u8 oscRate, u8 os
return result;
}
ALMicroTime updateOsc(void *oscState, f32 *updateVal)
ALMicroTime osc_update(void *oscState, f32 *updateVal)
{
f32 sp2c;
oscData *state = oscState;
ALMicroTime result = AL_USEC_PER_FRAME;
if (state->type != 1 && state->type != 0x80) {
return updateOscMain(oscState, updateVal);
if (state->type != OSCTYPE_TREM && state->type != OSCTYPE_VIB) {
return osc_update_other(oscState, updateVal);
}
switch (state->type) {
case 0x01:
case OSCTYPE_TREM:
state->unk24++;
if (state->unk24 >= state->unk22) {
@ -124,10 +145,10 @@ ALMicroTime updateOsc(void *oscState, f32 *updateVal)
sp2c = (f32)state->unk24 / (f32)state->unk22;
sp2c = sinf(sp2c * DTOR(360));
sp2c = sp2c * state->data.a.unk28;
*updateVal = state->data.a.unk29 + sp2c;
sp2c = sp2c * state->data.trem.unk28;
*updateVal = state->data.trem.unk29 + sp2c;
break;
case 0x80:
case OSCTYPE_VIB:
state->unk24++;
if (state->unk24 >= state->unk22) {
@ -135,7 +156,7 @@ ALMicroTime updateOsc(void *oscState, f32 *updateVal)
}
sp2c = (f32)state->unk24 / (f32)state->unk22;
sp2c = sinf(sp2c * DTOR(360)) * state->data.b.unk28;
sp2c = sinf(sp2c * DTOR(360)) * state->data.vib.unk28;
*updateVal = alCents2Ratio(sp2c);
break;
default:
@ -145,38 +166,48 @@ ALMicroTime updateOsc(void *oscState, f32 *updateVal)
return result;
}
void stopOsc(void *oscState)
void osc_stop(void *oscState)
{
oscData *state = (oscData *)oscState;
if (state->type != 1 && state->type != 0x80) {
func00030bd8(oscState);
if (state->type != OSCTYPE_TREM && state->type != OSCTYPE_VIB) {
/**
* @bug: This function does the same freeing behaviour, which would
* cause the state's `next` pointer to point to itself, thus corrupting
* the linked list.
*/
osc_stop_other(oscState);
}
((oscData*)oscState)->next = freeOscStateList;
freeOscStateList = (oscData*)oscState;
}
f32 func000301a4(f32 value)
/**
* 32767 => 0.00
* 16384 => 1.00
* 0 => 0.00
*/
f32 osc_s16_to_sine(f32 value)
{
// Almost value / (32768 / M_PI), but has a precision mismatch
return sinf(value / 10430.379882812f);
}
extern s32 var8005f150[];
extern f32 var8005f34c[100];
extern s32 g_CspTimeLookup[];
extern f32 g_CspRateLookup[100];
ALMicroTime initOscMain(void **oscState, f32 *initVal, u8 oscType, u8 arg3, u8 oscDepth, u8 arg5, u8 arg6)
ALMicroTime osc_init_other(void **oscState, f32 *initVal, u8 oscType, u8 oscRate, u8 oscDepth, u8 oscDelay, u8 arg6)
{
oscData *state;
f32 oscDepthf;
if (arg3 > 99) {
arg3 = 99;
if (oscRate > 99) {
oscRate = 99;
}
if (arg5 > 127) {
arg5 = 127;
if (oscDelay > 127) {
oscDelay = 127;
}
if (arg6 > 127) {
@ -194,51 +225,51 @@ ALMicroTime initOscMain(void **oscState, f32 *initVal, u8 oscType, u8 arg3, u8 o
state->unk1c = 0;
} else {
state->unk18 = 0;
state->unk1c = 1.0f / ((f32)var8005f150[arg6] / AL_USEC_PER_FRAME);
state->unk1c = 1.0f / ((f32)g_CspTimeLookup[arg6] / AL_USEC_PER_FRAME);
}
state->type = oscType;
state->unk14 = 0;
state->unk16 = 1000000.0f / (f32)var8005f34c[arg3] / AL_USEC_PER_FRAME;
state->unk16 = 1000000.0f / (f32)g_CspRateLookup[oscRate] / AL_USEC_PER_FRAME;
state->curCount = AL_USEC_PER_FRAME;
oscDepthf = oscDepth;
if (oscType & 0x80) {
if (oscType & OSCTYPE_VIB) {
oscDepthf = _depth2Cents(oscDepthf);
}
oscType &= ~0x80;
oscType &= ~OSCTYPE_VIB;
switch (oscType & ~0x80) {
case 2:
case 3:
case 4:
case 5:
switch (oscType & ~OSCTYPE_VIB) {
case OSCTYPE_02:
case OSCTYPE_03:
case OSCTYPE_04:
case OSCTYPE_05:
state->unk0c = oscDepthf;
if (oscType == 2) {
if (oscType == OSCTYPE_02) {
state->unk10 = -oscDepthf;
} else {
state->unk10 = 0;
}
state->curCount = 500000.0f / (f32)var8005f34c[arg3];
state->curCount = 500000.0f / (f32)g_CspRateLookup[oscRate];
break;
case 6:
case 8:
case 11:
case 12:
case OSCTYPE_06:
case OSCTYPE_08:
case OSCTYPE_11:
case OSCTYPE_12:
state->unk10 = 0;
state->unk0c = oscDepthf;
break;
case 7:
case 9:
case 13:
case OSCTYPE_07:
case OSCTYPE_09:
case OSCTYPE_13:
state->unk10 = oscDepthf / 2.0f;
state->unk0c = oscDepthf / 2.0f;
break;
case 10:
case OSCTYPE_10:
state->unk10 = -oscDepthf;
state->unk0c = oscDepthf * 2.0f;
break;
@ -246,7 +277,7 @@ ALMicroTime initOscMain(void **oscState, f32 *initVal, u8 oscType, u8 arg3, u8 o
return 0;
}
if (state->type & 0x80) {
if (state->type & OSCTYPE_VIB) {
*initVal = alCents2Ratio(state->unk10);
} else {
*initVal = state->unk10 + 127.0f;
@ -256,20 +287,20 @@ ALMicroTime initOscMain(void **oscState, f32 *initVal, u8 oscType, u8 arg3, u8 o
freeOscStateList = freeOscStateList->next;
if (arg5) {
return var8005f150[arg5];
if (oscDelay) {
return g_CspTimeLookup[oscDelay];
}
return AL_USEC_PER_FRAME;
}
ALMicroTime updateOscMain(oscData *statePtr, f32 *updateVal)
ALMicroTime osc_update_other(oscData *statePtr, f32 *updateVal)
{
f32 sp24;
f32 sp20;
f32 sp1c;
if ((statePtr->type & ~0x80) >= 6) {
if ((statePtr->type & ~OSCTYPE_VIB) >= 6) {
statePtr->unk14++;
if (statePtr->unk14 >= statePtr->unk16) {
@ -294,11 +325,11 @@ ALMicroTime updateOscMain(oscData *statePtr, f32 *updateVal)
sp24 *= statePtr->unk18;
}
switch (statePtr->type & ~0x80) {
case 2:
case 3:
case 4:
case 5:
switch (statePtr->type & ~OSCTYPE_VIB) {
case OSCTYPE_02:
case OSCTYPE_03:
case OSCTYPE_04:
case OSCTYPE_05:
if (statePtr->unk14) {
sp20 = sp24;
} else {
@ -306,8 +337,8 @@ ALMicroTime updateOscMain(oscData *statePtr, f32 *updateVal)
}
statePtr->unk14 ^= 1;
break;
case 6:
case 7:
case OSCTYPE_06:
case OSCTYPE_07:
if (sp20 < 0.25f) {
sp20 *= 4.0f * sp24;
} else if (sp20 >= 0.75f) {
@ -321,17 +352,17 @@ ALMicroTime updateOscMain(oscData *statePtr, f32 *updateVal)
}
sp20 += statePtr->unk10;
break;
case 8:
case 9:
sp20 = func000301a4(sp20 * 65536.0f) * sp24 + statePtr->unk10;
case OSCTYPE_08:
case OSCTYPE_09:
sp20 = osc_s16_to_sine(sp20 * 65536.0f) * sp24 + statePtr->unk10;
break;
case 10:
case 11:
case OSCTYPE_10:
case OSCTYPE_11:
sp20 *= sp24;
sp20 += statePtr->unk10;
break;
case 12:
case 13:
case OSCTYPE_12:
case OSCTYPE_13:
if (sp20 < 0.25f) {
sp20 *= 4.0f * sp24;
} else if (sp20 >= 0.75f) {
@ -346,13 +377,13 @@ ALMicroTime updateOscMain(oscData *statePtr, f32 *updateVal)
sp1c = statePtr->unk10 + sp20;
sp20 = (f32)statePtr->unk14 / (f32)statePtr->unk16;
sp20 = func000301a4(sp20 * 65536.0f) * sp24 + statePtr->unk10;
sp20 = osc_s16_to_sine(sp20 * 65536.0f) * sp24 + statePtr->unk10;
sp20 += sp1c;
sp20 /= 2.0f;
break;
}
if (statePtr->type & 0x80) {
if (statePtr->type & OSCTYPE_VIB) {
*updateVal = alCents2Ratio(sp20);
} else {
*updateVal = sp20 + 127;
@ -361,13 +392,13 @@ ALMicroTime updateOscMain(oscData *statePtr, f32 *updateVal)
return statePtr->curCount;
}
void func00030bd8(void *oscState)
void osc_stop_other(void *oscState)
{
((oscData*)oscState)->next = freeOscStateList;
freeOscStateList = (oscData*)oscState;
}
void func00030bfc(s32 arg0, s32 count)
void osc_build_linkedlist(s32 arg0, s32 count)
{
oscData *item;
s32 i;
@ -383,11 +414,11 @@ void func00030bfc(s32 arg0, s32 count)
item->next = NULL;
}
void func00030c98(ALSeqpConfig *config)
void osc_set_handlers(ALSeqpConfig *config)
{
config->initOsc = initOsc;
config->updateOsc = updateOsc;
config->stopOsc = stopOsc;
config->initOsc = osc_init;
config->updateOsc = osc_update;
config->stopOsc = osc_stop;
return;
}

34
src/lib/lib_39c80.c
View File

@ -5,47 +5,47 @@
#include "data.h"
#include "types.h"
void func00039cd0(N_ALCSPlayer *seqp)
void n_alCSPAllChanOn(N_ALCSPlayer *seqp)
{
s32 i;
seqp->chanMask = 0xffff;
for (i = 0; i < seqp->maxChannels; i++) {
seqp->chanState[i].unk0e = 0xff;
seqp->chanState[i].unk0d = 0xff;
seqp->chanState[i].fadevoltarget = 255;
seqp->chanState[i].fadevolcurrent = 255;
}
}
void func00039d68(N_ALCSPlayer *seqp, u32 status)
void n_alCSPChanOff(N_ALCSPlayer *seqp, s32 chan)
{
n_alCSPSendMidi(seqp, 0, status | 0xb0, 0xfc, 0);
n_alCSPSendMidi(seqp, 0, AL_MIDI_ControlChange | chan, AL_MIDI_FADEEND_CTRL, 0);
}
void func00039dac(N_ALCSPlayer *seqp, u32 arg1)
void n_alCSPChanOn(N_ALCSPlayer *seqp, s32 chan)
{
seqp->chanMask |= 1 << arg1;
seqp->chanMask |= 1 << chan;
n_alCSPSendMidi(seqp, 0, arg1 | 0xb0, 0xfc, 0xff);
n_alCSPSendMidi(seqp, 0, AL_MIDI_ControlChange | chan, AL_MIDI_FADEEND_CTRL, 255);
}
void func00039e10(N_ALCSPlayer *seqp, u32 arg1, u8 arg2)
void n_alCSPChanFadeAuto(N_ALCSPlayer *seqp, s32 chan, u8 targetvol)
{
n_alCSPSendMidi(seqp, 0, arg1 | 0xb0, 0xff, arg2);
n_alCSPSendMidi(seqp, 0, AL_MIDI_ControlChange | chan, AL_MIDI_FADESTART_CTRL, targetvol);
}
void func00039e5c(N_ALCSPlayer *seqp, s32 arg1, u8 arg2, u8 arg3)
void n_alCSPChanFade(N_ALCSPlayer *seqp, s32 chan, u8 targetvol, u8 incvol)
{
n_alCSPSendMidi(seqp, 0, arg1 | 0xb0, 0xfd, arg3);
n_alCSPSendMidi(seqp, 0, arg1 | 0xb0, 0xff, arg2);
n_alCSPSendMidi(seqp, 0, AL_MIDI_ControlChange | chan, AL_MIDI_FADESPEED_CTRL, incvol);
n_alCSPSendMidi(seqp, 0, AL_MIDI_ControlChange | chan, AL_MIDI_FADESTART_CTRL, targetvol);
}
void func00039ecc(N_ALCSPlayer *seqp, u32 arg1, u8 arg2)
void n_alCSPChanSurround(N_ALCSPlayer *seqp, s32 chan, u8 arg2)
{
n_alCSPSendMidi(seqp, 0, arg1 | 0xb0, 0x41, arg2);
n_alCSPSendMidi(seqp, 0, AL_MIDI_ControlChange | chan, AL_MIDI_FXMIX80_CTRL, arg2);
}
void func00039f18(N_ALCSPlayer *seqp, u32 arg1, u8 arg2)
void n_alCSPChanFadeForce(N_ALCSPlayer *seqp, s32 chan, u8 vol)
{
n_alCSPSendMidi(seqp, 0, arg1 | 0xb0, 0xfc, arg2);
n_alCSPSendMidi(seqp, 0, AL_MIDI_ControlChange | chan, AL_MIDI_FADEEND_CTRL, vol);
}

8
src/lib/lib_3e3e0.c
View File

@ -2,23 +2,23 @@
#include <n_libaudio.h>
#include "naudio/n_synthInternals.h"
ALFxRef func0003e540(s16 index)
ALFxRef n_alSynGetFXRef(s16 bus)
{
struct N_ALMainBus_s *mainbus = n_syn->mainBus;
if (mainbus->filter.handler == (void *)n_alFxPull) {
return (ALFxRef) n_syn->auxBus[index].fx;
return n_syn->auxBus[bus].fx;
} else {
return NULL;
}
}
ALFxRef func0003e5b8(s16 index)
ALFxRef n_alSynGetOutputLPRef(s16 bus)
{
struct N_ALMainBus_s *mainbus = n_syn->mainBus;
if (mainbus->filter.handler == (void *)n_alFxPull) {
return (ALFxRef) n_syn->auxBus[index].unk44;
return &n_syn->auxBus[bus].unk44->fx;
} else {
return NULL;
}

30
src/lib/music.c
View File

@ -15,7 +15,7 @@
#define RESULT_OK_NEXT 1
#define RESULT_OK_BREAK 2
const u8 var70053ca0[] = {0, 0, 0, 0, 0, 5};
const u8 g_FadeTargetByTrackType[] = {0, 0, 0, 0, 0, 5};
s32 g_MusicNextAmbientTick240 = -1;
@ -51,12 +51,12 @@ s32 music_handle_play_event(struct musicevent *event, s32 result)
// Check if this tracktype is currently in use. If it is then that's
// an error - the caller should have stopped the existing track first.
for (i = 0; i < 3; i++) {
for (i = 0; i < ARRAYCOUNT(g_SeqInstances); i++) {
if (event->tracktype == g_SeqChannels[i].tracktype && n_alCSPGetState(g_SeqInstances[i].seqp) == AL_PLAYING) {
value = event->tracktype == TRACKTYPE_AMBIENT ? 24 : 32;
for (j = 0; j < 16; j++) {
func00039e5c(g_SeqInstances[i].seqp, j, 0xff, value);
n_alCSPChanFade(g_SeqInstances[i].seqp, j, 0xff, value);
osSyncPrintf("MUSIC(Play) : Unpaused midi channel %d for state %d\n", j, event->tracktype);
}
@ -71,7 +71,7 @@ s32 music_handle_play_event(struct musicevent *event, s32 result)
if (result == RESULT_FAIL) {
// Find an unused channel
for (i = 0; i < 3; i++) {
for (i = 0; i < ARRAYCOUNT(g_SeqInstances); i++) {
/**
* @bug: When adding a new track, the seqp's state remains at AL_STOPPED
* and is only changed to AL_PLAYING once the audio thread has run.
@ -109,7 +109,7 @@ s32 music_handle_play_event(struct musicevent *event, s32 result)
if (result == RESULT_FAIL) {
index = -1;
for (i = 0; i < 3; i++) {
for (i = 0; i < ARRAYCOUNT(g_SeqInstances); i++) {
if ((g_SeqChannels[i].tracktype == TRACKTYPE_NONE || event->tracktype == g_SeqChannels[i].tracktype)
&& n_alCSPGetState(g_SeqInstances[i].seqp) != AL_STOPPED) {
index = i;
@ -120,7 +120,7 @@ s32 music_handle_play_event(struct musicevent *event, s32 result)
if (index == -1) {
if (event->failcount >= 3) {
for (i = 0; i < 3; i++) {
for (i = 0; i < ARRAYCOUNT(g_SeqInstances); i++) {
if (g_SeqChannels[i].tracktype == TRACKTYPE_AMBIENT
&& n_alCSPGetState(g_SeqInstances[i].seqp) != AL_STOPPED) {
index = i;
@ -165,7 +165,7 @@ s32 music_handle_stop_event(struct musicevent *event, s32 result)
{
s32 i;
for (i = 0; i < 3; i++) {
for (i = 0; i < ARRAYCOUNT(g_SeqInstances); i++) {
if (event->tracktype == g_SeqChannels[i].tracktype) {
n_alSeqpStop((N_ALSeqPlayer *)g_SeqInstances[i].seqp);
@ -186,15 +186,15 @@ s32 music_handle_fade_event(struct musicevent *event, s32 result)
s32 i;
s32 j;
for (i = 0; i < 3; i++) {
for (i = 0; i < ARRAYCOUNT(g_SeqInstances); i++) {
if (event->tracktype == g_SeqChannels[i].tracktype && g_SeqChannels[i].inuse) {
for (j = 0; j < 16; j++) {
func00039e5c(g_SeqInstances[i].seqp, j, var70053ca0[event->tracktype], 32);
n_alCSPChanFade(g_SeqInstances[i].seqp, j, g_FadeTargetByTrackType[event->tracktype], 32);
}
g_SeqChannels[i].inuse = event->keepafterfade;
g_SeqChannels[i].keepafterfade = event->keepafterfade;
g_SeqChannels[i].unk0c = g_SeqInstances[i].seqp->chanState[0].unk0d;
g_SeqChannels[i].unk0c = g_SeqInstances[i].seqp->chanState[0].fadevolcurrent;
}
}
@ -205,7 +205,7 @@ s32 music_handle_stop_all_event(s32 result)
{
s32 i;
for (i = 0; i < 3; i++) {
for (i = 0; i < ARRAYCOUNT(g_SeqInstances); i++) {
n_alSeqpStop((N_ALSeqPlayer *)g_SeqInstances[i].seqp);
g_SeqChannels[i].tracktype = 0;
@ -239,16 +239,16 @@ void music_tick_events(void)
if (g_MusicEventQueueLength);
// Release channels if their track has finished fading out
for (i = 0; i < 3; i++) {
for (i = 0; i < ARRAYCOUNT(g_SeqInstances); i++) {
if (!g_SeqChannels[i].inuse && n_alCSPGetState(g_SeqInstances[i].seqp) == AL_PLAYING) {
if (g_SeqInstances[i].seqp->chanState[0].unk0d <= var70053ca0[g_SeqChannels[i].tracktype]) {
if (g_SeqInstances[i].seqp->chanState[0].fadevolcurrent <= g_FadeTargetByTrackType[g_SeqChannels[i].tracktype]) {
n_alSeqpStop((N_ALSeqPlayer *)g_SeqInstances[i].seqp);
g_SeqChannels[i].tracktype = TRACKTYPE_NONE;
g_SeqChannels[i].inuse = false;
g_SeqChannels[i].keepafterfade = false;
g_SeqChannels[i].unk0c = 0;
} else if (g_SeqInstances[i].seqp->chanState[0].unk0d == g_SeqChannels[i].unk0c) {
} else if (g_SeqInstances[i].seqp->chanState[0].fadevolcurrent == g_SeqChannels[i].unk0c) {
n_alSeqpStop((N_ALSeqPlayer *)g_SeqInstances[i].seqp);
g_SeqChannels[i].tracktype = TRACKTYPE_NONE;
@ -508,7 +508,7 @@ bool music_is_track_type_playing(s32 tracktype)
{
s32 i;
for (i = 0; i < 3; i++) {
for (i = 0; i < ARRAYCOUNT(g_SeqInstances); i++) {
if (tracktype == g_SeqChannels[i].tracktype && n_alCSPGetState(g_SeqInstances[i].seqp) == AL_PLAYING) {
return true;
}

290
src/lib/naudio/n_csplayer.c
View File

@ -16,7 +16,7 @@ ALMicroTime __n_vsDelta(N_ALVoiceState *vs, ALMicroTime t);
u32 var8009c350[16];
// 110000 occurs twice in this table...
s32 var8005f150[] = {
s32 g_CspTimeLookup[] = {
0, 10000, 20000, 30000,
40000, 50000, 60000, 70000,
80000, 90000, 100000, 110000,
@ -51,7 +51,7 @@ s32 var8005f150[] = {
170000000, 175000000, 180000000,
};
f32 var8005f34c[100] = {
f32 g_CspRateLookup[100] = {
0.05, 0.05, 0.06, 0.06, 0.06, 0.07, 0.07, 0.08, 0.08, 0.09,
0.10, 0.11, 0.13, 0.14, 0.17, 0.20, 0.25, 0.33, 0.5, 1,
1.25, 1.5, 1.75, 2, 2.25, 2.5, 2.75, 3, 3.25, 3.5,
@ -64,9 +64,9 @@ f32 var8005f34c[100] = {
18.75, 19, 19.25, 19.5, 19.75, 20, 20.25, 20.5, 20.75, 21,
};
u32 var8005f4dc = 0x00000000;
s32 var8005f4dc = 0;
void func00039cd0(N_ALCSPlayer *seqp);
void n_alCSPAllChanOn(N_ALCSPlayer *seqp);
ALMicroTime __n_CSPVoiceHandler(void *node);
void n_alCSPNew(N_ALCSPlayer *seqp, ALSeqpConfig *c)
@ -86,12 +86,12 @@ void n_alCSPNew(N_ALCSPlayer *seqp, ALSeqpConfig *c)
seqp->drvr = n_syn;
seqp->chanMask = 0xffff;
func00039cd0(seqp);
n_alCSPAllChanOn(seqp);
seqp->uspt = 488;
seqp->nextDelta = 0;
seqp->state = AL_STOPPED;
seqp->vol = 0x7fff; /* full volume */
seqp->vol = AL_VOL_FULL;
seqp->debugFlags = c->debugFlags;
seqp->frameTime = AL_USEC_PER_FRAME; /* should get this from driver */
seqp->curTime = 0;
@ -99,11 +99,11 @@ void n_alCSPNew(N_ALCSPlayer *seqp, ALSeqpConfig *c)
seqp->updateOsc = c->updateOsc;
seqp->stopOsc = c->stopOsc;
seqp->unk7c = 0;
seqp->unk80 = 1;
seqp->fxmixmajor = 0;
seqp->fxmixmega = 1;
seqp->queue = 0;
seqp->unk89 = 0;
seqp->unk88 = c->maxVoices;
seqp->voicecount = 0;
seqp->voicelimit = c->maxVoices;
seqp->nextEvent.type = AL_SEQP_API_EVT; /* this will start the voice handler "spinning" */
@ -149,11 +149,10 @@ void __n_CSPHandleNextSeqEvent(N_ALCSPlayer *seqp);
void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event);
void n_alSynFilter13(N_ALVoice *v, f32 arg1);
u8 func0003d9cc(N_ALVoiceState *vs, N_ALCSPlayer *seqp);
ALFxRef func0003e540(u8 arg0);
ALFxRef func0003e5b8(u8 arg0);
void func0003e674(struct fx *fx, u8 arg1, void *param);
f32 func0003b9d4(s32 arg0);
u8 __n_vsMix(N_ALVoiceState *vs, N_ALCSPlayer *seqp);
ALFxRef n_alSynGetOutputLPRef(u8 arg0);
void n_alSynSetOutputLPParam(struct fx *fx, u8 arg1, void *param);
f32 alSemitones2Ratio(s32 arg0);
ALMicroTime __n_CSPVoiceHandler(void *node)
{
@ -228,7 +227,7 @@ ALMicroTime __n_CSPVoiceHandler(void *node)
if (seqp->chanState[chan].unk11) {
n_alSynFilter13(&vs->voice,
440
* func0003b9d4(seqp->chanState[chan].unk12 + (vs->key - vs->sound->keyMap->keyBase) - 64)
* alSemitones2Ratio(seqp->chanState[chan].unk12 + (vs->key - vs->sound->keyMap->keyBase) - 64)
* seqp->chanState[chan].pitchBend
* vs->vibrato);
}
@ -259,18 +258,18 @@ ALMicroTime __n_CSPVoiceHandler(void *node)
}
break;
case (AL_18_EVT):
seqp->unk7c = seqp->nextEvent.msg.evt18.unk00;
seqp->unk80 = seqp->nextEvent.msg.evt18.unk04;
case (AL_SEQP_FXMIX_EVT):
seqp->fxmixmajor = seqp->nextEvent.msg.evt18.unk00;
seqp->fxmixmega = seqp->nextEvent.msg.evt18.unk04;
for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) {
n_alSynSetFXMix(&vs->voice, func0003d9cc(vs, seqp));
n_alSynSetFXMix(&vs->voice, __n_vsMix(vs, seqp));
}
break;
case (AL_19_EVT):
case (AL_SEQP_FXPARAM_EVT):
if (seqp->nextEvent.msg.evt19.unk01 < 8) {
ALFxRef fx = func0003e540(seqp->nextEvent.msg.evt19.unk00);
ALFxRef fx = n_alSynGetFXRef(seqp->nextEvent.msg.evt19.unk00);
if (fx) {
n_alSynSetFXParam(fx,
@ -278,10 +277,10 @@ ALMicroTime __n_CSPVoiceHandler(void *node)
&seqp->nextEvent.msg.evt19.param);
}
} else {
ALFxRef fx = func0003e5b8(seqp->nextEvent.msg.evt19.unk00);
ALFxRef fx = n_alSynGetOutputLPRef(seqp->nextEvent.msg.evt19.unk00);
if (fx) {
func0003e674(fx, seqp->nextEvent.msg.evt19.unk01, &seqp->nextEvent.msg.evt19.param);
n_alSynSetOutputLPParam(fx, seqp->nextEvent.msg.evt19.unk01, &seqp->nextEvent.msg.evt19.param);
}
}
break;
@ -347,9 +346,9 @@ ALMicroTime __n_CSPVoiceHandler(void *node)
}
for (chan = 0; chan < 16; chan++) {
seqp->chanState[chan].unk0d = seqp->chanState[chan].unk0e;
seqp->chanState[chan].fadevolcurrent = seqp->chanState[chan].fadevoltarget;
if (seqp->chanState[chan].unk0d == 0) {
if (seqp->chanState[chan].fadevolcurrent == 0) {
seqp->chanMask &= (1 << chan) ^ 0xffff;
} else {
seqp->chanMask |= 1 << chan;
@ -456,7 +455,7 @@ void __n_CSPHandleNextSeqEvent(N_ALCSPlayer *seqp)
}
}
void func00034f0c(N_ALCSPlayer *seqp, u8 channel)
void n_alCSPApplyChlVol(N_ALCSPlayer *seqp, u8 channel)
{
N_ALVoiceState *vs;
@ -483,7 +482,7 @@ void func00034fb8(N_ALCSPlayer *seqp, u8 channel)
n_alSynFilter12(&vs->voice, sp2a);
if (sp2a) {
n_alSynFilter13(&vs->voice, func0003b9d4((vs->key - vs->sound->keyMap->keyBase) + sp29) * 440 * sp24);
n_alSynFilter13(&vs->voice, alSemitones2Ratio(vs->key - vs->sound->keyMap->keyBase + sp29) * 440 * sp24);
}
}
}
@ -558,7 +557,7 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
ERR_ALSEQP_NO_SOUND);
config.priority = chanstate->priority;
config.fxBus = chanstate->unk0b;
config.fxBus = chanstate->fxbus;
config.unityPitch = 0;
vstate = __n_mapVoice((N_ALSeqPlayer*)seqp, key, vel, chan);
@ -583,13 +582,13 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
cents = (key - sound->keyMap->keyBase) * 100 + sound->keyMap->detune;
if (chanstate->unk24) {
cents += chanstate->unk27;
if (chanstate->usechanparams) {
cents += chanstate->pitch;
}
vstate->pitch = alCents2Ratio(cents);
if (chanstate->unk24) {
if (chanstate->usechanparams) {
vstate->envGain = chanstate->attackVolume;
vstate->envEndTime = seqp->curTime + chanstate->attackTime;
} else {
@ -602,7 +601,7 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
*/
vstate->flags = 0;
if (chanstate->unk24) {
if (chanstate->usechanparams) {
sp90 = chanstate->tremType;
} else {
inst = seqp->chanState[chan].instrument;
@ -613,12 +612,12 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
if (sp90) {
if (seqp->initOsc) {
if (chanstate->unk24) {
deltaTime = (*seqp->initOsc)(&oscState,&oscValue,chanstate->tremType,
chanstate->tremRate,chanstate->tremDepth,chanstate->tremDelay, chanstate->unk31);
if (chanstate->usechanparams) {
deltaTime = (*seqp->initOsc)(&oscState, &oscValue, chanstate->tremType,
chanstate->tremRate, chanstate->tremDepth, chanstate->tremDelay, chanstate->timeindex);
} else {
deltaTime = (*seqp->initOsc)(&oscState,&oscValue,inst->tremType,
inst->tremRate,inst->tremDepth,inst->tremDelay, chanstate->unk31);
deltaTime = (*seqp->initOsc)(&oscState, &oscValue, inst->tremType,
inst->tremRate, inst->tremDepth, inst->tremDelay, chanstate->timeindex);
}
if (deltaTime) /* a deltaTime of zero means don't run osc */ {
@ -638,7 +637,7 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
oscValue = 1.0f; /* set this as a default */
if (chanstate->unk24) {
if (chanstate->usechanparams) {
sp90 = chanstate->vibType;
} else {
sp90 = inst->vibType;
@ -646,12 +645,12 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
if (sp90) {
if (seqp->initOsc) {
if (chanstate->unk24) {
deltaTime = (*seqp->initOsc)(&oscState,&oscValue,chanstate->vibType,
chanstate->vibRate,chanstate->vibDepth,chanstate->vibDelay, chanstate->unk31);
if (chanstate->usechanparams) {
deltaTime = (*seqp->initOsc)(&oscState, &oscValue, chanstate->vibType,
chanstate->vibRate, chanstate->vibDepth, chanstate->vibDelay, chanstate->timeindex);
} else {
deltaTime = (*seqp->initOsc)(&oscState,&oscValue,inst->vibType,
inst->vibRate,inst->vibDepth,inst->vibDelay, chanstate->unk31);
deltaTime = (*seqp->initOsc)(&oscState, &oscValue, inst->vibType,
inst->vibRate, inst->vibDepth, inst->vibDelay, chanstate->timeindex);
}
if (deltaTime) /* a deltaTime of zero means don't run osc. */ {
@ -673,12 +672,12 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
*/
pitch = vstate->pitch * chanstate->pitchBend * vstate->vibrato;
fxmix = func0003d9cc(vstate, seqp);
fxmix = __n_vsMix(vstate, seqp);
sp76 = chanstate->unk11;
if (sp76) {
sp70 = 440 * func0003b9d4(cents / 100 + chanstate->unk12 - 64) * chanstate->pitchBend;
sp70 = 440 * alSemitones2Ratio(cents / 100 + chanstate->unk12 - 64) * chanstate->pitchBend;
} else {
sp70 = 127.0f;
}
@ -686,7 +685,7 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
pan = __n_vsPan(vstate, (N_ALSeqPlayer*)seqp);
vol = __n_vsVol(vstate, (N_ALSeqPlayer*)seqp);
if (chanstate->unk24) {
if (chanstate->usechanparams) {
deltaTime = chanstate->attackTime;
} else {
deltaTime = sound->envelope->attackTime;
@ -701,7 +700,7 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
evt.type = AL_SEQP_ENV_EVT;
evt.msg.vol.voice = voice;
if (chanstate->unk24) {
if (chanstate->usechanparams) {
evt.msg.vol.vol = chanstate->decayVolume;
evt.msg.vol.delta = chanstate->decayTime;
} else {
@ -726,8 +725,8 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
n_alEvtqPostEvent(&seqp->evtq, &evt, deltaTime, 0);
}
if ((chanstate->unk10 & 1) && seqp->queue) {
osSendMesg(seqp->queue, (OSMesg)((var8009c350[chan] & 0xffffff00) | (chanstate->unk10 >> 2)), OS_MESG_NOBLOCK);
if ((chanstate->notemesgflags & 1) && seqp->queue) {
osSendMesg(seqp->queue, (OSMesg)((var8009c350[chan] & 0xffffff00) | (chanstate->notemesgflags >> 2)), OS_MESG_NOBLOCK);
}
break;
@ -751,17 +750,15 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
} else {
vstate->phase = AL_PHASE_RELEASE;
if (chanstate->unk24) {
__n_seqpReleaseVoice((N_ALSeqPlayer*)seqp, &vstate->voice,
chanstate->releaseTime);
if (chanstate->usechanparams) {
__n_seqpReleaseVoice((N_ALSeqPlayer*)seqp, &vstate->voice, chanstate->releaseTime);
} else {
__n_seqpReleaseVoice((N_ALSeqPlayer*)seqp, &vstate->voice,
vstate->sound->envelope->releaseTime);
__n_seqpReleaseVoice((N_ALSeqPlayer*)seqp, &vstate->voice, vstate->sound->envelope->releaseTime);
}
}
if ((chanstate->unk10 & 2) && seqp->queue) {
osSendMesg(seqp->queue, (OSMesg)(key << 16 | 8 | chanstate->unk10 >> 2), OS_MESG_NOBLOCK);
if ((chanstate->notemesgflags & 2) && seqp->queue) {
osSendMesg(seqp->queue, (OSMesg)(key << 16 | 8 | chanstate->notemesgflags >> 2), OS_MESG_NOBLOCK);
}
break;
@ -773,12 +770,12 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
* sounding.
*/
vstate = __n_lookupVoice((N_ALSeqPlayer*)seqp, key, chan);
ALFailIf(!vstate, ERR_ALSEQP_POLY_VOICE );
ALFailIf(!vstate, ERR_ALSEQP_POLY_VOICE );
vstate->velocity = byte2;
n_alSynSetVol( &vstate->voice,
n_alSynSetVol(&vstate->voice,
__n_vsVol(vstate, (N_ALSeqPlayer*)seqp),
__n_vsDelta(vstate,seqp->curTime));
__n_vsDelta(vstate, seqp->curTime));
break;
case (AL_MIDI_ChannelPressure):
@ -790,9 +787,9 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) {
if (vs->channel == chan) {
vs->velocity = byte1;
n_alSynSetVol( &vs->voice,
n_alSynSetVol(&vs->voice,
__n_vsVol(vs, (N_ALSeqPlayer*)seqp),
__n_vsDelta(vs,seqp->curTime));
__n_vsDelta(vs, seqp->curTime));
}
}
break;
@ -805,35 +802,38 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) {
if (vs->channel == chan) {
pan = __n_vsPan(vs, (N_ALSeqPlayer*)seqp);
n_alSynSetPan( &vs->voice, pan);
n_alSynSetPan(&vs->voice, pan);
}
}
break;
case (0xfd):
seqp->chanState[chan].unk0f = byte2;
case (AL_MIDI_FADESPEED_CTRL):
seqp->chanState[chan].fadevolinc = byte2;
break;
case (0xff):
if (seqp->chanState[chan].unk0f == 0) {
seqp->chanState[chan].unk0f = 0x90;
case (AL_MIDI_FADESTART_CTRL):
if (seqp->chanState[chan].fadevolinc == 0) {
seqp->chanState[chan].fadevolinc = 0x90;
}
if (seqp->chanState[chan].unk0e != byte2) {
if (seqp->chanState[chan].unk0e == seqp->chanState[chan].unk0d) {
seqp->chanState[chan].unk0e = byte2;
if (byte2 != seqp->chanState[chan].fadevoltarget) {
if (seqp->chanState[chan].fadevoltarget == seqp->chanState[chan].fadevolcurrent) {
// Not currently fading
seqp->chanState[chan].fadevoltarget = byte2;
} else {
seqp->chanState[chan].unk0e = byte2;
// Currently fading towards a different target volume, so update target
seqp->chanState[chan].fadevoltarget = byte2;
break;
}
} else {
// Already fading toward this target volume, so don't need to do anything
break;
}
midi->byte1 = 0xfe;
midi->byte1 = AL_MIDI_SETFADEINC_CTRL;
// fall-through
case (0xfe):
sp67 = seqp->chanState[chan].unk0d;
sp66 = seqp->chanState[chan].unk0e;
vel = seqp->chanState[chan].unk0f;
case (AL_MIDI_SETFADEINC_CTRL):
sp67 = seqp->chanState[chan].fadevolcurrent;
sp66 = seqp->chanState[chan].fadevoltarget;
vel = seqp->chanState[chan].fadevolinc;
sp60 = sp66 - sp67;
if (sp60 > 0) {
@ -853,7 +853,7 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
}
sp67 += sp60;
seqp->chanState[chan].unk0d = sp67;
seqp->chanState[chan].fadevolcurrent = sp67;
if (sp67 != sp66) {
n_alEvtqPostEvent(&seqp->evtq, event, seqp->uspt * 100, 0);
@ -865,11 +865,11 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
seqp->chanMask &= ~(1 << chan);
}
func00034f0c(seqp, chan);
n_alCSPApplyChlVol(seqp, chan);
break;
case (0xfc):
seqp->chanState[chan].unk0d = byte2;
seqp->chanState[chan].unk0e = byte2;
case (AL_MIDI_FADEEND_CTRL):
seqp->chanState[chan].fadevolcurrent = byte2;
seqp->chanState[chan].fadevoltarget = byte2;
if (byte2 == 0) {
seqp->chanMask &= (1 << chan) ^ 0xffff;
@ -877,17 +877,17 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
seqp->chanMask |= 1 << chan;
}
func00034f0c(seqp, chan);
n_alCSPApplyChlVol(seqp, chan);
break;
case (0x21):
case (AL_MIDI_UNK11_CTRL):
seqp->chanState[chan].unk11 = byte2;
func00034fb8(seqp, chan);
break;
case (0x22):
case (AL_MIDI_UNK12_CTRL):
seqp->chanState[chan].unk12 = byte2;
func00034fb8(seqp, chan);
break;
case (0x23):
case (AL_MIDI_UNK13_CTRL):
seqp->chanState[chan].unk13 = byte2;
for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) {
@ -896,7 +896,7 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
}
}
break;
case (0x1e):
case (AL_MIDI_OSMESG_CTRL):
if (seqp->queue) {
osSendMesg(seqp->queue, (OSMesg)((byte2 & 7) | 0x10 | ((seqp->node.samplesLeft << 5) & 0xffffff00)), OS_MESG_NOBLOCK);
}
@ -920,7 +920,7 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) {
if ((vs->channel == chan) && (vs->phase != AL_PHASE_RELEASE)) {
if ( byte2 > AL_SUSTAIN ) {
if (byte2 > AL_SUSTAIN) {
/*
* sustain pedal down
*/
@ -937,7 +937,7 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
vs->phase = AL_PHASE_RELEASE;
// @bug: chanstate is uninitialised
if (chanstate->unk24) {
if (chanstate->usechanparams) {
__n_seqpReleaseVoice((N_ALSeqPlayer*)seqp,
&vs->voice,
(seqp->chanState[chan].releaseTime < AL_USEC_PER_FRAME ? AL_USEC_PER_FRAME : seqp->chanState[chan].releaseTime));
@ -951,11 +951,11 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
}
}
break;
case (AL_MIDI_FX1_CTRL):
case (AL_MIDI_FXMIX7F_CTRL):
seqp->chanState[chan].fxmix = (seqp->chanState[chan].fxmix & 0x80) | byte2;
byte2 = seqp->chanState[chan].fxmix >> 7;
// fall-through
case (0x41):
case (AL_MIDI_FXMIX80_CTRL):
seqp->chanState[chan].fxmix = (seqp->chanState[chan].fxmix & 0x7f) | (byte2 << 7);
for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) {
@ -964,119 +964,119 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
}
}
break;
case (0x5c):
case (AL_MIDI_FXBUS_CTRL):
if (byte2 < n_syn->maxAuxBusses) {
seqp->chanState[chan].unk0b = byte2;
seqp->chanState[chan].fxbus = byte2;
}
break;
case (AL_MIDI_FX_CTRL_6):
case (AL_MIDI_MP3_CTRL):
snd_start_mp3_by_filenum(byte2);
break;
case (0x20):
seqp->chanState[chan].unk32 = byte2;
case (AL_MIDI_INST_MAJOR_CTRL):
seqp->chanState[chan].instmajor = byte2;
break;
case (AL_MIDI_FX_CTRL_0):
seqp->chanState[chan].attackTime = var8005f150[byte2];
seqp->chanState[chan].unk24 = 1;
case (AL_MIDI_ATTACKTIME_CTRL):
seqp->chanState[chan].attackTime = g_CspTimeLookup[byte2];
seqp->chanState[chan].usechanparams = 1;
break;
case (AL_MIDI_FX_CTRL_1):
case (AL_MIDI_ATTACKVOL_CTRL):
seqp->chanState[chan].attackVolume = byte2;
seqp->chanState[chan].unk24 = 1;
seqp->chanState[chan].usechanparams = 1;
break;
case (AL_MIDI_FX_CTRL_2):
seqp->chanState[chan].decayTime = var8005f150[byte2];
seqp->chanState[chan].unk24 = 1;
case (AL_MIDI_DECAYTIME_CTRL):
seqp->chanState[chan].decayTime = g_CspTimeLookup[byte2];
seqp->chanState[chan].usechanparams = 1;
break;
case (AL_MIDI_FX_CTRL_3):
case (AL_MIDI_DECAYVOL_CTRL):
seqp->chanState[chan].decayVolume = byte2;
seqp->chanState[chan].unk24 = 1;
seqp->chanState[chan].usechanparams = 1;
break;
case (AL_MIDI_FX_CTRL_4):
seqp->chanState[chan].releaseTime = var8005f150[byte2];
seqp->chanState[chan].unk24 = 1;
case (AL_MIDI_RELEASETIME_CTRL):
seqp->chanState[chan].releaseTime = g_CspTimeLookup[byte2];
seqp->chanState[chan].usechanparams = 1;
break;
case (0x02):
seqp->chanState[chan].unk27 = byte2 - 64;
seqp->chanState[chan].unk24 = 1;
case (AL_MIDI_PITCH_CTRL):
seqp->chanState[chan].pitch = byte2 - 64;
seqp->chanState[chan].usechanparams = 1;
break;
case (0x03):
case (AL_MIDI_BENDRANGE_MINOR_CTRL):
seqp->chanState[chan].bendRange /= 100;
seqp->chanState[chan].bendRange *= 100;
seqp->chanState[chan].bendRange += byte2;
break;
case (0x04):
case (AL_MIDI_BENDRANGE_MAJOR_CTRL):
seqp->chanState[chan].bendRange %= 100;
seqp->chanState[chan].bendRange += byte2 * 100;
break;
case (0x0b):
case (AL_MIDI_VIBTYPE_CTRL):
if (byte2) {
byte2 += 0x80;
}
seqp->chanState[chan].vibType = byte2;
seqp->chanState[chan].unk24 = 1;
seqp->chanState[chan].usechanparams = 1;
break;
case (0x0c):
case (AL_MIDI_VIBRATE_CTRL):
seqp->chanState[chan].vibRate = byte2;
seqp->chanState[chan].unk24 = 1;
seqp->chanState[chan].usechanparams = 1;
break;
case (0x0d):
case (AL_MIDI_VIBDEPTH_CTRL):
seqp->chanState[chan].vibDepth = byte2 * 2;
seqp->chanState[chan].unk24 = 1;
seqp->chanState[chan].usechanparams = 1;
break;
case (0x0e):
case (AL_MIDI_VIBDELAY_CTRL):
seqp->chanState[chan].vibDelay = byte2;
seqp->chanState[chan].unk24 = 1;
seqp->chanState[chan].usechanparams = 1;
break;
case (0x0f):
case (AL_MIDI_TREMTYPE_CTRL):
seqp->chanState[chan].tremType = byte2;
seqp->chanState[chan].unk24 = 1;
seqp->chanState[chan].usechanparams = 1;
break;
case (0x11):
case (AL_MIDI_TREMRATE_CTRL):
seqp->chanState[chan].tremRate = byte2;
seqp->chanState[chan].unk24 = 1;
seqp->chanState[chan].usechanparams = 1;
break;
case (0x12):
case (AL_MIDI_TREMDEPTH_CTRL):
seqp->chanState[chan].tremDepth = byte2;
seqp->chanState[chan].unk24 = 1;
seqp->chanState[chan].usechanparams = 1;
break;
case (0x13):
case (AL_MIDI_TREMDELAY_CTRL):
seqp->chanState[chan].tremDelay = byte2;
seqp->chanState[chan].unk24 = 1;
seqp->chanState[chan].usechanparams = 1;
break;
case (0x01):
case (AL_MIDI_OSC_CTRL):
byte2 *= 2;
for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) {
if (vs->channel == chan && vs->oscState2) {
struct oscstate *sp5c = vs->oscState2;
struct oscstate *osc = vs->oscState2;
switch (sp5c->unk04 & 0xffffff7f) {
switch (osc->unk04 & 0xffffff7f) {
case 0x02:
sp5c->unk10 = -_depth2Cents(byte2);
osc->unk10 = -_depth2Cents(byte2);
// fall-through
case 0x03:
case 0x04:
case 0x05:
sp5c->unk0c = _depth2Cents(byte2);
osc->unk0c = _depth2Cents(byte2);
break;
case 0x07:
case 0x09:
case 0x0d:
sp5c->unk0c = _depth2Cents(byte2) / 2.0f;
osc->unk0c = _depth2Cents(byte2) / 2.0f;
break;
case 0x0a:
sp5c->unk0c = _depth2Cents(byte2) * 2.0f;
osc->unk0c = _depth2Cents(byte2) * 2.0f;
break;
default:
sp5c->unk0c = _depth2Cents(byte2);
osc->unk0c = _depth2Cents(byte2);
break;
}
}
}
break;
case 0x19:
seqp->chanState[chan].unk31 = byte2;
case AL_MIDI_TIMEINDEX_CTRL:
seqp->chanState[chan].timeindex = byte2;
break;
default:
break;
@ -1084,7 +1084,7 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
break;
case (AL_MIDI_ProgramChange):
/* sct 1/16/96 - We must have a valid bank in order to process the program change. */
sp90 = (seqp->chanState[chan].unk32 << 7) + key;
sp90 = (seqp->chanState[chan].instmajor << 7) + key;
if (sp90 < seqp->bank->instCount) {
ALInstrument *inst = seqp->bank->instArray[sp90];
@ -1111,10 +1111,10 @@ void __n_CSPHandleMIDIMsg(N_ALCSPlayer *seqp, N_ALEvent *event)
for (vs = seqp->vAllocHead; vs != 0; vs = vs->next) {
if (vs->channel == chan) {
n_alSynSetPitch( &vs->voice, vs->pitch * bendRatio * vs->vibrato);
n_alSynSetPitch(&vs->voice, vs->pitch * bendRatio * vs->vibrato);
if (seqp->chanState[chan].unk11) {
n_alSynFilter13(&vs->voice, 440 * func0003b9d4(seqp->chanState[chan].unk12 + (vs->key - vs->sound->keyMap->keyBase) - 64) * bendRatio * vs->vibrato);
n_alSynFilter13(&vs->voice, 440 * alSemitones2Ratio(vs->key - vs->sound->keyMap->keyBase + seqp->chanState[chan].unk12 - 64) * bendRatio * vs->vibrato);
}
}
}
@ -1241,7 +1241,7 @@ void __n_CSPPostNextSeqEvent(N_ALCSPlayer *seqp)
n_alEvtqPostEvent(&seqp->evtq, &evt, deltaTicks * seqp->uspt, 0);
}
void func00037634(N_ALCSPlayer *seqp, u8 value)
void n_alCSPVoiceLimit(N_ALCSPlayer *seqp, u8 value)
{
seqp->unk88 = value;
seqp->voicelimit = value;
}

10
src/lib/naudio/n_drvrNew.c
View File

@ -62,7 +62,7 @@ void func0003b710(f32 outputrate, f32 arg1, f32 arg2, f32 *arg3, f32 *arg4)
arg4[2] = ((1 + sp20) - sp1c) / (1 + sp20 + sp1c);
}
void _init_lpfilter(ALLowPass *lp)
void n_alFxInitlpfilter(ALLowPass *lp)
{
s32 i, temp;
s16 fc;
@ -89,7 +89,7 @@ void _init_lpfilter(ALLowPass *lp)
}
}
f32 func0003b9d4(s32 arg0)
f32 alSemitones2Ratio(s32 arg0)
{
f32 mult;
f32 value;
@ -115,7 +115,7 @@ f32 func0003b9d4(s32 arg0)
return value;
}
void func0003ba64(struct fx *fx, f32 outputrate)
void n_alFxInitlpfilter_mono(struct fx *fx, f32 outputrate)
{
s32 i;
f32 sp30[3];
@ -156,7 +156,7 @@ void n_alFxNew(ALFx **fx_ar, ALSynConfig *c, s16 bus, ALHeap *hp)
*fx_ar = r = (ALFx *)alHeapAlloc(hp, 1, sizeof(ALFx));
switch (c->fxTypes[bus]) {
case 6:
case AL_FX_CUSTOM:
param = c->params[bus];
break;
default:
@ -225,7 +225,7 @@ void n_alFxNew(ALFx **fx_ar, ALSynConfig *c, s16 bus, ALHeap *hp)
d->lp->fstate[0] = alHeapAlloc(hp, 1, sizeof(POLEF_STATE));
d->lp->fstate[1] = alHeapAlloc(hp, 1, sizeof(POLEF_STATE));
d->lp->fc = param[j++];
_init_lpfilter(d->lp);
n_alFxInitlpfilter(d->lp);
} else {
d->lp = 0;
j++;

6
src/lib/naudio/n_env.c
View File

@ -306,13 +306,13 @@ s32 n_alEnvmixerParam(N_PVoice *filter, s32 paramID, void *param)
e->rs_first = 1;
e->rs_upitch = 0;
n_alResampleParam2(e, AL_FILTER_RESET, param);
n_alLPFilterParam(e, AL_FILTER_RESET, param);
break;
case AL_FILTER_START:
e->em_motion = AL_PLAYING;
break;
default:
n_alResampleParam2(e, paramID, param);
n_alLPFilterParam(e, paramID, param);
break;
}
@ -334,7 +334,7 @@ Acmd *_pullSubFrame(N_PVoice *filter, s16 *inp, s16 *outp, s32 outCount, Acmd *p
* lists.
*/
ptr = n_alResamplePull2(e, inp, outCount, p);
ptr = n_alLPFilterPull(e, inp, outCount, p);
/*
* construct our portion of the command list

4
src/lib/naudio/n_mainbus.c
View File

@ -2,7 +2,7 @@
#include "n_synthInternals.h"
s32 mp3_make_samples(s32 arg0, Acmd **cmd);
void func0003ba64(struct fx *fx, f32 outputrate);
void n_alFxInitlpfilter_mono(struct fx *fx, f32 outputrate);
Acmd *n_alMainBusPull(s32 sampleOffset, Acmd *p)
{
@ -36,7 +36,7 @@ Acmd *n_alMainBusPull(s32 sampleOffset, Acmd *p)
struct auxbus44 *bus44 = n_syn->auxBus[i].unk44;
if (bus44->unk28) {
func0003ba64(&bus44->fx, n_syn->outputRate);
n_alFxInitlpfilter_mono(&bus44->fx, n_syn->outputRate);
}
n_aLoadADPCM(ptr++, 32, osVirtualToPhysical(&bus44->fx.unk08));

8
src/lib/naudio/n_resample2.c
View File

@ -3,9 +3,9 @@
#include <gu.h>
#include "types.h"
void func0003ba64(struct fx *fx, f32 outputrate);
void n_alFxInitlpfilter_mono(struct fx *fx, f32 outputrate);
Acmd *n_alResamplePull2(N_PVoice *e, s16 *outp, s32 outCount, Acmd *p)
Acmd *n_alLPFilterPull(N_PVoice *e, s16 *outp, s32 outCount, Acmd *p)
{
Acmd *ptr = p;
f32 sp28;
@ -28,7 +28,7 @@ Acmd *n_alResamplePull2(N_PVoice *e, s16 *outp, s32 outCount, Acmd *p)
if (e->fx.unk02 > 0) {
if (e->unkb8 != 0) {
func0003ba64(&e->fx, 22050);
n_alFxInitlpfilter_mono(&e->fx, 22050);
}
n_aLoadADPCM(ptr++, 32, osVirtualToPhysical(e->fx.unk08))
@ -45,7 +45,7 @@ Acmd *n_alResamplePull2(N_PVoice *e, s16 *outp, s32 outCount, Acmd *p)
return ptr;
}
s32 n_alResampleParam2(N_PVoice *filter, s32 paramID, void *param)
s32 n_alLPFilterParam(N_PVoice *filter, s32 paramID, void *param)
{
f32 *f = (f32 *) &param;

2
src/lib/naudio/n_reverb.c
View File

@ -186,7 +186,7 @@ s32 n_alFxParamHdl(void *filter, s32 paramID, void *param)
case LPFILT_PARAM:
if (f->delay[s].lp) {
f->delay[s].lp->fc = (s16)val;
_init_lpfilter(f->delay[s].lp);
n_alFxInitlpfilter(f->delay[s].lp);
}
break;
}

36
src/lib/naudio/n_seqplayer.c
View File

@ -30,7 +30,7 @@ void __n_unmapVoice(N_ALSeqPlayer *seqp, N_ALVoice *voice)
vs->next = seqp->vFreeList;
seqp->vFreeList = vs;
seqp->unk89--;
seqp->voicecount--;
return;
}
@ -133,7 +133,7 @@ N_ALVoiceState *__n_mapVoice(N_ALSeqPlayer *seqp, u8 key, u8 vel, u8 channel)
{
N_ALVoiceState *vs = seqp->vFreeList;
if (seqp->unk89 > seqp->unk88) {
if (seqp->voicecount > seqp->voicelimit) {
return 0;
}
@ -154,7 +154,7 @@ N_ALVoiceState *__n_mapVoice(N_ALSeqPlayer *seqp, u8 key, u8 vel, u8 channel)
vs->velocity = vel;
vs->voice.clientPrivate = vs;
seqp->unk89++;
seqp->voicecount++;
}
return vs;
@ -213,8 +213,8 @@ s16 __n_vsVol(N_ALVoiceState *vs, N_ALSeqPlayer *seqp)
u32 t1 = (vs->tremelo * vs->velocity * vs->envGain) >> 6;
u32 t2 = (vs->sound->sampleVolume * seqp->vol * seqp->chanState[vs->channel].vol) >> 14;
if (seqp->chanState[vs->channel].unk0d != 0xff) {
t2 = (seqp->chanState[vs->channel].unk0d * t2 + 1) >> 8;
if (seqp->chanState[vs->channel].fadevolcurrent != 0xff) {
t2 = (seqp->chanState[vs->channel].fadevolcurrent * t2 + 1) >> 8;
}
t1 *= t2;
@ -223,12 +223,12 @@ s16 __n_vsVol(N_ALVoiceState *vs, N_ALSeqPlayer *seqp)
return t1;
}
u8 func0003d9cc(N_ALVoiceState *vs, N_ALCSPlayer *seqp)
u8 __n_vsMix(N_ALVoiceState *vs, N_ALCSPlayer *seqp)
{
s32 sp14 = seqp->chanState[vs->channel].fxmix & 0x80;
s32 sp10 = ((seqp->chanState[vs->channel].fxmix & 0x7f) + (s32)(seqp->unk7c * 127)) * seqp->unk80;
s32 sign = seqp->chanState[vs->channel].fxmix & 0x80;
s32 fxmix = ((seqp->chanState[vs->channel].fxmix & 0x7f) + (s32)(seqp->fxmixmajor * 127)) * seqp->fxmixmega;
return ((sp10 > 127 ? 127 : sp10) < 0 ? 0 : (sp10 > 127 ? 127 : sp10)) | sp14;
return MAX(0, MIN(127, fxmix)) | sign;
}
ALMicroTime __n_vsDelta(N_ALVoiceState *vs, ALMicroTime t)
@ -307,15 +307,15 @@ void __n_resetPerfChanState(N_ALSeqPlayer *seqp, s32 chan)
seqp->chanState[chan].sustain = 0;
seqp->chanState[chan].bendRange = 200;
seqp->chanState[chan].pitchBend = 1;
seqp->chanState[chan].unk10 = 0;
seqp->chanState[chan].unk0d = 255;
seqp->chanState[chan].unk0e = 255;
seqp->chanState[chan].unk0f = 0;
seqp->chanState[chan].unk0b = 0;
seqp->chanState[chan].notemesgflags = 0;
seqp->chanState[chan].fadevolcurrent = 255;
seqp->chanState[chan].fadevoltarget = 255;
seqp->chanState[chan].fadevolinc = 0;
seqp->chanState[chan].fxbus = 0;
seqp->chanState[chan].unk13 = 0;
seqp->chanState[chan].unk12 = 0;
seqp->chanState[chan].unk11 = 0;
seqp->chanState[chan].unk32 = 0;
seqp->chanState[chan].instmajor = 0;
}
void __n_setInstChanState(N_ALSeqPlayer *seqp, ALInstrument *inst, s32 chan)
@ -340,7 +340,7 @@ void __n_setInstChanState(N_ALSeqPlayer *seqp, ALInstrument *inst, s32 chan)
seqp->chanState[chan].attackVolume = sound->envelope->attackVolume;
seqp->chanState[chan].decayVolume = sound->envelope->decayVolume;
seqp->chanState[chan].unk27 = 0;
seqp->chanState[chan].pitch = 0;
seqp->chanState[chan].tremType = inst->tremType;
seqp->chanState[chan].tremRate = inst->tremRate;
seqp->chanState[chan].tremDepth = inst->tremDepth;
@ -350,8 +350,8 @@ void __n_setInstChanState(N_ALSeqPlayer *seqp, ALInstrument *inst, s32 chan)
seqp->chanState[chan].vibDepth = inst->vibDepth;
seqp->chanState[chan].vibDelay = inst->vibDelay;
seqp->chanState[chan].unk24 = 0;
seqp->chanState[chan].unk31 = 0;
seqp->chanState[chan].usechanparams = 0;
seqp->chanState[chan].timeindex = 0;
}
void __n_seqpStopOsc(N_ALSeqPlayer *seqp, N_ALVoiceState *vs)

95
src/lib/naudio/n_sndplayer.c
View File

@ -8,6 +8,14 @@
#include "data.h"
#include "types.h"
#define KEYMAP_DELAY(m) (m->velocityMax * 33333)
#define KEYMAP_FLAGS(m) (m->keyMax & 0xf0)
#define KEYMAP_FXMIX(m) ((m->keyMax & 0x0f) * 8)
#define KEYMAP_PITCHCENTS_EXACT(m) (m->keyBase * 100 + m->detune - 6000)
#define KEYMAP_PITCHCENTS_ROUGH(m) (m->keyBase * 100 - 6000)
#define KEYMAP_SOUNDNUM(m) (m->velocityMin + (m->keyMin & 0xc0) * 4)
#define KEYMAP_VOLINDEX(m) (m->keyMin & 0x1f)
u32 var8009c330;
s16 *g_SndpVolumeTable;
@ -60,7 +68,7 @@ void n_alSndpNew(ALSndpConfig *config)
g_SndpVolumeTable = alHeapAlloc(config->heap, sizeof(s16), config->maxVolumes);
for (i = 0; i < config->maxVolumes; i++) {
g_SndpVolumeTable[i] = 0x7fff;
g_SndpVolumeTable[i] = AL_VOL_FULL;
}
// Add ourselves to the driver
@ -165,12 +173,12 @@ void _n_handleEvent(N_ALSndpEvent *event)
config.unityPitch = 0;
isfull = g_SndpNumPlaying >= g_SndPlayer->maxSounds;
if (!isfull || (state->flags & SNDSTATEFLAG_10)) {
if (!isfull || (state->flags & SNDSTATEFLAG_PARENT_OF_LEAF)) {
hasvoice = n_alSynAllocVoice(&state->voice, &config);
}
if (!hasvoice) {
if (state->flags & (SNDSTATEFLAG_NO_DECAY | SNDSTATEFLAG_10) || state->unk34 > 0) {
if (state->flags & (SNDSTATEFLAG_NO_DECAY | SNDSTATEFLAG_PARENT_OF_LEAF) || state->unk34 > 0) {
state->state = AL_STATE4;
state->unk34--;
n_alEvtqPostEvent(&g_SndPlayer->evtq, &event->msg, 33333, 0);
@ -178,7 +186,7 @@ void _n_handleEvent(N_ALSndpEvent *event)
iterstate = g_SndpAllocStatesTail;
do {
if ((iterstate->flags & (SNDSTATEFLAG_NO_DECAY | SNDSTATEFLAG_10)) == 0
if ((iterstate->flags & (SNDSTATEFLAG_NO_DECAY | SNDSTATEFLAG_PARENT_OF_LEAF)) == 0
&& (iterstate->flags & SNDSTATEFLAG_HAS_VOICE)
&& iterstate->state != AL_STATE3) {
isfull = false;
@ -242,11 +250,11 @@ void _n_handleEvent(N_ALSndpEvent *event)
state->endtime = g_SndPlayer->curTime + delta;
#endif
vol = MAX(0, (g_SndpVolumeTable[keymap->keyMin & 0x1f] * (state->envvol * state->vol * sound->sampleVolume / 0x3f01)) / 0x7fff - 1);
vol = MAX(0, (g_SndpVolumeTable[KEYMAP_VOLINDEX(keymap)] * (state->envvol * state->vol * sound->sampleVolume / 0x3f01)) / AL_VOL_FULL - 1);
tmppan = state->pan + sound->samplePan - AL_PAN_CENTER;
pan = MIN(MAX(tmppan, 0), 127);
fxmix = (state->fxmix & 0x7f) + (keymap->keyMax & 0xf) * 8;
fxmix = (state->fxmix & 0x7f) + KEYMAP_FXMIX(keymap);
fxmix = MIN(127, MAX(0, fxmix));
fxmix |= state->fxmix & 0x80;
@ -258,7 +266,7 @@ void _n_handleEvent(N_ALSndpEvent *event)
if (delta == 0) {
state->envvol = sound->envelope->decayVolume;
vol = MAX(0, (g_SndpVolumeTable[keymap->keyMin & 0x1f] * (state->envvol * state->vol * sound->sampleVolume / 0x3f01)) / 0x7fff - 1);
vol = MAX(0, (g_SndpVolumeTable[KEYMAP_VOLINDEX(keymap)] * (state->envvol * state->vol * sound->sampleVolume / 0x3f01)) / AL_VOL_FULL - 1);
delta = sound->envelope->decayTime / state->basepitch / state->pitch;
@ -317,8 +325,8 @@ void _n_handleEvent(N_ALSndpEvent *event)
* - If the sound has no releaseTime, free it immediately
*/
case AL_SNDP_STOP_EVT:
case AL_SNDP_STOPALL_EVT:
case AL_SNDP_STOP2_EVT:
case AL_SNDP_STOPALL_EVT:
if (event->common.type != AL_SNDP_STOP2_EVT || (state->flags & SNDSTATEFLAG_NO_DECAY)) {
switch (state->state) {
case AL_PLAYING:
@ -356,6 +364,7 @@ void _n_handleEvent(N_ALSndpEvent *event)
}
}
break;
case AL_SNDP_PAN_EVT:
state->pan = event->common.unk08;
@ -381,7 +390,7 @@ void _n_handleEvent(N_ALSndpEvent *event)
state->fxmix = event->common.unk08;
if (state->state == AL_PLAYING) {
fxmix = (state->fxmix & 0x7f) + (keymap->keyMax & 0xf) * 8;
fxmix = (state->fxmix & 0x7f) + KEYMAP_FXMIX(keymap);
fxmix = MIN(127, MAX(0, fxmix));
fxmix |= state->fxmix & 0x80;
@ -392,7 +401,7 @@ void _n_handleEvent(N_ALSndpEvent *event)
state->fxmix = (u8)(state->fxmix & 0x7f) | (u8)(event->common.unk08 & 0x80);
if (state->state == AL_PLAYING) {
fxmix = (state->fxmix & 0x7f) + (keymap->keyMax & 0xf) * 8;
fxmix = (state->fxmix & 0x7f) + KEYMAP_FXMIX(keymap);
fxmix = MIN(127, MAX(0, fxmix));
fxmix |= state->fxmix & 0x80;
@ -414,7 +423,7 @@ void _n_handleEvent(N_ALSndpEvent *event)
state->vol = event->common.unk08;
if (state->state == AL_PLAYING) {
vol = MAX(0, (g_SndpVolumeTable[keymap->keyMin & 0x1f] * (state->envvol * state->vol * sound->sampleVolume / 0x3f01)) / 0x7fff - 1);
vol = MAX(0, (g_SndpVolumeTable[KEYMAP_VOLINDEX(keymap)] * (state->envvol * state->vol * sound->sampleVolume / 0x3f01)) / AL_VOL_FULL - 1);
n_alSynSetVol(&state->voice, vol, MAX(1000, state->endtime - g_SndPlayer->curTime));
}
@ -430,7 +439,7 @@ void _n_handleEvent(N_ALSndpEvent *event)
}
#endif
vol = MAX(0, g_SndpVolumeTable[keymap->keyMin & 0x1f] * (state->envvol * state->vol * sound->sampleVolume / 0x3f01) / 0x7fff - 1);
vol = MAX(0, g_SndpVolumeTable[KEYMAP_VOLINDEX(keymap)] * (state->envvol * state->vol * sound->sampleVolume / 0x3f01) / AL_VOL_FULL - 1);
n_alSynSetVol(&state->voice, vol, delta);
}
@ -438,7 +447,7 @@ void _n_handleEvent(N_ALSndpEvent *event)
case AL_SNDP_DECAY_EVT:
if ((state->flags & SNDSTATEFLAG_NO_DECAY) == 0) {
state->envvol = sound->envelope->decayVolume;
vol = MAX(0, g_SndpVolumeTable[keymap->keyMin & 0x1f] * (state->envvol * state->vol * sound->sampleVolume / 0x3f01) / 0x7fff - 1);
vol = MAX(0, g_SndpVolumeTable[KEYMAP_VOLINDEX(keymap)] * (state->envvol * state->vol * sound->sampleVolume / 0x3f01) / AL_VOL_FULL - 1);
delta = sound->envelope->decayTime / state->basepitch / state->pitch;
#if VERSION >= VERSION_NTSC_1_0
@ -466,7 +475,7 @@ void _n_handleEvent(N_ALSndpEvent *event)
sndp_free_state(state);
break;
case AL_SNDP_PLAYNEXT_EVT:
if (state->flags & SNDSTATEFLAG_10) {
if (state->flags & SNDSTATEFLAG_PARENT_OF_LEAF) {
sndp_play_sound(event->msg.msg.generic.data2, event->msg.msg.generic.data, state->vol, state->pan,
state->pitch, state->fxmix, state->fxbus, state->unk30);
}
@ -615,13 +624,13 @@ struct sndstate *sndp_alloc_state(s32 arg0, ALSound *sound)
state->state = AL_STATE5;
state->pitch = 1;
state->unk34 = 2;
state->flags = keymap->keyMax & 0xf0;
state->flags = KEYMAP_FLAGS(keymap);
state->unk30 = NULL;
if (state->flags & SNDSTATEFLAG_HAS_DETUNE_PITCH) {
state->basepitch = alCents2Ratio(keymap->keyBase * 100 - 6000);
state->basepitch = alCents2Ratio(KEYMAP_PITCHCENTS_ROUGH(keymap));
} else {
state->basepitch = alCents2Ratio(keymap->keyBase * 100 + keymap->detune - 6000);
state->basepitch = alCents2Ratio(KEYMAP_PITCHCENTS_EXACT(keymap));
}
if (sp18) {
@ -630,7 +639,7 @@ struct sndstate *sndp_alloc_state(s32 arg0, ALSound *sound)
state->fxmix = 0;
state->pan = AL_PAN_CENTER;
state->vol = 0x7fff;
state->vol = AL_VOL_FULL;
if (g_SndpAddRefCallback != NULL) {
g_SndpAddRefCallback(state->sound);
@ -712,8 +721,8 @@ struct sndstate *sndp_play_sound(s32 arg0, s16 soundnum, u16 vol, ALPan pan, f32
struct sndstate *leafstate = NULL;
ALKeyMap *keymap;
ALSound *sound;
s16 sp4e = 0;
s32 sp48;
s16 prevsoundnum = 0;
s32 prevdelay;
s32 thisdelay;
s32 sumdelay = 0;
s32 abspan;
@ -735,14 +744,14 @@ struct sndstate *sndp_play_sound(s32 arg0, s16 soundnum, u16 vol, ALPan pan, f32
evt.msg.generic.sndstate = state;
abspan = pan + state->pan - AL_PAN_CENTER;
if (abspan > 127) {
abspan = 127;
} else if (abspan < 0) {
abspan = 0;
if (abspan > AL_PAN_RIGHT) {
abspan = AL_PAN_RIGHT;
} else if (abspan < AL_PAN_LEFT) {
abspan = AL_PAN_LEFT;
}
state->pan = abspan;
state->vol = (u32)(vol * state->vol) >> 15;
state->vol = (u32)(vol * state->vol) / 32768;
state->pitch *= pitch;
state->fxmix = fxmix;
state->fxbus = fxbus;
@ -751,13 +760,13 @@ struct sndstate *sndp_play_sound(s32 arg0, s16 soundnum, u16 vol, ALPan pan, f32
state->cleanuptime = 0;
#endif
thisdelay = sound->keyMap->velocityMax * 33333;
thisdelay = KEYMAP_DELAY(sound->keyMap);
if (state->flags & SNDSTATEFLAG_10) {
state->flags &= ~SNDSTATEFLAG_10;
if (state->flags & SNDSTATEFLAG_RELATIVE_DELAY) {
state->flags &= ~SNDSTATEFLAG_RELATIVE_DELAY;
n_alEvtqPostEvent(&g_SndPlayer->evtq, &evt, sumdelay + 1, 0);
sp48 = thisdelay + 1;
sp4e = soundnum;
prevdelay = thisdelay + 1;
prevsoundnum = soundnum;
} else {
n_alEvtqPostEvent(&g_SndPlayer->evtq, &evt, thisdelay + 1, 0);
}
@ -767,22 +776,22 @@ struct sndstate *sndp_play_sound(s32 arg0, s16 soundnum, u16 vol, ALPan pan, f32
sumdelay += thisdelay;
keymap = sound->keyMap;
soundnum = keymap->velocityMin + ((keymap->keyMin & 0xc0) << 2);
soundnum = KEYMAP_SOUNDNUM(keymap);
} while (soundnum && state);
if (leafstate != NULL) {
leafstate->flags |= SNDSTATEFLAG_LEAF;
leafstate->unk30 = handleptr;
if (sp4e != 0) {
leafstate->flags |= SNDSTATEFLAG_10;
if (prevsoundnum != 0) {
leafstate->flags |= SNDSTATEFLAG_PARENT_OF_LEAF;
evt2.type = AL_SNDP_PLAYNEXT_EVT;
evt2.msg.generic.sndstate = leafstate;
evt2.msg.generic.data = sp4e;
evt2.msg.generic.data = prevsoundnum;
evt2.msg.generic.data2 = arg0;
n_alEvtqPostEvent(&g_SndPlayer->evtq, &evt2, sp48, 0);
n_alEvtqPostEvent(&g_SndPlayer->evtq, &evt2, prevdelay, 0);
}
}
}
@ -806,7 +815,7 @@ void sndp_stop_sound(struct sndstate *state)
evt.msg.generic.sndstate = state;
if (state != NULL) {
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_10;
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_PARENT_OF_LEAF;
n_alEvtqPostEvent(&g_SndPlayer->evtq, &evt, 0, 0);
}
@ -820,7 +829,7 @@ void sndp_stop_sound(struct sndstate *state)
evt.msg.generic.sndstate = state;
if (state != NULL) {
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_10;
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_PARENT_OF_LEAF;
n_alEvtqPostEvent(&g_SndPlayer->evtq, &evt, 0, 0);
}
@ -830,7 +839,7 @@ void sndp_stop_sound(struct sndstate *state)
evt.msg.generic.sndstate = state;
if (state != NULL) {
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_10;
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_PARENT_OF_LEAF;
n_alEvtqPostEvent(&g_SndPlayer->evtq, &evt, 0, 0);
}
@ -846,7 +855,7 @@ void sndp_post_end_event(struct sndstate *state)
evt.msg.generic.sndstate = state;
if (state) {
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_10;
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_PARENT_OF_LEAF;
n_alEvtqPostEvent(&g_SndPlayer->evtq, &evt, 0, 0);
}
@ -864,7 +873,7 @@ void sndp_post_stopall_event_bulk(u8 flags)
evt.msg.generic.sndstate = state;
if ((state->flags & flags) == flags) {
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_10;
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_PARENT_OF_LEAF;
n_alEvtqPostEvent(&g_SndPlayer->evtq, &evt, 0, 0);
}
@ -886,7 +895,7 @@ void sndp_post_end_event_bulk(u8 flags)
evt.msg.generic.sndstate = state;
if ((state->flags & flags) == flags) {
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_10;
evt.msg.generic.sndstate->flags &= ~SNDSTATEFLAG_PARENT_OF_LEAF;
n_alEvtqPostEvent(&g_SndPlayer->evtq, &evt, 0, 0);
}
@ -911,7 +920,7 @@ void sndp_stop_all(void)
void sndp_stop_specials(void)
{
sndp_post_stopall_event_bulk(SNDSTATEFLAG_LEAF | SNDSTATEFLAG_10);
sndp_post_stopall_event_bulk(SNDSTATEFLAG_LEAF | SNDSTATEFLAG_PARENT_OF_LEAF);
}
void sndp_stop_nodecays(void)
@ -969,7 +978,7 @@ void sndp_set_volume_entry(u8 index, u16 volume)
g_SndpVolumeTable[index] = volume;
for (i = 0; state != NULL; i++, state = (struct sndstate *)state->node.next) {
if ((state->sound->keyMap->keyMin & 0x1f) == index) {
if (KEYMAP_VOLINDEX(state->sound->keyMap) == index) {
evt.type = AL_SNDP_VOLTBL_EVT;
evt.msg.generic.sndstate = state;
n_alEvtqPostEvent(&g_SndPlayer->evtq, &evt, 0, 0);

6
src/lib/naudio/n_synsetfxparam.c
View File

@ -7,9 +7,9 @@ void n_alSynSetFXParam(ALFxRef fx, s16 paramID, void *param)
n_alFxParamHdl(f, (s32)paramID, param);
}
void func0003ba64(struct fx *fx, f32 outputrate);
void n_alFxInitlpfilter_mono(struct fx *fx, f32 outputrate);
void func0003e674(struct fx *fx, s16 arg1, void *param)
void n_alSynSetOutputLPParam(struct fx *fx, s16 arg1, void *param)
{
if (arg1 == 8) {
fx->unk02 = (*(s32 *)param * 0.1f);
@ -17,5 +17,5 @@ void func0003e674(struct fx *fx, s16 arg1, void *param)
fx->unk00 = *(s32 *)param;
}
func0003ba64(fx, n_syn->outputRate);
n_alFxInitlpfilter_mono(fx, n_syn->outputRate);
}

4
src/lib/naudio/n_synthInternals.h
View File

@ -151,9 +151,9 @@ Acmd *n_alAdpcmPull(N_PVoice *f,s16 *outp, s32 byteCount, Acmd *p);
s32 n_alLoadParam(N_PVoice *filter, s32 paramID, void *param);
Acmd *n_alResamplePull(N_PVoice *f, s16 *outp, Acmd *p);
Acmd *n_alResamplePull2(N_PVoice *f, s16 *outp, s32 outCount, Acmd *p);
Acmd *n_alLPFilterPull(N_PVoice *f, s16 *outp, s32 outCount, Acmd *p);
s32 n_alResampleParam(N_PVoice *f, s32 paramID, void *param);
s32 n_alResampleParam2(N_PVoice *f, s32 paramID, void *param);
s32 n_alLPFilterParam(N_PVoice *f, s32 paramID, void *param);
Acmd *n_alEnvmixerPull(N_PVoice *f, s32 sampleOffset, Acmd *p);
s32 n_alEnvmixerParam(N_PVoice *p, s32 paramID, void *param);

288
src/lib/snd.c
View File

@ -716,151 +716,130 @@ struct audioconfig g_AudioConfigs[] = {
{ /*62*/ 1000, 2500, 3000, -1, 100, -1, 0, AUDIOCONFIGFLAG_IGNOREROOMS },
{ /*63*/ 400, 1000, 1200, -1, 100, -1, 0, 0 },
#endif
{ 0 },
};
u32 var8005ecd8 = 0x00000000;
u32 var8005ecdc = 0x00000000;
u32 var8005ece0 = 0x00000000;
u32 var8005ece4 = 0x00000000;
u32 var8005ece8 = 0x00000000;
u32 var8005ecec = 0x00000000;
u32 var8005ecf0 = 0x00000000;
u32 var8005ecf4 = 0x00000000;
s16 var8005ecf8[] = {
0x6665,
0x5998,
0x5fff,
0x4ccc,
0x5fff,
0x2ccc,
0x5998,
0x6665,
0x4ccc,
0x5998,
0x5998,
0x5998,
0x5fff,
0x6665,
0x6665,
0x5fff,
0x5998,
0x6665,
0x5fff,
0x5fff,
0x5fff,
0x6665,
0x5fff,
0x5fff,
0x5fff,
0x7332,
0x5fff,
0x6665,
0x5fff,
#if VERSION >= VERSION_NTSC_1_0
0x5998,
0x5998,
#else
0x5fff,
0x5fff,
#endif
0x5332,
0x5332,
0x5fff,
0x3332,
#if VERSION >= VERSION_NTSC_1_0
0x4ccc,
#else
0x3fff,
#endif
0x5fff,
0x4ccc,
0x3fff,
0x5fff,
0x5fff,
0x5fff,
0x5fff,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x5fff,
0x5fff,
0x5fff,
0x5fff,
0x5fff,
0x5fff,
0x5fff,
0x4ccc,
0x5fff,
0x5fff,
0x5fff,
0x5fff,
0x5fff,
0x5fff,
0x5fff,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x7332,
0x7332,
0x7332,
0x4ccc,
#if VERSION >= VERSION_NTSC_1_0
0x3c28,
#else
0x4ccc,
#endif
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x7332,
0x7332,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x6665,
0x4ccc,
0x4ccc,
0x4ccc,
0x4ccc,
0x6ccb,
0x5fff,
0x5998,
0x7998,
0x5998,
0x5998,
0x6665,
0x5fff,
0x5fff,
0x7332,
0x7332,
0x7332,
0x7332,
0x7332,
0x4ccc,
0x6665,
0x6665,
0x6665,
0x4ccc,
0x6ccb,
s16 g_SeqVolumes[] = {
/* MUSIC_NONE */ AL_VOL_FULL * 0.80,
/* MUSIC_TITLE2 */ AL_VOL_FULL * 0.70,
/* MUSIC_EXTRACTION */ AL_VOL_FULL * 0.75,
/* MUSIC_PAUSEMENU */ AL_VOL_FULL * 0.60,
/* MUSIC_DEFENSE */ AL_VOL_FULL * 0.75,
/* MUSIC_INVESTIGATION_SFX */ AL_VOL_FULL * 0.35,
/* MUSIC_ESCAPE */ AL_VOL_FULL * 0.70,
/* MUSIC_DEEPSEA */ AL_VOL_FULL * 0.80,
/* MUSIC_DDTOWER_SFX */ AL_VOL_FULL * 0.60,
/* MUSIC_DEFECTION */ AL_VOL_FULL * 0.70,
/* MUSIC_DEATH_SOLO */ AL_VOL_FULL * 0.70,
/* MUSIC_DEFECTION_INTRO_SFX */ AL_VOL_FULL * 0.70,
/* MUSIC_VILLA */ AL_VOL_FULL * 0.75,
/* MUSIC_CI */ AL_VOL_FULL * 0.80,
/* MUSIC_CHICAGO */ AL_VOL_FULL * 0.80,
/* MUSIC_G5 */ AL_VOL_FULL * 0.75,
/* MUSIC_DEFECTION_X */ AL_VOL_FULL * 0.70,
/* MUSIC_EXTRACTION_X */ AL_VOL_FULL * 0.80,
/* MUSIC_INVESTIGATION */ AL_VOL_FULL * 0.75,
/* MUSIC_INVESTIGATION_X */ AL_VOL_FULL * 0.75,
/* MUSIC_INFILTRATION */ AL_VOL_FULL * 0.75,
/* MUSIC_DEATH_BETA */ AL_VOL_FULL * 0.80,
/* MUSIC_RESCUE */ AL_VOL_FULL * 0.75,
/* MUSIC_AIRBASE */ AL_VOL_FULL * 0.75,
/* MUSIC_AIRFORCEONE */ AL_VOL_FULL * 0.75,
/* MUSIC_DEATH_MP */ AL_VOL_FULL * 0.90,
/* MUSIC_EXTRACTION_OUTRO_SFX */ AL_VOL_FULL * 0.75,
/* MUSIC_MISSION_UNKNOWN */ AL_VOL_FULL * 0.80,
/* MUSIC_PELAGIC */ AL_VOL_FULL * 0.75,
/* MUSIC_CRASHSITE */ AL_VOL_FULL * (VERSION >= VERSION_NTSC_1_0 ? 0.70 : 0.75),
/* MUSIC_CRASHSITE_X */ AL_VOL_FULL * (VERSION >= VERSION_NTSC_1_0 ? 0.70 : 0.75),
/* MUSIC_ATTACKSHIP */ AL_VOL_FULL * 0.65,
/* MUSIC_ATTACKSHIP_X */ AL_VOL_FULL * 0.65,
/* MUSIC_SKEDARRUINS */ AL_VOL_FULL * 0.75,
/* MUSIC_DEFECTION_INTRO */ AL_VOL_FULL * 0.40,
/* MUSIC_DEFECTION_OUTRO */ AL_VOL_FULL * (VERSION >= VERSION_NTSC_1_0 ? 0.60 : 0.50),
/* MUSIC_DEFENSE_X */ AL_VOL_FULL * 0.75,
/* MUSIC_INVESTIGATION_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_INVESTIGATION_OUTRO */ AL_VOL_FULL * 0.50,
/* MUSIC_VILLA_X */ AL_VOL_FULL * 0.75,
/* MUSIC_CHICAGO_X */ AL_VOL_FULL * 0.75,
/* MUSIC_G5_X */ AL_VOL_FULL * 0.75,
/* MUSIC_INFILTRATION_X */ AL_VOL_FULL * 0.75,
/* MUSIC_CHICAGO_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_EXTRACTION_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_EXTRACTION_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_G5_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_CHICAGO_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_VILLA_INTRO1 */ AL_VOL_FULL * 0.60,
/* MUSIC_INFILTRATION_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_RESCUE_X */ AL_VOL_FULL * 0.75,
/* MUSIC_ESCAPE_X */ AL_VOL_FULL * 0.75,
/* MUSIC_AIRBASE_X */ AL_VOL_FULL * 0.75,
/* MUSIC_AIRFORCEONE_X */ AL_VOL_FULL * 0.75,
/* MUSIC_PELAGIC_X */ AL_VOL_FULL * 0.75,
/* MUSIC_DEEPSEA_X */ AL_VOL_FULL * 0.75,
/* MUSIC_SKEDARRUINS_X */ AL_VOL_FULL * 0.75,
/* MUSIC_AIRBASE_OUTRO_LONG */ AL_VOL_FULL * 0.60,
/* MUSIC_DARK_COMBAT */ AL_VOL_FULL * 0.75,
/* MUSIC_SKEDAR_MYSTERY */ AL_VOL_FULL * 0.75,
/* MUSIC_DEEPSEA_BETA */ AL_VOL_FULL * 0.75,
/* MUSIC_CI_OPERATIVE */ AL_VOL_FULL * 0.75,
/* MUSIC_DATADYNE_ACTION */ AL_VOL_FULL * 0.75,
/* MUSIC_MAIAN_TEARS */ AL_VOL_FULL * 0.75,
/* MUSIC_ALIEN_CONFLICT */ AL_VOL_FULL * 0.75,
/* MUSIC_ESCAPE_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_RESCUE_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_VILLA_INTRO2 */ AL_VOL_FULL * 0.60,
/* MUSIC_VILLA_INTRO3 */ AL_VOL_FULL * 0.60,
/* MUSIC_G5_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_G5_MIDCUTSCENE */ AL_VOL_FULL * 0.60,
/* MUSIC_MISSION_FAILED */ AL_VOL_FULL * 0.90,
/* MUSIC_COMBATSIM_MENU */ AL_VOL_FULL * 0.90,
/* MUSIC_MISSION_SUCCESS */ AL_VOL_FULL * 0.90,
/* MUSIC_CRASHSITE_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_AIRBASE_INTRO */ AL_VOL_FULL * (VERSION >= VERSION_NTSC_1_0 ? 0.47 : 0.60),
/* MUSIC_ATTACKSHIP_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_DEEPSEA_MIDCUTSCENE */ AL_VOL_FULL * 0.60,
/* MUSIC_AIRFORCEONE_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_ATTACKSHIP_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_ESCAPE_MIDCUTSCENE */ AL_VOL_FULL * 0.60,
/* MUSIC_RESCUE_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_DEEPSEA_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_INFILTRATION_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_PELAGIC_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_ESCAPE_OUTRO_LONG */ AL_VOL_FULL * 0.60,
/* MUSIC_DEFENSE_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_CRASHSITE_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_CREDITS */ AL_VOL_FULL * 0.90,
/* MUSIC_MAINMENU */ AL_VOL_FULL * 0.90,
/* MUSIC_DEEPSEA_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_AIRFORCEONE_MIDCUTSCENE */ AL_VOL_FULL * 0.60,
/* MUSIC_PELAGIC_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_AIRFORCEONE_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_SKEDARRUINS_INTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_BETA_NOTE */ AL_VOL_FULL * 0.80,
/* MUSIC_AIRBASE_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_DEFENSE_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_SKEDARRUINS_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_VILLA_OUTRO */ AL_VOL_FULL * 0.60,
/* MUSIC_SKEDARRUINS_KING */ AL_VOL_FULL * 0.85,
/* MUSIC_CI_TRAINING */ AL_VOL_FULL * 0.75,
/* MUSIC_CRASHSITE_WIND */ AL_VOL_FULL * 0.70,
/* MUSIC_COMBATSIM_COMPLETE */ AL_VOL_FULL * 0.95,
/* MUSIC_OCEAN */ AL_VOL_FULL * 0.70,
/* MUSIC_WIND */ AL_VOL_FULL * 0.70,
/* MUSIC_TRAFFIC */ AL_VOL_FULL * 0.80,
/* MUSIC_TITLE1 */ AL_VOL_FULL * 0.75,
/* MUSIC_CI_INTRO */ AL_VOL_FULL * 0.75,
/* MUSIC_INFILTRATION_SFX */ AL_VOL_FULL * 0.90,
/* MUSIC_DEEPSEA_SFX */ AL_VOL_FULL * 0.90,
/* MUSIC_AIRFORCEONE_SFX */ AL_VOL_FULL * 0.90,
/* MUSIC_ATTACKSHIP_SFX */ AL_VOL_FULL * 0.90,
/* MUSIC_SKEDAR_WIND */ AL_VOL_FULL * 0.90,
/* MUSIC_ESCAPE_OUTRO_SFX */ AL_VOL_FULL * 0.60,
/* MUSIC_A51_LOUDSPEAKER1 */ AL_VOL_FULL * 0.80,
/* MUSIC_A51_LOUDSPEAKER2 */ AL_VOL_FULL * 0.80,
/* MUSIC_BETA_MELODY */ AL_VOL_FULL * 0.80,
/* MUSIC_ESCAPE_OUTRO_SHORT */ AL_VOL_FULL * 0.60,
AL_VOL_FULL * 0.85,
-1,
};
@ -980,14 +959,13 @@ void snd_load_sfx_ctl(void)
g_NumSounds = ((ALInstrument *)buffer)->soundCount + 1;
// Calculate the size of the ALInstrument and load it. The pointer is then
// shifted forward to point to the instrument's ALSound array. This leaks
// some memory but this is initialisation code so it's not much of an issue.
// shifted forward to point to the instrument's ALSound array.
size = g_NumSounds * 4 + 20;
size = ALIGN16(size);
g_ALSoundRomOffsets = alHeapAlloc(&g_SndHeap, 1, size);
dma_exec(g_ALSoundRomOffsets, romaddr, size);
*(u32 *)&g_ALSoundRomOffsets += 0x10;
g_ALSoundRomOffsets += 4;
// Convert ctl-local offsets to ROM offsets
for (i = 0; i < g_NumSounds; i++) {
@ -1284,27 +1262,27 @@ void snd_set_sound_mode(s32 mode)
switch (mode) {
case SOUNDMODE_MONO:
speakers_set_mode(SPEAKERMODE_MONO);
alSurround_OutputType(SPEAKERMODE_MONO);
break;
case SOUNDMODE_STEREO:
speakers_set_mode(SPEAKERMODE_STEREO);
alSurround_OutputType(SPEAKERMODE_STEREO);
break;
case SOUNDMODE_HEADPHONE:
speakers_set_mode(SPEAKERMODE_HEADPHONE);
alSurround_OutputType(SPEAKERMODE_HEADPHONE);
break;
case SOUNDMODE_SURROUND:
speakers_set_mode(SPEAKERMODE_SURROUND);
alSurround_OutputType(SPEAKERMODE_SURROUND);
break;
}
speaker00034104(0, 4);
alSurround_ReverbSetup(0, 4);
for (i = 1; i < g_SndMaxFxBusses; i++) {
switch (mode) {
case SOUNDMODE_STEREO:
case SOUNDMODE_HEADPHONE:
case SOUNDMODE_SURROUND:
speaker00034104(i, 4);
alSurround_ReverbSetup(i, 4);
break;
}
}
@ -1405,7 +1383,7 @@ void seq_init(struct seqinstance *seq)
config.debugFlags = 0;
config.heap = &g_SndHeap;
func00030c98(&config);
osc_set_handlers(&config);
if (IS4MB()) {
g_SeqBufferSize = MAX_SEQ_SIZE_4MB;
@ -1533,7 +1511,7 @@ void snd_init(void)
synconfig.maxFXbusses = g_SndMaxFxBusses;
for (i = 0; i < g_SndMaxFxBusses; i++) {
synconfig.fxTypes[i] = 6;
synconfig.fxTypes[i] = AL_FX_CUSTOM;
}
sndpconfig.maxEvents = 64;
@ -1692,7 +1670,7 @@ u16 seq_get_volume(struct seqinstance *seq)
void seq_set_volume(struct seqinstance *seq, u16 volume)
{
if (!g_SndDisabled) {
u32 tmp = var8005ecf8[seq->tracknum] * volume;
u32 tmp = g_SeqVolumes[seq->tracknum] * volume;
tmp >>= 15;
seq->volume = volume;

6
src/lib/speaker.c
View File

@ -17,7 +17,7 @@ u8 var8009c344[2];
u8 var8009c346[2];
u8 var8009c348[4];
void speakers_set_mode(u8 mode)
void alSurround_OutputType(u8 mode)
{
s32 i;
@ -38,11 +38,11 @@ void speakers_set_mode(u8 mode)
}
for (i = 0; i < 2; i++) {
speaker00034104(i, 0);
alSurround_ReverbSetup(i, 0);
}
}
void speaker00034104(s32 index, s32 arg1)
void alSurround_ReverbSetup(s32 index, s32 arg1)
{
if (arg1 == 0) {
arg1 = var8009c348[index];

2
src/lib/ultra/audio/synthInternals.h
View File

@ -339,7 +339,7 @@ void _collectPVoices(ALSynth *drvr);
s32 _timeToSamples(ALSynth *ALSynth, s32 micros);
ALMicroTime _samplesToTime(ALSynth *synth, s32 samples);
void _init_lpfilter(ALLowPass *lp);
void n_alFxInitlpfilter(ALLowPass *lp);
#endif