Pi 5: USB audio playback silently drops one packet every ~5 s with a 128-frame buffer (UA Volt 2 Max, UAC2 explicit feedback)

// loopback: a USB interface's first output cabled to its first input; checks what ALSA's frame counts cannot.
//   loopback lat   [seconds] [period] [periods] [device]: a pulse every 0.25 s, the round trip in frames
//   loopback drift [seconds] [period] [periods] [device]: a 1 kHz sine written by the playback's frame count; its
//     phase in the capture over 10 ms windows (ten whole cycles: no leakage) gives the delay to far below a sample.
//     A flat delay is a clean path; steps are frames lost or repeated somewhere, a smooth ramp a clock of its own.
// Streams opened as pi_host opens them: interleaved S32, linked, the playback buffer filled with silence, then started
// together. Defaults: lat 20 s 32 x 6, drift 600 s 32 x 6, hw:CARD=Max,DEV=0 (UA Volt 2 Max), capture / playback
// channel 0. Build: g++ -O2 -std=c++17 pi/loopback.cpp -o loopback -lasound. Stop pi_host first: with it running
// the cable feeds the amp's output back into its input.
#include <alsa/asoundlib.h>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <string>
#include <vector>

static const unsigned rate = 48000;

struct Pcm
{
    snd_pcm_t* h = nullptr;
    unsigned channels = 0;
    snd_pcm_uframes_t period = 0, buffer = 0;
    std::vector<int32_t> raw;

    bool open (const char* dev, snd_pcm_stream_t stream, snd_pcm_uframes_t wantPeriod, unsigned periods)
    {
        if (snd_pcm_open (&h, dev, stream, 0) < 0) return false;
        snd_pcm_hw_params_t* hw;
        snd_pcm_hw_params_alloca (&hw);
        snd_pcm_hw_params_any (h, hw);
        snd_pcm_hw_params_set_access (h, hw, SND_PCM_ACCESS_RW_INTERLEAVED);
        if (snd_pcm_hw_params_set_format (h, hw, SND_PCM_FORMAT_S32_LE) < 0) return false;
        snd_pcm_hw_params_get_channels_min (hw, &channels); // the fewest the device takes (the Volt: 12 in, 8 out)
        snd_pcm_hw_params_set_channels (h, hw, std::max (channels, 2u));
        snd_pcm_hw_params_set_rate (h, hw, rate, 0);
        int dir = 0;
        period = wantPeriod;
        snd_pcm_hw_params_set_period_size_near (h, hw, &period, &dir);
        snd_pcm_hw_params_set_periods_near (h, hw, &periods, &dir);
        if (snd_pcm_hw_params (h, hw) < 0) return false;
        snd_pcm_hw_params_get_channels (hw, &channels);
        snd_pcm_hw_params_get_period_size (hw, &period, &dir);
        snd_pcm_hw_params_get_buffer_size (hw, &buffer);
        snd_pcm_sw_params_t* sw;
        snd_pcm_sw_params_alloca (&sw);
        snd_pcm_uframes_t boundary = 0;
        snd_pcm_sw_params_current (h, sw);
        snd_pcm_sw_params_get_boundary (sw, &boundary);
        snd_pcm_sw_params_set_avail_min (h, sw, period);
        snd_pcm_sw_params_set_start_threshold (h, sw, boundary); // started by hand, both together
        if (snd_pcm_sw_params (h, sw) < 0) return false;
        raw.assign (period * channels, 0);
        return true;
    }
    int read()
    {
        for (snd_pcm_uframes_t done = 0; done < period;)
        {
            const auto n = snd_pcm_readi (h, raw.data() + done * channels, period - done);
            if (n < 0) return (int) n;
            done += (snd_pcm_uframes_t) n;
        }
        return 0;
    }
    int write()
    {
        for (snd_pcm_uframes_t done = 0; done < period;)
        {
            const auto n = snd_pcm_writei (h, raw.data() + done * channels, period - done);
            if (n < 0) return (int) n;
            done += (snd_pcm_uframes_t) n;
        }
        return 0;
    }
    float get (size_t i) const { return (float) (raw[i * channels] * (1.0 / 2147483648.0)); }
    void put (size_t i, double x) { raw[i * channels] = (int32_t) std::lrint (std::clamp (x, -1.0, 1.0) * 2147483647.0); }
};

