Пример #1
0
def test_SynthDefDecompiler_08():
    r'''Multiple parameters with different lags.'''
    builder = synthdeftools.SynthDefBuilder(
        amp=0.5,
        freqs=synthdeftools.Parameter(
            lag=0.5,
            value=[300, 400],
        ),
    )
    with builder:
        sines = ugentools.SinOsc.ar(frequency=builder['freqs'], )
        sines = ugentools.Mix.new(sines)
        sines = sines * builder['amp']
        ugentools.Out.ar(
            bus=0,
            source=sines,
        )
    old_synthdef = builder.build('arrayarg')
    compiled_synthdef = old_synthdef.compile()
    new_synthdef = decompiler.decompile_synthdef(compiled_synthdef)
    assert str(old_synthdef) == str(new_synthdef)
    assert old_synthdef.indexed_parameters == new_synthdef.indexed_parameters
    assert compiled_synthdef == new_synthdef.compile()
    assert old_synthdef.anonymous_name == new_synthdef.anonymous_name
    assert old_synthdef.name == new_synthdef.name
Пример #2
0
 def _decode_parameters(value, index):
     from supriya.tools import synthdeftools
     sdd = SynthDefDecompiler
     parameter_values = []
     parameter_count, index = sdd._decode_int_32bit(value, index)
     for _ in range(parameter_count):
         parameter_value, index = sdd._decode_float(value, index)
         parameter_values.append(parameter_value)
     parameter_count, index = sdd._decode_int_32bit(value, index)
     parameter_names = []
     parameter_indices = []
     for _ in range(parameter_count):
         parameter_name, index = sdd._decode_string(value, index)
         parameter_index, index = sdd._decode_int_32bit(value, index)
         parameter_names.append(parameter_name)
         parameter_indices.append(parameter_index)
     indexed_parameters = []
     if parameter_count:
         pairs = tuple(zip(parameter_indices, parameter_names))
         pairs = sorted(pairs, key=lambda x: x[0])
         iterator = sequencetools.iterate_sequence_nwise(pairs)
         for (index_one, name_one), (index_two, name_two) in iterator:
             value = parameter_values[index_one:index_two]
             if len(value) == 1:
                 value = value[0]
             parameter = synthdeftools.Parameter(
                 name=name_one,
                 value=value,
             )
             indexed_parameters.append((index_one, parameter))
         index_one, name_one = pairs[-1]
         value = parameter_values[index_one:]
         if len(value) == 1:
             value = value[0]
         parameter = synthdeftools.Parameter(
             name=name_one,
             value=value,
         )
         indexed_parameters.append((index_one, parameter))
         indexed_parameters.sort(
             key=lambda x: parameter_names.index(x[1].name), )
     indexed_parameters = collections.OrderedDict(indexed_parameters)
     return indexed_parameters, index
Пример #3
0
 def add_parameter(self, *args):
     from supriya.tools import synthdeftools
     if 3 < len(args):
         raise ValueError(args)
     if len(args) == 1:
         assert isinstance(args[0], synthdeftools.Parameter)
         name, value, parameter_rate = \
             args[0].name, args[0], args[0].parameter_rate
     elif len(args) == 2:
         name, value = args
         if not isinstance(value, synthdeftools.Parameter):
             parameter_rate = synthdeftools.ParameterRate.SCALAR
             if name.startswith('a_'):
                 parameter_rate = synthdeftools.ParameterRate.AUDIO
             elif name.startswith('i_'):
                 parameter_rate = synthdeftools.ParameterRate.SCALAR
             elif name.startswith('t_'):
                 parameter_rate = synthdeftools.ParameterRate.TRIGGER
             else:
                 parameter_rate = synthdeftools.ParameterRate.CONTROL
         else:
             parameter_rate = value.parameter_rate
     elif len(args) == 3:
         name, value, parameter_rate = args
         parameter_rate = synthdeftools.ParameterRate.from_expr(
             parameter_rate, )
     else:
         raise ValueError(args)
     if not isinstance(value, synthdeftools.Parameter):
         parameter = synthdeftools.Parameter(
             name=name,
             parameter_rate=parameter_rate,
             value=value,
         )
     else:
         parameter = new(
             value,
             parameter_rate=parameter_rate,
             name=name,
         )
     self._parameters[name] = parameter
     return parameter
