Audio Effects

Независимо от того, используете ли вы synth или sample, вы можете применить любой из следующих встроенных audio effects. Как вы могли догадаться, effects могут быть объединены в цепочку, и они принимают строку pattern в качестве аргумента.

Signal chain

Signal chain в Strudel выглядит следующим образом:

• Звукогенерирующий event запускается pattern
  • У него есть время начала и продолжительность, которые обычно контролируются длиной ноты и параметрами ADSR
  • Если мы превышаем максимальную полифонию, старые звуки начинают исчезать
  • Заглушенные звуки (те, чье значение s равно -, ~ или _) пропускаются
• Производится звук (через, скажем, sample или oscillator)
  • Здесь происходят effects на основе detune (такие как detune, penv и т.д.)
• Следующее произойдет по порядку и только если они были вызваны в pattern. Обратите внимание, что все это effects одноразового использования, что означает, что множественные вхождения их в pattern просто переопределят значения (например, вы не можете сделать s("bd").lpf(100).distort(2).lpf(800) для lowpass, distort, а затем снова lowpass)
  • Phase vocoder (stretch)
  • Применяется Gain (gain)
    • Здесь происходит основной ADSR (громкости)
  • Lowpass filter (lpf)
  • Highpass filter (hpf)
  • Bandpass filter (bandpass)
  • Vowel filter (vowel)
  • Уменьшение частоты дискретизации (coarse)
  • Bit crushing (crush)
  • Waveshape distortion (shape)
  • Обычный distortion (distort)
  • Tremolo (tremolo)
  • Compressor (compressor)
  • Panning (pan)
  • Phaser (phaser)
  • Postgain (post)
• Затем звук разделяется на несколько назначений
  • Dry output (количество контролируется параметром dry)
  • The sends
    • Analyzers
      • Они используются для инструментов типа scope и spectrum, и их настройка обычно происходит за кулисами
    • Delay (количество контролируется параметром delay)
    • Reverb (количество контролируется параметром room)
• Dry output, delay и reverb объединяются в так называемый “orbit” pattern (подробнее см. в разделе ниже)
  • Effect duck влияет на громкость всех сигналов в orbit
  • Затем orbit отправляется в микшер

Orbits

Orbits — это способ обработки выходов в Strudel. Они также предписывают, какие delay и reverb связать с dry signal. По умолчанию все orbits смешиваются в каналы 1 и 2 в стерео, однако с настройкой “Multi Channel Orbits” (в разделе Настройки справа) вы можете использовать их как отдельные 2-канальные стерео выходы (orbit i будет отображен на каналы 2i и 2i + 1). Затем вы можете использовать маршрутизаторы типа Blackhole 16 для получения и записи всех каналов в DAW для последующей обработки.

Orbit по умолчанию — 1, и он устанавливается с помощью orbit. Вы можете отправить звук на несколько orbits через mininotation

s("white").orbit("2,3,4").gain(0.2)

но будьте осторожны, так как это создаст три копии звука за кулисами, что означает, что если они будут смешаны в один выход, они утроят громкость. Мы уменьшили gain здесь, чтобы сберечь ваши уши.

⚠️ На каждый orbit приходится только один delay и один reverb, поэтому имейте в виду, что если вы попытаетесь изменить параметры на двух patterns, указывающих на один и тот же orbit, это может привести к непредсказуемым результатам. Сравните, например, этот красивый pluck с большим reverb:

$: s("triangle*4").decay(0.5).n(irand(12)).scale('C minor')
.room(1).roomsize(10)

против того же pluck с заглушенным kick drum, который переопределяет значение roomsize:

$: s("triangle*4").decay(0.5).n(irand(12)).scale('C minor')
.room(1).roomsize(10)

$: s("bd*4").room(0.01).roomsize(0.01).postgain(0)

Это происходит из-за того, что они используют один и тот же orbit: по умолчанию 1. Это можно исправить, просто обновив orbits, чтобы они были различными:

$: s("triangle*4").decay(0.5).n(irand(12)).scale('C minor')
.room(1).roomsize(10).orbit(2)

$: s("bd*4").room(0.01).roomsize(0.01).postgain(0)

Непрерывные изменения

Поскольку все вышеперечисленное запускается при возникновении звука, часто бывает так, что параметры могут не изменяться непрерывно во времени. Например,

s("supersaw").lpf(tri.range(100, 5000).slow(2))

Не будет производить непрерывно модулированный LFO low-pass filter из-за того, что tri семплируется только каждый раз, когда звучит нота (в данном случае по умолчанию один раз за cycle). Вы можете имитировать это, введя больше звукогенерирующих events, например:

