SuperCollider: Modulación

TUTORIAL DE SUPERCOLLIDER 3 - PARTE 7
Rodrigo F. Cadiz, basado en apuntes de Gary S. Kendall
Northwestern University

(
Server.internal.boot;
Server.default = Server.internal;
s = Server.default;
)


Amplitude Modulation

Type #1 Ring/Balanced/Double-Sideband-Suppressed-Carrier Modulation

The amplitude of one signal varies according to another signal.

Slow amplitude modulation, that is, when the modulating frequency is less than 20 Hz., can
sound like a steady rhythm.  But when the modulating frequency is above 20 Hz, it sounds 
like a continuous tone with sidebands.

{SinOsc.ar(1000,0) * SinOsc.ar(Line.kr(1,50,30),0) }.play; 
// Nothing more than two sinusoids multiplied


Slow modulation of the modulator frequency reveals the sound of sidebands moving up and down simultaneously.

{
	var modFreq;
	modFreq = Line.kr(0, 600, 30); // Modulation frequency goes from 0 to 600 Hz
	SinOsc.ar(1000,0) * SinOsc.ar(modFreq,0) 
}.play;

The multiplication of one signal by another is better done with the mul: argument.

{
	var modFreq, amp;
	modFreq = Line.kr(0, 600, 30);
	amp = SinOsc.ar(modFreq,0);
	SinOsc.ar(1000,0,amp); // Rewritten for faster multiply
}.play;



Type #2 AM/Double-Sideband Modulation

Here the modulation index provides a way of controlling the amount of modulation
and simultaneously the amount of energy in the sidebands.

This example is easy to see in the time domain.

{
	var modIndex, modSignal;
	modIndex = Line.kr(0,1,12);		// Modulation Index goes from 0 to 1
	// Normalization is needed if you want to keep the signal level constant
	modSignal = (1 + (modIndex * SinOsc.ar(378,0))) / (1 + modIndex);
	modSignal * SinOsc.ar(1000,0,0.5);
}.play;

Below we use a conditional to mimic the behavior of an analog system. Overmodulation occures 
when the modIndex is greater than 1.  Here like in an analog system, the modution signal 
can not become negative and therefore the process in non-linear and produces many sidebands.

{
	var modIndex, modSignal;
	modIndex = Line.kr(0,5,10);
	modSignal = (1 + (modIndex * SinOsc.ar(79,0))) / (1 + modIndex);
	modSignal = modSignal.max(0); // passes just the positive part of the control signal
	modSignal * SinOsc.ar(1000,0,0.5);
}.play;



Frequency Modulation

In the following example the frequency of the audio rate oscillator is modulated by the control rate oscillator.

Carrier frequency is 700 Hz and the frequency deviation is 300 Hz.  The control frequency is only 0.5 Hz.

{
	SinOsc.ar(		// carrier oscillator
		SinOsc.ar(	// modulator oscillator
			0.5,		// modulating frequency
			0,		// zero phase
			300,		// mul field is the freqency deviation
			700		// add field is the carrier frequency
					// These settings of mul and add will cause the
					// frequency to vary from -300+700 to +300+700 Hz
					// which equals from 400 to 1000 Hz
		),
		0,			// zero phase
		0.5			// amplitude 0.5
	)
}.play;


The control frequency will now increate linearly from 0.5 to 100 Hz.  Note the changes in the resulting sound from a sine wave with changing pitch to a complex tone with multiple sidebands.

// sweep freq of LFO
{
	SinOsc.ar(			// carrier oscillator
		SinOsc.ar(		// modulator oscillator
			XLine.kr(		// make an exponential line generator for modulating freuqency
				1,		// begin at 1 Hz
				1000,	// end at 1000 Hz
				20		// in 20 seconds
			),
			0,			// zero phase
			300,		// mul field is the freqency deviation
			1000		// add field is the carrier frequency
		),
		0,				// zero phase
		0.5				// amplitude 0.5
	)
}.play;

By changing the frequency deviation (and thus, the modulation index) the distribution of energy in the sidebands changes.

(The nested style used above can become hard to read, so often it is preferable to use variables to make it  more readable.)

This one makes it easy to see the frequency modulation in the time domain.

{
	var freqDev, freq;		// declare the variables we will use in this function.
	
	freqDev = Line.kr(		// make a linear line generator
				({
	var fundFreq, peakFMI, carrierFreq, modulatorFreq, env1, env2, amp, instFreqDv, instFreq;
	fundFreq = 440.0;	// fundamental frequency
	c = 3; m = 1;	// All harmonics
	peakFMI = 2;
	carrierFreq = c * fundFreq;		// C:M ratio determines the carrier and
	modulatorFreq = m * fundFreq;	//  the modulator frequencies
	
	env1 = Env.new([0,5.0,3.75,3.0,0]/5,[0.15,0.15,0.15,0.15],'linear');
	amp = EnvGen.kr(env1);
	//env2 = Env.new([3*peakFMI, peakFMI, 0.7 * peakFMI],[0.3,0.45],'linear');
	env2 = Env.new([0.3*peakFMI, peakFMI, 2.0 * peakFMI],[0.3,0.45],'linear');
	instFreqDv = modulatorFreq * EnvGen.kr(env2);
	
	instFreq = SinOsc.ar(modulatorFreq,0,instFreqDv,carrierFreq);
	SinOsc.ar(instFreq,0,amp);	
}.play;)
0,		// begin at 0 Hz
				600,		// end at 600 Hz
				20		// in 20 seconds
			);
			
	freq = SinOsc.ar(	// modulating signal
			100,		// modulating frequency fixed at 100 Hz
			0,		// zero phase
			freqDev,	// mul field is the frequency deviation
			1000		// add field is the carrier frequency
		);
		
	SinOsc.ar(		// create a sine oscillator
		freq, 		// frequency modulator
		0,			// zero phase
		0.5			// amplitude 0.5
	)
}.play;


The example below implements a very simple Chowning FM instrument in which 
	the carrier and the modulating frequency are identical and one envelope controls the amplitude and the
	modulation index.

{
		var env, amp, instFreqDv, instFreq;	
		//env = Env.linen(3.0, 3.0, 3.0, 0.5); 
		env = Env.linen(0.1, 0.2, 0.3, 0.5); 
		amp = EnvGen.kr(env);	// amplitude envelope
		
		// instantaneous frequency = carrierFreq + FreqDv * Sin(modulatorFreq)
		// carrierFreq = modulatorFreq = 500 Hz
		// FreqDv = 2000 Hz
		instFreqDv = amp * 2000.0;  // amp envelop is used to change 
				// instantaneous frequency deviation
		instFreq = SinOsc.ar(500,0,instFreqDv,500);  // modulator = 500 Hz
		SinOsc.ar(instFreq,0,amp);					// carrier = 500 Hz
}.play;

Here is an example in which the C:M ratios and peakFMI can be altered.

({
	var fundFreq, peakFMI, carrierFreq, modulatorFreq, env, amp, instFreqDv, instFreq;
	fundFreq = 400.0;	// fundamental frequency
	c = 1; m = 1;	// All harmonics
	//c = 1; m = 2;	// Missing every 2nd harmonic
	//c = 1; m = 3;	// Missing every 3rd harmonic
	//c = 5; m = 1;	// All harmonics and starts on 5th harmonic
	//c = 1; m = 1.414;  //  Inharmonic 
	peakFMI = 10;
	carrierFreq = c * fundFreq;		// C:M ratio determines the carrier and
	modulatorFreq = m * fundFreq;	//  the modulator frequencies
	
	env = Env.new([0,5.0,3.75,3.0,0]/5,[0.15,0.15,0.15,0.15],'linear');
	amp = EnvGen.kr(env);
	
	instFreqDv = peakFMI * amp * modulatorFreq;
	instFreq = SinOsc.ar(modulatorFreq,0,instFreqDv,carrierFreq);
	SinOsc.ar(instFreq,0,amp);	
}.play;)

Here is an example with separate envelopes for the amplitude and for the frequency modulation index.

({
	var fundFreq, peakFMI, carrierFreq, modulatorFreq, env1, env2, amp, instFreqDv, instFreq;
	fundFreq = 440.0;	// fundamental frequency
	c = 3; m = 1;	// All harmonics
	peakFMI = 2;
	carrierFreq = c * fundFreq;		// C:M ratio determines the carrier and
	modulatorFreq = m * fundFreq;	//  the modulator frequencies
	
	env1 = Env.new([0,5.0,3.75,3.0,0]/5,[0.15,0.15,0.15,0.15],'linear');
	amp = EnvGen.kr(env1);
	//env2 = Env.new([3*peakFMI, peakFMI, 0.7 * peakFMI],[0.3,0.45],'linear');
	env2 = Env.new([0.3*peakFMI, peakFMI, 2.0 * peakFMI],[0.3,0.45],'linear');
	instFreqDv = modulatorFreq * EnvGen.kr(env2);
	
	instFreq = SinOsc.ar(modulatorFreq,0,instFreqDv,carrierFreq);
	SinOsc.ar(instFreq,0,amp);	
}.play;)

TUTORIAL DE SUPERCOLLIDER 3 - PARTE 8
Rodrigo F. Cadiz, basado en apuntes de Gary S. Kendall
Northwestern University

Mas FM

Detuning by a small factor.

({
	var fundFreq, detune, peakFMI, carrierFreq, modulatorFreq, env1, env2, amp, instFreqDv, instFreq;
	fundFreq = 440.0;	// fundamental frequency
	detune = 0.5;
	c = 1; 
	m = 1;
	peakFMI = 3;
	carrierFreq = c * fundFreq;				// C:M ratio determines the carrier and
	modulatorFreq = m * fundFreq + detune;     //  the modulator frequency + detuning
	
	env1 = Env.new([0,5.0,3.75,3.0,0]/5,[0.15,0.15,2,0.15],'linear');  // amp Env
	amp = EnvGen.kr(env1);
	env2 = Env.new([2 * peakFMI, peakFMI, peakFMI],[0.3,0.45],'linear');   // FMI Env
	instFreqDv = modulatorFreq * EnvGen.kr(env2);
	
	instFreq = SinOsc.ar(modulatorFreq,0,instFreqDv,carrierFreq);
	SinOsc.ar(instFreq,0,amp);	
}.play)


Multiple-Carrier FM can often produce tones with a vowel-like quality.

({
	var fundFreq, c1, c2, peakFMI, carrierFreq1, carrierFreq2, modulatorFreq, env1, env2; 
	var amp, freqDv, instFreqDv;
	fundFreq = 440.0;
	c1 = 1; 
	c2 = 6; 
	m = 1;
	peakFMI = 0.5;
	carrierFreq1 = c1 * fundFreq;  // C1 : C2 : M ratio
	carrierFreq2 = c2 * fundFreq;		
	modulatorFreq = m * fundFreq;	
	
	env1 = Env.new([0,5.0,3.75,3.0,0]/5,[0.15,0.15,2.0,0.15],'linear');
	amp = 0.3 * EnvGen.kr(env1);
	env2 = Env.new([0.5 * peakFMI, peakFMI, 0.7 * peakFMI],[0.3,0.45],'linear');
	freqDv = modulatorFreq * EnvGen.kr(env2);
	
	instFreqDv = SinOsc.ar(modulatorFreq,0,freqDv);
	SinOsc.ar(instFreqDv+carrierFreq1,0,amp) + 		// Two carriers are being modulated
	SinOsc.ar(instFreqDv+carrierFreq2,0,amp);	
}.play)


Multiple-Modulator FM can often produce tones with a smoother quality than raw FM.

({
	var fundFreq, m1, m2, peakFMI1, peakFMI2, carrierFreq, modulatorFreq1, modulatorFreq2;
	var env1, env2, amp, instFMI, instFreqDv1, instFreqDv2, instFreq;
	fundFreq = 440.0;	
	c = 1; 
	m1 = 1; 
	m2 = 4;
	peakFMI1 = 1;
	peakFMI2 = 0.4;
	carrierFreq = c * fundFreq + 0.5;  // C : M1 : M2 ratio
	modulatorFreq1 = m1 * fundFreq;	
	modulatorFreq2 = m2 * fundFreq;	
	
	env1 = Env.new([0,5.0,3.75,3.0,0]/5,[0.15,0.15,2.0,0.15],'linear');
	amp = 0.5 * EnvGen.kr(env1);
	env2 = Env.new([2.0, 1.0, 0.6],[0.3,0.45],'linear');
	instFMI = EnvGen.kr(env2);				                         //  One FMI envelope
	
	instFreqDv1 = peakFMI1 * modulatorFreq1 * instFMI;  //     with individual 
	instFreqDv2 = peakFMI2 * modulatorFreq2 * instFMI; // instantaneous frequency deviations
	
	instFreq = SinOsc.ar(modulatorFreq1,0,instFreqDv1) +  // Two modulating oscillators
				SinOsc.ar(modulatorFreq2,0,instFreqDv2) +
				carrierFreq;
	
	SinOsc.ar(instFreq,0,amp);   // One carrier
}.play)

({
	// Try different values for fundFreq
	var fundFreq = 1760;
	var duration, detune, peakFMI, vibRate, vibDepth;
	var carrierFreq, modulatorFreq, octave,attackTm, sustainTm, releaseTm;
	var env1, env2, env3, amp, instFreqDv, instVib, instFreq;
	
	// parameters
	duration = 2.0;
	detune = 0.5;
	c = 2; m = 1;
	peakFMI = 3.0;
	vibRate = 4.0;
	vibDepth = 0.006;
	
	//  calculate actual carrier and modulator frequencies
	carrierFreq = c * fundFreq;	
	modulatorFreq = m * fundFreq + detune.rand;  // random variations
	
	// modifications based on fundamental frequency
	octave = fundFreq.cpsoct;	// determine the octave
	post('octave = ');octave.postln;
	peakFMI = peakFMI * 20.0 / (octave*octave);  // peakFM decreases in higher octaves
	vibRate = vibRate * octave / 5.0;  // vibRate increases in higher octaves
	vibDepth = vibDepth * 5.0 / octave;
	postln('peakFMI/vibRate/vibDepth = '); peakFMI.postln;vibRate.postln;vibDepth.postln;
	// attack and release times based on fundamental frequency
	attackTm = 0.4 * 4.0 / fundFreq.cpsoct;   // attackTM decreases in higher octaves
	releaseTm = 1.5* attackTm;
	sustainTm = duration - attackTm - releaseTm;
	if (releaseTm > sustainTm, {releaseTm = sustainTm = (duration - attackTm)/2});

	//  amplitude envelope
	env1 = Env.new([0,1.0,0.75,0],[attackTm,sustainTm,releaseTm],'linear');
	amp = EnvGen.kr(env1);
	//  FMI envelope
	env2 = Env.new([2*peakFMI, peakFMI, 0.8*peakFMI, 
				0.5*peakFMI],[attackTm,sustainTm,releaseTm],'linear');
	instFreqDv = modulatorFreq * EnvGen.kr(env2);
	//  vibrato envelope
	env3 = Env.new([0,vibDepth,0.8*vibDepth,0],[attackTm,sustainTm,releaseTm],'linear');
	instVib = 1 + SinOsc.kr(vibRate + 3.0.rand,0,EnvGen.kr(env3));
	
	instFreq = SinOsc.ar(instVib*modulatorFreq,0,instFreqDv,instVib*carrierFreq);
	SinOsc.ar(instFreq,0,amp);	
}.play;)
More complete instrument design Version #1:

Vibrato added with its own envelope.

({
		var fundFreq, duration, detune, peakFMI, vibRate, vibDepth;
		var carrierFreq, modulatorFreq, attackTm, sustainTm, releaseTm;
		var env1, env2, env3, amp, instFreqDv, instVib, instFreq;
		
		// parameters
		fundFreq = 880.0;
		duration = 2.0;
		detune = 0.5;
		c = 2; m = 1;
		peakFMI = 3;
		vibRate = 5.0;  // vibrator rate
		vibDepth = 0.008;  // vibrato depth as a fraction of fundament frequency

		//  calculate actual carrier and modulator frequencies
		carrierFreq = c * fundFreq;	
		modulatorFreq = m * fundFreq + detune.rand;  // random detuning
		post('carrier frequency = '); carrierFreq.postln;
		post('modulator frequency = '); modulatorFreq.postln;

		// attack and release times
		attackTm = 0.3;
		releaseTm = 2.0* attackTm;
		sustainTm = duration - attackTm - releaseTm;
		if (releaseTm > sustainTm, {releaseTm = sustainTm = (duration - attackTm)/2});
		post('attack time = '); attackTm.postln;
		post('sustain time = '); sustainTm.postln;
		post('release time = '); releaseTm.postln;

		//  amplitude envelope
		env1 = Env.new([0,1.0,0.75,0],[attackTm,sustainTm,releaseTm],'linear');
		amp = EnvGen.kr(env1);
		//  FMI envelope
		env2 = Env.new([2*peakFMI, peakFMI, 0.8*peakFMI, 
					0.5*peakFMI],[attackTm,sustainTm,releaseTm],'linear');
		instFreqDv = modulatorFreq * EnvGen.kr(env2);
		//  vibrato envelope
		env3 = Env.new([0,vibDepth,0.8*vibDepth,0],[attackTm,sustainTm,releaseTm],'linear');
		instVib = 1 + SinOsc.kr(vibRate + 3.0.rand,0, EnvGen.kr(env3)); // random variations too
		
		instFreq = SinOsc.ar(instVib*modulatorFreq, 0, instFreqDv, instVib*carrierFreq); 
					// vibrator affects both carrier and modulators
		SinOsc.ar(instFreq,0,amp);	
}.play;)


