notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
spu: compact chan structure a bit
[pcsx_rearmed.git] / plugins / dfsound / adsr.c
CommitLineData
ef79bbde
P		 1/***************************************************************************\r
2 adsr.c - description\r
3 -------------------\r
4 begin : Wed May 15 2002\r
5 copyright : (C) 2002 by Pete Bernert\r
6 email : BlackDove@addcom.de\r
7 ***************************************************************************/\r
8/***************************************************************************\r
9 * *\r
10 * This program is free software; you can redistribute it and/or modify *\r
11 * it under the terms of the GNU General Public License as published by *\r
12 * the Free Software Foundation; either version 2 of the License, or *\r
13 * (at your option) any later version. See also the license.txt file for *\r
14 * additional informations. *\r
15 * *\r
16 ***************************************************************************/\r
17\r
18#include "stdafx.h"\r
19\r
20#define _IN_ADSR\r
21\r
22// will be included from spu.c\r
23#ifdef _IN_SPU\r
24\r
25////////////////////////////////////////////////////////////////////////\r
26// ADSR func\r
27////////////////////////////////////////////////////////////////////////\r
28\r
29unsigned long RateTable[160];\r
30\r
31void InitADSR(void) // INIT ADSR\r
32{\r
33 unsigned long r,rs,rd;int i;\r
34\r
35 memset(RateTable,0,sizeof(unsigned long)*160); // build the rate table according to Neill's rules (see at bottom of file)\r
36\r
37 r=3;rs=1;rd=0;\r
38\r
39 for(i=32;i<160;i++) // we start at pos 32 with the real values... everything before is 0\r
40 {\r
41 if(r<0x3FFFFFFF)\r
42 {\r
43 r+=rs;\r
44 rd++;if(rd==5) {rd=1;rs*=2;}\r
45 }\r
46 if(r>0x3FFFFFFF) r=0x3FFFFFFF;\r
47\r
48 RateTable[i]=r;\r
49 }\r
50}\r
51\r
52////////////////////////////////////////////////////////////////////////\r
53\r
54INLINE void StartADSR(int ch) // MIX ADSR\r
55{\r
6d866bb7 56 s_chan[ch].ADSRX.State=0; // and init some adsr vars\r
ef79bbde
P		 57 s_chan[ch].ADSRX.EnvelopeVol=0;\r
58}\r
59\r
60////////////////////////////////////////////////////////////////////////\r
61\r
62INLINE int MixADSR(int ch) // MIX ADSR\r
63{ \r
64 if(s_chan[ch].bStop) // should be stopped:\r
65 { // do release\r
66 if(s_chan[ch].ADSRX.ReleaseModeExp)\r
67 {\r
68 switch((s_chan[ch].ADSRX.EnvelopeVol>>28)&0x7)\r
69 {\r
70 case 0: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.ReleaseRate^0x1F))-0x18 +0 + 32]; break;\r
71 case 1: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.ReleaseRate^0x1F))-0x18 +4 + 32]; break;\r
72 case 2: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.ReleaseRate^0x1F))-0x18 +6 + 32]; break;\r
73 case 3: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.ReleaseRate^0x1F))-0x18 +8 + 32]; break;\r
74 case 4: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.ReleaseRate^0x1F))-0x18 +9 + 32]; break;\r
75 case 5: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.ReleaseRate^0x1F))-0x18 +10+ 32]; break;\r
76 case 6: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.ReleaseRate^0x1F))-0x18 +11+ 32]; break;\r
77 case 7: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.ReleaseRate^0x1F))-0x18 +12+ 32]; break;\r
78 }\r
79 }\r
80 else\r
81 {\r
82 s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.ReleaseRate^0x1F))-0x0C + 32];\r
83 }\r
84\r
85 if(s_chan[ch].ADSRX.EnvelopeVol<0) \r
86 {\r
87 s_chan[ch].ADSRX.EnvelopeVol=0;\r
08cfd5e5 88 // don't stop if this chan can still cause irqs\r
89 if(!(spuCtrl&0x40) || (s_chan[ch].pCurr > pSpuIrq && s_chan[ch].pLoop > pSpuIrq))\r
90 //s_chan[ch].bOn=0;\r
91 s_chan[ch].pCurr=(unsigned char *)-1;\r
ef79bbde
P		 92 //s_chan[ch].bReverb=0;\r
93 //s_chan[ch].bNoise=0;\r
94 }\r
95\r
6d866bb7 96 return s_chan[ch].ADSRX.EnvelopeVol>>21;\r
ef79bbde
P		 97 }\r
98 else // not stopped yet?\r
99 {\r
100 if(s_chan[ch].ADSRX.State==0) // -> attack\r
101 {\r
102 if(s_chan[ch].ADSRX.AttackModeExp)\r
103 {\r
104 if(s_chan[ch].ADSRX.EnvelopeVol<0x60000000) \r
105 s_chan[ch].ADSRX.EnvelopeVol+=RateTable[(s_chan[ch].ADSRX.AttackRate^0x7F)-0x10 + 32];\r
106 else\r
107 s_chan[ch].ADSRX.EnvelopeVol+=RateTable[(s_chan[ch].ADSRX.AttackRate^0x7F)-0x18 + 32];\r
108 }\r
109 else\r
110 {\r
111 s_chan[ch].ADSRX.EnvelopeVol+=RateTable[(s_chan[ch].ADSRX.AttackRate^0x7F)-0x10 + 32];\r
112 }\r
113\r
114 if(s_chan[ch].ADSRX.EnvelopeVol<0) \r
115 {\r
116 s_chan[ch].ADSRX.EnvelopeVol=0x7FFFFFFF;\r
117 s_chan[ch].ADSRX.State=1;\r
118 }\r
119\r
6d866bb7 120 return s_chan[ch].ADSRX.EnvelopeVol>>21;\r
ef79bbde
P		 121 }\r
122 //--------------------------------------------------//\r
123 if(s_chan[ch].ADSRX.State==1) // -> decay\r
124 {\r
125 switch((s_chan[ch].ADSRX.EnvelopeVol>>28)&0x7)\r
126 {\r
127 case 0: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.DecayRate^0x1F))-0x18+0 + 32]; break;\r
128 case 1: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.DecayRate^0x1F))-0x18+4 + 32]; break;\r
129 case 2: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.DecayRate^0x1F))-0x18+6 + 32]; break;\r
130 case 3: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.DecayRate^0x1F))-0x18+8 + 32]; break;\r
131 case 4: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.DecayRate^0x1F))-0x18+9 + 32]; break;\r
132 case 5: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.DecayRate^0x1F))-0x18+10+ 32]; break;\r
133 case 6: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.DecayRate^0x1F))-0x18+11+ 32]; break;\r
134 case 7: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[(4*(s_chan[ch].ADSRX.DecayRate^0x1F))-0x18+12+ 32]; break;\r
135 }\r
136\r
137 if(s_chan[ch].ADSRX.EnvelopeVol<0) s_chan[ch].ADSRX.EnvelopeVol=0;\r
138 if(((s_chan[ch].ADSRX.EnvelopeVol>>27)&0xF) <= s_chan[ch].ADSRX.SustainLevel)\r
139 {\r
140 s_chan[ch].ADSRX.State=2;\r
141 }\r
142\r
6d866bb7 143 return s_chan[ch].ADSRX.EnvelopeVol>>21;\r
ef79bbde
P		 144 }\r
145 //--------------------------------------------------//\r
146 if(s_chan[ch].ADSRX.State==2) // -> sustain\r
147 {\r
148 if(s_chan[ch].ADSRX.SustainIncrease)\r
149 {\r
150 if(s_chan[ch].ADSRX.SustainModeExp)\r
151 {\r
152 if(s_chan[ch].ADSRX.EnvelopeVol<0x60000000) \r
153 s_chan[ch].ADSRX.EnvelopeVol+=RateTable[(s_chan[ch].ADSRX.SustainRate^0x7F)-0x10 + 32];\r
154 else\r
155 s_chan[ch].ADSRX.EnvelopeVol+=RateTable[(s_chan[ch].ADSRX.SustainRate^0x7F)-0x18 + 32];\r
156 }\r
157 else\r
158 {\r
159 s_chan[ch].ADSRX.EnvelopeVol+=RateTable[(s_chan[ch].ADSRX.SustainRate^0x7F)-0x10 + 32];\r
160 }\r
161\r
162 if(s_chan[ch].ADSRX.EnvelopeVol<0) \r
163 {\r
164 s_chan[ch].ADSRX.EnvelopeVol=0x7FFFFFFF;\r
165 }\r
166 }\r
167 else\r
168 {\r
169 if(s_chan[ch].ADSRX.SustainModeExp)\r
170 {\r
171 switch((s_chan[ch].ADSRX.EnvelopeVol>>28)&0x7)\r
172 {\r
173 case 0: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[((s_chan[ch].ADSRX.SustainRate^0x7F))-0x1B +0 + 32];break;\r
174 case 1: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[((s_chan[ch].ADSRX.SustainRate^0x7F))-0x1B +4 + 32];break;\r
175 case 2: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[((s_chan[ch].ADSRX.SustainRate^0x7F))-0x1B +6 + 32];break;\r
176 case 3: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[((s_chan[ch].ADSRX.SustainRate^0x7F))-0x1B +8 + 32];break;\r
177 case 4: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[((s_chan[ch].ADSRX.SustainRate^0x7F))-0x1B +9 + 32];break;\r
178 case 5: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[((s_chan[ch].ADSRX.SustainRate^0x7F))-0x1B +10+ 32];break;\r
179 case 6: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[((s_chan[ch].ADSRX.SustainRate^0x7F))-0x1B +11+ 32];break;\r
180 case 7: s_chan[ch].ADSRX.EnvelopeVol-=RateTable[((s_chan[ch].ADSRX.SustainRate^0x7F))-0x1B +12+ 32];break;\r
181 }\r
182 }\r
183 else\r
184 {\r
185 s_chan[ch].ADSRX.EnvelopeVol-=RateTable[((s_chan[ch].ADSRX.SustainRate^0x7F))-0x0F + 32];\r
186 }\r
187\r
188 if(s_chan[ch].ADSRX.EnvelopeVol<0) \r
189 {\r
190 s_chan[ch].ADSRX.EnvelopeVol=0;\r
191 }\r
192 }\r
6d866bb7 193 return s_chan[ch].ADSRX.EnvelopeVol>>21;\r
ef79bbde
P		 194 }\r
195 }\r
196 return 0;\r
197}\r
198\r
199#endif\r
200\r
201/*\r
202James Higgs ADSR investigations:\r
203\r
204PSX SPU Envelope Timings\r
205~~~~~~~~~~~~~~~~~~~~~~~~\r
206\r
207First, here is an extract from doomed's SPU doc, which explains the basics\r
208of the SPU "volume envelope": \r
209\r
210*** doomed doc extract start ***\r
211\r
212--------------------------------------------------------------------------\r
213Voices.\r
214--------------------------------------------------------------------------\r
215The SPU has 24 hardware voices. These voices can be used to reproduce sample\r
216data, noise or can be used as frequency modulator on the next voice.\r
217Each voice has it's own programmable ADSR envelope filter. The main volume\r
218can be programmed independently for left and right output.\r
219\r
220The ADSR envelope filter works as follows:\r
221Ar = Attack rate, which specifies the speed at which the volume increases\r
222 from zero to it's maximum value, as soon as the note on is given. The\r
223 slope can be set to lineair or exponential.\r
224Dr = Decay rate specifies the speed at which the volume decreases to the\r
225 sustain level. Decay is always decreasing exponentially.\r
226Sl = Sustain level, base level from which sustain starts.\r
227Sr = Sustain rate is the rate at which the volume of the sustained note\r
228 increases or decreases. This can be either lineair or exponential.\r
229Rr = Release rate is the rate at which the volume of the note decreases\r
230 as soon as the note off is given.\r
231\r
232 lvl |\r
233 ^ | /\Dr __\r
234 Sl _| _ / _ \__--- \\r
235 | / ---__ \ Rr\r
236 | /Ar Sr \ \\r
237 | / \\\r
238 |/___________________\________\r
239 ->time\r
240\r
241The overal volume can also be set to sweep up or down lineairly or\r
242exponentially from it's current value. This can be done seperately\r
243for left and right.\r
244\r
245Relevant SPU registers:\r
246-------------------------------------------------------------\r
247$1f801xx8 Attack/Decay/Sustain level\r
248bit |0f|0e 0d 0c 0b 0a 09 08|07 06 05 04|03 02 01 00|\r
249desc.|Am| Ar |Dr |Sl |\r
250\r
251Am 0 Attack mode Linear\r
252 1 Exponential\r
253\r
254Ar 0-7f attack rate\r
255Dr 0-f decay rate\r
256Sl 0-f sustain level\r
257-------------------------------------------------------------\r
258$1f801xxa Sustain rate, Release Rate.\r
259bit |0f|0e|0d|0c 0b 0a 09 08 07 06|05|04 03 02 01 00|\r
260desc.|Sm|Sd| 0| Sr |Rm|Rr |\r
261\r
262Sm 0 sustain rate mode linear\r
263 1 exponential\r
264Sd 0 sustain rate mode increase\r
265 1 decrease\r
266Sr 0-7f Sustain Rate\r
267Rm 0 Linear decrease\r
268 1 Exponential decrease\r
269Rr 0-1f Release Rate\r
270\r
271Note: decay mode is always Expontial decrease, and thus cannot\r
272be set.\r
273-------------------------------------------------------------\r
274$1f801xxc Current ADSR volume\r
275bit |0f 0e 0d 0c 0b 0a 09 08 07 06 05 04 03 02 01 00|\r
276desc.|ADSRvol |\r
277\r
278ADSRvol Returns the current envelope volume when\r
279 read.\r
280-- James' Note: return range: 0 -> 32767\r
281\r
282*** doomed doc extract end *** \r
283\r
284By using a small PSX proggie to visualise the envelope as it was played,\r
285the following results for envelope timing were obtained:\r
286\r
2871. Attack rate value (linear mode)\r
288\r
289 Attack value range: 0 -> 127\r
290\r
291 Value | 48 | 52 | 56 | 60 | 64 | 68 | 72 | | 80 |\r
292 -----------------------------------------------------------------\r
293 Frames | 11 | 21 | 42 | 84 | 169| 338| 676| |2890|\r
294\r
295 Note: frames is no. of PAL frames to reach full volume (100%\r
296 amplitude)\r
297\r
298 Hmm, noticing that the time taken to reach full volume doubles\r
299 every time we add 4 to our attack value, we know the equation is\r
300 of form:\r
301 frames = k * 2 ^ (value / 4)\r
302\r
303 (You may ponder about envelope generator hardware at this point,\r
304 or maybe not... :)\r
305\r
306 By substituting some stuff and running some checks, we get:\r
307\r
308 k = 0.00257 (close enuf)\r
309\r
310 therefore,\r
311 frames = 0.00257 * 2 ^ (value / 4)\r
312 If you just happen to be writing an emulator, then you can probably\r
313 use an equation like:\r
314\r
315 %volume_increase_per_tick = 1 / frames\r
316\r
317\r
318 ------------------------------------\r
319 Pete:\r
320 ms=((1<<(value>>2))*514)/10000\r
321 ------------------------------------\r
322\r
3232. Decay rate value (only has log mode)\r
324\r
325 Decay value range: 0 -> 15\r
326\r
327 Value | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |\r
328 ------------------------------------------------\r
329 frames | | | | | 6 | 12 | 24 | 47 |\r
330\r
331 Note: frames here is no. of PAL frames to decay to 50% volume.\r
332\r
333 formula: frames = k * 2 ^ (value)\r
334\r
335 Substituting, we get: k = 0.00146\r
336\r
337 Further info on logarithmic nature:\r
338 frames to decay to sustain level 3 = 3 * frames to decay to \r
339 sustain level 9\r
340\r
341 Also no. of frames to 25% volume = roughly 1.85 * no. of frames to\r
342 50% volume.\r
343\r
344 Frag it - just use linear approx.\r
345\r
346 ------------------------------------\r
347 Pete:\r
348 ms=((1<<value)*292)/10000\r
349 ------------------------------------\r
350\r
351\r
3523. Sustain rate value (linear mode)\r
353\r
354 Sustain rate range: 0 -> 127\r
355\r
356 Value | 48 | 52 | 56 | 60 | 64 | 68 | 72 |\r
357 -------------------------------------------\r
358 frames | 9 | 19 | 37 | 74 | 147| 293| 587|\r
359\r
360 Here, frames = no. of PAL frames for volume amplitude to go from 100%\r
361 to 0% (or vice-versa).\r
362\r
363 Same formula as for attack value, just a different value for k:\r
364\r
365 k = 0.00225\r
366\r
367 ie: frames = 0.00225 * 2 ^ (value / 4)\r
368\r
369 For emulation purposes:\r
370\r
371 %volume_increase_or_decrease_per_tick = 1 / frames\r
372\r
373 ------------------------------------\r
374 Pete:\r
375 ms=((1<<(value>>2))*450)/10000\r
376 ------------------------------------\r
377\r
378\r
3794. Release rate (linear mode)\r
380\r
381 Release rate range: 0 -> 31\r
382\r
383 Value | 13 | 14 | 15 | 16 | 17 |\r
384 ---------------------------------------------------------------\r
385 frames | 18 | 36 | 73 | 146| 292|\r
386\r
387 Here, frames = no. of PAL frames to decay from 100% vol to 0% vol\r
388 after "note-off" is triggered.\r
389\r
390 Formula: frames = k * 2 ^ (value)\r
391\r
392 And so: k = 0.00223\r
393\r
394 ------------------------------------\r
395 Pete:\r
396 ms=((1<<value)*446)/10000\r
397 ------------------------------------\r
398\r
399\r
400Other notes: \r
401\r
402Log stuff not figured out. You may get some clues from the "Decay rate"\r
403stuff above. For emu purposes it may not be important - use linear\r
404approx.\r
405\r
406To get timings in millisecs, multiply frames by 20.\r
407\r
408\r
409\r
410- James Higgs 17/6/2000\r
411james7780@yahoo.com\r
412\r
413//---------------------------------------------------------------\r
414\r
415OLD adsr mixing according to james' rules... has to be called\r
416every one millisecond\r
417\r
418\r
419 long v,v2,lT,l1,l2,l3;\r
420\r
421 if(s_chan[ch].bStop) // psx wants to stop? -> release phase\r
422 {\r
423 if(s_chan[ch].ADSR.ReleaseVal!=0) // -> release not 0: do release (if 0: stop right now)\r
424 {\r
425 if(!s_chan[ch].ADSR.ReleaseVol) // --> release just started? set up the release stuff\r
426 {\r
427 s_chan[ch].ADSR.ReleaseStartTime=s_chan[ch].ADSR.lTime;\r
428 s_chan[ch].ADSR.ReleaseVol=s_chan[ch].ADSR.lVolume;\r
429 s_chan[ch].ADSR.ReleaseTime = // --> calc how long does it take to reach the wanted sus level\r
430 (s_chan[ch].ADSR.ReleaseTime*\r
431 s_chan[ch].ADSR.ReleaseVol)/1024;\r
432 }\r
433 // -> NO release exp mode used (yet)\r
434 v=s_chan[ch].ADSR.ReleaseVol; // -> get last volume\r
435 lT=s_chan[ch].ADSR.lTime- // -> how much time is past?\r
436 s_chan[ch].ADSR.ReleaseStartTime;\r
437 l1=s_chan[ch].ADSR.ReleaseTime;\r
438 \r
439 if(lT<l1) // -> we still have to release\r
440 {\r
441 v=v-((v*lT)/l1); // --> calc new volume\r
442 }\r
443 else // -> release is over: now really stop that sample\r
444 {v=0;s_chan[ch].bOn=0;s_chan[ch].ADSR.ReleaseVol=0;s_chan[ch].bNoise=0;}\r
445 }\r
446 else // -> release IS 0: release at once\r
447 {\r
448 v=0;s_chan[ch].bOn=0;s_chan[ch].ADSR.ReleaseVol=0;s_chan[ch].bNoise=0;\r
449 }\r
450 }\r
451 else \r
452 {//--------------------------------------------------// not in release phase:\r
453 v=1024;\r
454 lT=s_chan[ch].ADSR.lTime;\r
455 l1=s_chan[ch].ADSR.AttackTime;\r
456 \r
457 if(lT<l1) // attack\r
458 { // no exp mode used (yet)\r
459// if(s_chan[ch].ADSR.AttackModeExp)\r
460// {\r
461// v=(v*lT)/l1;\r
462// }\r
463// else\r
464 {\r
465 v=(v*lT)/l1;\r
466 }\r
467 if(v==0) v=1;\r
468 }\r
469 else // decay\r
470 { // should be exp, but who cares? ;)\r
471 l2=s_chan[ch].ADSR.DecayTime;\r
472 v2=s_chan[ch].ADSR.SustainLevel;\r
473\r
474 lT-=l1;\r
475 if(lT<l2)\r
476 {\r
477 v-=(((v-v2)*lT)/l2);\r
478 }\r
479 else // sustain\r
480 { // no exp mode used (yet)\r
481 l3=s_chan[ch].ADSR.SustainTime;\r
482 lT-=l2;\r
483 if(s_chan[ch].ADSR.SustainModeDec>0)\r
484 {\r
485 if(l3!=0) v2+=((v-v2)*lT)/l3;\r
486 else v2=v;\r
487 }\r
488 else\r
489 {\r
490 if(l3!=0) v2-=(v2*lT)/l3;\r
491 else v2=v;\r
492 }\r
493\r
494 if(v2>v) v2=v;\r
495 if(v2<=0) {v2=0;s_chan[ch].bOn=0;s_chan[ch].ADSR.ReleaseVol=0;s_chan[ch].bNoise=0;}\r
496\r
497 v=v2;\r
498 }\r
499 }\r
500 }\r
501\r
502 //----------------------------------------------------// \r
503 // ok, done for this channel, so increase time\r
504\r
505 s_chan[ch].ADSR.lTime+=1; // 1 = 1.020408f ms; \r
506\r
507 if(v>1024) v=1024; // adjust volume\r
508 if(v<0) v=0; \r
509 s_chan[ch].ADSR.lVolume=v; // store act volume\r
510\r
511 return v; // return the volume factor\r
512*/\r
513\r
514\r
515//-----------------------------------------------------------------------------\r
516//-----------------------------------------------------------------------------\r
517//-----------------------------------------------------------------------------\r
518\r
519\r
520/*\r
521-----------------------------------------------------------------------------\r
522Neill Corlett\r
523Playstation SPU envelope timing notes\r
524-----------------------------------------------------------------------------\r
525\r
526This is preliminary. This may be wrong. But the model described herein fits\r
527all of my experimental data, and it's just simple enough to sound right.\r
528\r
529ADSR envelope level ranges from 0x00000000 to 0x7FFFFFFF internally.\r
530The value returned by channel reg 0xC is (envelope_level>>16).\r
531\r
532Each sample, an increment or decrement value will be added to or\r
533subtracted from this envelope level.\r
534\r
535Create the rate log table. The values double every 4 entries.\r
536 entry #0 = 4\r
537\r
538 4, 5, 6, 7,\r
539 8,10,12,14,\r
540 16,20,24,28, ...\r
541\r
542 entry #40 = 4096...\r
543 entry #44 = 8192...\r
544 entry #48 = 16384...\r
545 entry #52 = 32768...\r
546 entry #56 = 65536...\r
547\r
548increments and decrements are in terms of ratelogtable[n]\r
549n may exceed the table bounds (plan on n being between -32 and 127).\r
550table values are all clipped between 0x00000000 and 0x3FFFFFFF\r
551\r
552when you "voice on", the envelope is always fully reset.\r
553(yes, it may click. the real thing does this too.)\r
554\r
555envelope level begins at zero.\r
556\r
557each state happens for at least 1 cycle\r
558(transitions are not instantaneous)\r
559this may result in some oddness: if the decay rate is uberfast, it will cut\r
560the envelope from full down to half in one sample, potentially skipping over\r
561the sustain level\r
562\r
563ATTACK\r
564------\r
565- if the envelope level has overflowed past the max, clip to 0x7FFFFFFF and\r
566 proceed to DECAY.\r
567\r
568Linear attack mode:\r
569- line extends upward to 0x7FFFFFFF\r
570- increment per sample is ratelogtable[(Ar^0x7F)-0x10]\r
571\r
572Logarithmic attack mode:\r
573if envelope_level < 0x60000000:\r
574 - line extends upward to 0x60000000\r
575 - increment per sample is ratelogtable[(Ar^0x7F)-0x10]\r
576else:\r
577 - line extends upward to 0x7FFFFFFF\r
578 - increment per sample is ratelogtable[(Ar^0x7F)-0x18]\r
579\r
580DECAY\r
581-----\r
582- if ((envelope_level>>27)&0xF) <= Sl, proceed to SUSTAIN.\r
583 Do not clip to the sustain level.\r
584- current line ends at (envelope_level & 0x07FFFFFF)\r
585- decrement per sample depends on (envelope_level>>28)&0x7\r
586 0: ratelogtable[(4*(Dr^0x1F))-0x18+0]\r
587 1: ratelogtable[(4*(Dr^0x1F))-0x18+4]\r
588 2: ratelogtable[(4*(Dr^0x1F))-0x18+6]\r
589 3: ratelogtable[(4*(Dr^0x1F))-0x18+8]\r
590 4: ratelogtable[(4*(Dr^0x1F))-0x18+9]\r
591 5: ratelogtable[(4*(Dr^0x1F))-0x18+10]\r
592 6: ratelogtable[(4*(Dr^0x1F))-0x18+11]\r
593 7: ratelogtable[(4*(Dr^0x1F))-0x18+12]\r
594 (note that this is the same as the release rate formula, except that\r
595 decay rates 10-1F aren't possible... those would be slower in theory)\r
596\r
597SUSTAIN\r
598-------\r
599- no terminating condition except for voice off\r
600- Sd=0 (increase) behavior is identical to ATTACK for both log and linear.\r
601- Sd=1 (decrease) behavior:\r
602Linear sustain decrease:\r
603- line extends to 0x00000000\r
604- decrement per sample is ratelogtable[(Sr^0x7F)-0x0F]\r
605Logarithmic sustain decrease:\r
606- current line ends at (envelope_level & 0x07FFFFFF)\r
607- decrement per sample depends on (envelope_level>>28)&0x7\r
608 0: ratelogtable[(Sr^0x7F)-0x1B+0]\r
609 1: ratelogtable[(Sr^0x7F)-0x1B+4]\r
610 2: ratelogtable[(Sr^0x7F)-0x1B+6]\r
611 3: ratelogtable[(Sr^0x7F)-0x1B+8]\r
612 4: ratelogtable[(Sr^0x7F)-0x1B+9]\r
613 5: ratelogtable[(Sr^0x7F)-0x1B+10]\r
614 6: ratelogtable[(Sr^0x7F)-0x1B+11]\r
615 7: ratelogtable[(Sr^0x7F)-0x1B+12]\r
616\r
617RELEASE\r
618-------\r
619- if the envelope level has overflowed to negative, clip to 0 and QUIT.\r
620\r
621Linear release mode:\r
622- line extends to 0x00000000\r
623- decrement per sample is ratelogtable[(4*(Rr^0x1F))-0x0C]\r
624\r
625Logarithmic release mode:\r
626- line extends to (envelope_level & 0x0FFFFFFF)\r
627- decrement per sample depends on (envelope_level>>28)&0x7\r
628 0: ratelogtable[(4*(Rr^0x1F))-0x18+0]\r
629 1: ratelogtable[(4*(Rr^0x1F))-0x18+4]\r
630 2: ratelogtable[(4*(Rr^0x1F))-0x18+6]\r
631 3: ratelogtable[(4*(Rr^0x1F))-0x18+8]\r
632 4: ratelogtable[(4*(Rr^0x1F))-0x18+9]\r
633 5: ratelogtable[(4*(Rr^0x1F))-0x18+10]\r
634 6: ratelogtable[(4*(Rr^0x1F))-0x18+11]\r
635 7: ratelogtable[(4*(Rr^0x1F))-0x18+12]\r
636\r
637-----------------------------------------------------------------------------\r
638*/\r
639\r
ARM optimized PCSX fork