Players are things that can play. The AbstractPlayer interface encapsulates each of the steps to load an object, get its resources onto the server (eg. loading buffers, populating lookup tables) , to play at precise times, stop and free its resources when finished.
Players may have one synth or many or even none. They may hold groups, busses and buffers in its instance variables.
Players have an output spec and some of them have inputs and input specs.
If they have editable parameters then the framework supports saving and loading of the player object in compile string document format.
AbstractPlayer.bundleClass = value
AbstractPlayer.bundle(server, atTime, buildFunction)
Arguments:
| server | |
| atTime |
see atTime |
| buildFunction | |
AbstractPlayer.ar( ... args)
AbstractPlayer.kr( ... args)
AbstractPlayer.annotate(thing, note)
AbstractPlayer.load(obj, warnIfNotFound: true)
AbstractPlayer.enpath(obj)
if loaded or saved, the player knows its path
Arguments:
.play(group, atTime, bus)
boots the server, prepares the player for play (loading resources like samples etc.) and spawns the player
all args are optional
Arguments:
| group |
a Server (will use the root node) a Group nil (default server's root node) |
| atTime |
see atTime |
| bus |
bus - (Bus,Integer,Nil) a specific Bus to play on, otherwise will default to the main audio outs |
.prPlay(atTime, bus, timeOfRequest)
Arguments:
| atTime |
see atTime |
| bus | |
| timeOfRequest | |
.prepareForPlay(group, private: false, bus)
this loads the synthDef to the server for the player and all of its children, and allocates any resources such as buffers, loading sound files etc.
Arguments:
| group |
group - a Server, a Group or Nil |
| private |
isPrivate: a public bus is one of the main audio outputs of your soundcard. a private bus is one that will be patched and mixed further down the line. When makePatchOut is called on the top player (the one that actually was sent .play) it plays to a public (main audio output), and any internal children are told to allocate and play onto a private bus. |
| bus |
bus - a specific Bus to play on. this will cause isPrivate to be ignored |
.prepareToBundle(agroup, bundle, private: false, bus)
.makePatchOut(agroup, private: false, bus, bundle)
.spawn(atTime, timeOfRequest)
assumes the player has been prepared. see prepareForPlay
Arguments:
| atTime |
see atTime |
| timeOfRequest | |
.spawnOn(group, bus, atTime, timeOfRequest)
Arguments:
| group | |
| bus | |
| atTime |
see atTime |
| timeOfRequest | |
.spawnToBundle(bundle, selector: 'addToTailMsg')
.onPlay(func, timeout, listener, oneShot: true, throwErrorOnTimeout)
Arguments:
| func | |
| timeout | |
| listener | |
| oneShot | |
| throwErrorOnTimeout | |
.onStop(func, timeout, listener, oneShot: true, throwErrorOnTimeout)
Arguments:
| func | |
| timeout | |
| listener | |
| oneShot | |
| throwErrorOnTimeout | |
.onReady(func, timeout, listener, oneShot: true, throwErrorOnTimeout)
Arguments:
| func | |
| timeout | |
| listener | |
| oneShot | |
| throwErrorOnTimeout | |
.prOn(status, func, timeout, listener, oneShot: true, throwErrorOnTimeout)
Arguments:
| status | |
| func | |
| timeout | |
| listener | |
| oneShot | |
| throwErrorOnTimeout | |
.stop(atTime)
stops playing but does not deallocate any resources (buffers etc.) You need to .free to deallocate it
Arguments:
.release(releaseTime, atTime)
call release on the synth, with the releaseTime then calls stop on the player, so even if the synthDef does not have a \gate input, it will function the same as stop after a short delay.
Arguments:
.free(atTime)
frees all allocated resources (buffers etc.) if it is playing then it also stops it
Arguments:
.record(path, endBeat, onComplete, recHeaderFormat, recSampleFormat, atTime)
Arguments:
| path | |
| endBeat | |
| onComplete | |
| recHeaderFormat | |
| recSampleFormat | |
| atTime |
see atTime |
.plot(duration: 5.0, bounds)
.connectToPatchIn(patchIn, needsValueSetNow: true)
for players that hold other players or objects, return those children player classes should implement where appropriate. a Patch has its args as children SFP has its underlying object as child
using this.children.do({arg item; .... }) can save you from having to muck up the Player class with extra methods.
do to allChildren
Arguments:
and all your children's children, and their children...
.name = value
if loaded or saved then the name is the filename, else its the normal asString for an object (eg. "a Patch")
.changed(what ... moreArgs)
.load(obj, warnIfNotFound: true)
.busReport: METHOD NOT FOUND!
.asKAsset: METHOD NOT FOUND!
Extension