
--------------------------------------------------------------------------
*#*

Bitwise NON EQUIVALENCE operator.

	a 	#	 b (bitwise NON EQUIVALENCE)

--------------------------------------------------------------------------
*#define*

Defines a macro.

		#define	 NAME # replacement text #
		#define	 NAME(a' b' c') # replacement text #

--------------------------------------------------------------------------
*#end*

Conditional reading of code.

		#ifdef	 NAME
	 ....
		#else	
	 ....
		#end	

--------------------------------------------------------------------------
*#end*

Conditional reading of code.

		#ifndef	 NAME
	 ....
		#else	
	 ....
		#end	

--------------------------------------------------------------------------
*#include*

Includes an external file for processing.

		#include	 "filename"

--------------------------------------------------------------------------
*#undef*

Un-defines a macro.

		#undef	 NAME

--------------------------------------------------------------------------
*$NAME*

Calls a defined macro.

		$NAME	

--------------------------------------------------------------------------
*%*

Modulus operator.

	a 	%	 b (no rate restriction)

--------------------------------------------------------------------------
*&&*

Logical AND operator.

	a 	&&	 b (logical AND; not audio-rate)

--------------------------------------------------------------------------
*&*

Bitwise AND operator.

	a 	&	 b (bitwise AND)

--------------------------------------------------------------------------
***

Multiplication operator.

	a 	*	 b (no rate restriction)

--------------------------------------------------------------------------
*+*

Addition operator

	a 	+	 b (no rate restriction)

--------------------------------------------------------------------------
*-*

Subtraction operator.

	a 	-	 b (no rate restriction)

