1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
/*
Copyright 2016-2020 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/.
*/
#ifndef SPU_H
#define SPU_H
#include "Savestate.h"
namespace SPU
{
bool Init();
void DeInit();
void Reset();
void Stop();
void DoSavestate(Savestate* file);
void SetBias(u16 bias);
void Mix(u32 samples);
void TrimOutput();
void DrainOutput();
void InitOutput();
int GetOutputSize();
void Sync(bool wait);
int ReadOutput(s16* data, int samples);
u8 Read8(u32 addr);
u16 Read16(u32 addr);
u32 Read32(u32 addr);
void Write8(u32 addr, u8 val);
void Write16(u32 addr, u16 val);
void Write32(u32 addr, u32 val);
class Channel
{
public:
Channel(u32 num);
~Channel();
void Reset();
void DoSavestate(Savestate* file);
u32 Num;
u32 Cnt;
u32 SrcAddr;
u16 TimerReload;
u32 LoopPos;
u32 Length;
u8 Volume;
u8 VolumeShift;
u8 Pan;
u32 Timer;
s32 Pos;
s16 CurSample;
u16 NoiseVal;
s32 ADPCMVal;
s32 ADPCMIndex;
s32 ADPCMValLoop;
s32 ADPCMIndexLoop;
u8 ADPCMCurByte;
u32 FIFO[8];
u32 FIFOReadPos;
u32 FIFOWritePos;
u32 FIFOReadOffset;
u32 FIFOLevel;
void FIFO_BufferData();
template<typename T> T FIFO_ReadData();
void SetCnt(u32 val)
{
u32 oldcnt = Cnt;
Cnt = val & 0xFF7F837F;
Volume = Cnt & 0x7F;
if (Volume == 127) Volume++;
const u8 volshift[4] = {4, 3, 2, 0};
VolumeShift = volshift[(Cnt >> 8) & 0x3];
Pan = (Cnt >> 16) & 0x7F;
if (Pan == 127) Pan++;
if ((val & (1<<31)) && !(oldcnt & (1<<31)))
{
Start();
}
}
void SetSrcAddr(u32 val) { SrcAddr = val & 0x07FFFFFC; }
void SetTimerReload(u32 val) { TimerReload = val & 0xFFFF; }
void SetLoopPos(u32 val) { LoopPos = (val & 0xFFFF) << 2; }
void SetLength(u32 val) { Length = (val & 0x001FFFFF) << 2; }
void Start();
void NextSample_PCM8();
void NextSample_PCM16();
void NextSample_ADPCM();
void NextSample_PSG();
void NextSample_Noise();
template<u32 type> void Run(s32* buf, u32 samples);
void DoRun(s32* buf, u32 samples)
{
for (u32 s = 0; s < samples; s++)
buf[s] = 0;
switch ((Cnt >> 29) & 0x3)
{
case 0: Run<0>(buf, samples); break;
case 1: Run<1>(buf, samples); break;
case 2: Run<2>(buf, samples); break;
case 3:
if (Num >= 14) Run<4>(buf, samples);
else if (Num >= 8) Run<3>(buf, samples);
break;
}
}
void PanOutput(s32* inbuf, u32 samples, s32* leftbuf, s32* rightbuf);
private:
u32 (*BusRead32)(u32 addr);
};
class CaptureUnit
{
public:
CaptureUnit(u32 num);
~CaptureUnit();
void Reset();
void DoSavestate(Savestate* file);
u32 Num;
u8 Cnt;
u32 DstAddr;
u16 TimerReload;
u32 Length;
u32 Timer;
s32 Pos;
u32 FIFO[4];
u32 FIFOReadPos;
u32 FIFOWritePos;
u32 FIFOWriteOffset;
u32 FIFOLevel;
void FIFO_FlushData();
template<typename T> void FIFO_WriteData(T val);
void SetCnt(u8 val)
{
if ((val & 0x80) && !(Cnt & 0x80))
Start();
val &= 0x8F;
if (!(val & 0x80)) val &= ~0x01;
Cnt = val;
}
void SetDstAddr(u32 val) { DstAddr = val & 0x07FFFFFC; }
void SetTimerReload(u32 val) { TimerReload = val & 0xFFFF; }
void SetLength(u32 val) { Length = val << 2; if (Length == 0) Length = 4; }
void Start()
{
Timer = TimerReload;
Pos = 0;
FIFOReadPos = 0;
FIFOWritePos = 0;
FIFOWriteOffset = 0;
FIFOLevel = 0;
}
void Run(s32 sample);
private:
void (*BusWrite32)(u32 addr, u32 val);
};
}
#endif // SPU_H
|