Stereo Imaging Transforms Illustrated | SuperCollider 3.13.0 Help

We'll first use the stereo scope to illustrate these transforms. Let's boot the server:s.boot

To display signals as lissajous patterns:// display ( var scope; var numChannels = 2; scope = Stethoscope.new(s, numChannels); scope.style = 2; // Lissajous display )

Stereo Transformations

Stereo domains: LR to MS and back

Our first two transforms translate between different representations of a stereo image. The left-right (LR) and middle-and-side (MS) domains are orthogonal: no information is lost transforming between the two.¹ Note that for both transforms, each channel is the scaled sum or difference of its counterpart's channels.

Transforming from MS to LR

Transforming from LR to MS

Stereo Rotation

Stereo rotation is the full-stereo equivalent of the Sine-Cosine panning law. Under the rotation transform, all elements of the stereo image are repositioned without any change to gain. Note that with true stereo rotation, it is possible to place the image in "phasey" regions of the stereo field, reducing mono compatibility.

Stereo rotation

Let's take a listen. Evaluate the following code block to hear the rotation of two enveloped sinusoids. Note the rotation of the the lissajous pattern on the stethoscope.( ~rotTest = { var in, inL, inR; var out; var lfo; var env1, env2; var freqMod; freqMod = LFNoise2.kr(3.3).range(0.99, 1.01); // L and R channels inL = SinOsc.ar(440 * freqMod, mul: 0.3); inR = SinOsc.ar(330 * freqMod, mul: 0.3); // L and R envelopes #env1, env2 = EnvGen.kr( Env.perc(releaseTime: 0.3), Impulse.kr([5, 3]) ); // Stereo input in = [ inL * env1, inR * env2 ]; lfo = LFSaw.kr(0.1).range(0, 2pi); out = BlumRotate.ar( in: in, angle: lfo ); // compare in/out signals // in out }.play )

Compression towards an axis: Width and Balance

The width transformation adjusts the relative gains of the M and S components of the stereo signal, compressing the image towards the M- or S- axis. This is equivalent to rotating the L and R axes opposite one another by a given angle.

Stereo width

