ShuriZma
/
melonDS
mirror of https://github.com/melonDS-emu/melonDS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
melonDS/src/SPU.cpp

1079 lines
25 KiB
C++
Raw Blame History

/*
Copyright 2016-2021 Arisotura
This file is part of melonDS.
melonDS is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
melonDS is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with melonDS. If not, see http://www.gnu.org/licenses/.
*/
#include <stdio.h>
#include <string.h>
#include "Platform.h"
#include "NDS.h"
#include "DSi.h"
#include "SPU.h"
// SPU TODO
// * capture addition modes, overflow bugs
// * channel hold
// * 'length less than 4' glitch
namespace SPU
{
const s8 ADPCMIndexTable[8] = {-1, -1, -1, -1, 2, 4, 6, 8};
const u16 ADPCMTable[89] =
{
0x0007, 0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E,
0x0010, 0x0011, 0x0013, 0x0015, 0x0017, 0x0019, 0x001C, 0x001F,
0x0022, 0x0025, 0x0029, 0x002D, 0x0032, 0x0037, 0x003C, 0x0042,
0x0049, 0x0050, 0x0058, 0x0061, 0x006B, 0x0076, 0x0082, 0x008F,
0x009D, 0x00AD, 0x00BE, 0x00D1, 0x00E6, 0x00FD, 0x0117, 0x0133,
0x0151, 0x0173, 0x0198, 0x01C1, 0x01EE, 0x0220, 0x0256, 0x0292,
0x02D4, 0x031C, 0x036C, 0x03C3, 0x0424, 0x048E, 0x0502, 0x0583,
0x0610, 0x06AB, 0x0756, 0x0812, 0x08E0, 0x09C3, 0x0ABD, 0x0BD0,
0x0CFF, 0x0E4C, 0x0FBA, 0x114C, 0x1307, 0x14EE, 0x1706, 0x1954,
0x1BDC, 0x1EA5, 0x21B6, 0x2515, 0x28CA, 0x2CDF, 0x315B, 0x364B,
0x3BB9, 0x41B2, 0x4844, 0x4F7E, 0x5771, 0x602F, 0x69CE, 0x7462,
0x7FFF
};
const s16 PSGTable[8][8] =
{
{-0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, 0x7FFF},
{-0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, 0x7FFF, 0x7FFF},
{-0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF},
{-0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF},
{-0x7FFF, -0x7FFF, -0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF},
{-0x7FFF, -0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF},
{-0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF},
{-0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF, -0x7FFF}
};
const u32 OutputBufferSize = 2*2048;
s16 OutputBackbuffer[2 * OutputBufferSize];
u32 OutputBackbufferWritePosition;
s16 OutputFrontBuffer[2 * OutputBufferSize];
u32 OutputFrontBufferWritePosition;
u32 OutputFrontBufferReadPosition;
Platform::Mutex* AudioLock;
u16 Cnt;
u8 MasterVolume;
u16 Bias;
Channel* Channels[16];
CaptureUnit* Capture[2];
bool Init()
{
for (int i = 0; i < 16; i++)
Channels[i] = new Channel(i);
Capture[0] = new CaptureUnit(0);
Capture[1] = new CaptureUnit(1);
AudioLock = Platform::Mutex_Create();
return true;
}
void DeInit()
{
for (int i = 0; i < 16; i++)
delete Channels[i];
delete Capture[0];
delete Capture[1];
Platform::Mutex_Free(AudioLock);
}
void Reset()
{
InitOutput();
Cnt = 0;
MasterVolume = 0;
Bias = 0;
for (int i = 0; i < 16; i++)
Channels[i]->Reset();
Capture[0]->Reset();
Capture[1]->Reset();
NDS::ScheduleEvent(NDS::Event_SPU, true, 1024, Mix, 0);
}
void Stop()
{
Platform::Mutex_Lock(AudioLock);
memset(OutputFrontBuffer, 0, 2*OutputBufferSize*2);
OutputBackbufferWritePosition = 0;
OutputFrontBufferReadPosition = 0;
OutputFrontBufferWritePosition = 0;
Platform::Mutex_Unlock(AudioLock);
}
void DoSavestate(Savestate* file)
{
file->Section("SPU.");
file->Var16(&Cnt);
file->Var8(&MasterVolume);
file->Var16(&Bias);
for (int i = 0; i < 16; i++)
Channels[i]->DoSavestate(file);
Capture[0]->DoSavestate(file);
Capture[1]->DoSavestate(file);
}
void SetBias(u16 bias)
{
Bias = bias;
}
Channel::Channel(u32 num)
{
Num = num;
}
Channel::~Channel()
{
}
void Channel::Reset()
{
if (NDS::ConsoleType == 1)
BusRead32 = DSi::ARM7Read32;
else
BusRead32 = NDS::ARM7Read32;
KeyOn = false;
SetCnt(0);
SrcAddr = 0;
TimerReload = 0;
LoopPos = 0;
Length = 0;
Timer = 0;
Pos = 0;
FIFOReadPos = 0;
FIFOWritePos = 0;
FIFOReadOffset = 0;
FIFOLevel = 0;
}
void Channel::DoSavestate(Savestate* file)
{
file->Var32(&Cnt);
file->Var32(&SrcAddr);
file->Var16(&TimerReload);
file->Var32(&LoopPos);
file->Var32(&Length);
file->Var8(&Volume);
file->Var8(&VolumeShift);
file->Var8(&Pan);
file->Var8((u8*)&KeyOn);
file->Var32(&Timer);
file->Var32((u32*)&Pos);
file->Var16((u16*)&CurSample);
file->Var16(&NoiseVal);
file->Var32((u32*)&ADPCMVal);
file->Var32((u32*)&ADPCMIndex);
file->Var32((u32*)&ADPCMValLoop);
file->Var32((u32*)&ADPCMIndexLoop);
file->Var8(&ADPCMCurByte);
file->Var32(&FIFOReadPos);
file->Var32(&FIFOWritePos);
file->Var32(&FIFOReadOffset);
file->Var32(&FIFOLevel);
file->VarArray(FIFO, 8*4);
}
void Channel::FIFO_BufferData()
{
u32 totallen = LoopPos + Length;
if (FIFOReadOffset >= totallen)
{
u32 repeatmode = (Cnt >> 27) & 0x3;
if (repeatmode & 1) FIFOReadOffset = LoopPos;
else if (repeatmode & 2) return; // one-shot sound, we're done
}
u32 burstlen = 16;
if ((FIFOReadOffset + 16) > totallen)
burstlen = totallen - FIFOReadOffset;
for (u32 i = 0; i < burstlen; i += 4)
{
FIFO[FIFOWritePos] = BusRead32(SrcAddr + FIFOReadOffset);
FIFOReadOffset += 4;
FIFOWritePos++;
FIFOWritePos &= 0x7;
}
FIFOLevel += burstlen;
}
template<typename T>
T Channel::FIFO_ReadData()
{
T ret = *(T*)&((u8*)FIFO)[FIFOReadPos];
FIFOReadPos += sizeof(T);
FIFOReadPos &= 0x1F;
FIFOLevel -= sizeof(T);
if (FIFOLevel <= 16)
FIFO_BufferData();
return ret;
}
void Channel::Start()
{
Timer = TimerReload;
if (((Cnt >> 29) & 0x3) == 3)
Pos = -1;
else
Pos = -3;
NoiseVal = 0x7FFF;
CurSample = 0;
FIFOReadPos = 0;
FIFOWritePos = 0;
FIFOReadOffset = 0;
FIFOLevel = 0;
// when starting a channel, buffer data
if (((Cnt >> 29) & 0x3) != 3)
{
FIFO_BufferData();
FIFO_BufferData();
}
}
void Channel::NextSample_PCM8()
{
Pos++;
if (Pos < 0) return;
if (Pos >= (LoopPos + Length))
{
u32 repeat = (Cnt >> 27) & 0x3;
if (repeat & 1)
{
Pos = LoopPos;
}
else if (repeat & 2)
{
CurSample = 0;
Cnt &= ~(1<<31);
return;
}
}
s8 val = FIFO_ReadData<s8>();
CurSample = val << 8;
}
void Channel::NextSample_PCM16()
{
Pos++;
if (Pos < 0) return;
if ((Pos<<1) >= (LoopPos + Length))
{
u32 repeat = (Cnt >> 27) & 0x3;
if (repeat & 1)
{
Pos = LoopPos>>1;
}
else if (repeat & 2)
{
CurSample = 0;
Cnt &= ~(1<<31);
return;
}
}
s16 val = FIFO_ReadData<s16>();
CurSample = val;
}
void Channel::NextSample_ADPCM()
{
Pos++;
if (Pos < 8)
{
if (Pos == 0)
{
// setup ADPCM
u32 header = FIFO_ReadData<u32>();
ADPCMVal = header & 0xFFFF;
ADPCMIndex = (header >> 16) & 0x7F;
if (ADPCMIndex > 88) ADPCMIndex = 88;
ADPCMValLoop = ADPCMVal;
ADPCMIndexLoop = ADPCMIndex;
}
return;
}
if ((Pos>>1) >= (LoopPos + Length))
{
u32 repeat = (Cnt >> 27) & 0x3;
if (repeat & 1)
{
Pos = LoopPos<<1;
ADPCMVal = ADPCMValLoop;
ADPCMIndex = ADPCMIndexLoop;
ADPCMCurByte = FIFO_ReadData<u8>();
}
else if (repeat & 2)
{
CurSample = 0;
Cnt &= ~(1<<31);
return;
}
}
else
{
if (!(Pos & 0x1))
ADPCMCurByte = FIFO_ReadData<u8>();
else
ADPCMCurByte >>= 4;
u16 val = ADPCMTable[ADPCMIndex];
u16 diff = val >> 3;
if (ADPCMCurByte & 0x1) diff += (val >> 2);
if (ADPCMCurByte & 0x2) diff += (val >> 1);
if (ADPCMCurByte & 0x4) diff += val;
if (ADPCMCurByte & 0x8)
{
ADPCMVal -= diff;
if (ADPCMVal < -0x7FFF) ADPCMVal = -0x7FFF;
}
else
{
ADPCMVal += diff;
if (ADPCMVal > 0x7FFF) ADPCMVal = 0x7FFF;
}
ADPCMIndex += ADPCMIndexTable[ADPCMCurByte & 0x7];
if (ADPCMIndex < 0) ADPCMIndex = 0;
else if (ADPCMIndex > 88) ADPCMIndex = 88;
if (Pos == (LoopPos<<1))
{
ADPCMValLoop = ADPCMVal;
ADPCMIndexLoop = ADPCMIndex;
}
}
CurSample = ADPCMVal;
}
void Channel::NextSample_PSG()
{
Pos++;
CurSample = PSGTable[(Cnt >> 24) & 0x7][Pos & 0x7];
}
void Channel::NextSample_Noise()
{
if (NoiseVal & 0x1)
{
NoiseVal = (NoiseVal >> 1) ^ 0x6000;
CurSample = -0x7FFF;
}
else
{
NoiseVal >>= 1;
CurSample = 0x7FFF;
}
}
template<u32 type>
s32 Channel::Run()
{
if (!(Cnt & (1<<31))) return 0;
if ((type < 3) && ((Length+LoopPos) < 16)) return 0;
if (KeyOn)
{
Start();
KeyOn = false;
}
Timer += 512; // 1 sample = 512 cycles at 16MHz
while (Timer >> 16)
{
Timer = TimerReload + (Timer - 0x10000);
switch (type)
{
case 0: NextSample_PCM8(); break;
case 1: NextSample_PCM16(); break;
case 2: NextSample_ADPCM(); break;
case 3: NextSample_PSG(); break;
case 4: NextSample_Noise(); break;
}
}
s32 val = (s32)CurSample;
val <<= VolumeShift;
val *= Volume;
return val;
}
void Channel::PanOutput(s32 in, s32& left, s32& right)
{
left += ((s64)in * (128-Pan)) >> 10;
right += ((s64)in * Pan) >> 10;
}
CaptureUnit::CaptureUnit(u32 num)
{
Num = num;
}
CaptureUnit::~CaptureUnit()
{
}
void CaptureUnit::Reset()
{
if (NDS::ConsoleType == 1)
BusWrite32 = DSi::ARM7Write32;
else
BusWrite32 = NDS::ARM7Write32;
SetCnt(0);
DstAddr = 0;
TimerReload = 0;
Length = 0;
Timer = 0;
Pos = 0;
FIFOReadPos = 0;
FIFOWritePos = 0;
FIFOWriteOffset = 0;
FIFOLevel = 0;
}
void CaptureUnit::DoSavestate(Savestate* file)
{
file->Var8(&Cnt);
file->Var32(&DstAddr);
file->Var16(&TimerReload);
file->Var32(&Length);
file->Var32(&Timer);
file->Var32((u32*)&Pos);
file->Var32(&FIFOReadPos);
file->Var32(&FIFOWritePos);
file->Var32(&FIFOWriteOffset);
file->Var32(&FIFOLevel);
file->VarArray(FIFO, 4*4);
}
void CaptureUnit::FIFO_FlushData()
{
for (u32 i = 0; i < 4; i++)
{
BusWrite32(DstAddr + FIFOWriteOffset, FIFO[FIFOReadPos]);
FIFOReadPos++;
FIFOReadPos &= 0x3;
FIFOLevel -= 4;
FIFOWriteOffset += 4;
if (FIFOWriteOffset >= Length)
{
FIFOWriteOffset = 0;
break;
}
}
}
template<typename T>
void CaptureUnit::FIFO_WriteData(T val)
{
*(T*)&((u8*)FIFO)[FIFOWritePos] = val;
FIFOWritePos += sizeof(T);
FIFOWritePos &= 0xF;
FIFOLevel += sizeof(T);
if (FIFOLevel >= 16)
FIFO_FlushData();
}
void CaptureUnit::Run(s32 sample)
{
Timer += 512;
if (Cnt & 0x08)
{
while (Timer >> 16)
{
Timer = TimerReload + (Timer - 0x10000);
FIFO_WriteData<s8>((s8)(sample >> 8));
Pos++;
if (Pos >= Length)
{
if (FIFOLevel >= 4)
FIFO_FlushData();
if (Cnt & 0x04)
{
Cnt &= 0x7F;
return;
}
else
Pos = 0;
}
}
}
else
{
while (Timer >> 16)
{
Timer = TimerReload + (Timer - 0x10000);
FIFO_WriteData<s16>((s16)sample);
Pos += 2;
if (Pos >= Length)
{
if (FIFOLevel >= 4)
FIFO_FlushData();
if (Cnt & 0x04)
{
Cnt &= 0x7F;
return;
}
else
Pos = 0;
}
}
}
}
void Mix(u32 dummy)
{
s32 left = 0, right = 0;
s32 leftoutput = 0, rightoutput = 0;
if (Cnt & (1<<15))
{
s32 ch0 = Channels[0]->DoRun();
s32 ch1 = Channels[1]->DoRun();
s32 ch2 = Channels[2]->DoRun();
s32 ch3 = Channels[3]->DoRun();
// TODO: addition from capture registers
Channels[0]->PanOutput(ch0, left, right);
Channels[2]->PanOutput(ch2, left, right);
if (!(Cnt & (1<<12))) Channels[1]->PanOutput(ch1, left, right);
if (!(Cnt & (1<<13))) Channels[3]->PanOutput(ch3, left, right);
for (int i = 4; i < 16; i++)
{
Channel* chan = Channels[i];
s32 channel = chan->DoRun();
chan->PanOutput(channel, left, right);
}
// sound capture
// TODO: other sound capture sources, along with their bugs
if (Capture[0]->Cnt & (1<<7))
{
s32 val = left;
val >>= 8;
if (val < -0x8000) val = -0x8000;
else if (val > 0x7FFF) val = 0x7FFF;
Capture[0]->Run(val);
}
if (Capture[1]->Cnt & (1<<7))
{
s32 val = right;
val >>= 8;
if (val < -0x8000) val = -0x8000;
else if (val > 0x7FFF) val = 0x7FFF;
Capture[1]->Run(val);
}
// final output
switch (Cnt & 0x0300)
{
case 0x0000: // left mixer
leftoutput = left;
break;
case 0x0100: // channel 1
{
s32 pan = 128 - Channels[1]->Pan;
leftoutput = ((s64)ch1 * pan) >> 10;
}
break;
case 0x0200: // channel 3
{
s32 pan = 128 - Channels[3]->Pan;
leftoutput = ((s64)ch3 * pan) >> 10;
}
break;
case 0x0300: // channel 1+3
{
s32 pan1 = 128 - Channels[1]->Pan;
s32 pan3 = 128 - Channels[3]->Pan;
leftoutput = (((s64)ch1 * pan1) >> 10) + (((s64)ch3 * pan3) >> 10);
}
break;
}
switch (Cnt & 0x0C00)
{
case 0x0000: // right mixer
rightoutput = right;
break;
case 0x0400: // channel 1
{
s32 pan = Channels[1]->Pan;
rightoutput = ((s64)ch1 * pan) >> 10;
}
break;
case 0x0800: // channel 3
{
s32 pan = Channels[3]->Pan;
rightoutput = ((s64)ch3 * pan) >> 10;
}
break;
case 0x0C00: // channel 1+3
{
s32 pan1 = Channels[1]->Pan;
s32 pan3 = Channels[3]->Pan;
rightoutput = (((s64)ch1 * pan1) >> 10) + (((s64)ch3 * pan3) >> 10);
}
break;
}
}
leftoutput = ((s64)leftoutput * MasterVolume) >> 7;
rightoutput = ((s64)rightoutput * MasterVolume) >> 7;
leftoutput >>= 8;
if (leftoutput < -0x8000) leftoutput = -0x8000;
else if (leftoutput > 0x7FFF) leftoutput = 0x7FFF;
rightoutput >>= 8;
if (rightoutput < -0x8000) rightoutput = -0x8000;
else if (rightoutput > 0x7FFF) rightoutput = 0x7FFF;
// OutputBufferFrame can never get full because it's
// transfered to OutputBuffer at the end of the frame
OutputBackbuffer[OutputBackbufferWritePosition ] = leftoutput >> 1;
OutputBackbuffer[OutputBackbufferWritePosition + 1] = rightoutput >> 1;
OutputBackbufferWritePosition += 2;
NDS::ScheduleEvent(NDS::Event_SPU, true, 1024, Mix, 0);
}
void TransferOutput()
{
Platform::Mutex_Lock(AudioLock);
for (u32 i = 0; i < OutputBackbufferWritePosition; i += 2)
{
OutputFrontBuffer[OutputFrontBufferWritePosition ] = OutputBackbuffer[i ];
OutputFrontBuffer[OutputFrontBufferWritePosition + 1] = OutputBackbuffer[i + 1];
OutputFrontBufferWritePosition += 2;
OutputFrontBufferWritePosition &= OutputBufferSize*2-1;
if (OutputFrontBufferWritePosition == OutputFrontBufferReadPosition)
{
// advance the read position too, to avoid losing the entire FIFO
OutputFrontBufferReadPosition += 2;
OutputFrontBufferReadPosition &= OutputBufferSize*2-1;
}
}
OutputBackbufferWritePosition = 0;
Platform::Mutex_Unlock(AudioLock);
}
void TrimOutput()
{
Platform::Mutex_Lock(AudioLock);
const int halflimit = (OutputBufferSize / 2);
int readpos = OutputFrontBufferWritePosition - (halflimit*2);
if (readpos < 0) readpos += (OutputBufferSize*2);
OutputFrontBufferReadPosition = readpos;
Platform::Mutex_Unlock(AudioLock);
}
void DrainOutput()
{
Platform::Mutex_Lock(AudioLock);
OutputFrontBufferWritePosition = 0;
OutputFrontBufferReadPosition = 0;
Platform::Mutex_Unlock(AudioLock);
}
void InitOutput()
{
Platform::Mutex_Lock(AudioLock);
memset(OutputBackbuffer, 0, 2*OutputBufferSize*2);
memset(OutputFrontBuffer, 0, 2*OutputBufferSize*2);
OutputFrontBufferReadPosition = 0;
OutputFrontBufferWritePosition = 0;
Platform::Mutex_Unlock(AudioLock);
}
int GetOutputSize()
{
Platform::Mutex_Lock(AudioLock);
int ret;
if (OutputFrontBufferWritePosition >= OutputFrontBufferReadPosition)
ret = OutputFrontBufferWritePosition - OutputFrontBufferReadPosition;
else
ret = (OutputBufferSize*2) - OutputFrontBufferReadPosition + OutputFrontBufferWritePosition;
ret >>= 1;
Platform::Mutex_Unlock(AudioLock);
return ret;
}
void Sync(bool wait)
{
// this function is currently not used anywhere
// depending on the usage context the thread safety measures could be made
// a lot faster
// sync to audio output in case the core is running too fast
// * wait=true: wait until enough audio data has been played
// * wait=false: merely skip some audio data to avoid a FIFO overflow
const int halflimit = (OutputBufferSize / 2);
if (wait)
{
// TODO: less CPU-intensive wait?
while (GetOutputSize() > halflimit);
}
else if (GetOutputSize() > halflimit)
{
Platform::Mutex_Lock(AudioLock);
int readpos = OutputFrontBufferWritePosition - (halflimit*2);
if (readpos < 0) readpos += (OutputBufferSize*2);
OutputFrontBufferReadPosition = readpos;
Platform::Mutex_Unlock(AudioLock);
}
}
int ReadOutput(s16* data, int samples)
{
Platform::Mutex_Lock(AudioLock);
if (OutputFrontBufferReadPosition == OutputFrontBufferWritePosition)
{
Platform::Mutex_Unlock(AudioLock);
return 0;
}
for (int i = 0; i < samples; i++)
{
*data++ = OutputFrontBuffer[OutputFrontBufferReadPosition];
*data++ = OutputFrontBuffer[OutputFrontBufferReadPosition + 1];
OutputFrontBufferReadPosition += 2;
OutputFrontBufferReadPosition &= ((2*OutputBufferSize)-1);
if (OutputFrontBufferWritePosition == OutputFrontBufferReadPosition)
{
Platform::Mutex_Unlock(AudioLock);
return i+1;
}
}
Platform::Mutex_Unlock(AudioLock);
return samples;
}
u8 Read8(u32 addr)
{
if (addr < 0x04000500)
{
Channel* chan = Channels[(addr >> 4) & 0xF];
switch (addr & 0xF)
{
case 0x0: return chan->Cnt & 0xFF;
case 0x1: return (chan->Cnt >> 8) & 0xFF;
case 0x2: return (chan->Cnt >> 16) & 0xFF;
case 0x3: return chan->Cnt >> 24;
}
}
else
{
switch (addr)
{
case 0x04000500: return Cnt & 0x7F;
case 0x04000501: return Cnt >> 8;
case 0x04000508: return Capture[0]->Cnt;
case 0x04000509: return Capture[1]->Cnt;
}
}
printf("unknown SPU read8 %08X\n", addr);
return 0;
}
u16 Read16(u32 addr)
{
if (addr < 0x04000500)
{
Channel* chan = Channels[(addr >> 4) & 0xF];
switch (addr & 0xF)
{
case 0x0: return chan->Cnt & 0xFFFF;
case 0x2: return chan->Cnt >> 16;
}
}
else
{
switch (addr)
{
case 0x04000500: return Cnt;
case 0x04000504: return Bias;
case 0x04000508: return Capture[0]->Cnt | (Capture[1]->Cnt << 8);
}
}
printf("unknown SPU read16 %08X\n", addr);
return 0;
}
u32 Read32(u32 addr)
{
if (addr < 0x04000500)
{
Channel* chan = Channels[(addr >> 4) & 0xF];
switch (addr & 0xF)
{
case 0x0: return chan->Cnt;
}
}
else
{
switch (addr)
{
case 0x04000500: return Cnt;
case 0x04000504: return Bias;
case 0x04000508: return Capture[0]->Cnt | (Capture[1]->Cnt << 8);
case 0x04000510: return Capture[0]->DstAddr;
case 0x04000518: return Capture[1]->DstAddr;
}
}
printf("unknown SPU read32 %08X\n", addr);
return 0;
}
void Write8(u32 addr, u8 val)
{
if (addr < 0x04000500)
{
Channel* chan = Channels[(addr >> 4) & 0xF];
switch (addr & 0xF)
{
case 0x0: chan->SetCnt((chan->Cnt & 0xFFFFFF00) | val); return;
case 0x1: chan->SetCnt((chan->Cnt & 0xFFFF00FF) | (val << 8)); return;
case 0x2: chan->SetCnt((chan->Cnt & 0xFF00FFFF) | (val << 16)); return;
case 0x3: chan->SetCnt((chan->Cnt & 0x00FFFFFF) | (val << 24)); return;
}
}
else
{
switch (addr)
{
case 0x04000500:
Cnt = (Cnt & 0xBF00) | (val & 0x7F);
MasterVolume = Cnt & 0x7F;
if (MasterVolume == 127) MasterVolume++;
return;
case 0x04000501:
Cnt = (Cnt & 0x007F) | ((val & 0xBF) << 8);
return;
case 0x04000508:
Capture[0]->SetCnt(val);
if (val & 0x03) printf("!! UNSUPPORTED SPU CAPTURE MODE %02X\n", val);
return;
case 0x04000509:
Capture[1]->SetCnt(val);
if (val & 0x03) printf("!! UNSUPPORTED SPU CAPTURE MODE %02X\n", val);
return;
}
}
printf("unknown SPU write8 %08X %02X\n", addr, val);
}
void Write16(u32 addr, u16 val)
{
if (addr < 0x04000500)
{
Channel* chan = Channels[(addr >> 4) & 0xF];
switch (addr & 0xF)
{
case 0x0: chan->SetCnt((chan->Cnt & 0xFFFF0000) | val); return;
case 0x2: chan->SetCnt((chan->Cnt & 0x0000FFFF) | (val << 16)); return;
case 0x8:
chan->SetTimerReload(val);
if ((addr & 0xF0) == 0x10) Capture[0]->SetTimerReload(val);
else if ((addr & 0xF0) == 0x30) Capture[1]->SetTimerReload(val);
return;
case 0xA: chan->SetLoopPos(val); return;
case 0xC: chan->SetLength(((chan->Length >> 2) & 0xFFFF0000) | val); return;
case 0xE: chan->SetLength(((chan->Length >> 2) & 0x0000FFFF) | (val << 16)); return;
}
}
else
{
switch (addr)
{
case 0x04000500:
Cnt = val & 0xBF7F;
MasterVolume = Cnt & 0x7F;
if (MasterVolume == 127) MasterVolume++;
return;
case 0x04000504:
Bias = val & 0x3FF;
return;
case 0x04000508:
Capture[0]->SetCnt(val & 0xFF);
Capture[1]->SetCnt(val >> 8);
if (val & 0x0303) printf("!! UNSUPPORTED SPU CAPTURE MODE %04X\n", val);
return;
case 0x04000514: Capture[0]->SetLength(val); return;
case 0x0400051C: Capture[1]->SetLength(val); return;
}
}
printf("unknown SPU write16 %08X %04X\n", addr, val);
}
void Write32(u32 addr, u32 val)
{
if (addr < 0x04000500)
{
Channel* chan = Channels[(addr >> 4) & 0xF];
switch (addr & 0xF)
{
case 0x0: chan->SetCnt(val); return;
case 0x4: chan->SetSrcAddr(val); return;
case 0x8:
chan->SetLoopPos(val >> 16);
val &= 0xFFFF;
chan->SetTimerReload(val);
if ((addr & 0xF0) == 0x10) Capture[0]->SetTimerReload(val);
else if ((addr & 0xF0) == 0x30) Capture[1]->SetTimerReload(val);
return;
case 0xC: chan->SetLength(val); return;
}
}
else
{
switch (addr)
{
case 0x04000500:
Cnt = val & 0xBF7F;
MasterVolume = Cnt & 0x7F;
if (MasterVolume == 127) MasterVolume++;
return;
case 0x04000504:
Bias = val & 0x3FF;
return;
case 0x04000508:
Capture[0]->SetCnt(val & 0xFF);
Capture[1]->SetCnt(val >> 8);
if (val & 0x0303) printf("!! UNSUPPORTED SPU CAPTURE MODE %04X\n", val);
return;
case 0x04000510: Capture[0]->SetDstAddr(val); return;
case 0x04000514: Capture[0]->SetLength(val & 0xFFFF); return;
case 0x04000518: Capture[1]->SetDstAddr(val); return;
case 0x0400051C: Capture[1]->SetLength(val & 0xFFFF); return;
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink