Function

Allocates a contigious block of numbers.

Boot a server with options and connect

alternate constructor resolves options, boots and loads interpreter

Allocates zero filled buffer to number of channels and samples.

Asynchronous. Replies with /done /b_alloc bufNum.

Allocate buffer space and read a sound file.

Allocates buffer to number of channels of file and number of samples requested, or fewer if sound file is smaller than requested. Reads sound file data from the given starting frame in the file. If the number of frames argument is less than or equal to zero, the entire file is read. Asynchronous. Replies with /done /b_allocRead bufNum.

Allocate buffer space and read channels from a sound file.

As b_allocRead, but reads individual channels into the allocated buffer in the order specified. Asynchronous. Replies with /done /b_allocReadChannel bufNum.

After using a buffer with DiskOut, close the soundfile and write header information.

Asynchronous. Replies with /done /b_close bufNum.

Fill ranges of samples with a value

Set contiguous ranges of sample indices to single values. For each range, the starting sample index is given followed by the number of samples to change, followed by the value to fill. This is only meant for setting a few samples, not whole buffers or large sections.

Frees buffer space allocated for this buffer.

Asynchronous. Replies with /done /b_free bufNum.

Call a command to fill a buffer.

Plug-ins can define commands that operate on buffers. The arguments after the command name are defined by the command. The currently defined buffer fill commands are listed below in a separate section.

Asynchronous. Replies with /done /b_gen bufNum.

Get sample value(s). Replies with the corresponding /b_set command.

Get ranges of sample value(s).

Get contiguous ranges of samples. Replies with the corresponding b_setn command. This is only meant for getting a few samples, not whole buffers or large sections.

Get buffer info.

Responds to the sender with a /b_info message with: multiple: param {int} bufferID param {int} - number of frames param {int} - number of channels param {float} sample rate

Read sound file data into an existing buffer.

Reads sound file data from the given starting frame in the file and writes it to the given starting frame in the buffer. If number of frames is less than zero, the entire file is read.

If reading a file to be used by DiskIn ugen then you will want to set "leave file open" to one, otherwise set it to zero.

Asynchronous. Replies with /done /b_read bufNum.

Read sound file channel data into an existing buffer.

As b_read, but reads individual channels in the order specified. The number of channels requested must match the number of channels in the buffer.

Asynchronous. Replies with /done /b_readChannel bufNum.

Takes a list of pairs of sample indices and values and sets the samples to those values.

Set ranges of sample value(s).

Set contiguous ranges of sample indices to sets of values. For each range, the starting sample index is given followed by the number of samples to change, followed by the values.

Write buffer contents to a sound file.

Not all combinations of header format and sample format are possible.

If number of frames is less than zero, all samples from the starting frame to the end of the buffer are written. If opening a file to be used by DiskOut ugen then you will want to set "leave file open" to one, otherwise set it to zero. If "leave file open" is set to one then the file is created, but no frames are written until the DiskOut ugen does so.

Asynchronous. Replies with /done /b_write bufNum.

Sets all samples in the buffer to zero.

Asynchronous. Replies with /done /b_zero bufNum.

If value is a function then call it, if function returns a Promise then resolve it.

Call and resolve each of the items in a list

Call and resolve each of the values of an Object.

Clear all scheduled bundles. Removes all bundles from the scheduling queue.

Execute a command defined by a UGen Plug-in

Compile a SynthDef from a snippet of supercollider source code, send it to the server and stores the SynthDesc in server.state

Fill ranges of bus value(s).

Set contiguous ranges of buses to single values. For each range, the starting sample index is given followed by the number of buses to change, followed by the value to fill. what is diff to c_setn ?

Get control bus values

Takes a bus ID and replies with the corresponding c_set command.

Get contiguous ranges of buses. Replies with the corresponding c_setn command.

Takes a list of pairs of bus indices and values and sets the buses to those values.

Set ranges of bus value(s).

Set contiguous ranges of buses to sets of values. For each range, the starting bus index is given followed by the number of channels to change, followed by the values.

Returns dB mapping function (DbFaderWarp)

Delete synth definition.

The definition is removed immediately, and does not wait for synth nodes based on that definition to end.

Load synth definition.

Loads a file of synth definitions. Resident definitions with the same names are overwritten. Asynchronous. Replies with /done.

Load a directory of synth definitions.

Asynchronous. Replies with /done.

Loads a file of synth definitions from a data buffer included in the message. Resident definitions with the same names are overwritten.

Asynchronous. Replies with /done.

deltaTimeTag(secondsFromNow, [now])

Make NTP timetag array relative to the current time.

Create a DryadPlayer from a Dryad or hyperscript definition.

Automatically includes the supercollider.js layer

usage:

var sc = require('supercolliderjs'); var player = sc.dryadic([ 'scserver', [ ['group', [ ['synth', { defName: 'sinosc', args: { freq: 440 } }] ] ]); player.play(); ... player.stop();

Dump incoming OSC messages to stdout

Enable/disable error message posting.

Returns an exponential mapping function

Returns amp mapping function (FaderWarp)

Return a previously allocated block back to the free list.

Defragments by merging with adjoining neighbors where possible

Returns a list of the free blocks and their sizes.

Free all synths in this group and all its sub-groups.

Traverses all groups below this group and frees all the synths. Sub-groups are not freed.

Post a representation of this group's node subtree to STDOUT

Posts a representation of this group's node subtree, i.e. all the groups and synths contained within it, optionally including the current control values for synths.

Frees all immediate children nodes in the group

Moves node to the head (first to be executed) of the group.

Create a new group.

Create a new group and add it to the tree of nodes. There are four ways to add the group to the tree as determined by the add action argument

Get a representation of this group's node subtree.

Request a representation of this group's node subtree, i.e. all the groups and synths contained within it. Replies to the sender with a /g_queryTree.reply message listing all of the nodes contained within the group in the following format:

param {int} - flag: if synth control values are included 1, else 0 param {int} nodeID - of the requested group param {int} - number of child nodes contained within the requested group then for each node in the subtree: param {int} nodeID - param {int} - number of child nodes contained within this node. If -1 this is a synth, if >=0 it's a group then, if this node is a synth: strongsymbol the SynthDef name for this node. then, if flag (see above) is true: param {int} - numControls for this synth (M) multiple: param {string|int} - control name or index param {float|String} value or control bus mapping symbol (e.g. 'c1')

N.B. The order of nodes corresponds to their execution order on the server. Thus child nodes (those contained within a group) are listed immediately following their parent. See the method Server:queryAllNodes for an example of how to process this reply.

Moves node to the tail (last to be executed) of the group.

Convert hyperscript object to a tree of Dryads.

This lookups each class by lower class 'classname' and creates an instance with properties and children.

A simple incrementing allocator used for nodeIds.

The return type is designed to be consistent with the block allocator and other mutating functions used by Server

Create initial state for block allocator.

Boots a new supercollider interpreter making it available for all children as context.lang.

Ignores any possibly already existing one in context.

Returns a linear mapping function

Format an object for osc-min bundle

Format an object for osc-min message

Places node A in the same group as node B, to execute immediately after node B.

Places node A in the same group as node B, to execute immediately before node B.

Fill ranges of a node's control value(s).

Set contiguous ranges of control indices to single values. For each range, the starting control index is given followed by the number of controls to change, followed by the value to fill. If the node is a group, then it sets the controls of every node in the group.

Delete/free a node

Map a node's controls to read from a bus.

Map a node's controls to read from an audio bus.

Takes a list of pairs of control names or indices and audio bus indices and causes those controls to be read continuously from a global audio bus. If the node is a group, then it maps the controls of every node in the group. If the audio bus index is -1 then any current mapping is undone. Any n_set, n_setn and n_fill command will also unmap the control. For the full audio rate signal, the argument must have its rate set to \ar.

Map a node's controls to read from audio buses.

Map a node's controls to read from buses.

Takes a list of triples of control names or indices, bus indices, and number of controls to map and causes those controls to be mapped sequentially to buses. If the node is a group, then it maps the controls of every node in the group. If the control bus index is -1 then any current mapping is undone. Any n_set, n_setn and n_fill command will also unmap the control.

Move and order a list of nodes.

Move the listed nodes to the location specified by the target and add action, and place them in the order specified. Nodes which have already been freed will be ignored.

Get info about a node.

The server sends an /n_info message for each node to registered clients. See Node Notifications for the format of the /n_info message.

Stop/start a node from running

Save computation by turning a node (and its children) off but without removing it from the UGen graph

Set a node's control value(s).

Takes a list of pairs of control indices and values and sets the controls to those values. If the node is a group, then it sets the controls of every node in the group.

This message now supports array type tags ($[ and $]) in the control/value component of the OSC message. Arrayed control values are applied in the manner of n_setn (i.e., sequentially starting at the indexed or named control).

I think this also takes [freq, 440],

Example:

nodeSet(id, [[0, 440], ...])

Set ranges of a node's control value(s).

Set contiguous ranges of control indices to sets of values. For each range, the starting control index is given followed by the number of controls to change, followed by the values. If the node is a group, then it sets the controls of every node in the group.

Trace a node.

Causes a synth to print out the values of the inputs and outputs of its unit generators for one control period. Causes a group to print the node IDs and names of each node in the group for one control period.

End real time mode, close file. Not yet implemented on server

This message should be sent in a bundle in non real time mode. The bundle timestamp will establish the ending time of the file. This command will end non real time mode and close the sound file. Replies with /done.

Register to receive notifications from server

Asynchronous. Replies with /done /notify clientID. If this client has registered for notifications before, this may be the same ID. Otherwise it will be a new one. Clients can use this ID in multi-client situations to avoid conflicts in node IDs, bus indices, buffer numbers, etc.

Call a function when the server sends an /n_end message One callback allowed per id and node.

Call a function when the server sends an /n_go message One callback allowed per id and node The id is usually a context id but could be a random guid

Create a new parallel group. supernova only

Create a new parallel group and add it to the tree of nodes. Parallel groups are relaxed groups, their child nodes are evaluated in unspecified order. There are four ways to add the group to the tree as determined by the add action argument

Multiple groups may be created in one command by adding arguments. (not implemented here)

Convert full OSC message to a simple Array

{address: '/n_go', args: [ Object { type: 'integer', value: 1000 }, Object { type: 'integer', value: 0 }, Object { type: 'integer', value: -1 }, Object { type: 'integer', value: 3 }, Object { type: 'integer', value: 0 } ], oscType: 'message' }

to:

['/n_go', 1000, 0, -1, 3, 0]

Play a Dryad or hyperscript document.

usage:

var sc = require('supercolliderjs'); var player = sc.play([ 'scserver', [ ['group', [ ['synth', { defName: 'sinosc', args: { freq: 440 } }] ] ]);

store synthDefDesc in server state.

This marks it as having been compiled and sent to server.

Tell server to exit

Boots a supercollider interpreter if none is already available in the context making it available for all children as context.lang.

Boots a supercollider server if none is already available in the context making it available for all children as context.server.

Reserve a block by re-writing the free list

Throw:

load configuration files and merge options into a final dict

Send OSC to the SuperCollider server (scsynth)

Command may have one of these forms:

msg: Array

bundle: { time: null|Number|Array|Date packets: Array of OSC messages }

callAndResponse: { call: response: }

sched: [ { time: null|Number|Array|Date messages: Array of OSC messages } ]

(sched will later use a just-in-time scheduler)

Alternatively you may supply a function that is called with context and returns one of these forms.

Bundle time format

Boots a new supercollider server making it available for all children making it available for all children as context.server.

Always boots a new one, ignoring any possibly already existing one in context.

Query for server status.

Server replies with /status.reply

Spawns each item returned by an Rx.Observable stream.

Each item returned by the stream should be a dryad like synth, group etc. It will be spawned as a child of this stream dryad.

Notify when async commands have completed.

Replies with a /synced message when all asynchronous commands received before this one have completed. The reply will contain the sent unique ID.

Asynchronous. Replies with /synced ID .