Пример #4
0
 def __init__(
     self,
     parameters,
     calculation_rate=None,
     starting_control_index=0,
 ):
     from supriya.tools import synthdeftools
     coerced_parameters = []
     for parameter in parameters:
         if not isinstance(parameter, synthdeftools.Parameter):
             parameter = synthdeftools.Parameter(name=parameter, value=0)
         coerced_parameters.append(parameter)
     #coerced_parameters.sort(key=lambda parameter: parameter.name)
     self._parameters = tuple(coerced_parameters)
     MultiOutUGen.__init__(
         self,
         channel_count=len(self),
         calculation_rate=calculation_rate,
         special_index=starting_control_index,
     )
Пример #5
0
 def __init__(
     self,
     parameters,
     calculation_rate=None,
     starting_control_index=0,
 ):
     from supriya.tools import synthdeftools
     coerced_parameters = []
     for parameter in parameters:
         if not isinstance(parameter, synthdeftools.Parameter):
             parameter = synthdeftools.Parameter(name=parameter, value=0)
         coerced_parameters.append(parameter)
     self._parameters = tuple(coerced_parameters)
     lags = []
     for parameter in self._parameters:
         lag = parameter.lag or 0.
         lags.extend([lag] * len(parameter))
     MultiOutUGen.__init__(
         self,
         channel_count=len(self),
         calculation_rate=calculation_rate,
         special_index=starting_control_index,
         lags=lags,
     )
Пример #6
0
def _build_default_synthdef():
    """
    SynthDef(\default, { arg out=0, freq=440, amp=0.1, pan=0, gate=1;
        var z;
        z = LPF.ar(
            Mix.new(
                VarSaw.ar(
                    freq + [0, Rand(-0.4, 0.0), Rand(0.0, 0.4)],
                    0,
                    0.3,
                    0.3
                    )
                ),
            XLine.kr(Rand(4000,5000), Rand(2500,3200), 1)
            );
        z = z * Linen.kr(gate, 0.01, 0.7, 0.3, 2);
        OffsetOut.ar(out, Pan2.ar(z, pan, amp));
    }, [\ir]).add;
    """

    builder = synthdeftools.SynthDefBuilder(
        amplitude=0.1,
        frequency=440,
        gate=1,
        out=synthdeftools.Parameter(
            name='out',
            parameter_rate=synthdeftools.ParameterRate.SCALAR,
            value=0,
        ),
        pan=0.5,
    )

    with builder:
        low_pass = ugentools.LPF.ar(source=ugentools.Mix.new(
            ugentools.VarSaw.ar(
                frequency=builder['frequency'] + (
                    0,
                    ugentools.Rand.ir(minimum=-0.4, maximum=0.),
                    ugentools.Rand.ir(minimum=0., maximum=0.4),
                ),
                width=0.3,
            ), ) * 0.3,
                                    frequency=ugentools.XLine.kr(
                                        start=ugentools.Rand.ir(minimum=4000,
                                                                maximum=5000),
                                        stop=ugentools.Rand.ir(minimum=2500,
                                                               maximum=3200),
                                    ))
        linen = ugentools.Linen.kr(
            attack_time=0.01,
            done_action=synthdeftools.DoneAction.FREE_SYNTH,
            gate=builder['gate'],
            release_time=0.3,
            sustain_level=0.7,
        )
        pan = ugentools.Pan2.ar(
            source=low_pass * linen * builder['amplitude'],
            position=builder['pan'],
        )
        ugentools.OffsetOut.ar(bus=builder['out'], source=pan)
    synthdef = builder.build()
    return synthdef
Пример #7
0
def test_SynthDefCompiler_parameters_02():

    sc_synthdef = synthdeftools.SuperColliderSynthDef(
        'test', r'''
        arg freq=1200, out=23;
        Out.ar(out, SinOsc.ar(freq: freq));
        ''')
    sc_compiled_synthdef = sc_synthdef.compile()

    builder = synthdeftools.SynthDefBuilder(
        freq=1200,
        out=23,
    )
    sine = ugentools.SinOsc.ar(frequency=builder['freq'])
    out = ugentools.Out.ar(bus=builder['out'], source=sine)
    builder.add_ugens(out)
    py_synthdef = builder.build('test')
    py_compiled_synthdef = py_synthdef.compile()

    assert py_synthdef.indexed_parameters == (
        (
            0,
            synthdeftools.Parameter(
                name='freq',
                parameter_rate=synthdeftools.ParameterRate.CONTROL,
                value=1200.0,
            ),
        ),
        (
            1,
            synthdeftools.Parameter(
                name='out',
                parameter_rate=synthdeftools.ParameterRate.CONTROL,
                value=23.0,
            ),
        ),
    )

    test_compiled_synthdef = bytes(
        b'SCgf'
        b'\x00\x00\x00\x02'
        b'\x00\x01'
        b'\x04test'
        b'\x00\x00\x00\x01'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x02'
        b'D\x96\x00\x00'
        b'A\xb8\x00\x00'
        b'\x00\x00\x00\x02'
        b'\x04freq'
        b'\x00\x00\x00\x00'
        b'\x03out'
        b'\x00\x00\x00\x01'
        b'\x00\x00\x00\x03'
        b'\x07Control'
        b'\x01'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x02'
        b'\x00\x00'
        b'\x01'
        b'\x01'
        b'\x06SinOsc'
        b'\x02'
        b'\x00\x00\x00\x02'
        b'\x00\x00\x00\x01'
        b'\x00\x00'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x00'
        b'\xff\xff\xff\xff'
        b'\x00\x00\x00\x00'
        b'\x02'
        b'\x03Out'
        b'\x02'
        b'\x00\x00\x00\x02'
        b'\x00\x00\x00\x00'
        b'\x00\x00'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x01'
        b'\x00\x00\x00\x01'
        b'\x00\x00\x00\x00'
        b'\x00\x00', )

    assert sc_compiled_synthdef == test_compiled_synthdef
    assert py_compiled_synthdef == test_compiled_synthdef
Пример #8
0
def test_SynthDefCompiler_parameters_06():
    r'''Literal array arguments.'''

    builder = synthdeftools.SynthDefBuilder(
        amp=0.1,
        freqs=synthdeftools.Parameter(
            lag=0.5,
            value=[300, 400],
        ),
    )
    with builder:
        sines = ugentools.SinOsc.ar(frequency=builder['freqs'], )
        sines = ugentools.Mix.new(sines)
        sines = sines * builder['amp']
        ugentools.Out.ar(
            bus=0,
            source=sines,
        )
    py_synthdef = builder.build('arrayarg')
    py_compiled_synthdef = py_synthdef.compile()

    assert py_synthdef.indexed_parameters == (
        (
            0,
            synthdeftools.Parameter(
                name='amp',
                parameter_rate=synthdeftools.ParameterRate.CONTROL,
                value=0.1,
            ),
        ),
        (
            1,
            synthdeftools.Parameter(
                lag=0.5,
                name='freqs',
                parameter_rate=synthdeftools.ParameterRate.CONTROL,
                value=(300.0, 400.0)),
        ),
    )

    sc_synthdef = synthdeftools.SuperColliderSynthDef(
        'arrayarg',
        r'''
        |
            amp = 0.1,
            freqs = #[300, 400]
        |
        var sines;
        sines = SinOsc.ar(freqs).sum;
        Out.ar(0, sines * amp);
        ''',
        [0, 0.5],
    )
    sc_compiled_synthdef = bytes(sc_synthdef.compile())

    test_compiled_synthdef = bytes(b'SCgf'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x01'
                                   b'\x08arrayarg'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\x00'
                                   b'?\x00\x00\x00'
                                   b'\x00\x00\x00\x03'
                                   b'=\xcc\xcc\xcd'
                                   b'C\x96\x00\x00'
                                   b'C\xc8\x00\x00'
                                   b'\x00\x00\x00\x02'
                                   b'\x03amp'
                                   b'\x00\x00\x00\x00'
                                   b'\x05freqs'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00\x00\x06'
                                   b'\nLagControl'
                                   b'\x01'
                                   b'\x00\x00\x00\x03'
                                   b'\x00\x00\x00\x03'
                                   b'\x00\x00'
                                   b'\xff\xff\xff\xff'
                                   b'\x00\x00\x00\x00'
                                   b'\xff\xff\xff\xff'
                                   b'\x00\x00\x00\x01'
                                   b'\xff\xff\xff\xff'
                                   b'\x00\x00\x00\x01'
                                   b'\x01'
                                   b'\x01'
                                   b'\x01'
                                   b'\x06SinOsc'
                                   b'\x02'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x01'
                                   b'\xff\xff\xff\xff'
                                   b'\x00\x00\x00\x00'
                                   b'\x02'
                                   b'\x06SinOsc'
                                   b'\x02'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x02'
                                   b'\xff\xff\xff\xff'
                                   b'\x00\x00\x00\x00'
                                   b'\x02'
                                   b'\x0cBinaryOpUGen'
                                   b'\x02'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\x00'
                                   b'\x02'
                                   b'\x0cBinaryOpUGen'
                                   b'\x02'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x02'
                                   b'\x00\x00\x00\x03'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x00'
                                   b'\x02'
                                   b'\x03Out'
                                   b'\x02'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00'
                                   b'\xff\xff\xff\xff'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x04'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00')

    assert sc_compiled_synthdef == test_compiled_synthdef
    assert py_compiled_synthdef == test_compiled_synthdef
Пример #9
0
def test_SynthDefCompiler_parameters_01():

    sc_synthdef = synthdeftools.SuperColliderSynthDef(
        'test', r'''
        | freq = 440 |
        Out.ar(0, SinOsc.ar(freq: freq))
        ''')
    sc_compiled_synthdef = sc_synthdef.compile()

    with synthdeftools.SynthDefBuilder(freq=440) as builder:
        sine = ugentools.SinOsc.ar(frequency=builder['freq'])
        ugentools.Out.ar(bus=0, source=sine)
    py_synthdef = builder.build('test')
    py_compiled_synthdef = py_synthdef.compile()

    assert py_synthdef.indexed_parameters == ((
        0,
        synthdeftools.Parameter(
            name='freq',
            parameter_rate=synthdeftools.ParameterRate.CONTROL,
            value=440.0,
        ),
    ), )

    test_compiled_synthdef = bytes(
        b'SCgf'
        b'\x00\x00\x00\x02'
        b'\x00\x01'
        b'\x04test'
        b'\x00\x00\x00\x01'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x01'
        b'C\xdc\x00\x00'
        b'\x00\x00\x00\x01'
        b'\x04freq'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x03'
        b'\x07Control'
        b'\x01'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x01'
        b'\x00\x00'
        b'\x01'
        b'\x06SinOsc'
        b'\x02'
        b'\x00\x00\x00\x02'
        b'\x00\x00\x00\x01'
        b'\x00\x00'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x00'
        b'\xff\xff\xff\xff'
        b'\x00\x00\x00\x00'
        b'\x02'
        b'\x03Out'
        b'\x02'
        b'\x00\x00\x00\x02'
        b'\x00\x00\x00\x00'
        b'\x00\x00'
        b'\xff\xff\xff\xff'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x01'
        b'\x00\x00\x00\x00'
        b'\x00\x00', )

    assert sc_compiled_synthdef == test_compiled_synthdef
    assert py_compiled_synthdef == test_compiled_synthdef
