add LFDNoise, Rand, Klank, DetectSilence. add Max and SoftClip methods to Input interface

Author: briansorahan

Makefile

@@ -2,7 +2,7 @@
 PLATFORM = $(shell uname -s)
 
 ifeq ($(PLATFORM),Darwin)
-SCLANG = /Applications/SuperCollider/SuperCollider.app/Contents//Resources/sclang
+SCLANG = /Applications/SuperCollider.app/Contents/MacOS/sclang
 endif
 
 ifeq ($(PLATFORM),Linux)
@@ -74,6 +74,8 @@ FIXTURES = fixtures/AllpassExample.scsyndef          \
 all:
 	@go install
 
+fixtures: $(FIXTURES)
+
 $(FIXTURES): fixtures/synthdefs.sc
 	@cd fixtures $(SCLANG) synthdefs.sc
 
@@ -85,9 +87,9 @@ coverage:
 	@go test -coverprofile cover.out && go tool cover -html cover.out -o cover.html
 
 clean:
-	@rm -rf *~ *.gosyndef *.svg *.dot *.json *.xml
+	@rm -rf *~ *.gosyndef *.svg *.dot *.json *.xml fixtures/*.scsyndef
 
 test: $(FIXTURES)
 	@go test
 
-.PHONY: all clean test
+.PHONY: all clean fixtures test

binop.go

@@ -1,5 +1,11 @@
 package sc
 
+// BinOpMax creates a BinaryOpUgen that represents the maximum of two signals.
+func BinOpMax(rate int8, x, y Input, numOutputs int) *UgenNode {
+	CheckRate(rate)
+	return NewUgenNode("BinaryOpUGen", rate, 13, numOutputs, x, y)
+}
+
 // BinOpMul creates a BinaryOpUGen that represents multiplication.
 func BinOpMul(rate int8, x, y Input, numOutputs int) *UgenNode {
 	CheckRate(rate)
@@ -16,3 +22,9 @@ func BinOpAdd(rate int8, x, y Input, numOutputs int) *UgenNode {
 func MulAdd(rate int8, in, mul, add Input, numOutputs int) *UgenNode {
 	return NewUgenNode("MulAdd", rate, 0, numOutputs, in, mul, add)
 }
+
+// BinOpSoftClip adds distortion to a ugen.
+func BinOpSoftClip(rate int8, in Input, numOutputs int) *UgenNode {
+	CheckRate(rate)
+	return NewUgenNode("BinaryOpUGen", rate, 43, numOutputs, in)
+}

c.go

@@ -3,6 +3,13 @@ package sc
 // C wraps a float32 and implements the Input interface.
 type C float32
 
+func (c C) Max(other Input) Input {
+	if v, ok := other.(C); ok {
+		return C(maxFloat32(float32(c), float32(v)))
+	}
+	return other.Max(c)
+}
+
 // Mul multiplies the constant by another input.
 func (c C) Mul(val Input) Input {
 	if v, ok := val.(C); ok {
@@ -29,3 +36,20 @@ func (c C) MulAdd(mul, add Input) Input {
 	}
 	return mul.MulAdd(c, add)
 }
+
+// SoftClip clips the constant to the range [-0.5, 0.5]
+func (c C) SoftClip() Input {
+	if float32(c) < -0.5 {
+		return C(-0.5)
+	} else if float32(c) > 0.5 {
+		return C(0.5)
+	}
+	return c
+}
+
+func maxFloat32(f1, f2 float32) float32 {
+	if f1 > f2 {
+		return f1
+	}
+	return f2
+}

control.go

@@ -37,6 +37,11 @@ func (ctl *Control) Add(val Input) Input {
 	return ctl
 }
 
+// Max computes the maximum of the Control and another UGen.
+func (ctl *Control) Max(other Input) Input {
+	return ctl
+}
+
 // Mul multiplies another input by the Control.
 func (ctl *Control) Mul(val Input) Input {
 	return ctl
@@ -47,6 +52,11 @@ func (ctl *Control) MulAdd(mul, add Input) Input {
 	return ctl
 }
 
+// SoftClip adds distortion to the Control.
+func (ctl *Control) SoftClip() Input {
+	return ctl
+}
+
 // NewControl creates a new Control.
 func NewControl(numOutputs int) Ugen {
 	outputs := make([]Output, numOutputs)

detect_silence.go

@@ -0,0 +1,29 @@
+package sc
+
+// DetectSilence evaluates Done when input falls below a certain threshold.
+type DetectSilence struct {
+	In   Input // The input signal.
+	Amp  Input // Amplitude threshold.
+	Time Input // The minimum duration for which amplitude must be below Amp before Done triggers.
+	Done int   // UGen done-action.
+}
+
+func (ds *DetectSilence) defaults() {
+	if ds.Amp == nil {
+		ds.Amp = C(0.0001)
+	}
+	if ds.Time == nil {
+		ds.Time = C(0.1)
+	}
+}
+
+// Rate creates a new ugen at a specific rate.
+// If rate is an unsupported value this method will cause a runtime panic.
+func (ds DetectSilence) Rate(rate int8) Input {
+	if ds.In == nil {
+		panic("DetectSilence expects In to not be nil")
+	}
+	CheckRate(rate)
+	(&ds).defaults()
+	return UgenInput("DetectSilence", rate, 0, 1, ds.In, ds.Amp, ds.Time)
+}

detectsilence_test.go

@@ -0,0 +1,32 @@
+package sc
+
+import "testing"
+
+func TestDetectSilence(t *testing.T) {
+	const name = "DetectTheSilence"
+
+	def := NewSynthdef(name, func(params Params) Ugen {
+		out := params.Add("out", 0)
+
+		sine := SinOsc{
+			Freq: Rand{
+				Lo: C(400),
+				Hi: C(700),
+			},
+		}.Rate(AR)
+		return Out{
+			Bus: out,
+			Channels: sine.Mul(LFDNoise{
+				Interpolation: InterpolationCubic,
+				Freq:          C(8),
+			}.Rate(KR)),
+		}.Rate(AR)
+	})
+	same, err := def.CompareToFile("fixtures/DetectSilence.scsyndef")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !same {
+		t.Fatalf("synthdef different from sclang version")
+	}
+}

fixtures/DetectSilence.scsyndef

@@ -327,23 +327,28 @@ SynthDef(\MixTest, {
 }).writeDefFile(File.getcwd);
 
 SynthDef(\THX, {
-var numVoices = 30;
-var fundamentals = ({rrand(200.0, 400.0)}!numVoices).sort;
-var finalPitches = (numVoices.collect({|nv| (nv/(numVoices/6)).round * 12; }) + 14.5).midicps;
-var sweepEnv = EnvGen.kr(Env([0, 0.1, 1], [5, 8], [2, 5]));
-var sig = Mix
-({|numTone|
+    var numVoices = 30;
+    var fundamentals = ({rrand(200.0, 400.0)}!numVoices).sort;
+    var finalPitches = (numVoices.collect({|nv| (nv/(numVoices/6)).round * 12; }) + 14.5).midicps;
+    var sweepEnv = EnvGen.kr(Env([0, 0.1, 1], [5, 8], [2, 5]));
+    var sig = Mix({ |numTone|
 	var initRandomFreq = fundamentals[numTone] + LFNoise2.kr(0.5, 3 * (numTone + 1));
 	var destinationFreq = finalPitches[numTone] + LFNoise2.kr(0.1, (numTone / 4));
 	var freq = ((1 - sweepEnv) * initRandomFreq) + (sweepEnv * destinationFreq);
-	Pan2.ar
-	(
+	Pan2.ar(
 		BLowPass.ar(Saw.ar(freq), freq * 8, 0.5),
 		rrand(-0.5, 0.5),
 		numVoices.reciprocal
 	)
-}!numVoices);
-Out.ar(0, sig);
+    }!numVoices);
+    Out.ar(0, sig);
+}).writeDefFile(File.getcwd);
+
+SynthDef(\DetectSilence, { arg out;
+    var z;
+    z = SinOsc.ar(Rand(400, 700), 0, LFDNoise3.kr(8).max(0)).softclip * 0.3;
+    DetectSilence.ar(z, doneAction:2);
+    Out.ar(out, z);
 }).writeDefFile(File.getcwd);
 
 0.exit;