Ported libmks4agb from pokeruby (#12)
* Port agb_flash from pokeruby * use ramscrgen * formatting * delete ewram_syms.txt and iwram_syms.txt * Finish port of agb_flash * Ported libmks4agb from pokeruby * Reordered declarations to match pokeruby
This commit is contained in:
Diegoisawesome
committed by
YamaArashi
YamaArashi
parent
2db94cf5eb
commit
69c734c9a8
+912
@@ -0,0 +1,912 @@
|
||||
#include "gba/m4a_internal.h"
|
||||
|
||||
#define BSS_CODE __attribute__((section(".bss.code")))
|
||||
|
||||
BSS_CODE ALIGNED(4) char SoundMainRAM_Buffer[0x800] = {0};
|
||||
|
||||
struct SoundInfo gSoundInfo;
|
||||
struct PokemonCrySong gPokemonCrySongs[MAX_POKEMON_CRIES];
|
||||
struct MusicPlayerInfo gPokemonCryMusicPlayers[MAX_POKEMON_CRIES];
|
||||
void *gMPlayJumpTable[36];
|
||||
struct CgbChannel gCgbChans[4];
|
||||
struct MusicPlayerTrack gPokemonCryTracks[MAX_POKEMON_CRIES * 2];
|
||||
struct PokemonCrySong gPokemonCrySong;
|
||||
struct MusicPlayerInfo gMPlay_BGM;
|
||||
struct MusicPlayerInfo gMPlay_SE1;
|
||||
struct MusicPlayerInfo gMPlay_SE2;
|
||||
struct MusicPlayerInfo gMPlay_SE3;
|
||||
u8 gMPlayMemAccArea[0x10];
|
||||
|
||||
u32 MidiKeyToFreq(struct WaveData *wav, u8 key, u8 fineAdjust)
|
||||
{
|
||||
u32 val1;
|
||||
u32 val2;
|
||||
u32 fineAdjustShifted = fineAdjust << 24;
|
||||
|
||||
if (key > 178)
|
||||
{
|
||||
key = 178;
|
||||
fineAdjustShifted = 255 << 24;
|
||||
}
|
||||
|
||||
val1 = gScaleTable[key];
|
||||
val1 = gFreqTable[val1 & 0xF] >> (val1 >> 4);
|
||||
|
||||
val2 = gScaleTable[key + 1];
|
||||
val2 = gFreqTable[val2 & 0xF] >> (val2 >> 4);
|
||||
|
||||
return umul3232H32(wav->freq, val1 + umul3232H32(val2 - val1, fineAdjustShifted));
|
||||
}
|
||||
|
||||
void UnusedDummyFunc()
|
||||
{
|
||||
}
|
||||
|
||||
void MPlayContinue(struct MusicPlayerInfo *mplayInfo)
|
||||
{
|
||||
if (mplayInfo->ident == ID_NUMBER)
|
||||
{
|
||||
mplayInfo->ident++;
|
||||
mplayInfo->status &= ~MUSICPLAYER_STATUS_PAUSE;
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
}
|
||||
|
||||
void MPlayFadeOut(struct MusicPlayerInfo *mplayInfo, u16 speed)
|
||||
{
|
||||
if (mplayInfo->ident == ID_NUMBER)
|
||||
{
|
||||
mplayInfo->ident++;
|
||||
mplayInfo->fadeOC = speed;
|
||||
mplayInfo->fadeOI = speed;
|
||||
mplayInfo->fadeOV = (64 << FADE_VOL_SHIFT);
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
}
|
||||
|
||||
void m4aSoundInit(void)
|
||||
{
|
||||
s32 i;
|
||||
|
||||
CpuCopy32((void *)((s32)SoundMainRAM & ~1), SoundMainRAM_Buffer, sizeof(SoundMainRAM_Buffer));
|
||||
|
||||
SoundInit(&gSoundInfo);
|
||||
MPlayExtender(gCgbChans);
|
||||
m4aSoundMode(SOUND_MODE_DA_BIT_8
|
||||
| SOUND_MODE_FREQ_13379
|
||||
| (12 << SOUND_MODE_MASVOL_SHIFT)
|
||||
| (5 << SOUND_MODE_MAXCHN_SHIFT));
|
||||
|
||||
for (i = 0; i < NUM_MUSIC_PLAYERS; i++)
|
||||
{
|
||||
struct MusicPlayerInfo *mplayInfo = gMPlayTable[i].info;
|
||||
MPlayOpen(mplayInfo, gMPlayTable[i].track, gMPlayTable[i].unk_8);
|
||||
mplayInfo->unk_B = gMPlayTable[i].unk_A;
|
||||
mplayInfo->memAccArea = gMPlayMemAccArea;
|
||||
}
|
||||
|
||||
memcpy(&gPokemonCrySong, &gPokemonCrySongTemplate, sizeof(struct PokemonCrySong));
|
||||
|
||||
for (i = 0; i < MAX_POKEMON_CRIES; i++)
|
||||
{
|
||||
struct MusicPlayerInfo *mplayInfo = &gPokemonCryMusicPlayers[i];
|
||||
struct MusicPlayerTrack *track = &gPokemonCryTracks[i * 2];
|
||||
MPlayOpen(mplayInfo, track, 2);
|
||||
track->chan = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void m4aSoundMain(void)
|
||||
{
|
||||
SoundMain();
|
||||
}
|
||||
|
||||
void m4aSongNumStart(u16 n)
|
||||
{
|
||||
const struct MusicPlayer *mplayTable = gMPlayTable;
|
||||
const struct Song *songTable = gSongTable;
|
||||
const struct Song *song = &songTable[n];
|
||||
const struct MusicPlayer *mplay = &mplayTable[song->ms];
|
||||
|
||||
MPlayStart(mplay->info, song->header);
|
||||
}
|
||||
|
||||
void m4aSongNumStartOrChange(u16 n)
|
||||
{
|
||||
const struct MusicPlayer *mplayTable = gMPlayTable;
|
||||
const struct Song *songTable = gSongTable;
|
||||
const struct Song *song = &songTable[n];
|
||||
const struct MusicPlayer *mplay = &mplayTable[song->ms];
|
||||
|
||||
if (mplay->info->songHeader != song->header)
|
||||
{
|
||||
MPlayStart(mplay->info, song->header);
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((mplay->info->status & MUSICPLAYER_STATUS_TRACK) == 0
|
||||
|| (mplay->info->status & MUSICPLAYER_STATUS_PAUSE))
|
||||
{
|
||||
MPlayStart(mplay->info, song->header);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void m4aSongNumStartOrContinue(u16 n)
|
||||
{
|
||||
const struct MusicPlayer *mplayTable = gMPlayTable;
|
||||
const struct Song *songTable = gSongTable;
|
||||
const struct Song *song = &songTable[n];
|
||||
const struct MusicPlayer *mplay = &mplayTable[song->ms];
|
||||
|
||||
if (mplay->info->songHeader != song->header)
|
||||
MPlayStart(mplay->info, song->header);
|
||||
else if ((mplay->info->status & MUSICPLAYER_STATUS_TRACK) == 0)
|
||||
MPlayStart(mplay->info, song->header);
|
||||
else if (mplay->info->status & MUSICPLAYER_STATUS_PAUSE)
|
||||
MPlayContinue(mplay->info);
|
||||
}
|
||||
|
||||
void m4aSongNumStop(u16 n)
|
||||
{
|
||||
const struct MusicPlayer *mplayTable = gMPlayTable;
|
||||
const struct Song *songTable = gSongTable;
|
||||
const struct Song *song = &songTable[n];
|
||||
const struct MusicPlayer *mplay = &mplayTable[song->ms];
|
||||
|
||||
if (mplay->info->songHeader == song->header)
|
||||
m4aMPlayStop(mplay->info);
|
||||
}
|
||||
|
||||
void m4aSongNumContinue(u16 n)
|
||||
{
|
||||
const struct MusicPlayer *mplayTable = gMPlayTable;
|
||||
const struct Song *songTable = gSongTable;
|
||||
const struct Song *song = &songTable[n];
|
||||
const struct MusicPlayer *mplay = &mplayTable[song->ms];
|
||||
|
||||
if (mplay->info->songHeader == song->header)
|
||||
MPlayContinue(mplay->info);
|
||||
}
|
||||
|
||||
void m4aMPlayAllStop(void)
|
||||
{
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < NUM_MUSIC_PLAYERS; i++)
|
||||
m4aMPlayStop(gMPlayTable[i].info);
|
||||
|
||||
for (i = 0; i < MAX_POKEMON_CRIES; i++)
|
||||
m4aMPlayStop(&gPokemonCryMusicPlayers[i]);
|
||||
}
|
||||
|
||||
void m4aMPlayContinue(struct MusicPlayerInfo *mplayInfo)
|
||||
{
|
||||
MPlayContinue(mplayInfo);
|
||||
}
|
||||
|
||||
void m4aMPlayAllContinue(void)
|
||||
{
|
||||
s32 i;
|
||||
|
||||
for (i = 0; i < NUM_MUSIC_PLAYERS; i++)
|
||||
MPlayContinue(gMPlayTable[i].info);
|
||||
|
||||
for (i = 0; i < MAX_POKEMON_CRIES; i++)
|
||||
MPlayContinue(&gPokemonCryMusicPlayers[i]);
|
||||
}
|
||||
|
||||
void m4aMPlayFadeOut(struct MusicPlayerInfo *mplayInfo, u16 speed)
|
||||
{
|
||||
MPlayFadeOut(mplayInfo, speed);
|
||||
}
|
||||
|
||||
void m4aMPlayFadeOutTemporarily(struct MusicPlayerInfo *mplayInfo, u16 speed)
|
||||
{
|
||||
if (mplayInfo->ident == ID_NUMBER)
|
||||
{
|
||||
mplayInfo->ident++;
|
||||
mplayInfo->fadeOC = speed;
|
||||
mplayInfo->fadeOI = speed;
|
||||
mplayInfo->fadeOV = (64 << FADE_VOL_SHIFT) | TEMPORARY_FADE;
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
}
|
||||
|
||||
void m4aMPlayFadeIn(struct MusicPlayerInfo *mplayInfo, u16 speed)
|
||||
{
|
||||
if (mplayInfo->ident == ID_NUMBER)
|
||||
{
|
||||
mplayInfo->ident++;
|
||||
mplayInfo->fadeOC = speed;
|
||||
mplayInfo->fadeOI = speed;
|
||||
mplayInfo->fadeOV = (0 << FADE_VOL_SHIFT) | FADE_IN;
|
||||
mplayInfo->status &= ~MUSICPLAYER_STATUS_PAUSE;
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
}
|
||||
|
||||
void m4aMPlayImmInit(struct MusicPlayerInfo *mplayInfo)
|
||||
{
|
||||
s32 trackCount = mplayInfo->trackCount;
|
||||
struct MusicPlayerTrack *track = mplayInfo->tracks;
|
||||
|
||||
while (trackCount > 0)
|
||||
{
|
||||
if (track->flags & MPT_FLG_EXIST)
|
||||
{
|
||||
if (track->flags & MPT_FLG_START)
|
||||
{
|
||||
Clear64byte(track);
|
||||
track->flags = MPT_FLG_EXIST;
|
||||
track->bendRange = 2;
|
||||
track->volX = 64;
|
||||
track->lfoSpeed = 22;
|
||||
track->tone.type = 1;
|
||||
}
|
||||
}
|
||||
|
||||
trackCount--;
|
||||
track++;
|
||||
}
|
||||
}
|
||||
|
||||
void MPlayExtender(struct CgbChannel *cgbChans)
|
||||
{
|
||||
struct SoundInfo *soundInfo;
|
||||
u32 ident;
|
||||
|
||||
REG_SOUNDCNT_X = SOUND_MASTER_ENABLE
|
||||
| SOUND_4_ON
|
||||
| SOUND_3_ON
|
||||
| SOUND_2_ON
|
||||
| SOUND_1_ON;
|
||||
REG_SOUNDCNT_L = 0; // set master volume to zero
|
||||
REG_NR12 = 0x8;
|
||||
REG_NR22 = 0x8;
|
||||
REG_NR42 = 0x8;
|
||||
REG_NR14 = 0x80;
|
||||
REG_NR24 = 0x80;
|
||||
REG_NR44 = 0x80;
|
||||
REG_NR30 = 0;
|
||||
REG_NR50 = 0x77;
|
||||
|
||||
soundInfo = SOUND_INFO_PTR;
|
||||
|
||||
ident = soundInfo->ident;
|
||||
|
||||
if (ident != ID_NUMBER)
|
||||
return;
|
||||
|
||||
soundInfo->ident++;
|
||||
|
||||
gMPlayJumpTable[8] = ply_memacc;
|
||||
gMPlayJumpTable[17] = ply_lfos;
|
||||
gMPlayJumpTable[19] = ply_mod;
|
||||
gMPlayJumpTable[28] = ply_xcmd;
|
||||
gMPlayJumpTable[29] = ply_endtie;
|
||||
gMPlayJumpTable[30] = SampleFreqSet;
|
||||
gMPlayJumpTable[31] = TrackStop;
|
||||
gMPlayJumpTable[32] = FadeOutBody;
|
||||
gMPlayJumpTable[33] = TrkVolPitSet;
|
||||
|
||||
soundInfo->cgbChans = (struct CgbChannel *)cgbChans;
|
||||
soundInfo->CgbSound = CgbSound;
|
||||
soundInfo->CgbOscOff = CgbOscOff;
|
||||
soundInfo->MidiKeyToCgbFreq = MidiKeyToCgbFreq;
|
||||
soundInfo->maxLines = MAX_LINES;
|
||||
|
||||
CpuFill32(0, cgbChans, sizeof(struct CgbChannel) * 4);
|
||||
|
||||
cgbChans[0].ty = 1;
|
||||
cgbChans[0].panMask = 0x11;
|
||||
cgbChans[1].ty = 2;
|
||||
cgbChans[1].panMask = 0x22;
|
||||
cgbChans[2].ty = 3;
|
||||
cgbChans[2].panMask = 0x44;
|
||||
cgbChans[3].ty = 4;
|
||||
cgbChans[3].panMask = 0x88;
|
||||
|
||||
soundInfo->ident = ident;
|
||||
}
|
||||
|
||||
void MusicPlayerJumpTableCopy(void)
|
||||
{
|
||||
asm("swi 0x2A");
|
||||
}
|
||||
|
||||
void ClearChain(void *x)
|
||||
{
|
||||
void (*func)(void *) = *(&gMPlayJumpTable[34]);
|
||||
func(x);
|
||||
}
|
||||
|
||||
void Clear64byte(void *x)
|
||||
{
|
||||
void (*func)(void *) = *(&gMPlayJumpTable[35]);
|
||||
func(x);
|
||||
}
|
||||
|
||||
void SoundInit(struct SoundInfo *soundInfo)
|
||||
{
|
||||
soundInfo->ident = 0;
|
||||
|
||||
if (REG_DMA1CNT & (DMA_REPEAT << 16))
|
||||
REG_DMA1CNT = ((DMA_ENABLE | DMA_START_NOW | DMA_32BIT | DMA_SRC_INC | DMA_DEST_FIXED) << 16) | 4;
|
||||
|
||||
if (REG_DMA2CNT & (DMA_REPEAT << 16))
|
||||
REG_DMA2CNT = ((DMA_ENABLE | DMA_START_NOW | DMA_32BIT | DMA_SRC_INC | DMA_DEST_FIXED) << 16) | 4;
|
||||
|
||||
REG_DMA1CNT_H = DMA_32BIT;
|
||||
REG_DMA2CNT_H = DMA_32BIT;
|
||||
REG_SOUNDCNT_X = SOUND_MASTER_ENABLE
|
||||
| SOUND_4_ON
|
||||
| SOUND_3_ON
|
||||
| SOUND_2_ON
|
||||
| SOUND_1_ON;
|
||||
REG_SOUNDCNT_H = SOUND_B_FIFO_RESET | SOUND_B_TIMER_0 | SOUND_B_LEFT_OUTPUT
|
||||
| SOUND_A_FIFO_RESET | SOUND_A_TIMER_0 | SOUND_A_RIGHT_OUTPUT
|
||||
| SOUND_ALL_MIX_FULL;
|
||||
REG_SOUNDBIAS_H = (REG_SOUNDBIAS_H & 0x3F) | 0x40;
|
||||
|
||||
REG_DMA1SAD = (s32)soundInfo->pcmBuffer;
|
||||
REG_DMA1DAD = (s32)®_FIFO_A;
|
||||
REG_DMA2SAD = (s32)soundInfo->pcmBuffer + PCM_DMA_BUF_SIZE;
|
||||
REG_DMA2DAD = (s32)®_FIFO_B;
|
||||
|
||||
SOUND_INFO_PTR = soundInfo;
|
||||
CpuFill32(0, soundInfo, sizeof(struct SoundInfo));
|
||||
|
||||
soundInfo->maxChans = 8;
|
||||
soundInfo->masterVolume = 15;
|
||||
soundInfo->plynote = (u32)ply_note;
|
||||
soundInfo->CgbSound = DummyFunc;
|
||||
soundInfo->CgbOscOff = (void (*)(u8))DummyFunc;
|
||||
soundInfo->MidiKeyToCgbFreq = (u32 (*)(u8, u8, u8))DummyFunc;
|
||||
soundInfo->ExtVolPit = (u32)DummyFunc;
|
||||
|
||||
MPlayJumpTableCopy(gMPlayJumpTable);
|
||||
|
||||
soundInfo->MPlayJumpTable = (u32)gMPlayJumpTable;
|
||||
|
||||
SampleFreqSet(SOUND_MODE_FREQ_13379);
|
||||
|
||||
soundInfo->ident = ID_NUMBER;
|
||||
}
|
||||
|
||||
void SampleFreqSet(u32 freq)
|
||||
{
|
||||
struct SoundInfo *soundInfo = SOUND_INFO_PTR;
|
||||
|
||||
freq = (freq & 0xF0000) >> 16;
|
||||
soundInfo->freq = freq;
|
||||
soundInfo->pcmSamplesPerVBlank = gPcmSamplesPerVBlankTable[freq - 1];
|
||||
soundInfo->pcmDmaPeriod = PCM_DMA_BUF_SIZE / soundInfo->pcmSamplesPerVBlank;
|
||||
|
||||
// LCD refresh rate 59.7275Hz
|
||||
soundInfo->pcmFreq = (597275 * soundInfo->pcmSamplesPerVBlank + 5000) / 10000;
|
||||
|
||||
// CPU frequency 16.78Mhz
|
||||
soundInfo->divFreq = (16777216 / soundInfo->pcmFreq + 1) >> 1;
|
||||
|
||||
// Turn off timer 0.
|
||||
REG_TM0CNT_H = 0;
|
||||
|
||||
// cycles per LCD fresh 280896
|
||||
REG_TM0CNT_L = -(280896 / soundInfo->pcmSamplesPerVBlank);
|
||||
|
||||
m4aSoundVSyncOn();
|
||||
|
||||
while (*(vu8 *)REG_ADDR_VCOUNT == 159)
|
||||
;
|
||||
|
||||
while (*(vu8 *)REG_ADDR_VCOUNT != 159)
|
||||
;
|
||||
|
||||
REG_TM0CNT_H = TIMER_ENABLE | TIMER_1CLK;
|
||||
}
|
||||
|
||||
void m4aSoundMode(u32 mode)
|
||||
{
|
||||
struct SoundInfo *soundInfo = SOUND_INFO_PTR;
|
||||
u32 temp;
|
||||
|
||||
if (soundInfo->ident != ID_NUMBER)
|
||||
return;
|
||||
|
||||
soundInfo->ident++;
|
||||
|
||||
temp = mode & (SOUND_MODE_REVERB_SET | SOUND_MODE_REVERB_VAL);
|
||||
|
||||
if (temp)
|
||||
soundInfo->reverb = temp & SOUND_MODE_REVERB_VAL;
|
||||
|
||||
temp = mode & SOUND_MODE_MAXCHN;
|
||||
|
||||
if (temp)
|
||||
{
|
||||
struct SoundChannel *chan;
|
||||
|
||||
soundInfo->maxChans = temp >> SOUND_MODE_MAXCHN_SHIFT;
|
||||
|
||||
temp = MAX_DIRECTSOUND_CHANNELS;
|
||||
chan = &soundInfo->chans[0];
|
||||
|
||||
while (temp != 0)
|
||||
{
|
||||
chan->status = 0;
|
||||
temp--;
|
||||
chan++;
|
||||
}
|
||||
}
|
||||
|
||||
temp = mode & SOUND_MODE_MASVOL;
|
||||
|
||||
if (temp)
|
||||
soundInfo->masterVolume = temp >> SOUND_MODE_MASVOL_SHIFT;
|
||||
|
||||
temp = mode & SOUND_MODE_DA_BIT;
|
||||
|
||||
if (temp)
|
||||
{
|
||||
temp = (temp & 0x300000) >> 14;
|
||||
REG_SOUNDBIAS_H = (REG_SOUNDBIAS_H & 0x3F) | temp;
|
||||
}
|
||||
|
||||
temp = mode & SOUND_MODE_FREQ;
|
||||
|
||||
if (temp)
|
||||
{
|
||||
m4aSoundVSyncOff();
|
||||
SampleFreqSet(temp);
|
||||
}
|
||||
|
||||
soundInfo->ident = ID_NUMBER;
|
||||
}
|
||||
|
||||
void SoundClear(void)
|
||||
{
|
||||
struct SoundInfo *soundInfo = SOUND_INFO_PTR;
|
||||
s32 i;
|
||||
void *chan;
|
||||
|
||||
if (soundInfo->ident != ID_NUMBER)
|
||||
return;
|
||||
|
||||
soundInfo->ident++;
|
||||
|
||||
i = MAX_DIRECTSOUND_CHANNELS;
|
||||
chan = &soundInfo->chans[0];
|
||||
|
||||
while (i > 0)
|
||||
{
|
||||
((struct SoundChannel *)chan)->status = 0;
|
||||
i--;
|
||||
chan = (void *)((s32)chan + sizeof(struct SoundChannel));
|
||||
}
|
||||
|
||||
chan = soundInfo->cgbChans;
|
||||
|
||||
if (chan)
|
||||
{
|
||||
i = 1;
|
||||
|
||||
while (i <= 4)
|
||||
{
|
||||
soundInfo->CgbOscOff(i);
|
||||
((struct CgbChannel *)chan)->sf = 0;
|
||||
i++;
|
||||
chan = (void *)((s32)chan + sizeof(struct CgbChannel));
|
||||
}
|
||||
}
|
||||
|
||||
soundInfo->ident = ID_NUMBER;
|
||||
}
|
||||
|
||||
void m4aSoundVSyncOff(void)
|
||||
{
|
||||
struct SoundInfo *soundInfo = SOUND_INFO_PTR;
|
||||
|
||||
if (soundInfo->ident >= ID_NUMBER && soundInfo->ident <= ID_NUMBER + 1)
|
||||
{
|
||||
soundInfo->ident += 10;
|
||||
|
||||
if (REG_DMA1CNT & (DMA_REPEAT << 16))
|
||||
REG_DMA1CNT = ((DMA_ENABLE | DMA_START_NOW | DMA_32BIT | DMA_SRC_INC | DMA_DEST_FIXED) << 16) | 4;
|
||||
|
||||
if (REG_DMA2CNT & (DMA_REPEAT << 16))
|
||||
REG_DMA2CNT = ((DMA_ENABLE | DMA_START_NOW | DMA_32BIT | DMA_SRC_INC | DMA_DEST_FIXED) << 16) | 4;
|
||||
|
||||
REG_DMA1CNT_H = DMA_32BIT;
|
||||
REG_DMA2CNT_H = DMA_32BIT;
|
||||
|
||||
CpuFill32(0, soundInfo->pcmBuffer, sizeof(soundInfo->pcmBuffer));
|
||||
}
|
||||
}
|
||||
|
||||
void m4aSoundVSyncOn(void)
|
||||
{
|
||||
struct SoundInfo *soundInfo = SOUND_INFO_PTR;
|
||||
u32 ident = soundInfo->ident;
|
||||
|
||||
if (ident == ID_NUMBER)
|
||||
return;
|
||||
|
||||
REG_DMA1CNT_H = DMA_ENABLE | DMA_START_SPECIAL | DMA_32BIT | DMA_REPEAT;
|
||||
REG_DMA2CNT_H = DMA_ENABLE | DMA_START_SPECIAL | DMA_32BIT | DMA_REPEAT;
|
||||
|
||||
soundInfo->pcmDmaCounter = 0;
|
||||
soundInfo->ident = ident - 10;
|
||||
}
|
||||
|
||||
void MPlayOpen(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *tracks, u8 trackCount)
|
||||
{
|
||||
struct SoundInfo *soundInfo;
|
||||
|
||||
if (trackCount == 0)
|
||||
return;
|
||||
|
||||
if (trackCount > MAX_MUSICPLAYER_TRACKS)
|
||||
trackCount = MAX_MUSICPLAYER_TRACKS;
|
||||
|
||||
soundInfo = SOUND_INFO_PTR;
|
||||
|
||||
if (soundInfo->ident != ID_NUMBER)
|
||||
return;
|
||||
|
||||
soundInfo->ident++;
|
||||
|
||||
Clear64byte(mplayInfo);
|
||||
|
||||
mplayInfo->tracks = tracks;
|
||||
mplayInfo->trackCount = trackCount;
|
||||
mplayInfo->status = MUSICPLAYER_STATUS_PAUSE;
|
||||
|
||||
while (trackCount != 0)
|
||||
{
|
||||
tracks->flags = 0;
|
||||
trackCount--;
|
||||
tracks++;
|
||||
}
|
||||
|
||||
if (soundInfo->func != 0)
|
||||
{
|
||||
mplayInfo->func = soundInfo->func;
|
||||
mplayInfo->intp = soundInfo->intp;
|
||||
soundInfo->func = 0;
|
||||
}
|
||||
|
||||
soundInfo->intp = (u32)mplayInfo;
|
||||
soundInfo->func = (u32)MPlayMain;
|
||||
soundInfo->ident = ID_NUMBER;
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
|
||||
void MPlayStart(struct MusicPlayerInfo *mplayInfo, struct SongHeader *songHeader)
|
||||
{
|
||||
s32 i;
|
||||
u8 unk_B;
|
||||
struct MusicPlayerTrack *track;
|
||||
|
||||
if (mplayInfo->ident != ID_NUMBER)
|
||||
return;
|
||||
|
||||
unk_B = mplayInfo->unk_B;
|
||||
|
||||
if (!unk_B
|
||||
|| ((!mplayInfo->songHeader || !(mplayInfo->tracks[0].flags & MPT_FLG_START))
|
||||
&& ((mplayInfo->status & MUSICPLAYER_STATUS_TRACK) == 0
|
||||
|| (mplayInfo->status & MUSICPLAYER_STATUS_PAUSE)))
|
||||
|| (mplayInfo->priority <= songHeader->priority))
|
||||
{
|
||||
mplayInfo->ident++;
|
||||
mplayInfo->status = 0;
|
||||
mplayInfo->songHeader = songHeader;
|
||||
mplayInfo->tone = songHeader->tone;
|
||||
mplayInfo->priority = songHeader->priority;
|
||||
mplayInfo->clock = 0;
|
||||
mplayInfo->tempoD = 150;
|
||||
mplayInfo->tempoI = 150;
|
||||
mplayInfo->tempoU = 0x100;
|
||||
mplayInfo->tempoC = 0;
|
||||
mplayInfo->fadeOI = 0;
|
||||
|
||||
i = 0;
|
||||
track = mplayInfo->tracks;
|
||||
|
||||
while (i < songHeader->trackCount && i < mplayInfo->trackCount)
|
||||
{
|
||||
TrackStop(mplayInfo, track);
|
||||
track->flags = MPT_FLG_EXIST | MPT_FLG_START;
|
||||
track->chan = 0;
|
||||
track->cmdPtr = songHeader->part[i];
|
||||
i++;
|
||||
track++;
|
||||
}
|
||||
|
||||
while (i < mplayInfo->trackCount)
|
||||
{
|
||||
TrackStop(mplayInfo, track);
|
||||
track->flags = 0;
|
||||
i++;
|
||||
track++;
|
||||
}
|
||||
|
||||
if (songHeader->reverb & 0x80)
|
||||
m4aSoundMode(songHeader->reverb);
|
||||
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
}
|
||||
|
||||
void m4aMPlayStop(struct MusicPlayerInfo *mplayInfo)
|
||||
{
|
||||
s32 i;
|
||||
struct MusicPlayerTrack *track;
|
||||
|
||||
if (mplayInfo->ident != ID_NUMBER)
|
||||
return;
|
||||
|
||||
mplayInfo->ident++;
|
||||
mplayInfo->status |= MUSICPLAYER_STATUS_PAUSE;
|
||||
|
||||
i = mplayInfo->trackCount;
|
||||
track = mplayInfo->tracks;
|
||||
|
||||
while (i > 0)
|
||||
{
|
||||
TrackStop(mplayInfo, track);
|
||||
i--;
|
||||
track++;
|
||||
}
|
||||
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
|
||||
void FadeOutBody(struct MusicPlayerInfo *mplayInfo)
|
||||
{
|
||||
s32 i;
|
||||
struct MusicPlayerTrack *track;
|
||||
u16 fadeOI = mplayInfo->fadeOI;
|
||||
register u32 temp asm("r3");
|
||||
register u16 mask asm("r2");
|
||||
|
||||
if (fadeOI == 0)
|
||||
return;
|
||||
|
||||
mplayInfo->fadeOC--;
|
||||
|
||||
temp = 0xFFFF;
|
||||
mask = temp;
|
||||
|
||||
if (mplayInfo->fadeOC != 0)
|
||||
return;
|
||||
|
||||
mplayInfo->fadeOC = fadeOI;
|
||||
|
||||
if (mplayInfo->fadeOV & FADE_IN)
|
||||
{
|
||||
mplayInfo->fadeOV += (4 << FADE_VOL_SHIFT);
|
||||
|
||||
if ((u16)(mplayInfo->fadeOV & mask) >= (64 << FADE_VOL_SHIFT))
|
||||
{
|
||||
mplayInfo->fadeOV = (64 << FADE_VOL_SHIFT);
|
||||
mplayInfo->fadeOI = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mplayInfo->fadeOV -= (4 << FADE_VOL_SHIFT);
|
||||
|
||||
if ((s16)(mplayInfo->fadeOV & mask) <= 0)
|
||||
{
|
||||
i = mplayInfo->trackCount;
|
||||
track = mplayInfo->tracks;
|
||||
|
||||
while (i > 0)
|
||||
{
|
||||
register u32 fadeOV asm("r7");
|
||||
u32 val;
|
||||
|
||||
TrackStop(mplayInfo, track);
|
||||
|
||||
val = TEMPORARY_FADE;
|
||||
fadeOV = mplayInfo->fadeOV;
|
||||
val &= fadeOV;
|
||||
|
||||
if (!val)
|
||||
track->flags = 0;
|
||||
|
||||
i--;
|
||||
track++;
|
||||
}
|
||||
|
||||
if (mplayInfo->fadeOV & TEMPORARY_FADE)
|
||||
mplayInfo->status |= MUSICPLAYER_STATUS_PAUSE;
|
||||
else
|
||||
mplayInfo->status = MUSICPLAYER_STATUS_PAUSE;
|
||||
|
||||
mplayInfo->fadeOI = 0;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
i = mplayInfo->trackCount;
|
||||
track = mplayInfo->tracks;
|
||||
|
||||
while (i > 0)
|
||||
{
|
||||
if (track->flags & MPT_FLG_EXIST)
|
||||
{
|
||||
track->volX = (mplayInfo->fadeOV >> FADE_VOL_SHIFT);
|
||||
track->flags |= MPT_FLG_VOLCHG;
|
||||
}
|
||||
|
||||
i--;
|
||||
track++;
|
||||
}
|
||||
}
|
||||
|
||||
void TrkVolPitSet(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
if (track->flags & MPT_FLG_VOLSET)
|
||||
{
|
||||
s32 x;
|
||||
s32 y;
|
||||
|
||||
x = (u32)(track->vol * track->volX) >> 5;
|
||||
|
||||
if (track->modT == 1)
|
||||
x = (u32)(x * (track->modM + 128)) >> 7;
|
||||
|
||||
y = 2 * track->pan + track->panX;
|
||||
|
||||
if (track->modT == 2)
|
||||
y += track->modM;
|
||||
|
||||
if (y < -128)
|
||||
y = -128;
|
||||
else if (y > 127)
|
||||
y = 127;
|
||||
|
||||
track->volMR = (u32)((y + 128) * x) >> 8;
|
||||
track->volML = (u32)((127 - y) * x) >> 8;
|
||||
}
|
||||
|
||||
if (track->flags & MPT_FLG_PITSET)
|
||||
{
|
||||
s32 bend = track->bend * track->bendRange;
|
||||
register s32 x asm("r1") = track->tune;
|
||||
x += bend;
|
||||
x *= 4;
|
||||
x += (track->keyShift << 8);
|
||||
x += (track->keyShiftX << 8);
|
||||
x += track->pitX;
|
||||
|
||||
if (track->modT == 0)
|
||||
x += 16 * track->modM;
|
||||
|
||||
track->keyM = x >> 8;
|
||||
track->pitM = x;
|
||||
}
|
||||
|
||||
track->flags &= ~(MPT_FLG_PITSET | MPT_FLG_VOLSET);
|
||||
}
|
||||
|
||||
u32 MidiKeyToCgbFreq(u8 chanNum, u8 key, u8 fineAdjust)
|
||||
{
|
||||
if (chanNum == 4)
|
||||
{
|
||||
if (key <= 20)
|
||||
{
|
||||
key = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
key -= 21;
|
||||
if (key > 59)
|
||||
key = 59;
|
||||
}
|
||||
|
||||
return gNoiseTable[key];
|
||||
}
|
||||
else
|
||||
{
|
||||
s32 val1;
|
||||
s32 val2;
|
||||
|
||||
if (key <= 35)
|
||||
{
|
||||
fineAdjust = 0;
|
||||
key = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
key -= 36;
|
||||
if (key > 130)
|
||||
{
|
||||
key = 130;
|
||||
fineAdjust = 255;
|
||||
}
|
||||
}
|
||||
|
||||
val1 = gCgbScaleTable[key];
|
||||
val1 = gCgbFreqTable[val1 & 0xF] >> (val1 >> 4);
|
||||
|
||||
val2 = gCgbScaleTable[key + 1];
|
||||
val2 = gCgbFreqTable[val2 & 0xF] >> (val2 >> 4);
|
||||
|
||||
return val1 + ((fineAdjust * (val2 - val1)) >> 8) + 2048;
|
||||
}
|
||||
}
|
||||
|
||||
void CgbOscOff(u8 chanNum)
|
||||
{
|
||||
switch (chanNum)
|
||||
{
|
||||
case 1:
|
||||
REG_NR12 = 8;
|
||||
REG_NR14 = 0x80;
|
||||
break;
|
||||
case 2:
|
||||
REG_NR22 = 8;
|
||||
REG_NR24 = 0x80;
|
||||
break;
|
||||
case 3:
|
||||
REG_NR30 = 0;
|
||||
break;
|
||||
default:
|
||||
REG_NR42 = 8;
|
||||
REG_NR44 = 0x80;
|
||||
}
|
||||
}
|
||||
|
||||
static inline int CgbPan(struct CgbChannel *chan)
|
||||
{
|
||||
u32 rightVolume = chan->rightVolume;
|
||||
u32 leftVolume = chan->leftVolume;
|
||||
|
||||
if ((rightVolume = (u8)rightVolume) >= (leftVolume = (u8)leftVolume))
|
||||
{
|
||||
if (rightVolume / 2 >= leftVolume)
|
||||
{
|
||||
chan->pan = 0x0F;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (leftVolume / 2 >= rightVolume)
|
||||
{
|
||||
chan->pan = 0xF0;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void CgbModVol(struct CgbChannel *chan)
|
||||
{
|
||||
struct SoundInfo *soundInfo = SOUND_INFO_PTR;
|
||||
|
||||
if ((soundInfo->mode & 1) || !CgbPan(chan))
|
||||
{
|
||||
chan->pan = 0xFF;
|
||||
chan->eg = (u32)(chan->rightVolume + chan->leftVolume) >> 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Force chan->rightVolume and chan->leftVolume to be read from memory again,
|
||||
// even though there is no reason to do so.
|
||||
// The command line option "-fno-gcse" achieves the same result as this.
|
||||
asm("" : : : "memory");
|
||||
|
||||
chan->eg = (u32)(chan->rightVolume + chan->leftVolume) >> 4;
|
||||
if (chan->eg > 15)
|
||||
chan->eg = 15;
|
||||
}
|
||||
|
||||
chan->sg = (chan->eg * chan->su + 15) >> 4;
|
||||
chan->pan &= chan->panMask;
|
||||
}
|
||||
+545
@@ -0,0 +1,545 @@
|
||||
#include "gba/m4a_internal.h"
|
||||
|
||||
void m4aMPlayTempoControl(struct MusicPlayerInfo *mplayInfo, u16 tempo)
|
||||
{
|
||||
if (mplayInfo->ident == ID_NUMBER)
|
||||
{
|
||||
mplayInfo->ident++;
|
||||
mplayInfo->tempoU = tempo;
|
||||
mplayInfo->tempoI = (mplayInfo->tempoD * mplayInfo->tempoU) >> 8;
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
}
|
||||
|
||||
void m4aMPlayVolumeControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, u16 volume)
|
||||
{
|
||||
s32 i;
|
||||
u32 bit;
|
||||
struct MusicPlayerTrack *track;
|
||||
|
||||
if (mplayInfo->ident != ID_NUMBER)
|
||||
return;
|
||||
|
||||
mplayInfo->ident++;
|
||||
|
||||
i = mplayInfo->trackCount;
|
||||
track = mplayInfo->tracks;
|
||||
bit = 1;
|
||||
|
||||
while (i > 0)
|
||||
{
|
||||
if (trackBits & bit)
|
||||
{
|
||||
if (track->flags & MPT_FLG_EXIST)
|
||||
{
|
||||
track->volX = volume / 4;
|
||||
track->flags |= MPT_FLG_VOLCHG;
|
||||
}
|
||||
}
|
||||
|
||||
i--;
|
||||
track++;
|
||||
bit <<= 1;
|
||||
}
|
||||
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
|
||||
void m4aMPlayPitchControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, u16 pitch)
|
||||
{
|
||||
s32 i;
|
||||
u32 bit;
|
||||
struct MusicPlayerTrack *track;
|
||||
|
||||
if (mplayInfo->ident != ID_NUMBER)
|
||||
return;
|
||||
|
||||
mplayInfo->ident++;
|
||||
|
||||
i = mplayInfo->trackCount;
|
||||
track = mplayInfo->tracks;
|
||||
bit = 1;
|
||||
|
||||
while (i > 0)
|
||||
{
|
||||
if (trackBits & bit)
|
||||
{
|
||||
if (track->flags & MPT_FLG_EXIST)
|
||||
{
|
||||
track->keyShiftX = (s16)pitch >> 8;
|
||||
track->pitX = pitch;
|
||||
track->flags |= MPT_FLG_PITCHG;
|
||||
}
|
||||
}
|
||||
|
||||
i--;
|
||||
track++;
|
||||
bit <<= 1;
|
||||
}
|
||||
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
|
||||
void m4aMPlayPanpotControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, s8 pan)
|
||||
{
|
||||
s32 i;
|
||||
u32 bit;
|
||||
struct MusicPlayerTrack *track;
|
||||
|
||||
if (mplayInfo->ident != ID_NUMBER)
|
||||
return;
|
||||
|
||||
mplayInfo->ident++;
|
||||
|
||||
i = mplayInfo->trackCount;
|
||||
track = mplayInfo->tracks;
|
||||
bit = 1;
|
||||
|
||||
while (i > 0)
|
||||
{
|
||||
if (trackBits & bit)
|
||||
{
|
||||
if (track->flags & MPT_FLG_EXIST)
|
||||
{
|
||||
track->panX = pan;
|
||||
track->flags |= MPT_FLG_VOLCHG;
|
||||
}
|
||||
}
|
||||
|
||||
i--;
|
||||
track++;
|
||||
bit <<= 1;
|
||||
}
|
||||
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
|
||||
void ClearModM(struct MusicPlayerTrack *track)
|
||||
{
|
||||
track->lfoSpeedC = 0;
|
||||
track->modM = 0;
|
||||
|
||||
if (track->modT == 0)
|
||||
track->flags |= MPT_FLG_PITCHG;
|
||||
else
|
||||
track->flags |= MPT_FLG_VOLCHG;
|
||||
}
|
||||
|
||||
void m4aMPlayModDepthSet(struct MusicPlayerInfo *mplayInfo, u16 trackBits, u8 modDepth)
|
||||
{
|
||||
s32 i;
|
||||
u32 bit;
|
||||
struct MusicPlayerTrack *track;
|
||||
|
||||
if (mplayInfo->ident != ID_NUMBER)
|
||||
return;
|
||||
|
||||
mplayInfo->ident++;
|
||||
|
||||
i = mplayInfo->trackCount;
|
||||
track = mplayInfo->tracks;
|
||||
bit = 1;
|
||||
|
||||
while (i > 0)
|
||||
{
|
||||
if (trackBits & bit)
|
||||
{
|
||||
if (track->flags & MPT_FLG_EXIST)
|
||||
{
|
||||
track->mod = modDepth;
|
||||
|
||||
if (!track->mod)
|
||||
ClearModM(track);
|
||||
}
|
||||
}
|
||||
|
||||
i--;
|
||||
track++;
|
||||
bit <<= 1;
|
||||
}
|
||||
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
|
||||
void m4aMPlayLFOSpeedSet(struct MusicPlayerInfo *mplayInfo, u16 trackBits, u8 lfoSpeed)
|
||||
{
|
||||
s32 i;
|
||||
u32 bit;
|
||||
struct MusicPlayerTrack *track;
|
||||
|
||||
if (mplayInfo->ident != ID_NUMBER)
|
||||
return;
|
||||
|
||||
mplayInfo->ident++;
|
||||
|
||||
i = mplayInfo->trackCount;
|
||||
track = mplayInfo->tracks;
|
||||
bit = 1;
|
||||
|
||||
while (i > 0)
|
||||
{
|
||||
if (trackBits & bit)
|
||||
{
|
||||
if (track->flags & MPT_FLG_EXIST)
|
||||
{
|
||||
track->lfoSpeed = lfoSpeed;
|
||||
|
||||
if (!track->lfoSpeed)
|
||||
ClearModM(track);
|
||||
}
|
||||
}
|
||||
|
||||
i--;
|
||||
track++;
|
||||
bit <<= 1;
|
||||
}
|
||||
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
}
|
||||
|
||||
#define MEMACC_COND_JUMP(cond) \
|
||||
if (cond) \
|
||||
goto cond_true; \
|
||||
else \
|
||||
goto cond_false; \
|
||||
|
||||
void ply_memacc(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
u32 op;
|
||||
u8 *addr;
|
||||
u8 data;
|
||||
|
||||
op = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
|
||||
addr = mplayInfo->memAccArea + *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
|
||||
data = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
|
||||
switch (op)
|
||||
{
|
||||
case 0:
|
||||
*addr = data;
|
||||
return;
|
||||
case 1:
|
||||
*addr += data;
|
||||
return;
|
||||
case 2:
|
||||
*addr -= data;
|
||||
return;
|
||||
case 3:
|
||||
*addr = mplayInfo->memAccArea[data];
|
||||
return;
|
||||
case 4:
|
||||
*addr += mplayInfo->memAccArea[data];
|
||||
return;
|
||||
case 5:
|
||||
*addr -= mplayInfo->memAccArea[data];
|
||||
return;
|
||||
case 6:
|
||||
MEMACC_COND_JUMP(*addr == data)
|
||||
return;
|
||||
case 7:
|
||||
MEMACC_COND_JUMP(*addr != data)
|
||||
return;
|
||||
case 8:
|
||||
MEMACC_COND_JUMP(*addr > data)
|
||||
return;
|
||||
case 9:
|
||||
MEMACC_COND_JUMP(*addr >= data)
|
||||
return;
|
||||
case 10:
|
||||
MEMACC_COND_JUMP(*addr <= data)
|
||||
return;
|
||||
case 11:
|
||||
MEMACC_COND_JUMP(*addr < data)
|
||||
return;
|
||||
case 12:
|
||||
MEMACC_COND_JUMP(*addr == mplayInfo->memAccArea[data])
|
||||
return;
|
||||
case 13:
|
||||
MEMACC_COND_JUMP(*addr != mplayInfo->memAccArea[data])
|
||||
return;
|
||||
case 14:
|
||||
MEMACC_COND_JUMP(*addr > mplayInfo->memAccArea[data])
|
||||
return;
|
||||
case 15:
|
||||
MEMACC_COND_JUMP(*addr >= mplayInfo->memAccArea[data])
|
||||
return;
|
||||
case 16:
|
||||
MEMACC_COND_JUMP(*addr <= mplayInfo->memAccArea[data])
|
||||
return;
|
||||
case 17:
|
||||
MEMACC_COND_JUMP(*addr < mplayInfo->memAccArea[data])
|
||||
return;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
||||
cond_true:
|
||||
{
|
||||
void (*func)(struct MusicPlayerInfo *, struct MusicPlayerTrack *) = *(&gMPlayJumpTable[1]);
|
||||
func(mplayInfo, track);
|
||||
return;
|
||||
}
|
||||
|
||||
cond_false:
|
||||
track->cmdPtr += 4;
|
||||
}
|
||||
|
||||
void ply_xcmd(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
u32 n = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
|
||||
gXcmdTable[n](mplayInfo, track);
|
||||
}
|
||||
|
||||
void ply_xxx(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
void (*func)(struct MusicPlayerInfo *, struct MusicPlayerTrack *) = *(&gMPlayJumpTable[0]);
|
||||
func(mplayInfo, track);
|
||||
}
|
||||
|
||||
#define READ_XCMD_BYTE(var, n) \
|
||||
{ \
|
||||
u32 byte = track->cmdPtr[(n)]; \
|
||||
byte <<= n * 8; \
|
||||
(var) &= ~(0xFF << (n * 8)); \
|
||||
(var) |= byte; \
|
||||
}
|
||||
|
||||
void ply_xwave(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
u32 wav;
|
||||
|
||||
READ_XCMD_BYTE(wav, 0) // UB: uninitialized variable
|
||||
READ_XCMD_BYTE(wav, 1)
|
||||
READ_XCMD_BYTE(wav, 2)
|
||||
READ_XCMD_BYTE(wav, 3)
|
||||
|
||||
track->tone.wav = (struct WaveData *)wav;
|
||||
track->cmdPtr += 4;
|
||||
}
|
||||
|
||||
void ply_xtype(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
track->tone.type = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
}
|
||||
|
||||
void ply_xatta(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
track->tone.attack = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
}
|
||||
|
||||
void ply_xdeca(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
track->tone.decay = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
}
|
||||
|
||||
void ply_xsust(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
track->tone.sustain = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
}
|
||||
|
||||
void ply_xrele(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
track->tone.release = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
}
|
||||
|
||||
void ply_xiecv(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
track->echoVolume = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
}
|
||||
|
||||
void ply_xiecl(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
track->echoLength = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
}
|
||||
|
||||
void ply_xleng(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
track->tone.length = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
}
|
||||
|
||||
void ply_xswee(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
track->tone.pan_sweep = *track->cmdPtr;
|
||||
track->cmdPtr++;
|
||||
}
|
||||
|
||||
void ply_xcmd_0C(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
u32 unk;
|
||||
|
||||
READ_XCMD_BYTE(unk, 0) // UB: uninitialized variable
|
||||
READ_XCMD_BYTE(unk, 1)
|
||||
|
||||
if (track->unk_3A < (u16)unk)
|
||||
{
|
||||
track->unk_3A++;
|
||||
track->cmdPtr -= 2;
|
||||
track->wait = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
track->unk_3A = 0;
|
||||
track->cmdPtr += 2;
|
||||
}
|
||||
}
|
||||
|
||||
void ply_xcmd_0D(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track)
|
||||
{
|
||||
u32 unk;
|
||||
|
||||
READ_XCMD_BYTE(unk, 0) // UB: uninitialized variable
|
||||
READ_XCMD_BYTE(unk, 1)
|
||||
READ_XCMD_BYTE(unk, 2)
|
||||
READ_XCMD_BYTE(unk, 3)
|
||||
|
||||
track->unk_3C = unk;
|
||||
track->cmdPtr += 4;
|
||||
}
|
||||
|
||||
void DummyFunc(void)
|
||||
{
|
||||
}
|
||||
|
||||
struct MusicPlayerInfo *SetPokemonCryTone(struct ToneData *tone)
|
||||
{
|
||||
u32 maxClock = 0;
|
||||
s32 maxClockIndex = 0;
|
||||
s32 i;
|
||||
struct MusicPlayerInfo *mplayInfo;
|
||||
|
||||
for (i = 0; i < MAX_POKEMON_CRIES; i++)
|
||||
{
|
||||
struct MusicPlayerTrack *track = &gPokemonCryTracks[i * 2];
|
||||
|
||||
if (!track->flags && (!track->chan || track->chan->track != track))
|
||||
goto start_song;
|
||||
|
||||
if (maxClock < gPokemonCryMusicPlayers[i].clock)
|
||||
{
|
||||
maxClock = gPokemonCryMusicPlayers[i].clock;
|
||||
maxClockIndex = i;
|
||||
}
|
||||
}
|
||||
|
||||
i = maxClockIndex;
|
||||
|
||||
start_song:
|
||||
mplayInfo = &gPokemonCryMusicPlayers[i];
|
||||
mplayInfo->ident++;
|
||||
|
||||
#define CRY ((s32)&gPokemonCrySongs + i * sizeof(struct PokemonCrySong))
|
||||
#define CRY_OFS(field) offsetof(struct PokemonCrySong, field)
|
||||
|
||||
memcpy((void *)CRY, &gPokemonCrySong, sizeof(struct PokemonCrySong));
|
||||
|
||||
*(u32 *)(CRY + CRY_OFS(tone)) = (u32)tone;
|
||||
*(u32 *)(CRY + CRY_OFS(part)) = CRY + CRY_OFS(part0);
|
||||
*(u32 *)(CRY + CRY_OFS(part) + 4) = CRY + CRY_OFS(part1);
|
||||
*(u32 *)(CRY + CRY_OFS(gotoTarget)) = CRY + CRY_OFS(cont);
|
||||
|
||||
#undef CRY_OFS
|
||||
#undef CRY
|
||||
|
||||
mplayInfo->ident = ID_NUMBER;
|
||||
|
||||
MPlayStart(mplayInfo, (struct SongHeader *)(&gPokemonCrySongs[i]));
|
||||
|
||||
return mplayInfo;
|
||||
}
|
||||
|
||||
void SetPokemonCryVolume(u8 val)
|
||||
{
|
||||
gPokemonCrySong.volumeValue = val & 0x7F;
|
||||
}
|
||||
|
||||
void SetPokemonCryPanpot(s8 val)
|
||||
{
|
||||
gPokemonCrySong.panValue = (val + C_V) & 0x7F;
|
||||
}
|
||||
|
||||
void SetPokemonCryPitch(s16 val)
|
||||
{
|
||||
s16 b = val + 0x80;
|
||||
u8 a = gPokemonCrySong.tuneValue2 - gPokemonCrySong.tuneValue;
|
||||
gPokemonCrySong.tieKeyValue = (b >> 8) & 0x7F;
|
||||
gPokemonCrySong.tuneValue = (b >> 1) & 0x7F;
|
||||
gPokemonCrySong.tuneValue2 = (a + ((b >> 1) & 0x7F)) & 0x7F;
|
||||
}
|
||||
|
||||
void SetPokemonCryLength(u16 val)
|
||||
{
|
||||
gPokemonCrySong.unkCmd0CParam = val;
|
||||
}
|
||||
|
||||
void SetPokemonCryRelease(u8 val)
|
||||
{
|
||||
gPokemonCrySong.releaseValue = val;
|
||||
}
|
||||
|
||||
void SetPokemonCryProgress(u32 val)
|
||||
{
|
||||
gPokemonCrySong.unkCmd0DParam = val;
|
||||
}
|
||||
|
||||
int IsPokemonCryPlaying(struct MusicPlayerInfo *mplayInfo)
|
||||
{
|
||||
struct MusicPlayerTrack *track = mplayInfo->tracks;
|
||||
|
||||
if (track->chan && track->chan->track == track)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
void SetPokemonCryChorus(s8 val)
|
||||
{
|
||||
if (val)
|
||||
{
|
||||
gPokemonCrySong.trackCount = 2;
|
||||
gPokemonCrySong.tuneValue2 = (val + gPokemonCrySong.tuneValue) & 0x7F;
|
||||
}
|
||||
else
|
||||
{
|
||||
gPokemonCrySong.trackCount = 1;
|
||||
}
|
||||
}
|
||||
|
||||
void SetPokemonCryStereo(u32 val)
|
||||
{
|
||||
struct SoundInfo *soundInfo = SOUND_INFO_PTR;
|
||||
|
||||
if (val)
|
||||
{
|
||||
REG_SOUNDCNT_H = SOUND_B_TIMER_0 | SOUND_B_LEFT_OUTPUT
|
||||
| SOUND_A_TIMER_0 | SOUND_A_RIGHT_OUTPUT
|
||||
| SOUND_ALL_MIX_FULL;
|
||||
soundInfo->mode &= ~1;
|
||||
}
|
||||
else
|
||||
{
|
||||
REG_SOUNDCNT_H = SOUND_B_TIMER_0 | SOUND_B_LEFT_OUTPUT | SOUND_B_RIGHT_OUTPUT
|
||||
| SOUND_A_TIMER_0 | SOUND_A_LEFT_OUTPUT | SOUND_A_RIGHT_OUTPUT
|
||||
| SOUND_B_MIX_HALF | SOUND_A_MIX_HALF | SOUND_CGB_MIX_FULL;
|
||||
soundInfo->mode |= 1;
|
||||
}
|
||||
}
|
||||
|
||||
void SetPokemonCryPriority(u8 val)
|
||||
{
|
||||
gPokemonCrySong.priority = val;
|
||||
}
|
||||
@@ -0,0 +1,307 @@
|
||||
#include "gba/m4a_internal.h"
|
||||
|
||||
// Some of these functions have different signatures, so we need to make this
|
||||
// an array of void pointers or a struct. It's simpler to just make it an array
|
||||
// for now.
|
||||
void * const gMPlayJumpTableTemplate[] =
|
||||
{
|
||||
ply_fine,
|
||||
ply_goto,
|
||||
ply_patt,
|
||||
ply_pend,
|
||||
ply_rept,
|
||||
ply_fine,
|
||||
ply_fine,
|
||||
ply_fine,
|
||||
ply_fine,
|
||||
ply_prio,
|
||||
ply_tempo,
|
||||
ply_keysh,
|
||||
ply_voice,
|
||||
ply_vol,
|
||||
ply_pan,
|
||||
ply_bend,
|
||||
ply_bendr,
|
||||
ply_lfos,
|
||||
ply_lfodl,
|
||||
ply_mod,
|
||||
ply_modt,
|
||||
ply_fine,
|
||||
ply_fine,
|
||||
ply_tune,
|
||||
ply_fine,
|
||||
ply_fine,
|
||||
ply_fine,
|
||||
ply_port,
|
||||
ply_fine,
|
||||
ply_endtie,
|
||||
SampleFreqSet,
|
||||
TrackStop,
|
||||
FadeOutBody,
|
||||
TrkVolPitSet,
|
||||
RealClearChain,
|
||||
SoundMainBTM,
|
||||
};
|
||||
|
||||
// This is a table of deltas between sample values in compressed PCM data.
|
||||
const s8 gDeltaEncodingTable[] =
|
||||
{
|
||||
0,
|
||||
1,
|
||||
4,
|
||||
9,
|
||||
16,
|
||||
25,
|
||||
36,
|
||||
49,
|
||||
-64,
|
||||
-49,
|
||||
-36,
|
||||
-25,
|
||||
-16,
|
||||
-9,
|
||||
-4,
|
||||
-1,
|
||||
};
|
||||
|
||||
const u8 gScaleTable[] =
|
||||
{
|
||||
0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB,
|
||||
0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB,
|
||||
0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB,
|
||||
0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB,
|
||||
0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB,
|
||||
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B,
|
||||
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B,
|
||||
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B,
|
||||
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B,
|
||||
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B,
|
||||
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
|
||||
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
|
||||
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B,
|
||||
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B,
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
|
||||
};
|
||||
|
||||
const u32 gFreqTable[] =
|
||||
{
|
||||
2147483648u,
|
||||
2275179671u,
|
||||
2410468894u,
|
||||
2553802834u,
|
||||
2705659852u,
|
||||
2866546760u,
|
||||
3037000500u,
|
||||
3217589947u,
|
||||
3408917802u,
|
||||
3611622603u,
|
||||
3826380858u,
|
||||
4053909305u,
|
||||
};
|
||||
|
||||
const u16 gPcmSamplesPerVBlankTable[] =
|
||||
{
|
||||
96,
|
||||
132,
|
||||
176,
|
||||
224,
|
||||
264,
|
||||
304,
|
||||
352,
|
||||
448,
|
||||
528,
|
||||
608,
|
||||
672,
|
||||
704,
|
||||
};
|
||||
|
||||
const u8 gCgbScaleTable[] =
|
||||
{
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
|
||||
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B,
|
||||
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B,
|
||||
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
|
||||
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B,
|
||||
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B,
|
||||
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B,
|
||||
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B,
|
||||
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B,
|
||||
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B,
|
||||
0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB,
|
||||
};
|
||||
|
||||
const s16 gCgbFreqTable[] =
|
||||
{
|
||||
-2004,
|
||||
-1891,
|
||||
-1785,
|
||||
-1685,
|
||||
-1591,
|
||||
-1501,
|
||||
-1417,
|
||||
-1337,
|
||||
-1262,
|
||||
-1192,
|
||||
-1125,
|
||||
-1062,
|
||||
};
|
||||
|
||||
const u8 gNoiseTable[] =
|
||||
{
|
||||
0xD7, 0xD6, 0xD5, 0xD4,
|
||||
0xC7, 0xC6, 0xC5, 0xC4,
|
||||
0xB7, 0xB6, 0xB5, 0xB4,
|
||||
0xA7, 0xA6, 0xA5, 0xA4,
|
||||
0x97, 0x96, 0x95, 0x94,
|
||||
0x87, 0x86, 0x85, 0x84,
|
||||
0x77, 0x76, 0x75, 0x74,
|
||||
0x67, 0x66, 0x65, 0x64,
|
||||
0x57, 0x56, 0x55, 0x54,
|
||||
0x47, 0x46, 0x45, 0x44,
|
||||
0x37, 0x36, 0x35, 0x34,
|
||||
0x27, 0x26, 0x25, 0x24,
|
||||
0x17, 0x16, 0x15, 0x14,
|
||||
0x07, 0x06, 0x05, 0x04,
|
||||
0x03, 0x02, 0x01, 0x00,
|
||||
};
|
||||
|
||||
const u8 gCgb3Vol[] =
|
||||
{
|
||||
0x00, 0x00,
|
||||
0x60, 0x60, 0x60, 0x60,
|
||||
0x40, 0x40, 0x40, 0x40,
|
||||
0x80, 0x80, 0x80, 0x80,
|
||||
0x20, 0x20,
|
||||
};
|
||||
|
||||
const u8 gClockTable[] =
|
||||
{
|
||||
0x00,
|
||||
0x01,
|
||||
0x02,
|
||||
0x03,
|
||||
0x04,
|
||||
0x05,
|
||||
0x06,
|
||||
0x07,
|
||||
0x08,
|
||||
0x09,
|
||||
0x0A,
|
||||
0x0B,
|
||||
0x0C,
|
||||
0x0D,
|
||||
0x0E,
|
||||
0x0F,
|
||||
0x10,
|
||||
0x11,
|
||||
0x12,
|
||||
0x13,
|
||||
0x14,
|
||||
0x15,
|
||||
0x16,
|
||||
0x17,
|
||||
0x18,
|
||||
0x1C,
|
||||
0x1E,
|
||||
0x20,
|
||||
0x24,
|
||||
0x28,
|
||||
0x2A,
|
||||
0x2C,
|
||||
0x30,
|
||||
0x34,
|
||||
0x36,
|
||||
0x38,
|
||||
0x3C,
|
||||
0x40,
|
||||
0x42,
|
||||
0x44,
|
||||
0x48,
|
||||
0x4C,
|
||||
0x4E,
|
||||
0x50,
|
||||
0x54,
|
||||
0x58,
|
||||
0x5A,
|
||||
0x5C,
|
||||
0x60,
|
||||
};
|
||||
|
||||
#define FINE 0xb1
|
||||
#define GOTO 0xb2
|
||||
#define PATT 0xb3
|
||||
#define PEND 0xb4
|
||||
#define REPT 0xb5
|
||||
#define MEMACC 0xb9
|
||||
#define PRIO 0xba
|
||||
#define TEMPO 0xbb
|
||||
#define KEYSH 0xbc
|
||||
#define VOICE 0xbd
|
||||
#define VOL 0xbe
|
||||
#define PAN 0xbf
|
||||
#define BEND 0xc0
|
||||
#define BENDR 0xc1
|
||||
#define LFOS 0xc2
|
||||
#define LFODL 0xc3
|
||||
#define MOD 0xc4
|
||||
#define MODT 0xc5
|
||||
#define TUNE 0xc8
|
||||
|
||||
#define XCMD 0xcd
|
||||
#define xRELE 0x07
|
||||
#define xIECV 0x08
|
||||
#define xIECL 0x09
|
||||
|
||||
#define EOT 0xce
|
||||
#define TIE 0xcf
|
||||
|
||||
const struct PokemonCrySong gPokemonCrySongTemplate =
|
||||
{
|
||||
1, // track count
|
||||
0, // block count
|
||||
255, // priority
|
||||
0, // reverb
|
||||
(struct ToneData *)&voicegroup_8675D04,
|
||||
NULL,
|
||||
NULL,
|
||||
0,
|
||||
TUNE, // part 0
|
||||
C_V, // TUNE value
|
||||
GOTO,
|
||||
0, // GOTO target address
|
||||
TUNE, // part 1
|
||||
C_V + 16, // TUNE value
|
||||
{VOICE, 0}, // part 0 jumps here with GOTO
|
||||
VOL,
|
||||
127, // volume
|
||||
{XCMD, 0x0D},
|
||||
0, // unk value
|
||||
{XCMD, xRELE},
|
||||
0, // release
|
||||
PAN,
|
||||
C_V, // PAN value
|
||||
TIE,
|
||||
60, // TIE key (default is Cn3)
|
||||
127, // TIE velocity
|
||||
{XCMD, 0x0C},
|
||||
60, // unk value
|
||||
{EOT, FINE} // end
|
||||
};
|
||||
|
||||
const XcmdFunc gXcmdTable[] =
|
||||
{
|
||||
ply_xxx,
|
||||
ply_xwave,
|
||||
ply_xtype,
|
||||
ply_xxx,
|
||||
ply_xatta,
|
||||
ply_xdeca,
|
||||
ply_xsust,
|
||||
ply_xrele,
|
||||
ply_xiecv,
|
||||
ply_xiecl,
|
||||
ply_xleng,
|
||||
ply_xswee,
|
||||
ply_xcmd_0C,
|
||||
ply_xcmd_0D,
|
||||
};
|
||||
Reference in New Issue
Block a user