Пример #10
0
def test_SynthDefCompiler_parameters_04():
    r'''Different calculation rates.'''

    sc_synthdef = synthdeftools.SuperColliderSynthDef(
        'trigTest', r'''
        |
            a_phase = 0.0,
            freq = 440,
            i_decay_time = 1.0,
            t_trig_a = 0,
            t_trig_b = 0
        |
        var decay = Decay2.kr([t_trig_a, t_trig_b], 0.005, i_decay_time);
        Out.ar(0, SinOsc.ar(freq, a_phase) * decay);
        ''')
    sc_compiled_synthdef = bytes(sc_synthdef.compile())

    builder = synthdeftools.SynthDefBuilder(
        a_phase=0.0,
        freq=440,
        i_decay_time=1.0,
        t_trig_a=0,
        t_trig_b=0,
    )
    with builder:
        decay = ugentools.Decay2.kr(
            source=(builder['t_trig_a'], builder['t_trig_b']),
            attack_time=0.005,
            decay_time=builder['i_decay_time'],
        )
        sin_osc = ugentools.SinOsc.ar(
            frequency=builder['freq'],
            phase=builder['a_phase'],
        )
        enveloped_sin_osc = sin_osc * decay
        ugentools.Out.ar(
            bus=0,
            source=enveloped_sin_osc,
        )
    py_synthdef = builder.build('trigTest')
    py_compiled_synthdef = py_synthdef.compile()

    assert py_synthdef.indexed_parameters == (
        (
            3,
            synthdeftools.Parameter(
                name='a_phase',
                parameter_rate=synthdeftools.ParameterRate.AUDIO,
                value=0.0,
            ),
        ),
        (
            4,
            synthdeftools.Parameter(
                name='freq',
                parameter_rate=synthdeftools.ParameterRate.CONTROL,
                value=440.0,
            ),
        ),
        (
            0,
            synthdeftools.Parameter(
                name='i_decay_time',
                parameter_rate=synthdeftools.ParameterRate.SCALAR,
                value=1.0,
            ),
        ),
        (
            1,
            synthdeftools.Parameter(
                name='t_trig_a',
                parameter_rate=synthdeftools.ParameterRate.TRIGGER,
                value=0.0,
            ),
        ),
        (
            2,
            synthdeftools.Parameter(
                name='t_trig_b',
                parameter_rate=synthdeftools.ParameterRate.TRIGGER,
                value=0.0,
            ),
        ),
    )

    test_compiled_synthdef = bytes(b'SCgf'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x01'
                                   b'\x08trigTest'
                                   b'\x00\x00\x00\x02'
                                   b';\xa3\xd7\n'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x05'
                                   b'?\x80\x00\x00'  # i_decay_time
                                   b'\x00\x00\x00\x00'  # t_trig_a
                                   b'\x00\x00\x00\x00'  # t_trig_b
                                   b'\x00\x00\x00\x00'  # a_phase
                                   b'C\xdc\x00\x00'  # freq
                                   b'\x00\x00\x00\x05'
                                   b'\x07a_phase'
                                   b'\x00\x00\x00\x03'
                                   b'\x04freq'
                                   b'\x00\x00\x00\x04'
                                   b'\x0ci_decay_time'
                                   b'\x00\x00\x00\x00'
                                   b'\x08t_trig_a'
                                   b'\x00\x00\x00\x01'
                                   b'\x08t_trig_b'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\n'
                                   b'\x07Control'
                                   b'\x00'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00'
                                   b'\x00'
                                   b'\x0bTrigControl'
                                   b'\x01'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x01'
                                   b'\x01'
                                   b'\x01'
                                   b'\x06Decay2'
                                   b'\x01'
                                   b'\x00\x00\x00\x03'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00\x00\x00'
                                   b'\xff\xff\xff\xff'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x00'
                                   b'\x01'
                                   b'\x06Decay2'
                                   b'\x01'
                                   b'\x00\x00\x00\x03'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00\x00\x01'
                                   b'\xff\xff\xff\xff'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x00'
                                   b'\x01'
                                   b'\x0cAudioControl'
                                   b'\x02'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x03'
                                   b'\x02'
                                   b'\x07Control'
                                   b'\x01'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x04'
                                   b'\x01'
                                   b'\x06SinOsc'
                                   b'\x02'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00'
                                   b'\x00\x00\x00\x05'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x04'
                                   b'\x00\x00\x00\x00'
                                   b'\x02'
                                   b'\x0cBinaryOpUGen'
                                   b'\x02'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x02'
                                   b'\x00\x00\x00\x06'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\x00'
                                   b'\x02'
                                   b'\x0cBinaryOpUGen'
                                   b'\x02'
                                   b'\x00\x00\x00\x02'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x02'
                                   b'\x00\x00\x00\x06'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x03'
                                   b'\x00\x00\x00\x00'
                                   b'\x02'
                                   b'\x03Out'
                                   b'\x02'
                                   b'\x00\x00\x00\x03'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00'
                                   b'\xff\xff\xff\xff'
                                   b'\x00\x00\x00\x01'
                                   b'\x00\x00\x00\x07'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00\x00\x08'
                                   b'\x00\x00\x00\x00'
                                   b'\x00\x00')

    assert sc_compiled_synthdef == test_compiled_synthdef
    assert py_compiled_synthdef == test_compiled_synthdef
Пример #11
0
def test_SynthDefCompiler_parameters_03():
    r'''Multiple parameters, including unused parameters.
    '''

    sc_synthdef = synthdeftools.SuperColliderSynthDef(
        'test', r'''
        | damping=0.1, delay_time=1.0, room_size=0.9 |
        Out.ar(0, DelayC.ar(In.ar(0), 5.0, delay_time))
        ''')
    sc_compiled_synthdef = sc_synthdef.compile()

    builder = synthdeftools.SynthDefBuilder(
        damping=0.1,
        delay_time=1.0,
        room_size=0.9,
    )
    with builder:
        microphone = ugentools.In.ar(bus=0)
        delay = ugentools.DelayC.ar(
            source=microphone,
            maximum_delay_time=5.0,
            delay_time=builder['delay_time'],
        )
        ugentools.Out.ar(bus=0, source=delay)
    py_synthdef = builder.build('test')
    py_compiled_synthdef = py_synthdef.compile()

    assert py_synthdef.indexed_parameters == (
        (
            0,
            synthdeftools.Parameter(
                name='damping',
                parameter_rate=synthdeftools.ParameterRate.CONTROL,
                value=0.1,
            ),
        ),
        (
            1,
            synthdeftools.Parameter(
                name='delay_time',
                parameter_rate=synthdeftools.ParameterRate.CONTROL,
                value=1.0,
            ),
        ),
        (
            2,
            synthdeftools.Parameter(
                name='room_size',
                parameter_rate=synthdeftools.ParameterRate.CONTROL,
                value=0.9,
            ),
        ),
    )

    test_compiled_synthdef = bytes(
        b'SCgf'
        b'\x00\x00\x00\x02'
        b'\x00\x01'
        b'\x04test'
        b'\x00\x00\x00\x02'
        b'\x00\x00\x00\x00'
        b'@\xa0\x00\x00'
        b'\x00\x00\x00\x03'
        b'=\xcc\xcc\xcd'
        b'?\x80\x00\x00'
        b'?fff'
        b'\x00\x00\x00\x03'
        b'\x07damping'
        b'\x00\x00\x00\x00'
        b'\ndelay_time'
        b'\x00\x00\x00\x01'
        b'\x09room_size'
        b'\x00\x00\x00\x02'
        b'\x00\x00\x00\x04'
        b'\x07Control'
        b'\x01'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x03'
        b'\x00\x00'
        b'\x01'
        b'\x01'
        b'\x01'
        b'\x02In'
        b'\x02'
        b'\x00\x00\x00\x01'
        b'\x00\x00\x00\x01'
        b'\x00\x00'
        b'\xff\xff\xff\xff'
        b'\x00\x00\x00\x00'
        b'\x02'
        b'\x06DelayC'
        b'\x02'
        b'\x00\x00\x00\x03'
        b'\x00\x00\x00\x01'
        b'\x00\x00'
        b'\x00\x00\x00\x01'
        b'\x00\x00\x00\x00'
        b'\xff\xff\xff\xff'
        b'\x00\x00\x00\x01'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x01'
        b'\x02'
        b'\x03Out'
        b'\x02'
        b'\x00\x00\x00\x02'
        b'\x00\x00\x00\x00'
        b'\x00\x00'
        b'\xff\xff\xff\xff'
        b'\x00\x00\x00\x00'
        b'\x00\x00\x00\x02'
        b'\x00\x00\x00\x00'
        b'\x00\x00', )

    assert sc_compiled_synthdef == test_compiled_synthdef
    assert py_compiled_synthdef == test_compiled_synthdef