More complete instrument design Version #2:

Parameters are made sensitive to the octave of the fundamental.

({
	// Try different values for fundFreq
	var fundFreq = 1760;
	var duration, detune, peakFMI, vibRate, vibDepth;
	var carrierFreq, modulatorFreq, octave,attackTm, sustainTm, releaseTm;
	var env1, env2, env3, amp, instFreqDv, instVib, instFreq;
	
	// parameters
	duration = 2.0;
	detune = 0.5;
	c = 2; m = 1;
	peakFMI = 3.0;
	vibRate = 4.0;
	vibDepth = 0.006;
	
	//  calculate actual carrier and modulator frequencies
	carrierFreq = c * fundFreq;	
	modulatorFreq = m * fundFreq + detune.rand;  // random variations
	
	// modifications based on fundamental frequency
	octave = fundFreq.cpsoct;	// determine the octave
	post('octave = ');octave.postln;
	peakFMI = peakFMI * 20.0 / (octave*octave);  // peakFM decreases in higher octaves
	vibRate = vibRate * octave / 5.0;  // vibRate increases in higher octaves
	vibDepth = vibDepth * 5.0 / octave;
	postln('peakFMI/vibRate/vibDepth = '); peakFMI.postln;vibRate.postln;vibDepth.postln;
	// attack and release times based on fundamental frequency
	attackTm = 0.4 * 4.0 / fundFreq.cpsoct;   // attackTM decreases in higher octaves
	releaseTm = 1.5* attackTm;
	sustainTm = duration - attackTm - releaseTm;
	if (releaseTm > sustainTm, {releaseTm = sustainTm = (duration - attackTm)/2});

	//  amplitud({
	// Try different values for fundFreq
	var fundFreq = 1760;
	var duration, detune, peakFMI, vibRate, vibDepth;
	var carrierFreq, modulatorFreq, octave,attackTm, sustainTm, releaseTm;
	var env1, env2, env3, amp, instFreqDv, instVib, instFreq;
	
	// parameters
	duration = 2.0;
	detune = 0.5;
	c = 2; m = 1;
	peakFMI = 3.0;
	vibRate = 4.0;
	vibDepth = 0.006;
	
	//  calculate actual carrier and modulator frequencies
	carrierFreq = c * fundFreq;	
	modulatorFreq = m * fundFreq + detune.rand;  // random variations
	
	// modifications based on fundamental frequency
	octave = fundFreq.cpsoct;	// determine the octave
	post('octave = ');octave.postln;
	peakFMI = pe({
	// Try different values for fundFreq
	var fundFreq = 1760;
	var duration, detune, peakFMI, vibRate, vibDepth;
	var carrierFreq, modulatorFreq, octave,attackTm, sustainTm, releaseTm;
	var env1, env2, env3, amp, instFreqDv, instVib, instFreq;
	
	// parameters
	duration = 2.0;
	detune = 0.5;
	c = 2; m = 1;
	peakFMI = 3.0;
	vibRate = 4.0;
	vibDepth = 0.006;
	
	//  calculate actual carrier and modulator frequencies
	carrierFreq = c * fundFreq;	
	modulatorFreq = m * fundFreq + detune.rand;  // random variations
	
	// modifications based on fundamental frequency
	octave = fundFreq.cpsoct;	// determine the octave
	post('octave = ');octave.postln;
	peakFMI = peakFMI * 20.0 / (octave*octave);  // peakFM decreases in higher octaves
	vibRate = vibRate * octave / 5.0;  // vibRate increases in higher octaves
	vibDepth = vibDepth * 5.0 / octave;
	postln('peakFMI/vibRate/vibDepth = '); peakFMI.postln;vibRate.postln;vibDepth.postln;
	// attack and release times based on fundamental frequency
	attackTm = 0.4 * 4.0 / fundFreq.cpsoct;   // attackTM decreases in higher octaves
	releaseTm = 1.5* attackTm;
	sustainTm = duration - attackTm - releaseTm;
	if (releaseTm > sustainTm, {releaseTm = sustainTm = (duration - attackTm)/2});

	//  amplitude envelope
	env1 = Env.new([0,1.0,0.75,0],[attackTm,sustainTm,releaseTm],'linear');
	amp = EnvGen.kr(env1);
	//  FMI envelope
	env2 = Env.new([2*peakFMI, peakFMI, 0.8*peakFMI, 
				0.5*peakFMI],[attackTm,sustainTm,releaseTm],'linear');
	instFreqDv = modulatorFreq * EnvGen.kr(env2);
	//  vibrato envelope
	env3 = Env.new([0,vibDepth,0.8*vibDepth,0],[attackTm,sustainTm,releaseTm],'linear');
	instVib = 1 + SinOsc.kr(vibRate + 3.0.rand,0,EnvGen.kr(env3));
	
	instFreq = SinOsc.ar(instVib*modulatorFreq,0,instFreqDv,instVib*carrierFreq);
	SinOsc.ar(instFreq,0,amp);	
}.play;)akFMI * 20.0 / (octave*octave);  // peakFM decreases in higher octaves
	vibRate = vibRate * octave / 5.0;  // vibRate increases in higher octaves
	vibDepth = vibDepth * 5.0 / octave;
	postln('peakFMI/vibRate/vibDepth = '); peakFMI.postln;vibRate.postln;vibDepth.postln;
	// attack and release times based on fundamental frequency
	attackTm = 0.4 * 4.0 / fundFreq.cpsoct;   // attackTM decreases in higher octaves
	releaseTm = 1.5* attackTm;
	sustainTm = duration - attackTm - releaseTm;
	if (releaseTm > sustainTm, {releaseTm = sustainTm = (duration - attackTm)/2});

	//  amplitude envelope
	env1 = Env.new([0,1.0,0.75,0],[attackTm,sustainTm,releaseTm],'linear');
	amp = EnvGen.kr(env1);
	//  FMI envelope
	env2 = Env.new([2*peakFMI, peakFMI, 0.8*peakFMI, 
				0.5*peakFMI],[attackTm,sustainTm,releaseTm],'linear');
	instFreqDv = modulatorFreq * EnvGen.kr(env2);
	//  vibrato envelope
	env3 = Env.new([0,vibDepth,0.8*vibDepth,0],[attackTm,sustainTm,releaseTm],'linear');
	instVib = 1 + SinOsc.kr(vibRate + 3.0.rand,0,EnvGen.kr(env3));
	
	instFreq = SinOsc.ar(instVib*modulatorFreq,0,instFreqDv,instVib*carrierFreq);
	SinOsc.ar(instFreq,0,amp);	
}.play;)e envelope
	env1 = Env.new([0,1.0,0.75,0],[attackTm,sustainTm,releaseTm],'linear');
	amp = EnvGen.kr(env1);
	//  FMI envelope
	env2 = Env.new([2*peakFMI, peakFMI, 0.8*peakFMI, 
				0.5*peakFMI],[attackTm,sustainTm,releaseTm],'linear');
	instFreqDv = modulatorFreq * EnvGen.kr(env2);
	//  vibrato envelope
	env3 = Env.new([0,vibDepth,0.8*vibDepth,0],[attackTm,sustainTm,releaseTm],'linear');
	instVib = 1 + SinOsc.kr(vibRate + 3.0.rand,0,EnvGen.kr(env3));
	
	instFreq = SinOsc.ar(instVib*modulatorFreq,0,instFreqDv,instVib*carrierFreq);
	SinOsc.ar(instFreq,0,amp);	
}.play;)