func main() { const synthName = "Balance2Example" client, err := sc.NewClient("udp", "127.0.0.1:57110", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { bus, gain := sc.C(0), sc.C(0.1) l, r := sc.LFSaw{Freq: sc.C(44)}.Rate(sc.AR), sc.Pulse{Freq: sc.C(33)}.Rate(sc.AR) pos := sc.SinOsc{Freq: sc.C(0.5)}.Rate(sc.KR) sig := sc.Balance2{L: l, R: r, Pos: pos, Level: gain}.Rate(sc.AR) return sc.Out{bus, sig}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } synthID := client.NextSynthID() if _, err := defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil); err != nil { log.Fatal(err) } log.Printf("created synth %d\n", synthID) }
func main() { const synthName = "BRFExample" client, err := sc.NewClient("udp", "127.0.0.1:57110", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { line := sc.XLine{sc.C(0.7), sc.C(300), sc.C(20), 0}.Rate(sc.KR) saw := sc.Saw{sc.C(200)}.Rate(sc.AR).Mul(sc.C(0.5)) sine := sc.SinOsc{line, sc.C(0)}.Rate(sc.KR).MulAdd(sc.C(3800), sc.C(4000)) bpf := sc.BRF{saw, sine, sc.C(0.3)}.Rate(sc.AR) return sc.Out{sc.C(0), bpf}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } synthID := client.NextSynthID() if _, err := defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil); err != nil { log.Fatal(err) } log.Printf("created synth %d\n", synthID) }
func main() { const synthName = "sc.LFPulseExample" client, err := sc.NewClient("udp", "127.0.0.1:57112", "127.0.0.1:57110", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { lfoFreq, lfoPhase, lfoWidth := sc.C(3), sc.C(0), sc.C(0.3) bus, gain := sc.C(0), sc.C(0.1) freq := sc.LFPulse{lfoFreq, lfoPhase, lfoWidth}.Rate(sc.KR).MulAdd(sc.C(200), sc.C(200)) iphase, width := sc.C(0), sc.C(0.2) sig := sc.LFPulse{freq, iphase, width}.Rate(sc.AR).Mul(gain) return sc.Out{bus, sig}.Rate(sc.AR) }) err = client.SendDef(def) if err != nil { log.Fatal(err) } synthID := client.NextSynthID() _, err = defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil) log.Printf("created synth %d\n", synthID) }
func main() { // create a client and connect to the server client, err := sc.NewClient("udp", "127.0.0.1:57121", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } // create a synthdef def := sc.NewSynthdef("Envgen1", func(p sc.Params) sc.Ugen { bus := sc.C(0) attack, release := sc.C(0.01), sc.C(1) level, curveature := sc.C(1), sc.C(-4) perc := sc.EnvPerc{attack, release, level, curveature} gate, levelScale, levelBias, timeScale := sc.C(1), sc.C(1), sc.C(0), sc.C(1) ampEnv := sc.EnvGen{perc, gate, levelScale, levelBias, timeScale, sc.FreeEnclosing}.Rate(sc.KR) noise := sc.PinkNoise{}.Rate(sc.AR).Mul(ampEnv) return sc.Out{bus, noise}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } time.Sleep(1000 * time.Millisecond) id := client.NextSynthID() if _, err = client.Synth("Envgen1", id, sc.AddToTail, sc.DefaultGroupID, nil); err != nil { log.Fatal(err) } time.Sleep(5000 * time.Millisecond) }
func main() { const synthName = "FSinOscExample" client, err := sc.NewClient("udp", "127.0.0.1:57110", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { bus := sc.C(0) line := sc.XLine{sc.C(4), sc.C(401), sc.C(8), 0}.Rate(sc.KR) sin1 := sc.SinOsc{line, sc.C(0)}.Rate(sc.AR).MulAdd(sc.C(200), sc.C(800)) sin2 := sc.SinOsc{Freq: sin1}.Rate(sc.AR).Mul(sc.C(0.2)) return sc.Out{bus, sin2}.Rate(sc.AR) }) err = client.SendDef(def) if err != nil { log.Fatal(err) } synthID := client.NextSynthID() _, err = defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil) log.Printf("created synth %d\n", synthID) }
func main() { const synthName = "Decay2Example" client, err := sc.NewClient("udp", "127.0.0.1:57110", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { bus := sc.C(0) line := sc.XLine{Start: sc.C(1), End: sc.C(50), Dur: sc.C(20)}.Rate(sc.KR) pulse := sc.Impulse{Freq: line, Phase: sc.C(0.25)}.Rate(sc.AR) sig := sc.Decay2{In: pulse, Attack: sc.C(0.01), Decay: sc.C(0.2)}.Rate(sc.AR) gain := sc.SinOsc{Freq: sc.C(600)}.Rate(sc.AR) return sc.Out{bus, sig.Mul(gain)}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } synthID := client.NextSynthID() if _, err := defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil); err != nil { log.Fatal(err) } }
func main() { const synthName = "playbufExample" const wavFile = "kalimba_mono.wav" var synthID int32 var speed, gain float32 // setup supercollider client client, err := sc.NewClient("udp", "127.0.0.1:57110", "127.0.0.1:57120", 5*time.Second) if err != nil { panic(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { panic(err) } // read a wav file buf, err := client.ReadBuffer(wavFile, 1) if err != nil { panic(err) } // send a synthdef def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { speed := p.Add("speed", 1.0) gain := p.Add("gain", 0.5) bus := sc.C(0) sig := sc.PlayBuf{ NumChannels: 1, BufNum: sc.C(float32(buf.Num)), Speed: speed, Done: sc.FreeEnclosing, }.Rate(sc.AR).Mul(gain) return sc.Out{bus, sig}.Rate(sc.AR) }) err = client.SendDef(def) if err != nil { panic(err) } ticker := time.NewTicker(125 * time.Millisecond) for _ = range ticker.C { synthID = client.NextSynthID() speed = (float32(8.0) * rand.Float32()) + float32(0.5) gain = rand.Float32() ctls := map[string]float32{"speed": speed, "gain": gain} _, err = defaultGroup.Synth(synthName, synthID, sc.AddToTail, ctls) } }
func main() { const synthName = "COscExample" client, err := sc.NewClient("udp", "127.0.0.1:57110", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } buf, err := client.AllocBuffer(512, 1) if err != nil { log.Fatal(err) } var ( bufRoutine = sc.BufferRoutineSine1 bufFlags = sc.BufferFlagNormalize | sc.BufferFlagWavetable | sc.BufferFlagClear partials = []float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} ) for i, p := range partials { partials[i] = 1 / p } if err := buf.Gen(bufRoutine, bufFlags, partials...); err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { bus, gain := sc.C(0), sc.C(0.25) freq, beats := sc.C(200), sc.C(0.7) sig := sc.COsc{ BufNum: sc.C(float32(buf.Num)), Freq: freq, Beats: beats, }.Rate(sc.AR) return sc.Out{bus, sig.Mul(gain)}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } synthID := client.NextSynthID() if _, err := defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil); err != nil { log.Fatal(err) } }
func main() { const synthName = "sc.LFCubExample" client, err := sc.NewClient("udp", "127.0.0.1:57110", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { bus, gain := sc.C(0), sc.C(0.1) lfo1 := sc.LFCub{Freq: sc.C(0.2)}.Rate(sc.KR).MulAdd(sc.C(8), sc.C(10)) lfo2 := sc.LFCub{Freq: lfo1}.Rate(sc.KR).MulAdd(sc.C(400), sc.C(800)) sig := sc.LFCub{Freq: lfo2}.Rate(sc.AR).Mul(gain) return sc.Out{bus, sig}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } synthID := client.NextSynthID() if _, err := defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil); err != nil { log.Fatal(err) } log.Printf("created synth %d\n", synthID) }
func main() { const synthName = "FreeVerbExample" client, err := sc.NewClient("udp", "127.0.0.1:57110", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { mix := p.Add("mix", 0.25) room := p.Add("room", 0.15) damp := p.Add("damp", 0.5) bus := sc.C(0) impulse := sc.Impulse{Freq: sc.C(1)}.Rate(sc.AR) lfcub := sc.LFCub{Freq: sc.C(1200), Iphase: sc.C(0)}.Rate(sc.AR).Mul(sc.C(0.1)) decay := sc.Decay{In: impulse, Decay: sc.C(0.25)}.Rate(sc.AR).Mul(lfcub) sig := sc.FreeVerb{In: decay, Mix: mix, Room: room, Damp: damp}.Rate(sc.AR) return sc.Out{bus, sig}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } synthID := client.NextSynthID() if _, err := defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil); err != nil { log.Fatal(err) } log.Printf("created synth %d\n", synthID) }
func main() { const synthName = "DelayCExample" client, err := sc.NewClient("udp", "127.0.0.1:57112", "127.0.0.1:57110", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { bus, dust := sc.C(0), sc.Dust{Density: sc.C(1)}.Rate(sc.AR).Mul(sc.C(0.5)) noise := sc.WhiteNoise{}.Rate(sc.AR) decay := sc.Decay{In: dust, Decay: sc.C(0.3)}.Rate(sc.AR).Mul(noise) sig := sc.Delay{ Interpolation: sc.InterpolationCubic, In: decay, MaxDelayTime: sc.C(0.2), DelayTime: sc.C(0.2), }.Rate(sc.AR).Add(decay) return sc.Out{bus, sig}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } synthID := client.NextSynthID() if _, err = defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil); err != nil { log.Fatal(err) } log.Printf("created synth %d\n", synthID) }
func main() { const synthName = "sineTone" var synthID int32 var note int var gain, dur float32 // setup supercollider client client, err := sc.NewClient("udp", "127.0.0.1:57111", "127.0.0.1:57110", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } err = client.DumpOSC(int32(1)) if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { freq := p.Add("freq", 440) gain := p.Add("gain", 0.5) dur := p.Add("dur", 1) bus := sc.C(0) env := sc.EnvGen{ Env: sc.EnvPerc{Release: dur}, LevelScale: gain, Done: sc.FreeEnclosing, }.Rate(sc.KR) sig := sc.SinOsc{Freq: freq}.Rate(sc.AR).Mul(env) return sc.Out{bus, sig}.Rate(sc.AR) }) err = client.SendDef(def) if err != nil { log.Fatal(err) } ticker := time.NewTicker(125 * time.Millisecond) for _ = range ticker.C { synthID = client.NextSynthID() note = rand.Intn(128) gain = rand.Float32() dur = rand.Float32() ctls := map[string]float32{ "freq": sc.Midicps(float32(note)), "gain": gain, "dur": dur, } _, err = defaultGroup.Synth(synthName, synthID, sc.AddToTail, ctls) } }
func main() { // create a client and connect to the server client, err := sc.NewClient("udp", "127.0.0.1:57121", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } def := sc.NewSynthdef("SineTone", func(p sc.Params) sc.Ugen { bus, chaos := sc.C(0), sc.Line{sc.C(1.0), sc.C(2.0), sc.C(10), sc.DoNothing}.Rate(sc.KR) sig := sc.Crackle{chaos}.Rate(sc.AR).MulAdd(sc.C(0.5), sc.C(0.5)) return sc.Out{bus, sig}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } id := client.NextSynthID() if _, err = client.Synth("SineTone", id, sc.AddToTail, sc.DefaultGroupID, nil); err != nil { log.Fatal(err) } }
func main() { const synthName = "CombCExample" client, err := sc.NewClient("udp", "127.0.0.1:57110", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { bus := sc.C(0) line := sc.XLine{ Start: sc.C(0.0001), End: sc.C(0.01), Dur: sc.C(20), }.Rate(sc.KR) sig := sc.Comb{ Interpolation: sc.InterpolationCubic, In: sc.WhiteNoise{}.Rate(sc.AR).Mul(sc.C(0.01)), MaxDelayTime: sc.C(0.01), DelayTime: line, DecayTime: sc.C(0.2), }.Rate(sc.AR) return sc.Out{bus, sig}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } synthID := client.NextSynthID() if _, err := defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil); err != nil { log.Fatal(err) } }
func main() { const ( synthName = "GrainFMExample" ) server := &sc.Server{ Network: "udp", Port: 57120, } stdout, stderr, err := server.Start(5 * time.Second) if err != nil { log.Fatalf("Could not start scsynth: %s", err) } defer func() { _ = server.Process.Kill() }() go func() { if _, err := io.Copy(os.Stderr, stderr); err != nil { log.Fatalf("Could not pipe scsynth stderr to terminal: %s", err) } }() go func() { if _, err := io.Copy(os.Stdout, stdout); err != nil { log.Fatalf("Could not pipe scsynth stdout to terminal: %s", err) } }() client, err := sc.NewClient("udp", "127.0.0.1:57110", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { var ( gate = p.Add("gate", 1) amp = p.Add("amp", 1) bus = sc.C(0) mousey = sc.MouseY{Min: sc.C(0), Max: sc.C(400)}.Rate(sc.KR) freqdev = sc.WhiteNoise{}.Rate(sc.KR).Mul(mousey) ) env := sc.Env{ Levels: []sc.Input{sc.C(0), sc.C(1), sc.C(0)}, Times: []sc.Input{sc.C(1), sc.C(1)}, Curve: []string{"sine", "sine"}, ReleaseNode: sc.C(1), } ampenv := sc.EnvGen{ Env: env, Gate: gate, LevelScale: amp, Done: sc.FreeEnclosing, }.Rate(sc.KR) var ( trigFreq = sc.MouseY{Min: sc.C(8), Max: sc.C(64)}.Rate(sc.KR) trig = sc.Impulse{Freq: trigFreq}.Rate(sc.KR) modIndex = sc.LFNoise{Interpolation: sc.NoiseLinear}.Rate(sc.KR).MulAdd(sc.C(5), sc.C(5)) pan = sc.MouseX{Min: sc.C(-1), Max: sc.C(1)}.Rate(sc.KR) ) sig := sc.GrainFM{ NumChannels: 2, Trigger: trig, Dur: sc.C(0.1), CarFreq: sc.C(440), ModFreq: sc.C(200).Add(freqdev), ModIndex: modIndex, Pan: pan, }.Rate(sc.AR) return sc.Out{bus, sig.Mul(ampenv)}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } synthID := client.NextSynthID() if _, err := defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil); err != nil { log.Fatal(err) } if err := server.Wait(); err != nil { log.Fatal(err) } }
package main import "github.com/scgolang/sc" const ( defName = "pattern_examples_rand" ) var def = sc.NewSynthdef(defName, func(p sc.Params) sc.Ugen { // Controls var ( bus = sc.C(0) gate, freq = p.Add("gate", 1), p.Add("freq", 440) gain, release = p.Add("gain", 1), p.Add("release", 0.2) timbre = p.Add("timbre", 0) ) envgen := sc.EnvGen{ Env: sc.EnvPerc{Release: release}, Gate: gate, LevelScale: gain, Done: sc.FreeEnclosing, }.Rate(sc.KR) // Oscillators var ( sine = sc.SinOsc{Freq: freq}.Rate(sc.AR) blip = sc.Blip{Freq: freq}.Rate(sc.AR) saw = sc.Saw{Freq: freq}.Rate(sc.AR) ) sig := sc.Select{ Which: timbre,
func main() { const synthName = "FormletExample" client, err := sc.NewClient("udp", "127.0.0.1:57110", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } defaultGroup, err := client.AddDefaultGroup() if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { bus, sine := sc.C(0), sc.SinOsc{Freq: sc.C(5)}.Rate(sc.KR).MulAdd(sc.C(20), sc.C(300)) blip := sc.Blip{Freq: sine, Harm: sc.C(1000)}.Rate(sc.AR).Mul(sc.C(0.1)) line := sc.XLine{Start: sc.C(1500), End: sc.C(700), Dur: sc.C(8)}.Rate(sc.KR) sig := sc.Formlet{ In: blip, Freq: line, AttackTime: sc.C(0.005), DecayTime: sc.C(0.4), }.Rate(sc.AR) return sc.Out{bus, sig}.Rate(sc.AR) }) if err := client.SendDef(def); err != nil { log.Fatal(err) } synthID := client.NextSynthID() if _, err := defaultGroup.Synth(synthName, synthID, sc.AddToTail, nil); err != nil { log.Fatal(err) } log.Printf("created synth %d\n", synthID) }
func main() { var synthID int32 const synthName = "sineTone" // Set up SuperCollider client. client, err := sc.NewClient("udp", "127.0.0.1:57121", "127.0.0.1:57120", 5*time.Second) if err != nil { log.Fatal(err) } _, err = client.AddDefaultGroup() if err != nil { log.Fatal(err) } err = client.DumpOSC(int32(1)) if err != nil { log.Fatal(err) } def := sc.NewSynthdef(synthName, func(p sc.Params) sc.Ugen { freq := p.Add("freq", 440) gain := p.Add("gain", 0.5) bus := sc.C(0) env := sc.EnvGen{ Env: sc.EnvPerc{}, Done: sc.FreeEnclosing, LevelScale: gain, }.Rate(sc.KR) sig := sc.SinOsc{Freq: freq}.Rate(sc.AR).Mul(env) return sc.Out{bus, sig}.Rate(sc.AR) }) err = client.SendDef(def) if err != nil { log.Fatal(err) } // initialize midi portmidi.Initialize() // this code can be uncommented to discover the // device ID's portmidi comes up with // deviceCount := portmidi.CountDevices() // enc := json.NewEncoder(os.Stdout) // for i := 0; i < deviceCount; i++ { // info := portmidi.GetDeviceInfo(portmidi.DeviceId(i)) // log.Printf("device %d - ", i) // err = enc.Encode(info) // if err != nil { // log.Fatal(err) // } // } // setup midi input stream and listen for midi events in, err := portmidi.NewInputStream(3, 1024) if err != nil { log.Fatal(err) } ch := in.Listen() for event := range ch { if event.Status == 144 { // MIDI note log.Printf("Note %-3d Velocity %-3d\n", event.Data1, event.Data2) if event.Data2 > 0 { // Note On synthID = client.NextSynthID() ctls := map[string]float32{ "freq": sc.Midicps(float32(event.Data1)), "gain": float32(event.Data2 / 127.0), } _, err = client.Synth(synthName, synthID, sc.AddToTail, sc.DefaultGroupID, ctls) } } } portmidi.Terminate() }
package main import ( "fmt" "github.com/scgolang/sc" ) var synthdefs = map[string]sc.UgenFunc{ "dx7_algo1": func(p sc.Params) sc.Ugen { gate, bus := p.Add("gate", 1), sc.C(0) op6 := NewOperator(6, p, gate, nil) op5 := NewOperator(5, p, gate, op6) op4 := NewOperator(4, p, gate, op5) op3 := NewOperator(3, p, gate, op4) op2 := NewOperator(2, p, gate, nil) op1 := NewOperator(1, p, gate, op2) sig := op1.Add(op3) sig = sc.Multi(sig, sig) return sc.Out{Bus: bus, Channels: sig}.Rate(sc.AR) }, "dx7_algo3": func(p sc.Params) sc.Ugen { gate, bus := p.Add("gate", 1), sc.C(0) op6 := NewOperator(6, p, gate, nil) op5 := NewOperator(5, p, gate, op6) op4 := NewOperator(4, p, gate, op5) op3 := NewOperator(3, p, gate, nil) op2 := NewOperator(2, p, gate, op3) op1 := NewOperator(1, p, gate, op2) sig := op1.Add(op4) sig = sc.Multi(sig, sig)