class RingBuffer

Represents a single-producer multi-consumer ring buffer of audio data. A ring buffer represents a

window into an infinite stream. Frame numbers are specified relative to this infinite stream --

the translation into ring buffer offsets happens internally.

## Concurrency

Code in this directory (`mix/`) is supposed to be single-threaded, but ring buffers are unusual.

Ring buffers are concurrent by their very nature: the producer and consumer may be running in

different threads, or even in different HW domains. Hence, all public methods in this class are

safe to call from any thread, except `PrepareToWrite`, which must be called by the producer.

The actual data in a ring buffer is synchronized by time, using one of two protocols, as

described below.

### External producer or consumer

If the ring buffer is shared with an external producer or consumer, such as a hardware device,

then we divide the ring buffer into two adjacent regions: a "safe write" region, which the

producer can write, and a "safe read" region, which the consumers can read. These regions meet at

the current time: the "safe write" region is in the future while the "safe read" region is in the

past. The producer and consumers must agree on these regions using some out-of-band mechanism.

More information about this protocol can be found at the documentation for the

`fuchsia.audio.RingBuffer` FIDL type.

### Splitters

Each SplitterNode uses a RingBuffer to connect a source stream (which writes to the buffer) with

one or more destination streams (which read from the buffer). SplitterNodes don't have a clean

separation into "safe read" and "safe write" regions. In some cases, consumers are allowed to

read from the same region the producer is writing to. See ../docs/splitters.h for a detailed

description of this protocol.