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