cue/bin finally implemented
[picodrive.git] / Pico / sound / sn76496.c
CommitLineData
cc68a136 1/***************************************************************************\r
2\r
3 sn76496.c\r
4\r
5 Routines to emulate the Texas Instruments SN76489 / SN76496 programmable\r
6 tone /noise generator. Also known as (or at least compatible with) TMS9919.\r
7\r
8 Noise emulation is not accurate due to lack of documentation. The noise\r
9 generator uses a shift register with a XOR-feedback network, but the exact\r
10 layout is unknown. It can be set for either period or white noise; again,\r
11 the details are unknown.\r
12\r
13 28/03/2005 : Sebastien Chevalier\r
14 Update th SN76496Write func, according to SN76489 doc found on SMSPower.\r
15 - On write with 0x80 set to 0, when LastRegister is other then TONE,\r
16 the function is similar than update with 0x80 set to 1\r
17***************************************************************************/\r
18\r
19#ifndef __GNUC__\r
20#pragma warning (disable:4244)\r
21#endif\r
22\r
23#include "sn76496.h"\r
24\r
25#define MAX_OUTPUT 0x47ff // was 0x7fff\r
26\r
27#define STEP 0x10000\r
28\r
29\r
30/* Formulas for noise generator */\r
31/* bit0 = output */\r
32\r
33/* noise feedback for white noise mode (verified on real SN76489 by John Kortink) */\r
34#define FB_WNOISE 0x14002 /* (16bits) bit16 = bit0(out) ^ bit2 ^ bit15 */\r
35\r
36/* noise feedback for periodic noise mode */\r
37//#define FB_PNOISE 0x10000 /* 16bit rorate */\r
38#define FB_PNOISE 0x08000 /* JH 981127 - fixes Do Run Run */\r
39\r
40/*\r
410x08000 is definitely wrong. The Master System conversion of Marble Madness\r
42uses periodic noise as a baseline. With a 15-bit rotate, the bassline is\r
43out of tune.\r
44The 16-bit rotate has been confirmed against a real PAL Sega Master System 2.\r
45Hope that helps the System E stuff, more news on the PSG as and when!\r
46*/\r
47\r
48/* noise generator start preset (for periodic noise) */\r
49#define NG_PRESET 0x0f35\r
50\r
51\r
52struct SN76496\r
53{\r
54 //sound_stream * Channel;\r
55 int SampleRate;\r
56 unsigned int UpdateStep;\r
57 int VolTable[16]; /* volume table */\r
58 int Register[8]; /* registers */\r
59 int LastRegister; /* last register written */\r
60 int Volume[4]; /* volume of voice 0-2 and noise */\r
61 unsigned int RNG; /* noise generator */\r
62 int NoiseFB; /* noise feedback mask */\r
63 int Period[4];\r
64 int Count[4];\r
65 int Output[4];\r
66 int pad[1];\r
67};\r
68\r
69static struct SN76496 ono_sn; // one and only SN76496\r
70int *sn76496_regs;\r
71\r
72//static\r
73void SN76496Write(int data)\r
74{\r
75 struct SN76496 *R = &ono_sn;\r
76 int n;\r
77\r
78\r
79 /* update the output buffer before changing the registers */\r
80 //stream_update(R->Channel,0);\r
81\r
82 if (data & 0x80)\r
83 {\r
84 int r = (data & 0x70) >> 4;\r
85 int c = r/2;\r
86\r
87 R->LastRegister = r;\r
88 R->Register[r] = (R->Register[r] & 0x3f0) | (data & 0x0f);\r
89 switch (r)\r
90 {\r
91 case 0: /* tone 0 : frequency */\r
92 case 2: /* tone 1 : frequency */\r
93 case 4: /* tone 2 : frequency */\r
94 R->Period[c] = R->UpdateStep * R->Register[r];\r
95 if (R->Period[c] == 0) R->Period[c] = R->UpdateStep;\r
96 if (r == 4)\r
97 {\r
98 /* update noise shift frequency */\r
99 if ((R->Register[6] & 0x03) == 0x03)\r
100 R->Period[3] = 2 * R->Period[2];\r
101 }\r
102 break;\r
103 case 1: /* tone 0 : volume */\r
104 case 3: /* tone 1 : volume */\r
105 case 5: /* tone 2 : volume */\r
106 case 7: /* noise : volume */\r
107 R->Volume[c] = R->VolTable[data & 0x0f];\r
108 break;\r
109 case 6: /* noise : frequency, mode */\r
110 {\r
111 int n = R->Register[6];\r
112 R->NoiseFB = (n & 4) ? FB_WNOISE : FB_PNOISE;\r
113 n &= 3;\r
114 /* N/512,N/1024,N/2048,Tone #3 output */\r
115 R->Period[3] = ((n&3) == 3) ? 2 * R->Period[2] : (R->UpdateStep << (5+(n&3)));\r
116\r
117 /* reset noise shifter */\r
118 R->RNG = NG_PRESET;\r
119 R->Output[3] = R->RNG & 1;\r
120 }\r
121 break;\r
122 }\r
123 }\r
124 else\r
125 {\r
126 int r = R->LastRegister;\r
127 int c = r/2;\r
128\r
129 switch (r)\r
130 {\r
131 case 0: /* tone 0 : frequency */\r
132 case 2: /* tone 1 : frequency */\r
133 case 4: /* tone 2 : frequency */\r
134 R->Register[r] = (R->Register[r] & 0x0f) | ((data & 0x3f) << 4);\r
135 R->Period[c] = R->UpdateStep * R->Register[r];\r
136 if (R->Period[c] == 0) R->Period[c] = R->UpdateStep;\r
137 if (r == 4)\r
138 {\r
139 /* update noise shift frequency */\r
140 if ((R->Register[6] & 0x03) == 0x03)\r
141 R->Period[3] = 2 * R->Period[2];\r
142 }\r
143 break;\r
144 case 1: /* tone 0 : volume */\r
145 case 3: /* tone 1 : volume */\r
146 case 5: /* tone 2 : volume */\r
147 case 7: /* noise : volume */\r
148 R->Volume[c] = R->VolTable[data & 0x0f];\r
149 R->Register[r] = (R->Register[r] & 0x3f0) | (data & 0x0f);\r
150 break;\r
151 case 6: /* noise : frequency, mode */\r
152 {\r
153 R->Register[r] = (R->Register[r] & 0x3f0) | (data & 0x0f);\r
154 n = R->Register[6];\r
155 R->NoiseFB = (n & 4) ? FB_WNOISE : FB_PNOISE;\r
156 n &= 3;\r
157 /* N/512,N/1024,N/2048,Tone #3 output */\r
158 R->Period[3] = ((n&3) == 3) ? 2 * R->Period[2] : (R->UpdateStep << (5+(n&3)));\r
159\r
160 /* reset noise shifter */\r
161 R->RNG = NG_PRESET;\r
162 R->Output[3] = R->RNG & 1;\r
163 }\r
164 break;\r
165 }\r
166 }\r
167}\r
168\r
169/*\r
170WRITE8_HANDLER( SN76496_0_w ) { SN76496Write(0,data); }\r
171WRITE8_HANDLER( SN76496_1_w ) { SN76496Write(1,data); }\r
172WRITE8_HANDLER( SN76496_2_w ) { SN76496Write(2,data); }\r
173WRITE8_HANDLER( SN76496_3_w ) { SN76496Write(3,data); }\r
174WRITE8_HANDLER( SN76496_4_w ) { SN76496Write(4,data); }\r
175*/\r
176\r
177//static\r
4f265db7 178void SN76496Update(short *buffer, int length, int stereo)\r
cc68a136 179{\r
180 int i;\r
181 struct SN76496 *R = &ono_sn;\r
182\r
183 /* If the volume is 0, increase the counter */\r
184 for (i = 0;i < 4;i++)\r
185 {\r
186 if (R->Volume[i] == 0)\r
187 {\r
188 /* note that I do count += length, NOT count = length + 1. You might think */\r
189 /* it's the same since the volume is 0, but doing the latter could cause */\r
190 /* interferencies when the program is rapidly modulating the volume. */\r
191 if (R->Count[i] <= length*STEP) R->Count[i] += length*STEP;\r
192 }\r
193 }\r
194\r
195 while (length > 0)\r
196 {\r
197 int vol[4];\r
198 unsigned int out;\r
199 int left;\r
200\r
201\r
202 /* vol[] keeps track of how long each square wave stays */\r
203 /* in the 1 position during the sample period. */\r
204 vol[0] = vol[1] = vol[2] = vol[3] = 0;\r
205\r
206 for (i = 0;i < 3;i++)\r
207 {\r
208 if (R->Output[i]) vol[i] += R->Count[i];\r
209 R->Count[i] -= STEP;\r
210 /* Period[i] is the half period of the square wave. Here, in each */\r
211 /* loop I add Period[i] twice, so that at the end of the loop the */\r
212 /* square wave is in the same status (0 or 1) it was at the start. */\r
213 /* vol[i] is also incremented by Period[i], since the wave has been 1 */\r
214 /* exactly half of the time, regardless of the initial position. */\r
215 /* If we exit the loop in the middle, Output[i] has to be inverted */\r
216 /* and vol[i] incremented only if the exit status of the square */\r
217 /* wave is 1. */\r
218 while (R->Count[i] <= 0)\r
219 {\r
220 R->Count[i] += R->Period[i];\r
221 if (R->Count[i] > 0)\r
222 {\r
223 R->Output[i] ^= 1;\r
224 if (R->Output[i]) vol[i] += R->Period[i];\r
225 break;\r
226 }\r
227 R->Count[i] += R->Period[i];\r
228 vol[i] += R->Period[i];\r
229 }\r
230 if (R->Output[i]) vol[i] -= R->Count[i];\r
231 }\r
232\r
233 left = STEP;\r
234 do\r
235 {\r
236 int nextevent;\r
237\r
238 if (R->Count[3] < left) nextevent = R->Count[3];\r
239 else nextevent = left;\r
240\r
241 if (R->Output[3]) vol[3] += R->Count[3];\r
242 R->Count[3] -= nextevent;\r
243 if (R->Count[3] <= 0)\r
244 {\r
245 if (R->RNG & 1) R->RNG ^= R->NoiseFB;\r
246 R->RNG >>= 1;\r
247 R->Output[3] = R->RNG & 1;\r
248 R->Count[3] += R->Period[3];\r
249 if (R->Output[3]) vol[3] += R->Period[3];\r
250 }\r
251 if (R->Output[3]) vol[3] -= R->Count[3];\r
252\r
253 left -= nextevent;\r
254 } while (left > 0);\r
255\r
256 out = vol[0] * R->Volume[0] + vol[1] * R->Volume[1] +\r
257 vol[2] * R->Volume[2] + vol[3] * R->Volume[3];\r
258\r
259 if (out > MAX_OUTPUT * STEP) out = MAX_OUTPUT * STEP;\r
260\r
4f265db7 261 if ((out /= STEP)) // will be optimized to shift; max 0x47ff = 18431\r
cc68a136 262 *buffer += out;\r
4f265db7 263 if(stereo) buffer+=2; // only left for stereo, to be mixed to right later\r
264 else buffer++;\r
cc68a136 265\r
266 length--;\r
267 }\r
268}\r
269\r
270\r
271static void SN76496_set_clock(struct SN76496 *R,int clock)\r
272{\r
273\r
274 /* the base clock for the tone generators is the chip clock divided by 16; */\r
275 /* for the noise generator, it is clock / 256. */\r
276 /* Here we calculate the number of steps which happen during one sample */\r
277 /* at the given sample rate. No. of events = sample rate / (clock/16). */\r
278 /* STEP is a multiplier used to turn the fraction into a fixed point */\r
279 /* number. */\r
280 R->UpdateStep = ((double)STEP * R->SampleRate * 16) / clock;\r
281}\r
282\r
283\r
284static void SN76496_set_gain(struct SN76496 *R,int gain)\r
285{\r
286 int i;\r
287 double out;\r
288\r
289\r
290 gain &= 0xff;\r
291\r
292 /* increase max output basing on gain (0.2 dB per step) */\r
293 out = MAX_OUTPUT / 3;\r
294 while (gain-- > 0)\r
295 out *= 1.023292992; /* = (10 ^ (0.2/20)) */\r
296\r
297 /* build volume table (2dB per step) */\r
298 for (i = 0;i < 15;i++)\r
299 {\r
300 /* limit volume to avoid clipping */\r
301 if (out > MAX_OUTPUT / 3) R->VolTable[i] = MAX_OUTPUT / 3;\r
302 else R->VolTable[i] = out;\r
303\r
304 out /= 1.258925412; /* = 10 ^ (2/20) = 2dB */\r
305 }\r
306 R->VolTable[15] = 0;\r
307}\r
308\r
309\r
310//static\r
311int SN76496_init(int clock,int sample_rate)\r
312{\r
313 struct SN76496 *R = &ono_sn;\r
314 int i;\r
315\r
316 //R->Channel = stream_create(0,1, sample_rate,R,SN76496Update);\r
317 sn76496_regs = R->Register;\r
318\r
319 R->SampleRate = sample_rate;\r
320 SN76496_set_clock(R,clock);\r
321\r
322 for (i = 0;i < 4;i++) R->Volume[i] = 0;\r
323\r
324 R->LastRegister = 0;\r
325 for (i = 0;i < 8;i+=2)\r
326 {\r
327 R->Register[i] = 0;\r
328 R->Register[i + 1] = 0x0f; /* volume = 0 */\r
329 }\r
330\r
331 for (i = 0;i < 4;i++)\r
332 {\r
333 R->Output[i] = 0;\r
334 R->Period[i] = R->Count[i] = R->UpdateStep;\r
335 }\r
336 R->RNG = NG_PRESET;\r
337 R->Output[3] = R->RNG & 1;\r
338\r
339 // added\r
340 SN76496_set_gain(R, 0);\r
341\r
342 return 0;\r
343}\r
344\r