1 /***************************************************************************
\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
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
16 ***************************************************************************/
\r
22 // will be included from spu.c
\r
25 ////////////////////////////////////////////////////////////////////////
\r
27 ////////////////////////////////////////////////////////////////////////
\r
29 static int RateTableAdd[128];
\r
30 static int RateTableSub[128];
\r
32 void InitADSR(void) // INIT ADSR
\r
36 // Optimize table - Dr. Hell ADSR math
\r
37 for (lcv = 0; lcv < 48; lcv++)
\r
39 RateTableAdd[lcv] = (7 - (lcv&3)) << (11 + 16 - (lcv >> 2));
\r
40 RateTableSub[lcv] = (-8 + (lcv&3)) << (11 + 16 - (lcv >> 2));
\r
43 for (; lcv < 128; lcv++)
\r
45 denom = 1 << ((lcv>>2) - 11);
\r
47 RateTableAdd[lcv] = ((7 - (lcv&3)) << 16) / denom;
\r
48 RateTableSub[lcv] = ((-8 + (lcv&3)) << 16) / denom;
\r
50 // XXX: this is wrong, we need more bits..
\r
51 if (RateTableAdd[lcv] == 0)
\r
52 RateTableAdd[lcv] = 1;
\r
56 ////////////////////////////////////////////////////////////////////////
\r
58 INLINE void StartADSR(int ch) // MIX ADSR
\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
64 ////////////////////////////////////////////////////////////////////////
\r
66 static int MixADSR(ADSRInfoEx *adsr, int ns_to)
\r
68 int EnvelopeVol = adsr->EnvelopeVol;
\r
69 int ns = 0, val, rto, level;
\r
71 if (adsr->State == ADSR_RELEASE)
\r
73 val = RateTableSub[adsr->ReleaseRate * 4];
\r
75 if (adsr->ReleaseModeExp)
\r
77 for (; ns < ns_to; ns++)
\r
79 EnvelopeVol += ((long long)val * EnvelopeVol) >> (15+16);
\r
80 if (EnvelopeVol <= 0)
\r
83 ChanBuf[ns] *= EnvelopeVol >> 21;
\r
89 for (; ns < ns_to; ns++)
\r
92 if (EnvelopeVol <= 0)
\r
95 ChanBuf[ns] *= EnvelopeVol >> 21;
\r
103 switch (adsr->State)
\r
105 case ADSR_ATTACK: // -> attack
\r
107 if (adsr->AttackModeExp && EnvelopeVol >= 0x60000000)
\r
109 val = RateTableAdd[adsr->AttackRate + rto];
\r
111 for (; ns < ns_to; ns++)
\r
113 EnvelopeVol += val;
\r
114 if (EnvelopeVol < 0)
\r
117 ChanBuf[ns] *= EnvelopeVol >> 21;
\r
118 ChanBuf[ns] >>= 10;
\r
121 if (EnvelopeVol < 0) // overflow
\r
123 EnvelopeVol = 0x7fffffff;
\r
124 adsr->State = ADSR_DECAY;
\r
125 ns++; // sample is good already
\r
130 //--------------------------------------------------//
\r
132 case ADSR_DECAY: // -> decay
\r
133 val = RateTableSub[adsr->DecayRate * 4];
\r
134 level = adsr->SustainLevel;
\r
136 for (; ns < ns_to; )
\r
138 EnvelopeVol += ((long long)val * EnvelopeVol) >> (15+16);
\r
139 if (EnvelopeVol < 0)
\r
142 ChanBuf[ns] *= EnvelopeVol >> 21;
\r
143 ChanBuf[ns] >>= 10;
\r
146 if (((EnvelopeVol >> 27) & 0xf) <= level)
\r
148 adsr->State = ADSR_SUSTAIN;
\r
154 //--------------------------------------------------//
\r
156 case ADSR_SUSTAIN: // -> sustain
\r
157 if (adsr->SustainIncrease)
\r
159 if (EnvelopeVol >= 0x7fff0000)
\r
166 if (adsr->SustainModeExp && EnvelopeVol >= 0x60000000)
\r
168 val = RateTableAdd[adsr->SustainRate + rto];
\r
170 for (; ns < ns_to; ns++)
\r
172 EnvelopeVol += val;
\r
173 if ((unsigned int)EnvelopeVol >= 0x7fe00000)
\r
175 EnvelopeVol = 0x7fffffff;
\r
180 ChanBuf[ns] *= EnvelopeVol >> 21;
\r
181 ChanBuf[ns] >>= 10;
\r
186 val = RateTableSub[adsr->SustainRate];
\r
187 if (adsr->SustainModeExp)
\r
189 for (; ns < ns_to; ns++)
\r
191 EnvelopeVol += ((long long)val * EnvelopeVol) >> (15+16);
\r
192 if (EnvelopeVol < 0)
\r
195 ChanBuf[ns] *= EnvelopeVol >> 21;
\r
196 ChanBuf[ns] >>= 10;
\r
201 for (; ns < ns_to; ns++)
\r
203 EnvelopeVol += val;
\r
204 if (EnvelopeVol < 0)
\r
207 ChanBuf[ns] *= EnvelopeVol >> 21;
\r
208 ChanBuf[ns] >>= 10;
\r
216 adsr->EnvelopeVol = EnvelopeVol;
\r
220 static int SkipADSR(ADSRInfoEx *adsr, int ns_to)
\r
222 int EnvelopeVol = adsr->EnvelopeVol;
\r
223 int ns = 0, val, rto, level;
\r
225 if (adsr->State == ADSR_RELEASE)
\r
227 val = RateTableSub[adsr->ReleaseRate * 4];
\r
228 if (adsr->ReleaseModeExp)
\r
230 for (; ns < ns_to; ns++)
\r
232 EnvelopeVol += ((long long)val * EnvelopeVol) >> (15+16);
\r
233 if (EnvelopeVol <= 0)
\r
239 EnvelopeVol += val * ns_to;
\r
240 if (EnvelopeVol > 0)
\r
246 switch (adsr->State)
\r
248 case ADSR_ATTACK: // -> attack
\r
250 if (adsr->AttackModeExp && EnvelopeVol >= 0x60000000)
\r
252 val = RateTableAdd[adsr->AttackRate + rto];
\r
254 for (; ns < ns_to; ns++)
\r
256 EnvelopeVol += val;
\r
257 if (EnvelopeVol < 0)
\r
260 if (EnvelopeVol < 0) // overflow
\r
262 EnvelopeVol = 0x7fffffff;
\r
263 adsr->State = ADSR_DECAY;
\r
269 //--------------------------------------------------//
\r
271 case ADSR_DECAY: // -> decay
\r
272 val = RateTableSub[adsr->DecayRate * 4];
\r
273 level = adsr->SustainLevel;
\r
275 for (; ns < ns_to; )
\r
277 EnvelopeVol += ((long long)val * EnvelopeVol) >> (15+16);
\r
278 if (EnvelopeVol < 0)
\r
283 if (((EnvelopeVol >> 27) & 0xf) <= level)
\r
285 adsr->State = ADSR_SUSTAIN;
\r
291 //--------------------------------------------------//
\r
293 case ADSR_SUSTAIN: // -> sustain
\r
294 if (adsr->SustainIncrease)
\r
296 if (EnvelopeVol >= 0x7fff0000)
\r
303 if (adsr->SustainModeExp && EnvelopeVol >= 0x60000000)
\r
305 val = RateTableAdd[adsr->SustainRate + rto];
\r
307 EnvelopeVol += val * (ns_to - ns);
\r
308 if ((unsigned int)EnvelopeVol >= 0x7fe00000)
\r
310 EnvelopeVol = 0x7fffffff;
\r
317 val = RateTableSub[adsr->SustainRate];
\r
318 if (adsr->SustainModeExp)
\r
320 for (; ns < ns_to; ns++)
\r
322 EnvelopeVol += ((long long)val * EnvelopeVol) >> (15+16);
\r
323 if (EnvelopeVol < 0)
\r
329 EnvelopeVol += val * (ns_to - ns);
\r
330 if (EnvelopeVol > 0)
\r
341 adsr->EnvelopeVol = EnvelopeVol;
\r
348 James Higgs ADSR investigations:
\r
350 PSX SPU Envelope Timings
\r
351 ~~~~~~~~~~~~~~~~~~~~~~~~
\r
353 First, here is an extract from doomed's SPU doc, which explains the basics
\r
354 of the SPU "volume envelope":
\r
356 *** doomed doc extract start ***
\r
358 --------------------------------------------------------------------------
\r
360 --------------------------------------------------------------------------
\r
361 The SPU has 24 hardware voices. These voices can be used to reproduce sample
\r
362 data, noise or can be used as frequency modulator on the next voice.
\r
363 Each voice has it's own programmable ADSR envelope filter. The main volume
\r
364 can be programmed independently for left and right output.
\r
366 The ADSR envelope filter works as follows:
\r
367 Ar = Attack rate, which specifies the speed at which the volume increases
\r
368 from zero to it's maximum value, as soon as the note on is given. The
\r
369 slope can be set to lineair or exponential.
\r
370 Dr = Decay rate specifies the speed at which the volume decreases to the
\r
371 sustain level. Decay is always decreasing exponentially.
\r
372 Sl = Sustain level, base level from which sustain starts.
\r
373 Sr = Sustain rate is the rate at which the volume of the sustained note
\r
374 increases or decreases. This can be either lineair or exponential.
\r
375 Rr = Release rate is the rate at which the volume of the note decreases
\r
376 as soon as the note off is given.
\r
380 Sl _| _ / _ \__--- \
\r
384 |/___________________\________
\r
387 The overal volume can also be set to sweep up or down lineairly or
\r
388 exponentially from it's current value. This can be done seperately
\r
389 for left and right.
\r
391 Relevant SPU registers:
\r
392 -------------------------------------------------------------
\r
393 $1f801xx8 Attack/Decay/Sustain level
\r
394 bit |0f|0e 0d 0c 0b 0a 09 08|07 06 05 04|03 02 01 00|
\r
395 desc.|Am| Ar |Dr |Sl |
\r
397 Am 0 Attack mode Linear
\r
400 Ar 0-7f attack rate
\r
402 Sl 0-f sustain level
\r
403 -------------------------------------------------------------
\r
404 $1f801xxa Sustain rate, Release Rate.
\r
405 bit |0f|0e|0d|0c 0b 0a 09 08 07 06|05|04 03 02 01 00|
\r
406 desc.|Sm|Sd| 0| Sr |Rm|Rr |
\r
408 Sm 0 sustain rate mode linear
\r
410 Sd 0 sustain rate mode increase
\r
412 Sr 0-7f Sustain Rate
\r
413 Rm 0 Linear decrease
\r
414 1 Exponential decrease
\r
415 Rr 0-1f Release Rate
\r
417 Note: decay mode is always Expontial decrease, and thus cannot
\r
419 -------------------------------------------------------------
\r
420 $1f801xxc Current ADSR volume
\r
421 bit |0f 0e 0d 0c 0b 0a 09 08 07 06 05 04 03 02 01 00|
\r
424 ADSRvol Returns the current envelope volume when
\r
426 -- James' Note: return range: 0 -> 32767
\r
428 *** doomed doc extract end ***
\r
430 By using a small PSX proggie to visualise the envelope as it was played,
\r
431 the following results for envelope timing were obtained:
\r
433 1. Attack rate value (linear mode)
\r
435 Attack value range: 0 -> 127
\r
437 Value | 48 | 52 | 56 | 60 | 64 | 68 | 72 | | 80 |
\r
438 -----------------------------------------------------------------
\r
439 Frames | 11 | 21 | 42 | 84 | 169| 338| 676| |2890|
\r
441 Note: frames is no. of PAL frames to reach full volume (100%
\r
444 Hmm, noticing that the time taken to reach full volume doubles
\r
445 every time we add 4 to our attack value, we know the equation is
\r
447 frames = k * 2 ^ (value / 4)
\r
449 (You may ponder about envelope generator hardware at this point,
\r
452 By substituting some stuff and running some checks, we get:
\r
454 k = 0.00257 (close enuf)
\r
457 frames = 0.00257 * 2 ^ (value / 4)
\r
458 If you just happen to be writing an emulator, then you can probably
\r
459 use an equation like:
\r
461 %volume_increase_per_tick = 1 / frames
\r
464 ------------------------------------
\r
466 ms=((1<<(value>>2))*514)/10000
\r
467 ------------------------------------
\r
469 2. Decay rate value (only has log mode)
\r
471 Decay value range: 0 -> 15
\r
473 Value | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
\r
474 ------------------------------------------------
\r
475 frames | | | | | 6 | 12 | 24 | 47 |
\r
477 Note: frames here is no. of PAL frames to decay to 50% volume.
\r
479 formula: frames = k * 2 ^ (value)
\r
481 Substituting, we get: k = 0.00146
\r
483 Further info on logarithmic nature:
\r
484 frames to decay to sustain level 3 = 3 * frames to decay to
\r
487 Also no. of frames to 25% volume = roughly 1.85 * no. of frames to
\r
490 Frag it - just use linear approx.
\r
492 ------------------------------------
\r
494 ms=((1<<value)*292)/10000
\r
495 ------------------------------------
\r
498 3. Sustain rate value (linear mode)
\r
500 Sustain rate range: 0 -> 127
\r
502 Value | 48 | 52 | 56 | 60 | 64 | 68 | 72 |
\r
503 -------------------------------------------
\r
504 frames | 9 | 19 | 37 | 74 | 147| 293| 587|
\r
506 Here, frames = no. of PAL frames for volume amplitude to go from 100%
\r
507 to 0% (or vice-versa).
\r
509 Same formula as for attack value, just a different value for k:
\r
513 ie: frames = 0.00225 * 2 ^ (value / 4)
\r
515 For emulation purposes:
\r
517 %volume_increase_or_decrease_per_tick = 1 / frames
\r
519 ------------------------------------
\r
521 ms=((1<<(value>>2))*450)/10000
\r
522 ------------------------------------
\r
525 4. Release rate (linear mode)
\r
527 Release rate range: 0 -> 31
\r
529 Value | 13 | 14 | 15 | 16 | 17 |
\r
530 ---------------------------------------------------------------
\r
531 frames | 18 | 36 | 73 | 146| 292|
\r
533 Here, frames = no. of PAL frames to decay from 100% vol to 0% vol
\r
534 after "note-off" is triggered.
\r
536 Formula: frames = k * 2 ^ (value)
\r
538 And so: k = 0.00223
\r
540 ------------------------------------
\r
542 ms=((1<<value)*446)/10000
\r
543 ------------------------------------
\r
548 Log stuff not figured out. You may get some clues from the "Decay rate"
\r
549 stuff above. For emu purposes it may not be important - use linear
\r
552 To get timings in millisecs, multiply frames by 20.
\r
556 - James Higgs 17/6/2000
\r
557 james7780@yahoo.com
\r
559 //---------------------------------------------------------------
\r
561 OLD adsr mixing according to james' rules... has to be called
\r
562 every one millisecond
\r
565 long v,v2,lT,l1,l2,l3;
\r
567 if(s_chan[ch].bStop) // psx wants to stop? -> release phase
\r
569 if(s_chan[ch].ADSR.ReleaseVal!=0) // -> release not 0: do release (if 0: stop right now)
\r
571 if(!s_chan[ch].ADSR.ReleaseVol) // --> release just started? set up the release stuff
\r
573 s_chan[ch].ADSR.ReleaseStartTime=s_chan[ch].ADSR.lTime;
\r
574 s_chan[ch].ADSR.ReleaseVol=s_chan[ch].ADSR.lVolume;
\r
575 s_chan[ch].ADSR.ReleaseTime = // --> calc how long does it take to reach the wanted sus level
\r
576 (s_chan[ch].ADSR.ReleaseTime*
\r
577 s_chan[ch].ADSR.ReleaseVol)/1024;
\r
579 // -> NO release exp mode used (yet)
\r
580 v=s_chan[ch].ADSR.ReleaseVol; // -> get last volume
\r
581 lT=s_chan[ch].ADSR.lTime- // -> how much time is past?
\r
582 s_chan[ch].ADSR.ReleaseStartTime;
\r
583 l1=s_chan[ch].ADSR.ReleaseTime;
\r
585 if(lT<l1) // -> we still have to release
\r
587 v=v-((v*lT)/l1); // --> calc new volume
\r
589 else // -> release is over: now really stop that sample
\r
590 {v=0;s_chan[ch].bOn=0;s_chan[ch].ADSR.ReleaseVol=0;s_chan[ch].bNoise=0;}
\r
592 else // -> release IS 0: release at once
\r
594 v=0;s_chan[ch].bOn=0;s_chan[ch].ADSR.ReleaseVol=0;s_chan[ch].bNoise=0;
\r
598 {//--------------------------------------------------// not in release phase:
\r
600 lT=s_chan[ch].ADSR.lTime;
\r
601 l1=s_chan[ch].ADSR.AttackTime;
\r
603 if(lT<l1) // attack
\r
604 { // no exp mode used (yet)
\r
605 // if(s_chan[ch].ADSR.AttackModeExp)
\r
616 { // should be exp, but who cares? ;)
\r
617 l2=s_chan[ch].ADSR.DecayTime;
\r
618 v2=s_chan[ch].ADSR.SustainLevel;
\r
623 v-=(((v-v2)*lT)/l2);
\r
626 { // no exp mode used (yet)
\r
627 l3=s_chan[ch].ADSR.SustainTime;
\r
629 if(s_chan[ch].ADSR.SustainModeDec>0)
\r
631 if(l3!=0) v2+=((v-v2)*lT)/l3;
\r
636 if(l3!=0) v2-=(v2*lT)/l3;
\r
641 if(v2<=0) {v2=0;s_chan[ch].bOn=0;s_chan[ch].ADSR.ReleaseVol=0;s_chan[ch].bNoise=0;}
\r
648 //----------------------------------------------------//
\r
649 // ok, done for this channel, so increase time
\r
651 s_chan[ch].ADSR.lTime+=1; // 1 = 1.020408f ms;
\r
653 if(v>1024) v=1024; // adjust volume
\r
655 s_chan[ch].ADSR.lVolume=v; // store act volume
\r
657 return v; // return the volume factor
\r
661 //-----------------------------------------------------------------------------
\r
662 //-----------------------------------------------------------------------------
\r
663 //-----------------------------------------------------------------------------
\r
667 -----------------------------------------------------------------------------
\r
669 Playstation SPU envelope timing notes
\r
670 -----------------------------------------------------------------------------
\r
672 This is preliminary. This may be wrong. But the model described herein fits
\r
673 all of my experimental data, and it's just simple enough to sound right.
\r
675 ADSR envelope level ranges from 0x00000000 to 0x7FFFFFFF internally.
\r
676 The value returned by channel reg 0xC is (envelope_level>>16).
\r
678 Each sample, an increment or decrement value will be added to or
\r
679 subtracted from this envelope level.
\r
681 Create the rate log table. The values double every 4 entries.
\r
688 entry #40 = 4096...
\r
689 entry #44 = 8192...
\r
690 entry #48 = 16384...
\r
691 entry #52 = 32768...
\r
692 entry #56 = 65536...
\r
694 increments and decrements are in terms of ratelogtable[n]
\r
695 n may exceed the table bounds (plan on n being between -32 and 127).
\r
696 table values are all clipped between 0x00000000 and 0x3FFFFFFF
\r
698 when you "voice on", the envelope is always fully reset.
\r
699 (yes, it may click. the real thing does this too.)
\r
701 envelope level begins at zero.
\r
703 each state happens for at least 1 cycle
\r
704 (transitions are not instantaneous)
\r
705 this may result in some oddness: if the decay rate is uberfast, it will cut
\r
706 the envelope from full down to half in one sample, potentially skipping over
\r
711 - if the envelope level has overflowed past the max, clip to 0x7FFFFFFF and
\r
714 Linear attack mode:
\r
715 - line extends upward to 0x7FFFFFFF
\r
716 - increment per sample is ratelogtable[(Ar^0x7F)-0x10]
\r
718 Logarithmic attack mode:
\r
719 if envelope_level < 0x60000000:
\r
720 - line extends upward to 0x60000000
\r
721 - increment per sample is ratelogtable[(Ar^0x7F)-0x10]
\r
723 - line extends upward to 0x7FFFFFFF
\r
724 - increment per sample is ratelogtable[(Ar^0x7F)-0x18]
\r
728 - if ((envelope_level>>27)&0xF) <= Sl, proceed to SUSTAIN.
\r
729 Do not clip to the sustain level.
\r
730 - current line ends at (envelope_level & 0x07FFFFFF)
\r
731 - decrement per sample depends on (envelope_level>>28)&0x7
\r
732 0: ratelogtable[(4*(Dr^0x1F))-0x18+0]
\r
733 1: ratelogtable[(4*(Dr^0x1F))-0x18+4]
\r
734 2: ratelogtable[(4*(Dr^0x1F))-0x18+6]
\r
735 3: ratelogtable[(4*(Dr^0x1F))-0x18+8]
\r
736 4: ratelogtable[(4*(Dr^0x1F))-0x18+9]
\r
737 5: ratelogtable[(4*(Dr^0x1F))-0x18+10]
\r
738 6: ratelogtable[(4*(Dr^0x1F))-0x18+11]
\r
739 7: ratelogtable[(4*(Dr^0x1F))-0x18+12]
\r
740 (note that this is the same as the release rate formula, except that
\r
741 decay rates 10-1F aren't possible... those would be slower in theory)
\r
745 - no terminating condition except for voice off
\r
746 - Sd=0 (increase) behavior is identical to ATTACK for both log and linear.
\r
747 - Sd=1 (decrease) behavior:
\r
748 Linear sustain decrease:
\r
749 - line extends to 0x00000000
\r
750 - decrement per sample is ratelogtable[(Sr^0x7F)-0x0F]
\r
751 Logarithmic sustain decrease:
\r
752 - current line ends at (envelope_level & 0x07FFFFFF)
\r
753 - decrement per sample depends on (envelope_level>>28)&0x7
\r
754 0: ratelogtable[(Sr^0x7F)-0x1B+0]
\r
755 1: ratelogtable[(Sr^0x7F)-0x1B+4]
\r
756 2: ratelogtable[(Sr^0x7F)-0x1B+6]
\r
757 3: ratelogtable[(Sr^0x7F)-0x1B+8]
\r
758 4: ratelogtable[(Sr^0x7F)-0x1B+9]
\r
759 5: ratelogtable[(Sr^0x7F)-0x1B+10]
\r
760 6: ratelogtable[(Sr^0x7F)-0x1B+11]
\r
761 7: ratelogtable[(Sr^0x7F)-0x1B+12]
\r
765 - if the envelope level has overflowed to negative, clip to 0 and QUIT.
\r
767 Linear release mode:
\r
768 - line extends to 0x00000000
\r
769 - decrement per sample is ratelogtable[(4*(Rr^0x1F))-0x0C]
\r
771 Logarithmic release mode:
\r
772 - line extends to (envelope_level & 0x0FFFFFFF)
\r
773 - decrement per sample depends on (envelope_level>>28)&0x7
\r
774 0: ratelogtable[(4*(Rr^0x1F))-0x18+0]
\r
775 1: ratelogtable[(4*(Rr^0x1F))-0x18+4]
\r
776 2: ratelogtable[(4*(Rr^0x1F))-0x18+6]
\r
777 3: ratelogtable[(4*(Rr^0x1F))-0x18+8]
\r
778 4: ratelogtable[(4*(Rr^0x1F))-0x18+9]
\r
779 5: ratelogtable[(4*(Rr^0x1F))-0x18+10]
\r
780 6: ratelogtable[(4*(Rr^0x1F))-0x18+11]
\r
781 7: ratelogtable[(4*(Rr^0x1F))-0x18+12]
\r
783 -----------------------------------------------------------------------------
\r
786 // vim:shiftwidth=1:expandtab
\r