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