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

1284 lines
38 KiB
C++
Raw Blame History

/* SPU2null
* Copyright (C) 2002-2005 SPU2null Team
*
* This program 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 2 of the License, or
* (at your option) any later version.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "SPU2.h"
#include <assert.h>
#include <stdlib.h>
#include <string>
using namespace std;
const u8 version = PS2E_SPU2_VERSION;
const u8 revision = 0;
const u8 build = 8; // increase that with each version
const u32 minor = 0; // increase that with each version
// ADSR constants
#define ATTACK_MS 494L
#define DECAYHALF_MS 286L
#define DECAY_MS 572L
#define SUSTAIN_MS 441L
#define RELEASE_MS 437L
#ifdef PCSX2_DEBUG
char *libraryName = "SPU2null (Debug)";
#else
char *libraryName = "SPU2null ";
#endif
string s_strIniPath = "inis/";
string s_strLogPath = "logs/";
FILE *spu2Log;
Config conf;
ADMA Adma4;
ADMA Adma7;
u32 MemAddr[2];
u32 g_nSpuInit = 0;
u16 interrupt = 0;
s8 *spu2regs = NULL;
u16 *spu2mem = NULL;
u16 *pSpuIrq[2] = {NULL};
u32 dwEndChannel2[2] = {0}; // keeps track of what channels have ended
u32 dwNoiseVal = 1; // global noise generator
s32 SPUCycles = 0, SPUWorkerCycles = 0;
s32 SPUStartCycle[2];
s32 SPUTargetCycle[2];
int ADMAS4Write();
int ADMAS7Write();
void InitADSR();
void (*irqCallbackSPU2)(); // func of main emu, called on spu irq
void (*irqCallbackDMA4)() = 0; // func of main emu, called on spu irq
void (*irqCallbackDMA7)() = 0; // func of main emu, called on spu irq
const s32 f[5][2] = {
{0, 0},
{60, 0},
{115, -52},
{98, -55},
{122, -60}};
u32 RateTable[160];
// channels and voices
VOICE_PROCESSED voices[SPU_NUMBER_VOICES + 1]; // +1 for modulation
EXPORT_C_(u32)
PS2EgetLibType()
{
return PS2E_LT_SPU2;
}
EXPORT_C_(char *)
PS2EgetLibName()
{
return libraryName;
}
EXPORT_C_(u32)
PS2EgetLibVersion2(u32 type)
{
return (version << 16) | (revision << 8) | build | (minor << 24);
}
void __Log(char *fmt, ...)
{
va_list list;
if (!conf.Log || spu2Log == NULL)
return;
va_start(list, fmt);
vfprintf(spu2Log, fmt, list);
va_end(list);
}
EXPORT_C_(void)
SPU2setSettingsDir(const char *dir)
{
s_strIniPath = (dir == NULL) ? "inis/" : dir;
}
bool OpenLog()
{
bool result = true;
#ifdef SPU2_LOG
if (spu2Log)
return result;
const std::string LogFile(s_strLogPath + "/spu2null.log");
spu2Log = fopen(LogFile.c_str(), "w");
if (spu2Log != NULL)
setvbuf(spu2Log, NULL, _IONBF, 0);
else {
SysMessage("Can't create log file %s\n", LogFile.c_str());
result = false;
}
SPU2_LOG("Spu2 null version %d,%d\n", revision, build);
SPU2_LOG("SPU2init\n");
#endif
return result;
}
EXPORT_C_(void)
SPU2setLogDir(const char *dir)
{
// Get the path to the log directory.
s_strLogPath = (dir == NULL) ? "logs/" : dir;
// Reload the log file after updated the path
if (spu2Log) {
fclose(spu2Log);
spu2Log = NULL;
}
OpenLog();
}
EXPORT_C_(s32)
SPU2init()
{
OpenLog();
spu2regs = (s8 *)malloc(0x10000);
if (spu2regs == NULL) {
SysMessage("Error allocating Memory\n");
return -1;
}
memset(spu2regs, 0, 0x10000);
spu2mem = (u16 *)malloc(0x200000); // 2Mb
if (spu2mem == NULL) {
SysMessage("Error allocating Memory\n");
return -1;
}
memset(spu2mem, 0, 0x200000);
memset(dwEndChannel2, 0, sizeof(dwEndChannel2));
InitADSR();
memset(voices, 0, sizeof(voices));
// last 24 channels have higher mem offset
for (int i = 0; i < 24; ++i)
voices[i + 24].memoffset = 0x400;
// init each channel
for (u32 i = 0; i < ArraySize(voices); ++i) {
voices[i].pLoop = voices[i].pStart = voices[i].pCurr = (u8 *)spu2mem;
voices[i].pvoice = (_SPU_VOICE *)((u8 *)spu2regs + voices[i].memoffset) + (i % 24);
voices[i].ADSRX.SustainLevel = 1024; // -> init sustain
}
return 0;
}
EXPORT_C_(s32)
SPU2open(void *pDsp)
{
LoadConfig();
SPUCycles = SPUWorkerCycles = 0;
interrupt = 0;
SPUStartCycle[0] = SPUStartCycle[1] = 0;
SPUTargetCycle[0] = SPUTargetCycle[1] = 0;
g_nSpuInit = 1;
return 0;
}
EXPORT_C_(void)
SPU2close()
{
g_nSpuInit = 0;
}
EXPORT_C_(void)
SPU2shutdown()
{
free(spu2regs);
spu2regs = NULL;
free(spu2mem);
spu2mem = NULL;
#ifdef SPU2_LOG
if (spu2Log) {
fclose(spu2Log);
spu2Log = NULL;
}
#endif
}
// simulate SPU2 for 1ms
void SPU2Worker();
#define CYCLES_PER_MS (36864000 / 1000)
EXPORT_C_(void)
SPU2async(u32 cycle)
{
SPUCycles += cycle;
if (interrupt & (1 << 2)) {
if (SPUCycles - SPUStartCycle[1] >= SPUTargetCycle[1]) {
interrupt &= ~(1 << 2);
irqCallbackDMA7();
}
}
if (interrupt & (1 << 1)) {
if (SPUCycles - SPUStartCycle[0] >= SPUTargetCycle[0]) {
interrupt &= ~(1 << 1);
irqCallbackDMA4();
}
}
if (g_nSpuInit) {
while (SPUCycles - SPUWorkerCycles > 0 && CYCLES_PER_MS < SPUCycles - SPUWorkerCycles) {
SPU2Worker();
SPUWorkerCycles += CYCLES_PER_MS;
}
}
}
void InitADSR() // INIT ADSR
{
u32 r, rs, rd;
s32 i;
memset(RateTable, 0, sizeof(u32) * 160); // build the rate table according to Neill's rules (see at bottom of file)
r = 3;
rs = 1;
rd = 0;
for (i = 32; i < 160; i++) // we start at pos 32 with the real values... everything before is 0
{
if (r < 0x3FFFFFFF) {
r += rs;
rd++;
if (rd == 5) {
rd = 1;
rs *= 2;
}
}
if (r > 0x3FFFFFFF)
r = 0x3FFFFFFF;
RateTable[i] = r;
}
}
int MixADSR(VOICE_PROCESSED *pvoice) // MIX ADSR
{
if (pvoice->bStop) // should be stopped:
{
if (pvoice->bIgnoreLoop == 0) {
pvoice->ADSRX.EnvelopeVol = 0;
pvoice->bOn = false;
pvoice->pStart = (u8 *)(spu2mem + pvoice->iStartAddr);
pvoice->pLoop = (u8 *)(spu2mem + pvoice->iStartAddr);
pvoice->pCurr = (u8 *)(spu2mem + pvoice->iStartAddr);
pvoice->bStop = true;
pvoice->bIgnoreLoop = false;
return 0;
}
if (pvoice->ADSRX.ReleaseModeExp) // do release
{
switch ((pvoice->ADSRX.EnvelopeVol >> 28) & 0x7) {
case 0:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x18 + 0 + 32];
break;
case 1:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x18 + 4 + 32];
break;
case 2:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x18 + 6 + 32];
break;
case 3:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x18 + 8 + 32];
break;
case 4:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x18 + 9 + 32];
break;
case 5:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x18 + 10 + 32];
break;
case 6:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x18 + 11 + 32];
break;
case 7:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x18 + 12 + 32];
break;
}
} else {
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.ReleaseRate ^ 0x1F)) - 0x0C + 32];
}
if (pvoice->ADSRX.EnvelopeVol < 0) {
pvoice->ADSRX.EnvelopeVol = 0;
pvoice->bOn = false;
pvoice->pStart = (u8 *)(spu2mem + pvoice->iStartAddr);
pvoice->pLoop = (u8 *)(spu2mem + pvoice->iStartAddr);
pvoice->pCurr = (u8 *)(spu2mem + pvoice->iStartAddr);
pvoice->bStop = true;
pvoice->bIgnoreLoop = false;
//pvoice->bReverb=0;
//pvoice->bNoise=0;
}
pvoice->ADSRX.lVolume = pvoice->ADSRX.EnvelopeVol >> 21;
pvoice->ADSRX.lVolume = pvoice->ADSRX.EnvelopeVol >> 21;
return pvoice->ADSRX.lVolume;
} else // not stopped yet?
{
if (pvoice->ADSRX.State == 0) // -> attack
{
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 {
pvoice->ADSRX.EnvelopeVol += RateTable[(pvoice->ADSRX.AttackRate ^ 0x7F) - 0x10 + 32];
}
if (pvoice->ADSRX.EnvelopeVol < 0) {
pvoice->ADSRX.EnvelopeVol = 0x7FFFFFFF;
pvoice->ADSRX.State = 1;
}
pvoice->ADSRX.lVolume = pvoice->ADSRX.EnvelopeVol >> 21;
return pvoice->ADSRX.lVolume;
}
//--------------------------------------------------//
if (pvoice->ADSRX.State == 1) // -> decay
{
switch ((pvoice->ADSRX.EnvelopeVol >> 28) & 0x7) {
case 0:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.DecayRate ^ 0x1F)) - 0x18 + 0 + 32];
break;
case 1:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.DecayRate ^ 0x1F)) - 0x18 + 4 + 32];
break;
case 2:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.DecayRate ^ 0x1F)) - 0x18 + 6 + 32];
break;
case 3:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.DecayRate ^ 0x1F)) - 0x18 + 8 + 32];
break;
case 4:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.DecayRate ^ 0x1F)) - 0x18 + 9 + 32];
break;
case 5:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.DecayRate ^ 0x1F)) - 0x18 + 10 + 32];
break;
case 6:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.DecayRate ^ 0x1F)) - 0x18 + 11 + 32];
break;
case 7:
pvoice->ADSRX.EnvelopeVol -= RateTable[(4 * (pvoice->ADSRX.DecayRate ^ 0x1F)) - 0x18 + 12 + 32];
break;
}
if (pvoice->ADSRX.EnvelopeVol < 0)
pvoice->ADSRX.EnvelopeVol = 0;
if (((pvoice->ADSRX.EnvelopeVol >> 27) & 0xF) <= pvoice->ADSRX.SustainLevel) {
pvoice->ADSRX.State = 2;
}
pvoice->ADSRX.lVolume = pvoice->ADSRX.EnvelopeVol >> 21;
return pvoice->ADSRX.lVolume;
}
//--------------------------------------------------//
if (pvoice->ADSRX.State == 2) // -> sustain
{
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 {
pvoice->ADSRX.EnvelopeVol += RateTable[(pvoice->ADSRX.SustainRate ^ 0x7F) - 0x10 + 32];
}
if (pvoice->ADSRX.EnvelopeVol < 0) {
pvoice->ADSRX.EnvelopeVol = 0x7FFFFFFF;
}
} 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;
case 1:
pvoice->ADSRX.EnvelopeVol -= RateTable[((pvoice->ADSRX.SustainRate ^ 0x7F)) - 0x1B + 4 + 32];
break;
case 2:
pvoice->ADSRX.EnvelopeVol -= RateTable[((pvoice->ADSRX.SustainRate ^ 0x7F)) - 0x1B + 6 + 32];
break;
case 3:
pvoice->ADSRX.EnvelopeVol -= RateTable[((pvoice->ADSRX.SustainRate ^ 0x7F)) - 0x1B + 8 + 32];
break;
case 4:
pvoice->ADSRX.EnvelopeVol -= RateTable[((pvoice->ADSRX.SustainRate ^ 0x7F)) - 0x1B + 9 + 32];
break;
case 5:
pvoice->ADSRX.EnvelopeVol -= RateTable[((pvoice->ADSRX.SustainRate ^ 0x7F)) - 0x1B + 10 + 32];
break;
case 6:
pvoice->ADSRX.EnvelopeVol -= RateTable[((pvoice->ADSRX.SustainRate ^ 0x7F)) - 0x1B + 11 + 32];
break;
case 7:
pvoice->ADSRX.EnvelopeVol -= RateTable[((pvoice->ADSRX.SustainRate ^ 0x7F)) - 0x1B + 12 + 32];
break;
}
} else {
pvoice->ADSRX.EnvelopeVol -= RateTable[((pvoice->ADSRX.SustainRate ^ 0x7F)) - 0x0F + 32];
}
if (pvoice->ADSRX.EnvelopeVol < 0) {
pvoice->ADSRX.EnvelopeVol = 0;
}
}
pvoice->ADSRX.lVolume = pvoice->ADSRX.EnvelopeVol >> 21;
return pvoice->ADSRX.lVolume;
}
}
return 0;
}
// simulate SPU2 for 1ms
void SPU2Worker()
{
u8 *start;
int ch, flags;
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) {
pChannel->StartSound(); // start new sound
dwEndChannel2[ch / 24] &= ~(1 << (ch % 24)); // clear end channel bit
}
if (!pChannel->bOn) {
// fill buffer with empty data
continue;
}
if (pChannel->iActFreq != pChannel->iUsedFreq) // new psx frequency?
pChannel->VoiceChangeFrequency();
// loop until 1 ms of data is reached
int ns = 0;
while (ns < NSSIZE) {
while (pChannel->spos >= 0x10000) {
if (pChannel->iSBPos == 28) // 28 reached?
{
start = pChannel->pCurr; // set up the current pos
// special "stop" sign
if (start == (u8 *)-1) //!pChannel->bOn
{
pChannel->bOn = false; // -> turn everything off
pChannel->ADSRX.lVolume = 0;
pChannel->ADSRX.EnvelopeVol = 0;
goto ENDX; // -> and done for this channel
}
pChannel->iSBPos = 0;
// decode the 16 byte packet
flags = (int)start[1];
start += 16;
// some callback and irq active?
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))) {
IRQINFO |= 4 << (int)(ch >= 24);
irqCallbackSPU2();
}
}
// flag handler
if ((flags & 4) && (!pChannel->bIgnoreLoop))
pChannel->pLoop = start - 16; // loop adress
if (flags & 1) // 1: stop/loop
{
// We play this block out first...
dwEndChannel2[ch / 24] |= (1 << (ch % 24));
//if(!(flags&2)) // 1+2: do loop... otherwise: stop
if (flags != 3 || pChannel->pLoop == NULL) // PETE: if we don't check exactly for 3, loop hang ups will happen (DQ4, for example)
{ // and checking if pLoop is set avoids crashes, yeah
start = (u8 *)-1;
pChannel->bStop = true;
pChannel->bIgnoreLoop = false;
} else {
start = pChannel->pLoop;
}
}
pChannel->pCurr = start; // store values for next cycle
}
pChannel->iSBPos++; // get sample data
pChannel->spos -= 0x10000;
}
MixADSR(pChannel);
// go to the next packet
ns++;
pChannel->spos += pChannel->sinc;
}
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++) {
Adma4.Index += 1;
if (Adma4.Index == 128 || Adma4.Index == 384) {
if (ADMAS4Write()) {
spu2Ru16(REG_C0_SPUSTAT) &= ~0x80;
irqCallbackDMA4();
} else
MemAddr[0] += 1024;
}
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++) {
Adma7.Index += 1;
if (Adma7.Index == 128 || Adma7.Index == 384) {
if (ADMAS7Write()) {
spu2Ru16(REG_C1_SPUSTAT) &= ~0x80;
irqCallbackDMA7();
} else
MemAddr[1] += 1024;
}
if (Adma7.Index == 512)
Adma7.Index = 0;
}
}
}
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++) {
*pMem++ = *(u16 *)(spu2mem + spuaddr);
if ((spu2Rs16(REG_C0_CTRL) & 0x40) && C0_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x4;
C0_SPUADDR_SET(spuaddr);
IRQINFO |= 4;
irqCallbackSPU2();
}
spuaddr++; // inc spu addr
if (spuaddr > 0x0fffff) // wrap at 2Mb
spuaddr = 0; // wrap
}
spuaddr += 19; //Transfer Local To Host TSAH/L + Data Size + 20 (already +1'd)
C0_SPUADDR_SET(spuaddr);
// got from J.F. and Kanodin... is it needed?
spu2Ru16(REG_C0_SPUSTAT) &= ~0x80; // DMA complete
SPUStartCycle[0] = SPUCycles;
SPUTargetCycle[0] = size;
interrupt |= (1 << 1);
}
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++) {
*pMem++ = *(u16 *)(spu2mem + spuaddr);
if ((spu2Rs16(REG_C1_CTRL) & 0x40) && C1_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x8;
C1_SPUADDR_SET(spuaddr);
IRQINFO |= 8;
irqCallbackSPU2();
}
spuaddr++; // inc spu addr
if (spuaddr > 0x0fffff) // wrap at 2Mb
spuaddr = 0; // wrap
}
spuaddr += 19; //Transfer Local To Host TSAH/L + Data Size + 20 (already +1'd)
C1_SPUADDR_SET(spuaddr);
// got from J.F. and Kanodin... is it needed?
spu2Ru16(REG_C1_SPUSTAT) &= ~0x80; // DMA complete
SPUStartCycle[1] = SPUCycles;
SPUTargetCycle[1] = size;
interrupt |= (1 << 2);
}
// WRITE
// AutoDMA's are used to transfer to the DIRECT INPUT area of the spu2 memory
// Left and Right channels are always interleaved together in the transfer so
// the AutoDMA's deinterleaves them and transfers them. An interrupt is
// generated when half of the buffer (256 short-words for left and 256
// short-words for right ) has been transferred. Another interrupt occurs at
// the end of the transfer.
int ADMAS4Write()
{
u32 spuaddr;
if (interrupt & 0x2)
return 0;
if (Adma4.AmountLeft <= 0)
return 1;
spuaddr = C0_SPUADDR;
// SPU2 Deinterleaves the Left and Right Channels
memcpy((s16 *)(spu2mem + spuaddr + 0x2000), (s16 *)Adma4.MemAddr, 512);
Adma4.MemAddr += 256;
memcpy((s16 *)(spu2mem + spuaddr + 0x2200), (s16 *)Adma4.MemAddr, 512);
Adma4.MemAddr += 256;
spuaddr = (spuaddr + 256) & 511;
C0_SPUADDR_SET(spuaddr);
Adma4.AmountLeft -= 512;
if (Adma4.AmountLeft == 0) {
SPUStartCycle[0] = SPUCycles;
SPUTargetCycle[0] = 1; //512*48000;
spu2Ru16(REG_C0_SPUSTAT) &= ~0x80;
interrupt |= (1 << 1);
}
return 0;
}
int ADMAS7Write()
{
u32 spuaddr;
if (interrupt & 0x4)
return 0;
if (Adma7.AmountLeft <= 0)
return 1;
spuaddr = C1_SPUADDR;
// SPU2 Deinterleaves the Left and Right Channels
memcpy((s16 *)(spu2mem + spuaddr + 0x2400), (s16 *)Adma7.MemAddr, 512);
Adma7.MemAddr += 256;
memcpy((s16 *)(spu2mem + spuaddr + 0x2600), (s16 *)Adma7.MemAddr, 512);
Adma7.MemAddr += 256;
spuaddr = (spuaddr + 256) & 511;
C1_SPUADDR_SET(spuaddr);
Adma7.AmountLeft -= 512;
if (Adma7.AmountLeft == 0) {
SPUStartCycle[1] = SPUCycles;
SPUTargetCycle[1] = 1; //512*48000;
spu2Ru16(REG_C1_SPUSTAT) &= ~0x80;
interrupt |= (1 << 2);
}
return 0;
}
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) {
//fwrite(pMem,iSize<<1,1,LogFile);
memset(&Adma4, 0, sizeof(ADMA));
C0_SPUADDR_SET(0);
Adma4.MemAddr = pMem;
Adma4.AmountLeft = size;
ADMAS4Write();
return;
}
spuaddr = C0_SPUADDR;
memcpy((u8 *)(spu2mem + spuaddr), (u8 *)pMem, size << 1);
spuaddr += size;
C0_SPUADDR_SET(spuaddr);
if ((spu2Ru16(REG_C0_CTRL) & 0x40) && C0_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x4;
IRQINFO |= 4;
irqCallbackSPU2();
}
if (spuaddr > 0xFFFFE)
spuaddr = 0x2800;
C0_SPUADDR_SET(spuaddr);
MemAddr[0] += size << 1;
spu2Ru16(REG_C0_SPUSTAT) &= ~0x80;
SPUStartCycle[0] = SPUCycles;
SPUTargetCycle[0] = 1; //iSize;
interrupt |= (1 << 1);
}
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) {
//fwrite(pMem,iSize<<1,1,LogFile);
memset(&Adma7, 0, sizeof(ADMA));
C1_SPUADDR_SET(0);
Adma7.MemAddr = pMem;
Adma7.AmountLeft = size;
ADMAS7Write();
return;
}
spuaddr = C1_SPUADDR;
memcpy((u8 *)(spu2mem + spuaddr), (u8 *)pMem, size << 1);
spuaddr += size;
C1_SPUADDR_SET(spuaddr);
if ((spu2Ru16(REG_C1_CTRL) & 0x40) && C1_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x8;
IRQINFO |= 8;
irqCallbackSPU2();
}
if (spuaddr > 0xFFFFE)
spuaddr = 0x2800;
C1_SPUADDR_SET(spuaddr);
MemAddr[1] += size << 1;
spu2Ru16(REG_C1_SPUSTAT) &= ~0x80;
SPUStartCycle[1] = SPUCycles;
SPUTargetCycle[1] = 1; //iSize;
interrupt |= (1 << 2);
}
EXPORT_C_(void)
SPU2interruptDMA4()
{
SPU2_LOG("SPU2 interruptDMA4\n");
spu2Rs16(REG_C0_CTRL) &= ~0x30;
spu2Ru16(REG_C0_SPUSTAT) |= 0x80;
}
EXPORT_C_(void)
SPU2interruptDMA7()
{
SPU2_LOG("SPU2 interruptDMA7\n");
// spu2Rs16(REG_C1_CTRL)&= ~0x30;
// //spu2Rs16(REG__5B0) = 0;
// spu2Rs16(SPU2_STATX_DREQ)|= 0x80;
spu2Rs16(REG_C1_CTRL) &= ~0x30;
spu2Ru16(REG_C1_SPUSTAT) |= 0x80;
}
// turn channels on
void SoundOn(s32 start, s32 end, u16 val) // SOUND ON PSX COMAND
{
for (s32 ch = start; ch < end; ch++, val >>= 1) // loop channels
{
if ((val & 1) && voices[ch].pStart) // mmm... start has to be set before key on !?!
{
voices[ch].bNew = true;
voices[ch].bIgnoreLoop = false;
}
}
}
// turn channels off
void SoundOff(s32 start, s32 end, u16 val) // SOUND OFF PSX COMMAND
{
for (s32 ch = start; ch < end; ch++, val >>= 1) // loop channels
{
if (val & 1) // && s_chan[i].bOn) mmm...
voices[ch].bStop = true;
}
}
void FModOn(s32 start, s32 end, u16 val) // FMOD ON PSX COMMAND
{
int ch;
for (ch = start; ch < end; ch++, val >>= 1) // loop channels
{
if (val & 1) // -> fmod on/off
{
if (ch > 0) {
}
} else {
// turn fmod off
}
}
}
EXPORT_C_(void)
SPU2write(u32 mem, u16 value)
{
u32 spuaddr;
SPU2_LOG("SPU2 write mem %x value %x\n", mem, value);
assert(C0_SPUADDR < 0x100000);
assert(C1_SPUADDR < 0x100000);
spu2Ru16(mem) = value;
u32 r = mem & 0xffff;
// channel info
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);
VOICE_PROCESSED *pvoice = &voices[ch];
switch (r & 0x0f) {
case 0:
case 2:
pvoice->SetVolume(mem & 0x2);
break;
case 4: {
int NP;
if (value > 0x3fff)
NP = 0x3fff; // get pitch val
else
NP = value;
pvoice->pvoice->pitch = NP;
NP = (44100L * NP) / 4096L; // calc frequency
if (NP < 1)
NP = 1; // some security
pvoice->iActFreq = NP; // store frequency
break;
}
case 6: {
pvoice->ADSRX.AttackModeExp = (value & 0x8000) ? 1 : 0;
pvoice->ADSRX.AttackRate = ((value >> 8) & 0x007f);
pvoice->ADSRX.DecayRate = (((value >> 4) & 0x000f));
pvoice->ADSRX.SustainLevel = (value & 0x000f);
break;
}
case 8:
pvoice->ADSRX.SustainModeExp = (value & 0x8000) ? 1 : 0;
pvoice->ADSRX.SustainIncrease = (value & 0x4000) ? 0 : 1;
pvoice->ADSRX.SustainRate = ((value >> 6) & 0x007f);
pvoice->ADSRX.ReleaseModeExp = (value & 0x0020) ? 1 : 0;
pvoice->ADSRX.ReleaseRate = ((value & 0x001f));
break;
}
return;
}
// more channel info
if ((r >= 0x01c0 && r <= 0x02E0) || (r >= 0x05c0 && r <= 0x06E0)) {
s32 ch = 0;
u32 rx = r;
if (rx >= 0x400) {
ch = 24;
rx -= 0x400;
}
ch += ((rx - 0x1c0) / 12);
rx -= (ch % 24) * 12;
VOICE_PROCESSED *pvoice = &voices[ch];
switch (rx) {
case 0x1C0:
pvoice->iStartAddr = (((u32)value & 0x3f) << 16) | (pvoice->iStartAddr & 0xFFFF);
pvoice->pStart = (u8 *)(spu2mem + pvoice->iStartAddr);
break;
case 0x1C2:
pvoice->iStartAddr = (pvoice->iStartAddr & 0x3f0000) | (value & 0xFFFF);
pvoice->pStart = (u8 *)(spu2mem + pvoice->iStartAddr);
break;
case 0x1C4:
pvoice->iLoopAddr = (((u32)value & 0x3f) << 16) | (pvoice->iLoopAddr & 0xFFFF);
pvoice->pLoop = (u8 *)(spu2mem + pvoice->iLoopAddr);
pvoice->bIgnoreLoop = pvoice->iLoopAddr > 0;
break;
case 0x1C6:
pvoice->iLoopAddr = (pvoice->iLoopAddr & 0x3f0000) | (value & 0xFFFF);
pvoice->pLoop = (u8 *)(spu2mem + pvoice->iLoopAddr);
pvoice->bIgnoreLoop = pvoice->iLoopAddr > 0;
break;
case 0x1C8:
// unused... check if it gets written as well
pvoice->iNextAddr = (((u32)value & 0x3f) << 16) | (pvoice->iNextAddr & 0xFFFF);
break;
case 0x1CA:
// unused... check if it gets written as well
pvoice->iNextAddr = (pvoice->iNextAddr & 0x3f0000) | (value & 0xFFFF);
break;
}
return;
}
// process non-channel data
switch (mem & 0xffff) {
case REG_C0_SPUDATA:
spuaddr = C0_SPUADDR;
spu2mem[spuaddr] = value;
spuaddr++;
if ((spu2Ru16(REG_C0_CTRL) & 0x40) && C0_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x4;
IRQINFO |= 4;
irqCallbackSPU2();
}
if (spuaddr > 0xFFFFE)
spuaddr = 0x2800;
C0_SPUADDR_SET(spuaddr);
spu2Ru16(REG_C0_SPUSTAT) &= ~0x80;
spu2Ru16(REG_C0_CTRL) &= ~0x30;
break;
case REG_C1_SPUDATA:
spuaddr = C1_SPUADDR;
spu2mem[spuaddr] = value;
spuaddr++;
if ((spu2Ru16(REG_C1_CTRL) & 0x40) && C1_IRQA == spuaddr) {
spu2Ru16(SPDIF_OUT) |= 0x8;
IRQINFO |= 8;
irqCallbackSPU2();
}
if (spuaddr > 0xFFFFE)
spuaddr = 0x2800;
C1_SPUADDR_SET(spuaddr);
spu2Ru16(REG_C1_SPUSTAT) &= ~0x80;
spu2Ru16(REG_C1_CTRL) &= ~0x30;
break;
case REG_C0_IRQA_HI:
case REG_C0_IRQA_LO:
pSpuIrq[0] = spu2mem + (C0_IRQA << 1);
break;
case REG_C1_IRQA_HI:
case REG_C1_IRQA_LO:
pSpuIrq[1] = spu2mem + (C1_IRQA << 1);
break;
case REG_C0_SPUADDR_HI:
case REG_C1_SPUADDR_HI:
spu2Ru16(mem) = value & 0xf;
break;
case REG_C0_SPUON1:
SoundOn(0, 16, value);
break;
case REG_C0_SPUON2:
SoundOn(16, 24, value);
break;
case REG_C1_SPUON1:
SoundOn(24, 40, value);
break;
case REG_C1_SPUON2:
SoundOn(40, 48, value);
break;
case REG_C0_SPUOFF1:
SoundOff(0, 16, value);
break;
case REG_C0_SPUOFF2:
SoundOff(16, 24, value);
break;
case REG_C1_SPUOFF1:
SoundOff(24, 40, value);
break;
case REG_C1_SPUOFF2:
SoundOff(40, 48, value);
break;
// According to manual all bits are cleared by writing an arbitary value
case REG_C0_END1:
dwEndChannel2[0] = 0;
break;
case REG_C0_END2:
dwEndChannel2[0] = 0;
break;
case REG_C1_END1:
dwEndChannel2[1] = 0;
break;
case REG_C1_END2:
dwEndChannel2[1] = 0;
break;
case REG_C0_FMOD1:
FModOn(0, 16, value);
break;
case REG_C0_FMOD2:
FModOn(16, 24, value);
break;
case REG_C1_FMOD1:
FModOn(24, 40, value);
break;
case REG_C1_FMOD2:
FModOn(40, 48, value);
break;
}
assert(C0_SPUADDR < 0x100000);
assert(C1_SPUADDR < 0x100000);
}
EXPORT_C_(u16)
SPU2read(u32 mem)
{
u32 spuaddr;
u16 ret;
u32 r = mem & 0xffff;
if ((r >= 0x0000 && r <= 0x0180) || (r >= 0x0400 && r <= 0x0580)) // some channel info?
{
s32 ch = 0;
if (r >= 0x400)
ch = ((r - 0x400) >> 4) + 24;
else
ch = (r >> 4);
VOICE_PROCESSED *pvoice = &voices[ch];
switch (r & 0x0f) {
case 10:
return (u16)(pvoice->ADSRX.EnvelopeVol >> 16);
}
}
if ((r > 0x01c0 && r <= 0x02E0) || (r > 0x05c0 && r <= 0x06E0)) // some channel info?
{
s32 ch = 0;
u32 rx = r;
if (rx >= 0x400) {
ch = 24;
rx -= 0x400;
}
ch += ((rx - 0x1c0) / 12);
rx -= (ch % 24) * 12;
VOICE_PROCESSED *pvoice = &voices[ch];
switch (rx) {
case 0x1C0:
return (u16)(((pvoice->pStart - (u8 *)spu2mem) >> 17) & 0x3F);
case 0x1C2:
return (u16)(((pvoice->pStart - (u8 *)spu2mem) >> 1) & 0xFFFF);
case 0x1C4:
return (u16)(((pvoice->pLoop - (u8 *)spu2mem) >> 17) & 0x3F);
case 0x1C6:
return (u16)(((pvoice->pLoop - (u8 *)spu2mem) >> 1) & 0xFFFF);
case 0x1C8:
return (u16)(((pvoice->pCurr - (u8 *)spu2mem) >> 17) & 0x3F);
case 0x1CA:
return (u16)(((pvoice->pCurr - (u8 *)spu2mem) >> 1) & 0xFFFF);
}
}
switch (mem & 0xffff) {
case REG_C0_SPUDATA:
spuaddr = C0_SPUADDR;
ret = spu2mem[spuaddr];
spuaddr++;
if (spuaddr > 0xfffff)
spuaddr = 0;
C0_SPUADDR_SET(spuaddr);
break;
case REG_C1_SPUDATA:
spuaddr = C1_SPUADDR;
ret = spu2mem[spuaddr];
spuaddr++;
if (spuaddr > 0xfffff)
spuaddr = 0;
C1_SPUADDR_SET(spuaddr);
break;
case REG_C0_END1:
return (dwEndChannel2[0] & 0xffff);
case REG_C0_END2:
return (dwEndChannel2[0] >> 16);
case REG_C1_END1:
return (dwEndChannel2[1] & 0xffff);
case REG_C1_END2:
return (dwEndChannel2[1] >> 16);
case REG_IRQINFO:
ret = IRQINFO;
IRQINFO = 0;
break;
default:
ret = spu2Ru16(mem);
}
SPU2_LOG("SPU2 read mem %x: %x\n", mem, ret);
return ret;
}
EXPORT_C_(void)
SPU2WriteMemAddr(int core, u32 value)
{
MemAddr[core] = value;
}
EXPORT_C_(u32)
SPU2ReadMemAddr(int core)
{
return MemAddr[core];
}
EXPORT_C_(void)
SPU2irqCallback(void (*SPU2callback)(), void (*DMA4callback)(), void (*DMA7callback)())
{
irqCallbackSPU2 = SPU2callback;
irqCallbackDMA4 = DMA4callback;
irqCallbackDMA7 = DMA7callback;
}
// VOICE_PROCESSED definitions
SPU_CONTROL_ *VOICE_PROCESSED::GetCtrl()
{
return ((SPU_CONTROL_ *)(spu2regs + memoffset + REG_C0_CTRL));
}
void VOICE_PROCESSED::SetVolume(int iProcessRight)
{
u16 vol = iProcessRight ? pvoice->right.word : pvoice->left.word;
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
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:
{
if (vol & 0x4000) // -> mmm... phase inverted? have to investigate this
vol = 0x3fff - (vol & 0x3fff);
}
vol &= 0x3fff;
// set volume
//if( iProcessRight ) right = vol;
//else left = vol;
}
void VOICE_PROCESSED::StartSound()
{
ADSRX.lVolume = 1; // and init some adsr vars
ADSRX.State = 0;
ADSRX.EnvelopeVol = 0;
if (bReverb && GetCtrl()->reverb) {
// setup the reverb effects
}
pCurr = pStart; // set sample start
iSBPos = 28;
bNew = false; // init channel flags
bStop = false;
bOn = true;
spos = 0x10000L;
}
void VOICE_PROCESSED::VoiceChangeFrequency()
{
iUsedFreq = iActFreq; // -> take it and calc steps
sinc = (u32)pvoice->pitch << 4;
if (!sinc)
sinc = 1;
}
void VOICE_PROCESSED::Stop()
{
}
// GUI Routines
EXPORT_C_(s32)
SPU2test()
{
return 0;
}
typedef struct
{
u32 version;
u8 spu2regs[0x10000];
} SPU2freezeData;
EXPORT_C_(s32)
SPU2freeze(int mode, freezeData *data)
{
SPU2freezeData *spud;
if (mode == FREEZE_LOAD) {
spud = (SPU2freezeData *)data->data;
if (spud->version == 0x11223344) {
memcpy(spu2regs, spud->spu2regs, 0x10000);
} else {
printf("SPU2null wrong format\n");
}
} else if (mode == FREEZE_SAVE) {
spud = (SPU2freezeData *)data->data;
spud->version = 0x11223344;
memcpy(spud->spu2regs, spu2regs, 0x10000);
} else if (mode == FREEZE_SIZE) {
data->size = sizeof(SPU2freezeData);
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink