Audio setup

Supported bindings: ossia, vst, vst3, clap, Max, Pd

It is fairly common for audio systems to need to have some buffers allocated or perform pre-computations depending on the sample rate and buffer size of the system.

This can be done by adding the following method in the processor:

void prepare(/* some_type */ info) {
    ...
}

some_type can be a custom type with the following allowed fields:

• rate: will be filled with the sample rate.
• frames: will be filled with the maximum frame (buffer) size.
• input_channels / output_channels: for processors with unspecified numbers of channels, it will be notified here.
• Alternatively, just specifying channels works too if inputs and outputs are expected to be the same.
• instance: allows to give processor instances an unique identifier which, if the host supports it, will be serialized / deserialized across restarts of the host and thus stay constant.

Those variables must be assignable, and are all optional (remember the foreword: Avendish is UNCOMPROMISING).

Here are some valid examples:

• No member at all: this can be used to just notify the processor than processing is about to start.

struct setup_a { };
void prepare(setup_a info) {
    ...
}

• Most common use case

struct setup_b {
  float rate{};
  int frames{};
};
void prepare(setup_b info) {
    ...
}

• For variable channels in simple audio filters:

struct setup_c {
  float rate{};
  int frames{};
  int channels{};
};
void prepare(setup_c info) {
    ...
}

Helper library

halp provides the halp::setup which covers the most usual use cases:

void prepare(halp::setup info) {
  info.rate; // etc...
}

How does this work ?

If you are interested in the implementation, it is actually fairly simple.

• First we extract the function arguments of prepare if the function exists (see avnd/common/function_reflection.hpp for the method), to get the type T of the first argument.
• Then we do the following if it exists:

using type = /* type of T in prepare(T t) */;
if constexpr(requires (T t) { t.frames = 123; })
  t.frames = ... the buffer size reported by the DAW ...;
if constexpr(requires (T t) { t.rate = 44100; })
  t.rate = ... the sample-rate reported by the DAW ...;

This way, only the cost of the variables that are actually used by the algorithm is ever incurred, which is of course not super important but a good reference implementation for this way of doing for other parts of the system where it matters more.