sound.c

   1 /* FCE Ultra - NES/Famicom Emulator
   2  *
   3  * Copyright notice for this file:
   4  *  Copyright (C) 2002 Ben Parnell
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /********************************************************/
  22 /*******                sound.c                         */
  23 /*******                                                */
  24 /*******  Sound emulation code and waveform synthesis   */
  25 /*******  routines.  A few ideas were inspired          */
  26 /*******  by code from Marat Fayzullin's EMUlib         */
  27 /*******                                                */
  28 /********************************************************/
  29
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32
  33 #include <string.h>
  34
  35 #include "types.h"
  36 #include "x6502.h"
  37
  38 #include "fce.h"
  39 #include "svga.h"
  40 #include "sound.h"
  41
  42 uint32 soundtsinc;
  43 uint32 soundtsi;
  44
  45 uint32 Wave[2048];
  46 int16 WaveFinalMono[2048];
  47
  48 EXPSOUND GameExpSound={0,0,0};
  49
  50 uint8 trimode=0;
  51 uint8 tricoop=0;
  52 uint8 PSG[0x18];
  53
  54 uint8 decvolume[3];
  55 uint8 realvolume[3];
  56
  57 static int32 count[5];
  58 static int32 sqacc[2]={0,0};
  59 uint8 sqnon=0;
  60
  61 uint32 soundtsoffs=0;
  62
  63 #undef printf
  64 uint16 nreg;
  65
  66 int32 lengthcount[4];
  67
  68 extern int soundvol;
  69
  70 static const uint8 Slengthtable[0x20]=
  71 {
  72  0x5,0x7f,0xA,0x1,0x14,0x2,0x28,0x3,0x50,0x4,0x1E,0x5,0x7,0x6,0x0E,0x7,
  73  0x6,0x08,0xC,0x9,0x18,0xa,0x30,0xb,0x60,0xc,0x24,0xd,0x8,0xe,0x10,0xf
  74 };
  75
  76 static uint32 lengthtable[0x20];
  77
  78 static const uint32 SNoiseFreqTable[0x10]=
  79 {
  80  2,4,8,0x10,0x20,0x30,0x40,0x50,0x65,0x7f,0xbe,0xfe,0x17d,0x1fc,0x3f9,0x7f2
  81 };
  82 static uint32 NoiseFreqTable[0x10];
  83
  84 static int32 nesincsize32;
  85 int64 nesincsize;
  86
  87 static const uint8 NTSCPCMTable[0x10]=
  88 {
  89  0xd6,0xbe,0xaa,0xa0,0x8f,0x7f,0x71,0x6b,
  90  0x5f,0x50,0x47,0x40,0x35,0x2a,0x24,0x1b
  91 };
  92
  93 static const uint8 PALPCMTable[0x10]=   // These values are just guessed.
  94 {
  95  0xc6,0xb0,0x9d,0x94,0x84,0x75,0x68,0x63,
  96  0x58,0x4a,0x41,0x3b,0x31,0x27,0x21,0x19
  97 };
  98
  99 uint32 PSG_base;
 100
 101 // $4010        -        Frequency
 102 // $4011        -        Actual data outputted
 103 // $4012        -        Address register: $c000 + V*64
 104 // $4013        -        Size register:  Size in bytes = (V+1)*64
 105
 106
 107 static int32 PCMacc=0;
 108 static int PCMfreq;
 109 int32 PCMIRQCount;
 110 uint8 PCMBitIndex=0;
 111 uint32 PCMAddressIndex=0;
 112 int32 PCMSizeIndex=0;
 113 uint8 PCMBuffer=0;
 114 int vdis=0;
 115
 116 static void Dummyfunc(int end) {};
 117
 118 static void (*DoNoise)(int end)=Dummyfunc;
 119 static void (*DoTriangle)(int end)=Dummyfunc;
 120 static void (*DoPCM)(int end)=Dummyfunc;
 121 static void (*DoSQ1)(int end)=Dummyfunc;
 122 static void (*DoSQ2)(int end)=Dummyfunc;
 123
 124 static void CalcDPCMIRQ(void)
 125 {
 126  uint32 freq;
 127  uint32 honk;
 128  uint32 cycles;
 129
 130  if(PAL)
 131   freq=(PALPCMTable[PSG[0x10]&0xF]<<4);
 132  else
 133   freq=(NTSCPCMTable[PSG[0x10]&0xF]<<4);
 134
 135  cycles=(((PSG[0x13]<<4)+1));
 136  cycles*=freq/14;
 137  honk=((PSG[0x13]<<4)+1)*freq;
 138  honk-=cycles;
 139  //if(PAL) honk/=107;
 140  //else honk/=(double)113.66666666;
 141  PCMIRQCount=honk*48;
 142  //PCMIRQCount=honk*3; //180;
 143  //if(PAL) PCMIRQCount*=.93;
 144  vdis=0;
 145 }
 146
 147 static void PrepDPCM()
 148 {
 149  PCMAddressIndex=0x4000+(PSG[0x12]<<6);
 150  PCMSizeIndex=(PSG[0x13]<<4)+1;
 151  PCMBitIndex=0;
 152  //PCMBuffer=ARead[0x8000+PCMAddressIndex](0x8000+PCMAddressIndex);
 153  if(PAL)
 154   PCMfreq=PALPCMTable[PSG[0x10]&0xF];
 155  else
 156   PCMfreq=NTSCPCMTable[PSG[0x10]&0xF];
 157  PCMacc=PCMfreq<<18;
 158 }
 159
 160 uint8 sweepon[2]={0,0};
 161 int32 curfreq[2]={0,0};
 162
 163
 164 uint8 SIRQStat=0;
 165
 166 uint8 SweepCount[2];
 167 uint8 DecCountTo1[3];
 168
 169 uint8 fcnt=0;
 170 int32 fhcnt=0;
 171 int32 fhinc;
 172
 173 static uint8 laster;
 174
 175 /* Instantaneous?  Maybe the new freq value is being calculated all of the time... */
 176 static int FASTAPASS(2) CheckFreq(uint32 cf, uint8 sr)
 177 {
 178  uint32 mod;
 179  if(!(sr&0x8))
 180  {
 181   mod=cf>>(sr&7);
 182   if((mod+cf)&0x800)
 183    return(0);
 184  }
 185  return(1);
 186 }
 187
 188 static DECLFW(Write0x11)
 189 {
 190  DoPCM(0);
 191  PSG[0x11]=V&0x7F;
 192 }
 193
 194 static uint8 DutyCount[2]={0,0};
 195
 196 static DECLFW(Write_PSG)
 197 {
 198  //if((A>=0x4004 && A<=0x4007) || A==0x4015)
 199   //printf("$%04x:$%02x, %d\n",A,V,SOUNDTS);
 200  A&=0x1f;
 201  switch(A)
 202  {
 203   case 0x0:
 204            DoSQ1(0);
 205            if(V&0x10)
 206             realvolume[0]=V&0xF;
 207            break;
 208   case 0x1:
 209            sweepon[0]=V&0x80;
 210            break;
 211   case 0x2:
 212            DoSQ1(0);
 213            curfreq[0]&=0xFF00;
 214            curfreq[0]|=V;
 215            break;
 216   case 0x3:
 217            if(PSG[0x15]&1)
 218            {
 219             DoSQ1(0);
 220             lengthcount[0]=lengthtable[(V>>3)&0x1f];
 221             sqnon|=1;
 222            }
 223            sweepon[0]=PSG[1]&0x80;
 224            curfreq[0]=PSG[0x2]|((V&7)<<8);
 225            decvolume[0]=0xF;
 226            DecCountTo1[0]=(PSG[0]&0xF)+1;
 227            SweepCount[0]=((PSG[0x1]>>4)&7)+1;
 228            DutyCount[0]=0;
 229            sqacc[0]=((int32)curfreq[0]+1)<<18;
 230            break;
 231
 232   case 0x4:
 233            DoSQ2(0);
 234            if(V&0x10)
 235             realvolume[1]=V&0xF;
 236            break;
 237   case 0x5:
 238           sweepon[1]=V&0x80;
 239           break;
 240   case 0x6:
 241           DoSQ2(0);
 242           curfreq[1]&=0xFF00;
 243           curfreq[1]|=V;
 244           break;
 245   case 0x7:
 246           if(PSG[0x15]&2)
 247           {
 248            DoSQ2(0);
 249            lengthcount[1]=lengthtable[(V>>3)&0x1f];
 250            sqnon|=2;
 251           }
 252           sweepon[1]=PSG[0x5]&0x80;
 253           curfreq[1]=PSG[0x6]|((V&7)<<8);
 254           decvolume[1]=0xF;
 255           DecCountTo1[1]=(PSG[0x4]&0xF)+1;
 256           SweepCount[1]=((PSG[0x5]>>4)&7)+1;
 257           DutyCount[1]=0;
 258           sqacc[1]=((int32)curfreq[1]+1)<<18;
 259           break;
 260   case 0x8:
 261           DoTriangle(0);
 262           if(laster&0x80)
 263           {
 264             tricoop=V&0x7F;
 265             trimode=V&0x80;
 266           }
 267           if(!(V&0x7F))
 268            tricoop=0;
 269           laster=V&0x80;
 270           break;
 271   case 0xa:DoTriangle(0);
 272            break;
 273   case 0xb:
 274           if(PSG[0x15]&0x4)
 275           {
 276            DoTriangle(0);
 277            sqnon|=4;
 278            lengthcount[2]=lengthtable[(V>>3)&0x1f];
 279           }
 280           laster=0x80;
 281           tricoop=PSG[0x8]&0x7f;
 282           trimode=PSG[0x8]&0x80;
 283           break;
 284   case 0xC:DoNoise(0);
 285            if(V&0x10)
 286             realvolume[2]=V&0xF;
 287            break;
 288   case 0xE:DoNoise(0);break;
 289   case 0xF:
 290            if(PSG[0x15]&8)
 291            {
 292             DoNoise(0);
 293             sqnon|=8;
 294             lengthcount[3]=lengthtable[(V>>3)&0x1f];
 295            }
 296            decvolume[2]=0xF;
 297            DecCountTo1[2]=(PSG[0xC]&0xF)+1;
 298            break;
 299  case 0x10:DoPCM(0);
 300            if(!(V&0x80))
 301             X6502_IRQEnd(FCEU_IQDPCM);
 302            break;
 303  case 0x15:
 304            {
 305             int t=V^PSG[0x15];
 306
 307             if(t&1)
 308              DoSQ1(0);
 309             if(t&2)
 310              DoSQ2(0);
 311             if(t&4)
 312              DoTriangle(0);
 313             if(t&8)
 314              DoNoise(0);
 315             if(t&0x10)
 316              DoPCM(0);
 317             sqnon&=V;
 318             if(V&0x10)
 319             {
 320              if(!(PSG[0x15]&0x10))
 321              {
 322               PrepDPCM();
 323               CalcDPCMIRQ();
 324              }
 325              else if(vdis)
 326               CalcDPCMIRQ();
 327             }
 328             else
 329              PCMIRQCount=0;
 330             X6502_IRQEnd(FCEU_IQDPCM);
 331            }
 332            break;
 333  }
 334  PSG[A]=V;
 335 }
 336
 337 DECLFR(Read_PSG)
 338 {
 339    uint8 ret;
 340    if(PSG[0x15]&0x10)
 341     DoPCM(0);
 342    ret=(PSG[0x15]&(sqnon|0x10))|SIRQStat;
 343    SIRQStat&=~0x40;
 344    X6502_IRQEnd(/*FCEU_IQDPCM|*/FCEU_IQFCOUNT);
 345    return ret;
 346 }
 347
 348 DECLFR(Read_PSGDummy)
 349 {
 350    uint8 ret;
 351
 352    ret=(PSG[0x15]&sqnon)|SIRQStat;
 353    SIRQStat&=~0x40;
 354    X6502_IRQEnd(/*FCEU_IQDPCM|*/FCEU_IQFCOUNT);
 355    return ret;
 356 }
 357
 358 static void FASTAPASS(1) FrameSoundStuff(int V)
 359 {
 360  int P;
 361  uint32 end = (SOUNDTS<<16)/soundtsinc;
 362
 363  DoSQ1(end);
 364  DoSQ2(end);
 365  DoNoise(end);
 366
 367  switch((V&1))
 368  {
 369   case 1:       /* Envelope decay, linear counter, length counter, freq sweep */
 370         if(PSG[0x15]&4 && sqnon&4)
 371          if(!(PSG[8]&0x80))
 372          {
 373           if(lengthcount[2]>0)
 374           {
 375             lengthcount[2]--;
 376             if(lengthcount[2]<=0)
 377              {
 378               DoTriangle(0);
 379               sqnon&=~4;
 380              }
 381            }
 382          }
 383
 384         for(P=0;P<2;P++)
 385         {
 386          if(PSG[0x15]&(P+1) && sqnon&(P+1))
 387          {
 388           if(!(PSG[P<<2]&0x20))
 389           {
 390            if(lengthcount[P]>0)
 391            {
 392             lengthcount[P]--;
 393             if(lengthcount[P]<=0)
 394              {
 395               sqnon&=~(P+1);
 396              }
 397            }
 398           }
 399          }
 400                 /* Frequency Sweep Code Here */
 401                 /* xxxx 0000 */
 402                 /* xxxx = hz.  120/(x+1)*/
 403           if(sweepon[P])
 404           {
 405            int32 mod=0;
 406
 407            if(SweepCount[P]>0) SweepCount[P]--;
 408            if(SweepCount[P]<=0)
 409            {
 410             SweepCount[P]=((PSG[(P<<2)+0x1]>>4)&7)+1; //+1;
 411             {
 412              if(PSG[(P<<2)+0x1]&0x8)
 413              {
 414               mod-=(P^1)+((curfreq[P])>>(PSG[(P<<2)+0x1]&7));
 415
 416               if(curfreq[P] && (PSG[(P<<2)+0x1]&7)/* && sweepon[P]&0x80*/)
 417               {
 418                curfreq[P]+=mod;
 419               }
 420              }
 421              else
 422              {
 423               mod=curfreq[P]>>(PSG[(P<<2)+0x1]&7);
 424               if((mod+curfreq[P])&0x800)
 425               {
 426                sweepon[P]=0;
 427                curfreq[P]=0;
 428               }
 429               else
 430               {
 431                if(curfreq[P] && (PSG[(P<<2)+0x1]&7)/* && sweepon[P]&0x80*/)
 432                {
 433                 curfreq[P]+=mod;
 434                }
 435               }
 436              }
 437             }
 438            }
 439           }
 440          }
 441
 442        if(PSG[0x15]&0x8 && sqnon&8)
 443         {
 444          if(!(PSG[0xC]&0x20))
 445          {
 446           if(lengthcount[3]>0)
 447           {
 448            lengthcount[3]--;
 449            if(lengthcount[3]<=0)
 450            {
 451             sqnon&=~8;
 452            }
 453           }
 454          }
 455         }
 456
 457   case 0:       /* Envelope decay + linear counter */
 458          if(!trimode)
 459          {
 460            laster=0;
 461            if(tricoop)
 462            {
 463             if(tricoop==1) DoTriangle(0);
 464             tricoop--;
 465            }
 466          }
 467
 468         for(P=0;P<2;P++)
 469         {
 470           if(DecCountTo1[P]>0) DecCountTo1[P]--;
 471           if(DecCountTo1[P]<=0)
 472           {
 473            DecCountTo1[P]=(PSG[P<<2]&0xF)+1;
 474            if(decvolume[P] || PSG[P<<2]&0x20)
 475            {
 476             decvolume[P]--;
 477             /* Step from 0 to full volume seems to take twice as long
 478                as the other steps.  I don't know if this is the correct
 479                way to double its length, though(or if it even matters).
 480             */
 481             if((PSG[P<<2]&0x20) && (decvolume[P]==0))
 482              DecCountTo1[P]<<=1;
 483             decvolume[P]&=15;
 484            }
 485           }
 486           if(!(PSG[P<<2]&0x10))
 487            realvolume[P]=decvolume[P];
 488         }
 489
 490          if(DecCountTo1[2]>0) DecCountTo1[2]--;
 491          if(DecCountTo1[2]<=0)
 492          {
 493           DecCountTo1[2]=(PSG[0xC]&0xF)+1;
 494           if(decvolume[2] || PSG[0xC]&0x20)
 495           {
 496             decvolume[2]--;
 497             /* Step from 0 to full volume seems to take twice as long
 498                as the other steps.  I don't know if this is the correct
 499                way to double its length, though(or if it even matters).
 500             */
 501             if((PSG[0xC]&0x20) && (decvolume[2]==0))
 502              DecCountTo1[2]<<=1;
 503             decvolume[2]&=15;
 504           }
 505          }
 506          if(!(PSG[0xC]&0x10))
 507           realvolume[2]=decvolume[2];
 508
 509         break;
 510  }
 511
 512 }
 513
 514 void FrameSoundUpdate(void)
 515 {
 516  // Linear counter:  Bit 0-6 of $4008
 517  // Length counter:  Bit 4-7 of $4003, $4007, $400b, $400f
 518
 519  if(fcnt==3)
 520  {
 521         if(PSG[0x17]&0x80)
 522          fhcnt+=fhinc;
 523         if(!(PSG[0x17]&0xC0))
 524         {
 525          SIRQStat|=0x40;
 526          X6502_IRQBegin(FCEU_IQFCOUNT);
 527         }
 528  }
 529  //if(SIRQStat&0x40) X6502_IRQBegin(FCEU_IQFCOUNT);
 530  FrameSoundStuff(fcnt);
 531  fcnt=(fcnt+1)&3;
 532 }
 533
 534 static uint32 ChannelBC[5];
 535
 536 static uint32 RectAmp[2][8];
 537
 538 static void FASTAPASS(1) CalcRectAmp(int P)
 539 {
 540   static int tal[4]={1,2,4,6};
 541   int V;
 542   int x;
 543   uint32 *b=RectAmp[P];
 544   int m;
 545
 546   //if(PSG[P<<2]&0x10)
 547    V=realvolume[P]<<4;
 548   //V=(PSG[P<<2]&15)<<4;
 549   //else
 550   // V=decvolume[P]<<4;
 551   m=tal[(PSG[P<<2]&0xC0)>>6];
 552   for(x=0;x<m;x++,b++)
 553    *b=0;
 554   for(;x<8;x++,b++)
 555    *b=V;
 556 }
 557
 558 static void RDoPCM(int32 end)
 559 {
 560    int32 V;
 561    int32 start;
 562    int32 freq;
 563    uint32 out=PSG[0x11]<<3;
 564
 565    start=ChannelBC[4];
 566    if(end==0) end=(SOUNDTS<<16)/soundtsinc;
 567    if(end<=start) return;
 568    ChannelBC[4]=end;
 569
 570    if(PSG[0x15]&0x10)
 571    {
 572       freq=PCMfreq;
 573       freq<<=18;
 574
 575       for(V=start;V<end;V++)
 576       {
 577        PCMacc-=nesincsize32;
 578        if(PCMacc<=0)
 579        {
 580         if(!PCMBitIndex)
 581         {
 582          PCMSizeIndex--;
 583          if(!PCMSizeIndex)
 584          {
 585           if(PSG[0x10]&0x40)
 586            PrepDPCM();
 587           else
 588           {
 589            PSG[0x15]&=~0x10;
 590            for(;V<end;V++)
 591             Wave[V>>4]+=PSG[0x11]<<3;
 592            goto endopcmo;
 593           }
 594          }
 595          else
 596          {
 597           PCMBuffer=ARead[0x8000+PCMAddressIndex](0x8000+PCMAddressIndex);
 598           PCMAddressIndex=(PCMAddressIndex+1)&0x7fff;
 599          }
 600         }
 601
 602         {
 603          int t=(((PCMBuffer>>PCMBitIndex)&1)<<2)-2;
 604          uint8 bah=PSG[0x11];
 605
 606          PCMacc+=freq;
 607          PSG[0x11]+=t;
 608          if(PSG[0x11]&0x80)
 609           PSG[0x11]=bah;
 610          else
 611           out=PSG[0x11]<<3;
 612         }
 613         PCMBitIndex=(PCMBitIndex+1)&7;
 614        }
 615        Wave[V>>4]+=out; //(PSG[0x11]-64)<<3;
 616       }
 617    }
 618    else
 619    {
 620      if((end-start)>64)
 621      {
 622       for(V=start;V<=(start|15);V++)
 623        Wave[V>>4]+=out;
 624       out<<=4;
 625       for(V=(start>>4)+1;V<(end>>4);V++)
 626        Wave[V]+=out;
 627       out>>=4;
 628       for(V=end&(~15);V<end;V++)
 629        Wave[V>>4]+=out;
 630      }
 631      else
 632       for(V=start;V<end;V++)
 633        Wave[V>>4]+=out;
 634    }
 635     endopcmo:;
 636 }
 637
 638 static void RDoSQ1(int32 end)
 639 {
 640    int32 V;
 641    int32 start;
 642    int32 freq;
 643
 644    start=ChannelBC[0];
 645    if(end==0) end=(SOUNDTS<<16)/soundtsinc;
 646    if(end<=start) return;
 647    ChannelBC[0]=end;
 648
 649    if(!(PSG[0x15]&1 && sqnon&1))
 650     return;
 651
 652    if(curfreq[0]<8 || curfreq[0]>0x7ff)
 653     return;
 654    if(!CheckFreq(curfreq[0],PSG[0x1]))
 655     return;
 656
 657    CalcRectAmp(0);
 658
 659    {
 660     uint32 out=RectAmp[0][DutyCount[0]];
 661     freq=curfreq[0]+1;
 662     {
 663       freq<<=18;
 664       for(V=start;V<end;V++)
 665       {
 666        Wave[V>>4]+=out;
 667        sqacc[0]-=nesincsize32;
 668        if(sqacc[0]<=0)
 669        {
 670         rea:
 671         sqacc[0]+=freq;
 672         DutyCount[0]++;
 673         if(sqacc[0]<=0) goto rea;
 674
 675         DutyCount[0]&=7;
 676         out=RectAmp[0][DutyCount[0]];
 677        }
 678       }
 679     }
 680    }
 681 }
 682
 683 static void RDoSQ2(int32 end)
 684 {
 685    int32 V;
 686    int32 start;
 687    int32 freq;
 688
 689    start=ChannelBC[1];
 690    if(end==0) end=(SOUNDTS<<16)/soundtsinc;
 691    if(end<=start) return;
 692    ChannelBC[1]=end;
 693
 694    if(!(PSG[0x15]&2 && sqnon&2))
 695     return;
 696
 697    if(curfreq[1]<8 || curfreq[1]>0x7ff)
 698     return;
 699    if(!CheckFreq(curfreq[1],PSG[0x5]))
 700     return;
 701
 702    CalcRectAmp(1);
 703
 704    {
 705     uint32 out=RectAmp[1][DutyCount[1]];
 706     freq=curfreq[1]+1;
 707
 708     {
 709       freq<<=18;
 710       for(V=start;V<end;V++)
 711       {
 712        Wave[V>>4]+=out;
 713        sqacc[1]-=nesincsize32;
 714        if(sqacc[1]<=0)
 715        {
 716         rea:
 717         sqacc[1]+=freq;
 718         DutyCount[1]++;
 719         if(sqacc[1]<=0) goto rea;
 720
 721         DutyCount[1]&=7;
 722         out=RectAmp[1][DutyCount[1]];
 723        }
 724       }
 725     }
 726    }
 727 }
 728
 729
 730 static void RDoTriangle(int32 end)
 731 {
 732    static uint32 tcout=0;
 733    int32 V;
 734    int32 start; //,freq;
 735    int32 freq=(((PSG[0xa]|((PSG[0xb]&7)<<8))+1));
 736
 737    start=ChannelBC[2];
 738    if(end==0) end=(SOUNDTS<<16)/soundtsinc;
 739    if(end<=start) return;
 740    ChannelBC[2]=end;
 741
 742     if(! (PSG[0x15]&0x4 && sqnon&4 && tricoop) )
 743     {   // Counter is halted, but we still need to output.
 744      for(V=start;V<end;V++)
 745        Wave[V>>4]+=tcout;
 746     }
 747     else if(freq<=4) // 55.9Khz - Might be barely audible on a real NES, but
 748                // it's too costly to generate audio at this high of a frequency
 749                // (55.9Khz * 32 for the stepping).
 750                // The same could probably be said for ~27.8Khz, so we'll
 751                // take care of that too.  We'll just output the average
 752                // value(15/2 - scaled properly for our output format, of course).
 753                // We'll also take care of ~18Khz and ~14Khz too, since they should be barely audible.
 754                // (Some proof or anything to confirm/disprove this would be nice.).
 755     {
 756      for(V=start;V<end;V++)
 757       Wave[V>>4]+=((0xF<<4)+(0xF<<2))>>1;
 758     }
 759     else
 760     {
 761      static int32 triacc=0;
 762      static uint8 tc=0;
 763
 764       freq<<=17;
 765       for(V=start;V<end;V++)
 766       {
 767        triacc-=nesincsize32;
 768        if(triacc<=0)
 769        {
 770         rea:
 771         triacc+=freq; //t;
 772         tc=(tc+1)&0x1F;
 773         if(triacc<=0) goto rea;
 774
 775         tcout=(tc&0xF);
 776         if(tc&0x10) tcout^=0xF;
 777         tcout=(tcout<<4)+(tcout<<2);
 778        }
 779        Wave[V>>4]+=tcout;
 780       }
 781     }
 782 }
 783
 784 static void RDoNoise(int32 end)
 785 {
 786    int32 inc,V;
 787    int32 start;
 788
 789    start=ChannelBC[3];
 790    if(end==0) end=(SOUNDTS<<16)/soundtsinc;
 791    if(end<=start) return;
 792    ChannelBC[3]=end;
 793
 794    if(PSG[0x15]&0x8 && sqnon&8)
 795    {
 796       uint32 outo;
 797       uint32 amptab[2];
 798       uint8 amplitude;
 799
 800       amplitude=realvolume[2];
 801       //if(PSG[0xC]&0x10)
 802       // amplitude=(PSG[0xC]&0xF);
 803       //else
 804       // amplitude=decvolume[2]&0xF;
 805
 806       inc=NoiseFreqTable[PSG[0xE]&0xF];
 807       amptab[0]=((amplitude<<2)+amplitude+amplitude)<<1;
 808       amptab[1]=0;
 809       outo=amptab[nreg&1];
 810
 811       if(amplitude)
 812       {
 813        if(PSG[0xE]&0x80)        // "short" noise
 814         for(V=start;V<end;V++)
 815         {
 816          Wave[V>>4]+=outo;
 817          if(count[3]>=inc)
 818          {
 819           uint8 feedback;
 820
 821           feedback=((nreg>>8)&1)^((nreg>>14)&1);
 822           nreg=(nreg<<1)+feedback;
 823           nreg&=0x7fff;
 824           outo=amptab[nreg&1];
 825           count[3]-=inc;
 826          }
 827          count[3]+=0x1000;
 828         }
 829        else
 830         for(V=start;V<end;V++)
 831         {
 832          Wave[V>>4]+=outo;
 833          if(count[3]>=inc)
 834          {
 835           uint8 feedback;
 836
 837           feedback=((nreg>>13)&1)^((nreg>>14)&1);
 838           nreg=(nreg<<1)+feedback;
 839           nreg&=0x7fff;
 840           outo=amptab[nreg&1];
 841           count[3]-=inc;
 842          }
 843          count[3]+=0x1000;
 844         }
 845       }
 846    }
 847 }
 848
 849 DECLFW(Write_IRQFM)
 850 {
 851  PSG[0x17]=V;
 852  V=(V&0xC0)>>6;
 853  fcnt=0;
 854  if(V&0x2)
 855   FrameSoundUpdate();
 856  fcnt=1;
 857  fhcnt=fhinc;
 858  X6502_IRQEnd(FCEU_IQFCOUNT);
 859  SIRQStat&=~0x40;
 860  //IRQFrameMode=V; // IRQFrameMode is PSG[0x17] upper bits
 861 }
 862
 863 void SetNESSoundMap(void)
 864 {
 865   SetWriteHandler(0x4000,0x4013,Write_PSG);
 866   SetWriteHandler(0x4011,0x4011,Write0x11);
 867   SetWriteHandler(0x4015,0x4015,Write_PSG);
 868   SetWriteHandler(0x4017,0x4017,Write_IRQFM);
 869   SetReadHandler(0x4015,0x4015,Read_PSG);
 870 }
 871
 872 int32 highp;                   // 0 through 65536, 0 = no high pass, 65536 = max high pass
 873
 874 int32 lowp;                    // 0 through 65536, 65536 = max low pass(total attenuation)
 875                                 // 65536 = no low pass
 876 static int32 flt_acc=0, flt_acc2=0;
 877
 878 static void FilterSound(uint32 *in, int16 *outMono, int count)
 879 {
 880 // static int min=0, max=0;
 881
 882  for(;count;count--,in++,outMono++)
 883  {
 884   int32 diff;
 885
 886   diff = *in - flt_acc;
 887
 888   flt_acc += (diff*highp)>>16;
 889   flt_acc2+= (int32) (((int64)((diff-flt_acc2)*lowp))>>16);
 890   *in=0;
 891
 892   *outMono = flt_acc2*7 >> 2; // * 1.75
 893 //  if (acc2 < min) { printf("min: %i %04x\n", acc2, acc2); min = acc2; }
 894 //  if (acc2 > max) { printf("max: %i %04x\n", acc2, acc2); max = acc2; }
 895  }
 896 }
 897
 898
 899
 900 static int32 inbuf=0;
 901 int FlushEmulateSound(void)
 902 {
 903   int x;
 904   uint32 end;
 905
 906   if(!timestamp) return(0);
 907
 908   if(!FSettings.SndRate || (soundvol == 0))
 909   {
 910    end=0;
 911    goto nosoundo;
 912   }
 913
 914   end=(SOUNDTS<<16)/soundtsinc;
 915   DoSQ1(end);
 916   DoSQ2(end);
 917   DoTriangle(end);
 918   DoNoise(end);
 919   DoPCM(end);
 920
 921   if(GameExpSound.Fill)
 922    GameExpSound.Fill(end&0xF);
 923
 924   FilterSound(Wave,WaveFinalMono,end>>4);
 925
 926   if(end&0xF)
 927    Wave[0]=Wave[(end>>4)];
 928   Wave[(end>>4)]=0;
 929
 930   nosoundo:
 931   for(x=0;x<5;x++)
 932    ChannelBC[x]=end&0xF;
 933   soundtsoffs=(soundtsinc*(end&0xF))>>16;
 934   end>>=4;
 935   inbuf=end;
 936   return(end);
 937 }
 938
 939 int GetSoundBuffer(int16 **W)
 940 {
 941  *W=WaveFinalMono;
 942  return inbuf;
 943 }
 944
 945 void PowerSound(void)
 946 {
 947         int x;
 948
 949         SetNESSoundMap();
 950
 951         for(x=0;x<0x16;x++)
 952          if(x!=0x14)
 953           BWrite[0x4000+x](0x4000+x,0);
 954         PSG[0x17]=0; //x40;
 955         fhcnt=fhinc;
 956         fcnt=0;
 957         nreg=1;
 958         soundtsoffs=0;
 959 }
 960
 961 void ResetSound(void)
 962 {
 963         int x;
 964         for(x=0;x<0x16;x++)
 965          if(x!=1 && x!=5 && x!=0x14) BWrite[0x4000+x](0x4000+x,0);
 966         PSG[0x17]=0;
 967         fhcnt=fhinc;
 968         fcnt=0;
 969         nreg=1;
 970 }
 971
 972 void SetSoundVariables(void)
 973 {
 974   int x;
 975
 976   fhinc=PAL?16626:14915;        // *2 CPU clock rate
 977   fhinc*=24;
 978   for(x=0;x<0x20;x++)
 979    lengthtable[x]=Slengthtable[x]<<1;
 980
 981   if(FSettings.SndRate)
 982   {
 983    DoNoise=RDoNoise;
 984    DoTriangle=RDoTriangle;
 985    DoPCM=RDoPCM;
 986    DoSQ1=RDoSQ1;
 987    DoSQ2=RDoSQ2;
 988   }
 989   else
 990   {
 991    DoNoise=DoTriangle=DoPCM=DoSQ1=DoSQ2=Dummyfunc;
 992   }
 993
 994   if(!FSettings.SndRate) return;
 995   if(GameExpSound.RChange)
 996    GameExpSound.RChange();
 997
 998   // nesincsizeLL=(int64)((int64)562949953421312*(double)(PAL?PAL_CPU:NTSC_CPU)/(FSettings.SndRate OVERSAMPLE));
 999   nesincsize=(int64)(((int64)1<<17)*(double)(PAL?PAL_CPU:NTSC_CPU)/(FSettings.SndRate * 16)); // 308845 - 1832727
1000   nesincsize32=(int32)nesincsize;
1001   PSG_base=(uint32)(PAL?(long double)PAL_CPU/16:(long double)NTSC_CPU/16);
1002
1003   for(x=0;x<0x10;x++)
1004   {
1005    long double z;
1006    z=SNoiseFreqTable[x]<<1;
1007    z=(PAL?PAL_CPU:NTSC_CPU)/z;
1008    z=(long double)((uint32)((FSettings.SndRate OVERSAMPLE)<<12))/z;
1009    NoiseFreqTable[x]=z;
1010   }
1011   soundtsinc=(uint32)((uint64)(PAL?(long double)PAL_CPU*65536:(long double)NTSC_CPU*65536)/(FSettings.SndRate OVERSAMPLE));
1012   memset(Wave,0,sizeof(Wave));
1013   for(x=0;x<5;x++)
1014    ChannelBC[x]=0;
1015   highp=(250<<16)/FSettings.SndRate;  // Arbitrary
1016   lowp=(25000<<16)/FSettings.SndRate; // Arbitrary
1017
1018   if(highp>(1<<16)) highp=1<<16;
1019   if(lowp>(1<<16)) lowp=1<<16;
1020
1021   flt_acc=flt_acc2=0;
1022 }
1023
1024 void FixOldSaveStateSFreq(void)
1025 {
1026         int x;
1027         for(x=0;x<2;x++)
1028         {
1029          curfreq[x]=PSG[0x2+(x<<2)]|((PSG[0x3+(x<<2)]&7)<<8);
1030         }
1031 }
1032
1033 void FCEUI_Sound(int Rate)
1034 {
1035  FSettings.SndRate=Rate;
1036  SetSoundVariables();
1037 }
1038
1039 void FCEUI_SetSoundVolume(uint32 volume)
1040 {
1041  FSettings.SoundVolume=volume;
1042 }