static double now()
{
    timespec t;
    clock_gettime (CLOCK_MONOTONIC, &t);
    return (double) t.tv_sec + 1e-9 * (double) t.tv_nsec;
}

int main (int argc, char** argv)
{
    setvbuf (stdout, nullptr, _IOLBF, 0);
    const std::string mode = argc > 1 ? argv[1] : "drift";
    const bool lat = mode == "lat";
    if (! lat && mode != "drift") { std::printf ("usage: loopback lat|drift [seconds] [period] [periods] [device]\n"); return 1; }
    const double seconds = argc > 2 ? std::atof (argv[2]) : (lat ? 20.0 : 600.0);
    const unsigned wantPeriod = argc > 3 ? (unsigned) std::atoi (argv[3]) : 32;
    const unsigned periods = argc > 4 ? (unsigned) std::atoi (argv[4]) : 6;
    const char* dev = argc > 5 ? argv[5] : "hw:CARD=Max,DEV=0";

    Pcm in, out;
    if (! in.open (dev, SND_PCM_STREAM_CAPTURE, wantPeriod, periods) || ! out.open (dev, SND_PCM_STREAM_PLAYBACK, wantPeriod, periods)
        || in.period != out.period)
    { std::printf ("cannot open %s with equal periods\n", dev); return 1; }
    const int P = (int) in.period;
    std::printf ("%s: %s, period %d, buffer %lu / %lu (in / out), %u / %u channels\n", mode.c_str(), dev, P, in.buffer, out.buffer, in.channels, out.channels);
    const bool linked = snd_pcm_link (in.h, out.h) == 0;
    snd_pcm_prepare (in.h);
    snd_pcm_prepare (out.h);
    for (snd_pcm_uframes_t f = 0; f + out.period <= out.buffer; f += out.period) out.write();
    const long long prefill = (long long) (out.buffer / out.period * out.period);
    if (linked) snd_pcm_start (in.h); else { snd_pcm_start (out.h); snd_pcm_start (in.h); }
    const double t0 = now();

    const long long total = (long long) (seconds * rate);
    std::vector<float> cap; // lat: every captured frame
    if (lat) cap.reserve ((size_t) total + (size_t) P);
    long long inN = 0, outN = 0;
    long delayMin = 1L << 30, delayMax = 0, backlogMax = 0;
    float peak = 0.0f; // after the first second (the converters start with a spike)
    const int W = 480;
    double I = 0.0, Q = 0.0, E = 0.0;
    int wn = 0;
    std::vector<double> D, R; // drift: delay (samples, unwrapped) and residual off the sine (dB) per window
    double sinT[48], cosT[48];
    for (int k = 0; k < 48; ++k) { sinT[k] = std::sin (2.0 * M_PI * k / 48.0); cosT[k] = std::cos (2.0 * M_PI * k / 48.0); }

    while (inN < total)
    {
        if (in.read() < 0) { std::printf ("capture xrun at %.2f s\n", inN / (double) rate); break; }
        for (int i = 0; i < P; ++i)
        {
            const float x = in.get ((size_t) i);
            if (inN > rate) peak = std::max (peak, std::abs (x));
            if (lat) { cap.push_back (x); continue; }
            const int k = (int) ((inN + i) % 48);
            I += x * cosT[k]; Q += x * sinT[k]; E += (double) x * x;
            if (++wn == W)
            {
                double phi = std::atan2 (-I, Q) / (2.0 * M_PI) * 48.0; // the sine's delay, mod 48 samples
                if (! D.empty()) phi += 48.0 * std::round ((D.back() - phi) / 48.0);
                D.push_back (phi);
                const double fit = 2.0 / W * (I * I + Q * Q);
                R.push_back (10.0 * std::log10 (std::max (1e-30, (E - fit) / std::max (1e-30, fit))));
                I = Q = E = 0.0;
                wn = 0;
            }
        }
        for (int i = 0; i < P; ++i)
        {
            const long long n = lat ? inN + i : outN + i; // lat: output frame i answers input frame i, as pi_host does
            out.put ((size_t) i, lat ? ((n >= rate && n % 12000 == 6000) ? 0.5 : 0.0) : 0.25 * sinT[n % 48]);
        }
        inN += P;
        if (out.write() < 0) { std::printf ("playback xrun at %.2f s\n", inN / (double) rate); break; }
        outN += P;
        snd_pcm_sframes_t d = 0;
        if (snd_pcm_delay (out.h, &d) == 0 && inN > rate) { delayMin = std::min (delayMin, (long) d); delayMax = std::max (delayMax, (long) d); }
        const long backlog = (long) snd_pcm_avail (in.h);
        if (inN > rate) backlogMax = std::max (backlogMax, backlog);
        if (! lat && D.size() > 1 && inN % (rate * 60) < (long long) P)
            std::printf ("%4.0f s: delay %+.3f samples since the start\n", inN / (double) rate, D.back() - D.front());
    }

    // ALSA's view: frames moved per second of the system clock, each stream
    const double t1 = now();
    snd_pcm_sframes_t d = 0;
    snd_pcm_delay (out.h, &d);
    const snd_pcm_sframes_t av = snd_pcm_avail (in.h);
    const double capRate = (double) (inN + av) / (t1 - t0), playRate = (double) (outN + prefill - d) / (t1 - t0);
    std::printf ("in peak %.1f dBFS, playback delay %ld..%ld, capture backlog max %ld\n", 20.0 * std::log10 (std::max (1e-9f, peak)), delayMin, delayMax, backlogMax);
    std::printf ("ALSA: capture %.3f, playback %.3f frames/s (playback %+.1f ppm against capture)\n", capRate, playRate, (playRate / capRate - 1.0) * 1e6);

    if (lat)
    {
        // each pulse: the peak of |x| within 100 ms (a parabola through the top three)
        std::vector<double> rt;
        for (long long n = 6000 + rate; n + 4800 < (long long) cap.size(); n += 12000)
        {
            long long m = n;
            for (long long j = n; j < n + 4800; ++j) if (std::abs (cap[j]) > std::abs (cap[m])) m = j;
            const double a = std::abs (cap[m - 1]), b = std::abs (cap[m]), c = std::abs (cap[m + 1]);
            if (b < 0.001) continue;
            rt.push_back ((double) (m - n) + ((a - 2 * b + c) != 0.0 ? 0.5 * (a - c) / (a - 2 * b + c) : 0.0));
        }
        if (rt.empty()) { std::printf ("no pulses came back (cable? output level?)\n"); return 1; }
        std::sort (rt.begin(), rt.end());
        std::printf ("round trip: %zu pulses, min %.2f, median %.2f, max %.2f frames (median %.3f ms)\n", rt.size(), rt.front(),
                     rt[rt.size() / 2], rt.back(), rt[rt.size() / 2] / rate * 1000.0);
        return 0;
    }

    // drift: the windows after the first second (start-up), a line through their delays, and the steps between them
    const size_t k0 = (size_t) (rate / W), n = D.size();
    if (n < k0 + 10) { std::printf ("too short\n"); return 1; }
    double sx = 0, sy = 0, sxx = 0, sxy = 0;
    for (size_t k = k0; k < n; ++k) { const double x = (double) k; sx += x; sy += D[k]; sxx += x * x; sxy += x * D[k]; }
    const double m = (double) (n - k0), slope = (m * sxy - sx * sy) / (m * sxx - sx * sx), icpt = (sy - slope * sx) / m;
    double rms = 0.0, off = 0.0, worst = -300.0;
    int steps = 0, glitches = 0;
    for (size_t k = k0; k < n; ++k)
    {
        const double e = D[k] - (icpt + slope * k);
        rms += e * e;
        off = std::max (off, std::abs (e));
        worst = std::max (worst, R[k]);
        if (R[k] > -60.0) ++glitches;
        if (k > k0 && std::abs (D[k] - D[k - 1]) > 0.3 && steps++ < 20)
            std::printf ("  step %+.3f samples at %.2f s (residual %.1f dB)\n", D[k] - D[k - 1], k * W / (double) rate, R[k]);
    }
    std::vector<double> r (R.begin() + (long) k0, R.end());
    std::sort (r.begin(), r.end());
    std::printf ("after the first second: delay %+.3f ppm (%+.3f samples/s), off the line rms %.4f / max %.4f samples\n",
                 slope / W * 1e6, slope / W * rate, std::sqrt (rms / m), off);
    std::printf ("%d steps over 0.3 samples between 10 ms windows; residual median %.1f dB, worst %.1f dB, %d windows over -60 dB\n",
                 steps, r[r.size() / 2], worst, glitches);
    return 0;
}