cybin.cybin

Utils={}
function Utils.scale(x,a,b,na,nb)
  local i=(x-a)/(b-a)
  return na*i+(nb*(1-i))
end
--------------------------------------------
UGen={__call=function(self,...) return self:Set(...) end}
UGen.__index=UGen
setmetatable(UGen,{__call=function(cls,...) return cls.new(...) end})
function UGen.new(params)
  local o=params or {}
  setmetatable(o,UGen)
  return o
end
function UGen:Set(params)
  for k,v in pairs(params) do
    if type(self[k])=='function' then
      self[k](self,v)
    else
      self[k]=v
    end
  end
end
function UGen:Process()
  return 0
end
--------------------------------------------
Sin={__call=function(self,...) return self:Set(...) end}
Sin.__index=Sin
setmetatable(Sin,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Sin.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.phase = o.phase or 0
  o.delta = o.delta or 2*math.pi*(o.freq or 440)/o.samplerate
  o.amp = o.amp or 1
  o.freq=nil
  setmetatable(o,Sin)
  return o
end
function Sin:freq(frequency)
  self.delta = (2*math.pi*frequency)/self.samplerate
end
function Sin:Process(phase)
  self.phase=self.phase+self.delta
  while self.phase>2*math.pi do self.phase=self.phase-2*math.pi end
  return math.sin(self.phase+(phase or 0))*self.amp
end
--------------------------------------------
Pulse={__call=function(self,...) return self:Set(...) end}
Pulse.__index=Pulse
setmetatable(Pulse,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Pulse.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.phase = o.phase or 0
  o.delta = o.delta or (o.freq or 440)/o.samplerate
  o.freq = nil
  o.amp = o.amp or 1
  o.width = o.width or 0.5
  setmetatable(o,Pulse)
  return o
end
function Pulse:freq(frequency)
  self.delta = frequency/self.samplerate
end
function Pulse:Process(params)
  self.phase=self.phase+self.delta
  while self.phase>1 do self.phase=self.phase-1 end
  if self.phase > self.width then return 1*self.amp else return -1*self.amp end
end
--------------------------------------------
Saw={__call=function(self,...) return self:Set(...) end}
Saw.__index=Saw
setmetatable(Saw,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Saw.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.phase = o.phase or 0
  o.delta = o.delta or (o.freq or 440)/o.samplerate
  o.freq=nil
  o.amp = o.amp or 1
  setmetatable(o,Saw)
  return o
end
function Saw:freq(frequency)
  self.delta = frequency/self.samplerate
end
function Saw:Process(params)
  self.phase=self.phase+self.delta
  while self.phase>1 do self.phase=self.phase-1 end
  return (self.phase*2-1)*self.amp
end
--------------------------------------------
Tri={__call=function(self,...) return self:Set(...) end}
Tri.__index=Tri
setmetatable(Tri,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Tri.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.phase = o.phase or 0
  o.delta = o.delta or (o.freq or 440)/o.samplerate
  o.freq=nil
  o.amp = o.amp or 1
  setmetatable(o,Tri)
  return o
end
function Tri:freq(frequency)
  self.delta = frequency/self.samplerate
end
function Tri:Process(params)
  self.phase=self.phase+self.delta
  while self.phase>1 do self.phase=self.phase-1 end
  return (math.abs(self.phase-0.5)*4-1)*self.amp
end
--------------------------------------------
Filter={__call=function(self,...) return self:Set(...) end}
Filter.__index=Filter
setmetatable(Filter,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Filter.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.a0=1
  o.a1=0
  o.a2=0
  o.b1=0
  o.b2=0
  o.Fc=(o.freq or 1000)/o.samplerate
  o.Q=o.reso or 0.7
  o.peakGain=0
  o.z1=0
  o.z2=0
  o.ft=o.filterType or "lowpass"
  o.freq=nil
  o.reso=nil
  o.filterType=nil
  setmetatable(o,Filter)
  o:filterType()
  return o
end
function Filter:freq(frequency)
  self.Fc=frequency/self.samplerate
  self:filterType()
end
function Filter:reso(resonance)
  self.Q=resonance
  self:filterType()
end
function Filter:filterType(filtertype)
  if filtertype==nil then
    filtertype=self.ft
  else
    self.ft=filtertype
  end
  local norm
  local V=math.pow(10,math.abs(self.peakGain)/20)
  local K=math.tan(math.pi*self.Fc)
  if filtertype=="lowpass" then
    norm = 1 / (1 + K / self.Q + K * K)
    self.a0 = K * K * norm
    self.a1 = 2 * self.a0
    self.a2 = self.a0
    self.b1 = 2 * (K * K - 1) * norm
    self.b2 = (1 - K / self.Q + K * K) * norm
  end
  if filtertype=="highpass" then
    norm = 1 / (1 + K / self.Q + K * K);
    self.a0 = 1 * norm;
    self.a1 = -2 * self.a0;
    self.a2 = self.a0;
    self.b1 = 2 * (K * K - 1) * norm;
    self.b2 = (1 - K / self.Q + K * K) * norm;
  end
  if filtertype=="bandpass" then
    norm = 1 / (1 + K / self.Q + K * K);
    self.a0 = K / self.Q * norm;
    self.a1 = 0;
    self.a2 = -self.a0;
    self.b1 = 2 * (K * K - 1) * norm;
    self.b2 = (1 - K / self.Q + K * K) * norm;
  end
  if filtertype=="notch" then
    norm = 1 / (1 + K / self.Q + K * K);
    self.a0 = (1 + K * K) * norm;
    self.a1 = 2 * (K * K - 1) * norm;
    self.a2 = self.a0;
    self.b1 = self.a1;
    self.b2 = (1 - K / self.Q + K * K) * norm;
  end
  if filtertype=="peak" then
    if self.peakGain >= 0 then
      norm = 1 / (1 + 1/self.Q * K + K * K);
      self.a0 = (1 + V/self.Q * K + K * K) * norm;
      self.a1 = 2 * (K * K - 1) * norm;
      self.a2 = (1 - V/self.Q * K + K * K) * norm;
      self.b1 = self.a1;
      self.b2 = (1 - 1/self.Q * K + K * K) * norm;
    else
      norm = 1 / (1 + V/self.Q * K + K * K);
      self.a0 = (1 + 1/self.Q * K + K * K) * norm;
      self.a1 = 2 * (K * K - 1) * norm;
      self.a2 = (1 - 1/self.Q * K + K * K) * norm;
      self.b1 = self.a1;
      self.b2 = (1 - V/self.Q * K + K * K) * norm;
    end
  end
  if filtertype=="lowshelf" then
    if self.peakGain >= 0 then
      norm = 1 / (1 + math.sqrt(2) * K + K * K);
      self.a0 = (1 + math.sqrt(2*V) * K + V * K * K) * norm;
      self.a1 = 2 * (V * K * K - 1) * norm;
      self.a2 = (1 - math.sqrt(2*V) * K + V * K * K) * norm;
      self.b1 = 2 * (K * K - 1) * norm;
      self.b2 = (1 - math.sqrt(2) * K + K * K) * norm;
    else
      norm = 1 / (1 + math.sqrt(2*V) * K + V * K * K);
      self.a0 = (1 + math.sqrt(2) * K + K * K) * norm;
      self.a1 = 2 * (K * K - 1) * norm;
      self.a2 = (1 - math.sqrt(2) * K + K * K) * norm;
      self.b1 = 2 * (V * K * K - 1) * norm;
      self.b2 = (1 - math.sqrt(2*V) * K + V * K * K) * norm;
    end
  end
  if filtertype=="highshelf" then
    if self.peakGain >= 0 then
      norm = 1 / (1 + math.sqrt(2) * K + K * K);
      self.a0 = (V + math.sqrt(2*V) * K + K * K) * norm;
      self.a1 = 2 * (K * K - V) * norm;
      self.a2 = (V - math.sqrt(2*V) * K + K * K) * norm;
      self.b1 = 2 * (K * K - 1) * norm;
      self.b2 = (1 - math.sqrt(2) * K + K * K) * norm;
    else
      norm = 1 / (V + math.sqrt(2*V) * K + K * K);
      self.a0 = (1 + math.sqrt(2) * K + K * K) * norm;
      self.a1 = 2 * (K * K - 1) * norm;
      self.a2 = (1 - math.sqrt(2) * K + K * K) * norm;
      self.b1 = 2 * (K * K - V) * norm;
      self.b2 = (V - math.sqrt(2*V) * K + K * K) * norm;
    end
  end
end
function Filter:Process(input)
  local output = input * self.a0 + self.z1;
  self.z1 = input * self.a1 + self.z2 - self.b1 * output;
  self.z2 = input * self.a2 - self.b2 * output;
  return output;
end
--------------------------------------------
Metro={__call=function(self,...) return self:Set(...) end}
Metro.__index=Metro
setmetatable(Metro,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Metro.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.events = {}
  o.pats = {}
  o.time = o.time or 0
  o.cps = o.cps or 1
  setmetatable(o,Metro)
  return o
end
function Metro:Set(...)
  arg = { ... }
  if type(arg[1])=='string' or type(arg[1])=='function' then
    self:Interval(arg[1])
  elseif type(arg[1])=='table' and getmetatable(arg[1])==Pat then
    self:Pat(unpack(arg))
  elseif type(arg[1])=='table' then
    UGen.Set(self,arg[1])
  end
end
function Metro:Process(params)
  local rmindices={}
  local now=self.time
  for i=1,#self.events do
    if self.time>=self.events[i].start then
      self.events[i].func(self.events[i].start,self.events[i].stop)
      table.insert(rmindices,i)
    end
  end
  for i=1,#rmindices do
    table.remove(self.events,rmindices[#rmindices-i+1])
  end
  self.time=self.time+self.cps/self.samplerate
  return now
end
function Metro:Pat(pat,handler,start,stop)
  if stop==nil then
    if start==nil then
      start=math.ceil(self.time)
      stop=math.ceil(self.time+1)
    else
      stop=math.ceil(self.time)+start
      start=math.ceil(self.time)
    end
  end
  local function close(value)
    return function(start,stop)
      handler(value,start,stop)
    end
  end
  local events=pat:QueryEvents(start,stop,1)
  for i=1,#events do
    events[i].func=close(events[i].value)
  end
  self:Events(events)
end
function Metro:Event(func,start,stop)
  table.insert(self.events,{func=func,start=start,stop=stop})
end
function Metro:Events(e)
  for i=1,#e do
    table.insert(self.events,e[i])
  end
end
function Metro:Interval(func)
  local callback=nil
  if type(func)=='function' then
    callback=function(start,stop)
      start = start or math.ceil(self.time)
      local interval=func(start,stop)
      local nextTime=start+interval
      self:Event(callback,nextTime,nextTime+interval)
    end
  elseif type(func)=='string' and _G[func]~=nil then
    callback=function(start,stop)
      if _G[func]~=nil then
        start = start or math.ceil(self.time)
        local interval=_G[func](start,stop) or 1
        local nextTime=start+interval
        self:Event(callback,nextTime,nextTime+interval)
      end
    end
  end
  if callback~=nil then self:Event(callback,math.ceil(self.time),math.ceil(self.time+1)) end
end
function Metro:Stop()
   self.events={}
end
function Metro:Cycles2Seconds(cycles)
   return cycles/self.cps
end
Metro.c2s=Metro.Cycles2Seconds
--------------------------------------------
Sampler={__call=function(self,...) return self:Set(...) end}
Sampler.__index=Sampler
setmetatable(Sampler,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Sampler.new(params)
  local o=UGen.new(params)
  if type(o.sample)=='string' then
    o.sample=cybin.loadaudiofile(o.sample)
  end
  o.samplerate=o.samplerate or cybin.samplerate or 48000
  o.grainsize=o.grainsize or o.sample.samplerate*30/1000
  o.grain1start=0
  o.grain1sindex=0
  o.grain2start=0
  o.grain2sindex=0
  o.grainwindex=0
  o.sindex=1
  o.speed=o.speed or 1
  o.pitch=o.pitch or 1
  o.loop=o.loop or false
  o.grainxfade=1
  o.basenote=60
  o.amp=o.amp or 1
  o.env=o.env or nil
  if o.offset~=nil then Sampler.offset(o,o.offset); o.offset=nil end
  if o.duration~=nil then Sampler.duration(o,o.duration); o.duration=nil end
  if o.grainDuration~=nil then Sampler.grainDuration(o,o.grainDuration); o.grainDuration=nil end
  setmetatable(o,Sampler)
  return o
end
function Sampler:offset(offset)
   self.sindex=self.sample.frames*offset
   if self.grain1start==0 and self.grain2start==0 then
      self.grain1start=self.sindex
      self.grain2start=self.sindex
   end
end
function Sampler:duration(dur)
   local seconds=self.sample.frames/self.samplerate
   self.speed=seconds/dur
end
function Sampler:grainDuration(dur)
   self.grainsize=math.floor(dur*self.samplerate)
end
function Sampler:Process()
  local out={}
  local env=1
  if self.env~=nil then
     env=self.env:Process()
     if self.env.phase==-1 then self.free=true end
  end
  for i=1,self.sample.channels do out[i]=0 end
  if (self.loop==false and (self.sindex>self.sample.frames or self.sindex<0)) or self.free==true then
    self.free=true
    return unpack(out)
  end
  if self.grainwindex >= self.grainsize then
    self.grainwindex=0
    self.grain1sindex=0
    self.grain1start=self.grain2start+self.grain2sindex
    self.grain2sindex=0
    self.grain2start=self.sindex
  end
  local grain1channels=self:GetChannels(self.grain1sindex+self.grain1start)
  local grain2channels=self:GetChannels(self.grain2sindex+self.grain2start)
  local nofx=self:GetChannels(self.sindex)
  for i=1,self.sample.channels do
    local window1=math.cos(math.pi*0.5*self.grainwindex/self.grainsize)
    local window2=math.sin(math.pi*0.5*self.grainwindex/self.grainsize)
    out[i]=grain1channels[i]*window1+grain2channels[i]*window2
    out[i]=(out[i]*self.grainxfade+nofx[i]*(1-self.grainxfade))*env
  end
  self.grain1sindex=self.grain1sindex+1*self.pitch
  self.grain2sindex=self.grain2sindex+1*self.pitch
  self.grainwindex=self.grainwindex+1
  self.sindex=self.sindex+1*self.speed
  return unpack(out)
end
function Sampler:GetChannels(i)
  if self.loop==false and i>self.sample.frames then
    local out={}
    for i=1,self.sample.channels do out[i]=0 end
    return out
  end
  while i>self.sample.frames do i=i-self.sample.frames end
  while i<1 do i=i+self.sample.frames end
  if i==0 then i=1 end
  local out={}
  ---
  local intIndex,fracIndex=math.modf(i)
  local intNextIndex=intIndex+1
  if self.pitch<0 then intNextIndex=intIndex-1 end
  for j=1,self.sample.channels do
    local currentSample=self.sample[intIndex*self.sample.channels+j-1] or 0
    local nextSample=self.sample[intNextIndex*self.sample.channels+j-1] or currentSample
    out[j]=(currentSample*(1-fracIndex)+nextSample*fracIndex)*self.amp
    -- simplified version doesn't work even though mathematically equivalent?????
    --out[j]=currentSample-(currentSample+nextSample)*fracIndex
  end
  return out
end
--------------------------------------------
Env={__call=function(self,...) return self:Reset(...) end}
Env.__index=Env
setmetatable(Env,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Env.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.values=o.values or {1,0}
  o.durations=o.durations or {1}
  o.times={}
  local sum=0
  for i=1,#o.durations do
    o.times[i]=sum
    sum=sum+o.durations[i]
  end
  o.times[#o.durations+1]=sum
  o.delta=1/o.samplerate
  o.phase=-1
  o.out=0
  setmetatable(o,Env)
  return o
end
function Env:Reset()
  self.phase=0
  return self
end
function Env:Process(samplerate)
  local i=1
  if self.phase==-1 then return self.out end
  if self.phase>=self.times[#self.times] then
    self.phase=-1
    self.out=self.values[#self.values]
    return self.out
  end
  local function wrap(t,i) return t[((i-1)%#t)+1] end
  for i=1,#self.durations do
    if self.phase<=self.times[i+1] then
      local interp=(self.phase-self.times[i])/self.durations[i]
      self.out=self.values[i]*(1-interp)+self.values[i+1]*interp
      self.phase=self.phase+self.delta
      return self.out
    end
  end
  return self.out
end
--------------------------------------------
Compressor={__call=function(self,...) return self:Reset(...) end}
Compressor.__index=Compressor
setmetatable(Compressor,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Compressor.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.threshold=o.threshold or -10
  o.ratio=o.ratio or 2
  o.attack=o.attack or 0.015
  o.release=o.release or 0.07
  o.makeup=o.makeup or 0
  o.lsat=1
  setmetatable(o,Compressor)
  return o
end
function Compressor:Process(carrier,modulator)
  if modulator==nil then modulator=carrier end
  local function lin2db(x) return math.log10(x)*20 end
  local function db2lin(x) return math.pow(10,x/20) end
  local function rectify(x)
    if x>=0 then return x else return 0 end
  end
  local dBaboveThreshold=rectify(lin2db(math.abs(modulator))-self.threshold)
  local linAboveThreshold=db2lin(dBaboveThreshold)
  local coef=1/(self.release*self.samplerate)
  if linAboveThreshold>self.lsat then coef=1/(self.attack*self.samplerate) end
  self.lsat=math.abs(linAboveThreshold)*coef+self.lsat*(1-coef)
  dBaboveThreshold=lin2db(self.lsat)
  local dBin=lin2db(math.abs(carrier))
  local signIn=1
  if carrier<0 then signIn=-1 end
  return db2lin(dBin-dBaboveThreshold+dBaboveThreshold/self.ratio)*db2lin(self.makeup)*signIn
end
--------------------------------------------
Interp={}
setmetatable(Interp,{__call=function(cls,...) return cls.new(...) end})
function Interp.new(t)
  local o={}
  o.t={}
  for i=1,#t do o.t[i]=t[i] end
  setmetatable(o,Interp)
  return o
end
function Interp:Write(k,v)
  if self.lastWriteIndex==nil or self.lastWriteIndex==k then
    k=math.floor(k)
    while k<=0 do k=k+#self.t end
    while k>#self.t do k=k-#self.t end
    self.t[k]=v
    self.lastWriteIndex=k
  else
    local fwdDistance=k-self.lastWriteIndex
    while fwdDistance<0 do fwdDistance=fwdDistance+#self.t end
    while fwdDistance>#self.t do fwdDistance=fwdDistance-#self.t end
    local bckDistance=self.lastWriteIndex-k
    while bckDistance<0 do bckDistance=bckDistance+#self.t end
    while bckDistance>#self.t do bckDistance=bckDistance-#self.t end
    local from=self.t[self.lastWriteIndex]
    local to=v
    if fwdDistance<bckDistance then
      for i=0,fwdDistance do
        local interp=i/fwdDistance
        self.t[self.lastWriteIndex]=from*(1-interp)+to*interp
        if i~=fwdDistance then self.lastWriteIndex=self.lastWriteIndex+1 end
        if self.lastWriteIndex>#self.t then self.lastWriteIndex=self.lastWriteIndex-#self.t end
      end
    else
      for i=0,bckDistance do
        local interp=i/bckDistance
        self.t[self.lastWriteIndex]=from*(1-interp)+to*interp
        if i~=bckDistance then self.lastWriteIndex=self.lastWriteIndex-1 end
        if self.lastWriteIndex<1 then self.lastWriteIndex=self.lastWriteIndex+#self.t end
      end
    end
  end
end
function Interp:Read(k)
  local int=math.floor(k)
  local frac=math.fmod(k,1)
  while int<=0 do int=int+#self.t end
  while int>#self.t do int=int-#self.t end
  local nextInt=int+1
  if nextInt>#self.t then nextInt=nextInt-#self.t end
  return self.t[int]*(1-frac)+self.t[nextInt]*frac
end
Interp.__index=function(self,k)
  if type(k)=='number' then
    return self:Read(k)
  else
    return Interp[k]
  end
end
Interp.__newindex=function(self,k,v)
  if type(k)=='number' then
    self:Write(k,v)
  else
    rawset(self,k,v)
  end
end
--------------------------------------------
Allpass={__call=function(self,...) return self:Set(...) end}
Allpass.__index=Allpass
setmetatable(Allpass,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Allpass.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.buf={}
  o.size=math.floor(o.samplerate*(o.delay or 0.123))
  for i=1,o.size do o.buf[i]=0 end
  o.buf=Interp(o.buf)
  o.coef=o.coef or 0.5
  o.index=0
  setmetatable(o,Allpass)
  return o
end
function Allpass:Process(input,sampleOffset)
  local output=input*self.coef+self.buf[self.index+(sampleOffset or 0)]
  self.buf[self.index]=input+output*-self.coef
  self.index=self.index+1
  while self.index>self.size do self.index=self.index-self.size end
  return output
end
--------------------------------------------
Comb={__call=function(self,...) return self:Set(...) end}
Comb.__index=Comb
setmetatable(Comb,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Comb.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.buf={}
  o.size=math.floor(o.samplerate*(o.delay or 0.123))
  for i=1,o.size do o.buf[i]=0 end
  o.buf=Interp(o.buf)
  o.coef=o.coef or 0.5
  o.index=0
  setmetatable(o,Comb)
  return o
end
function Comb:Process(input,sampleOffset)
  self.buf[self.index]=input+self.buf[self.index+(sampleOffset or 0)]*self.coef
  local output=self.buf[self.index]
  self.index=self.index+1
  while self.index>self.size do self.index=self.index-self.size end
  return output
end
--------------------------------------------
Delay={__call=function(self,...) return self:Set(...) end}
Delay.__index=Delay
setmetatable(Delay,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Delay.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.buf={}
  o.size=math.floor(o.samplerate*(o.delay or 0.123))
  for i=1,o.size do o.buf[i]=0 end
  o.buf=Interp(o.buf)
  o.index=0
  setmetatable(o,Delay)
  return o
end
function Delay:Process(input,sampleOffset)
  local output=self.buf[self.index+(sampleOffset or 0)]
  self.buf[self.index]=input
  self.index=self.index+1
  while self.index>self.size do self.index=self.index-self.size end
  return output
end
--------------------------------------------
Reverb={__call=function(self,...) return self:Set(...) end}
Reverb.__index=Reverb
setmetatable(Reverb,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Reverb.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.coef=o.coef or 0.9
  o.nodes = o.nodes or 5
  o.spacing = o.spacing or 1.123
  o.lastSample=0
  o.allpasses={}
  for i=1,o.nodes do o.allpasses[i]=Allpass{delay=0.0123*math.pow(o.spacing,i),coef=o.coef,samplerate=o.samplerate} end
  setmetatable(o,Reverb)
  return o
end
function Reverb:Process(input)
  local out=input+self.lastSample*self.coef
  for i=1,#self.allpasses do
    self.allpasses[i].coef=self.coef
    out=self.allpasses[i]:Process(out)
  end
  return out
end
--------------------------------------------
Reverb2={__call=function(self,...) return self:Set(...) end}
Reverb2.__index=Reverb2
setmetatable(Reverb2,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Reverb2.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.coef=o.coef or 0.9
  o.damp=o.damp or 0.3
  o.lowpass=Filter{filterType='lowpass',freq=o.lowpassFreq or 5000,reso=0.1}
  o.delay=Delay{delay=o.echoDuration or 1}
  o.nodes = o.nodes or 5
  o.spacing = o.spacing or 1.123
  o.lastSample=0
  o.allpasses={}
  for i=1,o.nodes do o.allpasses[i]=Allpass{delay=0.0123*math.pow(o.spacing,i),coef=o.coef,samplerate=o.samplerate} end
  setmetatable(o,Reverb2)
  return o
end
function Reverb2:Process(input)
   local out=input+self.lowpass:Process(self.delay:Process(self.lastSample)*self.damp)
   for i=1,#self.allpasses do
      self.allpasses[i].coef=self.coef
      out=self.allpasses[i]:Process(out)
   end
   self.lastSample=out
   return out
end
--------------------------------------------
Poly={__call=function(self,...) return self:Set(...) end}
Poly.__index=Poly
setmetatable(Poly,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Poly.new(params)
  local o=UGen.new(params)
  o.samplerate = o.samplerate or cybin.samplerate or 48000
  o.voice=o.voice
  o.voices={}
  o.maxVoices=o.maxVoices or 3
  o.voiceIndex=1
  setmetatable(o,Poly)
  return o
end
function Poly:Set(params)
  if params.voice~=nil then self.voice=params.voice end
  params.samplerate=self.samplerate
  local voice=self.voice(params)
  if self.maxVoices<1 then
    table.insert(self.voices,voice)
  else
    self.voices[self.voiceIndex]=voice
    self.voiceIndex=self.voiceIndex+1
    self.voiceIndex=((self.voiceIndex-1)%self.maxVoices)+1
  end
  return voice
end
function Poly:Process(samplerate)
  local out=0
  for i=self.maxVoices,1,-1 do
    if self.voices[i]~=nil then
      if self.voices[i].free~=nil then
        table.remove(self.voices,i)
      else
        out=out+self.voices[i]:Process(samplerate)
      end
    end
  end
  return out
end
--------------------------------------------
FMVoice={__call=function(self,...) return self:Set(...) end}
FMVoice.__index=FMVoice
setmetatable(FMVoice,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function FMVoice.new(params)
  local o=UGen.new(params)
  o.env=o.env or Env{values=o.values or {0,1,0},durations=o.durations or {0.01,0.3}}
  o.env:Reset()
  o.modCoef=o.modCoef or 3
  o.modAmp=o.modAmp or 300
  o.modShape=o.modShape or 1
  o.carrierShape=o.carrierShape or 1
  o.amp=o.amp or 0.1
  o.carrier=Sin{samplerate=o.samplerate}
  o.modulator=Sin{samplerate=o.samplerate}
  o.freq=o.freq or 440
  o.carrier{freq=o.freq}
  o.modulator{freq=o.freq*o.modCoef}
  setmetatable(o,FMVoice)
  return o
end
function FMVoice:Process()
  local env=self.env:Process()
  if self.env.phase==-1 then self.free=true end
  self.modulator{freq=self.freq*self.modCoef}
  self.carrier{freq=self.freq+math.atan(self.modulator:Process(sr)*self.modShape)*self.modAmp*env}
  return math.atan(self.carrier:Process(sr)*self.carrierShape)*env
end
--------------------------------------------
Pluck={__call=function(self,...) return self:Set(...) end}
Pluck.__index=Pluck
setmetatable(Pluck,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Pluck.new(params)
   local o=UGen.new(params)
   o.samplerate=o.samplerate or cybin.samplerate or 48000
   o.freq=o.freq or 220
   o.harmonic=o.harmonic or 3.93
   o.coef=o.coef or 0.9
   o.cutoff=o.cutoff or o.samplerate*0.25
   o.reso=o.reso or 1
   o.osc=Saw{freq=o.freq} or o.osc
   o.env=o.env or Env{values=o.values or {0,1,0},durations=o.durations or {0.01,0.4}}
   o.env{}
   o.filter=o.filter or Filter{filterType='lowpass',freq=o.cutoff,reso=o.reso}
   o.comb=Comb{delay=1/(o.freq*o.harmonic),coef=o.coef}
   setmetatable(o,Pluck)
   return o
end
function Pluck:Process()
   local env=math.pow(self.env:Process(),10)
   if self.env.phase==-1 then self.free=true end
   self.filter{freq=env*self.cutoff+100,reso=self.reso}
   return self.filter:Process(self.comb:Process(self.osc:Process()))*env
end
--------------------------------------------
Fring={__call=function(self,...) return self:Set(...) end}
Fring.__index=Fring
setmetatable(Fring,{__call=function(cls,...) return cls.new(...) end,__index=UGen})
function Fring.new(params)
   local o=UGen.new(params)
   o.env=o.env or Env{values=o.values or {0,1,0},durations=o.durations or {0.01,0.5}}
   o.env:Reset()
   o.modf=o.modf or function(x) return math.random(50,5000) end
   o.basef=o.basef or function(x) return math.random(50,5000) end
   o.pitch=o.pitch or 1
   o.drive=o.drive or 2
   o.nodes=o.nodes or 8
   o.oscs={}
   o.lasts={}
   for i=1,o.nodes do
      o.lasts[i]=math.random()*2-1
      o.oscs[i]=Sin{freq=o.basef(i),phase=math.random()*2*math.pi}
   end
   setmetatable(o,Fring)
   return o
end
function Fring:Process(input)
   input=math.atan(input or 0)
   local out=0
   local env=self.env:Process()
   if self.env.phase==-1 then self.free=true end
   for i=1,self.nodes do
      local lastIndex=i-1
      if lastIndex<1 then lastIndex=lastIndex+self.nodes end
      self.oscs[i]{freq=(self.lasts[lastIndex]*self.modf(i)+self.basef(i))*self.pitch}
      self.lasts[i]=(math.atan(self.oscs[i]:Process()*self.drive)+input)*math.pow(env,2)
      out=out+self.lasts[i]
   end
   self.last=out*math.pow(env,2)/self.nodes
   return self.last
end
----------------------------------------------------------------
-- TODO: Make methods functionalish/idempotent with deep copy --
----------------------------------------------------------------
Pat={}
setmetatable(Pat, {__call = function (cls, ...) return cls.new(...) end,})
Pat.__index=function(t,k)
  if type(k)=='number' then
    return t.t[k]
  else
    return Pat[k]
  end
end
Pat.__newindex=function(t,k,v)
  if type(k)=='number' then
    t.t[k]=v
  else
    rawset(t,k,v)
  end
end
function Pat.new(t)
  local o={}
  setmetatable(o,Pat)
  o.t={}
  o.cycles=t.cycles or 1
  o.offset=t.offset or 0
  o.parallel=t.parallel or false
  for i=1,#(t.t or t) do
    if type(t[i])=='table' then
      o.t[i]=Pat(t[i])
    else
      o.t[i]=t[i]
    end
  end
  return o
end
function Pat.GenDup(n,size)
  local pat=Pat{}
  for i=1,size do pat[i]=n end
  return pat
end
function Pat.GenBjork(nPegs,nHoles)
  local pegs,holes,lastPegIndex,work,pegs,holes
  local function genDup(n,size)
    local t={}
    for i=1,size do t[i]=n end
    return t
  end
  local flatten=function(arr)
    local result={}
    local function flatten(arr)
      for _, v in ipairs(arr) do
        if type(v)=="table" then
          flatten(v)
        else
          table.insert(result,v)
        end
      end
    end
    flatten(arr)
    return result
  end
  local function concat(a,b)
    if b==nil then return a end
    local ret={}
    for i=1,#a do ret[#ret+1]=a[i] end
    for i=1,#b do ret[#ret+1]=b[i] end
    return ret
  end
  local function selectRange(t,from,to)
    local ret={}
    for i=from,to,1 do ret[#ret+1]=t[i] end
    return ret
  end
  if nPegs<1 then return Pat.GenDup(0,nHoles) end
  nHoles=nHoles-nPegs
  pegs=genDup({1},nPegs)
  holes=genDup({0},nHoles)
  lastPegIndex=0
  work=function()
    if (lastPegIndex~=0) then
      holes=selectRange(pegs,lastPegIndex,#pegs)
      pegs=selectRange(pegs,1,lastPegIndex-1)
    end
    nPegs=#pegs
    nHoles=#holes
    for inc=0,nHoles-1,1 do
      pegs[(inc%nPegs)+1]=concat(pegs[(inc%nPegs)+1],holes[inc+1])
    end
    lastPegIndex=(nHoles%nPegs)+1
  end
  work()
  while (lastPegIndex~=1) and (lastPegIndex~=(nPegs)) do
    work()
  end
  return Pat.new(flatten(pegs))
end
function Pat.GenBjorkStructure(size,selects)
  local currentLevel=Pat.GenDup(1,size)
  local ret=Pat.GenDup(0,size)
  for i=1,#selects do
    currentLevel=currentLevel:BjorkSelect(selects[i])
    ret=ret+currentLevel
  end
  return ret
end
function Pat:BjorkSelect(select)
  local selectIndex,selectPattern,outPattern
  outPattern=Pat.new(self)
  outPattern.t={}
  for i=1,#self.t do outPattern[i]=self[i] end
  selectIndex=1
  selectPattern=Pat.GenBjork(select,Pat.Sum(self:Apply(function(x) if x>0 then return 1 else return 0 end end)))
  for i=1,#outPattern.t do
    if outPattern[i]>0 then
      outPattern[i]=outPattern[i]*selectPattern[selectIndex]
      selectIndex=selectIndex+1
    end
  end
  return outPattern
end
function Pat:Select(select)
   local ret=Pat(self);ret.t={}
   for i=1,#self.t do
      if Pat.WrapAt(select,i)>0 then
	 ret[#ret.t+1]=self[i]
      end
   end
   return ret
end
function Pat:Mask(select)
   local ret=Pat(self);ret.t={}
   for i=1,#self.t do
      if Pat.WrapAt(select,i)>0 then
	 ret[#ret.t+1]=self[i]
      else
	 ret[#ret.t+1]=Pat{}
      end
   end
   return ret
end
function Pat:SuperMask(select)
   local ret=Pat(self);ret.t={}
   local selecti=1
   for i=1,#self.t do
      if Pat.WrapAt(select,selecti)>0 then
	 ret[#ret.t+1]=self[i]
      else
	 ret[#ret.t+1]=Pat{}
      end
      if not(type(self[i])=='table' and #self[i].t<1) then selecti=selecti+1 end
   end
   return ret
end
function Pat:RemoveAt(index)
  local ret=Pat(self)
  local len=#(ret.t or ret)
  while index<1 do index=index+len end
  local remIndex=((index-1)%len)+1
  table.remove(ret.t,remIndex)
  return ret
end
function Pat:WrapAt(index)
  local len=#(self.t or self)
  while index<1 do index=index+len end
  local out=self[((index-1)%len)+1]
  if type(out)=='table' then
     return Pat(out)
  else
     return out
  end
end
function Pat:SelectRange(from,to)
  local ret=Pat(self);ret.t={}
  for i=from,to,1 do ret.t[#ret.t+1]=self.t[i] end
  return ret
end
function Pat:Clump(n)
   local ret=Pat{}
   local i=1
   n=math.max(n,1)
   while i<=#self.t do
      ret[#ret.t+1]=self:SelectRange(i,math.min(i+n-1,#self.t))
      i=i+n
   end
   return ret
end
function Pat:Flatter()
   local ret=Pat(self);ret.t={}
   for i=1,#self.t do
      ret=ret..self[i]
   end
   return ret
end
function Pat:Shuffle(f)
   local ret=Pat(self);ret.t={}
   local rem=Pat(self)
   for i=1,#self.t do
      local index=f(i)
      ret[i]=rem:WrapAt(index)
      rem=rem:RemoveAt(index)
   end
   return ret
end
function Pat:Sum()
  local sum=0
  for i=1,#self.t do
    if type(self.t[i])=='table' then
      sum=sum+Pat.Sum(self.t[i])
    else
      sum=sum+self.t[i]
    end
  end
  return sum
end
function Pat.combine(a,b,operator)
  local function opwrapper(a,b)
  if a==nil or b==nil then
      return Pat{}
    else
      return operator(a,b)
    end
  end
  local ret
  if type(a)=='table' then
    ret=Pat(a);ret.t={}
  elseif type(b)=='table' then
    ret=Pat(b);ret.t={}
  else
    ret=Pat{}
  end
  if a==nil or b==nil then
    ret=Pat{}
  elseif type(a)=="table" and type(b)=="table" then
    for i=1,math.max(#a.t,#b.t) do ret[i]=opwrapper(Pat.WrapAt(a,i),Pat.WrapAt(b,i)) end
  elseif type(a)=="number" and type(b)=="table" then
    for i=1,#b.t do ret[i]=opwrapper(a,Pat.WrapAt(b,i)) end
  elseif type(a)=="table" and type(b)=="number" then
    for i=1,#a.t do ret[i]=opwrapper(Pat.WrapAt(a,i),b) end
  end
  return ret
end
function Pat:Substitute(values)
  local ret=Pat(self);ret.t={}
  for i=1,#self.t do ret[i]=Pat.WrapAt(values,self[i]) end
  return ret
end
function Pat:SequencedSubstitute(values)
  local valuesIndices={}
  local ret=Pat(self);ret.t={}
  for i=1,#self.t do
    local indicesIndex=self[i]
    if valuesIndices[indicesIndex]==nil then valuesIndices[indicesIndex]=1 end
    ret[i]=Pat.WrapAt(Pat.WrapAt(values,indicesIndex),valuesIndices[indicesIndex])
    valuesIndices[indicesIndex]=valuesIndices[indicesIndex]+1
  end
  return ret
end
function Pat:Expand(by)
  local ret=Pat(self);ret.t={}
  local retIndex=1
  for i=1,#self.t do
    for j=1,by do
      ret[retIndex]=self[i]
      retIndex=retIndex+1
    end
  end
  return ret
end
function Pat:Replace(a,b)
  local ret=Pat(self);ret.t={}
  for i=1,#self.t do
    ret[i]=self[i]
    if ret[i]==a then ret[i]=b end
  end
  return ret
end
function Pat:Integrate()
  local ret=Pat(self);ret.t={}
  for i=1,#self.t do
    ret[i]=self[i]
    if i>1 then ret[i]=ret[i]+ret[i-1] end
  end
  return ret
end
function Pat:Derive()
  local ret=Pat(self);ret.t={}
  for i=1,#self.t do
    ret[i]=self[i]
    if i>1 then ret[i]=ret[i]-self[i-1] end
  end
  return ret
end
function Pat:QueryEvents(a,b,c)
  if a>b then local temp=b; b=a; a=temp; end
  --
  a=a+self.offset
  b=b+self.offset
  if a<0 then a=0 end
  if b<=0 then return {} end
  --
  c=c/self.cycles
  a=a*c;b=b*c
  local out={}
  local span=b-a
  local step=1/#self.t
  local i=0
  local eventOffset=math.floor(a*#self.t+0.5)
  local startTime=eventOffset/#self.t
  local numEvents=math.floor(span*#self.t+0.5)
  if self.parallel~=true then
     while i<numEvents do
	local e=self.t[((i+eventOffset)%#self.t)+1]
	local start=startTime+(i/#self.t)
	local stop=startTime+((i+1)/#self.t)
	if type(e)=='table' then
	   local events=e:QueryEvents(start,stop,#self.t)
	   for i=1,#events do table.insert(out,events[i]) end
	else
	   table.insert(out,{start=start,stop=stop,value=e})
	end
	i=i+1
     end
  else
     for i=1,#self.t do
	local e=self.t[i]
	local start=a
	local stop=b
	if type(e)=='table' then
	   local events=e:QueryEvents(start,stop,1)
	   for i=1,#events do table.insert(out,events[i]) end
	else
	   table.insert(out,{start=start,stop=stop,value=e})
	end
     end
  end
  for i=1,#out do
    out[i].start=out[i].start/c-self.offset
    out[i].stop=out[i].stop/c-self.offset
  end
  return out
end
function Pat:P()
  local ret=Pat(self)
  ret.parallel=true
  return ret
end
function Pat:Slow(x)
  local ret=Pat(self)
  ret.cycles=x
  return ret
end
function Pat:Fast(x)
  local ret=Pat(self)
  ret.cycles=1/x
  return ret
end
function Pat:Offset(x)
   local ret=Pat(self)
   ret.offset=x
   return ret
end
function Pat:Apply(f)
  for i=1,#(self.t or self) do
    local value=self.t[i]
    if type(value)=='table' then
      self.t[i]=value:Apply(f)
    else
      self.t[i]=f(value,i)
    end
  end
  return self
end
function Pat:MapValues(f) -- backwards compatibilty
  return self:Apply(f)
end
function Pat:Map(f)
   local ret=Pat.new(self)
   for i=1,#(ret.t or ret) do
      ret.t[i]=f(ret.t[i],i)
   end
   return ret
end
function Pat:Max(func)
  local ret=self[1]
  for i=1,#self.t do
    if self[i]>ret then ret=self[i] end
  end
  return ret
end
function Pat:Min(func)
  local ret=self[1]
  for i=1,#self.t do
    if self[i]<ret then ret=self[i] end
  end
  return ret
end
function Pat:Normalize(func)
  local ret=Pat.new({})
  local min=self:Min()
  local max=self:Max()
  for i=1,#self.t do
    ret[i]=(self[i]-min)/(max-min)
  end
  return ret
end
function Pat:Degree2Pitch(scale,octaveLength)
   scale = scale or {0,2,3,5,7,8,10}
   octaveLength = octaveLength or 12
   local ret=Pat(self)
   local function helper(degree)
      local octave=math.floor(degree/#scale,1)
      local class=math.fmod(degree,#scale)
      while class<0 do class=class+#scale end
      class=class+1
      return scale[class]+octave*octaveLength
   end
   return ret:Apply(helper)
end
function Pat:EdoPitch2Freq(baseNote,baseFreq,divisions,ratio)
   if divisions==nil then divisions=12 end
   if baseFreq==nil then baseFreq=440 end
   if baseNote==nil then baseNote=57 end
   if ratio==nil then ratio=2 end
   ret=Pat(self)
   local function helper(note)
      return baseFreq*math.pow(ratio,(note-baseNote)/divisions)
   end
   return ret:Apply(helper)
end
function Pat:PitchCompress(low,high,octaveLength)
   if octaveLength==nil then octaveLength=12 end
   local ret=Pat(self)
   local function helper(pitch)
      while pitch<low do pitch=pitch+octaveLength end
      while pitch>high do pitch=pitch-octaveLength end
      return pitch
   end
   return ret:Apply(helper)
end
function Pat:NoRepeats()
   local ret=Pat(self)
   if #ret.t<2 then return ret end
   for i=2,#ret.t do
      if ret.t[i]==ret.t[i-1] then
	 ret.t[i]=Pat{}
      end
   end
   return ret
end
function Pat:Reverse()
   local ret=Pat(self);ret.t={}
   for i=#self.t,1,-1 do
      ret.t[#ret.t+1]=self[i]
   end
   return ret
end
function Pat:__tostring()
  local function tprint(t)
    local out='['
    for i=1,#t do
      local separator=' '
      if i==1 then separator='' end
      if type(t[i])=='table' and #t[i]<1 and #t[i].t<1 then
        out=out..separator..'_'
      else
        out=out..separator..tostring(t[i])
      end
    end
    return out..']'
  end
  return tprint(self.t)
end
function Pat:__concat(pat)
  if pat==nil then return self end
  local ret=Pat(self);
  for i=1,#pat.t do table.insert(ret.t,pat.t[i]) end
  return ret
end
function Pat.__add(a,b)
  return Pat.combine(a,b,function(a,b) return a+b end)
end
function Pat.__sub(a,b)
  return Pat.combine(a,b,function(a,b) return a-b end)
end
function Pat.__mul(a,b)
  return Pat.combine(a,b,function(a,b) return a*b end)
end
function Pat.__div(a,b)
  return Pat.combine(a,b,function(a,b) return a/b end)
end
function Pat.__mod(a,b)
  return Pat.combine(a,b,function(a,b) return a%b end)
end
function Pat.__pow(a,b)
  return Pat.combine(a,b,function(a,b) return a^b end)
end
function Pat.__unm(self)
  return Pat.combine(0,self,function(a,b) return a-b end)
end
P=Pat
_=P{}