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