opal-sid 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93bc7981f8bb7b27219304680ac4218c9491227e
-  data.tar.gz: f5029c4b4b60d87a155c3bab7123aeafa2d239ef
+  metadata.gz: ff9968c09be7f4ea961dc509b1ea4c66ec8469b8
+  data.tar.gz: 9b984ee9664a07ac9fb2e82a2e6295a2757d7610
 SHA512:
-  metadata.gz: bd167be9fe703445d8224d4c3b36122fd3f4fcdd0ab29942997bf68ef57a6081d632e3ff64e410ca6e1ab0b8ef2ecb6c866ddbe6f6d944fc40c57ad05f440d5d
-  data.tar.gz: 17399fc0b91c5cb1040ce215bb38f3778f1d379ece43d1492fd0f6c332332b1304f331973ff19f4c2af044c0618229c3c47b8c9eb2a949158cebf00bdb8c348a
+  metadata.gz: 8bd572ed8c9095b78ea1011118fd2f30a499e0f588c94726a593ac654fd8f9fc55a02ba69f86189a53be0fd3fa7adea956a96a66d35f977dc591e9d900586926
+  data.tar.gz: 6355e52f3119748c5dd895eaf8b9d6e1b7641155cf4eff43cb66cb85fa75283d43ffbf15be25ba69b76a105f92f44391a477f8351fe369010f6360a7a276c145

data/Rakefile

@@ -6,7 +6,7 @@ require 'open-uri'
 
 desc 'Update JS dependencies'
 task :js_deps do
-  js_lib_url = 'https://raw.githubusercontent.com/hermitsoft/jsSID/master/jsSID.js'
+  js_lib_url = 'https://raw.githubusercontent.com/hermitsoft/jsSID/master/source/jsSID.js'
   js_lib_dest = File.join(File.dirname(__FILE__), './opal/vendor/jssid.js')
   open(js_lib_url) do |f|
     File.write(js_lib_dest, f.readlines.join)

data/opal-sid.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'opal-sid'
-  s.version     = '0.0.3'
+  s.version     = '0.0.4'
   s.authors     = ['Michał Kalbarczyk']
   s.email       = 'fazibear@gmail.com'
   s.homepage    = 'http://github.com/fazibear/opal-sid'

data/opal/sid.rb

@@ -26,6 +26,7 @@ class SID
   alias_native :setloadcallback
   alias_native :setstartcallback
   alias_native :setendcallback
+  alias_native :setmemorywritecallback
 
   def initialize(buffersize = 16384, background_noise = 0.0005)
     @native = `new jsSID(#{buffersize}, #{background_noise})`
@@ -42,4 +43,8 @@ class SID
   def on_end(time, &block)
     setendcallback(block, time)
   end
+
+  def on_memory_write(&block)
+    setmemorywritecallback(block)
+  end
 end

data/opal/vendor/jssid.js

