Conference Year: 2024

There is a dramatically increasing demand for artists and audio professionals to create content specifically for 3D-immersive listening on headphones and at home plus new audio experiences as demonstrated by venues such as Lightroom (London), Dareshack (Bristol) and Sphere (Las Vegas).

Most immersive music content, however, is re-purposed stereo productions never intended to be heard outside the two-speaker stereo environment with resulting output feeling disconnected and unfulfilling.

Record companies and artists want to avoid paying for post-production immersive audio mixes of original stereo recordings. They are increasingly requesting music studios deliver cost-effective ways for recording music from the outset in both stereo and immersive formats.

In this panel talk, the makers of 'Flow', Real World Studios, Dr Ruth Farrar from Bath Spa University and Adrian Utley from the band Portishead will share knowledge gained during this immersive music project. They will share insights from their trial to develop new immersive audio processing workflows to overcome current challenges of moving between stereo and immersive formats. They will also discuss their process for developing equipment set-up and sound capture approaches to create novel immersive audio compositions, elevating production processes from traditional stereo to being truly immersive.

Panel members include Hans Martin-Buff, Andrew Scheps, Adrian Utley, Theo Kozlowski and Ruth Farrar.

When developing real-time audio processing applications in C++, the following problem arises almost inevitably: how can we share data between the real-time audio thread and the other threads (such as a GUI thread) in a way that is real-time safe? How can we synchronise reads and writes to C++ objects across threads, and manage the lifetime of these objects, while remaining wait-free on the real-time thread?

This talk is the second in a series of talks about thread synchronisation in a real-time context. In the first episode, given at ADC 2022, we focused on the case where the real-time thread needs to read a sufficiently large, persistent object that is simultaneously mutated on another thread. In this second episode, we focus on the reverse case: the real-time thread needs to write the value while remaining wait-free, and while other (non-real-time) threads are reading it.

The traditional solution for this problem in audio processing code today is double buffering. This strategy works well in certain cases, but like every algorithm it has certain tradeoffs. If we look beyond the audio industry, it turns out there is actually another strategy that has more favourable tradeoffs for some use cases: the SeqLock.

We describe the general idea of the SeqLock, discuss the different parts of the algorithm, and show a working reference implementation. It turns out that in order to implement a SeqLock portably and without introducing undefined behaviour, we need to reconcile the algorithm with the C++ memory model, which presents an interesting challenge. In order to make it work and be efficient, we need to be very careful with our use of memory fences, memory ordering, and atomic vs. non-atomic memory accesses. Along the way we will learn useful things about writing lock-free code in Standard C++.

Finally, we compare the tradeoffs between SeqLock and other approaches to this problem, offer some guidelines on which approach to use when, and present a proposal to add the SeqLock algorithm to the C++ Standard.