Getting Vivid to work with Tidal and SuperDirt

[jarmitage]

I tried to get Vivid and Tidal + SuperDirt working together based on this post:

http://lurk.org/groups/haskell-art/messages/topic/46bqOK1iOsiMy0fgOWMZa4

import Vivid

let (freq,_) = pI "freq" (Just 440)

defineSD $ sdNamed "foooo" () $ do
   s <- sinOsc (freq_ 440)
   out 0 [s, s]

d1 $ sound "foooo" # freq "400"

But it's not recognised by SuperDirt:

no synth or sample named 'foooo' could be found.
instrument not found: nil
[ "#bundle", 15955788339759360291, 
  [ 12, 1003, 1 ],
  [ 12, 1002, 1 ],
  [ "/g_new", 1103, 1, 2 ],
  [ "/s_new", "dirt_gate2", -1, 1, 1103, "in", 18, "out", 20, "amp", 0.4, "sample", 0, "sustain", 0.999, "fadeInTime", 0, "fadeTime", 0.001 ]
]

Most SuperDirt synths have this kind of format:

(
SynthDef(\foo, { |out, freq = 440|
	blah blah blah
	OffsetOut.ar(out, DirtPan.ar(sound, ~dirt.numChannels, pan, env))
}).add
);

So maybe it's the difference in output destination that's causing the issue?

Would love to get this to work! Thanks for making Vivid.

[telephon]

There are two issues:

1. you need to register the SynthDef name in supercollider. This you can do by writing:

~dirt.addSynth(\foooo)

2. you need to keep with the channel mapping conventions to make it work properly. The minimum is that the out parameter needs to be left open. In vivid that would probably be:

defineSD $ sdNamed "foooo" () $ do
   s <- sinOsc (freq_ 440)
   o <- out_ 0
   out o [s, s]

The panning is another thing, but let's see if that works for you.

[jarmitage]

For this:

defineSD $ sdNamed "foooo" () $ do
   s <- sinOsc (freq_ 440)
   o <- out_ 0
   out o [s, s]

I get out_ not in scope error.

If I do

defineSD $ sdNamed "foooo" () $ do
   s <- sinOsc (freq_ 440)
   out 0 [s, s]

And then ~dirt.addSynth(\foooo), I get ERROR: Message 'addSynth' not understood

[telephon]

ok, I don't know how vivid works: all you need is a synth that has a control name called out.

If addSynth is not understood, then could you please also write who didn't understand it? The receiver is what? nil or SuperDirt?

[vivid-synth]

@telephon can you point to where addSynth is defined? I can't find it in the source for SuperDirt or supercollider.

@jarmitage to solve the first half of the problem (making "out" be an argument instead of a hardcoded 0), you'd say:

defineSD $ sdNamed "foooo" (0 ::I "out") $ do
   s <- sinOsc (freq_ 440)
   out (V::V "out") [s, s]

[telephon]

It's in DirtSoundLibrary the 1.0-dev branch: https://github.com/musikinformatik/SuperDirt/blob/1.0-dev/classes/DirtSoundLibrary.sc#L50

[vivid-synth]

@telephon I'm very close to getting this working but still hitting an issue.

My boot.scd file:

Server.supernova;
s.options.numBuffers = 1024 * 16;

s.waitForBoot{
Routine{
include("Vowel");
include("SuperDirt");
2.wait;

~dirt = SuperDirt.start;

5.wait;
postln(~dirt.soundLibrary);

// This seems to work!:
~dirt.soundLibrary.addSynth(\foo4);

}.play
}

(I then boot with sclang boot.scd)

I then open test.tidal in emacs and evaluate each line:

d1 $ sound "~ bd"

:set -XDataKinds
import Vivid

-- This is just on one line so we can easily eval it:
let s' = sdNamed "foo4" (0::I "out") $ do { s <- sinOsc (freq_ 440) ~* percGen none ~* 0.1 ; out (V::V "out") [s,s] } :: SynthDef '["out"]

defineSD s'

-- Neither of these lines work:
d2 $ s "foo4"
d2 $ sound "foo4"

The SynthDef is defined properly: I can open ghci and call synthNamed "foo4" () and hear a sound.

The complete error SuperDirt gives is:

ERROR: Message 'flop' not understood.
RECEIVER:
   nil
ARGS:

PROTECTED CALL STACK:
        Meta_MethodError:new    0x114e2c0
                arg this = DoesNotUnderstandError
                arg what = nil
                arg receiver = nil
        Meta_DoesNotUnderstandError:new 0x1150280
                arg this = DoesNotUnderstandError
                arg receiver = nil
                arg selector = flop
                arg args = [  ]
        Object:doesNotUnderstand        0xdd3cc0
                arg this = nil
                arg selector = flop
                arg args = nil
        DirtEvent:sendSynth     0x110b940
                arg this = a DirtEvent
                arg instrument = foo4
                arg args = nil
                var group = 1037
        DirtModule:value        0x1e5bac0
                arg this = DirtModule('sound')
                arg orbit = a DirtEvent
        ArrayedCollection:do    0x1c15f00
                arg this = [ DirtModule('sound'), DirtModule('vowel'), DirtModule('shape'), DirtModule('hpf'), DirtModule('bpf'), DirtModule('crush'), DirtModule('coarse'), DirtModule('lpf'), DirtModule('envelope'), DirtModule('tremolo'), DirtModule('phaser') ]
                arg function = a Function
                var i = 0
        a FunctionDef   0x110d400
                sourceCode = "<an open Function>"
        a FunctionDef   0x1d737c0
                sourceCode = "<an open Function>"
        Function:prTry  0x123e400
                arg this = a Function
                var result = nil
                var thread = a Thread
                var next = a Function
                var wasInProtectedFunc = true
        Function:try    0x123dec0
                arg this = a Function
                arg handler = a Function
                var result = nil
        Server:makeBundle       0x1d73400
                arg this = localhost
                arg time = 0.29827090190248
                arg func = a Function
                arg bundle = nil
        DirtEvent:playSynths    0x110cec0
                arg this = a DirtEvent
                var cutGroup = nil
        a FunctionDef   0x1cb2300
                sourceCode = "<an open Function>"
        Function:prTry  0x123e400
                arg this = a Function
                var result = nil
                var thread = a Thread
                var next = nil
                var wasInProtectedFunc = false

CALL STACK:
        DoesNotUnderstandError:reportError   0x2a58b28
                arg this = <instance of DoesNotUnderstandError>
        Nil:handleError   0xf3de18
                arg this = nil
                arg error = <instance of DoesNotUnderstandError>
        Thread:handleError   0x25c9cf8
                arg this = <instance of Thread>
                arg error = <instance of DoesNotUnderstandError>
        Object:throw   0x2209c88
                arg this = <instance of DoesNotUnderstandError>
        Function:protect   0x2a4bc38
                arg this = <instance of Function>
                arg handler = <instance of Function>
                var result = <instance of DoesNotUnderstandError>
        Environment:use   0x32531f8
                arg this = <instance of Event>
                arg function = <instance of Function>
                var result = nil
                var saveEnvir = <instance of Environment>
        DirtEvent:play   0x2a4c5d8
                arg this = <instance of DirtEvent>
        OSCFuncBothMessageMatcher:value   0x3254208
                arg this = <instance of OSCFuncBothMessageMatcher>
                arg msg = [*9]
                arg time = 26.947354181902
                arg testAddr = <instance of NetAddr>
                arg testRecvPort = 57120
        OSCMessageDispatcher:value   0x3251d98
                arg this = <instance of OSCMessageDispatcher>
                arg msg = [*9]
                arg time = 26.947354181902
                arg addr = <instance of NetAddr>
                arg recvPort = 57120
        Main:recvOSCmessage   0x3250128
                arg this = <instance of Main>
                arg time = 26.947354181902
                arg replyAddr = <instance of NetAddr>
                arg recvPort = 57120
                arg msg = [*9]
^^ The preceding error dump is for ERROR: Message 'flop' not understood.
RECEIVER: nil

[vivid-synth]

It at least appears that SuperDirt depends on some sclang-based registry of SynthDefs.

If I add this to the end of the boot.scd file:

SynthDef(\foo4, {|out=0|
   Out.ar(out, DC.ar(0))
}).add;

(I.e. I add a totally empty SynthDef, so that sclang knows there's something defined with that name)

...and then I run all the stuff above, things work as expected (I'm able to re-define the SynthDef in Haskell to my heart's content).

So @jarmitage here's your answer for now, although I'd love to know (cc @telephon @yaxu ) if there's a way to do this more cleanly.

[vivid-synth]

PS: by "at the end of the boot.scd file" I mean after everything except the final:

}.play
}

[telephon]

Yes, we currently assume that your SynthDef is registered in the SynthDescLibrary, so that we know which arguments it takes.

What you can do is just modify your default sound module. You can even do this on the fly and play around with it.

Please note that you may need the 1.0-dev-branch for it. You should be able to install it via the GUI or directly via git checkout 1.0-dev (in your SuperDirt quark folder).

(
var argNames = [\out];
~dirt.addModule('sound',
	{ |dirtEvent|
		if(~diversion.value.isNil) {
			if(~buffer.notNil) {
				// argumets could be omitted using getMsgFunc, but for making it easier to understand, we write them out
				dirtEvent.sendSynth(~instrument,  [
					bufnum: ~buffer,
					sustain: ~sustain,
					speed: ~speed,
					endSpeed: ~endSpeed,
					begin: ~begin,
					end: ~end,
					loop: ~loop,
					pan: ~pan,
					out: ~out
				])
			} {
				if(~instrument.isNil) {
					"instrument not found: %".format(~sound).postln
				} {
					// here, we just derive the arguments as necessary from the environment
					dirtEvent.sendSynth(~instrument, argNames)
				}
			}
		}
});
)

Much better is this, I'll also add this to superdirt. I haven't tested this, so let us know if it works.

(
~dirt.addModule('sound',
	{ |dirtEvent|
		if(~diversion.value.isNil) {
			if(~buffer.notNil) {
				// argumets could be omitted using getMsgFunc, but for making it easier to understand, we write them out
				dirtEvent.sendSynth(~instrument,  [
					bufnum: ~buffer,
					sustain: ~sustain,
					speed: ~speed,
					endSpeed: ~endSpeed,
					begin: ~begin,
					end: ~end,
					loop: ~loop,
					pan: ~pan,
					out: ~out
				])
			} {
				if(~instrument.isNil) {
					"instrument not found: %".format(~sound).postln
				} {
					// here, we just derive the arguments as necessary from the environment
					dirtEvent.sendSynth(~instrument, ~argNames)
				}
			}
		}
});
)

// then add your synth arguments for each synth separately:

~dirt.soundLibrary.addEvent(\foo4, (argNames: [\out]));

[vivid-synth]

@telephon I tried those two code snippets (on the 1.0-dev branch), but neither worked -- in fact, they wouldn't play samples either.

[telephon]

Can you describe? Did they post any error message? Have you tried adding a postln to see if the function is called?

[jarmitage]

Thanks @vivid-synth I'm going to try the workaround and will post any results here...

[jarmitage]

My startup.scd looks a bit different to yours @vivid-synth, so I just tried running:

SynthDef(\foo4, {|out=0|
	Out.ar(out, DC.ar(0))
}).add;

~dirt.soundLibrary.addSynth(\foo4);

After SuperDirt had launched, and got:

ERROR: tried to add Nil to synth event library
CALL STACK:
	Exception:reportError   0x118e11058
		arg this = <instance of Error>
	Nil:handleError   0x118e11688
		arg this = nil
		arg error = <instance of Error>
	Thread:handleError   0x118e11528
		arg this = <instance of Thread>
		arg error = <instance of Error>
	Object:throw   0x118e11898
		arg this = <instance of Error>
	DirtSoundLibrary:addSynth   0x1189cd5f8
		arg this = <instance of DirtSoundLibrary>
		arg name = 'foo4'
		arg event = nil
		arg appendToExisting = true
	Interpreter:interpretPrintCmdLine   0x1189cb978
		arg this = <instance of Interpreter>
		var res = nil
		var func = <instance of Function>
		var code = "~dirt.soundLibrary.addSynth(..."
		var doc = nil
		var ideClass = <instance of Meta_ScIDE>
	Process:interpretPrintCmdLine   0x118e11e18
		arg this = <instance of Main>
^^ The preceding error dump is for ERROR: tried to add Nil to synth event library

I'm on the SuperDirt 1.0-dev branch.

[telephon]

maybe you could instead try the code I suggested above?