--------------------------------------------------------------------------
*/*

Division operator.

	a 	/	 b (no rate restriction)

--------------------------------------------------------------------------
*0dbfs*

Sets the value of 0 decibels using full scale amplitude.

		0dbfs	 = iarg

--------------------------------------------------------------------------
*:*

Compares two values for equality.

	(a 	==	 b 	?	 v1 	:	 v2)

--------------------------------------------------------------------------
*:*

Determines if one value is greater than another.

	(a 	>	 b 	?	 v1 	:	 v2)

--------------------------------------------------------------------------
*:*

Determines if one value is greater than or equal to another.

	(a 	>=	 b 	?	 v1 	:	 v2)

--------------------------------------------------------------------------
*:*

Determines if one value is less than another.

	(a 	<	 b 	?	 v1 	:	 v2)

--------------------------------------------------------------------------
*:*

Determines if one value is less than or equal to another.

	(a 	<=	 b 	?	 v1 	:	 v2)

--------------------------------------------------------------------------
*:*

Determines if one value is not equal to another.

	(a 	!=	 b 	?	 v1 	:	 v2)

--------------------------------------------------------------------------
*<<*

Bitshift left operator.

	a 	<<	 b (bitshift left)

--------------------------------------------------------------------------
*=*

Assign value to a string variable

	Sdst 	strcpy	 Ssrc
	Sdst 	=	 Ssrc

--------------------------------------------------------------------------
*=*

Performs a simple assignment.

	ares 	=	 xarg
	ires 	=	 iarg
	kres 	=	 karg
	ires, ... 	=	 iarg, ...
	kres, ... 	=	 karg, ...

--------------------------------------------------------------------------
*>>*

Bitshift right operator.

	a 	>>	 b (bitshift left)

--------------------------------------------------------------------------
*ATSadd*

uses the data from an ATS analysis file to perform additive synthesis.

	ar 	ATSadd	 ktimepnt, kfmod, iatsfile, ifn, ipartials[, ipartialoffset, ipartialincr, igatefn]

--------------------------------------------------------------------------
*ATSaddnz*

uses the data from an ATS analysis file to perform noise resynthesis.

	ar 	ATSaddnz	 ktimepnt, iatsfile, ibands[, ibandoffset, ibandincr]

--------------------------------------------------------------------------
*ATSbufread*

reads data from and ATS data file and stores it in an internal data table of frequency, amplitude pairs.

		ATSbufread	 ktimepnt, kfmod, iatsfile, ipartials[, ipartialoffset, ipartialincr]

--------------------------------------------------------------------------
*ATScross*

perform cross synthesis from ATS analysis files.

	ar 	ATScross	 ktimepnt, kfmod, iatsfile, ifn, kmylev, kbuflev, ipartials [, ipartialoffset, ipartialincr]

--------------------------------------------------------------------------
*ATSinfo*

reads data out of the header of an ATS file.

	idata 	ATSinfo	 iatsfile, ilocation

--------------------------------------------------------------------------
*ATSinterpread*

allows a user to determine the frequency envelope of any

	kamp 	ATSinterpread	 kfreq

--------------------------------------------------------------------------
*ATSpartialtap*

returns a frequency, amplitude pair from an

	kfrq, kamp 	ATSpartialtap	 ipartialnum

--------------------------------------------------------------------------
*ATSread*

reads data from an ATS file.

	kfreq, kamp 	ATSread	 ktimepnt, iatsfile, ipartial

--------------------------------------------------------------------------
*ATSreadnz*

reads data from an ATS file.

	kenergy 	ATSreadnz	 ktimepnt, iatsfile, iband

--------------------------------------------------------------------------
*ATSsinnoi*

uses the data from an ATS analysis file to perform resynthesis.

	ar 	ATSsinnoi	 ktimepnt, ksinlev, knzlev, kfmod, iatsfile, ipartials [, ipartialoffset, ipartialincr]

--------------------------------------------------------------------------
*FLbox*

A FLTK widget that displays text inside of a box.

	ihandle 	FLbox	 "label", itype, ifont, isize, iwidth, iheight, ix, iy [, image]

--------------------------------------------------------------------------
*FLbutBank*

A FLTK widget opcode that creates a bank of buttons.

	kout, ihandle 	FLbutBank	 itype, inumx, inumy, iwidth, iheight, ix, iy, iopcode [, kp1] [, kp2] [, kp3] [, kp4] [, kp5] [....] [, kpN]

--------------------------------------------------------------------------
*FLbutton*

A FLTK widget opcode that creates a button.

	kout, ihandle 	FLbutton	 "label", ion, ioff, itype, iwidth, iheight, ix, iy, iopcode [, kp1] [, kp2] [, kp3] [, kp4] [, kp5] [....] [, kpN]

--------------------------------------------------------------------------
*FLcloseButton*

A FLTK widget opcode that creates a button that will close the panel window it is a part of.

	ihandle 	FLcloseButton	 "label", iwidth, iheight, ix, iy

--------------------------------------------------------------------------
*FLcolor2*

A FLTK opcode that sets the secondary (selection) color.

		FLcolor2	 ired, igreen, iblue

--------------------------------------------------------------------------
*FLcolor*

A FLTK opcode that sets the primary colors.

		FLcolor	 ired, igreen, iblue [, ired2, igreen2, iblue2]

--------------------------------------------------------------------------
*FLcount*

A FLTK widget opcode that creates a counter.

	kout, ihandle 	FLcount	 "label", imin, imax, istep1, istep2, itype, iwidth, iheight, ix, iy, iopcode [, kp1] [, kp2] [, kp3] [...] [, kpN]

--------------------------------------------------------------------------
*FLexecButton*

A FLTK widget opcode that creates a button that executes a command.

	ihandle 	FLexecButton	 "command", iwidth, iheight, ix, iy

--------------------------------------------------------------------------
*FLgetsnap*

Retrieves a previously stored FLTK snapshot.

	inumsnap 	FLgetsnap	 index [, igroup]

--------------------------------------------------------------------------
*FLgroup*

A FLTK container opcode that groups child widgets.

		FLgroup	 "label", iwidth, iheight, ix, iy [, iborder] [, image]

--------------------------------------------------------------------------
*FLgroupEnd*

Marks the end of a group of FLTK child widgets.

		FLgroupEnd	

--------------------------------------------------------------------------
*FLhide*

Hides the target FLTK widget.

		FLhide	 ihandle

--------------------------------------------------------------------------
*FLhvsBox*

Displays a box with a grid useful for visualizing two-dimensional Hyper Vectorial Synthesis.

	ihandle 	FLhvsBox	 inumlinesX, inumlinesY, iwidth, iheight, ix, iy [, image]

--------------------------------------------------------------------------
*FLhvsBox*

Sets the cursor position of a previously-declared FLhvsBox widget.

		FLhvsBox	 kx, ky, ihandle

--------------------------------------------------------------------------
*FLjoy*

A FLTK opcode that acts like a joystick.

	koutx, kouty, ihandlex, ihandley 	FLjoy	 "label", iminx, imaxx, iminy, imaxy, iexpx, iexpy, idispx, idispy, iwidth, iheight, ix, iy

--------------------------------------------------------------------------
*FLkeyIn*

Reports keys pressed (on alphanumeric keyboard) when an FLTK panel has focus.

	kascii 	FLkeyIn	 [ifn]

--------------------------------------------------------------------------
*FLknob*

A FLTK widget opcode that creates a knob.

	kout, ihandle 	FLknob	 "label", imin, imax, iexp, itype, idisp, iwidth, ix, iy [, icursorsize]

--------------------------------------------------------------------------
*FLlabel*

A FLTK opcode that modifies the appearance of a text label.

		FLlabel	 isize, ifont, ialign, ired, igreen, iblue

--------------------------------------------------------------------------
*FLloadsnap*

Loads all snapshots into the memory bank of the current orchestra.

		FLloadsnap	 "filename" [, igroup]

--------------------------------------------------------------------------
*FLmouse*

Returns the mouse position and the state of the three mouse buttons.

	kx, ky, kb1, kb2, kb3 	FLmouse	 [imode]

--------------------------------------------------------------------------
*FLpack*

Provides the functionality of compressing and aligning FLTK widgets.

		FLpack	 iwidth, iheight, ix, iy, itype, ispace, iborder

--------------------------------------------------------------------------
*FLpackEnd*

Marks the end of a group of compressed or aligned FLTK widgets.

		FLpackEnd	

--------------------------------------------------------------------------
*FLpanel*

Creates a window that contains FLTK widgets.

		FLpanel	 "label", iwidth, iheight [, ix] [, iy] [, iborder] [, ikbdcapture] [, iclose]

--------------------------------------------------------------------------
*FLpanelEnd*

Marks the end of a group of FLTK widgets contained inside of a window (panel).

		FLpanelEnd	

--------------------------------------------------------------------------
*FLprintk2*

A FLTK opcode that prints a new value every time a control-rate variable changes.

		FLprintk2	 kval, idisp

--------------------------------------------------------------------------
*FLprintk*

A FLTK opcode that prints a k-rate value at specified intervals.

		FLprintk	 itime, kval, idisp

--------------------------------------------------------------------------
*FLroller*

A FLTK widget that creates a transversal knob.

	kout, ihandle 	FLroller	 "label", imin, imax, istep, iexp, itype, idisp, iwidth, iheight, ix, iy

--------------------------------------------------------------------------
*FLrun*

Starts the FLTK widget thread.

		FLrun	

--------------------------------------------------------------------------
*FLsavesnap*

Saves all snapshots currently created into a file.

		FLsavesnap	 "filename" [, igroup]

--------------------------------------------------------------------------
*FLscroll*

A FLTK opcode that adds scroll bars to an area.

		FLscroll	 iwidth, iheight [, ix] [, iy]

--------------------------------------------------------------------------
*FLscrollEnd*

A FLTK opcode that marks the end of an area with scrollbars.

		FLscrollEnd	

--------------------------------------------------------------------------
*FLsetAlign*

Sets the text alignment of a label of a FLTK widget.

		FLsetAlign	 ialign, ihandle

--------------------------------------------------------------------------
*FLsetBox*

Sets the appearance of a box surrounding a FLTK widget.

		FLsetBox	 itype, ihandle

--------------------------------------------------------------------------
*FLsetColor2*

Sets the secondary (or selection) color of a FLTK widget.

		FLsetColor2	 ired, igreen, iblue, ihandle

--------------------------------------------------------------------------
*FLsetColor*

Sets the primary color of a FLTK widget.

		FLsetColor	 ired, igreen, iblue, ihandle

--------------------------------------------------------------------------
*FLsetFont*

Sets the font type of a FLTK widget.

		FLsetFont	 ifont, ihandle

--------------------------------------------------------------------------
*FLsetPosition*

Sets the position of a FLTK widget.

		FLsetPosition	 ix, iy, ihandle

--------------------------------------------------------------------------
*FLsetSize*

Resizes a FLTK widget.

		FLsetSize	 iwidth, iheight, ihandle

--------------------------------------------------------------------------
*FLsetSnapGroup*

Determines the snapshot group for FL valuators.

		FLsetSnapGroup	 igroup

--------------------------------------------------------------------------
*FLsetText*

Sets the label of a FLTK widget.

		FLsetText	 "itext", ihandle

--------------------------------------------------------------------------
*FLsetTextColor*

Sets the color of the text label of a FLTK widget.

		FLsetTextColor	 ired, iblue, igreen, ihandle

--------------------------------------------------------------------------
*FLsetTextSize*

Sets the size of the text label of a FLTK widget.

		FLsetTextSize	 isize, ihandle

--------------------------------------------------------------------------
*FLsetTextType*

Sets some font attributes of the text label of a FLTK widget.

		FLsetTextType	 itype, ihandle

--------------------------------------------------------------------------
*FLsetVal*

Sets the value of a FLTK valuator at control-rate.

		FLsetVal	 ktrig, kvalue, ihandle

--------------------------------------------------------------------------
*FLsetVal_i*

Sets the value of a FLTK valuator to a number provided by the user.

		FLsetVal_i	 ivalue, ihandle

--------------------------------------------------------------------------
*FLsetsnap*

Stores the current status of all FLTK valuators into a snapshot location.

	inumsnap, inumval 	FLsetsnap	 index [, ifn, igroup]

--------------------------------------------------------------------------
*FLshow*

Restores the visibility of a previously hidden FLTK widget.

		FLshow	 ihandle

--------------------------------------------------------------------------
*FLslidBnk2*

A FLTK widget containing a bank of horizontal sliders.

		FLslidBnk2	 "names", inumsliders, ioutable, iconfigtable [,iwidth, iheight, ix, iy, istart_index] 

--------------------------------------------------------------------------
*FLslidBnk2Set*

modify the values of a slider bank.

		FLslidBnk2Set	 ihandle, ifn [, istartIndex, istartSlid, inumSlid]

--------------------------------------------------------------------------
*FLslidBnk2Setk*

modify the values of a slider bank.

		FLslidBnk2Setk	 ktrig, ihandle, ifn [, istartIndex, istartSlid, inumSlid]

--------------------------------------------------------------------------
*FLslidBnk*

A FLTK widget containing a bank of horizontal sliders.

		FLslidBnk	 "names", inumsliders [, ioutable] [, iwidth] [, iheight] [, ix] [, iy] [, itypetable] [, iexptable] [, istart_index] [, iminmaxtable]

--------------------------------------------------------------------------
*FLslidBnkGetHandle*

gets the handle of last slider bank created.

	ihandle 	FLslidBnkGetHandle	

--------------------------------------------------------------------------
*FLslidBnkSet*

modify the values of a slider bank.

		FLslidBnkSet	 ihandle, ifn [, istartIndex, istartSlid, inumSlid]

--------------------------------------------------------------------------
*FLslidBnkSetk*

modify the values of a slider bank.

		FLslidBnkSetk	 ktrig, ihandle, ifn [, istartIndex, istartSlid, inumSlid]

--------------------------------------------------------------------------
*FLslider*

Puts a slider into the corresponding FLTK container.

	kout, ihandle 	FLslider	 "label", imin, imax, iexp, itype, idisp, iwidth, iheight, ix, iy

--------------------------------------------------------------------------
*FLtabs*

Creates a tabbed FLTK interface.

		FLtabs	 iwidth, iheight, ix, iy

--------------------------------------------------------------------------
*FLtabsEnd*

Marks the end of a tabbed FLTK interface.

		FLtabsEnd	

--------------------------------------------------------------------------
*FLtext*

A FLTK widget opcode that creates a textbox.

	kout, ihandle 	FLtext	 "label", imin, imax, istep, itype, iwidth, iheight, ix, iy

--------------------------------------------------------------------------
*FLupdate*

Same as the FLrun opcode.

		FLupdate	

--------------------------------------------------------------------------
*FLvalue*

Shows the current value of a FLTK valuator.

	ihandle 	FLvalue	 "label", iwidth, iheight, ix, iy

--------------------------------------------------------------------------
*FLvkeybd*

An FLTK widget opcode that creates a virtual keyboard widget.

		FLvkeybd	 "keyboard.map", iwidth, iheight, ix, iy

--------------------------------------------------------------------------
*FLvslidBnk2*

A FLTK widget containing a bank of vertical sliders.

		FLvslidBnk2	 "names", inumsliders, ioutable, iconfigtable [,iwidth, iheight, ix, iy, istart_index]

--------------------------------------------------------------------------
*FLvslidBnk*

A FLTK widget containing a bank of vertical sliders.

		FLvslidBnk	 "names", inumsliders [, ioutable] [, iwidth] [, iheight] [, ix] [, iy] [, itypetable] [, iexptable] [, istart_index] [, iminmaxtable]

--------------------------------------------------------------------------
*FLxyin*

Senses the mouse cursor position in a user-defined area inside an FLpanel.

	koutx, kouty, kinside 	FLxyin	 ioutx_min, ioutx_max, iouty_min, iouty_max, iwindx_min, iwindx_max, iwindy_min, iwindy_max [, iexpx, iexpy, ioutx, iouty]

--------------------------------------------------------------------------
*MixerClear*

Resets all channels of a buss to 0.

		MixerClear	

--------------------------------------------------------------------------
*MixerGetLevel*

Gets the level of a send to a buss.

	kgain 	MixerGetLevel	 isend, ibuss

--------------------------------------------------------------------------
*MixerReceive*

Receives an arate signal from a channel of a buss.

	asignal 	MixerReceive	 ibuss, ichannel

--------------------------------------------------------------------------
*MixerSend*

Mixes an arate signal into a channel of a buss.

		MixerSend	 asignal, isend, ibuss, ichannel

--------------------------------------------------------------------------
*MixerSetLevel*

Sets the level of a send to a buss.

		MixerSetLevel	 isend, ibuss, kgain

--------------------------------------------------------------------------
*MixerSetLevel_i*

Sets the level of a send to a buss.

		MixerSetLevel_i	 isend, ibuss, igain

--------------------------------------------------------------------------
*OSCinit*

Start a listening process for OSC messages to a particular port.

	ihandle 	OSCinit	 iport

--------------------------------------------------------------------------
*OSClisten*

Listen for OSC messages to a particular path.

	kans 	OSClisten	 ihandle, idest, itype [, xdata1, xdata2, ...]

--------------------------------------------------------------------------
*OSCsend*

Sends data to other processes using the OSC protocol

		OSCsend	 kwhen, ihost, iport, idestination, itype [, kdata1, kdata2, ...]

--------------------------------------------------------------------------
*^*



	a 	^	 b (b not audio-rate)

--------------------------------------------------------------------------
*a*

Converts a k-rate parameter to an a-rate value with interpolation.

		a	(x) (control-rate args only)

--------------------------------------------------------------------------
*abs*

Returns an absolute value.

		abs	(x) (no rate restriction)

--------------------------------------------------------------------------
*active*

Returns the number of active instances of an instrument.

	ir 	active	 insnum
	kres 	active	 kinsnum

--------------------------------------------------------------------------
*adsr*

Calculates the classical ADSR envelope using linear segments.

	ares 	adsr	 iatt, idec, islev, irel [, idel]
	kres 	adsr	 iatt, idec, islev, irel [, idel]

--------------------------------------------------------------------------
*adsyn*

Output is an additive set of individually controlled sinusoids, using an oscillator bank.

	ares 	adsyn	 kamod, kfmod, ksmod, ifilcod

--------------------------------------------------------------------------
*adsynt2*

Performs additive synthesis with an arbitrary number of partials -not necessarily harmonic- with interpolation.

	ar 	adsynt2	 kamp, kcps, iwfn, ifreqfn, iampfn, icnt [, iphs]

--------------------------------------------------------------------------
*adsynt*

Performs additive synthesis with an arbitrary number of partials, not necessarily harmonic.

	ares 	adsynt	 kamp, kcps, iwfn, ifreqfn, iampfn, icnt [, iphs]

--------------------------------------------------------------------------
*aftouch*

Get the current after-touch value for this channel.

	kaft 	aftouch	 [imin] [, imax]

--------------------------------------------------------------------------
*alpass*

Reverberates an input signal with a flat frequency response.

	ares 	alpass	 asig, krvt, ilpt [, iskip] [, insmps]

--------------------------------------------------------------------------
*alwayson *

Activates the indicated instrument in the orchestra header, without need for an i statement. Instruments must be activated in the same order as they are defined.

		alwayson 	Tinstrument [p4, ..., pn]

--------------------------------------------------------------------------
*ampdb*

Returns the amplitude equivalent of the decibel value x.

		ampdb	(x) (no rate restriction)

--------------------------------------------------------------------------
*ampdbfs*

Returns the amplitude equivalent (in 16-bit signed integer scale) of the full scale decibel (dB FS) value

		ampdbfs	(x) (no rate restriction)

--------------------------------------------------------------------------
*ampmidi*

Get the velocity of the current MIDI event.

	iamp 	ampmidi	 iscal [, ifn]

--------------------------------------------------------------------------
*areson*

A notch filter whose transfer functions are the complements of the reson opcode.

	ares 	areson	 asig, kcf, kbw [, iscl] [, iskip]

--------------------------------------------------------------------------
*aresonk*

A notch filter whose transfer functions are the complements of the reson opcode.

	kres 	aresonk	 ksig, kcf, kbw [, iscl] [, iskip]

--------------------------------------------------------------------------
*atone*

A hi-pass filter whose transfer functions are the complements of the

	ares 	atone	 asig, khp [, iskip]

--------------------------------------------------------------------------
*atonek*

A hi-pass filter whose transfer functions are the complements of the

	kres 	atonek	 ksig, khp [, iskip]

--------------------------------------------------------------------------
*atonex*

Emulates a stack of filters using the atone opcode.

	ares 	atonex	 asig, khp [, inumlayer] [, iskip]

--------------------------------------------------------------------------
*babo*

A physical model reverberator.

	a1, a2 	babo	 asig, ksrcx, ksrcy, ksrcz, irx, iry, irz [, idiff] [, ifno]

--------------------------------------------------------------------------
*balance*

Adjust one audio signal according to the values of another.

	ares 	balance	 asig, acomp [, ihp] [, iskip]

--------------------------------------------------------------------------
*bamboo*

Semi-physical model of a bamboo sound.

	ares 	bamboo	 kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq] [, ifreq1] [, ifreq2]

--------------------------------------------------------------------------
*barmodel*

Creates a tone similar to a struck metal bar.

	ares 	barmodel	 kbcL, kbcR, iK, ib, kscan, iT30, ipos, ivel, iwid

--------------------------------------------------------------------------
*bbcutm*

Generates breakbeat-style cut-ups of a mono audio stream.

	a1 	bbcutm	 asource, ibps, isubdiv, ibarlength, iphrasebars, inumrepeats [, istutterspeed] [, istutterchance] [, ienvchoice ]

--------------------------------------------------------------------------
*bbcuts*

Generates breakbeat-style cut-ups of a stereo audio stream.

	a1,a2 	bbcuts	 asource1, asource2, ibps, isubdiv, ibarlength, iphrasebars, inumrepeats [, istutterspeed] [, istutterchance] [, ienvchoice]

--------------------------------------------------------------------------
*betarand*

Beta distribution random number generator (positive values only).

	ares 	betarand	 krange, kalpha, kbeta
	ires 	betarand	 krange, kalpha, kbeta
	kres 	betarand	 krange, kalpha, kbeta

--------------------------------------------------------------------------
*bexprnd*

Exponential distribution random number generator.

	ares 	bexprnd	 krange
	ires 	bexprnd	 krange
	kres 	bexprnd	 krange

--------------------------------------------------------------------------
*bformdec1*

Decodes an ambisonic B format signal

	ao1, ao2 	bformdec1	 isetup, aw, ax, ay, az [, ar, as, at, au, av [, abk, al, am, an, ao, ap, aq]]
	ao1, ao2, ao3, ao4 	bformdec1	 isetup, aw, ax, ay, az [, ar, as, at, au, av [, abk, al, am, an, ao, ap, aq]]
	ao1, ao2, ao3, ao4, ao5 	bformdec1	 isetup, aw, ax, ay, az [, ar, as, at, au, av [, abk, al, am, an, ao, ap, aq]]
	ao1, ao2, ao3, ao4, ao5, ao6, ao7, ao8 	bformdec1	 isetup, aw, ax, ay, az [, ar, as, at, au, av [, abk, al, am, an, ao, ap, aq]]]

--------------------------------------------------------------------------
*bformdec*

Deprecated. Decodes an ambisonic B format signal.

	ao1, ao2 	bformdec	 isetup, aw, ax, ay, az [, ar, as, at, au, av [, abk, al, am, an, ao, ap, aq]]
	ao1, ao2, ao3, ao4 	bformdec	 isetup, aw, ax, ay, az [, ar, as, at, au, av [, abk, al, am, an, ao, ap, aq]]
	ao1, ao2, ao3, ao4, ao5 	bformdec	 isetup, aw, ax, ay, az [, ar, as, at, au, av [, abk, al, am, an, ao, ap, aq]]
	ao1, ao2, ao3, ao4, ao5, ao6, ao7, ao8 	bformdec	 isetup, aw, ax, ay, az [, ar, as, at, au, av [, abk, al, am, an, ao, ap, aq]]]

--------------------------------------------------------------------------
*bformenc1*

Codes a signal into the ambisonic B format.

	aw, ax, ay, az 	bformenc1	 asig, kalpha, kbeta
	aw, ax, ay, az, ar, as, at, au, av 	bformenc1	 asig, kalpha, kbeta
	aw, ax, ay, az, ar, as, at, au, av, ak, al, am, an, ao, ap, aq 	bformenc1	 asig, kalpha, kbeta

--------------------------------------------------------------------------
*bformenc*

Deprecated. Codes a signal into the ambisonic B format.

	aw, ax, ay, az 	bformenc	 asig, kalpha, kbeta, kord0, kord1
	aw, ax, ay, az, ar, as, at, au, av 	bformenc	 asig, kalpha, kbeta, kord0, kord1 , kord2
	aw, ax, ay, az, ar, as, at, au, av, ak, al, am, an, ao, ap, aq 	bformenc	 asig, kalpha, kbeta, kord0, kord1, kord2, kord3

--------------------------------------------------------------------------
*binit*

PVS tracks to amplitude+frequency conversion.

	fsig 	binit	 fin, isize

--------------------------------------------------------------------------
*biquad*

A sweepable general purpose biquadratic digital filter.

	ares 	biquad	 asig, kb0, kb1, kb2, ka0, ka1, ka2 [, iskip]

--------------------------------------------------------------------------
*biquada*

A sweepable general purpose biquadratic digital filter with a-rate parameters.

	ares 	biquada	 asig, ab0, ab1, ab2, aa0, aa1, aa2 [, iskip]

--------------------------------------------------------------------------
*birnd*

Returns a random number in a bi-polar range.

		birnd	(x) (init- or control-rate only)

--------------------------------------------------------------------------
*bqrez*

A second-order multi-mode filter.

	ares 	bqrez	 asig, xfco, xres [, imode] [, iskip]

--------------------------------------------------------------------------
*butbp*

Same as the butterbp opcode.

	ares 	butbp	 asig, kfreq, kband [, iskip]

--------------------------------------------------------------------------
*butbr*

Same as the butterbr opcode.

	ares 	butbr	 asig, kfreq, kband [, iskip]

--------------------------------------------------------------------------
*buthp*

Same as the butterhp opcode.

	ares 	buthp	 asig, kfreq [, iskip]

--------------------------------------------------------------------------
*butlp*

Same as the butterlp opcode.

	ares 	butlp	 asig, kfreq [, iskip]

--------------------------------------------------------------------------
*butterbp*

A band-pass Butterworth filter.

	ares 	butterbp	 asig, kfreq, kband [, iskip]

--------------------------------------------------------------------------
*butterbr*

A band-reject Butterworth filter.

	ares 	butterbr	 asig, kfreq, kband [, iskip]

--------------------------------------------------------------------------
*butterhp*

A high-pass Butterworth filter.

	ares 	butterhp	 asig, kfreq [, iskip]

--------------------------------------------------------------------------
*butterlp*

A low-pass Butterworth filter.

	ares 	butterlp	 asig, kfreq [, iskip]

--------------------------------------------------------------------------
*button*

Sense on-screen controls.

	kres 	button	 knum

--------------------------------------------------------------------------
*buzz*

Output is a set of harmonically related sine partials.

	ares 	buzz	 xamp, xcps, knh, ifn [, iphs]

--------------------------------------------------------------------------
*cabasa*

Semi-physical model of a cabasa sound.

	ares 	cabasa	 iamp, idettack [, inum] [, idamp] [, imaxshake]

--------------------------------------------------------------------------
*cauchy*

Cauchy distribution random number generator.

	ares 	cauchy	 kalpha
	ires 	cauchy	 kalpha
	kres 	cauchy	 kalpha

--------------------------------------------------------------------------
*ceil*

Returns the smallest integer not less than

		ceil	(x) (init-, control-, or audio-rate arg allowed)

--------------------------------------------------------------------------
*cent*

Calculates a factor to raise/lower a frequency by a given amount of cents.

		cent	(x) 

--------------------------------------------------------------------------
*cggoto*

Conditionally transfer control on every pass.

		cggoto	 condition, label

--------------------------------------------------------------------------
*chanctrl*

Get the current value of a MIDI channel controller.

	ival 	chanctrl	 ichnl, ictlno [, ilow] [, ihigh]
	kval 	chanctrl	 ichnl, ictlno [, ilow] [, ihigh]

--------------------------------------------------------------------------
*changed*

k-rate signal change detector.

	ktrig 	changed	 kvar1 [, kvar2,..., kvarN]

--------------------------------------------------------------------------
*chani*

Reads data from the software bus

	kval 	chani	 kchan
	aval 	chani	 kchan

--------------------------------------------------------------------------
*chano*

Send data to the outwards software bus

		chano	 kval, kchan
		chano	 aval, kchan

--------------------------------------------------------------------------
*chebyshevpoly*

Efficiently evaluates the sum of Chebyshev polynomials of arbitrary order.

	aout 	chebyshevpoly	 ain, k0 [, k1 [, k2 [...]]]

--------------------------------------------------------------------------
*checkbox*

Sense on-screen controls.

	kres 	checkbox	 knum

--------------------------------------------------------------------------
*chn_S*

Declare a channel of the named software bus.

	 	chn_k	 Sname, imode[, itype, idflt, imin, imax]
	 	chn_a	 Sname, imode
	 	chn_S	 Sname, imode

--------------------------------------------------------------------------
*chnclear*

Clears an audio output channel of the named software bus.

		chnclear	 Sname

--------------------------------------------------------------------------
*chnexport*

Export a global variable as a channel of the bus.

	gival 	chnexport	 Sname, imode[, itype, idflt, imin, imax]
	gkval 	chnexport	 Sname, imode[, itype, idflt, imin, imax]
	gaval 	chnexport	 Sname, imode
	gSval 	chnexport	 Sname, imode

--------------------------------------------------------------------------
*chnget*

Reads data from the software bus.

	ival 	chnget	 Sname
	kval 	chnget	 Sname
	aval 	chnget	 Sname
	Sval 	chnget	 Sname

--------------------------------------------------------------------------
*chnmix*

Writes audio data to the named software bus, mixing to the previous output.

		chnmix	 aval, Sname

--------------------------------------------------------------------------
*chnparams*

Query parameters of a channel.

	itype, imode, ictltype, idflt, imin, imax 	chnparams	

--------------------------------------------------------------------------
*chnrecv*

Recieves data from the software bus.

	ival 	chnrecv	 Sname
	kval 	chnrecv	 Sname
	aval 	chnrecv	 Sname
	Sval 	chnrecv	 Sname

--------------------------------------------------------------------------
*chnsend*

Sends data via the named software bus.

		chnsend	 ival, Sname
		chnsend	 kval, Sname
		chnsend	 aval, Sname
		chnsend	 Sval, Sname

--------------------------------------------------------------------------
*chnset*

Writes data to the named software bus.

		chnset	 ival, Sname
		chnset	 kval, Sname
		chnset	 aval, Sname
		chnset	 Sval, Sname

--------------------------------------------------------------------------
*chuap*

Simulates Chua's oscillator, an LRC oscillator with an active resistor, proved capable of bifurcation and chaotic attractors, with k-rate control of circuit elements.

	aI3, aV2, aV1 	chuap	 kL, kR0, kC1, kG, kGa, kGb, kE, kC2, iI3, iV2, iV1, ktime_step

--------------------------------------------------------------------------
*cigoto*

Conditionally transfer control during the i-time pass.

		cigoto	 condition, label

--------------------------------------------------------------------------
*ckgoto*

Conditionally transfer control during the p-time passes.

		ckgoto	 condition, label

--------------------------------------------------------------------------
*clear*

Zeroes a list of audio signals.

		clear	 avar1 [, avar2] [, avar3] [...]

--------------------------------------------------------------------------
*clfilt*

Implements low-pass and high-pass filters of different styles.

	ares 	clfilt	 asig, kfreq, itype, inpol [, ikind] [, ipbr] [, isba] [, iskip]

--------------------------------------------------------------------------
*clip*

Clips a signal to a predefined limit.

	ares 	clip	 asig, imeth, ilimit [, iarg]

--------------------------------------------------------------------------
*clockoff*

Stops one of a number of internal clocks.

		clockoff	 inum

--------------------------------------------------------------------------
*clockon*

Starts one of a number of internal clocks.

		clockon	 inum

--------------------------------------------------------------------------
*cngoto*

Transfers control on every pass when a condition is not true.

		cngoto	 condition, label

--------------------------------------------------------------------------
*comb*

Reverberates an input signal with a

	ares 	comb	 asig, krvt, ilpt [, iskip] [, insmps]

--------------------------------------------------------------------------
*compress*

Compress, limit, expand, duck or gate an audio signal.

	ar 	compress	 aasig, acsig, kthresh, kloknee, khiknee, kratio, katt, krel, ilook

--------------------------------------------------------------------------
*connect *

Connects the named outlet ports of source instruments to the named inlet ports of sink instruments.

		connect 	Tsource1, Soutlet1, Tsink1, Sinlet1

--------------------------------------------------------------------------
*control*

Configurable slider controls for realtime user input.

	kres 	control	 knum

--------------------------------------------------------------------------
*convolve*

Convolves a signal and an impulse response.

	ar1 [, ar2] [, ar3] [, ar4] 	convolve	 ain, ifilcod [, ichannel]

--------------------------------------------------------------------------
*cos*

Performs a cosine function.

		cos	(x) (no rate restriction)

--------------------------------------------------------------------------
*cosh*

Performs a hyperbolic cosine function.

		cosh	(x) (no rate restriction)

--------------------------------------------------------------------------
*cosinv*

Performs a arccosine function.

		cosinv	(x) (no rate restriction)

--------------------------------------------------------------------------
*cps2pch*

Converts a pitch-class value into cycles-per-second (Hz) for equal divisions of the octave.

	icps 	cps2pch	 ipch, iequal

--------------------------------------------------------------------------
*cpsmidi*

Get the note number of the current MIDI event, expressed in cycles-per-second.

	icps 	cpsmidi	

--------------------------------------------------------------------------
*cpsmidib*

Get the note number of the current MIDI event and modify it by the current pitch-bend value, express it in cycles-per-second.

	icps 	cpsmidib	 [irange]
	kcps 	cpsmidib	 [irange]

--------------------------------------------------------------------------
*cpsmidinn*

Converts a Midi note number value to cycles-per-second.

		cpsmidinn	 (MidiNoteNumber) (init- or control-rate args only)

--------------------------------------------------------------------------
*cpsoct*

Converts an octave-point-decimal value to cycles-per-second.

		cpsoct	 (oct) (no rate restriction)

--------------------------------------------------------------------------
*cpspch*

Converts a pitch-class value to cycles-per-second.

		cpspch	 (pch) (init- or control-rate args only)

--------------------------------------------------------------------------
*cpstmid*

Get a MIDI note number (allows customized micro-tuning scales).

	icps 	cpstmid	 ifn

--------------------------------------------------------------------------
*cpstun*

Returns micro-tuning values at k-rate.

	kcps 	cpstun	 ktrig, kindex, kfn

--------------------------------------------------------------------------
*cpstuni*

Returns micro-tuning values at init-rate.

	icps 	cpstuni	 index, ifn

--------------------------------------------------------------------------
*cpsxpch*

Converts a pitch-class value into cycles-per-second (Hz) for equal divisions of any interval.

	icps 	cpsxpch	 ipch, iequal, irepeat, ibase

--------------------------------------------------------------------------
*cpuprc*

Control allocation of cpu resources on a per-instrument basis, to optimize realtime output.

		cpuprc	 insnum, ipercent

--------------------------------------------------------------------------
*cross2*

Cross synthesis using FFT's.

	ares 	cross2	 ain1, ain2, isize, ioverlap, iwin, kbias

--------------------------------------------------------------------------
*crossfmpmi*

Two mutually frequency and/or phase modulated oscillators.

	a1, a2 	crossfm	 xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]
	a1, a2 	crossfmi	 xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]
	a1, a2 	crosspm	 xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]
	a1, a2 	crosspmi	 xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]
	a1, a2 	crossfmpm	 xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]
	a1, a2 	crossfmpmi	 xfrq1, xfrq2, xndx1, xndx2, kcps, ifn1, ifn2 [, iphs1] [, iphs2]

--------------------------------------------------------------------------
*crunch*

Semi-physical model of a crunch sound.

	ares 	crunch	 iamp, idettack [, inum] [, idamp] [, imaxshake]

--------------------------------------------------------------------------
*cs*

Starts Csound with a set of options that can be controlled by environment variables, and input and output files determined by the specified filename stem.

		cs	 [-OPTIONS] <name> [CSOUND OPTIONS ... ]

--------------------------------------------------------------------------
*csb64enc*

Converts a binary file to a Base64 encoded text file.

		csb64enc	 [OPTIONS ... ] infile1 [ infile2 [ ... ]]

--------------------------------------------------------------------------
*csound -U atsa*

Performs ATS analysis on a soundfile.

		csound -U atsa	 [flags] infilename outfilename

--------------------------------------------------------------------------
*ctrl14*

Allows a floating-point 14-bit MIDI signal scaled with a minimum and a maximum range.

	idest 	ctrl14	 ichan, ictlno1, ictlno2, imin, imax [, ifn]
	kdest 	ctrl14	 ichan, ictlno1, ictlno2, kmin, kmax [, ifn]

--------------------------------------------------------------------------
*ctrl21*

Allows a floating-point 21-bit MIDI signal scaled with a minimum and a maximum range.

	idest 	ctrl21	 ichan, ictlno1, ictlno2, ictlno3, imin, imax [, ifn]
	kdest 	ctrl21	 ichan, ictlno1, ictlno2, ictlno3, kmin, kmax [, ifn]

--------------------------------------------------------------------------
*ctrl7*

Allows a floating-point 7-bit MIDI signal scaled with a minimum and a maximum range.

	idest 	ctrl7	 ichan, ictlno, imin, imax [, ifn]
	kdest 	ctrl7	 ichan, ictlno, kmin, kmax [, ifn]
	adest 	ctrl7	 ichan, ictlno, kmin, kmax [, ifn] [, icutoff]

--------------------------------------------------------------------------
*ctrlinit*

Sets the initial values for a set of MIDI controllers.

		ctrlinit	 ichnl, ictlno1, ival1 [, ictlno2] [, ival2] [, ictlno3] [, ival3] [,...ival32]

--------------------------------------------------------------------------
*cuserrnd*

Continuous USER-defined-distribution RaNDom generator.

	aout 	cuserrnd	 kmin, kmax, ktableNum
	iout 	cuserrnd	 imin, imax, itableNum
	kout 	cuserrnd	 kmin, kmax, ktableNum

--------------------------------------------------------------------------
*cvanal*

Converts a soundfile into a single Fourier transform frame.

		csound -U cvanal	 [flags] infilename outfilename
		cvanal	 [flags] infilename outfilename

--------------------------------------------------------------------------
*dam*

A dynamic compressor/expander.

	ares 	dam	 asig, kthreshold, icomp1, icomp2, irtime, iftime

--------------------------------------------------------------------------
*date*

Returns the number seconds since 1 January 1970.

	ir 	date	

--------------------------------------------------------------------------
*dates*

Returns as a string the date and time specified.

	Sir 	dates	 [ itime]

--------------------------------------------------------------------------
*db*

Returns the amplitude equivalent for a given decibel amount.

		db	(x)

--------------------------------------------------------------------------
*dbamp*

Returns the decibel equivalent of the raw amplitude

		dbamp	(x) (init-rate or control-rate args only)

--------------------------------------------------------------------------
*dbfsamp*

Returns the decibel equivalent of the raw amplitude

		dbfsamp	(x) (init-rate or control-rate args only)

--------------------------------------------------------------------------
*dcblock2*

A DC blocking filter.

	ares 	dcblock2	 ain [, iorder] [, iskip]

--------------------------------------------------------------------------
*dcblock*

A DC blocking filter.

	ares 	dcblock	 ain [, igain]

--------------------------------------------------------------------------
*dconv*

A direct convolution opcode.

	ares 	dconv	 asig, isize, ifn

--------------------------------------------------------------------------
*delay1*

Delays an input signal by one sample.

	ares 	delay1	 asig [, iskip]

--------------------------------------------------------------------------
*delay*

Delays an input signal by some time interval.

	ares 	delay	 asig, idlt [, iskip]

--------------------------------------------------------------------------
*delayr*

Reads from an automatically established digital delay line.

	ares 	delayr	 idlt [, iskip]

--------------------------------------------------------------------------
*delayw*

Writes the audio signal to a digital delay line.

		delayw	 asig

--------------------------------------------------------------------------
*deltap3*

Taps a delay line at variable offset times, uses cubic interpolation.

	ares 	deltap3	 xdlt

--------------------------------------------------------------------------
*deltap*

Taps a delay line at variable offset times.

	ares 	deltap	 kdlt

--------------------------------------------------------------------------
*deltapi*

Taps a delay line at variable offset times, uses interpolation.

	ares 	deltapi	 xdlt

--------------------------------------------------------------------------
*deltapn*

Taps a delay line at variable offset times.

	ares 	deltapn	 xnumsamps

--------------------------------------------------------------------------
*deltapx*

Read from or write to a delay line with interpolation.

	aout 	deltapx	 adel, iwsize

--------------------------------------------------------------------------
*deltapxw*

Mixes the input signal to a delay line.

		deltapxw	 ain, adel, iwsize

--------------------------------------------------------------------------
*denorm*

Mixes low level noise to a list of a-rate signals

		denorm	 a1[, a2[, a3[, ... ]]]

--------------------------------------------------------------------------
*diff*

Modify a signal by differentiation.

	ares 	diff	 asig [, iskip]
	kres 	diff	 ksig [, iskip]

--------------------------------------------------------------------------
*diskgrain*

Synchronous granular synthesis, using a soundfile as source.

	asig 	diskgrain	 Sfname, kamp, kfreq, kpitch, kgrsize, kprate, ifun, iolaps [,imaxgrsize , ioffset]

--------------------------------------------------------------------------
*diskin2*

Reads audio data from a file, and can alter its pitch using one of several available interpolation types, as well as convert the sample rate to match the orchestra sr setting.

	a1[, a2[, ... a24]] 	diskin2	 ifilcod, kpitch[, iskiptim [, iwrap[, iformat [, iwsize[, ibufsize[, iskipinit]]]]]]

--------------------------------------------------------------------------
*diskin*

Deprecated. Reads audio data from an external device or stream and can alter its pitch.

	ar1 [, ar2 [, ar3 [, ... ar24]]] 	diskin	 ifilcod, kpitch [, iskiptim] [, iwraparound] [, iformat] [, iskipinit]

--------------------------------------------------------------------------
*dispfft*

Displays the Fourier Transform of an audio or control signal.

		dispfft	 xsig, iprd, iwsiz [, iwtyp] [, idbout] [, iwtflg]

--------------------------------------------------------------------------
*display*

Displays the audio or control signals as an amplitude vs. time graph.

		display	 xsig, iprd [, inprds] [, iwtflg]

--------------------------------------------------------------------------
*distort1*

Modified hyperbolic tangent distortion.

	ares 	distort1	 asig, kpregain, kpostgain, kshape1, kshape2[, imode]

--------------------------------------------------------------------------
*distort*

Distort an audio signal via waveshaping and optional clipping.

	ar 	distort	 asig, kdist, ifn[, ihp, istor]

--------------------------------------------------------------------------
*divz*

Safely divides two numbers.

	ares 	divz	 xa, xb, ksubst
	ires 	divz	 ia, ib, isubst
	kres 	divz	 ka, kb, ksubst

--------------------------------------------------------------------------
*dnoise*

Reduces noise in a file.

		dnoise	 [flags] -i noise_ref_file -o output_soundfile input_soundfile

--------------------------------------------------------------------------
*doppler*

A fast and robust method for approximating sound propagation, achieving convincing Doppler shifts without having to solve equations.

	ashifted 	doppler	 asource, ksourceposition, kmicposition [, isoundspeed, ifiltercutoff]

--------------------------------------------------------------------------
*downsamp*

Modify a signal by down-sampling.

	kres 	downsamp	 asig [, iwlen]

--------------------------------------------------------------------------
*dripwater*

Semi-physical model of a water drop.

	ares 	dripwater	 kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq] [, ifreq1] [, ifreq2]

--------------------------------------------------------------------------
*dssiactivate*

Activates or deactivates a DSSI or LADSPA plugin.

		dssiactivate	 ihandle, ktoggle 

--------------------------------------------------------------------------
*dssiaudio*

Processes audio using a LADSPA or DSSI plugin.

	aout1 [, aout2, aout3, aout4] 	dssiaudio	 ihandle, ain1 [,ain2, ain3, ain4] 

--------------------------------------------------------------------------
*dssictls*

Send control information to a LADSPA or DSSI plugin.

		dssictls	 ihandle, iport, kvalue, ktrigger 

--------------------------------------------------------------------------
*dssiinit*

Loads a DSSI or LADSPA plugin.

	ihandle 	dssiinit	 ilibraryname, iplugindex [, iverbose] 

--------------------------------------------------------------------------
*dssilist*

Lists all available DSSI and LADSPA plugins.

		dssilist	

--------------------------------------------------------------------------
*dumpk2*

Periodically writes two orchestra control-signal values to an external file.

		dumpk2	 ksig1, ksig2, ifilname, iformat, iprd

--------------------------------------------------------------------------
*dumpk3*

Periodically writes three orchestra control-signal values to an external file.

		dumpk3	 ksig1, ksig2, ksig3, ifilname, iformat, iprd

--------------------------------------------------------------------------
*dumpk4*

Periodically writes four orchestra control-signal values to an external file.

		dumpk4	 ksig1, ksig2, ksig3, ksig4, ifilname, iformat, iprd

--------------------------------------------------------------------------
*dumpk*

Periodically writes an orchestra control-signal value to an external file.

		dumpk	 ksig, ifilname, iformat, iprd

--------------------------------------------------------------------------
*duserrnd*

Discrete USER-defined-distribution RaNDom generator.

	aout 	duserrnd	 ktableNum
	iout 	duserrnd	 itableNum
	kout 	duserrnd	 ktableNum

--------------------------------------------------------------------------
*else*

Executes a block of code when an "if...then" condition is false.

		else	

--------------------------------------------------------------------------
*endif*

Closes a block of code that begins with an "if...then" statement.

		endif	

--------------------------------------------------------------------------
*endin*

Ends the current instrument block.

		endin	

--------------------------------------------------------------------------
*endop*

Marks the end of an user-defined opcode block.

		endop	

--------------------------------------------------------------------------
*envext*

Extracts the envelope of a file to a text file.

		envext	 [-flags] soundfile
	csound -U 	envext	 [-flags] soundfile

--------------------------------------------------------------------------
*envlpx*

Applies an envelope consisting of 3 segments.

	ares 	envlpx	 xamp, irise, idur, idec, ifn, iatss, iatdec [, ixmod]
	kres 	envlpx	 kamp, irise, idur, idec, ifn, iatss, iatdec [, ixmod]

--------------------------------------------------------------------------
*envlpxr*

The

	ares 	envlpxr	 xamp, irise, idec, ifn, iatss, iatdec [, ixmod] [,irind]
	kres 	envlpxr	 kamp, irise, idec, ifn, iatss, iatdec [, ixmod] [,irind]

--------------------------------------------------------------------------
*eqfil*

Equalizer filter

	asig 	eqfil	 ain, kcf, kbw, kgain[, istor]

--------------------------------------------------------------------------
*event*

Generates a score event from an instrument.

		event	 "scorechar", kinsnum, kdelay, kdur, [, kp4] [, kp5] [, ...]
		event	 "scorechar", "insname", kdelay, kdur, [, kp4] [, kp5] [, ...]

--------------------------------------------------------------------------
*event_i*

Generates a score event from an instrument.

		event_i	 "scorechar", iinsnum, idelay, idur, [, ip4] [, ip5] [, ...]
		event_i	 "scorechar", "insname", idelay, idur, [, ip4] [, ip5] [, ...]

--------------------------------------------------------------------------
*exitnow*

Exit Csound as fast as possible, with no cleaning up.

		exitnow	

--------------------------------------------------------------------------
*exp*

Returns e raised to the x-th power.

		exp	(x) (no rate restriction)

--------------------------------------------------------------------------
*expcurve*

This opcode implements a formula for generating a normalised exponential curve in range 0 - 1. It is based on the Max / MSP work of Eric Singer (c) 1994.

	kout 	expcurve	 kindex, ksteepness

--------------------------------------------------------------------------
*expon*

Trace an exponential curve between specified points.

	ares 	expon	 ia, idur, ib
	kres 	expon	 ia, idur, ib

--------------------------------------------------------------------------
*exprand*

Exponential distribution random number generator (positive values only).

	ares 	exprand	 klambda
	ires 	exprand	 klambda
	kres 	exprand	 klambda

--------------------------------------------------------------------------
*expseg*

Trace a series of exponential segments between specified points.

	ares 	expseg	 ia, idur1, ib [, idur2] [, ic] [...]
	kres 	expseg	 ia, idur1, ib [, idur2] [, ic] [...]

--------------------------------------------------------------------------
*expsega*

An exponential segment generator operating at a-rate.

	ares 	expsega	 ia, idur1, ib [, idur2] [, ic] [...]

--------------------------------------------------------------------------
*expsegr*

Trace a series of exponential segments between specified points including a release segment.

	ares 	expsegr	 ia, idur1, ib [, idur2] [, ic] [...], irel, iz
	kres 	expsegr	 ia, idur1, ib [, idur2] [, ic] [...], irel, iz

--------------------------------------------------------------------------
*extractor*

Extract a section of audio from an audio file.

		extractor	 [OPTIONS ... ] infile

--------------------------------------------------------------------------
*ficlose*

Closes a previously opened file.

		ficlose	 ihandle
		ficlose	 Sfilename

--------------------------------------------------------------------------
*filebit*

Returns the number of bits in each sample in a sound file.

	ir 	filebit	 ifilcod [, iallowraw]

--------------------------------------------------------------------------
*filelen*

Returns the length of a sound file.

	ir 	filelen	 ifilcod, [iallowraw]

--------------------------------------------------------------------------
*filenchnls*

Returns the number of channels in a sound file.

	ir 	filenchnls	 ifilcod [, iallowraw]

--------------------------------------------------------------------------
*filepeak*

Returns the peak absolute value of a sound file.

	ir 	filepeak	 ifilcod [, ichnl]

--------------------------------------------------------------------------
*filesr*

Returns the sample rate of a sound file.

	ir 	filesr	 ifilcod [, iallowraw]

--------------------------------------------------------------------------
*filter2*

Performs filtering using a transposed form-II digital filter lattice with no time-varying control.

	ares 	filter2	 asig, iM, iN, ib0, ib1, ..., ibM, ia1, ia2, ..., iaN
	kres 	filter2	 ksig, iM, iN, ib0, ib1, ..., ibM, ia1, ia2, ..., iaN

--------------------------------------------------------------------------
*fin*

Read signals from a file at a-rate.

		fin	 ifilename, iskipframes, iformat, ain1 [, ain2] [, ain3] [,...]

--------------------------------------------------------------------------
*fini*

Read signals from a file at i-rate.

		fini	 ifilename, iskipframes, iformat, in1 [, in2] [, in3] [, ...]

--------------------------------------------------------------------------
*fink*

Read signals from a file at k-rate.

		fink	 ifilename, iskipframes, iformat, kin1 [, kin2] [, kin3] [,...]

--------------------------------------------------------------------------
*fiopen*

Opens a file in a specific mode.

	ihandle 	fiopen	 ifilename, imode

--------------------------------------------------------------------------
*flanger*

A user controlled flanger.

	ares 	flanger	 asig, adel, kfeedback [, imaxd]

--------------------------------------------------------------------------
*flashtxt*

Allows text to be displayed from instruments like sliders

		flashtxt	 iwhich, String

--------------------------------------------------------------------------
*flooper2*

Function-table-based crossfading looper.

	asig 	flooper2	 kamp, kpitch, kloopstart, kloopend, kcrossfade, ifn [, istart, imode, ifenv, iskip]

--------------------------------------------------------------------------
*flooper*

Function-table-based crossfading looper.

	asig 	flooper	 kamp, kpitch, istart, idur, ifad, ifn

--------------------------------------------------------------------------
*floor*

Returns the largest integer not greater than

		floor	(x) (init-, control-, or audio-rate arg allowed)

--------------------------------------------------------------------------
*fluidAllOut*

Collects all audio from all Fluidsynth engines in a performance

	aleft, aright 	fluidAllOut	

--------------------------------------------------------------------------
*fluidCCi*

Sends a MIDI controller data message to fluid.

		fluidCCi	 iEngineNumber, iChannelNumber, iControllerNumber, iValue

--------------------------------------------------------------------------
*fluidCCk*

Sends a MIDI controller data message to fluid.

		fluidCCk	 iEngineNumber, iChannelNumber, iControllerNumber, kValue

--------------------------------------------------------------------------
*fluidControl*

Sends MIDI note on, note off, and other messages to a SoundFont preset.

		fluidControl	 ienginenum, kstatus, kchannel, kdata1, kdata2

--------------------------------------------------------------------------
*fluidEngine*

Instantiates a fluidsynth engine.

	ienginenum 	fluidEngine	 [iReverbEnabled] [, iChorusEnabled] [,iNumChannels] [, iPolyphony] 

--------------------------------------------------------------------------
*fluidLoad*

Loads a SoundFont into a fluidEngine, optionally listing SoundFont contents.

	isfnum 	fluidLoad	 soundfont, ienginenum[, ilistpresets]

--------------------------------------------------------------------------
*fluidNote*

Plays a note on a channel in a fluidSynth engine.

		fluidNote	 ienginenum, ichannelnum, imidikey, imidivel

--------------------------------------------------------------------------
*fluidOut*

Outputs sound from a given fluidEngine

	aleft, aright 	fluidOut	 ienginenum

--------------------------------------------------------------------------
*fluidProgramSelect*

Assigns a preset from a SoundFont to a channel on a fluidEngine.

		fluidProgramSelect	 ienginenum, ichannelnum, isfnum, ibanknum, ipresetnum

--------------------------------------------------------------------------
*fluidSetInterpMethod*

Set interpolation method for channel in Fluid Engine

		fluidSetInterpMethod	 ienginenum, ichannelnum, iInterpMethod

--------------------------------------------------------------------------
*fmb3*

Uses FM synthesis to create a Hammond B3 organ sound.

	ares 	fmb3	 kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3, ifn4, ivfn

--------------------------------------------------------------------------
*fmbell*

Uses FM synthesis to create a tublar bell sound.

	ares 	fmbell	 kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3, ifn4, ivfn

--------------------------------------------------------------------------
*fmmetal*

Uses FM synthesis to create a

	ares 	fmmetal	 kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3, ifn4, ivfn

--------------------------------------------------------------------------
*fmpercfl*

Uses FM synthesis to create a percussive flute sound.

	ares 	fmpercfl	 kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3, ifn4, ivfn

--------------------------------------------------------------------------
*fmrhode*

Uses FM synthesis to create a Fender Rhodes electric piano sound.

	ares 	fmrhode	 kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3, ifn4, ivfn

--------------------------------------------------------------------------
*fmvoice*

FM Singing Voice Synthesis

	ares 	fmvoice	 kamp, kfreq, kvowel, ktilt, kvibamt, kvibrate, ifn1, ifn2, ifn3, ifn4, ivibfn

--------------------------------------------------------------------------
*fmwurlie*

Uses FM synthesis to create a Wurlitzer electric piano sound.

	ares 	fmwurlie	 kamp, kfreq, kc1, kc2, kvdepth, kvrate, ifn1, ifn2, ifn3, ifn4, ivfn

--------------------------------------------------------------------------
*fof2*

Produces sinusoid bursts including k-rate incremental indexing with each successive burst.

	ares 	fof2	 xamp, xfund, xform, koct, kband, kris, kdur, kdec, iolaps, ifna, ifnb, itotdur, kphs, kgliss [, iskip]

--------------------------------------------------------------------------
*fof*

Produces sinusoid bursts useful for formant and granular synthesis.

	ares 	fof	 xamp, xfund, xform, koct, kband, kris, kdur, kdec, iolaps, ifna, ifnb, itotdur [, iphs] [, ifmode] [, iskip]

--------------------------------------------------------------------------
*fofilter*

Formant filter.

	asig 	fofilter	 ain, kcf, kris, kdec[, istor]

--------------------------------------------------------------------------
*fog*

Audio output is a succession of grains derived from data in a stored function table

	ares 	fog	 xamp, xdens, xtrans, aspd, koct, kband, kris, kdur, kdec, iolaps, ifna, ifnb, itotdur [, iphs] [, itmode] [, iskip]

--------------------------------------------------------------------------
*fold*

Adds artificial foldover to an audio signal.

	ares 	fold	 asig, kincr

--------------------------------------------------------------------------
*follow2*

Another controllable envelope extractor.

	ares 	follow2	 asig, katt, krel

--------------------------------------------------------------------------
*follow*

Envelope follower unit generator.

	ares 	follow	 asig, idt

--------------------------------------------------------------------------
*foscil*

A basic frequency modulated oscillator.

	ares 	foscil	 xamp, kcps, xcar, xmod, kndx, ifn [, iphs]

--------------------------------------------------------------------------
*foscili*

Basic frequency modulated oscillator with linear interpolation.

	ares 	foscili	 xamp, kcps, xcar, xmod, kndx, ifn [, iphs]

--------------------------------------------------------------------------
*fout*

Outputs a-rate signals to an arbitrary number of channels.

		fout	 ifilename, iformat, aout1 [, aout2, aout3,...,aoutN]

--------------------------------------------------------------------------
*fouti*

Outputs i-rate signals of an arbitrary number of channels to a specified file.

		fouti	 ihandle, iformat, iflag, iout1 [, iout2, iout3,....,ioutN]

--------------------------------------------------------------------------
*foutir*

Outputs i-rate signals from an arbitrary number of channels to a specified file.

		foutir	 ihandle, iformat, iflag, iout1 [, iout2, iout3,....,ioutN]

--------------------------------------------------------------------------
*foutk*

Outputs k-rate signals of an arbitrary number of channels to a specified file, in raw (headerless) format.

		foutk	 ifilename, iformat, kout1 [, kout2, kout3,....,koutN]

--------------------------------------------------------------------------
*fprintks*

Similar to printks but prints to a file.

		fprintks	 "filename", "string", [, kval1] [, kval2] [...]

--------------------------------------------------------------------------
*fprints*

Similar to prints but prints to a file.

		fprints	 "filename", "string" [, ival1] [, ival2] [...]

--------------------------------------------------------------------------
*frac*

Returns the fractional part of a decimal number.

		frac	(x) (init-rate or control-rate args; also works at audio rate in Csound5)

--------------------------------------------------------------------------
*freeverb*

Opcode version of Jezar's Freeverb

	aoutL, aoutR 	freeverb	 ainL, ainR, kRoomSize, kHFDamp[, iSRate[, iSkip]] 

--------------------------------------------------------------------------
*ftchnls*

Returns the number of channels in a stored function table.

		ftchnls	(x) (init-rate args only)

--------------------------------------------------------------------------
*ftconv*

Low latency multichannel convolution, using a function table as impulse response source.

	a1[, a2[, a3[, ... a8]]] 	ftconv	 ain, ift, iplen[, iskipsamples [, iirlen[, iskipinit]]]

--------------------------------------------------------------------------
*ftfree*

Deletes function table.

		ftfree	 ifno, iwhen

--------------------------------------------------------------------------
*ftgen*

Generate a score function table from within the orchestra.

	gir 	ftgen	 ifn, itime, isize, igen, iarga [, iargb ] [...]

--------------------------------------------------------------------------
*ftgenonce*

Generate a function table from within an instrument definition, without duplication of data.

	ifno 	ftgenonce	 ip1dummy, ip2dummy, isize, igen, iarga, iargb, ...

--------------------------------------------------------------------------
*ftgentmp*

Generate a score function table from within the orchestra, which is deleted at the end of the note.

	ifno 	ftgentmp	 ip1, ip2dummy, isize, igen, iarga, iargb, ...

--------------------------------------------------------------------------
*ftlen*

Returns the size of a stored function table.

		ftlen	(x) (init-rate args only)

--------------------------------------------------------------------------
*ftload*

Load a set of previously-allocated tables from a file.

		ftload	 "filename", iflag, ifn1 [, ifn2] [...]

--------------------------------------------------------------------------
*ftloadk*

Load a set of previously-allocated tables from a file.

		ftloadk	 "filename", ktrig, iflag, ifn1 [, ifn2] [...]

--------------------------------------------------------------------------
*ftlptim*

Returns the loop segment start-time of a stored function table number.

		ftlptim	(x) (init-rate args only)

--------------------------------------------------------------------------
*ftmorf*

Morphs between multiple ftables as specified in a list.

		ftmorf	 kftndx, iftfn, iresfn

--------------------------------------------------------------------------
*ftsave*

Save a set of previously-allocated tables to a file.

		ftsave	 "filename", iflag, ifn1 [, ifn2] [...]

--------------------------------------------------------------------------
*ftsavek*

Save a set of previously-allocated tables to a file.

		ftsavek	 "filename", ktrig, iflag, ifn1 [, ifn2] [...]

--------------------------------------------------------------------------
*ftsr*

Returns the sampling-rate of a stored function table.

		ftsr	(x) (init-rate args only)

--------------------------------------------------------------------------
*gain*

Adjusts the amplitude audio signal according to a root-mean-square value.

	ares 	gain	 asig, krms [, ihp] [, iskip]

--------------------------------------------------------------------------
*gainslider*

An implementation of a logarithmic gain curve which is similar to the gainslider~ object from Cycling 74 Max / MSP.

	kout 	gainslider	 kindex

--------------------------------------------------------------------------
*gauss*

Gaussian distribution random number generator.

	ares 	gauss	 krange
	ires 	gauss	 krange
	kres 	gauss	 krange

--------------------------------------------------------------------------
*gbuzz*

Output is a set of harmonically related cosine partials.

	ares 	gbuzz	 xamp, xcps, knh, klh, kmul, ifn [, iphs]

--------------------------------------------------------------------------
*getcfg*

Return Csound settings.

	Svalue 	getcfg	 iopt

--------------------------------------------------------------------------
*gogobel*

Audio output is a tone related to the striking of a cow bell or similar.

	ares 	gogobel	 kamp, kfreq, ihrd, ipos, imp, kvibf, kvamp, ivfn

--------------------------------------------------------------------------
*goto*

Transfer control on every pass.

		goto	 label

--------------------------------------------------------------------------
*grain2*

Easy-to-use granular synthesis texture generator.

	ares 	grain2	 kcps, kfmd, kgdur, iovrlp, kfn, iwfn [, irpow] [, iseed] [, imode]

--------------------------------------------------------------------------
*grain3*

Generate granular synthesis textures with more user control.

	ares 	grain3	 kcps, kphs, kfmd, kpmd, kgdur, kdens, imaxovr, kfn, iwfn, kfrpow, kprpow [, iseed] [, imode]

--------------------------------------------------------------------------
*grain*

Generates granular synthesis textures.

	ares 	grain	 xamp, xpitch, xdens, kampoff, kpitchoff, kgdur, igfn, iwfn, imgdur [, igrnd]

--------------------------------------------------------------------------
*granule*

A more complex granular synthesis texture generator.

	ares 	granule	 xamp, ivoice, iratio, imode, ithd, ifn, ipshift, igskip, igskip_os, ilength, kgap, igap_os, kgsize, igsize_os, iatt, idec [, iseed] [, ipitch1] [, ipitch2] [, ipitch3] [, ipitch4] [, ifnenv]

--------------------------------------------------------------------------
*guiro*

Semi-physical model of a guiro sound.

	ares 	guiro	 kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq] [, ifreq1]

--------------------------------------------------------------------------
*harmon4*

Analyze an audio input and generate harmonizing voices in synchrony with formants preserved.

	ares 	harmon2	 asig, koct, kfrq1, kfrq2, icpsmode, ilowest[, ipolarity]
	ares 	harmon3	 asig, koct, kfrq1, kfrq2, kfrq3, icpsmode, ilowest[, ipolarity]
	ares 	harmon4	 asig, koct, kfrq1, kfrq2, kfrq3, kfrq4, icpsmode, ilowest[, ipolarity]

--------------------------------------------------------------------------
*harmon*

Analyze an audio input and generate harmonizing voices in synchrony.

	ares 	harmon	 asig, kestfrq, kmaxvar, kgenfreq1, kgenfreq2, imode, iminfrq, iprd

--------------------------------------------------------------------------
*het_export*

Converts a .het file to a comma separated text file.

		het_export	 het_file cstext_file
	csound -U 	het_export	 het_file cstext_file

--------------------------------------------------------------------------
*het_import*

Converts a comma-separated text file to a .het file.

		het_import	 cstext_file het_file
	csound -U 	het_import	 cstext_file het_file

--------------------------------------------------------------------------
*hetro*

Decomposes an input soundfile into component sinusoids.

		csound -U hetro	 [flags] infilename outfilename
		hetro	 [flags] infilename outfilename

--------------------------------------------------------------------------
*hilbert*

A Hilbert transformer.

	ar1, ar2 	hilbert	 asig

--------------------------------------------------------------------------
*hrtfer*

Creates 3D audio for two speakers.

	aleft, aright 	hrtfer	 asig, kaz, kelev, <quote>HRTFcompact</quote>

--------------------------------------------------------------------------
*hrtfmove2*

Generates dynamic 3d binaural audio for headphones using a Woodworth based spherical head model with improved low frequency phase accuracy.

	aleft, aright 	hrtfmove2	 asrc, kAz, kElev, ifilel, ifiler [,ioverlap, iradius, isr]

--------------------------------------------------------------------------
*hrtfmove*

Generates dynamic 3d binaural audio for headphones using magnitude interpolation and phase truncation.

	aleft, aright 	hrtfmove	 asrc, kAz, kElev, ifilel, ifiler [, imode, ifade, isr]

--------------------------------------------------------------------------
*hrtfstat*

Generates static 3d binaural audio for headphones using a Woodworth based spherical head model with improved low frequency phase accuracy.

	 aleft, aright 	hrtfstat	 asrc, iAz, iElev, ifilel, ifiler [,iradius, isr] 

--------------------------------------------------------------------------
*hsboscil*

An oscillator which takes tonality and brightness as arguments.

	ares 	hsboscil	 kamp, ktone, kbrite, ibasfreq, iwfn, ioctfn [, ioctcnt] [, iphs]

--------------------------------------------------------------------------
*hvs1*

Allows one-dimensional Hyper Vectorial Synthesis (HVS) controlled by externally-updated k-variables.

		hvs1	 kx, inumParms, inumPointsX, iOutTab, iPositionsTab, iSnapTab [, iConfigTab]

--------------------------------------------------------------------------
*hvs2*

Allows two-dimensional Hyper Vectorial Synthesis (HVS) controlled by externally-updated k-variables.

		hvs2	 kx, ky, inumParms, inumPointsX, iOutTab, iPositionsTab, iSnapTab [, iConfigTab]

--------------------------------------------------------------------------
*hvs3*

Allows three-dimensional Hyper Vectorial Synthesis (HVS) controlled by externally-updated k-variables.

		hvs3	 kx, ky, kz, inumParms, inumPointsX, iOutTab, iPositionsTab, iSnapTab [, iConfigTab]

--------------------------------------------------------------------------
*i*

Returns an init-type equivalent of a k-rate argument.

		i	(x) (control-rate args only)

--------------------------------------------------------------------------
*igoto*

Transfer control during the i-time pass.

		igoto	 label

--------------------------------------------------------------------------
*ihold*

Creates a held note.

		ihold	

--------------------------------------------------------------------------
*imagecreate*

Create an empty image of a given size.

	iimagenum 	imagecreate	 iwidth, iheight

--------------------------------------------------------------------------
*imagefree*

Frees memory allocated for a previously loaded or created image.

		imagefree	 iimagenum

--------------------------------------------------------------------------
*imagegetpixel*

Return the RGB pixel values of a previously opened or created image.

	ared agreen ablue 	imagegetpixel	 iimagenum, ax, ay
	kred kgreen kblue 	imagegetpixel	 iimagenum, kx, ky

--------------------------------------------------------------------------
*imagegetpixel*

Set the RGB value of a pixel inside a previously opened or created image.

		imagegetpixel	 iimagenum, ax, ay, ared, agreen, ablue
		imagegetpixel	 iimagenum, kx, ky, kred, kgreen, kblue

--------------------------------------------------------------------------
*imageload*

Load an image.

	iimagenum 	imageload	 filename

--------------------------------------------------------------------------
*imagesave*

Save a previously created image.

		imagesave	 iimagenum, filename

--------------------------------------------------------------------------
*imagesize*

Return the width and height of a previously opened or created image.

	iwidth iheight 	imagesize	 iimagenum

--------------------------------------------------------------------------
*in32*

Reads a 32-channel audio signal from an external device or stream.

	ar1, ar2, ar3, ar4, ar5, ar6, ar7, ar8, ar9, ar10, ar11, ar12, ar13, ar14, ar15, ar16, ar17, ar18, ar19, ar20, ar21, ar22, ar23, ar24, ar25, ar26, ar27, ar28, ar29, ar30, ar31, ar32 	in32	

--------------------------------------------------------------------------
*in*

Reads mono audio data from an external device or stream.

	ar1 	in	

--------------------------------------------------------------------------
*inch*

Reads from a numbered channel in an external audio signal or stream.

	ain 	inch	 kchan

--------------------------------------------------------------------------
*inh*

Reads six-channel audio data from an external device or stream.

	ar1, ar2, ar3, ar4, ar5, ar6 	inh	

--------------------------------------------------------------------------
*init*

Puts the value of the i-time expression into a k- or a-rate variable.

	ares 	init	 iarg
	ires 	init	 iarg
	kres 	init	 iarg
	ares, ... 	init	 iarg, ...
	ires, ... 	init	 iarg, ...
	kres, ...	init	 iarg, ...

--------------------------------------------------------------------------
*initc14*

Initializes the controllers used to create a 14-bit MIDI value.

		initc14	 ichan, ictlno1, ictlno2, ivalue

--------------------------------------------------------------------------
*initc21*

Initializes the controllers used to create a 21-bit MIDI value.

		initc21	 ichan, ictlno1, ictlno2, ictlno3, ivalue

--------------------------------------------------------------------------
*initc7*

Initializes the controller used to create a 7-bit MIDI value.

		initc7	 ichan, ictlno, ivalue

--------------------------------------------------------------------------
*inleta *

Receives an arate signal into an instrument through a named port.

	asignal 	inleta 	Sname

--------------------------------------------------------------------------
*inletf *

Receives an frate signal (fsig) into an instrument from a named port.

	fsignal 	inletf 	Sname

--------------------------------------------------------------------------
*inletk *

Receives a krate signal into an instrument from a named port.

	ksignal 	inletk 	Sname

--------------------------------------------------------------------------
*ino*

Reads eight-channel audio data from an external device or stream.

	ar1, ar2, ar3, ar4, ar5, ar6, ar7, ar8 	ino	

--------------------------------------------------------------------------
*inq*

Reads quad audio data from an external device or stream.

	ar1, ar2, ar3, a4 	inq	

--------------------------------------------------------------------------
*inrg*

Allow input from a range of adjacent audio channels from the audio input device

		inrg	 kstart, ain1 [,ain2, ain3, ..., ainN]

--------------------------------------------------------------------------
*ins*

Reads stereo audio data from an external device or stream.

	ar1, ar2 	ins	

--------------------------------------------------------------------------
*insglobal*

An opcode which can be used to implement a remote orchestra. This opcode will send note events from a source machine to many destinations.

		insglobal	isource, instrnum [,instrnum...] 

--------------------------------------------------------------------------
*insremot*

An opcode which can be used to implement a remote orchestra. This opcode will send note events from a source machine to one destination.

		insremot	idestination, isource, instrnum [,instrnum...] 

--------------------------------------------------------------------------
*instr*

Starts an instrument block.

		instr	 i, j, ...

--------------------------------------------------------------------------
*int*

Extracts an integer from a decimal number.

		int	(x) (init-rate or control-rate; also works at audio rate in Csound5)

--------------------------------------------------------------------------
*integ*

Modify a signal by integration.

	ares 	integ	 asig [, iskip]
	kres 	integ	 ksig [, iskip]

--------------------------------------------------------------------------
*interp*

Converts a control signal to an audio signal using linear interpolation.

	ares 	interp	 ksig [, iskip] [, imode]

--------------------------------------------------------------------------
*invalue*

Reads a k-rate signal from a user-defined channel.

	kvalue 	invalue	 "channel name"
	Sname 	invalue	 "channel name"

--------------------------------------------------------------------------
*inx*

Reads a 16-channel audio signal from an external device or stream.

	ar1, ar2, ar3, ar4, ar5, ar6, ar7, ar8, ar9, ar10, ar11, ar12, ar13, ar14, ar15, ar16 	inx	

--------------------------------------------------------------------------
*inz*

Reads multi-channel audio samples into a ZAK array from an external device or stream.

		inz	 ksig1

--------------------------------------------------------------------------
*jacktransport*

Start/stop jack_transport and can optionally relocate the playback head.

		jacktransport	 icommand [, ilocation]

--------------------------------------------------------------------------
*jitter2*

Generates a segmented line with user-controllable random segments.

	kout 	jitter2	 ktotamp, kamp1, kcps1, kamp2, kcps2, kamp3, kcps3

--------------------------------------------------------------------------
*jitter*

Generates a segmented line whose segments are randomly generated.

	kout 	jitter	 kamp, kcpsMin, kcpsMax

--------------------------------------------------------------------------
*jspline*

A jitter-spline generator.

	ares 	jspline	 xamp, kcpsMin, kcpsMax
	kres 	jspline	 kamp, kcpsMin, kcpsMax

--------------------------------------------------------------------------
*k*

Converts a i-rate parameter to an k-rate value.

		k	(x) (i-rate args only)

--------------------------------------------------------------------------
*kgoto*

Transfer control during the p-time passes.

		kgoto	 label

--------------------------------------------------------------------------
*kr*

Sets the control rate.

		kr	 = iarg

--------------------------------------------------------------------------
*ksmps*

Sets the number of samples in a control period.

		ksmps	 = iarg

--------------------------------------------------------------------------
*ktableseg*

Deprecated.

		ktableseg	 ifn1, idur1, ifn2 [, idur2] [, ifn3] [...]

--------------------------------------------------------------------------
*lfo*

A low frequency oscillator of various shapes.

	kres 	lfo	 kamp, kcps [, itype]
	ares 	lfo	 kamp, kcps [, itype]

--------------------------------------------------------------------------
*limit*

Sets the lower and upper limits of the value it processes.

	ares 	limit	 asig, klow, khigh
	ires 	limit	 isig, ilow, ihigh
	kres 	limit	 ksig, klow, khigh

--------------------------------------------------------------------------
*line*

Trace a straight line between specified points.

	ares 	line	 ia, idur, ib
	kres 	line	 ia, idur, ib

--------------------------------------------------------------------------
*linen*

Applies a straight line rise and decay pattern to an input amp signal.

	ares 	linen	 xamp, irise, idur, idec
	kres 	linen	 kamp, irise, idur, idec

--------------------------------------------------------------------------
*linenr*

The

	ares 	linenr	 xamp, irise, idec, iatdec
	kres 	linenr	 kamp, irise, idec, iatdec

--------------------------------------------------------------------------
*lineto*

Generate glissandos starting from a control signal.

	kres 	lineto	 ksig, ktime

--------------------------------------------------------------------------
*linrand*

Linear distribution random number generator (positive values only).

	ares 	linrand	 krange
	ires 	linrand	 krange
	kres 	linrand	 krange

--------------------------------------------------------------------------
*linseg*

Trace a series of line segments between specified points.

	ares 	linseg	 ia, idur1, ib [, idur2] [, ic] [...]
	kres 	linseg	 ia, idur1, ib [, idur2] [, ic] [...]

--------------------------------------------------------------------------
*linsegr*

Trace a series of line segments between specified points including a release segment.

	ares 	linsegr	 ia, idur1, ib [, idur2] [, ic] [...], irel, iz
	kres 	linsegr	 ia, idur1, ib [, idur2] [, ic] [...], irel, iz

--------------------------------------------------------------------------
*locsend*

Distributes the audio signals of a previous

	a1, a2 	locsend	
	a1, a2, a3, a4 	locsend	

--------------------------------------------------------------------------
*locsig*

Takes and input signal and distributes between 2 or 4 channels.

	a1, a2 	locsig	 asig, kdegree, kdistance, kreverbsend
	a1, a2, a3, a4 	locsig	 asig, kdegree, kdistance, kreverbsend

--------------------------------------------------------------------------
*log10*

Returns a base 10 log.

		log10	(x) (no rate restriction)

--------------------------------------------------------------------------
*log*

Returns a natural log.

		log	(x) (no rate restriction)

--------------------------------------------------------------------------
*logbtwo*

Performs a logarithmic base two calculation.

		logbtwo	(x) (init-rate or control-rate args only)

--------------------------------------------------------------------------
*logcurve*

This opcode implements a formula for generating a normalised logarithmic curve in range 0 - 1. It is based on the Max / MSP work of Eric Singer (c) 1994.

	kout 	logcurve	 kindex, ksteepness

--------------------------------------------------------------------------
*loop_ge*

Looping constructions.

		loop_ge	 indx, idecr, imin, label
		loop_ge	 kndx, kdecr, kmin, label

--------------------------------------------------------------------------
*loop_gt*

Looping constructions.

		loop_gt	 indx, idecr, imin, label
		loop_gt	 kndx, kdecr, kmin, label

--------------------------------------------------------------------------
*loop_le*

Looping constructions.

		loop_le	 indx, incr, imax, label
		loop_le	 kndx, kncr, kmax, label

--------------------------------------------------------------------------
*loop_lt*

Looping constructions.

		loop_lt	 indx, incr, imax, label
		loop_lt	 kndx, kncr, kmax, label

--------------------------------------------------------------------------
*loopseg*

Generate control signal consisting of linear segments delimited by two or more specified points.

	ksig 	loopseg	 kfreq, ktrig, ktime0, kvalue0 [, ktime1] [, kvalue1] [, ktime2] [, kvalue2] [...]

--------------------------------------------------------------------------
*loopsegp*

Control signals based on linear segments.

	ksig 	loopsegp	 kphase, kvalue0, kdur0, kvalue1 [, kdur1, ... , kdurN-1, kvalueN]

--------------------------------------------------------------------------
*looptseg*

Generate control signal consisting of exponential or linear segments delimited by two or more specified points.

	ksig 	looptseg	 kfreq, ktrig, ktime0, kvalue0, ktype, [, ktime1] [,ktype1] [, kvalue1] [, ktime2] [,ktype2] [, kvalue2] [...]

--------------------------------------------------------------------------
*loopxseg*

Generate control signal consisting of exponential segments delimited by two or more specified points.

	ksig 	loopxseg	 kfreq, ktrig, ktime0, kvalue0 [, ktime1] [, kvalue1] [, ktime2] [, kvalue2] [...]

--------------------------------------------------------------------------
*lorenz*

Implements the Lorenz system of equations.

	ax, ay, az 	lorenz	 ksv, krv, kbv, kh, ix, iy, iz, iskip [, iskipinit]

--------------------------------------------------------------------------
*lorismorph*

Morphs two stored sets of bandwidth-enhanced partials and stores a new set of partials representing the morphed sound. The morph is performed by linearly interpolating the parameter envelopes (frequency, amplitude, and bandwidth, or noisiness) of the bandwidth-enhanced partials according to control-rate frequency, amplitude, and bandwidth morphing functions.

		lorismorph	 isrcidx, itgtidx, istoreidx, kfreqmorphenv, kampmorphenv, kbwmorphenv

--------------------------------------------------------------------------
*lorisplay*

renders a stored set of bandwidth-enhanced partials using the method of Bandwidth-Enhanced Additive Synthesis implemented in the Loris software, applying control-rate frequency, amplitude, and bandwidth scaling envelopes.

	ar 	lorisplay	 ireadidx, kfreqenv, kampenv, kbwenv

--------------------------------------------------------------------------
*lorisread*

Imports a set of bandwidth-enhanced partials from a SDIF-format data file, applying control-rate frequency, amplitude, and bandwidth scaling envelopes, and stores the modified partials in memory.

		lorisread	 ktimpnt, ifilcod, istoreidx, kfreqenv, kampenv, kbwenv[, ifadetime]

--------------------------------------------------------------------------
*loscil3*

Read sampled sound from a table using cubic interpolation.

	ar1 [,ar2] 	loscil3	 xamp, kcps, ifn [, ibas] [, imod1] [, ibeg1] [, iend1] [, imod2] [, ibeg2] [, iend2]

--------------------------------------------------------------------------
*loscil*

Read sampled sound from a table.

	ar1 [,ar2] 	loscil	 xamp, kcps, ifn [, ibas] [, imod1] [, ibeg1] [, iend1] [, imod2] [, ibeg2] [, iend2]

--------------------------------------------------------------------------
*loscilx*

Loop oscillator.

	ar1 [, ar2, ar3, ar4, ar5, ar6, ar7, ar8, ar9, ar10, ar11, ar12, ar13, ar14, ar15, ar16] 	loscilx	 xamp, kcps, ifn [, iwsize, ibas, istrt, imod1, ibeg1, iend1]

--------------------------------------------------------------------------
*lowpass2*

A resonant lowpass filter.

	ares 	lowpass2	 asig, kcf, kq [, iskip]

--------------------------------------------------------------------------
*lowres*

Another resonant lowpass filter.

	ares 	lowres	 asig, kcutoff, kresonance [, iskip]

--------------------------------------------------------------------------
*lowresx*

Simulates layers of serially connected resonant lowpass filters.

	ares 	lowresx	 asig, kcutoff, kresonance [, inumlayer] [, iskip]

--------------------------------------------------------------------------
*lpanal*

Performs both linear predictive and pitch-tracking analysis on a soundfile.

		csound -U lpanal	 [flags] infilename outfilename
		lpanal	 [flags] infilename outfilename

--------------------------------------------------------------------------
*lpf18*

A 3-pole sweepable resonant lowpass filter.

	ares 	lpf18	 asig, kfco, kres, kdist

--------------------------------------------------------------------------
*lpfreson*

Resynthesises a signal from the data passed internally by a previous lpread, applying formant shifting.

	ares 	lpfreson	 asig, kfrqratio

--------------------------------------------------------------------------
*lphasor*

Generates a table index for sample playback

	ares 	lphasor	 xtrns [, ilps] [, ilpe] [, imode] [, istrt] [, istor]

--------------------------------------------------------------------------
*lpinterp*

Computes a new set of poles from the interpolation between two analysis.

		lpinterp	 islot1, islot2, kmix

--------------------------------------------------------------------------
*lposcil3*

Read sampled sound from a table with high precision and cubic interpolation.

	ares 	lposcil3	 kamp, kfreqratio, kloop, kend, ifn [, iphs]

--------------------------------------------------------------------------
*lposcil*

Read sampled sound from a table with optional looping and high precision.

	ares 	lposcil	 kamp, kfreqratio, kloop, kend, ifn [, iphs]

--------------------------------------------------------------------------
*lposcila*

Read sampled sound from a table with optional looping and high precision.

	ar 	lposcila	 aamp, kfreqratio, kloop, kend, ift [,iphs] 

--------------------------------------------------------------------------
*lposcilsa2*

Read stereo sampled sound from a table with optional looping and high precision.

	ar1, ar2 	lposcilsa2	 aamp, kfreqratio, kloop, kend, ift [,iphs] 

--------------------------------------------------------------------------
*lposcilsa*

Read stereo sampled sound from a table with optional looping and high precision.

	ar1, ar2 	lposcilsa	 aamp, kfreqratio, kloop, kend, ift [,iphs] 

--------------------------------------------------------------------------
*lpread*

Reads a control file of time-ordered information frames.

	krmsr, krmso, kerr, kcps 	lpread	 ktimpnt, ifilcod [, inpoles] [, ifrmrate]

--------------------------------------------------------------------------
*lpreson*

Resynthesises a signal from the data passed internally by a previous lpread.

	ares 	lpreson	 asig

--------------------------------------------------------------------------
*lpshold*

Generate control signal consisting of held segments.

	ksig 	lpshold	 kfreq, ktrig, ktime0, kvalue0 [, ktime1] [, kvalue1] [, ktime2] [, kvalue2] [...]

--------------------------------------------------------------------------
*lpsholdp*

Control signals based on held segments.

	ksig 	lpsholdp	 kphase, ktrig, ktime0, kvalue0 [, ktime1] [, kvalue1] [, ktime2] [, kvalue2] [...]

--------------------------------------------------------------------------
*lpslot*

Selects the slot to be use by further lp opcodes.

		lpslot	 islot

--------------------------------------------------------------------------
*mac*

Multiplies and accumulates a- and k-rate signals.

	ares 	mac	 asig1, ksig1 [, asig2] [, ksig2] [, asig3] [, ksig3] [...]

--------------------------------------------------------------------------
*maca*

Multiply and accumulate a-rate signals only.

	ares 	maca	 asig1 , asig2 [, asig3] [, asig4] [, asig5] [...]

--------------------------------------------------------------------------
*madsr*

Calculates the classical ADSR envelope using the

	ares 	madsr	 iatt, idec, islev, irel [, idel] [, ireltim]
	kres 	madsr	 iatt, idec, islev, irel [, idel] [, ireltim]

--------------------------------------------------------------------------
*makecsd*

Creates a CSD file from the specified input files.

		makecsd	 [OPTIONS ... ] infile1 [ infile2 [ ... ]]

--------------------------------------------------------------------------
*mandel*

Mandelbrot set

	kiter, koutrig 	mandel	 ktrig, kx, ky, kmaxIter

--------------------------------------------------------------------------
*mandol*

An emulation of a mandolin.

	ares 	mandol	 kamp, kfreq, kpluck, kdetune, kgain, ksize, ifn [, iminfreq]

--------------------------------------------------------------------------
*marimba*

Physical model related to the striking of a wooden block.

	ares 	marimba	 kamp, kfreq, ihrd, ipos, imp, kvibf, kvamp, ivibfn, idec [, idoubles] [, itriples]

--------------------------------------------------------------------------
*massign*

Assigns a MIDI channel number to a Csound instrument.

		massign	 ichnl, insnum[, ireset]
		massign	 ichnl, "insname"[, ireset]

--------------------------------------------------------------------------
*max*

Produces a signal that is the maximum of any number of input signals.

	amax 	max	 ain1 [, ain2] [, ain3] [, ain4] [...]
	kmax 	max	 kin1 [, kin2] [, kin3] [, kin4] [...]

--------------------------------------------------------------------------
*max_k*

Local maximum (or minimum) value of an incoming asig signal

	knumkout 	max_k	 asig, ktrig, itype

--------------------------------------------------------------------------
*maxabs*

Produces a signal that is the maximum of the absolute values of any number of input signals.

	amax 	maxabs	 ain1 [, ain2] [, ain3] [, ain4] [...]
	kmax 	maxabs	 kin1 [, kin2] [, kin3] [, kin4] [...]

--------------------------------------------------------------------------
*maxabsaccum*

Accumulates the maximum of the absolute values of audio signals.

		maxabsaccum	 aAccumulator, aInput

--------------------------------------------------------------------------
*maxaccum*

Accumulates the maximum value of audio signals.

		maxaccum	 aAccumulator, aInput

--------------------------------------------------------------------------
*maxalloc*

Limits the number of allocations of an instrument.

		maxalloc	 insnum, icount

--------------------------------------------------------------------------
*mclock*

Sends a MIDI CLOCK message.

		mclock	 ifreq

--------------------------------------------------------------------------
*mdelay*

A MIDI delay opcode.

		mdelay	 kstatus, kchan, kd1, kd2, kdelay

--------------------------------------------------------------------------
*metro*

Trigger Metronome

	ktrig 	metro	 kfreq [, initphase]

--------------------------------------------------------------------------
*midglobal*

An opcode which can be used to implement a remote midi orchestra. This opcode will broadcast the midi events to all the machines involved in the remote concert.

		midglobal	isource, instrnum [,instrnum...] 

--------------------------------------------------------------------------
*midic14*

Allows a floating-point 14-bit MIDI signal scaled with a minimum and a maximum range.

	idest 	midic14	 ictlno1, ictlno2, imin, imax [, ifn]
	kdest 	midic14	 ictlno1, ictlno2, kmin, kmax [, ifn]

--------------------------------------------------------------------------
*midic21*

Allows a floating-point 21-bit MIDI signal scaled with a minimum and a maximum range.

	idest 	midic21	 ictlno1, ictlno2, ictlno3, imin, imax [, ifn]
	kdest 	midic21	 ictlno1, ictlno2, ictlno3, kmin, kmax [, ifn]

--------------------------------------------------------------------------
*midic7*

Allows a floating-point 7-bit MIDI signal scaled with a minimum and a maximum range.

	idest 	midic7	 ictlno, imin, imax [, ifn]
	kdest 	midic7	 ictlno, kmin, kmax [, ifn]

--------------------------------------------------------------------------
*midichannelaftertouch*

Gets a MIDI channel's aftertouch value.

		midichannelaftertouch	 xchannelaftertouch [, ilow] [, ihigh]

--------------------------------------------------------------------------
*midichn*

Returns the MIDI channel number from which the note was activated.

	ichn 	midichn	

--------------------------------------------------------------------------
*midicontrolchange*

Gets a MIDI control change value.

		midicontrolchange	 xcontroller, xcontrollervalue [, ilow] [, ihigh]

--------------------------------------------------------------------------
*midictrl*

Get the current value (0-127) of a specified MIDI controller.

	ival 	midictrl	 inum [, imin] [, imax]
	kval 	midictrl	 inum [, imin] [, imax]

--------------------------------------------------------------------------
*mididefault*

Changes values, depending on MIDI activation.

		mididefault	 xdefault, xvalue

--------------------------------------------------------------------------
*midiin*

Returns a generic MIDI message received by the MIDI IN port.

	kstatus, kchan, kdata1, kdata2 	midiin	

--------------------------------------------------------------------------
*midinoteoff*

Gets a MIDI noteoff value.

		midinoteoff	 xkey, xvelocity

--------------------------------------------------------------------------
*midinoteoncps*

Gets a MIDI note number as a cycles-per-second frequency.

		midinoteoncps	 xcps, xvelocity

--------------------------------------------------------------------------
*midinoteonkey*

Gets a MIDI note number value.

		midinoteonkey	 xkey, xvelocity

--------------------------------------------------------------------------
*midinoteonoct*

Gets a MIDI note number value as octave-point-decimal value.

		midinoteonoct	 xoct, xvelocity

--------------------------------------------------------------------------
*midinoteonpch*

Gets a MIDI note number as a pitch-class value.

		midinoteonpch	 xpch, xvelocity

--------------------------------------------------------------------------
*midion2*

Sends noteon and noteoff messages to the MIDI OUT port.

		midion2	 kchn, knum, kvel, ktrig

--------------------------------------------------------------------------
*midion*

Generates MIDI note messages at k-rate.

		midion	 kchn, knum, kvel

--------------------------------------------------------------------------
*midiout*

Sends a generic MIDI message to the MIDI OUT port.

		midiout	 kstatus, kchan, kdata1, kdata2

--------------------------------------------------------------------------
*midipitchbend*

Gets a MIDI pitchbend value.

		midipitchbend	 xpitchbend [, ilow] [, ihigh]

--------------------------------------------------------------------------
*midipolyaftertouch*

Gets a MIDI polyphonic aftertouch value.

		midipolyaftertouch	 xpolyaftertouch, xcontrollervalue [, ilow] [, ihigh]

--------------------------------------------------------------------------
*midiprogramchange*

Gets a MIDI program change value.

		midiprogramchange	 xprogram

--------------------------------------------------------------------------
*miditempo*

Returns the current tempo at k-rate, of either the MIDI file (if available) or the score

	ksig 	miditempo	

--------------------------------------------------------------------------
*midremot*

An opcode which can be used to implement a remote midi orchestra. This opcode will send midi events from a source machine to one destination.

		midremot	idestination, isource, instrnum [,instrnum...] 

--------------------------------------------------------------------------
*min*

Produces a signal that is the minimum of any number of input signals.

	amin 	min	 ain1 [, ain2] [, ain3] [, ain4] [...]
	kmin 	min	 kin1 [, kin2] [, kin3] [, kin4] [...]

--------------------------------------------------------------------------
*minabs*

Produces a signal that is the minimum of the absolute values of any number of input signals.

	amin 	minabs	 ain1 [, ain2] [, ain3] [, ain4] [...]
	kmin 	minabs	 kin1 [, kin2] [, kin3] [, kin4] [...]

--------------------------------------------------------------------------
*minabsaccum*

Accumulates the minimum of the absolute values of audio signals.

		minabsaccum	 aAccumulator, aInput

--------------------------------------------------------------------------
*minaccum*

Accumulates the minimum value of audio signals.

		minaccum	 aAccumulator, aInput

--------------------------------------------------------------------------
*mirror*

Reflects the signal that exceeds the low and high thresholds.

	ares 	mirror	 asig, klow, khigh
	ires 	mirror	 isig, ilow, ihigh
	kres 	mirror	 ksig, klow, khigh

--------------------------------------------------------------------------
*mixer*

Mixes together a number of soundfiles.

		mixer	 [OPTIONS ... ] infile [[OPTIONS... ] infile] ...

--------------------------------------------------------------------------
*mode*

A filter that simulates a mass-spring-damper system

	aout 	mode	 ain, kfreq, kQ [, iskip]

--------------------------------------------------------------------------
*modmatrix*

Modulation matrix opcode with optimizations for sparse matrices.

		modmatrix	 iresfn, isrcmodfn, isrcparmfn, imodscale, inum_mod,\inum_parm, kupdate

--------------------------------------------------------------------------
*monitor*

Returns the audio spout frame.

	aout1 [,aout2 ... aoutX] 	monitor	

--------------------------------------------------------------------------
*moog*

An emulation of a mini-Moog synthesizer.

	ares 	moog	 kamp, kfreq, kfiltq, kfiltrate, kvibf, kvamp, iafn, iwfn, ivfn

--------------------------------------------------------------------------
*moogladder*

Moog ladder lowpass filter.

	asig 	moogladder	 ain, kcf, kres[, istor]

--------------------------------------------------------------------------
*moogvcf2*

A digital emulation of the Moog diode ladder filter configuration.

	ares 	moogvcf2	 asig, xfco, xres [,iscale, iskip]

--------------------------------------------------------------------------
*moogvcf*

A digital emulation of the Moog diode ladder filter configuration.

	ares 	moogvcf	 asig, xfco, xres [,iscale, iskip]

--------------------------------------------------------------------------
*moscil*

Sends a stream of the MIDI notes.

		moscil	 kchn, knum, kvel, kdur, kpause

--------------------------------------------------------------------------
*mp3in*

Reads stereo audio data from an external MP3 file.

	ar1, ar2 	mp3in	 ifilcod, iskptim, iformat, iskipinit, ibufsize

--------------------------------------------------------------------------
*mpulse*

Generates a set of impulses.

	ares 	mpulse	 kamp, kintvl [, ioffset]

--------------------------------------------------------------------------
*mrtmsg*

Send system real-time messages to the MIDI OUT port.

		mrtmsg	 imsgtype

--------------------------------------------------------------------------
*multitap*

Multitap delay line implementation.

	ares 	multitap	 asig [, itime1] [, igain1] [, itime2] [, igain2] [...]

--------------------------------------------------------------------------
*mute*

Mutes/unmutes new instances of a given instrument.

		mute	 insnum [, iswitch]
		mute	 "insname" [, iswitch]

--------------------------------------------------------------------------
*mxadsr*

Calculates the classical ADSR envelope using the

	ares 	mxadsr	 iatt, idec, islev, irel [, idel] [, ireltim]
	kres 	mxadsr	 iatt, idec, islev, irel [, idel] [, ireltim]

--------------------------------------------------------------------------
*nchnls*

Sets the number of channels of audio output.

		nchnls	 = iarg

--------------------------------------------------------------------------
*nestedap*

Three different nested all-pass filters.

	ares 	nestedap	 asig, imode, imaxdel, idel1, igain1 [, idel2] [, igain2] [, idel3] [, igain3] [, istor]

--------------------------------------------------------------------------
*newopcodename*

Short description. Single line for opcode listing.

	outarg1, outarg2 	newopcodename	 inarg1, inarg2

--------------------------------------------------------------------------
*nlfilt*

A filter with a non-linear effect.

	ares 	nlfilt	 ain, ka, kb, kd, kC, kL

--------------------------------------------------------------------------
*noise*

A white noise generator with an IIR lowpass filter.

	ares 	noise	 xamp, kbeta

--------------------------------------------------------------------------
*noteoff*

Send a noteoff message to the MIDI OUT port.

		noteoff	 ichn, inum, ivel

--------------------------------------------------------------------------
*noteon*

Send a noteon message to the MIDI OUT port.

		noteon	 ichn, inum, ivel

--------------------------------------------------------------------------
*noteondur2*

Sends a noteon and a noteoff MIDI message both with the same channel, number and velocity.

		noteondur2	 ichn, inum, ivel, idur

--------------------------------------------------------------------------
*noteondur*

Sends a noteon and a noteoff MIDI message both with the same channel, number and velocity.

		noteondur	 ichn, inum, ivel, idur

--------------------------------------------------------------------------
*notnum*

Get a note number from a MIDI event.

	ival 	notnum	

--------------------------------------------------------------------------
*nreverb*

A reverberator consisting of 6 parallel comb-lowpass filters.

	ares 	nreverb	 asig, ktime, khdif [, iskip] [,inumCombs] [, ifnCombs] [, inumAlpas] [, ifnAlpas]

--------------------------------------------------------------------------
*nrpn*

Sends a Non-Registered Parameter Number to the MIDI OUT port.

		nrpn	 kchan, kparmnum, kparmvalue

--------------------------------------------------------------------------
*nsamp*

Returns the number of samples loaded into a stored function table number.

		nsamp	(x) (init-rate args only)

--------------------------------------------------------------------------
*nstrnum*

Returns the number of a named instrument.

	insno 	nstrnum	 "name"

--------------------------------------------------------------------------
*ntrpol*

Calculates the weighted mean value of two input signals.

	ares 	ntrpol	 asig1, asig2, kpoint [, imin] [, imax]
	ires 	ntrpol	 isig1, isig2, ipoint [, imin] [, imax]
	kres 	ntrpol	 ksig1, ksig2, kpoint [, imin] [, imax]

--------------------------------------------------------------------------
*octave*

Calculates a factor to raise/lower a frequency by a given amount of octaves.

		octave	(x)

--------------------------------------------------------------------------
*octcps*

Converts a cycles-per-second value to octave-point-decimal.

		octcps	 (cps) (init- or control-rate args only)

--------------------------------------------------------------------------
*octmidi*

Get the note number, in octave-point-decimal units, of the current MIDI event.

	ioct 	octmidi	

--------------------------------------------------------------------------
*octmidib*

Get the note number of the current MIDI event and modify it by the current pitch-bend value, express it in octave-point-decimal.

	ioct 	octmidib	 [irange]
	koct 	octmidib	 [irange]

--------------------------------------------------------------------------
*octmidinn*

Converts a Midi note number value to octave-point-decimal.

		octmidinn	 (MidiNoteNumber) (init- or control-rate args only)

--------------------------------------------------------------------------
*octpch*

Converts a pitch-class value to octave-point-decimal.

		octpch	 (pch) (init- or control-rate args only)

--------------------------------------------------------------------------
*opcode*

Defines the start of user-defined opcode block.

		opcode	 name, outtypes, intypes

--------------------------------------------------------------------------
*oscbnk*

Mixes the output of any number of oscillators.

	ares 	oscbnk	 kcps, kamd, kfmd, kpmd, iovrlap, iseed, kl1minf, kl1maxf, kl2minf, kl2maxf, ilfomode, keqminf, keqmaxf, keqminl, keqmaxl, keqminq, keqmaxq, ieqmode, kfn [, il1fn] [, il2fn] [, ieqffn] [, ieqlfn] [, ieqqfn] [, itabl] [, ioutfn]

--------------------------------------------------------------------------
*oscil1*

Accesses table values by incremental sampling.

	kres 	oscil1	 idel, kamp, idur, ifn

--------------------------------------------------------------------------
*oscil1i*

Accesses table values by incremental sampling with linear interpolation.

	kres 	oscil1i	 idel, kamp, idur, ifn

--------------------------------------------------------------------------
*oscil3*

A simple oscillator with cubic interpolation.

	ares 	oscil3	 xamp, xcps, ifn [, iphs]
	kres 	oscil3	 kamp, kcps, ifn [, iphs]

--------------------------------------------------------------------------
*oscil*

A simple oscillator.

	ares 	oscil	 xamp, xcps, ifn [, iphs]
	kres 	oscil	 kamp, kcps, ifn [, iphs]

--------------------------------------------------------------------------
*oscili*

A simple oscillator with linear interpolation.

	ares 	oscili	 xamp, xcps, ifn [, iphs]
	kres 	oscili	 kamp, kcps, ifn [, iphs]

--------------------------------------------------------------------------
*oscilikt*

A linearly interpolated oscillator that allows changing the table number at k-rate.

	ares 	oscilikt	 xamp, xcps, kfn [, iphs] [, istor]
	kres 	oscilikt	 kamp, kcps, kfn [, iphs] [, istor]

--------------------------------------------------------------------------
*osciliktp*

A linearly interpolated oscillator that allows allows phase modulation.

	ares 	osciliktp	 kcps, kfn, kphs [, istor]

--------------------------------------------------------------------------
*oscilikts*

A linearly interpolated oscillator with sync status that allows changing the table number at k-rate.

	ares 	oscilikts	 xamp, xcps, kfn, async, kphs [, istor]

--------------------------------------------------------------------------
*osciln*

Accesses table values at a user-defined frequency.

	ares 	osciln	 kamp, ifrq, ifn, itimes

--------------------------------------------------------------------------
*oscils*

A simple, fast sine oscillator

	ares 	oscils	 iamp, icps, iphs [, iflg]

--------------------------------------------------------------------------
*out32*

Writes 32-channel audio data to an external device or stream.

		out32	 asig1, asig2, asig3, asig4, asig5, asig6, asig7, asig8, asig10, asig11, asig12, asig13, asig14, asig15, asig16, asig17, asig18, asig19, asig20, asig21, asig22, asig23, asig24, asig25, asig26, asig27, asig28, asig29, asig30, asig31, asig32

--------------------------------------------------------------------------
*out*

Writes mono audio data to an external device or stream.

		out	 asig

--------------------------------------------------------------------------
*outc*

Writes audio data with an arbitrary number of channels to an external device or stream.

		outc	 asig1 [, asig2] [...]

--------------------------------------------------------------------------
*outch*

Writes multi-channel audio data, with user-controllable channels, to an external device or stream.

		outch	 kchan1, asig1 [, kchan2] [, asig2] [...]

--------------------------------------------------------------------------
*outh*

Writes 6-channel audio data to an external device or stream.

		outh	 asig1, asig2, asig3, asig4, asig5, asig6

--------------------------------------------------------------------------
*outiat*

Sends MIDI aftertouch messages at i-rate.

		outiat	 ichn, ivalue, imin, imax

--------------------------------------------------------------------------
*outic14*

Sends 14-bit MIDI controller output at i-rate.

		outic14	 ichn, imsb, ilsb, ivalue, imin, imax

--------------------------------------------------------------------------
*outic*

Sends MIDI controller output at i-rate.

		outic	 ichn, inum, ivalue, imin, imax

--------------------------------------------------------------------------
*outipat*

Sends polyphonic MIDI aftertouch messages at i-rate.

		outipat	 ichn, inotenum, ivalue, imin, imax

--------------------------------------------------------------------------
*outipb*

Sends MIDI pitch-bend messages at i-rate.

		outipb	 ichn, ivalue, imin, imax

--------------------------------------------------------------------------
*outipc*

Sends MIDI program change messages at i-rate

		outipc	 ichn, iprog, imin, imax

--------------------------------------------------------------------------
*outkat*

Sends MIDI aftertouch messages at k-rate.

		outkat	 kchn, kvalue, kmin, kmax

--------------------------------------------------------------------------
*outkc14*

Sends 14-bit MIDI controller output at k-rate.

		outkc14	 kchn, kmsb, klsb, kvalue, kmin, kmax

--------------------------------------------------------------------------
*outkc*

Sends MIDI controller messages at k-rate.

		outkc	 kchn, knum, kvalue, kmin, kmax

--------------------------------------------------------------------------
*outkpat*

Sends polyphonic MIDI aftertouch messages at k-rate.

		outkpat	 kchn, knotenum, kvalue, kmin, kmax

--------------------------------------------------------------------------
*outkpb*

Sends MIDI pitch-bend messages at k-rate.

		outkpb	 kchn, kvalue, kmin, kmax

--------------------------------------------------------------------------
*outkpc*

Sends MIDI program change messages at k-rate.

		outkpc	 kchn, kprog, kmin, kmax

--------------------------------------------------------------------------
*outleta *

Sends an arate signal out from an instrument to a named port.

		outleta 	Sname, asignal

--------------------------------------------------------------------------
*outletf *

Sends a frate signal (fsig) out from an instrument to a named port.

		outletf 	Sname, fsignal

--------------------------------------------------------------------------
*outletk *

Sends a krate signal out from an instrument to a named port.

		outletk 	Sname, ksignal

--------------------------------------------------------------------------
*outo*

Writes 8-channel audio data to an external device or stream.

		outo	 asig1, asig2, asig3, asig4, asig5, asig6, asig7, asig8

--------------------------------------------------------------------------
*outq1*

Writes samples to quad channel 1 of an external device or stream.

		outq1	 asig

--------------------------------------------------------------------------
*outq2*

Writes samples to quad channel 2 of an external device or stream.

		outq2	 asig

--------------------------------------------------------------------------
*outq3*

Writes samples to quad channel 3 of an external device or stream.

		outq3	 asig

--------------------------------------------------------------------------
*outq4*

Writes samples to quad channel 4 of an external device or stream.

		outq4	 asig

--------------------------------------------------------------------------
*outq*

Writes 4-channel audio data to an external device or stream.

		outq	 asig1, asig2, asig3, asig4

--------------------------------------------------------------------------
*outrg*

Allow output to a range of adjacent audio channels on the audio output device

		outrg	 kstart, aout1 [,aout2, aout3, ..., aoutN]

--------------------------------------------------------------------------
*outs1*

Writes samples to stereo channel 1 of an external device or stream.

		outs1	 asig

--------------------------------------------------------------------------
*outs2*

Writes samples to stereo channel 2 of an external device or stream.

		outs2	 asig

--------------------------------------------------------------------------
*outs*

Writes stereo audio data to an external device or stream.

		outs	 asig1, asig2

--------------------------------------------------------------------------
*outvalue*

Sends a k-rate signal or string to a user-defined channel.

		outvalue	 "channel name", kvalue
		outvalue	 "channel name", "string"

--------------------------------------------------------------------------
*outx*

Writes 16-channel audio data to an external device or stream.

		outx	 asig1, asig2, asig3, asig4, asig5, asig6, asig7, asig8, asig9, asig10, asig11, asig12, asig13, asig14, asig15, asig16

--------------------------------------------------------------------------
*outz*

Writes multi-channel audio data from a ZAK array to an external device or stream.

		outz	 ksig1

--------------------------------------------------------------------------
*p5gconnect*

Reads data from a P5 Glove controller.

		p5gconnect	

--------------------------------------------------------------------------
*p5gdata*

Reads data fields from an external P5 Glove.

	kres 	p5gdata	 kcontrol

--------------------------------------------------------------------------
*p*

Show the value in a given p-field.

		p	(x) 

--------------------------------------------------------------------------
*pan2*

Distribute an audio signal across two channels.

	a1, a2 	pan2	 asig, xp [, imode]

--------------------------------------------------------------------------
*pan*

Distribute an audio signal amongst four channels.

	a1, a2, a3, a4 	pan	 asig, kx, ky, ifn [, imode] [, ioffset]

--------------------------------------------------------------------------
*pareq*

Implementation of Zoelzer's parametric equalizer filters.

	ares 	pareq	 asig, kc, kv, kq [, imode] [, iskip]

--------------------------------------------------------------------------
*partials*

Partial track spectral analysis.

	ftrks 	partials	 ffr, fphs, kthresh, kminpts, kmaxgap, imaxtracks

--------------------------------------------------------------------------
*partikkel*

Granular synthesizer with "per grain" control over many of its parameters. Has a sync input to sychronize its internal grain scheduler clock to an external clock source.

	a1 [, a2, a3, a4, a5, a6, a7, a8] 	partikkel	 agrainfreq, kdistribution, idisttab, async, kenv2amt, ienv2tab, ienv_attack, ienv_decay, ksustain_amount, ka_d_ratio, kduration, kamp, igainmasks, kwavfreq, ksweepshape, iwavfreqstarttab, iwavfreqendtab, awavfm, ifmamptab, kfmenv, icosine, ktraincps, knumpartials, kchroma, ichannelmasks, krandommask, kwaveform1, kwaveform2, kwaveform3, kwaveform4, iwaveamptab, asamplepos1, asamplepos2, asamplepos3, asamplepos4, kwavekey1, kwavekey2, kwavekey3, kwavekey4, imax_grains [, iopcode_id]

--------------------------------------------------------------------------
*partikkelsync*

Outputs

	async [,aphase] 	partikkelsync	 iopcode_id

--------------------------------------------------------------------------
*passign*

Assigns a range of p-fields to ivariables.

	 ivar1, ... 	passign	 [istart]

--------------------------------------------------------------------------
*pcauchy*

Cauchy distribution random number generator (positive values only).

	ares 	pcauchy	 kalpha
	ires 	pcauchy	 kalpha
	kres 	pcauchy	 kalpha

--------------------------------------------------------------------------
*pchbend*

Get the current pitch-bend value for this channel.

	ibend 	pchbend	 [imin] [, imax]
	kbend 	pchbend	 [imin] [, imax]

--------------------------------------------------------------------------
*pchmidi*

Get the note number of the current MIDI event, expressed in pitch-class units.

	ipch 	pchmidi	

--------------------------------------------------------------------------
*pchmidib*

Get the note number of the current MIDI event and modify it by the current pitch-bend value, express it in pitch-class units.

	ipch 	pchmidib	 [irange]
	kpch 	pchmidib	 [irange]

--------------------------------------------------------------------------
*pchmidinn*

Converts a Midi note number value to octave point pitch-class units.

		pchmidinn	 (MidiNoteNumber) (init- or control-rate args only)

--------------------------------------------------------------------------
*pchoct*

Converts an octave-point-decimal value to pitch-class.

		pchoct	 (oct) (init- or control-rate args only)

--------------------------------------------------------------------------
*pconvolve*

Convolution based on a uniformly partitioned overlap-save algorithm

	ar1 [, ar2] [, ar3] [, ar4] 	pconvolve	 ain, ifilcod [, ipartitionsize, ichannel]

--------------------------------------------------------------------------
*pcount*

Returns the number of pfields belonging to a note event.

	icount 	pcount	

--------------------------------------------------------------------------
*pdclip*

Performs linear clipping on an audio signal or a phasor.

	aout 	pdclip	 ain, kWidth, kCenter [, ibipolar [, ifullscale]]

--------------------------------------------------------------------------
*pdhalf*

Distorts a phasor for reading the two halves of a table at different rates.

	aout 	pdhalf	 ain, kShapeAmount [, ibipolar [, ifullscale]]

--------------------------------------------------------------------------
*pdhalfy*

Distorts a phasor for reading two unequal portions of a table in equal periods.

	aout 	pdhalfy	 ain, kShapeAmount [, ibipolar [, ifullscale]]

--------------------------------------------------------------------------
*peak*

Maintains the output equal to the highest absolute value received.

	kres 	peak	 asig
	kres 	peak	 ksig

--------------------------------------------------------------------------
*pgmassign*

Assigns an instrument number to a specified MIDI program.

		pgmassign	 ipgm, inst[, ichn]
		pgmassign	 ipgm, "insname"[, ichn]

--------------------------------------------------------------------------
*phaser1*

First-order allpass filters arranged in a series.

	ares 	phaser1	 asig, kfreq, kord, kfeedback [, iskip]

--------------------------------------------------------------------------
*phaser2*

Second-order allpass filters arranged in a series.

	ares 	phaser2	 asig, kfreq, kq, kord, kmode, ksep, kfeedback

--------------------------------------------------------------------------
*phasor*

Produce a normalized moving phase value.

	ares 	phasor	 xcps [, iphs]
	kres 	phasor	 kcps [, iphs]

--------------------------------------------------------------------------
*phasorbnk*

Produce an arbitrary number of normalized moving phase values.

	ares 	phasorbnk	 xcps, kndx, icnt [, iphs]
	kres 	phasorbnk	 kcps, kndx, icnt [, iphs]

--------------------------------------------------------------------------
*pindex*

Returns the value of a specified pfield.

	ivalue 	pindex	 ipfieldIndex

--------------------------------------------------------------------------
*pinkish*

Generates approximate pink noise.

	ares 	pinkish	 xin [, imethod] [, inumbands] [, iseed] [, iskip]

--------------------------------------------------------------------------
*pitch*

Tracks the pitch of a signal.

	koct, kamp 	pitch	 asig, iupdte, ilo, ihi, idbthresh [, ifrqs] [, iconf] [, istrt] [, iocts] [, iq] [, inptls] [, irolloff] [, iskip]

--------------------------------------------------------------------------
*pitchamdf*

Follows the pitch of a signal based on the AMDF method.

	kcps, krms 	pitchamdf	 asig, imincps, imaxcps [, icps] [, imedi] [, idowns] [, iexcps] [, irmsmedi]

--------------------------------------------------------------------------
*planet*

Simulates a planet orbiting in a binary star system.

	ax, ay, az 	planet	 kmass1, kmass2, ksep, ix, iy, iz, ivx, ivy, ivz, idelta [, ifriction] [, iskip]

--------------------------------------------------------------------------
*pluck*

Produces a naturally decaying plucked string or drum sound.

	ares 	pluck	 kamp, kcps, icps, ifn, imeth [, iparm1] [, iparm2]

--------------------------------------------------------------------------
*plyexect*

Execute a script from a file at k-time or i-time (i suffix).

		pyexec	 "filename"
		pyexeci	 "filename"
		pylexec	 "filename"
		pylexeci	 "filename"
		pyexect	 ktrigger, "filename"
		plyexect	 ktrigger, "filename"

--------------------------------------------------------------------------
*poisson*

Poisson distribution random number generator (positive values only).

	ares 	poisson	 klambda
	ires 	poisson	 klambda
	kres 	poisson	 klambda

--------------------------------------------------------------------------
*polyaft*

Returns the polyphonic after-touch pressure of the selected note number.

	ires 	polyaft	 inote [, ilow] [, ihigh]
	kres 	polyaft	 inote [, ilow] [, ihigh]

--------------------------------------------------------------------------
*polynomial*

Efficiently evaluates a polynomial of arbitrary order.

	aout 	polynomial	 ain, k0 [, k1 [, k2 [...]]]

--------------------------------------------------------------------------
*pop*

Pops values from the global stack.

	xval1, [xval2, ... , xval31] 	pop	
	ival1, [ival2, ... , ival31] 	pop	

--------------------------------------------------------------------------
*pop_f*

Pops an f-sig frame from the global stack.

	fsig 	pop_f	

--------------------------------------------------------------------------
*port*

Applies portamento to a step-valued control signal.

	kres 	port	 ksig, ihtim [, isig]

--------------------------------------------------------------------------
*portk*

Applies portamento to a step-valued control signal.

	kres 	portk	 ksig, khtim [, isig]

--------------------------------------------------------------------------
*poscil3*

High precision oscillator with cubic interpolation.

	ares 	poscil3	 kamp, kcps, ifn [, iphs]
	kres 	poscil3	 kamp, kcps, ifn [, iphs]

--------------------------------------------------------------------------
*poscil*

High precision oscillator.

	ares 	poscil	 aamp, acps, ifn [, iphs]
	ares 	poscil	 aamp, kcps, ifn [, iphs]
	ares 	poscil	 kamp, acps, ifn [, iphs]
	ares 	poscil	 kamp, kcps, ifn [, iphs]
	ires 	poscil	 kamp, kcps, ifn [, iphs]
	kres 	poscil	 kamp, kcps, ifn [, iphs]

--------------------------------------------------------------------------
*pow*

Computes one argument to the power of another argument.

	ares 	pow	 aarg, kpow [, inorm]
	ires 	pow	 iarg, ipow [, inorm]
	kres 	pow	 karg, kpow [, inorm]

--------------------------------------------------------------------------
*powershape*

Waveshapes a signal by raising it to a variable exponent.

	aout 	powershape	 ain, kShapeAmount [, ifullscale]

--------------------------------------------------------------------------
*powoftwo*

Performs a power-of-two calculation.

		powoftwo	(x) (init-rate or control-rate args only)

--------------------------------------------------------------------------
*prealloc*

Creates space for instruments but does not run them.

		prealloc	 insnum, icount
		prealloc	 "insname", icount

--------------------------------------------------------------------------
*prepiano*

Creates a tone similar to a piano string prepared in a Cageian fashion.

	ares 	prepiano	 ifreq, iNS, iD, iK, iT30,iB, kbcl, kbcr, imass, ifreq, iinit, ipos, ivel, isfreq, isspread[, irattles, irubbers]
	al,ar 	prepiano	 ifreq, iNS, iD, iK, iT30,iB, kbcl, kbcr, imass, ifreq, iinit, ipos, ivel, isfreq, isspread[, irattles, irubbers]

--------------------------------------------------------------------------
*print*

Displays the values init (i-rate) variables.

		print	 iarg [, iarg1] [, iarg2] [...]

--------------------------------------------------------------------------
*printf*

printf-style formatted output

		printf_i	 Sfmt, itrig, [iarg1[, iarg2[, ... ]]]
		printf	 Sfmt, ktrig, [xarg1[, xarg2[, ... ]]]

--------------------------------------------------------------------------
*printk2*

Prints a new value every time a control variable changes.

		printk2	 kvar [, inumspaces]

--------------------------------------------------------------------------
*printk*

Prints one k-rate value at specified intervals.

		printk	 itime, kval [, ispace]

--------------------------------------------------------------------------
*printks*

Prints at k-rate using a printf() style syntax.

		printks	 "string", itime [, kval1] [, kval2] [...]

--------------------------------------------------------------------------
*prints*

Prints at init-time using a printf() style syntax.

		prints	 "string" [, kval1] [, kval2] [...]

--------------------------------------------------------------------------
*product*

Multiplies any number of a-rate signals.

	ares 	product	 asig1, asig2 [, asig3] [...]

--------------------------------------------------------------------------
*pset*

Defines and initializes numeric arrays at orchestra load time.

		pset	 icon1 [, icon2] [...]

--------------------------------------------------------------------------
*ptrack*

Tracks the pitch of a signal.

	kcps, kamp 	ptrack	 asig, ihopsize[,ipeaks]

--------------------------------------------------------------------------
*push*

Pushes a value into the global stack.

		push	 xval1, [xval2, ... , xval31]
		push	 ival1, [ival2, ... , ival31]

--------------------------------------------------------------------------
*push_f*

Pushes an f-sig frame into the global stack.

		push_f	 fsig

--------------------------------------------------------------------------
*puts*

Print a string constant or variable

		puts	 Sstr, ktrig[, inonl]

--------------------------------------------------------------------------
*pv_export*

Converts a .pvx file to a comma separated text file.

		pv_export	 pv_file cstext_file
	csound -U 	pv_export	 pv_file cstext_file

--------------------------------------------------------------------------
*pv_import*

Converts a comma-separated text file to a .pvx file.

		pv_import	 cstext_file pv_file
	csound -U 	pv_import	 cstext_file pv_file

--------------------------------------------------------------------------
*pvadd*

Reads from a

	ares 	pvadd	 ktimpnt, kfmod, ifilcod, ifn, ibins [, ibinoffset] [, ibinincr] [, iextractmode] [, ifreqlim] [, igatefn]

--------------------------------------------------------------------------
*pvanal*

Converts a soundfile into a series of short-time Fourier transform frames.

		csound -U pvanal	 [flags] infilename outfilename
		pvanal	 [flags] infilename outfilename

--------------------------------------------------------------------------
*pvbufread*

Reads from a phase vocoder analysis file and makes the retrieved data available.

		pvbufread	 ktimpnt, ifile

--------------------------------------------------------------------------
*pvcross*

Applies the amplitudes from one phase vocoder analysis file to the data from a second file.

	ares 	pvcross	 ktimpnt, kfmod, ifile, kampscale1, kampscale2 [, ispecwp]

--------------------------------------------------------------------------
*pvinterp*

Interpolates between the amplitudes and frequencies of two phase vocoder analysis files.

	ares 	pvinterp	 ktimpnt, kfmod, ifile, kfreqscale1, kfreqscale2, kampscale1, kampscale2, kfreqinterp, kampinterp

--------------------------------------------------------------------------
*pvlook*

View formatted text output of STFT analysis files.

		csound	 -U 	pvlook	 [flags] infilename
		pvlook	 [flags] infilename

--------------------------------------------------------------------------
*pvoc*

Implements signal reconstruction using an fft-based phase vocoder.

	ares 	pvoc	 ktimpnt, kfmod, ifilcod [, ispecwp] [, iextractmode] [, ifreqlim] [, igatefn]

--------------------------------------------------------------------------
*pvread*

Reads from a phase vocoder analysis file and returns the frequency and amplitude from a single analysis channel or bin.

	kfreq, kamp 	pvread	 ktimpnt, ifile, ibin

--------------------------------------------------------------------------
*pvsadsyn*

Resynthesize using a fast oscillator-bank.

	ares 	pvsadsyn	 fsrc, inoscs, kfmod [, ibinoffset] [, ibinincr] [, iinit]

--------------------------------------------------------------------------
*pvsanal*

Generate an fsig from a mono audio source ain, using phase vocoder overlap-add analysis.

	fsig 	pvsanal	 ain, ifftsize, ioverlap, iwinsize, iwintype [, iformat] [, iinit]

--------------------------------------------------------------------------
*pvsarp*

Arpeggiate the spectral components of a streaming pv signal.

	fsig 	pvsarp	 fsigin, kbin, kdepth, kgain

--------------------------------------------------------------------------
*pvsbandp*

A band pass filter working in the spectral domain.

	fsig 	pvsbandp	 fsigin, xlowcut, xlowfull, xhighfull, xhighcut[, ktype]

--------------------------------------------------------------------------
*pvsbandr*

A band reject filter working in the spectral domain.

	fsig 	pvsbandr	 fsigin, xlowcut, xlowfull, xhighfull, xhighcut[, ktype]

--------------------------------------------------------------------------
*pvsbin*

Obtain the amp and freq values off a PVS signal bin.

	kamp, kfr 	pvsbin	 fsig, kbin

--------------------------------------------------------------------------
*pvsblur*

Average the amp/freq time functions of each analysis channel for a specified time.

	fsig 	pvsblur	 fsigin, kblurtime, imaxdel

--------------------------------------------------------------------------
*pvsbuffer*

This opcode creates and writes to a circular buffer for f-signals (streaming PV signals).

	ihandle, ktime 	pvsbuffer	 fsig, ilen 

--------------------------------------------------------------------------
*pvsbufread*

This opcode reads a circular buffer of f-signals (streaming PV signals).

	fsig 	pvsbufread	 ktime, khandle[, ilo, ihi] 

--------------------------------------------------------------------------
*pvscale*

Scale the frequency components of a pv stream.

	fsig 	pvscale	 fsigin, kscal[, ikeepform, igain]]

--------------------------------------------------------------------------
*pvscent*

Calculate the spectral centroid of a signal.

	kcent 	pvscent	 fsig

--------------------------------------------------------------------------
*pvscross*

Performs cross-synthesis between two source fsigs.

	fsig 	pvscross	 fsrc, fdest, kamp1, kamp2

--------------------------------------------------------------------------
*pvsdemix*

Spectral azimuth-based de-mixing of stereo sources.

	fsig 	pvsdemix	 fleft, fright, kpos, kwidth, ipoints

--------------------------------------------------------------------------
*pvsdiskin*

Read a selected channel from a PVOC-EX analysis file.

	fsig 	pvsdiskin	SFname,ktscal,kgain[,ioffset, ichan]

--------------------------------------------------------------------------
*pvsdisp*

Displays a PVS signal as an amplitude vs. freq graph.

		pvsdisp	 fsig[, ibins, iwtflg] 

--------------------------------------------------------------------------
*pvsfilter*

Multiply amplitudes of a pvoc stream by those of a secondpvoc stream, with dynamic scaling.

	fsig 	pvsfilter	 fsigin, fsigfil, kdepth[, igain]

--------------------------------------------------------------------------
*pvsfread*

Read a selected channel from a PVOC-EX analysis file.

	fsig 	pvsfread	 ktimpt, ifn [, ichan]

--------------------------------------------------------------------------
*pvsfreeze*

Freeze the amplitude and frequency time functions of a pv stream according to a control-rate trigger.

	fsig 	pvsfreeze	 fsigin, kfreeza, kfreezf

--------------------------------------------------------------------------
*pvsftr*

Reads amplitude and/or frequency data from function tables.

		pvsftr	 fsrc, ifna [, ifnf]

--------------------------------------------------------------------------
*pvsftw*

Writes amplitude and/or frequency data to function tables.

	kflag 	pvsftw	 fsrc, ifna [, ifnf]

--------------------------------------------------------------------------
*pvsfwrite*

Write a fsig to a PVOCEX file.

		pvsfwrite	 fsig, ifile

--------------------------------------------------------------------------
*pvshift*

Shift the frequency components of a pv stream, stretching/compressingits spectrum.

	fsig 	pvshift	 fsigin, kshift, klowest[, ikeepform, igain]

--------------------------------------------------------------------------
*pvsifd*

Instantaneous Frequency Distribution, magnitude and phase analysis.

	ffr,fphs 	pvsifd	 ain, ifftsize, ihopsize, iwintype[,iscal]

--------------------------------------------------------------------------
*pvsin*

Retrieve an fsig from the input software bus; a pvs equivalent to chani.

	fsig 	pvsin	 kchan[,isize,iolap,iwinsize,iwintype,iformat]

--------------------------------------------------------------------------
*pvsinfo*

Get information from a PVOC-EX formatted source.

	ioverlap, inumbins, iwinsize, iformat 	pvsinfo	 fsrc

--------------------------------------------------------------------------
*pvsinit*

Initialise a spectral (f) variable to zero.

	fsig 	pvsinit	 isize[,iolap,iwinsize,iwintype, iformat]

--------------------------------------------------------------------------
*pvsmaska*

Modify amplitudes using a function table, with dynamic scaling.

	fsig 	pvsmaska	 fsrc, ifn, kdepth

--------------------------------------------------------------------------
*pvsmix*

Mix 'seamlessly' two pv signals.

	fsig 	pvsmix	 fsigin1, fsigin2

--------------------------------------------------------------------------
*pvsmooth*

Smooth the amplitude and frequency time functions of a pv stream using parallel 1st order lowpass IIR filters with time-varying cutoff frequency.

	fsig 	pvsmooth	 fsigin, kacf, kfcf

--------------------------------------------------------------------------
*pvsmorph*

Performs morphing (or interpolation) between two source fsigs.

	fsig 	pvsmorph	 fsig1, fsig2, kampint, kfrqint

--------------------------------------------------------------------------
*pvsosc*

PVS-based oscillator simulator.

	fsig 	pvsosc	 kamp, kfreq, ktype, isize [,ioverlap] [, iwinsize] [, iwintype] [, iformat]

--------------------------------------------------------------------------
*pvsout*

Write a fsig to the pvs output bus.

		pvsout	 fsig, kchan

--------------------------------------------------------------------------
*pvspitch*

Track the pitch and amplitude of a PVS signal.

	kfr, kamp 	pvspitch	 fsig, kthresh

--------------------------------------------------------------------------
*pvstencil*

Transforms a pvoc stream according to a masking function table.

	fsig 	pvstencil	 fsigin, kgain, klevel, iftable

--------------------------------------------------------------------------
*pvsvoc*

Combine the spectral envelope of one fsig with the excitation (frequencies) of another.

	fsig 	pvsvoc	 famp, fexc, kdepth, kgain

--------------------------------------------------------------------------
*pvsynth*

Resynthesise using a FFT overlap-add.

	ares 	pvsynth	 fsrc, [iinit]

--------------------------------------------------------------------------
*pyinit*

Initialize the Python interpreter.

		pyinit	

--------------------------------------------------------------------------
*pylassignt*

Assign the value of the given Csound variable to a Python variable possibly destroying its previous content.

		pyassign	 "variable", kvalue
		pyassigni	 "variable", ivalue
		pylassign	 "variable", kvalue
		pylassigni	 "variable", ivalue
		pyassignt	 ktrigger, "variable", kvalue
		pylassignt	 ktrigger, "variable", kvalue

--------------------------------------------------------------------------
*pylcallni*

Invoke the specified Python callable at k-time and i-time (i suffix), passing the given arguments. The call is perfomed in the global environment, and the result (the returning value) is copied into the Csound output variables specified.

	 	pycall	 "callable", karg1, ...
	kresult 	pycall1	 "callable", karg1, ...
	kresult1, kresult2 	pycall2	 "callable", karg1, ...
	kr1, kr2, kr3 	pycall3	 "callable", karg1, ...
	kr1, kr2, kr3, kr4 	pycall4	 "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5 	pycall5	 "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6 	pycall6	 "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6, kr7 	pycall7	 "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6, kr7, kr8 	pycall8	 "callable", karg1, ...
	 	pycallt	 ktrigger, "callable", karg1, ...
	kresult 	pycall1t	 ktrigger, "callable", karg1, ...
	kresult1, kresult2 	pycall2t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3 	pycall3t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3, kr4 	pycall4t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5 	pycall5t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6 	pycall6t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6, kr7 	pycall7t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6, kr7, kr8 	pycall8t	 ktrigger, "callable", karg1, ...
	 	pycalli	 "callable", karg1, ...
	iresult 	pycall1i	 "callable", iarg1, ...
	iresult1, iresult2 	pycall2i	 "callable", iarg1, ...
	ir1, ir2, ir3 	pycall3i	 "callable", iarg1, ...
	ir1, ir2, ir3, ir4 	pycall4i	 "callable", iarg1, ...
	ir1, ir2, ir3, ir4, ir5 	pycall5i	 "callable", iarg1, ...
	ir1, ir2, ir3, ir4, ir5, ir6 	pycall6i	 "callable", iarg1, ...
	ir1, ir2, ir3, ir4, ir5, ir6, ir7 	pycall7i	 "callable", iarg1, ...
	ir1, ir2, ir3, ir4, ir5, ir6, ir7, ir8 	pycall8i	 "callable", iarg1, ...
		pycalln	 "callable", nresults, kresult1, ..., kresultn, karg1, ...
		pycallni	 "callable", nresults, iresult1, ..., iresultn, iarg1, ...
	 	pylcall	 "callable", karg1, ...
	kresult 	pylcall1	 "callable", karg1, ...
	kresult1, kresult2 	pylcall2	 "callable", karg1, ...
	kr1, kr2, kr3 	pylcall3	 "callable", karg1, ...
	kr1, kr2, kr3, kr4 	pylcall4	 "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5 	pylcall5	 "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6 	pylcall6	 "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6, kr7 	pylcall7	 "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6, kr7, kr8 	pylcall8	 "callable", karg1, ...
	 	pylcallt	 ktrigger, "callable", karg1, ...
	kresult 	pylcall1t	 ktrigger, "callable", karg1, ...
	kresult1, kresult2 	pylcall2t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3 	pylcall3t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3, kr4 	pylcall4t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5 	pylcall5t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6 	pylcall6t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6, kr7 	pylcall7t	 ktrigger, "callable", karg1, ...
	kr1, kr2, kr3, kr4, kr5, kr6, kr7, kr8 	pylcall8t	 ktrigger, "callable", karg1, ...
	 	pylcalli	 "callable", karg1, ...
	iresult 	pylcall1i	 "callable", iarg1, ...
	iresult1, iresult2 	pylcall2i	 "callable", iarg1, ...
	ir1, ir2, ir3 	pylcall3i	 "callable", iarg1, ...
	ir1, ir2, ir3, ir4 	pylcall4i	 "callable", iarg1, ...
	ir1, ir2, ir3, ir4, ir5 	pylcall5i	 "callable", iarg1, ...
	ir1, ir2, ir3, ir4, ir5, ir6 	pylcall6i	 "callable", iarg1, ...
	ir1, ir2, ir3, ir4, ir5, ir6, ir7 	pylcall7i	 "callable", iarg1, ...
	ir1, ir2, ir3, ir4, ir5, ir6, ir7, ir8 	pylcall8i	 "callable", iarg1, ...
		pylcalln	 "callable", nresults, kresult1, ..., kresultn, karg1, ...
		pylcallni	 "callable", nresults, iresult1, ..., iresultn, iarg1, ...

--------------------------------------------------------------------------
*pylevalt*

Evaluate a generic Python expression and store the result in a Csound variable at k-time or i-time (i suffix).

	kresult 	pyeval	 "expression"
	iresult 	pyevali	 "expression"
	kresult 	pyleval	 "expression"
	iresult 	pylevali	 "expression"
	kresult 	pyevalt	 ktrigger, "expression"
	kresult 	pylevalt	 ktrigger, "expression"

--------------------------------------------------------------------------
*pylrunt*

Run a Python statement or block of statements.

		pyrun	 "statement"
		pyruni	 "statement"
		pylrun	 "statement"
		pylruni	 "statement"
		pyrunt	 ktrigger, "statement"
		pylrunt	 ktrigger, "statement"

--------------------------------------------------------------------------
*rand*

Generates a controlled random number series.

	ares 	rand	 xamp [, iseed] [, isel] [, ioffset]
	kres 	rand	 xamp [, iseed] [, isel] [, ioffset]

--------------------------------------------------------------------------
*randh*

Generates random numbers and holds them for a period of time.

	ares 	randh	 xamp, xcps [, iseed] [, isize] [, ioffset]
	kres 	randh	 kamp, kcps [, iseed] [, isize] [, ioffset]

--------------------------------------------------------------------------
*randi*

Generates a controlled random number series with interpolation between each new number.

	ares 	randi	 xamp, xcps [, iseed] [, isize] [, ioffset]
	kres 	randi	 kamp, kcps [, iseed] [, isize] [, ioffset]

--------------------------------------------------------------------------
*random*

Generates a controlled pseudo-random number series between min and max values.

	ares 	random	 kmin, kmax
	ires 	random	 imin, imax
	kres 	random	 kmin, kmax

--------------------------------------------------------------------------
*randomh*

Generates random numbers with a user-defined limit and holds them for a period of time.

	ares 	randomh	 kmin, kmax, acps
	kres 	randomh	 kmin, kmax, kcps

--------------------------------------------------------------------------
*randomi*

Generates a user-controlled random number series with interpolation between each new number.

	ares 	randomi	 kmin, kmax, acps
	kres 	randomi	 kmin, kmax, kcps

--------------------------------------------------------------------------
*rbjeq*

Parametric equalizer and filter opcode with 7 filter types, based on algorithm by Robert Bristow-Johnson.

	ar 	rbjeq	 asig, kfco, klvl, kQ, kS[, imode]

--------------------------------------------------------------------------
*readclock*

Reads the value of an internal clock.

	ir 	readclock	 inum

--------------------------------------------------------------------------
*readk2*

Periodically reads two orchestra control-signal values from an external file.

	kr1, kr2 	readk2	 ifilname, iformat, iprd

--------------------------------------------------------------------------
*readk3*

Periodically reads three orchestra control-signal values from an external file.

	kr1, kr2, kr3 	readk3	 ifilname, iformat, iprd

--------------------------------------------------------------------------
*readk4*

Periodically reads four orchestra control-signal values from an external file.

	kr1, kr2, kr3, kr4 	readk4	 ifilname, iformat, iprd

--------------------------------------------------------------------------
*readk*

Periodically reads an orchestra control-signal value from an external file.

	kres 	readk	 ifilname, iformat, iprd

--------------------------------------------------------------------------
*reinit*

Suspends a performance while a special initialization pass is executed.

		reinit	 label

--------------------------------------------------------------------------
*release*

Indicates whether a note is in its

	kflag 	release	

--------------------------------------------------------------------------
*remoteport*

Defines the port for use with the remote system.

		remoteport	 iportnum

--------------------------------------------------------------------------
*remove*

Removes the definition of an instrument.

		remove	 insnum

--------------------------------------------------------------------------
*repluck*

Physical model of the plucked string.

	ares 	repluck	 iplk, kamp, icps, kpick, krefl, axcite

--------------------------------------------------------------------------
*reson*

A second-order resonant filter.

	ares 	reson	 asig, kcf, kbw [, iscl] [, iskip]

--------------------------------------------------------------------------
*resonk*

A second-order resonant filter.

	kres 	resonk	 ksig, kcf, kbw [, iscl] [, iskip]

--------------------------------------------------------------------------
*resonr*

A bandpass filter with variable frequency response.

	ares 	resonr	 asig, kcf, kbw [, iscl] [, iskip]

--------------------------------------------------------------------------
*resonx*

Emulates a stack of filters using the reson opcode.

	ares 	resonx	 asig, kcf, kbw [, inumlayer] [, iscl] [, iskip]

--------------------------------------------------------------------------
*resonxk*

Control signal resonant filter stack.

	kres 	resonxk	 ksig, kcf, kbw[, inumlayer, iscl, istor]

--------------------------------------------------------------------------
*resony*

A bank of second-order bandpass filters, connected in parallel.

	ares 	resony	 asig, kbf, kbw, inum, ksep [, isepmode] [, iscl] [, iskip]

--------------------------------------------------------------------------
*resonz*

A bandpass filter with variable frequency response.

	ares 	resonz	 asig, kcf, kbw [, iscl] [, iskip]

--------------------------------------------------------------------------
*resyn*

Streaming partial track additive synthesis with cubic phase interpolation withpitch control and support for timescale-modified input

	asig 	resyn	 fin, kscal, kpitch, kmaxtracks, ifn

--------------------------------------------------------------------------
*reverb2*

Same as the nreverb opcode.

	ares 	reverb2	 asig, ktime, khdif [, iskip] [,inumCombs] [, ifnCombs] [, inumAlpas] [, ifnAlpas]

--------------------------------------------------------------------------
*reverb*

Reverberates an input signal with a

	ares 	reverb	 asig, krvt [, iskip]

--------------------------------------------------------------------------
*reverbsc*

8 delay line stereo FDN reverb, based on work by Sean Costello

	aoutL, aoutR 	reverbsc	 ainL, ainR, kfblvl, kfco[, israte[, ipitchm[, iskip]]] 

--------------------------------------------------------------------------
*rewindscore*

Rewinds the playback position of the current score performance.

	 	rewindscore	

--------------------------------------------------------------------------
*rezzy*

A resonant low-pass filter.

	ares 	rezzy	 asig, xfco, xres [, imode, iskip]

--------------------------------------------------------------------------
*rigoto*

Transfers control during a reinit pass.

		rigoto	 label

--------------------------------------------------------------------------
*rireturn*

Terminates a reinit pass.

		rireturn	

--------------------------------------------------------------------------
*rms*

Determines the root-mean-square amplitude of an audio signal.

	kres 	rms	 asig [, ihp] [, iskip]

--------------------------------------------------------------------------
*rnd31*

31-bit bipolar random opcodes with controllable distribution.

	ax 	rnd31	 kscl, krpow [, iseed]
	ix 	rnd31	 iscl, irpow [, iseed]
	kx 	rnd31	 kscl, krpow [, iseed]

--------------------------------------------------------------------------
*rnd*

Returns a random number in a unipolar range at the rate given by the input argument.

		rnd	(x) (init- or control-rate only)

--------------------------------------------------------------------------
*round*

Returns the integer value nearest to

		round	(x) (init-, control-, or audio-rate arg allowed)

--------------------------------------------------------------------------
*rspline*

Generate random spline curves.

	ares 	rspline	 xrangeMin, xrangeMax, kcpsMin, kcpsMax
	kres 	rspline	 krangeMin, krangeMax, kcpsMin, kcpsMax

--------------------------------------------------------------------------
*rtclock*

Read the real time clock from the operating system.

	ires 	rtclock	
	kres 	rtclock	

--------------------------------------------------------------------------
*s16b14*

Creates a bank of 16 different 14-bit MIDI control message numbers.

	i1,...,i16 	s16b14	 ichan, ictlno_msb1, ictlno_lsb1, imin1, imax1, initvalue1, ifn1,..., ictlno_msb16, ictlno_lsb16, imin16, imax16, initvalue16, ifn16
	k1,...,k16 	s16b14	 ichan, ictlno_msb1, ictlno_lsb1, imin1, imax1, initvalue1, ifn1,..., ictlno_msb16, ictlno_lsb16, imin16, imax16, initvalue16, ifn16

--------------------------------------------------------------------------
*s32b14*

Creates a bank of 32 different 14-bit MIDI control message numbers.

	i1,...,i32 	s32b14	 ichan, ictlno_msb1, ictlno_lsb1, imin1, imax1, initvalue1, ifn1,..., ictlno_msb32, ictlno_lsb32, imin32, imax32, initvalue32, ifn32
	k1,...,k32 	s32b14	 ichan, ictlno_msb1, ictlno_lsb1, imin1, imax1, initvalue1, ifn1,..., ictlno_msb32, ictlno_lsb32, imin32, imax32, initvalue32, ifn32

--------------------------------------------------------------------------
*samphold*

Performs a sample-and-hold operation on its input.

	ares 	samphold	 asig, agate [, ival] [, ivstor]
	kres 	samphold	 ksig, kgate [, ival] [, ivstor]

--------------------------------------------------------------------------
*sandpaper*

Semi-physical model of a sandpaper sound.

	ares 	sandpaper	 iamp, idettack [, inum] [, idamp] [, imaxshake]

--------------------------------------------------------------------------
*scale*

Arbitrary signal scaling.

	kscl 	scale	 kinput, kmax, kmin

--------------------------------------------------------------------------
*scale*

Scale the amplitude of a sound file.

		scale	 [OPTIONS ... ] infile

--------------------------------------------------------------------------
*scanhammer*

Copies from one table to another with a gain control.

		scanhammer	 isrc, idst, ipos, imult

--------------------------------------------------------------------------
*scans*

Generate audio output using scanned synthesis.

	ares 	scans	 kamp, kfreq, ifn, id [, iorder]

--------------------------------------------------------------------------
*scantable*

A simpler scanned synthesis implementation.

	aout 	scantable	 kamp, kpch, ipos, imass, istiff, idamp, ivel

--------------------------------------------------------------------------
*scanu*

Compute the waveform and the wavetable for use in scanned synthesis.

		scanu	 init, irate, ifnvel, ifnmass, ifnstif, ifncentr, ifndamp, kmass, kstif, kcentr, kdamp, ileft, iright, kpos, kstrngth, ain, idisp, id

--------------------------------------------------------------------------
*schedkwhen*

Adds a new score event generated by a k-rate trigger.

		schedkwhen	 ktrigger, kmintim, kmaxnum, kinsnum, kwhen, kdur [, ip4] [, ip5] [...]
		schedkwhen	 ktrigger, kmintim, kmaxnum, "insname", kwhen, kdur [, ip4] [, ip5] [...]

--------------------------------------------------------------------------
*schedkwhennamed*

Similar to schedkwhen but uses a named instrument at init-time.

		schedkwhennamed	 ktrigger, kmintim, kmaxnum, "name", kwhen, kdur [, ip4] [, ip5] [...]

--------------------------------------------------------------------------
*schedule*

Adds a new score event.

		schedule	 insnum, iwhen, idur [, ip4] [, ip5] [...]
		schedule	 "insname", iwhen, idur [, ip4] [, ip5] [...]

--------------------------------------------------------------------------
*schedwhen*

Adds a new score event.

		schedwhen	 ktrigger, kinsnum, kwhen, kdur [, ip4] [, ip5] [...]
		schedwhen	 ktrigger, "insname", kwhen, kdur [, ip4] [, ip5] [...]

--------------------------------------------------------------------------
*scoreline*

Issues one or more score line events from an instrument.

		scoreline	 Sin, ktrig

--------------------------------------------------------------------------
*scoreline_i*

Issues one or more score line events from an instrument at i-time.

		scoreline_i	 Sin

--------------------------------------------------------------------------
*sdif2ad*

Converts SDIF files to files usable by adsynt.

		sdif2ad	 [flags] infilename outfilename

--------------------------------------------------------------------------
*seed*

Sets the global seed value.

		seed	 ival

--------------------------------------------------------------------------
*sekere*

Semi-physical model of a sekere sound.

	ares 	sekere	 iamp, idettack [, inum] [, idamp] [, imaxshake]

--------------------------------------------------------------------------
*semitone*

Calculates a factor to raise/lower a frequency by a given amount of semitones.

		semitone	(x)

--------------------------------------------------------------------------
*sensekey*

Returns the ASCII code of a key that has been pressed.

	kres[, kkeydown] 	sensekey	

--------------------------------------------------------------------------
*seqtime2*

Generates a trigger signal according to the values stored in a table.

	ktrig_out 	seqtime2	 ktrig_in, ktime_unit, kstart, kloop, kinitndx, kfn_times

--------------------------------------------------------------------------
*seqtime*

Generates a trigger signal according to the values stored in a table.

	ktrig_out 	seqtime	 ktime_unit, kstart, kloop, kinitndx, kfn_times

--------------------------------------------------------------------------
*setctrl*

Configurable slider controls for realtime user input.

		setctrl	 inum, ival, itype

--------------------------------------------------------------------------
*setksmps*

Sets the local ksmps value in a user-defined opcode block.

		setksmps	 iksmps

--------------------------------------------------------------------------
*setscorepos ipos*

Sets the playback position of the current score performance to a given position.

	 	setscorepos ipos	

--------------------------------------------------------------------------
*sfilist*

Prints a list of all instruments of a previously loaded SoundFont2 (SF2) file.

		sfilist	 ifilhandle

--------------------------------------------------------------------------
*sfinstr3*

Plays a SoundFont2 (SF2) sample instrument, generating a stereo sound with cubic interpolation.

	ar1, ar2 	sfinstr3	 ivel, inotenum, xamp, xfreq, instrnum, ifilhandle [, iflag] [, ioffset]

--------------------------------------------------------------------------
*sfinstr3m*

Plays a SoundFont2 (SF2) sample instrument, generating a mono sound with cubic interpolation.

	ares 	sfinstr3m	 ivel, inotenum, xamp, xfreq, instrnum, ifilhandle [, iflag] [, ioffset]

--------------------------------------------------------------------------
*sfinstr*

Plays a SoundFont2 (SF2) sample instrument, generating a stereo sound.

	ar1, ar2 	sfinstr	 ivel, inotenum, xamp, xfreq, instrnum, ifilhandle [, iflag] [, ioffset]

--------------------------------------------------------------------------
*sfinstrm*

Plays a SoundFont2 (SF2) sample instrument, generating a mono sound.

	ares 	sfinstrm	 ivel, inotenum, xamp, xfreq, instrnum, ifilhandle [, iflag] [, ioffset]

--------------------------------------------------------------------------
*sfload*

Loads an entire SoundFont2 (SF2) sample file into memory.

	ir 	sfload	 "filename"

--------------------------------------------------------------------------
*sflooper*

Plays a SoundFont2 (SF2) sample preset, generating a stereo sound, with user-defined time-varying crossfade looping.

	ar1, ar2 	sflooper	 ivel, inotenum, kamp, kpitch, ipreindex, kloopstart, kloopend, kcrossfade, ifn [, istart, imode, ifenv, iskip] 

--------------------------------------------------------------------------
*sfpassign*

Assigns all presets of a SoundFont2 (SF2) sample file to a sequence of progressive index numbers.

		sfpassign	 istartindex, ifilhandle[, imsgs]

--------------------------------------------------------------------------
*sfplay3*

Plays a SoundFont2 (SF2) sample preset, generating a stereo sound with cubic interpolation.

	ar1, ar2 	sfplay3	 ivel, inotenum, xamp, xfreq, ipreindex [, iflag] [, ioffset] [, ienv]

--------------------------------------------------------------------------
*sfplay3m*

Plays a SoundFont2 (SF2) sample preset, generating a mono sound with cubic interpolation.

	ares 	sfplay3m	 ivel, inotenum, xamp, xfreq, ipreindex [, iflag] [, ioffset] [, ienv]

--------------------------------------------------------------------------
*sfplay*

Plays a SoundFont2 (SF2) sample preset, generating a stereo sound.

	ar1, ar2 	sfplay	 ivel, inotenum, xamp, xfreq, ipreindex [, iflag] [, ioffset] [, ienv]

--------------------------------------------------------------------------
*sfplaym*

Plays a SoundFont2 (SF2) sample preset, generating a mono sound.

	ares 	sfplaym	 ivel, inotenum, xamp, xfreq, ipreindex [, iflag] [, ioffset] [, ienv]

--------------------------------------------------------------------------
*sfplist*

Prints a list of all presets of a SoundFont2 (SF2) sample file.

		sfplist	 ifilhandle

--------------------------------------------------------------------------
*sfpreset*

Assigns an existing preset of a SoundFont2 (SF2) sample file to an index number.

	ir 	sfpreset	 iprog, ibank, ifilhandle, ipreindex

--------------------------------------------------------------------------
*shaker*

Sounds like the shaking of a maraca or similar gourd instrument.

	ares 	shaker	 kamp, kfreq, kbeans, kdamp, ktimes [, idecay]

--------------------------------------------------------------------------
*sin*

Performs a sine function.

		sin	(x) (no rate restriction)

--------------------------------------------------------------------------
*sinh*

Performs a hyperbolic sine function.

		sinh	(x) (no rate restriction)

--------------------------------------------------------------------------
*sininv*

Performs an arcsine function.

		sininv	(x) (no rate restriction)

--------------------------------------------------------------------------
*sinsyn*

Streaming partial track additive synthesis with cubic phase interpolation

	asig 	sinsyn	 fin, kscal, kmaxtracks, ifn

--------------------------------------------------------------------------
*sleighbells*

Semi-physical model of a sleighbell sound.

	ares 	sleighbells	 kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq] [, ifreq1] [, ifreq2]

--------------------------------------------------------------------------
*slider16*

Creates a bank of 16 different MIDI control message numbers.

	i1,...,i16 	slider16	 ichan, ictlnum1, imin1, imax1, init1, ifn1,..., ictlnum16, imin16, imax16, init16, ifn16
	k1,...,k16 	slider16	 ichan, ictlnum1, imin1, imax1, init1, ifn1,..., ictlnum16, imin16, imax16, init16, ifn16

--------------------------------------------------------------------------
*slider16f*

Creates a bank of 16 different MIDI control message numbers, filtered before output.

	k1,...,k16 	slider16f	 ichan, ictlnum1, imin1, imax1, init1, ifn1, icutoff1,..., ictlnum16, imin16, imax16, init16, ifn16, icutoff16

--------------------------------------------------------------------------
*slider16table*

Stores a bank of 16 different MIDI control messages to a table.

	kflag 	slider16table	 ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, init1, ifn1, .... , ictlnum16, imin16, imax16, init16, ifn16

--------------------------------------------------------------------------
*slider16tablef*

Stores a bank of 16 different MIDI control messages to a table, filtered before output.

	kflag 	slider16tablef	 ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, init1, ifn1, icutoff1, .... , ictlnum16, imin16, imax16, init16, ifn16, icutoff16

--------------------------------------------------------------------------
*slider32*

Creates a bank of 32 different MIDI control message numbers.

	i1,...,i32 	slider32	 ichan, ictlnum1, imin1, imax1, init1, ifn1,..., ictlnum32, imin32, imax32, init32, ifn32
	k1,...,k32 	slider32	 ichan, ictlnum1, imin1, imax1, init1, ifn1,..., ictlnum32, imin32, imax32, init32, ifn32

--------------------------------------------------------------------------
*slider32f*

Creates a bank of 32 different MIDI control message numbers, filtered before output.

	k1,...,k32 	slider32f	 ichan, ictlnum1, imin1, imax1, init1, ifn1, icutoff1, ..., ictlnum32, imin32, imax32, init32, ifn32, icutoff32

--------------------------------------------------------------------------
*slider32table*

Stores a bank of 32 different MIDI control messages to a table.

	kflag 	slider32table	 ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, init1, ifn1, .... , ictlnum32, imin32, imax32, init32, ifn32

--------------------------------------------------------------------------
*slider32tablef*

Creates a bank of 32 different MIDI control message numbers, filtered before output.

	kflag 	slider32tablef	 ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, init1, ifn1, icutoff1, .... , ictlnum32, imin32, imax32, init32, ifn32, icutoff32

--------------------------------------------------------------------------
*slider64*

Creates a bank of 64 different MIDI control message numbers.

	i1,...,i64 	slider64	 ichan, ictlnum1, imin1, imax1, init1, ifn1,..., ictlnum64, imin64, imax64, init64, ifn64
	k1,...,k64 	slider64	 ichan, ictlnum1, imin1, imax1, init1, ifn1,..., ictlnum64, imin64, imax64, init64, ifn64

--------------------------------------------------------------------------
*slider64f*

Creates a bank of 64 different MIDI control message numbers, filtered before output.

	k1,...,k64 	slider64f	 ichan, ictlnum1, imin1, imax1, init1, ifn1, icutoff1,..., ictlnum64, imin64, imax64, init64, ifn64, icutoff64

--------------------------------------------------------------------------
*slider64table*

Stores a bank of 64 different MIDI control messages to a table.

	kflag 	slider64table	 ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, init1, ifn1, .... , ictlnum64, imin64, imax64, init64, ifn64

--------------------------------------------------------------------------
*slider64tablef*

Stores a bank of 64 different MIDI control messages to a table, filtered before output.

	kflag 	slider64tablef	 ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, init1, ifn1, icutoff1, .... , ictlnum64, imin64, imax64, init64, ifn64, icutoff64

--------------------------------------------------------------------------
*slider8*

Creates a bank of 8 different MIDI control message numbers.

	i1,...,i8 	slider8	 ichan, ictlnum1, imin1, imax1, init1, ifn1,..., ictlnum8, imin8, imax8, init8, ifn8
	k1,...,k8 	slider8	 ichan, ictlnum1, imin1, imax1, init1, ifn1,..., ictlnum8, imin8, imax8, init8, ifn8

--------------------------------------------------------------------------
*slider8f*

Creates a bank of 8 different MIDI control message numbers, filtered before output.

	k1,...,k8 	slider8f	 ichan, ictlnum1, imin1, imax1, init1, ifn1, icutoff1, ..., ictlnum8, imin8, imax8, init8, ifn8, icutoff8

--------------------------------------------------------------------------
*slider8table*

Stores a bank of 8 different MIDI control messages to a table.

	kflag 	slider8table	 ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, init1, ifn1,..., ictlnum8, imin8, imax8, init8, ifn8

--------------------------------------------------------------------------
*slider8tablef*

Stores a bank of 8 different MIDI control messages to a table, filtered before output.

	kflag 	slider8tablef	 ichan, ioutTable, ioffset, ictlnum1, imin1, imax1, init1, ifn1, icutoff1, .... , ictlnum8, imin8, imax8, init8, ifn8, icutoff8

--------------------------------------------------------------------------
*sliderKawai*

Creates a bank of 16 different MIDI control message numbers from a KAWAI MM-16 midi mixer.

	k1, k2, ...., k16 	sliderKawai	 imin1, imax1, init1, ifn1, imin2, imax2, init2, ifn2, ..., imin16, imax16, init16, ifn16

--------------------------------------------------------------------------
*sndinfo*

Displays information about a soundfile.

		csound -U sndinfo	 [options] soundfilenames ...
		sndinfo	 [options] soundfilenames ...

--------------------------------------------------------------------------
*sndload*

Loads a sound file into memory for use by

		sndload	 Sfname[, ifmt[, ichns[, isr[, ibas[, iamp[, istrt [, ilpmod[, ilps[, ilpe]]]]]]]]]

--------------------------------------------------------------------------
*sndloop*

A sound looper with pitch control.

	asig, krec 	sndloop	 ain, kpitch, ktrig, idur, ifad

--------------------------------------------------------------------------
*sndwarp*

Reads a mono sound sample from a table and applies time-stretching and/or pitch modification.

	ares [, ac] 	sndwarp	 xamp, xtimewarp, xresample, ifn1, ibeg, iwsize, irandw, ioverlap, ifn2, itimemode

--------------------------------------------------------------------------
*sndwarpst*

Reads a stereo sound sample from a table and applies time-stretching and/or pitch modification.

	ar1, ar2 [,ac1] [, ac2] 	sndwarpst	 xamp, xtimewarp, xresample, ifn1, ibeg, iwsize, irandw, ioverlap, ifn2, itimemode

--------------------------------------------------------------------------
*soundin*

Reads audio data from an external device or stream.

	ar1[, ar2[, ar3[, ... a24]]] 	soundin	 ifilcod [, iskptim] [, iformat] [, iskipinit] [, ibufsize]

--------------------------------------------------------------------------
*soundout*

Deprecated. Writes audio output to a disk file.

		soundout	 asig1, ifilcod [, iformat]

--------------------------------------------------------------------------
*soundouts*

Deprecated. Writes audio output to a disk file.

		soundouts	 asigl, asigr, ifilcod [, iformat]

--------------------------------------------------------------------------
*space*

Distributes an input signal among 4 channels using cartesian coordinates.

	a1, a2, a3, a4 	space	 asig, ifn, ktime, kreverbsend, kx, ky

--------------------------------------------------------------------------
*spat3d*

Positions the input sound in a 3D space and allows moving the sound at k-rate.

	aW, aX, aY, aZ 	spat3d	 ain, kX, kY, kZ, idist, ift, imode, imdel, iovr [, istor]

--------------------------------------------------------------------------
*spat3di*

Positions the input sound in a 3D space with the sound source position set at i-time.

	aW, aX, aY, aZ 	spat3di	 ain, iX, iY, iZ, idist, ift, imode [, istor]

--------------------------------------------------------------------------
*spat3dt*

Can be used to render an impulse response for a 3D space at i-time.

		spat3dt	 ioutft, iX, iY, iZ, idist, ift, imode, irlen [, iftnocl]

--------------------------------------------------------------------------
*spdist*

Calculates distance values from xy coordinates.

	k1 	spdist	 ifn, ktime, kx, ky

--------------------------------------------------------------------------
*specaddm*

Perform a weighted add of two input spectra.

	wsig 	specaddm	 wsig1, wsig2 [, imul2]

--------------------------------------------------------------------------
*specdiff*

Finds the positive difference values between consecutive spectral frames.

	wsig 	specdiff	 wsigin

--------------------------------------------------------------------------
*specdisp*

Displays the magnitude values of the spectrum.

		specdisp	 wsig, iprd [, iwtflg]

--------------------------------------------------------------------------
*specfilt*

Filters each channel of an input spectrum.

	wsig 	specfilt	 wsigin, ifhtim

--------------------------------------------------------------------------
*spechist*

Accumulates the values of successive spectral frames.

	wsig 	spechist	 wsigin

--------------------------------------------------------------------------
*specptrk*

Estimates the pitch of the most prominent complex tone in the spectrum.

	koct, kamp 	specptrk	 wsig, kvar, ilo, ihi, istr, idbthresh, inptls, irolloff [, iodd] [, iconfs] [, interp] [, ifprd] [, iwtflg]

--------------------------------------------------------------------------
*specscal*

Scales an input spectral datablock with spectral envelopes.

	wsig 	specscal	 wsigin, ifscale, ifthresh

--------------------------------------------------------------------------
*specsum*

Sums the magnitudes across all channels of the spectrum.

	ksum 	specsum	 wsig [, interp]

--------------------------------------------------------------------------
*spectrum*

Generate a constant-Q, exponentially-spaced DFT.

	wsig 	spectrum	 xsig, iprd, iocts, ifrqa [, iq] [, ihann] [, idbout] [, idsprd] [, idsinrs]

--------------------------------------------------------------------------
*splitrig*

Split a trigger signal

		splitrig	 ktrig, kndx, imaxtics, ifn, kout1 [,kout2,...,koutN]

--------------------------------------------------------------------------
*sprintfk*

printf-style formatted output to a string variable at k-rate.

	Sdst 	sprintfk	 Sfmt, xarg1[, xarg2[, ... ]]

--------------------------------------------------------------------------
*sprintfk*

printf-style formatted output to a string variable.

	Sdst 	sprintf	 Sfmt, xarg1[, xarg2[, ... ]]
	Sdst 	sprintfk	 Sfmt, xarg1[, xarg2[, ... ]]

--------------------------------------------------------------------------
*spsend*

Generates output signals based on a previously defined

	a1, a2, a3, a4 	spsend	

--------------------------------------------------------------------------
*sqrt*

Returns a square root value.

		sqrt	(x) (no rate restriction)

--------------------------------------------------------------------------
*sr*

Sets the audio sampling rate.

		sr	 = iarg

--------------------------------------------------------------------------
*srconv*

Converts the sample rate of an audio file.

		srconv	 [flags] infile

--------------------------------------------------------------------------
*stack*

Initializes the stack.

		stack	 iStackSize

--------------------------------------------------------------------------
*statevar*

State-variable filter.

	ahp,alp,abp,abr 	statevar	 ain, kcf, kq [, iosamps, istor]

--------------------------------------------------------------------------
*stix*

Semi-physical model of a stick sound.

	ares 	stix	 iamp, idettack [, inum] [, idamp] [, imaxshake]

--------------------------------------------------------------------------
*strcat*

Concatenate strings

	Sdst 	strcat	 Ssrc1, Ssrc2

--------------------------------------------------------------------------
*strcatk*

Concatenate strings (k-rate)

	Sdst 	strcatk	 Ssrc1, Ssrc2

--------------------------------------------------------------------------
*strchar*

Return the ASCII code of a character in a string

	ichr 	strchar	 Sstr[, ipos]

--------------------------------------------------------------------------
*strchark*

Return the ASCII code of a character in a string

	kchr 	strchark	 Sstr[, kpos]

--------------------------------------------------------------------------
*strcmp*

Compare strings

	ires 	strcmp	 S1, S2

--------------------------------------------------------------------------
*strcmpk*

Compare strings

	kres 	strcmpk	 S1, S2

--------------------------------------------------------------------------
*strcpyk*

Assign value to a string variable (k-rate)

	Sdst 	strcpyk	 Ssrc

--------------------------------------------------------------------------
*strecv*

Receives data from other processes using the low-level UDP or TCP protocols

	asig 	sockrecv	 iport, ilength
	asigl, asigr 	sockrecvs	 iport, ilength
	asig 	strecv	 Sipaddr, iport

--------------------------------------------------------------------------
*streson*

A string resonator with variable fundamental frequency.

	ares 	streson	 asig, kfr, ifdbgain

--------------------------------------------------------------------------
*strget*

Set string variable to value from strset table or string p-field

	Sdst 	strget	 indx

--------------------------------------------------------------------------
*strindex*

Return the position of the first occurence of a string in another string

	ipos 	strindex	 S1, S2

--------------------------------------------------------------------------
*strindexk*

Return the position of the first occurence of a string in another string

	kpos 	strindexk	 S1, S2

--------------------------------------------------------------------------
*strlen*

Return the length of a string

	ilen 	strlen	 Sstr

--------------------------------------------------------------------------
*strlenk*

Return the length of a string

	klen 	strlenk	 Sstr

--------------------------------------------------------------------------
*strlower*

Convert a string to lower case

	Sdst 	strlower	 Ssrc

--------------------------------------------------------------------------
*strlowerk*

Convert a string to lower case

	Sdst 	strlowerk	 Ssrc

--------------------------------------------------------------------------
*strrindex*

Return the position of the last occurence of a string in another string

	ipos 	strrindex	 S1, S2

--------------------------------------------------------------------------
*strrindexk*

Return the position of the last occurence of a string in another string

	kpos 	strrindexk	 S1, S2

--------------------------------------------------------------------------
*strset*

Allows a string to be linked with a numeric value.

		strset	 iarg, istring

--------------------------------------------------------------------------
*strsub*

Extract a substring

	Sdst 	strsub	 Ssrc[, istart[, iend]]

--------------------------------------------------------------------------
*strsubk*

Extract a substring

	Sdst 	strsubk	 Ssrc, kstart, kend

--------------------------------------------------------------------------
*strtod*

Converts a string to a float (i-rate).

	ir 	strtod	 Sstr
	ir 	strtod	 indx

--------------------------------------------------------------------------
*strtodk*

Converts a string to a float (k-rate).

	kr 	strtodk	 Sstr
	kr 	strtodk	 kndx

--------------------------------------------------------------------------
*strtol*

Converts a string to a signed integer (i-rate).

	ir 	strtol	 Sstr
	ir 	strtol	 indx

--------------------------------------------------------------------------
*strtolk*

Converts a string to a signed integer (k-rate).

	kr 	strtolk	 Sstr
	kr 	strtolk	 kndx

--------------------------------------------------------------------------
*strupper*

Convert a string to upper case

	Sdst 	strupper	 Ssrc

--------------------------------------------------------------------------
*strupperk*

Convert a string to upper case

	Sdst 	strupperk	 Ssrc

--------------------------------------------------------------------------
*stsend*

Sends data to other processes using the low-level UDP or TCP protocols

		socksend	 asig, Sipaddr, iport, ilength
		socksends	 asigl, asigr, Sipaddr, iport, ilength
		stsend	 asig, Sipaddr, iport

--------------------------------------------------------------------------
*subinstr*

Creates and runs a numbered instrument instance.

	a1, [...] [, a8] 	subinstr	 instrnum [, p4] [, p5] [...]
	a1, [...] [, a8] 	subinstr	 "insname" [, p4] [, p5] [...]

--------------------------------------------------------------------------
*subinstrinit*

Creates and runs a numbered instrument instance at init-time.

		subinstrinit	 instrnum [, p4] [, p5] [...]
		subinstrinit	 "insname" [, p4] [, p5] [...]

--------------------------------------------------------------------------
*sum*

Sums any number of a-rate signals.

	ares 	sum	 asig1 [, asig2] [, asig3] [...]

--------------------------------------------------------------------------
*svfilter*

A resonant second order filter, with simultaneous lowpass, highpass and bandpass outputs.

	alow, ahigh, aband 	svfilter	 asig, kcf, kq [, iscl]

--------------------------------------------------------------------------
*syncgrain*

Synchronous granular synthesis.

	asig 	syncgrain	 kamp, kfreq, kpitch, kgrsize, kprate, ifun1, ifun2, iolaps

--------------------------------------------------------------------------
*syncloop*

Synchronous granular synthesis.

	asig 	syncloop	 kamp, kfreq, kpitch, kgrsize, kprate, klstart, klend, ifun1, ifun2, iolaps[,istart, iskip]

--------------------------------------------------------------------------
*syncphasor*

Produces a normalized moving phase value with sync input and output.

	aphase, asyncout 	syncphasor	 xcps, asyncin, [, iphs]

--------------------------------------------------------------------------
*system*

Call an external program via the system call

	ires 	system_i	 itrig, Scmd, [inowait]
	kres 	system	 ktrig, Scmd, [knowait]

--------------------------------------------------------------------------
*table3*

Accesses table values by direct indexing with cubic interpolation.

	ares 	table3	 andx, ifn [, ixmode] [, ixoff] [, iwrap]
	ires 	table3	 indx, ifn [, ixmode] [, ixoff] [, iwrap]
	kres 	table3	 kndx, ifn [, ixmode] [, ixoff] [, iwrap]

--------------------------------------------------------------------------
*table*

Accesses table values by direct indexing.

	ares 	table	 andx, ifn [, ixmode] [, ixoff] [, iwrap]
	ires 	table	 indx, ifn [, ixmode] [, ixoff] [, iwrap]
	kres 	table	 kndx, ifn [, ixmode] [, ixoff] [, iwrap]

--------------------------------------------------------------------------
*tablecopy*

Simple, fast table copy opcode.

		tablecopy	 kdft, ksft

--------------------------------------------------------------------------
*tablegpw*

Writes a table's guard point.

		tablegpw	 kfn

--------------------------------------------------------------------------
*tablei*

Accesses table values by direct indexing with linear interpolation.

	ares 	tablei	 andx, ifn [, ixmode] [, ixoff] [, iwrap]
	ires 	tablei	 indx, ifn [, ixmode] [, ixoff] [, iwrap]
	kres 	tablei	 kndx, ifn [, ixmode] [, ixoff] [, iwrap]

--------------------------------------------------------------------------
*tableicopy*

Simple, fast table copy opcode.

		tableicopy	 idft, isft

--------------------------------------------------------------------------
*tableigpw*

Writes a table's guard point.

		tableigpw	 ifn

--------------------------------------------------------------------------
*tableikt*

Provides k-rate control over table numbers.

	ares 	tableikt	 xndx, kfn [, ixmode] [, ixoff] [, iwrap]
	kres 	tableikt	 kndx, kfn [, ixmode] [, ixoff] [, iwrap]

--------------------------------------------------------------------------
*tableimix*

Mixes two tables.

		tableimix	 idft, idoff, ilen, is1ft, is1off, is1g, is2ft, is2off, is2g

--------------------------------------------------------------------------
*tableiw*

Change the contents of existing function tables.

		tableiw	 isig, indx, ifn [, ixmode] [, ixoff] [, iwgmode]

--------------------------------------------------------------------------
*tablekt*

Provides k-rate control over table numbers.

	ares 	tablekt	 xndx, kfn [, ixmode] [, ixoff] [, iwrap]
	kres 	tablekt	 kndx, kfn [, ixmode] [, ixoff] [, iwrap]

--------------------------------------------------------------------------
*tablemix*

Mixes two tables.

		tablemix	 kdft, kdoff, klen, ks1ft, ks1off, ks1g, ks2ft, ks2off, ks2g

--------------------------------------------------------------------------
*tableng*

Interrogates a function table for length.

	ires 	tableng	 ifn
	kres 	tableng	 kfn

--------------------------------------------------------------------------
*tablera*

Reads tables in sequential locations.

	ares 	tablera	 kfn, kstart, koff

--------------------------------------------------------------------------
*tableseg*

Creates a new function table by making linear segments between values in stored function tables.

		tableseg	 ifn1, idur1, ifn2 [, idur2] [, ifn3] [...]

--------------------------------------------------------------------------
*tablew*

Change the contents of existing function tables.

		tablew	 asig, andx, ifn [, ixmode] [, ixoff] [, iwgmode]
		tablew	 isig, indx, ifn [, ixmode] [, ixoff] [, iwgmode]
		tablew	 ksig, kndx, ifn [, ixmode] [, ixoff] [, iwgmode]

--------------------------------------------------------------------------
*tablewa*

Writes tables in sequential locations.

	kstart 	tablewa	 kfn, asig, koff

--------------------------------------------------------------------------
*tablewkt*

Change the contents of existing function tables.

		tablewkt	 asig, andx, kfn [, ixmode] [, ixoff] [, iwgmode]
		tablewkt	 ksig, kndx, kfn [, ixmode] [, ixoff] [, iwgmode]

--------------------------------------------------------------------------
*tablexkt*

Reads function tables with linear, cubic, or sinc interpolation.

	ares 	tablexkt	 xndx, kfn, kwarp, iwsize [, ixmode] [, ixoff] [, iwrap]

--------------------------------------------------------------------------
*tablexseg*

Creates a new function table by making exponential segments between values in stored function tables.

		tablexseg	 ifn1, idur1, ifn2 [, idur2] [, ifn3] [...]

--------------------------------------------------------------------------
*tabmorph*

Allow morphing between a set of tables.

	kout 	tabmorph	 kindex, kweightpoint, ktabnum1, ktabnum2, ifn1, ifn2 [, ifn3, ifn4, ... ifnN]

--------------------------------------------------------------------------
*tabmorpha*

Allow morphing between a set of tables at audio rate with interpolation.

	aout 	tabmorpha	 aindex, aweightpoint, atabnum1, atabnum2, ifn1, ifn2 [, ifn3, ifn4, ... ifnN]

--------------------------------------------------------------------------
*tabmorphak*

Allow morphing between a set of tables at audio rate with interpolation.

	aout 	tabmorphak	 aindex, kweightpoint, ktabnum1, ktabnum2, ifn1, ifn2 [, ifn3, ifn4, ... ifnN]

--------------------------------------------------------------------------
*tabmorphi*

Allow morphing between a set of tables with interpolation.

	kout 	tabmorphi	 kindex, kweightpoint, ktabnum1, ktabnum2, ifn1, ifn2 [, ifn3, ifn4, ... ifnN]

--------------------------------------------------------------------------
*tabplay*

Playing-back control signals.

		tabplay	 ktrig, knumtics, kfn, kout1 [,kout2,..., koutN]

--------------------------------------------------------------------------
*tabrec*

Recording of control signals.

		tabrec	 ktrig_start, ktrig_stop, knumtics, kfn, kin1 [,kin2,...,kinN]

--------------------------------------------------------------------------
*tabsum*

Adding values in a range of a table.

	kr 	tabsum	 ifn[[, kmin] [, kmax]]

--------------------------------------------------------------------------
*tabw*

Fast table opcodes.

	ir 	tab_i	 indx, ifn[, ixmode]
	kr 	tab	 kndx, ifn[, ixmode]
	ar 	tab	 xndx, ifn[, ixmode]
		tabw_i	 isig, indx, ifn [,ixmode]
		tabw	 ksig, kndx, ifn [,ixmode]
		tabw	 asig, andx, ifn [,ixmode]

--------------------------------------------------------------------------
*tambourine*

Semi-physical model of a tambourine sound.

	ares 	tambourine	 kamp, idettack [, inum] [, idamp] [, imaxshake] [, ifreq] [, ifreq1] [, ifreq2]

--------------------------------------------------------------------------
*tan*

Performs a tangent function.

		tan	(x) (no rate restriction)

--------------------------------------------------------------------------
*tanh*

Performs a hyperbolic tangent function.

		tanh	(x) (no rate restriction)

--------------------------------------------------------------------------
*taninv2*

Returns an arctangent.

	ares 	taninv2	 ay, ax
	ires 	taninv2	 iy, ix
	kres 	taninv2	 ky, kx

--------------------------------------------------------------------------
*taninv*

Performs an arctangent function.

		taninv	(x) (no rate restriction)

--------------------------------------------------------------------------
*tb15*

Table Read Access inside expressions.

		tb0_init	 ifn
		tb1_init	 ifn
		tb2_init	 ifn
		tb3_init	 ifn
		tb4_init	 ifn
		tb5_init	 ifn
		tb6_init	 ifn
		tb7_init	 ifn
		tb8_init	 ifn
		tb9_init	 ifn
		tb10_init	 ifn
		tb11_init	 ifn
		tb12_init	 ifn
		tb13_init	 ifn
		tb14_init	 ifn
		tb15_init	 ifn
	iout = 	tb0	(iIndex)
	kout = 	tb0	(kIndex)
	iout = 	tb1	(iIndex)
	kout = 	tb1	(kIndex)
	iout = 	tb2	(iIndex)
	kout = 	tb2	(kIndex)
	iout = 	tb3	(iIndex)
	kout = 	tb3	(kIndex)
	iout = 	tb4	(iIndex)
	kout = 	tb4	(kIndex)
	iout = 	tb5	(iIndex)
	kout = 	tb5	(kIndex)
	iout = 	tb6	(iIndex)
	kout = 	tb6	(kIndex)
	iout = 	tb7	(iIndex)
	kout = 	tb7	(kIndex)
	iout = 	tb8	(iIndex)
	kout = 	tb8	(kIndex)
	iout = 	tb9	(iIndex)
	kout = 	tb9	(kIndex)
	iout = 	tb10	(iIndex)
	kout = 	tb10	(kIndex)
	iout = 	tb11	(iIndex)
	kout = 	tb11	(kIndex)
	iout = 	tb12	(iIndex)
	kout = 	tb12	(kIndex)
	iout = 	tb13	(iIndex)
	kout = 	tb13	(kIndex)
	iout = 	tb14	(iIndex)
	kout = 	tb14	(kIndex)
	iout = 	tb15	(iIndex)
	kout = 	tb15	(kIndex)

--------------------------------------------------------------------------
*tbvcf*

Models some of the filter characteristics of a Roland TB303 voltage-controlled filter.

	ares 	tbvcf	 asig, xfco, xres, kdist, kasym [, iskip]

--------------------------------------------------------------------------
*tempest*

Estimate the tempo of beat patterns in a control signal.

	ktemp 	tempest	 kin, iprd, imindur, imemdur, ihp, ithresh, ihtim, ixfdbak, istartempo, ifn [, idisprd] [, itweek]

--------------------------------------------------------------------------
*tempo*

Apply tempo control to an uninterpreted score.

		tempo	 ktempo, istartempo

--------------------------------------------------------------------------
*tempoval*

Reads the current value of the tempo.

	kres 	tempoval	

--------------------------------------------------------------------------
*then*

Branches conditionally at initialization or during performance time.

		if	 ia R ib 	igoto	 label
		if	 ka R kb 	kgoto	 label
		if	 xa R xb 	goto	 label
		if	 xa R xb 	then	

--------------------------------------------------------------------------
*then*

Defines another "if...then" condition when a "if...then" condition is false.

		elseif	 xa R xb 	then	

--------------------------------------------------------------------------
*tigoto*

Transfer control at i-time when a new note is being tied onto a previously held note

		tigoto	 label

--------------------------------------------------------------------------
*timedseq*

Time Variant Sequencer

	ktrig 	timedseq	 ktimpnt, ifn, kp1 [,kp2, kp3, ...,kpN]

--------------------------------------------------------------------------
*timeinstk*

Read absolute time in k-rate cycles.

	kres 	timeinstk	

--------------------------------------------------------------------------
*timeinsts*

Read absolute time in seconds.

	kres 	timeinsts	

--------------------------------------------------------------------------
*timek*

Read absolute time in k-rate cycles.

	ires 	timek	
	kres 	timek	

--------------------------------------------------------------------------
*times*

Read absolute time in seconds.

	ires 	times	
	kres 	times	

--------------------------------------------------------------------------
*timout*

Conditional branch during p-time depending on elapsed note time.

		timout	 istrt, idur, label

--------------------------------------------------------------------------
*tival*

Puts the value of the instrument's internal

	ir 	tival	

--------------------------------------------------------------------------
*tlineto*

Generate glissandos starting from a control signal.

	kres 	tlineto	 ksig, ktime, ktrig

--------------------------------------------------------------------------
*tone*

A first-order recursive low-pass filter with variable frequency response.

	ares 	tone	 asig, khp [, iskip]

--------------------------------------------------------------------------
*tonek*

A first-order recursive low-pass filter with variable frequency response.

	kres 	tonek	 ksig, khp [, iskip]

--------------------------------------------------------------------------
*tonex*

Emulates a stack of filters using the tone opcode.

	ares 	tonex	 asig, khp [, inumlayer] [, iskip]

--------------------------------------------------------------------------
*tradsyn*

Streaming partial track additive synthesis

	asig 	tradsyn	 fin, kscal, kpitch, kmaxtracks, ifn

--------------------------------------------------------------------------
*trandom*

Generates a controlled pseudo-random number series between min and max values according to a trigger.

	kout 	trandom	 ktrig, kmin, kmax

--------------------------------------------------------------------------
*transeg*

Constructs a user-definable envelope.

	ares 	transeg	 ia, idur, itype, ib [, idur2] [, itype] [, ic] ...
	kres 	transeg	 ia, idur, itype, ib [, idur2] [, itype] [, ic] ...

--------------------------------------------------------------------------
*transegr*

Constructs a user-definable envelope with extended release segment.

	ares 	transegr	 ia, idur, itype, ib [, idur2] [, itype] [, ic] ...
	kres 	transegr	 ia, idur, itype, ib [, idur2] [, itype] [, ic] ...

--------------------------------------------------------------------------
*trcross*

Streaming partial track cross-synthesis.

	fsig 	trcross	 fin1, fin2, ksearch,kdepth[,kmode] 

--------------------------------------------------------------------------
*trfilter*

Streaming partial track filtering.

	fsig 	trfilter	 fin, kamnt, ifn

--------------------------------------------------------------------------
*trhighest*

Extracts the highest-frequency track from a streaming track input signal.

	fsig, kfr,kamp 	trhighest	 fin1, kscal

--------------------------------------------------------------------------
*trigger*

Informs when a krate signal crosses a threshold.

	kout 	trigger	 ksig, kthreshold, kmode

--------------------------------------------------------------------------
*trigseq*

Accepts a trigger signal as input and outputs a group of values.

		trigseq	 ktrig_in, kstart, kloop, kinitndx, kfn_values, kout1 [, kout2] [...]

--------------------------------------------------------------------------
*trirand*

Triangular distribution random number generator

	ares 	trirand	 krange
	ires 	trirand	 krange
	kres 	trirand	 krange

--------------------------------------------------------------------------
*trlowest*

Extracts the lowest-frequency track from a streaming track input signal.

	fsig, kfr,kamp 	trlowest	 fin1, kscal

--------------------------------------------------------------------------
*trmix*

Streaming partial track mixing.

	fsig 	trmix	 fin1, fin2 

--------------------------------------------------------------------------
*trscale*

Streaming partial track frequency scaling.

	fsig 	trscale	 fin, kpitch[, kgain]

--------------------------------------------------------------------------
*trshift*

Streaming partial track frequency scaling.

	fsig 	trshift	 fin, kpshift[, kgain]

--------------------------------------------------------------------------
*trsplit*

Streaming partial track frequency splitting.

	fsiglow, fsighi 	trsplit	 fin, ksplit[, kgainlow, kgainhigh]

--------------------------------------------------------------------------
*turnoff2*

Turn off instance(s) of other instruments at performance time.

		turnoff2	 kinsno, kmode, krelease 

--------------------------------------------------------------------------
*turnoff*

Enables an instrument to turn itself off.

		turnoff	

--------------------------------------------------------------------------
*turnon*

Activate an instrument for an indefinite time.

		turnon	 insnum [, itime]

--------------------------------------------------------------------------
*unirand*

Uniform distribution random number generator (positive values only).

	ares 	unirand	 krange
	ires 	unirand	 krange
	kres 	unirand	 krange

--------------------------------------------------------------------------
*upsamp*

Modify a signal by up-sampling.

	ares 	upsamp	 ksig

--------------------------------------------------------------------------
*urd*

A discrete user-defined-distribution random generator that can be used as a function.

	aout = 	urd	(ktableNum)
	iout = 	urd	(itableNum)
	kout = 	urd	(ktableNum)

--------------------------------------------------------------------------
*vadd*

Adds a scalar value to a vector in a table.

		vadd	 ifn, kval, kelements [, kdstoffset] [, kverbose]

--------------------------------------------------------------------------
*vadd_i*

Adds a scalar value to a vector in a table.

		vadd_i	 ifn, ival, ielements [, idstoffset]

--------------------------------------------------------------------------
*vaddv*

Performs addition between two vectorial control signals

		vaddv	 ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]

--------------------------------------------------------------------------
*vaddv_i*

Performs addition between two vectorial control signals at init time.

		vaddv_i	 ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]

--------------------------------------------------------------------------
*vaget*

Access values of the current buffer of an a-rate variable by indexing.

	kval 	vaget	 kndx, avar

--------------------------------------------------------------------------
*valpass*

Variably reverberates an input signal with a flat frequency response.

	ares 	valpass	 asig, krvt, xlpt, imaxlpt [, iskip] [, insmps]

--------------------------------------------------------------------------
*vaset*

Write value of into the current buffer of an a-rate variable by index.

		vaset	 kval, kndx, avar

--------------------------------------------------------------------------
*vbap16*

Distributes an audio signal among 16 channels.

	ar1, ..., ar16 	vbap16	 asig, kazim [, kelev] [, kspread]

--------------------------------------------------------------------------
*vbap16move*

Distribute an audio signal among 16 channels with moving virtual sources.

	ar1, ..., ar16 	vbap16move	 asig, idur, ispread, ifldnum, ifld1 [, ifld2] [...]

--------------------------------------------------------------------------
*vbap4*

Distributes an audio signal among 4 channels.

	ar1, ar2, ar3, ar4 	vbap4	 asig, kazim [, kelev] [, kspread]

--------------------------------------------------------------------------
*vbap4move*

Distributes an audio signal among 4 channels with moving virtual sources.

	ar1, ar2, ar3, ar4 	vbap4move	 asig, idur, ispread, ifldnum, ifld1 [, ifld2] [...]

--------------------------------------------------------------------------
*vbap8*

Distributes an audio signal among 8 channels.

	ar1, ..., ar8 	vbap8	 asig, kazim [, kelev] [, kspread]

--------------------------------------------------------------------------
*vbap8move*

Distributes an audio signal among 8 channels with moving virtual sources.

	ar1, ..., ar8 	vbap8move	 asig, idur, ispread, ifldnum, ifld1 [, ifld2] [...]

--------------------------------------------------------------------------
*vbaplsinit*

Configures VBAP output according to loudspeaker parameters.

		vbaplsinit	 idim, ilsnum [, idir1] [, idir2] [...] [, idir32]

--------------------------------------------------------------------------
*vbapz*

Writes a multi-channel audio signal to a ZAK array.

		vbapz	 inumchnls, istartndx, asig, kazim [, kelev] [, kspread]

--------------------------------------------------------------------------
*vbapzmove*

Writes a multi-channel audio signal to a ZAK array with moving virtual sources.

		vbapzmove	 inumchnls, istartndx, asig, idur, ispread, ifldnum, ifld1, ifld2, [...]

--------------------------------------------------------------------------
*vcella*

Cellular Automata

		vcella	 ktrig, kreinit, ioutFunc, initStateFunc, iRuleFunc, ielements, irulelen [, iradius]

--------------------------------------------------------------------------
*vco2*

Implementation of a band-limited oscillator using pre-calculated tables.

	ares 	vco2	 kamp, kcps [, imode] [, kpw] [, kphs] [, inyx]

--------------------------------------------------------------------------
*vco2ft*

Returns a table number at k-time for a given oscillator frequency and wavform.

	kfn 	vco2ft	 kcps, iwave [, inyx]

--------------------------------------------------------------------------
*vco2ift*

Returns a table number at i-time for a given oscillator frequency and wavform.

	ifn 	vco2ift	 icps, iwave [, inyx]

--------------------------------------------------------------------------
*vco2init*

Calculates tables for use by vco2 opcode.

	ifn 	vco2init	 iwave [, ibasfn] [, ipmul] [, iminsiz] [, imaxsiz] [, isrcft]

--------------------------------------------------------------------------
*vco*

Implementation of a band limited, analog modeled oscillator.

	ares 	vco	 xamp, xcps, iwave, kpw [, ifn] [, imaxd] [, ileak] [, inyx] [, iphs] [, iskip]

--------------------------------------------------------------------------
*vcomb*

Variably reverberates an input signal with a

	ares 	vcomb	 asig, krvt, xlpt, imaxlpt [, iskip] [, insmps]

--------------------------------------------------------------------------
*vcopy*

Copies between two vectorial control signals

		vcopy	 ifn, ifn2, kelements [, kdstoffset] [, ksrcoffset] [, kverbose]

--------------------------------------------------------------------------
*vcopy_i*

Copies a vector from one table to another.

		vcopy_i	 ifn, ifn2, ielements [,idstoffset, isrcoffset]

--------------------------------------------------------------------------
*vdel_k *

Delays an input signal by some time interval.

	kr 	delayk 	 ksig, idel[, imode]
	kr 	vdel_k 	 ksig, kdel, imdel[, imode]

--------------------------------------------------------------------------
*vdelay3*

A variable time delay with cubic interpolation.

	ares 	vdelay3	 asig, adel, imaxdel [, iskip]

--------------------------------------------------------------------------
*vdelay*

An interpolating variable time delay.

	ares 	vdelay	 asig, adel, imaxdel [, iskip]

--------------------------------------------------------------------------
*vdelayk*

k-rate variable time delay.

	kout 	vdelayk	 iksig, kdel, imaxdel [, iskip, imode]

--------------------------------------------------------------------------
*vdelayx*

A variable delay opcode with high quality interpolation.

	aout 	vdelayx	 ain, adl, imd, iws [, ist]

--------------------------------------------------------------------------
*vdelayxq*

A 4-channel variable delay opcode with high quality interpolation.

	aout1, aout2, aout3, aout4 	vdelayxq	 ain1, ain2, ain3, ain4, adl, imd, iws [, ist]

--------------------------------------------------------------------------
*vdelayxs*

A stereo variable delay opcode with high quality interpolation.

	aout1, aout2 	vdelayxs	 ain1, ain2, adl, imd, iws [, ist]

--------------------------------------------------------------------------
*vdelayxw*

Variable delay opcodes with high quality interpolation.

	aout 	vdelayxw	 ain, adl, imd, iws [, ist]

--------------------------------------------------------------------------
*vdelayxwq*

Variable delay opcodes with high quality interpolation.

	aout1, aout2, aout3, aout4 	vdelayxwq	 ain1, ain2, ain3, ain4, adl, imd, iws [, ist]

--------------------------------------------------------------------------
*vdelayxws*

Variable delay opcodes with high quality interpolation.

	aout1, aout2 	vdelayxws	 ain1, ain2, adl, imd, iws [, ist]

--------------------------------------------------------------------------
*vdivv*

Performs division between two vectorial control signals

		vdivv	 ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]

--------------------------------------------------------------------------
*vdivv_i*

Performs division between two vectorial control signals at init time.

		vdivv_i	 ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]

--------------------------------------------------------------------------
*vecdelay*

Vectorial Control-rate Delay Paths

		vecdelay	 ifn, ifnIn, ifnDel, ielements, imaxdel [, iskip]

--------------------------------------------------------------------------
*veloc*

Get the velocity from a MIDI event.

	ival 	veloc	 [ilow] [, ihigh]

--------------------------------------------------------------------------
*vexp*

Performs power-of operations between a vector and a scalar

		vexp	 ifn, kval, kelements [, kdstoffset] [, kverbose]

--------------------------------------------------------------------------
*vexp_i*

Performs power-of operations between a vector and a scalar

		vexp_i	 ifn, ival, ielements[, idstoffset]

--------------------------------------------------------------------------
*vexpseg*

Vectorial envelope generator

		vexpseg	 ifnout, ielements, ifn1, idur1, ifn2 [, idur2, ifn3 [...]]

--------------------------------------------------------------------------
*vexpv*

Performs exponential operations between two vectorial control signals

		vexpv	 ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]

--------------------------------------------------------------------------
*vexpv_i*

Performs exponential operations between two vectorial control signals at init time.

		vexpv_i	 ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]

--------------------------------------------------------------------------
*vibes*

Physical model related to the striking of a metal block.

	ares 	vibes	 kamp, kfreq, ihrd, ipos, imp, kvibf, kvamp, ivibfn, idec

--------------------------------------------------------------------------
*vibr*

Easier-to-use user-controllable vibrato.

	kout 	vibr	 kAverageAmp, kAverageFreq, ifn

--------------------------------------------------------------------------
*vibrato*

Generates a natural-sounding user-controllable vibrato.

	kout 	vibrato	 kAverageAmp, kAverageFreq, kRandAmountAmp, kRandAmountFreq, kAmpMinRate, kAmpMaxRate, kcpsMinRate, kcpsMaxRate, ifn [, iphs]

--------------------------------------------------------------------------
*vincr*

Accumulates audio signals.

		vincr	 accum, aincr

--------------------------------------------------------------------------
*vlimit*

Limiting and Wrapping Vectorial Signals

		vlimit	 ifn, kmin, kmax, ielements

--------------------------------------------------------------------------
*vlinseg*

Vectorial envelope generator

		vlinseg	 ifnout, ielements, ifn1, idur1, ifn2 [, idur2, ifn3 [...]]

--------------------------------------------------------------------------
*vlowres*

A bank of filters in which the cutoff frequency can be separated under user control.

	ares 	vlowres	 asig, kfco, kres, iord, ksep

--------------------------------------------------------------------------
*vmap*

Maps elements from a vector according to indeces contained in another vector

		vmap	 ifn1, ifn2, ielements [,idstoffset, isrcoffset]

--------------------------------------------------------------------------
*vmirror*

Limiting and Wrapping Vectorial Signals

		vmirror	 ifn, kmin, kmax, ielements

--------------------------------------------------------------------------
*vmult*

Multiplies a vector in a table by a scalar value.

		vmult	 ifn, kval, kelements [, kdstoffset] [, kverbose]

--------------------------------------------------------------------------
*vmult_i*

Multiplies a vector in a table by a scalar value.

		vmult_i	 ifn, ival, ielements [, idstoffset]

--------------------------------------------------------------------------
*vmultv*

Performs mutiplication between two vectorial control signals

		vmultv	 ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]

--------------------------------------------------------------------------
*vmultv_i*

Performs mutiplication between two vectorial control signals at init time.

		vmultv_i	 ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]

--------------------------------------------------------------------------
*voice*

An emulation of a human voice.

	ares 	voice	 kamp, kfreq, kphoneme, kform, kvibf, kvamp, ifn, ivfn

--------------------------------------------------------------------------
*vosim*

Simple vocal simulation based on glottal pulses with formant characteristics.

	ar 	vosim	 kamp, kFund, kForm, kDecay, kPulseCount, kPulseFactor, ifn [, iskip]

--------------------------------------------------------------------------
*vphaseseg*

Allows one-dimensional HVS (Hyper-Vectorial Synthesis).

		vphaseseg	 kphase, ioutab, ielems, itab1,idist1,itab2 [,idist2,itab3, ... ,idistN-1,itabN]

--------------------------------------------------------------------------
*vport*

Vectorial Control-rate Delay Paths

		vport	 ifn, khtime, ielements [, ifnInit]

--------------------------------------------------------------------------
*vpow*

Raises each element of a vector to a scalar power

		vpow	 ifn, kval, kelements [, kdstoffset] [, kverbose]

--------------------------------------------------------------------------
*vpow_i*

Raises each element of a vector to a scalar power

		vpow_i	 ifn, ival, ielements [, idstoffset]

--------------------------------------------------------------------------
*vpowv*

Performs power-of operations between two vectorial control signals

		vpowv	 ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]

--------------------------------------------------------------------------
*vpowv_i*

Performs power-of operations between two vectorial control signals at init time.

		vpowv_i	 ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]

--------------------------------------------------------------------------
*vpvoc*

Implements signal reconstruction using an fft-based phase vocoder and an extra envelope.

	ares 	vpvoc	 ktimpnt, kfmod, ifile [, ispecwp] [, ifn]

--------------------------------------------------------------------------
*vrandh*

Generates a vector of random numbers stored into a table, holding the values for a period of time.

		vrandh	 ifn, krange, kcps, ielements [, idstoffset] [, iseed] [, isize] [, ioffset]

--------------------------------------------------------------------------
*vrandi*

Generate a sort of 'vectorial band-limited noise'

		vrandi	 ifn, krange, kcps, ielements [, idstoffset] [, iseed] [, isize] [, ioffset]

--------------------------------------------------------------------------
*vstaudiog*

VST audio output.

	aout1,aout2 	vstaudio	 instance, [ain1, ain2]
	aout1,aout2 	vstaudiog	 instance, [ain1, ain2]

--------------------------------------------------------------------------
*vstbankload*

Loads parameter banks to a VST plugin.

		vstbankload	 instance, ipath

--------------------------------------------------------------------------
*vstedit*

Opens the GUI editor widow for a VST plugin.

		vstedit	 instance

--------------------------------------------------------------------------
*vstinfo*

Displays the parameters and the programs of a VST plugin.

		vstinfo	 instance

--------------------------------------------------------------------------
*vstinit*

Load a VST plugin into memory for use with the other vst4cs opcodes.

	instance 	vstinit	 ilibrarypath [,iverbose]

--------------------------------------------------------------------------
*vstmidiout*

Sends MIDI information to a VST plugin.

		vstmidiout	 instance, kstatus, kchan, kdata1, kdata2

--------------------------------------------------------------------------
*vstnote*

Sends a MIDI note with definite duration to a VST plugin.

		vstnote	 instance, kchan, knote, kveloc, kdur 

--------------------------------------------------------------------------
*vstparamget *

Used for parameter comunication to and from a VST plugin.

		vstparamset 	instance, kparam, kvalue
	kvalue 	vstparamget 	instance, kparam

--------------------------------------------------------------------------
*vstprogset*

Loads parameter banks to a VST plugin.

		vstprogset	 instance, kprogram

--------------------------------------------------------------------------
*vsubv*

Performs subtraction between two vectorial control signals

		vsubv	 ifn1, ifn2, kelements [, kdstoffset] [, ksrcoffset] [,kverbose]

--------------------------------------------------------------------------
*vsubv_i*

Performs subtraction between two vectorial control signals at init time.

		vsubv_i	 ifn1, ifn2, ielements [, idstoffset] [, isrcoffset]

--------------------------------------------------------------------------
*vtaba*

Read vectors (from tables -or arrays of vectors).

		vtaba	 andx, ifn, aout1 [, aout2, aout3, .... , aoutN ]

--------------------------------------------------------------------------
*vtabi*

Read vectors (from tables -or arrays of vectors).

		vtabi	 indx, ifn, iout1 [, iout2, iout3, .... , ioutN ]

--------------------------------------------------------------------------
*vtabk*

Read vectors (from tables -or arrays of vectors).

		vtabk	 kndx, ifn, kout1 [, kout2, kout3, .... , koutN ]

--------------------------------------------------------------------------
*vtable1k*

Read a vector (several scalars simultaneously) from a table.

		vtable1k	 kfn,kout1 [, kout2, kout3, .... , koutN ]

--------------------------------------------------------------------------
*vtablea*

Read vectors (from tables -or arrays of vectors).

		vtablea	 andx, kfn, kinterp, ixmode, aout1 [, aout2, aout3, .... , aoutN ]

--------------------------------------------------------------------------
*vtablei*

Read vectors (from tables -or arrays of vectors).

		vtablei	 indx, ifn, interp, ixmode, iout1 [, iout2, iout3, .... , ioutN ]

--------------------------------------------------------------------------
*vtablek*

Read vectors (from tables -or arrays of vectors).

		vtablek	 kndx, kfn, kinterp, ixmode, kout1 [, kout2, kout3, .... , koutN ]

--------------------------------------------------------------------------
*vtablewa*

Write vectors (to tables -or arrays of vectors).

		vtablewa	 andx, kfn, ixmode, ainarg1 [, ainarg2, ainarg3 , .... , ainargN ]

--------------------------------------------------------------------------
*vtablewi*

Write vectors (to tables -or arrays of vectors).

		vtablewi	 indx, ifn, ixmode, inarg1 [, inarg2, inarg3 , .... , inargN ]

--------------------------------------------------------------------------
*vtablewk*

Write vectors (to tables -or arrays of vectors).

		vtablewk	 kndx, kfn, ixmode, kinarg1 [, kinarg2, kinarg3 , .... , kinargN ]

--------------------------------------------------------------------------
*vtabwa*

Write vectors (to tables -or arrays of vectors).

		vtabwa	 andx, ifn, ainarg1 [, ainarg2, ainarg3 , .... , ainargN ]

--------------------------------------------------------------------------
*vtabwi*

Write vectors (to tables -or arrays of vectors).

		vtabwi	 indx, ifn, inarg1 [, inarg2, inarg3 , .... , inargN ]

--------------------------------------------------------------------------
*vtabwk*

Write vectors (to tables -or arrays of vectors).

		vtabwk	 kndx, ifn, kinarg1 [, kinarg2, kinarg3 , .... , kinargN ]

--------------------------------------------------------------------------
*vwrap*

Limiting and Wrapping Vectorial Signals

		vwrap	 ifn, kmin, kmax, ielements

--------------------------------------------------------------------------
*waveset*

A simple time stretch by repeating cycles.

	ares 	waveset	 ain, krep [, ilen]

--------------------------------------------------------------------------
*weibull*

Weibull distribution random number generator (positive values only).

	ares 	weibull	 ksigma, ktau
	ires 	weibull	 ksigma, ktau
	kres 	weibull	 ksigma, ktau

--------------------------------------------------------------------------
*wgbow*

Creates a tone similar to a bowed string.

	ares 	wgbow	 kamp, kfreq, kpres, krat, kvibf, kvamp, ifn [, iminfreq]

--------------------------------------------------------------------------
*wgbowedbar*

A physical model of a bowed bar.

	ares 	wgbowedbar	 kamp, kfreq, kpos, kbowpres, kgain [, iconst] [, itvel] [, ibowpos] [, ilow]

--------------------------------------------------------------------------
*wgbrass*

Creates a tone related to a brass instrument.

	ares 	wgbrass	 kamp, kfreq, ktens, iatt, kvibf, kvamp, ifn [, iminfreq]

--------------------------------------------------------------------------
*wgclar*

Creates a tone similar to a clarinet.

	ares 	wgclar	 kamp, kfreq, kstiff, iatt, idetk, kngain, kvibf, kvamp, ifn [, iminfreq]

--------------------------------------------------------------------------
*wgflute*

Creates a tone similar to a flute.

	ares 	wgflute	 kamp, kfreq, kjet, iatt, idetk, kngain, kvibf, kvamp, ifn [, iminfreq] [, ijetrf] [, iendrf]

--------------------------------------------------------------------------
*wgpluck2*

Physical model of the plucked string.

	ares 	wgpluck2	 iplk, kamp, icps, kpick, krefl

--------------------------------------------------------------------------
*wgpluck*

A high fidelity simulation of a plucked string.

	ares 	wgpluck	 icps, iamp, kpick, iplk, idamp, ifilt, axcite

--------------------------------------------------------------------------
*wguide1*

A simple waveguide model consisting of one delay-line and one first-order lowpass filter.

	ares 	wguide1	 asig, xfreq, kcutoff, kfeedback

--------------------------------------------------------------------------
*wguide2*

A model of beaten plate consisting of two parallel delay-lines and two first-order lowpass filters.

	ares 	wguide2	 asig, xfreq1, xfreq2, kcutoff1, kcutoff2, kfeedback1, kfeedback2

--------------------------------------------------------------------------
*wiiconnect*

Reads data from a number of external Nintendo Wiimote controllers.

	kres 	wiiconnect	 [itimeout, imaxnum]

--------------------------------------------------------------------------
*wiidata*

Reads data fields from a number of external Nintendo Wiimote controllers.

	kres 	wiidata	 kcontrol[, knum]

--------------------------------------------------------------------------
*wiirange*

Sets scaling and range limits for certain Wiimote fields.

	 	wiirange	 icontrol, iminimum, imaximum[, inum]

--------------------------------------------------------------------------
*wiisend*

Sends data to one of a number of external Nintendo Wiimote controllers.

	kres 	wiisend	 kcontrol, kvalue[, knum]

--------------------------------------------------------------------------
*wrap*

Wraps-around the signal that exceeds the low and high thresholds.

	ares 	wrap	 asig, klow, khigh
	ires 	wrap	 isig, ilow, ihigh
	kres 	wrap	 ksig, klow, khigh

--------------------------------------------------------------------------
*wterrain*

A simple wave-terrain synthesis opcode.

	aout 	wterrain	 kamp, kpch, k_xcenter, k_ycenter, k_xradius, k_yradius, itabx, itaby

--------------------------------------------------------------------------
*xadsr*

Calculates the classical ADSR envelope.

	ares 	xadsr	 iatt, idec, islev, irel [, idel]
	kres 	xadsr	 iatt, idec, islev, irel [, idel]

--------------------------------------------------------------------------
*xin*

Passes variables to a user-defined opcode block,

	xinarg1 [, xinarg2] ... [xinargN] 	xin	

--------------------------------------------------------------------------
*xout*

Retrieves variables from a user-defined opcode block,

		xout	 xoutarg1 [, xoutarg2] ... [, xoutargN]

--------------------------------------------------------------------------
*xscanmap*

Allows the position and velocity of a node in a scanned process to be read.

	kpos, kvel 	xscanmap	 iscan, kamp, kvamp [, iwhich]

--------------------------------------------------------------------------
*xscans*

Fast scanned synthesis waveform and the wavetable generator.

	ares 	xscans	 kamp, kfreq, ifntraj, id [, iorder]

--------------------------------------------------------------------------
*xscansmap*

Allows the position and velocity of a node in a scanned process to be read.

		xscansmap	 kpos, kvel, iscan, kamp, kvamp [, iwhich]

--------------------------------------------------------------------------
*xscanu*

Compute the waveform and the wavetable for use in scanned synthesis.

		xscanu	 init, irate, ifnvel, ifnmass, ifnstif, ifncentr, ifndamp, kmass, kstif, kcentr, kdamp, ileft, iright, kpos, kstrngth, ain, idisp, id

--------------------------------------------------------------------------
*xtratim*

Extend the duration of real-time generated events.

		xtratim	 iextradur

--------------------------------------------------------------------------
*xyin*

Sense the cursor position in an output window

	kx, ky 	xyin	 iprd, ixmin, ixmax, iymin, iymax [, ixinit] [, iyinit]

--------------------------------------------------------------------------
*zacl*

Clears one or more variables in the za space.

		zacl	 kfirst, klast

--------------------------------------------------------------------------
*zakinit*

Establishes zak space.

		zakinit	 isizea, isizek

--------------------------------------------------------------------------
*zamod*

Modulates one a-rate signal by a second one.

	ares 	zamod	 asig, kzamod

--------------------------------------------------------------------------
*zar*

Reads from a location in za space at a-rate.

	ares 	zar	 kndx

--------------------------------------------------------------------------
*zarg*

Reads from a location in za space at a-rate, adds some gain.

	ares 	zarg	 kndx, kgain

--------------------------------------------------------------------------
*zaw*

Writes to a za variable at a-rate without mixing.

		zaw	 asig, kndx

--------------------------------------------------------------------------
*zawm*

Writes to a za variable at a-rate with mixing.

		zawm	 asig, kndx [, imix]

--------------------------------------------------------------------------
*zfilter2*

Performs filtering using a transposed form-II digital filter lattice with radial pole-shearing and angular pole-warping.

	ares 	zfilter2	 asig, kdamp, kfreq, iM, iN, ib0, ib1, ..., ibM, ia1,ia2, ..., iaN

--------------------------------------------------------------------------
*zir*

Reads from a location in zk space at i-rate.

	ir 	zir	 indx

--------------------------------------------------------------------------
*ziw*

Writes to a zk variable at i-rate without mixing.

		ziw	 isig, indx

--------------------------------------------------------------------------
*ziwm*

Writes to a zk variable to an i-rate variable with mixing.

		ziwm	 isig, indx [, imix]

--------------------------------------------------------------------------
*zkcl*

Clears one or more variables in the zk space.

		zkcl	 kfirst, klast

--------------------------------------------------------------------------
*zkmod*

Facilitates the modulation of one signal by another.

	kres 	zkmod	 ksig, kzkmod

--------------------------------------------------------------------------
*zkr*

Reads from a location in zk space at k-rate.

	kres 	zkr	 kndx

--------------------------------------------------------------------------
*zkw*

Writes to a zk variable at k-rate without mixing.

		zkw	 ksig, kndx

--------------------------------------------------------------------------
*zkwm*

Writes to a zk variable at k-rate with mixing.

		zkwm	 ksig, kndx [, imix]

--------------------------------------------------------------------------
*|*

Bitwise OR operator.

	a 	|	 b (bitwise OR)

--------------------------------------------------------------------------
*||*

Logical OR operator.

	a 	||	 b (logical OR; not audio-rate)

--------------------------------------------------------------------------
*~*

Bitwise NOT operator.

		~	 a (bitwise NOT)
