|
Minim |
|
|
GranulateRandom Fields
audio Methods
channelCount ( ) |
GranulateRandom is randomly varying version of GranulateSteady.
Rather than have fixed values for grain length, space length,
and fade length, it has min and max values for each so that each
grain is different from the last.
Constructors Constructor for GranulateRandom. grainLengthMin, minimum grain length of each grain, defaults to 10 msec. spaceLengthMin, minimum space between each grain, defaults to 20 msec. fadeLengthMin, minimum length of the linear fade in and fade out of the i grain envelope, defaults to 2.5 msec. grainLengthMax, maximum grain length of each grain, defaults to 100 msec. spaceLengthMax, maximum space between each grain, defaults to 200 msec. fadeLengthMax, maximum length of the linear fade in and fade out of the grain envelope, defaults to 25 msec. minAmp, minimum amplitude of the envelope, defaults to 0. maxAmp, maximum amplitude of the envelope, defaults to 1. GranulateRandom() Constructor for GranulateRandom. minAmp, minimum amplitude of the envelope, defaults to 0. maxAmp, maximum amplitude of the envelope, defaults to 1. GranulateRandom(float grainLengthMin, float spaceLengthMin, float fadeLengthMin, float grainLengthMax, float spaceLengthMax, float fadeLengthMax) Constructor for GranulateRandom GranulateRandom(float grainLengthMin, float spaceLengthMin, float fadeLengthMin, float grainLengthMax, float spaceLengthMax, float fadeLengthMax, float minAmp, float maxAmp) Parameters grainLengthMin — float: minimum grain length of each grain in secondsspaceLengthMin — float: minimum space between each grain in seconds fadeLengthMin — float: minimum length of the linear fade in and fade out of the grain envelope in seconds grainLengthMax — float: maximum grain length of each grain in seconds spaceLengthMax — float: maximum space between each grain in seconds fadeLengthMax — float: maximum length of the linear fade in and fade out of the grain envelope in seconds minAmp — float: minimum amplitude of the envelope maxAmp — float: maximum amplitude of the envelope Related GranulateSteadyUGen Example /* granulateRandomExample<br/>
is an example of using the GranulateRandom UGen inside an instrument.
The GranulateRandom UGen is basically an amplitude modulation of the
incoming audio, which turns on for a random amount of time and then off
again for a random amount of time. If one uses several of these concurrently
it produces the "grain cloud" typical of granular synthesis.
<p>
For more information about Minim and additional features,
visit http://code.compartmental.net/minim/
<p>
author: Anderson Mills<br/>
Anderson Mills's work was supported by numediart (www.numediart.org)
*/
// import everything necessary to make sound.
import ddf.minim.*;
import ddf.minim.ugens.*;
// create all of the variables that will need to be accessed in
// more than one methods (setup(), draw(), stop()).
Minim minim;
AudioOutput out;
// The GranularInstrument is intended use GranulateRandom to chop up audio
// generated using a triangle wave
// into sound grains which are random in length and spaced randomly within the
// parameters given. The beginning frequency and the ending frequency of the
// tone is set in the constructor of the instrument.
// Every instrument must implement the Instrument interface so
// playNote() can call the instrument's methods.
class GrabularInstrument implements Instrument
{
// create all variables that must be used throughout the class
Line freqLine;
GranulateRandom chopper;
// the constructor for this instrument. The amplitude and beginning and ending
// frequency must all be specified.
GrabularInstrument( float amplitude, float begFreq, float endFreq )
{
// create new instances of any UGen objects necessary
// the tone
Oscil toneOsc = new Oscil( begFreq, amplitude, Waves.TRIANGLE);
// a line to specify the frequency of the tone
freqLine = new Line( 2.6, begFreq, endFreq );
// the granulation of the tone
chopper = new GranulateRandom( 0.005, 0.005, 0.001, 0.020, 0.020, 0.002 );
// patch everything together up until the output
// the frequency line goes to the toneOsc frequency
freqLine.patch( toneOsc.frequency );
// and the tone goes into the chopper
toneOsc.patch( chopper );
}
// every instrument must have a noteOn( float ) method
void noteOn( float dur )
{
// change the time of the line to the duration minus 1 second
freqLine.setLineTime( dur - 1.0 );
// activate the line
freqLine.activate();
// and patch the chopper to the output to get the ball rolling
chopper.patch( out );
}
// every instrument must have a noteOff() method
void noteOff()
{
// pull the chopper off the output
// an ADSR here would be nicer, but this is the dirty way
chopper.unpatch( out );
}
}
// setup is run once at the beginning
void setup()
{
// initialize the drawing window
size(512, 200, P2D);
// initialize the minim and out objects
minim = new Minim(this);
out = minim.getLineOut(Minim.MONO, 2048);
// the note offsets are calculated because this makes composition easier
// because there are so many calls to the granularInstrument, it becomes easier
// to compose here by using variables for note parameters.
float myOffset = 0.5;
float noteLen = 0.0;
out.setNoteOffset( myOffset );
// this starts with three GroanularInstruments all taking the same path
float myTargetFreq = 660.9f;
float vol = 0.2;
noteLen = 4.5;
out.playNote( 0.0, noteLen, new GrabularInstrument( vol, 440.0f, myTargetFreq ) );
out.playNote( 0.1, noteLen, new GrabularInstrument( vol, 440.0f, myTargetFreq ) );
out.playNote( 0.2, noteLen, new GrabularInstrument( vol, 440.0f, myTargetFreq ) );
// set up the offset for the next note
myOffset += noteLen;
out.setNoteOffset( myOffset );
// The next "note" will be nine GranularInstruments headed from the previous myTargetFreq
// to the first 9 harmonics of 220Hz (220, 440, 660, ... )
vol = 0.15;
noteLen = 7.0;
int nFreqs = 9;
float myFreqs[] = new float[ nFreqs ];
for ( int i=0; i<nFreqs; i++ )
{
//myFreqs[ i ] = random( 900 ) + 100.0;
myFreqs[ i ] = i*220.0;
}
out.playNote( 0.00, noteLen, new GrabularInstrument( vol, myTargetFreq, myFreqs[ 0 ] ) );
out.playNote( 0.05, noteLen, new GrabularInstrument( vol, myTargetFreq, myFreqs[ 1 ] ) );
out.playNote( 0.10, noteLen, new GrabularInstrument( vol, myTargetFreq, myFreqs[ 2 ] ) );
out.playNote( 0.15, noteLen, new GrabularInstrument( vol, myTargetFreq, myFreqs[ 3 ] ) );
out.playNote( 0.20, noteLen, new GrabularInstrument( vol, myTargetFreq, myFreqs[ 4 ] ) );
out.playNote( 0.25, noteLen, new GrabularInstrument( vol, myTargetFreq, myFreqs[ 5 ] ) );
out.playNote( 0.30, noteLen, new GrabularInstrument( vol, myTargetFreq, myFreqs[ 6 ] ) );
out.playNote( 0.35, noteLen, new GrabularInstrument( vol, myTargetFreq, myFreqs[ 7 ] ) );
out.playNote( 0.40, noteLen, new GrabularInstrument( vol, myTargetFreq, myFreqs[ 8 ] ) );
// set up the next note offset
myOffset += noteLen;
out.setNoteOffset( myOffset );
// The next note will be 9 GranularInstruments going from their previous values to a
// new myTargetFreq.
myTargetFreq = 1320.9f;
vol = 0.15;
noteLen = 7.0;
out.playNote( 0.05, noteLen, new GrabularInstrument( vol, myFreqs[ 0 ], myTargetFreq ) );
out.playNote( 0.10, noteLen, new GrabularInstrument( vol, myFreqs[ 1 ], myTargetFreq ) );
out.playNote( 0.15, noteLen, new GrabularInstrument( vol, myFreqs[ 2 ], myTargetFreq ) );
out.playNote( 0.20, noteLen, new GrabularInstrument( vol, myFreqs[ 3 ], myTargetFreq ) );
out.playNote( 0.25, noteLen, new GrabularInstrument( vol, myFreqs[ 4 ], myTargetFreq ) );
out.playNote( 0.30, noteLen, new GrabularInstrument( vol, myFreqs[ 5 ], myTargetFreq ) );
out.playNote( 0.35, noteLen, new GrabularInstrument( vol, myFreqs[ 6 ], myTargetFreq ) );
out.playNote( 0.40, noteLen, new GrabularInstrument( vol, myFreqs[ 7 ], myTargetFreq ) );
out.playNote( 0.45, noteLen, new GrabularInstrument( vol, myFreqs[ 8 ], myTargetFreq ) );
}
// draw is run many times
void draw()
{
// erase the window to dark green
background( 0, 64, 32 );
// draw using a purple stroke
stroke( 232, 0, 255 );
// draw the waveforms
for( int i = 0; i < out.bufferSize() - 1; i++ )
{
// find the x position of each buffer value
float x1 = map( i, 0, out.bufferSize(), 0, width );
float x2 = map( i+1, 0, out.bufferSize(), 0, width );
// draw a line from one buffer position to the next for both channels
line( x1, 50 + out.left.get(i)*50, x2, 50 + out.left.get(i+1)*50);
line( x1, 150 + out.right.get(i)*50, x2, 150 + out.right.get(i+1)*50);
}
}
Usage Web & Application |