copyright : (C) 2002 by Pete Bernert
email : BlackDove@addcom.de
- Portions (C) Gražvydas "notaz" Ignotas, 2010-2012,2014
+ Portions (C) Gražvydas "notaz" Ignotas, 2010-2012,2014,2015
***************************************************************************/
/***************************************************************************
#ifndef _WIN32
#include <sys/time.h> // gettimeofday in xa.c
+#define THREAD_ENABLED 1
#endif
#include "stdafx.h"
SPUCHAN s_chan[MAXCHAN+1]; // channel + 1 infos (1 is security for fmod handling)
REVERBInfo rvb;
+#ifdef THREAD_ENABLED
+
+#include <pthread.h>
+#include <semaphore.h>
+#include <unistd.h>
+
+// worker thread state
+static struct {
+ unsigned int pending:1;
+ unsigned int exit_thread:1;
+ int ns_to;
+ int ctrl;
+ int decode_pos;
+ int silentch;
+ int *sRVBStart;
+ unsigned char *ram;
+ unsigned int chmask;
+ unsigned int r_chan_end;
+ unsigned int r_decode_dirty;
+ pthread_t thread;
+ sem_t sem_avail;
+ sem_t sem_done;
+ struct {
+ int spos;
+ int sbpos;
+ int sinc;
+ int start;
+ int loop;
+ int ns_to;
+ ADSRInfoEx adsr;
+ // might want to add vol and fmod flags..
+ } ch[24];
+} *worker;
+
+#else
+static const void * const worker = NULL;
+#endif
+
// certain globals (were local before, but with the new timeproc I need em global)
static const int f[8][2] = { { 0, 0 },
// /
//
-
-INLINE void InterpolateUp(int ch)
+static void InterpolateUp(int *SB, int sinc)
{
- if(s_chan[ch].SB[32]==1) // flag == 1? calc step and set flag... and don't change the value in this pass
+ if(SB[32]==1) // flag == 1? calc step and set flag... and don't change the value in this pass
{
- const int id1=s_chan[ch].SB[30]-s_chan[ch].SB[29]; // curr delta to next val
- const int id2=s_chan[ch].SB[31]-s_chan[ch].SB[30]; // and next delta to next-next val :)
+ const int id1=SB[30]-SB[29]; // curr delta to next val
+ const int id2=SB[31]-SB[30]; // and next delta to next-next val :)
- s_chan[ch].SB[32]=0;
+ SB[32]=0;
if(id1>0) // curr delta positive
{
if(id2<id1)
- {s_chan[ch].SB[28]=id1;s_chan[ch].SB[32]=2;}
+ {SB[28]=id1;SB[32]=2;}
else
if(id2<(id1<<1))
- s_chan[ch].SB[28]=(id1*s_chan[ch].sinc)/0x10000L;
+ SB[28]=(id1*sinc)>>16;
else
- s_chan[ch].SB[28]=(id1*s_chan[ch].sinc)/0x20000L;
+ SB[28]=(id1*sinc)>>17;
}
else // curr delta negative
{
if(id2>id1)
- {s_chan[ch].SB[28]=id1;s_chan[ch].SB[32]=2;}
+ {SB[28]=id1;SB[32]=2;}
else
if(id2>(id1<<1))
- s_chan[ch].SB[28]=(id1*s_chan[ch].sinc)/0x10000L;
+ SB[28]=(id1*sinc)>>16;
else
- s_chan[ch].SB[28]=(id1*s_chan[ch].sinc)/0x20000L;
+ SB[28]=(id1*sinc)>>17;
}
}
else
- if(s_chan[ch].SB[32]==2) // flag 1: calc step and set flag... and don't change the value in this pass
+ if(SB[32]==2) // flag 1: calc step and set flag... and don't change the value in this pass
{
- s_chan[ch].SB[32]=0;
+ SB[32]=0;
- s_chan[ch].SB[28]=(s_chan[ch].SB[28]*s_chan[ch].sinc)/0x20000L;
- //if(s_chan[ch].sinc<=0x8000)
- // s_chan[ch].SB[29]=s_chan[ch].SB[30]-(s_chan[ch].SB[28]*((0x10000/s_chan[ch].sinc)-1));
+ SB[28]=(SB[28]*sinc)>>17;
+ //if(sinc<=0x8000)
+ // SB[29]=SB[30]-(SB[28]*((0x10000/sinc)-1));
//else
- s_chan[ch].SB[29]+=s_chan[ch].SB[28];
+ SB[29]+=SB[28];
}
else // no flags? add bigger val (if possible), calc smaller step, set flag1
- s_chan[ch].SB[29]+=s_chan[ch].SB[28];
+ SB[29]+=SB[28];
}
//
// even easier interpolation on downsampling, also no special filter, again just "Pete's common sense" tm
//
-INLINE void InterpolateDown(int ch)
+static void InterpolateDown(int *SB, int sinc)
{
- if(s_chan[ch].sinc>=0x20000L) // we would skip at least one val?
+ if(sinc>=0x20000L) // we would skip at least one val?
{
- s_chan[ch].SB[29]+=(s_chan[ch].SB[30]-s_chan[ch].SB[29])/2; // add easy weight
- if(s_chan[ch].sinc>=0x30000L) // we would skip even more vals?
- s_chan[ch].SB[29]+=(s_chan[ch].SB[31]-s_chan[ch].SB[30])/2;// add additional next weight
+ SB[29]+=(SB[30]-SB[29])/2; // add easy weight
+ if(sinc>=0x30000L) // we would skip even more vals?
+ SB[29]+=(SB[31]-SB[30])/2; // add additional next weight
}
}
////////////////////////////////////////////////////////////////////////
// helpers for gauss interpolation
-#define gval0 (((short*)(&s_chan[ch].SB[29]))[gpos&3])
-#define gval(x) ((int)((short*)(&s_chan[ch].SB[29]))[(gpos+x)&3])
+#define gval0 (((short*)(&SB[29]))[gpos&3])
+#define gval(x) ((int)((short*)(&SB[29]))[(gpos+x)&3])
#include "gauss_i.h"
StartADSR(ch);
StartREVERB(ch);
- // fussy timing issues - do in VoiceOn
- //s_chan[ch].pCurr=s_chan[ch].pStart; // set sample start
- //s_chan[ch].bStop=0;
- //s_chan[ch].bOn=1;
+ s_chan[ch].prevflags=2;
s_chan[ch].SB[26]=0; // init mixing vars
s_chan[ch].SB[27]=0;
s_chan[ch].spos=0;
spu.dwNewChannel&=~(1<<ch); // clear new channel bit
+ spu.dwChannelOn|=1<<ch;
+ spu.dwChannelDead&=~(1<<ch);
}
////////////////////////////////////////////////////////////////////////
// ALL KIND OF HELPERS
////////////////////////////////////////////////////////////////////////
-INLINE int FModChangeFrequency(int ch,int ns)
+INLINE int FModChangeFrequency(int *SB, int pitch, int ns)
{
- unsigned int NP=s_chan[ch].iRawPitch;
+ unsigned int NP=pitch;
int sinc;
- NP=((32768L+iFMod[ns])*NP)/32768L;
+ NP=((32768L+iFMod[ns])*NP)>>15;
if(NP>0x3fff) NP=0x3fff;
if(NP<0x1) NP=0x1;
sinc=NP<<4; // calc frequency
if(spu_config.iUseInterpolation==1) // freq change in simple interpolation mode
- s_chan[ch].SB[32]=1;
+ SB[32]=1;
iFMod[ns]=0;
return sinc;
////////////////////////////////////////////////////////////////////////
-INLINE void StoreInterpolationVal(int ch,int fa)
+INLINE void StoreInterpolationVal(int *SB, int sinc, int fa, int fmod_freq)
{
- if(s_chan[ch].bFMod==2) // fmod freq channel
- s_chan[ch].SB[29]=fa;
+ if(fmod_freq) // fmod freq channel
+ SB[29]=fa;
else
{
ssat32_to_16(fa);
if(spu_config.iUseInterpolation>=2) // gauss/cubic interpolation
- {
- int gpos = s_chan[ch].SB[28];
- gval0 = fa;
+ {
+ int gpos = SB[28];
+ gval0 = fa;
gpos = (gpos+1) & 3;
- s_chan[ch].SB[28] = gpos;
+ SB[28] = gpos;
}
else
if(spu_config.iUseInterpolation==1) // simple interpolation
{
- s_chan[ch].SB[28] = 0;
- s_chan[ch].SB[29] = s_chan[ch].SB[30]; // -> helpers for simple linear interpolation: delay real val for two slots, and calc the two deltas, for a 'look at the future behaviour'
- s_chan[ch].SB[30] = s_chan[ch].SB[31];
- s_chan[ch].SB[31] = fa;
- s_chan[ch].SB[32] = 1; // -> flag: calc new interolation
+ SB[28] = 0;
+ SB[29] = SB[30]; // -> helpers for simple linear interpolation: delay real val for two slots, and calc the two deltas, for a 'look at the future behaviour'
+ SB[30] = SB[31];
+ SB[31] = fa;
+ SB[32] = 1; // -> flag: calc new interolation
}
- else s_chan[ch].SB[29]=fa; // no interpolation
+ else SB[29]=fa; // no interpolation
}
}
////////////////////////////////////////////////////////////////////////
-INLINE int iGetInterpolationVal(int ch, int spos)
+INLINE int iGetInterpolationVal(int *SB, int sinc, int spos, int fmod_freq)
{
int fa;
- if(s_chan[ch].bFMod==2) return s_chan[ch].SB[29];
+ if(fmod_freq) return SB[29];
switch(spu_config.iUseInterpolation)
- {
+ {
//--------------------------------------------------//
case 3: // cubic interpolation
{
long xd;int gpos;
xd = (spos >> 1)+1;
- gpos = s_chan[ch].SB[28];
+ gpos = SB[28];
fa = gval(3) - 3*gval(2) + 3*gval(1) - gval0;
fa *= (xd - (2<<15)) / 6;
{
int vl, vr;int gpos;
vl = (spos >> 6) & ~3;
- gpos = s_chan[ch].SB[28];
+ gpos = SB[28];
vr=(gauss[vl]*(int)gval0)&~2047;
vr+=(gauss[vl+1]*gval(1))&~2047;
vr+=(gauss[vl+2]*gval(2))&~2047;
//--------------------------------------------------//
case 1: // simple interpolation
{
- if(s_chan[ch].sinc<0x10000L) // -> upsampling?
- InterpolateUp(ch); // --> interpolate up
- else InterpolateDown(ch); // --> else down
- fa=s_chan[ch].SB[29];
+ if(sinc<0x10000L) // -> upsampling?
+ InterpolateUp(SB, sinc); // --> interpolate up
+ else InterpolateDown(SB, sinc); // --> else down
+ fa=SB[29];
} break;
//--------------------------------------------------//
default: // no interpolation
{
- fa=s_chan[ch].SB[29];
+ fa=SB[29];
} break;
//--------------------------------------------------//
}
}
}
-static int decode_block(int ch)
+static int decode_block(int ch, int *SB)
{
unsigned char *start;
int predict_nr, shift_factor, flags;
shift_factor = predict_nr & 0xf;
predict_nr >>= 4;
- decode_block_data(s_chan[ch].SB, start + 2, predict_nr, shift_factor);
+ decode_block_data(SB, start + 2, predict_nr, shift_factor);
flags = start[1];
if (flags & 4)
return ret;
}
+#ifdef THREAD_ENABLED
+
+static int decode_block_work(int ch, int *SB)
+{
+ int predict_nr, shift_factor, flags;
+ const unsigned char *ram = worker->ram;
+ int start = worker->ch[ch].start;
+ int loop = worker->ch[ch].loop;
+
+ predict_nr = ram[start];
+ shift_factor = predict_nr & 0xf;
+ predict_nr >>= 4;
+
+ decode_block_data(SB, ram + start + 2, predict_nr, shift_factor);
+
+ flags = ram[start + 1];
+ if (flags & 4)
+ loop = start; // loop adress
+
+ start += 16;
+
+ if (flags & 1) // 1: stop/loop
+ start = loop;
+
+ worker->ch[ch].start = start & 0x7ffff;
+ worker->ch[ch].loop = loop;
+
+ return 0;
+}
+
+#endif
+
// if irq is going to trigger sooner than in upd_samples, set upd_samples
static void scan_for_irq(int ch, unsigned int *upd_samples)
{
}
#define make_do_samples(name, fmod_code, interp_start, interp1_code, interp2_code, interp_end) \
-static noinline int do_samples_##name(int ch, int ns_to) \
+static noinline int do_samples_##name(int (*decode_f)(int ch, int *SB), int ch, \
+ int ns_to, int *SB, int sinc, int *spos, int *sbpos) \
{ \
- int sinc = s_chan[ch].sinc; \
- int spos = s_chan[ch].spos; \
- int sbpos = s_chan[ch].iSBPos; \
- int *SB = s_chan[ch].SB; \
int ns, d, fa; \
int ret = ns_to; \
interp_start; \
{ \
fmod_code; \
\
- spos += sinc; \
- while (spos >= 0x10000) \
+ *spos += sinc; \
+ while (*spos >= 0x10000) \
{ \
- fa = SB[sbpos++]; \
- if (sbpos >= 28) \
+ fa = SB[(*sbpos)++]; \
+ if (*sbpos >= 28) \
{ \
- sbpos = 0; \
- d = decode_block(ch); \
+ *sbpos = 0; \
+ d = decode_f(ch, SB); \
if (d && ns < ret) \
ret = ns; \
} \
\
interp1_code; \
- spos -= 0x10000; \
+ *spos -= 0x10000; \
} \
\
interp2_code; \
} \
\
- s_chan[ch].sinc = sinc; \
- s_chan[ch].spos = spos; \
- s_chan[ch].iSBPos = sbpos; \
interp_end; \
\
return ret; \
#define fmod_recv_check \
if(s_chan[ch].bFMod==1 && iFMod[ns]) \
- sinc = FModChangeFrequency(ch,ns)
+ sinc = FModChangeFrequency(SB, s_chan[ch].iRawPitch, ns)
make_do_samples(default, fmod_recv_check, ,
- StoreInterpolationVal(ch, fa),
- ChanBuf[ns] = iGetInterpolationVal(ch, spos), )
-make_do_samples(noint, , fa = s_chan[ch].SB[29], , ChanBuf[ns] = fa, s_chan[ch].SB[29] = fa)
+ StoreInterpolationVal(SB, sinc, fa, s_chan[ch].bFMod==2),
+ ChanBuf[ns] = iGetInterpolationVal(SB, sinc, *spos, s_chan[ch].bFMod==2), )
+make_do_samples(noint, , fa = SB[29], , ChanBuf[ns] = fa, SB[29] = fa)
#define simple_interp_store \
SB[28] = 0; \
SB[32] = 1
#define simple_interp_get \
- if(sinc<0x10000) /* -> upsampling? */ \
- InterpolateUp(ch); /* --> interpolate up */ \
- else InterpolateDown(ch); /* --> else down */ \
- ChanBuf[ns] = s_chan[ch].SB[29]
+ if(sinc<0x10000) /* -> upsampling? */ \
+ InterpolateUp(SB, sinc); /* --> interpolate up */ \
+ else InterpolateDown(SB, sinc); /* --> else down */ \
+ ChanBuf[ns] = SB[29]
make_do_samples(simple, , ,
simple_interp_store, simple_interp_get, )
static void do_channels(int ns_to)
{
unsigned int mask;
+ int *SB, sinc;
int ch, d;
InitREVERB(ns_to);
{
if (!(mask & 1)) continue; // channel not playing? next
+ SB = s_chan[ch].SB;
+ sinc = s_chan[ch].sinc;
+
if (s_chan[ch].bNoise)
d = do_samples_noise(ch, ns_to);
else if (s_chan[ch].bFMod == 2
|| (s_chan[ch].bFMod == 0 && spu_config.iUseInterpolation == 0))
- d = do_samples_noint(ch, ns_to);
+ d = do_samples_noint(decode_block, ch, ns_to,
+ SB, sinc, &s_chan[ch].spos, &s_chan[ch].iSBPos);
else if (s_chan[ch].bFMod == 0 && spu_config.iUseInterpolation == 1)
- d = do_samples_simple(ch, ns_to);
+ d = do_samples_simple(decode_block, ch, ns_to,
+ SB, sinc, &s_chan[ch].spos, &s_chan[ch].iSBPos);
else
- d = do_samples_default(ch, ns_to);
+ d = do_samples_default(decode_block, ch, ns_to,
+ SB, sinc, &s_chan[ch].spos, &s_chan[ch].iSBPos);
- d = MixADSR(ch, d);
+ d = MixADSR(&s_chan[ch].ADSRX, d);
if (d < ns_to) {
spu.dwChannelOn &= ~(1 << ch);
- s_chan[ch].bStop = 1;
s_chan[ch].ADSRX.EnvelopeVol = 0;
memset(&ChanBuf[d], 0, (ns_to - d) * sizeof(ChanBuf[0]));
}
}
}
+static void do_samples_finish(int ns_to, int silentch, int decode_pos);
+
+// optional worker thread handling
+
+#ifdef THREAD_ENABLED
+
+static void queue_channel_work(int ns_to, int silentch)
+{
+ unsigned int mask;
+ int ch;
+
+ worker->ns_to = ns_to;
+ worker->ctrl = spu.spuCtrl;
+ worker->decode_pos = spu.decode_pos;
+ worker->silentch = silentch;
+ worker->sRVBStart = spu.sRVBStart;
+ worker->ram = spu.spuMemC;
+
+ mask = worker->chmask = spu.dwChannelOn & 0xffffff;
+ for (ch = 0; mask != 0; ch++, mask >>= 1)
+ {
+ if (!(mask & 1)) continue;
+
+ worker->ch[ch].spos = s_chan[ch].spos;
+ worker->ch[ch].sbpos = s_chan[ch].iSBPos;
+ worker->ch[ch].sinc = s_chan[ch].sinc;
+ worker->ch[ch].adsr = s_chan[ch].ADSRX;
+ worker->ch[ch].start = s_chan[ch].pCurr - spu.spuMemC;
+ worker->ch[ch].loop = s_chan[ch].pLoop - spu.spuMemC;
+ if (s_chan[ch].prevflags & 1)
+ worker->ch[ch].start = worker->ch[ch].loop;
+
+ worker->ch[ch].ns_to = do_samples_skip(ch, ns_to);
+ }
+
+ worker->pending = 1;
+ sem_post(&worker->sem_avail);
+}
+
+static void do_channel_work(void)
+{
+ unsigned int mask, endmask = 0;
+ unsigned int decode_dirty_ch = 0;
+ int *SB, sinc, spos, sbpos;
+ int d, ch, ns_to;
+
+ ns_to = worker->ns_to;
+ memset(worker->sRVBStart, 0, ns_to * sizeof(worker->sRVBStart[0]) * 2);
+
+ mask = worker->chmask;
+ for (ch = 0; mask != 0; ch++, mask >>= 1)
+ {
+ if (!(mask & 1)) continue;
+
+ d = worker->ch[ch].ns_to;
+ spos = worker->ch[ch].spos;
+ sbpos = worker->ch[ch].sbpos;
+ sinc = worker->ch[ch].sinc;
+ SB = s_chan[ch].SB;
+
+ if (s_chan[ch].bNoise)
+ do_lsfr_samples(d, worker->ctrl, &spu.dwNoiseCount, &spu.dwNoiseVal);
+ else if (s_chan[ch].bFMod == 2
+ || (s_chan[ch].bFMod == 0 && spu_config.iUseInterpolation == 0))
+ do_samples_noint(decode_block_work, ch, d, SB, sinc, &spos, &sbpos);
+ else if (s_chan[ch].bFMod == 0 && spu_config.iUseInterpolation == 1)
+ do_samples_simple(decode_block_work, ch, d, SB, sinc, &spos, &sbpos);
+ else
+ do_samples_default(decode_block_work, ch, d, SB, sinc, &spos, &sbpos);
+
+ d = MixADSR(&worker->ch[ch].adsr, d);
+ if (d < ns_to) {
+ endmask |= 1 << ch;
+ worker->ch[ch].adsr.EnvelopeVol = 0;
+ memset(&ChanBuf[d], 0, (ns_to - d) * sizeof(ChanBuf[0]));
+ }
+
+ if (ch == 1 || ch == 3)
+ {
+ do_decode_bufs((void *)worker->ram, ch/2, ns_to, worker->decode_pos);
+ decode_dirty_ch |= 1 << ch;
+ }
+
+ if (s_chan[ch].bFMod == 2) // fmod freq channel
+ memcpy(iFMod, &ChanBuf, ns_to * sizeof(iFMod[0]));
+ if (s_chan[ch].bRVBActive)
+ mix_chan_rvb(0, ns_to, s_chan[ch].iLeftVolume, s_chan[ch].iRightVolume, worker->sRVBStart);
+ else
+ mix_chan(0, ns_to, s_chan[ch].iLeftVolume, s_chan[ch].iRightVolume);
+ }
+
+ worker->r_chan_end = endmask;
+ worker->r_decode_dirty = decode_dirty_ch;
+}
+
+static void sync_worker_thread(void)
+{
+ unsigned int mask;
+ int ch;
+
+ if (!worker->pending)
+ return;
+
+ sem_wait(&worker->sem_done);
+ worker->pending = 0;
+
+ mask = worker->chmask;
+ for (ch = 0; mask != 0; ch++, mask >>= 1) {
+ if (!(mask & 1)) continue;
+
+ // be sure there was no keyoff while thread was working
+ if (s_chan[ch].ADSRX.State != ADSR_RELEASE)
+ s_chan[ch].ADSRX.State = worker->ch[ch].adsr.State;
+ s_chan[ch].ADSRX.EnvelopeVol = worker->ch[ch].adsr.EnvelopeVol;
+ }
+
+ spu.dwChannelOn &= ~worker->r_chan_end;
+ spu.decode_dirty_ch |= worker->r_decode_dirty;
+
+ do_samples_finish(worker->ns_to, worker->silentch,
+ worker->decode_pos);
+}
+
+#else
+
+static void queue_channel_work(int ns_to, int silentch) {}
+static void sync_worker_thread(void) {}
+
+#endif // THREAD_ENABLED
+
////////////////////////////////////////////////////////////////////////
// MAIN SPU FUNCTION
// here is the main job handler...
////////////////////////////////////////////////////////////////////////
-void do_samples_finish(int ns_to, int silentch);
-
-void do_samples(unsigned int cycles_to)
+void do_samples(unsigned int cycles_to, int do_sync)
{
unsigned int mask;
int ch, ns_to;
}
}
- silentch = ~(spu.dwChannelOn|spu.dwNewChannel);
+ if (worker != NULL)
+ sync_worker_thread();
mask = spu.dwNewChannel & 0xffffff;
for (ch = 0; mask != 0; ch++, mask >>= 1) {
StartSound(ch);
}
- if (spu.dwChannelOn == 0)
+ silentch = ~spu.dwChannelOn & 0xffffff;
+
+ if (spu.dwChannelOn == 0) {
InitREVERB(ns_to);
+ do_samples_finish(ns_to, silentch, spu.decode_pos);
+ }
else {
- do_channels(ns_to);
+ if (do_sync || worker == NULL || !spu_config.iUseThread) {
+ do_channels(ns_to);
+ do_samples_finish(ns_to, silentch, spu.decode_pos);
+ }
+ else {
+ queue_channel_work(ns_to, silentch);
+ }
}
- do_samples_finish(ns_to, silentch);
-
// advance "stopped" channels that can cause irqs
// (all chans are always playing on the real thing..)
if (spu.spuCtrl & CTRL_IRQ)
spu.decode_pos = (spu.decode_pos + ns_to) & 0x1ff;
}
-void do_samples_finish(int ns_to, int silentch)
+static void do_samples_finish(int ns_to, int silentch, int decode_pos)
{
int volmult = spu_config.iVolume;
int ns;
//---------------------------------------------------//
// mix XA infos (if any)
- MixXA(ns_to, spu.decode_pos);
+ MixXA(ns_to, decode_pos);
///////////////////////////////////////////////////////
// mix all channels (including reverb) into one buffer
void CALLBACK SPUasync(unsigned int cycle, unsigned int flags)
{
- do_samples(cycle);
+ do_samples(cycle, 0);
if (spu.spuCtrl & CTRL_IRQ)
schedule_next_irq();
spu.CDDAStart = NULL;
}
-// INIT/EXIT STUFF
+#ifdef THREAD_ENABLED
+
+static void *spu_worker_thread(void *unused)
+{
+ while (1) {
+ sem_wait(&worker->sem_avail);
+ if (worker->exit_thread)
+ break;
+
+ do_channel_work();
+
+ sem_post(&worker->sem_done);
+ }
+
+ return NULL;
+}
+
+static void init_spu_thread(void)
+{
+ int ret;
+
+ if (sysconf(_SC_NPROCESSORS_ONLN) <= 1)
+ return;
+
+ worker = calloc(1, sizeof(*worker));
+ if (worker == NULL)
+ return;
+ ret = sem_init(&worker->sem_avail, 0, 0);
+ if (ret != 0)
+ goto fail_sem_avail;
+ ret = sem_init(&worker->sem_done, 0, 0);
+ if (ret != 0)
+ goto fail_sem_done;
+
+ ret = pthread_create(&worker->thread, NULL, spu_worker_thread, NULL);
+ if (ret != 0)
+ goto fail_thread;
+
+ return;
+
+fail_thread:
+ sem_destroy(&worker->sem_done);
+fail_sem_done:
+ sem_destroy(&worker->sem_avail);
+fail_sem_avail:
+ free(worker);
+ worker = NULL;
+}
+
+static void exit_spu_thread(void)
+{
+ if (worker == NULL)
+ return;
+ worker->exit_thread = 1;
+ sem_post(&worker->sem_avail);
+ pthread_join(worker->thread, NULL);
+ sem_destroy(&worker->sem_done);
+ sem_destroy(&worker->sem_avail);
+ free(worker);
+ worker = NULL;
+}
+
+#else // if !THREAD_ENABLED
+
+static void init_spu_thread(void)
+{
+}
+
+static void exit_spu_thread(void)
+{
+}
+
+#endif
// SPUINIT: this func will be called first by the main emu
long CALLBACK SPUinit(void)
if (spu_config.iVolume == 0)
spu_config.iVolume = 768; // 1024 is 1.0
+ init_spu_thread();
+
return 0;
}
RemoveStreams(); // no more streaming
spu.bSpuInit=0;
+ exit_spu_thread();
+
return 0;
}