ShuriZma
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SPU2null reformat

This commit is contained in:
Clang Format 2016-08-24 23:15:05 +02:00 committed by Gregory Hainaut
parent 67e7d63f0f
commit e3a2ad03bc
5 changed files with 1224 additions and 1270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
plugins/SPU2null/Linux/Config.cpp
View File

@ -23,14 +23,16 @@ using namespace std;
extern string s_strIniPath;
PluginConf Ini;
EXPORT_C_(void) SPU2configure()
EXPORT_C_(void)
SPU2configure()
{
LoadConfig();
PluginNullConfigure("Since this is a null plugin, all that is really configurable is logging.", conf.Log);
SaveConfig();
}
EXPORT_C_(void) SPU2about()
EXPORT_C_(void)
SPU2about()
{
//SysMessage("%s %d.%d", libraryName, version, build);
SysMessage("SPU2null: A simple null plugin.");
@ -40,8 +42,7 @@ void LoadConfig()
{
const std::string iniFile(s_strIniPath + "/Spu2null.ini");
if (!Ini.Open(iniFile, READ_FILE))
{
if (!Ini.Open(iniFile, READ_FILE)) {
printf("failed to open %s\n", iniFile.c_str());
SaveConfig(); //save and return
return;
@ -55,8 +56,7 @@ void SaveConfig()
{
const std::string iniFile(s_strIniPath + "/Spu2null.ini");
if (!Ini.Open(iniFile, WRITE_FILE))
{
if (!Ini.Open(iniFile, WRITE_FILE)) {
printf("failed to open %s\n", iniFile.c_str());
return;
}

389
plugins/SPU2null/SPU2.cpp
View File

@ -76,25 +76,27 @@ const s32 f[5][2] = {
{60, 0},
{115, -52},
{98, -55},
{ 122, -60 }
};
{122, -60}};
u32 RateTable[160];
// channels and voices
VOICE_PROCESSED voices[SPU_NUMBER_VOICES + 1]; // +1 for modulation
EXPORT_C_(u32) PS2EgetLibType()
EXPORT_C_(u32)
PS2EgetLibType()
{
return PS2E_LT_SPU2;
}
EXPORT_C_(char*) PS2EgetLibName()
EXPORT_C_(char*)
PS2EgetLibName()
{
return libraryName;
}
EXPORT_C_(u32) PS2EgetLibVersion2(u32 type)
EXPORT_C_(u32)
PS2EgetLibVersion2(u32 type)
{
return (version << 16) | (revision << 8) | build | (minor << 24);
}
@ -103,22 +105,26 @@ void __Log(char *fmt, ...)
{
va_list list;
if (!conf.Log || spu2Log == NULL) return;
if (!conf.Log || spu2Log == NULL)
return;
va_start(list, fmt);
vfprintf(spu2Log, fmt, list);
va_end(list);
}
EXPORT_C_(void) SPU2setSettingsDir(const char* dir)
EXPORT_C_(void)
SPU2setSettingsDir(const char* dir)
{
s_strIniPath = (dir == NULL) ? "inis/" : dir;
}
bool OpenLog() {
bool OpenLog()
{
bool result = true;
#ifdef SPU2_LOG
if(spu2Log) return result;
if (spu2Log)
return result;
const std::string LogFile(s_strLogPath + "/spu2null.log");
@ -135,7 +141,8 @@ bool OpenLog() {
return result;
}
EXPORT_C_(void) SPU2setLogDir(const char* dir)
EXPORT_C_(void)
SPU2setLogDir(const char* dir)
{
// Get the path to the log directory.
s_strLogPath = (dir == NULL) ? "logs/" : dir;
@ -148,21 +155,20 @@ EXPORT_C_(void) SPU2setLogDir(const char* dir)
OpenLog();
}
EXPORT_C_(s32) SPU2init()
EXPORT_C_(s32)
SPU2init()
{
OpenLog();
spu2regs = (s8*)malloc(0x10000);
if (spu2regs == NULL)
{
if (spu2regs == NULL) {
SysMessage("Error allocating Memory\n");
return -1;
}
memset(spu2regs, 0, 0x10000);
spu2mem = (u16*)malloc(0x200000); // 2Mb
if (spu2mem == NULL)
{
if (spu2mem == NULL) {
SysMessage("Error allocating Memory\n");
return -1;
}
@ -177,8 +183,7 @@ EXPORT_C_(s32) SPU2init()
voices[i + 24].memoffset = 0x400;
// init each channel
for (u32 i = 0; i < ArraySize(voices); ++i)
{
for (u32 i = 0; i < ArraySize(voices); ++i) {
voices[i].pLoop = voices[i].pStart = voices[i].pCurr = (u8*)spu2mem;
@ -189,7 +194,8 @@ EXPORT_C_(s32) SPU2init()
return 0;
}
EXPORT_C_(s32) SPU2open(void *pDsp)
EXPORT_C_(s32)
SPU2open(void* pDsp)
{
LoadConfig();
SPUCycles = SPUWorkerCycles = 0;
@ -200,12 +206,14 @@ EXPORT_C_(s32) SPU2open(void *pDsp)
return 0;
}
EXPORT_C_(void) SPU2close()
EXPORT_C_(void)
SPU2close()
{
g_nSpuInit = 0;
}
EXPORT_C_(void) SPU2shutdown()
EXPORT_C_(void)
SPU2shutdown()
{
free(spu2regs);
spu2regs = NULL;
@ -224,33 +232,27 @@ void SPU2Worker();
#define CYCLES_PER_MS (36864000 / 1000)
EXPORT_C_(void) SPU2async(u32 cycle)
EXPORT_C_(void)
SPU2async(u32 cycle)
{
SPUCycles += cycle;
if (interrupt & (1 << 2))
{
if (SPUCycles - SPUStartCycle[1] >= SPUTargetCycle[1])
{
if (interrupt & (1 << 2)) {
if (SPUCycles - SPUStartCycle[1] >= SPUTargetCycle[1]) {
interrupt &= ~(1 << 2);
irqCallbackDMA7();
}
}
if (interrupt & (1 << 1))
{
if (SPUCycles - SPUStartCycle[0] >= SPUTargetCycle[0])
{
if (interrupt & (1 << 1)) {
if (SPUCycles - SPUStartCycle[0] >= SPUTargetCycle[0]) {
interrupt &= ~(1 << 1);
irqCallbackDMA4();
}
}
if (g_nSpuInit)
{
if (g_nSpuInit) {
while (SPUCycles - SPUWorkerCycles > 0 && CYCLES_PER_MS < SPUCycles - SPUWorkerCycles)
{
while (SPUCycles - SPUWorkerCycles > 0 && CYCLES_PER_MS < SPUCycles - SPUWorkerCycles) {
SPU2Worker();
SPUWorkerCycles += CYCLES_PER_MS;
}
@ -269,17 +271,16 @@ void InitADSR() // INIT ADSR
for (i = 32; i < 160; i++) // we start at pos 32 with the real values... everything before is 0
{
if (r < 0x3FFFFFFF)
{
if (r < 0x3FFFFFFF) {
r += rs;
rd++;
if (rd == 5)
{
if (rd == 5) {
rd = 1;
rs *= 2;
}
}
if (r > 0x3FFFFFFF) r = 0x3FFFFFFF;
if (r > 0x3FFFFFFF)
r = 0x3FFFFFFF;
RateTable[i] = r;
}
@ -289,8 +290,7 @@ int MixADSR(VOICE_PROCESSED* pvoice) // MIX ADSR
{
if (pvoice->bStop) // should be stopped:
{
if (pvoice->bIgnoreLoop == 0)
{
if (pvoice->bIgnoreLoop == 0) {
pvoice->ADSRX.EnvelopeVol = 0;
pvoice->bOn = false;
pvoice->pStart = (u8*)(spu2mem + pvoice->iStartAddr);
@ -302,8 +302,7 @@ int MixADSR(VOICE_PROCESSED* pvoice) // MIX ADSR
}
if (pvoice->ADSRX.ReleaseModeExp) // do release
{
switch ((pvoice->ADSRX.EnvelopeVol >> 28)&0x7)
{
switch ((pvoice->ADSRX.EnvelopeVol >> 28) & 0x7) {
case 0:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x18 + 0 + 32];
break;
@ -329,14 +328,11 @@ int MixADSR(VOICE_PROCESSED* pvoice) // MIX ADSR
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x18 + 12 + 32];
break;
}
}
else
{
} else {
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x0C + 32];
}
if (pvoice->ADSRX.EnvelopeVol < 0)
{
if (pvoice->ADSRX.EnvelopeVol < 0) {
pvoice->ADSRX.EnvelopeVol = 0;
pvoice->bOn = false;
pvoice->pStart = (u8*)(spu2mem + pvoice->iStartAddr);
@ -351,25 +347,20 @@ int MixADSR(VOICE_PROCESSED* pvoice) // MIX ADSR
pvoice->ADSRX.lVolume = pvoice->ADSRX.EnvelopeVol >> 21;
pvoice->ADSRX.lVolume = pvoice->ADSRX.EnvelopeVol >> 21;
return pvoice->ADSRX.lVolume;
}
else // not stopped yet?
} else // not stopped yet?
{
if (pvoice->ADSRX.State == 0) // -> attack
{
if (pvoice->ADSRX.AttackModeExp)
{
if (pvoice->ADSRX.AttackModeExp) {
if (pvoice->ADSRX.EnvelopeVol < 0x60000000)
pvoice->ADSRX.EnvelopeVol += RateTable[(pvoice->ADSRX.AttackRate ^ 0x7F) - 0x10 + 32];
else
pvoice->ADSRX.EnvelopeVol += RateTable[(pvoice->ADSRX.AttackRate ^ 0x7F) - 0x18 + 32];
}
else
{
} else {
pvoice->ADSRX.EnvelopeVol += RateTable[(pvoice->ADSRX.AttackRate ^ 0x7F) - 0x10 + 32];
}
if (pvoice->ADSRX.EnvelopeVol < 0)
{
if (pvoice->ADSRX.EnvelopeVol < 0) {
pvoice->ADSRX.EnvelopeVol = 0x7FFFFFFF;
pvoice->ADSRX.State = 1;
}
@ -380,8 +371,7 @@ int MixADSR(VOICE_PROCESSED* pvoice) // MIX ADSR
//--------------------------------------------------//
if (pvoice->ADSRX.State == 1) // -> decay
{
switch ((pvoice->ADSRX.EnvelopeVol >> 28)&0x7)
{
switch ((pvoice->ADSRX.EnvelopeVol >> 28) & 0x7) {
case 0:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.DecayRate ^ 0x1F)) - 0x18 + 0 + 32];
break;
@ -408,9 +398,9 @@ int MixADSR(VOICE_PROCESSED* pvoice) // MIX ADSR
break;
}
if (pvoice->ADSRX.EnvelopeVol < 0) pvoice->ADSRX.EnvelopeVol = 0;
if (((pvoice->ADSRX.EnvelopeVol >> 27)&0xF) <= pvoice->ADSRX.SustainLevel)
{
if (pvoice->ADSRX.EnvelopeVol < 0)
pvoice->ADSRX.EnvelopeVol = 0;
if (((pvoice->ADSRX.EnvelopeVol >> 27) & 0xF) <= pvoice->ADSRX.SustainLevel) {
pvoice->ADSRX.State = 2;
}
@ -420,31 +410,22 @@ int MixADSR(VOICE_PROCESSED* pvoice) // MIX ADSR
//--------------------------------------------------//
if (pvoice->ADSRX.State == 2) // -> sustain
{
if (pvoice->ADSRX.SustainIncrease)
{
if (pvoice->ADSRX.SustainModeExp)
{
if (pvoice->ADSRX.SustainIncrease) {
if (pvoice->ADSRX.SustainModeExp) {
if (pvoice->ADSRX.EnvelopeVol < 0x60000000)
pvoice->ADSRX.EnvelopeVol += RateTable[(pvoice->ADSRX.SustainRate ^ 0x7F) - 0x10 + 32];
else
pvoice->ADSRX.EnvelopeVol += RateTable[(pvoice->ADSRX.SustainRate ^ 0x7F) - 0x18 + 32];
}
else
{
} else {
pvoice->ADSRX.EnvelopeVol += RateTable[(pvoice->ADSRX.SustainRate ^ 0x7F) - 0x10 + 32];
}
if (pvoice->ADSRX.EnvelopeVol < 0)
{
if (pvoice->ADSRX.EnvelopeVol < 0) {
pvoice->ADSRX.EnvelopeVol = 0x7FFFFFFF;
}
}
else
{
if (pvoice->ADSRX.SustainModeExp)
{
switch ((pvoice->ADSRX.EnvelopeVol >> 28)&0x7)
{
} else {
if (pvoice->ADSRX.SustainModeExp) {
switch ((pvoice->ADSRX.EnvelopeVol >> 28) & 0x7) {
case 0:
pvoice->ADSRX.EnvelopeVol -= RateTable[((pvoice->ADSRX.SustainRate ^ 0x7F)) - 0x1B + 0 + 32];
break;
@ -470,14 +451,11 @@ int MixADSR(VOICE_PROCESSED* pvoice) // MIX ADSR
pvoice->ADSRX.EnvelopeVol -= RateTable[((pvoice->ADSRX.SustainRate ^ 0x7F)) - 0x1B + 12 + 32];
break;
}
}
else
{
} else {
pvoice->ADSRX.EnvelopeVol -= RateTable[((pvoice->ADSRX.SustainRate ^ 0x7F)) - 0x0F + 32];
}
if (pvoice->ADSRX.EnvelopeVol < 0)
{
if (pvoice->ADSRX.EnvelopeVol < 0) {
pvoice->ADSRX.EnvelopeVol = 0;
}
}
@ -497,14 +475,12 @@ void SPU2Worker()
VOICE_PROCESSED* pChannel = voices;
for (ch = 0; ch < SPU_NUMBER_VOICES; ch++, pChannel++) // loop em all... we will collect 1 ms of sound of each playing channel
{
if (pChannel->bNew)
{
if (pChannel->bNew) {
pChannel->StartSound(); // start new sound
dwEndChannel2[ch / 24] &= ~(1 << (ch % 24)); // clear end channel bit
}
if (!pChannel->bOn)
{
if (!pChannel->bOn) {
// fill buffer with empty data
continue;
}
@ -514,10 +490,8 @@ void SPU2Worker()
// loop until 1 ms of data is reached
int ns = 0;
while (ns < NSSIZE)
{
while (pChannel->spos >= 0x10000)
{
while (ns < NSSIZE) {
while (pChannel->spos >= 0x10000) {
if (pChannel->iSBPos == 28) // 28 reached?
{
start = pChannel->pCurr; // set up the current pos
@ -539,13 +513,10 @@ void SPU2Worker()
start += 16;
// some callback and irq active?
if (pChannel->GetCtrl()->irq)
{
if (pChannel->GetCtrl()->irq) {
// if irq address reached or irq on looping addr, when stop/loop flag is set
u8* pirq = (u8*)pSpuIrq[ch >= 24];
if ((pirq > start - 16 && pirq <= start)
|| ((flags&1) && (pirq > pChannel->pLoop - 16 && pirq <= pChannel->pLoop)))
{
if ((pirq > start - 16 && pirq <= start) || ((flags & 1) && (pirq > pChannel->pLoop - 16 && pirq <= pChannel->pLoop))) {
IRQINFO |= 4 << (int)(ch >= 24);
irqCallbackSPU2();
}
@ -565,9 +536,7 @@ void SPU2Worker()
start = (u8*)-1;
pChannel->bStop = true;
pChannel->bIgnoreLoop = false;
}
else
{
} else {
start = pChannel->pLoop;
}
}
@ -585,68 +554,58 @@ void SPU2Worker()
ns++;
pChannel->spos += pChannel->sinc;
}
ENDX:
;
ENDX:;
}
// mix all channels
if ((spu2Ru16(REG_C0_MMIX) & 0xC0) && (spu2Ru16(REG_C0_ADMAS) & 0x1) && !(spu2Ru16(REG_C0_CTRL) & 0x30))
{
for (int ns = 0;ns < NSSIZE;ns++)
{
if ((spu2Ru16(REG_C0_MMIX) & 0xC0) && (spu2Ru16(REG_C0_ADMAS) & 0x1) && !(spu2Ru16(REG_C0_CTRL) & 0x30)) {
for (int ns = 0; ns < NSSIZE; ns++) {
Adma4.Index += 1;
if (Adma4.Index == 128 || Adma4.Index == 384)
{
if (ADMAS4Write())
{
if (Adma4.Index == 128 || Adma4.Index == 384) {
if (ADMAS4Write()) {
spu2Ru16(REG_C0_SPUSTAT) &= ~0x80;
irqCallbackDMA4();
}
else MemAddr[0] += 1024;
} else
MemAddr[0] += 1024;
}
if (Adma4.Index == 512)
{
if (Adma4.Index == 512) {
Adma4.Index = 0;
}
}
}
if ((spu2Ru16(REG_C1_MMIX) & 0xC0) && (spu2Ru16(REG_C1_ADMAS) & 0x2) && !(spu2Ru16(REG_C1_CTRL) & 0x30))
{
for (int ns = 0;ns < NSSIZE;ns++)
{
if ((spu2Ru16(REG_C1_MMIX) & 0xC0) && (spu2Ru16(REG_C1_ADMAS) & 0x2) && !(spu2Ru16(REG_C1_CTRL) & 0x30)) {
for (int ns = 0; ns < NSSIZE; ns++) {
Adma7.Index += 1;
if (Adma7.Index == 128 || Adma7.Index == 384)
{
if (ADMAS7Write())
{
if (Adma7.Index == 128 || Adma7.Index == 384) {
if (ADMAS7Write()) {
spu2Ru16(REG_C1_SPUSTAT) &= ~0x80;
irqCallbackDMA7();
}
else MemAddr[1] += 1024;
} else
MemAddr[1] += 1024;
}
if (Adma7.Index == 512) Adma7.Index = 0;
if (Adma7.Index == 512)
Adma7.Index = 0;
}
}
}
EXPORT_C_(void) SPU2readDMA4Mem(u16 *pMem, int size)
EXPORT_C_(void)
SPU2readDMA4Mem(u16* pMem, int size)
{
u32 spuaddr = C0_SPUADDR;
int i;
SPU2_LOG("SPU2 readDMA4Mem size %x, addr: %x\n", size, pMem);
for (i = 0;i < size;i++)
{
for (i = 0; i < size; i++) {
*pMem++ = *(u16*)(spu2mem + spuaddr);
if ((spu2Rs16(REG_C0_CTRL)&0x40) && C0_IRQA == spuaddr)
{
if ((spu2Rs16(REG_C0_CTRL) & 0x40) && C0_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x4;
C0_SPUADDR_SET(spuaddr);
IRQINFO |= 4;
@ -668,18 +627,17 @@ EXPORT_C_(void) SPU2readDMA4Mem(u16 *pMem, int size)
interrupt |= (1 << 1);
}
EXPORT_C_(void) SPU2readDMA7Mem(u16* pMem, int size)
EXPORT_C_(void)
SPU2readDMA7Mem(u16* pMem, int size)
{
u32 spuaddr = C1_SPUADDR;
int i;
SPU2_LOG("SPU2 readDMA7Mem size %x, addr: %x\n", size, pMem);
for (i = 0;i < size;i++)
{
for (i = 0; i < size; i++) {
*pMem++ = *(u16*)(spu2mem + spuaddr);
if ((spu2Rs16(REG_C1_CTRL)&0x40) && C1_IRQA == spuaddr)
{
if ((spu2Rs16(REG_C1_CTRL) & 0x40) && C1_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x8;
C1_SPUADDR_SET(spuaddr);
IRQINFO |= 8;
@ -711,8 +669,10 @@ EXPORT_C_(void) SPU2readDMA7Mem(u16* pMem, int size)
int ADMAS4Write()
{
u32 spuaddr;
if (interrupt & 0x2) return 0;
if (Adma4.AmountLeft <= 0) return 1;
if (interrupt & 0x2)
return 0;
if (Adma4.AmountLeft <= 0)
return 1;
spuaddr = C0_SPUADDR;
// SPU2 Deinterleaves the Left and Right Channels
@ -724,8 +684,7 @@ int ADMAS4Write()
C0_SPUADDR_SET(spuaddr);
Adma4.AmountLeft -= 512;
if (Adma4.AmountLeft == 0)
{
if (Adma4.AmountLeft == 0) {
SPUStartCycle[0] = SPUCycles;
SPUTargetCycle[0] = 1; //512*48000;
spu2Ru16(REG_C0_SPUSTAT) &= ~0x80;
@ -737,8 +696,10 @@ int ADMAS4Write()
int ADMAS7Write()
{
u32 spuaddr;
if (interrupt & 0x4) return 0;
if (Adma7.AmountLeft <= 0) return 1;
if (interrupt & 0x4)
return 0;
if (Adma7.AmountLeft <= 0)
return 1;
spuaddr = C1_SPUADDR;
// SPU2 Deinterleaves the Left and Right Channels
@ -750,8 +711,7 @@ int ADMAS7Write()
C1_SPUADDR_SET(spuaddr);
Adma7.AmountLeft -= 512;
if (Adma7.AmountLeft == 0)
{
if (Adma7.AmountLeft == 0) {
SPUStartCycle[1] = SPUCycles;
SPUTargetCycle[1] = 1; //512*48000;
spu2Ru16(REG_C1_SPUSTAT) &= ~0x80;
@ -760,14 +720,14 @@ int ADMAS7Write()
return 0;
}
EXPORT_C_(void) SPU2writeDMA4Mem(u16* pMem, int size)
EXPORT_C_(void)
SPU2writeDMA4Mem(u16* pMem, int size)
{
u32 spuaddr;
SPU2_LOG("SPU2 writeDMA4Mem size %x, addr: %x\n", size, pMem);
if ((spu2Ru16(REG_C0_ADMAS) & 0x1) && (spu2Ru16(REG_C0_CTRL) & 0x30) == 0 && size)
{
if ((spu2Ru16(REG_C0_ADMAS) & 0x1) && (spu2Ru16(REG_C0_CTRL) & 0x30) == 0 && size) {
//fwrite(pMem,iSize<<1,1,LogFile);
memset(&Adma4, 0, sizeof(ADMA));
C0_SPUADDR_SET(0);
@ -782,8 +742,7 @@ EXPORT_C_(void) SPU2writeDMA4Mem(u16* pMem, int size)
spuaddr += size;
C0_SPUADDR_SET(spuaddr);
if ((spu2Ru16(REG_C0_CTRL)&0x40) && C0_IRQA == spuaddr)
{
if ((spu2Ru16(REG_C0_CTRL) & 0x40) && C0_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x4;
IRQINFO |= 4;
irqCallbackSPU2();
@ -799,14 +758,14 @@ EXPORT_C_(void) SPU2writeDMA4Mem(u16* pMem, int size)
interrupt |= (1 << 1);
}
EXPORT_C_(void) SPU2writeDMA7Mem(u16* pMem, int size)
EXPORT_C_(void)
SPU2writeDMA7Mem(u16* pMem, int size)
{
u32 spuaddr;
SPU2_LOG("SPU2 writeDMA7Mem size %x, addr: %x\n", size, pMem);
if ((spu2Ru16(REG_C1_ADMAS) & 0x2) && (spu2Ru16(REG_C1_CTRL) & 0x30) == 0 && size)
{
if ((spu2Ru16(REG_C1_ADMAS) & 0x2) && (spu2Ru16(REG_C1_CTRL) & 0x30) == 0 && size) {
//fwrite(pMem,iSize<<1,1,LogFile);
memset(&Adma7, 0, sizeof(ADMA));
C1_SPUADDR_SET(0);
@ -821,8 +780,7 @@ EXPORT_C_(void) SPU2writeDMA7Mem(u16* pMem, int size)
spuaddr += size;
C1_SPUADDR_SET(spuaddr);
if ((spu2Ru16(REG_C1_CTRL)&0x40) && C1_IRQA == spuaddr)
{
if ((spu2Ru16(REG_C1_CTRL) & 0x40) && C1_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x8;
IRQINFO |= 8;
irqCallbackSPU2();
@ -838,7 +796,8 @@ EXPORT_C_(void) SPU2writeDMA7Mem(u16* pMem, int size)
interrupt |= (1 << 2);
}
EXPORT_C_(void) SPU2interruptDMA4()
EXPORT_C_(void)
SPU2interruptDMA4()
{
SPU2_LOG("SPU2 interruptDMA4\n");
@ -846,7 +805,8 @@ EXPORT_C_(void) SPU2interruptDMA4()
spu2Ru16(REG_C0_SPUSTAT) |= 0x80;
}
EXPORT_C_(void) SPU2interruptDMA7()
EXPORT_C_(void)
SPU2interruptDMA7()
{
SPU2_LOG("SPU2 interruptDMA7\n");
@ -888,18 +848,16 @@ void FModOn(s32 start, s32 end, u16 val) // FMOD ON PSX COMMAND
{
if (val & 1) // -> fmod on/off
{
if (ch > 0)
{
if (ch > 0) {
}
}
else
{
} else {
// turn fmod off
}
}
}
EXPORT_C_(void) SPU2write(u32 mem, u16 value)
EXPORT_C_(void)
SPU2write(u32 mem, u16 value)
{
u32 spuaddr;
@ -915,19 +873,19 @@ EXPORT_C_(void) SPU2write(u32 mem, u16 value)
if ((r >= 0x0000 && r < 0x0180) || (r >= 0x0400 && r < 0x0580)) // some channel info?
{
int ch = 0;
if (r >= 0x400) ch = ((r - 0x400) >> 4) + 24;
else ch = (r >> 4);
if (r >= 0x400)
ch = ((r - 0x400) >> 4) + 24;
else
ch = (r >> 4);
VOICE_PROCESSED* pvoice = &voices[ch];
switch (r&0x0f)
{
switch (r & 0x0f) {
case 0:
case 2:
pvoice->SetVolume(mem & 0x2);
break;
case 4:
{
case 4: {
int NP;
if (value > 0x3fff)
NP = 0x3fff; // get pitch val
@ -937,12 +895,12 @@ EXPORT_C_(void) SPU2write(u32 mem, u16 value)
pvoice->pvoice->pitch = NP;
NP = (44100L * NP) / 4096L; // calc frequency
if (NP < 1) NP = 1; // some security
if (NP < 1)
NP = 1; // some security
pvoice->iActFreq = NP; // store frequency
break;
}
case 6:
{
case 6: {
pvoice->ADSRX.AttackModeExp = (value & 0x8000) ? 1 : 0;
pvoice->ADSRX.AttackRate = ((value >> 8) & 0x007f);
pvoice->ADSRX.DecayRate = (((value >> 4) & 0x000f));
@ -962,12 +920,10 @@ EXPORT_C_(void) SPU2write(u32 mem, u16 value)
}
// more channel info
if ((r >= 0x01c0 && r <= 0x02E0) || (r >= 0x05c0 && r <= 0x06E0))
{
if ((r >= 0x01c0 && r <= 0x02E0) || (r >= 0x05c0 && r <= 0x06E0)) {
s32 ch = 0;
u32 rx = r;
if (rx >= 0x400)
{
if (rx >= 0x400) {
ch = 24;
rx -= 0x400;
}
@ -976,8 +932,7 @@ EXPORT_C_(void) SPU2write(u32 mem, u16 value)
rx -= (ch % 24) * 12;
VOICE_PROCESSED* pvoice = &voices[ch];
switch (rx)
{
switch (rx) {
case 0x1C0:
pvoice->iStartAddr = (((u32)value & 0x3f) << 16) | (pvoice->iStartAddr & 0xFFFF);
pvoice->pStart = (u8*)(spu2mem + pvoice->iStartAddr);
@ -1010,19 +965,18 @@ EXPORT_C_(void) SPU2write(u32 mem, u16 value)
}
// process non-channel data
switch (mem&0xffff)
{
switch (mem & 0xffff) {
case REG_C0_SPUDATA:
spuaddr = C0_SPUADDR;
spu2mem[spuaddr] = value;
spuaddr++;
if ((spu2Ru16(REG_C0_CTRL)&0x40) && C0_IRQA == spuaddr)
{
if ((spu2Ru16(REG_C0_CTRL) & 0x40) && C0_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x4;
IRQINFO |= 4;
irqCallbackSPU2();
}
if (spuaddr > 0xFFFFE) spuaddr = 0x2800;
if (spuaddr > 0xFFFFE)
spuaddr = 0x2800;
C0_SPUADDR_SET(spuaddr);
spu2Ru16(REG_C0_SPUSTAT) &= ~0x80;
@ -1032,13 +986,13 @@ EXPORT_C_(void) SPU2write(u32 mem, u16 value)
spuaddr = C1_SPUADDR;
spu2mem[spuaddr] = value;
spuaddr++;
if ((spu2Ru16(REG_C1_CTRL)&0x40) && C1_IRQA == spuaddr)
{
if ((spu2Ru16(REG_C1_CTRL) & 0x40) && C1_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x8;
IRQINFO |= 8;
irqCallbackSPU2();
}
if (spuaddr > 0xFFFFE) spuaddr = 0x2800;
if (spuaddr > 0xFFFFE)
spuaddr = 0x2800;
C1_SPUADDR_SET(spuaddr);
spu2Ru16(REG_C1_SPUSTAT) &= ~0x80;
@ -1114,7 +1068,8 @@ EXPORT_C_(void) SPU2write(u32 mem, u16 value)
assert(C1_SPUADDR < 0x100000);
}
EXPORT_C_(u16) SPU2read(u32 mem)
EXPORT_C_(u16)
SPU2read(u32 mem)
{
u32 spuaddr;
u16 ret;
@ -1131,8 +1086,7 @@ EXPORT_C_(u16) SPU2read(u32 mem)
VOICE_PROCESSED* pvoice = &voices[ch];
switch (r&0x0f)
{
switch (r & 0x0f) {
case 10:
return (u16)(pvoice->ADSRX.EnvelopeVol >> 16);
}
@ -1143,8 +1097,7 @@ EXPORT_C_(u16) SPU2read(u32 mem)
s32 ch = 0;
u32 rx = r;
if (rx >= 0x400)
{
if (rx >= 0x400) {
ch = 24;
rx -= 0x400;
}
@ -1153,8 +1106,7 @@ EXPORT_C_(u16) SPU2read(u32 mem)
rx -= (ch % 24) * 12;
VOICE_PROCESSED* pvoice = &voices[ch];
switch (rx)
{
switch (rx) {
case 0x1C0:
return (u16)(((pvoice->pStart - (u8*)spu2mem) >> 17) & 0x3F);
case 0x1C2:
@ -1170,13 +1122,13 @@ EXPORT_C_(u16) SPU2read(u32 mem)
}
}
switch (mem&0xffff)
{
switch (mem & 0xffff) {
case REG_C0_SPUDATA:
spuaddr = C0_SPUADDR;
ret = spu2mem[spuaddr];
spuaddr++;
if (spuaddr > 0xfffff) spuaddr = 0;
if (spuaddr > 0xfffff)
spuaddr = 0;
C0_SPUADDR_SET(spuaddr);
break;
@ -1184,7 +1136,8 @@ EXPORT_C_(u16) SPU2read(u32 mem)
spuaddr = C1_SPUADDR;
ret = spu2mem[spuaddr];
spuaddr++;
if (spuaddr > 0xfffff) spuaddr = 0;
if (spuaddr > 0xfffff)
spuaddr = 0;
C1_SPUADDR_SET(spuaddr);
break;
@ -1210,17 +1163,20 @@ EXPORT_C_(u16) SPU2read(u32 mem)
return ret;
}
EXPORT_C_(void) SPU2WriteMemAddr(int core, u32 value)
EXPORT_C_(void)
SPU2WriteMemAddr(int core, u32 value)
{
MemAddr[core] = value;
}
EXPORT_C_(u32) SPU2ReadMemAddr(int core)
EXPORT_C_(u32)
SPU2ReadMemAddr(int core)
{
return MemAddr[core];
}
EXPORT_C_(void) SPU2irqCallback(void (*SPU2callback)(), void (*DMA4callback)(), void (*DMA7callback)())
EXPORT_C_(void)
SPU2irqCallback(void (*SPU2callback)(), void (*DMA4callback)(), void (*DMA7callback)())
{
irqCallbackSPU2 = SPU2callback;
irqCallbackDMA4 = DMA4callback;
@ -1240,13 +1196,14 @@ void VOICE_PROCESSED::SetVolume(int iProcessRight)
if (vol & 0x8000) // sweep not working
{
s16 sInc = 1; // -> sweep up?
if (vol&0x2000) sInc = -1; // -> or down?
if (vol&0x1000) vol ^= 0xffff; // -> mmm... phase inverted? have to investigate this
if (vol & 0x2000)
sInc = -1; // -> or down?
if (vol & 0x1000)
vol ^= 0xffff; // -> mmm... phase inverted? have to investigate this
vol = ((vol & 0x7f) + 1) / 2; // -> sweep: 0..127 -> 0..64
vol += vol / (2 * sInc); // -> HACK: we don't sweep right now, so we just raise/lower the volume by the half!
vol *= 128;
}
else // no sweep:
} else // no sweep:
{
if (vol & 0x4000) // -> mmm... phase inverted? have to investigate this
vol = 0x3fff - (vol & 0x3fff);
@ -1264,8 +1221,7 @@ void VOICE_PROCESSED::StartSound()
ADSRX.State = 0;
ADSRX.EnvelopeVol = 0;
if (bReverb && GetCtrl()->reverb)
{
if (bReverb && GetCtrl()->reverb) {
// setup the reverb effects
}
@ -1291,7 +1247,8 @@ void VOICE_PROCESSED::Stop()
}
// GUI Routines
EXPORT_C_(s32) SPU2test()
EXPORT_C_(s32)
SPU2test()
{
return 0;
}
@ -1302,35 +1259,25 @@ typedef struct
u8 spu2regs[0x10000];
} SPU2freezeData;
EXPORT_C_(s32) SPU2freeze(int mode, freezeData *data)
EXPORT_C_(s32)
SPU2freeze(int mode, freezeData* data)
{
SPU2freezeData* spud;
if (mode == FREEZE_LOAD)
{
if (mode == FREEZE_LOAD) {
spud = (SPU2freezeData*)data->data;
if (spud->version == 0x11223344)
{
if (spud->version == 0x11223344) {
memcpy(spu2regs, spud->spu2regs, 0x10000);
}
else
{
} else {
printf("SPU2null wrong format\n");
}
}
else
if (mode == FREEZE_SAVE)
{
} else if (mode == FREEZE_SAVE) {
spud = (SPU2freezeData*)data->data;
spud->version = 0x11223344;
memcpy(spud->spu2regs, spu2regs, 0x10000);
}
else
if (mode == FREEZE_SIZE)
{
} else if (mode == FREEZE_SIZE) {
data->size = sizeof(SPU2freezeData);
}
return 0;
}

14
plugins/SPU2null/SPU2.h
View File

@ -24,8 +24,7 @@
#include <stdio.h>
#include <string.h>
extern "C"
{
extern "C" {
#define SPU2defs
#include "PS2Edefs.h"
}
@ -143,10 +142,11 @@ void SysMessage(char *fmt, ...);
#define IRQINFO spu2Ru16(REG_IRQINFO)
#define SPU2_GET32BIT(lo, hi) (((u32)(spu2Ru16(hi) & 0x3f) << 16) | (u32)spu2Ru16(lo))
#define SPU2_SET32BIT(value, lo, hi) { \
#define SPU2_SET32BIT(value, lo, hi) \
{ \
spu2Ru16(hi) = ((value) >> 16) & 0x3f; \
spu2Ru16(lo) = (value)&0xffff; \
} \
}
#define C0_IRQA SPU2_GET32BIT(REG_C0_IRQA_LO, REG_C0_IRQA_HI)
#define C1_IRQA SPU2_GET32BIT(REG_C1_IRQA_LO, REG_C1_IRQA_HI)
@ -178,12 +178,14 @@ struct _SPU_VOICE
{
union
{
struct {
struct
{
u16 Vol : 14;
u16 Inverted : 1;
u16 Sweep0 : 1;
} vol;
struct {
struct
{
u16 Vol : 7;
u16 res1 : 5;
u16 Inverted : 1;

15
plugins/SPU2null/Windows/Config.cpp
View File

@ -28,14 +28,15 @@ void SaveConfig()
GetModuleFileName(GetModuleHandle((LPCSTR)hInst), szIniFile, 256);
szTemp = strrchr(szIniFile, '\\');
if(!szTemp) return;
if (!szTemp)
return;
strcpy(szTemp, "\\inis\\spu2null.ini");
sprintf(szValue, "%u", Conf1->Log);
WritePrivateProfileString("Interface", "Logging", szValue, szIniFile);
}
void LoadConfig() {
void LoadConfig()
{
FILE* fp;
@ -46,11 +47,11 @@ void LoadConfig() {
GetModuleFileName(GetModuleHandle((LPCSTR)hInst), szIniFile, 256);
szTemp = strrchr(szIniFile, '\\');
if(!szTemp) return ;
if (!szTemp)
return;
strcpy(szTemp, "\\inis\\spu2null.ini");
fp = fopen("inis\\usbnull.ini", "rt"); //check if usbnull.ini really exists
if (!fp)
{
if (!fp) {
CreateDirectory("inis", NULL);
memset(&conf, 0, sizeof(conf));
conf.Log = 0; //default value
@ -61,6 +62,4 @@ void LoadConfig() {
GetPrivateProfileString("Interface", "Logging", NULL, szValue, 20, szIniFile);
Conf1->Log = strtoul(szValue, NULL, 10);
return;
}

26
plugins/SPU2null/Windows/Win32.cpp
View File

@ -22,7 +22,8 @@
HINSTANCE hInst;
void SysMessage(char *fmt, ...) {
void SysMessage(char* fmt, ...)
{
va_list list;
char tmp[512];
@ -32,12 +33,14 @@ void SysMessage(char *fmt, ...) {
MessageBox(0, tmp, "SPU2NULL Msg", 0);
}
BOOL CALLBACK ConfigureDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam) {
BOOL CALLBACK ConfigureDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg) {
case WM_INITDIALOG:
LoadConfig();
if (conf.Log) CheckDlgButton(hW, IDC_LOGGING, TRUE);
if (conf.Log)
CheckDlgButton(hW, IDC_LOGGING, TRUE);
return TRUE;
case WM_COMMAND:
@ -48,7 +51,8 @@ BOOL CALLBACK ConfigureDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam)
case IDOK:
if (IsDlgButtonChecked(hW, IDC_LOGGING))
conf.Log = 1;
else conf.Log = 0;
else
conf.Log = 0;
SaveConfig();
EndDialog(hW, FALSE);
return TRUE;
@ -57,7 +61,8 @@ BOOL CALLBACK ConfigureDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam)
return FALSE;
}
BOOL CALLBACK AboutDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam) {
BOOL CALLBACK AboutDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg) {
case WM_INITDIALOG:
return TRUE;
@ -72,15 +77,16 @@ BOOL CALLBACK AboutDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam) {
return FALSE;
}
void CALLBACK SPU2configure() {
void CALLBACK SPU2configure()
{
DialogBox(hInst,
MAKEINTRESOURCE(IDD_CONFIG),
GetActiveWindow(),
(DLGPROC)ConfigureDlgProc);
}
void CALLBACK SPU2about() {
void CALLBACK SPU2about()
{
DialogBox(hInst,
MAKEINTRESOURCE(IDD_ABOUT),
GetActiveWindow(),
@ -89,8 +95,8 @@ void CALLBACK SPU2about() {
BOOL APIENTRY DllMain(HANDLE hModule, // DLL INIT
DWORD dwReason,
LPVOID lpReserved) {
LPVOID lpReserved)
{
hInst = (HINSTANCE)hModule;
return TRUE; // very quick :)
}