plugins/dfsound/registers.c

   1 /***************************************************************************\r
   2                          registers.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_REGISTERS\r
  21 \r
  22 #include "externals.h"\r
  23 #include "registers.h"\r
  24 #include "regs.h"\r
  25 #include "reverb.h"\r
  26 \r
  27 /*\r
  28 // adsr time values (in ms) by James Higgs ... see the end of\r
  29 // the adsr.c source for details\r
  30 \r
  31 #define ATTACK_MS     514L\r
  32 #define DECAYHALF_MS  292L\r
  33 #define DECAY_MS      584L\r
  34 #define SUSTAIN_MS    450L\r
  35 #define RELEASE_MS    446L\r
  36 */\r
  37 \r
  38 // we have a timebase of 1.020408f ms, not 1 ms... so adjust adsr defines\r
  39 #define ATTACK_MS      494L\r
  40 #define DECAYHALF_MS   286L\r
  41 #define DECAY_MS       572L\r
  42 #define SUSTAIN_MS     441L\r
  43 #define RELEASE_MS     437L\r
  44 \r
  45 ////////////////////////////////////////////////////////////////////////\r
  46 // WRITE REGISTERS: called by main emu\r
  47 ////////////////////////////////////////////////////////////////////////\r
  48 \r
  49 void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)\r
  50 {\r
  51  const unsigned long r=reg&0xfff;\r
  52  regArea[(r-0xc00)>>1] = val;\r
  53 \r
  54  if(r>=0x0c00 && r<0x0d80)                             // some channel info?\r
  55   {\r
  56    int ch=(r>>4)-0xc0;                                 // calc channel\r
  57    switch(r&0x0f)\r
  58     {\r
  59      //------------------------------------------------// r volume\r
  60      case 0:                                           \r
  61        SetVolumeL((unsigned char)ch,val);\r
  62        break;\r
  63      //------------------------------------------------// l volume\r
  64      case 2:                                           \r
  65        SetVolumeR((unsigned char)ch,val);\r
  66        break;\r
  67      //------------------------------------------------// pitch\r
  68      case 4:                                           \r
  69        SetPitch(ch,val);\r
  70        break;\r
  71      //------------------------------------------------// start\r
  72      case 6:      \r
  73        // Brain Dead 13 - align to 16 boundary\r
  74        s_chan[ch].pStart= spuMemC+(unsigned long)((val<<3)&~0xf);\r
  75        break;\r
  76      //------------------------------------------------// level with pre-calcs\r
  77      case 8:\r
  78        {\r
  79         const unsigned long lval=val;\r
  80         //---------------------------------------------//\r
  81         s_chan[ch].ADSRX.AttackModeExp=(lval&0x8000)?1:0; \r
  82         s_chan[ch].ADSRX.AttackRate=(lval>>8) & 0x007f;\r
  83         s_chan[ch].ADSRX.DecayRate=(lval>>4) & 0x000f;\r
  84         s_chan[ch].ADSRX.SustainLevel=lval & 0x000f;\r
  85         //---------------------------------------------//\r
  86 #if 0\r
  87         if(!iDebugMode) break;\r
  88         //---------------------------------------------// stuff below is only for debug mode\r
  89 \r
  90         s_chan[ch].ADSR.AttackModeExp=(lval&0x8000)?1:0;        //0x007f\r
  91 \r
  92         lx=(((lval>>8) & 0x007f)>>2);                  // attack time to run from 0 to 100% volume\r
  93         lx=min(31,lx);                                 // no overflow on shift!\r
  94         if(lx) \r
  95          { \r
  96           lx = (1<<lx);\r
  97           if(lx<2147483) lx=(lx*ATTACK_MS)/10000L;     // another overflow check\r
  98           else           lx=(lx/10000L)*ATTACK_MS;\r
  99           if(!lx) lx=1;\r
 100          }\r
 101         s_chan[ch].ADSR.AttackTime=lx;                \r
 102 \r
 103         s_chan[ch].ADSR.SustainLevel=                 // our adsr vol runs from 0 to 1024, so scale the sustain level\r
 104          (1024*((lval) & 0x000f))/15;\r
 105 \r
 106         lx=(lval>>4) & 0x000f;                         // decay:\r
 107         if(lx)                                         // our const decay value is time it takes from 100% to 0% of volume\r
 108          {\r
 109           lx = ((1<<(lx))*DECAY_MS)/10000L;\r
 110           if(!lx) lx=1;\r
 111          }\r
 112         s_chan[ch].ADSR.DecayTime =                   // so calc how long does it take to run from 100% to the wanted sus level\r
 113          (lx*(1024-s_chan[ch].ADSR.SustainLevel))/1024;\r
 114 #endif\r
 115        }\r
 116       break;\r
 117      //------------------------------------------------// adsr times with pre-calcs\r
 118      case 10:\r
 119       {\r
 120        const unsigned long lval=val;\r
 121 \r
 122        //----------------------------------------------//\r
 123        s_chan[ch].ADSRX.SustainModeExp = (lval&0x8000)?1:0;\r
 124        s_chan[ch].ADSRX.SustainIncrease= (lval&0x4000)?0:1;\r
 125        s_chan[ch].ADSRX.SustainRate = (lval>>6) & 0x007f;\r
 126        s_chan[ch].ADSRX.ReleaseModeExp = (lval&0x0020)?1:0;\r
 127        s_chan[ch].ADSRX.ReleaseRate = lval & 0x001f;\r
 128        //----------------------------------------------//\r
 129 #if 0\r
 130        if(!iDebugMode) break;\r
 131        //----------------------------------------------// stuff below is only for debug mode\r
 132 \r
 133        s_chan[ch].ADSR.SustainModeExp = (lval&0x8000)?1:0;\r
 134        s_chan[ch].ADSR.ReleaseModeExp = (lval&0x0020)?1:0;\r
 135                    \r
 136        lx=((((lval>>6) & 0x007f)>>2));                 // sustain time... often very high\r
 137        lx=min(31,lx);                                  // values are used to hold the volume\r
 138        if(lx)                                          // until a sound stop occurs\r
 139         {                                              // the highest value we reach (due to \r
 140          lx = (1<<lx);                                 // overflow checking) is: \r
 141          if(lx<2147483) lx=(lx*SUSTAIN_MS)/10000L;     // 94704 seconds = 1578 minutes = 26 hours... \r
 142          else           lx=(lx/10000L)*SUSTAIN_MS;     // should be enuff... if the stop doesn't \r
 143          if(!lx) lx=1;                                 // come in this time span, I don't care :)\r
 144         }\r
 145        s_chan[ch].ADSR.SustainTime = lx;\r
 146 \r
 147        lx=(lval & 0x001f);\r
 148        s_chan[ch].ADSR.ReleaseVal     =lx;\r
 149        if(lx)                                          // release time from 100% to 0%\r
 150         {                                              // note: the release time will be\r
 151          lx = (1<<lx);                                 // adjusted when a stop is coming,\r
 152          if(lx<2147483) lx=(lx*RELEASE_MS)/10000L;     // so at this time the adsr vol will \r
 153          else           lx=(lx/10000L)*RELEASE_MS;     // run from (current volume) to 0%\r
 154          if(!lx) lx=1;\r
 155         }\r
 156        s_chan[ch].ADSR.ReleaseTime=lx;\r
 157 \r
 158        if(lval & 0x4000)                               // add/dec flag\r
 159             s_chan[ch].ADSR.SustainModeDec=-1;\r
 160        else s_chan[ch].ADSR.SustainModeDec=1;\r
 161 #endif\r
 162       }\r
 163      break;\r
 164      //------------------------------------------------// adsr volume... mmm have to investigate this\r
 165      case 12:\r
 166        break;\r
 167      //------------------------------------------------//\r
 168      case 14:                                          // loop?\r
 169        //WaitForSingleObject(s_chan[ch].hMutex,2000);        // -> no multithread fuckups\r
 170        s_chan[ch].pLoop=spuMemC+((unsigned long)((val<<3)&~0xf));\r
 171        s_chan[ch].bIgnoreLoop=1;\r
 172        //ReleaseMutex(s_chan[ch].hMutex);                    // -> oki, on with the thread\r
 173        break;\r
 174      //------------------------------------------------//\r
 175     }\r
 176    iSpuAsyncWait=0;\r
 177    return;\r
 178   }\r
 179 \r
 180  switch(r)\r
 181    {\r
 182     //-------------------------------------------------//\r
 183     case H_SPUaddr:\r
 184       spuAddr = (unsigned long) val<<3;\r
 185       break;\r
 186     //-------------------------------------------------//\r
 187     case H_SPUdata:\r
 188       spuMem[spuAddr>>1] = val;\r
 189       spuAddr+=2;\r
 190       if(spuAddr>0x7ffff) spuAddr=0;\r
 191       break;\r
 192     //-------------------------------------------------//\r
 193     case H_SPUctrl:\r
 194       spuCtrl=val;\r
 195       break;\r
 196     //-------------------------------------------------//\r
 197     case H_SPUstat:\r
 198       spuStat=val & 0xf800;\r
 199       break;\r
 200     //-------------------------------------------------//\r
 201     case H_SPUReverbAddr:\r
 202       if(val==0xFFFF || val<=0x200)\r
 203        {rvb.StartAddr=rvb.CurrAddr=0;}\r
 204       else\r
 205        {\r
 206         const long iv=(unsigned long)val<<2;\r
 207         if(rvb.StartAddr!=iv)\r
 208          {\r
 209           rvb.StartAddr=(unsigned long)val<<2;\r
 210           rvb.CurrAddr=rvb.StartAddr;\r
 211          }\r
 212        }\r
 213       break;\r
 214     //-------------------------------------------------//\r
 215     case H_SPUirqAddr:\r
 216       spuIrq = val;\r
 217       pSpuIrq=spuMemC+((unsigned long) val<<3);\r
 218       break;\r
 219     //-------------------------------------------------//\r
 220     case H_SPUrvolL:\r
 221       rvb.VolLeft=val;\r
 222       break;\r
 223     //-------------------------------------------------//\r
 224     case H_SPUrvolR:\r
 225       rvb.VolRight=val;\r
 226       break;\r
 227     //-------------------------------------------------//\r
 228 \r
 229 /*\r
 230     case H_ExtLeft:\r
 231      //auxprintf("EL %d\n",val);\r
 232       break;\r
 233     //-------------------------------------------------//\r
 234     case H_ExtRight:\r
 235      //auxprintf("ER %d\n",val);\r
 236       break;\r
 237     //-------------------------------------------------//\r
 238     case H_SPUmvolL:\r
 239      //auxprintf("ML %d\n",val);\r
 240       break;\r
 241     //-------------------------------------------------//\r
 242     case H_SPUmvolR:\r
 243      //auxprintf("MR %d\n",val);\r
 244       break;\r
 245     //-------------------------------------------------//\r
 246     case H_SPUMute1:\r
 247      //auxprintf("M0 %04x\n",val);\r
 248       break;\r
 249     //-------------------------------------------------//\r
 250     case H_SPUMute2:\r
 251      //auxprintf("M1 %04x\n",val);\r
 252       break;\r
 253 */\r
 254     //-------------------------------------------------//\r
 255     case H_SPUon1:\r
 256       SoundOn(0,16,val);\r
 257       break;\r
 258     //-------------------------------------------------//\r
 259      case H_SPUon2:\r
 260       SoundOn(16,24,val);\r
 261       break;\r
 262     //-------------------------------------------------//\r
 263     case H_SPUoff1:\r
 264       SoundOff(0,16,val);\r
 265       break;\r
 266     //-------------------------------------------------//\r
 267     case H_SPUoff2:\r
 268       SoundOff(16,24,val);\r
 269       break;\r
 270     //-------------------------------------------------//\r
 271     case H_CDLeft:\r
 272       iLeftXAVol=val  & 0x7fff;\r
 273       if(cddavCallback) cddavCallback(0,val);\r
 274       break;\r
 275     case H_CDRight:\r
 276       iRightXAVol=val & 0x7fff;\r
 277       if(cddavCallback) cddavCallback(1,val);\r
 278       break;\r
 279     //-------------------------------------------------//\r
 280     case H_FMod1:\r
 281       FModOn(0,16,val);\r
 282       break;\r
 283     //-------------------------------------------------//\r
 284     case H_FMod2:\r
 285       FModOn(16,24,val);\r
 286       break;\r
 287     //-------------------------------------------------//\r
 288     case H_Noise1:\r
 289       NoiseOn(0,16,val);\r
 290       break;\r
 291     //-------------------------------------------------//\r
 292     case H_Noise2:\r
 293       NoiseOn(16,24,val);\r
 294       break;\r
 295     //-------------------------------------------------//\r
 296     case H_RVBon1:\r
 297       ReverbOn(0,16,val);\r
 298       break;\r
 299     //-------------------------------------------------//\r
 300     case H_RVBon2:\r
 301       ReverbOn(16,24,val);\r
 302       break;\r
 303     //-------------------------------------------------//\r
 304     case H_Reverb+0:\r
 305 \r
 306       rvb.FB_SRC_A=val;\r
 307 \r
 308       // OK, here's the fake REVERB stuff...\r
 309       // depending on effect we do more or less delay and repeats... bah\r
 310       // still... better than nothing :)\r
 311 \r
 312       SetREVERB(val);\r
 313       break;\r
 314 \r
 315 \r
 316     case H_Reverb+2   : rvb.FB_SRC_B=(short)val;       break;\r
 317     case H_Reverb+4   : rvb.IIR_ALPHA=(short)val;      break;\r
 318     case H_Reverb+6   : rvb.ACC_COEF_A=(short)val;     break;\r
 319     case H_Reverb+8   : rvb.ACC_COEF_B=(short)val;     break;\r
 320     case H_Reverb+10  : rvb.ACC_COEF_C=(short)val;     break;\r
 321     case H_Reverb+12  : rvb.ACC_COEF_D=(short)val;     break;\r
 322     case H_Reverb+14  : rvb.IIR_COEF=(short)val;       break;\r
 323     case H_Reverb+16  : rvb.FB_ALPHA=(short)val;       break;\r
 324     case H_Reverb+18  : rvb.FB_X=(short)val;           break;\r
 325     case H_Reverb+20  : rvb.IIR_DEST_A0=(short)val;    break;\r
 326     case H_Reverb+22  : rvb.IIR_DEST_A1=(short)val;    break;\r
 327     case H_Reverb+24  : rvb.ACC_SRC_A0=(short)val;     break;\r
 328     case H_Reverb+26  : rvb.ACC_SRC_A1=(short)val;     break;\r
 329     case H_Reverb+28  : rvb.ACC_SRC_B0=(short)val;     break;\r
 330     case H_Reverb+30  : rvb.ACC_SRC_B1=(short)val;     break;\r
 331     case H_Reverb+32  : rvb.IIR_SRC_A0=(short)val;     break;\r
 332     case H_Reverb+34  : rvb.IIR_SRC_A1=(short)val;     break;\r
 333     case H_Reverb+36  : rvb.IIR_DEST_B0=(short)val;    break;\r
 334     case H_Reverb+38  : rvb.IIR_DEST_B1=(short)val;    break;\r
 335     case H_Reverb+40  : rvb.ACC_SRC_C0=(short)val;     break;\r
 336     case H_Reverb+42  : rvb.ACC_SRC_C1=(short)val;     break;\r
 337     case H_Reverb+44  : rvb.ACC_SRC_D0=(short)val;     break;\r
 338     case H_Reverb+46  : rvb.ACC_SRC_D1=(short)val;     break;\r
 339     case H_Reverb+48  : rvb.IIR_SRC_B1=(short)val;     break;\r
 340     case H_Reverb+50  : rvb.IIR_SRC_B0=(short)val;     break;\r
 341     case H_Reverb+52  : rvb.MIX_DEST_A0=(short)val;    break;\r
 342     case H_Reverb+54  : rvb.MIX_DEST_A1=(short)val;    break;\r
 343     case H_Reverb+56  : rvb.MIX_DEST_B0=(short)val;    break;\r
 344     case H_Reverb+58  : rvb.MIX_DEST_B1=(short)val;    break;\r
 345     case H_Reverb+60  : rvb.IN_COEF_L=(short)val;      break;\r
 346     case H_Reverb+62  : rvb.IN_COEF_R=(short)val;      break;\r
 347    }\r
 348 \r
 349  iSpuAsyncWait=0;\r
 350 }\r
 351 \r
 352 ////////////////////////////////////////////////////////////////////////\r
 353 // READ REGISTER: called by main emu\r
 354 ////////////////////////////////////////////////////////////////////////\r
 355 \r
 356 unsigned short CALLBACK SPUreadRegister(unsigned long reg)\r
 357 {\r
 358  const unsigned long r=reg&0xfff;\r
 359         \r
 360  iSpuAsyncWait=0;\r
 361 \r
 362  if(r>=0x0c00 && r<0x0d80)\r
 363   {\r
 364    switch(r&0x0f)\r
 365     {\r
 366      case 12:                                          // get adsr vol\r
 367       {\r
 368        const int ch=(r>>4)-0xc0;\r
 369        if(dwNewChannel&(1<<ch)) return 1;              // we are started, but not processed? return 1\r
 370        if((dwChannelOn&(1<<ch)) &&                     // same here... we haven't decoded one sample yet, so no envelope yet. return 1 as well\r
 371           !s_chan[ch].ADSRX.EnvelopeVol)\r
 372         return 1;\r
 373        return (unsigned short)(s_chan[ch].ADSRX.EnvelopeVol>>16);\r
 374       }\r
 375 \r
 376      case 14:                                          // get loop address\r
 377       {\r
 378        const int ch=(r>>4)-0xc0;\r
 379        if(s_chan[ch].pLoop==NULL) return 0;\r
 380        return (unsigned short)((s_chan[ch].pLoop-spuMemC)>>3);\r
 381       }\r
 382     }\r
 383   }\r
 384 \r
 385  switch(r)\r
 386   {\r
 387     case H_SPUctrl:\r
 388      return spuCtrl;\r
 389 \r
 390     case H_SPUstat:\r
 391      return spuStat;\r
 392         \r
 393     case H_SPUaddr:\r
 394      return (unsigned short)(spuAddr>>3);\r
 395 \r
 396     case H_SPUdata:\r
 397      {\r
 398       unsigned short s=spuMem[spuAddr>>1];\r
 399       spuAddr+=2;\r
 400       if(spuAddr>0x7ffff) spuAddr=0;\r
 401       return s;\r
 402      }\r
 403 \r
 404     case H_SPUirqAddr:\r
 405      return spuIrq;\r
 406 \r
 407     //case H_SPUIsOn1:\r
 408     // return IsSoundOn(0,16);\r
 409 \r
 410     //case H_SPUIsOn2:\r
 411     // return IsSoundOn(16,24);\r
 412  \r
 413   }\r
 414 \r
 415  return regArea[(r-0xc00)>>1];\r
 416 }\r
 417  \r
 418 ////////////////////////////////////////////////////////////////////////\r
 419 // SOUND ON register write\r
 420 ////////////////////////////////////////////////////////////////////////\r
 421 \r
 422 void SoundOn(int start,int end,unsigned short val)     // SOUND ON PSX COMAND\r
 423 {\r
 424  int ch;\r
 425 \r
 426  for(ch=start;ch<end;ch++,val>>=1)                     // loop channels\r
 427   {\r
 428    if((val&1) && s_chan[ch].pStart)                    // mmm... start has to be set before key on !?!\r
 429     {\r
 430      s_chan[ch].bIgnoreLoop=0;\r
 431 \r
 432      // do this here, not in StartSound\r
 433      // - fixes fussy timing issues\r
 434      s_chan[ch].bStop=0;\r
 435      s_chan[ch].pCurr=s_chan[ch].pStart;\r
 436 \r
 437      dwNewChannel|=(1<<ch);                            // bitfield for faster testing\r
 438      dwChannelOn|=1<<ch;\r
 439     }\r
 440   }\r
 441 }\r
 442 \r
 443 ////////////////////////////////////////////////////////////////////////\r
 444 // SOUND OFF register write\r
 445 ////////////////////////////////////////////////////////////////////////\r
 446 \r
 447 void SoundOff(int start,int end,unsigned short val)    // SOUND OFF PSX COMMAND\r
 448 {\r
 449  int ch;\r
 450  for(ch=start;ch<end;ch++,val>>=1)                     // loop channels\r
 451   {\r
 452    if(val&1)                                           // && s_chan[i].bOn)  mmm...\r
 453     {\r
 454      s_chan[ch].bStop=1;\r
 455 \r
 456      // Jungle Book - Rhythm 'n Groove\r
 457      // - turns off buzzing sound (loop hangs)\r
 458      dwNewChannel &= ~(1<<ch);\r
 459     }                                                  \r
 460   }\r
 461 }\r
 462 \r
 463 ////////////////////////////////////////////////////////////////////////\r
 464 // FMOD register write\r
 465 ////////////////////////////////////////////////////////////////////////\r
 466 \r
 467 void FModOn(int start,int end,unsigned short val)      // FMOD ON PSX COMMAND\r
 468 {\r
 469  int ch;\r
 470 \r
 471  for(ch=start;ch<end;ch++,val>>=1)                     // loop channels\r
 472   {\r
 473    if(val&1)                                           // -> fmod on/off\r
 474     {\r
 475      if(ch>0) \r
 476       {\r
 477        s_chan[ch].bFMod=1;                             // --> sound channel\r
 478        s_chan[ch-1].bFMod=2;                           // --> freq channel\r
 479       }\r
 480     }\r
 481    else\r
 482     {\r
 483      s_chan[ch].bFMod=0;                               // --> turn off fmod\r
 484     }\r
 485   }\r
 486 }\r
 487 \r
 488 ////////////////////////////////////////////////////////////////////////\r
 489 // NOISE register write\r
 490 ////////////////////////////////////////////////////////////////////////\r
 491 \r
 492 void NoiseOn(int start,int end,unsigned short val)     // NOISE ON PSX COMMAND\r
 493 {\r
 494  int ch;\r
 495 \r
 496  for(ch=start;ch<end;ch++,val>>=1)                     // loop channels\r
 497   {\r
 498    s_chan[ch].bNoise=val&1;                            // -> noise on/off\r
 499   }\r
 500 }\r
 501 \r
 502 ////////////////////////////////////////////////////////////////////////\r
 503 // LEFT VOLUME register write\r
 504 ////////////////////////////////////////////////////////////////////////\r
 505 \r
 506 // please note: sweep and phase invert are wrong... but I've never seen\r
 507 // them used\r
 508 \r
 509 void SetVolumeL(unsigned char ch,short vol)            // LEFT VOLUME\r
 510 {\r
 511  if(vol&0x8000)                                        // sweep?\r
 512   {\r
 513    short sInc=1;                                       // -> sweep up?\r
 514    if(vol&0x2000) sInc=-1;                             // -> or down?\r
 515    if(vol&0x1000) vol^=0xffff;                         // -> mmm... phase inverted? have to investigate this\r
 516    vol=((vol&0x7f)+1)/2;                               // -> sweep: 0..127 -> 0..64\r
 517    vol+=vol/(2*sInc);                                  // -> HACK: we don't sweep right now, so we just raise/lower the volume by the half!\r
 518    vol*=128;\r
 519   }\r
 520  else                                                  // no sweep:\r
 521   {\r
 522    if(vol&0x4000)                                      // -> mmm... phase inverted? have to investigate this\r
 523     //vol^=0xffff;\r
 524     vol=0x3fff-(vol&0x3fff);\r
 525   }\r
 526 \r
 527  vol&=0x3fff;\r
 528  s_chan[ch].iLeftVolume=vol;                           // store volume\r
 529 }\r
 530 \r
 531 ////////////////////////////////////////////////////////////////////////\r
 532 // RIGHT VOLUME register write\r
 533 ////////////////////////////////////////////////////////////////////////\r
 534 \r
 535 void SetVolumeR(unsigned char ch,short vol)            // RIGHT VOLUME\r
 536 {\r
 537  if(vol&0x8000)                                        // comments... see above :)\r
 538   {\r
 539    short sInc=1;\r
 540    if(vol&0x2000) sInc=-1;\r
 541    if(vol&0x1000) vol^=0xffff;\r
 542    vol=((vol&0x7f)+1)/2;        \r
 543    vol+=vol/(2*sInc);\r
 544    vol*=128;\r
 545   }\r
 546  else            \r
 547   {\r
 548    if(vol&0x4000) //vol=vol^=0xffff;\r
 549     vol=0x3fff-(vol&0x3fff);\r
 550   }\r
 551 \r
 552  vol&=0x3fff;\r
 553 \r
 554  s_chan[ch].iRightVolume=vol;\r
 555 }\r
 556 \r
 557 ////////////////////////////////////////////////////////////////////////\r
 558 // PITCH register write\r
 559 ////////////////////////////////////////////////////////////////////////\r
 560 \r
 561 void SetPitch(int ch,unsigned short val)               // SET PITCH\r
 562 {\r
 563  int NP;\r
 564  if(val>0x3fff) NP=0x3fff;                             // get pitch val\r
 565  else           NP=val;\r
 566 \r
 567  s_chan[ch].iRawPitch=NP;\r
 568 \r
 569  NP=(44100L*NP)/4096L;                                 // calc frequency\r
 570  if(NP<1) NP=1;                                        // some security\r
 571  s_chan[ch].iActFreq=NP;                               // store frequency\r
 572 }\r
 573 \r
 574 ////////////////////////////////////////////////////////////////////////\r
 575 // REVERB register write\r
 576 ////////////////////////////////////////////////////////////////////////\r
 577 \r
 578 void ReverbOn(int start,int end,unsigned short val)    // REVERB ON PSX COMMAND\r
 579 {\r
 580  int ch;\r
 581 \r
 582  for(ch=start;ch<end;ch++,val>>=1)                     // loop channels\r
 583   {\r
 584    s_chan[ch].bReverb=val&1;                           // -> reverb on/off\r
 585   }\r
 586 }\r