The code below illustrates the bounds of the width transformation. On the lissajous display, observe the compression of the pattern towards one axis, then another (Note: this display is rotated 45 degrees from what one would expect to see on a goniometer. Here, the stereo L and R channels are mapped to the X- and Y- inputs, respectively).( ~widthTest = { var in, out; var lfo; var freq1, freq2; freq1 = LFNoise2.kr(freq: 1000).range(330 * 0.8, 330 * 1.2); freq2 = LFNoise2.kr(freq: 1000).range(440 * 0.8, 440 * 1.2); // Select an input // in = SinOsc.ar([440, 330], mul: 0.3); // in = PinkNoise.ar(mul: [0.5, 0.5]); in = SinOsc.ar([freq1, freq2], mul: 0.3); // LFOs lfo = LFTri.kr(0.1).range(-pi/4, pi/4); // alternate between fully M and fully S out = BlumWidth.ar(in, lfo); // compare in/out signals // in out }.play )

Stereo balance, on the other hand, adjusts the relative gains of the L and R components of the stereo signal. It is the L-R domain equivalent of the width transformation, as if rotating the M and S axes opposite one another.

Stereo balance

In this example, we'll hear a pair of enveloped sinusoids panned hard left and right. Modulating the balance of the stereo image results in the alternation between apparent singals. Observe how this produces a lissajous pattern similar to that of the width transform, but shifted 90 degrees.( ~balanceTest = { var inL, inR; var out; var env1, env2; var in; var lfo; var freqMod; freqMod = LFNoise2.kr(3.3).range(0.98, 1.02); // L and R channels inL = SinOsc.ar(440 * freqMod, mul: 0.3); inR = SinOsc.ar(330 * freqMod, mul: 0.3); // L and R envelopes #env1, env2 = EnvGen.kr( Env.perc(releaseTime: 0.3), Impulse.kr([10, 7]) ); // Stereo input in = [ inL * env1, inR * env2 ]; // Other inputs // in = SinOsc.ar([440, 330], mul: 0.3); // Transform LFO lfo = LFTri.kr(0.3).range(-pi/4, pi/4); // Note that values outside these bounds will wrap out = BlumBalance.ar(in, lfo); // compare in/out signals // in out }.play; )

Rotations of a single axis: Middle, Left, and Right Panorama, and Asymmetry

Middle panorama rotates the M-axis, leaving the S-axis in place. The equation below is derived from the rotation transform applied in the MS domain.

Middle panorama

In the following example, we start by defining an input signal in the MS domain. Decorrelated sinusoid appear in the side, while pink noise appears in the middle channel. After encoding the stereo signal in the LR domain, transforming the image with middle panorama rotates the noise component around the stereo field, leaving the sinusoids at the side of the image.( ~mPanTest = { var in, out; var env; var lfo; var m, s; // Inputs env = EnvGen.kr( envelope: Env.perc(releaseTime: 0.3), gate: Impulse.kr(4.0); ); // ms input m = PinkNoise.ar(0.5); s = SinOsc.ar(phase: [0, pi/2], mul: 0.3) * env; in = BlumMStoLR.ar([m, s]); // LFOs // lfo = LFTri.kr(0.3).range(-pi/4, pi/4); // standard bounds lfo = LFSaw.kr(0.1).range(0, 2pi); // full rotation of m-channel out = BlumMPan.ar(in, lfo); // compare in/out signals // in out }.play )

Similarly, asymmetry is the rotation of the S-axis, leaving the M-axis in place.

Stereo asymmetry

Like the above example, we author a stereo image in the MS domain. This time, we rotate the side component: enveloped noise. The sinusoid in the middle of the image is static.( ~asymTest = { var in, out; var env; var lfo; var m, s; // Inputs env = EnvGen.kr( envelope: Env.perc(releaseTime: 0.3), gate: Impulse.kr(8.0); ); // ms input m = SinOsc.ar(330, mul: 0.15); s = PinkNoise.ar(0.8) * env; in = BlumMStoLR.ar([m, s]); // LFOs // lfo = LFTri.kr(0.3).range(-pi/4, pi/4); // standard bounds lfo = LFSaw.kr(0.1).range(0, 2pi); // full rotation of m-channel out = BlumAsym.ar(in, lfo); // compare in/out signals // in out }.play )

Left and Right panorama are the LR domain applications of the above two transforms. Note the similarity between left panorama and asymmetry and between right and middle panorama.

Left panorama

right panorama

These examples use a pair of harmonic sinusoids panned hard left and right to illustrate the rotation of only L or R channels.( ~lPanTest = { var in, out; var lfo; // Inputs in = SinOsc.ar([440, 330], mul: 0.3); // LFOs lfo = LFTri.kr(0.3).range(-pi/2, pi/2); // wide bounds out = BlumLPan.ar(in, lfo); // compare in/out signals // in out }.play ) ( ~rPanTest = { var in, out; var lfo; // Inputs in = SinOsc.ar([330, 440], mul: 0.3); // LFOs lfo = LFTri.kr(0.3).range(-pi/2, pi/2); // wide bounds out = BlumRPan.ar(in, lfo); // compare in/out signals // in out }.play )

Stereo Analyses

This tutorial is derived from lecture notes from DXARTS 462: Digital Sound Processing, University of Washington, Spring 2022.²

Signal Power

The following analysis functions assume that the input is a stereo signal. To begin, let's consider a mono source encoded with the Sine-Cosine Panning Law. The following are the scalars with which to multiply the mono signal to derive the left and right stereo channels.

Sine-Cosine coefficients

Applying coefficients to the input to place it in the stereo field

Though all BlumBox analysis functions have a flag for instantaneous analysis, we'll focus on their time averaged counterparts. We'll denote time averaging of a signal with angle brackets:

Time averaging

The time averaged power of the input monphonic signal is calculated:

Time Averaged Power

With a signal encoded with the sine-cosine law, let's review how to find the power of the encoded input signal:

What we see is that given the Pythagorean trigonometric identity, the coefficients gL and gR drop out, and we can directly extract the time averaged power of the input monphonic signal. We can re-write for clarity:

The BlumBox includes an analysis function for both instantaneous and time averaged stereo signal power: BlumFollowPower.

Cartesian image analysis: stereo balance and correlation

The time averaged balance indicates how the power is balanced across the left-right axis of the stereo field, and can be found:

And solving for the trigonometric expression:

The returned value varies between 1 and -1, and these are mapped across the image:

position	left	center	right
value	`1.0`	`0.0`	`-1.0`

To find stereo signal balance, we'll use the BlumBox's BlumFollowBalance.

Time averaged correlation indicates how the power is balanced across the middle-side axis of the stereo field. We can think of this value as indicating how stereo the signal is:

And solving for the trigonometric expression:

The returned value varies between 1 and -1 and these are mapped:

position	middle	de-correlated	side
value	`1.0`	`0.0`	`-1.0`

See Kendall's discussion as to how these values of correlation audition.³

BlumFollowCorrelation gives us a quick way to return stereo correlation.

Polar image analysis: Encoding angle and radius

Both balance and correlation are returned to us as trigonometric expressions:

You'll notice that we can extract the panorama angle:

The Blumlein Box function BlumFollowAngle does this for us!

Similarly, using the trigonometric relationship between balance and correlation, we can extract the encoding radius of the stereo signal with BlumFollowRadius.

What use is this?

Synthesis & Analysis

SuperCollider's colored noise generators can be used to return decorrelated signals. Given a decorrelated SOURCE, we can use stereo imaging transforms to further shape the panorama of the generated image. In the example below we'll use width followed by rotate.

We'll then display an analysis of balance and correlation of the synthesized image in a scope. Left-Right balance is mapped to the x-axis and Middle-Side correlation to the y-axis. Additionally, we'll poll the analyzed panorama angle to the post window.

Realtime Example

NOTE: For those using the Composer's Toolkit, see CTKanalysis: CTK Imaging Analysis

We'll render this in realtime.

____________________

Evaluate the codeblock below. Notice, there are several example note calls to try.

NOTE: Un-comment only one note example at a time!

(
///////////////// DEFINE VARIABLES //////////////////

var score, pinkSynthDef, analyDef, envDef;
var start, dur, gain, panAngle, widthAngle;
var outBus, dispBus, dispBusIndex, ctrlBus, group;
var pink, envCtrl, analySynth, server;

server = Server.default;

server.waitForBoot({

///////////////// DEFINE SYNTHS //////////////////

// audio source: pink noise
    SynthDef.new(\pink, { |dur, gain = 0.0, ris = 0.01, dec = 0.01, outBus, ctrlBus|
        var hardwareOut = 0;  // bus index for hardware output
        var amp;          // a few vars for synthesis
        var sig, out;     // vars assigned to audio signals
        var ampEnv;       // var for envelope signal
        var panAngle, widthAngle; // signals read from control bus
        var doneAction = Done.freeSelf;
        var numCtrlChans = 2; // control bus has two signals

// calcs
        amp = gain.dbamp;  // convert from gain in dB to linear amplitude scale

// the amplitude envelope nested in the UGen that synthesises the envelope
        ampEnv = EnvGen.kr(
            Env.linen(ris, 1.0 - (ris + dec), dec),
            timeScale: dur,
            doneAction: doneAction
        );

// read pan and with angles from control bus
        #panAngle, widthAngle = In.kr(ctrlBus, numCtrlChans);

// post pan angle in degrees (for display)
        panAngle.raddeg.poll(label: "pan_____");  // <-- Quote this out if you don't want to post the angle

// generate test signal, decorrelated PinkNoise
        sig = PinkNoise.ar([1, 1]);  // <-- Imaging happens here!

// stereo imaging - width & rotate
        sig = BlumWidth.ar(sig, widthAngle); // <-- And here!
        sig = BlumRotate.ar(sig, panAngle); // <-- And here!

// apply envelope
        sig = amp * ampEnv * sig;

// imaged
        out = sig;

// out!!
        Out.ar(outBus, out); // private bussing
        Out.ar(hardwareOut, out); // hardware output
    }).add;

// envelope generator for width and rotation
    SynthDef.new(\envCtrl,
        { |dur = 20.0, panStart = 0.0, panEnd = 0.0, widthStart = 0.0, widthEnd = 0.0, ctrlBus|
            var panEnv, widthEnv;
            var ctrlSig;
            var doneAction = Done.freeSelf;

panEnv = EnvGen.kr(
                envelope: Env.new([panStart, panEnd], [1.0], \lin),
                timeScale: dur,
                doneAction: doneAction
            );

widthEnv = EnvGen.kr(
                envelope: Env.new([widthStart, widthEnd], [1.0], \lin),
                timeScale: dur
            );

ctrlSig = [panEnv, widthEnv];

Out.kr(ctrlBus, ctrlSig)
        }
    ).add;

// a simple synthDef to analize the stereo image
    // in terms of stereo balance and correlation
    // we'll use SC3's X/Y scope to view!
    SynthDef.new(\analySynth, { |dur, aveTime = 0.005, radius = 0.1, receiveBus, dispBus|
        var inSig, dispSig;
        var numChannels = 2;
        var circle;
        var angle;
        var balance, correlation;
        var numSamps;

// select instantaneous vs time-averaged analysis
        var method = 'average';
        // var method = 'instant';

// calculate number of samples for time averaged analysis
        numSamps = aveTime * SampleRate.ir;

// for instantaneous analysis, round number of samples to next power of 2
        (method == 'instant').if({ numSamps = 2 ** (log(numSamps)/log(2)).ceil });

// generate "noisy circle"
        circle = (SinOsc.ar(ControlRate.ir, [pi/2, 0.0]) * LFNoise2.ar(ControlRate.ir, [1, 1]));

// receive test signal
        inSig = In.ar(receiveBus, numChannels);

// analysis - find angle (for display)
        angle = BlumFollowAngle.ar(inSig, numSamps, method: 'average');

// post angle analysis result in degrees
        (angle.raddeg).poll(label: "analyzed");  // <-- Quote this out if you don't want to post the angle

// analysis: find balance & correlation
        balance = BlumFollowBalance.ar(inSig, numSamps, method: 'average');
        correlation = BlumFollowCorrelation.ar(inSig, numSamps, method: 'average');

dispSig = [balance, correlation];

dispSig = ((1.0 - radius) * dispSig) + (radius * circle);  // add the "noisy circle"
        dispSig = [-1, 1] * dispSig;  // remap for X/Y display

// outputs here
        Out.ar(
            dispBus, // analysis send outs
            dispSig
        );
    }).add;

server.sync;

///////////////// SET VARIABLE VALUES //////////////////

// create the bus for hardware output
    outBus = Bus.audio(server: server, numChannels: 2);

// create the sendBus: a two channel (stereo) bus
    dispBus = Bus.audio(server: server, numChannels: 2);

// control bus for pan and width angle parameters
    ctrlBus = Bus.control(server: server, numChannels: 2);

// create a node group
    group = Group.new();

server.sync;

///////////////// SET PARAMETER VALUES //////////////////

// common values...
    dur = 15.0;
    gain = -6.0;

///////////////// EXAMPLES //////////////////

// Uncomment one of the following synths:

// Example 1
    //
    // mono pink noise - pan from -S to +S
    //
    // same as PAN!
    //
    // write envelope values to control bus
    envCtrl = Synth.new(
        defName: \envCtrl,
        args: [
            \dur, dur,
            \panStart, -90.0.degrad, \panEnd, 90.0.degrad,
            \widthStart, -45.0.degrad, \widthEnd, -45.0.degrad,
            \ctrlBus, ctrlBus.index
        ],
        target: group,
        addAction: \addToHead
    );

// Example 2
    //
    // partially decorrelated pink noise - pan from -S to +S
    //
    // ROTATE a stereo image
    //
    // write envelope values to control bus
    /*envCtrl = Synth.new(
    defName: \envCtrl,
    args: [
    \dur, dur,
    \panStart, -90.0.degrad, \panEnd, 90.0.degrad,
    \widthStart, -22.5.degrad, \widthEnd, -22.5.degrad,
    \ctrlBus, ctrlBus.index
    ],
    target: group,
    addAction: \addToHead
    );*/

// Example 3
    //
    // mono - decorrelated - mono pink noise - pan from +R to +L
    //
    // same as BALANCE!
    //
    // write envelope values to control bus
    /*envCtrl = Synth.new(
    defName: \envCtrl,
    args: [
    \dur, dur,
    \panStart, -45.degrad, \panEnd, -45.degrad,
    \widthStart, -45.0.degrad, \widthEnd, 45.0.degrad,
    \ctrlBus, ctrlBus.index
    ],
    target: group,
    addAction: \addToHead
    );*/

// Example 4
    //
    // mono - decorrelated - mono pink noise - pan from +M to +S
    //
    // same as WIDTH!
    //
    // write envelope values to control bus
    /*envCtrl = Synth.new(
    defName: \envCtrl,
    args: [
    \dur, dur,
    \panStart, 0.degrad, \panEnd, 0.degrad,
    \widthStart, -45.0.degrad, \widthEnd, 45.0.degrad,
    \ctrlBus, ctrlBus.index
    ],
    target: group,
    addAction: \addToHead
    );*/

// play synth, reading values from control bus
    pink = Synth.new(
        defName: \pink,
        args: [\dur, dur, \gain, gain, \outBus, outBus.index, \ctrlBus, ctrlBus.index],
        target: group,
        addAction: \addToTail
    );

// write to display bus
    analySynth = Synth.new(
        defName: \analySynth,
        args: [\dur, dur, \receiveBus, outBus.index, \dispBus, dispBus.index],
        target: group,
        addAction:\addToTail
    );

// view the analysis, using the X/Y scope
    server.scope(2, index: dispBus.index).style_(2);

// free the buses, group etc...
    dur.wait;
    analySynth.free;
    ctrlBus.free;
    outBus.free;
    group.free;
})

)

Stereo Imaging Transforms Illustrated
Extension