Installing Meson and Ninja

The best maintained backend of Meson is Ninja. Installing both can be done with your distribution's package manager, with PIP, Homebrew, etc. The version for your user and your superuser has to be the same.

Fedora

sudo dnf install meson ninja-build

Debian/Ubuntu

sudo apt install meson

macOS:

sudo brew install meson

PIP:

sudo pip install meson ninja

Build

Meson builds in a separate directory. It doesn't touch anything of your project. This way you can have seperate debug and release build directories for example.

Prepare your build directory:

meson builddir                                  # defaults to debug build

## Additional build directories
meson --buildtype release build_release         # release build
meson --buildtype debugoptimized build_debug    # optimized debug build
```

Now build with Ninja:

cd builddir
ninja

Install with:

sudo ninja install

Configuration

If you are in a build directory, meson configure shows you all available options.

Activating DSP

PD patches will only process audio when DSP has been activated. This can be done in the Media section of the top menu or with the shortcut Ctrl+/ (Cmd+/ on Mac). DSP can always be killed using the shortcut Ctrl+. (Cmd+. on Mac).

References

Spherical Harmonics

Ambisonics is based on a decomposition of a sound field into spherical harmonics. These spherical harmonics encode the sound field according to different axes, respectively angles of incidence. The number of Ambisonics channels $N$ is equal to the number of spherical harmonics. It can be calculated for a given order $M$ with the following formula:

Figure 1 shows the first 16 spherical harmonics. The first row ($N=1$) is the omnidirectional sound pressure for the order $M=0$. Rows 1-2 together represent the $N=4$ spherical harmonics of the first order Ambisonics signal, rows 1-3 correspond to $M=2$, respectively $N=9$ and rows 1-4 to the third order Ambisonics signal with $N=16$ spherical harmonics. First order ambisonics is sufficient to encode a threedimensional sound field. The higher the Ambisonics order, the more precise the directional encoding.

Ambisonic Formats

An Ambisonics B Format file or signal carries all $N$ spherical harmonics. Figure 2 shows a first order B Format signal.

There are different conventions for the sequence of the individual signals, as well as for the normalization.

The Recording

Load HOA Stuff

// load HOA stuff for binaural:
(
HOABinaural.loadbinauralIRs(s);
HOABinaural.loadHeadphoneCorrections(s);
HOABinaural.binauralIRs;
HOABinaural.headPhoneIRs;
)

Load Ambisonics File into Buffer

The following code works with the file located in the same directory as the working script. A buffer is used to read the four channel file:

(
var str = "210321_011_Raven.WAV";
~buf    = Buffer.read(s,str,0,-1);
)


// plot the audio data (may take some time):
~buf.plot();

Create a Playback Node

The buffer can be used with a PlayBuf UGen, to create a node which plays the sample in a continuous loop. An extra 4-channel audio bus is created for the Ambisonics signal. It can be monitored to check whether the signal is playing properly:

// create a 4-channel audio bus for the Ambisonics signal
~ambi_BUS =Bus.audio(s,4);

// create a playback node (looped)
(
~playback = {

    var signal  =   PlayBuf.ar(4, ~buf, 1, loop:1);

    Out.ar(~ambi_BUS,signal*5);

}.play;

)

// monitor all 4 Ambisonics channel
~ambi_BUS.scope();

Create Binaural Decoder

An second node is created for decoding the Ambisonics signal, allowing an additional rotation of the sound image. It has three arguments for setting pitch, roll and yaw. Make sure to move the new node after the playback node to get an audible result:

// create a decoder with angles as arguments:
(

~decoder = {

    arg pitch=0, roll=0, yaw=0;

    var input    = In.ar(~ambi_BUS.index, 4);

    var rotated  = HOATransRotateXYZ.ar(1, input, pitch, roll, yaw);

    var binaural = HOABinaural.ar(1,rotated);

    Out.ar(0, binaural);

}.play;

)

// move after playback node
~decoder.moveAfter(~playback);

Exercises

Stereo Version

Although this stereo version does not capture the full spatial experience, it conveys the granular nature of the piece:

Spectral Spatialization

Spectral spatialization is an advanced form of spatialization, which is based on a separation of audio signals into frequency bands (Kim-Boyle, 2008). These frequency bands can be distributed in space which allows a dynamic spreading of existing sound material. Spectral spatialization methods are found in many electroacoustic compositions and live electronic performances.

Spatial Sound Synthesis

Spatial sound synthesis refers to spatialization at an early stage in the synthesis process. In contrast to classic spatialization of existing sources, this results in spatially distributed sounds. Approaches towards spatial sound synthesis have been presented for most known synthesis principles, including additive synthesis (Topper, 2002), granular synthesis (Roads, 2004), physical modeling (Mueller, 2009) and modulation synthesis (McGee, 2015).

References

Installing the Library

On Ubuntu systems, as the ones used in this class, the liblo library is installed with the following command:

$ sudo apt-get install liblo-dev

Including the Library

The liblo comes with additional C++11 wrappers to offer an object-oriented workflow. This feature is also used in the examples of this class. The following lines include both headers:

#include <lo/lo.h>
#include <lo/lo_cpp.h>

The GainExample

The GainExample is based on the ThroughExample, adding the capability to control the gain of the passed through signal with OSC messages.

$ ./gain_example -p 6666

// create new server
st = new lo::ServerThread ( p );

// / Add the example handler to the server !
st->add_method("/gain", "f", gain_callback, this);

st -> start ();

statCast->gain = argv[0]->f;

// get the recent gain value from the OSC manager
double gain = oscman->get_gain();

out[chanCNT][sampCNT] = in[chanCNT][sampCNT] * gain;

Compiling

When compiling with g++, the liblo library needs to be linked in addition to the JACK library:

$ g++ -Wall -std=c++11 src/main.cpp src/gain_example.cpp src/oscman.cpp -ljack -llo -o gain_example

Compiling a Program

Examples and projects in this modules can be compiled with g++ from the GNU Compiler Collection. With the proper libraries installed, g++ can be called directly for small to medium sized projects. The first example, just passing through the audio, is compiled with the following command:

g++ -Wall src/gain_example.cpp src/oscman.cpp -ljack -o gain_example

The compiler gets the extra argument Wall to print all warnings. All source (cpp) files are passed to the compiler, followed by all libraries which need to be linked (linker arguments). The name of the binary or executable is specified after the -o flag.

Build Scripts