Using groups with a Pattern

[dayunbao]

I'm still playing around with granular synthesis, and am starting to get something I like. I have two SynthDefs with GrainBufs, and initially added reverb and delay to each. I decided to put the effects in their own SynthDefs and route to them with buses. I'm using Patterns to play the Synths. However, I'm not sure how to make sure the Synths that the Patterns create are added before the effects so the audio is routed correctly. I didn't see anything in the Pattern arguments that gave me any hints on how to do this. Ideas?

import sys
import time
from pathlib import Path

from supriya import AddAction, Envelope, Server, synthdef, UGenOperable
from supriya.clocks import Clock
from supriya.conversions import midi_note_number_to_frequency
from supriya.patterns import EventPattern, RandomPattern, SequencePattern
from supriya.ugens import (
    CombL,
    Envelope,
    EnvGen,
    FreeVerb,
    In,
    Out, 
    Pan2,
    SinOsc,
)
from supriya.ugens.core import UGenRecursiveInput
from supriya.ugens.dynamics import Limiter
from supriya.ugens.filters import RLPF
from supriya.ugens.granular import GrainBuf
from supriya.ugens.lines import LinExp
from supriya.ugens.noise import LFNoise1, LFNoise2, Rand
from supriya.ugens.panning import Splay
from supriya.ugens.osc import Impulse


def grain_generator_spooky(
        buffer_id: UGenRecursiveInput,
        grain_duration: UGenRecursiveInput,
        position: UGenRecursiveInput,
        trigger_frequency: UGenRecursiveInput,
) -> UGenOperable:
    duration_modulator = LFNoise1.ar(frequency=5).scale(-1.0, 1.0, -0.5, 0.5)
    grain_duration += duration_modulator

    position_modulator = LFNoise2.ar(frequency=50).scale(-1.0, 1.0, -0.05, 0.05)
    position += position_modulator
    
    signal = GrainBuf.ar(
        buffer_id=buffer_id,
        duration=grain_duration,
        position=position,
        rate=LFNoise1.ar(frequency=0.1).scale(-1, 1, 0, 1),
        trigger=Impulse.ar(frequency=trigger_frequency),
    )

    return signal

@synthdef()
def granular_synthesis_spooky(
    adsr=(0.01, 0.3, 0.5, 1.0),
    buffer_id=0,
    gate=1,
    grain_duration=1,
    out_bus=0,
    position=0,
    rate=1,
    trigger_frequency=440,
) -> None:
    envelope = EnvGen.kr(
        envelope=Envelope.adsr(
            attack_time=adsr[0],
            decay_time=adsr[1],
            sustain=adsr[2],
            release_time=adsr[3],
        ),
        gate=gate,
        done_action=2,
    )

    signals = []
    for _ in range(2):
        signal = grain_generator_spooky(
            buffer_id=buffer_id,
            grain_duration=grain_duration,
            position=position,
            rate=rate,
            trigger_frequency=trigger_frequency
        )
        signal_detune = Rand.ir(minimum=-0.5, maximum=0.5)
        signal += signal_detune
        signal *= envelope
        signals.append(signal)

    signals = Splay.ar(source=signals, level=0.1)
    Limiter.ar(source=signals, level=0.01)
    Out.ar(bus=out_bus, source=signals)

@synthdef()
def granular_synthesis_bass(
    buffer_id=0,
    gate=1,
    grain_duration=1,
    out_bus=0,
    position=0,
    rate=1,
    trigger_frequency=440,
) -> None:
    envelope = EnvGen.kr(
        envelope=Envelope.percussive(),
        gate=gate,
    )

    signal = GrainBuf.ar(
        buffer_id=buffer_id,
        duration=grain_duration,
        position=position,
        rate=rate,
        trigger=Impulse.ar(frequency=[trigger_frequency, trigger_frequency - 0.5]),
    )
    mod_signal = SinOsc.ar(frequency=1)
    # Convert output to frequency range.
    mod_freq = LinExp.ar(
        input_minimum=-1.0, 
        input_maximum=1.0, 
        output_minimum=100, 
        output_maximum=4000,
        source=mod_signal,
    )
    signal *= envelope
    signal = RLPF.ar(source=signal, frequency=mod_freq, reciprocal_of_q=0.15)
    signal = Pan2.ar(source=signal)
    Out.ar(bus=out_bus, source=signal)

@synthdef()
def delay(
    in_bus: 2, 
    out_bus: 0
):
    signal = In.ar(bus=in_bus, channel_count=2)
    signal = CombL.ar(
        delay_time=0.2,
        decay_time=3.5,
        maximum_delay_time=0.2, 
        source=signal
    )
    Out.ar(bus=out_bus, source=signal)

@synthdef()
def reverb(
    in_bus=2,
    out_bus=0,
):
    signal = In.ar(bus=in_bus, channel_count=2)
    signal = FreeVerb.ar(source=signal, mix=0.6, room_size=0.65, damping=0.5)
    Out.ar(bus=out_bus, source=signal)


def main() -> None:
    server = Server().boot()
    server.add_synthdefs(
        delay, 
        granular_synthesis_bass, 
        granular_synthesis_spooky,
        reverb,
    )
    server.sync()

    time_tombs_sample_path = Path(__file__).parent / 'samples/time_tombs.mp3'
    time_tombs_sample_buffer = server.add_buffer(file_path=str(time_tombs_sample_path))
    server.sync()

    synth_group = server.add_group()  <- I WANTED TO ADD THE SYNTHS TO THIS GROUP TO MAKE SURE THE ORDER OF OPERATIONS WAS CORRECT, BUT I'M NOT SURE HOW TO DO IT.

    effects_group = server.add_group(add_action=AddAction.ADD_AFTER)

    delay_bus = server.add_bus(calculation_rate='audio')
    reverb_bus = server.add_bus(calculation_rate='audio')

    effects_group.add_synth(
        synthdef=delay,
        in_bus=delay_bus,
        out_bus=reverb_bus
    )

    effects_group.add_synth(
        synthdef=reverb,
        in_bus=reverb_bus,
        out_bus=0,
    )

    time_tombs_start = 3.269/10.948
    time_tombs_grain_duration = 1.069

    ten_thousand_years_start = 9.882/10.948

    spooky_pattern = EventPattern(
        delta=0.25,
        duration=0.25,
        buffer_id=time_tombs_sample_buffer.id_,
        grain_duration=time_tombs_grain_duration,
        out_bus=delay_bus,
        position=time_tombs_start,
        synthdef=granular_synthesis_spooky,
        trigger_frequency=RandomPattern(minimum=10000, maximum=50000, iterations=None),
    )

    diminshed_bass_scale = [0, 3, 4, 1]
    root_note = 26
    bass_scale = [midi_note_number_to_frequency(root_note + n) for n in diminshed_bass_scale]
    sequence_pattern = SequencePattern(sequence=bass_scale, iterations=None)
    bass_pattern = EventPattern(
        delta=0.5,
        duration=0.25,
        buffer_id=time_tombs_sample_buffer.id_,
        grain_duration=0.09,
        out_bus=delay_bus,
        position=ten_thousand_years_start,
        rate=0.75,
        synthdef=granular_synthesis_bass,
        trigger_frequency=sequence_pattern,
    )

    clock = Clock()
    clock.start(beats_per_minute=80)
    spooky_pattern.play(clock=clock, context=server)
    bass_pattern.play(clock=clock, context=server)

    while True:
        time.sleep(1)

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        sys.exit(0)

[josephine-wolf-oberholtzer]

I'm assuming you figured this one out?

[dayunbao]

I did. Thanks! I removed the groups, since I didn't need them. I just added the effects synths with `server.add_synth` and made sure to add them to the tail. I think so ran into another issue with @synthdef. Passing a bus coverts it to an int, but that doesn't happen passing a bus via `server.add_synth`. This stopped everything from working, but I just cast the buses to ints when calling `server.add_synth`and then everything worked.

…

On Sun, May 25, 2025, 3:16 PM Joséphine Wolf Oberholtzer < ***@***.***> wrote: I'm assuming you figured this one out? — Reply to this email directly, view it on GitHub <#500 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ACVNNERZVMTWMIUZI2RECTT3AG7BLAVCNFSM6AAAAAB53XZPNCVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTGMRWGM3DGNA> . You are receiving this because you modified the open/close state.Message ID: ***@***.*** .com>

[josephine-wolf-oberholtzer]

1. I realize there's no tutorial docs for these, but you didn't find FxPattern (adds a synth after the synths created by an event pattern) or GroupPattern (wraps the synths created by an event pattern into a group)?

2. I think I'm confused on what you expect @synthdef and add_synth to do. @synthdef converts every argument into a float because that's the only value a Control UGen can have. Whereas add_synth (as defined in the official spec!) allows passing either a float or a string (where the string is the pattern [ac]\d+ and maps the new synth's parameter to a bus). I made the assumption - maybe wrong - that if you pass a Bus or BusGroup as an argument when instantiating a synth with add_synth() that you'd want to map it. But maybe I need to just enforce that we only accept floats or strings, and force the user to make the explicit choice. Do take a look at the source for @synthdef. It's just doing some pre-processing before turning the decorated function's arguments into SynthDef parameters via SynthDefBuilder's add_parameter: https://github.com/supriya-project/supriya/blob/main/supriya/ugens/core.py#L5967

[dayunbao]

1. I realize there's no tutorial docs for these, but you didn't find FxPattern (adds a synth after the synths created by an event pattern) or GroupPattern (wraps the synths created by an event pattern into a group)?

Like you, I have constraints on my time and energy. To give you some idea of how I work, if I'm working on the demo scripts, my usual workflow is:

1. Start with SuperCollider/sclang and work backwards to Supriya, which I have to do because I'm the only one showing how to do things with Supriya :)
2. Watch Eli Fieldsteel's tutorials on whatever kind of synthesis I want to learn and make a demo for.
3. Figure out if there are any UGens, methods or functions he uses that are not available in Supriya. Since things can be named differently or work slightly differently in Supriya, this step might take a while.
4. If everything is available in Supriya, reproduce his script.
5. If not, try to figure out a work around, or failing that, try making a demo of something else.
6. Once I have a working version of Eli's script, usually spend around a week learning how this kind of synthesis works, and figure out something unique and interesting I want to do with it.
7. Spend around half of a day writing up the Reddit post. How long this actually takes depends on the complexity of the demo.

Considering how much of a time and energy investment the above is, I go with what I know works. I also try not to bother you with questions too much, since you have a busy life of your own. If I try to start using stuff that's available in Supriya but isn't in sclang, it also becomes more difficult/time consuming to troubleshoot because you're the only person I can ask for help. When I did the FM/PM synthesis tutorials, I actually got help on the SuperCollider forums, since my questions weren't specific to Supriya, and I also didn't know if you had experience making FM/PM operators and algorithms. Either way, I didn't want to take up more of your time with those questions (there's only one of you) when I had access to a large group of people who could share their time with me by answering my questions.

When I'm not working on the demos, but my modular groovebox project, there are a totally different set of constraints and pressures at work. Supriya is just one part of a much larger system, and getting the project to a prototype or, even better, some kind of MVP, is the main priority. Actually, most of my time is spent with vanilla Python, doing more typical software engineering architectural stuff. I also spend a lot of time with CircuitPython, coding how the microcontroller is reading the potentiomemters, buttons, switches, and converting those to MIDI messages, etc., and writing the logic for how the hardware modules communicate with the main module. The priority is getting something I can put into people's hands, so I can start getting some feedback/validation on the idea. Since this is a hardware unit, it takes a lot more time to get to that point because I can't throw together a minimal website with a few button and features, point potential customers to it, and ask what they think. So I haven't been digging into Supriya to figure out better ways to do things because what I have now is "good enough" for a prototype.

Hopefully I'm not laboring the point too much. I just wanted to explain my situation. My health issues are also making things worse because of some minor problems I've been dealing with after my first surgery. I've actually put my main project, the modular groovebox, on hold because I lack the energy and focus to work on it. I have a second surgery scheduled for a few weeks from now, and it's going to be much bigger and complicated than the first. I'll be spending 2 weeks recovering in the hospital, and then a few more weeks recovering at home. I can't do nothing while waiting for the second surgery, though. So I've been working on demo scripts, which are simpler than the modular groovebox, but my energy and ability to focus are still limited right now.

2. I think I'm confused on what you expect @synthdef and add_synth to do. @synthdef converts every argument into a float because that's the only value a Control UGen can have. Whereas add_synth (as defined in the official spec!) allows passing either a float or a string (where the string is the pattern [ac]\d+ and maps the new synth's parameter to a bus). I made the assumption - maybe wrong - that if you pass a Bus or BusGroup as an argument when instantiating a synth with add_synth() that you'd want to map it. But maybe I need to just enforce that we only accept floats or strings, and force the user to make the explicit choice. Do take a look at the source for @synthdef. It's just doing some pre-processing before turning the decorated function's arguments into SynthDef parameters via SynthDefBuilder's add_parameter: https://github.com/supriya-project/supriya/blob/main/supriya/ugens/core.py#L5967

However it's implemented under the hood, if you have something like this:

@synthdef()
def delay(
    in_bus: 2, 
    out_bus: 0
):
    signal = In.ar(bus=in_bus, channel_count=1)
    signal = CombL.ar(
        delay_time=0.2,
        decay_time=3.5,
        maximum_delay_time=0.2,
        source=signal
    )
    Out.ar(bus=out_bus, source=signal)

@synthdef()
def granular_synthesis_bass(
    amplitude=1.0,
    buffer_id=0,
    gate=1,
    grain_duration=1.0,
    grain_start=0.0,
    out_bus=0,
    rate=1,
    trigger_frequency=440,
) -> None:
    some UGens doing stuff
    ...
    Out.ar(bus=out_bus, source=signal)

@synthdef()
def reverb(
    in_bus=2,
    out_bus=0,
):
    signal = In.ar(bus=in_bus, channel_count=1)
    signal = FreeVerb.ar(source=signal, mix=0.65, room_size=0.55, damping=0.9)
    signal = Pan2.ar(source=signal)
    Out.ar(bus=out_bus, source=signal)


def main() -> None:
    ...
    server.add_synth(
        add_action=AddAction.ADD_TO_TAIL,
        in_bus=delay_bus, <- PASS THE BUS WITHOUT CASTING TO INT
        out_bus=int(reverb_bus),
        synthdef=delay,
    )
    
    server.add_synth(
        add_action=AddAction.ADD_TO_TAIL,
        in_bus=reverb_bus, <- PASS THE BUS WITHOUT CASTING TO INT
        out_bus=0, <- PASS THE BUS WITHOUT CASTING TO INT
        synthdef=reverb,
    )

    bass_pattern = EventPattern(
        ....
        out_bus=delay_bus, <- SYNTHDEF WILL AUTOMATICALLY CAST TO INT
        synthdef=granular_synthesis_bass,
    )

    ...
    bass_pattern.play(clock=clock, context=server)
    ...

and you dump the tree, you'll see this:

NODE TREE 0 group
    1 group
        1021 granular_synthesis_bass
            amplitude: 1.75, buffer_id: 0.0, gate: 1.0, grain_duration: 0.05, grain_start: 9.882, out_bus: 16.0, rate: 1.0, trigger_frequency: 46.249302
        1000 delay
            in_bus: a16, out_bus: 17.0
        1001 reverb
            in_bus: a17, out_bus: 0.0

You can see that the values of the in/out_bus arguments are mixed (16, 17, a16, a17). This breaks the buses, and no audio is output. The simple solution is to cast the buses to integers when creating the effects synths. So:

    server.add_synth(
        add_action=AddAction.ADD_TO_TAIL,
        in_bus=int(delay_bus), <- CAST THE BUS TO AN INT
        out_bus=int(reverb_bus),
        synthdef=delay,
    )
...

NODE TREE 0 group
    1 group
        1002 granular_synthesis_bass
            amplitude: 1.75, buffer_id: 0.0, gate: 1.0, grain_duration: 0.05, grain_start: 9.882, out_bus: 16.0, rate: 1.0, trigger_frequency: 36.708096
        1000 delay
            in_bus: 16.0, out_bus: 17.0
        1001 reverb
            in_bus: 17.0, out_bus: 0.0

Now the buses all have the same data type, and sound is output. This is all I was pointing out. I would expect that regardless of the underlying implementation, I would be able to pass a bus to a SynthDef or add_synth and it would work.

[josephine-wolf-oberholtzer]

OK, so we just need to make the way everything treats busses consistent? Is it safe to say that we just cast anything bus, bus group, buffer, buffer group to an int? And if people want to map a bus, we mandate that they use the map symbol string? I think that's reasonable.

[dayunbao]

That makes sense to me!

…

On Sat, May 31, 2025, 6:42 PM Joséphine Wolf Oberholtzer < ***@***.***> wrote: OK, so we just need to make the way everything treats busses consistent? Is it safe to say that we just cast anything bus, bus group, buffer, buffer group to an int? And if people want to map a bus, we mandate that they use the map symbol string? I think that's reasonable. — Reply to this email directly, view it on GitHub <#500 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ACVNNEU6MNZMA64465WISCT3BHLW7AVCNFSM6AAAAAB53XZPNCVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTGMZTGAYDCOI> . You are receiving this because you modified the open/close state.Message ID: ***@***.*** .com>

[josephine-wolf-oberholtzer]

I don't know if you're in a position to try out branches, but this PR changes Server.add_synth() to only accept floats and strings (or arrays of floats and strings): #501