s("supersaw").seg(16).lpf(tri.range(100, 5000).slow(2))

Некоторые параметры действительно вызывают непрерывные изменения во времени, хотя:

• Кривая ADSR (управляется attack, sustain, decay, release)
• Кривая pitch envelope (управляется penv и связанными ADSR)
• Кривая FM (fmenv)
• Filter envelopes (lpenv, hpenv, bpenv)
• Tremolo (tremolo)
• Phaser (phaser)
• Vibrato (vib)
• Ducking (duckorbit)

Filters

Filters являются важным строительным блоком subtractive synthesis. Strudel поставляется с 3 типами filters:

• low-pass filter: низкие частоты могут пройти, высокие частоты обрезаются
• high-pass filter: высокие частоты могут пройти, низкие частоты обрезаются
• band-pass filters: может пройти только частотная полоса, низкие и высокие частоты вокруг обрезаются

Каждый filter имеет 2 параметра:

• cutoff: частота, на которой filter начинает работать. например, low-pass filter с cutoff 1000Hz позволяет частотам ниже 1000Hz проходить.
• q-value: Контролирует резонанс filter. Более высокие значения звучат более агрессивно. См. также Q-Factor

lpf

s("bd sd [~ bd] sd,hh*6").lpf("<4000 2000 1000 500 200 100>")

s("bd*16").lpf("1000:0 1000:10 1000:20 1000:30")

lpq

s("bd sd [~ bd] sd,hh*8").lpf(2000).lpq("<0 10 20 30>")

hpf

s("bd sd [~ bd] sd,hh*8").hpf("<4000 2000 1000 500 200 100>")

s("bd sd [~ bd] sd,hh*8").hpf("<2000 2000:25>")

hpq

s("bd sd [~ bd] sd,hh*8").hpf(2000).hpq("<0 10 20 30>")

bpf

s("bd sd [~ bd] sd,hh*6").bpf("<1000 2000 4000 8000>")

bpq

s("bd sd [~ bd] sd").bpf(500).bpq("<0 1 2 3>")

ftype

note("{f g g c d a a#}%8").s("sawtooth").lpenv(4).lpf(500).ftype("<0 1 2>").lpq(1)

note("c f g g a c d4").fast(2)
.sound('sawtooth')
.lpf(200).fanchor(0)
.lpenv(3).lpq(1)
.ftype("<ladder 12db 24db>")

vowel

note("[c2 <eb2 <g2 g1>>]*2").s('sawtooth')
.vowel("<a e i <o u>>")

s("bd sd mt ht bd [~ cp] ht lt").vowel("[a|e|i|o|u]")

Amplitude Modulation

Amplitude modulation периодически изменяет амплитуду (gain) во времени.

am

tremolosync

note("d d d# d".fast(4)).s("supersaw").tremolosync("4").tremoloskew("<1 .5 0>")

tremolodepth

note("a1 a1 a#1 a1".fast(4)).s("pulse").tremsync(4).tremolodepth("<1 2 .7>")

tremoloskew

note("{f a c e}%16").s("sawtooth").tremsync(4).tremoloskew("<.5 0 1>")

tremolophase

note("{f a c e}%16").s("sawtooth").tremsync(4).tremolophase("<0 .25 .66>")

tremoloshape

note("{f g c d}%16").tremsync(4).tremoloshape("<sine tri square>").s("sawtooth")

Amplitude Envelope

Amplitude envelope контролирует динамический контур звука. Strudel использует ADSR envelopes, которые, вероятно, являются наиболее распространенным способом описания envelope:

ссылка на изображение

attack

note("c3 e3 f3 g3").attack("<0 .1 .5>")

decay

note("c3 e3 f3 g3").decay("<.1 .2 .3 .4>").sustain(0)

sustain

note("c3 e3 f3 g3").decay(.2).sustain("<0 .1 .4 .6 1>")

release

note("c3 e3 g3 c4").release("<0 .1 .4 .6 1>/2")

adsr

note("[c3 bb2 f3 eb3]*2").sound("sawtooth").lpf(600).adsr(".1:.1:.5:.2")

Filter Envelope

Каждый filter может получить дополнительный filter envelope, динамически контролирующий значение cutoff. Он использует ADSR envelope, аналогичный используемому для амплитуды. Есть дополнительный параметр для контроля глубины модуляции filter: lpenv|hpenv|bpenv. Это позволяет вам воспроизводить тонкие или огромные модуляции filter просто увеличивая или уменьшая глубину.

note("[c eb g <f bb>](3,8,<0 1>)".sub(12))
.s("<sawtooth>/64")
.lpf(sine.range(300,2000).slow(16))
.lpa(0.005)
.lpd(perlin.range(.02,.2))
.lps(perlin.range(0,.5).slow(3))
.lpq(sine.range(2,10).slow(32))
.release(.5)
.lpenv(perlin.range(1,8).slow(2))
.ftype('24db')
.room(1)
.juxBy(.5,rev)
.sometimes(add(note(12)))
.stack(s("bd*2").bank('RolandTR909'))
.gain(.5).fast(2)

Есть один filter envelope для каждого типа filter и, следовательно, один набор параметров envelope filter с префиксом lp, hp или bp:

• lpattack, lpdecay, lpsustain, lprelease, lpenv: filter envelope для lowpass filter.
  • альтернативно: lpa, lpd, lps, lpr и lpe.
• hpattack, hpdecay, hpsustain, hprelease, hpenv: filter envelope для highpass filter.
  • альтернативно: hpa, hpd, hps, hpr и hpe.
• bpattack, bpdecay, bpsustain, bprelease, bpenv: filter envelope для bandpass filter.
  • альтернативно: bpa, bpd, bps, bpr и bpe.

lpattack

note("c2 e2 f2 g2")
.sound('sawtooth')
.lpf(300)
.lpa("<.5 .25 .1 .01>/4")
.lpenv(4)

lpdecay

note("c2 e2 f2 g2")
.sound('sawtooth')
.lpf(300)
.lpd("<.5 .25 .1 0>/4")
.lpenv(4)

lpsustain

note("c2 e2 f2 g2")
.sound('sawtooth')
.lpf(300)
.lpd(.5)
.lps("<0 .25 .5 1>/4")
.lpenv(4)

lprelease

note("c2 e2 f2 g2")
.sound('sawtooth')
.clip(.5)
.lpf(300)
.lpenv(4)
.lpr("<.5 .25 .1 0>/4")
.release(.5)

lpenv

note("c2 e2 f2 g2")
.sound('sawtooth')
.lpf(300)
.lpa(.5)
.lpenv("<4 2 1 0 -1 -2 -4>/4")

Pitch Envelope

Вы также можете контролировать высоту тона с помощью envelopes! Pitch envelopes могут вдохнуть жизнь в статичные звуки:

n("<-4,0 5 2 1>*<2!3 4>")
.scale("<C F>/8:pentatonic")
.s("gm_electric_guitar_jazz")
.penv("<.5 0 7 -2>*2").vib("4:.1")
.phaser(2).delay(.25).room(.3)
.size(4).fast(1.5)

Вы также можете создать прекрасные звуки в стиле chiptune:

n(run("<4 8>/16")).jux(rev)
.chord("<C^7 <Db^7 Fm7>>")
.dict('ireal')
.voicing().add(note("<0 1>/8"))
.dec(.1).room(.2)
.segment("<4 [2 8]>")
.penv("<0 <2 -2>>").patt(.02).fast(2)

Давайте разберем все элементы управления pitch envelope:

pattack

note("c eb g bb").pattack("0 .1 .25 .5").slow(2)

pdecay

note("<c eb g bb>").pdecay("<0 .1 .25 .5>")

prelease

note("<c eb g bb> ~")
.release(.5) // чтобы услышать pitch release
.prelease("<0 .1 .25 .5>")

penv

note("c")
.penv("<12 7 1 .5 0 -1 -7 -12>")

pcurve

note("g1*4")
.s("sine").pdec(.5)
.penv(32)
.pcurve("<0 1>")

panchor

note("c c4").penv(12).panchor("<0 .5 1 .5>")

Dynamics

gain

s("hh*8").gain(".4!2 1 .4!2 1 .4 1").fast(2)

velocity

s("hh*8")
.gain(".4!2 1 .4!2 1 .4 1")
.velocity(".4 1")

compressor

s("bd sd [~ bd] sd,hh*8")
.compressor("-20:20:10:.002:.02")

postgain

s("bd sd [~ bd] sd,hh*8")
.compressor("-20:20:10:.002:.02").postgain(1.5)

xfade

xfade(s("bd*2"), "<0 .25 .5 .75 1>", s("hh*8"))

Panning

jux

s("bd lt [~ ht] mt cp ~ bd hh").jux(rev)

s("bd lt [~ ht] mt cp ~ bd hh").jux(press)

s("bd lt [~ ht] mt cp ~ bd hh").jux(iter(4))

juxBy

s("bd lt [~ ht] mt cp ~ bd hh").juxBy("<0 .5 1>/2", rev)

pan

s("[bd hh]*2").pan("<.5 1 .5 0>")