@@ -1 +1,1070 @@
-function playSID(sidurl,subtune){if(typeof SIDplayer==='undefined')SIDplayer=new jsSID(16384,0.0005);SIDplayer.loadstart(sidurl,subtune);}function jsSID(bufln,bgnoi){this.author='Hermit';this.sourcecode='http://hermit.sidrip.com';this.version='0.9.1';this.year='2016';if(typeof AudioContext!=='undefined'){var aCtx=new AudioContext();}else {var aCtx=new webkitAudioContext();};var smpr=aCtx.sampleRate;if(typeof aCtx.createJavaScriptNode==='function'){var scrNod=aCtx.createJavaScriptNode(bufln,0,1);}else {var scrNod=aCtx.createScriptProcessor(bufln,0,1);}scrNod.onaudioprocess=function (e){var oBuf=e.outputBuffer;var oDat=oBuf.getChannelData(0);for(var sample=0;sample<oBuf.length;sample++){oDat[sample]=play();}};this.loadstart=function (sidurl,subt){this.loadinit(sidurl,subt);if(startcallback!==null)startcallback();this.playcont();};this.loadinit=function (sidurl,subt){ldd=0;this.pause();initSID();subtune=subt;var req=new XMLHttpRequest();req.open('GET',sidurl,true);req.responseType='arraybuffer';req.onload=function (){if(req.status == 200){var fdat=new Uint8Array(req.response);var i,strend,offs=fdat[7];ldad=fdat[8]+fdat[9]?fdat[8]*256+fdat[9]:fdat[offs]+fdat[offs+1]*256;for(i=0;i<32;i++)tmod[31-i]=fdat[0x12+(i>>3)]&Math.pow(2,7-i%8);for(i=0;i<M.length;i++)M[i]=0;for(i=offs+2;i<fdat.byteLength;i++){if(ldad+i-(offs+2)<M.length)M[ldad+i-(offs+2)]=fdat[i];}strend=1;for(i=0;i<32;i++){if(strend!=0)strend=tit[i]=fdat[0x16+i];else strend=tit[i]=0;}strend=1;for(i=0;i<32;i++){if(strend!=0)strend=auth[i]=fdat[0x36+i];else strend=auth[i]=0;}strend=1;for(i=0;i<32;i++){if(strend!=0)strend=inf[i]=fdat[0x56+i];else strend=inf[i]=0;}ina=fdat[0xA]+fdat[0xB]?fdat[0xA]*256+fdat[0xB]:ldad;pla=plf=fdat[0xC]*256+fdat[0xD];subtune_amount=fdat[0xF];prSIDm[0]=(fdat[0x77]&0x30)>=0x20?8580:6581;prSIDm[1]=(fdat[0x77]&0xC0)>=0x80?8580:6581;prSIDm[2]=(fdat[0x76]&3)>=3?8580:6581;SID_address[1]=fdat[0x7A]>=0x42&&(fdat[0x7A]<0x80||fdat[0x7A]>=0xE0)?0xD000+fdat[0x7A]*16:0;SID_address[2]=fdat[0x7B]>=0x42&&(fdat[0x7B]<0x80||fdat[0x7B]>=0xE0)?0xD000+fdat[0x7B]*16:0;SIDamount=1+(SID_address[1]>0)+(SID_address[2]>0);ldd=1;if(loadcallback!==null)loadcallback();init(subtune);}};req.send(null);};this.start=function (subt){init(subt);if(startcallback!==null)startcallback();this.playcont();};this.playcont=function (){scrNod.connect(aCtx.destination);};this.pause=function (){if(ldd&&ind)scrNod.disconnect(aCtx.destination);};this.stop=function (){this.pause();init(subtune);};this.gettitle=function (){return String.fromCharCode.apply(null,tit);};this.getauthor=function (){return String.fromCharCode.apply(null,auth);};this.getinfo=function (){return String.fromCharCode.apply(null,inf);};this.getsubtunes=function (){return subtune_amount;};this.getprefmodel=function (){return prSIDm[0];};this.getmodel=function (){return SIDm;};this.getoutput=function (){return (output/SCALE)*(M[0xD418]&0xF);};this.getplaytime=function (){return parseInt(playtime);};this.setmodel=function (model){SIDm=model;};this.setvolume=function (vol){volume=vol;};this.setloadcallback=function (fname){loadcallback=fname;};this.setstartcallback=function (fname){startcallback=fname;};this.setendcallback=function (fname,seconds){endcallback=fname;playlength=seconds;};var CLK=985248,FR=50,CHA=3,SCALE=0x10000*CHA*16;var SIDamount_vol=[0,1,0.6,0.4];var tit=new Uint8Array(0x20);var auth=new Uint8Array(0x20);var inf=new Uint8Array(0x20);var tmod=new Uint8Array(0x20);var ldad=0x1000,ina=0x1000,plf=0x1003,pla=0x1003,subtune=0,subtune_amount=1,playlength=0;var prSIDm=[8580.0,8580.0,8580.0];var SIDm=8580.0;var SID_address=[0xD400,0,0];var M=new Uint8Array(65536);var ldd=0,ind=0,fin=0,loadcallback=null,startcallback=null;endcallback=null,playtime=0,ended=0;var ckr=CLK/smpr;var fspd=smpr/FR;var fcnt=1,volume=1.0,CPUtime=0,pPC;var SIDamount=1,mix=0;function init(subt){if(ldd){ind=0;subtune=subt;initCPU(ina);initSID();A=subtune;M[1]=0x37;M[0xDC05]=0;for(var tout=100000;tout>=0;tout--){if(CPU())break;}if(tmod[subtune]||M[0xDC05]){if(!M[0xDC05]){M[0xDC04]=0x24;M[0xDC05]=0x40;}fspd=(M[0xDC04]+M[0xDC05]*256)/ckr;}else fspd=smpr/FR;if(plf==0)pla=((M[1]&3)<2)?M[0xFFFE]+M[0xFFFF]*256:M[0x314]+M[0x315]*256;else {pla=plf;if(pla>=0xE000&&M[1]==0x37)M[1]=0x35;}initCPU(pla);fcnt=1;fin=0;CPUtime=0;playtime=0;ended=0;ind=1;}}function play(){if(ldd&&ind){fcnt--;playtime+=1/smpr;if(fcnt<=0){fcnt=fspd;fin=0;PC=pla;SP=0xFF;}if(fin==0){while(CPUtime<=ckr){pPC=PC;if(CPU()>=0xFE){fin=1;break;}else CPUtime+=cyc;if((M[1]&3)>1&&pPC<0xE000&&(PC==0xEA31||PC==0xEA81)){fin=1;break;}if((addr==0xDC05||addr==0xDC04)&&(M[1]&3)&&tmod[subtune])fspd=(M[0xDC04]+M[0xDC05]*256)/ckr;if(sta>=0xD420&&sta<0xD800&&(M[1]&3)){if(!(SID_address[1]<=sta&&sta<SID_address[1]+0x1F)&&!(SID_address[2]<=sta&&sta<SID_address[2]+0x1F))M[sta&0xD41F]=M[sta];}if(addr==0xD404&&!(M[0xD404]&1))Ast[0]&=0x3E;if(addr==0xD40B&&!(M[0xD40B]&1))Ast[1]&=0x3E;if(addr==0xD412&&!(M[0xD412]&1))Ast[2]&=0x3E;}CPUtime-=ckr;}}if(playlength>0&&parseInt(playtime)==parseInt(playlength)&&endcallback!==null&&ended==0){ended=1;endcallback();}mix=SID(0,0xD400);if(SID_address[1])mix+=SID(1,SID_address[1]);if(SID_address[2])mix+=SID(2,SID_address[2]);return mix*volume*SIDamount_vol[SIDamount]+(Math.random()*bgnoi-bgnoi/2);};var flagsw=[0x01,0x21,0x04,0x24,0x00,0x40,0x08,0x28],brf=[0x80,0x40,0x01,0x02];var PC=0,A=0,T=0,X=0,Y=0,SP=0xFF,IR=0,addr=0,ST=0x00,cyc=0,sta=0;function initCPU(mempos){PC=mempos;A=0;X=0;Y=0;ST=0;SP=0xFF;}function CPU(){IR=M[PC];cyc=2;sta=0;if(IR&1){switch(IR&0x1F){case 1:case 3:addr=M[M[++PC]+X]+M[M[PC]+X+1]*256;cyc=6;break;case 0x11:case 0x13:addr=M[M[++PC]]+M[M[PC]+1]*256+Y;cyc=6;break;case 0x19:case 0x1F:addr=M[++PC]+M[++PC]*256+Y;cyc=5;break;case 0x1D:addr=M[++PC]+M[++PC]*256+X;cyc=5;break;case 0xD:case 0xF:addr=M[++PC]+M[++PC]*256;cyc=4;break;case 0x15:addr=M[++PC]+X;cyc=4;break;case 5:case 7:addr=M[++PC];cyc=3;break;case 0x17:addr=M[++PC]+Y;cyc=4;break;case 9:case 0xB:addr=++PC;cyc=2;}addr&=0xFFFF;switch(IR&0xE0){case 0x60:T=A;A+=M[addr]+(ST&1);ST&=20;ST|=(A&128)|(A>255);A&=0xFF;ST|=(!A)<<1|(!((T^M[addr])&0x80)&&((T^A)&0x80))>>1;break;case 0xE0:T=A;A-=M[addr]+!(ST&1);ST&=20;ST|=(A&128)|(A>=0);A&=0xFF;ST|=(!A)<<1|(((T^M[addr])&0x80)&&((T^A)&0x80))>>1;break;case 0xC0:T=A-M[addr];ST&=124;ST|=(!(T&0xFF))<<1|(T&128)|(T>=0);break;case 0x00:A|=M[addr];ST&=125;ST|=(!A)<<1|(A&128);break;case 0x20:A&=M[addr];ST&=125;ST|=(!A)<<1|(A&128);break;case 0x40:A^=M[addr];ST&=125;ST|=(!A)<<1|(A&128);break;case 0xA0:A=M[addr];ST&=125;ST|=(!A)<<1|(A&128);if((IR&3)==3)X=A;break;case 0x80:M[addr]=A&(((IR&3)==3)?X:0xFF);sta=addr;}}else if(IR&2){switch(IR&0x1F){case 0x1E:addr=M[++PC]+M[++PC]*256+(((IR&0xC0)!=0x80)?X:Y);cyc=5;break;case 0xE:addr=M[++PC]+M[++PC]*256;cyc=4;break;case 0x16:addr=M[++PC]+(((IR&0xC0)!=0x80)?X:Y);cyc=4;break;case 6:addr=M[++PC];cyc=3;break;case 2:addr=++PC;cyc=2;}addr&=0xFFFF;switch(IR&0xE0){case 0x00:ST&=0xFE;case 0x20:if((IR&0xF)==0xA){A=(A<<1)+(ST&1);ST&=60;ST|=(A&128)|(A>255);A&=0xFF;ST|=(!A)<<1;}else {T=(M[addr]<<1)+(ST&1);ST&=60;ST|=(T&128)|(T>255);T&=0xFF;ST|=(!T)<<1;M[addr]=T;cyc+=2;}break;case 0x40:ST&=0xFE;case 0x60:if((IR&0xF)==0xA){T=A;A=(A>>1)+(ST&1)*128;ST&=60;ST|=(A&128)|(T&1);A&=0xFF;ST|=(!A)<<1;}else {T=(M[addr]>>1)+(ST&1)*128;ST&=60;ST|=(T&128)|(M[addr]&1);T&=0xFF;ST|=(!T)<<1;M[addr]=T;cyc+=2;}break;case 0xC0:if(IR&4){M[addr]--;M[addr]&=0xFF;ST&=125;ST|=(!M[addr])<<1|(M[addr]&128);cyc+=2;}else {X--;X&=0xFF;ST&=125;ST|=(!X)<<1|(X&128);}break;case 0xA0:if((IR&0xF)!=0xA)X=M[addr];else if(IR&0x10){X=SP;break;}else X=A;ST&=125;ST|=(!X)<<1|(X&128);break;case 0x80:if(IR&4){M[addr]=X;sta=addr;}else if(IR&0x10)SP=X;else {A=X;ST&=125;ST|=(!A)<<1|(A&128);}break;case 0xE0:if(IR&4){M[addr]++;M[addr]&=0xFF;ST&=125;ST|=(!M[addr])<<1|(M[addr]&128);cyc+=2;}}}else if((IR&0xC)==8){switch(IR&0xF0){case 0x60:SP++;SP&=0xFF;A=M[0x100+SP];ST&=125;ST|=(!A)<<1|(A&128);cyc=4;break;case 0xC0:Y++;Y&=0xFF;ST&=125;ST|=(!Y)<<1|(Y&128);break;case 0xE0:X++;X&=0xFF;ST&=125;ST|=(!X)<<1|(X&128);break;case 0x80:Y--;Y&=0xFF;ST&=125;ST|=(!Y)<<1|(Y&128);break;case 0x00:M[0x100+SP]=ST;SP--;SP&=0xFF;cyc=3;break;case 0x20:SP++;SP&=0xFF;ST=M[0x100+SP];cyc=4;break;case 0x40:M[0x100+SP]=A;SP--;SP&=0xFF;cyc=3;break;case 0x90:A=Y;ST&=125;ST|=(!A)<<1|(A&128);break;case 0xA0:Y=A;ST&=125;ST|=(!Y)<<1|(Y&128);break;default:if(flagsw[IR>>5]&0x20)ST|=(flagsw[IR>>5]&0xDF);else ST&=255-(flagsw[IR>>5]&0xDF);}}else {if((IR&0x1F)==0x10){PC++;T=M[PC];if(T&0x80)T-=0x100;if(IR&0x20){if(ST&brf[IR>>6]){PC+=T;cyc=3;}}else {if(!(ST&brf[IR>>6])){PC+=T;cyc=3;}}}else {switch(IR&0x1F){case 0:addr=++PC;cyc=2;break;case 0x1C:addr=M[++PC]+M[++PC]*256+X;cyc=5;break;case 0xC:addr=M[++PC]+M[++PC]*256;cyc=4;break;case 0x14:addr=M[++PC]+X;cyc=4;break;case 4:addr=M[++PC];cyc=3;}addr&=0xFFFF;switch(IR&0xE0){case 0x00:M[0x100+SP]=PC%256;SP--;SP&=0xFF;M[0x100+SP]=PC/256;SP--;SP&=0xFF;M[0x100+SP]=ST;SP--;SP&=0xFF;PC=M[0xFFFE]+M[0xFFFF]*256-1;cyc=7;break;case 0x20:if(IR&0xF){ST&=0x3D;ST|=(M[addr]&0xC0)|(!(A&M[addr]))<<1;}else {M[0x100+SP]=(PC+2)%256;SP--;SP&=0xFF;M[0x100+SP]=(PC+2)/256;SP--;SP&=0xFF;PC=M[addr]+M[addr+1]*256-1;cyc=6;}break;case 0x40:if(IR&0xF){PC=addr-1;cyc=3;}else {if(SP>=0xFF)return 0xFE;SP++;SP&=0xFF;ST=M[0x100+SP];SP++;SP&=0xFF;T=M[0x100+SP];SP++;SP&=0xFF;PC=M[0x100+SP]+T*256-1;cyc=6;}break;case 0x60:if(IR&0xF){PC=M[addr]+M[addr+1]*256-1;cyc=5;}else {if(SP>=0xFF)return 0xFF;SP++;SP&=0xFF;T=M[0x100+SP];SP++;SP&=0xFF;PC=M[0x100+SP]+T*256-1;cyc=6;}break;case 0xC0:T=Y-M[addr];ST&=124;ST|=(!(T&0xFF))<<1|(T&128)|(T>=0);break;case 0xE0:T=X-M[addr];ST&=124;ST|=(!(T&0xFF))<<1|(T&128)|(T>=0);break;case 0xA0:Y=M[addr];ST&=125;ST|=(!Y)<<1|(Y&128);break;case 0x80:M[addr]=Y;sta=addr;}}}PC++;PC&=0xFFFF;return 0;};var GAT=0x01,SYN=0x02,RNG=0x04,TST=0x08,TRI=0x10,SAW=0x20,PUL=0x40,NOI=0x80,HZ=0x10,DECSUS=0x40,ATK=0x80,FSW=[1,2,4,1,2,4,1,2,4],LP=0x10,BP=0x20,HP=0x40,OFF3=0x80;var Ast=[0,0,0,0,0,0,0,0,0],rcnt=[0,0,0,0,0,0,0,0,0],envcnt=[0,0,0,0,0,0,0,0,0],expcnt=[0,0,0,0,0,0,0,0,0],pSR=[0,0,0,0,0,0,0,0,0];var pacc=[0,0,0,0,0,0,0,0,0],pracc=[0,0,0,0,0,0,0,0,0],sMSBrise=[0,0,0],sMSB=[0,0,0];var nLFSR=[0x7FFFF8,0x7FFFF8,0x7FFFF8,0x7FFFF8,0x7FFFF8,0x7FFFF8,0x7FFFF8,0x7FFFF8,0x7FFFF8];var prevwfout=[0,0,0,0,0,0,0,0,0],pwv=[0,0,0,0,0,0,0,0,0],combiwf;var plp=[0,0,0],pbp=[0,0,0],ctfr=-2*3.14*(12500/256)/smpr,ctf_ratio_6581=-2*3.14*(20000/256)/smpr;var pgt,chnadd,ctrl,wf,test,prd,step,SR,aAdd,MSB,tmp,pw,lim,wfout,ctf,reso,flin,output;function initSID(){for(var i=0xD400;i<=0xD7FF;i++)M[i]=0;for(var i=0xDE00;i<=0xDFFF;i++)M[i]=0;for(var i=0;i<9;i++){Ast[i]=HZ;rcnt[i]=envcnt[i]=expcnt[i]=pSR[i]=0;}}function SID(num,SIDaddr){flin=0;output=0;for(var chn=num*CHA;chn<(num+1)*CHA;chn++){pgt=(Ast[chn]&GAT);chnadd=SIDaddr+(chn-num*CHA)*7,ctrl=M[chnadd+4];wf=ctrl&0xF0;test=ctrl&TST;SR=M[chnadd+6];tmp=0;if(pgt!=(ctrl&GAT)){if(pgt){Ast[chn]&=0xFF-(GAT|ATK|DECSUS);}else {Ast[chn]=(GAT|ATK|DECSUS);if((SR&0xF)>(pSR[chn]&0xF))tmp=1;}}pSR[chn]=SR;rcnt[chn]+=ckr;if(rcnt[chn]>=0x8000)rcnt[chn]-=0x8000;if(Ast[chn]&ATK){step=M[chnadd+5]>>4;prd=Aprd[step];}else if(Ast[chn]&DECSUS){step=M[chnadd+5]&0xF;prd=Aprd[step];}else {step=SR&0xF;prd=Aprd[step];}step=Astp[step];if(rcnt[chn]>=prd&&rcnt[chn]<prd+ckr&&tmp==0){rcnt[chn]-=prd;if((Ast[chn]&ATK)||++expcnt[chn]==Aexp[envcnt[chn]]){if(!(Ast[chn]&HZ)){if(Ast[chn]&ATK){envcnt[chn]+=step;if(envcnt[chn]>=0xFF){envcnt[chn]=0xFF;Ast[chn]&=0xFF-ATK;}}else if(!(Ast[chn]&DECSUS)||envcnt[chn]>(SR>>4)+(SR&0xF0)){envcnt[chn]-=step;if(envcnt[chn]<=0&&envcnt[chn]+step!=0){envcnt[chn]=0;Ast[chn]|=HZ;}}}expcnt[chn]=0;}}envcnt[chn]&=0xFF;aAdd=(M[chnadd]+M[chnadd+1]*256)*ckr;if(test||((ctrl&SYN)&&sMSBrise[num])){pacc[chn]=0;}else {pacc[chn]+=aAdd;if(pacc[chn]>0xFFFFFF)pacc[chn]-=0x1000000;}MSB=pacc[chn]&0x800000;sMSBrise[num]=(MSB>(pracc[chn]&0x800000))?1:0;if(wf&NOI){tmp=nLFSR[chn];if(((pacc[chn]&0x100000)!=(pracc[chn]&0x100000))||aAdd>=0x100000){step=(tmp&0x400000)^((tmp&0x20000)<<5);tmp=((tmp<<1)+(step>0||test))&0x7FFFFF;nLFSR[chn]=tmp;}wfout=(wf&0x70)?0:((tmp&0x100000)>>5)+((tmp&0x40000)>>4)+((tmp&0x4000)>>1)+((tmp&0x800)<<1)+((tmp&0x200)<<2)+((tmp&0x20)<<5)+((tmp&0x04)<<7)+((tmp&0x01)<<8);}else if(wf&PUL){pw=(M[chnadd+2]+(M[chnadd+3]&0xF)*256)*16;tmp=aAdd>>9;if(0<pw&&pw<tmp)pw=tmp;tmp^=0xFFFF;if(pw>tmp)pw=tmp;tmp=pacc[chn]>>8;if(wf==PUL){step=256/(aAdd>>16);if(test)wfout=0xFFFF;else if(tmp<pw){lim=(0xFFFF-pw)*step;if(lim>0xFFFF)lim=0xFFFF;wfout=lim-(pw-tmp)*step;if(wfout<0)wfout=0;}else {lim=pw*step;if(lim>0xFFFF)lim=0xFFFF;wfout=(0xFFFF-tmp)*step-lim;if(wfout>=0)wfout=0xFFFF;wfout&=0xFFFF;}}else {wfout=(tmp>=pw||test)?0xFFFF:0;if(wf&TRI){if(wf&SAW){wfout=(wfout)?cmbWF(chn,Pulsetrsaw,tmp>>4,1):0;}else {tmp=pacc[chn]^(ctrl&RNG?sMSB[num]:0);wfout=(wfout)?cmbWF(chn,pusaw,(tmp^(tmp&0x800000?0xFFFFFF:0))>>11,0):0;}}else if(wf&SAW)wfout=(wfout)?cmbWF(chn,pusaw,tmp>>4,1):0;}}else if(wf&SAW){wfout=pacc[chn]>>8;if(wf&TRI)wfout=cmbWF(chn,trsaw,wfout>>4,1);else {step=aAdd/0x1200000;wfout+=wfout*step;if(wfout>0xFFFF)wfout=0xFFFF-(wfout-0x10000)/step;}}else if(wf&TRI){tmp=pacc[chn]^(ctrl&RNG?sMSB[num]:0);wfout=(tmp^(tmp&0x800000?0xFFFFFF:0))>>7;}if(wf)prevwfout[chn]=wfout;else {wfout=prevwfout[chn];}pracc[chn]=pacc[chn];sMSB[num]=MSB;if(M[SIDaddr+0x17]&FSW[chn])flin+=(wfout-0x8000)*(envcnt[chn]/256);else if((chn%CHA)!=2||!(M[SIDaddr+0x18]&OFF3))output+=(wfout-0x8000)*(envcnt[chn]/256);}if(M[1]&3)M[SIDaddr+0x1B]=wfout>>8;M[SIDaddr+0x1C]=envcnt[3];ctf=(M[SIDaddr+0x15]&7)/8+M[SIDaddr+0x16]+0.2;if(SIDm==8580.0){ctf=1-Math.exp(ctf*ctfr);reso=Math.pow(2,((4-(M[SIDaddr+0x17]>>4))/8));}else {if(ctf<24)ctf=0.035;else ctf=1-1.263*Math.exp(ctf*ctf_ratio_6581);reso=(M[SIDaddr+0x17]>0x5F)?8/(M[SIDaddr+0x17]>>4):1.41;}tmp=flin+pbp[num]*reso+plp[num];if(M[SIDaddr+0x18]&HP)output-=tmp;tmp=pbp[num]-tmp*ctf;pbp[num]=tmp;if(M[SIDaddr+0x18]&BP)output-=tmp;tmp=plp[num]+tmp*ctf;plp[num]=tmp;if(M[SIDaddr+0x18]&LP)output+=tmp;return (output/SCALE)*(M[SIDaddr+0x18]&0xF);}function cmbWF(chn,wfa,index,differ6581){if(differ6581&&SIDm==6581.0)index&=0x7FF;combiwf=(wfa[index]+pwv[chn])/2;pwv[chn]=wfa[index];return combiwf;}function cCmbWF(wfa,bitmul,bstr,trh){for(var i=0;i<4096;i++){wfa[i]=0;for(var j=0;j<12;j++){var blvl=0;for(var k=0;k<12;k++){blvl+=(bitmul/Math.pow(bstr,Math.abs(k-j)))*(((i>>k)&1)-0.5);}wfa[i]+=(blvl>=trh)?Math.pow(2,j):0;}wfa[i]*=12;}}trsaw=new Array(4096);cCmbWF(trsaw,0.8,2.4,0.64);pusaw=new Array(4096);cCmbWF(pusaw,1.4,1.9,0.68);Pulsetrsaw=new Array(4096);cCmbWF(Pulsetrsaw,0.8,2.5,0.64);var prd0=Math.max(ckr,9);var Aprd=[prd0,32*1,63*1,95*1,149*1,220*1,267*1,313*1,392*1,977*1,1954*1,3126*1,3907*1,11720*1,19532*1,31251*1];var Astp=[Math.ceil(prd0/9),1,1,1,1,1,1,1,1,1,1,1,1,1,1,1];var Aexp=[1,30,30,30,30,30,30,16,16,16,16,16,16,16,16,8,8,8,8,8,8,8,8,8,8,8,8,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1];}
+//jsSID by Hermit (Mihaly Horvath) : a javascript SID emulator and player for the Web Audio API
+//(Year 2016) http://hermit.sidrip.com
+function playSID(sidurl, subtune) {
+  //convenience function to create default-named jsSID object and play in one call, easily includable as inline JS function call in HTML
+  if (typeof SIDplayer === 'undefined') {
+    SIDplayer = new jsSID(16384, 0.0005); //create the object if doesn't exist yet
+  }
+  SIDplayer.loadstart(sidurl, subtune);
+}
+
+
+function jsSID(bufferlen, background_noise) {
+
+  this.author = 'Hermit';
+  this.sourcecode = 'http://hermit.sidrip.com';
+  this.version = '0.9.1';
+  this.year = '2016';
+
+  //create Web Audio context and scriptNode at jsSID object initialization (at the moment only mono output)
+  if (typeof AudioContext !== 'undefined') {
+    var jsSID_audioCtx = new AudioContext();
+  } else {
+    var jsSID_audioCtx = new webkitAudioContext();
+  }
+  var samplerate = jsSID_audioCtx.sampleRate;
+  if (typeof jsSID_audioCtx.createJavaScriptNode === 'function') {
+    var jsSID_scriptNode = jsSID_audioCtx.createJavaScriptNode(bufferlen, 0, 1);
+  } else {
+    var jsSID_scriptNode = jsSID_audioCtx.createScriptProcessor(bufferlen, 0, 1);
+  }
+
+  jsSID_scriptNode.onaudioprocess = function(e) {
+    //scriptNode will be replaced by AudioWorker in new browsers sooner or later
+    var outBuffer = e.outputBuffer;
+    var outData = outBuffer.getChannelData(0);
+    for (var sample = 0; sample < outBuffer.length; sample++) {
+      outData[sample] = play();
+    }
+  }
+
+
+  //user functions callable from outside
+  this.loadstart = function(sidurl, subt) {
+    this.loadinit(sidurl, subt);
+    if (startcallback !== null) startcallback();
+    this.playcont();
+  }
+
+  this.loadinit = function(sidurl, subt) {
+    loaded = 0;
+    this.pause();
+    initSID();
+    subtune = subt; //stop playback before loading new tune
+    var request = new XMLHttpRequest();
+    request.open('GET', sidurl, true);
+    request.responseType = 'arraybuffer';
+
+    request.onload = function() { //request.onreadystatechange=function(){ if (this.readyState!==4) return; ... could be used too
+      var filedata = new Uint8Array(request.response); //SID-file format information can be found at HVSC
+      var i, strend, offs = filedata[7];
+      loadaddr = filedata[8] + filedata[9] ? filedata[8] * 256 + filedata[9] : filedata[offs] + filedata[
+        offs + 1] * 256;
+      for (i = 0; i < 32; i++) timermode[31 - i] = filedata[0x12 + (i >> 3)] & Math.pow(2, 7 - i % 8);
+      for (i = 0; i < memory.length; i++) memory[i] = 0;
+      for (i = offs + 2; i < filedata.byteLength; i++) {
+        if (loadaddr + i - (offs + 2) < memory.length) memory[loadaddr + i - (offs + 2)] = filedata[i];
+      }
+      strend = 1;
+      for (i = 0; i < 32; i++) {
+        if (strend != 0) strend = SIDtitle[i] = filedata[0x16 + i];
+        else strend = SIDtitle[i] = 0;
+      }
+      strend = 1;
+      for (i = 0; i < 32; i++) {
+        if (strend != 0) strend = SIDauthor[i] = filedata[0x36 + i];
+        else strend = SIDauthor[i] = 0;
+      }
+      strend = 1;
+      for (i = 0; i < 32; i++) {
+        if (strend != 0) strend = SIDinfo[i] = filedata[0x56 + i];
+        else strend = SIDinfo[i] = 0;
+      }
+      initaddr = filedata[0xA] + filedata[0xB] ? filedata[0xA] * 256 + filedata[0xB] : loadaddr;
+      playaddr = playaddf = filedata[0xC] * 256 + filedata[0xD];
+      subtune_amount = filedata[0xF];
+      preferred_SID_model[0] = (filedata[0x77] & 0x30) >= 0x20 ? 8580 : 6581;
+      preferred_SID_model[1] = (filedata[0x77] & 0xC0) >= 0x80 ? 8580 : 6581;
+      preferred_SID_model[2] = (filedata[0x76] & 3) >= 3 ? 8580 : 6581;
+      SID_address[1] = filedata[0x7A] >= 0x42 && (filedata[0x7A] < 0x80 || filedata[0x7A] >= 0xE0) ?
+        0xD000 + filedata[0x7A] * 16 : 0;
+      SID_address[2] = filedata[0x7B] >= 0x42 && (filedata[0x7B] < 0x80 || filedata[0x7B] >= 0xE0) ?
+        0xD000 + filedata[0x7B] * 16 : 0;
+      SIDamount = 1 + (SID_address[1] > 0) + (SID_address[2] > 0);
+      loaded = 1;
+      if (loadcallback !== null) loadcallback();
+      init(subtune);
+    }; // ';' is needed here (and similar places) so that minimized/compacted jsSID.js generated by Makefile will work in the browser
+
+    request.send(null);
+  }
+
+  this.start = function(subt) {
+    init(subt);
+    if (startcallback !== null) startcallback();
+    this.playcont();
+  }
+  this.playcont = function() {
+    jsSID_scriptNode.connect(jsSID_audioCtx.destination);
+  }
+  this.pause = function() {
+      if (loaded && initialized) jsSID_scriptNode.disconnect(jsSID_audioCtx.destination);
+    }
+    //(Checking state before disconnecting is a workaround for Opera: gave error when code tried disconnecting what is not connected.
+    //Checking inner state variables here, but maybe audioContext status info could be more reliable. I just didn't want to rely too many Audio API function.)
+  this.stop = function() {
+      this.pause();
+      init(subtune);
+    }
+    //using functions to get states instead of variables. this enables value conversions and gives easier/explicite scoping
+  this.gettitle = function() {
+    return String.fromCharCode.apply(null, SIDtitle);
+  }
+  this.getauthor = function() {
+    return String.fromCharCode.apply(null, SIDauthor);
+  }
+  this.getinfo = function() {
+    return String.fromCharCode.apply(null, SIDinfo);
+  }
+  this.getsubtunes = function() {
+    return subtune_amount;
+  }
+  this.getprefmodel = function() {
+    return preferred_SID_model[0];
+  }
+  this.getmodel = function() {
+    return SID_model;
+  }
+  this.getoutput = function() {
+    return (output / OUTPUT_SCALEDOWN) * (memory[0xD418] & 0xF);
+  }
+  this.getplaytime = function() {
+    return parseInt(playtime);
+  }
+  this.setmodel = function(model) {
+    SID_model = model;
+  }
+  this.setvolume = function(vol) {
+    volume = vol;
+  }
+  this.setloadcallback = function(fname) {
+    loadcallback = fname;
+  }
+  this.setstartcallback = function(fname) {
+    startcallback = fname;
+  }
+  this.setendcallback = function(fname, seconds) {
+    endcallback = fname;
+    playlength = seconds;
+  }
+  this.setmemorywritecallback = function(fname) {
+    memorywritecallback = fname;
+  }
+  var //emulated machine constants
+    C64_PAL_CPUCLK = 985248, //Hz
+    PAL_FRAMERATE = 50, //NTSC_FRAMERATE = 60;
+    SID_CHANNEL_AMOUNT = 3,
+    OUTPUT_SCALEDOWN = 0x10000 * SID_CHANNEL_AMOUNT * 16;
+  var SIDamount_vol = [0, 1, 0.6, 0.4]; //how much to attenuate with more 2SID/3SID to avoid master-output overflows
+
+  //SID playback related arrays/variables - avoiding internal/automatic variables to retain speed
+  var SIDtitle = new Uint8Array(0x20);
+  var SIDauthor = new Uint8Array(0x20);
+  var SIDinfo = new Uint8Array(0x20);
+  var timermode = new Uint8Array(0x20);
+  var loadaddr = 0x1000,
+    initaddr = 0x1000,
+    playaddf = 0x1003,
+    playaddr = 0x1003,
+    subtune = 0,
+    subtune_amount = 1,
+    playlength = 0; //framespeed = 1;
+  var preferred_SID_model = [8580.0, 8580.0, 8580.0];
+  var SID_model = 8580.0;
+  var SID_address = [0xD400, 0, 0];
+  var memory = new Uint8Array(65536); //for(var i=0;i<memory.length;i++) memory[i]=0;
+  var loaded = 0,
+    initialized = 0,
+    finished = 0,
+    loadcallback = null,
+    startcallback = null,
+    endcallback = null,
+    memorywritecallback = null,
+    playtime = 0,
+    ended = 0;
+  var clk_ratio = C64_PAL_CPUCLK / samplerate;
+  var frame_sampleperiod = samplerate / PAL_FRAMERATE; //samplerate/(PAL_FRAMERATE*framespeed);
+  var framecnt = 1,
+    volume = 1.0,
+    CPUtime = 0,
+    pPC;
+  var SIDamount = 1,
+    mix = 0;
+
+  function init(subt) {
+    if (loaded) {
+      initialized = 0;
+      subtune = subt;
+      initCPU(initaddr);
+      initSID();
+      A = subtune;
+      memory[1] = 0x37;
+      memory[0xDC05] = 0;
+      for (var timeout = 100000; timeout >= 0; timeout--) {
+        if (CPU()) break;
+      }
+      if (timermode[subtune] || memory[0xDC05]) { //&& playaddf {   //CIA timing
+        if (!memory[0xDC05]) {
+          memory[0xDC04] = 0x24;
+          memory[0xDC05] = 0x40;
+        }
+        frame_sampleperiod = (memory[0xDC04] + memory[0xDC05] * 256) / clk_ratio;
+      } else frame_sampleperiod = samplerate / PAL_FRAMERATE; //Vsync timing
+      //frame_sampleperiod = (memory[0xDC05]!=0 || (!timermode[subtune] && playaddf))? samplerate/PAL_FRAMERATE : (memory[0xDC04] + memory[0xDC05]*256) / clk_ratio;
+      if (playaddf == 0) playaddr = ((memory[1] & 3) < 2) ? memory[0xFFFE] + memory[0xFFFF] * 256 : memory[
+        0x314] + memory[0x315] * 256;
+      else {
+        playaddr = playaddf;
+        if (playaddr >= 0xE000 && memory[1] == 0x37) memory[1] = 0x35;
+      } //player under KERNAL (Crystal Kingdom Dizzy)
+      initCPU(playaddr);
+      framecnt = 1;
+      finished = 0;
+      CPUtime = 0;
+      playtime = 0;
+      ended = 0;
+      initialized = 1;
+    }
+  }
+
+  function play() {
+    //called internally by the Web Audio API scriptNode callback;
+    //handles SID-register reading/processing and SID emulation
+    if (loaded && initialized) {
+      framecnt--;
+      playtime += 1 / samplerate;
+      if (framecnt <= 0) {
+        framecnt = frame_sampleperiod;
+        finished = 0;
+        PC = playaddr;
+        SP = 0xFF;
+      }
+      if (finished == 0) {
+        while (CPUtime <= clk_ratio) {
+          pPC = PC;
+          if (CPU() >= 0xFE) {
+            finished = 1;
+            break;
+          } else CPUtime += cycles;
+          if ((memory[1] & 3) > 1 && pPC < 0xE000 && (PC == 0xEA31 || PC == 0xEA81)) {
+            finished = 1;
+            break;
+          } //IRQ player ROM return handling
+          if ((addr == 0xDC05 || addr == 0xDC04) && (memory[1] & 3) && timermode[subtune]) frame_sampleperiod =
+            (memory[0xDC04] + memory[0xDC05] * 256) / clk_ratio; //Galway/Rubicon workaround
+          if (storadd >= 0xD420 && storadd < 0xD800 && (memory[1] & 3)) { //CJ in the USA workaround (writing above $d420, except SID2/SID3)
+            if (!(SID_address[1] <= storadd && storadd < SID_address[1] + 0x1F) && !(SID_address[2] <=
+                storadd && storadd < SID_address[2] + 0x1F))
+              memoryWrite(storadd & 0xD41F, memory[storadd]);
+          }
+          if (addr == 0xD404 && !(memory[0xD404] & 1)) ADSRstate[0] &= 0x3E;
+          if (addr == 0xD40B && !(memory[0xD40B] & 1)) ADSRstate[1] &= 0x3E;
+          if (addr == 0xD412 && !(memory[0xD412] & 1)) ADSRstate[2] &= 0x3E; //Whittaker player workaround
+        }
+        CPUtime -= clk_ratio;
+      }
+    }
+
+    if (playlength > 0 && parseInt(playtime) == parseInt(playlength) && endcallback !== null && ended == 0) {
+      ended = 1;
+      endcallback();
+    }
+    mix = SID(0, 0xD400);
+    if (SID_address[1]) mix += SID(1, SID_address[1]);
+    if (SID_address[2]) mix += SID(2, SID_address[2]);
+
+    return mix * volume * SIDamount_vol[SIDamount] + (Math.random() * background_noise - background_noise / 2);
+  }
+
+
+  var //CPU (and CIA/VIC-IRQ) emulation constants and variables - avoiding internal/automatic variables to retain speed
+    flagsw = [0x01, 0x21, 0x04, 0x24, 0x00, 0x40, 0x08, 0x28],
+    branchflag = [0x80, 0x40, 0x01, 0x02];
+  var PC = 0,
+    A = 0,
+    T = 0,
+    X = 0,
+    Y = 0,
+    SP = 0xFF,
+    IR = 0,
+    addr = 0,
+    ST = 0x00,
+    cycles = 0,
+    storadd = 0; //STATUS-flags: N V - B D I Z C
+
+  function initCPU(mempos) {
+    PC = mempos;
+    A = 0;
+    X = 0;
+    Y = 0;
+    ST = 0;
+    SP = 0xFF;
+  }
+
+  //My CPU implementation is based on the instruction table by Graham at codebase64.
+  //After some examination of the table it was clearly seen that columns of the table (instructions' 2nd nybbles)
+  // mainly correspond to addressing modes, and double-rows usually have the same instructions.
+  //The code below is laid out like this, with some exceptions present.
+  //Thanks to the hardware being in my mind when coding this, more of the illegal instructions can be added fairly easily...
+
+  function memoryWrite(addr, val){
+    memory[addr] = val
+    if(memorywritecallback){
+      memorywritecallback(addr, val);
+    }
+  }
+
+  function CPU() //the CPU emulation for SID/PRG playback (ToDo: CIA/VIC-IRQ/NMI/RESET vectors, BCD-mode)
+  { //'IR' is the instruction-register, naming after the hardware-equivalent
+    IR = memory[PC];
+    cycles = 2;
+    storadd = 0; //'cycle': ensure smallest 6510 runtime (for implied/register instructions)
+
+    if (IR & 1) { //nybble2:  1/5/9/D:accu.instructions, 3/7/B/F:illegal opcodes
+      switch (IR & 0x1F) { //addressing modes (begin with more complex cases), PC wraparound not handled inside to save codespace
+        case 1:
+        case 3:
+          addr = memory[memory[++PC] + X] + memory[memory[PC] + X + 1] * 256;
+          cycles = 6;
+          break; //(zp,x)
+        case 0x11:
+        case 0x13:
+          addr = memory[memory[++PC]] + memory[memory[PC] + 1] * 256 + Y;
+          cycles = 6;
+          break; //(zp),y
+        case 0x19:
+        case 0x1F:
+          addr = memory[++PC] + memory[++PC] * 256 + Y;
+          cycles = 5;
+          break; //abs,y
+        case 0x1D:
+          addr = memory[++PC] + memory[++PC] * 256 + X;
+          cycles = 5;
+          break; //abs,x
+        case 0xD:
+        case 0xF:
+          addr = memory[++PC] + memory[++PC] * 256;
+          cycles = 4;
+          break; //abs
+        case 0x15:
+          addr = memory[++PC] + X;
+          cycles = 4;
+          break; //zp,x
+        case 5:
+        case 7:
+          addr = memory[++PC];
+          cycles = 3;
+          break; //zp
+        case 0x17:
+          addr = memory[++PC] + Y;
+          cycles = 4;
+          break; //zp,y for LAX/SAX illegal opcodes
+        case 9:
+        case 0xB:
+          addr = ++PC;
+          cycles = 2; //immediate
+      }
+      addr &= 0xFFFF;
+      switch (IR & 0xE0) {
+        case 0x60:
+          T = A;
+          A += memory[addr] + (ST & 1);
+          ST &= 20;
+          ST |= (A & 128) | (A > 255);
+          A &= 0xFF;
+          ST |= (!A) << 1 | (!((T ^ memory[addr]) & 0x80) && ((T ^ A) & 0x80)) >> 1;
+          break; //ADC
+        case 0xE0:
+          T = A;
+          A -= memory[addr] + !(ST & 1);
+          ST &= 20;
+          ST |= (A & 128) | (A >= 0);
+          A &= 0xFF;
+          ST |= (!A) << 1 | (((T ^ memory[addr]) & 0x80) && ((T ^ A) & 0x80)) >> 1;
+          break; //SBC
+        case 0xC0:
+          T = A - memory[addr];
+          ST &= 124;
+          ST |= (!(T & 0xFF)) << 1 | (T & 128) | (T >= 0);
+          break; //CMP
+        case 0x00:
+          A |= memory[addr];
+          ST &= 125;
+          ST |= (!A) << 1 | (A & 128);
+          break; //ORA
+        case 0x20:
+          A &= memory[addr];
+          ST &= 125;
+          ST |= (!A) << 1 | (A & 128);
+          break; //AND
+        case 0x40:
+          A ^= memory[addr];
+          ST &= 125;
+          ST |= (!A) << 1 | (A & 128);
+          break; //EOR
+        case 0xA0:
+          A = memory[addr];
+          ST &= 125;
+          ST |= (!A) << 1 | (A & 128);
+          if ((IR & 3) == 3) X = A;
+          break; //LDA / LAX (illegal, used by my 1 rasterline player)
+        case 0x80:
+          memoryWrite(addr, A & (((IR & 3) == 3) ? X : 0xFF));
+          storadd = addr; //STA / SAX (illegal)
+      }
+    } else if (IR & 2) { //nybble2:  2:illegal/LDX, 6:A/X/INC/DEC, A:Accu-shift/reg.transfer/NOP, E:shift/X/INC/DEC
+      switch (IR & 0x1F) { //addressing modes
+        case 0x1E:
+          addr = memory[++PC] + memory[++PC] * 256 + (((IR & 0xC0) != 0x80) ? X : Y);
+          cycles = 5;
+          break; //abs,x / abs,y
+        case 0xE:
+          addr = memory[++PC] + memory[++PC] * 256;
+          cycles = 4;
+          break; //abs
+        case 0x16:
+          addr = memory[++PC] + (((IR & 0xC0) != 0x80) ? X : Y);
+          cycles = 4;
+          break; //zp,x / zp,y
+        case 6:
+          addr = memory[++PC];
+          cycles = 3;
+          break; //zp
+        case 2:
+          addr = ++PC;
+          cycles = 2; //imm.
+      }
+      addr &= 0xFFFF;
+      switch (IR & 0xE0) {
+        case 0x00:
+          ST &= 0xFE;
+        case 0x20:
+          if ((IR & 0xF) == 0xA) {
+            A = (A << 1) + (ST & 1);
+            ST &= 60;
+            ST |= (A & 128) | (A > 255);
+            A &= 0xFF;
+            ST |= (!A) << 1;
+          } //ASL/ROL (Accu)
+          else {
+            T = (memory[addr] << 1) + (ST & 1);
+            ST &= 60;
+            ST |= (T & 128) | (T > 255);
+            T &= 0xFF;
+            ST |= (!T) << 1;
+            memoryWrite(addr, T);
+            cycles += 2;
+          }
+          break; //RMW (Read-Write-Modify)
+        case 0x40:
+          ST &= 0xFE;
+        case 0x60:
+          if ((IR & 0xF) == 0xA) {
+            T = A;
+            A = (A >> 1) + (ST & 1) * 128;
+            ST &= 60;
+            ST |= (A & 128) | (T & 1);
+            A &= 0xFF;
+            ST |= (!A) << 1;
+          } //LSR/ROR (Accu)
+          else {
+            T = (memory[addr] >> 1) + (ST & 1) * 128;
+            ST &= 60;
+            ST |= (T & 128) | (memory[addr] & 1);
+            T &= 0xFF;
+            ST |= (!T) << 1;
+            memoryWrite(addr, T);
+            cycles += 2;
+          }
+          break; //RMW
+        case 0xC0:
+          if (IR & 4) {
+            memory[addr]--;
+            memory[addr] &= 0xFF;
+            ST &= 125;
+            ST |= (!memory[addr]) << 1 | (memory[addr] & 128);
+            cycles += 2;
+          } //DEC
+          else {
+            X--;
+            X &= 0xFF;
+            ST &= 125;
+            ST |= (!X) << 1 | (X & 128);
+          }
+          break; //DEX
+        case 0xA0:
+          if ((IR & 0xF) != 0xA) X = memory[addr];
+          else if (IR & 0x10) {
+            X = SP;
+            break;
+          } else X = A;
+          ST &= 125;
+          ST |= (!X) << 1 | (X & 128);
+          break; //LDX/TSX/TAX
+        case 0x80:
+          if (IR & 4) {
+            memoryWrite(addr, X);
+            storadd = addr;
+          } else if (IR & 0x10) SP = X;
+          else {
+            A = X;
+            ST &= 125;
+            ST |= (!A) << 1 | (A & 128);
+          }
+          break; //STX/TXS/TXA
+        case 0xE0:
+          if (IR & 4) {
+            memoryWrite(addr, memory[addr] + 1);
+            memoryWrite(addr, memory[addr] & 0xFF);
+            ST &= 125;
+            ST |= (!memory[addr]) << 1 | (memory[addr] & 128);
+            cycles += 2;
+          } //INC/NOP
+      }
+    } else if ((IR & 0xC) == 8) { //nybble2:  8:register/status
+      switch (IR & 0xF0) {
+        case 0x60:
+          SP++;
+          SP &= 0xFF;
+          A = memory[0x100 + SP];
+          ST &= 125;
+          ST |= (!A) << 1 | (A & 128);
+          cycles = 4;
+          break; //PLA
+        case 0xC0:
+          Y++;
+          Y &= 0xFF;
+          ST &= 125;
+          ST |= (!Y) << 1 | (Y & 128);
+          break; //INY
+        case 0xE0:
+          X++;
+          X &= 0xFF;
+          ST &= 125;
+          ST |= (!X) << 1 | (X & 128);
+          break; //INX
+        case 0x80:
+          Y--;
+          Y &= 0xFF;
+          ST &= 125;
+          ST |= (!Y) << 1 | (Y & 128);
+          break; //DEY
+        case 0x00:
+          memoryWrite(0x100 + SP, ST);
+          SP--;
+          SP &= 0xFF;
+          cycles = 3;
+          break; //PHP
+        case 0x20:
+          SP++;
+          SP &= 0xFF;
+          ST = memory[0x100 + SP];
+          cycles = 4;
+          break; //PLP
+        case 0x40:
+          memoryWrite(0x100 + SP, A);
+          SP--;
+          SP &= 0xFF;
+          cycles = 3;
+          break; //PHA
+        case 0x90:
+          A = Y;
+          ST &= 125;
+          ST |= (!A) << 1 | (A & 128);
+          break; //TYA
+        case 0xA0:
+          Y = A;
+          ST &= 125;
+          ST |= (!Y) << 1 | (Y & 128);
+          break; //TAY
+        default:
+          if (flagsw[IR >> 5] & 0x20) ST |= (flagsw[IR >> 5] & 0xDF);
+          else ST &= 255 - (flagsw[IR >> 5] & 0xDF); //CLC/SEC/CLI/SEI/CLV/CLD/SED
+      }
+    } else { //nybble2:  0: control/branch/Y/compare  4: Y/compare  C:Y/compare/JMP
+      if ((IR & 0x1F) == 0x10) {
+        PC++;
+        T = memory[PC];
+        if (T & 0x80) T -= 0x100; //BPL/BMI/BVC/BVS/BCC/BCS/BNE/BEQ  relative branch
+        if (IR & 0x20) {
+          if (ST & branchflag[IR >> 6]) {
+            PC += T;
+            cycles = 3;
+          }
+        } else {
+          if (!(ST & branchflag[IR >> 6])) {
+            PC += T;
+            cycles = 3;
+          }
+        }
+      } else { //nybble2:  0:Y/control/Y/compare  4:Y/compare  C:Y/compare/JMP
+        switch (IR & 0x1F) { //addressing modes
+          case 0:
+            addr = ++PC;
+            cycles = 2;
+            break; //imm. (or abs.low for JSR/BRK)
+          case 0x1C:
+            addr = memory[++PC] + memory[++PC] * 256 + X;
+            cycles = 5;
+            break; //abs,x
+          case 0xC:
+            addr = memory[++PC] + memory[++PC] * 256;
+            cycles = 4;
+            break; //abs
+          case 0x14:
+            addr = memory[++PC] + X;
+            cycles = 4;
+            break; //zp,x
+          case 4:
+            addr = memory[++PC];
+            cycles = 3; //zp
+        }
+        addr &= 0xFFFF;
+        switch (IR & 0xE0) {
+          case 0x00:
+            memoryWrite(0x100 + SP, PC % 256);
+            SP--;
+            SP &= 0xFF;
+            memoryWrite(0x100 + SP, PC / 256);
+            SP--;
+            SP &= 0xFF;
+            memoryWrite(0x100 + SP, ST);
+            SP--;
+            SP &= 0xFF;
+            PC = memory[0xFFFE] + memory[0xFFFF] * 256 - 1;
+            cycles = 7;
+            break; //BRK
+          case 0x20:
+            if (IR & 0xF) {
+              ST &= 0x3D;
+              ST |= (memory[addr] & 0xC0) | (!(A & memory[addr])) << 1;
+            } //BIT
+            else {
+              memoryWrite(0x100 + SP, (PC + 2) % 256);
+              SP--;
+              SP &= 0xFF;
+              memoryWrite(0x100 + SP, (PC + 2) / 256);
+              SP--;
+              SP &= 0xFF;
+              PC = memory[addr] + memory[addr + 1] * 256 - 1;
+              cycles = 6;
+            }
+            break; //JSR
+          case 0x40:
+            if (IR & 0xF) {
+              PC = addr - 1;
+              cycles = 3;
+            } //JMP
+            else {
+              if (SP >= 0xFF) return 0xFE;
+              SP++;
+              SP &= 0xFF;
+              ST = memory[0x100 + SP];
+              SP++;
+              SP &= 0xFF;
+              T = memory[0x100 + SP];
+              SP++;
+              SP &= 0xFF;
+              PC = memory[0x100 + SP] + T * 256 - 1;
+              cycles = 6;
+            }
+            break; //RTI
+          case 0x60:
+            if (IR & 0xF) {
+              PC = memory[addr] + memory[addr + 1] * 256 - 1;
+              cycles = 5;
+            } //JMP() (indirect)
+            else {
+              if (SP >= 0xFF) return 0xFF;
+              SP++;
+              SP &= 0xFF;
+              T = memory[0x100 + SP];
+              SP++;
+              SP &= 0xFF;
+              PC = memory[0x100 + SP] + T * 256 - 1;
+              cycles = 6;
+            }
+            break; //RTS
+          case 0xC0:
+            T = Y - memory[addr];
+            ST &= 124;
+            ST |= (!(T & 0xFF)) << 1 | (T & 128) | (T >= 0);
+            break; //CPY
+          case 0xE0:
+            T = X - memory[addr];
+            ST &= 124;
+            ST |= (!(T & 0xFF)) << 1 | (T & 128) | (T >= 0);
+            break; //CPX
+          case 0xA0:
+            Y = memory[addr];
+            ST &= 125;
+            ST |= (!Y) << 1 | (Y & 128);
+            break; //LDY
+          case 0x80:
+            memoryWrite(addr, Y);
+            storadd = addr; //STY
+        }
+      }
+    }
+
+    PC++;
+    PC &= 0xFFFF;
+    return 0; //memory[addr]&=0xFF;
+  }
+
+
+  //My SID implementation is similar to what I worked out in a SwinSID variant during 3..4 months of development. (So jsSID only took 2 weeks armed with this experience.)
+  //I learned the workings of ADSR/WAVE/filter operations mainly from the quite well documented resid and resid-fp codes.
+  //(The SID reverse-engineering sites were also good sources.)
+  //Note that I avoided internal/automatic variables from the SID function, assuming that JavaScript is better this way. (Not using stack as much, but I'm not sure and it may depend on platform...)
+  //So I advise to keep them here. As they have 'var' in the declaration, they are in this scope and won't interfere with anything outside jsSID.
+  //(The same is true for CPU emulation and player.)
+
+  var //SID emulation constants and variables
+    GATE_BITMASK = 0x01,
+    SYNC_BITMASK = 0x02,
+    RING_BITMASK = 0x04,
+    TEST_BITMASK = 0x08,
+    TRI_BITMASK = 0x10,
+    SAW_BITMASK = 0x20,
+    PULSE_BITMASK = 0x40,
+    NOISE_BITMASK = 0x80,
+    HOLDZERO_BITMASK = 0x10,
+    DECAYSUSTAIN_BITMASK = 0x40,
+    ATTACK_BITMASK = 0x80,
+    FILTSW = [1, 2, 4, 1, 2, 4, 1, 2, 4],
+    LOWPASS_BITMASK = 0x10,
+    BANDPASS_BITMASK = 0x20,
+    HIGHPASS_BITMASK = 0x40,
+    OFF3_BITMASK = 0x80;
+  var ADSRstate = [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    ratecnt = [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    envcnt = [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    expcnt = [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    prevSR = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+  var phaseaccu = [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    prevaccu = [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    sourceMSBrise = [0, 0, 0],
+    sourceMSB = [0, 0, 0];
+  var noise_LFSR = [0x7FFFF8, 0x7FFFF8, 0x7FFFF8, 0x7FFFF8, 0x7FFFF8, 0x7FFFF8, 0x7FFFF8, 0x7FFFF8, 0x7FFFF8];
+  var prevwfout = [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    prevwavdata = [0, 0, 0, 0, 0, 0, 0, 0, 0],
+    combiwf;
+  var prevlowpass = [0, 0, 0],
+    prevbandpass = [0, 0, 0],
+    cutoff_ratio_8580 = -2 * 3.14 * (12500 / 256) / samplerate,
+    cutoff_ratio_6581 = -2 * 3.14 * (20000 / 256) / samplerate;
+  var prevgate, chnadd, ctrl, wf, test, period, step, SR, accuadd, MSB, tmp, pw, lim, wfout, cutoff,
+    resonance, filtin, output;
+  //registers: 0:freql1  1:freqh1  2:pwml1  3:pwmh1  4:ctrl1  5:ad1   6:sr1  7:freql2  8:freqh2  9:pwml2 10:pwmh2 11:ctrl2 12:ad2  13:sr 14:freql3 15:freqh3 16:pwml3 17:pwmh3 18:ctrl3 19:ad3  20:sr3
+  //           21:cutoffl 22:cutoffh 23:flsw_reso 24:vol_ftype 25:potX 26:potY 27:OSC3 28:ENV3
+
+  function initSID() {
+    for (var i = 0xD400; i <= 0xD7FF; i++) memory[i] = 0;
+    for (var i = 0xDE00; i <= 0xDFFF; i++) memory[i] = 0;
+    for (var i = 0; i < 9; i++) {
+      ADSRstate[i] = HOLDZERO_BITMASK;
+      ratecnt[i] = envcnt[i] = expcnt[i] = prevSR[i] = 0;
+    }
+  }
+
+
+  function SID(num, SIDaddr) //the SID emulation itself ('num' is the number of SID to iterate (0..2)
+  {
+    filtin = 0;
+    output = 0;
+
+    //treating 2SID and 3SID channels uniformly (0..5 / 0..8), this probably avoids some extra code
+    for (var channel = num * SID_CHANNEL_AMOUNT; channel < (num + 1) * SID_CHANNEL_AMOUNT; channel++) {
+      prevgate = (ADSRstate[channel] & GATE_BITMASK);
+      chnadd = SIDaddr + (channel - num * SID_CHANNEL_AMOUNT) * 7;
+      ctrl = memory[chnadd + 4];
+      wf = ctrl & 0xF0;
+      test = ctrl & TEST_BITMASK;
+      SR = memory[chnadd + 6];
+      tmp = 0;
+
+      //ADSR envelope generator:
+      if (prevgate != (ctrl & GATE_BITMASK)) { //gatebit-change?
+        if (prevgate) {
+          ADSRstate[channel] &= 0xFF - (GATE_BITMASK | ATTACK_BITMASK | DECAYSUSTAIN_BITMASK);
+        } //falling edge (with Whittaker workaround this never happens, but should be here)
+        else {
+          ADSRstate[channel] = (GATE_BITMASK | ATTACK_BITMASK | DECAYSUSTAIN_BITMASK); //rising edge, also sets hold_zero_bit=0
+          if ((SR & 0xF) > (prevSR[channel] & 0xF)) tmp = 1; //assume SR->GATE write order: workaround to have crisp soundstarts by triggering delay-bug
+        } //(this is for the possible missed CTRL(GATE) vs SR register write order situations (1MHz CPU is cca 20 times faster than samplerate)
+      }
+      prevSR[channel] = SR;
+
+      ratecnt[channel] += clk_ratio;
+      if (ratecnt[channel] >= 0x8000) ratecnt[channel] -= 0x8000; //can wrap around (ADSR delay-bug: short 1st frame is usually achieved by utilizing this bug)
+
+      //set ADSR period that should be checked against rate-counter (depending on ADSR state Attack/DecaySustain/Release)
+      if (ADSRstate[channel] & ATTACK_BITMASK) {
+        step = memory[chnadd + 5] >> 4;
+        period = ADSRperiods[step];
+      } else if (ADSRstate[channel] & DECAYSUSTAIN_BITMASK) {
+        step = memory[chnadd + 5] & 0xF;
+        period = ADSRperiods[step];
+      } else {
+        step = SR & 0xF;
+        period = ADSRperiods[step];
+      }
+      step = ADSRstep[step];
+
+      if (ratecnt[channel] >= period && ratecnt[channel] < period + clk_ratio && tmp == 0) { //ratecounter shot (matches rateperiod) (in genuine SID ratecounter is LFSR)
+        ratecnt[channel] -= period; //compensation for timing instead of simply setting 0 on rate-counter overload
+        if ((ADSRstate[channel] & ATTACK_BITMASK) || ++expcnt[channel] == ADSR_exptable[envcnt[channel]]) {
+          if (!(ADSRstate[channel] & HOLDZERO_BITMASK)) {
+            if (ADSRstate[channel] & ATTACK_BITMASK) {
+              envcnt[channel] += step;
+              if (envcnt[channel] >= 0xFF) {
+                envcnt[channel] = 0xFF;
+                ADSRstate[channel] &= 0xFF - ATTACK_BITMASK;
+              }
+            } else if (!(ADSRstate[channel] & DECAYSUSTAIN_BITMASK) || envcnt[channel] > (SR >> 4) + (SR &
+                0xF0)) {
+              envcnt[channel] -= step;
+              if (envcnt[channel] <= 0 && envcnt[channel] + step != 0) {
+                envcnt[channel] = 0;
+                ADSRstate[channel] |= HOLDZERO_BITMASK;
+              }
+            }
+          }
+          expcnt[channel] = 0;
+        }
+      }
+
+      envcnt[channel] &= 0xFF; //'envcnt' may wrap around in some cases, mostly 0 -> FF (e.g.: Cloudless Rain, Boombox Alley)
+
+      //WAVE generation codes (phase accumulator and waveform-selector):  (They are explained in resid source, I won't go in details, the code speaks for itself.)
+      accuadd = (memory[chnadd] + memory[chnadd + 1] * 256) * clk_ratio;
+      if (test || ((ctrl & SYNC_BITMASK) && sourceMSBrise[num])) {
+        phaseaccu[channel] = 0;
+      } else {
+        phaseaccu[channel] += accuadd;
+        if (phaseaccu[channel] > 0xFFFFFF) phaseaccu[channel] -= 0x1000000;
+      }
+      MSB = phaseaccu[channel] & 0x800000;
+      sourceMSBrise[num] = (MSB > (prevaccu[channel] & 0x800000)) ? 1 : 0; //phaseaccu[channel] &= 0xFFFFFF;
+
+      //waveform-selector:
+      if (wf & NOISE_BITMASK) { //noise waveform
+        tmp = noise_LFSR[channel];
+        if (((phaseaccu[channel] & 0x100000) != (prevaccu[channel] & 0x100000)) || accuadd >= 0x100000) { //clock LFSR all time if clockrate exceeds observable at given samplerate
+          step = (tmp & 0x400000) ^ ((tmp & 0x20000) << 5);
+          tmp = ((tmp << 1) + (step > 0 || test)) & 0x7FFFFF;
+          noise_LFSR[channel] = tmp;
+        }
+        //we simply zero output when other waveform is mixed with noise. On real SID LFSR continuously gets filled by zero and locks up. ($C1 waveform with pw<8 can keep it for a while...)
+        wfout = (wf & 0x70) ? 0 : ((tmp & 0x100000) >> 5) + ((tmp & 0x40000) >> 4) + ((tmp & 0x4000) >> 1) +
+          ((tmp & 0x800) << 1) + ((tmp & 0x200) << 2) + ((tmp & 0x20) << 5) + ((tmp & 0x04) << 7) + ((tmp &
+            0x01) << 8);
+      } else if (wf & PULSE_BITMASK) { //simple pulse
+        pw = (memory[chnadd + 2] + (memory[chnadd + 3] & 0xF) * 256) * 16;
+        tmp = accuadd >> 9;
+        if (0 < pw && pw < tmp) pw = tmp;
+        tmp ^= 0xFFFF;
+        if (pw > tmp) pw = tmp;
+        tmp = phaseaccu[channel] >> 8;
+        if (wf == PULSE_BITMASK) {
+          step = 256 / (accuadd >> 16); //simple pulse, most often used waveform, make it sound as clean as possible without oversampling
+          //One of my biggest success with the SwinSID-variant was that I could clean the high-pitched and thin sounds.
+          //(You might have faced with the unpleasant sound quality of high-pitched sounds without oversampling. We need so-called 'band-limited' synthesis instead.
+          // There are a lot of articles about this issue on the internet. In a nutshell, the harsh edges produce harmonics that exceed the
+          // Nyquist frequency (samplerate/2) and they are folded back into hearable range, producing unvanted ringmodulation-like effect.)
+          //After so many trials with dithering/filtering/oversampling/etc. it turned out I can't eliminate the fukkin aliasing in time-domain, as suggested at pages.
+          //Oversampling (running the wave-generation 8 times more) was not a way at 32MHz SwinSID. It might be an option on PC but I don't prefer it in JavaScript.)
+          //The only solution that worked for me in the end, what I came up eventually: The harsh rising and falling edges of the pulse are
+          //elongated making it a bit trapezoid. But not in time-domain, but altering the transfer-characteristics. This had to be done
+          //in a frequency-dependent way, proportionally to pitch, to keep the deep sounds crisp. The following code does this (my favourite testcase is Robocop3 intro):
+          if (test) wfout = 0xFFFF;
+          else if (tmp < pw) {
+            lim = (0xFFFF - pw) * step;
+            if (lim > 0xFFFF) lim = 0xFFFF;
+            wfout = lim - (pw - tmp) * step;
+            if (wfout < 0) wfout = 0;
+          } //rising edge
+          else {
+            lim = pw * step;
+            if (lim > 0xFFFF) lim = 0xFFFF;
+            wfout = (0xFFFF - tmp) * step - lim;
+            if (wfout >= 0) wfout = 0xFFFF;
+            wfout &= 0xFFFF;
+          } //falling edge
+        } else { //combined pulse
+          wfout = (tmp >= pw || test) ? 0xFFFF : 0; //(this would be enough for simple but aliased-at-high-pitches pulse)
+          if (wf & TRI_BITMASK) {
+            if (wf & SAW_BITMASK) {
+              wfout = (wfout) ? combinedWF(channel, PulseTriSaw_8580, tmp >> 4, 1) : 0;
+            } //pulse+saw+triangle (waveform nearly identical to tri+saw)
+            else {
+              tmp = phaseaccu[channel] ^ (ctrl & RING_BITMASK ? sourceMSB[num] : 0);
+              wfout = (wfout) ? combinedWF(channel, PulseSaw_8580, (tmp ^ (tmp & 0x800000 ? 0xFFFFFF : 0)) >>
+                11, 0) : 0;
+            }
+          } //pulse+triangle
+          else if (wf & SAW_BITMASK) wfout = (wfout) ? combinedWF(channel, PulseSaw_8580, tmp >> 4, 1) : 0; //pulse+saw
+        }
+      } else if (wf & SAW_BITMASK) { //saw
+        wfout = phaseaccu[channel] >> 8; //saw (this row would be enough for simple but aliased-at-high-pitch saw)
+        //The anti-aliasing (cleaning) of high-pitched sawtooth wave works by the same principle as mentioned above for the pulse,
+        //but the sawtooth has even harsher edge/transition, and as the falling edge gets longer, tha rising edge should became shorter,
+        //and to keep the amplitude, it should be multiplied a little bit (with reciprocal of rising-edge steepness).
+        //The waveform at the output essentially becomes an asymmetric triangle, more-and-more approaching symmetric shape towards high frequencies.
+        //(If you check a recording from the real SID, you can see a similar shape, the high-pitch sawtooth waves are triangle-like...)
+        //But for deep sounds the sawtooth is really close to a sawtooth, as there is no aliasing there, but deep sounds should be sharp...
+        if (wf & TRI_BITMASK) wfout = combinedWF(channel, TriSaw_8580, wfout >> 4, 1); //saw+triangle
+        else {
+          step = accuadd / 0x1200000;
+          wfout += wfout * step;
+          if (wfout > 0xFFFF) wfout = 0xFFFF - (wfout - 0x10000) / step;
+        } //simple cleaned (bandlimited) saw
+      } else if (wf & TRI_BITMASK) { //triangle (this waveform has no harsh edges, so it doesn't suffer from strong aliasing at high pitches)
+        tmp = phaseaccu[channel] ^ (ctrl & RING_BITMASK ? sourceMSB[num] : 0);
+        wfout = (tmp ^ (tmp & 0x800000 ? 0xFFFFFF : 0)) >> 7;
+      }
+
+      if (wf) prevwfout[channel] = wfout;
+      else {
+        wfout = prevwfout[channel];
+      } //emulate waveform 00 floating wave-DAC (on real SID waveform00 decays after 15s..50s depending on temperature?)
+      prevaccu[channel] = phaseaccu[channel];
+      sourceMSB[num] = MSB; //(So the decay is not an exact value. Anyway, we just simply keep the value to avoid clicks and support SounDemon digi later...)
+
+      //routing the channel signal to either the filter or the unfiltered master output depending on filter-switch SID-registers
+      if (memory[SIDaddr + 0x17] & FILTSW[channel]) filtin += (wfout - 0x8000) * (envcnt[channel] / 256);
+      else if ((channel % SID_CHANNEL_AMOUNT) != 2 || !(memory[SIDaddr + 0x18] & OFF3_BITMASK)) output += (
+        wfout - 0x8000) * (envcnt[channel] / 256);
+    }
+
+    //update readable SID-registers (some SID tunes might use 3rd channel ENV3/OSC3 value as control)
+    //HERE TODO STH !!!
+    //if (memory[1] & 3) memory[SIDaddr + 0x1B] =  wfout >> 8;
+    //memory[SIDaddr + 0x1C] = envcnt[3]; //OSC3, ENV3 (some players rely on it)
+
+    //FILTER: two integrator loop bi-quadratic filter, workings learned from resid code, but I kindof simplified the equations
+    //The phases of lowpass and highpass outputs are inverted compared to the input, but bandpass IS in phase with the input signal.
+    //The 8580 cutoff frequency control-curve is ideal, while the 6581 has a treshold, and below it it outputs a constant lowpass frequency.
+    cutoff = (memory[SIDaddr + 0x15] & 7) / 8 + memory[SIDaddr + 0x16] + 0.2;
+    if (SID_model == 8580.0) {
+      cutoff = 1 - Math.exp(cutoff * cutoff_ratio_8580);
+      resonance = Math.pow(2, ((4 - (memory[SIDaddr + 0x17] >> 4)) / 8));
+    } else {
+      if (cutoff < 24) cutoff = 0.035;
+      else cutoff = 1 - 1.263 * Math.exp(cutoff * cutoff_ratio_6581);
+      resonance = (memory[SIDaddr + 0x17] > 0x5F) ? 8 / (memory[SIDaddr + 0x17] >> 4) : 1.41;
+    }
+    tmp = filtin + prevbandpass[num] * resonance + prevlowpass[num];
+    if (memory[SIDaddr + 0x18] & HIGHPASS_BITMASK) output -= tmp;
+    tmp = prevbandpass[num] - tmp * cutoff;
+    prevbandpass[num] = tmp;
+    if (memory[SIDaddr + 0x18] & BANDPASS_BITMASK) output -= tmp;
+    tmp = prevlowpass[num] + tmp * cutoff;
+    prevlowpass[num] = tmp;
+    if (memory[SIDaddr + 0x18] & LOWPASS_BITMASK) output += tmp;
+
+    //when it comes to $D418 volume-register digi playback, I made an AC / DC separation for $D418 value in the SwinSID at low (20Hz or so) cutoff-frequency,
+    //and sent the AC (highpass) value to a 4th 'digi' channel mixed to the master output, and set ONLY the DC (lowpass) value to the volume-control.
+    //This solved 2 issues: Thanks to the lowpass filtering of the volume-control, SID tunes where digi is played together with normal SID channels,
+    //won't sound distorted anymore, and the volume-clicks disappear when setting SID-volume. (This is useful for fade-in/out tunes like Hades Nebula, where clicking ruins the intro.)
+    return (output / OUTPUT_SCALEDOWN) * (memory[SIDaddr + 0x18] & 0xF); // SID output
+  }
+
+
+  //And now, the combined waveforms. The resid source simply uses 4kbyte 8bit samples from wavetable arrays, says these waveforms are mystic due to the analog behaviour.
+  //It's true, the analog things inside SID play a significant role in how the combined waveforms look like, but process variations are not so huge that cause much differences in SIDs.
+  //After checking these waveforms by eyes, it turned out for me that these waveform are fractal-like, recursively approachable waveforms.
+  //My 1st thought and trial was to store only a portion of the waveforms in table, and magnify them depending on phase-accumulator's state.
+  //But I wanted to understand how these waveforms are produced. I felt from the waveform-diagrams that the bits of the waveforms affect each other,
+  //hence the recursive look. A short C code proved by assumption, I could generate something like a pulse+saw combined waveform.
+  //Recursive calculations were not feasible for MCU of SwinSID, but for jsSID I could utilize what I found out and code below generates the combined waveforms into wavetables.
+  //To approach the combined waveforms as much as possible, I checked out the SID schematic that can be found at some reverse-engineering sites...
+  //The SID's R-2R ladder WAVE DAC is driven by operation-amplifier like complementary FET output drivers, so that's not the place where I first thought the magic happens.
+  //These 'opamps' (for all 12 wave-bits) have single FETs as inputs, and they switch on above a certain level of input-voltage, causing 0 or 1 bit as R-2R DAC input.
+  //So the first keyword for the workings is TRESHOLD. These FET inputs are driven through serial switch FETs (wave-selector) that normally enables one waveform at a time.
+  //The phase-accumulator's output is brought to 3 kinds of circuitries for the 3 basic waveforms. The pulse simply drives
+  //all wave-selector inputs with a 0/1 depending on pulsewidth, the sawtooth has a XOR for triangle/ringmod generation, but what
+  //is common for all waveforms, they have an open-drain driver before the wave-selector, which has FETs towards GND and 'FET resistor' towards the power-supply rail.
+  //These outputs are clearly not designed to drive high loads, and normally they only have to drive the FETs input mentioned above.
+  //But when more of these output drivers are switched together by the switch-FETs in the wave-selector, they affect each other by loading each other.
+  //The pulse waveform, when selected, connects all of them together through a fairly strong connection, and its signal also affects the analog level (pulls below the treshold)...
+  //The farther a specific DAC bit driver is from the other, the less it affects its output. It turned out it's not powers of 2 but something else,
+  //that creates similar combined waveforms to that of real SID's...
+  //The analog levels that get generated by the various bit drivers, that pull each other up/down depends on the resistances the components inside the SID have.
+  //And finally, what is output on the DAC depends on whether these analog levels are below or above the FET gate's treshold-level,
+  //That's how the combined waveform is generated. Maybe I couldn't explain well enough, but the code below is simple enough to understand the mechanism algoritmically.
+  //This simplified schematic exapmle might make it easier to understand sawtooth+pulse combination (must be observed with monospace fonts):
+  //                               _____            |-    .--------------.   /\/\--.
+  // Vsupply                /  .----| |---------*---|-    /    Vsupply   !    R    !      As can be seen on this schematic,
+  //  ------.       other   !  !   _____        !  TRES   \       \      !         /      the pulse wave-selector FETs
+  //        !       saw bit *--!----| |---------'  HOLD   /       !     |-     2R  \      connect the neighbouring sawtooth
+  //        /       output  !  !                          !      |------|-         /      outputs with a fairly strong
+  //     Rd \              |-  !WAVEFORM-SELECTOR         *--*---|-      !    R    !      connection to each other through
+  //        /              |-  !SWITCHING FETs            !  !    !      *---/\/\--*      their own wave-selector FETs.
+  //        ! saw-bit          !    _____                |-  !   ---     !         !      So the adjacent sawtooth outputs
+  //        *------------------!-----| |-----------*-----|-  !          |-         /      pull each other upper/lower
+  //        ! (weak drive,so   !  saw switch       ! TRES-!  `----------|-     2R  \      depending on their low/high state and
+  //       |- can be shifted   !                   ! HOLD !              !         /      distance from each other, causing
+  //  -----|- by neighbours    !    _____          !      !              !     R   !      the resulting analog level that
+  //        ! up or down)      *-----| |-----------'     ---            ---   /\/\-*      will either turn the output on or not.
+  //   GND ---                 !  pulse switch                                     !      (Depending on their relation to treshold.)
+  //
+  //(As triangle waveform connects adjacent bits by default, the above explained effect becomes even stronger, that's why combined waveforms with thriangle are at 0 level most of the time.)
+
+  function combinedWF(channel, wfarray, index, differ6581) { //on 6581 most combined waveforms are essentially halved 8580-like waves
+    if (differ6581 && SID_model == 6581.0) index &= 0x7FF;
+    combiwf = (wfarray[index] + prevwavdata[channel]) / 2;
+    prevwavdata[channel] = wfarray[index];
+    return combiwf;
+  }
+
+  function createCombinedWF(wfarray, bitmul, bitstrength, treshold) { //I found out how the combined waveform works (neighboring bits affect each other recursively)
+    for (var i = 0; i < 4096; i++) {
+      wfarray[i] = 0; //neighbour-bit strength and DAC MOSFET treshold is approximately set by ears'n'trials
+      for (var j = 0; j < 12; j++) {
+        var bitlevel = 0;
+        for (var k = 0; k < 12; k++) {
+          bitlevel += (bitmul / Math.pow(bitstrength, Math.abs(k - j))) * (((i >> k) & 1) - 0.5);
+        }
+        wfarray[i] += (bitlevel >= treshold) ? Math.pow(2, j) : 0;
+      }
+      wfarray[i] *= 12;
+    }
+  }
+
+  TriSaw_8580 = new Array(4096);
+  createCombinedWF(TriSaw_8580, 0.8, 2.4, 0.64); //precalculate combined waveform
+  PulseSaw_8580 = new Array(4096);
+  createCombinedWF(PulseSaw_8580, 1.4, 1.9, 0.68);
+  PulseTriSaw_8580 = new Array(4096);
+  createCombinedWF(PulseTriSaw_8580, 0.8, 2.5, 0.64);
+
+  var period0 = Math.max(clk_ratio, 9);
+  var ADSRperiods = [period0, 32 * 1, 63 * 1, 95 * 1, 149 * 1, 220 * 1, 267 * 1, 313 * 1, 392 * 1, 977 * 1,
+    1954 * 1, 3126 * 1, 3907 * 1, 11720 * 1, 19532 * 1, 31251 * 1
+  ];
+  var ADSRstep = [Math.ceil(period0 / 9), 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+
+  //prescaler values that slow down the envelope-counter as it decays and approaches zero level
+  var ADSR_exptable = [1, 30, 30, 30, 30, 30, 30, 16, 16, 16, 16, 16, 16, 16, 16, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 4, 4, 4, 4, 4, //pos0:1  pos6:30  pos14:16  pos26:8
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, //pos54:4 //pos93:2
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
+  ];
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opal-sid
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Michał Kalbarczyk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-11 00:00:00.000000000 Z
+date: 2016-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal