/* ZeroSPU2
* Copyright (C) 2006-2010 zerofrog
*
* 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 "zerospu2.h"
#include "zeroworker.h"
#include "soundtouch/SoundTouch.h"
#ifdef __linux__
#include "WavFile.h"
#else
#include "soundtouch/WavFile.h"
#endif
s32 g_logsound = 0;
WavOutFile* g_pWavRecord=NULL; // used for recording
const s32 f[5][2] = {
{ 0, 0 },
{ 60, 0 },
{ 115, -52 },
{ 98, -55 },
{ 122, -60 } };
s32 predict_nr, shift_factor, flags;
s32 s_1, s_2;
static __forceinline s32 SetPacket(s32 val)
{
s32 ret;
if (val & 0x8000) val |= 0xffff0000;
ret = (val >> shift_factor);
ret += ((s_1 * f[predict_nr][0]) >> 6) + ((s_2 * f[predict_nr][1]) >> 6);
s_2 = s_1;
s_1 = ret;
return ret;
}
void SPU2Loop(VOICE_PROCESSED* pChannel, u32 ch)
{
u8* start;
u32 nSample;
for (u32 ns = 0; ns < NSSIZE; ns++)
{
// fmod freq channel
if (pChannel->bFMod == 1 && iFMod[ns]) pChannel->FModChangeFrequency(ns);
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;
return; // -> and done for this channel
}
predict_nr = (s32)start[0];
shift_factor = predict_nr&0xf;
predict_nr >>= 4;
flags=(s32)start[1];
start += 2;
pChannel->iSBPos = 0;
// decode the 16byte packet
s_1 = pChannel->s_1;
s_2 = pChannel->s_2;
for (nSample=0; nSample<28; ++start)
{
s32 d = (s32)*start;
s32 s;
s = ((d & 0xf)<<12);
pChannel->SB[nSample++] = SetPacket(s);
s = ((d & 0xf0) << 8);
pChannel->SB[nSample++] = SetPacket(s);
}
// irq occurs no matter what core accesses the address
for (s32 core = 0; core < 2; ++core)
{
if (spu2attr(core).irq) // some callback and irq active?
{
// if irq address reached or irq on looping addr, when stop/loop flag is set
u8* pirq = (u8*)pSpuIrq[core];
if ((pirq > (start - 16) && pirq <= start) ||
((flags & 1) && (pirq > (pChannel->pLoop - 16) && pirq <= pChannel->pLoop)))
{
IRQINFO |= 4 << core;
SPU2_LOG("SPU2Worker:interrupt\n");
irqCallbackSPU2();
}
}
}
// flag handler
if ((flags & 4) && (!pChannel->bIgnoreLoop))
pChannel->pLoop = start - 16; // loop address
if (flags & 1) // 1: stop/loop
{
// We play this block out first...
dwEndChannel2[ch / 24] |= (1 << (ch % 24));
if (flags != 3 || pChannel->pLoop == NULL)
{ // 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->s_1 = s_1;
pChannel->s_2 = s_2;
}
pChannel->StoreInterpolationVal(pChannel->SB[pChannel->iSBPos++]); // get sample data
pChannel->spos -= 0x10000;
}
s32 sval = (MixADSR(pChannel) * pChannel->iGetVal()) / 1023; // mix adsr with noise or sample val.
if (pChannel->bFMod == 2) // fmod freq channel
{
// -> store 1T sample data, use that to do fmod on next channel
if (!pChannel->bNoise) iFMod[ns] = sval;
}
else
{
if (pChannel->bVolumeL)
s_buffers[ns][0] += (sval * pChannel->leftvol) >> 14;
if (pChannel->bVolumeR)
s_buffers[ns][1] += (sval * pChannel->rightvol) >> 14;
}
pChannel->spos += pChannel->sinc;
}
}
// simulate SPU2 for 1ms
void SPU2Worker()
{
// assume s_buffers are zeroed out
if (dwNewChannel2[0] || dwNewChannel2[1]) s_pAudioBuffers[s_nCurBuffer].newchannels++;
VOICE_PROCESSED* pChannel = voices;
for (u32 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
dwNewChannel2[ch / 24] &= ~(1 << (ch % 24)); // clear channel bit
}
if (!pChannel->bOn) continue;
if (pChannel->iActFreq != pChannel->iUsedFreq) // new psx frequency?
pChannel->VoiceChangeFrequency();
// loop until 1 ms of data is reached
SPU2Loop(pChannel, ch);
}
// mix all channels
MixChannels(0);
MixChannels(1);
if ( g_bPlaySound )
{
assert( s_pCurOutput != NULL);
for (u32 ns = 0; ns < NSSIZE; ns++)
{
// clamp and write
clampandwrite16(s_pCurOutput[0],s_buffers[ns][0]);
clampandwrite16(s_pCurOutput[1],s_buffers[ns][1]);
s_pCurOutput += 2;
s_buffers[ns][0] = 0;
s_buffers[ns][1] = 0;
}
// check if end reached
if ((uptr)s_pCurOutput - (uptr)s_pAudioBuffers[s_nCurBuffer].pbuf >= 4 * NS_TOTAL_SIZE)
{
if ( conf.options & OPTION_RECORDING )
{
static s32 lastrectime = 0;
if (timeGetTime() - lastrectime > 5000)
{
WARN_LOG("ZeroSPU2: recording\n");
lastrectime = timeGetTime();
}
LogRawSound(s_pAudioBuffers[s_nCurBuffer].pbuf, 4, s_pAudioBuffers[s_nCurBuffer].pbuf+2, 4, NS_TOTAL_SIZE);
}
if ( s_nQueuedBuffers >= ArraySize(s_pAudioBuffers)-1 )
{
//ZeroSPU2: dropping packets! game too fast
s_nDropPacket += NSFRAMES;
s_GlobalTimeStamp = GetMicroTime();
}
else {
// submit to final mixer
#ifdef ZEROSPU2_DEVBUILD
if ( g_logsound )
LogRawSound(s_pAudioBuffers[s_nCurBuffer].pbuf, 4, s_pAudioBuffers[s_nCurBuffer].pbuf + 2, 4, NS_TOTAL_SIZE);
#endif
if ( g_startcount == 0xffffffff )
{
g_startcount = timeGetTime();
g_packetcount = 0;
}
if ( conf.options & OPTION_TIMESTRETCH )
{
u32 newtotal = s_nTotalDuration - s_nDurations[s_nCurDuration];
u64 newtime = GetMicroTime();
u32 duration;
if (s_GlobalTimeStamp == 0) s_GlobalTimeStamp = newtime - NSFRAMES * 1000;
duration = (u32)(newtime-s_GlobalTimeStamp);
s_nDurations[s_nCurDuration] = duration;
s_nTotalDuration = newtotal + duration;
s_nCurDuration = (s_nCurDuration+1)%ArraySize(s_nDurations);
s_GlobalTimeStamp = newtime;
s_pAudioBuffers[s_nCurBuffer].timestamp = timeGetTime();
s_pAudioBuffers[s_nCurBuffer].avgtime = s_nTotalDuration/ArraySize(s_nDurations);
}
s_pAudioBuffers[s_nCurBuffer].len = 4 * NS_TOTAL_SIZE;
InterlockedExchangeAdd((long*)&s_nQueuedBuffers, 1);
s_nCurBuffer = (s_nCurBuffer+1)%ArraySize(s_pAudioBuffers);
s_pAudioBuffers[s_nCurBuffer].newchannels = 0; // reset
}
// restart
s_pCurOutput = (s16*)s_pAudioBuffers[s_nCurBuffer].pbuf;
}
}
}
// size is in bytes
void LogPacketSound(void* packet, s32 memsize)
{
u16 buf[28];
u8* pstart = (u8*)packet;
s_1 = s_2 = 0;
for (s32 i = 0; i < memsize; i += 16)
{
predict_nr = (s32)pstart[0];
shift_factor = predict_nr&0xf;
predict_nr >>= 4;
pstart += 2;
for (s32 nSample = 0;nSample < 28; ++pstart)
{
s32 d = (s32)*pstart;
s32 temp;
temp = ((d & 0xf) << 12);
buf[nSample++] = SetPacket(temp);
temp = ((d & 0xf0) << 8);
buf[nSample++] = SetPacket(temp);
}
LogRawSound(buf, 2, buf, 2, 28);
}
}
void LogRawSound(void* pleft, s32 leftstride, void* pright, s32 rightstride, s32 numsamples)
{
if (g_pWavRecord == NULL )
g_pWavRecord = new WavOutFile(RECORD_FILENAME, SAMPLE_RATE, 16, 2);
u8* left = (u8*)pleft;
u8* right = (u8*)pright;
static vector<s16> tempbuf;
tempbuf.resize(2 * numsamples);
for (s32 i = 0; i < numsamples; ++i)
{
tempbuf[2*i+0] = *(s16*)left;
tempbuf[2*i+1] = *(s16*)right;
left += leftstride;
right += rightstride;
}
g_pWavRecord->write(&tempbuf[0], numsamples*2);
}