s("bd rim sd rim bd ~ cp rim").pan(sine.slow(2))

Waveshaping

coarse

s("bd sd [~ bd] sd,hh*8").coarse("<1 4 8 16 32>")

crush

s("<bd sd>,hh*3").fast(2).crush("<16 8 7 6 5 4 3 2>")

distort

s("bd sd [~ bd] sd,hh*8").distort("<0 2 3 10:.5>")

note("d1!8").s("sine").penv(36).pdecay(.12).decay(.23).distort("8:.4")

s("bd:4*4").bank("tr808").distort("3:0.5:diode")

Global Effects

Local vs Global Effects

В то время как вышеперечисленные “локальные” effects всегда будут создавать отдельную цепочку effects для каждого event, global effects используют одну и ту же цепочку для всех events одного orbit:

orbit

stack(
  s("hh*6").delay(.5).delaytime(.25).orbit(1),
  s("~ sd ~ sd").delay(.5).delaytime(.125).orbit(2)
)

Delay

delay

s("bd bd").delay("<0 .25 .5 1>")

s("bd bd").delay("0.65:0.25:0.9 0.65:0.125:0.7")

delaytime

delayfeedback

s("bd").delay(.25).delayfeedback("<.25 .5 .75 1>")

Reverb

room

s("bd sd [~ bd] sd").room("<0 .2 .4 .6 .8 1>")

s("bd sd [~ bd] sd").room("<0.9:1 0.9:4>")

roomsize

s("bd sd [~ bd] sd").room(.8).rsize(1)

s("bd sd [~ bd] sd").room(.8).rsize(4)

roomfade

s("bd sd [~ bd] sd").room(0.5).rlp(10000).rfade(0.5)

s("bd sd [~ bd] sd").room(0.5).rlp(5000).rfade(4)

roomlp

s("bd sd [~ bd] sd").room(0.5).rlp(10000)

s("bd sd [~ bd] sd").room(0.5).rlp(5000)

roomdim

s("bd sd [~ bd] sd").room(0.5).rlp(10000).rdim(8000)

s("bd sd [~ bd] sd").room(0.5).rlp(5000).rdim(400)

iresponse

s("bd sd [~ bd] sd").room(.8).ir("<shaker_large:0 shaker_large:2>")

Phaser

phaser

n(run(8)).scale("D:pentatonic").s("sawtooth").release(0.5)
.phaser("<1 2 4 8>")

phaserdepth

n(run(8)).scale("D:pentatonic").s("sawtooth").release(0.5)
.phaser(2).phaserdepth("<0 .5 .75 1>")

phasercenter

n(run(8)).scale("D:pentatonic").s("sawtooth").release(0.5)
.phaser(2).phasercenter("<800 2000 4000>")

phasersweep

n(run(8)).scale("D:pentatonic").s("sawtooth").release(0.5)
.phaser(2).phasersweep("<800 2000 4000>")

Duck

duckorbit

$: n(run(16)).scale("c:minor:pentatonic").s("sawtooth").delay(.7).orbit(2)
$: s("bd:4!4").beat("0,4,8,11,14",16).duckorbit(2).duckattack(0.2).duckdepth(1)

$: n(run(16)).scale("c:minor:pentatonic").s("sawtooth").delay(.7).orbit(2)
$: s("hh*16").orbit(3)
$: s("bd:4!4").beat("0,4,8,11,14",16).duckorbit("2:3").duckattack(0.2).duckdepth(1)

duckattack

sound: n(run(8)).scale("c:minor").s("sawtooth").delay(.7).orbit(2)
ducker: s("bd:4!4").beat("0,4,8,11,14",16).duckorbit(2).duckattack("<0.2 0 0.4>").duckdepth(1)

moreduck: n(run(8)).scale("c:minor").s("sawtooth").delay(.7).orbit(2)
lessduck: s("hh*16").orbit(5)
ducker: s("bd:4!4").beat("0,4,8,11,14",16).duckorbit("2:5").duckattack("0.4:0.1")

duckdepth

stack( n(run(8)).scale("c:minor").s("sawtooth").delay(.7).orbit(2), s("bd:4!4").beat("0,4,8,11,14",16).duckorbit(2).duckattack(0.2).duckdepth("<1 .9 .6 0>"))

$: n(run(16)).scale("c:minor:pentatonic").s("sawtooth").delay(.7).orbit(2)
$: s("hh*16").orbit(3)
$: s("bd:4!4").beat("0,4,8,11,14",16).duckorbit("2:3").duckattack(0.2).duckdepth("1:0.5")

Далее мы рассмотрим ввод/вывод через MIDI, OSC и другие методы.