bpf

Break point function with linear interpolation

Plugin opcode in emugens.

Syntax

ky bpf kx, kx1, ky1, kx2, ..., kxn, kyn
iy bpf ix, ix1, iy1, ix2, ..., ixn, iyn
kys[] bpf kxs[], kx1, ky1, kx2, ..., kxn, kyn
iys[] bpf ixs[], ix1, iy1, ix2, ..., ixn, iyn
ky bpf kx, kxs[], kys[]
iy bpf ix, ixs[], iys[]
ay bpf ax, kx1, ky1, kx2, ..., kxn, kyn
ay bpf ax, kxs[], kys[]
ky, kw bpf kx, kxs[], kys[], kws[]

Performance

kx -- Input value

kxn, kyn -- Defines a breakpoint. Can be changed at krate, but all _kx_s must be sorted.

The points (kx1, ky1), (kx2, ky2), etc, define a linearly interpolated function. This function is evaluated at point kx. This function extends to both -inf and +inf, so if kx < kx1 then ky = ky1 and the same holds true the other end.

These are equivalent:

ky bpf kx, 0, 0,  0.5, 10,  1.02, 200

itab ftgenonce 0, 0, -27, 0, 0, 50, 10, 102, 200
ky = tablei(limit(kx, 0, 1.02)*100, itab)

Note

x values need to be sorted. Both x and y values can change but x values must stay sorted.

Examples

Here is an example of the bpf opcode. It uses the file bpf.csd.

<CsoundSynthesizer>
<CsOptions>
-odac
</CsOptions>
<CsInstruments>

; Example for opcode bpf

/*

  bpf stands for Break Point Function

  Given an x value and a series of pairs (x, y), it returns
  the corresponding y value in the linear curve defined by the
  pairs

  It works both at i- and k- time

  ky    bpf kx,    kx0, ky0, kx1, ky1, kx2, ky2, ...
  kys[] bpf kxs[], kx0, ky0, kx1, ky1, kx2, ky2, ...

  NB: x values must be ordered (kx0 < kx1 < kx2 etc)

  See also: bpfcos, linlin, lincos

*/

sr = 44100
ksmps = 64
nchnls = 2
0dbfs = 1

instr 1
  kx line -1, p3, 2.5
  ky bpf kx,        \
         0,    0,   \
         1.01, 10,  \
         2,    0.5, \
         2.5,  -1
  if metro(10) == 1 then
    printsk "kx: %f   ky: %f \n", kx, ky
  endif
endin

instr 2
  ; test i-time
  ix = 1.2
  iy bpf ix, 0,0, 0.5,5, 1,10, 1.5,15, 2,20, 2.5,25, 3,30
  prints "iy: %f", iy
  turnoff
endin

instr 3
  ; bpf also works with arrays
  kx[] fillarray 0, 0.15, 0.25, 0.35, 0.45, 0.55, 0.6
  ky[] bpf kx, 0,0, 0.1,10, 0.2,20, 0.3,30, 0.4,40, 0.5,50
  printarray ky, 1, "", "ky="
  turnoff
endin

instr 4
  ; bpf as an envelope generator, like linsegb but driven by external phase
  ; bpf + rms can also be used as compressor

  atime linseg 0, p3*0.62, p3, p3*0.38, 0
  aenv = bpf(atime, 0,0, 0.1,1, 0.5, 0.2) ^ 2
  kbw  = bpf(timeinsts(), 0, 0, p3*0.62, 1) ^ 3
  asig = (beosc(1000, kbw, -1, rnd(6.28)) + beosc(1012, kbw, -1, rnd(6.28))) * 0.3
  kratio bpf dbamp(rms:k(asig)), -12, 1, -6, 0.4, -3, 1/100
  asig *= aenv * interp(lagud(kratio, 0.01, 0.1))
  outs asig, asig
endin

</CsInstruments>
<CsScore>
; i 1 0 3 
; i 2 0 -1
; i 3 0 -1
i 4 0 3

</CsScore>
</CsoundSynthesizer>

See also

Linear and Exponential Generators

Credits

By: Eduardo Moguillansky 2017